codiedev 0.9.25 → 0.9.28

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/commands/capture.d.ts

@@ -0,0 +1,14 @@
+import { type CodiedevConfig } from "../utils";
+import { apiRequest } from "./shared";
+export interface CaptureCommandDeps {
+    readConfig: () => CodiedevConfig | null;
+    writeConfig: (config: CodiedevConfig) => void;
+    apiRequest: typeof apiRequest;
+    log: (line: string) => void;
+    warn: (line: string) => void;
+    randomUUID: () => string;
+    hostname: () => string;
+    normalizePath: (value: string) => string;
+    configForRequest: (config: CodiedevConfig) => CodiedevConfig;
+}
+export declare function runCaptureCommand(args: string[], depsOverride?: Partial<CaptureCommandDeps>): Promise<void>;

package/dist/commands/capture.js

@@ -0,0 +1,148 @@
+"use strict";
+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.runCaptureCommand = runCaptureCommand;
+const crypto = __importStar(require("crypto"));
+const os = __importStar(require("os"));
+const captureExclusions_1 = require("../captureExclusions");
+const utils_1 = require("../utils");
+const shared_1 = require("./shared");
+const DEFAULT_DEPS = {
+    readConfig: utils_1.readConfig,
+    writeConfig: utils_1.writeConfig,
+    apiRequest: shared_1.apiRequest,
+    log: console.log,
+    warn: console.warn,
+    randomUUID: () => crypto.randomUUID(),
+    hostname: () => os.hostname(),
+    normalizePath: captureExclusions_1.normalizeCapturePath,
+    configForRequest: shared_1.applyConfigEnvOverrides,
+};
+function requireConnectedConfig(deps) {
+    const config = deps.readConfig();
+    if (!config) {
+        throw new Error("Not connected. Run `npx codiedev connect` first.");
+    }
+    return config;
+}
+function withDeviceIdentity(config, deps) {
+    return {
+        ...config,
+        deviceId: config.deviceId || deps.randomUUID(),
+        deviceName: config.deviceName || deps.hostname(),
+    };
+}
+async function syncExclusions(config, deps) {
+    try {
+        await deps.apiRequest("POST", "/api/cli/capture-exclusions", {
+            config: deps.configForRequest(config),
+            body: {
+                deviceId: config.deviceId,
+                deviceName: config.deviceName,
+                ignoredPaths: config.captureIgnoredPaths ?? [],
+            },
+        });
+        deps.log("Portal status synced.");
+    }
+    catch (error) {
+        deps.warn(`Privacy setting saved locally, but portal status did not sync: ${error.message}`);
+    }
+}
+function requirePath(args) {
+    const value = args.slice(1).join(" ").trim();
+    if (!value) {
+        throw new Error("Usage: codiedev ignore <path> | codiedev unignore <path>");
+    }
+    return value;
+}
+function reportCheck(rawPath, current, deps) {
+    const target = deps.normalizePath(rawPath);
+    const match = (0, captureExclusions_1.findMatchingCaptureExclusion)(target, current.captureIgnoredPaths);
+    if (match) {
+        deps.log(`IGNORED: ${target}`);
+        deps.log(`Matched exclusion: ${match}`);
+    }
+    else {
+        deps.log(`CAPTURED: ${target}`);
+        deps.log("No ignored-folder rule matches this path.");
+    }
+}
+async function runCaptureCommand(args, depsOverride = {}) {
+    const deps = { ...DEFAULT_DEPS, ...depsOverride };
+    const subcommand = args[0];
+    const current = requireConnectedConfig(deps);
+    if (subcommand === "ignore") {
+        const target = deps.normalizePath(requirePath(args));
+        const existing = (current.captureIgnoredPaths ?? []).map(deps.normalizePath);
+        const nextPaths = existing.includes(target) ? existing : [...existing, target];
+        const next = withDeviceIdentity({ ...current, captureIgnoredPaths: nextPaths }, deps);
+        deps.writeConfig(next);
+        deps.log(`Ignoring ${target} and all child folders.`);
+        await syncExclusions(next, deps);
+        return;
+    }
+    if (subcommand === "unignore") {
+        const target = deps.normalizePath(requirePath(args));
+        const existing = (current.captureIgnoredPaths ?? []).map(deps.normalizePath);
+        const next = withDeviceIdentity({ ...current, captureIgnoredPaths: existing.filter((value) => value !== target) }, deps);
+        deps.writeConfig(next);
+        deps.log(`No longer ignoring ${target}.`);
+        await syncExclusions(next, deps);
+        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);
+            return;
+        }
+        const paths = current.captureIgnoredPaths ?? [];
+        if (paths.length === 0) {
+            deps.log("No ignored folders configured on this device.");
+            return;
+        }
+        deps.log("Ignored folders:");
+        for (const value of paths)
+            deps.log(`  ${value}`);
+        return;
+    }
+    // Back-compat: the earlier `codiedev capture check <path>` form.
+    if (subcommand === "check") {
+        reportCheck(requirePath(args), current, deps);
+        return;
+    }
+    throw new Error(`Unknown command: ${subcommand ?? "(missing)"}. Use ignore, unignore, or ignored.`);
+}

package/dist/configDir.d.ts

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

package/dist/configDir.js

