codiedev 0.10.0-beta.3 → 0.10.0-beta.5

package/dist/codieRuntimeInstall.js

@@ -1,10 +1,4 @@
 "use strict";
-// First-run install of the OpenCode engine for the Codie harness.
-//
-// Staged then renamed: npm writes into a sibling staging directory and only an
-// install that actually produced the engine binary gets promoted to the real
-// runtime path. An interrupted or half-finished download therefore never
-// leaves a directory that resolveCodieRuntime() would report as "ready".
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -39,9 +33,15 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.IGNORE_SCRIPTS = void 0;
 exports.buildRuntimeInstallArgs = buildRuntimeInstallArgs;
 exports.installCodieRuntime = installCodieRuntime;
 exports.ensureCodieRuntimeBinary = ensureCodieRuntimeBinary;
+exports.linkFailure = linkFailure;
+exports.windowsCommand = windowsCommand;
+exports.isEngineOnDisk = isEngineOnDisk;
+exports.npmIgnoresScripts = npmIgnoresScripts;
+exports.linkEngineOnDisk = linkEngineOnDisk;
 exports.installCodieRuntimeOnDisk = installCodieRuntimeOnDisk;
 exports.defaultStagingRoot = defaultStagingRoot;
 const fs = __importStar(require("fs"));
