codiedev 0.9.26 → 0.9.28

package/dist/codieLauncher.js

@@ -0,0 +1,352 @@
+"use strict";
+// Pure launcher logic for the Codie harness.
+//
+// Ported from codiedev-gateway-cli/npm/lib/launcher.js when the harness folded
+// into this package so `npm i -g codiedev` is the only install a developer
+// needs — Claude Code, Codex, Cursor, and Codie all come from one package and
+// share the one token `codiedev connect` stored.
+//
+// Everything here is pure (no fs/network side effects beyond an injected
+// fetch) so the governance rules can be tested without a live gateway.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HIDDEN_WORDMARK = exports.CODIEDEV_WORDMARK = exports.LEGACY_CODIEDEV_WORDMARK = exports.STOCK_WORDMARK = exports.BRAND_PLUGIN_SPEC = void 0;
+exports.bareModel = bareModel;
+exports.buildCodieConfig = buildCodieConfig;
+exports.withBrandPlugin = withBrandPlugin;
+exports.patchBrandWordmark = patchBrandWordmark;
+exports.resolveCapturePlugin = resolveCapturePlugin;
+exports.fetchApprovedCatalog = fetchApprovedCatalog;
+exports.parseCodieArgs = parseCodieArgs;
+exports.validateCodieArgs = validateCodieArgs;
+const path = __importStar(require("path"));
+const url_1 = require("url");
+const DEFAULT_NAMES = {
+    "openai/gpt-5.3-codex": "GPT-5.3 Codex",
+    "openai/gpt-5.2-codex": "GPT-5.2 Codex",
+    "openai/gpt-5.1-codex-mini": "GPT-5.1 Codex Mini",
+    "anthropic/claude-sonnet-4.6": "Claude Sonnet 4.6",
+    "z-ai/glm-5.2": "GLM 5.2 · Fireworks ZDR",
+    "moonshotai/kimi-k2.7-code": "Kimi K2.7 Code · Fireworks ZDR",
+};
+function cleanBaseUrl(value) {
+    return String(value || "https://gateway.codiedev.com/api/v1").replace(/\/+$/, "");
+}
+function bareModel(value) {
+    return String(value || "").trim().replace(/^codiedev\//, "");
+}
+function governedModel(value, approved, fallback, label) {
+    const model = bareModel(value || fallback);
+    if (!approved.has(model)) {
+        throw new Error(`${label} model is not approved for this Codiedev account: ${model || "(empty)"}`);
+    }
+    return `codiedev/${model}`;
+}
+function economicalModel(catalog, primary) {
+    // Catalog ids arrive already normalized through bareModel(), so the
+    // gateway's `codiedev/fast` alias appears here as plain "fast".
+    const preferred = ["openai/gpt-5.1-codex-mini", "fast", "z-ai/glm-5.2"];
+    return preferred.find((id) => catalog.some((model) => model.id === id)) || primary;
+}
+function normalizeAgentModels(agents, approved, fallback) {
+    const normalized = {};
+    for (const [name, definition] of Object.entries(agents || {})) {
+        const next = definition && typeof definition === "object" ? { ...definition } : definition;
+        if (next && typeof next === "object" && next.model) {
+            next.model = governedModel(next.model, approved, fallback, `Agent “${name}”`);
+        }
+        normalized[name] = next;
+    }
+    return normalized;
+}
+function buildCodieConfig({ existing = {}, catalog, env = {}, plugin, plugins = [], }) {
+    if (!Array.isArray(catalog) || catalog.length === 0) {
+        throw new Error("No company-approved models were returned by Codiedev");
+    }
+    const approved = new Set(catalog.map((model) => bareModel(model.id)).filter(Boolean));
+    const first = bareModel(catalog[0].id);
+    const requestedPrimary = env.CODIEDEV_PRIMARY_MODEL || env.CODIEDEV_MODEL || existing.model || first;
+    const primary = bareModel(requestedPrimary);
+    const fast = economicalModel(catalog, primary);
+    const requestedSubagent = env.CODIEDEV_SUBAGENT_MODEL || fast;
+    const requestedPlan = env.CODIEDEV_PLAN_MODEL || requestedSubagent;
+    const agents = normalizeAgentModels(existing.agent, approved, primary);
+    const subagentModel = governedModel(requestedSubagent, approved, fast, "Subagent");
+    const planModel = governedModel(requestedPlan, approved, fast, "Plan agent");
+    const existingPlugins = Array.isArray(existing.plugin) ? existing.plugin : [];
+    const requiredPlugins = [...plugins, plugin].filter(Boolean);
+    const models = Object.fromEntries(catalog.map((model) => [
+        bareModel(model.id),
+        { name: model.name || DEFAULT_NAMES[bareModel(model.id)] || bareModel(model.id) },
+    ]));
+    return {
+        ...existing,
+        model: governedModel(primary, approved, first, "Primary agent"),
+        enabled_providers: ["codiedev"],
+        share: "disabled",
+        provider: {
+            ...(existing.provider || {}),
+            codiedev: {
+                npm: "@ai-sdk/openai-compatible",
+                name: "Codiedev Models",
+                options: {
+                    baseURL: cleanBaseUrl(env.CODIEDEV_GATEWAY_URL),
+                    apiKey: "{env:CODIEDEV_GATEWAY_KEY}",
+                },
+                models,
+            },
+        },
+        agent: {
+            ...agents,
+            plan: { ...(agents.plan || {}), model: agents.plan?.model || planModel },
+            general: { ...(agents.general || {}), model: agents.general?.model || subagentModel },
+            explore: { ...(agents.explore || {}), model: agents.explore?.model || subagentModel },
+            scout: { ...(agents.scout || {}), model: agents.scout?.model || subagentModel },
+        },
+        plugin: [...existingPlugins.filter((item) => !requiredPlugins.includes(item)), ...requiredPlugins],
+    };
+}
+exports.BRAND_PLUGIN_SPEC = "./plugins/codiedev-brand.tsx";
+// Pure merge for ~/.config/opencode/tui.json: TUI plugins load from tui.json,
+// not the opencode.json we inject via OPENCODE_CONFIG_CONTENT.
+function withBrandPlugin(existing) {
+    const config = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
+    const plugins = Array.isArray(config.plugin) ? config.plugin : [];
+    const present = plugins.some((item) => (Array.isArray(item) ? item[0] : item) === exports.BRAND_PLUGIN_SPEC);
+    if (present)
+        return { config, changed: false };
+    return { config: { ...config, plugin: [...plugins, exports.BRAND_PLUGIN_SPEC] }, changed: true };
+}
+// ── Engine wordmark suppression ─────────────────────────────────────────
+// The OpenCode engine prints a block-letter "opencode" wordmark to terminal
+// scrollback around each session (the boot/exit banner). A four-row terminal
+// raster cannot reproduce the real Codiedev wordmark cleanly, so leave that
+// surface blank and keep the proper brand mark on the plugin-driven home
+// screen. The bundled JS table is replaced byte-for-byte so binary offsets do
+// not move.
+function escapeJsSource(row) {
+    let out = "";
+    for (const ch of row) {
+        const code = ch.codePointAt(0);
+        out += code > 127 ? `\\u${code.toString(16).padStart(4, "0")}` : ch;
+    }
+    return out;
+}
+function wordmarkRegion(left, right, { escapeUnicode = true } = {}) {
+    const rows = (list) => list.map((row) => `"${escapeUnicode ? escapeJsSource(row) : row}"`).join(",");
+    return `var vn={left:[${rows(left)}],right:[${rows(right)}]};`;
+}
+// o p e n | c o d e — must match the engine's bundle byte-for-byte.
+exports.STOCK_WORDMARK = wordmarkRegion([
+    "                   ",
+    "█▀▀█ █▀▀█ █▀▀█ █▀▀▄",
+    "█__█ █__█ █^^^ █__█",
+    "▀▀▀▀ █▀▀▀ ▀▀▀▀ ▀~~▀",
+], [
+    "             ▄     ",
+    "█▀▀▀ █▀▀█ █▀▀█ █▀▀█",
+    "█___ █__█ █__█ █^^^",
+    "▀▀▀▀ ▀▀▀▀ ▀▀▀▀ ▀▀▀▀",
+]);
+// c o d i | e d e v, rasterized from public/codiedevlogo.svg at eight vertical
+// pixels and packed into four terminal rows with half-block characters. This
+// preserves the real mark's round lowercase bowls, linked c/o, ascenders, and
+// compact v instead of approximating the letters with OpenCode's square font.
+// The engine inserts one column between left and right, so the blank source
+// column at the codi/edev boundary is intentionally omitted.
+const CODIE_LEFT = [
+    "                   ▄ ▄",
+    "  ▄▄█▄▄ ▄▄█▄▄  ▄████ █",
+    "  █   ▄██   █ █   ██ █",
+    "  ▀▀█▀▀ ▀▀█▀▀  ▀▀▀▀  ▀",
+];
+const CODIE_RIGHT = [
+    "          ▄              ",
+    "▄▄█▄▄ ▄▄█▄█  ▄██▄▄▄  ▄▄  ",
+    "██▀▀█ █   █ ██▄▀█ ▀█▄█   ",
+    "▀▀█▀▀ ▀▀▀▀▀  ▀▀▀▀  ▀▀    ",
+];
+// Migration source for the first hand-drawn banner shipped during development.
+// Recognizing it lets an existing install upgrade in place instead of keeping
+// the old square letterforms until OpenCode happens to reinstall its binary.
+const LEGACY_CODIE_LEFT = [
+    "             ▄  ▄  ",
+    "█▀▀▀ █▀▀█ █▀▀█  █  ",
+    "█___ █__█ █__█  █  ",
+    "▀▀▀▀ ▀▀▀▀ ▀▀▀▀  ▀  ",
+];
+const LEGACY_CODIE_RIGHT = [
+    "        ▄          ",
+    "█▀▀█ █▀▀█ █▀▀█ █__█",
+    "█^^^ █__█ █^^^ █__█",
+    "▀▀▀▀ ▀▀▀▀ ▀▀▀▀  ▀▀ ",
+];
+exports.LEGACY_CODIEDEV_WORDMARK = (() => {
+    const unpadded = wordmarkRegion(LEGACY_CODIE_LEFT, LEGACY_CODIE_RIGHT);
+    const deficit = Buffer.byteLength(exports.STOCK_WORDMARK) - Buffer.byteLength(unpadded);
+    const share = Math.floor(deficit / LEGACY_CODIE_RIGHT.length);
+    const extra = deficit % LEGACY_CODIE_RIGHT.length;
+    const padded = LEGACY_CODIE_RIGHT.map((row, index) => row + " ".repeat(share + (index < extra ? 1 : 0)));
+    return wordmarkRegion(LEGACY_CODIE_LEFT, padded);
+})();
+exports.CODIEDEV_WORDMARK = (() => {
+    // Raw Unicode is valid JavaScript and costs fewer source bytes than \uXXXX.
+    // Put the remaining byte padding outside the strings so it cannot widen the
+    // rendered banner or shift its centering.
+    const unpadded = wordmarkRegion(CODIE_LEFT, CODIE_RIGHT, { escapeUnicode: false });
+    const deficit = Buffer.byteLength(exports.STOCK_WORDMARK) - Buffer.byteLength(unpadded);
+    if (deficit < 0)
+        throw new Error("Codiedev wordmark is larger than the stock region");
+    const region = `${unpadded.slice(0, -1)}${" ".repeat(deficit)};`;
+    if (Buffer.byteLength(region) !== Buffer.byteLength(exports.STOCK_WORDMARK)) {
+        throw new Error("Codiedev wordmark does not match the stock region byte length");
+    }
+    return region;
+})();
+exports.HIDDEN_WORDMARK = (() => {
+    const unpadded = wordmarkRegion([], [], { escapeUnicode: false });
+    const deficit = Buffer.byteLength(exports.STOCK_WORDMARK) - Buffer.byteLength(unpadded);
+    if (deficit < 0)
+        throw new Error("Hidden wordmark is larger than the stock region");
+    const region = `${unpadded.slice(0, -1)}${" ".repeat(deficit)};`;
+    if (Buffer.byteLength(region) !== Buffer.byteLength(exports.STOCK_WORDMARK)) {
+        throw new Error("Hidden wordmark does not match the stock region byte length");
+    }
+    return region;
+})();
+// Pure: locate the stock or an earlier Codiedev wordmark in an engine binary.
+// Refuses to touch the file unless exactly one known region appears; an
+// already-hidden or reshaped upstream bundle is left alone.
+function patchBrandWordmark(binary) {
+    const stock = Buffer.from(exports.STOCK_WORDMARK);
+    const candidates = [stock, Buffer.from(exports.LEGACY_CODIEDEV_WORDMARK), Buffer.from(exports.CODIEDEV_WORDMARK)];
+    const matches = candidates.flatMap((candidate) => {
+        const offset = binary.indexOf(candidate);
+        if (offset === -1)
+            return [];
+        if (binary.indexOf(candidate, offset + 1) !== -1)
+            return [offset, offset];
+        return [offset];
+    });
+    if (matches.length !== 1) {
+        return { changed: false, offset: -1, stock, replacement: null };
+    }
+    return { changed: true, offset: matches[0], stock, replacement: Buffer.from(exports.HIDDEN_WORDMARK) };
+}
+function resolveCapturePlugin({ homeDir, existsSync, }) {
+    const capturePath = path.join(homeDir, ".config", "opencode", "plugins", "codiedev.js");
+    if (!existsSync(capturePath)) {
+        throw new Error("Codiedev session capture is not installed. Run `codiedev connect` first");
+    }
+    return (0, url_1.pathToFileURL)(capturePath).href;
+}
+async function fetchApprovedCatalog({ baseUrl, key, fetchImpl = fetch, }) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    try {
+        const response = await fetchImpl(`${cleanBaseUrl(baseUrl)}/models`, {
+            headers: { Authorization: `Bearer ${key}` },
+            signal: controller.signal,
+        });
+        // The `codie` bin ships to every connected machine, including companies
+        // whose gateway is still switched off. Those developers must get an
+        // answer, not an HTTP status.
+        if (response.status === 403) {
+            throw new Error("The Codie harness is not enabled for your company yet. Ask your Codiedev admin to turn it on — " +
+                "your session capture keeps working in the meantime.");
+        }
+        if (response.status === 401) {
+            throw new Error("Your Codiedev token was rejected. Run `codiedev connect` to relink this machine.");
+        }
+        if (!response.ok)
+            throw new Error(`model catalog returned ${response.status}`);
+        const payload = (await response.json());
+        if (!Array.isArray(payload?.data) || payload.data.length === 0) {
+            throw new Error("model catalog is empty");
+        }
+        return payload.data.map((model) => ({
+            id: bareModel(model.id),
+            name: typeof model.name === "string" && model.name ? model.name : DEFAULT_NAMES[bareModel(model.id)],
+        }));
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function parseCodieArgs(argv) {
+    const args = [];
+    const overrides = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const value = argv[index];
+        const next = argv[index + 1];
+        if (["--primary-model", "--subagent-model", "--plan-model"].includes(value)) {
+            if (!next)
+                throw new Error(`${value} requires a model`);
+            const envKey = value === "--primary-model"
+                ? "CODIEDEV_PRIMARY_MODEL"
+                : value === "--subagent-model"
+                    ? "CODIEDEV_SUBAGENT_MODEL"
+                    : "CODIEDEV_PLAN_MODEL";
+            overrides[envKey] = bareModel(next);
+            index += 1;
+            continue;
+        }
+        if ((value === "-m" || value === "--model") && next) {
+            args.push(value, `codiedev/${bareModel(next)}`);
+            index += 1;
+            continue;
+        }
+        if (value.startsWith("--model=")) {
+            args.push(`--model=codiedev/${bareModel(value.slice("--model=".length))}`);
+            continue;
+        }
+        args.push(value);
+    }
+    return { args, overrides };
+}
+function validateCodieArgs(args, catalog) {
+    const approved = new Set((catalog || []).map((model) => bareModel(model.id)).filter(Boolean));
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        const model = value === "-m" || value === "--model"
+            ? args[index + 1]
+            : value.startsWith("--model=")
+                ? value.slice("--model=".length)
+                : "";
+        if (model && !approved.has(bareModel(model))) {
+            throw new Error(`Requested model is not approved for this Codiedev account: ${bareModel(model)}`);
+        }
+    }
+}

