commandmate 0.42.2 → 0.43.0

package/dist/server/src/lib/hooks/sources/opencode-v2/source.js

@@ -0,0 +1,295 @@
+"use strict";
+/**
+ * OpenCode V2's agent event source (Issue #2934, Epic #2370 Phase 1).
+ *
+ * A pull source like v1's: CommandMate subscribes to the agent's server rather
+ * than being called by it. What differs is whose server it is. v1's TUI serves
+ * the API itself once given `--port`; OpenCode V2's TUI is a client of a
+ * separate `opencode2 serve`, so the launch line runs
+ * `scripts/opencode-v2/launch.sh`, which starts the server on the instance's
+ * own port with the instance's own password, waits for it, runs the TUI
+ * against it, and stops the server however the TUI goes away.
+ *
+ * Phase 1 publishes state, and (Issue #2940) each finished turn's reply into
+ * History (`./history`).
+ *
+ * Issue #2945 (Phase 2) makes approvals and questions answerable from
+ * CommandMate: `eventIdentity: 'permission-id'` (the `per_…` / `frm_…` id the
+ * reply URL takes), `listPending` reads the server's own lists
+ * (`GET /api/permission/request`, `GET /api/form`), and `decide` answers over
+ * `POST …/permission/{requestID}/reply` / `POST …/form/{formID}/reply`. The
+ * PC panel, the phone sheet, `commandmate respond` and Auto-Yes all reach
+ * those through the tool-independent seams (`answerPendingDecision`,
+ * `adjudicatePendingPermission`), exactly as they reach v1.
+ *
+ * @module lib/hooks/sources/opencode-v2/source
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opencodeV2AgentEventSource = exports.OPENCODE_V2_LAUNCH_SCRIPT_RELATIVE_PATH = void 0;
+exports.resolveOpencodeV2LaunchScriptPath = resolveOpencodeV2LaunchScriptPath;
+exports.prepareOpencodeV2Launch = prepareOpencodeV2Launch;
+exports.toOpencodeV2PermissionReply = toOpencodeV2PermissionReply;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const hook_settings_generator_1 = require("../../../../lib/hooks/hook-settings-generator");
+const logger_1 = require("../../../../lib/logger");
+const define_source_1 = require("../define-source");
+const event_mapper_1 = require("../event-mapper");
+const pending_decisions_1 = require("../pending-decisions");
+const client_1 = require("./client");
+const mappers_1 = require("./mappers");
+const payloads_1 = require("./payloads");
+const ports_1 = require("./ports");
+const secrets_1 = require("./secrets");
+const subscription_1 = require("./subscription");
+const tool_id_1 = require("./tool-id");
+const logger = (0, logger_1.createLogger)('lib/hooks/sources/opencode-v2/source');
+/** The wrapper, relative to the package root CommandMate runs from. */
+exports.OPENCODE_V2_LAUNCH_SCRIPT_RELATIVE_PATH = ['scripts', 'opencode-v2', 'launch.sh'];
+/** Absolute path of the wrapper, or null when it is not on disk. */
+function resolveOpencodeV2LaunchScriptPath() {
+    const candidate = (0, path_1.resolve)(process.cwd(), ...exports.OPENCODE_V2_LAUNCH_SCRIPT_RELATIVE_PATH);
+    return (0, fs_1.existsSync)(candidate) ? candidate : null;
+}
+/**
+ * The launch line for an instance.
+ *
+ * With a reserved port and a written password file (the runtime's
+ * `reserveOpencodeV2Server` does both first) it is
+ * `bash <launch.sh> --port <N> --password-file <path> --directory <worktree>
+ * --executable <path>`:
+ * the password travels as a PATH, and `env` stays empty, so neither the line
+ * typed into the pane nor the environment it renders carries the secret.
+ *
+ * Without them — the port range exhausted, the state directory unwritable, the
+ * wrapper missing from the install — it falls back to
+ * `opencode2 --standalone <worktree>`: a private server with no structured
+ * events, which the screen scraper still reads. Never the bare `opencode2`,
+ * which would attach to the user's shared background service.
+ *
+ * Issue #2952: the wrapper is handed the resolved executable with
+ * `--executable <path>`, so OpenCode V2 installed under the `opencode` name
+ * alone gets its own server too, and the pane runs the very binary that
+ * answered `--version` rather than whatever its PATH names `opencode2`. The
+ * flag is left off only for the bare name `opencode2`, the wrapper's default.
+ */
+function prepareOpencodeV2Launch({ target, executablePath, worktreePath, }) {
+    const standalone = {
+        command: `${(0, hook_settings_generator_1.shellQuote)(executablePath)} --standalone ${(0, hook_settings_generator_1.shellQuote)(worktreePath)}`,
+        settingsPath: null,
+        env: {},
+    };
+    const port = (0, ports_1.getAssignedOpencodeV2Port)(target);
+    if (port === null)
+        return standalone;
+    const passwordFile = (0, secrets_1.getOpencodeV2PasswordFilePath)(target);
+    const script = resolveOpencodeV2LaunchScriptPath();
+    const reason = script === null
+        ? 'launch-script-missing'
+        : !(0, fs_1.existsSync)(passwordFile)
+            ? 'password-file-missing'
+            : null;
+    if (script === null || reason !== null) {
+        logger.warn('opencode-v2-launch-degraded-to-standalone', {
+            worktreeId: target.worktreeId,
+            instanceId: target.instanceId ?? target.cliToolId,
+            reason,
+        });
+        return standalone;
+    }
+    return {
+        command: [
+            'bash',
+            (0, hook_settings_generator_1.shellQuote)(script),
+            '--port',
+            String(port),
+            '--password-file',
+            (0, hook_settings_generator_1.shellQuote)(passwordFile),
+            '--directory',
+            (0, hook_settings_generator_1.shellQuote)(worktreePath),
+            ...(executablePath === tool_id_1.OPENCODE_V2_COMMAND
+                ? []
+                : ['--executable', (0, hook_settings_generator_1.shellQuote)(executablePath)]),
+        ].join(' '),
+        settingsPath: null,
+        env: {},
+    };
+}
+/**
+ * Map a verdict onto OpenCode V2's three-valued reply (`Permission.Reply`), or
+ * null when it has none — the same mapping v1 uses: `Allow once` → `once`,
+ * `Always allow` → `always`, reject → `reject`.
+ */
+function toOpencodeV2PermissionReply(verdict) {
+    switch (verdict.kind) {
+        case 'allowOnce':
+            return 'once';
+        case 'allowAlways':
+            return 'always';
+        case 'deny':
+            return 'reject';
+        case 'answer':
+        case 'abstain':
+            return null;
+    }
+}
+/** The instance's server and its password, or why a request cannot be made. */
+function serverOf(target) {
+    const port = (0, ports_1.getAssignedOpencodeV2Port)(target);
+    if (port === null)
+        return { reason: 'no-port' };
+    const password = (0, secrets_1.readOpencodeV2Password)(target);
+    if (password === null)
+        return { reason: 'no-password' };
+    return { port, password };
+}
+/**
+ * Send a verdict to the instance's server (Issue #2945).
+ *
+ * An approval goes to `…/permission/{requestID}/reply` as `{decision}`; a
+ * question to `…/form/{formID}/reply` as `{answer}`, built from the form the
+ * pending decision was read from. Both URLs name the session, which is the
+ * decision's `conversationId`. Every outcome is recorded with
+ * `recordDecisionDelivery`, so the caller knows whether anybody is still
+ * blocked.
+ */
+async function decideOpencodeV2(target, decision, verdict) {
+    const instanceId = target.instanceId ?? target.cliToolId;
+    const undelivered = (reason) => {
+        logger.info('opencode-v2-verdict-undelivered', {
+            worktreeId: target.worktreeId,
+            instanceId,
+            decisionId: decision.id,
+            verdict: verdict.kind,
+            reason,
+        });
+        (0, pending_decisions_1.recordDecisionDelivery)(target, decision.id, { delivered: false, reason });
+    };
+    // Silence is an action here, as on v1: the agent waits with no timeout.
+    if (verdict.kind === 'abstain')
+        return undelivered('abstained');
+    const sessionId = decision.conversationId;
+    if (!sessionId)
+        return undelivered('no-session');
+    const server = serverOf(target);
+    if ('reason' in server)
+        return undelivered(server.reason);
+    if (decision.kind === 'question') {
+        if (verdict.kind !== 'answer')
+            return undelivered('question-needs-answer-verdict');
+        const answer = (0, payloads_1.buildOpencodeV2FormAnswer)(decision.raw, verdict.answers);
+        if (answer === null)
+            return undelivered('form-answer-does-not-fit');
+        const delivered = await (0, client_1.replyOpencodeV2Form)(server.port, server.password, sessionId, decision.id, answer);
+        logger.info('opencode-v2-form-replied', {
+            worktreeId: target.worktreeId,
+            instanceId,
+            decisionId: decision.id,
+            delivered,
+        });
+        (0, pending_decisions_1.recordDecisionDelivery)(target, decision.id, {
+            delivered,
+            reason: delivered ? 'form-reply' : 'form-reply-failed',
+        });
+        return;
+    }
+    const reply = toOpencodeV2PermissionReply(verdict);
+    if (reply === null)
+        return undelivered('no-wire-value');
+    const delivered = await (0, client_1.replyOpencodeV2Permission)(server.port, server.password, sessionId, decision.id, reply, verdict.kind === 'deny' ? verdict.message : undefined);
+    logger.info('opencode-v2-permission-replied', {
+        worktreeId: target.worktreeId,
+        instanceId,
+        decisionId: decision.id,
+        reply,
+        delivered,
+    });
+    (0, pending_decisions_1.recordDecisionDelivery)(target, decision.id, {
+        delivered,
+        reason: delivered ? `permission-reply:${reply}` : 'permission-reply-failed',
+    });
+}
+/**
+ * What the instance's server is waiting on a human for (Issue #2945).
+ *
+ * Read from the server itself — `GET /api/permission/request` and
+ * `GET /api/form` — so an id the `/respond` route is asked about is checked
+ * against the agent's own lists, not against what the stream happened to
+ * deliver. The server is the instance's alone, so both lists are this
+ * instance's. An unreachable server answers an empty list, as v1 does.
+ */
+async function listOpencodeV2Pending(target) {
+    const server = serverOf(target);
+    if ('reason' in server)
+        return [];
+    const askedAt = Date.now();
+    const [permissions, forms] = await Promise.all([
+        (0, client_1.fetchOpencodeV2PendingPermissions)(server.port, server.password),
+        (0, client_1.fetchOpencodeV2PendingForms)(server.port, server.password),
+    ]);
+    const pending = [];
+    for (const entry of permissions ?? []) {
+        if (!(0, event_mapper_1.isPlainObject)(entry))
+            continue;
+        const decision = (0, payloads_1.toOpencodeV2PendingPermission)(entry, askedAt);
+        if (decision)
+            pending.push(decision);
+    }
+    for (const entry of forms ?? []) {
+        if (!(0, event_mapper_1.isPlainObject)(entry))
+            continue;
+        const decision = (0, payloads_1.toOpencodeV2PendingQuestion)(entry, askedAt);
+        if (decision)
+            pending.push(decision);
+    }
+    return pending;
+}
+exports.opencodeV2AgentEventSource = (0, define_source_1.definePullEventSource)({
+    cliToolId: tool_id_1.OPENCODE_V2_CLI_TOOL_ID,
+    noDecision: { kind: 'blocks' },
+    capabilities: {
+        supportedEvents: ['user_prompt_submit', 'stop', 'notification'],
+        configScope: 'none',
+        decisionTimeoutSeconds: null,
+        permissionHookPredictsDialog: false,
+        sessionStartMayArriveLate: false,
+        permissionReplyReleasesPrompt: true,
+        // Issue #2945: `per_…` / `frm_…`, the id the reply URL takes and the one
+        // `permission.replied` / `form.replied` settle. Moves together with
+        // `extractEventIdentity` below.
+        eventIdentity: 'permission-id',
+        // Issue #2951: `listPending` re-reads the server's own lists, so Auto-Yes
+        // switched on under an open approval answers it
+        // (`recheckPendingDecisions`), and each re-connect replays them
+        // (`./subscription`). No session-status poll, hence not v1's value.
+        resync: 'pending-list',
+        // Issue #2940: the subscription writes each finished turn from
+        // `GET /api/session/{id}/message` (`./history`), so the scraper stands
+        // down while it is live.
+        transcriptHistory: 'push',
+        stopReportsSelfResume: false,
+    },
+    mappers: mappers_1.OPENCODE_V2_MAPPERS,
+    nativeEventNameFields: ['type'],
+    conversationIdFields: [],
+    // Issue #2964: no `session.*` frame carries a model. The model that answered
+    // is read off `/message` after each turn (`./history`) and latched there.
+    extractModel: () => null,
+    extractEventIdentity: mappers_1.opencodeV2EventIdentity,
+    extractDetail: () => null,
+    parsePermissionRequest: payloads_1.parseOpencodeV2PermissionRequest,
+    // `form.created` carries the form as `data.form`; when a frame does not, the
+    // ingest reads it from `GET /api/session/{id}/form`.
+    parseQuestion: payloads_1.parseOpencodeV2Form,
+    subscribe: async (target, onEvent) => {
+        const port = (0, ports_1.getAssignedOpencodeV2Port)(target);
+        if (port === null)
+            return { close: async () => { }, liveness: { state: 'unknown' } };
+        return (0, subscription_1.openOpencodeV2Subscription)(target, port, onEvent, (raw) => exports.opencodeV2AgentEventSource.normalizeEvent(raw));
+    },
+    decide: decideOpencodeV2,
+    listPending: listOpencodeV2Pending,
+    probeActivity: async () => null,
+    liveness: (target) => (0, subscription_1.getOpencodeV2Liveness)(target),
+    prepareLaunch: prepareOpencodeV2Launch,
+});