@wenrwa/marketplace-cli 0.7.8 → 0.8.2

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

@@ -0,0 +1,43 @@
+/**
+ * oc-08 — the CANONICAL OpenCode launch config (docs/prd/opencode-engine.md,
+ * ADR-0013, shape verified in oc-04). Pure: no I/O, no process.env.
+ *
+ * The hosted lane (infra/terminal-image/opencode/build-config.js, oc-05) must
+ * emit the SAME JSON for the same inputs; a parity test on each side should pin
+ * it. The OpenRouter key is NEVER an input here: the only credential OpenCode
+ * ever holds is the per-agent gateway token, and it is passed by reference
+ * (`{env:HIVEOP_GATEWAY_TOKEN}`) so it never appears inside the JSON.
+ */
+/** 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_PROVIDER_ID = "hiveop";
+export declare const OPENCODE_GATEWAY_TOKEN_ENV = "HIVEOP_GATEWAY_TOKEN";
+export interface OpencodeConfigInput {
+    /** Chosen model id (the gateway's catalogue id, e.g. an OpenRouter slug). */
+    model: string;
+    /** Full OpenAI-compatible base URL, i.e. `<api>/api/v1/opencode/v1`. */
+    gatewayBaseUrl: string;
+    /** permission "allow" when true (autonomous agent), OpenCode's default otherwise. */
+    autonomous?: boolean;
+    /** Add the wenrwa-marketplace MCP server (token read from env, not inlined). */
+    withMcp?: boolean;
+    /** argv of the MCP server; defaults to npx. */
+    mcpCommand?: string[];
+    /** Extra env var NAMES the MCP server needs, passed by reference (`{env:NAME}`), never inlined. */
+    mcpEnvPassthrough?: string[];
+    /** Project-relative files OpenCode loads as extra instructions. The local lane passes the
+     *  bridge's `.hiveop/context.md` (oc-23): OpenCode has no SessionStart hook to inject it. */
+    instructions?: string[];
+}
+export declare function buildOpencodeConfig(input: OpencodeConfigInput): Record<string, unknown>;
+/** OpenCode session ids are generated by OpenCode (`ses_...`); anything else
+ *  (e.g. the uuid oc-01 pre-mints on the row) would fail "Session not found". */
+export declare const isCapturedOpencodeSessionId: (id: unknown) => id is string;
+/** True iff `versionOutput` (from `opencode --version`) is >= the minimum. */
+export declare function opencodeVersionOk(versionOutput: string | null | undefined, min?: string): boolean;