package/dist/codieRuntime.d.ts

@@ -0,0 +1,19 @@
+export declare const OPENCODE_RUNTIME_SPEC = "opencode-ai@1.18.4";
+export declare const CODIE_MIN_NODE_MAJOR = 20;
+export type CodieRuntime = {
+    kind: "ready";
+    binary: string;
+} | {
+    kind: "missing";
+    installDir: string;
+    binary: string;
+    spec: string;
+};
+export declare function codieRuntimeDir(stateDir: string): string;
+export declare function resolveCodieRuntime({ env, stateDir, existsSync, resolveBundled, }: {
+    env: Record<string, string | undefined>;
+    stateDir: string;
+    existsSync: (candidate: string) => boolean;
+    resolveBundled: () => string | null;
+}): CodieRuntime;
+export declare function assertCodieNodeVersion(version: string): void;

package/dist/codieRuntime.js

@@ -0,0 +1,91 @@
+"use strict";
+// Where the Codie harness gets its engine.
+//
+// The engine (`opencode-ai`) is a ~132MB platform binary. It is deliberately
+// NOT a dependency of this package: the overwhelming majority of installs are
+// capture-only (Claude Code, Codex, Cursor) and must not pay for a harness
+// they never launch. So `npm i -g codiedev` stays small, and the first `codie`
+// run downloads the engine into the Codiedev state dir.
+//
+// Resolution is pure and injectable so the precedence can be tested without
+// touching the network or a real 132MB install.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CODIE_MIN_NODE_MAJOR = exports.OPENCODE_RUNTIME_SPEC = void 0;
+exports.codieRuntimeDir = codieRuntimeDir;
+exports.resolveCodieRuntime = resolveCodieRuntime;
+exports.assertCodieNodeVersion = assertCodieNodeVersion;
+const path = __importStar(require("path"));
+// Pinned exactly, not a range. patchBrandWordmark() only rewrites bundles it
+// recognizes byte-for-byte, so a floating version would silently regress the
+// terminal branding whenever OpenCode ships a new build.
+exports.OPENCODE_RUNTIME_SPEC = "opencode-ai@1.18.4";
+// The harness needs 20; capture does not. package.json `engines` stays >=18 so
+// `codiedev connect` still installs for Node 18 users — this floor is enforced
+// at `codie` launch instead.
+exports.CODIE_MIN_NODE_MAJOR = 20;
+function codieRuntimeDir(stateDir) {
+    return path.join(stateDir, "runtime");
+}
+function installedBinary(stateDir) {
+    return path.join(codieRuntimeDir(stateDir), "node_modules", "opencode-ai", "bin", "opencode.exe");
+}
+function resolveCodieRuntime({ env, stateDir, existsSync, resolveBundled, }) {
+    // 1. Explicit override — the air-gapped / pre-provisioned escape hatch.
+    const override = env.CODIEDEV_OPENCODE_BINARY?.trim();
+    if (override) {
+        if (!existsSync(override)) {
+            throw new Error(`CODIEDEV_OPENCODE_BINARY points at a missing file: ${override}`);
+        }
+        return { kind: "ready", binary: override };
+    }
+    // 2. A bundled engine, if this package was installed with one (dev checkout,
+    //    or a future vendored distribution).
+    const bundled = resolveBundled();
+    if (bundled)
+        return { kind: "ready", binary: bundled };
+    // 3. The lazily installed engine.
+    const binary = installedBinary(stateDir);
+    if (existsSync(binary))
+        return { kind: "ready", binary };
+    return { kind: "missing", installDir: codieRuntimeDir(stateDir), binary, spec: exports.OPENCODE_RUNTIME_SPEC };
+}
+function assertCodieNodeVersion(version) {
+    const major = Number.parseInt(String(version).split(".")[0], 10);
+    if (Number.isFinite(major) && major < exports.CODIE_MIN_NODE_MAJOR) {
+        throw new Error(`The Codie harness needs Node ${exports.CODIE_MIN_NODE_MAJOR} or newer (found ${version}). ` +
+            `Session capture still works on this version — only \`codie\` requires the upgrade.`);
+    }
+}