@@ -0,0 +1,54 @@
+"use strict";
+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.codiedevStateDir = codiedevStateDir;
+// Single source of truth for where the CLI's config/state lives on disk.
+//
+// Defaults to ~/.codiedev. The desktop app sets CODIEDEV_CONFIG_DIR to
+// ~/.codiedev-desktop so a desktop session never touches the user's real
+// prod config — env-based (not a flag) so detached capture-finish/upload
+// children inherit the override automatically.
+//
+// Deliberately dependency-free (only node:path/os) so it can be imported
+// by both utils.ts and modules utils.ts itself imports (e.g. captureLog.ts)
+// without creating a circular import.
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const CONFIG_DIR = process.env.CODIEDEV_CONFIG_DIR?.trim()
+    ? path.resolve(process.env.CODIEDEV_CONFIG_DIR.trim())
+    : path.join(os.homedir(), ".codiedev");
+function codiedevStateDir() {
+    return CONFIG_DIR;
+}

package/dist/connect.js

@@ -37,6 +37,8 @@ exports.runConnect = runConnect;
 const readline = __importStar(require("readline"));
 const https = __importStar(require("https"));
 const http = __importStar(require("http"));
+const crypto = __importStar(require("crypto"));
+const os = __importStar(require("os"));
 const utils_1 = require("./utils");
 const connectFlow_1 = require("./connectFlow");
 const version_1 = require("./version");
@@ -210,6 +212,9 @@ async function runConnect(args = []) {
         repos,
         lastSynced: new Date().toISOString(),
         backendUrl: BACKEND_URL,
+        deviceId: saved?.deviceId || crypto.randomUUID(),
+        deviceName: saved?.deviceName || os.hostname(),
+        captureIgnoredPaths: saved?.captureIgnoredPaths ?? [],
     };
     try {
         (0, utils_1.writeConfig)(config);
@@ -223,6 +228,20 @@ async function runConnect(args = []) {
     // a timeline when a customer says "it connected but it doesn't work."
     // Fire-and-forget — never blocks the connect flow.
     (0, shared_1.recordInstallEvent)(config, { step: "started", ok: true });
+    // One-way device status sync. Local config remains authoritative: a network
+    // failure here never removes or weakens an ignored path. This also registers
+    // a freshly connected device with an empty list so the portal can distinguish
+    // "connected, no exclusions" from "old CLI has never reported status".
+    try {
+        await postJson(`${BACKEND_URL}/api/cli/capture-exclusions`, {
+            deviceId: config.deviceId,
+            deviceName: config.deviceName,
+            ignoredPaths: config.captureIgnoredPaths,
+        }, { Authorization: `Bearer ${token}` });
+    }
+    catch (err) {
+        console.warn(`Warning: Local capture settings are active, but portal status did not sync — ${err.message}`);
+    }
     // Migration: strip MCP server entries written by pre-CLI-only versions
     // of `codiedev connect`. These pointed at `npx codiedev-mcp`, a binary
     // that was removed in 0.3.4 and that 0.7.11+ no longer ships. Without
@@ -251,9 +270,11 @@ async function runConnect(args = []) {
     const hasClaude = (0, utils_1.claudeCodeInstalled)();
     const hasCodex = (0, utils_1.codexInstalled)();
     const hasCursor = (0, utils_1.cursorInstalled)();
+    const hasOpenCode = (0, utils_1.openCodeInstalled)();
     (0, shared_1.recordInstallEvent)(config, { step: "detect", target: "claude-code", ok: hasClaude });
     (0, shared_1.recordInstallEvent)(config, { step: "detect", target: "codex", ok: hasCodex });
     (0, shared_1.recordInstallEvent)(config, { step: "detect", target: "cursor", ok: hasCursor });
+    (0, shared_1.recordInstallEvent)(config, { step: "detect", target: "opencode", ok: hasOpenCode });
     const installed = [];
     // Machine-readable target keys reported back to the backend via
     // /api/cli/markInstalled so the portal's "Connected" state reflects
@@ -292,6 +313,10 @@ async function runConnect(args = []) {
         runInstall("cursor-hook", utils_1.installCursorHook, "Cursor sessionEnd (capture + auto-backup) hooks (~/.cursor/hooks.json)", "cursor-hook");
         runInstall("cursor-instructions", utils_1.installCursorInstructions, "Cursor agent instructions (~/.cursor/rules/codiedev.mdc)", "cursor-instructions");
     }
+    // Always stage the adapter. It is dormant until OpenCode starts, which lets
+    // a user connect Claude Code today and install the Codie harness tomorrow
+    // without needing a second setup ritual.
+    runInstall("opencode-capture-adapter", utils_1.installOpenCodeCapturePlugin, "OpenCode session capture adapter (~/.config/opencode/plugins/codiedev.js)", "opencode-capture");
     // Tell the backend which targets we wired up so the portal's onboarding
     // card flips to "Connected" only when something actually installed —
     // not on bare token validation. Best-effort: a network failure here
@@ -314,8 +339,8 @@ async function runConnect(args = []) {
             });
         }
     }
-    if (!hasClaude && !hasCodex && !hasCursor) {
-        console.warn("\nNo Claude Code, Codex, or Cursor install detected.");
+    if (!hasClaude && !hasCodex && !hasCursor && !hasOpenCode) {
+        console.warn("\nNo existing AI client detected; the Codie/OpenCode adapter is ready for a later install.");
         console.warn("If you just installed Claude Code, launch it once (so ~/.claude is created),");
         console.warn("then re-run `npx codiedev connect` to wire up the capture hook.");
     }