@kafca/agentdock 0.1.55 → 0.1.57

package/dist-electron/tests/electron/core-client.test.js

@@ -0,0 +1,284 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = __importDefault(require("node:test"));
+const client_js_1 = require("../../packages/core-sdk/src/client.js");
+class FakeEventSource {
+    listeners = new Map();
+    onerror = null;
+    onopen = null;
+    closed = false;
+    addEventListener(type, listener) {
+        const listeners = this.listeners.get(type) || new Set();
+        listeners.add(listener);
+        this.listeners.set(type, listeners);
+    }
+    emit(type, payload) {
+        for (const listener of this.listeners.get(type) || []) {
+            listener({ data: typeof payload === 'string' ? payload : JSON.stringify(payload) });
+        }
+    }
+    close() {
+        this.closed = true;
+    }
+}
+(0, node_test_1.default)('core client shares one event source across subscribers and closes it after the last unsubscribe', () => {
+    const sources = [];
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9831/api/local/v1/',
+        eventSourceFactory: () => {
+            const source = new FakeEventSource();
+            sources.push(source);
+            return source;
+        },
+    });
+    const first = client.events.subscribe(() => { });
+    const second = client.events.subscribe(() => { });
+    strict_1.default.equal(sources.length, 1);
+    strict_1.default.equal(client.baseUrl, 'http://127.0.0.1:9831/api/local/v1');
+    first();
+    strict_1.default.equal(sources[0].closed, false);
+    second();
+    strict_1.default.equal(sources[0].closed, true);
+});
+(0, node_test_1.default)('core clients with the same base URL share one event source across instances', () => {
+    const sources = [];
+    const firstClient = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9831/api/local/v1/',
+        eventSourceFactory: () => {
+            const source = new FakeEventSource();
+            sources.push(source);
+            return source;
+        },
+    });
+    const secondClient = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9831/api/local/v1',
+        eventSourceFactory: () => {
+            const source = new FakeEventSource();
+            sources.push(source);
+            return source;
+        },
+    });
+    const firstEventTypes = [];
+    const secondEventTypes = [];
+    const stopFirst = firstClient.events.subscribe((event) => firstEventTypes.push(event.type));
+    const stopSecond = secondClient.events.subscribe((event) => secondEventTypes.push(event.type));
+    strict_1.default.equal(sources.length, 1);
+    sources[0].emit('presence.updated', { type: 'presence.updated', live: true });
+    strict_1.default.deepEqual(firstEventTypes, ['presence.updated']);
+    strict_1.default.deepEqual(secondEventTypes, ['presence.updated']);
+    stopFirst();
+    strict_1.default.equal(sources[0].closed, false);
+    stopSecond();
+    strict_1.default.equal(sources[0].closed, true);
+});
+(0, node_test_1.default)('core client ignores malformed events and maps stream events to bridge subscribers', () => {
+    const source = new FakeEventSource();
+    const events = [];
+    const bridgeContents = [];
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9831/api/local/v1',
+        eventSourceFactory: () => source,
+    });
+    const stopEvents = client.events.subscribe((event) => events.push(event.type));
+    const stopBridge = client.events.subscribeBridge((event) => bridgeContents.push(event.content || ''));
+    source.emit('stream.updated', '{not-json');
+    source.emit('stream.updated', {
+        type: 'stream.updated',
+        stream: { type: 'reply', sessionKey: 'workspace:thread', content: 'done' },
+    });
+    strict_1.default.deepEqual(events, ['stream.updated']);
+    strict_1.default.deepEqual(bridgeContents, ['done']);
+    stopBridge();
+    stopEvents();
+});
+(0, node_test_1.default)('core client ignores valid JSON events that do not match the event contract', () => {
+    const source = new FakeEventSource();
+    const events = [];
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9841/api/local/v1',
+        eventSourceFactory: () => source,
+    });
+    const stop = client.events.subscribe((event) => events.push(event.type));
+    source.emit('runtime.updated', { type: 'runtime.updated' });
+    source.emit('presence.updated', { type: 'presence.updated', live: 'yes' });
+    source.emit('stream.updated', { type: 'stream.updated', stream: { content: 'missing bridge type' } });
+    source.emit('presence.updated', { type: 'presence.updated', live: false });
+    strict_1.default.deepEqual(events, ['presence.updated']);
+    stop();
+});
+(0, node_test_1.default)('core client rejects events whose nested payload misses required contract fields', () => {
+    const source = new FakeEventSource();
+    const events = [];
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9831/api/local/v1',
+        eventSourceFactory: () => source,
+    });
+    const stop = client.events.subscribe((event) => events.push(event.type));
+    source.emit('run.updated', { type: 'run.updated', run: {} });
+    source.emit('message.created', { type: 'message.created', threadId: 'thread-1', message: {} });
+    source.emit('scheduler.run.updated', { type: 'scheduler.run.updated', run: { id: 'run-1' } });
+    source.emit('run.updated', {
+        type: 'run.updated',
+        run: {
+            id: 'run-1',
+            threadId: 'thread-1',
+            status: 'running',
+            startedAt: '2026-06-21T00:00:00.000Z',
+            updatedAt: '2026-06-21T00:00:01.000Z',
+        },
+    });
+    strict_1.default.deepEqual(events, ['run.updated']);
+    stop();
+});
+(0, node_test_1.default)('identical listener functions retain independent subscriptions', () => {
+    const source = new FakeEventSource();
+    let calls = 0;
+    const listener = () => {
+        calls += 1;
+    };
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9831/api/local/v1',
+        eventSourceFactory: () => source,
+    });
+    const stopFirst = client.events.subscribe(listener);
+    const stopSecond = client.events.subscribe(listener);
+    stopFirst();
+    strict_1.default.equal(source.closed, false);
+    source.emit('presence.updated', { type: 'presence.updated', live: true });
+    strict_1.default.equal(calls, 1);
+    stopSecond();
+    strict_1.default.equal(source.closed, true);
+});
+(0, node_test_1.default)('one failing event listener does not prevent other subscribers from receiving the event', () => {
+    const source = new FakeEventSource();
+    const events = [];
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9844/api/local/v1',
+        eventSourceFactory: () => source,
+    });
+    const stopFailing = client.events.subscribe(() => {
+        throw new Error('listener failed');
+    });
+    const stopHealthy = client.events.subscribe((event) => events.push(event.type));
+    source.emit('presence.updated', { type: 'presence.updated', live: true });
+    strict_1.default.deepEqual(events, ['presence.updated']);
+    stopFailing();
+    stopHealthy();
+});
+(0, node_test_1.default)('core client schedules only one reconnect while an error is outstanding', () => {
+    const sources = [];
+    const reconnects = [];
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9831/api/local/v1',
+        eventSourceFactory: () => {
+            const source = new FakeEventSource();
+            sources.push(source);
+            return source;
+        },
+        scheduleReconnect: (callback) => {
+            reconnects.push(callback);
+            return reconnects.length;
+        },
+        cancelReconnect: () => { },
+    });
+    const stop = client.events.subscribe(() => { });
+    sources[0].onerror?.();
+    sources[0].onerror?.();
+    strict_1.default.equal(reconnects.length, 1);
+    reconnects[0]();
+    strict_1.default.equal(sources.length, 2);
+    stop();
+});
+(0, node_test_1.default)('an obsolete event source cannot schedule another reconnect after replacement', () => {
+    const sources = [];
+    const reconnects = [];
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9842/api/local/v1',
+        eventSourceFactory: () => {
+            const source = new FakeEventSource();
+            sources.push(source);
+            return source;
+        },
+        scheduleReconnect: (callback) => {
+            reconnects.push(callback);
+            return reconnects.length;
+        },
+        cancelReconnect: () => { },
+    });
+    const stop = client.events.subscribe(() => { });
+    sources[0].onerror?.();
+    reconnects[0]();
+    sources[0].onerror?.();
+    strict_1.default.equal(reconnects.length, 1);
+    stop();
+});
+(0, node_test_1.default)('core client reports reconnect so consumers can recover missed state', () => {
+    const sources = [];
+    const reconnects = [];
+    const states = [];
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9845/api/local/v1',
+        eventSourceFactory: () => {
+            const source = new FakeEventSource();
+            sources.push(source);
+            return source;
+        },
+        scheduleReconnect: (callback) => {
+            reconnects.push(callback);
+            return reconnects.length;
+        },
+        cancelReconnect: () => { },
+    });
+    const stop = client.events.subscribeConnectionState((state) => states.push(state));
+    sources[0].onopen?.();
+    sources[0].onerror?.();
+    reconnects[0]();
+    sources[1].onopen?.();
+    strict_1.default.deepEqual(states, ['connected', 'disconnected', 'connected']);
+    stop();
+    strict_1.default.equal(sources[1].closed, true);
+});
+(0, node_test_1.default)('core client rejects partially populated scheduler and automation payloads', () => {
+    const source = new FakeEventSource();
+    const events = [];
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9843/api/local/v1',
+        eventSourceFactory: () => source,
+    });
+    const stop = client.events.subscribe((event) => events.push(event.type));
+    source.emit('scheduler.job.updated', {
+        type: 'scheduler.job.updated',
+        job: {
+            id: 'job-1',
+            workspaceId: 'workspace-1',
+            platform: 'local',
+            triggerType: 'cron',
+            promptTemplate: 'run',
+            enabled: true,
+            createdAt: '',
+            updatedAt: '',
+        },
+    });
+    source.emit('automation.monitor.updated', {
+        type: 'automation.monitor.updated',
+        monitor: {
+            id: 'monitor-1',
+            workspaceId: 'workspace-1',
+            title: 'price',
+            sourceType: 'stock.quote',
+            sourceConfig: {},
+            condition: {},
+            promptTemplate: 'analyze',
+            enabled: true,
+            cooldownMs: 1000,
+            createdAt: '',
+            updatedAt: '',
+        },
+    });
+    strict_1.default.deepEqual(events, []);
+    stop();
+});

