@kafca/agentdock 0.1.61 → 0.1.62

package/dist-electron/tests/electron/condition-trigger-skill.test.js

@@ -0,0 +1,93 @@
+"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_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const node_child_process_1 = require("node:child_process");
+const managed_skill_catalog_js_1 = require("../../services/local-ai-core/src/runtime/managed-skill-catalog.js");
+const sourceSkillPath = (0, node_path_1.join)(process.cwd(), 'electron', 'managed-skills', 'condition-trigger', 'SKILL.md');
+(0, node_test_1.default)('condition trigger skill requires the staged two-approval workflow and helper owns exact LAC requests', () => {
+    const content = (0, node_fs_1.readFileSync)(sourceSkillPath, 'utf8');
+    strict_1.default.match(content, /temporary source bundle/i);
+    strict_1.default.match(content, /create.*Automation Script.*record/is);
+    strict_1.default.match(content, /manifest\.json.*entrypoint.*fixtures.*tests/is);
+    strict_1.default.match(content, /stage/i);
+    strict_1.default.match(content, /stop.*test authorization/is);
+    strict_1.default.match(content, /apply.*approved.*decision.*before.*test/is);
+    strict_1.default.match(content, /sandbox test/i);
+    strict_1.default.match(content, /stop.*final.*approval/is);
+    strict_1.default.match(content, /apply.*approved.*decision.*before.*Automation/is);
+    strict_1.default.match(content, /create.*Automation/is);
+    strict_1.default.match(content, /Do not write.*managed script directory/i);
+    strict_1.default.doesNotMatch(content, /automations\/scripts\/[^\s]+\/(?:sha|hash)/i);
+    const helper = (0, node_fs_1.readFileSync)((0, node_path_1.join)(process.cwd(), 'electron', 'managed-skills', 'condition-trigger', 'scripts', 'register-condition-trigger.sh'), 'utf8');
+    strict_1.default.match(helper, /lac script stage --script/);
+    strict_1.default.match(helper, /lac script create --title/);
+    strict_1.default.match(helper, /lac script test-approval/);
+    strict_1.default.match(helper, /lac script test/);
+    strict_1.default.match(helper, /lac script enable-approval/);
+    strict_1.default.match(helper, /lac script approve/);
+    strict_1.default.match(helper, /lac automation add --script-version/);
+    strict_1.default.match(helper, /--source-file/);
+    strict_1.default.doesNotMatch(helper, /--source-json/);
+    strict_1.default.match(helper, /openSync.*O_NOFOLLOW.*fstatSync/s);
+    strict_1.default.match(helper, /MAX_FILES.*MAX_BYTES/s);
+    strict_1.default.match(helper, /O_NOFOLLOW.*fstatSync.*readSync/s);
+});
+(0, node_test_1.default)('managed skill catalog loads exact source and packaged condition-trigger skill layouts', () => {
+    const source = new managed_skill_catalog_js_1.ManagedSkillCatalog({ rootDir: (0, node_path_1.join)(process.cwd(), 'electron', 'managed-skills') }).get('condition-trigger');
+    (0, strict_1.default)(source);
+    strict_1.default.equal(source.content, (0, node_fs_1.readFileSync)(sourceSkillPath, 'utf8'));
+    const packagedRoot = (0, node_path_1.join)(process.cwd(), 'dist-electron', 'electron', 'managed-skills');
+    strict_1.default.equal((0, node_fs_1.existsSync)((0, node_path_1.join)(packagedRoot, 'condition-trigger', 'SKILL.md')), true);
+    const packaged = new managed_skill_catalog_js_1.ManagedSkillCatalog({ rootDir: packagedRoot }).get('condition-trigger');
+    (0, strict_1.default)(packaged);
+    strict_1.default.equal(packaged.content, source.content);
+});
+(0, node_test_1.default)('condition trigger helper creates source-only staging input through a temporary file and rejects symlink roots', async () => {
+    const root = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'condition-trigger-skill-'));
+    const source = (0, node_path_1.join)(root, 'source');
+    const bin = (0, node_path_1.join)(root, 'bin');
+    const captureArgs = (0, node_path_1.join)(root, 'args');
+    const captureBody = (0, node_path_1.join)(root, 'body');
+    (0, node_fs_1.mkdirSync)(source);
+    (0, node_fs_1.mkdirSync)(bin);
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(source, 'manifest.json'), '{}');
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(source, 'check.js'), '#!/usr/bin/env node\n');
+    const fakeLac = (0, node_path_1.join)(bin, 'lac');
+    (0, node_fs_1.writeFileSync)(fakeLac, '#!/bin/sh\nprintf "%s\\n" "$@" > "$CAPTURE_ARGS"\nfor argument in "$@"; do last="$argument"; done\ncat "$last" > "$CAPTURE_BODY"\n');
+    (0, node_fs_1.chmodSync)(fakeLac, 0o755);
+    const helper = (0, node_path_1.join)(process.cwd(), 'electron', 'managed-skills', 'condition-trigger', 'scripts', 'register-condition-trigger.sh');
+    const run = (args) => new Promise((resolve, reject) => {
+        (0, node_child_process_1.execFile)(helper, args, {
+            env: { ...process.env, PATH: `${bin}:${process.env.PATH || ''}`, CAPTURE_ARGS: captureArgs, CAPTURE_BODY: captureBody },
+        }, (error) => error ? reject(error) : resolve());
+    });
+    try {
+        await run(['stage', 'script-1', source]);
+        const args = (0, node_fs_1.readFileSync)(captureArgs, 'utf8').trim().split('\n');
+        strict_1.default.deepEqual(args.slice(0, 5), ['script', 'stage', '--script', 'script-1', '--source-file']);
+        strict_1.default.equal((0, node_fs_1.existsSync)(args[5]), false, 'temporary serialized source is removed after lac exits');
+        strict_1.default.deepEqual(JSON.parse((0, node_fs_1.readFileSync)(captureBody, 'utf8')), [
+            { path: 'check.js', content: '#!/usr/bin/env node\n' },
+            { path: 'manifest.json', content: '{}' },
+        ]);
+        const symlink = (0, node_path_1.join)(root, 'source-link');
+        (0, node_fs_1.symlinkSync)(source, symlink);
+        await strict_1.default.rejects(run(['stage', 'script-1', symlink]), /source root must be a non-symlink directory/);
+        (0, node_fs_1.mkdirSync)((0, node_path_1.join)(source, 'nested'));
+        await strict_1.default.rejects(run(['stage', 'script-1', source]), /source bundle must be flat/);
+        (0, node_fs_1.rmSync)((0, node_path_1.join)(source, 'nested'), { recursive: true, force: true });
+        for (let index = 0; index < 65; index += 1)
+            (0, node_fs_1.writeFileSync)((0, node_path_1.join)(source, `limit-${index}.txt`), 'x');
+        await strict_1.default.rejects(run(['stage', 'script-1', source]), /source bundle exceeds 64 files/);
+    }
+    finally {
+        (0, node_fs_1.rmSync)(root, { recursive: true, force: true });
+    }
+});

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

