Files
Netcatty/application/state/useExternalMcpToggleState.test.ts
T
陈大猫 faeaa238e9 feat: share reversible AI privacy across Catty, agents, and MCP (#3805)
Share opt-in, reversible privacy masking through main-owned policy and conversation maps across Catty, integrated agents, and External MCP. Restore managed arguments before validation, approval, and execution; fail closed on retired policy state. Add shared settings, documentation, boundary and lifecycle regressions.

Validated with deterministic regressions, production desktop smoke, clean Codex review and passing cross-platform CI.

Closes #3620
2026-10-21 01:29:17 +08:00

791 lines
34 KiB
TypeScript

import assert from 'node:assert/strict';
import { describe, it } from 'node:test';
import { createSessionIdleManager } from '../../electron/bridges/mcpServerBridge/sessionIdleManager.cjs';
import { STORAGE_KEY_AI_SESSION_IDLE_TIMEOUT_MINUTES, STORAGE_KEY_AI_PRIVACY, STORAGE_KEY_AI_EXTERNAL_MCP_REDACTION, STORAGE_KEY_AI_EXTERNAL_MCP_ENABLED, STORAGE_KEY_AI_EXTERNAL_MCP_MODE } from '../../infrastructure/config/storageKeys';
import { localStorageAdapter } from '../../infrastructure/persistence/localStorageAdapter';
import {
readExternalMcpHttpAllowCustomBind,
readExternalMcpHttpEnabled,
readExternalMcpHttpListenAddress,
readExternalMcpHttpPort,
readExternalMcpHttpSettings,
writeExternalMcpHttpAllowCustomBind,
writeExternalMcpHttpEnabled,
writeExternalMcpHttpListenAddress,
writeExternalMcpHttpPort,
} from "./useExternalMcpToggleState.ts";
import {
EXTERNAL_MCP_RUNTIME_STATUS_POLL_MS,
applyAIPrivacySettings,
readAIPrivacySettings,
applyExternalMcpRedactionSettings,
readExternalMcpRedactionSettings,
bumpExternalMcpEnableGenerationForTests,
createExternalMcpStartupSyncPlan,
getExternalMcpEnableGenerationForTests,
getExternalMcpStartupReadyWaiterCountForTests,
isExternalMcpStartupReady,
markExternalMcpStartupReady,
normalizeExternalMcpApprovalAlertMode,
normalizeExternalMcpIdleTimeoutMinutes,
normalizeExternalMcpMode,
normalizeSessionIdleTimeoutMinutes,
readExternalMcpApprovalAlertMode,
readExternalMcpFocusOnHostOpen,
readExternalMcpSilentSessions,
readExternalMcpStoredEnabled,
resetExternalMcpStartupReadyForTests,
resetExternalMcpStartupSyncOnceForTests,
shouldStartExternalMcpOnStartup,
shouldWaitForExternalMcpStartupReady,
syncExternalMcpConfig,
syncExternalMcpStartupState,
syncExternalMcpStartupStateOnce,
waitForExternalMcpStartupReady,
writeExternalMcpApprovalAlertMode,
writeExternalMcpFocusOnHostOpen,
writeExternalMcpSilentSessions,
} from './useExternalMcpToggleState.ts';
function installMemoryLocalStorage() {
const previousLocalStorage = Object.getOwnPropertyDescriptor(globalThis, 'localStorage');
const previousDispatchEvent = Object.getOwnPropertyDescriptor(globalThis, 'dispatchEvent');
const backing = new Map<string, string>();
const storage: Storage = {
get length() { return backing.size; },
clear() { backing.clear(); },
getItem(key: string) { return backing.get(key) ?? null; },
key(index: number) { return Array.from(backing.keys())[index] ?? null; },
removeItem(key: string) { backing.delete(key); },
setItem(key: string, value: string) { backing.set(key, value); },
};
Object.defineProperty(globalThis, 'localStorage', { value: storage, configurable: true });
Object.defineProperty(globalThis, 'dispatchEvent', { value: () => true, configurable: true });
return () => {
if (previousLocalStorage) {
Object.defineProperty(globalThis, 'localStorage', previousLocalStorage);
} else {
Reflect.deleteProperty(globalThis, 'localStorage');
}
if (previousDispatchEvent) {
Object.defineProperty(globalThis, 'dispatchEvent', previousDispatchEvent);
} else {
Reflect.deleteProperty(globalThis, 'dispatchEvent');
}
};
}
describe('useExternalMcpToggleState helpers', () => {
it('normalizes mode and idle timeout', () => {
assert.equal(normalizeExternalMcpMode('persistent'), 'persistent');
assert.equal(normalizeExternalMcpMode('other'), 'temporary');
assert.equal(normalizeExternalMcpIdleTimeoutMinutes(null), 10);
assert.equal(normalizeExternalMcpIdleTimeoutMinutes(0), 1);
assert.equal(normalizeExternalMcpIdleTimeoutMinutes(99999), 24 * 60);
assert.equal(normalizeSessionIdleTimeoutMinutes(null), 8 * 60);
assert.equal(normalizeSessionIdleTimeoutMinutes(0), 1);
assert.equal(normalizeExternalMcpApprovalAlertMode(null), 'unfocused');
assert.equal(normalizeExternalMcpApprovalAlertMode('always'), 'always');
assert.equal(normalizeExternalMcpApprovalAlertMode('nope'), 'unfocused');
});
it('stores the approval alert preference and defaults to unfocused', () => {
const restore = installMemoryLocalStorage();
try {
assert.equal(readExternalMcpApprovalAlertMode(), 'unfocused');
assert.equal(writeExternalMcpApprovalAlertMode('off'), 'off');
assert.equal(readExternalMcpApprovalAlertMode(), 'off');
assert.equal(writeExternalMcpApprovalAlertMode('always'), 'always');
assert.equal(readExternalMcpApprovalAlertMode(), 'always');
} finally {
restore();
}
});
for (const savedMinutes of [null, 30]) {
it(`syncs the session idle timeout without replacing saved value ${savedMinutes}`, async () => {
const restore = installMemoryLocalStorage();
const manager = createSessionIdleManager();
try {
assert.equal(manager.getTimeoutMinutes(), 8 * 60, 'main-process default');
if (savedMinutes !== null) {
localStorageAdapter.writeNumber(STORAGE_KEY_AI_SESSION_IDLE_TIMEOUT_MINUTES, savedMinutes);
}
const expected = savedMinutes ?? manager.getTimeoutMinutes();
const received: number[] = [];
const bridge = {
externalMcpSetConfig: (config: { sessionIdleTimeoutMinutes: number }) => {
received.push(config.sessionIdleTimeoutMinutes);
manager.setTimeoutMinutes(config.sessionIdleTimeoutMinutes);
return { ok: true };
},
};
await syncExternalMcpStartupState(bridge);
assert.equal(manager.getTimeoutMinutes(), expected, 'startup keeps the intended timeout');
await syncExternalMcpConfig(bridge);
assert.deepEqual(received, [expected, expected]);
assert.equal(manager.getTimeoutMinutes(), expected, 'config sync keeps the intended timeout');
assert.equal(
localStorageAdapter.readNumber(STORAGE_KEY_AI_SESSION_IDLE_TIMEOUT_MINUTES),
savedMinutes,
'sync does not migrate or overwrite the stored preference',
);
} finally {
manager.clearAll();
restore();
}
});
}
it('only starts on launch for persistent+enabled', () => {
assert.equal(shouldStartExternalMcpOnStartup({ enabled: true, mode: 'persistent' }), true);
assert.equal(shouldStartExternalMcpOnStartup({ enabled: true, mode: 'temporary' }), false);
assert.equal(shouldStartExternalMcpOnStartup({ enabled: false, mode: 'persistent' }), false);
});
it('startup sync plan clears temporary stored enabled', () => {
const plan = createExternalMcpStartupSyncPlan({
enabled: true,
mode: 'temporary',
idleTimeoutMinutes: 15,
sessionIdleTimeoutMinutes: 30,
});
assert.equal(plan.runtimeEnabled, false);
assert.equal(plan.storedEnabled, false);
assert.equal(plan.shouldPersistStoredEnabled, true);
assert.equal(plan.config.idleTimeoutMinutes, 15);
assert.equal(plan.config.sessionIdleTimeoutMinutes, 30);
});
it('startup sync plan keeps persistent enabled', () => {
const plan = createExternalMcpStartupSyncPlan({
enabled: true,
mode: 'persistent',
idleTimeoutMinutes: 20,
sessionIdleTimeoutMinutes: 45,
});
assert.equal(plan.runtimeEnabled, true);
assert.equal(plan.storedEnabled, true);
assert.equal(plan.shouldPersistStoredEnabled, false);
});
it('focus-on-host-open defaults to true and round-trips through storage', () => {
const restore = installMemoryLocalStorage();
try {
assert.equal(readExternalMcpFocusOnHostOpen(), true);
writeExternalMcpFocusOnHostOpen(false);
assert.equal(readExternalMcpFocusOnHostOpen(), false);
writeExternalMcpFocusOnHostOpen(true);
assert.equal(readExternalMcpFocusOnHostOpen(), true);
} finally {
restore();
}
});
it('polls runtime status on a short interval for the top-bar switch', () => {
assert.equal(EXTERNAL_MCP_RUNTIME_STATUS_POLL_MS, 3000);
});
it('silent-sessions defaults to false and round-trips through storage', () => {
const restore = installMemoryLocalStorage();
try {
assert.equal(readExternalMcpSilentSessions(), false);
writeExternalMcpSilentSessions(true);
assert.equal(readExternalMcpSilentSessions(), true);
writeExternalMcpSilentSessions(false);
assert.equal(readExternalMcpSilentSessions(), false);
} finally {
restore();
}
});
});
describe('useExternalMcpToggleState runtime poll wiring', () => {
it('uses the shared poll interval constant', async () => {
const source = await import('node:fs').then((fs) =>
fs.readFileSync(new URL('./useExternalMcpToggleState.ts', import.meta.url), 'utf8'),
);
assert.match(source, /EXTERNAL_MCP_RUNTIME_STATUS_POLL_MS = 3000/);
assert.match(source, /setInterval\([\s\S]*EXTERNAL_MCP_RUNTIME_STATUS_POLL_MS\)/);
assert.doesNotMatch(source, /setInterval\([\s\S]*,\s*30000\)/);
});
});
describe('useExternalMcpToggleState startup ready gate', () => {
it('blocks main-window runtime poll consumers until startup reconcile marks ready', async () => {
resetExternalMcpStartupReadyForTests();
assert.equal(isExternalMcpStartupReady(), false);
assert.equal(shouldWaitForExternalMcpStartupReady(''), true);
assert.equal(shouldWaitForExternalMcpStartupReady('#/settings'), false);
assert.equal(shouldWaitForExternalMcpStartupReady('#/tray'), false);
assert.equal(shouldWaitForExternalMcpStartupReady('#/session-window'), false);
let resolved = false;
const pending = waitForExternalMcpStartupReady('').then(() => {
resolved = true;
});
// Single-flight: repeated waits share one waiter.
const pending2 = waitForExternalMcpStartupReady('');
await Promise.resolve();
assert.equal(resolved, false);
assert.equal(getExternalMcpStartupReadyWaiterCountForTests(), 1);
markExternalMcpStartupReady();
await pending;
await pending2;
assert.equal(isExternalMcpStartupReady(), true);
assert.equal(resolved, true);
assert.equal(getExternalMcpStartupReadyWaiterCountForTests(), 0);
await waitForExternalMcpStartupReady('');
});
it('does not block settings/tray consumers on the App-only gate', async () => {
resetExternalMcpStartupReadyForTests();
await waitForExternalMcpStartupReady('#/settings');
await waitForExternalMcpStartupReady('#/tray');
assert.equal(isExternalMcpStartupReady(), false);
assert.equal(getExternalMcpStartupReadyWaiterCountForTests(), 0);
});
it('wires App startup reconcile to release the gate after enable settles', async () => {
const appSource = await import('node:fs').then((fs) =>
fs.readFileSync(new URL('../app/AppSideEffects.tsx', import.meta.url), 'utf8'),
);
const hookSource = await import('node:fs').then((fs) =>
fs.readFileSync(new URL('./useExternalMcpToggleState.ts', import.meta.url), 'utf8'),
);
assert.match(appSource, /await syncExternalMcpStartupStateOnce\(netcattyBridge\.get\(\)\)/);
assert.match(appSource, /markExternalMcpStartupReady\(\)/);
assert.ok(
appSource.indexOf('await syncExternalMcpStartupStateOnce(netcattyBridge.get())')
< appSource.indexOf('markExternalMcpStartupReady()'),
'startup ready must be marked only after await syncExternalMcpStartupStateOnce',
);
assert.match(hookSource, /export async function syncExternalMcpStartupState/);
assert.match(hookSource, /await Promise\.resolve\(bridge\?\.externalMcpSetEnabled\?\.\(plan\.runtimeEnabled\)\)/);
assert.match(hookSource, /shouldWaitForExternalMcpStartupReady/);
assert.match(hookSource, /!status\.enabled && !status\.error/);
assert.match(hookSource, /if \(isPeerSessionWindow \|\| !enabled\) return;/);
});
it('restores saved permission before enabling persistent External MCP', async () => {
const restore = installMemoryLocalStorage();
try {
const storageKeys = await import('../../infrastructure/config/storageKeys.ts');
globalThis.localStorage.setItem(storageKeys.STORAGE_KEY_AI_EXTERNAL_MCP_ENABLED, 'true');
globalThis.localStorage.setItem(storageKeys.STORAGE_KEY_AI_EXTERNAL_MCP_MODE, 'persistent');
globalThis.localStorage.setItem(storageKeys.STORAGE_KEY_AI_PERMISSION_MODE, 'auto');
const calls: string[] = [];
await syncExternalMcpStartupState({
aiMcpSetPermissionMode: async (mode) => {
calls.push(`permission:${mode}`);
return { ok: true };
},
externalMcpSetConfig: async () => {
calls.push('config');
return { ok: true };
},
externalMcpSetEnabled: async (enabled) => {
calls.push(`enabled:${enabled}`);
return { ok: true, enabled };
},
});
assert.deepEqual(calls, ['permission:auto', 'config', 'enabled:true']);
} finally {
restore();
}
});
it('re-reads storage after config await so concurrent top-bar toggles win', async () => {
const restore = installMemoryLocalStorage();
try {
const storageKeys = await import('../../infrastructure/config/storageKeys.ts');
globalThis.localStorage.setItem(storageKeys.STORAGE_KEY_AI_EXTERNAL_MCP_ENABLED, 'true');
globalThis.localStorage.setItem(storageKeys.STORAGE_KEY_AI_EXTERNAL_MCP_MODE, 'persistent');
let enabledCalls: boolean[] = [];
const plan = await syncExternalMcpStartupState({
externalMcpSetConfig: async () => {
// Simulate a user turning the top-bar switch off while config sync is in flight.
globalThis.localStorage.setItem(storageKeys.STORAGE_KEY_AI_EXTERNAL_MCP_ENABLED, 'false');
return { ok: true };
},
externalMcpSetEnabled: async (enabled) => {
enabledCalls.push(enabled);
return { ok: true, enabled };
},
});
assert.equal(plan.runtimeEnabled, false);
assert.deepEqual(enabledCalls, [false]);
assert.equal(readExternalMcpStoredEnabled(), false);
} finally {
restore();
}
});
it('keeps stored switch when startup enable reports disabled with error', async () => {
const restore = installMemoryLocalStorage();
try {
const storageKeys = await import('../../infrastructure/config/storageKeys.ts');
globalThis.localStorage.setItem(storageKeys.STORAGE_KEY_AI_EXTERNAL_MCP_ENABLED, 'true');
globalThis.localStorage.setItem(storageKeys.STORAGE_KEY_AI_EXTERNAL_MCP_MODE, 'persistent');
assert.equal(readExternalMcpStoredEnabled(), true);
const plan = await syncExternalMcpStartupState({
externalMcpSetConfig: async () => ({ ok: true }),
externalMcpSetEnabled: async () => ({ ok: true, enabled: false, state: 'error', error: 'boom' }),
});
assert.equal(plan.runtimeEnabled, true);
assert.equal(plan.storedEnabled, true);
assert.equal(readExternalMcpStoredEnabled(), true);
} finally {
restore();
}
});
});
describe('syncExternalMcpStartupStateOnce single-flight', () => {
it('reaches the bridge once when the startup effect is invoked twice', async () => {
const restore = installMemoryLocalStorage();
try {
resetExternalMcpStartupReadyForTests();
resetExternalMcpStartupSyncOnceForTests();
const storageKeys = await import('../../infrastructure/config/storageKeys.ts');
globalThis.localStorage.setItem(storageKeys.STORAGE_KEY_AI_EXTERNAL_MCP_ENABLED, 'true');
globalThis.localStorage.setItem(storageKeys.STORAGE_KEY_AI_EXTERNAL_MCP_MODE, 'persistent');
const configCalls: unknown[] = [];
const enabledCalls: boolean[] = [];
const bridge = {
externalMcpSetConfig: async (config: unknown) => {
configCalls.push(config);
return { ok: true };
},
externalMcpSetEnabled: async (enabled: boolean) => {
enabledCalls.push(enabled);
return { ok: true, enabled };
},
};
// Mount, cleanup, mount again: both effect runs share one reconcile.
const first = syncExternalMcpStartupStateOnce(bridge);
const second = syncExternalMcpStartupStateOnce(bridge);
assert.equal(first, second);
const [firstPlan, secondPlan] = await Promise.all([first, second]);
assert.equal(firstPlan, secondPlan);
assert.equal(firstPlan.runtimeEnabled, true);
assert.equal(configCalls.length, 1);
assert.deepEqual(enabledCalls, [true]);
// A later remount awaits the settled promise instead of re-sending IPC.
await syncExternalMcpStartupStateOnce(bridge);
assert.equal(configCalls.length, 1);
assert.deepEqual(enabledCalls, [true]);
} finally {
resetExternalMcpStartupSyncOnceForTests();
restore();
}
});
});
describe('syncExternalMcpStartupState generation guard', () => {
it('skips stale startup enable after concurrent top-bar toggle generation bump', async () => {
const restore = installMemoryLocalStorage();
try {
resetExternalMcpStartupReadyForTests();
const storageKeys = await import('../../infrastructure/config/storageKeys.ts');
globalThis.localStorage.setItem(storageKeys.STORAGE_KEY_AI_EXTERNAL_MCP_ENABLED, 'true');
globalThis.localStorage.setItem(storageKeys.STORAGE_KEY_AI_EXTERNAL_MCP_MODE, 'persistent');
const enabledCalls: boolean[] = [];
const plan = await syncExternalMcpStartupState({
externalMcpSetConfig: async () => {
// Simulate a top-bar toggle landing during config await.
globalThis.localStorage.setItem(storageKeys.STORAGE_KEY_AI_EXTERNAL_MCP_ENABLED, 'false');
bumpExternalMcpEnableGenerationForTests();
return { ok: true };
},
externalMcpSetEnabled: async (enabled) => {
enabledCalls.push(enabled);
return { ok: true, enabled };
},
});
assert.equal(plan.runtimeEnabled, false);
// Generation changed during config await, so stale startup enable is skipped.
assert.deepEqual(enabledCalls, []);
assert.equal(readExternalMcpStoredEnabled(), false);
assert.ok(getExternalMcpEnableGenerationForTests() > 0);
} finally {
restore();
}
});
});
describe("external MCP HTTP settings", () => {
it("defaults HTTP off on loopback and round-trips the explicit listen option", () => {
const restore = installMemoryLocalStorage();
try {
assert.deepEqual(readExternalMcpHttpSettings(), {
enabled: false,
port: 47391,
allowCustomBind: false,
listenAddress: "0.0.0.0",
clientHost: "",
});
assert.equal(readExternalMcpHttpEnabled(), false);
writeExternalMcpHttpEnabled(true);
assert.equal(writeExternalMcpHttpPort(80), 47391);
assert.equal(writeExternalMcpHttpPort(48080), 48080);
writeExternalMcpHttpAllowCustomBind(true);
writeExternalMcpHttpListenAddress("172.22.0.1");
assert.equal(readExternalMcpHttpEnabled(), true);
assert.equal(readExternalMcpHttpPort(), 48080);
assert.equal(readExternalMcpHttpAllowCustomBind(), true);
assert.equal(readExternalMcpHttpListenAddress(), "172.22.0.1");
} finally {
restore();
}
});
});
describe('Shared AI privacy settings', () => {
const settings = {
enabled: true,
redactPrivateIps: true,
cidrs: ['192.0.2.0/24'],
patterns: ['INTERNAL_[A-Z0-9]+'],
};
it('defaults off and persists only after successful bridge validation', async () => {
const restore = installMemoryLocalStorage();
try {
assert.deepEqual(readExternalMcpRedactionSettings(), {
enabled: false, redactPrivateIps: false, cidrs: [], patterns: [],
});
let resolveConfig: (value: unknown) => void;
const apply = applyExternalMcpRedactionSettings(settings, {
externalMcpSetConfig: async (config) => {
assert.deepEqual(config, { redaction: settings });
return new Promise((resolve) => { resolveConfig = resolve; });
},
});
assert.equal(localStorageAdapter.readString(STORAGE_KEY_AI_PRIVACY), null);
resolveConfig!({ ok: true });
await apply;
assert.deepEqual(readExternalMcpRedactionSettings(), settings);
assert.deepEqual(localStorageAdapter.read(STORAGE_KEY_AI_PRIVACY), settings);
assert.equal(localStorageAdapter.readString(STORAGE_KEY_AI_EXTERNAL_MCP_REDACTION), null);
} finally {
restore();
}
});
it('reads legacy privacy preferences until a validated shared preference is applied', async () => {
const restore = installMemoryLocalStorage();
try {
localStorageAdapter.write(STORAGE_KEY_AI_EXTERNAL_MCP_REDACTION, settings);
assert.deepEqual(readAIPrivacySettings(), settings);
assert.equal(localStorageAdapter.readString(STORAGE_KEY_AI_PRIVACY), null, 'reads must not migrate or discard data');
const changed = { ...settings, redactPrivateIps: false };
await applyAIPrivacySettings(changed, { externalMcpSetConfig: async () => ({ ok: true }) });
assert.deepEqual(readAIPrivacySettings(), changed);
assert.deepEqual(readExternalMcpRedactionSettings(), changed, 'legacy API must read the same shared policy');
assert.deepEqual(localStorageAdapter.read(STORAGE_KEY_AI_PRIVACY), changed);
assert.deepEqual(localStorageAdapter.read(STORAGE_KEY_AI_EXTERNAL_MCP_REDACTION), settings, 'keep legacy storage intact');
} finally {
restore();
}
});
it('never falls back to legacy settings when a shared preference exists, even if corrupt', () => {
const restore = installMemoryLocalStorage();
try {
localStorageAdapter.write(STORAGE_KEY_AI_EXTERNAL_MCP_REDACTION, settings);
const disabled = { enabled: false, redactPrivateIps: false, cidrs: [], patterns: [] };
localStorageAdapter.write(STORAGE_KEY_AI_PRIVACY, disabled);
assert.deepEqual(readAIPrivacySettings(), disabled);
localStorageAdapter.writeString(STORAGE_KEY_AI_PRIVACY, '{');
assert.throws(readAIPrivacySettings, /Invalid saved AI privacy settings/);
localStorageAdapter.remove(STORAGE_KEY_AI_PRIVACY);
localStorageAdapter.writeString(STORAGE_KEY_AI_EXTERNAL_MCP_REDACTION, '{');
assert.throws(readAIPrivacySettings, /Invalid saved AI privacy settings/);
} finally {
restore();
}
});
it('restores the shared policy even when External MCP is disabled', async () => {
const restore = installMemoryLocalStorage();
try {
resetExternalMcpStartupReadyForTests();
localStorageAdapter.writeBoolean(STORAGE_KEY_AI_EXTERNAL_MCP_ENABLED, false);
localStorageAdapter.write(STORAGE_KEY_AI_PRIVACY, settings);
const calls: string[] = [];
const plan = await syncExternalMcpStartupState({
externalMcpSetConfig: async (config) => {
assert.deepEqual(config.redaction, settings);
calls.push('shared-policy');
return { ok: true };
},
externalMcpSetEnabled: async (enabled) => { calls.push(`external:${enabled}`); },
});
assert.deepEqual(calls, ['shared-policy', 'external:false']);
assert.equal(plan.runtimeEnabled, false);
assert.deepEqual(readAIPrivacySettings(), settings);
} finally {
restore();
}
});
it('does not persist rejected, unverified or failed privacy changes', async () => {
const restore = installMemoryLocalStorage();
try {
localStorageAdapter.write(STORAGE_KEY_AI_PRIVACY, settings);
const changed = { ...settings, patterns: ['['] };
for (const result of [{ ok: false, error: 'Invalid regular expression' }, { ok: false, error: '' }, undefined, {}]) {
await assert.rejects(applyExternalMcpRedactionSettings(changed, {
externalMcpSetConfig: async () => result,
}));
assert.deepEqual(readExternalMcpRedactionSettings(), settings);
}
await assert.rejects(applyExternalMcpRedactionSettings(changed, {
externalMcpSetConfig: async () => { throw new Error('Disconnected'); },
}), /Disconnected/);
assert.deepEqual(readExternalMcpRedactionSettings(), settings);
} finally {
restore();
}
});
it('syncs saved privacy settings before persistent startup enable', async () => {
const restore = installMemoryLocalStorage();
try {
resetExternalMcpStartupReadyForTests();
localStorageAdapter.writeBoolean(STORAGE_KEY_AI_EXTERNAL_MCP_ENABLED, true);
localStorageAdapter.writeString(STORAGE_KEY_AI_EXTERNAL_MCP_MODE, 'persistent');
localStorageAdapter.write(STORAGE_KEY_AI_PRIVACY, settings);
const calls: string[] = [];
await syncExternalMcpStartupState({
externalMcpSetConfig: async (config) => {
assert.deepEqual(config.redaction, settings);
calls.push('config');
return { ok: true };
},
externalMcpSetEnabled: async (enabled) => { calls.push(`enabled:${enabled}`); },
});
assert.deepEqual(calls, ['config', 'enabled:true']);
} finally {
restore();
}
});
it('fails closed at startup when saved privacy settings are malformed', async () => {
const restore = installMemoryLocalStorage();
try {
for (const saved of ['{', 'null', '{}', '{"enabled":"true"}', '{"enabled":false,"redactPrivateIps":false,"cidrs":[],"patterns":[2]}', '{"enabled":false,"redactPrivateIps":false,"cidrs":[],"patterns":[],"unexpected":true}']) {
resetExternalMcpStartupReadyForTests();
localStorageAdapter.writeBoolean(STORAGE_KEY_AI_EXTERNAL_MCP_ENABLED, true);
localStorageAdapter.writeString(STORAGE_KEY_AI_EXTERNAL_MCP_MODE, 'persistent');
localStorageAdapter.writeString(STORAGE_KEY_AI_PRIVACY, saved);
const enabledCalls: boolean[] = [];
let configCalls = 0;
const bridge = {
externalMcpSetConfig: async (config: unknown) => {
assert.deepEqual(config, { redaction: null });
configCalls += 1;
return { ok: false, error: 'Shared AI privacy configuration is unavailable.' };
},
externalMcpSetEnabled: async (enabled: boolean) => { enabledCalls.push(enabled); },
};
const plan = await syncExternalMcpStartupState(bridge);
assert.equal(plan.runtimeEnabled, false);
assert.match(plan.configError!, /Invalid saved/);
assert.equal(configCalls, 1, 'invalidate shared privacy instead of applying unprotected defaults');
assert.deepEqual(enabledCalls, [false]);
assert.equal(readExternalMcpStoredEnabled(), false);
await assert.rejects(syncExternalMcpConfig(bridge), /Invalid saved/);
assert.equal(configCalls, 2);
}
} finally {
restore();
}
});
it('fails closed when the backend rejects or cannot verify startup config', async () => {
const restore = installMemoryLocalStorage();
try {
for (const result of [{ ok: false, error: 'Invalid CIDR' }, { ok: false, error: '' }, undefined, {}]) {
resetExternalMcpStartupReadyForTests();
localStorageAdapter.writeBoolean(STORAGE_KEY_AI_EXTERNAL_MCP_ENABLED, true);
localStorageAdapter.writeString(STORAGE_KEY_AI_EXTERNAL_MCP_MODE, 'persistent');
localStorageAdapter.write(STORAGE_KEY_AI_PRIVACY, settings);
const enabledCalls: boolean[] = [];
const plan = await syncExternalMcpStartupState({
externalMcpSetConfig: async () => result,
externalMcpSetEnabled: async (enabled) => { enabledCalls.push(enabled); },
});
assert.equal(plan.runtimeEnabled, false);
assert.ok(plan.configError);
assert.deepEqual(enabledCalls, [false]);
assert.deepEqual(readExternalMcpRedactionSettings(), settings);
}
} finally {
restore();
}
});
it('preserves the corrupt-settings error if shared policy invalidation cannot reach the bridge', async () => {
const restore = installMemoryLocalStorage();
try {
resetExternalMcpStartupReadyForTests();
localStorageAdapter.writeString(STORAGE_KEY_AI_PRIVACY, '{');
const calls: boolean[] = [];
const bridge = {
externalMcpSetConfig: async (config: unknown) => {
assert.deepEqual(config, { redaction: null });
throw new Error('Disconnected');
},
externalMcpSetEnabled: async (enabled: boolean) => { calls.push(enabled); },
};
const plan = await syncExternalMcpStartupState(bridge);
assert.match(plan.configError!, /Invalid saved AI privacy settings/);
assert.deepEqual(calls, [false]);
await assert.rejects(syncExternalMcpConfig(bridge), /Invalid saved AI privacy settings/);
assert.equal(localStorageAdapter.readString(STORAGE_KEY_AI_PRIVACY), '{');
} finally {
restore();
}
});
it('does not enable from a stale privacy snapshot changed during config sync', async () => {
const restore = installMemoryLocalStorage();
try {
resetExternalMcpStartupReadyForTests();
localStorageAdapter.writeBoolean(STORAGE_KEY_AI_EXTERNAL_MCP_ENABLED, true);
localStorageAdapter.writeString(STORAGE_KEY_AI_EXTERNAL_MCP_MODE, 'persistent');
const calls: boolean[] = [];
const plan = await syncExternalMcpStartupState({
externalMcpSetConfig: async () => {
localStorageAdapter.write(STORAGE_KEY_AI_PRIVACY, settings);
return { ok: true };
},
externalMcpSetEnabled: async (enabled) => { calls.push(enabled); },
});
assert.deepEqual(calls, [false]);
assert.match(plan.configError!, /changed during startup/);
await assert.rejects(syncExternalMcpConfig({
externalMcpSetConfig: async () => {
localStorageAdapter.write(STORAGE_KEY_AI_PRIVACY, { ...settings, cidrs: [] });
return { ok: true };
},
}), /settings changed/);
} finally {
restore();
}
});
it('fails closed on a startup config transport failure', async () => {
const restore = installMemoryLocalStorage();
try {
resetExternalMcpStartupReadyForTests();
localStorageAdapter.writeBoolean(STORAGE_KEY_AI_EXTERNAL_MCP_ENABLED, true);
localStorageAdapter.writeString(STORAGE_KEY_AI_EXTERNAL_MCP_MODE, 'persistent');
const calls: boolean[] = [];
const plan = await syncExternalMcpStartupState({
externalMcpSetConfig: async () => { throw new Error('Disconnected'); },
externalMcpSetEnabled: async (enabled) => { calls.push(enabled); },
});
assert.deepEqual(calls, [false]);
assert.equal(plan.configError, 'Disconnected');
} finally {
restore();
}
});
});
describe('External MCP manual enable privacy gate', () => {
it('waits for validated config and keeps rejected or superseded enables off', async () => {
const React = await import('react');
const { act, create } = await import('react-test-renderer');
const { useExternalMcpToggleState } = await import('./useExternalMcpToggleState.ts');
const restoreStorage = installMemoryLocalStorage();
const previousWindow = Object.getOwnPropertyDescriptor(globalThis, 'window');
const previousAct = Object.getOwnPropertyDescriptor(globalThis, 'IS_REACT_ACT_ENVIRONMENT');
const events = new EventTarget();
let resolveConfig!: (value: unknown) => void;
const calls: string[] = [];
const bridge = {
externalMcpSetConfig: async () => {
calls.push('config');
return new Promise((resolve) => { resolveConfig = resolve; });
},
externalMcpSetEnabled: async (enabled: boolean) => {
calls.push(`enabled:${enabled}`);
return { ok: true, enabled };
},
};
Object.defineProperty(globalThis, 'IS_REACT_ACT_ENVIRONMENT', { value: true, configurable: true });
Object.defineProperty(globalThis, 'window', {
value: {
netcatty: bridge,
location: { hash: '#/settings' },
addEventListener: events.addEventListener.bind(events),
removeEventListener: events.removeEventListener.bind(events),
dispatchEvent: events.dispatchEvent.bind(events),
setInterval,
clearInterval,
},
configurable: true,
});
let hook!: ReturnType<typeof useExternalMcpToggleState>;
const Capture = () => { hook = useExternalMcpToggleState(); return null; };
let renderer: ReturnType<typeof create> | undefined;
try {
resetExternalMcpStartupReadyForTests();
await act(async () => { renderer = create(React.createElement(Capture)); });
let pending!: Promise<void>;
await act(async () => { pending = hook.setEnabled(true); });
assert.deepEqual(calls, ['config']);
assert.equal(hook.enabled, false);
assert.equal(readExternalMcpStoredEnabled(), false);
await act(async () => { resolveConfig({ ok: false, error: 'Invalid privacy rules' }); await pending; });
assert.deepEqual(calls, ['config', 'enabled:false']);
assert.equal(hook.enabled, false);
assert.match(hook.error!, /Invalid privacy rules/);
calls.length = 0;
await act(async () => { pending = hook.setEnabled(true); });
await act(async () => { await hook.setEnabled(false); });
await act(async () => { resolveConfig({ ok: true }); await pending; });
assert.deepEqual(calls, ['config', 'enabled:false']);
assert.equal(hook.enabled, false, 'a newer disable wins over a pending enable');
calls.length = 0;
await act(async () => { pending = hook.setEnabled(true); });
await act(async () => { resolveConfig({ ok: true }); await pending; });
assert.deepEqual(calls, ['config', 'enabled:true']);
assert.equal(hook.enabled, true);
assert.equal(readExternalMcpStoredEnabled(), true);
assert.equal(hook.error, null);
} finally {
if (renderer) await act(async () => renderer!.unmount());
if (previousWindow) Object.defineProperty(globalThis, 'window', previousWindow);
else Reflect.deleteProperty(globalThis, 'window');
if (previousAct) Object.defineProperty(globalThis, 'IS_REACT_ACT_ENVIRONMENT', previousAct);
else Reflect.deleteProperty(globalThis, 'IS_REACT_ACT_ENVIRONMENT');
restoreStorage();
}
});
});