@wenrwa/marketplace-cli 0.7.8 → 0.8.1

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

@@ -0,0 +1,179 @@
+"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));
+    });
+});

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 {};

package/dist/__tests__/opencode-plugin.test.js

@@ -0,0 +1,197 @@
+"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-06 — the OpenCode activity plugin must write the SAME lines the Claude
+ * Code hooks write. Expected lines for tool/stop are produced by running the
+ * REAL hooks (so the contract cannot drift); the plugin (ESM) is driven in a
+ * child node process.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const opencodePlugin_1 = require("../bridge/opencodePlugin");
+const ROOT = path.join(__dirname, '..', '..');
+const LOCAL_PLUGIN = path.join(ROOT, 'hooks', 'opencode-plugin.mjs');
+const HOSTED_PLUGIN = path.join(ROOT, '..', 'infra', 'terminal-image', 'opencode', 'hiveop-plugin.mjs');
+const HOOKS = path.join(ROOT, 'hooks');
+function tmp() { return fs.mkdtempSync(path.join(os.tmpdir(), 'oc06-')); }
+function runPlugin(calls, env, plugin = LOCAL_PLUGIN) {
+    const script = `
+    const { HiveOp } = await import(process.argv[1]);
+    const h = await HiveOp({});
+    for (const c of JSON.parse(process.argv[2])) {
+      if ('event' in c) await h.event({ event: c.event });
+      else await h[c.hook](c.input, c.output);
+    }`;
+    const base = { ...process.env };
+    delete base.HIVEOP_ACTIVITY_FILE;
+    delete base.WENRWA_SESSION_ID;
+    (0, child_process_1.execFileSync)(process.execPath, ['--input-type=module', '-e', script, plugin, JSON.stringify(calls)], {
+        env: { ...base, ...env },
+    });
+}
+function runClaudeHook(file, event, af, cwd) {
+    (0, child_process_1.execFileSync)(process.execPath, [path.join(HOOKS, file)], {
+        input: JSON.stringify(event), cwd,
+        env: { ...process.env, WENRWA_SESSION_ID: 's1', WENRWA_WORKSPACE_ID: 'w1', HIVEOP_ACTIVITY_FILE: af },
+    });
+}
+const lines = (f) => fs.existsSync(f) ? fs.readFileSync(f, 'utf8').trim().split('\n').filter(Boolean).map((l) => JSON.parse(l)) : [];
+const ENV = (af) => ({ WENRWA_SESSION_ID: 's1', WENRWA_WORKSPACE_ID: 'w1', HIVEOP_ACTIVITY_FILE: af });
+describe('opencode plugin activity lines (oc-06)', () => {
+    let dir;
+    let af;
+    let ref;
+    beforeEach(() => { dir = tmp(); af = path.join(dir, 'a.jsonl'); ref = path.join(dir, 'ref.jsonl'); });
+    it('tool.execute.before for edit matches the Claude PostToolUse Edit line', () => {
+        runClaudeHook('post-tool-use.js', { tool_name: 'Edit', tool_input: { file_path: '/repo/src/foo.ts' } }, ref);
+        runPlugin([{ hook: 'tool.execute.before', input: { tool: 'edit', sessionID: 'x' }, output: { args: { filePath: '/repo/src/foo.ts' } } }], ENV(af));
+        expect(lines(af)).toEqual(lines(ref));
+        expect(lines(af)[0]).toMatchObject({ kind: 'tool', tool: 'Edit', thinking: 'Editing foo.ts' });
+    });
+    it('tool.execute.after emits the same working line (args from input)', () => {
+        runClaudeHook('post-tool-use.js', { tool_name: 'Read', tool_input: { file_path: '/repo/a.ts' } }, ref);
+        runPlugin([{ hook: 'tool.execute.after', input: { tool: 'read', args: { filePath: '/repo/a.ts' } }, output: {} }], ENV(af));
+        expect(lines(af)).toEqual(lines(ref));
+    });
+    it('bash with an existing path matches the Claude hook (bash path extraction parity)', () => {
+        const f = path.join(dir, 'real.txt');
+        fs.writeFileSync(f, 'x');
+        runClaudeHook('post-tool-use.js', { tool_name: 'Bash', tool_input: { command: `cat ${f}` } }, ref, dir);
+        runPlugin([{ hook: 'tool.execute.before', input: { tool: 'bash' }, output: { args: { command: `cat ${f}` } } }], ENV(af));
+        const got = lines(af);
+        expect(got).toEqual(lines(ref));
+        expect(got[0].filePaths).toEqual([f]);
+    });
+    it('unknown tool and missing args fall back to Working', () => {
+        runClaudeHook('post-tool-use.js', { tool_name: 'mcp_thing', tool_input: {} }, ref);
+        runPlugin([{ hook: 'tool.execute.before', input: { tool: 'mcp_thing' }, output: {} }], ENV(af));
+        expect(lines(af)).toEqual(lines(ref));
+    });
+    it('session.idle matches the Claude Stop line', () => {
+        runClaudeHook('stop.js', {}, ref);
+        runPlugin([{ event: { type: 'session.idle', properties: { sessionID: 'o' } } }], ENV(af));
+        expect(lines(af)).toEqual(lines(ref));
+    });
+    it('session.status idle is a stop; idle then session.idle writes ONE stop; busy writes nothing', () => {
+        runPlugin([
+            { event: { type: 'session.status', properties: { status: { type: 'busy' } } } },
+            { event: { type: 'session.status', properties: { status: { type: 'idle' } } } },
+            { event: { type: 'session.idle', properties: {} } },
+        ], ENV(af));
+        expect(lines(af).map((l) => l.kind)).toEqual(['stop']);
+    });
+    it('a stop after new work is written again', () => {
+        runPlugin([
+            { event: { type: 'session.idle', properties: {} } },
+            { hook: 'tool.execute.before', input: { tool: 'bash' }, output: { args: {} } },
+            { event: { type: 'session.idle', properties: {} } },
+        ], ENV(af));
+        expect(lines(af).map((l) => l.kind)).toEqual(['stop', 'tool', 'stop']);
+    });
+    it('permission.asked and question.asked are needs_you; permission.replied is working', () => {
+        runPlugin([
+            { event: { type: 'permission.asked', properties: {} } },
+            { event: { type: 'permission.replied', properties: {} } },
+            { event: { type: 'question.asked', properties: {} } },
+        ], ENV(af));
+        expect(lines(af)).toEqual([
+            { sessionId: 's1', workspaceId: 'w1', kind: 'needs_you', thinking: 'Waiting for you' },
+            { sessionId: 's1', workspaceId: 'w1', kind: 'tool', tool: '', filePaths: [], thinking: 'Working' },
+            { sessionId: 's1', workspaceId: 'w1', kind: 'needs_you', thinking: 'Waiting for you' },
+        ]);
+    });
+    it('is a no-op without HIVEOP_ACTIVITY_FILE, and without a session id (like the hooks)', () => {
+        runPlugin([{ event: { type: 'session.idle', properties: {} } }], { WENRWA_SESSION_ID: 's1' });
+        runPlugin([{ event: { type: 'session.idle', properties: {} } }], { HIVEOP_ACTIVITY_FILE: af });
+        expect(fs.existsSync(af)).toBe(false);
+    });
+    it('swallows write errors and malformed input', () => {
+        const blocker = path.join(dir, 'file');
+        fs.writeFileSync(blocker, '');
+        expect(() => runPlugin([
+            { event: { type: 'session.idle', properties: {} } },
+            { event: null },
+            { hook: 'tool.execute.before', input: null, output: null },
+        ], ENV(path.join(blocker, 'sub', 'a.jsonl')))).not.toThrow();
+    });
+    it('session.created capture is kept behind captureSessionId (primary only)', () => {
+        const sess = path.join(dir, 'sessions');
+        const env = { ...ENV(af), WENRWA_AGENT_ID: 'ag1', HIVEOP_OPENCODE_SESSIONS_DIR: sess };
+        runPlugin([
+            { event: { type: 'session.created', properties: { sessionID: 'ses_main', info: {} } } },
+            { event: { type: 'session.created', properties: { sessionID: 'ses_sub', info: { parentID: 'ses_main' } } } },
+        ], env);
+        expect(fs.readFileSync(path.join(sess, 'ag1'), 'utf8')).toBe('ses_main');
+        expect(fs.existsSync(af)).toBe(false);
+    });
+    it('the hosted and local copies are byte-identical', () => {
+        expect(fs.readFileSync(LOCAL_PLUGIN, 'utf8')).toBe(fs.readFileSync(HOSTED_PLUGIN, 'utf8'));
+    });
+});
+describe('opencode plugin local helper (oc-06, for oc-08)', () => {
+    it('resolves the bundled plugin that ships in the package', () => {
+        const p = (0, opencodePlugin_1.resolveOpenCodePluginPath)();
+        expect(p).toBe(LOCAL_PLUGIN);
+        expect(fs.existsSync(p)).toBe(true);
+    });
+    it('builds a plugin config fragment with an encoded file URL', () => {
+        expect((0, opencodePlugin_1.buildOpenCodePluginConfig)('/a b/opencode-plugin.mjs')).toEqual({ plugin: ['file:///a%20b/opencode-plugin.mjs'] });
+    });
+});
+// OpenCode loads EVERY export of a plugin module as a plugin and reads hooks off
+// whatever it returns. A helper export (e.g. a string-returning function) yields
+// no hooks object, and OpenCode's Plugin.trigger then throws on every prompt —
+// found live in image v62 against a fake gateway ("evaluating 'N.config'").
+describe('module shape OpenCode loads', () => {
+    for (const plugin of [LOCAL_PLUGIN, HOSTED_PLUGIN]) {
+        it(`${path.basename(plugin)}: every export is a plugin that resolves to a hooks object`, () => {
+            const script = `
+        const mod = await import(process.argv[1]);
+        const bad = [];
+        for (const [name, fn] of Object.entries(mod)) {
+          if (typeof fn !== 'function') { bad.push(name + ':not-a-function'); continue; }
+          const h = await fn({});
+          if (!h || typeof h !== 'object') bad.push(name + ':no-hooks');
+        }
+        process.stdout.write(JSON.stringify({ names: Object.keys(mod), bad }));`;
+            const out = JSON.parse((0, child_process_1.execFileSync)(process.execPath, ['--input-type=module', '-e', script, plugin]).toString());
+            expect(out.bad).toEqual([]);
+            expect(out.names).toContain('HiveOp');
+        });
+    }
+});

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

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

