@wenrwa/marketplace-cli 0.7.8 → 0.8.2

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.d.ts

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

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

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * oc-08 — the local bridge launches OpenCode agents.
+ * Resolver per engine (exact command/args/env), the install hint, the minimum
+ * version, `-s` only for a captured id, and the relay lane carrying the
+ * server-delivered launch block through to the spawn.
+ */
+const ws_1 = require("ws");
+const agentLaunch_1 = require("../bridge/agentLaunch");
+const opencodeConfig_1 = require("../bridge/opencodeConfig");
+const relayClient_1 = require("../bridge/relayClient");
+const sessionManager_1 = require("../bridge/sessionManager");
+const GW = 'https://api.example.test/api/v1/opencode/v1';
+const oc = (extra = {}) => ({
+    engine: 'opencode', model: 'moonshotai/kimi-k2', gatewayUrl: GW, gatewayToken: 'hgw_abc', ...extra,
+});
+describe('oc-07 — local MCP entry', () => {
+    const mcpOf = (l) => JSON.parse(l.env.OPENCODE_CONFIG_CONTENT).mcp['wenrwa-marketplace'];
+    it('uses the resolved installed server (never npx) and passes MARKETPLACE_API_URL by reference', () => {
+        const l = (0, agentLaunch_1.resolveAgentLaunch)({
+            opencode: oc(), connectToken: 'tok',
+            mcpServer: { command: '/usr/bin/node', args: ['/h/.wen-market/mcp/dist/index.js'] },
+            apiUrl: 'https://api.example.test/api/v1',
+        });
+        const m = mcpOf(l);
+        expect(m.command).toEqual(['/usr/bin/node', '/h/.wen-market/mcp/dist/index.js']);
+        expect(m.environment).toEqual({
+            WENRWA_CONNECT_TOKEN: '{env:WENRWA_CONNECT_TOKEN}',
+            MARKETPLACE_API_URL: '{env:MARKETPLACE_API_URL}',
+        });
+        expect(l.env.MARKETPLACE_API_URL).toBe('https://api.example.test/api/v1');
+        expect(l.env.OPENCODE_CONFIG_CONTENT).not.toContain('tok"');
+    });
+    it('npx fallback must not inherit npm_config_offline=true', () => {
+        const l = (0, agentLaunch_1.resolveAgentLaunch)({ opencode: oc(), connectToken: 'tok' });
+        expect(l.env.npm_config_offline).toBe('true'); // the pane itself stays quiet
+        const m = mcpOf(l);
+        expect(m.command).toEqual(['npx', '@wenrwa/marketplace-mcp']);
+        expect(m.environment.npm_config_offline).toBe('false');
+    });
+    it('no connect token -> no mcp entry', () => {
+        expect(JSON.parse((0, agentLaunch_1.resolveAgentLaunch)({ opencode: oc(), mcpServer: { command: 'n', args: [] } }).env.OPENCODE_CONFIG_CONTENT).mcp).toBeUndefined();
+    });
+});
+describe('resolveAgentLaunch per engine', () => {
+    it('Claude path is unchanged when no opencode block, or engine is claude_code', () => {
+        const base = (0, agentLaunch_1.resolveAgentLaunch)({ autonomous: true, workspaceId: 'w1' });
+        expect(base).toEqual({
+            command: 'claude',
+            args: ['--dangerously-skip-permissions'],
+            env: { HIVEOP_CONTEXT_FILE: '.hiveop/context.md', WENRWA_WORKSPACE_ID: 'w1' },
+        });
+        expect((0, agentLaunch_1.resolveAgentLaunch)({ autonomous: true, workspaceId: 'w1', opencode: { engine: 'claude_code' } })).toEqual(base);
+        // an opencode engine without a token/model/url must NOT half-launch
+        expect((0, agentLaunch_1.resolveAgentLaunch)({ opencode: { engine: 'opencode', model: 'm' } }).command).toBe('claude');
+    });
+    it('opencode: command, args, env, and no gateway token on the Claude path', () => {
+        const l = (0, agentLaunch_1.resolveAgentLaunch)({ autonomous: false, opencode: oc(), workspaceId: 'w1', sessionPin: { agentId: 'a1', exists: true } });
+        expect(l.command).toBe('opencode');
+        expect(l.args).toEqual([]);
+        expect(l.env).toMatchObject({
+            ...opencodeConfig_1.OPENCODE_QUIET_ENV,
+            HIVEOP_GATEWAY_TOKEN: 'hgw_abc',
+            WENRWA_WORKSPACE_ID: 'w1',
+            WENRWA_AGENT_ID: 'a1',
+            HIVEOP_CONTEXT_FILE: '.hiveop/context.md',
+        });
+        const claude = (0, agentLaunch_1.resolveAgentLaunch)({ workspaceId: 'w1' });
+        expect(claude.env.HIVEOP_GATEWAY_TOKEN).toBeUndefined();
+        expect(claude.env.OPENCODE_CONFIG_CONTENT).toBeUndefined();
+    });
+    it('config JSON: gateway provider, single model, small_model, no secrets inline', () => {
+        const l = (0, agentLaunch_1.resolveAgentLaunch)({ opencode: oc() });
+        const cfg = JSON.parse(l.env.OPENCODE_CONFIG_CONTENT);
+        expect(cfg).toMatchObject({
+            autoupdate: false, share: 'disabled', enabled_providers: ['hiveop'],
+            model: 'hiveop/moonshotai/kimi-k2', small_model: 'hiveop/moonshotai/kimi-k2',
+        });
+        expect(cfg.provider.hiveop.options).toEqual({ baseURL: GW, apiKey: '{env:HIVEOP_GATEWAY_TOKEN}' });
+        expect(cfg.provider.hiveop.whitelist).toEqual(['moonshotai/kimi-k2']);
+        expect(cfg.permission).toBeUndefined();
+        expect(cfg.mcp).toBeUndefined();
+        expect(l.env.OPENCODE_CONFIG_CONTENT).not.toContain('hgw_abc');
+        expect(JSON.stringify(l)).not.toMatch(/OPENROUTER|sk-or-/i);
+    });
+    it('autonomous -> permission allow; connect token -> MCP server by env reference', () => {
+        const l = (0, agentLaunch_1.resolveAgentLaunch)({ autonomous: true, connectToken: 'ct_1', opencode: oc() });
+        const cfg = JSON.parse(l.env.OPENCODE_CONFIG_CONTENT);
+        expect(cfg.permission).toBe('allow');
+        expect(cfg.mcp['wenrwa-marketplace']).toMatchObject({
+            type: 'local', enabled: true, environment: { WENRWA_CONNECT_TOKEN: '{env:WENRWA_CONNECT_TOKEN}' },
+        });
+        expect(l.env.WENRWA_CONNECT_TOKEN).toBe('ct_1');
+        expect(l.env.OPENCODE_CONFIG_CONTENT).not.toContain('ct_1');
+    });
+    it('-s only when a CAPTURED (ses_) id exists; a pre-minted uuid never resumes', () => {
+        expect((0, agentLaunch_1.resolveAgentLaunch)({ opencode: oc() }).args).toEqual([]);
+        expect((0, agentLaunch_1.resolveAgentLaunch)({ opencode: oc({ sessionId: 'ses_29fabc123' }) }).args).toEqual(['-s', 'ses_29fabc123']);
+        expect((0, agentLaunch_1.resolveAgentLaunch)({ opencode: oc({ sessionId: '2b7c1e0a-1111-4222-8333-444455556666' }) }).args).toEqual([]);
+        expect((0, opencodeConfig_1.isCapturedOpencodeSessionId)('ses_x; rm -rf')).toBe(false);
+    });
+    it('buildOpencodeConfig is pure and deterministic', () => {
+        const i = { model: 'm', gatewayBaseUrl: GW, autonomous: true, withMcp: true };
+        expect((0, opencodeConfig_1.buildOpencodeConfig)(i)).toEqual((0, opencodeConfig_1.buildOpencodeConfig)(i));
+    });
+});
+describe('install hint and minimum version', () => {
+    it('hint mirrors the Claude message', () => {
+        expect(opencodeConfig_1.OPENCODE_INSTALL_HINT).toBe(`Install OpenCode: npm i -g opencode-ai@>=${opencodeConfig_1.OPENCODE_MIN_VERSION}`);
+        expect((0, agentLaunch_1.missingCommandMessage)('opencode')).toContain(opencodeConfig_1.OPENCODE_INSTALL_HINT);
+        expect((0, agentLaunch_1.missingCommandMessage)('claude')).toBe('claude not found on PATH — install Claude Code CLI on this machine');
+    });
+    it('version gate', () => {
+        expect((0, opencodeConfig_1.opencodeVersionOk)('1.18.35')).toBe(true);
+        expect((0, opencodeConfig_1.opencodeVersionOk)('opencode 1.18.36\n')).toBe(true);
+        expect((0, opencodeConfig_1.opencodeVersionOk)('1.19.0')).toBe(true);
+        expect((0, opencodeConfig_1.opencodeVersionOk)('2.0.0')).toBe(true);
+        expect((0, opencodeConfig_1.opencodeVersionOk)('1.18.34')).toBe(false);
+        expect((0, opencodeConfig_1.opencodeVersionOk)('0.99.99')).toBe(false);
+        expect((0, opencodeConfig_1.opencodeVersionOk)('garbage')).toBe(false);
+        expect((0, opencodeConfig_1.opencodeVersionOk)(null)).toBe(false);
+    });
+});
+class FakePty {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    write() { }
+    resize() { }
+    kill() { }
+    onData() { }
+    onExit() { }
+}
+function setup() {
+    const ptys = [];
+    const factory = { spawn: (o) => { const p = new FakePty(o); ptys.push(p); return p; } };
+    return new Promise((resolve) => {
+        const wss = new ws_1.WebSocketServer({ port: 0, host: '127.0.0.1' });
+        wss.on('listening', () => resolve({ wss, port: wss.address().port, ptys, factory }));
+    });
+}
+describe('relay lane carries the server-delivered opencode block', () => {
+    it('spawns opencode with the gateway env; refuses with the install hint when missing', 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 exists = true;
+        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: () => exists,
+        });
+        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: 'a-1', workspaceId: 'w', connectToken: 'ct_9', opencode: oc({ sessionId: 'ses_abc' }) }));
+        await wait((f) => f.t === 'opened');
+        expect(ptys[0].opts.command).toBe('opencode');
+        expect(ptys[0].opts.args).toEqual(['-s', 'ses_abc']);
+        expect(ptys[0].opts.env).toMatchObject({ HIVEOP_GATEWAY_TOKEN: 'hgw_abc', OPENCODE_DISABLE_MODELS_FETCH: '1', WENRWA_CONNECT_TOKEN: 'ct_9' });
+        exists = false;
+        conn.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, sessionId: 'a-2', workspaceId: 'w', opencode: oc() }));
+        const err = await wait((f) => f.t === 'error' && f.sessionId === 'a-2');
+        expect(err.message).toContain(opencodeConfig_1.OPENCODE_INSTALL_HINT);
+        expect(ptys).toHaveLength(1);
+        handle.close();
+        for (const c of wss.clients)
+            c.terminate();
+        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__/bridge-relay-pucc14.test.js