@@ -110,6 +110,105 @@ class FakeEventSource {
     strict_1.default.deepEqual(events, ['presence.updated']);
     stop();
 });
+(0, node_test_1.default)('core client accepts all four complete unified automation SSE events and rejects partial payloads', () => {
+    const source = new FakeEventSource();
+    const events = [];
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9851/api/local/v1',
+        eventSourceFactory: () => source,
+    });
+    const stop = client.events.subscribe((event) => events.push(event.type));
+    source.emit('automation.definition.updated', {
+        type: 'automation.definition.updated',
+        automation: completeAutomation(),
+    });
+    source.emit('automation.definition.updated', {
+        type: 'automation.definition.updated', automation: { ...completeAutomation(), health: 'blocked' },
+    });
+    source.emit('automation.evaluation.updated', {
+        type: 'automation.evaluation.updated',
+        evaluation: completeEvaluation(),
+    });
+    source.emit('automation.evaluation.updated', {
+        type: 'automation.evaluation.updated',
+        evaluation: { ...completeEvaluation(), conditionOutcome: 'matched', triggerDecision: 'not_evaluated' },
+    });
+    source.emit('automation.evaluation.updated', {
+        type: 'automation.evaluation.updated',
+        evaluation: { id: 'evaluation-running', automationId: 'automation-1', activationKind: 'interval', status: 'running', startedAt: '2026-07-12T00:00:00.000Z', finishedAt: '2026-07-12T00:00:01.000Z' },
+    });
+    source.emit('automation.run.updated', {
+        type: 'automation.run.updated',
+        run: completeAutomationRun(),
+    });
+    source.emit('automation.script-version.updated', {
+        type: 'automation.script-version.updated',
+        version: completeScriptVersion(),
+    });
+    source.emit('automation.definition.updated', {
+        type: 'automation.definition.updated',
+        automation: { ...completeAutomation(), condition: { kind: 'approved-script', scriptId: 'script-1', approvedVersionId: 'version-1', edge: 'falling' } },
+    });
+    source.emit('automation.evaluation.updated', {
+        type: 'automation.evaluation.updated',
+        evaluation: { ...completeEvaluation(), conditionOutcome: 'matched', triggerDecision: 'not_rising' },
+    });
+    source.emit('automation.run.updated', {
+        type: 'automation.run.updated', run: { ...completeAutomationRun(), status: 'unknown' },
+    });
+    source.emit('automation.script-version.updated', {
+        type: 'automation.script-version.updated', version: { ...completeScriptVersion(), env: ['TOKEN', 1] },
+    });
+    source.emit('automation.definition.updated', {
+        type: 'automation.definition.updated',
+        automation: { id: 'automation-1' },
+    });
+    source.emit('automation.script-version.updated', {
+        type: 'automation.script-version.updated',
+        version: { id: 'version-1', scriptId: 'script-1' },
+    });
+    strict_1.default.deepEqual(events, [
+        'automation.definition.updated',
+        'automation.evaluation.updated',
+        'automation.run.updated',
+        'automation.script-version.updated',
+        'automation.evaluation.updated',
+    ]);
+    stop();
+});
+function completeAutomation() {
+    return {
+        id: 'automation-1', workspaceId: 'workspace-1', title: 'Automation', enabled: true, health: 'healthy',
+        activation: { kind: 'interval', intervalMs: 1_000 }, condition: { kind: 'always' },
+        action: { kind: 'agent-prompt', promptTemplate: 'hello', executionMode: 'same-thread' },
+        delivery: { platform: 'lark', route: { type: 'group', channelId: 'channel-1' } },
+        policies: { concurrency: 'skip-if-running', cooldownMs: 0 }, consecutiveEvaluationFailures: 0,
+        createdAt: '2026-07-12T00:00:00.000Z', updatedAt: '2026-07-12T00:00:00.000Z',
+    };
+}
+function completeEvaluation() {
+    return {
+        id: 'evaluation-1', automationId: 'automation-1', activationKind: 'interval', status: 'finished',
+        startedAt: '2026-07-12T00:00:00.000Z', finishedAt: '2026-07-12T00:00:01.000Z',
+        conditionOutcome: 'not_matched', triggerDecision: 'not_rising',
+    };
+}
+function completeAutomationRun() {
+    return {
+        id: 'run-1', automationId: 'automation-1', evaluationId: 'evaluation-1', status: 'succeeded',
+        executionMode: 'same-thread', createdAt: '2026-07-12T00:00:00.000Z',
+    };
+}
+function completeScriptVersion() {
+    return {
+        id: 'version-1', scriptId: 'script-1', status: 'approved', packageSha256: 'a'.repeat(64),
+        packagePath: '/managed/a', shebang: '#!/usr/bin/env node', interpreterPath: '/usr/bin/node', interpreterVersion: 'v22',
+        capabilities: {}, config: {}, configSchema: {}, networkMode: 'none', internalAccess: false,
+        allowedReadDirs: [], secretRefs: [], env: [],
+        limits: { timeoutMs: 30_000, stdoutBytes: 1_000, stderrBytes: 1_000, payloadBytes: 1_000, stateBytes: 1_000 },
+        staticCheck: {}, testPlan: {}, createdAt: '2026-07-12T00:00:00.000Z', updatedAt: '2026-07-12T00:00:00.000Z',
+    };
+}
 (0, node_test_1.default)('core client rejects events whose nested payload misses required contract fields', () => {
     const source = new FakeEventSource();
     const events = [];

package/dist-electron/tests/electron/lac-cli.test.js

@@ -702,3 +702,113 @@ function withFetchMock(mock) {
         restore();
     }
 });
