mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-16 20:11:08 +00:00
* feat(ai): provider switcher chip in the Catty Agent chat input Catty Agent currently has no model chip in the chat input — modelPresets is empty for the catty agentId so `hasModelPicker` is false. The provider/model the chat ends up using comes from the global `activeProviderId` / `activeModelId`, which means switching providers requires opening Settings → AI → Providers. Closes the gap surfaced in the original feedback on #1101 (problem 2) and partially addresses #986 (per-context model switching) by going per-agent. State layer adds an `agentProviderMap` (`Record<agentId, providerId>`) alongside the existing `agentModelMap`. Both are written together when the user picks from the new dropdown; together they form a per-agent override that beats the global active provider/model when set. Cross- window sync mirrors the agentModelMap pattern. ChatInput grows a `providerSwitcher` prop carrying the enabled ProviderConfigs, the selected (providerId, modelId), and an onSelect callback. When supplied, the model chip switches from the Cpu glyph to the provider's ProviderIconBadge + `providerName · modelId`, and the popover renders a two-column layout — providers on the left (icon + name + default model caption), that provider's known model(s) on the right. ACP agents (Claude/Codex) are untouched because they plumb their provider through the CLI, not the Vercel AI SDK. AIChatSidePanel resolves `effectiveActiveProvider` / `effectiveActiveModelId` for the catty agent from the per-agent map, falling back to the global selection. handleSend now passes those through to sendToCattyAgent so a provider picked in one Catty session applies everywhere Catty runs. For v1, each provider's right column shows just its configured `defaultModel`. The two-level structure is in place to absorb richer listings (cached /models, manual additions) later without UI surgery — left a note in the popover code. Refs #1101, #986. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * polish(ai): flatten provider picker to a single list Two-level dropdown was theatre — each ProviderConfig exposes exactly one model (its `defaultModel`), so the right column ended up showing the same string already captioned on the left row. Picking a provider implicitly picks its model; one click is enough. Also drops the `p.enabled !== false` filter on the picker list. The user's expectation, confirmed by feedback on the first cut, is that the chat-input list mirrors what Settings → AI → Providers shows. The per-provider `enabled` toggle is an "active-ish" flag, not a visibility gate; hiding disabled providers in the picker silently made everything but the one currently active disappear, which is what the reviewer hit. Pares the popover down to a vertical list — provider icon + name + default-model caption (mono if set, italic "configure default model" hint if not) + a Check on the bound row. Removes the `hoveredProviderId` state along with the right-column rendering since it's no longer driving anything. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * polish(ai): tune provider icon sizes in the chat input Chip icon was sitting at sm (20px badge) and crowded the h-6 toolbar chip alongside the truncated label; popover rows used the same sm, so nothing differentiated the picker from the chip visually. Adds an xs size to ProviderIconBadge (16px badge, 10px glyph, 9px letter fallback) and uses it on the chip. Popover rows step up to md (32px badge, 16px glyph) and the row padding grows accordingly so the larger brand mark has room to breathe — the picker now reads like a list of choices, the chip reads like a status line. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(ai): keep per-agent override honest in model fallback + chip label Two codex P1/P2 findings on #1107: P1 — When Catty has a per-agent provider override but no per-agent model (agentModelMap['catty'] empty), cattyAgentModelId fell through to the global `activeModelId`. That id belongs to whichever provider was globally active, not the one Catty is now bound to, so e.g. overriding to DeepSeek without a defaultModel happily sent gpt-4o (global) to DeepSeek and produced a wrong-model error. The fallback is now: stored agent model → override provider's defaultModel → empty. Only the no-override path keeps the activeModelId tail; the no-provider send guard catches the empty case for everyone else. P2 — ChatInput's selectedSwitcherProvider used `?? providers[0]` so the chip always displayed *some* provider even when none was actually bound (selectedProviderId missing). The rest of the pipeline (send guard, agentProviderMap) treats that as "no provider", so the chip was lying. Dropped the fallback; when nothing is bound the chip now shows a generic Cpu glyph + "Select provider" label until the user picks one from the popover. Adds `ai.chat.selectProvider` in en / zh-CN / ru. Refs codex review on #1107. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(ai): purge per-agent binding when the bound provider is deleted Codex local review (round 2) flagged that a saved Catty model id could outlive its provider. The chain: - catty bound to provider A (DeepSeek): agentProviderMap['catty']='A', agentModelMap['catty']='deepseek-v4-flash' - user deletes provider A - cattyAgentProvider falls back to the global active provider (B, OpenAI) - cattyAgentModelId still returned the saved 'deepseek-v4-flash' - send dispatched the DeepSeek model id to OpenAI → wrong-model error Two layers of fix: 1. **Defensive resolution** (AIChatSidePanel) — cattyAgentModelId now looks at the override provider before trusting the stored model id. If the override is stale (provider deleted), the stored model id is treated as orphan and the resolution falls back to the global active selection just like cattyAgentProvider already does. 2. **Cleanup on remove** (useAIState.removeProvider) — when a provider is deleted, any agent whose agentProviderMap entry pointed at it gets both maps cleared (provider override + saved model). Same rationale: that model id is now meaningless against every other provider. Mirrors the existing activeProviderId cleanup. Adds a small agentProviderMapRef so removeProvider can snapshot which agents to clean up without relying on the captured-at-callback-create state (which would be stale). Refs codex local review on #1107. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(ai): include agentProviderMap in settings sync + block empty-model send Codex local review (round 3) found two issues: P2 — `agentProviderMap` was missing from the cross-device sync surface. Added it to the sync key list, the build path, the apply path, and the SyncPayload type alongside the existing `agentModelMap`. Sync tests in `syncPayload.test.ts` now cover the new field on both the build and apply sides. P2 — Provider rows with no `defaultModel` were still clickable in the chat-input picker, so selecting one would save a binding with empty model id; the send path then dispatched an empty model name and the SDK would surface a vague backend error. Two changes: 1. ChatInput disables the row (\`disabled\`, \`aria-disabled\`, dimmed styling, tooltip pointing the user to Settings) when the provider has no \`defaultModel\`. Click is suppressed. 2. AIChatSidePanel \`handleSend\` adds a model-required guard mirroring the existing no-provider guard — surfaces \`ai.chat.noProviderModel\` as an assistant message. Catches stale bindings (e.g. user edited the provider's \`defaultModel\` to empty after binding) before they reach the SDK. Refs codex local review on #1107. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(ai): trim whitespace-only model ids + reconcile orphan bindings on sync Codex local review (round 4) found two more leaks: P2 — Whitespace-only `defaultModel` passed the picker's `disabled` gate (which trims) but every other layer (cattyAgentModelId resolution, the send-guard `!sendActiveModelId` check, the SDK call) compared the raw string. A provider whose default model was " " could still reach the SDK and surface a vague backend error. Normalized: trim at the resolution boundary (catty model fallback chain) and trim before the send-guard's existence check. P2 — Sync apply did not reconcile per-agent bindings against the incoming provider set. A payload could change `providers` without shipping a fresh `agentProviderMap`, leaving local overrides pointing to provider ids the synced set no longer includes — the same ghost- binding bug that `removeProvider` already handles for explicit user deletes. Added `pruneOrphanPerAgentBindings()` that runs after every AI settings apply: it walks `agentProviderMap`, drops any entry whose provider id isn't in the current `providers` list, and clears the saved model id for those agents alongside it (mirroring removeProvider cleanup). A new test in `syncPayload.test.ts` exercises the ghost- binding case end-to-end. Refs codex local review on #1107. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(ai): notify open AI state of cross-device sync apply in the same window Codex local review (round 4) flagged that `applySyncPayload` writes straight to localStorage but `useAIState` only re-reads on browser `storage` events. Those events only fire in *other* windows — the window doing the apply (the one with the active chat panel) keeps showing pre-sync providers and per-agent bindings until reload. Concrete leak: cloud sync swaps in a new provider set, pruning runs, localStorage is correct, but the open Catty chip still references the ghost provider binding until the user reloads. Extracts the existing `AI_STATE_CHANGED_EVENT` constant + `emitAIStateChanged` helper out of `useAIState` and into a new `application/state/aiStateEvents.ts` so non-React call sites (sync apply, future IPC handlers) can fire it without pulling in the hook. After AI settings apply, `syncPayload.ts` walks every AI key it touched (including the agentProviderMap / agentModelMap that the reconcile step may have mutated even when the payload didn't ship them) and emits a same-window nudge. `useAIState`'s existing local listener routes unknown keys back through its storage handler, so each affected piece of React state rehydrates from localStorage. Adds a regression test in `syncPayload.test.ts` that asserts the expected `netcatty:ai-state-changed` keys are dispatched for the providers + per-agent map keys. Refs codex local review on #1107. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
752 lines
23 KiB
TypeScript
752 lines
23 KiB
TypeScript
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
|
|
import type { SyncPayload } from "../domain/sync.ts";
|
|
import type { KnownHost } from "../domain/models.ts";
|
|
import type { SyncableVaultData } from "./syncPayload.ts";
|
|
|
|
type LocalStorageMock = {
|
|
clear(): void;
|
|
getItem(key: string): string | null;
|
|
setItem(key: string, value: string): void;
|
|
removeItem(key: string): void;
|
|
};
|
|
|
|
function installLocalStorage(): LocalStorageMock {
|
|
const store = new Map<string, string>();
|
|
const localStorage: LocalStorageMock = {
|
|
clear() {
|
|
store.clear();
|
|
},
|
|
getItem(key: string) {
|
|
return store.has(key) ? store.get(key)! : null;
|
|
},
|
|
setItem(key: string, value: string) {
|
|
store.set(key, String(value));
|
|
},
|
|
removeItem(key: string) {
|
|
store.delete(key);
|
|
},
|
|
};
|
|
Object.defineProperty(globalThis, "localStorage", {
|
|
value: localStorage,
|
|
configurable: true,
|
|
});
|
|
return localStorage;
|
|
}
|
|
|
|
const localStorage = installLocalStorage();
|
|
const {
|
|
applyLocalVaultPayload,
|
|
applySyncPayload,
|
|
buildLocalVaultPayload,
|
|
buildSyncPayload,
|
|
hasMeaningfulCloudSyncData,
|
|
} = await import("./syncPayload.ts");
|
|
const storageKeys = await import("../infrastructure/config/storageKeys.ts");
|
|
|
|
const knownHost = (id = "kh-1"): KnownHost => ({
|
|
id,
|
|
hostname: `${id}.example.com`,
|
|
port: 22,
|
|
keyType: "ssh-ed25519",
|
|
publicKey: `SHA256:${id}`,
|
|
discoveredAt: 1,
|
|
});
|
|
|
|
const vault = (knownHosts: KnownHost[] = [knownHost()]): SyncableVaultData => ({
|
|
hosts: [],
|
|
keys: [],
|
|
identities: [],
|
|
snippets: [],
|
|
customGroups: [],
|
|
snippetPackages: [],
|
|
knownHosts,
|
|
groupConfigs: [],
|
|
});
|
|
|
|
test.beforeEach(() => {
|
|
localStorage.clear();
|
|
});
|
|
|
|
test("buildSyncPayload treats known hosts as local-only data", () => {
|
|
const payload = buildSyncPayload(vault([knownHost("kh-cloud")]));
|
|
|
|
assert.equal("knownHosts" in payload, false);
|
|
});
|
|
|
|
test("buildSyncPayload includes reusable proxy profiles", () => {
|
|
const proxyProfiles = [
|
|
{
|
|
id: "proxy-1",
|
|
label: "Office Proxy",
|
|
config: { type: "socks5", host: "proxy.example.com", port: 1080 },
|
|
createdAt: 1,
|
|
updatedAt: 1,
|
|
},
|
|
];
|
|
|
|
const payload = buildSyncPayload({
|
|
...vault(),
|
|
proxyProfiles,
|
|
} as SyncableVaultData & { proxyProfiles: typeof proxyProfiles });
|
|
|
|
assert.deepEqual(payload.proxyProfiles, proxyProfiles);
|
|
});
|
|
|
|
test("buildSyncPayload includes AI configuration settings", () => {
|
|
const providers = [{
|
|
id: "openai-main",
|
|
providerId: "openai",
|
|
name: "OpenAI",
|
|
apiKey: "enc:v1:test",
|
|
defaultModel: "gpt-test",
|
|
enabled: true,
|
|
}];
|
|
const webSearch = {
|
|
providerId: "tavily",
|
|
apiKey: "enc:v1:web",
|
|
enabled: true,
|
|
maxResults: 7,
|
|
};
|
|
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_PROVIDERS, JSON.stringify(providers));
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_ACTIVE_PROVIDER, "openai-main");
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_ACTIVE_MODEL, "gpt-test");
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_PERMISSION_MODE, "autonomous");
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_TOOL_INTEGRATION_MODE, "skills");
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_DEFAULT_AGENT, "codex");
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_COMMAND_BLOCKLIST, JSON.stringify(["rm -rf"]));
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_COMMAND_TIMEOUT, "120");
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_MAX_ITERATIONS, "10");
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_AGENT_MODEL_MAP, JSON.stringify({ codex: "gpt-test" }));
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_AGENT_PROVIDER_MAP, JSON.stringify({ catty: "openai-main" }));
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_WEB_SEARCH, JSON.stringify(webSearch));
|
|
|
|
const payload = buildSyncPayload(vault([]));
|
|
|
|
assert.deepEqual(payload.settings?.ai, {
|
|
providers,
|
|
activeProviderId: "openai-main",
|
|
activeModelId: "gpt-test",
|
|
globalPermissionMode: "autonomous",
|
|
toolIntegrationMode: "skills",
|
|
defaultAgentId: "codex",
|
|
commandBlocklist: ["rm -rf"],
|
|
commandTimeout: 120,
|
|
maxIterations: 10,
|
|
agentModelMap: { codex: "gpt-test" },
|
|
agentProviderMap: { catty: "openai-main" },
|
|
webSearchConfig: webSearch,
|
|
});
|
|
});
|
|
|
|
test("buildSyncPayload excludes externalAgents (device-local OS-bound config)", () => {
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_EXTERNAL_AGENTS, JSON.stringify([
|
|
{ id: "codex", name: "Codex", command: "/opt/homebrew/bin/codex", enabled: true },
|
|
]));
|
|
|
|
const payload = buildSyncPayload(vault([]));
|
|
|
|
assert.equal("ai" in (payload.settings ?? {}), false);
|
|
});
|
|
|
|
test("buildSyncPayload omits device-bound encrypted AI API keys", () => {
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_PROVIDERS, JSON.stringify([{
|
|
id: "openai-main",
|
|
providerId: "openai",
|
|
name: "OpenAI",
|
|
apiKey: "enc:v1:djEwAAAA",
|
|
enabled: true,
|
|
}]));
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_WEB_SEARCH, JSON.stringify({
|
|
providerId: "tavily",
|
|
apiKey: "enc:v1:djEwAAAA",
|
|
enabled: true,
|
|
}));
|
|
|
|
const payload = buildSyncPayload(vault([]));
|
|
|
|
assert.equal("apiKey" in (payload.settings?.ai?.providers?.[0] ?? {}), false);
|
|
assert.equal("apiKey" in (payload.settings?.ai?.webSearchConfig ?? {}), false);
|
|
});
|
|
|
|
test("applySyncPayload restores AI configuration settings", async () => {
|
|
const providers = [{
|
|
id: "anthropic-main",
|
|
providerId: "anthropic",
|
|
name: "Anthropic",
|
|
apiKey: "enc:v1:test",
|
|
enabled: true,
|
|
}];
|
|
const webSearch = {
|
|
providerId: "exa",
|
|
apiKey: "enc:v1:web",
|
|
enabled: true,
|
|
};
|
|
|
|
const payload: SyncPayload = {
|
|
hosts: [],
|
|
keys: [],
|
|
identities: [],
|
|
snippets: [],
|
|
customGroups: [],
|
|
settings: {
|
|
ai: {
|
|
providers,
|
|
activeProviderId: "anthropic-main",
|
|
activeModelId: "claude-test",
|
|
globalPermissionMode: "observer",
|
|
toolIntegrationMode: "mcp",
|
|
defaultAgentId: "claude",
|
|
commandBlocklist: ["shutdown"],
|
|
commandTimeout: 30,
|
|
maxIterations: 5,
|
|
agentModelMap: { claude: "claude-test" },
|
|
agentProviderMap: { catty: "anthropic-main" },
|
|
webSearchConfig: webSearch,
|
|
},
|
|
},
|
|
syncedAt: 1,
|
|
} as SyncPayload;
|
|
|
|
await applySyncPayload(payload, { importVaultData: () => {} });
|
|
|
|
assert.deepEqual(JSON.parse(localStorage.getItem(storageKeys.STORAGE_KEY_AI_PROVIDERS)!), providers);
|
|
assert.equal(localStorage.getItem(storageKeys.STORAGE_KEY_AI_ACTIVE_PROVIDER), "anthropic-main");
|
|
assert.equal(localStorage.getItem(storageKeys.STORAGE_KEY_AI_ACTIVE_MODEL), "claude-test");
|
|
assert.equal(localStorage.getItem(storageKeys.STORAGE_KEY_AI_PERMISSION_MODE), "observer");
|
|
assert.equal(localStorage.getItem(storageKeys.STORAGE_KEY_AI_TOOL_INTEGRATION_MODE), "mcp");
|
|
assert.equal(localStorage.getItem(storageKeys.STORAGE_KEY_AI_DEFAULT_AGENT), "claude");
|
|
assert.deepEqual(JSON.parse(localStorage.getItem(storageKeys.STORAGE_KEY_AI_COMMAND_BLOCKLIST)!), ["shutdown"]);
|
|
assert.equal(localStorage.getItem(storageKeys.STORAGE_KEY_AI_COMMAND_TIMEOUT), "30");
|
|
assert.equal(localStorage.getItem(storageKeys.STORAGE_KEY_AI_MAX_ITERATIONS), "5");
|
|
assert.deepEqual(JSON.parse(localStorage.getItem(storageKeys.STORAGE_KEY_AI_AGENT_MODEL_MAP)!), { claude: "claude-test" });
|
|
assert.deepEqual(JSON.parse(localStorage.getItem(storageKeys.STORAGE_KEY_AI_AGENT_PROVIDER_MAP)!), { catty: "anthropic-main" });
|
|
assert.deepEqual(JSON.parse(localStorage.getItem(storageKeys.STORAGE_KEY_AI_WEB_SEARCH)!), webSearch);
|
|
});
|
|
|
|
test("applySyncPayload dispatches a same-window AI-state-changed event so the open chat panel rehydrates", async () => {
|
|
// Without this nudge, the apply path writes to localStorage but
|
|
// `useAIState` (listening for `storage` events) never sees the changes
|
|
// in the calling window — mounted UI keeps showing pre-sync data.
|
|
const dispatched: Array<{ type: string; detail: unknown }> = [];
|
|
const fakeWindow = {
|
|
addEventListener: () => {},
|
|
removeEventListener: () => {},
|
|
dispatchEvent(event: Event) {
|
|
dispatched.push({
|
|
type: event.type,
|
|
detail: (event as CustomEvent).detail,
|
|
});
|
|
return true;
|
|
},
|
|
};
|
|
Object.defineProperty(globalThis, "window", { value: fakeWindow, configurable: true });
|
|
try {
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_AGENT_PROVIDER_MAP, JSON.stringify({ catty: "deepseek-local" }));
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_AGENT_MODEL_MAP, JSON.stringify({ catty: "deepseek-v4-flash" }));
|
|
|
|
const payload: SyncPayload = {
|
|
hosts: [],
|
|
keys: [],
|
|
identities: [],
|
|
snippets: [],
|
|
customGroups: [],
|
|
settings: {
|
|
ai: {
|
|
providers: [{ id: "openai-main", providerId: "openai", name: "OpenAI", enabled: true }],
|
|
},
|
|
},
|
|
syncedAt: 1,
|
|
} as SyncPayload;
|
|
|
|
await applySyncPayload(payload, { importVaultData: () => {} });
|
|
|
|
const events = dispatched.filter((e) => e.type === "netcatty:ai-state-changed");
|
|
const keys = events.map((e) => (e.detail as { key?: string })?.key);
|
|
assert.ok(keys.includes(storageKeys.STORAGE_KEY_AI_PROVIDERS), "providers nudge");
|
|
assert.ok(keys.includes(storageKeys.STORAGE_KEY_AI_AGENT_PROVIDER_MAP), "agentProviderMap nudge");
|
|
assert.ok(keys.includes(storageKeys.STORAGE_KEY_AI_AGENT_MODEL_MAP), "agentModelMap nudge");
|
|
} finally {
|
|
delete (globalThis as { window?: unknown }).window;
|
|
}
|
|
});
|
|
|
|
test("applySyncPayload prunes per-agent bindings that reference providers absent from the synced set", async () => {
|
|
// Local state has Catty bound to a provider the incoming sync no longer
|
|
// ships — both the per-agent provider override and the saved model should
|
|
// be cleared so we don't dispatch a ghost provider id (or its now-orphan
|
|
// model name) to the wrong endpoint.
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_AGENT_PROVIDER_MAP, JSON.stringify({
|
|
catty: "deepseek-local",
|
|
codex: "openai-main",
|
|
}));
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_AGENT_MODEL_MAP, JSON.stringify({
|
|
catty: "deepseek-v4-flash",
|
|
codex: "gpt-test",
|
|
}));
|
|
|
|
const syncedProviders = [
|
|
{ id: "openai-main", providerId: "openai", name: "OpenAI", enabled: true },
|
|
];
|
|
|
|
const payload: SyncPayload = {
|
|
hosts: [],
|
|
keys: [],
|
|
identities: [],
|
|
snippets: [],
|
|
customGroups: [],
|
|
settings: {
|
|
ai: {
|
|
providers: syncedProviders,
|
|
// Intentionally omit agentProviderMap — exercises the reconcile path.
|
|
},
|
|
},
|
|
syncedAt: 1,
|
|
} as SyncPayload;
|
|
|
|
await applySyncPayload(payload, { importVaultData: () => {} });
|
|
|
|
assert.deepEqual(
|
|
JSON.parse(localStorage.getItem(storageKeys.STORAGE_KEY_AI_AGENT_PROVIDER_MAP)!),
|
|
{ codex: "openai-main" },
|
|
);
|
|
// Catty's saved model belonged to the now-missing deepseek-local — drop it.
|
|
// Codex's binding stays, so its saved model stays.
|
|
assert.deepEqual(
|
|
JSON.parse(localStorage.getItem(storageKeys.STORAGE_KEY_AI_AGENT_MODEL_MAP)!),
|
|
{ codex: "gpt-test" },
|
|
);
|
|
});
|
|
|
|
test("applySyncPayload preserves local externalAgents and ignores legacy payload field", async () => {
|
|
const localAgents = [
|
|
{ id: "codex", name: "Codex", command: "/usr/local/bin/codex", enabled: true },
|
|
];
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_EXTERNAL_AGENTS, JSON.stringify(localAgents));
|
|
|
|
const payload = {
|
|
hosts: [],
|
|
keys: [],
|
|
identities: [],
|
|
snippets: [],
|
|
customGroups: [],
|
|
settings: {
|
|
ai: {
|
|
// Legacy snapshot still carries externalAgents; current code must ignore it.
|
|
externalAgents: [
|
|
{ id: "claude", name: "Claude", command: "C:\\Tools\\claude.exe", enabled: true },
|
|
],
|
|
},
|
|
},
|
|
syncedAt: 1,
|
|
} as unknown as SyncPayload;
|
|
|
|
await applySyncPayload(payload, { importVaultData: () => {} });
|
|
|
|
assert.deepEqual(
|
|
JSON.parse(localStorage.getItem(storageKeys.STORAGE_KEY_AI_EXTERNAL_AGENTS)!),
|
|
localAgents,
|
|
);
|
|
});
|
|
|
|
test("applySyncPayload preserves local AI provider apiKeys when synced payload omits them", async () => {
|
|
const localProviders = [
|
|
{
|
|
id: "openai-main",
|
|
providerId: "openai",
|
|
name: "OpenAI",
|
|
apiKey: "enc:v1:djEwLOCAL",
|
|
enabled: true,
|
|
},
|
|
{
|
|
id: "anthropic-main",
|
|
providerId: "anthropic",
|
|
name: "Anthropic",
|
|
apiKey: "enc:v1:djEwANTHROPIC",
|
|
enabled: true,
|
|
},
|
|
];
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_PROVIDERS, JSON.stringify(localProviders));
|
|
|
|
// Synced payload mirrors what `collectSyncableSettings` produces on another device:
|
|
// metadata is preserved but encrypted device-bound apiKeys are stripped.
|
|
const syncedProviders = [
|
|
{ id: "openai-main", providerId: "openai", name: "OpenAI (renamed)", enabled: true },
|
|
{ id: "anthropic-main", providerId: "anthropic", name: "Anthropic", enabled: false },
|
|
];
|
|
|
|
const payload: SyncPayload = {
|
|
hosts: [],
|
|
keys: [],
|
|
identities: [],
|
|
snippets: [],
|
|
customGroups: [],
|
|
settings: { ai: { providers: syncedProviders } },
|
|
syncedAt: 1,
|
|
} as SyncPayload;
|
|
|
|
await applySyncPayload(payload, { importVaultData: () => {} });
|
|
|
|
const stored = JSON.parse(localStorage.getItem(storageKeys.STORAGE_KEY_AI_PROVIDERS)!);
|
|
assert.deepEqual(stored, [
|
|
{
|
|
id: "openai-main",
|
|
providerId: "openai",
|
|
name: "OpenAI (renamed)",
|
|
apiKey: "enc:v1:djEwLOCAL",
|
|
enabled: true,
|
|
},
|
|
{
|
|
id: "anthropic-main",
|
|
providerId: "anthropic",
|
|
name: "Anthropic",
|
|
apiKey: "enc:v1:djEwANTHROPIC",
|
|
enabled: false,
|
|
},
|
|
]);
|
|
});
|
|
|
|
test("applySyncPayload prefers explicit synced apiKey over local apiKey", async () => {
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_PROVIDERS, JSON.stringify([
|
|
{ id: "openai-main", providerId: "openai", name: "OpenAI", apiKey: "enc:v1:djEwLOCAL", enabled: true },
|
|
]));
|
|
|
|
const payload: SyncPayload = {
|
|
hosts: [],
|
|
keys: [],
|
|
identities: [],
|
|
snippets: [],
|
|
customGroups: [],
|
|
settings: {
|
|
ai: {
|
|
providers: [
|
|
{ id: "openai-main", providerId: "openai", name: "OpenAI", apiKey: "plaintext-from-other-device", enabled: true },
|
|
],
|
|
},
|
|
},
|
|
syncedAt: 1,
|
|
} as SyncPayload;
|
|
|
|
await applySyncPayload(payload, { importVaultData: () => {} });
|
|
|
|
const stored = JSON.parse(localStorage.getItem(storageKeys.STORAGE_KEY_AI_PROVIDERS)!);
|
|
assert.equal(stored[0].apiKey, "plaintext-from-other-device");
|
|
});
|
|
|
|
test("applySyncPayload preserves local web-search apiKey when synced config omits it", async () => {
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_WEB_SEARCH, JSON.stringify({
|
|
providerId: "tavily",
|
|
apiKey: "enc:v1:djEwWEB",
|
|
enabled: true,
|
|
maxResults: 7,
|
|
}));
|
|
|
|
const payload: SyncPayload = {
|
|
hosts: [],
|
|
keys: [],
|
|
identities: [],
|
|
snippets: [],
|
|
customGroups: [],
|
|
settings: {
|
|
ai: {
|
|
webSearchConfig: { providerId: "tavily", enabled: false, maxResults: 12 },
|
|
},
|
|
},
|
|
syncedAt: 1,
|
|
} as SyncPayload;
|
|
|
|
await applySyncPayload(payload, { importVaultData: () => {} });
|
|
|
|
const stored = JSON.parse(localStorage.getItem(storageKeys.STORAGE_KEY_AI_WEB_SEARCH)!);
|
|
assert.deepEqual(stored, {
|
|
providerId: "tavily",
|
|
apiKey: "enc:v1:djEwWEB",
|
|
enabled: false,
|
|
maxResults: 12,
|
|
});
|
|
});
|
|
|
|
test("applySyncPayload drops local web-search apiKey when synced config switches provider", async () => {
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_AI_WEB_SEARCH, JSON.stringify({
|
|
providerId: "tavily",
|
|
apiKey: "enc:v1:djEwWEB",
|
|
enabled: true,
|
|
}));
|
|
|
|
const payload: SyncPayload = {
|
|
hosts: [],
|
|
keys: [],
|
|
identities: [],
|
|
snippets: [],
|
|
customGroups: [],
|
|
settings: {
|
|
ai: {
|
|
webSearchConfig: { providerId: "exa", enabled: true },
|
|
},
|
|
},
|
|
syncedAt: 1,
|
|
} as SyncPayload;
|
|
|
|
await applySyncPayload(payload, { importVaultData: () => {} });
|
|
|
|
const stored = JSON.parse(localStorage.getItem(storageKeys.STORAGE_KEY_AI_WEB_SEARCH)!);
|
|
assert.equal("apiKey" in stored, false);
|
|
assert.equal(stored.providerId, "exa");
|
|
});
|
|
|
|
test("buildSyncPayload includes syncable terminal options from settings", () => {
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_TERM_FOLLOW_APP_THEME, "true");
|
|
localStorage.setItem(storageKeys.STORAGE_KEY_TERM_SETTINGS, JSON.stringify({
|
|
terminalEmulationType: "vt100",
|
|
altAsMeta: true,
|
|
showServerStats: false,
|
|
serverStatsRefreshInterval: 12,
|
|
rendererType: "dom",
|
|
localShell: "/bin/zsh",
|
|
}));
|
|
|
|
const payload = buildSyncPayload(vault([]));
|
|
|
|
assert.equal(payload.settings?.followAppTerminalTheme, true);
|
|
assert.deepEqual(payload.settings?.terminalSettings, {
|
|
terminalEmulationType: "vt100",
|
|
altAsMeta: true,
|
|
showServerStats: false,
|
|
serverStatsRefreshInterval: 12,
|
|
rendererType: "dom",
|
|
});
|
|
});
|
|
|
|
test("hasMeaningfulCloudSyncData ignores legacy cloud known hosts", () => {
|
|
assert.equal(
|
|
hasMeaningfulCloudSyncData({
|
|
hosts: [],
|
|
keys: [],
|
|
identities: [],
|
|
snippets: [],
|
|
customGroups: [],
|
|
knownHosts: [knownHost("kh-only")],
|
|
syncedAt: 1,
|
|
}),
|
|
false,
|
|
);
|
|
});
|
|
|
|
test("buildLocalVaultPayload preserves known hosts for local backups", () => {
|
|
const payload = buildLocalVaultPayload(vault([knownHost("kh-local")]));
|
|
|
|
assert.deepEqual(payload.knownHosts, [knownHost("kh-local")]);
|
|
});
|
|
|
|
test("applySyncPayload ignores legacy cloud known hosts", async () => {
|
|
let imported: Record<string, unknown> | null = null;
|
|
const proxyProfiles = [
|
|
{
|
|
id: "proxy-1",
|
|
label: "Office Proxy",
|
|
config: { type: "socks5", host: "proxy.example.com", port: 1080 },
|
|
createdAt: 1,
|
|
updatedAt: 1,
|
|
},
|
|
];
|
|
const payload: SyncPayload = {
|
|
hosts: [],
|
|
keys: [],
|
|
identities: [],
|
|
snippets: [],
|
|
customGroups: [],
|
|
knownHosts: [knownHost("kh-legacy")],
|
|
proxyProfiles,
|
|
syncedAt: 1,
|
|
} as SyncPayload & { proxyProfiles: typeof proxyProfiles };
|
|
|
|
await applySyncPayload(payload, {
|
|
importVaultData: (json) => {
|
|
imported = JSON.parse(json);
|
|
},
|
|
});
|
|
|
|
assert.ok(imported);
|
|
assert.equal("knownHosts" in imported, false);
|
|
assert.deepEqual(imported.proxyProfiles, proxyProfiles);
|
|
});
|
|
|
|
test("applySyncPayload keeps missing proxy references visible to connection guards", async () => {
|
|
let imported: Record<string, unknown> | null = null;
|
|
const payload: SyncPayload = {
|
|
hosts: [{
|
|
id: "host-1",
|
|
label: "Host",
|
|
hostname: "example.com",
|
|
username: "root",
|
|
tags: [],
|
|
os: "linux",
|
|
proxyProfileId: "missing-proxy",
|
|
}],
|
|
keys: [],
|
|
identities: [],
|
|
proxyProfiles: [],
|
|
snippets: [],
|
|
customGroups: [],
|
|
groupConfigs: [{ path: "prod", proxyProfileId: "missing-proxy" }],
|
|
syncedAt: 1,
|
|
};
|
|
|
|
await applySyncPayload(payload, {
|
|
importVaultData: (json) => {
|
|
imported = JSON.parse(json);
|
|
},
|
|
});
|
|
|
|
assert.ok(imported);
|
|
assert.equal((imported.hosts as SyncPayload["hosts"])[0]?.proxyProfileId, "missing-proxy");
|
|
assert.equal((imported.groupConfigs as SyncPayload["groupConfigs"])?.[0]?.proxyProfileId, "missing-proxy");
|
|
});
|
|
|
|
test("applySyncPayload preserves host proxy references when group configs are absent", async () => {
|
|
let imported: Record<string, unknown> | null = null;
|
|
const payload: SyncPayload = {
|
|
hosts: [{
|
|
id: "host-1",
|
|
label: "Host",
|
|
hostname: "example.com",
|
|
username: "root",
|
|
tags: [],
|
|
os: "linux",
|
|
proxyProfileId: "missing-proxy",
|
|
}],
|
|
keys: [],
|
|
identities: [],
|
|
proxyProfiles: [],
|
|
snippets: [],
|
|
customGroups: [],
|
|
syncedAt: 1,
|
|
};
|
|
|
|
await applySyncPayload(payload, {
|
|
importVaultData: (json) => {
|
|
imported = JSON.parse(json);
|
|
},
|
|
});
|
|
|
|
assert.ok(imported);
|
|
assert.equal((imported.hosts as SyncPayload["hosts"])[0]?.proxyProfileId, "missing-proxy");
|
|
assert.equal("groupConfigs" in imported, false);
|
|
});
|
|
|
|
test("applySyncPayload waits for async vault imports", async () => {
|
|
let finished = false;
|
|
const payload: SyncPayload = {
|
|
hosts: [],
|
|
keys: [],
|
|
identities: [],
|
|
snippets: [],
|
|
customGroups: [],
|
|
syncedAt: 1,
|
|
};
|
|
|
|
const promise = applySyncPayload(payload, {
|
|
importVaultData: async () => {
|
|
await new Promise((resolve) => setTimeout(resolve, 1));
|
|
finished = true;
|
|
},
|
|
});
|
|
|
|
assert.equal(finished, false);
|
|
await promise;
|
|
assert.equal(finished, true);
|
|
});
|
|
|
|
test("buildSyncPayload includes fallbackFont when present in TERM_SETTINGS", () => {
|
|
localStorage.setItem(
|
|
storageKeys.STORAGE_KEY_TERM_SETTINGS,
|
|
JSON.stringify({ scrollback: 5000, fallbackFont: "PingFang SC", fontLigatures: true }),
|
|
);
|
|
|
|
const payload = buildSyncPayload(vault());
|
|
const termSettings = (payload.settings?.terminalSettings ?? {}) as Record<string, unknown>;
|
|
assert.equal(termSettings.fallbackFont, "PingFang SC");
|
|
});
|
|
|
|
test("buildSyncPayload omits fallbackFont when TERM_SETTINGS does not set it", () => {
|
|
localStorage.setItem(
|
|
storageKeys.STORAGE_KEY_TERM_SETTINGS,
|
|
JSON.stringify({ scrollback: 5000, fontLigatures: true }),
|
|
);
|
|
|
|
const payload = buildSyncPayload(vault());
|
|
const termSettings = (payload.settings?.terminalSettings ?? {}) as Record<string, unknown>;
|
|
assert.equal("fallbackFont" in termSettings, false);
|
|
});
|
|
|
|
test("applySyncPayload writes incoming fallbackFont into local TERM_SETTINGS", async () => {
|
|
const payload: SyncPayload = {
|
|
hosts: [],
|
|
keys: [],
|
|
identities: [],
|
|
snippets: [],
|
|
customGroups: [],
|
|
syncedAt: 1,
|
|
settings: { terminalSettings: { fallbackFont: "Sarasa Mono SC" } },
|
|
};
|
|
|
|
await applySyncPayload(payload, {
|
|
importVaultData: () => {},
|
|
});
|
|
|
|
const raw = localStorage.getItem(storageKeys.STORAGE_KEY_TERM_SETTINGS);
|
|
assert.ok(raw, "TERM_SETTINGS should be written");
|
|
const parsed = JSON.parse(raw!);
|
|
assert.equal(parsed.fallbackFont, "Sarasa Mono SC");
|
|
});
|
|
|
|
test("applySyncPayload from legacy client (no fallbackFont) preserves local value", async () => {
|
|
localStorage.setItem(
|
|
storageKeys.STORAGE_KEY_TERM_SETTINGS,
|
|
JSON.stringify({ scrollback: 5000, fallbackFont: "Microsoft YaHei UI" }),
|
|
);
|
|
|
|
const payload: SyncPayload = {
|
|
hosts: [],
|
|
keys: [],
|
|
identities: [],
|
|
snippets: [],
|
|
customGroups: [],
|
|
syncedAt: 1,
|
|
settings: { terminalSettings: { scrollback: 9999 } },
|
|
};
|
|
|
|
await applySyncPayload(payload, {
|
|
importVaultData: () => {},
|
|
});
|
|
|
|
const raw = localStorage.getItem(storageKeys.STORAGE_KEY_TERM_SETTINGS);
|
|
const parsed = JSON.parse(raw!);
|
|
assert.equal(parsed.fallbackFont, "Microsoft YaHei UI", "legacy payload must not wipe local fallbackFont");
|
|
assert.equal(parsed.scrollback, 9999);
|
|
});
|
|
|
|
test("applyLocalVaultPayload restores known hosts from local backups", async () => {
|
|
let imported: Record<string, unknown> | null = null;
|
|
const payload: SyncPayload = {
|
|
hosts: [],
|
|
keys: [],
|
|
identities: [],
|
|
snippets: [],
|
|
customGroups: [],
|
|
knownHosts: [knownHost("kh-backup")],
|
|
syncedAt: 1,
|
|
};
|
|
|
|
await applyLocalVaultPayload(payload, {
|
|
importVaultData: (json) => {
|
|
imported = JSON.parse(json);
|
|
},
|
|
});
|
|
|
|
assert.ok(imported);
|
|
assert.deepEqual(imported.knownHosts, [knownHost("kh-backup")]);
|
|
});
|