@wenrwa/marketplace-cli 0.8.1 → 0.8.3

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/__tests__/opencode-local-launch-parity.test.d.ts

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

package/dist/__tests__/opencode-local-launch-parity.test.js

@@ -0,0 +1,129 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * oc-27 — the ACTUAL local launch must carry the same keys the hosted config does:
+ * `plugin` (activity, titles, Needs-you, session-id capture), `mcp.wenrwa-marketplace`
+ * (when a connect token exists) and `theme`. A builder-only test missed this: the
+ * builder was fine, the local call sites never fed it a plugin or a token.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const url_1 = require("url");
+const ws_1 = __importDefault(require("ws"));
+const agentLaunch_1 = require("../bridge/agentLaunch");
+const server_1 = require("../bridge/server");
+const sessionManager_1 = require("../bridge/sessionManager");
+const hosted = require(path.join(__dirname, '..', '..', '..', 'infra', 'terminal-image', 'opencode', 'build-config.js'));
+const GW = 'https://api.example.test/api/v1/opencode/v1';
+const oc = { engine: 'opencode', model: 'moonshotai/kimi-k2', gatewayUrl: GW, gatewayToken: 'hgw_abc' };
+const cfgOf = (l) => JSON.parse(l.env.OPENCODE_CONFIG_CONTENT);
+// The shape cli/src/commands/bridge.ts hands resolveAgentLaunch (mcpInstall + bridgeApiUrl).
+const realDeps = {
+    mcpServer: { command: '/usr/bin/node', args: ['/h/.wen-market/mcp/dist/index.js'] },
+    apiUrl: 'https://api.example.test/api/v1',
+    activity: { settingsPath: '/h/.wen-market/hiveop-settings.json', sessionId: 'a1', activityFile: '/h/.wen-market/activity.jsonl' },
+    sessionPin: { agentId: 'a1', exists: false },
+};
+describe('local OpenCode launch carries the hosted keys', () => {
+    const hostedCfg = hosted.buildConfig({
+        WENRWA_AGENT_MODEL: oc.model, HIVEOP_GATEWAY_URL: GW, HIVEOP_GATEWAY_TOKEN: 't', WENRWA_CONNECT_TOKEN: 'c',
+    });
+    it('plugin is a file:// URL to a file that exists in the installed package', () => {
+        const cfg = cfgOf((0, agentLaunch_1.resolveAgentLaunch)({ opencode: oc, connectToken: 'c', ...realDeps }));
+        expect(cfg.plugin).toHaveLength(1);
+        expect(cfg.plugin[0]).toMatch(/^file:\/\//);
+        expect(fs.existsSync((0, url_1.fileURLToPath)(cfg.plugin[0]))).toBe(true);
+        expect(path.basename((0, url_1.fileURLToPath)(cfg.plugin[0]))).toBe('opencode-plugin.mjs');
+    });
+    it('mcp.wenrwa-marketplace is present with the token by reference only', () => {
+        const l = (0, agentLaunch_1.resolveAgentLaunch)({ opencode: oc, connectToken: 'secret-conn-token', ...realDeps });
+        expect(cfgOf(l).mcp['wenrwa-marketplace'].environment.WENRWA_CONNECT_TOKEN).toBe('{env:WENRWA_CONNECT_TOKEN}');
+        expect(l.env.OPENCODE_CONFIG_CONTENT).not.toContain('secret-conn-token');
+        expect(l.env.WENRWA_CONNECT_TOKEN).toBe('secret-conn-token');
+    });
+    it('env carries HIVEOP_GATEWAY_URL so the plugin can report the session id (resume)', () => {
+        const l = (0, agentLaunch_1.resolveAgentLaunch)({ opencode: oc, connectToken: 'c', ...realDeps });
+        expect(l.env.HIVEOP_GATEWAY_URL).toBe(GW);
+        expect(l.env.HIVEOP_GATEWAY_TOKEN).toBe('hgw_abc');
+    });
+    it('theme matches the hosted config (terminal palette, no own background)', () => {
+        const cfg = cfgOf((0, agentLaunch_1.resolveAgentLaunch)({ opencode: oc, ...realDeps }));
+        expect(cfg.theme).toBe('system');
+        expect(cfg.theme).toBe(hostedCfg.theme);
+    });
+    it('the same top-level keys as hosted (modulo the hosted-only plugin path)', () => {
+        const local = cfgOf((0, agentLaunch_1.resolveAgentLaunch)({ opencode: oc, connectToken: 'c', ...realDeps }));
+        const keys = (o) => Object.keys(o).filter((k) => k !== 'instructions').sort();
+        expect(keys(local)).toEqual(keys(hostedCfg));
+    });
+});
+describe('loopback open (real bridge wiring) falls back to the bridge-config connect token', () => {
+    let handle;
+    let spawns;
+    beforeEach(async () => {
+        spawns = [];
+        const pty = { write() { }, resize() { }, kill() { }, onData() { }, onExit() { } };
+        handle = await (0, server_1.startBridgeServer)({
+            sessionToken: 'tok', allowedOrigin: 'https://app.hiveop.io',
+            sessions: new sessionManager_1.SessionManager({ spawn: (o) => { spawns.push(o); return pty; } }),
+            resolveLocalAgentCwd: () => '/tmp/proj',
+            commandExists: () => true,
+            activityFile: '/h/activity.jsonl', hiveOpSettingsPath: '/h/settings.json',
+            mcpServer: realDeps.mcpServer, mcpApiUrl: realDeps.apiUrl,
+            connectToken: 'bridge-cfg-token',
+        });
+    });
+    afterEach(async () => { await handle.close(); });
+    it('open frame without connectToken still yields plugin + mcp + theme', async () => {
+        const ws = new ws_1.default(`ws://127.0.0.1:${handle.port}`, { headers: { origin: 'https://app.hiveop.io' } });
+        await new Promise((r) => ws.on('open', r));
+        ws.send(JSON.stringify({ v: 1, token: 'tok' }));
+        const opened = new Promise((r) => ws.on('message', (m) => { if (JSON.parse(String(m)).t === 'opened')
+            r(null); }));
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, agentId: 'a1', workspaceId: 'w1', opencode: oc }));
+        await opened;
+        ws.close();
+        const cfg = cfgOf({ env: spawns[0].env });
+        expect(cfg.plugin[0]).toMatch(/^file:\/\//);
+        expect(cfg.mcp['wenrwa-marketplace']).toBeDefined();
+        expect(cfg.theme).toBe('system');
+        expect(spawns[0].env.WENRWA_CONNECT_TOKEN).toBe('bridge-cfg-token');
+        expect(spawns[0].env.OPENCODE_CONFIG_CONTENT).not.toContain('bridge-cfg-token');
+    });
+});

