akm-cli 0.7.5 → 0.8.0-rc.6

package/dist/tasks/resolveAkmBin.js

@@ -0,0 +1,87 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * Resolve the absolute invocation that the OS scheduler should run.
+ *
+ * cron / launchd / schtasks all execute jobs with a stripped environment and
+ * a minimal PATH, so the registered command must be an absolute path.
+ *
+ * Resolution order:
+ *
+ *   1. `$AKM_BIN` (explicit override; takes precedence everywhere).
+ *   2. `process.execPath` + the resolved CLI script — works when running
+ *      from a development checkout (`bun /repo/src/cli.ts`) and from a
+ *      compiled install (`bun /opt/akm/dist/cli.js`).
+ *   3. `which akm` / `where akm` — last resort when the binary is on PATH
+ *      but neither override applies.
+ *
+ * Returns the argv array the scheduler should execute (e.g.
+ * `["/usr/local/bin/bun", "/repo/dist/cli.js"]`). The caller appends
+ * subcommand args (`"tasks", "run", "<id>"`).
+ */
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { ConfigError } from "../core/errors";
+export function resolveAkmInvocation(options = {}) {
+    const env = options.env ?? process.env;
+    const override = env.AKM_BIN?.trim();
+    if (override) {
+        return { argv: [override], via: "AKM_BIN" };
+    }
+    const cliPath = resolveCliEntry(options.cliEntryUrl ?? import.meta.url);
+    if (cliPath && process.execPath) {
+        return { argv: [process.execPath, cliPath], via: "execPath" };
+    }
+    const whichBin = findOnPath("akm", env);
+    if (whichBin) {
+        return { argv: [whichBin], via: "which" };
+    }
+    throw new ConfigError("Cannot resolve absolute path to the akm binary for scheduler registration.", "INVALID_CONFIG_FILE", "Set AKM_BIN to the absolute path of the akm binary, or ensure `akm` is on PATH.");
+}
+/**
+ * From the URL of a module inside `src/tasks/` figure out the CLI entry.
+ *
+ *   • dev      `…/src/tasks/resolveAkmBin.ts`   → `…/src/cli.ts`
+ *   • build    `…/dist/tasks/resolveAkmBin.js`  → `…/dist/cli.js`
+ */
+function resolveCliEntry(moduleUrl) {
+    let modulePath;
+    try {
+        modulePath = fileURLToPath(moduleUrl);
+    }
+    catch {
+        return undefined;
+    }
+    const dir = path.dirname(modulePath); // .../tasks
+    const parent = path.dirname(dir); // .../src or .../dist
+    const ext = path.extname(modulePath); // .ts | .js
+    const candidate = path.join(parent, `cli${ext}`);
+    if (fs.existsSync(candidate))
+        return candidate;
+    // Fallback: try the other extension.
+    const alt = path.join(parent, ext === ".ts" ? "cli.js" : "cli.ts");
+    if (fs.existsSync(alt))
+        return alt;
+    return undefined;
+}
+function findOnPath(bin, env) {
+    const tool = process.platform === "win32" ? "where" : "which";
+    try {
+        const out = spawnSync(tool, [bin], { encoding: "utf8", env });
+        if (out.status === 0 && typeof out.stdout === "string") {
+            const first = out.stdout
+                .split(/\r?\n/)
+                .map((s) => s.trim())
+                .find(Boolean);
+            if (first && fs.existsSync(first))
+                return first;
+        }
+    }
+    catch {
+        // ignore — caller will throw a ConfigError
+    }
+    return undefined;
+}

package/dist/tasks/runner.js