+(0, node_test_1.default)('lac automation add verifies an approved script version before creating the automation', async () => {
+    const requests = [];
+    const { restore } = withFetchMock(async (input, init) => {
+        const url = String(input);
+        requests.push({ url, method: init?.method || 'GET', body: init?.body ? JSON.parse(String(init.body)) : undefined });
+        if (url.includes('/automation-scripts/versions/version-1')) {
+            return new Response(JSON.stringify({ ok: true, data: { id: 'version-1', scriptId: 'script-1', status: 'approved' } }), { headers: { 'content-type': 'application/json' } });
+        }
+        return new Response(JSON.stringify({ ok: true, data: { id: 'automation-1', title: 'Price watch' } }), { headers: { 'content-type': 'application/json' } });
+    });
+    try {
+        const { io } = createIo();
+        const exitCode = await (0, lac_js_1.runCli)([
+            'automation', 'add', '--title', 'Price watch', '--script-version', 'version-1', '--script-id', 'script-1',
+            '--interval', '1m', '--message', 'Tell me when it matches', '--json',
+        ], {
+            LOCAL_AI_CORE_BASE: 'http://127.0.0.1:9831/api/local/v1',
+            LOCAL_AI_WORKSPACE_ID: 'workspace-1',
+            LOCAL_AI_THREAD_ID: 'thread-1',
+            LOCAL_AI_PLATFORM: 'lark',
+            LOCAL_AI_CHAT_ID: 'chat-1',
+            LOCAL_AI_PLATFORM_USER_ID: 'user-1',
+        }, io);
+        strict_1.default.equal(exitCode, 0);
+        strict_1.default.deepEqual(requests, [
+            { url: 'http://127.0.0.1:9831/api/local/v1/automation-scripts/versions/version-1?workspace_id=workspace-1', method: 'GET', body: undefined },
+            {
+                url: 'http://127.0.0.1:9831/api/local/v1/automations', method: 'POST', body: {
+                    workspaceId: 'workspace-1', title: 'Price watch', enabled: true,
+                    activation: { kind: 'interval', intervalMs: 60_000 },
+                    condition: { kind: 'approved-script', scriptId: 'script-1', approvedVersionId: 'version-1', edge: 'rising' },
+                    action: { kind: 'agent-prompt', promptTemplate: 'Tell me when it matches', executionMode: 'side-thread' },
+                    delivery: { platform: 'lark', route: { type: 'channel.chat', channelId: 'chat-1', participantId: 'user-1', threadId: 'thread-1' } },
+                    policies: { concurrency: 'skip-if-running', cooldownMs: 0 },
+                },
+            },
+        ]);
+    }
+    finally {
+        restore();
+    }
+});
+(0, node_test_1.default)('lac script stage uploads only a bounded source bundle and script test requires claimable authorization', async () => {
+    const requests = [];
+    const { restore } = withFetchMock(async (input, init) => {
+        const url = String(input);
+        requests.push({ url, method: init?.method || 'GET', body: init?.body ? JSON.parse(String(init.body)) : undefined });
+        if (url.includes('/versions/version-1') && !url.endsWith('/test')) {
+            return new Response(JSON.stringify({ ok: true, data: { id: 'version-1', status: 'test_authorized' } }), { headers: { 'content-type': 'application/json' } });
+        }
+        return new Response(JSON.stringify({ ok: true, data: { id: 'version-1', status: 'pending_test_approval' } }), { headers: { 'content-type': 'application/json' } });
+    });
+    try {
+        const { io } = createIo();
+        const env = { LOCAL_AI_CORE_BASE: 'http://127.0.0.1:9831/api/local/v1', LOCAL_AI_WORKSPACE_ID: 'workspace-1', LOCAL_AI_THREAD_ID: 'thread-1' };
+        strict_1.default.equal(await (0, lac_js_1.runCli)(['script', 'stage', '--script', 'script-1', '--source-json', '[{"path":"manifest.json","content":"{}"},{"path":"check.js","content":"#!/usr/bin/env node"}]'], env, io), 0);
+        strict_1.default.deepEqual(requests[0], {
+            url: 'http://127.0.0.1:9831/api/local/v1/automation-scripts/script-1/versions?workspace_id=workspace-1', method: 'POST',
+            body: { files: [{ path: 'manifest.json', content: '{}' }, { path: 'check.js', content: '#!/usr/bin/env node' }] },
+        });
+        strict_1.default.equal(await (0, lac_js_1.runCli)(['script', 'test', 'version-1', '--actor', 'agent'], env, io), 0);
+        strict_1.default.deepEqual(requests.slice(1), [
+            { url: 'http://127.0.0.1:9831/api/local/v1/automation-scripts/versions/version-1?workspace_id=workspace-1', method: 'GET', body: undefined },
+            { url: 'http://127.0.0.1:9831/api/local/v1/automation-scripts/versions/version-1/test?workspace_id=workspace-1', method: 'POST', body: { actor: 'agent' } },
+        ]);
+    }
+    finally {
+        restore();
+    }
+});
+(0, node_test_1.default)('lac script and automation commands fail closed before a server-approved status permits execution', async () => {
+    const requests = [];
+    const { restore } = withFetchMock(async (input) => {
+        requests.push(String(input));
+        return new Response(JSON.stringify({ ok: true, data: { id: 'version-1', scriptId: 'script-1', status: 'pending_approval' } }), { headers: { 'content-type': 'application/json' } });
+    });
+    try {
+        const { io } = createIo();
+        const env = { LOCAL_AI_CORE_BASE: 'http://127.0.0.1:9831/api/local/v1', LOCAL_AI_WORKSPACE_ID: 'workspace-1' };
+        strict_1.default.equal(await (0, lac_js_1.runCli)(['automation', 'add', '--title', 'blocked', '--script-id', 'script-1', '--script-version', 'version-1', '--message', 'nope'], env, io), 1);
+        strict_1.default.equal(await (0, lac_js_1.runCli)(['script', 'test', 'version-1', '--actor', 'agent'], env, io), 1);
+        strict_1.default.deepEqual(requests, [
+            'http://127.0.0.1:9831/api/local/v1/automation-scripts/versions/version-1?workspace_id=workspace-1',
+            'http://127.0.0.1:9831/api/local/v1/automation-scripts/versions/version-1?workspace_id=workspace-1',
+        ]);
+    }
+    finally {
+        restore();
+    }
+});
+(0, node_test_1.default)('lac automation add uses local delivery when channel identifiers are incomplete', async () => {
+    let body;
+    const { restore } = withFetchMock(async (input, init) => {
+        if (String(input).includes('/versions/version-1')) {
+            return new Response(JSON.stringify({ ok: true, data: { id: 'version-1', scriptId: 'script-1', status: 'approved' } }), { headers: { 'content-type': 'application/json' } });
+        }
+        body = JSON.parse(String(init?.body));
+        return new Response(JSON.stringify({ ok: true, data: { id: 'automation-1' } }), { headers: { 'content-type': 'application/json' } });
+    });
+    try {
+        const { io } = createIo();
+        strict_1.default.equal(await (0, lac_js_1.runCli)(['automation', 'add', '--title', 'local', '--script-id', 'script-1', '--script-version', 'version-1', '--message', 'check'], {
+            LOCAL_AI_CORE_BASE: 'http://127.0.0.1:9831/api/local/v1', LOCAL_AI_WORKSPACE_ID: 'workspace-1', LOCAL_AI_PLATFORM: 'lark',
+        }, io), 0);
+        strict_1.default.deepEqual(body?.delivery, { platform: 'local', route: { type: 'local.thread', channelId: 'workspace-1' } });
+    }
+    finally {
+        restore();
+    }
+});

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