@@ -331,6 +331,34 @@ describe('relay client — hooks-based activity tail (fcct-25)', () => {
         handle.close();
         await closeRelay(relay.wss);
     });
+    it('oc-22: forwards an OpenCode needs_you record as an activity frame carrying kind', async () => {
+        fs.writeFileSync(activityFile, '');
+        process.env.HIVEOP_ACTIVITY_FILE = activityFile;
+        const relay = await startFakeRelay();
+        const { factory } = makeFactory();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        let tick = null;
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            setIntervalFn: (cb) => { tick = cb; return 1; },
+            clearIntervalFn: () => { },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        fs.appendFileSync(activityFile, JSON.stringify({ sessionId: 'agent-A', workspaceId: 'ws-7', kind: 'needs_you', thinking: 'Waiting for you' }) + '\n');
+        tick();
+        expect(await q.next()).toEqual({
+            t: 'activity',
+            sessionId: 'agent-A',
+            thinking: 'Waiting for you',
+            kind: 'needs_you',
+        });
+        handle.close();
+        await closeRelay(relay.wss);
+    });
     it('never schedules the tail when HIVEOP_ACTIVITY_FILE is unset (no stray fs polling)', async () => {
         delete process.env.HIVEOP_ACTIVITY_FILE;
         const relay = await startFakeRelay();

package/dist/__tests__/bridge-server.test.js

@@ -814,6 +814,38 @@ describe('bridge WebSocket server — fcct-24 local-workspace-agent activity', (
             await handle.close();
         }
     });
+    it('oc-22: local lane — an OpenCode needs_you record reaches the app as an activity frame carrying kind', async () => {
+        const file = fs.mkdtempSync(path.join(os.tmpdir(), 'oc22-server-activity-')) + '/activity.jsonl';
+        fs.writeFileSync(file, '');
+        const factory = { spawn: () => new FakePty() };
+        const tickBox = { fn: null };
+        const handle = await (0, server_1.startBridgeServer)({
+            sessionToken: TOKEN,
+            allowedOrigin: ORIGIN,
+            sessions: new sessionManager_1.SessionManager(factory),
+            resolveLocalAgentCwd: () => '/Users/dev/my-project',
+            activityFile: file,
+            hiveOpSettingsPath: '/Users/t/.wen-market/claude-hooks-settings.json',
+            activityScheduleInterval: (cb) => { tickBox.fn = cb; return 'h'; },
+            activityCancelInterval: () => { },
+        });
+        try {
+            const { ws, q } = await openAndAuth(handle.port);
+            ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, agentId: 'agent-1', workspaceId: 'ws-1' }));
+            await q.next();
+            fs.appendFileSync(file, JSON.stringify({ sessionId: 'agent-1', kind: 'needs_you', thinking: 'Waiting for you' }) + '\n');
+            tickBox.fn?.();
+            expect(await q.next()).toEqual({ t: 'activity', sessionId: 'agent-1', thinking: 'Waiting for you', kind: 'needs_you' });
+            // Claude's records carry kind 'tool'/'stop' — the outward frame must stay exactly as it was.
+            fs.appendFileSync(file, JSON.stringify({ sessionId: 'agent-1', kind: 'stop', thinking: '' }) + '\n');
+            tickBox.fn?.();
+            expect(await q.next()).toEqual({ t: 'activity', sessionId: 'agent-1', thinking: '' });
+            ws.close();
+        }
+        finally {
+            await handle.close();
+        }
+    });
 });
 // lws — GET /local-file/:workspaceId?path=…&token=… . Same origin+token gate
 // as /local-tree; the interesting part is that refusal REASONS survive as

