codiedev 0.9.25 → 0.9.28

package/dist/codie.js

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+"use strict";
+// `codie` — Codiedev's governed coding harness.
+//
+// Ships from the same package as `codiedev` so a developer runs one install and
+// then picks their surface: Claude Code, Codex, and Cursor get session capture
+// via `codiedev connect`; `codie` launches the governed harness against the
+// same token. OpenCode is the embedded engine; all user-facing identity,
+// credentials, models, policy, and capture belong to Codiedev.
+//
+// The engine is downloaded on first run (see codieRuntime.ts) so capture-only
+// users never pay for it.
+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 });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const url_1 = require("url");
+const configDir_1 = require("./configDir");
+const codieLauncher_1 = require("./codieLauncher");
+const codieRuntime_1 = require("./codieRuntime");
+const codieRuntimeInstall_1 = require("./codieRuntimeInstall");
+function git(args) {
+    const result = (0, child_process_1.spawnSync)("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    return result.status === 0 ? result.stdout.trim() : "";
+}
+function safeRepoUrl(value) {
+    if (!value)
+        return "";
+    try {
+        const url = new URL(value);
+        url.username = "";
+        url.password = "";
+        return url.toString();
+    }
+    catch {
+        return value.replace(/^[^@\s]+@(?=[^:/\s]+[:/])/, "");
+    }
+}
+function existingInlineConfig() {
+    const raw = process.env.OPENCODE_CONFIG_CONTENT;
+    if (!raw)
+        return {};
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error("OPENCODE_CONFIG_CONTENT is not valid JSON");
+    }
+}
+// The one credential. `codiedev connect` wrote it; the gateway validates the
+// same userApiTokens row, so there is no second harness token to mint.
+function connectedCodiedevConfig() {
+    try {
+        return JSON.parse(fs.readFileSync(path.join((0, configDir_1.codiedevStateDir)(), "config.json"), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function assetPath(name) {
+    // dist/codie.js → ../assets/<name>; src/codie.ts → ../assets/<name>.
+    return path.join(__dirname, "..", "assets", name);
+}
+// Stage the home-screen branding plugin. TUI plugins only load from tui.json
+// in the OpenCode config dir, so the packaged file is copied next to the
+// capture plugin and referenced with a relative spec. Best-effort: any
+// failure (e.g. a hand-edited tui.json with comments) leaves the stock logo.
+function installBrandPlugin() {
+    try {
+        // OpenCode resolves its config dir per the XDG spec, so a customized
+        // XDG_CONFIG_HOME must be honored or tui.json lands where it never reads.
+        const configDir = path.join(process.env.XDG_CONFIG_HOME?.trim() || path.join(os.homedir(), ".config"), "opencode");
+        const pluginDir = path.join(configDir, "plugins");
+        fs.mkdirSync(pluginDir, { recursive: true });
+        const source = fs.readFileSync(assetPath("tui-brand-plugin.tsx"), "utf8");
+        const destination = path.join(pluginDir, "codiedev-brand.tsx");
+        if (!fs.existsSync(destination) || fs.readFileSync(destination, "utf8") !== source) {
+            fs.writeFileSync(destination, source);
+        }
+        const tuiConfigPath = path.join(configDir, "tui.json");
+        const existing = fs.existsSync(tuiConfigPath) ? JSON.parse(fs.readFileSync(tuiConfigPath, "utf8")) : {};
+        const { config, changed } = (0, codieLauncher_1.withBrandPlugin)(existing);
+        if (changed)
+            fs.writeFileSync(tuiConfigPath, `${JSON.stringify(config, null, 2)}\n`);
+    }
+    catch (error) {
+        console.error(`codie: continuing without Codiedev branding (${error instanceof Error ? error.message : error})`);
+    }
+}
+// Remove the engine's boot/exit banner wordmark in place (see
+// patchBrandWordmark). Best-effort like the TUI plugin: any failure rolls the
+// bytes back and the stock banner keeps working. Runs once per install; an
+// already-suppressed binary has no known source region and is skipped.
+function installBrandWordmark(runtime) {
+    try {
+        installBrandWordmarkUnsafe(runtime);
+    }
+    catch (error) {
+        console.error(`codie: continuing with the stock banner (${error instanceof Error ? error.message : error})`);
+    }
+}
+function installBrandWordmarkUnsafe(runtime) {
+    const binary = fs.readFileSync(runtime);
+    const { changed, offset, replacement } = (0, codieLauncher_1.patchBrandWordmark)(binary);
+    if (!changed || !replacement)
+        return;
+    // In-place write (not copy+rename): opencode-ai/bin/opencode.exe and the
+    // platform package's binary are hardlinks to one inode, and this keeps them
+    // consistent. Restoring the original bytes is a true rollback — identical
+    // content revalidates the existing macOS signature.
+    const writeAt = (bytes) => {
+        const fd = fs.openSync(runtime, "r+");
+        try {
+            fs.writeSync(fd, bytes, 0, bytes.length, offset);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    };
+    const restore = () => writeAt(binary.subarray(offset, offset + replacement.length));
+    writeAt(replacement);
+    if (process.platform === "darwin") {
+        // A modified Mach-O needs a fresh ad-hoc signature or the OS kills it.
+        const signed = (0, child_process_1.spawnSync)("codesign", ["--force", "--sign", "-", runtime], { stdio: "ignore" });
+        if (signed.status !== 0) {
+            restore();
+            return;
+        }
+    }
+    const probe = (0, child_process_1.spawnSync)(runtime, ["--version"], { stdio: "ignore", timeout: 30000 });
+    if (probe.status !== 0) {
+        restore();
+        if (process.platform === "darwin")
+            (0, child_process_1.spawnSync)("codesign", ["--force", "--sign", "-", runtime], { stdio: "ignore" });
+    }
+}
+async function main() {
+    (0, codieRuntime_1.assertCodieNodeVersion)(process.versions.node);
+    const connected = connectedCodiedevConfig();
+    const key = process.env.CODIEDEV_GATEWAY_KEY ||
+        process.env.CODIEDEV_TOKEN ||
+        (typeof connected.token === "string" ? connected.token.trim() : "");
+    if (!key) {
+        throw new Error("Connect your Codiedev account first with `codiedev connect`");
+    }
+    const gatewayUrl = process.env.CODIEDEV_GATEWAY_URL || "https://gateway.codiedev.com/api/v1";
+    const catalog = await (0, codieLauncher_1.fetchApprovedCatalog)({ baseUrl: gatewayUrl, key });
+    const parsed = (0, codieLauncher_1.parseCodieArgs)(process.argv.slice(2));
+    if (parsed.args.length === 1 && parsed.args[0] === "models") {
+        console.log("Codiedev approved models\n");
+        catalog.forEach((model) => console.log(`  ${model.id.padEnd(38)} ${model.name || ""}`));
+        return;
+    }
+    (0, codieLauncher_1.validateCodieArgs)(parsed.args, catalog);
+    const stateDir = (0, configDir_1.codiedevStateDir)();
+    const runtime = (0, codieRuntimeInstall_1.ensureCodieRuntimeBinary)({
+        resolve: () => (0, codieRuntime_1.resolveCodieRuntime)({
+            env: process.env,
+            stateDir,
+            existsSync: (candidate) => fs.existsSync(candidate),
+            resolveBundled: () => {
+                try {
+                    return require.resolve("opencode-ai/bin/opencode.exe");
+                }
+                catch {
+                    return null;
+                }
+            },
+        }),
+        install: (missing) => (0, codieRuntimeInstall_1.installCodieRuntimeOnDisk)(missing, stateDir),
+    });
+    const metadataPlugin = (0, url_1.pathToFileURL)(assetPath("opencode-plugin.mjs")).href;
+    const capturePlugin = (0, codieLauncher_1.resolveCapturePlugin)({ homeDir: os.homedir(), existsSync: fs.existsSync });
+    installBrandPlugin();
+    installBrandWordmark(runtime);
+    const config = (0, codieLauncher_1.buildCodieConfig)({
+        existing: existingInlineConfig(),
+        catalog,
+        env: { ...process.env, ...parsed.overrides, CODIEDEV_GATEWAY_URL: gatewayUrl },
+        plugins: [capturePlugin, metadataPlugin],
+    });
+    const env = {
+        ...process.env,
+        ...parsed.overrides,
+        CODIEDEV_GATEWAY_KEY: key,
+        CODIEDEV_REPO_URL: safeRepoUrl(git(["remote", "get-url", "origin"])),
+        CODIEDEV_BRANCH: git(["branch", "--show-current"]),
+        CODIEDEV_HEAD_SHA: git(["rev-parse", "HEAD"]),
+        OPENCODE_CONFIG_CONTENT: JSON.stringify(config),
+    };
+    const result = (0, child_process_1.spawnSync)(runtime, parsed.args, { stdio: "inherit", env });
+    if (result.error)
+        throw result.error;
+    process.exitCode = result.status === null ? 1 : result.status;
+}
+main().catch((error) => {
+    console.error(`codie: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+});

package/dist/codieLauncher.d.ts

@@ -0,0 +1,41 @@
+export interface CatalogModel {
+    id: string;
+    name?: string;
+}
+export declare function bareModel(value: unknown): string;
+export declare function buildCodieConfig({ existing, catalog, env, plugin, plugins, }: {
+    existing?: Record<string, any>;
+    catalog: CatalogModel[];
+    env?: Record<string, string | undefined>;
+    plugin?: string;
+    plugins?: string[];
+}): Record<string, any>;
+export declare const BRAND_PLUGIN_SPEC = "./plugins/codiedev-brand.tsx";
+export declare function withBrandPlugin(existing: Record<string, any> | undefined): {
+    config: Record<string, any>;
+    changed: boolean;
+};
+export declare const STOCK_WORDMARK: string;
+export declare const LEGACY_CODIEDEV_WORDMARK: string;
+export declare const CODIEDEV_WORDMARK: string;
+export declare const HIDDEN_WORDMARK: string;
+export declare function patchBrandWordmark(binary: Buffer): {
+    changed: boolean;
+    offset: number;
+    stock: Buffer;
+    replacement: Buffer | null;
+};
+export declare function resolveCapturePlugin({ homeDir, existsSync, }: {
+    homeDir: string;
+    existsSync: (candidate: string) => boolean;
+}): string;
+export declare function fetchApprovedCatalog({ baseUrl, key, fetchImpl, }: {
+    baseUrl?: string;
+    key: string;
+    fetchImpl?: typeof fetch;
+}): Promise<CatalogModel[]>;
+export declare function parseCodieArgs(argv: string[]): {
+    args: string[];
+    overrides: Record<string, string>;
+};
+export declare function validateCodieArgs(args: string[], catalog: CatalogModel[]): void;

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;