@@ -0,0 +1,458 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * `akm tasks run <id>` — what cron / launchd / schtasks invoke at the
+ * scheduled moment.
+ *
+ * Responsibilities:
+ *
+ *   1. Resolve the task file via `resolveAssetPath(stashDir, "task", id)`.
+ *   2. Parse the task document. (Validation runs at `tasks add` /
+ *      `tasks sync` time, not here — at run time we still want to attempt
+ *      execution and surface the actual failure rather than re-fail on a
+ *      validation error that the user already knows about.)
+ *   3. Refuse to run when `enabled === false` (defense-in-depth).
+ *   4. Dispatch by target kind:
+ *        • workflow → `startWorkflowRun(ref, params)`
+ *        • prompt   → `runAgent(profile, prompt, { stdio: "captured" })`
+ *   5. Capture stdout / stderr to `<cacheDir>/tasks/logs/<id>/<ts>.log`.
+ *   6. Write a history row to state.db task_history table.
+ *
+ * Returns a structured result so the CLI handler can shape it for `output()`
+ * and so tests can assert against it without scraping stdout.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { parseAssetRef } from "../core/asset-ref";
+import { resolveStashDir } from "../core/common";
+import { loadConfig } from "../core/config";
+import { NotFoundError, rethrowIfTestIsolationError } from "../core/errors";
+import { getTaskLogDir } from "../core/paths";
+import { getTaskHistory, openStateDatabase, queryTaskHistory, upsertTaskHistory } from "../core/state-db";
+import { error } from "../core/warn";
+import { requireAgentProfile, runAgent } from "../integrations/agent";
+import { resolveProcessAgentProfile } from "../integrations/agent/config";
+import { resolveRunner } from "../integrations/agent/runner";
+import { resolveAssetPath } from "../sources/resolve";
+import { startWorkflowRun } from "../workflows/runs";
+import { parseTaskDocument } from "./parser";
+export async function runTask(id, options = {}) {
+    const stashDir = options.stashDir ?? resolveStashDir();
+    const runAgentImpl = options.runAgentImpl ?? runAgent;
+    const startWorkflowRunImpl = options.startWorkflowRunImpl ?? startWorkflowRun;
+    const now = options.now ?? (() => new Date());
+    const logDir = options.logDir ?? getTaskLogDir();
+    const filePath = await resolveAssetPath(stashDir, "task", id);
+    const yaml = fs.readFileSync(filePath, "utf8");
+    const task = parseTaskDocument({ yaml, filePath, id });
+    const startedAt = now();
+    const startedIso = startedAt.toISOString();
+    const tsSlug = startedIso.replace(/[:.]/g, "-");
+    const taskLogDir = path.join(logDir, id);
+    fs.mkdirSync(taskLogDir, { recursive: true });
+    const logPath = path.join(taskLogDir, `${tsSlug}.log`);
+    if (!task.enabled) {
+        const finishedAt = now();
+        const disabledTarget = task.target.kind === "workflow"
+            ? { kind: "workflow", ref: task.target.ref }
+            : task.target.kind === "command"
+                ? { kind: "prompt", profile: undefined }
+                : { kind: "prompt", profile: task.target.profile };
+        const result = {
+            id,
+            status: "disabled",
+            startedAt: startedIso,
+            finishedAt: finishedAt.toISOString(),
+            durationMs: finishedAt.getTime() - startedAt.getTime(),
+            log: logPath,
+            target: disabledTarget,
+        };
+        fs.writeFileSync(logPath, `[akm tasks] task "${id}" is disabled — skipping run.\n`);
+        appendHistory(result);
+        return result;
+    }
+    if (task.target.kind === "workflow") {
+        return await runWorkflowTask({
+            task,
+            logPath,
+            startedAt,
+            now,
+            startWorkflowRunImpl,
+        });
+    }
+    if (task.target.kind === "command") {
+        return await runCommandTask({ task, logPath, startedAt, now });
+    }
+    // Resolve config once here so runPromptTask does not call loadConfig()
+    // on every dispatch in a batch run (Fix C6).
+    const config = loadConfig();
+    return await runPromptTask({
+        task,
+        stashDir,
+        logPath,
+        startedAt,
+        now,
+        runAgentImpl,
+        agentOptions: options.agentOptions,
+        agentConfig: config,
+        agentTimeoutMs: undefined,
+    });
+}
+// ── command target ──────────────────────────────────────────────────────────
+async function runCommandTask(input) {
+    const { task, logPath, startedAt, now } = input;
+    if (task.target.kind !== "command")
+        throw new Error("invariant: command target");
+    const { cmd } = task.target;
+    const timeoutMs = task.timeoutMs !== undefined ? task.timeoutMs : null;
+    const logLines = [`[akm tasks] task=${task.id} kind=command cmd=${cmd.join(" ")}`];
+    let stdout = "";
+    let stderr = "";
+    let exitCode = null;
+    try {
+        const proc = Bun.spawn(cmd, {
+            stdin: "ignore",
+            stdout: "pipe",
+            stderr: "pipe",
+            cwd: process.env.HOME ?? "/tmp",
+        });
+        let timer;
+        let timedOut = false;
+        if (timeoutMs !== null) {
+            timer = setTimeout(() => {
+                timedOut = true;
+                try {
+                    proc.kill("SIGTERM");
+                }
+                catch {
+                    /* ignore */
+                }
+            }, timeoutMs);
+        }
+        const [stdoutBuf, stderrBuf] = await Promise.all([
+            new Response(proc.stdout).text(),
+            new Response(proc.stderr).text(),
+        ]);
+        await proc.exited;
+        if (timer !== undefined)
+            clearTimeout(timer);
+        stdout = stdoutBuf;
+        stderr = stderrBuf;
+        exitCode = proc.exitCode ?? (timedOut ? 143 : 1);
+        if (timedOut) {
+            logLines.push(`timed_out=true timeout_ms=${timeoutMs}`);
+        }
+        logLines.push(`exit_code=${exitCode}`);
+        if (stdout) {
+            logLines.push("--- stdout ---");
+            logLines.push(stdout);
+        }
+        if (stderr) {
+            logLines.push("--- stderr ---");
+            logLines.push(stderr);
+        }
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        logLines.push(`spawn_error=${msg}`);
+        exitCode = 1;
+    }
+    fs.writeFileSync(logPath, `${logLines.join("\n")}\n`);
+    const finishedAt = now();
+    const status = exitCode === 0 ? "completed" : "failed";
+    const result = {
+        id: task.id,
+        status,
+        startedAt: startedAt.toISOString(),
+        finishedAt: finishedAt.toISOString(),
+        durationMs: finishedAt.getTime() - startedAt.getTime(),
+        log: logPath,
+        target: { kind: "prompt", profile: undefined },
+        detail: { exitCode },
+    };
+    appendHistory(result);
+    return result;
+}
+// ── workflow target ─────────────────────────────────────────────────────────
+async function runWorkflowTask(input) {
+    const { task, logPath, startedAt, now, startWorkflowRunImpl } = input;
+    if (task.target.kind !== "workflow")
+        throw new Error("invariant: workflow target");
+    const ref = parseAssetRef(task.target.ref);
+    if (ref.type !== "workflow") {
+        throw new NotFoundError(`Task "${task.id}" workflow target must be a workflow ref (got "${task.target.ref}").`, "WORKFLOW_NOT_FOUND");
+    }
+    let detail;
+    let error;
+    try {
+        detail = await startWorkflowRunImpl(task.target.ref, task.target.params);
+    }
+    catch (e) {
+        error = e instanceof Error ? e : new Error(String(e));
+    }
+    const finishedAt = now();
+    const status = error ? "failed" : mapWorkflowStatus(detail?.run.status);
+    const log = renderWorkflowLog({ task, detail, error });
+    fs.writeFileSync(logPath, log);
+    const result = {
+        id: task.id,
+        status,
+        startedAt: startedAt.toISOString(),
+        finishedAt: finishedAt.toISOString(),
+        durationMs: finishedAt.getTime() - startedAt.getTime(),
+        log: logPath,
+        target: { kind: "workflow", ref: task.target.ref },
+        detail: {
+            runId: detail?.run.id,
+            ...(error ? { error: error.message } : {}),
+        },
+    };
+    appendHistory(result);
+    // Don't re-throw on workflow failure: the OS scheduler reads exit codes,
+    // not exceptions, and the CLI maps `status: "failed"` to a non-zero exit
+    // via exitCodeForStatus(). Throwing here would route through the generic
+    // runWithJsonErrors path and lose the structured result/history we just
+    // recorded.
+    return result;
+}
+/**
+ * Map the workflow runtime's status into the task-runner status space.
+ * Workflows can legitimately remain `active` after `startWorkflowRun`
+ * returns (multi-step workflows pause for user input); recording them as
+ * "completed" would be misleading. We preserve "active" as a first-class
+ * task status with exit code 0 — the OS scheduler treats it as success.
+ */
+function mapWorkflowStatus(status) {
+    switch (status) {
+        case "completed":
+        case "blocked":
+        case "failed":
+        case "active":
+            return status;
+        default:
+            return "completed";
+    }
+}
+function renderWorkflowLog(input) {
+    const lines = [];
+    lines.push(`[akm tasks] task=${input.task.id} kind=workflow ref=${input.task.target.ref}`);
+    if (input.detail) {
+        lines.push(`run_id=${input.detail.run.id} status=${input.detail.run.status}`);
+        lines.push(`workflow_title=${input.detail.run.workflowTitle}`);
+    }
+    if (input.error) {
+        lines.push(`error=${input.error.message}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+// ── prompt target ───────────────────────────────────────────────────────────
+async function runPromptTask(input) {
+    const { task, stashDir, logPath, startedAt, now, runAgentImpl, agentOptions } = input;
+    if (task.target.kind !== "prompt")
+        throw new Error("invariant: prompt target");
+    // Use pre-resolved agent config when available to avoid redundant loadConfig()
+    // calls in batch task runs (Fix C6). Fall back to loadConfig() for callers
+    // that invoke runPromptTask directly without threading config.
+    const fullConfig = loadConfig();
+    const agentCfg = input.agentConfig !== undefined ? input.agentConfig : fullConfig;
+    // Resolve the profile for this task. When the task doc specifies a profile,
+    // use it directly. Otherwise fall back to the per-process config for "task"
+    // (agent.processes["task"]), which itself falls back to agent.default.
+    let profile;
+    let processTimeoutMs;
+    if (task.target.profile) {
+        // v2: if profiles.agent is configured, resolve through new runner
+        if (fullConfig.profiles?.agent) {
+            const mode = task.target.mode ?? "agent";
+            if (mode !== "llm") {
+                const runnerSpec = resolveRunner(mode, task.target.profile, fullConfig);
+                if (runnerSpec.kind === "agent" || runnerSpec.kind === "sdk") {
+                    profile = runnerSpec.profile;
+                    processTimeoutMs = runnerSpec.timeoutMs;
+                }
+                else {
+                    profile = requireAgentProfile(agentCfg, task.target.profile);
+                }
+            }
+            else {
+                profile = requireAgentProfile(agentCfg, task.target.profile);
+            }
+        }
+        else {
+            // v1: Task doc explicitly names a profile — honour it directly.
+            profile = requireAgentProfile(agentCfg, task.target.profile);
+        }
+    }
+    else {
+        // No per-task profile: use process config for "task" as a fallback.
+        const resolved = resolveProcessAgentProfile("task", agentCfg);
+        profile = resolved.profile;
+        processTimeoutMs = resolved.timeoutMs;
+    }
+    // Task-level timeoutMs (including null = disabled) wins over global config.
+    // Resolution: task.timeoutMs → process entry timeoutMs → input.agentTimeoutMs → agentCfg.timeoutMs.
+    const agentTimeoutMs = task.timeoutMs !== undefined
+        ? task.timeoutMs
+        : processTimeoutMs !== undefined
+            ? processTimeoutMs
+            : input.agentTimeoutMs !== undefined
+                ? input.agentTimeoutMs
+                : undefined;
+    const promptText = await resolvePromptText(task, stashDir);
+    const result = await runAgentImpl(profile, promptText, {
+        stdio: "captured",
+        timeoutMs: agentTimeoutMs,
+        cwd: stashDir,
+        ...agentOptions,
+    });
+    const finishedAt = now();
+    const log = renderPromptLog({ task, profileName: profile.name, result });
+    fs.writeFileSync(logPath, log);
+    const status = result.ok ? "completed" : "failed";
+    const out = {
+        id: task.id,
+        status,
+        startedAt: startedAt.toISOString(),
+        finishedAt: finishedAt.toISOString(),
+        durationMs: finishedAt.getTime() - startedAt.getTime(),
+        log: logPath,
+        target: { kind: "prompt", profile: profile.name },
+        detail: result.ok
+            ? { exitCode: result.exitCode }
+            : { reason: result.reason, error: result.error, exitCode: result.exitCode },
+    };
+    appendHistory(out);
+    return out;
+}
+async function resolvePromptText(task, stashDir) {
+    if (task.target.kind !== "prompt")
+        throw new Error("invariant: prompt target");
+    const src = task.target.source;
+    if (src.kind === "inline")
+        return src.text;
+    if (src.kind === "file") {
+        const taskDir = path.dirname(task.source.path);
+        const filePath = path.isAbsolute(src.path) ? src.path : path.resolve(taskDir, src.path);
+        if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+            throw new NotFoundError(`Prompt file not found: ${filePath}`, "FILE_NOT_FOUND");
+        }
+        return fs.readFileSync(filePath, "utf8");
+    }
+    // asset
+    const ref = parseAssetRef(src.ref);
+    const assetPath = await resolveAssetPath(stashDir, ref.type, ref.name);
+    return fs.readFileSync(assetPath, "utf8");
+}
+function renderPromptLog(input) {
+    const lines = [];
+    lines.push(`[akm tasks] task=${input.task.id} kind=prompt profile=${input.profileName}`);
+    lines.push(`ok=${input.result.ok} exit_code=${input.result.exitCode ?? "null"} duration_ms=${input.result.durationMs}`);
+    if (!input.result.ok) {
+        lines.push(`reason=${input.result.reason ?? ""} error=${input.result.error ?? ""}`);
+    }
+    if (input.result.stdout) {
+        lines.push("--- agent stdout ---");
+        lines.push(input.result.stdout);
+    }
+    if (input.result.stderr) {
+        lines.push("--- agent stderr ---");
+        lines.push(input.result.stderr);
+    }
+    return `${lines.join("\n")}\n`;
+}
+// ── history ─────────────────────────────────────────────────────────────────
+function appendHistory(result) {
+    try {
+        const db = openStateDatabase();
+        try {
+            upsertTaskHistory(db, {
+                task_id: result.id,
+                status: result.status,
+                started_at: result.startedAt,
+                completed_at: result.finishedAt,
+                failed_at: result.status === "failed" ? result.finishedAt : null,
+                log_path: result.log,
+                target_kind: result.target.kind,
+                target_ref: result.target.kind === "workflow" ? result.target.ref : null,
+                metadata_json: JSON.stringify({
+                    durationMs: result.durationMs,
+                    detail: result.detail ?? null,
+                    profile: result.target.kind === "prompt" ? result.target.profile : undefined,
+                }),
+            });
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (err) {
+        rethrowIfTestIsolationError(err);
+        error(`[akm] task history DB write failed: ${String(err)}`);
+    }
+}
+export function readTaskHistory(options = {}) {
+    const db = openStateDatabase();
+    try {
+        let rows;
+        if (options.id) {
+            const row = getTaskHistory(db, options.id);
+            rows = row ? [taskHistoryRowToResult(row)] : [];
+        }
+        else {
+            rows = queryTaskHistory(db, {}).map(taskHistoryRowToResult);
+        }
+        rows.sort((a, b) => (a.startedAt < b.startedAt ? 1 : -1));
+        if (options.limit !== undefined && options.limit >= 0) {
+            return rows.slice(0, options.limit);
+        }
+        return rows;
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * Convert a `TaskHistoryRow` from state.db back to a `TaskRunResult` shape
+ * that callers of `readTaskHistory()` expect.
+ */
+function taskHistoryRowToResult(row) {
+    let meta = {};
+    try {
+        meta = JSON.parse(row.metadata_json);
+    }
+    catch {
+        // ignore corrupt JSON
+    }
+    const target = row.target_kind === "workflow"
+        ? { kind: "workflow", ref: row.target_ref ?? "" }
+        : { kind: "prompt", profile: meta.profile };
+    return {
+        id: row.task_id,
+        status: row.status,
+        startedAt: row.started_at,
+        finishedAt: row.completed_at ?? row.failed_at ?? row.started_at,
+        durationMs: meta.durationMs ?? 0,
+        log: row.log_path ?? "",
+        target,
+        ...(meta.detail !== undefined ? { detail: meta.detail } : {}),
+    };
+}
+/**
+ * The exit code surfaced to the OS scheduler. Mapped from {@link TaskRunStatus}
+ * so cron / launchd / schtasks see a useful return value.
+ */
+export function exitCodeForStatus(status) {
+    switch (status) {
+        case "completed":
+            return 0;
+        case "active":
+            return 0;
+        case "blocked":
+            return 1;
+        case "failed":
+            return 1;
+        case "disabled":
+            return 0;
+    }
+}