@@ -1003,6 +1003,31 @@ 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)('scheduler ignores malformed enabled legacy cron jobs during startup and ticks', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-malformed-cron-'));
+    const runtime = (0, bootstrap_js_1.bootstrapLocalCoreRuntime)({ userDataPath, enableKnowledge: false, log: () => { } });
+    try {
+        const job = runtime.store.createScheduledJob({
+            workspaceId: 'workspace-a',
+            platform: 'local',
+            route: { type: 'local.thread', channelId: 'workspace-a', threadId: 'thread-1' },
+            executionMode: 'side-thread',
+            triggerType: 'cron',
+            cronExpr: '* * * * *',
+            promptTemplate: 'legacy',
+            description: 'malformed legacy job',
+            enabled: true,
+        });
+        runtime.store.db.prepare('UPDATE scheduled_jobs SET cron_expr = ? WHERE id = ?').run('*/0 * * * *', job.id);
+        await runtime.scheduler.start();
+        await runtime.scheduler.tick();
+        strict_1.default.equal(runtime.store.listScheduledJobRuns(job.id).length, 0);
+    }
+    finally {
+        await runtime.stop();
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)('scheduler auto-disables a job after 5 consecutive failures', async () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-autodisable-'));
     try {

package/dist-electron/tests/integration/automation-routes.test.js

@@ -0,0 +1,186 @@
+"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 node_stream_1 = require("node:stream");
+const server_routes_js_1 = require("../../services/local-ai-core/src/runtime/server-routes.js");
+const automations_handler_js_1 = require("../../services/local-ai-core/src/runtime/handlers/automations-handler.js");
+(0, node_test_1.default)('unified automation routes are explicit and do not overlap legacy monitor routes', () => {
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('GET', '/api/local/v1/automations'), { name: 'automations.list' });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('POST', '/api/local/v1/automations'), { name: 'automations.create' });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('GET', '/api/local/v1/automations/automation%2Fone'), {
+        name: 'automation.get', automationId: 'automation/one',
+    });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('PATCH', '/api/local/v1/automations/automation-1'), {
+        name: 'automation.update', automationId: 'automation-1',
+    });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('DELETE', '/api/local/v1/automations/automation-1'), {
+        name: 'automation.delete', automationId: 'automation-1',
+    });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('POST', '/api/local/v1/automations/automation-1/check'), {
+        name: 'automation.check', automationId: 'automation-1',
+    });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('GET', '/api/local/v1/automations/automation-1/evaluations'), {
+        name: 'automation.evaluations', automationId: 'automation-1',
+    });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('GET', '/api/local/v1/automations/automation-1/runs'), {
+        name: 'automation.runs', automationId: 'automation-1',
+    });
+    strict_1.default.equal((0, server_routes_js_1.parseLocalAiCoreRoute)('GET', '/api/local/v1/automations/automation-1/check'), null);
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('GET', '/api/local/v1/automation/monitors'), { name: 'automation.monitors.list' });
+});
+(0, node_test_1.default)('unified script routes expose only lifecycle transitions', () => {
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('GET', '/api/local/v1/automation-scripts'), { name: 'automation-scripts.list' });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('POST', '/api/local/v1/automation-scripts'), { name: 'automation-scripts.create' });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('GET', '/api/local/v1/automation-scripts/script-1/versions'), {
+        name: 'automation-script.versions', scriptId: 'script-1',
+    });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('POST', '/api/local/v1/automation-scripts/script-1/versions'), {
+        name: 'automation-script.version.submit', scriptId: 'script-1',
+    });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('POST', '/api/local/v1/automation-scripts/versions/version-1/test-approval'), {
+        name: 'automation-script-version.test-approval', versionId: 'version-1',
+    });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('POST', '/api/local/v1/automation-scripts/versions/version-1/test'), {
+        name: 'automation-script-version.test', versionId: 'version-1',
+    });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('POST', '/api/local/v1/automation-scripts/versions/version-1/enable-approval'), {
+        name: 'automation-script-version.enable-approval', versionId: 'version-1',
+    });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('POST', '/api/local/v1/automation-scripts/versions/version-1/approve'), {
+        name: 'automation-script-version.approve', versionId: 'version-1',
+    });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('POST', '/api/local/v1/automation-scripts/versions/version-1/reject'), {
+        name: 'automation-script-version.reject', versionId: 'version-1',
+    });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('POST', '/api/local/v1/automation-scripts/versions/version-1/revoke'), {
+        name: 'automation-script-version.revoke', versionId: 'version-1',
+    });
+    strict_1.default.equal((0, server_routes_js_1.parseLocalAiCoreRoute)('POST', '/api/local/v1/automation-scripts/versions/version-1/stage'), null);
+    strict_1.default.equal((0, server_routes_js_1.parseLocalAiCoreRoute)('POST', '/api/local/v1/automation-scripts/versions/version-1/approve/extra'), null);
+});
+(0, node_test_1.default)('unified handlers enforce workspace ownership and reject server-owned fields', async () => {
+    const map = new Map();
+    (0, automations_handler_js_1.registerUnifiedAutomationHandlers)(map, {
+        automations: {
+            get: () => ({ id: 'automation-1', workspaceId: 'workspace-a' }),
+            create: () => { throw new Error('must not create'); },
+        },
+        store: { getAutomationScript: () => ({ id: 'script-1', workspaceId: 'workspace-a' }) },
+    });
+    await strict_1.default.rejects(map.get('automation.get')({ name: 'automation.get', automationId: 'automation-1' }, node_stream_1.Readable.from([]), response(), new URL('http://127.0.0.1/automations/automation-1?workspace_id=workspace-b')), /not found in this workspace/);
+    await strict_1.default.rejects(map.get('automations.create')({ name: 'automations.create' }, requestBody({
+        workspaceId: 'workspace-a', title: 'Automation', enabled: true,
+        activation: { kind: 'interval', intervalMs: 1000 }, condition: { kind: 'always' },
+        action: { kind: 'agent-prompt', promptTemplate: 'hello', executionMode: 'same-thread' },
+        delivery: { platform: 'lark', route: { type: 'group', channelId: 'channel-1' } },
+        policies: { concurrency: 'skip-if-running', cooldownMs: 0 }, health: 'healthy',
+    }), response(), new URL('http://127.0.0.1/automations')), /health is not writable/);
+    await strict_1.default.rejects(map.get('automation-scripts.create')({ name: 'automation-scripts.create' }, requestBody({ workspaceId: 'workspace-a', title: 'Script', packagePath: '/tmp/attacker-controlled' }), response(), new URL('http://127.0.0.1/automation-scripts')), /packagePath is not writable/);
+    await strict_1.default.rejects(map.get('automation-script.version.submit')({ name: 'automation-script.version.submit', scriptId: 'script-1' }, requestBody({ files: [], sourceDir: '/tmp/attacker-controlled' }), response(), new URL('http://127.0.0.1/automation-scripts/script-1/versions?workspace_id=workspace-a')), /sourceDir is not writable/);
+});
+(0, node_test_1.default)('script approval lifecycle selects the transition from the server-owned version state', async () => {
+    const calls = [];
+    let status = 'pending_test_approval';
+    const version = () => ({ id: 'version-1', scriptId: 'script-1', status });
+    const map = new Map();
+    (0, automations_handler_js_1.registerUnifiedAutomationHandlers)(map, {
+        automations: {},
+        store: {
+            getAutomationScriptVersion: () => version(),
+            getAutomationScript: () => ({ id: 'script-1', workspaceId: 'workspace-a' }),
+            getApprovalRequest: (approvalId) => ({ approvalId, status: approvalId === 'approval-test' ? 'approved' : 'rejected' }),
+            authorizeAutomationScriptTest: () => {
+                calls.push('authorize-test');
+                return version();
+            },
+            approveAutomationScriptVersion: () => {
+                calls.push('approve-enable');
+                return version();
+            },
+        },
+    });
+    await map.get('automation-script-version.approve')({ name: 'automation-script-version.approve', versionId: 'version-1' }, requestBody({ approvalId: 'approval-test', actor: 'user' }), response(), new URL('http://127.0.0.1/automation-scripts/versions/version-1/approve?workspace_id=workspace-a'));
+    status = 'pending_approval';
+    await map.get('automation-script-version.reject')({ name: 'automation-script-version.reject', versionId: 'version-1' }, requestBody({ approvalId: 'approval-enable', actor: 'user' }), response(), new URL('http://127.0.0.1/automation-scripts/versions/version-1/reject?workspace_id=workspace-a'));
+    strict_1.default.deepEqual(calls, ['authorize-test', 'approve-enable']);
+    status = 'pending_test_approval';
+    await strict_1.default.rejects(map.get('automation-script-version.reject')({ name: 'automation-script-version.reject', versionId: 'version-1' }, requestBody({ approvalId: 'approval-test', actor: 'user' }), response(), new URL('http://127.0.0.1/automation-scripts/versions/version-1/reject?workspace_id=workspace-a')), /requires a rejected approval decision/);
+    strict_1.default.deepEqual(calls, ['authorize-test', 'approve-enable']);
+});
+(0, node_test_1.default)('script test execution accepts only an actor and persists the server-produced report', async () => {
+    const reports = [];
+    const version = { id: 'version-1', scriptId: 'script-1', status: 'test_authorized' };
+    const map = new Map();
+    (0, automations_handler_js_1.registerUnifiedAutomationHandlers)(map, {
+        automations: {},
+        store: {
+            getAutomationScriptVersion: () => version,
+            getAutomationScript: () => ({ id: 'script-1', workspaceId: 'workspace-a' }),
+            claimAutomationScriptTestExecution: () => ({ ...version, status: 'testing' }),
+            recordAutomationScriptTestResult: (_versionId, report) => {
+                reports.push(report);
+                return { ...version, status: 'tested' };
+            },
+        },
+        executeScriptTest: async () => ({ status: 'passed', finishedAt: '2026-07-12T00:00:00.000Z', summary: 'server test' }),
+    });
+    await map.get('automation-script-version.test')({ name: 'automation-script-version.test', versionId: 'version-1' }, requestBody({ actor: 'user' }), response(), new URL('http://127.0.0.1/automation-scripts/versions/version-1/test?workspace_id=workspace-a'));
+    strict_1.default.deepEqual(reports, [{ status: 'passed', finishedAt: '2026-07-12T00:00:00.000Z', summary: 'server test' }]);
+    await strict_1.default.rejects(map.get('automation-script-version.test')({ name: 'automation-script-version.test', versionId: 'version-1' }, requestBody({ actor: 'user', testReport: { status: 'passed' } }), response(), new URL('http://127.0.0.1/automation-scripts/versions/version-1/test?workspace_id=workspace-a')), /testReport is not writable/);
+});
+(0, node_test_1.default)('only one concurrent request can claim a one-shot script test before sandbox execution', async () => {
+    let status = 'test_authorized';
+    let resolveExecution;
+    const execution = new Promise((resolve) => { resolveExecution = resolve; });
+    let executions = 0;
+    const version = () => ({ id: 'version-1', scriptId: 'script-1', status });
+    const map = new Map();
+    (0, automations_handler_js_1.registerUnifiedAutomationHandlers)(map, {
+        automations: {},
+        store: {
+            getAutomationScriptVersion: () => version(),
+            getAutomationScript: () => ({ id: 'script-1', workspaceId: 'workspace-a' }),
+            claimAutomationScriptTestExecution: () => {
+                if (status !== 'test_authorized')
+                    throw new Error(`claim requires test_authorized, got ${status}`);
+                status = 'testing';
+                return version();
+            },
+            recordAutomationScriptTestResult: () => ({ ...version(), status: 'tested' }),
+        },
+        executeScriptTest: async () => {
+            executions += 1;
+            await execution;
+            return { status: 'passed', finishedAt: '2026-07-12T00:00:00.000Z' };
+        },
+    });
+    const route = { name: 'automation-script-version.test', versionId: 'version-1' };
+    const url = new URL('http://127.0.0.1/automation-scripts/versions/version-1/test?workspace_id=workspace-a');
+    const first = map.get('automation-script-version.test')(route, requestBody({ actor: 'user' }), response(), url);
+    await Promise.resolve();
+    await strict_1.default.rejects(map.get('automation-script-version.test')(route, requestBody({ actor: 'user' }), response(), url), /already executing/);
+    strict_1.default.equal(executions, 1);
+    resolveExecution();
+    await first;
+});
+(0, node_test_1.default)('source submission rejects an oversized body before JSON parsing or package staging', async () => {
+    const map = new Map();
+    (0, automations_handler_js_1.registerUnifiedAutomationHandlers)(map, {
+        automations: {},
+        store: { getAutomationScript: () => ({ id: 'script-1', workspaceId: 'workspace-a' }) },
+    });
+    await strict_1.default.rejects(map.get('automation-script.version.submit')({ name: 'automation-script.version.submit', scriptId: 'script-1' }, node_stream_1.Readable.from([Buffer.alloc(1_200_001)]), response(), new URL('http://127.0.0.1/automation-scripts/script-1/versions?workspace_id=workspace-a')), /exceeds 1200000 bytes/);
+});
+function requestBody(value) {
+    return node_stream_1.Readable.from([Buffer.from(JSON.stringify(value))]);
+}
+function response() {
+    return {
+        setHeader() { },
+        end() { },
+    };
+}

