@kafca/agentdock 0.1.58 → 0.1.62

package/dist-electron/services/local-ai-core/src/automation/scripts/script-protocol-runner.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScriptProtocolRunner = exports.ScriptProtocolError = void 0;
+const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
+const script_package_js_1 = require("./script-package.js");
+const anthropic_sandbox_runner_js_1 = require("./anthropic-sandbox-runner.js");
+const secret_resolver_js_1 = require("./secret-resolver.js");
+const DEFAULT_TIMEOUT_MS = 30_000;
+const MAX_TIMEOUT_MS = 5 * 60_000;
+class ScriptProtocolError extends Error {
+    code;
+    blockAutomation;
+    networkAudit;
+    constructor(code, message, blockAutomation = false, networkAudit) {
+        super(message);
+        this.code = code;
+        this.blockAutomation = blockAutomation;
+        this.networkAudit = networkAudit;
+        this.name = 'ScriptProtocolError';
+    }
+}
+exports.ScriptProtocolError = ScriptProtocolError;
+/** Executes only the exact approved script version using protocol v1. */
+class ScriptProtocolRunner {
+    options;
+    secrets;
+    constructor(options) {
+        this.options = options;
+        this.secrets = options.secretResolver || new secret_resolver_js_1.EnvironmentSecretResolver();
+    }
+    async run(request) {
+        return this.runForStatus(request, 'approved');
+    }
+    /** Runs the one-shot server-authorized test path without granting enable approval. */
+    async runTest(request) {
+        return this.runForStatus(request, 'testing');
+    }
+    async runForStatus(request, expectedStatus) {
+        const version = this.requireVersionForStatus(request, expectedStatus);
+        let capability;
+        try {
+            capability = await this.options.sandbox.probe();
+        }
+        catch {
+            throw new ScriptProtocolError('sandbox_unavailable', 'sandbox_unavailable', true);
+        }
+        if (!capability.available) {
+            throw new ScriptProtocolError('sandbox_unavailable', `sandbox_unavailable: ${capability.missing.join(', ') || capability.platform}`, true);
+        }
+        this.assertVersionFacts(version);
+        let interpreterVersion;
+        try {
+            const interpreterCheck = await this.options.sandbox.run({
+                command: `${quoteShell(version.interpreterPath)} --version`,
+                interpreterPath: version.interpreterPath,
+                cwd: version.packagePath,
+                packagePath: version.packagePath,
+                network: 'none',
+                timeoutMs: 5_000,
+                stdoutBytes: 16_384,
+                stderrBytes: 16_384,
+            });
+            if (interpreterCheck.exitCode !== 0 || interpreterCheck.signal || interpreterCheck.outputLimitExceeded) {
+                throw new Error('interpreter check failed');
+            }
+            interpreterVersion = interpreterCheck.stdout.trim();
+        }
+        catch {
+            throw new ScriptProtocolError('interpreter_unavailable', 'Approved interpreter validation is unavailable.', true);
+        }
+        if (interpreterVersion !== version.interpreterVersion) {
+            throw new ScriptProtocolError('interpreter_mismatch', 'Approved interpreter version does not match the installed interpreter.', true);
+        }
+        let secrets;
+        try {
+            secrets = await (0, secret_resolver_js_1.resolveDeclaredEnvironmentSecrets)(version.secretRefs, version.env, this.secrets);
+        }
+        catch (error) {
+            if (error instanceof secret_resolver_js_1.SecretUnavailableError)
+                throw new ScriptProtocolError('secret_unavailable', error.message);
+            throw error;
+        }
+        // Re-read after checks so a concurrently revoked/replaced record cannot run.
+        const current = this.options.getVersion(request.approvedVersionId);
+        if (!current || !sameExecutionFacts(version, current, expectedStatus)) {
+            throw new ScriptProtocolError('approval_mismatch', 'Approved script facts changed before execution.', true);
+        }
+        const entrypoint = (this.options.entrypointFor || entrypointFromManifest)(version);
+        const stdin = JSON.stringify({
+            protocolVersion: 1,
+            evaluationId: request.evaluationId,
+            triggeredAt: request.triggeredAt,
+            config: version.config,
+            previousState: request.previousState,
+        });
+        let result;
+        try {
+            result = await this.options.sandbox.run({
+                command: `${quoteShell(version.interpreterPath)} ${quoteShell((0, node_path_1.join)(version.packagePath, entrypoint))}`,
+                interpreterPath: version.interpreterPath,
+                cwd: version.packagePath,
+                packagePath: version.packagePath,
+                network: version.networkMode,
+                allowedReadDirs: version.allowedReadDirs,
+                env: secrets,
+                allowedEnv: version.env,
+                stdin,
+                timeoutMs: clampTimeout(version.limits.timeoutMs),
+                stdoutBytes: version.limits.stdoutBytes,
+                stderrBytes: version.limits.stderrBytes,
+            });
+        }
+        catch (error) {
+            if (error instanceof anthropic_sandbox_runner_js_1.SandboxUnavailableError || (typeof error === 'object' && error !== null && error.code === 'sandbox_unavailable')) {
+                throw new ScriptProtocolError('sandbox_unavailable', 'sandbox_unavailable', true);
+            }
+            throw error;
+        }
+        const redacted = redactResult(result.stdout, result.stderr, Object.values(secrets).filter((value) => value !== undefined));
+        if (result.outputLimitExceeded) {
+            throw new ScriptProtocolError('output_limit', `${result.outputLimitExceeded} output limit exceeded.`, false, result.networkAudit);
+        }
+        if (result.exitCode !== 0) {
+            throw new ScriptProtocolError('script_exit', `Script exited with exit code ${result.exitCode ?? 'unknown'}.`, false, result.networkAudit);
+        }
+        if (result.signal)
+            throw new ScriptProtocolError('script_signal', `Script terminated by ${result.signal}.`, false, result.networkAudit);
+        let response;
+        let payload;
+        let nextState;
+        try {
+            response = parseResponse(redacted.stdout);
+            payload = response.payload === undefined ? undefined : sanitizeRecord(response.payload, Object.values(secrets));
+            nextState = response.nextState === undefined ? undefined : sanitizeRecord(response.nextState, Object.values(secrets));
+            assertBounded(payload, version.limits.payloadBytes, 'payload');
+            assertBounded(nextState, version.limits.stateBytes, 'nextState');
+        }
+        catch (error) {
+            if (error instanceof ScriptProtocolError)
+                throw new ScriptProtocolError(error.code, error.message, error.blockAutomation, result.networkAudit);
+            throw error;
+        }
+        return {
+            matched: response.matched,
+            ...(response.summary === undefined ? {} : { summary: sanitizeText(response.summary, Object.values(secrets)) }),
+            ...(payload === undefined ? {} : { payload }),
+            ...(nextState === undefined ? {} : { nextState }),
+            // JSON response fields were redacted structurally above. Raw diagnostic
+            // strings can encode a secret (for example with JSON escapes), so do
+            // not persist them for secret-bearing runs.
+            stdout: Object.keys(secrets).length === 0 ? redacted.stdout : '',
+            stderr: Object.keys(secrets).length === 0 ? redacted.stderr : '',
+            exitCode: result.exitCode,
+            outputTruncated: false,
+            ...(result.networkAudit === undefined ? {} : { networkAudit: result.networkAudit }),
+        };
+    }
+    requireVersionForStatus(request, expectedStatus) {
+        const version = this.options.getVersion(request.approvedVersionId);
+        if (!version) {
+            throw new ScriptProtocolError('script_unavailable', 'Approved script runtime is unavailable.', true);
+        }
+        if (version.scriptId !== request.scriptId || version.status !== expectedStatus) {
+            throw new ScriptProtocolError('approval_mismatch', `The requested script version is not ${expectedStatus}.`, true);
+        }
+        return version;
+    }
+    assertVersionFacts(version) {
+        if (!/^[a-f0-9]{64}$/i.test(version.packageSha256) || (0, node_path_1.basename)(version.packagePath) !== version.packageSha256) {
+            throw new ScriptProtocolError('package_mismatch', 'Approved script package facts do not match.', true);
+        }
+        try {
+            (this.options.verifyPackage || ((candidate) => (0, script_package_js_1.verifyStagedScriptPackage)(candidate.packagePath, candidate.packageSha256)))(version);
+        }
+        catch {
+            throw new ScriptProtocolError('package_mismatch', 'Approved script package integrity verification failed.', true);
+        }
+    }
+}
+exports.ScriptProtocolRunner = ScriptProtocolRunner;
+function sameExecutionFacts(left, right, expectedStatus) {
+    return left.id === right.id && left.scriptId === right.scriptId && left.status === expectedStatus && right.status === expectedStatus
+        && left.packageSha256 === right.packageSha256 && left.packagePath === right.packagePath
+        && left.interpreterPath === right.interpreterPath && left.interpreterVersion === right.interpreterVersion;
+}
+function entrypointFromManifest(version) {
+    let parsed;
+    try {
+        parsed = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(version.packagePath, 'manifest.json'), 'utf8'));
+    }
+    catch {
+        throw new ScriptProtocolError('package_mismatch', 'Approved script manifest is unavailable.', true);
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed) || typeof parsed.entrypoint !== 'string') {
+        throw new ScriptProtocolError('protocol_invalid', 'Approved script manifest has no valid entrypoint.', true);
+    }
+    const entrypoint = parsed.entrypoint;
+    if (!entrypoint || entrypoint.startsWith('/') || entrypoint.split('/').includes('..')) {
+        throw new ScriptProtocolError('protocol_invalid', 'Approved script manifest entrypoint is invalid.', true);
+    }
+    return entrypoint;
+}
+function parseResponse(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed)
+        throw new ScriptProtocolError('protocol_invalid', 'Script stdout must contain exactly one JSON response.');
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        throw new ScriptProtocolError('protocol_invalid', 'Script stdout must contain exactly one JSON response.');
+    }
+    if (!isRecord(parsed) || parsed.protocolVersion !== 1 || typeof parsed.matched !== 'boolean') {
+        throw new ScriptProtocolError('protocol_invalid', 'Script response must be protocolVersion 1 with a boolean matched field.');
+    }
+    for (const key of Object.keys(parsed)) {
+        if (!['protocolVersion', 'matched', 'summary', 'payload', 'nextState'].includes(key)) {
+            throw new ScriptProtocolError('protocol_invalid', `Script response includes unsupported field ${key}.`);
+        }
+    }
+    if (parsed.summary !== undefined && typeof parsed.summary !== 'string')
+        throw new ScriptProtocolError('protocol_invalid', 'Script response summary must be a string.');
+    if (parsed.payload !== undefined && !isRecord(parsed.payload))
+        throw new ScriptProtocolError('protocol_invalid', 'Script response payload must be an object.');
+    if (parsed.nextState !== undefined && !isRecord(parsed.nextState))
+        throw new ScriptProtocolError('protocol_invalid', 'Script response nextState must be an object.');
+    return { matched: parsed.matched, ...(parsed.summary === undefined ? {} : { summary: parsed.summary }), ...(parsed.payload === undefined ? {} : { payload: parsed.payload }), ...(parsed.nextState === undefined ? {} : { nextState: parsed.nextState }) };
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+function assertBounded(value, limit, name) {
+    if (value !== undefined && Buffer.byteLength(JSON.stringify(value), 'utf8') > limit) {
+        throw new ScriptProtocolError('protocol_limit', `${name} exceeds its approved size limit.`);
+    }
+}
+function clampTimeout(value) {
+    if (!value || !Number.isSafeInteger(value) || value < 1)
+        return DEFAULT_TIMEOUT_MS;
+    return Math.min(value, MAX_TIMEOUT_MS);
+}
+function quoteShell(value) { return `'${value.replace(/'/g, "'\\''")}'`; }
+function redactResult(stdout, stderr, values) {
+    return { stdout: sanitizeText(stdout, values), stderr: sanitizeText(stderr, values) };
+}
+function sanitizeText(value, values) {
+    let result = value.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, '');
+    for (const secret of values)
+        if (secret)
+            result = result.split(secret).join('[REDACTED]');
+    return result;
+}
+function sanitizeRecord(value, secrets) {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, sanitizeJsonValue(item, secrets)]));
+}
+function sanitizeJsonValue(value, secrets) {
+    if (typeof value === 'string')
+        return sanitizeText(value, secrets);
+    if (Array.isArray(value))
+        return value.map((item) => sanitizeJsonValue(item, secrets));
+    if (isRecord(value))
+        return sanitizeRecord(value, secrets);
+    return value;
+}

