outsrc 0.2.0 → 0.2.1

package/dist/updates.js

@@ -0,0 +1,136 @@
+import { execFile } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { z } from "zod";
+import { ensureOutsrcHome } from "./fs-home.js";
+import { readJson, writeJson } from "./state.js";
+import { isBehind, parseVersion } from "./version.js";
+export const PRODUCTS = ["claude", "codex", "grok", "outsrc"];
+const Check = z.object({ installed: z.string().nullable(), latest: z.string().nullable(), error: z.string().nullable() });
+const Pending = z.object({ installed: z.string(), latest: z.string(), first_seen_at: z.string() });
+const StateSchema = z.object({
+    version: z.literal(1),
+    checked_at: z.string().nullable(),
+    checks: z.partialRecord(z.enum(PRODUCTS), Check),
+    pending: z.partialRecord(z.enum(PRODUCTS), Pending),
+});
+const AckSchema = z.object({ version: z.literal(1), acked: z.array(z.string()) });
+// refresh is the only writer of updates.json; ack is the only writer of updates-ack.json.
+export function updatesFile(home) { return join(home, "updates.json"); }
+export function ackFile(home) { return join(home, "updates-ack.json"); }
+const EMPTY = { version: 1, checked_at: null, checks: {}, pending: {} };
+export function readUpdates(home) {
+    const file = updatesFile(home);
+    if (!existsSync(file))
+        return EMPTY;
+    const parsed = StateSchema.safeParse(readJson(file));
+    return parsed.success ? parsed.data : EMPTY;
+}
+function readAcks(home) {
+    const file = ackFile(home);
+    if (!existsSync(file))
+        return [];
+    const parsed = AckSchema.safeParse(readJson(file));
+    return parsed.success ? parsed.data.acked : [];
+}
+export function notifications(state) {
+    return PRODUCTS.flatMap((product) => {
+        const entry = state.pending[product];
+        return entry ? [{ id: `${product}@${entry.latest}`, product, ...entry }] : [];
+    });
+}
+/** Pending updates the owner has not acknowledged yet. */
+export function unread(home, state = readUpdates(home)) {
+    const acked = new Set(readAcks(home));
+    return notifications(state).filter((note) => !acked.has(note.id));
+}
+export function ack(home, ids) {
+    const chosen = ids === "all" ? unread(home).map((note) => note.id) : ids;
+    const acked = [...new Set([...readAcks(home), ...chosen])].slice(-200);
+    ensureOutsrcHome(home);
+    writeJson(ackFile(home), { version: 1, acked });
+    return chosen;
+}
+async function settle(read) {
+    try {
+        const text = await read();
+        const version = parseVersion(text);
+        return version ? { version: version.text, error: null } : { version: null, error: `no version in ${JSON.stringify(text.slice(0, 80))}`, missing: false };
+    }
+    catch (error) {
+        const missing = error.code === "ENOENT";
+        return { version: null, error: error instanceof Error ? error.message.split("\n")[0] ?? "failed" : String(error), missing };
+    }
+}
+/**
+ * Checks every product and records which are behind. Never installs anything.
+ * A pending entry keeps its first_seen_at until a different latest version appears, so reruns are idempotent,
+ * and a failed check keeps the previous entry instead of dropping it and announcing it again later.
+ */
+export async function refresh(home, probe, now = new Date()) {
+    const previous = readUpdates(home);
+    const checkedAt = now.toISOString();
+    const results = await Promise.all(PRODUCTS.map(async (product) => {
+        const [installed, latest] = await Promise.all([settle(() => probe.installed(product)), settle(() => probe.latest(product))]);
+        return { product, installed, latest };
+    }));
+    const state = { version: 1, checked_at: checkedAt, checks: {}, pending: {} };
+    const fresh = [];
+    for (const { product, installed, latest } of results) {
+        state.checks[product] = { installed: installed.version, latest: latest.version, error: installed.error ?? latest.error };
+        const before = previous.pending[product];
+        if (installed.version === null || latest.version === null) {
+            // An uninstalled CLI has nothing to update; any other failure keeps what the last good check found.
+            const uninstalled = installed.version === null && installed.missing;
+            if (before && !uninstalled)
+                state.pending[product] = before;
+            continue;
+        }
+        if (!isBehind(installed.version, latest.version))
+            continue;
+        const entry = before?.latest === latest.version
+            ? { ...before, installed: installed.version }
+            : { installed: installed.version, latest: latest.version, first_seen_at: checkedAt };
+        state.pending[product] = entry;
+        if (before?.latest !== latest.version)
+            fresh.push({ id: `${product}@${entry.latest}`, product, ...entry });
+    }
+    ensureOutsrcHome(home);
+    writeJson(updatesFile(home), state);
+    return { state, fresh };
+}
+const run = promisify(execFile);
+const TIMEOUT_MS = 20_000;
+const NPM_PACKAGE = { claude: "@anthropic-ai/claude-code", codex: "@openai/codex", outsrc: "outsrc" };
+const PACKAGE_JSON = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+async function stdout(command, args) {
+    return (await run(command, args, { timeout: TIMEOUT_MS, encoding: "utf8" })).stdout;
+}
+/** Version queries only: `<cli> --version`, the npm registry, and `grok update --check`. No model calls. */
+export const defaultProbe = {
+    async installed(product) {
+        if (product === "outsrc")
+            return JSON.parse(readFileSync(PACKAGE_JSON, "utf8")).version;
+        return stdout(product, ["--version"]);
+    },
+    async latest(product) {
+        if (product === "grok") {
+            const body = JSON.parse(await stdout("grok", ["update", "--check", "--json"]));
+            if (typeof body.latestVersion !== "string")
+                throw new Error("grok update --check gave no latestVersion");
+            return body.latestVersion;
+        }
+        const name = NPM_PACKAGE[product];
+        if (!name)
+            throw new Error(`no registry package for ${product}`);
+        const response = await fetch(`https://registry.npmjs.org/${name.replace("/", "%2F")}/latest`, { signal: AbortSignal.timeout(TIMEOUT_MS) });
+        if (!response.ok)
+            throw new Error(`npm registry ${response.status} for ${name}`);
+        const body = (await response.json());
+        if (typeof body.version !== "string")
+            throw new Error(`npm registry gave no version for ${name}`);
+        return body.version;
+    },
+};

