commandmate 0.42.2 → 0.44.0

package/dist/server/src/lib/cli-tools/opencode-executable.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * Which `opencode` is OpenCode 1.x and which is OpenCode V2 (Issue #2939).
+ *
+ * ## Why the name is not enough
+ *
+ * OpenCode V2's npm package `@opencode/cli` (2.0.18) registers **both**
+ * `opencode` and `opencode2` in its `bin`. So on a machine that has it,
+ * `opencode` may be OpenCode 1.x (its own installer, `~/.opencode/bin`) or
+ * OpenCode V2 (`/opt/homebrew/bin/opencode`), decided by nothing but the order
+ * of `PATH`. Asking `which opencode` then answers "OpenCode is installed" for a
+ * V2 binary, and the v1 launch line (`opencode --port N --hostname …`) reaches
+ * a program that has neither flag.
+ *
+ * The answer here is the version each candidate prints about itself:
+ *
+ *  - OpenCode 1.x prints a bare `1.18.33`;
+ *  - OpenCode V2 prints `opencode v2.0.18`.
+ *
+ * Every `opencode` / `opencode2` on `PATH` is a candidate, not just the first,
+ * so a V2 `opencode` earlier on `PATH` no longer hides a 1.x one behind it.
+ *
+ * ## Probe and launch are one measurement
+ *
+ * The path that answered is the path the launch line runs — the rule
+ * `./copilot-executable` set for copilot (#1907). The server resolves names on
+ * its own `PATH`, the pane on its login shell's; typing a bare `opencode` would
+ * let the two disagree.
+ *
+ * ## Cost
+ *
+ * `opencode --version` takes ~0.4 s and both tools probe `opencode`, so one
+ * probe per path is shared for {@link OPENCODE_EXECUTABLE_CACHE_TTL_MS}, and a
+ * concurrent caller gets the probe already in flight.
+ *
+ * @module lib/cli-tools/opencode-executable
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPENCODE_EXECUTABLE_CACHE_TTL_MS = exports.OPENCODE_VERSION_PROBE_TIMEOUT_MS = exports.OPENCODE_V2_BINARY_NAME = exports.OPENCODE_V1_BINARY_NAME = void 0;
+exports.parseOpencodeVersionOutput = parseOpencodeVersionOutput;
+exports.clearOpencodeExecutableCache = clearOpencodeExecutableCache;
+exports.probeOpencodeExecutable = probeOpencodeExecutable;
+exports.resolveOpencodeV1Executable = resolveOpencodeV1Executable;
+exports.resolveOpencodeV2Executable = resolveOpencodeV2Executable;
+exports.describeOpencodeV1Unavailable = describeOpencodeV1Unavailable;
+const child_process_1 = require("child_process");
+const copilot_executable_1 = require("./copilot-executable");
+const env_sanitizer_1 = require("../security/env-sanitizer");
+/** OpenCode 1.x's executable name (tool id `opencode`). */
+exports.OPENCODE_V1_BINARY_NAME = 'opencode';
+/** OpenCode V2's own executable name (tool id `opencode-v2`). */
+exports.OPENCODE_V2_BINARY_NAME = 'opencode2';
+/** Budget for one `--version`. */
+exports.OPENCODE_VERSION_PROBE_TIMEOUT_MS = 5000;
+/** `--version` prints one short line; anything bigger is not an answer. */
+const OPENCODE_VERSION_PROBE_MAX_BUFFER = 64 * 1024;
+/** How long one probe result is reused (same TTL as the installed-agents cache). */
+exports.OPENCODE_EXECUTABLE_CACHE_TTL_MS = 30_000;
+/** Candidates probed per name. A PATH with more copies than this is not a setup to guess about. */
+const MAX_CANDIDATES_PER_NAME = 4;
+/** `opencode v2.0.18` — OpenCode V2's form. */
+const PREFIXED_VERSION_LINE = /^opencode v(\d+)\.(\d+)\.(\d+)((?:[-+][0-9A-Za-z.-]+)?)$/;
+/** `1.18.33` — OpenCode 1.x's form: the version and nothing else. */
+const BARE_VERSION_LINE = /^v?(\d+)\.(\d+)\.(\d+)((?:[-+][0-9A-Za-z.-]+)?)$/;
+/**
+ * Classify `opencode --version` / `opencode2 --version` output.
+ *
+ * A line has to be a version in one of the two forms and nothing else, so a
+ * different program that happens to print a number is not taken for either.
+ * The major version decides: 1 is OpenCode 1.x, 2 or later is OpenCode V2.
+ * `0.x` (the pre-1.0 `opencode`) and anything unreadable are null.
+ *
+ * @returns The generation and version, or null when the output is not OpenCode's
+ */
+function parseOpencodeVersionOutput(output) {
+    for (const rawLine of output.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const match = PREFIXED_VERSION_LINE.exec(line) ?? BARE_VERSION_LINE.exec(line);
+        if (!match)
+            continue;
+        const major = Number(match[1]);
+        const version = `${match[1]}.${match[2]}.${match[3]}${match[4] ?? ''}`;
+        if (major === 1)
+            return { generation: 'v1', version };
+        if (major >= 2)
+            return { generation: 'v2', version };
+        return null;
+    }
+    return null;
+}
+const probeCache = new Map();
+/** Forget every cached probe (tests, and a caller that knows the install changed). */
+function clearOpencodeExecutableCache() {
+    probeCache.clear();
+}
+function runVersionProbe(executable) {
+    return new Promise((resolve) => {
+        try {
+            (0, child_process_1.execFile)(executable, ['--version'], {
+                timeout: exports.OPENCODE_VERSION_PROBE_TIMEOUT_MS,
+                maxBuffer: OPENCODE_VERSION_PROBE_MAX_BUFFER,
+                env: (0, env_sanitizer_1.sanitizeEnvForChildProcess)(),
+            }, (error, stdout, stderr) => {
+                if (error) {
+                    resolve(null);
+                    return;
+                }
+                resolve(parseOpencodeVersionOutput(`${stdout ?? ''}\n${stderr ?? ''}`));
+            });
+        }
+        catch {
+            resolve(null);
+        }
+    });
+}
+/** `<path> --version`, classified; cached per path. Never rejects. */
+function probeOpencodeExecutable(path) {
+    const now = Date.now();
+    const cached = probeCache.get(path);
+    if (cached && cached.expiresAt > now)
+        return cached.info;
+    const info = runVersionProbe(path);
+    probeCache.set(path, { expiresAt: now + exports.OPENCODE_EXECUTABLE_CACHE_TTL_MS, info });
+    return info;
+}
+/** Probe `names` in order and return the first candidate of `generation`. */
+async function resolveGeneration(names, generation) {
+    const probed = [];
+    for (const name of names) {
+        for (const path of (0, copilot_executable_1.findExecutablesOnPath)(name, MAX_CANDIDATES_PER_NAME)) {
+            if (probed.some((p) => p.path === path))
+                continue;
+            const info = await probeOpencodeExecutable(path);
+            probed.push({ path, info });
+            if (info?.generation === generation) {
+                return { executable: { path, version: info.version, generation }, probed };
+            }
+        }
+    }
+    return { executable: null, probed };
+}
+/**
+ * OpenCode 1.x: the first `opencode` on `PATH` that prints a 1.x version.
+ * An `opencode` that answers `opencode v2.x` is skipped, never launched.
+ */
+function resolveOpencodeV1Executable() {
+    return resolveGeneration([exports.OPENCODE_V1_BINARY_NAME], 'v1');
+}
+/**
+ * OpenCode V2: `opencode2` first, then an `opencode` that prints
+ * `opencode v2.x` — for an operator who has V2 only under the `opencode` name.
+ */
+function resolveOpencodeV2Executable() {
+    return resolveGeneration([exports.OPENCODE_V2_BINARY_NAME, exports.OPENCODE_V1_BINARY_NAME], 'v2');
+}
+/**
+ * Why OpenCode 1.x counts as not installed, when there is more to say than
+ * "no `opencode` on PATH".
+ *
+ * @returns A sentence naming the `opencode` that is there and what it is, or
+ *   null when nothing called `opencode` was found at all
+ */
+function describeOpencodeV1Unavailable(resolution) {
+    if (resolution.executable)
+        return null;
+    const v2 = resolution.probed.find((p) => p.info?.generation === 'v2');
+    if (v2?.info) {
+        return (`\`opencode\` at ${v2.path} is OpenCode V2 ${v2.info.version}, not OpenCode 1.x ` +
+            '(npm `@opencode/cli` registers both `opencode` and `opencode2`). ' +
+            'Use the OpenCode V2 agent, or put an OpenCode 1.x `opencode` on PATH.');
+    }
+    const other = resolution.probed[0];
+    if (other) {
+        return `\`opencode\` at ${other.path} did not report an OpenCode 1.x version (\`opencode --version\`).`;
+    }
+    return null;
+}

package/dist/server/src/lib/cli-tools/opencode-v2.js

@@ -0,0 +1,369 @@
+"use strict";
+/**
+ * OpenCode V2 (`opencode2`) CLI tool (Issue #2934, Epic #2370 Phase 1).
+ *
+ * A separate tool from `opencode` (v1), not a version branch of it: OpenCode
+ * 2.0's server, event vocabulary and screen all differ, and v1 keeps every
+ * behaviour it had (Epic #2370, decision 1).
+ *
+ * ## The pane
+ *
+ * One tmux pane holds both processes OpenCode V2 needs. The launch line runs
+ * `scripts/opencode-v2/launch.sh`, which starts `opencode2 serve` on the
+ * instance's own port with the instance's own password, waits for
+ * `GET /openapi.json`, runs `opencode2 --server <url> <worktree>` in the
+ * foreground, and — through a trap on EXIT / HUP / INT / TERM — stops the server
+ * whichever way the TUI goes. So `/exit`, a crashed TUI and `tmux kill-session`
+ * all release the port (the #1905 failure, prevented by construction), and a
+ * CommandMate restart leaves both running because neither is CommandMate's
+ * child.
+ *
+ * ## What is structured and what is read off the screen
+ *
+ *  - state (running / ready / waiting) comes from the server's SSE stream
+ *    (`@/lib/hooks/sources/opencode-v2`), subscribed once the TUI is up;
+ *  - sending goes through the TUI's composer via tmux, as for v1's fallback
+ *    path (D6). `session.prompt` is not used: it addresses a session by id, and
+ *    the TUI may be showing a different one;
+ *  - the screen scraper still reads the pane, as every tool's fallback.
+ *
+ * Phase 2 adds approvals / questions / History, Phase 3 richer screen reading
+ * and quick keys ({@link OpenCodeV2Tool.navigationKeys}, Issue #2966).
+ *
+ * @module lib/cli-tools/opencode-v2
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenCodeV2Tool = exports.OPENCODE_V2_NAVIGATION_KEY_VALUES = exports.OPENCODE_V2_RESUME_RETRY_MS = exports.OPENCODE_V2_READY_MAX_ATTEMPTS = exports.OPENCODE_V2_READY_POLL_INTERVAL_MS = void 0;
+exports.parseOpencodeV2Version = parseOpencodeV2Version;
+exports.toOpencodeV2ComposerText = toOpencodeV2ComposerText;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const base_1 = require("./base");
+const terminal_keys_1 = require("../../types/terminal-keys");
+const tmux_1 = require("../tmux/tmux");
+const cli_patterns_1 = require("../detection/cli-patterns");
+const submit_verified_sender_1 = require("./submit-verified-sender");
+const tmux_capture_cache_1 = require("../tmux/tmux-capture-cache");
+const tmux_pane_config_1 = require("../../config/tmux-pane-config");
+const logger_1 = require("../../lib/logger");
+const errors_1 = require("../../lib/errors");
+const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifecycle");
+const runtime_1 = require("../../lib/hooks/sources/opencode-v2/runtime");
+const client_1 = require("../../lib/hooks/sources/opencode-v2/client");
+const ports_1 = require("../../lib/hooks/sources/opencode-v2/ports");
+const subscription_1 = require("../../lib/hooks/sources/opencode-v2/subscription");
+const tool_id_1 = require("../../lib/hooks/sources/opencode-v2/tool-id");
+const graceful_exit_1 = require("./graceful-exit");
+const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
+const install_hints_1 = require("./install-hints");
+const opencode_executable_1 = require("./opencode-executable");
+const logger = (0, logger_1.createLogger)('cli-tools/opencode-v2');
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+/** Interval between composer polls (launch and send). */
+exports.OPENCODE_V2_READY_POLL_INTERVAL_MS = 500;
+/** Composer polls after the launch line before giving up (30 s at 500 ms). */
+exports.OPENCODE_V2_READY_MAX_ATTEMPTS = 60;
+/** Rows captured when looking for the composer. The pane is 200 rows tall. */
+const OPENCODE_V2_READY_CAPTURE_LINES = tmux_pane_config_1.OPENCODE_PANE_HEIGHT;
+/**
+ * How long a failed lazy resume is not retried (ms). `isRunning` is polled, and
+ * a server that is really gone must not be probed on every poll.
+ */
+exports.OPENCODE_V2_RESUME_RETRY_MS = 30_000;
+/**
+ * The version `opencode2 --version` reports, or null when the output is not
+ * OpenCode V2's. Issue #2939: the same rule OpenCode 1.x is told apart by
+ * (`./opencode-executable`), so `1.18.33` is not V2 and `opencode v2.0.18` is.
+ */
+function parseOpencodeV2Version(output) {
+    const info = (0, opencode_executable_1.parseOpencodeVersionOutput)(output);
+    return info?.generation === 'v2' ? info.version : null;
+}
+/** A bare `/<name>`: a slash command with no argument and no whitespace at all. */
+const BARE_SLASH_COMMAND = /^\/\S+$/;
+/**
+ * The text to type for `message` (Issue #2950).
+ *
+ * The TUI opens its command dropdown on any composer text starting with `/`,
+ * and while it is open Enter picks a row instead of submitting — so a bare
+ * `/probe-agentsskills` sits in the composer ("No matching commands") and runs
+ * nothing, while `/probe-agentsskills ` (one trailing space) closes the
+ * dropdown and runs. The palette already inserts `` `${trigger} ` `` (see
+ * `loadOpencodeSkills` in `@/lib/slash-commands`, "The trailing space is
+ * load-bearing"), but the send route trims the body, so the space never
+ * arrives. It is put back here, and only for a bare `/<name>`: a command with
+ * an argument already has a space after the name, and ordinary text does not
+ * open the dropdown.
+ */
+function toOpencodeV2ComposerText(message) {
+    return BARE_SLASH_COMMAND.test(message) ? `${message} ` : message;
+}
+/**
+ * The leader-chord letters OpenCode V2 2.0.18 answers on its home screen, as
+ * sent by `OpencodeQuickKeys`' v2 strip (Issue #2966): `a` agents, `l`
+ * sessions, `m` models. `n` (new session) is also sent, but is already in
+ * {@link NAVIGATION_KEY_VALUES} (#2254), so it is not listed twice.
+ *
+ * Deliberately narrower than v1's `OPENCODE_CHORD_ONLY_VALUES`. Measured on
+ * 2.0.18 (private tmux socket, 80 columns, isolated `HOME` / XDG dirs):
+ * `ctrl+x t` is not `theme_list` any more — on the home screen the leader lets
+ * the `t` through into the composer, and inside a session it opens a terminal
+ * pane. `g` / `u` / `r` / `c` work only inside a session and type their letter
+ * into the composer otherwise; the strip does not offer them for v2 (see
+ * `OpencodeQuickKeys`), so they are not declared either.
+ */
+const OPENCODE_V2_CHORD_ONLY_VALUES = ['a', 'l', 'm'];
+/**
+ * Everything an OpenCode V2 pane may be sent through `/special-keys`: the base
+ * pad plus the `ctrl+x` leader, `ctrl+p` / `ctrl+t`, and the three chord
+ * letters above (Issue #2966).
+ */
+exports.OPENCODE_V2_NAVIGATION_KEY_VALUES = [
+    ...terminal_keys_1.NAVIGATION_KEY_VALUES,
+    terminal_keys_1.OPENCODE_LEADER_KEY,
+    ...terminal_keys_1.OPENCODE_DIRECT_KEY_VALUES,
+    ...OPENCODE_V2_CHORD_ONLY_VALUES,
+];
+class OpenCodeV2Tool extends base_1.BaseCLITool {
+    id = tool_id_1.OPENCODE_V2_CLI_TOOL_ID;
+    name = 'OpenCode V2';
+    command = tool_id_1.OPENCODE_V2_COMMAND;
+    /** Last lazy-resume attempt per session name, for {@link OPENCODE_V2_RESUME_RETRY_MS}. */
+    resumeAttemptedAt = new Map();
+    /**
+     * Declare the keys OpenCode V2's quick keys send (Issue #2966).
+     *
+     * Without this override the route validates against the base pad and answers
+     * 400 for `C-p` / `C-t` / `C-x`, so the palette, the variant cycle and every
+     * leader chord on the strip would be unsendable. The leader is `ctrl+x`, the
+     * same default as v1 — 2.0.18's own palette prints `ctrl+x m`, `ctrl+x a`,
+     * `ctrl+x l`, `ctrl+x n`.
+     *
+     * @returns This tool's {@link NavigationKeySpec}
+     */
+    navigationKeys() {
+        return {
+            keys: exports.OPENCODE_V2_NAVIGATION_KEY_VALUES,
+            leaderKey: terminal_keys_1.OPENCODE_LEADER_KEY,
+        };
+    }
+    /**
+     * Installed means an executable that identifies itself as OpenCode V2
+     * (`opencode v<semver>`, D1): `opencode2`, or — Issue #2939 — an `opencode`
+     * that answers as V2, for an operator who has V2 under that name only.
+     */
+    async isInstalled() {
+        return (await (0, opencode_executable_1.resolveOpencodeV2Executable)()).executable !== null;
+    }
+    /**
+     * Whether the instance's tmux session exists.
+     *
+     * A live session this process holds no subscription for — a pane that
+     * outlived a CommandMate restart — gets its event stream back here, fire and
+     * forget and at most every {@link OPENCODE_V2_RESUME_RETRY_MS}, so status
+     * comes from the server again as soon as anything polls the pane.
+     */
+    async isRunning(worktreeId, instanceId) {
+        const sessionName = this.getSessionName(worktreeId, instanceId);
+        const running = await (0, tmux_1.hasSession)(sessionName);
+        if (running)
+            this.resumeInBackground(worktreeId, sessionName, instanceId);
+        return running;
+    }
+    resumeInBackground(worktreeId, sessionName, instanceId) {
+        const target = (0, runtime_1.opencodeV2Target)(worktreeId, instanceId);
+        if ((0, subscription_1.isOpencodeV2Subscribed)(target))
+            return;
+        const now = Date.now();
+        const last = this.resumeAttemptedAt.get(sessionName);
+        if (last !== undefined && now - last < exports.OPENCODE_V2_RESUME_RETRY_MS)
+            return;
+        this.resumeAttemptedAt.set(sessionName, now);
+        void (async () => {
+            try {
+                const worktreePath = await (0, tmux_1.getSessionWorkingDirectory)(sessionName);
+                if (worktreePath === null)
+                    return;
+                await (0, runtime_1.resumeOpencodeV2EventStream)(target, worktreePath);
+            }
+            catch (error) {
+                logger.debug('opencode-v2-lazy-resume-failed', { error: (0, errors_1.getErrorMessage)(error) });
+            }
+        })();
+    }
+    async launchSession(worktreeId, worktreePath, instanceId) {
+        // Issue #2939: the file that answered as V2 is the file the line runs.
+        const executable = (await (0, opencode_executable_1.resolveOpencodeV2Executable)()).executable;
+        if (!executable) {
+            throw (0, install_hints_1.missingToolError)(this);
+        }
+        const sessionName = this.getSessionName(worktreeId, instanceId);
+        const target = (0, runtime_1.opencodeV2Target)(worktreeId, instanceId);
+        const geometry = { windowWidth: (0, tmux_pane_config_1.resolveOpencodePaneWidth)(), windowHeight: tmux_pane_config_1.OPENCODE_PANE_HEIGHT };
+        const exists = await (0, tmux_1.hasSession)(sessionName);
+        if (exists) {
+            await this.reconcileExistingSession(sessionName, worktreePath, geometry);
+            if (await this.isToolLive(sessionName, { confirm: true })) {
+                await (0, runtime_1.resumeOpencodeV2EventStream)(target, worktreePath);
+                logger.info('opencode-v2-session-exists');
+                return;
+            }
+            logger.warn('opencode-v2-session-relaunch', { sessionName });
+            // The pane is back at its shell, so whatever it held is gone with it.
+            await (0, runtime_1.releaseOpencodeV2Server)(target);
+        }
+        (0, agent_session_lifecycle_1.beginAgentSession)(target);
+        try {
+            if (!exists) {
+                await (0, tmux_1.createSession)({ sessionName, workingDirectory: worktreePath });
+                await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_SESSION_CREATE_WAIT_MS));
+            }
+            try {
+                await execFileAsync('tmux', [
+                    'resize-window', '-t', (0, tmux_1.exactTarget)(sessionName),
+                    '-x', String(geometry.windowWidth), '-y', String(geometry.windowHeight),
+                ]);
+            }
+            catch {
+                // Non-fatal, as for v1: the TUI still starts at whatever size it gets.
+            }
+            // Port and password first: the launch line is built from both.
+            const port = await (0, runtime_1.reserveOpencodeV2Server)(target, worktreePath);
+            if (port === null) {
+                logger.warn('opencode-v2-launch-without-server', { worktreeId, instanceId });
+            }
+            await (0, tmux_1.sendKeys)(sessionName, (0, agent_session_lifecycle_1.buildAgentLaunchCommandLine)({ target, executablePath: executable.path, worktreePath }), true);
+            await this.waitForReady(sessionName);
+            await (0, runtime_1.attachOpencodeV2EventStream)(target);
+            logger.info('started-opencode-v2-session');
+        }
+        catch (error) {
+            throw new Error(`Failed to start OpenCode V2 session: ${(0, errors_1.getErrorMessage)(error)}`);
+        }
+    }
+    /** Poll until the composer is on screen (or give up quietly). */
+    async waitForReady(sessionName) {
+        for (let attempt = 0; attempt < exports.OPENCODE_V2_READY_MAX_ATTEMPTS; attempt++) {
+            try {
+                const output = (0, cli_patterns_1.stripAnsi)(await (0, tmux_1.capturePane)(sessionName, OPENCODE_V2_READY_CAPTURE_LINES));
+                if ((0, cli_patterns_1.isOpencodeV2ComposerVisible)(output)) {
+                    logger.info('opencode-v2-composer-detected', { attempt });
+                    return true;
+                }
+            }
+            catch {
+                // The pane may not be readable yet; keep polling.
+            }
+            await new Promise((resolve) => setTimeout(resolve, exports.OPENCODE_V2_READY_POLL_INTERVAL_MS));
+        }
+        logger.info('opencode-v2-ready-detection-timeout');
+        return false;
+    }
+    /**
+     * Wait for the composer before typing into it (D6).
+     *
+     * Issue #2971: a dialog open over the composer (model / variant picker,
+     * Commands, Sessions, agents) leaves the footer on screen, so the composer
+     * check alone passes and the text went into the dialog's filter. The send is
+     * refused instead, on the first frame that shows one: the dialog is someone's
+     * choice in progress, so it is neither dismissed (Escape would throw that
+     * choice away) nor waited out (nothing closes it but a person).
+     *
+     * @throws When a dialog is open, or when the composer does not appear within
+     *   {@link OPENCODE_V2_COMPOSER_WAIT_MS}
+     */
+    async waitForComposer(sessionName) {
+        const deadline = Date.now() + cli_tool_timing_config_1.OPENCODE_V2_COMPOSER_WAIT_MS;
+        for (;;) {
+            let dialog = null;
+            try {
+                const output = (0, cli_patterns_1.stripAnsi)(await (0, tmux_1.capturePane)(sessionName, OPENCODE_V2_READY_CAPTURE_LINES));
+                dialog = (0, cli_patterns_1.findOpencodeV2DialogTitle)(output);
+                if (dialog === null && (0, cli_patterns_1.isOpencodeV2ComposerVisible)(output))
+                    return;
+            }
+            catch {
+                // Treated as "not yet".
+            }
+            if (dialog !== null) {
+                throw new Error(`OpenCode V2 composer not available: the "${dialog}" dialog is open. ` +
+                    'Close it (esc) or finish the choice, then send again');
+            }
+            if (Date.now() >= deadline)
+                break;
+            await new Promise((resolve) => setTimeout(resolve, exports.OPENCODE_V2_READY_POLL_INTERVAL_MS));
+        }
+        throw new Error('OpenCode V2 composer not ready: timed out waiting for it before sending');
+    }
+    async sendMessage(worktreeId, message, instanceId) {
+        const sessionName = this.getSessionName(worktreeId, instanceId);
+        if (!(await (0, tmux_1.hasSession)(sessionName))) {
+            throw new Error(`OpenCode V2 session ${sessionName} does not exist. Start the session first.`);
+        }
+        await this.relaunchIfToolExited(worktreeId, instanceId);
+        try {
+            await this.waitForComposer(sessionName);
+            await (0, submit_verified_sender_1.sendMessageWithSubmitVerification)({
+                sessionName,
+                message: toOpencodeV2ComposerText(message),
+                cliToolId: tool_id_1.OPENCODE_V2_CLI_TOOL_ID,
+                composer: this.describeComposer(),
+            });
+            (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+            logger.info('sent-message-to-opencode-v2-session');
+        }
+        catch (error) {
+            throw new Error(`Failed to send message to OpenCode V2: ${(0, errors_1.getErrorMessage)(error)}`);
+        }
+    }
+    /**
+     * Stop the TUI and, through the wrapper's trap, its server.
+     *
+     * `/exit` and a separate Enter first (the declared graceful sequence), then
+     * the postcondition: the session gone AND the port no longer answering. If
+     * either fails the session is killed — the SIGHUP reaches the wrapper, whose
+     * trap stops the server. Everything the instance held (subscription, port,
+     * password file) is released at the end.
+     */
+    async killSession(worktreeId, instanceId) {
+        const sessionName = this.getSessionName(worktreeId, instanceId);
+        const target = (0, runtime_1.opencodeV2Target)(worktreeId, instanceId);
+        const port = (0, ports_1.getAssignedOpencodeV2Port)(target);
+        try {
+            if (await (0, tmux_1.hasSession)(sessionName)) {
+                await (0, tmux_1.sendKeys)(sessionName, graceful_exit_1.OPENCODE_V2_EXIT_COMMAND_TEXT, false);
+                await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS));
+                await (0, tmux_1.sendSpecialKeys)(sessionName, ['Enter']);
+                await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.OPENCODE_V2_EXIT_WAIT_MS));
+                const verdict = await (0, graceful_exit_1.verifyGracefulExit)({
+                    sessionAlive: () => (0, tmux_1.hasSession)(sessionName),
+                    portAnswering: port === null
+                        ? null
+                        : async () => (await (0, client_1.probeOpencodeV2Server)(port, '')).kind !== 'unreachable',
+                });
+                if (!verdict.ok) {
+                    logger.info('opencode-v2-graceful-exit-postcondition-unmet', {
+                        sessionName,
+                        reason: verdict.reason,
+                        ...(port !== null ? { port } : {}),
+                    });
+                    await (0, tmux_1.killSession)(sessionName);
+                }
+            }
+            else {
+                await (0, tmux_1.killSession)(sessionName);
+            }
+            (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+            this.resumeAttemptedAt.delete(sessionName);
+            logger.info('stopped-opencode-v2-session');
+        }
+        catch (error) {
+            logger.error('session:stop-failed', { error: (0, errors_1.getErrorMessage)(error) });
+            throw error;
+        }
+        finally {
+            await (0, runtime_1.releaseOpencodeV2Server)(target);
+        }
+    }
+}
+exports.OpenCodeV2Tool = OpenCodeV2Tool;