package/dist/__tests__/opencode-config-parity.test.d.ts

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

package/dist/__tests__/opencode-config-parity.test.js

@@ -0,0 +1,85 @@
+"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 });
+/**
+ * oc-05/oc-08 — ONE config contract. The hosted image builds OPENCODE_CONFIG_CONTENT with
+ * infra/terminal-image/opencode/build-config.js (the image may carry an older CLI, so it does
+ * not import the compiled builder); this pins it deep-equal to the canonical
+ * buildOpencodeConfig for equivalent inputs, and the quiet env identical.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const opencodeConfig_1 = require("../bridge/opencodeConfig");
+const INFRA = path.join(__dirname, '..', '..', '..', 'infra', 'terminal-image');
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const hosted = require(path.join(INFRA, 'opencode', 'build-config.js'));
+const BASE = {
+    WENRWA_AGENT_MODEL: 'anthropic/claude-sonnet-4.5',
+    HIVEOP_GATEWAY_URL: 'https://api.wenrwa.com/api/v1/opencode/v1',
+    HIVEOP_GATEWAY_TOKEN: 'hgw_x',
+};
+const table = [
+    { name: 'supervised, no mcp', env: BASE, autonomous: false, withMcp: false },
+    { name: 'autonomous', env: { ...BASE, HT_AUTONOMOUS: '1' }, autonomous: true, withMcp: false },
+    { name: 'mcp', env: { ...BASE, WENRWA_CONNECT_TOKEN: 'tok' }, autonomous: false, withMcp: true },
+    { name: 'autonomous + mcp, other model', env: { ...BASE, WENRWA_AGENT_MODEL: 'moonshotai/kimi-k2', HT_AUTONOMOUS: '1', WENRWA_CONNECT_TOKEN: 'tok' }, autonomous: true, withMcp: true },
+];
+describe('hosted build-config.js == CLI buildOpencodeConfig', () => {
+    it.each(table)('$name', ({ env, autonomous, withMcp }) => {
+        const canonical = {
+            ...(0, opencodeConfig_1.buildOpencodeConfig)({
+                model: env.WENRWA_AGENT_MODEL,
+                gatewayBaseUrl: env.HIVEOP_GATEWAY_URL,
+                autonomous,
+                withMcp,
+                mcpCommand: ['marketplace-mcp'],
+                mcpEnvPassthrough: ['MARKETPLACE_API_URL'],
+            }),
+            plugin: [hosted.PLUGIN_URL],
+        };
+        expect(hosted.buildConfig(env)).toEqual(canonical);
+    });
+    it('quiet env is identical, and autolaunch.sh exports exactly it', () => {
+        expect(hosted.QUIET_ENV).toEqual({ ...opencodeConfig_1.OPENCODE_QUIET_ENV });
+        const sh = fs.readFileSync(path.join(INFRA, 'autolaunch.sh'), 'utf8');
+        for (const [k, v] of Object.entries(opencodeConfig_1.OPENCODE_QUIET_ENV)) {
+            expect(sh).toMatch(new RegExp(`(^|\\s)${k}=${v}(\\s|$)`, 'm'));
+        }
+    });
+    it('the hosted plugin URL is the file the Dockerfile installs', () => {
+        expect(fs.readFileSync(path.join(INFRA, 'Dockerfile'), 'utf8')).toContain('COPY opencode/hiveop-plugin.mjs /opt/hiveop/opencode/hiveop-plugin.mjs');
+        expect(hosted.PLUGIN_URL).toBe('file:///opt/hiveop/opencode/hiveop-plugin.mjs');
+    });
+});

package/dist/__tests__/opencode-plugin.test.d.ts

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