@@ -50,8 +50,6 @@ const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const codieRuntime_1 = require("./codieRuntime");
 function buildRuntimeInstallArgs(stagingDir, spec) {
-    // No --registry / --proxy: inherit whatever npm config the developer's
-    // machine already has so an internal mirror keeps working.
     return [
         "install",
         "--prefix",
@@ -64,7 +62,7 @@ function buildRuntimeInstallArgs(stagingDir, spec) {
     ];
 }
 function installCodieRuntime(deps) {
-    const { runtime, makeStagingDir, run, exists, rename, remove, log } = deps;
+    const { runtime, makeStagingDir, run, exists, rename, remove, log, isEngine = () => true, linkEngine } = deps;
     const staging = makeStagingDir();
     log(`Installing the Codie engine (${runtime.spec}). This runs once, and only for \`codie\`.`);
     let result;
@@ -79,56 +77,141 @@ function installCodieRuntime(deps) {
         remove(staging);
         throw installFailure(result.stderr?.trim() || `npm exited with ${result.status}`);
     }
-    // Trust the artifact, not the exit code — a misconfigured mirror can succeed
-    // with nothing useful in the tarball.
     const stagedBinary = path.join(staging, "node_modules", "opencode-ai", "bin", "opencode.exe");
     if (!exists(stagedBinary)) {
         remove(staging);
         throw new Error(`The Codie engine install did not produce a runtime binary. ` +
             `Check that ${runtime.spec} is available from your npm registry.`);
     }
+    if (!isEngine(stagedBinary)) {
+        let linked = { ok: false };
+        try {
+            linked = linkEngine?.(path.dirname(path.dirname(stagedBinary))) ?? { ok: false };
+        }
+        catch (error) {
+            linked = { ok: false, detail: error instanceof Error ? error.message : String(error) };
+        }
+        if (!linked.ok || !isEngine(stagedBinary)) {
+            if (linked.detail === exports.IGNORE_SCRIPTS) {
+                try {
+                    rename(staging, runtime.installDir);
+                }
+                finally {
+                    remove(staging);
+                }
+            }
+            else {
+                remove(staging);
+            }
+            throw new Error(linkFailure(linked, path.join(runtime.installDir, "node_modules", "opencode-ai")));
+        }
+    }
     try {
         rename(staging, runtime.installDir);
     }
     finally {
-        // No-op after a successful promote (rmSync is force: true); after a failed
-        // one it keeps a ~132MB staging dir from being orphaned — mkdtemp mints a
-        // fresh sibling every attempt, so leaks would accumulate.
         remove(staging);
     }
 }
-// Resolve the engine, downloading it once if this is the first `codie` run.
-async function ensureCodieRuntimeBinary({ resolve, install, confirmUpdate = async () => false, }) {
+async function ensureCodieRuntimeBinary({ resolve, install, confirmUpdate = async () => false, repair, }) {
     const runtime = resolve();
     if (runtime.kind === "ready")
         return runtime.binary;
-    if (runtime.kind === "outdated" && !(await confirmUpdate(runtime)))
+    if (runtime.kind === "outdated" && !(await confirmUpdate(runtime))) {
+        if (runtime.linked !== false || !repair || !runtime.packageDir)
+            return runtime.binary;
+        if (repair({ kind: "unlinked", installDir: runtime.installDir, binary: runtime.binary, spec: runtime.spec, packageDir: runtime.packageDir })) {
+            return runtime.binary;
+        }
+        install(runtime);
         return runtime.binary;
+    }
+    if (runtime.kind === "unlinked" && repair?.(runtime)) {
+        const after = resolve();
+        if (after.kind === "ready")
+            return after.binary;
+    }
     install(runtime);
     return runtime.binary;
 }
+function linkFailure(linked, packageDir) {
+    if (linked.detail === exports.IGNORE_SCRIPTS) {
+        const script = packageDir ? `"${path.join(packageDir, "postinstall.mjs")}"` : "postinstall.mjs in the opencode-ai package";
+        return (`The Codie engine installed, but npm is set to ignore install scripts (ignore-scripts=true), ` +
+            `so codie won't run opencode-ai's setup step. Run \`node ${script}\` yourself, ` +
+            `or set CODIEDEV_OPENCODE_BINARY to an opencode binary.`);
+    }
+    return (`The Codie engine installed, but its setup step (opencode-ai's postinstall) failed, so there is no runnable engine` +
+        (linked.detail ? `: ${linked.detail}` : ".") +
+        ` Set CODIEDEV_OPENCODE_BINARY to an opencode binary to use a pre-provisioned engine.`);
+}
+exports.IGNORE_SCRIPTS = "ignore-scripts";
 function installFailure(detail) {
     return new Error(`Could not download the Codie engine: ${detail}\n` +
         `If you are behind a proxy or an internal registry, make sure npm can reach it. ` +
         `To use a pre-provisioned engine instead, set CODIEDEV_OPENCODE_BINARY to its path.`);
 }
-// ── Real-world wiring ───────────────────────────────────────────────────
-// Kept separate from the pure logic above so tests never shell out to npm.
+function windowsCommand(command, args) {
+    const quote = (a) => (/[\s"&|<>^()%!]/.test(a) ? `"${a.replace(/"/g, '""')}"` : a);
+    return [command, ...args.map(quote)].join(" ");
+}
+function isEngineOnDisk(candidate) {
+    try {
+        return (0, codieRuntime_1.isEngineSize)(fs.statSync(candidate).size);
+    }
+    catch {
+        return false;
+    }
+}
+function npmIgnoresScripts(env = process.env) {
+    const fromEnv = env.npm_config_ignore_scripts ?? env.NPM_CONFIG_IGNORE_SCRIPTS;
+    if (fromEnv !== undefined)
+        return !["", "false", "0", "null", "no"].includes(fromEnv.trim().toLowerCase());
+    const opts = { encoding: "utf8", timeout: 10_000, windowsHide: true };
+    const result = process.platform === "win32"
+        ? (0, child_process_1.spawnSync)("npm.cmd config get ignore-scripts", { ...opts, shell: true })
+        : (0, child_process_1.spawnSync)("npm", ["config", "get", "ignore-scripts"], opts);
+    return result.status === 0 && (result.stdout || "").trim() === "true";
+}
+const LINK_TIMEOUT_MS = 120_000;
+function linkEngineOnDisk(packageDir, { ignoreScripts = npmIgnoresScripts } = {}) {
+    const script = path.join(packageDir, "postinstall.mjs");
+    if (!fs.existsSync(script))
+        return { ok: false, detail: "opencode-ai has no postinstall.mjs" };
+    if (ignoreScripts())
+        return { ok: false, detail: exports.IGNORE_SCRIPTS };
+    const result = (0, child_process_1.spawnSync)(process.execPath, [script], {
+        cwd: packageDir,
+        encoding: "utf8",
+        stdio: ["ignore", "ignore", "pipe"],
+        timeout: LINK_TIMEOUT_MS,
+        windowsHide: true,
+    });
+    if (result.error || result.signal) {
+        return { ok: false, detail: result.error ? result.error.message : `timed out after ${LINK_TIMEOUT_MS / 1000}s` };
+    }
+    if (result.status !== 0)
+        return { ok: false, detail: (result.stderr || "").trim().split("\n").slice(-3).join(" ") || `exit ${result.status}` };
+    return isEngineOnDisk(path.join(packageDir, "bin", "opencode.exe"))
+        ? { ok: true }
+        : { ok: false, detail: "postinstall ran but left no engine" };
+}
 function installCodieRuntimeOnDisk(runtime, stateDir) {
     installCodieRuntime({
         runtime,
         makeStagingDir: () => {
-            // Sibling of the final dir so the promote is a same-filesystem rename.
             fs.mkdirSync(path.dirname((0, codieRuntime_1.codieRuntimeDir)(stateDir)), { recursive: true });
             return fs.mkdtempSync(path.join(path.dirname((0, codieRuntime_1.codieRuntimeDir)(stateDir)), ".runtime-staging-"));
         },
         run: (args) => {
-            const npm = process.platform === "win32" ? "npm.cmd" : "npm";
-            const result = (0, child_process_1.spawnSync)(npm, args, {
+            const opts = {
                 encoding: "utf8",
                 stdio: ["ignore", "inherit", "pipe"],
                 env: { ...process.env, npm_config_yes: "true" },
-            });
+            };
+            const result = process.platform === "win32"
+                ? (0, child_process_1.spawnSync)(windowsCommand("npm.cmd", args), { ...opts, shell: true, windowsHide: true })
+                : (0, child_process_1.spawnSync)("npm", args, opts);
             if (result.error)
                 throw result.error;
             return { status: result.status, stderr: result.stderr || "" };
@@ -140,6 +223,8 @@ function installCodieRuntimeOnDisk(runtime, stateDir) {
         },
         remove: (target) => fs.rmSync(target, { recursive: true, force: true }),
         log: (message) => console.error(message),
+        isEngine: isEngineOnDisk,
+        linkEngine: linkEngineOnDisk,
     });
 }
 function defaultStagingRoot() {

package/dist/codieStartup.js

@@ -3,9 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.refreshCodieSecurityPolicy = refreshCodieSecurityPolicy;
 const securityFeature_1 = require("./securityFeature");
 const securityPolicy_1 = require("./securityPolicy");
-/** Refresh the endpoint policy before Codie hands the terminal to OpenCode.
- * Enforcement remains available offline because hooks keep using the last
- * verified company-scoped policy when this best-effort refresh cannot land. */
 async function refreshCodieSecurityPolicy(config, syncPolicy = securityPolicy_1.syncEndpointSecurityPolicy) {
     if (!(0, securityFeature_1.isAgentSecurityEnabled)(config))
         return { status: "disabled" };

package/dist/codieUsage.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatUsageLine = formatUsageLine;
+exports.usageTone = usageTone;
+exports.formatSessionCostLine = formatSessionCostLine;
+exports.fetchCodieUsage = fetchCodieUsage;
+const USAGE_TIMEOUT_MS = 4000;
+function cleanBaseUrl(value) {
+    return String(value || "https://gateway.codiedev.com/api/v1").replace(/\/+$/, "");
+}
+function money(value) {
+    return `$${value.toFixed(2)}`;
+}
+function budgetMoney(value) {
+    return Number.isInteger(value) ? `$${value}` : money(value);
+}
+function percent(spent, budget) {
+    if (!(budget > 0))
+        return null;
+    const share = (spent / budget) * 100;
+    if (share > 0 && share < 1)
+        return "<1%";
+    return `${Math.round(share)}%`;
+}
+function formatUsageLine(usage) {
+    if (!usage || !usage.enabled)
+        return "";
+    const { budget, inFlight } = usage;
+    const segments = [];
+    if (usage.user?.name)
+        segments.push(usage.user.name);
+    if (typeof budget.userBudgetUsd === "number") {
+        segments.push(`${money(budget.userSpentUsd)} / ${budgetMoney(budget.userBudgetUsd)}`);
+        const share = percent(budget.userSpentUsd, budget.userBudgetUsd);
+        if (share)
+            segments.push(share);
+        if (poolBindsFirst(budget) && typeof budget.companyBudgetUsd === "number"
+            && budget.companyBudgetUsd > 0
+            && budget.companySpentUsd / budget.companyBudgetUsd >= 0.75) {
+            const share = percent(budget.companySpentUsd, budget.companyBudgetUsd);
+            if (share)
+                segments.push(`team pool ${share}`);
+        }
+    }
+    else {
+        segments.push(money(budget.userSpentUsd));
+        if (typeof budget.companyBudgetUsd === "number") {
+            const share = percent(budget.companySpentUsd, budget.companyBudgetUsd);
+            if (share)
+                segments.push(`team ${share}`);
+        }
+    }
+    if (typeof budget.companyBudgetUsd === "number" && budget.companyBudgetUsd > 0
+        && budget.companySpentUsd >= budget.companyBudgetUsd) {
+        segments.push("team pool used up");
+    }
+    if (inFlight.requests > 0)
+        segments.push(`${inFlight.requests} in flight`);
+    if (inFlight.staleHeldUsd > 0)
+        segments.push(`${money(inFlight.staleHeldUsd)} held stale`);
+    return segments.join(" · ");
+}
+function poolBindsFirst(budget) {
+    if (typeof budget.companyBudgetUsd !== "number" || typeof budget.userBudgetUsd !== "number")
+        return false;
+    const poolLeft = Math.max(0, budget.companyBudgetUsd - budget.companySpentUsd);
+    const userLeft = Math.max(0, budget.userBudgetUsd - budget.userSpentUsd);
+    return budget.userBudgetUsd > 0 && poolLeft < userLeft;
+}
+function usageTone(usage) {
+    if (!usage || !usage.enabled)
+        return "normal";
+    const { budget } = usage;
+    const ratios = [];
+    if (typeof budget.userBudgetUsd === "number" && budget.userBudgetUsd > 0) {
+        ratios.push(budget.userSpentUsd / budget.userBudgetUsd);
+    }
+    if (typeof budget.companyBudgetUsd === "number" && budget.companyBudgetUsd > 0
+        && (typeof budget.userBudgetUsd !== "number" || poolBindsFirst(budget))) {
+        ratios.push(budget.companySpentUsd / budget.companyBudgetUsd);
+    }
+    const worst = ratios.length ? Math.max(...ratios) : 0;
+    if (worst >= 0.9)
+        return "critical";
+    if (worst >= 0.75)
+        return "warn";
+    return "normal";
+}
+function tokens(total) {
+    if (total >= 1_000_000)
+        return `${Math.round(total / 100_000) / 10}M`;
+    if (total >= 1_000)
+        return `${Math.round(total / 1_000)}k`;
+    return String(total);
+}
+function formatSessionCostLine(usage) {
+    const since = readSince(usage?.since);
+    if (!since || since.requests <= 0)
+        return "";
+    const cost = since.costUsd > 0 && since.costUsd < 0.005 ? "<$0.01" : money(since.costUsd);
+    const requests = `${since.requests} ${since.requests === 1 ? "request" : "requests"}`;
+    return `This session: ${cost} · ${requests} · ${tokens(since.promptTokens + since.completionTokens)} tokens`;
+}
+function readSince(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const { costUsd, promptTokens, completionTokens, requests } = value;
+    const finite = (candidate) => typeof candidate === "number" && Number.isFinite(candidate);
+    if (!finite(costUsd) || !finite(promptTokens) || !finite(completionTokens) || !finite(requests)) {
+        return undefined;
+    }
+    return { costUsd, promptTokens, completionTokens, requests };
+}
+function readNumber(value, fallback = 0) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function readBudgetCap(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function readUser(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const { name, email, role } = value;
+    if (typeof name !== "string" || !name)
+        return null;
+    return {
+        name,
+        email: typeof email === "string" ? email : "",
+        role: typeof role === "string" ? role : "",
+    };
+}
+async function fetchCodieUsage({ baseUrl, key, sinceMs, fetchImpl = fetch, }) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), USAGE_TIMEOUT_MS);
+    try {
+        const query = typeof sinceMs === "number" && sinceMs > 0 ? `?since=${sinceMs}` : "";
+        const response = await fetchImpl(`${cleanBaseUrl(baseUrl)}/me/usage${query}`, {
+            headers: { Authorization: `Bearer ${key}` },
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            return null;
+        const payload = (await response.json());
+        const budget = payload?.budget;
+        if (!budget || typeof budget !== "object")
+            return null;
+        const raw = budget;
+        const flight = (payload?.inFlight ?? {});
+        return {
+            enabled: payload?.enabled === true,
+            user: readUser(payload?.user),
+            budget: {
+                companyBudgetUsd: readBudgetCap(raw.companyBudgetUsd),
+                companySpentUsd: readNumber(raw.companySpentUsd),
+                companyHeldUsd: readNumber(raw.companyHeldUsd),
+                userBudgetUsd: readBudgetCap(raw.userBudgetUsd),
+                userSpentUsd: readNumber(raw.userSpentUsd),
+                userHeldUsd: readNumber(raw.userHeldUsd),
+                keyBudgetUsd: readBudgetCap(raw.keyBudgetUsd),
+                keySpentUsd: readNumber(raw.keySpentUsd),
+                keyHeldUsd: typeof raw.keyHeldUsd === "number" ? raw.keyHeldUsd : null,
+            },
+            inFlight: {
+                requests: readNumber(flight.requests),
+                heldUsd: readNumber(flight.heldUsd),
+                staleRequests: readNumber(flight.staleRequests),
+                staleHeldUsd: readNumber(flight.staleHeldUsd),
+            },
+            ...(() => {
+                const since = readSince(payload?.since);
+                return since ? { since } : {};
+            })(),
+        };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/commands/ask.js

@@ -3,9 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runAsk = runAsk;
 const shared_1 = require("./shared");
 function parseArgs(args) {
-    // Everything after the command, joined back into a question string. Allows
-    // both quoted and unquoted forms: `codiedev ask "why pg-bouncer?"` or
-    // `codiedev ask why did we drop pg-bouncer`.
     const question = args
         .filter((a) => !a.startsWith("--"))
         .join(" ")

package/dist/commands/capture.js

@@ -123,7 +123,6 @@ async function runCaptureCommand(args, depsOverride = {}) {
         return;
     }
     if (subcommand === "ignored") {
-        // `ignored` lists everything; `ignored <path>` answers "is this ignored?".
         const query = args.slice(1).join(" ").trim();
         if (query) {
             reportCheck(query, current, deps);
@@ -139,7 +138,6 @@ async function runCaptureCommand(args, depsOverride = {}) {
             deps.log(`  ${value}`);
         return;
     }
-    // Back-compat: the earlier `codiedev capture check <path>` form.
     if (subcommand === "check") {
         reportCheck(requirePath(args), current, deps);
         return;

package/dist/commands/createTicket.js

@@ -100,7 +100,6 @@ async function runCreateTicket(args) {
         await runBare(config, parsed.prompt);
         return;
     }
-    // submit mode
     if (!parsed.submitSource) {
         console.error("--submit requires a path or '-' for stdin");
         process.exit(1);
@@ -114,7 +113,6 @@ async function runCreateTicket(args) {
         console.error(`Failed to read plan: ${err.message}`);
         process.exit(1);
     }
-    // Translate fullNames → IDs before submitting
     let parsedPlan;
     try {
         parsedPlan = JSON.parse(raw);
@@ -141,14 +139,6 @@ async function runCreateTicket(args) {
     }
     await runSubmit(config, JSON.stringify(parsedPlan));
 }
-/**
- * Bare-mode entrypoint. Fetches the protocol body from the backend so we can
- * iterate on it without shipping a new CLI, substitutes the user's prompt,
- * and writes the result to stdout for the agent to follow. Hard-errors on
- * fetch failure rather than falling back to a stale local copy — the whole
- * point of moving the protocol server-side is that the freshest version is
- * the only version.
- */
 async function runBare(config, prompt) {
     let res;
     try {