package/dist/usage.d.ts

@@ -0,0 +1,105 @@
+import { z } from "zod";
+import type { Adapter } from "./adapters.js";
+export declare const RunUsageSchema: z.ZodObject<{
+    tokens_in: z.ZodNullable<z.ZodNumber>;
+    tokens_out: z.ZodNullable<z.ZodNumber>;
+    estimated_cost_usd: z.ZodNullable<z.ZodNumber>;
+    wall_minutes: z.ZodNullable<z.ZodNumber>;
+    model: z.ZodNullable<z.ZodString>;
+    effort: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type RunUsage = z.infer<typeof RunUsageSchema>;
+export declare function emptyUsage(): RunUsage;
+export declare function readAdapterUsage(input: {
+    adapter: Adapter;
+    stdout: string;
+}): RunUsage;
+export type UsageSample = {
+    target: string;
+    created_at: string;
+    usage: RunUsage;
+};
+export declare function aggregateUsage(samples: UsageSample[], now?: Date): {
+    ok: boolean;
+    as_of: string;
+    today: {
+        runs: number;
+        tokens_in: {
+            total: number | null;
+            missing_runs: number;
+        };
+        tokens_out: {
+            total: number | null;
+            missing_runs: number;
+        };
+        estimated_cost_usd: {
+            total: number | null;
+            missing_runs: number;
+        };
+        wall_minutes: {
+            total: number | null;
+            missing_runs: number;
+        };
+        since: string;
+        by_target: {
+            runs: number;
+            tokens_in: {
+                total: number | null;
+                missing_runs: number;
+            };
+            tokens_out: {
+                total: number | null;
+                missing_runs: number;
+            };
+            estimated_cost_usd: {
+                total: number | null;
+                missing_runs: number;
+            };
+            wall_minutes: {
+                total: number | null;
+                missing_runs: number;
+            };
+            target: string;
+        }[];
+    };
+    last_7_days: {
+        runs: number;
+        tokens_in: {
+            total: number | null;
+            missing_runs: number;
+        };
+        tokens_out: {
+            total: number | null;
+            missing_runs: number;
+        };
+        estimated_cost_usd: {
+            total: number | null;
+            missing_runs: number;
+        };
+        wall_minutes: {
+            total: number | null;
+            missing_runs: number;
+        };
+        since: string;
+        by_target: {
+            runs: number;
+            tokens_in: {
+                total: number | null;
+                missing_runs: number;
+            };
+            tokens_out: {
+                total: number | null;
+                missing_runs: number;
+            };
+            estimated_cost_usd: {
+                total: number | null;
+                missing_runs: number;
+            };
+            wall_minutes: {
+                total: number | null;
+                missing_runs: number;
+            };
+            target: string;
+        }[];
+    };
+};

package/dist/usage.js

@@ -0,0 +1,106 @@
+import { z } from "zod";
+const Tokens = z.number().int().nonnegative();
+const Amount = z.number().nonnegative();
+export const RunUsageSchema = z.object({
+    tokens_in: Tokens.nullable(),
+    tokens_out: Tokens.nullable(),
+    estimated_cost_usd: Amount.nullable(),
+    wall_minutes: Amount.nullable(),
+    model: z.string().min(1).nullable(),
+    effort: z.string().nullable(),
+});
+export function emptyUsage() {
+    return { tokens_in: null, tokens_out: null, estimated_cost_usd: null, wall_minutes: null, model: null, effort: null };
+}
+const Metadata = z.object({
+    type: z.string().optional(),
+    usage: z.unknown().optional(),
+    total_cost_usd: z.unknown().optional(),
+    model: z.unknown().optional(),
+    modelUsage: z.unknown().optional(),
+});
+function metadata(raw) {
+    const parsed = Metadata.safeParse(raw);
+    if (!parsed.success)
+        return emptyUsage();
+    const value = parsed.data;
+    const counters = z.object({ input_tokens: z.unknown().optional(), output_tokens: z.unknown().optional() }).safeParse(value.usage).data;
+    const models = Object.keys(z.record(z.string(), z.unknown()).safeParse(value.modelUsage).data ?? {});
+    return {
+        tokens_in: Tokens.safeParse(counters?.input_tokens).data ?? null,
+        tokens_out: Tokens.safeParse(counters?.output_tokens).data ?? null,
+        estimated_cost_usd: Amount.safeParse(value.total_cost_usd).data ?? null,
+        wall_minutes: null,
+        model: z.string().min(1).safeParse(value.model).data ??
+            z.string().min(1).safeParse(models.length === 1 ? models[0] : undefined).data ?? null,
+        effort: null,
+    };
+}
+export function readAdapterUsage(input) {
+    try {
+        if (input.adapter === "custom" || input.adapter === "codex-plugin")
+            return emptyUsage();
+        if (input.adapter === "codex") {
+            const events = input.stdout.split("\n").flatMap((line) => {
+                try {
+                    return [JSON.parse(line)];
+                }
+                catch {
+                    return [];
+                }
+            });
+            const completed = events.filter((event) => Metadata.safeParse(event).data?.type === "turn.completed");
+            if (completed.length === 0)
+                return emptyUsage();
+            const usage = completed.map(metadata);
+            const sum = (key) => usage.every((item) => item[key] !== null)
+                ? usage.reduce((total, item) => total + (item[key] ?? 0), 0) : null;
+            return { ...emptyUsage(), tokens_in: sum("tokens_in"), tokens_out: sum("tokens_out") };
+        }
+        const raw = JSON.parse(input.stdout);
+        if (input.adapter === "grok-plugin") {
+            const payload = z.object({ result: z.unknown().optional(), grok: z.object({ stdout: z.string().optional() }).optional() }).parse(raw);
+            const primary = metadata(payload.result);
+            let fallback = emptyUsage();
+            try {
+                if (payload.grok?.stdout)
+                    fallback = metadata(JSON.parse(payload.grok.stdout));
+            }
+            catch { }
+            return { ...primary, tokens_in: primary.tokens_in ?? fallback.tokens_in, tokens_out: primary.tokens_out ?? fallback.tokens_out,
+                estimated_cost_usd: primary.estimated_cost_usd ?? fallback.estimated_cost_usd, model: primary.model ?? fallback.model };
+        }
+        const messages = z.array(z.unknown()).safeParse(raw);
+        return metadata(messages.success ? messages.data.findLast((item) => Metadata.safeParse(item).data?.type === "result") : raw);
+    }
+    catch {
+        return emptyUsage();
+    }
+}
+function totals(samples) {
+    function metric(key) {
+        const missing = samples.filter((sample) => sample.usage[key] === null).length;
+        return { total: missing === 0 ? samples.reduce((sum, sample) => sum + (sample.usage[key] ?? 0), 0) : null, missing_runs: missing };
+    }
+    return { runs: samples.length, tokens_in: metric("tokens_in"), tokens_out: metric("tokens_out"),
+        estimated_cost_usd: metric("estimated_cost_usd"), wall_minutes: metric("wall_minutes") };
+}
+export function aggregateUsage(samples, now = new Date()) {
+    const today = new Date(now);
+    today.setHours(0, 0, 0, 0);
+    const start7d = now.getTime() - 7 * 86400_000;
+    function window(start) {
+        const selected = samples.filter((sample) => {
+            const time = Date.parse(sample.created_at);
+            if (!Number.isFinite(time))
+                throw new Error("Invalid run created_at in usage records");
+            return time >= start && time <= now.getTime();
+        });
+        const targets = [...new Set(selected.map((sample) => sample.target))].sort();
+        return {
+            since: new Date(start).toISOString(), ...totals(selected),
+            by_target: targets.map((target) => ({ target, ...totals(selected.filter((sample) => sample.target === target)) })),
+        };
+    }
+    return { ok: true, as_of: now.toISOString(), today: window(today.getTime()), last_7_days: window(start7d) };
+}

package/dist/version.d.ts

@@ -0,0 +1,13 @@
+export type Version = {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease: string[];
+    text: string;
+};
+/** First x.y.z[-pre] in the text, or null. */
+export declare function parseVersion(text: string): Version | null;
+/** Negative when a is older than b, zero when equal, positive when newer. */
+export declare function compareVersions(a: Version, b: Version): number;
+/** True when both parse and latest is newer than installed. */
+export declare function isBehind(installed: string, latest: string): boolean;

package/dist/version.js

@@ -0,0 +1,45 @@
+// Semver-shaped versions as the CLIs print them: "2.1.285 (Claude Code)", "codex-cli 0.159.2", "grok 1.0.44 (abc) [stable]".
+const VERSION = /(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/;
+/** First x.y.z[-pre] in the text, or null. */
+export function parseVersion(text) {
+    const match = VERSION.exec(text);
+    if (!match)
+        return null;
+    const [whole, major, minor, patch, pre] = match;
+    return { major: Number(major), minor: Number(minor), patch: Number(patch), prerelease: pre ? pre.split(".") : [], text: whole };
+}
+function comparePrerelease(a, b) {
+    // A release sorts above any of its prereleases.
+    if (a.length === 0 || b.length === 0)
+        return b.length - a.length;
+    for (let i = 0; i < Math.max(a.length, b.length); i += 1) {
+        const x = a[i];
+        const y = b[i];
+        if (x === undefined)
+            return -1;
+        if (y === undefined)
+            return 1;
+        if (x === y)
+            continue;
+        const nx = /^\d+$/.test(x) ? Number(x) : null;
+        const ny = /^\d+$/.test(y) ? Number(y) : null;
+        if (nx !== null && ny !== null)
+            return nx - ny;
+        if (nx !== null)
+            return -1;
+        if (ny !== null)
+            return 1;
+        return x < y ? -1 : 1;
+    }
+    return 0;
+}
+/** Negative when a is older than b, zero when equal, positive when newer. */
+export function compareVersions(a, b) {
+    return a.major - b.major || a.minor - b.minor || a.patch - b.patch || comparePrerelease(a.prerelease, b.prerelease);
+}
+/** True when both parse and latest is newer than installed. */
+export function isBehind(installed, latest) {
+    const a = parseVersion(installed);
+    const b = parseVersion(latest);
+    return a !== null && b !== null && compareVersions(a, b) < 0;
+}

package/dist/wrapper.js

@@ -12,6 +12,7 @@ import { engineDir, isPluginAdapter, teardownInvocation } from "./plugins.js";
 import { writeJson } from "./state.js";
 import { parseThreadId } from "./types.js";
 import { collectWorkspaceDiff, commitWorkspace } from "./workspace.js";
+import { emptyUsage, readAdapterUsage } from "./usage.js";
 const RunSpecSchema = z.object({
     threadId: z.string().transform(parseThreadId),
     runId: z.string(),
@@ -38,7 +39,7 @@ function failure(message, sessionId) {
     return { kind: "failed", message, sessionId, findings: [] };
 }
 function execute(input) {
-    return new Promise((resolveResult, reject) => {
+    return new Promise((resolveResult) => {
         const child = spawn(input.command, input.args, {
             cwd: input.cwd,
             env: { ...process.env, ...input.env },
@@ -78,10 +79,8 @@ function execute(input) {
                 return;
             settled = true;
             clearTimeout(timer);
-            if (error !== undefined)
-                reject(error);
-            else
-                resolveResult({ stdout: Buffer.concat(stdout).toString("utf8"), exitCode });
+            const output = { stdout: Buffer.concat(stdout).toString("utf8"), exitCode };
+            resolveResult(error === undefined ? { ...output, kind: "exited" } : { ...output, kind: "failed", error });
         }
         const timer = input.deadlineMs === null ? undefined : setTimeout(() => {
             timedOut = true;
@@ -94,11 +93,17 @@ function execute(input) {
         child.stdout.on("data", (chunk) => {
             stdout.push(chunk);
             append(chunk);
+            try {
+                input.onStdout?.(Buffer.concat(stdout).toString("utf8"));
+            }
+            catch (error) {
+                logError = error;
+            }
         });
         child.stderr.on("data", append);
         child.once("close", (exitCode) => {
             if (timedOut)
-                finish(new Error(`Run exceeded the ${input.deadlineMs}ms deadline`), null);
+                finish(new Error(`Run exceeded the ${input.deadlineMs}ms deadline`), exitCode);
             else if (logError !== undefined)
                 finish(logError, null);
             else
@@ -107,6 +112,8 @@ function execute(input) {
     });
 }
 export async function run(spec) {
+    const startedAt = performance.now();
+    let usage = emptyUsage();
     let output = failure("Agent did not run", spec.sessionId);
     let exitCode = null;
     let commit = null;
@@ -124,10 +131,13 @@ export async function run(spec) {
         return left;
     }
     function publish(result) {
+        const recorded = { ...result,
+            ...(existsSync(join(spec.runDir, "cancelled")) ? { kind: "cancelled", message: "Task cancelled" } : {}),
+            usage: { ...usage, wall_minutes: (performance.now() - startedAt) / 60_000 } };
         const temporary = join(spec.runDir, "result.json.tmp");
-        writeHomeFile(temporary, JSON.stringify(result));
+        writeHomeFile(temporary, JSON.stringify(recorded));
         renameSync(temporary, join(spec.runDir, "result.json"));
-        return result;
+        return recorded;
     }
     mkdirSync(spec.runDir, { recursive: true, mode: 0o700 });
     try {
@@ -150,6 +160,8 @@ export async function run(spec) {
             if (!executable)
                 throw new Error("command is empty");
             const setup = await execute({ command: executable, args, cwd: spec.worktree, logPath, deadlineMs: timeLeft() });
+            if (setup.kind === "failed")
+                throw setup.error;
             if (setup.exitCode !== 0) {
                 exitCode = setup.exitCode;
                 throw new Error(`exited with ${setup.exitCode ?? "a signal"}`);
@@ -171,9 +183,41 @@ export async function run(spec) {
             dataDir,
             threadId: spec.threadId,
         });
+        const ignoresEffort = (spec.target.adapter === "codex-plugin" && spec.kind !== "task" && spec.base !== null) ||
+            (spec.target.adapter === "custom" && !spec.target.args.some((arg) => arg.includes("{effort}")));
+        usage.effort = ignoresEffort ? null : spec.effort;
+        const ignoresModel = (spec.target.adapter === "codex-plugin" && spec.kind !== "task" && spec.base !== null) ||
+            (spec.target.adapter === "custom" && !spec.target.args.some((arg) => arg.includes("{model}")));
+        usage.model = ignoresModel ? null : spec.model;
+        let savedUsage = JSON.stringify(usage);
+        function captureUsage(stdout) {
+            if (spec.target.adapter !== "codex") {
+                try {
+                    JSON.parse(stdout);
+                }
+                catch {
+                    return;
+                }
+            }
+            const reported = readAdapterUsage({ adapter: spec.target.adapter, stdout });
+            usage = { ...reported, model: reported.model ?? usage.model, effort: usage.effort };
+            const serialized = JSON.stringify(usage);
+            if (serialized === savedUsage)
+                return;
+            writeJson(join(spec.runDir, "usage.json"), usage);
+            savedUsage = serialized;
+        }
+        writeJson(join(spec.runDir, "usage.json"), usage);
         let executed;
         try {
-            executed = await execute({ ...invocation, cwd: spec.worktree, logPath, deadlineMs: timeLeft() });
+            const supportsUsage = spec.target.adapter !== "custom" && spec.target.adapter !== "codex-plugin";
+            executed = await execute({ ...invocation, cwd: spec.worktree, logPath, deadlineMs: timeLeft(),
+                ...(supportsUsage ? { onStdout: captureUsage } : {}) });
+            exitCode = executed.exitCode;
+            if (supportsUsage)
+                captureUsage(executed.stdout);
+            if (executed.kind === "failed")
+                throw executed.error;
         }
         finally {
             if (isPluginAdapter(spec.target.adapter)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "outsrc",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Local MCP mailbox that lets any agent hand coding tasks to Claude Code, Codex and Grok Build in git worktrees.",
   "homepage": "https://outsrc.ing",
   "keywords": [
@@ -37,15 +37,15 @@
     "node": "^22.12.0 || ^24.0.0 || >=26.0.0"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.25.1",
-    "smol-toml": "^1.4.2",
+    "@modelcontextprotocol/sdk": "^1.30.1",
+    "smol-toml": "^1.9.0",
     "zod": "^4.6.5"
   },
   "devDependencies": {
     "@types/node": "^22.15.0",
     "tsx": "^4.20.0",
     "typescript": "^7.0.2",
-    "vitest": "^5.0.1"
+    "vitest": "^5.0.2"
   },
   "license": "MIT",
   "repository": {