package/dist-electron/services/local-ai-core/src/automation/scripts/secret-resolver.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecretUnavailableError = exports.EnvironmentSecretResolver = void 0;
+exports.resolveDeclaredEnvironmentSecrets = resolveDeclaredEnvironmentSecrets;
+class EnvironmentSecretResolver {
+    get(name) {
+        return process.env[name];
+    }
+}
+exports.EnvironmentSecretResolver = EnvironmentSecretResolver;
+class SecretUnavailableError extends Error {
+    name;
+    code = 'secret_unavailable';
+    constructor(name) {
+        super(`secret_unavailable: ${name}`);
+        this.name = name;
+        this.name = 'SecretUnavailableError';
+    }
+}
+exports.SecretUnavailableError = SecretUnavailableError;
+async function resolveDeclaredEnvironmentSecrets(secretRefs, envNames, resolver) {
+    const declared = new Set(envNames);
+    const result = {};
+    for (const ref of secretRefs) {
+        if (!ref.startsWith('env://'))
+            throw new SecretUnavailableError('unsupported_reference');
+        const name = ref.slice('env://'.length);
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name) || !declared.has(name)) {
+            throw new SecretUnavailableError(name || 'invalid_reference');
+        }
+        const value = await resolver.get(name);
+        if (value === undefined)
+            throw new SecretUnavailableError(name);
+        result[name] = value;
+    }
+    return result;
+}