package/dist/codieRuntimeInstall.d.ts

@@ -0,0 +1,27 @@
+import { CodieRuntime } from "./codieRuntime";
+export declare function buildRuntimeInstallArgs(stagingDir: string, spec: string): string[];
+export interface InstallDeps {
+    runtime: Extract<CodieRuntime, {
+        kind: "missing";
+    }>;
+    makeStagingDir: () => string;
+    run: (args: string[]) => {
+        status: number | null;
+        stderr: string;
+    };
+    exists: (candidate: string) => boolean;
+    rename: (from: string, to: string) => void;
+    remove: (target: string) => void;
+    log: (message: string) => void;
+}
+export declare function installCodieRuntime(deps: InstallDeps): void;
+export declare function ensureCodieRuntimeBinary({ resolve, install, }: {
+    resolve: () => CodieRuntime;
+    install: (runtime: Extract<CodieRuntime, {
+        kind: "missing";
+    }>) => void;
+}): string;
+export declare function installCodieRuntimeOnDisk(runtime: Extract<CodieRuntime, {
+    kind: "missing";
+}>, stateDir: string): void;
+export declare function defaultStagingRoot(): string;

package/dist/codieRuntimeInstall.js

@@ -0,0 +1,145 @@
+"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);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRuntimeInstallArgs = buildRuntimeInstallArgs;
+exports.installCodieRuntime = installCodieRuntime;
+exports.ensureCodieRuntimeBinary = ensureCodieRuntimeBinary;
+exports.installCodieRuntimeOnDisk = installCodieRuntimeOnDisk;
+exports.defaultStagingRoot = defaultStagingRoot;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+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",
+        stagingDir,
+        "--no-audit",
+        "--no-fund",
+        "--omit=dev",
+        "--loglevel=error",
+        spec,
+    ];
+}
+function installCodieRuntime(deps) {
+    const { runtime, makeStagingDir, run, exists, rename, remove, log } = deps;
+    const staging = makeStagingDir();
+    log(`Installing the Codie engine (${runtime.spec}). This runs once, and only for \`codie\`.`);
+    let result;
+    try {
+        result = run(buildRuntimeInstallArgs(staging, runtime.spec));
+    }
+    catch (error) {
+        remove(staging);
+        throw installFailure(error instanceof Error ? error.message : String(error));
+    }
+    if (result.status !== 0) {
+        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.`);
+    }
+    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.
+function ensureCodieRuntimeBinary({ resolve, install, }) {
+    const runtime = resolve();
+    if (runtime.kind === "ready")
+        return runtime.binary;
+    install(runtime);
+    return runtime.binary;
+}
+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 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, {
+                encoding: "utf8",
+                stdio: ["ignore", "inherit", "pipe"],
+                env: { ...process.env, npm_config_yes: "true" },
+            });
+            if (result.error)
+                throw result.error;
+            return { status: result.status, stderr: result.stderr || "" };
+        },
+        exists: (candidate) => fs.existsSync(candidate),
+        rename: (from, to) => {
+            fs.rmSync(to, { recursive: true, force: true });
+            fs.renameSync(from, to);
+        },
+        remove: (target) => fs.rmSync(target, { recursive: true, force: true }),
+        log: (message) => console.error(message),
+    });
+}
+function defaultStagingRoot() {
+    return os.tmpdir();
+}

package/dist/configDir.d.ts

@@ -0,0 +1 @@
+export declare function codiedevStateDir(): string;