@kafca/agentdock 0.1.56 → 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-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');
+});

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

@@ -1265,7 +1265,7 @@ function findLarkPostMdText(content) {
     });
     strict_1.default.equal(sentMessages.length, 1);
     strict_1.default.equal(sentMessages[0]?.threadId, 'thread-1');
-    strict_1.default.match(sentMessages[0]?.content?.displayText, /\[User Message\]\n\[Image\]\n\[\/User Message\]/);
+    strict_1.default.equal(sentMessages[0]?.content?.displayText, '[Image]');
     strict_1.default.deepEqual(sentMessages[0]?.content?.contentParts?.map((part) => part.type), ['text', 'image']);
     strict_1.default.equal(sentMessages[0]?.content?.contentParts?.[1]?.mimeType, 'image/png');
     strict_1.default.equal(sentMessages[0]?.content?.contentParts?.[1]?.data, pngBytes.toString('base64'));
@@ -1366,7 +1366,7 @@ function findLarkPostMdText(content) {
     });
     strict_1.default.equal(sentMessages.length, 1);
     strict_1.default.equal(sentMessages[0]?.threadId, 'thread-1');
-    strict_1.default.match(sentMessages[0]?.content?.displayText, /\[User Message\]\n\[File: report\.pdf\]\n\[\/User Message\]/);
+    strict_1.default.equal(sentMessages[0]?.content?.displayText, '[File: report.pdf]');
     strict_1.default.deepEqual(sentMessages[0]?.content?.contentParts?.map((part) => part.type), ['text', 'file']);
     strict_1.default.equal(sentMessages[0]?.content?.contentParts?.[1]?.mimeType, 'application/pdf');
     strict_1.default.equal(sentMessages[0]?.content?.contentParts?.[1]?.data, undefined);
@@ -1494,7 +1494,7 @@ function findLarkPostMdText(content) {
     });
     strict_1.default.equal(sentMessages.length, 1);
     strict_1.default.equal(sentMessages[0]?.threadId, 'thread-1');