package/dist-electron/services/local-ai-core/src/channel/weixin/inbound-poller.js

@@ -41,8 +41,7 @@ async function runWeixinInboundPoller(input) {
     while (!signal.aborted) {
         try {
             const resp = await (0, transport_js_1.getWeixinUpdates)(binding, buf, signal);
-            const isApiError = (resp.ret !== undefined && resp.ret !== 0) || (resp.errcode !== undefined && resp.errcode !== 0);
-            if (isApiError) {
+            if ((0, transport_js_1.isWeixinApiError)(resp)) {
                 consecutiveFailures += 1;
                 const state = input.getRuntimeState();
                 const retryDelayMs = computeRetryDelay(consecutiveFailures);

package/dist-electron/services/local-ai-core/src/channel/weixin/transport.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UPLOAD_MEDIA_TYPE_FILE = exports.FILE_ITEM_TYPE = exports.VOICE_ITEM_TYPE = exports.IMAGE_ITEM_TYPE = exports.TEXT_ITEM_TYPE = exports.WEIXIN_ILINK_APP_CLIENT_VERSION = exports.WEIXIN_ILINK_APP_ID = exports.WEIXIN_CHANNEL_VERSION = exports.API_TIMEOUT_MS = void 0;
 exports.createWechatUin = createWechatUin;
 exports.createIlinkHeaders = createIlinkHeaders;
+exports.applyWeixinAuthHeaders = applyWeixinAuthHeaders;
 exports.weixinApiPost = weixinApiPost;
 exports.weixinApiGet = weixinApiGet;
 exports.getWeixinUpdates = getWeixinUpdates;
@@ -33,6 +34,12 @@ function createIlinkHeaders() {
         'iLink-App-ClientVersion': exports.WEIXIN_ILINK_APP_CLIENT_VERSION,
     };
 }
+function applyWeixinAuthHeaders(headers, binding) {
+    if (binding.token) {
+        headers.AuthorizationType = 'ilink_bot_token';
+        headers.Authorization = `Bearer ${binding.token}`;
+    }
+}
 async function weixinApiPost(binding, endpoint, bodyObj, timeoutMs, signal) {
     const url = `${binding.baseUrl.replace(/\/$/, '')}/${endpoint}`;
     const body = JSON.stringify(bodyObj);
@@ -47,10 +54,7 @@ async function weixinApiPost(binding, endpoint, bodyObj, timeoutMs, signal) {
             'X-WECHAT-UIN': createWechatUin(),
             ...createIlinkHeaders(),
         };
-        if (binding.token) {
-            headers.AuthorizationType = 'ilink_bot_token';
-            headers.Authorization = `Bearer ${binding.token}`;
-        }
+        applyWeixinAuthHeaders(headers, binding);
         const res = await fetch(url, {
             method: 'POST',
             headers,
@@ -72,10 +76,7 @@ async function weixinApiGet(binding, endpoint, timeoutMs = exports.API_TIMEOUT_M
     const timer = setTimeout(() => controller.abort(), timeoutMs);
     try {
         const headers = createIlinkHeaders();
-        if (binding.token) {
-            headers.AuthorizationType = 'ilink_bot_token';
-            headers.Authorization = `Bearer ${binding.token}`;
-        }
+        applyWeixinAuthHeaders(headers, binding);
         const res = await fetch(url, {
             method: 'GET',
             headers,

package/dist-electron/services/local-ai-core/src/cli/lac.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCli = runCli;
 const node_process_1 = __importDefault(require("node:process"));
+const node_fs_1 = require("node:fs");
 const superai_contracts_1 = require("../../../../packages/contracts/src/index.js");
 const job_id_js_1 = require("../scheduler/job-id.js");
 const scheduled_job_route_js_1 = require("../scheduler/scheduled-job-route.js");
@@ -46,6 +47,37 @@ async function runCli(argv, env = node_process_1.default.env, io = node_process_
                     return 2;
             }
         }
+        if (domain === 'automation') {
+            switch (action) {
+                case 'add': return await handleAutomationAdd(flags, env, io, json);
+                case 'list': return await handleAutomationList(flags, env, io, json);
+                case 'info': return await handleAutomationInfo(maybeId, flags, env, io, json);
+                case 'edit': return await handleAutomationEdit(maybeId, flags, env, io, json);
+                case 'del':
+                case 'delete': return await handleAutomationDelete(maybeId, flags, env, io, json);
+                case 'check': return await handleAutomationCheck(maybeId, flags, env, io, json);
+                default:
+                    printUsage(io.stderr);
+                    return 2;
+            }
+        }
+        if (domain === 'script') {
+            switch (action) {
+                case 'list': return await handleScriptList(flags, env, io, json);
+                case 'create': return await handleScriptCreate(flags, env, io, json);
+                case 'stage': return await handleScriptStage(flags, env, io, json);
+                case 'status': return await handleScriptStatus(maybeId, flags, env, io, json);
+                case 'test-approval': return await handleScriptTransition('test-approval', maybeId, flags, env, io, json);
+                case 'test': return await handleScriptTest(maybeId, flags, env, io, json);
+                case 'enable-approval': return await handleScriptTransition('enable-approval', maybeId, flags, env, io, json);
+                case 'approve': return await handleScriptApprovalDecision('approve', maybeId, flags, env, io, json);
+                case 'reject': return await handleScriptApprovalDecision('reject', maybeId, flags, env, io, json);
+                case 'revoke': return await handleScriptTransition('revoke', maybeId, flags, env, io, json);
+                default:
+                    printUsage(io.stderr);
+                    return 2;
+            }
+        }
         if (domain !== 'scheduler') {
             printUsage(io.stderr);
             return 2;
@@ -74,6 +106,198 @@ async function runCli(argv, env = node_process_1.default.env, io = node_process_
         return 1;
     }
 }
+async function handleAutomationAdd(flags, env, io, json) {
+    const context = requireWorkspaceContext(flags, env, 'automation add');
+    const scriptId = getRequiredFlag(flags, 'script-id');
+    const versionId = getRequiredFlag(flags, 'script-version');
+    const version = await request(context.baseUrl, 'GET', scriptVersionPath(versionId, context));
+    if (version.status !== 'approved')
+        throw new Error(`automation add requires an approved script version, got ${version.status}.`);
+    if (version.scriptId !== scriptId)
+        throw new Error('automation add script id does not match the approved script version.');
+    const intervalMs = (0, monitor_cli_parsers_js_1.parseDurationMs)(getFlag(flags, 'interval') || '1m');
+    const hasChannelRoute = Boolean(context.platform && context.chatId);
+    const platform = hasChannelRoute ? context.platform : 'local';
+    const route = hasChannelRoute
+        ? { type: context.routeType || 'channel.chat', channelId: context.chatId, ...(context.platformInstanceId ? { instanceId: context.platformInstanceId } : {}), ...(context.platformUserId ? { participantId: context.platformUserId } : {}), ...(context.threadId ? { threadId: context.threadId } : {}) }
+        : { type: 'local.thread', channelId: context.workspaceId, ...(context.threadId ? { threadId: context.threadId } : {}) };
+    const automation = await request(context.baseUrl, 'POST', '/automations', {
+        workspaceId: context.workspaceId,
+        title: getRequiredFlag(flags, 'title'),
+        enabled: getBooleanFlag(flags, 'enabled', true),
+        activation: { kind: 'interval', intervalMs },
+        condition: { kind: 'approved-script', scriptId, approvedVersionId: versionId, edge: getFlag(flags, 'edge') || 'rising' },
+        action: { kind: 'agent-prompt', promptTemplate: getRequiredFlag(flags, 'message'), executionMode: getFlag(flags, 'execution-mode') || 'side-thread' },
+        delivery: { platform, route },
+        policies: { concurrency: 'skip-if-running', cooldownMs: getFlag(flags, 'cooldown') ? (0, monitor_cli_parsers_js_1.parseDurationMs)(getFlag(flags, 'cooldown')) : 0 },
+    });
+    print(json, io.stdout, automation, `Created automation ${automation.id || ''}`.trim());
+    return 0;
+}
+async function handleAutomationList(flags, env, io, json) {
+    const context = requireWorkspaceContext(flags, env, 'automation list');
+    const response = await request(context.baseUrl, 'GET', `/automations?workspace_id=${encodeURIComponent(context.workspaceId)}`);
+    print(json, io.stdout, response, response.automations.length ? response.automations.map((item) => JSON.stringify(item)).join('\n') : 'No automations.');
+    return 0;
+}
+async function handleAutomationInfo(id, flags, env, io, json) {
+    if (!id)
+        throw new Error('automation info requires an automation id.');
+    const context = requireWorkspaceContext(flags, env, 'automation info');
+    const automation = await request(context.baseUrl, 'GET', `/automations/${encodeURIComponent(id)}?workspace_id=${encodeURIComponent(context.workspaceId)}`);
+    print(json, io.stdout, automation, JSON.stringify(automation, null, 2));
+    return 0;
+}
+async function handleAutomationEdit(id, flags, env, io, json) {
+    if (!id)
+        throw new Error('automation edit requires an automation id.');
+    const context = requireWorkspaceContext(flags, env, 'automation edit');
+    const body = {};
+    const title = getFlag(flags, 'title');
+    const enabled = getOptionalBooleanFlag(flags, 'enabled');
+    if (title)
+        body.title = title;
+    if (enabled !== undefined)
+        body.enabled = enabled;
+    if (!Object.keys(body).length)
+        throw new Error('automation edit requires --title or --enabled.');
+    const automation = await request(context.baseUrl, 'PATCH', `/automations/${encodeURIComponent(id)}?workspace_id=${encodeURIComponent(context.workspaceId)}`, body);
+    print(json, io.stdout, automation, `Updated automation ${id}`);
+    return 0;
+}
+async function handleAutomationDelete(id, flags, env, io, json) {
+    if (!id)
+        throw new Error('automation del requires an automation id.');
+    const context = requireWorkspaceContext(flags, env, 'automation del');
+    const result = await request(context.baseUrl, 'DELETE', `/automations/${encodeURIComponent(id)}?workspace_id=${encodeURIComponent(context.workspaceId)}`);
+    print(json, io.stdout, result, `Deleted automation ${id}`);
+    return 0;
+}
+async function handleAutomationCheck(id, flags, env, io, json) {
+    if (!id)
+        throw new Error('automation check requires an automation id.');
+    const context = requireWorkspaceContext(flags, env, 'automation check');
+    const result = await request(context.baseUrl, 'POST', `/automations/${encodeURIComponent(id)}/check?workspace_id=${encodeURIComponent(context.workspaceId)}`);
+    print(json, io.stdout, result, `Checked automation ${id}`);
+    return 0;
+}
+async function handleScriptList(flags, env, io, json) {
+    const context = requireWorkspaceContext(flags, env, 'script list');
+    const result = await request(context.baseUrl, 'GET', `/automation-scripts?workspace_id=${encodeURIComponent(context.workspaceId)}`);
+    print(json, io.stdout, result, JSON.stringify(result, null, 2));
+    return 0;
+}
+async function handleScriptCreate(flags, env, io, json) {
+    const context = requireWorkspaceContext(flags, env, 'script create');
+    const result = await request(context.baseUrl, 'POST', '/automation-scripts', { workspaceId: context.workspaceId, title: getRequiredFlag(flags, 'title'), ...(getFlag(flags, 'desc') ? { description: getFlag(flags, 'desc') } : {}) });
+    print(json, io.stdout, result, `Created script ${result.id || ''}`.trim());
+    return 0;
+}
+async function handleScriptStage(flags, env, io, json) {
+    const context = requireWorkspaceContext(flags, env, 'script stage');
+    const scriptId = getRequiredFlag(flags, 'script');
+    const sourceJson = getFlag(flags, 'source-json');
+    const sourceFile = getFlag(flags, 'source-file');
+    if (Boolean(sourceJson) === Boolean(sourceFile))
+        throw new Error('script stage requires exactly one of --source-json or --source-file.');
+    let source;
+    if (sourceFile) {
+        source = readStableSourceFile(sourceFile);
+    }
+    else {
+        source = sourceJson;
+    }
+    if (Buffer.byteLength(source, 'utf8') > 1_200_000)
+        throw new Error('script stage source bundle exceeds 1,200,000 bytes.');
+    let files;
+    try {
+        files = JSON.parse(source);
+    }
+    catch {
+        throw new Error('script stage --source-json must be a JSON array.');
+    }
+    if (!Array.isArray(files) || files.some((file) => !file || typeof file !== 'object' || Array.isArray(file) || Object.keys(file).some((key) => key !== 'path' && key !== 'content'))) {
+        throw new Error('script stage accepts only source file path and content fields.');
+    }
+    const result = await request(context.baseUrl, 'POST', `/automation-scripts/${encodeURIComponent(scriptId)}/versions?workspace_id=${encodeURIComponent(context.workspaceId)}`, { files });
+    print(json, io.stdout, result, `Staged script version ${result.id || ''}`.trim());
+    return 0;
+}
+function readStableSourceFile(path) {
+    if (!node_fs_1.constants.O_NOFOLLOW)
+        throw new Error('script stage --source-file requires O_NOFOLLOW support.');
+    const fd = (0, node_fs_1.openSync)(path, node_fs_1.constants.O_RDONLY | node_fs_1.constants.O_NOFOLLOW);
+    try {
+        const before = (0, node_fs_1.fstatSync)(fd);
+        if (!before.isFile())
+            throw new Error('script stage --source-file must be a regular file.');
+        if (before.size > 1_200_000)
+            throw new Error('script stage source bundle exceeds 1,200,000 bytes.');
+        const buffer = Buffer.allocUnsafe(before.size);
+        let offset = 0;
+        while (offset < buffer.length) {
+            const read = (0, node_fs_1.readSync)(fd, buffer, offset, buffer.length - offset, null);
+            if (!read)
+                throw new Error('script stage source file changed while reading.');
+            offset += read;
+        }
+        const after = (0, node_fs_1.fstatSync)(fd);
+        if (before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs) {
+            throw new Error('script stage source file changed while reading.');
+        }
+        return new TextDecoder('utf-8', { fatal: true }).decode(buffer);
+    }
+    finally {
+        (0, node_fs_1.closeSync)(fd);
+    }
+}
+async function handleScriptStatus(versionId, flags, env, io, json) {
+    if (!versionId)
+        throw new Error('script status requires a version id.');
+    const context = requireWorkspaceContext(flags, env, 'script status');
+    const version = await request(context.baseUrl, 'GET', scriptVersionPath(versionId, context));
+    print(json, io.stdout, version, JSON.stringify(version, null, 2));
+    return 0;
+}
+async function handleScriptTransition(action, versionId, flags, env, io, json) {
+    if (!versionId)
+        throw new Error(`script ${action} requires a version id.`);
+    const context = requireWorkspaceContext(flags, env, `script ${action}`);
+    const result = await request(context.baseUrl, 'POST', scriptVersionActionPath(versionId, action, context), { actor: getRequiredFlag(flags, 'actor') });
+    print(json, io.stdout, result, `Requested script ${action} for ${versionId}`);
+    return 0;
+}
+async function handleScriptTest(versionId, flags, env, io, json) {
+    if (!versionId)
+        throw new Error('script test requires a version id.');
+    const context = requireWorkspaceContext(flags, env, 'script test');
+    const version = await request(context.baseUrl, 'GET', scriptVersionPath(versionId, context));
+    if (version.status !== 'test_authorized')
+        throw new Error(`script test requires a live unconsumed test authorization, got ${version.status}.`);
+    const result = await request(context.baseUrl, 'POST', scriptVersionActionPath(versionId, 'test', context), { actor: getRequiredFlag(flags, 'actor') });
+    print(json, io.stdout, result, `Ran script test for ${versionId}`);
+    return 0;
+}
+async function handleScriptApprovalDecision(action, versionId, flags, env, io, json) {
+    if (!versionId)
+        throw new Error(`script ${action} requires a version id.`);
+    const context = requireWorkspaceContext(flags, env, `script ${action}`);
+    const result = await request(context.baseUrl, 'POST', scriptVersionActionPath(versionId, action, context), { approvalId: getRequiredFlag(flags, 'approval'), actor: getRequiredFlag(flags, 'actor') });
+    print(json, io.stdout, result, `Applied script ${action} for ${versionId}`);
+    return 0;
+}
+function scriptVersionPath(versionId, context) {
+    return `/automation-scripts/versions/${encodeURIComponent(versionId)}?workspace_id=${encodeURIComponent(context.workspaceId)}`;
+}
+function scriptVersionActionPath(versionId, action, context) {
+    return `/automation-scripts/versions/${encodeURIComponent(versionId)}/${action}?workspace_id=${encodeURIComponent(context.workspaceId)}`;
+}
+function requireWorkspaceContext(flags, env, operation) {
+    const context = resolveContext(flags, env);
+    if (!context.workspaceId)
+        throw new Error(`${operation} requires a workspace context. Set LOCAL_AI_WORKSPACE_ID or pass --workspace.`);
+    return context;
+}
 async function handleMonitorAdd(flags, env, io, json) {
     const context = resolveContext(flags, env);
     if (!context.workspaceId) {
@@ -444,6 +668,11 @@ function printUsage(output) {
         '  lac monitor edit <monitor-id> [--title "<title>"] [--condition "<expr>"] [--message "<text>"] [--enabled true|false] [--cooldown 15m] [--execution-mode same-thread|side-thread] [--json]',
         '  lac monitor del <monitor-id> [--json]',
         '  lac monitor run <monitor-id> [--json]',
+        '  lac automation add --title "<title>" --script-id <script-id> --script-version <approved-version-id> --interval <duration> --message "<prompt>" [--json]',
+        '  lac automation list|info <id>|edit <id> [--title "<title>"] [--enabled true|false]|del <id>|check <id> [--json]',
+        '  lac script list|create --title "<title>"|stage --script <script-id> --source-json "<files-json>"|status <version-id> [--json]',
+        '  lac script test-approval|test|enable-approval|revoke <version-id> --actor <actor> [--json]',
+        '  lac script approve|reject <version-id> --approval <approval-id> --actor <actor> [--json]',
         '  lac channel send-file --path "<file>" [--target <chat-or-user-id>] [--workspace <id>] [--workspace-path <path>] [--platform lark] [--name <filename>] [--json]',
     ].join('\n') + '\n');
 }