package/dist/server/src/lib/cli-tools/opencode.js

@@ -73,6 +73,8 @@ const opencode_session_store_1 = require("../../lib/session/opencode-session-sto
 const graceful_exit_1 = require("./graceful-exit");
 const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
 const install_hints_1 = require("./install-hints");
+const opencode_executable_1 = require("./opencode-executable");
+const log_diagnosis_1 = require("../../lib/hooks/sources/opencode/log-diagnosis");
 const logger = (0, logger_1.createLogger)('cli-tools/opencode');
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 /**
@@ -227,6 +229,14 @@ class OpenCodeTool extends base_1.BaseCLITool {
             leaderKey: terminal_keys_1.OPENCODE_LEADER_KEY,
         };
     }
+    /**
+     * Installed means an `opencode` on PATH that reports a 1.x version (Issue
+     * #2939). `which opencode` is not enough: npm `@opencode/cli` registers
+     * `opencode` for OpenCode V2 too. See `./opencode-executable`.
+     */
+    async isInstalled() {
+        return (await (0, opencode_executable_1.resolveOpencodeV1Executable)()).executable !== null;
+    }
     /**
      * Check if OpenCode session is running for a worktree
      */
@@ -242,9 +252,12 @@ class OpenCodeTool extends base_1.BaseCLITool {
      * @param worktreePath - Worktree path
      */
     async launchSession(worktreeId, worktreePath, instanceId) {
-        const opencodeAvailable = await this.isInstalled();
-        if (!opencodeAvailable) {
-            throw (0, install_hints_1.missingToolError)(this);
+        // Issue #2939: one resolution decides both whether to start and what to
+        // run, so the launch line names the very file that answered as 1.x.
+        const resolution = await (0, opencode_executable_1.resolveOpencodeV1Executable)();
+        const executable = resolution.executable;
+        if (!executable) {
+            throw (0, install_hints_1.missingToolError)(this, (0, opencode_executable_1.describeOpencodeV1Unavailable)(resolution));
         }
         const sessionName = this.getSessionName(worktreeId, instanceId);
         const target = (0, runtime_1.opencodeTarget)(worktreeId, instanceId);
@@ -355,7 +368,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
             // variable, because CommandMate holds the connection (#1846).
             const plannedCommand = (0, agent_session_lifecycle_1.buildAgentLaunchCommandLine)({
                 target,
-                executablePath: this.command,
+                executablePath: executable.path,
                 worktreePath,
             });
             // Issue #2038: continue the conversation this instance was in before it
@@ -379,6 +392,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
                     sessionId: resumeSessionId,
                 });
             }
+            const launchedAt = Date.now();
             await (0, tmux_1.sendKeys)(sessionName, launchCommand, true);
             // Issue #1908: poll for opencode's own composer instead of sleeping 15 s.
             await this.waitForReady(sessionName);
@@ -393,7 +407,17 @@ class OpenCodeTool extends base_1.BaseCLITool {
             // with the server already listening, which the fixed 15 s wait did not
             // guarantee: the 22.8 s run had nothing to probe at 15 s and would have
             // lost structured events for the whole session.
-            await (0, runtime_1.attachOpencodeEventStream)(target);
+            const attached = await (0, runtime_1.attachOpencodeEventStream)(target);
+            // Issue #2939 (D2): a server that never answered may be OpenCode 1.x
+            // dying on the database OpenCode V2 migrated. opencode's own log says so;
+            // when it does, that is the start error. Otherwise nothing changes.
+            if (!attached && (0, ports_1.getAssignedOpencodePort)(target) !== null) {
+                const conflict = await (0, log_diagnosis_1.findOpencodeSharedDataConflict)(launchedAt);
+                if (conflict !== null) {
+                    logger.warn('opencode-shared-data-conflict', { worktreeId, finding: conflict });
+                    throw new Error((0, log_diagnosis_1.buildOpencodeSharedDataConflictMessage)(conflict));
+                }
+            }
             logger.info('started-opencode-session:sessionname');
         }
         catch (error) {

package/dist/server/src/lib/cli-tools/types.js

@@ -24,7 +24,7 @@ exports.isImageCapableCLITool = isImageCapableCLITool;
  * T2.1: Single source of truth for CLI tool IDs
  * CLIToolType is derived from this constant (DRY principle)
  */
-exports.CLI_TOOL_IDS = ['claude', 'codex', 'gemini', 'vibe-local', 'opencode', 'copilot', 'antigravity', 'command-code'];
+exports.CLI_TOOL_IDS = ['claude', 'codex', 'gemini', 'vibe-local', 'opencode', 'copilot', 'antigravity', 'command-code', 'opencode-v2'];
 /**
  * CLI tools that render inside the terminal's alternate screen (Issue #1268).
  *
@@ -48,6 +48,9 @@ const ALTERNATE_SCREEN_CLI_TOOLS = new Set([
     // INLINE -- measured on 1.40.1, `#{alternate_on}` is 0 and the pane keeps its
     // scrollback -- so its captured line count really is a monotonic cursor, the
     // way codex's and agy's are.
+    // Issue #2934: OpenCode V2's TUI is the same full-screen toolkit as v1's
+    // (`#{alternate_on}` 1 on 2.0.18, measured 2026-09-28).
+    'opencode-v2',
 ]);
 /**
  * Whether a CLI tool renders in the terminal's alternate screen, making the
@@ -195,6 +198,7 @@ exports.CLI_TOOL_DISPLAY_NAMES = {
     copilot: 'Copilot',
     antigravity: 'Antigravity',
     'command-code': 'Command Code',
+    'opencode-v2': 'OpenCode V2',
 };
 /**
  * Check if a string is a valid CLIToolType