-    strict_1.default.match(sentMessages[0]?.content, /\[User Message\]\nask @张三 to review\n\[\/User Message\]/);
+    strict_1.default.equal(sentMessages[0]?.content, 'ask @张三 to review');
 });
 (0, node_test_1.default)('lark group text messages ignore non-mentioned bot messages by default', async () => {
     const sentMessages = [];
@@ -1620,7 +1620,7 @@ function findLarkPostMdText(content) {
     });
     strict_1.default.equal(sentMessages.length, 1);
     strict_1.default.equal(sentMessages[0]?.threadId, 'thread-1');
-    strict_1.default.match(sentMessages[0]?.content, /\[User Message\]\n1\. hi\n2\. hello\n\[\/User Message\]/);
+    strict_1.default.equal(sentMessages[0]?.content, '1. hi\n2. hello');
 });
 (0, node_test_1.default)('lark inbound messages create a chat binding when an authorized user has an old direct thread', async () => {
     const bindings = [];

package/dist-electron/tests/integration/weixin-runtime-state.test.js

@@ -0,0 +1,32 @@
+"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 runtime_state_js_1 = require("../../services/local-ai-core/src/channel/weixin/runtime-state.js");
+(0, node_test_1.default)('weixin turn state keeps thought, tool progress, and final reply ordered', () => {
+    const turn = (0, runtime_state_js_1.createWeixinTurnState)('workspace:thread');
+    (0, runtime_state_js_1.consumeWeixinBridgeEvent)(turn, { type: 'typing_start', sessionKey: turn.sessionKey });
+    (0, runtime_state_js_1.consumeWeixinBridgeEvent)(turn, { type: 'update_message', sessionKey: turn.sessionKey, bridgeKind: 'thought', content: 'Inspecting' });
+    (0, runtime_state_js_1.consumeWeixinBridgeEvent)(turn, { type: 'reply', sessionKey: turn.sessionKey, bridgeKind: 'tool', content: 'Search - running' });
+    const finalEvent = { type: 'reply', sessionKey: turn.sessionKey, bridgeKind: 'assistant', content: 'Done' };
+    (0, runtime_state_js_1.consumeWeixinBridgeEvent)(turn, finalEvent);
+    const rendered = (0, runtime_state_js_1.renderWeixinTurnText)(turn);
+    strict_1.default.match(rendered, /Inspecting/);
+    strict_1.default.match(rendered, /Done/);
+    strict_1.default.equal((0, runtime_state_js_1.isTerminalWeixinBridgeMessage)(finalEvent, rendered), true);
+});
+(0, node_test_1.default)('weixin permission events remain terminal and render fallback actions', () => {
+    const turn = (0, runtime_state_js_1.createWeixinTurnState)('workspace:thread');
+    const event = {
+        type: 'buttons',
+        sessionKey: turn.sessionKey,
+        buttonRows: [[{ text: 'Allow', data: 'allow' }]],
+    };
+    (0, runtime_state_js_1.consumeWeixinBridgeEvent)(turn, event);
+    const rendered = (0, runtime_state_js_1.renderWeixinTurnText)(turn);
+    strict_1.default.match(rendered, /allow all/);
+    strict_1.default.equal((0, runtime_state_js_1.isTerminalWeixinBridgeMessage)(event, rendered), true);
+});

package/dist-electron/tests/integration/weixin-text-utils.test.js

@@ -0,0 +1,15 @@
+"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 text_utils_js_1 = require("../../services/local-ai-core/src/channel/weixin/text-utils.js");
+(0, node_test_1.default)('weixin text utilities preserve utf8 boundaries and decode simple html', () => {
+    strict_1.default.equal((0, text_utils_js_1.stripWeixinHtml)('<p>A&amp;B</p>'), 'A&B');
+    const chunks = (0, text_utils_js_1.splitTextByUtf8Bytes)('你好世界', 6);
+    strict_1.default.deepEqual(chunks, ['你好', '世界']);
+    strict_1.default.ok(chunks.every((chunk) => (0, text_utils_js_1.utf8ByteLength)(chunk) <= 6));
+    strict_1.default.ok((0, text_utils_js_1.utf8ByteLength)((0, text_utils_js_1.truncateTextByUtf8Bytes)('很长的内容'.repeat(20), 80)) <= 80);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kafca/agentdock",
-  "version": "0.1.56",
+  "version": "0.1.57",
   "license": "PolyForm-Noncommercial-1.0.0",
   "type": "module",
   "main": "dist-electron/electron/main.js",
@@ -26,13 +26,14 @@
     "dev": "node scripts/dev.mjs",
     "dev:web": "pnpm exec vite --host 127.0.0.1 --port 5173",
     "dev:core": "pnpm build:electron && node scripts/launch-core.mjs",
-    "build": "vite build && node scripts/write-electron-package.mjs && tsc -p tsconfig.electron.json",
+    "build": "vite build && node scripts/write-electron-package.mjs && tsc -p tsconfig.electron.json && tsc-alias -p tsconfig.electron.json",
     "build:npm": "VITE_LOCAL_AI_CORE_BASE=/api/local/v1 pnpm build",
     "build:web": "vite build",
     "build:renderer": "vite build",
-    "build:electron": "node scripts/write-electron-package.mjs && tsc -p tsconfig.electron.json",
+    "build:electron": "node scripts/write-electron-package.mjs && tsc -p tsconfig.electron.json && tsc-alias -p tsconfig.electron.json",
     "build:core": "pnpm build:electron",
-    "test": "pnpm build:renderer && pnpm build:electron && node --test dist-electron/tests/electron/*.test.js dist-electron/tests/contracts/*.test.js dist-electron/tests/integration/*.test.js dist-electron/packages/knowledge-api/test/*.test.js dist-electron/src/pages/Threads/thread-chat-permission.test.js",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "pnpm typecheck && pnpm build:renderer && pnpm build:electron && node --test dist-electron/tests/electron/*.test.js dist-electron/tests/contracts/*.test.js dist-electron/tests/integration/*.test.js dist-electron/packages/knowledge-api/test/*.test.js dist-electron/src/pages/Threads/thread-chat-permission.test.js",
     "e2e:smoke": "pnpm build && node scripts/e2e-smoke.mjs",
     "e2e:compose": "node scripts/e2e-compose.mjs",
     "dist:mac": "pnpm build && electron-builder --mac dmg zip --arm64",
@@ -45,6 +46,9 @@
   },
   "dependencies": {
     "@agentclientprotocol/claude-agent-acp": "^0.30.0",
+    "@cc/core-sdk": "workspace:*",
+    "@cc/plugin-sdk": "workspace:*",
+    "@cc/superai-contracts": "workspace:*",
     "@iarna/toml": "^2.2.5",
     "@larksuiteoapi/node-sdk": "^1.58.0",
     "@mariozechner/pi-coding-agent": "^0.72.1",
@@ -78,6 +82,7 @@
     "electron-builder": "^26.8.1",
     "postcss": "^8.5.3",
     "tailwindcss": "^3.4.17",
+    "tsc-alias": "^1.8.17",
     "typescript": "~5.8.3",
     "vite": "^6.3.2"
   },