@wenrwa/marketplace-cli 0.8.1 → 0.8.2

package/dist/__tests__/bridge-opencode-binary.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/bridge-opencode-binary.test.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/** oc-25 — the bridge provides OpenCode (resolution order, shared install, failure text). */
+const opencodeBinary_1 = require("../bridge/opencodeBinary");
+const opencodeConfig_1 = require("../bridge/opencodeConfig");
+const BASE = '/h/.wen-market/opencode';
+const PREFIX = (0, opencodeBinary_1.managedPrefix)(BASE);
+const BIN = (0, opencodeBinary_1.managedBin)(PREFIX);
+const launch = { command: 'opencode', args: ['-s', 'ses_a'], env: { ...opencodeConfig_1.OPENCODE_QUIET_ENV, X: '1' } };
+function harness(over = {}) {
+    const files = new Map();
+    const npmCalls = [];
+    let release;
+    const gate = new Promise((r) => { release = r; });
+    const deps = {
+        exists: (p) => files.has(p),
+        writeFile: (p, c) => { files.set(p, c); },
+        mkdirp: () => { },
+        rm: (p) => { files.delete(p); },
+        runNpm: async (args, env) => {
+            npmCalls.push({ args, env });
+            await gate;
+            if ((over.npmCode ?? 0) === 0)
+                files.set(BIN, 'bin');
+            return { code: over.npmCode ?? 0, stderr: '' };
+        },
+        pathOpencode: () => null,
+        versionOf: () => opencodeConfig_1.OPENCODE_PINNED_VERSION,
+        env: { PATH: '/usr/bin', npm_config_offline: 'true' },
+        platform: 'darwin',
+        ...over,
+    };
+    return { files, npmCalls, release, deps };
+}
+describe('oc-25 — pinned version lives in one place', () => {
+    it('the minimum IS the pinned version', () => {
+        expect(opencodeConfig_1.OPENCODE_MIN_VERSION).toBe(opencodeConfig_1.OPENCODE_PINNED_VERSION);
+    });
+});
+describe('oc-25 — resolution order', () => {
+    it('1. managed pinned binary wins over a newer PATH one; absolute path, no install', () => {
+        const h = harness({ pathOpencode: () => ({ path: '/usr/local/bin/opencode', version: '9.9.9' }) });
+        h.files.set(BIN, 'x');
+        h.files.set(`${PREFIX}/.ready`, '1');
+        const r = (0, opencodeBinary_1.createOpencodeProvisioner)(BASE, h.deps).prepare(launch);
+        expect(r).toEqual({ ok: true, launch: { ...launch, command: BIN } });
+        expect(h.npmCalls).toHaveLength(0);
+    });
+    it('2. PATH opencode at/above the minimum is used by absolute path', () => {
+        const h = harness({ pathOpencode: () => ({ path: '/opt/bin/opencode', version: '1.20.0' }) });
+        const r = (0, opencodeBinary_1.createOpencodeProvisioner)(BASE, h.deps).prepare(launch);
+        expect(r).toEqual({ ok: true, launch: { ...launch, command: '/opt/bin/opencode' } });
+        expect(h.npmCalls).toHaveLength(0);
+    });
+    it('3. a PATH opencode below the minimum is ignored and the pinned one is installed', async () => {
+        const h = harness({ pathOpencode: () => ({ path: '/opt/bin/opencode', version: '1.2.0' }) });
+        const p = (0, opencodeBinary_1.createOpencodeProvisioner)(BASE, h.deps);
+        const r = p.prepare(launch);
+        expect(h.npmCalls).toHaveLength(1);
+        expect(r.ok && r.launch.command).toBe('/bin/sh');
+        h.release();
+        await p.settled();
+    });
+});
+describe('oc-25 — install', () => {
+    it('installs the pinned version into the bridge prefix with npm_config_offline scrubbed', async () => {
+        const h = harness();
+        const p = (0, opencodeBinary_1.createOpencodeProvisioner)(BASE, h.deps);
+        const r = p.prepare(launch);
+        expect(h.npmCalls[0].args).toEqual(['install', '--prefix', PREFIX, `opencode-ai@${opencodeConfig_1.OPENCODE_PINNED_VERSION}`, '--no-audit', '--no-fund']);
+        expect(h.npmCalls[0].env.npm_config_offline).toBeUndefined();
+        expect(h.npmCalls[0].env.PATH).toBe('/usr/bin');
+        // the pane runs a waiter that execs the ABSOLUTE managed binary with the original args
+        expect(r.ok && r.launch.args).toEqual(['-c', opencodeBinary_1.OPENCODE_WAIT_SCRIPT, 'opencode-wait', `${PREFIX}/.ready`, `${PREFIX}/.install-failed`, BIN, '-s', 'ses_a']);
+        expect(r.ok && r.launch.env).toEqual(launch.env);
+        expect(h.files.has(`${PREFIX}/.ready`)).toBe(false);
+        h.release();
+        await p.settled();
+        expect(h.files.has(`${PREFIX}/.ready`)).toBe(true);
+        // and the next open uses it directly
+        expect(p.prepare(launch)).toEqual({ ok: true, launch: { ...launch, command: BIN } });
+        expect(h.npmCalls).toHaveLength(1);
+    });
+    it('two panes opening at once share ONE install', async () => {
+        const h = harness();
+        const p = (0, opencodeBinary_1.createOpencodeProvisioner)(BASE, h.deps);
+        p.prepare(launch);
+        p.prepare(launch);
+        expect(h.npmCalls).toHaveLength(1);
+        h.release();
+        await p.settled();
+    });
+    it('failure writes a short wrapped message with the manual command, no ready marker; a later open retries', async () => {
+        const h = harness({ npmCode: 1 });
+        const p = (0, opencodeBinary_1.createOpencodeProvisioner)(BASE, h.deps);
+        p.prepare(launch);
+        h.release();
+        await p.settled();
+        const msg = h.files.get(`${PREFIX}/.install-failed`);
+        expect(msg).toContain(`npm i -g opencode-ai@${opencodeConfig_1.OPENCODE_PINNED_VERSION}`);
+        for (const line of msg.split('\n'))
+            expect(line.length).toBeLessThanOrEqual(40);
+        expect(h.files.has(`${PREFIX}/.ready`)).toBe(false);
+        p.prepare(launch);
+        expect(h.npmCalls).toHaveLength(2);
+        expect(h.files.has(`${PREFIX}/.install-failed`)).toBe(false); // stale verdict cleared
+        h.release();
+        await p.settled();
+    });
+    it('a thrown npm spawn error is a failure, not a crash', async () => {
+        const h = harness({ runNpm: async () => { throw new Error('spawn npm ENOENT'); } });
+        const p = (0, opencodeBinary_1.createOpencodeProvisioner)(BASE, h.deps);
+        p.prepare(launch);
+        await p.settled();
+        expect(h.files.get(`${PREFIX}/.install-failed`)).toContain('spawn npm ENOENT');
+    });
+    it('refuses with the manual command on win32 (no sh waiter)', () => {
+        const h = harness({ platform: 'win32' });
+        const r = (0, opencodeBinary_1.createOpencodeProvisioner)(BASE, h.deps).prepare(launch);
+        expect(r.ok).toBe(false);
+        expect(!r.ok && r.message).toContain(`npm i -g opencode-ai@${opencodeConfig_1.OPENCODE_PINNED_VERSION}`);
+        expect(h.npmCalls).toHaveLength(0);
+    });
+    it('failure lines are short', () => {
+        for (const l of (0, opencodeBinary_1.opencodeInstallFailureLines)('x'.repeat(200)))
+            expect(l.length).toBeLessThanOrEqual(65);
+    });
+});

