Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

fix(companions): keep import archives out of tool discovery

Chris08b5cd466c55
diff --git a/apps/desktop/src/main/bot-import/README.md b/apps/desktop/src/main/bot-import/README.md
index 487a7ca3d6..b2ea9d0486 100644
--- a/apps/desktop/src/main/bot-import/README.md
+++ b/apps/desktop/src/main/bot-import/README.md
@@ -194,6 +194,12 @@ omitting it retains normal companion defaults, and a rejected request can be cor
reordered or truncated chunks. Large JSON encode/decode/hash work runs in a
short-lived Node worker; checkpoint conversion yields between resource files
and reuses already captured bytes when publishing the environment.
+ Tool discovery and harness session initialization read a separate encrypted
+ projection containing only connection inputs, a credential identity hash and
+ the pending-setup flag. Source files and the retry snapshot stay in the original
+ archive. Writes invalidate/rebuild the projection under a per-companion lock;
+ legacy or missing projections rebuild once, with large archive parsing and
+ projection in a worker. Both encrypted records participate in deletion recovery.
Legacy single-value ciphertext and numeric-array snapshots remain readable;
normal writes automatically use the chunked format. Legacy decryption itself
remains synchronous until that first rewrite. This changes only the private
diff --git a/apps/desktop/src/main/bot-import/__tests__/connectionProvider.test.ts b/apps/desktop/src/main/bot-import/__tests__/connectionProvider.test.ts
index c87d1e88ac..67119eca50 100644
--- a/apps/desktop/src/main/bot-import/__tests__/connectionProvider.test.ts
+++ b/apps/desktop/src/main/bot-import/__tests__/connectionProvider.test.ts
@@ -1,4 +1,4 @@
-import { afterEach, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
import { promises as fs } from 'node:fs';
import path from 'node:path';
import os from 'node:os';
@@ -8,8 +8,9 @@ import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
vi.mock('@cindy/mcps', () => ({ resolveLiziMcpSessionContext: () => ({ sessionId: 'fixture-session' }) }));
vi.mock('../host.js', () => ({ continueCompanionImport: vi.fn(), getCompanionImportSetupStatus: vi.fn(), useCindyImportSettings: vi.fn() }));
-vi.mock('../runtime.js', () => ({ readCompanionSessionEnvironment: vi.fn(), readCompanionSessionScope: vi.fn() }));
-import { readCompanionSessionEnvironment, readCompanionSessionScope } from '../runtime.js';
+vi.mock('../runtime.js', () => ({ readCompanionSessionDiscovery: vi.fn(), readCompanionSessionEnvironment: vi.fn(), readCompanionSessionScope: vi.fn() }));
+import { readCompanionSessionDiscovery, readCompanionSessionEnvironment, readCompanionSessionScope } from '../runtime.js';
+import { projectEnvironmentDiscovery } from '../environmentJson.js';
import { createCompanionConnectionsProvider } from '../connectionProvider.js';
import { redactEnvironmentData } from '../process.js';
import { withImportedConnection } from '../connections.js';
@@ -17,8 +18,30 @@ import * as connectionModule from '../connections.js';
import { connectionRedactions, redactImportedTool, restoreImportedArguments } from '../connectionCatalog.js';
import { CallToolResultSchema, type Tool } from '@modelcontextprotocol/sdk/types.js';
let root: string | undefined;
+beforeEach(() => {
+ vi.mocked(readCompanionSessionDiscovery).mockReset().mockImplementation(async session => {
+ const scope = await readCompanionSessionEnvironment(session);
+ return scope ? { ...scope, environment: projectEnvironmentDiscovery(scope.environment) } : undefined;
+ });
+});
afterEach(async () => { vi.unstubAllEnvs(); if (root) await fs.rm(root, { recursive: true, force: true }); });
+it('lists and refreshes pending setup tools without loading the retry archive', async () => {
+ vi.mocked(readCompanionSessionEnvironment).mockReset().mockRejectedValue(new Error('must not load full environment'));
+ const assertOwner = vi.fn();
+ vi.mocked(readCompanionSessionDiscovery).mockResolvedValue({ identity: 'fixture', botId: 'bot', userData: '/fixture', assertOwner,
+ environment: { env: {}, mcp: [], identity: 'fixture', pendingImport: true } });
+ const config = createCompanionConnectionsProvider().toClaudeSdkConfig!({} as never) as { instance: McpServer };
+ const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+ const client = new Client({ name: 'fixture', version: '1' });
+ await config.instance.connect(serverTransport); await client.connect(clientTransport);
+ try {
+ for (let i = 0; i < 3; i++) expect((await client.listTools()).tools.map(tool => tool.name)).toEqual(['run_command', 'import_setup']);
+ expect(readCompanionSessionEnvironment).not.toHaveBeenCalled();
+ expect(assertOwner).toHaveBeenCalled();
+ } finally { await client.close(); await config.instance.close(); }
+});
+
it.skipIf(process.platform === 'win32')('uses original credentials in a real imported command and redacts arbitrary names from its response', async () => {
vi.stubEnv('CINDY_UNRELATED_TEST_SECRET', 'fixture-launch-secret');
vi.stubEnv('HTTPS_PROXY', 'http://fixture-user:[email protected]');
diff --git a/apps/desktop/src/main/bot-import/__tests__/connections.test.ts b/apps/desktop/src/main/bot-import/__tests__/connections.test.ts
index a9d3dffd3d..a43833de5d 100644
--- a/apps/desktop/src/main/bot-import/__tests__/connections.test.ts
+++ b/apps/desktop/src/main/bot-import/__tests__/connections.test.ts
@@ -81,7 +81,7 @@ readline.createInterface({input:process.stdin}).on('line', line => {
});`);
}
const secretValues = new Map<string, string>();
- const secretIo = { read: (key: string) => secretValues.get(key) ?? null, write: (key: string, value: string) => { secretValues.set(key, value); return true; }, remove: (key: string) => secretValues.delete(key) };
+ const secretIo = { read: (key: string) => secretValues.get(key) ?? null, write: (key: string, value: string) => { secretValues.set(key, value); return true; }, remove: (key: string) => { secretValues.delete(key); return true; } };
for (const cwd of [undefined, 'server files', custom, `~/${path.relative(directory, custom).split(path.sep).join('/')}`]) {
const config = { workdir: workspace, agents: { defaults: { workspace } }, mcpServers: { fixture: { command: process.execPath, args: ['./server.cjs'], ...(cwd === undefined ? {} : { cwd }) } } };
await fs.writeFile(path.join(root, kind === 'hermes' ? 'config.yaml' : 'openclaw.json'), JSON.stringify(config));
diff --git a/apps/desktop/src/main/bot-import/__tests__/environment.test.ts b/apps/desktop/src/main/bot-import/__tests__/environment.test.ts
index 32c0f6ef0d..8f07ec7a67 100644
--- a/apps/desktop/src/main/bot-import/__tests__/environment.test.ts
+++ b/apps/desktop/src/main/bot-import/__tests__/environment.test.ts
@@ -35,6 +35,7 @@ it('retains credentials before deletion commits and retries failed cleanup after
const store = createCompanionEnvironmentStore(io);
const environment = { version: 1 as const, env: { TOKEN: 'fixture-secret' }, mcp: [], credentials: [] };
await store.write(root, 'fixture', environment, () => {});
+ remove.mockClear();
await store.stageRemoval(root, 'fixture', () => {});
const marker = path.join(root, 'companion-import-cleanups/fixture.json');
expect(await fs.readFile(marker, 'utf8')).not.toContain('fixture-secret');
@@ -46,14 +47,14 @@ it('retains credentials before deletion commits and retries failed cleanup after
await fs.rm(path.join(root, 'bots/fixture'), { recursive: true });
remove.mockReturnValueOnce(false);
await expect(store.finishRemoval(root, 'fixture', () => {})).rejects.toThrow('CREDENTIAL_STORAGE_FAILED');
- expect(values.size).toBe(1);
+ expect(values.size).toBe(2);
expect(await fs.readFile(marker, 'utf8')).toContain('fixture');
const restarted = createCompanionEnvironmentStore(io);
await restarted.recoverRemovals(root, () => {}, async () => false);
expect(values.size).toBe(0);
await expect(fs.access(marker)).rejects.toThrow();
await restarted.recoverRemovals(root, () => {}, async () => false);
- expect(remove).toHaveBeenCalledTimes(2);
+ expect(remove).toHaveBeenCalledTimes(3);
});
it('retains pending cleanup if ownership changes while checking the committed profile state', async () => {
@@ -83,7 +84,7 @@ it('does no cleanup writes for ordinary companions even when the cleanup path is
it('still stages a vault-only checkpoint left before the binding was written', async () => {
const values = new Map([[companionEnvironmentKey('fixture'), 'private-checkpoint']]);
- const store = createCompanionEnvironmentStore({ read: key => values.get(key) ?? null, write: () => true, remove: key => values.delete(key) });
+ const store = createCompanionEnvironmentStore({ read: key => values.get(key) ?? null, write: () => true, remove: key => { values.delete(key); return true; } });
await store.stageRemoval(root, 'fixture', () => {});
await store.finishRemoval(root, 'fixture', () => {});
expect(values.size).toBe(0);
@@ -139,6 +140,6 @@ it('recovers media cleanup before removing the private import checkpoint', async
await expect(fs.access(path.join(root, 'companion-import-cleanups/fixture.json'))).resolves.toBeUndefined();
await store.recoverRemovals(root, () => {}, async () => false);
expect(removeResources).toHaveBeenCalledTimes(2);
- expect(remove).toHaveBeenCalledOnce();
+ expect(remove).toHaveBeenCalledTimes(2);
await expect(fs.access(path.join(root, 'companion-import-cleanups/fixture.json'))).rejects.toThrow();
});
diff --git a/apps/desktop/src/main/bot-import/__tests__/environmentDiscovery.test.ts b/apps/desktop/src/main/bot-import/__tests__/environmentDiscovery.test.ts
new file mode 100644
index 0000000000..8ae0c45177
--- /dev/null
+++ b/apps/desktop/src/main/bot-import/__tests__/environmentDiscovery.test.ts
@@ -0,0 +1,101 @@
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { companionEnvironmentKey, companionDiscoveryKey, createCompanionEnvironmentStore, type CompanionEnvironment } from '../environment.js';
+import { projectEnvironmentDiscovery } from '../environmentJson.js';
+
+let root: string;
+beforeEach(async () => { root = await fs.mkdtemp(path.join(os.tmpdir(), 'cindy-import-discovery-')); });
+afterEach(async () => { await fs.rm(root, { recursive: true, force: true }); });
+const fixture = (): CompanionEnvironment => ({ version: 1, env: { TOKEN: 'fixture-token' }, mcp: [{ name: 'data', url: 'https://example.invalid/mcp' }],
+ credentials: [{ id: 'config', format: 'json', value: { token: 'fixture-credential' } }],
+ memoryFiles: { 'original.txt': 'fixture-original'.repeat(100000) },
+ pendingImport: { selection: { previewId: 'preview', requestId: 'fixture-request-discovery', name: 'Ada', entryIds: ['one'], takeover: true }, snapshotJson: 'fixture-snapshot'.repeat(100000) } });
+function storage() {
+ const values = new Map<string, string>();
+ const io = { read: vi.fn((key: string) => values.get(key) ?? null),
+ write: vi.fn((key: string, value: string) => { values.set(key, value); return true; }),
+ remove: vi.fn((key: string) => { values.delete(key); return true; }) };
+ return { values, io, store: createCompanionEnvironmentStore(io) };
+}
+
+it('discovers repeatedly after restart without reading the archive, while retry restores every original', async () => {
+ const { values, io, store } = storage(); const original = fixture();
+ await store.write(root, 'bot', original, () => {});
+ const restarted = createCompanionEnvironmentStore(io); io.read.mockClear();
+ for (let i = 0; i < 3; i++) {
+ const result = await restarted.readDiscovery(root, 'bot', () => {});
+ expect(result).toMatchObject({ env: original.env, mcp: original.mcp, pendingImport: true });
+ expect(Object.keys(result!).sort()).toEqual(['env', 'identity', 'mcp', 'pendingImport']);
+ expect(JSON.stringify(result).length).toBeLessThan(1000);
+ }
+ expect(io.read.mock.calls.every(([key]) => key === companionDiscoveryKey('bot'))).toBe(true);
+ expect(await restarted.read(root, 'bot', () => {})).toEqual(original);
+ const binding = await fs.readFile(path.join(root, 'bots/bot/environment.json'), 'utf8');
+ expect(binding).not.toContain('fixture-token'); expect(binding).not.toContain('fixture-snapshot');
+ expect(values.get(companionDiscoveryKey('bot'))).not.toContain('fixture-original');
+});
+
+it('derives legacy or missing/corrupt discovery data once without rewriting the original archive', async () => {
+ const { values, io, store } = storage(); const original = fixture();
+ await fs.mkdir(path.join(root, 'bots/bot'), { recursive: true });
+ await fs.writeFile(path.join(root, 'bots/bot/environment.json'), JSON.stringify({ version: 1 }));
+ const archive = JSON.stringify(original); values.set(companionEnvironmentKey('bot'), archive);
+ for (const cache of [undefined, 'corrupt', JSON.stringify({ version: 1, revision: 'stale', environment: {} })]) {
+ if (cache === undefined) values.delete(companionDiscoveryKey('bot')); else values.set(companionDiscoveryKey('bot'), cache);
+ io.read.mockClear(); io.write.mockClear();
+ const results = await Promise.all(Array.from({ length: 3 }, () => store.readDiscovery(root, 'bot', () => {})));
+ expect(results[0]).toEqual(projectEnvironmentDiscovery(original));
+ expect(results.every(result => JSON.stringify(result) === JSON.stringify(results[0]))).toBe(true);
+ expect(io.read.mock.calls.filter(([key]) => key === companionEnvironmentKey('bot'))).toHaveLength(1);
+ expect(io.write.mock.calls.map(([key]) => key)).toEqual([companionDiscoveryKey('bot')]);
+ expect(values.get(companionEnvironmentKey('bot'))).toBe(archive);
+ }
+});
+
+it('recovers the current archive after projection publication fails and cleans a projection-only orphan', async () => {
+ const { values, io, store } = storage(); await store.write(root, 'bot', fixture(), () => {});
+ const write = io.write.getMockImplementation()!;
+ io.write.mockImplementationOnce(write).mockImplementationOnce(() => false);
+ const changed = { ...fixture(), env: { TOKEN: 'replacement' } };
+ await expect(store.write(root, 'bot', changed, () => {})).rejects.toThrow('CREDENTIAL_STORAGE_FAILED');
+ io.read.mockImplementationOnce(() => { throw new Error('corrupt derived ciphertext'); });
+ expect(await store.readDiscovery(root, 'bot', () => {})).toEqual(projectEnvironmentDiscovery(changed));
+ expect(await store.read(root, 'bot', () => {})).toEqual(changed);
+ await fs.rm(path.join(root, 'bots/bot'), { recursive: true });
+ values.delete(companionEnvironmentKey('bot'));
+ await store.stageRemoval(root, 'bot', () => {});
+ await store.finishRemoval(root, 'bot', () => {});
+ expect(values.size).toBe(0);
+});
+
+it('refreshes connections and credential identity after updates and removes the setup tool flag on completion', async () => {
+ const { store } = storage(); await store.write(root, 'bot', fixture(), () => {});
+ const first = await store.readDiscovery(root, 'bot', () => {});
+ await store.update(root, 'bot', () => {}, value => { value.credentials[0]!.value = 'changed'; });
+ const next = await store.readDiscovery(root, 'bot', () => {});
+ expect(next!.identity).not.toBe(first!.identity);
+ await store.update(root, 'bot', () => {}, value => { value.env = { TOKEN: 'new-token' }; value.mcp = []; delete value.pendingImport; });
+ expect(await store.readDiscovery(root, 'bot', () => {})).toMatchObject({ env: { TOKEN: 'new-token' }, mcp: [], pendingImport: false });
+});
+
+it('never reuses stale discovery after an interrupted write and joins rebuilds before deletion', async () => {
+ const { values, io, store } = storage(); await store.write(root, 'bot', fixture(), () => {});
+ io.write.mockImplementationOnce(() => false);
+ await expect(store.write(root, 'bot', { ...fixture(), env: { TOKEN: 'replacement' } }, () => {})).rejects.toThrow('CREDENTIAL_STORAGE_FAILED');
+ expect(values.has(companionDiscoveryKey('bot'))).toBe(false);
+ expect(await store.readDiscovery(root, 'bot', () => {})).toMatchObject({ env: { TOKEN: 'fixture-token' } });
+ values.delete(companionDiscoveryKey('bot'));
+ await store.stageRemoval(root, 'bot', () => {});
+ let current = true; let release!: () => void; let started = false;
+ const barrier = new Promise<void>(resolve => { release = resolve; });
+ const asyncIo = { ...io, write: async (key: string, value: string) => { started = true; await barrier; values.set(key, value); return true; } };
+ const restarted = createCompanionEnvironmentStore(asyncIo);
+ const reading = restarted.readDiscovery(root, 'bot', () => { if (!current) throw new Error('owner changed'); });
+ const rejected = expect(reading).rejects.toThrow('owner changed');
+ await vi.waitFor(() => expect(started).toBe(true)); current = false;
+ const removing = restarted.finishRemoval(root, 'bot', () => {});
+ release(); await rejected; await removing;
+ expect(values.size).toBe(0);
+});
diff --git a/apps/desktop/src/main/bot-import/__tests__/host.test.ts b/apps/desktop/src/main/bot-import/__tests__/host.test.ts
index 23b8c08958..a248963278 100644
--- a/apps/desktop/src/main/bot-import/__tests__/host.test.ts
+++ b/apps/desktop/src/main/bot-import/__tests__/host.test.ts
@@ -214,7 +214,7 @@ it('rejects a simultaneous normalized-name conflict, removes only the loser chec
expect(await h.store.read(h.root, botId, () => {})).toBeUndefined();
const winner = selections[1 - rejectedIndex]!;
await vi.waitFor(async () => expect((await getCompanionImportResult(winner.requestId))?.status).toBe('complete'));
- expect(h.secretValues.size).toBe(1);
+ expect(h.secretValues.size).toBe(2);
const receiptText = await fs.readFile(path.join(h.root, 'companion-imports', `${rejected.requestId}.json`), 'utf8');
expect(receiptText).not.toContain('fixture-private-key');
expect(JSON.parse(receiptText).creationRejected).toBe('IMPORT_NAME_EXISTS');
@@ -223,7 +223,7 @@ it('rejects a simultaneous normalized-name conflict, removes only the loser chec
await startCompanionImport({ ...rejected, name: 'Grace', requestId: 'name-race-renamed-request' }, 'fixture');
await vi.waitFor(async () => expect((await getCompanionImportResult('name-race-renamed-request'))?.status).toBe('complete'));
expect(profiles.size).toBe(2);
- expect(h.secretValues.size).toBe(2);
+ expect(h.secretValues.size).toBe(4);
expect(h.pause).not.toHaveBeenCalled();
});
@@ -234,7 +234,7 @@ it('recovers rejected creation cleanup after a storage failure without retrying
const preview = await previewCompanionImport(source!.id, 'fixture');
const selection = { requestId: 'name-rejection-recovery', previewId: preview.id, name: 'Ada', entryIds: ['task'], takeover: true };
await expect(startCompanionImport(selection, 'fixture')).rejects.toThrow('CREDENTIAL_STORAGE_FAILED');
- expect(h.secretValues.size).toBe(1);
+ expect(h.secretValues.size).toBe(2);
await recoverCompanionImports();
expect(h.secretValues.size).toBe(0);
expect(finish).toHaveBeenCalledTimes(2);
@@ -255,7 +255,7 @@ it('retains a committed profile and credentials when a create conflict acknowled
await startCompanionImport(selection, 'fixture');
await vi.waitFor(async () => expect((await getCompanionImportResult(selection.requestId))?.status).toBe('complete'));
expect(h.created).toBe(true);
- expect(h.secretValues.size).toBe(1);
+ expect(h.secretValues.size).toBe(2);
expect(await h.store.read(h.root, h.botId, () => {})).toBeDefined();
});
@@ -952,7 +952,7 @@ it.each(['readback', 'binding'] as const)('cleans an unbound first checkpoint af
});
const result = await startCompanionImport(selection, 'fixture');
expect(result.status).toBe('needs-attention');
- expect(h.created).toBe(false); expect(values.size).toBe(1);
+ expect(h.created).toBe(false); expect(values.size).toBe(failure === 'binding' ? 2 : 1);
await expect(fs.access(bindingFile)).rejects.toThrow();
bindingFailure?.mockRestore();
// A new vault instance and the startup receipt scan must find and remove it,
@@ -962,14 +962,14 @@ it.each(['readback', 'binding'] as const)('cleans an unbound first checkpoint af
// A committed profile or an uncertain lookup must never lose its vault key.
vi.mocked(getBotRemoteResourceSource).mockResolvedValueOnce({ canonicalSessionId: 'chat' } as never);
await recoverCompanionImports();
- expect(values.size).toBe(1); expect(remove).not.toHaveBeenCalled();
+ expect(values.size).toBe(failure === 'binding' ? 2 : 1); expect(remove).not.toHaveBeenCalled();
vi.mocked(getBotRemoteResourceSource).mockRejectedValueOnce(new Error('fixture database unavailable'));
await recoverCompanionImports();
- expect(values.size).toBe(1); expect(remove).not.toHaveBeenCalled();
+ expect(values.size).toBe(failure === 'binding' ? 2 : 1); expect(remove).not.toHaveBeenCalled();
await recoverCompanionImports();
- expect(values.size).toBe(1);
+ expect(values.size).toBe(failure === 'binding' ? 2 : 1);
await recoverCompanionImports();
- expect(values.size).toBe(0); expect(remove).toHaveBeenCalledTimes(2);
+ expect(values.size).toBe(0); expect(remove).toHaveBeenCalledTimes(3);
expect(h.created).toBe(false);
});
diff --git a/apps/desktop/src/main/bot-import/__tests__/runtime.test.ts b/apps/desktop/src/main/bot-import/__tests__/runtime.test.ts
index eec4e4ba5e..2930a91a44 100644
--- a/apps/desktop/src/main/bot-import/__tests__/runtime.test.ts
+++ b/apps/desktop/src/main/bot-import/__tests__/runtime.test.ts
@@ -11,16 +11,19 @@ vi.mock('../../localDb/client/current.js', () => ({ getDbClient: () => {
} }));
import { companionEnvironmentStore, finishCompanionEnvironmentRemoval, readCompanionSessionEnvironment, readCompanionSessionScope, resolveCompanionRuntimeEnvironment } from '../runtime.js';
import { withImportedConnection } from '../connections.js';
+import { projectEnvironmentDiscovery } from '../environmentJson.js';
afterEach(() => vi.restoreAllMocks());
it('projects only opaque identity and owner fencing into all harnesses, never imported values', async () => {
const env = { TELEGRAM_BOT_TOKEN: 'fixture-token', GITHUB_PAT: 'fixture-pat', DATABASE_URL: 'postgres://fixture:[email protected]/db',
ANTHROPIC_CUSTOM_HEADERS: 'Authorization: fixture-header', ANTHROPIC_UNIX_SOCKET: '/fixture/socket', UNUSUAL_NAME: 'short' };
- vi.spyOn(companionEnvironmentStore, 'read').mockResolvedValue({ version: 1, env, mcp: [], credentials: [] });
+ const archive = vi.spyOn(companionEnvironmentStore, 'read').mockRejectedValue(new Error('must not load archive'));
+ vi.spyOn(companionEnvironmentStore, 'readDiscovery').mockResolvedValue(projectEnvironmentDiscovery({ version: 1, env, mcp: [], credentials: [] }));
const result = await resolveCompanionRuntimeEnvironment('fixture-session');
expect(result).toEqual({ identity: expect.any(String), assertCurrent: expect.any(Function) });
for (const value of Object.values(env)) expect(JSON.stringify(result)).not.toContain(value);
result!.assertCurrent();
+ expect(archive).not.toHaveBeenCalled();
});
it('drains deleted companion transports before vault removal and rejects stale scopes without affecting another companion', async () => {
diff --git a/apps/desktop/src/main/bot-import/connectionProvider.ts b/apps/desktop/src/main/bot-import/connectionProvider.ts
index b51575d1b1..f1e0237b63 100644
--- a/apps/desktop/src/main/bot-import/connectionProvider.ts
+++ b/apps/desktop/src/main/bot-import/connectionProvider.ts
@@ -4,7 +4,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { CallToolRequestSchema, ListToolsRequestSchema, type Tool } from '@modelcontextprotocol/sdk/types.js';
import type { McpProvider } from '@cindy/maker-core';
import { resolveLiziMcpSessionContext } from '@cindy/mcps';
-import { readCompanionSessionEnvironment, readCompanionSessionScope } from './runtime.js';
+import { readCompanionSessionDiscovery, readCompanionSessionEnvironment, readCompanionSessionScope } from './runtime.js';
import { IMPORTED_TOOL_LIMIT, listImportedTools, withImportedConnection } from './connections.js';
import { fingerprint } from './files.js';
import { continueCompanionImport, getCompanionImportSetupStatus, useCindyImportSettings } from './host.js';
@@ -19,14 +19,14 @@ export function createCompanionConnectionsProvider(): McpProvider {
name: COMPANION_CONNECTIONS_MCP_NAME,
toClaudeSdkConfig(context) {
const server = new McpServer({ name: COMPANION_CONNECTIONS_MCP_NAME, version: '1.0.0' }, { capabilities: { tools: {} } });
- const resolve = async () => {
+ const resolve = async <T>(read: (sessionId: string) => Promise<T>) => {
const session = resolveLiziMcpSessionContext(context);
if (!session.sessionId) return undefined;
- return readCompanionSessionEnvironment(session.sessionId);
+ return read(session.sessionId);
};
const toolName = (connection: string, tool: string, publicName = tool) => `c_${fingerprint(connection).slice(0, 12)}_${publicName.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 32)}_${fingerprint(tool).slice(0, 8)}`;
server.server.setRequestHandler(ListToolsRequestSchema, async (_request, extra) => {
- const scope = await resolve();
+ const scope = await resolve(readCompanionSessionDiscovery);
if (!scope) return { tools: [] };
const tools: Tool[] = [{ name: 'run_command', description: 'Run a command with this companion’s imported environment and API credentials. Use this for imported skills and data queries that require their original environment. This executes arbitrary shell code with private credentials and may write files or use the network; it requires the current task’s command authorization. Output masking is not a security sandbox.', annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }, inputSchema: { type: 'object', properties: { command: { type: 'string' } }, required: ['command'], additionalProperties: false } }];
if (scope.environment.pendingImport) tools.push({ name: 'import_setup',
@@ -67,7 +67,7 @@ export function createCompanionConnectionsProvider(): McpProvider {
scope.assertOwner();
return { content: [{ type: 'text', text: JSON.stringify(response) }] };
}
- const scope = await resolve();
+ const scope = await resolve(readCompanionSessionEnvironment);
if (!scope) throw new Error('Companion connection unavailable');
if (request.params.name === 'run_command') {
const command = request.params.arguments?.command;
diff --git a/apps/desktop/src/main/bot-import/environment.ts b/apps/desktop/src/main/bot-import/environment.ts
index 549718d46b..c2287cd7d0 100644
--- a/apps/desktop/src/main/bot-import/environment.ts
+++ b/apps/desktop/src/main/bot-import/environment.ts
@@ -2,7 +2,7 @@ import { promises as fs } from 'node:fs';
import path from 'node:path';
import { atomicWriteFileSync, readAtomicFileSync } from '../utils/atomicWriteFile.js';
import { fingerprint } from './files.js';
-import { encodeEnvironment, decodeEnvironment } from './environmentJson.js';
+import { encodeEnvironment, decodeEnvironment, decodeEnvironmentDiscovery, projectEnvironmentDiscovery } from './environmentJson.js';
import { CompanionImportError, type ImportedMcpServer } from './types.js';
/** Never returned over IPC, included in profile JSON, or passed to a language model. */
@@ -40,15 +40,25 @@ export interface CompanionSecretIo {
has?(key: string): boolean;
read(key: string, assertOwner?: () => void): string | null | Promise<string | null>;
write(key: string, value: string, assertOwner?: () => void): boolean | Promise<boolean>;
+ /** Idempotent: a missing key is a successful removal, matching the account vault. */
remove(key: string): boolean;
removeResources?(botId: string, assertOwner: () => void): Promise<void>;
}
+export interface CompanionDiscoveryEnvironment {
+ env: CompanionEnvironment['env'];
+ mcp: CompanionEnvironment['mcp'];
+ identity: string;
+ pendingImport: boolean;
+}
+
function bindingPath(userData: string, botId: string): string {
if (!/^[a-z0-9][a-z0-9_-]{0,127}$/.test(botId)) throw new CompanionImportError('INVALID_COMPANION');
return path.join(userData, 'bots', botId, 'environment.json');
}
export const companionEnvironmentKey = (botId: string): string => `bot_environment_${fingerprint(botId)}`;
+// Same account-scoped encrypted namespace; separate from the authoritative, backwards-compatible archive.
+export const companionDiscoveryKey = (botId: string): string => `bot_environment_${fingerprint(['discovery', botId])}`;
function removalPath(userData: string, botId: string): string {
bindingPath(userData, botId); // Apply the same host-owned ID validation.
return path.join(userData, 'companion-import-cleanups', `${botId}.json`);
@@ -58,29 +68,73 @@ function removalPath(userData: string, botId: string): string {
export function createCompanionEnvironmentStore(io: CompanionSecretIo) {
const queues = new Map<string, Promise<unknown>>();
const writes = new Map<string, Set<Promise<void>>>();
+ const discoveryQueue = new Map<string, Promise<unknown>>();
+ const serializeDiscovery = async <T>(key: string, run: () => Promise<T>): Promise<T> => {
+ const task = (discoveryQueue.get(key) ?? Promise.resolve()).catch(() => {}).then(run);
+ discoveryQueue.set(key, task);
+ try { return await task; } finally { if (discoveryQueue.get(key) === task) discoveryQueue.delete(key); }
+ };
+ const saveDiscovery = async (botId: string, revision: unknown, environment: CompanionDiscoveryEnvironment, assertOwner: () => void) => {
+ const { text } = await encodeEnvironment({ version: 1, revision: revision ?? null, environment }, assertOwner);
+ assertOwner();
+ if (!await io.write(companionDiscoveryKey(botId), text, assertOwner) || await io.read(companionDiscoveryKey(botId), assertOwner) !== text)
+ throw new CompanionImportError('CREDENTIAL_STORAGE_FAILED');
+ assertOwner();
+ };
const store = {
async write(userData: string, botId: string, value: CompanionEnvironment, assertOwner: () => void): Promise<void> {
const key = `${userData}:${botId}`;
- const task = (async () => {
+ const task = serializeDiscovery(key, async () => {
const file = bindingPath(userData, botId);
assertOwner();
await fs.mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
assertOwner();
const { text: encoded, revision } = await encodeEnvironment(value, assertOwner);
assertOwner();
+ // Invalidate before touching the archive: a crash or failed write cannot retain stale connections.
+ if (!io.remove(companionDiscoveryKey(botId))) throw new CompanionImportError('CREDENTIAL_STORAGE_FAILED');
if (!await io.write(companionEnvironmentKey(botId), encoded, assertOwner) || await io.read(companionEnvironmentKey(botId), assertOwner) !== encoded)
throw new CompanionImportError('CREDENTIAL_STORAGE_FAILED');
assertOwner();
+ await saveDiscovery(botId, revision, projectEnvironmentDiscovery(value), assertOwner);
// Names are untrusted too: a connection or variable identifier can contain
// a credential. This existence binding has no consumer for original names.
const manifest = JSON.stringify({ version: 1, variables: Object.keys(value.env).map(name => fingerprint(name)), connections: value.mcp.map(server => fingerprint(server.name)), revision,
importRequestId: value.pendingImport?.selection.requestId ?? null });
atomicWriteFileSync(file, manifest);
- })();
+ });
const pending = writes.get(key) ?? new Set<Promise<void>>();
pending.add(task); writes.set(key, pending);
try { await task; } finally { pending.delete(task); if (!pending.size) writes.delete(key); }
},
+ /** Persisted discovery survives restarts; missing/legacy artifacts rebuild once under the writer lock. */
+ async readDiscovery(userData: string, botId: string, assertOwner: () => void): Promise<CompanionDiscoveryEnvironment | undefined> {
+ return serializeDiscovery(`${userData}:${botId}`, async () => {
+ assertOwner();
+ const binding = readAtomicFileSync(bindingPath(userData, botId));
+ if (binding === null) return undefined;
+ const revision: unknown = JSON.parse(binding).revision ?? null;
+ let cached: string | null = null;
+ try { cached = await io.read(companionDiscoveryKey(botId), assertOwner); }
+ catch { assertOwner(); /* A damaged ciphertext is also a rebuildable derived artifact. */ }
+ assertOwner();
+ if (cached !== null) {
+ try {
+ const data = await decodeEnvironment<{ version: number; revision: unknown; environment: CompanionDiscoveryEnvironment }>(cached, assertOwner);
+ if (data.version === 1 && data.revision === revision && data.environment?.env && Array.isArray(data.environment.mcp)
+ && /^[a-f0-9]{64}$/.test(data.environment.identity) && typeof data.environment.pendingImport === 'boolean') return data.environment;
+ } catch { assertOwner(); /* Rebuild a damaged derived artifact from the unchanged archive. */ }
+ }
+ const encoded = await io.read(companionEnvironmentKey(botId), assertOwner);
+ assertOwner();
+ if (encoded === null) throw new CompanionImportError('CREDENTIAL_STORAGE_UNAVAILABLE');
+ let environment: CompanionDiscoveryEnvironment;
+ try { environment = await decodeEnvironmentDiscovery(encoded, assertOwner); }
+ catch { assertOwner(); throw new CompanionImportError('CREDENTIAL_STORAGE_INVALID'); }
+ await saveDiscovery(botId, revision, environment, assertOwner);
+ return environment;
+ });
+ },
/** Opaque request binding only. Undefined means a legacy manifest needs one-time migration. */
readImportRequestId(userData: string, botId: string, assertOwner: () => void): string | null | undefined {
assertOwner();
@@ -107,6 +161,7 @@ export function createCompanionEnvironmentStore(io: CompanionSecretIo) {
return result;
},
remove(botId: string): void {
+ if (!io.remove(companionDiscoveryKey(botId))) throw new CompanionImportError('CREDENTIAL_STORAGE_FAILED');
if (!io.remove(companionEnvironmentKey(botId))) throw new CompanionImportError('CREDENTIAL_STORAGE_FAILED');
},
/** Non-secret intent survives a crash between the DB commit and vault cleanup. */
@@ -116,7 +171,8 @@ export function createCompanionEnvironmentStore(io: CompanionSecretIo) {
// A failed manifest write can leave a vault-only checkpoint. Preserve its
// cleanup path, while ordinary companions require no staging filesystem.
const key = companionEnvironmentKey(botId);
- if (readAtomicFileSync(bindingPath(userData, botId)) === null && !(io.has ? io.has(key) : await io.read(key) !== null)) return;
+ if (readAtomicFileSync(bindingPath(userData, botId)) === null && !(io.has ? io.has(key) : await io.read(key) !== null)
+ && !(io.has ? io.has(companionDiscoveryKey(botId)) : await io.read(companionDiscoveryKey(botId)) !== null)) return;
assertOwner();
await fs.mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
assertOwner();
@@ -132,6 +188,7 @@ export function createCompanionEnvironmentStore(io: CompanionSecretIo) {
const key = `${userData}:${botId}`;
await queues.get(key)?.catch(() => {});
await Promise.allSettled([...(writes.get(key) ?? [])]);
+ await discoveryQueue.get(key)?.catch(() => {});
assertOwner();
await io.removeResources?.(botId, assertOwner);
assertOwner();
diff --git a/apps/desktop/src/main/bot-import/environmentJson.ts b/apps/desktop/src/main/bot-import/environmentJson.ts
index 4b1174ec1c..0b06922e95 100644
--- a/apps/desktop/src/main/bot-import/environmentJson.ts
+++ b/apps/desktop/src/main/bot-import/environmentJson.ts
@@ -1,5 +1,12 @@
import { createHash } from 'node:crypto';
import { Worker } from 'node:worker_threads';
+import type { CompanionEnvironment, CompanionDiscoveryEnvironment } from './environment.js';
+
+/** Only live connection inputs belong in discovery, never original files or retry archives. */
+export function projectEnvironmentDiscovery(value: CompanionEnvironment): CompanionDiscoveryEnvironment {
+ return { env: value.env, mcp: value.mcp, pendingImport: !!value.pendingImport,
+ identity: createHash('sha256').update(JSON.stringify([value.env, value.mcp, value.credentials])).digest('hex') };
+}
const LARGE_JSON = 256 * 1024;
function isLarge(value: unknown): boolean {
@@ -21,7 +28,12 @@ const { parentPort } = require('node:worker_threads');
const { createHash } = require('node:crypto');
parentPort.once('message', ({ operation, value }) => {
try {
- const result = operation === 'decode' ? JSON.parse(value) : (() => {
+ const result = operation === 'discovery' ? (() => {
+ const data = JSON.parse(value);
+ if (data.version !== 1 || !data.env || !Array.isArray(data.mcp) || !Array.isArray(data.credentials)) throw new Error();
+ return { env: data.env, mcp: data.mcp, pendingImport: !!data.pendingImport,
+ identity: createHash('sha256').update(JSON.stringify([data.env, data.mcp, data.credentials])).digest('hex') };
+ })() : operation === 'decode' ? JSON.parse(value) : (() => {
const text = JSON.stringify(value);
return { text, revision: createHash('sha256').update(text).digest('hex') };
})();
@@ -29,7 +41,7 @@ parentPort.once('message', ({ operation, value }) => {
} catch { parentPort.postMessage({ failed: true }); }
});`;
-async function convert<T>(operation: 'encode' | 'decode', value: unknown, assertOwner: () => void): Promise<T> {
+async function convert<T>(operation: 'encode' | 'decode' | 'discovery', value: unknown, assertOwner: () => void): Promise<T> {
assertOwner();
const worker = new Worker(JSON_WORKER, { eval: true });
let fence: ReturnType<typeof setInterval> | undefined;
@@ -58,3 +70,12 @@ export async function decodeEnvironment<T>(value: string, assertOwner: () => voi
assertOwner();
return value.length > LARGE_JSON ? convert<T>('decode', value, assertOwner) : JSON.parse(value) as T;
}
+
+/** Legacy recovery parses the archive in a worker but clones only connection metadata back to Main. */
+export async function decodeEnvironmentDiscovery(value: string, assertOwner: () => void): Promise<CompanionDiscoveryEnvironment> {
+ assertOwner();
+ if (value.length > LARGE_JSON) return convert('discovery', value, assertOwner);
+ const data = JSON.parse(value) as CompanionEnvironment;
+ if (data.version !== 1 || !data.env || !Array.isArray(data.mcp) || !Array.isArray(data.credentials)) throw new Error('CREDENTIAL_STORAGE_INVALID');
+ return projectEnvironmentDiscovery(data);
+}
diff --git a/apps/desktop/src/main/bot-import/runtime.ts b/apps/desktop/src/main/bot-import/runtime.ts
index 0bad62e806..c4f1bd0289 100644
--- a/apps/desktop/src/main/bot-import/runtime.ts
+++ b/apps/desktop/src/main/bot-import/runtime.ts
@@ -4,6 +4,7 @@ import { getDbClient } from '../localDb/client/current.js';
import { botSessionLinks, botProfiles, sessions } from '../localDb/schema.js';
import { botEnvironmentSecretIo } from '../secrets/providerSecretStore.js';
import { createCompanionEnvironmentStore } from './environment.js';
+import { projectEnvironmentDiscovery } from './environmentJson.js';
import { fingerprint } from './files.js';
import { CompanionImportError } from './types.js';
import { removeImportedMemoryMedia } from './memoryMedia.js';
@@ -71,10 +72,19 @@ export async function readCompanionSessionEnvironment(sessionId: string) {
const { owner, userData, botId, assertOwner } = scope;
const environment = await companionEnvironmentStore.read(userData, botId, assertOwner);
if (!environment) return undefined;
- return { identity: fingerprint([owner, botId, environment.env, environment.mcp, environment.credentials]), environment, assertOwner, botId, userData };
+ return { identity: fingerprint([owner, botId, projectEnvironmentDiscovery(environment).identity]), environment, assertOwner, botId, userData };
+}
+
+export async function readCompanionSessionDiscovery(sessionId: string) {
+ const scope = await readCompanionSessionScope(sessionId);
+ if (!scope) return undefined;
+ const { owner, userData, botId, assertOwner } = scope;
+ const environment = await companionEnvironmentStore.readDiscovery(userData, botId, assertOwner);
+ if (!environment) return undefined;
+ return { identity: fingerprint([owner, botId, environment.identity]), environment, assertOwner, botId, userData };
}
export async function resolveCompanionRuntimeEnvironment(sessionId: string) {
- const result = await readCompanionSessionEnvironment(sessionId);
+ const result = await readCompanionSessionDiscovery(sessionId);
return result ? { identity: result.identity, assertCurrent: result.assertOwner } : undefined;
}