@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/commands/background-command.js

@@ -0,0 +1,378 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBackgroundCommand = runBackgroundCommand;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const product_storage_1 = require("../workers/product-storage");
+function runBackgroundCommand(cwd, args) {
+    const options = parseArgs(args);
+    if (options.action === "run-once") {
+        return runBackgroundOnce(cwd, options);
+    }
+    if (options.action === "status") {
+        return readBackgroundStatus(options);
+    }
+    if (["install", "enable", "disable", "uninstall"].includes(options.action)) {
+        return runWindowsTaskAction(options);
+    }
+    return {
+        ok: false,
+        command: "background",
+        error: `Unknown background action: ${options.action}`,
+        availableActions: ["run-once", "status", "install", "enable", "disable", "uninstall"]
+    };
+}
+function runBackgroundOnce(cwd, options) {
+    const startedAt = Date.now();
+    const config = readScheduleConfig(options.configPath);
+    const policy = readPolicyConfig();
+    const status = readStatus(options);
+    const lock = readLock(options.lockPath);
+    if (lock && Date.parse(lock.expiresAt) > Date.now()) {
+        return {
+            ok: true,
+            command: "background",
+            action: "run-once",
+            skipped: true,
+            reason: "background runner is already locked",
+            lock,
+            statusPath: options.statusPath
+        };
+    }
+    const currentLock = {
+        acquiredAt: new Date().toISOString(),
+        expiresAt: new Date(Date.now() + 10 * 60 * 1000).toISOString(),
+        pid: process.pid
+    };
+    writeJson(options.lockPath, currentLock);
+    const evaluatedAt = new Date().toISOString();
+    const routeResults = [];
+    let ok = true;
+    try {
+        if (config.enabled === false || status.enabled === false || policy?.background?.enabled === false || policy?.killSwitches?.includes("background")) {
+            status.lastEvaluationAt = evaluatedAt;
+            status.updatedAt = evaluatedAt;
+            status.configVersion = config.configVersion;
+            writeStatus(options.statusPath, options.configPath, status);
+            return {
+                ok: true,
+                command: "background",
+                action: "run-once",
+                skipped: true,
+                reason: "background schedule is disabled",
+                configVersion: config.configVersion,
+                policyVersion: readString(policy?.configVersion) ?? null,
+                statusPath: options.statusPath
+            };
+        }
+        for (const route of config.routes) {
+            const previous = status.routes[route.route] ?? {};
+            const due = options.force || isDue(route, previous.lastRunAt, Date.now());
+            if (!route.enabled) {
+                routeResults.push({ route: route.route, ok: true, skipped: true, reason: "route disabled" });
+                continue;
+            }
+            if (!due) {
+                routeResults.push({ route: route.route, ok: true, skipped: true, reason: "not due", nextDueAt: nextDueAt(route, previous.lastRunAt) });
+                continue;
+            }
+            const result = runRoute(cwd, route, options.runsDir, options.cliScriptPath);
+            routeResults.push(result);
+            status.routes[route.route] = {
+                lastRunAt: evaluatedAt,
+                lastStatus: typeof result.status === "number" ? result.status : null,
+                lastOk: result.ok === true,
+                ...(typeof result.error === "string" ? { lastError: result.error } : {}),
+                ...(typeof result.artifact === "string" ? { lastArtifact: result.artifact } : {})
+            };
+            if (result.ok !== true) {
+                ok = false;
+            }
+        }
+    }
+    finally {
+        node_fs_1.default.rmSync(options.lockPath, { force: true });
+    }
+    status.updatedAt = new Date().toISOString();
+    status.lastEvaluationAt = evaluatedAt;
+    status.configVersion = config.configVersion;
+    writeStatus(options.statusPath, options.configPath, status);
+    pruneRunArtifacts(options.runsDir, 20);
+    return {
+        ok,
+        command: "background",
+        action: "run-once",
+        configVersion: config.configVersion,
+        evaluatedRoutes: routeResults.length,
+        routes: routeResults,
+        durationMs: Date.now() - startedAt,
+        statusPath: options.statusPath
+    };
+}
+function runRoute(cwd, route, runsDir, cliScript) {
+    const runId = `${new Date().toISOString().replace(/[:.]/g, "-")}-${route.route}`;
+    const runDir = node_path_1.default.join(runsDir, runId);
+    node_fs_1.default.mkdirSync(runDir, { recursive: true });
+    const stdoutPath = node_path_1.default.join(runDir, "stdout.log");
+    const stderrPath = node_path_1.default.join(runDir, "stderr.log");
+    const summaryPath = node_path_1.default.join(runDir, "summary.json");
+    const result = (0, node_child_process_1.spawnSync)(process.execPath, [cliScript, "worker", route.route, "--", ...route.args], {
+        cwd,
+        encoding: "utf8",
+        timeout: route.timeoutSeconds * 1000,
+        env: process.env
+    });
+    node_fs_1.default.writeFileSync(stdoutPath, result.stdout ?? "", "utf8");
+    node_fs_1.default.writeFileSync(stderrPath, result.stderr ?? "", "utf8");
+    const parsed = parseJson(result.stdout);
+    const ok = result.status === 0 && parsed.ok !== false;
+    const summary = {
+        ok,
+        route: route.route,
+        status: result.status ?? null,
+        signal: result.signal ?? null,
+        timeoutMs: route.timeoutSeconds * 1000,
+        stdout: stdoutPath,
+        stderr: stderrPath,
+        payload: parsed
+    };
+    writeJson(summaryPath, summary);
+    return {
+        ok,
+        route: route.route,
+        status: result.status ?? null,
+        artifact: summaryPath,
+        ...(ok ? {} : {
+            error: result.error?.message ?? (result.stderr?.trim() || "background route failed")
+        })
+    };
+}
+function readBackgroundStatus(options) {
+    const status = readStatus(options);
+    const config = safeReadScheduleConfig(options.configPath);
+    const task = windowsTaskCommand(options);
+    return {
+        ok: true,
+        command: "background",
+        action: "status",
+        backend: "windows-scheduled-task",
+        installed: task.installed,
+        taskName: options.taskName,
+        wakeCommand: task.command,
+        configPath: options.configPath,
+        statusPath: options.statusPath,
+        lockPath: options.lockPath,
+        configVersion: config?.configVersion ?? status.configVersion ?? null,
+        routeCount: config?.routes.length ?? 0,
+        status
+    };
+}
+function runWindowsTaskAction(options) {
+    const task = windowsTaskCommand(options);
+    if (options.dryRun) {
+        return {
+            ok: true,
+            command: "background",
+            action: options.action,
+            dryRun: true,
+            backend: "windows-scheduled-task",
+            taskName: options.taskName,
+            wakeCommand: task.command
+        };
+    }
+    if (process.platform !== "win32") {
+        return {
+            ok: false,
+            command: "background",
+            action: options.action,
+            error: "Windows Scheduled Task backend is only available on win32."
+        };
+    }
+    const argsByAction = {
+        install: ["/Create", "/F", "/SC", "MINUTE", "/MO", String(options.wakeEveryMinutes), "/TN", options.taskName, "/TR", task.command],
+        enable: ["/Change", "/TN", options.taskName, "/ENABLE"],
+        disable: ["/Change", "/TN", options.taskName, "/DISABLE"],
+        uninstall: ["/Delete", "/F", "/TN", options.taskName]
+    };
+    const result = (0, node_child_process_1.spawnSync)("schtasks.exe", argsByAction[options.action] ?? [], {
+        encoding: "utf8"
+    });
+    return {
+        ok: result.status === 0,
+        command: "background",
+        action: options.action,
+        backend: "windows-scheduled-task",
+        taskName: options.taskName,
+        wakeCommand: task.command,
+        status: result.status ?? null,
+        stdout: result.stdout.trim(),
+        stderr: result.stderr.trim()
+    };
+}
+function parseArgs(args) {
+    const root = (0, product_storage_1.productStorageRoot)();
+    const backgroundDir = node_path_1.default.join(root, "background");
+    const options = {
+        action: args[0] ?? "status",
+        force: false,
+        dryRun: false,
+        configPath: node_path_1.default.join(backgroundDir, "schedule-config.json"),
+        statusPath: node_path_1.default.join(backgroundDir, "status.json"),
+        lockPath: node_path_1.default.join(backgroundDir, "lock.json"),
+        runsDir: node_path_1.default.join(backgroundDir, "runs"),
+        cliScriptPath: cliScriptPath(),
+        taskName: "AIB Control Plane Background",
+        wakeEveryMinutes: 5
+    };
+    for (let index = 1; index < args.length; index += 1) {
+        const current = args[index];
+        const next = args[index + 1];
+        if (current === "--force") {
+            options.force = true;
+            continue;
+        }
+        if (current === "--dry-run") {
+            options.dryRun = true;
+            continue;
+        }
+        if (current === "--config" && next) {
+            options.configPath = node_path_1.default.resolve(next);
+            index += 1;
+            continue;
+        }
+        if (current === "--task-name" && next) {
+            options.taskName = next;
+            index += 1;
+            continue;
+        }
+        if (current === "--cli-script" && next) {
+            options.cliScriptPath = node_path_1.default.resolve(next);
+            index += 1;
+            continue;
+        }
+        if (current === "--wake-every-minutes" && next) {
+            options.wakeEveryMinutes = Number.parseInt(next, 10);
+            index += 1;
+            continue;
+        }
+    }
+    return options;
+}
+function readScheduleConfig(configPath) {
+    const config = safeReadScheduleConfig(configPath);
+    if (!config) {
+        throw new Error(`Background schedule config not found or invalid: ${configPath}`);
+    }
+    return config;
+}
+function safeReadScheduleConfig(configPath) {
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(configPath, "utf8"));
+        return parsed && parsed.schemaVersion === 1 && Array.isArray(parsed.routes) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readStatus(options) {
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(options.statusPath, "utf8"));
+        if (parsed && parsed.schemaVersion === 1 && parsed.routes) {
+            return parsed;
+        }
+    }
+    catch { }
+    return {
+        schemaVersion: 1,
+        updatedAt: new Date().toISOString(),
+        enabled: true,
+        configPath: options.configPath,
+        routes: {}
+    };
+}
+function readPolicyConfig() {
+    try {
+        const filePath = node_path_1.default.join((0, product_storage_1.productStorageRoot)(), "control-plane", "policy-config.json");
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(filePath, "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeStatus(statusPath, configPath, status) {
+    writeJson(statusPath, {
+        ...status,
+        configPath,
+        lock: readLock(node_path_1.default.join(node_path_1.default.dirname(statusPath), "lock.json")) ?? undefined
+    });
+}
+function readLock(lockPath) {
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(lockPath, "utf8"));
+        return parsed && typeof parsed === "object" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isDue(route, lastRunAt, nowMs) {
+    if (!lastRunAt) {
+        return true;
+    }
+    return nowMs >= Date.parse(lastRunAt) + route.intervalMinutes * 60_000;
+}
+function nextDueAt(route, lastRunAt) {
+    return lastRunAt ? new Date(Date.parse(lastRunAt) + route.intervalMinutes * 60_000).toISOString() : null;
+}
+function windowsTaskCommand(options) {
+    const command = `"${process.execPath}" "${options.cliScriptPath}" background run-once`;
+    if (process.platform !== "win32") {
+        return { installed: null, command };
+    }
+    const result = (0, node_child_process_1.spawnSync)("schtasks.exe", ["/Query", "/TN", options.taskName], {
+        encoding: "utf8"
+    });
+    return { installed: result.status === 0, command };
+}
+function cliScriptPath() {
+    return node_path_1.default.resolve(process.argv[1] ?? __filename);
+}
+function parseJson(text) {
+    try {
+        const parsed = JSON.parse(text);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : { ok: false, error: "worker produced non-object json stdout" };
+    }
+    catch {
+        return {
+            ok: false,
+            error: text.trim() ? `worker produced non-json stdout: ${text.trim()}` : "worker produced no stdout"
+        };
+    }
+}
+function readString(value) {
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function writeJson(filePath, value) {
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
+    node_fs_1.default.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+function pruneRunArtifacts(runsDir, keep) {
+    try {
+        const entries = node_fs_1.default.readdirSync(runsDir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => node_path_1.default.join(runsDir, entry.name))
+            .sort()
+            .reverse();
+        for (const dir of entries.slice(keep)) {
+            node_fs_1.default.rmSync(dir, { recursive: true, force: true });
+        }
+    }
+    catch { }
+}

package/dist/commands/captured-input.js

@@ -1,2 +1,74 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.attachCapturedInput=$;const h=require("node:crypto"),m=require("../shared/agent-text"),b=require("./session-workspace");function $(e,r,n,t,u){if(!p(n)||y(t))return t;const f=I(r,n),o=A(n,t),c=(0,b.captureSessionInput)(e,f,o,n,u);if(!c)return t;const a=l(n)?"capturedInput":"input",s=t[a]!==void 0?t:{...t,[a]:c.handle};return t.ok!==!1||d(r)?s:g(e,r,f,c,s)}function y(e){if(e.ok===!1)return!1;const r=i(e.operation);return r!==null&&r.endsWith(".execute")}function I(e,r){return e!=="inspect"?e:F(r,"modulePlan")?"modulePlan":"inspect"}function d(e){return e==="inspect"||e==="graph"||e==="modulePlan"||e==="move"||e==="refactor"}function g(e,r,n,t,u){const f=v(r,n,u.operation,t.handle),o=f?(0,b.useSessionGuidance)(e,`failureInputRecovery.${r}.${i(u.operation)??"unknown"}`,`Edit inputFile, then rerun: ${f}`):void 0,c={...u,input:t.handle,inputFile:t.file,...o?{inputNext:o}:{}},a=(0,m.readAgentText)(u);if(!a)return c;const s=[a.trimEnd(),`input: ${t.handle}`,`inputFile: ${t.file}`,...o?[`next: ${o}`]:[]];return(0,m.attachAgentText)(c,s.join(`
-`))}function v(e,r,n,t){const u=i(n)??"";return e==="modulePlan"?`aib modulePlan preview --from ${t}`:e==="move"?u==="move.toFile.execute"?`aib move toFile execute --from ${t}`:`aib move toFile preview --from ${t}`:e==="rename"?u==="rename.execute"?`aib rename execute --from ${t}`:`aib rename preview --from ${t}`:e==="refactor"?u==="refactor.batch.execute"?`aib refactor batch execute --from ${t}`:u==="refactor.batch.apply"?`aib refactor batch apply --from ${t}`:`aib refactor batch preview --from ${t}`:r==="modulePlan"?`aib modulePlan preview --from ${t}`:null}function A(e,r){const n=i(e.save);return n||(i(r.planId)??i(r.previewId)??x(r.results,"planId")??x(r.results,"previewId")??`req_${_(e).slice(0,12)}`)}function F(e,r){return e.op===r?!0:(Array.isArray(e.requests)?e.requests:[]).some(t=>p(t)&&t.op===r)}function l(e){return Array.isArray(e)?e.some(r=>l(r)):p(e)?e.execute===!0?!0:Object.values(e).some(r=>l(r)):!1}function _(e){return(0,h.createHash)("sha256").update(JSON.stringify(e)).digest("hex")}function i(e){return typeof e=="string"&&e.trim()!==""?e.trim():null}function x(e,r){if(!Array.isArray(e))return null;const n=e.find(p);return n?i(n[r]):null}function p(e){return!!e&&typeof e=="object"&&!Array.isArray(e)}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachCapturedInput = attachCapturedInput;
+const node_crypto_1 = require("node:crypto");
+const session_workspace_1 = require("./session-workspace");
+function attachCapturedInput(cwd, kind, rawPayload, response, source) {
+    if (!isObject(rawPayload)) {
+        return response;
+    }
+    if (isSuccessfulExecuteResponse(response)) {
+        return response;
+    }
+    const captureKind = inferCaptureKind(kind);
+    const captureName = inferCaptureName(rawPayload, response);
+    const captured = (0, session_workspace_1.captureSessionInput)(cwd, captureKind, captureName, rawPayload, source);
+    if (!captured) {
+        return response;
+    }
+    const field = hasExecuteTrue(rawPayload) ? "capturedInput" : "input";
+    const withInput = response[field] !== undefined ? response : {
+        ...response,
+        [field]: captured.handle
+    };
+    return withInput;
+}
+function isSuccessfulExecuteResponse(response) {
+    if (response.ok === false) {
+        return false;
+    }
+    const operation = readString(response.operation);
+    return operation !== null && operation.endsWith(".execute");
+}
+function inferCaptureKind(kind) {
+    return kind;
+}
+function inferCaptureName(payload, response) {
+    const payloadName = readString(payload.save);
+    if (payloadName) {
+        return payloadName;
+    }
+    const responseName = readString(response.planId) ??
+        readString(response.previewId) ??
+        readStringFromFirstResult(response.results, "planId") ??
+        readStringFromFirstResult(response.results, "previewId");
+    return responseName ?? `req_${hashPayload(payload).slice(0, 12)}`;
+}
+function hasExecuteTrue(value) {
+    if (Array.isArray(value)) {
+        return value.some((item) => hasExecuteTrue(item));
+    }
+    if (!isObject(value)) {
+        return false;
+    }
+    if (value.execute === true) {
+        return true;
+    }
+    return Object.values(value).some((item) => hasExecuteTrue(item));
+}
+function hashPayload(payload) {
+    return (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(payload)).digest("hex");
+}
+function readString(value) {
+    return typeof value === "string" && value.trim() !== "" ? value.trim() : null;
+}
+function readStringFromFirstResult(value, key) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    const first = value.find(isObject);
+    return first ? readString(first[key]) : null;
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}