package/dist/__tests__/bridge-opencode-launch.test.js

@@ -177,3 +177,40 @@ describe('relay lane carries the server-delivered opencode block', () => {
         await new Promise((r) => wss.close(r));
     });
 });
+describe('oc-25 — relay lane spawns what the provisioner prepared', () => {
+    it('swaps in the absolute binary; a refusal becomes the typed error with its own message', async () => {
+        const { wss, port, ptys, factory } = await setup();
+        const frames = [];
+        let conn;
+        const got = new Promise((r) => wss.on('connection', (ws) => { conn = ws; ws.on('message', (m) => frames.push(JSON.parse(String(m)))); r(); }));
+        let refuse = false;
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${port}`, relayToken: 'tok',
+            sessions: new sessionManager_1.SessionManager(factory),
+            resolveLaunch: (o) => (0, agentLaunch_1.resolveAgentLaunch)({ autonomous: true, opencode: o.opencode, connectToken: o.connectToken }),
+            commandExists: () => true,
+            prepareOpencodeLaunch: (l) => refuse
+                ? { ok: false, message: 'short refusal' }
+                : { ok: true, launch: { ...l, command: '/h/.wen-market/opencode/1.18.35/node_modules/.bin/opencode' } },
+        });
+        await got;
+        const wait = async (pred) => { for (let i = 0; i < 100; i++) {
+            const f = frames.find(pred);
+            if (f)
+                return f;
+            await new Promise((r) => setTimeout(r, 10));
+        } throw new Error('timeout'); };
+        conn.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, sessionId: 'b-1', workspaceId: 'w', opencode: oc() }));
+        await wait((f) => f.t === 'opened');
+        expect(ptys[0].opts.command).toBe('/h/.wen-market/opencode/1.18.35/node_modules/.bin/opencode');
+        refuse = true;
+        conn.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, sessionId: 'b-2', workspaceId: 'w', opencode: oc() }));
+        const err = await wait((f) => f.t === 'error' && f.sessionId === 'b-2');
+        expect(err.message).toBe('short refusal');
+        expect(ptys).toHaveLength(1);
+        handle.close();
+        for (const c of wss.clients)
+            c.terminate();
+        await new Promise((r) => wss.close(r));
+    });
+});

package/dist/bridge/opencodeBinary.d.ts

@@ -0,0 +1,47 @@
+export declare const OPENCODE_PACKAGE = "opencode-ai";
+export declare const OPENCODE_INSTALL_TIMEOUT_MS: number;
+export interface OpencodeBinaryDeps {
+    exists: (p: string) => boolean;
+    writeFile: (p: string, content: string) => void;
+    mkdirp: (dir: string) => void;
+    rm: (p: string) => void;
+    /** Run npm with exactly this env. Resolves { code } (never rejects on non-zero). */
+    runNpm: (args: string[], env: NodeJS.ProcessEnv) => Promise<{
+        code: number;
+        stderr?: string;
+    }>;
+    /** PATH lookup: absolute path + `--version` output of the `opencode` on PATH, or null. */
+    pathOpencode: () => {
+        path: string;
+        version: string | null;
+    } | null;
+    /** `<bin> --version` output, or null if it will not run. */
+    versionOf: (bin: string) => string | null;
+    env: NodeJS.ProcessEnv;
+    platform: NodeJS.Platform;
+}
+export interface LaunchShape {
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+}
+export type PreparedLaunch = {
+    ok: true;
+    launch: LaunchShape;
+} | {
+    ok: false;
+    message: string;
+};
+export declare function managedPrefix(baseDir: string, version?: string): string;
+export declare const managedBin: (prefix: string) => string;
+/** Short lines on purpose: a narrow pane wraps long ones badly. */
+export declare function opencodeInstallFailureLines(reason: string): string[];
+/** POSIX sh waiter: progress now, then exec once the bridge marks the install ready (or print the failure). */
+export declare const OPENCODE_WAIT_SCRIPT: string;
+export declare function createOpencodeProvisioner(baseDir: string, deps: OpencodeBinaryDeps): {
+    managedBin: string;
+    /** Resolve (or start provisioning) and return the launch to spawn. Synchronous. */
+    prepare(launch: LaunchShape): PreparedLaunch;
+    /** Test seam: resolves when the in-flight install (if any) settles. */
+    settled: () => Promise<void>;
+};

package/dist/bridge/opencodeBinary.js

@@ -0,0 +1,161 @@
+"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.OPENCODE_WAIT_SCRIPT = exports.managedBin = exports.OPENCODE_INSTALL_TIMEOUT_MS = exports.OPENCODE_PACKAGE = void 0;
+exports.managedPrefix = managedPrefix;
+exports.opencodeInstallFailureLines = opencodeInstallFailureLines;
+exports.createOpencodeProvisioner = createOpencodeProvisioner;
+/**
+ * oc-25 — the bridge provides OpenCode itself (ADR-0013 local-lane parity).
+ *
+ * A user must never install OpenCode by hand. Binary choice, in order:
+ *   1. the bridge-managed pinned copy (~/.wen-market/opencode/<pinned>), if there;
+ *   2. else a PATH `opencode` at or above the minimum;
+ *   3. else install the pinned version into the managed prefix (lazy: only on
+ *      the first OpenCode launch, so Claude-only users never download it).
+ *
+ * The launch always carries an ABSOLUTE binary path. While an install runs the
+ * PTY runs a tiny `sh` waiter (progress line, then exec) — the pane shows
+ * "Setting up OpenCode" instead of a blank wait or a bare shell. Concurrent
+ * opens share ONE install (in-flight promise). The install must NOT inherit
+ * OPENCODE_QUIET_ENV's npm_config_offline=true, so it runs with a scrubbed env.
+ */
+const path = __importStar(require("path"));
+const opencodeConfig_1 = require("./opencodeConfig");
+exports.OPENCODE_PACKAGE = 'opencode-ai';
+exports.OPENCODE_INSTALL_TIMEOUT_MS = 5 * 60 * 1000;
+function managedPrefix(baseDir, version = opencodeConfig_1.OPENCODE_PINNED_VERSION) {
+    return path.join(baseDir, version);
+}
+const managedBin = (prefix) => path.join(prefix, 'node_modules', '.bin', 'opencode');
+exports.managedBin = managedBin;
+const readyMarker = (prefix) => path.join(prefix, '.ready');
+const failMarker = (prefix) => path.join(prefix, '.install-failed');
+/** Short lines on purpose: a narrow pane wraps long ones badly. */
+function opencodeInstallFailureLines(reason) {
+    const why = reason.replace(/\s+/g, ' ').trim().slice(0, 60);
+    return [
+        'Could not set up OpenCode.',
+        ...(why ? [why] : []),
+        'Install it by hand:',
+        `npm i -g ${exports.OPENCODE_PACKAGE}@${opencodeConfig_1.OPENCODE_PINNED_VERSION}`,
+        'Then reopen this pane.',
+    ];
+}
+/** POSIX sh waiter: progress now, then exec once the bridge marks the install ready (or print the failure). */
+exports.OPENCODE_WAIT_SCRIPT = [
+    'ready=$1; fail=$2; shift 2',
+    "printf '\\r\\n\\033[2mSetting up OpenCode (one-time, ~30s)...\\033[0m\\r\\n'",
+    'while [ ! -e "$ready" ]; do',
+    '  if [ -e "$fail" ]; then',
+    "    printf '\\r\\n'",
+    "    while IFS= read -r l; do printf '\\033[31m%s\\033[0m\\r\\n' \"$l\"; done < \"$fail\"",
+    '    exit 1',
+    '  fi',
+    '  sleep 1',
+    'done',
+    'exec "$@"',
+].join('\n');
+function createOpencodeProvisioner(baseDir, deps) {
+    const prefix = managedPrefix(baseDir);
+    const bin = (0, exports.managedBin)(prefix);
+    let inflight = null;
+    function install() {
+        if (inflight)
+            return inflight;
+        // Clear the previous verdict synchronously so a waiter spawned right after never reads a stale one.
+        try {
+            deps.rm(failMarker(prefix));
+        }
+        catch { /* none */ }
+        const env = { ...deps.env };
+        for (const k of Object.keys(env))
+            if (k.toLowerCase() === 'npm_config_offline')
+                delete env[k];
+        const fail = (reason) => {
+            try {
+                deps.writeFile(failMarker(prefix), opencodeInstallFailureLines(reason).join('\n') + '\n');
+            }
+            catch { /* best effort */ }
+        };
+        const run = (async () => {
+            try {
+                deps.mkdirp(prefix);
+                const pkg = path.join(prefix, 'package.json');
+                if (!deps.exists(pkg))
+                    deps.writeFile(pkg, JSON.stringify({ name: 'wen-market-opencode', private: true }) + '\n');
+                const res = await deps.runNpm(['install', '--prefix', prefix, `${exports.OPENCODE_PACKAGE}@${opencodeConfig_1.OPENCODE_PINNED_VERSION}`, '--no-audit', '--no-fund'], env);
+                if (res.code !== 0)
+                    return fail(`npm exited ${res.code}`);
+                if (!deps.exists(bin) || !(0, opencodeConfig_1.opencodeVersionOk)(deps.versionOf(bin)))
+                    return fail('installed binary will not run');
+                deps.writeFile(readyMarker(prefix), opencodeConfig_1.OPENCODE_PINNED_VERSION);
+            }
+            catch (err) {
+                fail(err instanceof Error ? err.message : String(err));
+            }
+        })();
+        inflight = run;
+        void run.then(() => { if (inflight === run)
+            inflight = null; });
+        return run;
+    }
+    return {
+        managedBin: bin,
+        /** Resolve (or start provisioning) and return the launch to spawn. Synchronous. */
+        prepare(launch) {
+            const withBin = (b) => ({ ...launch, command: b });
+            if (deps.exists(bin) && deps.exists(readyMarker(prefix)))
+                return { ok: true, launch: withBin(bin) };
+            const onPath = deps.pathOpencode();
+            if (onPath && (0, opencodeConfig_1.opencodeVersionOk)(onPath.version))
+                return { ok: true, launch: withBin(onPath.path) };
+            if (deps.platform === 'win32') {
+                return { ok: false, message: opencodeInstallFailureLines('automatic setup is not on Windows yet').join('\r\n') };
+            }
+            void install();
+            return {
+                ok: true,
+                launch: {
+                    ...launch,
+                    command: '/bin/sh',
+                    args: ['-c', exports.OPENCODE_WAIT_SCRIPT, 'opencode-wait', readyMarker(prefix), failMarker(prefix), bin, ...launch.args],
+                },
+            };
+        },
+        /** Test seam: resolves when the in-flight install (if any) settles. */
+        settled: () => inflight ?? Promise.resolve(),
+    };
+}

package/dist/bridge/opencodeConfig.d.ts

@@ -10,6 +10,8 @@
  */
 /** Oldest OpenCode the local lane accepts. 1.18.35 is the version oc-04 verified
  *  (`permission.asked` / `session.idle` events, `-s <id>` resume, quiet env). */
+export declare const OPENCODE_PINNED_VERSION = "1.18.35";
+/** oc-25: the version the bridge installs for itself IS the minimum it accepts from PATH. */
 export declare const OPENCODE_MIN_VERSION = "1.18.35";
 export declare const OPENCODE_INSTALL_HINT = "Install OpenCode: npm i -g opencode-ai@>=1.18.35";
 /** Every outbound call OpenCode makes at startup besides the gateway (oc-04 s5). */

package/dist/bridge/opencodeConfig.js

@@ -10,12 +10,14 @@
  * (`{env:HIVEOP_GATEWAY_TOKEN}`) so it never appears inside the JSON.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCapturedOpencodeSessionId = exports.OPENCODE_GATEWAY_TOKEN_ENV = exports.OPENCODE_PROVIDER_ID = exports.OPENCODE_QUIET_ENV = exports.OPENCODE_INSTALL_HINT = exports.OPENCODE_MIN_VERSION = void 0;
+exports.isCapturedOpencodeSessionId = exports.OPENCODE_GATEWAY_TOKEN_ENV = exports.OPENCODE_PROVIDER_ID = exports.OPENCODE_QUIET_ENV = exports.OPENCODE_INSTALL_HINT = exports.OPENCODE_MIN_VERSION = exports.OPENCODE_PINNED_VERSION = void 0;
 exports.buildOpencodeConfig = buildOpencodeConfig;
 exports.opencodeVersionOk = opencodeVersionOk;
 /** Oldest OpenCode the local lane accepts. 1.18.35 is the version oc-04 verified
  *  (`permission.asked` / `session.idle` events, `-s <id>` resume, quiet env). */
-exports.OPENCODE_MIN_VERSION = '1.18.35';
+exports.OPENCODE_PINNED_VERSION = '1.18.35';
+/** oc-25: the version the bridge installs for itself IS the minimum it accepts from PATH. */
+exports.OPENCODE_MIN_VERSION = exports.OPENCODE_PINNED_VERSION;
 exports.OPENCODE_INSTALL_HINT = `Install OpenCode: npm i -g opencode-ai@>=${exports.OPENCODE_MIN_VERSION}`;
 /** Every outbound call OpenCode makes at startup besides the gateway (oc-04 s5). */
 exports.OPENCODE_QUIET_ENV = Object.freeze({

package/dist/bridge/relayClient.d.ts

@@ -17,6 +17,7 @@
  * `replay`, exactly as it would against the local server.
  */
 import { type OpencodeLaunchInput } from './agentLaunch';
+import type { PreparedLaunch } from './opencodeBinary';
 import { SessionManager } from './sessionManager';
 import { MemInfo } from './containerMemory';
 import { BrowserDriver } from './browserDriver';
@@ -200,6 +201,12 @@ export interface RelayClientOpts {
      * error frame the conductor can report.
      */
     commandExists?: (command: string) => boolean;
+    /** oc-25 — see BridgeServerOpts#prepareOpencodeLaunch. */
+    prepareOpencodeLaunch?: (launch: {
+        command: string;
+        args: string[];
+        env: Record<string, string>;
+    }) => PreparedLaunch;
     /**
      * fcct-27 — RELAY-OWNED SESSIONS ONLY. The consent boundary, made structural.
      *

package/dist/bridge/relayClient.js

@@ -1060,9 +1060,17 @@ function startRelayClient(opts) {
                             // no override, so realPty spawns $SHELL and autolaunch.sh turns it
                             // into claude. Present (laptop) → `claude` explicitly, since
                             // nothing on a user's machine does that for us.
-                            const launch = opts.resolveLaunch?.({ workspaceId, sessionId: relaySessionId, autonomous, opencode, connectToken }) ?? null;
-                            if (launch && opts.commandExists && !opts.commandExists(launch.command)) {
-                                const message = (0, agentLaunch_1.missingCommandMessage)(launch.command);
+                            let launch = opts.resolveLaunch?.({ workspaceId, sessionId: relaySessionId, autonomous, opencode, connectToken }) ?? null;
+                            let refusal = null;
+                            if (launch && launch.command === 'opencode' && opts.prepareOpencodeLaunch) {
+                                const prepared = opts.prepareOpencodeLaunch({ ...launch, env: launch.env ?? {} });
+                                if (prepared.ok)
+                                    launch = prepared.launch;
+                                else
+                                    refusal = prepared.message;
+                            }
+                            if (launch && (refusal || (opts.commandExists && !opts.commandExists(launch.command)))) {
+                                const message = refusal ?? (0, agentLaunch_1.missingCommandMessage)(launch.command);
                                 console.error(`[bridge] refusing PTY spawn — ${message}`);
                                 send(socket, {
                                     t: 'error',

package/dist/bridge/server.d.ts

@@ -2,6 +2,7 @@ import { SessionManager } from './sessionManager';
 import { ValidatePathResult } from './localPathValidation';
 import { PickFolderResult } from './folderPicker';
 import { LocalAddCoreResult } from './localAdd';
+import type { PreparedLaunch } from './opencodeBinary';
 import { VerifyOriginResult } from './originVerification';
 import { PublishResult } from './localPublish';
 import { PublishPreflightResult } from './publishPreflight';
@@ -108,6 +109,14 @@ export interface BridgeServerOpts {
      * crashes the open — see the 'open' handler below.
      */
     commandExists?: (command: string) => boolean;
+    /** oc-25 — resolves/provisions OpenCode for an `opencode` launch: returns the
+     *  launch to spawn (absolute binary, or a progress waiter while the bridge
+     *  installs the pinned copy) or a refusal message. Absent → bare `opencode`. */
+    prepareOpencodeLaunch?: (launch: {
+        command: string;
+        args: string[];
+        env: Record<string, string>;
+    }) => PreparedLaunch;
     /**
      * psp-01 (production bug, 2026-09-14; supersedes bres-01's `hasSessionHistory`)
      * — does Claude Code already have a conversation on disk for THIS AGENT at

package/dist/bridge/server.js

@@ -733,7 +733,7 @@ function startBridgeServer(opts) {
                             // folder still falls back to $HOME for its PTY cwd, but the
                             // workgraph MCP pin should still match whatever workspace the
                             // arena client actually asked to open.
-                            const launch = (0, agentLaunch_1.resolveAgentLaunch)({
+                            let launch = (0, agentLaunch_1.resolveAgentLaunch)({
                                 autonomous: !!frame.autonomous,
                                 ...(frame.opencode ? { opencode: frame.opencode } : {}),
                                 ...(frame.connectToken ? { connectToken: frame.connectToken } : {}),
@@ -745,7 +745,15 @@ function startBridgeServer(opts) {
                                     : {}),
                                 ...(frame.workspaceId ? { workspaceId: frame.workspaceId } : {}),
                             });
-                            const claudeAvailable = opts.commandExists ? opts.commandExists(launch.command) : true;
+                            let refusal = null;
+                            if (launch.command === 'opencode' && opts.prepareOpencodeLaunch) {
+                                const prepared = opts.prepareOpencodeLaunch(launch);
+                                if (prepared.ok)
+                                    launch = prepared.launch;
+                                else
+                                    refusal = prepared.message;
+                            }
+                            const claudeAvailable = !refusal && (opts.commandExists ? opts.commandExists(launch.command) : true);
                             if (!claudeAvailable) {
                                 // Never crash on a missing binary: open a plain session (no
                                 // command override — realPty's $SHELL default) so the pane
@@ -771,9 +779,11 @@ function startBridgeServer(opts) {
                                     send(ws, {
                                         t: 'data',
                                         sessionId,
-                                        data: launch.command === 'opencode'
-                                            ? `\r\n\x1b[31m${(0, agentLaunch_1.missingCommandMessage)('opencode')}, then reopen this pane.\x1b[0m\r\n`
-                                            : '\r\n\x1b[31mclaude not found on PATH — install Claude Code CLI, then reopen this pane.\x1b[0m\r\n',
+                                        data: refusal
+                                            ? `\r\n\x1b[31m${refusal}\x1b[0m\r\n`
+                                            : launch.command === 'opencode'
+                                                ? `\r\n\x1b[31m${(0, agentLaunch_1.missingCommandMessage)('opencode')}, then reopen this pane.\x1b[0m\r\n`
+                                                : '\r\n\x1b[31mclaude not found on PATH — install Claude Code CLI, then reopen this pane.\x1b[0m\r\n',
                                     });
                                 }).catch((err) => {
                                     console.error('[bridge] session attach failed:', err);

package/dist/commands/bridge.js

@@ -70,6 +70,7 @@ const realPty_1 = require("../bridge/realPty");
 const config_1 = require("../bridge/config");
 const mcpRegister_1 = require("../bridge/mcpRegister");
 const mcpInstall_1 = require("../bridge/mcpInstall");
+const opencodeBinary_1 = require("../bridge/opencodeBinary");
 const autostart_1 = require("../bridge/autostart");
 const repoCheckout_1 = require("../bridge/repoCheckout");
 const bundleInstaller_1 = require("../bridge/bundleInstaller");
@@ -192,6 +193,43 @@ function opencodeUsable() {
  * pane). One implementation so the two lanes can never disagree about whether
  * this machine can run Claude Code.
  */
+/**
+ * oc-25 — ONE provisioner for the process, so the loopback lane and the crew
+ * relay lane (and every pane) share a single in-flight OpenCode install.
+ */
+const opencodeProvisioner = (0, opencodeBinary_1.createOpencodeProvisioner)(path.join(os.homedir(), '.wen-market', 'opencode'), {
+    exists: (p) => fs.existsSync(p),
+    writeFile: (p, c) => fs.writeFileSync(p, c),
+    mkdirp: (d) => fs.mkdirSync(d, { recursive: true }),
+    rm: (p) => fs.rmSync(p, { force: true }),
+    runNpm: (args, env) => new Promise((resolve) => {
+        (0, child_process_1.execFile)(process.platform === 'win32' ? 'npm.cmd' : 'npm', args, { env, timeout: opencodeBinary_1.OPENCODE_INSTALL_TIMEOUT_MS }, (err, _out, stderr) => {
+            resolve({ code: err ? (typeof err.code === 'number' ? err.code : 1) : 0, stderr: String(stderr ?? '') });
+        });
+    }),
+    pathOpencode: () => {
+        try {
+            const abs = (0, child_process_1.execFileSync)(process.platform === 'win32' ? 'where' : 'command', process.platform === 'win32' ? ['opencode'] : ['-v', 'opencode'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], shell: process.platform !== 'win32' }).split(/\r?\n/)[0].trim();
+            if (!abs)
+                return null;
+            return { path: abs, version: opencodeVersionOf(abs) };
+        }
+        catch {
+            return null;
+        }
+    },
+    versionOf: (bin) => opencodeVersionOf(bin),
+    env: process.env,
+    platform: process.platform,
+});
+function opencodeVersionOf(bin) {
+    try {
+        return (0, child_process_1.execFileSync)(bin, ['--version'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 15000 });
+    }
+    catch {
+        return null;
+    }
+}
 function commandExistsOnPath(command) {
     if (command === 'opencode')
         return opencodeUsable();
@@ -1210,6 +1248,7 @@ exports.bridgeCommand = new commander_1.Command('bridge')
         // agent's PTY, so a missing install surfaces a clear in-pane error
         // line (server.ts) instead of a raw spawn ENOENT crash.
         commandExists: (command) => commandExistsOnPath(command),
+        prepareOpencodeLaunch: (l) => opencodeProvisioner.prepare(l),
         // psp-01 — real on-disk check: does THIS AGENT already have a Claude
         // Code conversation for this cwd (a "<agentId>.jsonl" transcript)?
         // Drives server.ts's per-agent session-pin decision on the
@@ -1324,6 +1363,7 @@ exports.bridgeCommand = new commander_1.Command('bridge')
             // A missing binary is refused rather than degraded to a shell — a crew
             // member has no pane to print a red line into.
             commandExists: (command) => commandExistsOnPath(command),
+            prepareOpencodeLaunch: (l) => opencodeProvisioner.prepare(l),
             // fcct-27 — this is what keeps "crews may run here" from becoming "the
             // platform may drive any terminal on this machine". Both lanes share one
             // SessionManager by necessity, so without it the relay could attach to,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wenrwa/marketplace-cli",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "CLI tool for the Wenrwa Agent Marketplace — monitor bounties, agents, workspaces, and treasury from your terminal",
   "author": "Wenrwa <dev@wenrwa.com>",
   "license": "MIT",