package/dist/__tests__/opencode-title.test.js

@@ -0,0 +1,99 @@
+"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-17 -- OpenCode sets its own OSC title ("OpenCode" at home / for an untitled
+ * session, "OC | <title>" otherwise; observed on 1.18.35). The app ingests the OSC
+ * title verbatim, so the launch turns OpenCode's title off
+ * (OPENCODE_DISABLE_TERMINAL_TITLE=1) and the HiveOp plugin writes the bare session
+ * title itself. The plugin is driven in a child node process; HIVEOP_TITLE_TTY stands
+ * in for /dev/tty.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const opencodeConfig_1 = require("../bridge/opencodeConfig");
+const ROOT = path.join(__dirname, '..', '..');
+const PLUGINS = [
+    path.join(ROOT, 'hooks', 'opencode-plugin.mjs'),
+    path.join(ROOT, '..', 'infra', 'terminal-image', 'opencode', 'hiveop-plugin.mjs'),
+];
+function titlesFor(plugin, infos) {
+    const tty = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'oc17-')), 'tty');
+    fs.writeFileSync(tty, '');
+    const script = `
+    const { HiveOp } = await import(process.argv[1]);
+    const h = await HiveOp({});
+    for (const info of JSON.parse(process.argv[2])) await h.event({ event: { type: 'session.updated', properties: { info } } });`;
+    (0, child_process_1.execFileSync)('node', ['--input-type=module', '-e', script, plugin, JSON.stringify(infos)], {
+        env: { PATH: process.env.PATH, HIVEOP_TITLE_TTY: tty },
+    });
+    return fs.readFileSync(tty, 'utf-8');
+}
+const osc = (t) => `\x1b]0;${t}\x07`;
+describe.each(PLUGINS.map((p) => [path.basename(p), p]))('oc-17 pane title (%s)', (_n, plugin) => {
+    it('writes the bare session title as OSC 0, no "OC | " prefix', () => {
+        expect(titlesFor(plugin, [{ id: 'ses_1', title: 'Fix the login redirect' }])).toBe(osc('Fix the login redirect'));
+    });
+    it('ignores the placeholder titles OpenCode starts every session with', () => {
+        expect(titlesFor(plugin, [
+            { id: 'ses_1', title: 'New session - 2026-10-11T03:29:07.080Z' },
+            { id: 'ses_2', title: 'Child session - 2026-10-11T03:29:07.080Z' },
+        ])).toBe('');
+    });
+    it('ignores sub-agent sessions and events without a title', () => {
+        expect(titlesFor(plugin, [{ id: 'ses_2', parentID: 'ses_1', title: 'Explore repo' }, { id: 'ses_1' }, null])).toBe('');
+    });
+    it('writes a changed title once, not once per event', () => {
+        const out = titlesFor(plugin, [
+            { id: 'ses_1', title: 'First' }, { id: 'ses_1', title: 'First' }, { id: 'ses_1', title: 'Second' },
+        ]);
+        expect(out).toBe(osc('First') + osc('Second'));
+    });
+    it('strips control characters (no escape injection from a model-written title) and caps length', () => {
+        const out = titlesFor(plugin, [{ id: 'ses_1', title: 'ok\x1b]0;evil\x07 title' }, { id: 'ses_1', title: 'x'.repeat(200) }]);
+        expect(out).toBe(osc('ok ]0;evil title') + osc('x'.repeat(79) + '…'));
+    });
+});
+describe('oc-17 launch env', () => {
+    it("switches OpenCode's own terminal title off", () => {
+        expect(opencodeConfig_1.OPENCODE_QUIET_ENV.OPENCODE_DISABLE_TERMINAL_TITLE).toBe('1');
+    });
+    it('hosted autolaunch exports the same switch', () => {
+        const sh = fs.readFileSync(path.join(ROOT, '..', 'infra', 'terminal-image', 'autolaunch.sh'), 'utf-8');
+        expect(sh).toMatch(/export [^\n]*OPENCODE_DISABLE_TERMINAL_TITLE=1/);
+    });
+});

package/dist/__tests__/opencode-transcript-reader.test.d.ts

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