package/dist/bridge/opencodeConfig.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * oc-08 — the CANONICAL OpenCode launch config (docs/prd/opencode-engine.md,
+ * ADR-0013, shape verified in oc-04). Pure: no I/O, no process.env.
+ *
+ * The hosted lane (infra/terminal-image/opencode/build-config.js, oc-05) must
+ * emit the SAME JSON for the same inputs; a parity test on each side should pin
+ * it. The OpenRouter key is NEVER an input here: the only credential OpenCode
+ * ever holds is the per-agent gateway token, and it is passed by reference
+ * (`{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 = 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_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({
+    OPENCODE_DISABLE_MODELS_FETCH: '1',
+    OPENCODE_DISABLE_AUTOUPDATE: '1',
+    OPENCODE_DISABLE_SHARE: '1',
+    OPENCODE_DISABLE_LSP_DOWNLOAD: '1',
+    // oc-17: the HiveOp plugin sets the pane title itself (a bare "OpenCode" would clobber the auto-title).
+    OPENCODE_DISABLE_TERMINAL_TITLE: '1',
+    npm_config_offline: 'true',
+});
+exports.OPENCODE_PROVIDER_ID = 'hiveop';
+exports.OPENCODE_GATEWAY_TOKEN_ENV = 'HIVEOP_GATEWAY_TOKEN';
+function buildOpencodeConfig(input) {
+    const { model } = input;
+    const config = {
+        $schema: 'https://opencode.ai/config.json',
+        autoupdate: false,
+        share: 'disabled',
+        enabled_providers: [exports.OPENCODE_PROVIDER_ID],
+        model: `${exports.OPENCODE_PROVIDER_ID}/${model}`,
+        // OpenCode makes a second, billed "title" call on the small model.
+        small_model: `${exports.OPENCODE_PROVIDER_ID}/${model}`,
+        provider: {
+            [exports.OPENCODE_PROVIDER_ID]: {
+                npm: '@ai-sdk/openai-compatible',
+                name: 'HiveOp',
+                options: {
+                    baseURL: input.gatewayBaseUrl,
+                    apiKey: `{env:${exports.OPENCODE_GATEWAY_TOKEN_ENV}}`,
+                },
+                whitelist: [model],
+                models: {
+                    [model]: {
+                        name: model,
+                        attachment: true,
+                        tool_call: true,
+                        modalities: { input: ['text', 'image'], output: ['text'] },
+                        limit: { context: 200000, output: 8192 },
+                    },
+                },
+            },
+        },
+    };
+    if (input.instructions && input.instructions.length > 0)
+        config.instructions = [...input.instructions];
+    if (input.autonomous)
+        config.permission = 'allow';
+    if (input.withMcp) {
+        // oc-07: OPENCODE_QUIET_ENV sets npm_config_offline=true for the pane; a bare
+        // npx MCP server inherits it and cannot fetch itself on a cold npm cache
+        // ("MCP error -32000: Connection closed"). Override it for npx only.
+        const cmd = input.mcpCommand ?? ['npx', '@wenrwa/marketplace-mcp'];
+        const usesNpx = /(^|[\\/])npx(\.cmd)?$/.test(cmd[0] ?? '');
+        config.mcp = {
+            'wenrwa-marketplace': {
+                type: 'local',
+                command: cmd,
+                environment: {
+                    WENRWA_CONNECT_TOKEN: '{env:WENRWA_CONNECT_TOKEN}',
+                    ...Object.fromEntries((input.mcpEnvPassthrough ?? []).map((n) => [n, `{env:${n}}`])),
+                    ...(usesNpx ? { npm_config_offline: 'false' } : {}),
+                },
+                enabled: true,
+            },
+        };
+    }
+    return config;
+}
+/** OpenCode session ids are generated by OpenCode (`ses_...`); anything else
+ *  (e.g. the uuid oc-01 pre-mints on the row) would fail "Session not found". */
+const isCapturedOpencodeSessionId = (id) => typeof id === 'string' && /^ses_[A-Za-z0-9]+$/.test(id);
+exports.isCapturedOpencodeSessionId = isCapturedOpencodeSessionId;
+const parseVersion = (v) => {
+    const m = /(\d+)\.(\d+)\.(\d+)/.exec(v);
+    return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+};
+/** True iff `versionOutput` (from `opencode --version`) is >= the minimum. */
+function opencodeVersionOk(versionOutput, min = exports.OPENCODE_MIN_VERSION) {
+    const got = parseVersion(versionOutput ?? '');
+    const want = parseVersion(min);
+    if (!got)
+        return false;
+    for (let i = 0; i < 3; i++) {
+        if (got[i] !== want[i])
+            return got[i] > want[i];
+    }
+    return true;
+}

package/dist/bridge/opencodePlugin.d.ts

@@ -0,0 +1,13 @@
+/**
+ * oc-06 — the HiveOp OpenCode activity plugin (cli/hooks/opencode-plugin.mjs,
+ * shipped in the npm package beside the Claude hooks). The local launch
+ * resolver (oc-08) merges `buildOpenCodePluginConfig()` into the agent's
+ * OPENCODE_CONFIG_CONTENT; OpenCode loads plugins from `plugin: [file URL]`
+ * (the path the oc-04 spike verified). Hosted uses the copy under
+ * /opt/hiveop/opencode/ via the same key.
+ */
+export declare function resolveOpenCodePluginPath(hooksDir?: string): string;
+/** Config fragment to merge into OpenCode's config. pathToFileURL encodes spaces. */
+export declare function buildOpenCodePluginConfig(pluginPath?: string): {
+    plugin: string[];
+};

package/dist/bridge/opencodePlugin.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveOpenCodePluginPath = resolveOpenCodePluginPath;
+exports.buildOpenCodePluginConfig = buildOpenCodePluginConfig;
+const path = __importStar(require("path"));
+const url_1 = require("url");
+/**
+ * oc-06 — the HiveOp OpenCode activity plugin (cli/hooks/opencode-plugin.mjs,
+ * shipped in the npm package beside the Claude hooks). The local launch
+ * resolver (oc-08) merges `buildOpenCodePluginConfig()` into the agent's
+ * OPENCODE_CONFIG_CONTENT; OpenCode loads plugins from `plugin: [file URL]`
+ * (the path the oc-04 spike verified). Hosted uses the copy under
+ * /opt/hiveop/opencode/ via the same key.
+ */
+function resolveOpenCodePluginPath(hooksDir = path.join(__dirname, '..', '..', 'hooks')) {
+    return path.join(hooksDir, 'opencode-plugin.mjs');
+}
+/** Config fragment to merge into OpenCode's config. pathToFileURL encodes spaces. */
+function buildOpenCodePluginConfig(pluginPath = resolveOpenCodePluginPath()) {
+    return { plugin: [(0, url_1.pathToFileURL)(pluginPath).href] };
+}

package/dist/bridge/opencodeTranscriptReader.d.ts

@@ -0,0 +1,24 @@
+export type SqliteRow = Record<string, unknown>;
+/** Run one read-only SELECT. Throws 'sqlite-unavailable' when no driver exists. */
+export type SqliteQuery = (dbPath: string, sql: string) => SqliteRow[];
+export type OpencodeTranscriptResult = {
+    ok: true;
+    content: string;
+} | {
+    ok: false;
+    reason: 'not-found' | 'too-large' | 'transcript-unavailable';
+};
+export interface OpencodeTranscriptDeps {
+    /** Root holding one dir per agent (default $WENRWA_OPENCODE_DATA_ROOT or /data/.opencode). */
+    dataRoot?: string;
+    existsSync?: (p: string) => boolean;
+    query?: SqliteQuery;
+}
+/** Where the hosted launch put this agent's OpenCode database. */
+export declare function opencodeDbPath(agentId: string, deps?: OpencodeTranscriptDeps): string;
+/** Default driver: node:sqlite (Node >= 22.5, the image runs 24), else the sqlite3 CLI. */
+export declare const defaultSqliteQuery: SqliteQuery;
+/** Pure: OpenCode message/part rows -> Claude-shaped jsonl lines. */
+export declare function opencodeRowsToJsonl(sessionId: string, messages: SqliteRow[], parts: SqliteRow[]): string;
+/** Read ONE agent's OpenCode transcript. `sessionId` pins a session; absent -> the newest root session. */
+export declare function readOpencodeTranscript(agentId: string, sessionId: string | undefined, deps?: OpencodeTranscriptDeps): OpencodeTranscriptResult;

package/dist/bridge/opencodeTranscriptReader.js

@@ -0,0 +1,178 @@
+"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.defaultSqliteQuery = void 0;
+exports.opencodeDbPath = opencodeDbPath;
+exports.opencodeRowsToJsonl = opencodeRowsToJsonl;
+exports.readOpencodeTranscript = readOpencodeTranscript;
+/**
+ * oc-17 — the OpenCode half of the wte-10 transcript read. Claude Code keeps
+ * one jsonl per agent; OpenCode (1.18.x, oc-04 findings) keeps every session
+ * in ONE SQLite file, `$XDG_DATA_HOME/opencode/opencode.db`, tables
+ *   session(id 'ses_…', parent_id, title, time_created, time_updated, …)
+ *   message(id, session_id, time_created, data JSON {role, time, …})
+ *   part(id, message_id, session_id, data JSON {type: text|tool|reasoning|…})
+ * Hosted lane: XDG_DATA_HOME is per AGENT (autolaunch.sh):
+ *   <WENRWA_OPENCODE_DATA_ROOT or /data/.opencode>/<agentId>/share/opencode/opencode.db
+ *
+ * The result is re-serialised as Claude-shaped jsonl (user / assistant lines,
+ * tool_use + tool_result blocks) so every consumer of the Claude transcript
+ * reads an OpenCode agent's without knowing the engine. Read-only: the DB is
+ * opened read-only (node:sqlite, else the `sqlite3` CLI); nothing is written,
+ * cached or kept. With neither available the answer is the typed
+ * 'transcript-unavailable' refusal, never a crash.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const claudeTranscriptReader_1 = require("./claudeTranscriptReader");
+const SESSION_ID = /^ses_[A-Za-z0-9]+$/;
+/** Where the hosted launch put this agent's OpenCode database. */
+function opencodeDbPath(agentId, deps = {}) {
+    const root = deps.dataRoot ?? process.env.WENRWA_OPENCODE_DATA_ROOT ?? '/data/.opencode';
+    return path.join(root, agentId, 'share', 'opencode', 'opencode.db');
+}
+/** Default driver: node:sqlite (Node >= 22.5, the image runs 24), else the sqlite3 CLI. */
+const defaultSqliteQuery = (dbPath, sql) => {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { DatabaseSync } = require('node:sqlite');
+        const db = new DatabaseSync(dbPath, { readOnly: true });
+        try {
+            return db.prepare(sql).all();
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (e) {
+        const code = e?.code;
+        if (code !== 'MODULE_NOT_FOUND' && code !== 'ERR_UNKNOWN_BUILTIN_MODULE')
+            throw e;
+    }
+    try {
+        const out = (0, child_process_1.execFileSync)('sqlite3', ['-readonly', '-json', dbPath, sql], {
+            encoding: 'utf-8',
+            maxBuffer: 4 * claudeTranscriptReader_1.MAX_TRANSCRIPT_BYTES,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        return out.trim() ? JSON.parse(out) : [];
+    }
+    catch (e) {
+        if (e?.code === 'ENOENT')
+            throw new Error('sqlite-unavailable');
+        throw e;
+    }
+};
+exports.defaultSqliteQuery = defaultSqliteQuery;
+function parseJson(v) {
+    try {
+        const o = JSON.parse(String(v));
+        return o && typeof o === 'object' ? o : {};
+    }
+    catch {
+        return {};
+    }
+}
+const iso = (ms) => (typeof ms === 'number' ? new Date(ms).toISOString() : undefined);
+/** Pure: OpenCode message/part rows -> Claude-shaped jsonl lines. */
+function opencodeRowsToJsonl(sessionId, messages, parts) {
+    const byMessage = new Map();
+    for (const p of parts) {
+        const list = byMessage.get(String(p.message_id)) ?? [];
+        list.push(parseJson(p.data));
+        byMessage.set(String(p.message_id), list);
+    }
+    const lines = [];
+    const emit = (type, content, ts) => {
+        if (!content.length)
+            return;
+        lines.push(JSON.stringify({ type, sessionId, timestamp: iso(ts), message: { role: type, content } }));
+    };
+    for (const m of messages) {
+        const info = parseJson(m.data);
+        const role = info.role === 'assistant' ? 'assistant' : 'user';
+        const content = [];
+        const results = [];
+        for (const part of byMessage.get(String(m.id)) ?? []) {
+            if (part.type === 'text' && typeof part.text === 'string' && part.text) {
+                content.push({ type: 'text', text: part.text });
+            }
+            else if (part.type === 'file') {
+                content.push({ type: 'text', text: `[file: ${part.filename ?? part.mime ?? 'attachment'}]` });
+            }
+            else if (part.type === 'tool' && role === 'assistant') {
+                const st = part.state ?? {};
+                content.push({ type: 'tool_use', id: part.callID, name: part.tool, input: st.input ?? {} });
+                if (st.status === 'completed') {
+                    results.push({ type: 'tool_result', tool_use_id: part.callID, content: String(st.output ?? '') });
+                }
+                else if (st.status === 'error') {
+                    results.push({ type: 'tool_result', tool_use_id: part.callID, is_error: true, content: String(st.error ?? '') });
+                }
+            }
+        }
+        emit(role, content, m.time_created);
+        emit('user', results, m.time_created);
+    }
+    return lines.length ? lines.join('\n') + '\n' : '';
+}
+/** Read ONE agent's OpenCode transcript. `sessionId` pins a session; absent -> the newest root session. */
+function readOpencodeTranscript(agentId, sessionId, deps = {}) {
+    const existsSync = deps.existsSync ?? fs.existsSync;
+    const query = deps.query ?? exports.defaultSqliteQuery;
+    if (sessionId !== undefined && !SESSION_ID.test(sessionId))
+        return { ok: false, reason: 'not-found' };
+    const db = opencodeDbPath(agentId, deps);
+    if (!existsSync(db))
+        return { ok: false, reason: 'not-found' };
+    try {
+        const sessions = sessionId
+            ? query(db, `SELECT id FROM session WHERE id = '${sessionId}'`)
+            : query(db, 'SELECT id FROM session WHERE parent_id IS NULL ORDER BY time_updated DESC LIMIT 1');
+        const id = sessions[0]?.id;
+        if (typeof id !== 'string' || !SESSION_ID.test(id))
+            return { ok: false, reason: 'not-found' };
+        const messages = query(db, `SELECT id, time_created, data FROM message WHERE session_id = '${id}' ORDER BY time_created, id`);
+        const parts = query(db, `SELECT message_id, data FROM part WHERE session_id = '${id}' ORDER BY message_id, id`);
+        const content = opencodeRowsToJsonl(id, messages, parts);
+        if (Buffer.byteLength(content) > claudeTranscriptReader_1.MAX_TRANSCRIPT_BYTES)
+            return { ok: false, reason: 'too-large' };
+        return { ok: true, content };
+    }
+    catch {
+        return { ok: false, reason: 'transcript-unavailable' };
+    }
+}

package/dist/bridge/relayClient.d.ts

@@ -1,3 +1,23 @@
+/**
+ * ht-05 — Terminal Bridge relay mode (dial-out).
+ *
+ * Instead of listening on localhost for browser connections (server.ts),
+ * this DIALS OUT to the platform relay over a single outbound wss
+ * connection, authenticates with a per-container relay token, and serves
+ * the same v1 frame protocol (see PROTOCOL.md) through the existing
+ * SessionManager. Multi-session multiplexing is unchanged: every frame
+ * already carries a sessionId, so one outbound socket serves every session
+ * exactly like the local server serves them over N inbound sockets.
+ *
+ * PTYs live in the SessionManager, not the socket — a relay drop never
+ * kills a session. This module owns only: dialing out, the auth frame,
+ * frame routing through SessionManager, and reconnect-with-backoff. It
+ * does no scrollback bookkeeping of its own (SessionManager already does
+ * that) — on re-pair the pane sends `attach` again and gets a fresh
+ * `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';
@@ -163,6 +183,8 @@ export interface RelayClientOpts {
         workspaceId?: string;
         sessionId?: string;
         autonomous?: boolean;
+        opencode?: OpencodeLaunchInput;
+        connectToken?: string;
     }) => {
         command: string;
         args: string[];
@@ -179,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.
      *
@@ -214,6 +242,7 @@ export interface RelayClientOpts {
     installBundle?: (bundle: {
         workspaceId: string;
         files: Record<string, string>;
+        engine?: string;
     }) => {
         written: string[];
         skipped: Array<{
@@ -237,10 +266,12 @@ export interface RelayClientOpts {
      */
     refreshContextPointers?: (args: {
         workspaceId: string;
+        engine?: string;
     }) => void | Promise<void>;
     writeContext?: (manifest: {
         workspaceId: string;
         content: string;
+        engine?: string;
     }) => {
         action: string;
         claudeMdPath: string | null;
@@ -307,12 +338,14 @@ export interface RelayClientOpts {
     readTranscript?: (args: {
         workspaceId: string;
         agentId: string;
+        engine?: 'claude_code' | 'opencode';
+        opencodeSessionId?: string;
     }) => {
         ok: true;
         content: string;
     } | {
         ok: false;
-        reason: 'not-found' | 'invalid-agent-id' | 'too-large';
+        reason: 'not-found' | 'invalid-agent-id' | 'too-large' | 'transcript-unavailable';
     };
     /** Injectable for tests: defaults to `new WebSocket(url)` from `ws`. */
     wsFactory?: (url: string) => WebSocketLike;