package/dist-electron/tests/electron/plugin-kernel.test.js

@@ -1021,6 +1021,60 @@ model = "deepseek-v4-flash"
     strict_1.default.match(response.body.error, /Unknown route/);
     strict_1.default.equal(response.body.errorInfo?.severity, 'error');
 });
+(0, node_test_1.default)('server rejects malformed endpoint input with a 400 response before domain dispatch', async () => {
+    let dispatched = false;
+    const controller = new node_events_1.EventEmitter();
+    const workspaceRouter = {
+        createThread: async () => {
+            dispatched = true;
+            return {};
+        },
+    };
+    const server = new server_js_1.LocalAiCoreServer({ controller, workspaceRouter }, { port: 0 });
+    const response = await invokeServer(server, 'POST', '/api/local/v1/threads', { workspaceId: 42 });
+    strict_1.default.equal(response.statusCode, 400);
+    strict_1.default.equal(response.body.ok, false);
+    strict_1.default.match(response.body.error, /workspaceId/);
+    strict_1.default.equal(dispatched, false);
+    const emptyResponse = await invokeServer(server, 'POST', '/api/local/v1/threads', { workspaceId: '   ' });
+    strict_1.default.equal(emptyResponse.statusCode, 400);
+    strict_1.default.match(emptyResponse.body.error, /workspaceId/);
+    strict_1.default.equal(dispatched, false);
+});
+(0, node_test_1.default)('server validates the actual desktop settings contract before dispatch', async () => {
+    let dispatched = false;
+    const controller = new node_events_1.EventEmitter();
+    controller.saveSettings = async () => {
+        dispatched = true;
+        return {};
+    };
+    const server = new server_js_1.LocalAiCoreServer({ controller }, { port: 0 });
+    const invalidKnowledge = await invokeServer(server, 'POST', '/api/local/v1/runtime/settings', { knowledge: 42 });
+    strict_1.default.equal(invalidKnowledge.statusCode, 400);
+    strict_1.default.match(invalidKnowledge.body.error, /knowledge/);
+    const invalidPlugins = await invokeServer(server, 'POST', '/api/local/v1/runtime/settings', { plugins: [] });
+    strict_1.default.equal(invalidPlugins.statusCode, 400);
+    strict_1.default.match(invalidPlugins.body.error, /plugins/);
+    const invalidPluginSettings = await invokeServer(server, 'POST', '/api/local/v1/runtime/settings', {
+        plugins: { 'channel.lark': { enabled: 'yes' } },
+    });
+    strict_1.default.equal(invalidPluginSettings.statusCode, 400);
+    strict_1.default.match(invalidPluginSettings.body.error, /plugins\.channel\.lark\.enabled/);
+    const invalidAuthMode = await invokeServer(server, 'POST', '/api/local/v1/runtime/settings', {
+        knowledge: { authMode: 'cookie' },
+    });
+    strict_1.default.equal(invalidAuthMode.statusCode, 400);
+    strict_1.default.match(invalidAuthMode.body.error, /knowledge\.authMode/);
+    strict_1.default.equal(dispatched, false);
+    const valid = await invokeServer(server, 'POST', '/api/local/v1/runtime/settings', {
+        autoStartService: true,
+        defaultProject: 'workspace-stable',
+        knowledge: { authMode: 'bearer', token: 'secret' },
+        plugins: { 'channel.lark': { enabled: true, config: { appId: 'app-id' } } },
+    });
+    strict_1.default.equal(valid.statusCode, 200);
+    strict_1.default.equal(dispatched, true);
+});
 (0, node_test_1.default)('server diagnostics routes dispatch through generic bindings', async () => {
     const calls = [];
     const controller = Object.assign(new node_events_1.EventEmitter(), {

package/dist-electron/tests/electron/renderer-packaging.test.js

@@ -31,6 +31,15 @@ const rootDir = node_process_1.default.cwd();
     strict_1.default.ok(buildIndex >= 0, 'pnpm e2e:smoke must start from a production build');
     strict_1.default.ok(smokeIndex > buildIndex, 'pnpm e2e:smoke must run smoke checks after the production build');
 });
+(0, node_test_1.default)('development startup rewrites workspace aliases before launching Electron', () => {
+    const devScript = (0, node_fs_1.readFileSync)((0, node_path_1.join)(rootDir, 'scripts', 'dev.mjs'), 'utf8');
+    const aliasCommandIndex = devScript.indexOf("['exec', 'tsc-alias', '-p', 'tsconfig.electron.json']");
+    const readyAssignmentIndex = devScript.indexOf('electronReady = true', aliasCommandIndex);
+    const launchIndex = devScript.indexOf('maybeLaunchElectron()', readyAssignmentIndex);
+    strict_1.default.ok(aliasCommandIndex >= 0, 'pnpm dev must rewrite emitted @cc/* aliases');
+    strict_1.default.ok(readyAssignmentIndex > aliasCommandIndex, 'Electron must become ready only after alias rewriting is configured');
+    strict_1.default.ok(launchIndex > readyAssignmentIndex, 'Electron must launch only after alias rewriting completes');
+});
 (0, node_test_1.default)('production renderer build has a loadable entry document and assets', () => {
     const rendererDir = (0, node_path_1.join)(rootDir, 'dist', 'renderer');
     const indexPath = (0, node_path_1.join)(rendererDir, 'index.html');

package/dist-electron/tests/electron/workspace-task-store.test.js

@@ -42,6 +42,37 @@ const env_utils_js_1 = require("../../services/local-ai-core/src/runtime/env-uti
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('runtime project migration makes workspace registry authoritative and preserves identity across rename', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'workspace-project-migration-'));
+    try {
+        const runtime = (0, bootstrap_js_1.bootstrapLocalCoreRuntime)({ userDataPath, enableKnowledge: false, log: () => { } });
+        const controller = new local_core_controller_js_1.LocalCoreController(userDataPath, runtime);
+        await controller.saveRuntimeConfig({
+            projects: [{
+                    name: 'Workspace A',
+                    agent: { type: 'pi', options: { work_dir: '/tmp/workspace-a' } },
+                    platforms: [],
+                }],
+        });
+        const first = await controller.readRuntimeConfig();
+        const workspaceId = first.config.projects?.[0]?.workspace_id;
+        strict_1.default.ok(workspaceId);
+        strict_1.default.equal(controller.store.getWorkspaceRegistryEntry(workspaceId)?.displayName, 'Workspace A');
+        strict_1.default.equal(controller.store.readRuntimeConfig().config.projects, undefined);
+        await controller.saveRuntimeConfig({
+            ...first.config,
+            projects: [{ ...first.config.projects[0], name: 'Workspace B' }],
+        });
+        const renamed = await controller.readRuntimeConfig();
+        strict_1.default.equal(renamed.config.projects?.[0]?.workspace_id, workspaceId);
+        strict_1.default.equal(controller.store.getWorkspaceRegistryEntry(workspaceId)?.displayName, 'Workspace B');
+        strict_1.default.equal((await controller.workspaceRouter.listWorkspaces())[0]?.id, workspaceId);
+        await controller.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)('model providers persist independently from workspace config', () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'model-provider-store-'));
     try {

package/dist-electron/tests/integration/channel-inbound-attachment-store.test.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = __importDefault(require("node:test"));
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_stream_1 = require("node:stream");
+const inbound_attachment_store_js_1 = require("../../services/local-ai-core/src/channel/shared/inbound-attachment-store.js");
+(0, node_test_1.default)('inbound attachment store streams a platform source into an atomic local file', async () => {
+    const tempDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'channel-inbound-store-'));
+    try {
+        const store = new inbound_attachment_store_js_1.FileSystemInboundAttachmentStore();
+        const stored = await store.save({
+            directory: tempDir,
+            storedFileName: 'message/one-report.pdf',
+            displayFileName: 'report.pdf',
+            source: {
+                open: async () => ({
+                    stream: node_stream_1.Readable.from([Buffer.from('hello '), Buffer.from('world')]),
+                    mimeType: 'application/pdf',
+                }),
+            },
+        });
+        strict_1.default.equal(stored.path, (0, node_path_1.join)(tempDir, 'message_one-report.pdf'));
+        strict_1.default.equal(stored.fileName, 'report.pdf');
+        strict_1.default.equal(stored.mimeType, 'application/pdf');
+        strict_1.default.equal(stored.size, 11);
+        strict_1.default.equal((0, node_fs_1.readFileSync)(stored.path, 'utf8'), 'hello world');
+        strict_1.default.deepEqual((0, node_fs_1.readdirSync)(tempDir), ['message_one-report.pdf']);
+    }
+    finally {
+        (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('inbound attachment store removes partial files when the size limit is exceeded', async () => {
+    const tempDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'channel-inbound-limit-'));
+    try {
+        const store = new inbound_attachment_store_js_1.FileSystemInboundAttachmentStore();
+        await strict_1.default.rejects(() => store.save({
+            directory: tempDir,
+            storedFileName: 'large.bin',
+            displayFileName: 'large.bin',
+            maxBytes: 4,
+            source: {
+                open: async () => ({ stream: node_stream_1.Readable.from([Buffer.from('12345')]) }),
+            },
+        }), /exceeds 4 bytes/);
+        strict_1.default.deepEqual((0, node_fs_1.readdirSync)(tempDir), []);
+    }
+    finally {
+        (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('inbound attachment store finalizes the filename before commit and can return base64', async () => {
+    const tempDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'channel-inbound-finalize-'));
+    try {
+        const store = new inbound_attachment_store_js_1.FileSystemInboundAttachmentStore();
+        const stored = await store.save({
+            directory: tempDir,
+            storedFileName: 'image-1',
+            displayFileName: 'image.png',
+            includeBase64: true,
+            finalizeStoredFileName: ({ storedFileName, prefix }) => {
+                strict_1.default.deepEqual(prefix.subarray(0, 4), Buffer.from([0x89, 0x50, 0x4e, 0x47]));
+                return `${storedFileName}.png`;
+            },
+            source: {
+                open: async () => ({ stream: node_stream_1.Readable.from([Buffer.from([0x89, 0x50, 0x4e, 0x47, 1, 2])]) }),
+            },
+        });
+        strict_1.default.equal(stored.path, (0, node_path_1.join)(tempDir, 'image-1.png'));
+        strict_1.default.equal(stored.data, 'iVBORwEC');
+        strict_1.default.deepEqual((0, node_fs_1.readdirSync)(tempDir), ['image-1.png']);
+    }
+    finally {
+        (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('inbound attachment store removes temporary data when filename finalization fails', async () => {
+    const tempDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'channel-inbound-finalize-error-'));
+    try {
+        const store = new inbound_attachment_store_js_1.FileSystemInboundAttachmentStore();
+        await strict_1.default.rejects(() => store.save({
+            directory: tempDir,
+            storedFileName: 'image-1',
+            displayFileName: 'image.png',
+            finalizeStoredFileName: () => {
+                throw new Error('cannot identify image');
+            },
+            source: {
+                open: async () => ({ stream: node_stream_1.Readable.from([Buffer.from('image')]) }),
+            },
+        }), /cannot identify image/);
+        strict_1.default.deepEqual((0, node_fs_1.readdirSync)(tempDir), []);
+    }
+    finally {
+        (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('inbound attachment URI maps workspace files into sandbox and hides external files', () => {
+    strict_1.default.equal((0, inbound_attachment_store_js_1.resolveInboundAttachmentUri)({
+        filePath: '/host/project/.agentdock/image.png',
+        workspacePath: '/host/project',
+        sandboxEnabled: true,
+        sandboxWorkspacePath: '/workspace',
+    }), 'file:///workspace/.agentdock/image.png');
+    strict_1.default.equal((0, inbound_attachment_store_js_1.resolveInboundAttachmentUri)({
+        filePath: '/host/state/image.png',
+        workspacePath: '/host/project',
+        sandboxEnabled: true,
+        sandboxWorkspacePath: '/workspace',
+    }), undefined);
+});

package/dist-electron/tests/integration/channel-inbound-authorization.test.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = __importDefault(require("node:test"));
+const inbound_authorization_js_1 = require("../../services/local-ai-core/src/channel/shared/inbound-authorization.js");
+function createStore() {
+    const authorizedUsers = [];
+    const pairings = [];
+    return {
+        authorizedUsers,
+        pairings,
+        store: {
+            expirePendingPairings() { },
+            getAuthorizedUser(workspaceId, platformUserId, platform) {
+                return authorizedUsers.find((row) => row.workspace_id === workspaceId &&
+                    row.platform_user_id === platformUserId &&
+                    row.platform === platform);
+            },
+            createAuthorizedUser(input) {
+                authorizedUsers.push(input);
+            },
+            listPendingPairings() {
+                return pairings;
+            },
+            createPairingRequest(input) {
+                pairings.push(input);
+            },
+        },
+    };
+}
+const identity = {
+    workspaceId: 'workspace-1',
+    platformKey: 'lark:default',
+    platformUserId: 'user-1',
+    chatId: 'chat-1',
+    displayName: 'User One',
+};
+(0, node_test_1.default)('shared inbound authorization auto-approves and returns the stored user', () => {
+    const fixture = createStore();
+    let changes = 0;
+    const result = (0, inbound_authorization_js_1.resolveInboundChannelAuthorization)({
+        store: fixture.store,
+        identity,
+        autoApprove: true,
+        authorizedUserIdPrefix: 'lark-user',
+        generatePairingCode: () => '123456',
+        onStateChanged: () => { changes += 1; },
+    });
+    strict_1.default.equal(result.status, 'authorized');
+    strict_1.default.equal(fixture.authorizedUsers.length, 1);
+    strict_1.default.equal(changes, 1);
+});
+(0, node_test_1.default)('shared inbound authorization reuses an existing pending pairing', () => {
+    const fixture = createStore();
+    fixture.pairings.push({
+        code: '654321',
+        workspace_id: 'workspace-1',
+        platform: 'lark:default',
+        platform_user_id: 'user-1',
+        chat_id: 'chat-1',
+        status: 'pending',
+    });
+    let generated = 0;
+    const result = (0, inbound_authorization_js_1.resolveInboundChannelAuthorization)({
+        store: fixture.store,
+        identity,
+        autoApprove: false,
+        authorizedUserIdPrefix: 'lark-user',
+        generatePairingCode: () => {
+            generated += 1;
+            return '123456';
+        },
+    });
+    strict_1.default.deepEqual(result, { status: 'pending', pairingCode: '654321' });
+    strict_1.default.equal(generated, 0);
+    strict_1.default.equal(fixture.pairings.length, 1);
+});

package/dist-electron/tests/integration/lark-gateway-utils.test.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = __importDefault(require("node:test"));
+const gateway_utils_js_1 = require("../../services/local-ai-core/src/channel/lark/gateway-utils.js");
+(0, node_test_1.default)('lark gateway attachment utilities preserve content summaries and mime detection', () => {
+    strict_1.default.equal((0, gateway_utils_js_1.summarizeLarkInboundContentParts)([{ type: 'file', fileName: 'report.pdf' }]), '[File: report.pdf]');
+    strict_1.default.equal((0, gateway_utils_js_1.extractLarkHeaderMimeType)({ 'Content-Type': 'image/png; charset=binary' }), 'image/png');
+    strict_1.default.equal((0, gateway_utils_js_1.sniffLarkImageExtension)(Buffer.from([0x89, 0x50, 0x4e, 0x47])), 'png');
+});