package/dist/bridge/agentLaunch.js

@@ -4,6 +4,7 @@ exports.HIVEOP_CONTEXT_ENV_VALUE = exports.HIVEOP_CONTEXT_ENV_VAR = void 0;
 exports.missingCommandMessage = missingCommandMessage;
 exports.resolveAgentLaunch = resolveAgentLaunch;
 const localContextWriter_1 = require("./localContextWriter");
+const opencodePlugin_1 = require("./opencodePlugin");
 const opencodeConfig_1 = require("./opencodeConfig");
 /** lws-08 — env var name a spawned `claude` (or any tooling inspecting its
  *  own environment) can read to find the pushed context manifest. */
@@ -46,21 +47,27 @@ function resolveOpencodeLaunch(opts, oc) {
     const args = [];
     if ((0, opencodeConfig_1.isCapturedOpencodeSessionId)(oc.sessionId))
         args.push('-s', oc.sessionId);
-    const config = (0, opencodeConfig_1.buildOpencodeConfig)({
-        model: oc.model,
-        gatewayBaseUrl: oc.gatewayUrl,
-        autonomous: !!opts.autonomous,
-        withMcp: !!opts.connectToken,
-        // oc-23: Claude loads .hiveop/context.md via its SessionStart hook; OpenCode has none, so it reads it as instructions.
-        instructions: [exports.HIVEOP_CONTEXT_ENV_VALUE],
-        ...(opts.mcpServer ? { mcpCommand: [opts.mcpServer.command, ...opts.mcpServer.args] } : {}),
-        ...(opts.apiUrl ? { mcpEnvPassthrough: ['MARKETPLACE_API_URL'] } : {}),
-    });
+    const config = {
+        ...(0, opencodeConfig_1.buildOpencodeConfig)({
+            model: oc.model,
+            gatewayBaseUrl: oc.gatewayUrl,
+            autonomous: !!opts.autonomous,
+            withMcp: !!opts.connectToken,
+            // oc-23: Claude loads .hiveop/context.md via its SessionStart hook; OpenCode has none, so it reads it as instructions.
+            instructions: [exports.HIVEOP_CONTEXT_ENV_VALUE],
+            ...(opts.mcpServer ? { mcpCommand: [opts.mcpServer.command, ...opts.mcpServer.args] } : {}),
+            ...(opts.apiUrl ? { mcpEnvPassthrough: ['MARKETPLACE_API_URL'] } : {}),
+        }),
+        // oc-27: the HiveOp plugin (activity, titles, Needs-you, session-id capture) — as hosted does.
+        ...(0, opencodePlugin_1.buildOpenCodePluginConfig)(),
+    };
     const env = {
         [exports.HIVEOP_CONTEXT_ENV_VAR]: exports.HIVEOP_CONTEXT_ENV_VALUE,
         ...opencodeConfig_1.OPENCODE_QUIET_ENV,
         OPENCODE_CONFIG_CONTENT: JSON.stringify(config),
         [opencodeConfig_1.OPENCODE_GATEWAY_TOKEN_ENV]: oc.gatewayToken,
+        // oc-27: the plugin POSTs the captured session id to <gateway>/hiveop/session (resume).
+        HIVEOP_GATEWAY_URL: oc.gatewayUrl,
     };
     if (opts.connectToken)
         env.WENRWA_CONNECT_TOKEN = opts.connectToken;

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,10 +10,13 @@
  */
 /** 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). */
 export declare const OPENCODE_QUIET_ENV: Readonly<Record<string, string>>;
+export declare const OPENCODE_THEME = "system";
 export declare const OPENCODE_PROVIDER_ID = "hiveop";
 export declare const OPENCODE_GATEWAY_TOKEN_ENV = "HIVEOP_GATEWAY_TOKEN";
 export interface OpencodeConfigInput {

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_THEME = 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({
@@ -27,6 +29,7 @@ exports.OPENCODE_QUIET_ENV = Object.freeze({
     OPENCODE_DISABLE_TERMINAL_TITLE: '1',
     npm_config_offline: 'true',
 });
+exports.OPENCODE_THEME = 'system';
 exports.OPENCODE_PROVIDER_ID = 'hiveop';
 exports.OPENCODE_GATEWAY_TOKEN_ENV = 'HIVEOP_GATEWAY_TOKEN';
 function buildOpencodeConfig(input) {
@@ -39,6 +42,9 @@ function buildOpencodeConfig(input) {
         model: `${exports.OPENCODE_PROVIDER_ID}/${model}`,
         // OpenCode makes a second, billed "title" call on the small model.
         small_model: `${exports.OPENCODE_PROVIDER_ID}/${model}`,
+        // oc-27: OpenCode's built-in "system" theme derives its palette from the terminal and
+        // leaves the background transparent, so the pane blends with the canvas like Claude's.
+        theme: exports.OPENCODE_THEME,
         provider: {
             [exports.OPENCODE_PROVIDER_ID]: {
                 npm: '@ai-sdk/openai-compatible',

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
@@ -235,6 +244,9 @@ export interface BridgeServerOpts {
         args: string[];
     };
     mcpApiUrl?: string;
+    /** oc-27 — the bridge's own stored Connect Token: the fallback for an `open` frame that carries none
+     *  (loopback frames from the browser never do), so local OpenCode agents get the same MCP as Claude. */
+    connectToken?: string;
     /**
      * rival-10 — every file touch of a LOCAL WORKSPACE AGENT (an `open` with
      * agentId + workspaceId), handed on for the ranked rival feed. The hook

package/dist/bridge/server.js

@@ -733,10 +733,10 @@ 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 } : {}),
+                                ...((frame.connectToken || opts.connectToken) ? { connectToken: (frame.connectToken || opts.connectToken) } : {}),
                                 ...(opts.mcpServer ? { mcpServer: opts.mcpServer } : {}),
                                 ...(opts.mcpApiUrl ? { apiUrl: opts.mcpApiUrl } : {}),
                                 ...(cwd ? { sessionPin: { agentId, exists: agentSessionExists } } : {}),
@@ -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();
@@ -1089,6 +1127,8 @@ exports.bridgeCommand = new commander_1.Command('bridge')
         hiveOpSettingsPath,
         ...(mcpInstall.ok ? { mcpServer: { command: mcpInstall.command, args: mcpInstall.args } } : {}),
         mcpApiUrl: bridgeApiUrl(),
+        // oc-27: local OpenCode panes get the HiveOp MCP with the same token Claude's registration uses.
+        connectToken: config.connectToken,
         // tchp-18: the loopback changes reporter is opt-in; without this the
         // tchp-12 machinery never constructs on a laptop and local panels sit
         // on "Waiting for changes…" forever.
@@ -1210,6 +1250,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
@@ -1314,7 +1355,7 @@ exports.bridgeCommand = new commander_1.Command('bridge')
             resolveLaunch: ({ sessionId, opencode, connectToken }) => (0, agentLaunch_1.resolveAgentLaunch)({
                 autonomous: true,
                 ...(opencode ? { opencode } : {}),
-                ...(connectToken ? { connectToken } : {}),
+                ...((connectToken || config.connectToken) ? { connectToken: (connectToken || config.connectToken) } : {}),
                 ...(mcpInstall.ok ? { mcpServer: { command: mcpInstall.command, args: mcpInstall.args } } : {}),
                 apiUrl: bridgeApiUrl(),
                 ...(activityFile && hiveOpSettingsPath && sessionId
@@ -1324,6 +1365,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.3",
   "description": "CLI tool for the Wenrwa Agent Marketplace — monitor bounties, agents, workspaces, and treasury from your terminal",
   "author": "Wenrwa <dev@wenrwa.com>",
   "license": "MIT",