package/dist-electron/tests/integration/automation-sandbox-runtime.test.js

@@ -0,0 +1,92 @@
+"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 anthropic_sandbox_runner_js_1 = require("../../services/local-ai-core/src/automation/scripts/anthropic-sandbox-runner.js");
+const root = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'automation-sandbox-runtime-'));
+const packagePath = (0, node_path_1.join)(root, 'package');
+const tempDir = (0, node_path_1.join)(root, 'tmp');
+const secretPath = (0, node_path_1.join)(root, 'fixture-secret.txt');
+(0, node_fs_1.mkdirSync)(packagePath);
+(0, node_fs_1.mkdirSync)(tempDir);
+(0, node_fs_1.writeFileSync)((0, node_path_1.join)(packagePath, 'entry.js'), '#!/usr/bin/env node\n');
+(0, node_fs_1.chmodSync)((0, node_path_1.join)(packagePath, 'entry.js'), 0o444);
+(0, node_fs_1.writeFileSync)(secretPath, 'fixture-secret-value');
+const runner = new anthropic_sandbox_runner_js_1.AnthropicSandboxRunner({ tempRoot: root });
+const nodeCommand = process.execPath;
+(0, node_test_1.default)('real Anthropic Sandbox Runtime enforces package, temp, and network policy', async (context) => {
+    const capability = await runner.probe();
+    const outboundUnavailable = process.env.AGENTDOCK_TEST_NO_OUTBOUND === '1';
+    const skipReason = !capability.available
+        ? `sandbox capability unavailable: ${capability.missing.join(', ')}`
+        : outboundUnavailable
+            ? 'outbound networking explicitly unavailable by AGENTDOCK_TEST_NO_OUTBOUND=1'
+            : undefined;
+    if (skipReason) {
+        context.skip(skipReason);
+        (0, node_fs_1.rmSync)(root, { recursive: true, force: true });
+        return;
+    }
+    try {
+        const write = await runner.run({
+            command: `${nodeCommand} -e ${JSON.stringify("require('fs').writeFileSync('" + tempDir + "/written.txt','ok')")}`,
+            cwd: root,
+            packagePath,
+            tempDir,
+            network: 'none',
+            denyRead: [secretPath],
+        });
+        strict_1.default.equal(write.exitCode, 0, write.stderr);
+        strict_1.default.equal((0, node_fs_1.readFileSync)((0, node_path_1.join)(tempDir, 'written.txt'), 'utf8'), 'ok');
+        const secretRead = await runner.run({
+            command: `${nodeCommand} -e ${JSON.stringify("const value=require('fs').readFileSync('" + secretPath + "','utf8'); process.exit(value==='fixture-secret-value'?0:1)")}`,
+            cwd: root,
+            packagePath,
+            tempDir,
+            network: 'none',
+            denyRead: [secretPath],
+        });
+        strict_1.default.notEqual(secretRead.exitCode, 0);
+        const packageWrite = await runner.run({
+            command: `${nodeCommand} -e ${JSON.stringify("require('fs').writeFileSync('" + packagePath + "/unexpected.txt','no')")}`,
+            cwd: root,
+            packagePath,
+            tempDir,
+            network: 'none',
+        });
+        strict_1.default.notEqual(packageWrite.exitCode, 0);
+        const defaultTempWrite = await runner.run({
+            command: `${nodeCommand} -e ${JSON.stringify("require('fs').writeFileSync('/tmp/claude/unexpected.txt','no')")}`,
+            cwd: root,
+            packagePath,
+            tempDir,
+            network: 'none',
+        });
+        strict_1.default.notEqual(defaultTempWrite.exitCode, 0);
+        const publicEgress = await runner.run({
+            command: 'curl -fsS https://example.com >/dev/null',
+            cwd: root,
+            packagePath,
+            tempDir,
+            network: 'public',
+        });
+        strict_1.default.equal(publicEgress.exitCode, 0, publicEgress.stderr);
+        const privateEgress = await runner.run({
+            command: 'curl --noproxy \'\' -fsS --connect-timeout 2 http://127.0.0.1:9 >/dev/null',
+            cwd: root,
+            packagePath,
+            tempDir,
+            network: 'public',
+        });
+        strict_1.default.notEqual(privateEgress.exitCode, 0);
+    }
+    finally {
+        (0, node_fs_1.rmSync)(root, { recursive: true, force: true });
+    }
+});