commandmate 0.42.2 → 0.43.0

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

@@ -0,0 +1,271 @@
+"use strict";
+/**
+ * Where OpenCode V2's mapped events enter CommandMate's agent-event state
+ * (Issue #2934, decision D5).
+ *
+ *  - a turn boundary (`user_prompt_submit` / `stop`) is recorded as-is, and a
+ *    `stop` also runs the same stop side effects every tool's `Stop` does
+ *    (`applyAgentStopEvent`: task events, verification) so `commandmate wait`
+ *    completes on it. A failed turn (`stop` / `error`) is logged as an error;
+ *  - an approval request (Issue #2945 D1/D3) is adjudicated FIRST — Auto-Yes
+ *    answers it over `…/permission/{id}/reply` through the same
+ *    `adjudicatePendingPermission` v1 uses — and then recorded as a pending
+ *    decision carrying its action, the rule `Always allow` would save and the
+ *    diff, so the PC panel and the phone sheet can show what they are
+ *    approving. `promptSettled` is whether the verdict was delivered; the
+ *    `permission.replied` that follows any answer (ours, another client's, or
+ *    the human's in the TUI) retires it by id;
+ *  - a question (`form.created`, Issue #2945 D2) is recorded, its fields are
+ *    read (off the frame's `data.form`, or `GET /api/session/{id}/form`) and
+ *    published as the question's choices, the phone is notified the way v1's
+ *    `question.asked` notifies it, and `form.replied` / `form.cancelled` retire
+ *    it.
+ *
+ * Never throws: an ingest failure is logged and the scraper keeps deciding.
+ *
+ * @module lib/hooks/sources/opencode-v2/ingest
+ */
+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.ingestOpencodeV2Event = ingestOpencodeV2Event;
+const logger_1 = require("../../../../lib/logger");
+const agent_event_types_1 = require("../../../../lib/hooks/agent-event-types");
+const permission_adjudication_1 = require("../../../../lib/hooks/permission-adjudication");
+const pending_decision_kind_1 = require("../../../../lib/hooks/pending-decision-kind");
+const agent_event_state_1 = require("../../../../lib/session/agent-event-state");
+const structured_prompt_1 = require("../../../../lib/session/structured-prompt");
+const event_mapper_1 = require("../event-mapper");
+const push_1 = require("../opencode/push");
+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 source_1 = require("./source");
+const tool_id_1 = require("./tool-id");
+const logger = (0, logger_1.createLogger)('lib/hooks/sources/opencode-v2/ingest');
+async function applyStop(target, instanceId) {
+    const [{ getDbInstance }, { getWorktreeById }, { applyAgentStopEvent }] = await Promise.all([
+        Promise.resolve().then(() => __importStar(require('../../../../lib/db/db-instance'))),
+        Promise.resolve().then(() => __importStar(require('../../../../lib/db'))),
+        Promise.resolve().then(() => __importStar(require('../../../../lib/hooks/agent-event-service'))),
+    ]);
+    const db = getDbInstance();
+    const worktree = getWorktreeById(db, target.worktreeId) ?? null;
+    if (!worktree) {
+        logger.info('opencode-v2-stop-unresolved-target', { worktreeId: target.worktreeId });
+        return;
+    }
+    await applyAgentStopEvent(db, worktree, tool_id_1.OPENCODE_V2_CLI_TOOL_ID, instanceId);
+}
+/** `GET /api/session/{id}/form`, the form with this id. */
+async function loadFormFromServer(target, sessionId, formId) {
+    const port = (0, ports_1.getAssignedOpencodeV2Port)(target);
+    const password = (0, secrets_1.readOpencodeV2Password)(target);
+    if (port === null || password === null)
+        return null;
+    const forms = await (0, client_1.fetchOpencodeV2SessionForms)(port, password, sessionId);
+    const form = forms?.find((entry) => (0, event_mapper_1.isPlainObject)(entry) && entry.id === formId);
+    return (0, event_mapper_1.isPlainObject)(form) ? form : null;
+}
+/**
+ * Judge one approval and deliver the verdict, before it is recorded
+ * (Issue #2945 D3; the order is v1's #1898 fix).
+ *
+ * `adjudicatePendingPermission` is the one shared adjudicator: with Auto-Yes
+ * off it abstains and nothing is sent; with it on it answers `once` unless a
+ * deny pattern or the execution contract withholds it.
+ *
+ * @returns Whether the dialog may be treated as closed
+ */
+async function adjudicatePermission(target, event, instanceId) {
+    const pending = (0, payloads_1.toOpencodeV2PendingPermission)(event.raw, event.receivedAt);
+    if (!pending) {
+        logger.info('opencode-v2-permission-unparsed', { worktreeId: target.worktreeId, instanceId });
+        return false;
+    }
+    const outcome = await (0, permission_adjudication_1.adjudicatePendingPermission)(source_1.opencodeV2AgentEventSource, target, pending, source_1.opencodeV2AgentEventSource.parsePermissionRequest(event.raw));
+    logger.info('opencode-v2-permission-decided', {
+        worktreeId: target.worktreeId,
+        instanceId,
+        decisionId: pending.id,
+        behavior: outcome.behavior,
+        reason: outcome.reason,
+        delivered: outcome.delivered,
+        settled: outcome.settled,
+    });
+    return outcome.settled;
+}
+/**
+ * The question a `form.created` frame opened, with its choices (Issue #2945 D2).
+ *
+ * The form is read off the frame — 2.0.18 sends the whole form as
+ * `data.form` (measured for this Issue) — and, when a frame arrives without
+ * it, from `GET /api/session/{id}/form`, the call Phase 0 answered it with.
+ */
+async function readQuestion(target, event, loadForm) {
+    const fromFrame = (0, payloads_1.parseOpencodeV2Form)(event.raw);
+    if (fromFrame)
+        return fromFrame;
+    const formId = (0, mappers_1.frameDecisionId)(event.raw);
+    const sessionId = (0, mappers_1.frameSessionId)(event.raw);
+    if (formId === null || sessionId === null)
+        return null;
+    const form = await loadForm(target, sessionId, formId);
+    return form ? (0, payloads_1.parseOpencodeV2Form)(form) : null;
+}
+/**
+ * Record one mapped event for the instance it arrived on.
+ *
+ * @param target - The instance whose server produced the event
+ * @param event - The normalized event
+ * @param stopEffect - What a `stop` runs after being recorded (tests replace it)
+ * @param loadForm - How a question's form is read (tests replace it)
+ */
+async function ingestOpencodeV2Event(target, event, stopEffect = applyStop, loadForm = loadFormFromServer) {
+    const instanceId = target.instanceId ?? tool_id_1.OPENCODE_V2_CLI_TOOL_ID;
+    try {
+        const delivery = (0, agent_event_state_1.classifyAgentEventDelivery)({
+            worktreeId: target.worktreeId,
+            cliToolId: tool_id_1.OPENCODE_V2_CLI_TOOL_ID,
+            instanceId,
+            event: event.event,
+            detail: event.detail,
+            sessionId: event.conversationId,
+            at: event.receivedAt,
+            // Issue #2945: the decision id, so two approvals a second apart are two
+            // approvals — not one and a repeat inside the time window.
+            identity: source_1.opencodeV2AgentEventSource.eventIdentityOf(event.raw),
+            identityKind: source_1.opencodeV2AgentEventSource.capabilities.eventIdentity,
+        });
+        if (delivery.duplicate) {
+            logger.info('opencode-v2-event-duplicate-dropped', {
+                worktreeId: target.worktreeId,
+                instanceId,
+                event: event.event,
+                detail: event.detail,
+                by: delivery.by,
+            });
+            return;
+        }
+        const record = {
+            event: event.event,
+            at: event.receivedAt,
+            detail: event.detail?.slice(0, agent_event_types_1.MAX_EVENT_DETAIL_LENGTH) ?? null,
+            sessionId: event.conversationId,
+            message: null,
+            model: event.model,
+        };
+        const options = { sessionStartMayArriveLate: false };
+        if (event.event === 'notification' && event.detail === mappers_1.OPENCODE_V2_PERMISSION_DETAIL) {
+            record.decisionId = (0, mappers_1.frameDecisionId)(event.raw);
+            const subject = (0, payloads_1.readOpencodeV2PermissionSubject)(event.raw);
+            record.toolName = subject?.toolName ?? (0, mappers_1.framePermissionAction)(event.raw);
+            record.decisionPatterns = subject?.patterns ?? null;
+            // D1: the diff is what the card shows, carried as the record's message.
+            record.message =
+                (0, payloads_1.describeOpencodeV2Permission)(event.raw)?.slice(0, structured_prompt_1.MAX_STRUCTURED_PROMPT_MESSAGE_LENGTH) ??
+                    null;
+            // D3: the verdict leaves BEFORE the record is written (v1's #1898 order).
+            record.promptSettled = await adjudicatePermission(target, event, instanceId);
+            (0, agent_event_state_1.recordAgentEvent)(target.worktreeId, tool_id_1.OPENCODE_V2_CLI_TOOL_ID, instanceId, record, options);
+        }
+        else if (event.event === 'notification' &&
+            event.detail === mappers_1.OPENCODE_V2_DECISION_SETTLED_DETAIL) {
+            record.decisionId = (0, mappers_1.frameDecisionId)(event.raw);
+            record.promptSettled = true;
+            (0, agent_event_state_1.recordAgentEvent)(target.worktreeId, tool_id_1.OPENCODE_V2_CLI_TOOL_ID, instanceId, record, options);
+        }
+        else if (event.event === 'notification' && event.detail === mappers_1.OPENCODE_V2_QUESTION_DETAIL) {
+            const spec = await readQuestion(target, event, loadForm);
+            record.message =
+                spec?.questions[0]?.question.slice(0, structured_prompt_1.MAX_STRUCTURED_PROMPT_MESSAGE_LENGTH) ?? null;
+            (0, agent_event_state_1.recordAgentEvent)(target.worktreeId, tool_id_1.OPENCODE_V2_CLI_TOOL_ID, instanceId, record, options);
+            // D2: the choices, for the panel's picker and `capture --prompts`. A form
+            // no surface can offer choices for still opens the wait below, and the
+            // human answers it in the TUI.
+            if (spec) {
+                (0, agent_event_state_1.recordAskUserQuestion)(target.worktreeId, tool_id_1.OPENCODE_V2_CLI_TOOL_ID, instanceId, spec, event.receivedAt);
+            }
+            (0, agent_event_state_1.reportQuestionPending)(target.worktreeId, tool_id_1.OPENCODE_V2_CLI_TOOL_ID, instanceId, {
+                toolName: pending_decision_kind_1.OPENCODE_QUESTION_TOOL_NAME,
+                decisionId: (0, mappers_1.frameDecisionId)(event.raw),
+                detail: mappers_1.OPENCODE_V2_QUESTION_DETAIL,
+            }, event.receivedAt);
+            logger.info('opencode-v2-question-recorded', {
+                worktreeId: target.worktreeId,
+                instanceId,
+                decisionId: (0, mappers_1.frameDecisionId)(event.raw),
+                parsed: spec !== null,
+                questionCount: spec?.questions.length ?? 0,
+            });
+            // After the record, for v1's reason (#2045): the notification must not
+            // describe a wait the rest of the process has not been told about yet.
+            await (0, push_1.notifyOpencodeQuestionPush)(target, instanceId, record.message, event.receivedAt);
+        }
+        else if (event.event === 'stop') {
+            if (event.detail === mappers_1.OPENCODE_V2_FAILED_DETAIL) {
+                record.message =
+                    (0, mappers_1.frameFailureMessage)(event.raw)?.slice(0, structured_prompt_1.MAX_STRUCTURED_PROMPT_MESSAGE_LENGTH) ?? null;
+                logger.error('opencode-v2-turn-failed', {
+                    worktreeId: target.worktreeId,
+                    instanceId,
+                    sessionId: event.conversationId,
+                    message: record.message,
+                });
+            }
+            (0, agent_event_state_1.recordAgentEvent)(target.worktreeId, tool_id_1.OPENCODE_V2_CLI_TOOL_ID, instanceId, record, options);
+            await stopEffect(target, instanceId);
+        }
+        else {
+            (0, agent_event_state_1.recordAgentEvent)(target.worktreeId, tool_id_1.OPENCODE_V2_CLI_TOOL_ID, instanceId, record, options);
+        }
+        logger.info('opencode-v2-event-received', {
+            worktreeId: target.worktreeId,
+            instanceId,
+            type: (0, mappers_1.frameType)(event.raw),
+            event: event.event,
+            detail: event.detail,
+        });
+    }
+    catch (error) {
+        logger.error('opencode-v2-event-ingest-failed', {
+            worktreeId: target.worktreeId,
+            instanceId,
+            event: event.event,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}

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

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * OpenCode V2's SSE vocabulary, mapped onto CommandMate's agent events
+ * (Issue #2934, decision D5).
+ *
+ * The envelope, measured on 2.0.18 (#2370 Phase 0):
+ * `{id, created?, type, location?, data, durable?}`. `location.directory` is
+ * present on some events and absent on others (`session.execution.succeeded`
+ * carries `durable` instead), so nothing here reads it: one instance owns one
+ * server, and every frame on that server's stream is that instance's.
+ *
+ * Phase 1 mapped the turn boundaries and the two kinds of "the agent is waiting
+ * for a human":
+ *
+ * | OpenCode V2 event                               | agent event                          |
+ * |-------------------------------------------------|--------------------------------------|
+ * | `session.execution.started`                     | `user_prompt_submit` → running       |
+ * | `session.execution.succeeded` / `interrupted`   | `stop` → ready                       |
+ * | `session.execution.failed`                      | `stop` (detail `error`) → ready      |
+ * | `permission.asked`                              | `notification(permission_prompt)`    |
+ * | `permission.replied`                            | `notification(permission_replied)`   |
+ * | `form.created`                                  | `notification(question_prompt)`      |
+ * | `form.replied` / `form.cancelled`               | `notification(permission_replied)`   |
+ *
+ * Every other type is dropped before it reaches the normalizer
+ * ({@link isHandledOpencodeV2EventType}), so the unknown-event tally does not
+ * fill up with `session.reasoning.delta` and friends.
+ *
+ * `form.replied` / `form.cancelled` reuse `permission_replied` on purpose: that
+ * detail is the agent-event state's one "this decision is settled, retire it by
+ * id" signal, and a question is a decision exactly as an approval is.
+ *
+ * @module lib/hooks/sources/opencode-v2/mappers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPENCODE_V2_MAPPERS = exports.OPENCODE_V2_HANDLED_EVENT_TYPES = exports.OPENCODE_V2_FAILED_DETAIL = exports.OPENCODE_V2_DECISION_SETTLED_DETAIL = exports.OPENCODE_V2_QUESTION_DETAIL = exports.OPENCODE_V2_PERMISSION_DETAIL = void 0;
+exports.isHandledOpencodeV2EventType = isHandledOpencodeV2EventType;
+exports.frameType = frameType;
+exports.frameData = frameData;
+exports.frameSessionId = frameSessionId;
+exports.frameDecisionId = frameDecisionId;
+exports.opencodeV2EventIdentity = opencodeV2EventIdentity;
+exports.framePermissionAction = framePermissionAction;
+exports.frameFailureMessage = frameFailureMessage;
+const agent_event_types_1 = require("../../../../lib/hooks/agent-event-types");
+const event_mapper_1 = require("../event-mapper");
+/** `notification` detail of an approval request. */
+exports.OPENCODE_V2_PERMISSION_DETAIL = 'permission_prompt';
+/** `notification` detail of a question (a `form`). */
+exports.OPENCODE_V2_QUESTION_DETAIL = 'question_prompt';
+/** `notification` detail that retires a decision — approval or question. */
+exports.OPENCODE_V2_DECISION_SETTLED_DETAIL = agent_event_types_1.PERMISSION_REPLIED_DETAIL;
+/** `stop` detail of a turn that ended in `session.execution.failed`. */
+exports.OPENCODE_V2_FAILED_DETAIL = 'error';
+/** The event types Phase 1 reads. Anything else is ignored. */
+exports.OPENCODE_V2_HANDLED_EVENT_TYPES = [
+    'session.execution.started',
+    'session.execution.succeeded',
+    'session.execution.failed',
+    'session.execution.interrupted',
+    'permission.asked',
+    'permission.replied',
+    'form.created',
+    'form.replied',
+    'form.cancelled',
+];
+/** Whether a frame's `type` is one {@link OPENCODE_V2_MAPPERS} maps. */
+function isHandledOpencodeV2EventType(type) {
+    return type !== null && exports.OPENCODE_V2_HANDLED_EVENT_TYPES.includes(type);
+}
+/** The frame's `type`, or null. */
+function frameType(payload) {
+    return (0, event_mapper_1.readNestedString)(payload, ['type']);
+}
+/** The frame's `data` object (empty when absent). */
+function frameData(payload) {
+    return (0, event_mapper_1.isPlainObject)(payload.data) ? payload.data : {};
+}
+/**
+ * The OpenCode session a frame belongs to.
+ *
+ * `data.sessionID` where the event carries it; otherwise the durable
+ * aggregate id (`durable.aggregateID`), which for the `session.*` events is the
+ * session. Used as the turn's conversation id, never for routing.
+ */
+function frameSessionId(payload) {
+    return ((0, event_mapper_1.readNestedString)(frameData(payload), ['sessionID']) ??
+        // Issue #2945: `form.created` nests the form — `data.form.sessionID`
+        // (measured on 2.0.18).
+        (0, event_mapper_1.readNestedString)(frameData(payload), ['form', 'sessionID']) ??
+        (0, event_mapper_1.readNestedString)(payload, ['durable', 'aggregateID']));
+}
+/**
+ * The id of the decision a frame opens or settles.
+ *
+ * `permission.asked` carries it as `data.id` (`per_…`), `form.created` as
+ * `data.form.id` (`frm_…`, the form is nested — measured, Issue #2945);
+ * `permission.replied` names it `data.requestID`; the form replies carry
+ * `data.id` and are read under the other spellings too.
+ */
+function frameDecisionId(payload) {
+    const data = frameData(payload);
+    switch (frameType(payload)) {
+        case 'permission.asked':
+            return (0, event_mapper_1.readNestedString)(data, ['id']);
+        case 'form.created':
+            // Measured on 2.0.18 (Issue #2945): the form is nested,
+            // `data.form.id`. `data.id` is read as well, for a frame that is not.
+            return (0, event_mapper_1.readNestedString)(data, ['form', 'id']) ?? (0, event_mapper_1.readNestedString)(data, ['id']);
+        case 'permission.replied':
+            return (0, event_mapper_1.readNestedString)(data, ['requestID']) ?? (0, event_mapper_1.readNestedString)(data, ['id']);
+        case 'form.replied':
+        case 'form.cancelled':
+            return ((0, event_mapper_1.readNestedString)(data, ['formID']) ??
+                (0, event_mapper_1.readNestedString)(data, ['id']) ??
+                (0, event_mapper_1.readNestedString)(data, ['requestID']));
+        default:
+            return null;
+    }
+}
+/**
+ * The frame's own identity, for de-duplication (Issue #2945,
+ * `eventIdentity: 'permission-id'`).
+ *
+ * The decision id ({@link frameDecisionId}) — the `per_…` / `frm_…` the reply
+ * URL takes. An approval and the reply that settles it carry the SAME id, which
+ * is why `classifyAgentEventDelivery` keys on `(event, detail, identity)`
+ * rather than on the id alone. Every other frame (the `session.execution.*`
+ * boundaries) answers null and keeps the time window, as v1's `session.idle`
+ * does. The envelope's `evt_…` is not used, for v1's reason: nothing measured
+ * says it is unique per frame.
+ */
+function opencodeV2EventIdentity(payload) {
+    return (0, event_mapper_1.readEventIdentity)(frameDecisionId(payload));
+}
+/** The action an approval is for (`edit`, `shell`, …), or null. */
+function framePermissionAction(payload) {
+    return (0, event_mapper_1.readNestedString)(frameData(payload), ['action']);
+}
+/** A human-readable reason a failed turn gives, or null. */
+function frameFailureMessage(payload) {
+    const data = frameData(payload);
+    return ((0, event_mapper_1.readNestedString)(data, ['error', 'message']) ??
+        (0, event_mapper_1.readNestedString)(data, ['error', 'data', 'message']) ??
+        (0, event_mapper_1.readNestedString)(data, ['error', 'name']) ??
+        (0, event_mapper_1.readNestedString)(data, ['message']));
+}
+const OPENCODE_V2_BASE_MAPPERS = [
+    (0, event_mapper_1.whenNamed)('session.execution.started', 'user_prompt_submit'),
+    (0, event_mapper_1.whenNamed)('session.execution.succeeded', 'stop'),
+    (0, event_mapper_1.whenNamed)('session.execution.interrupted', 'stop'),
+    (0, event_mapper_1.whenNamed)('session.execution.failed', 'stop', exports.OPENCODE_V2_FAILED_DETAIL),
+    (0, event_mapper_1.whenNamed)('permission.asked', 'notification', exports.OPENCODE_V2_PERMISSION_DETAIL),
+    (0, event_mapper_1.whenNamed)('permission.replied', 'notification', exports.OPENCODE_V2_DECISION_SETTLED_DETAIL),
+    (0, event_mapper_1.whenNamed)('form.created', 'notification', exports.OPENCODE_V2_QUESTION_DETAIL),
+    (0, event_mapper_1.whenNamed)('form.replied', 'notification', exports.OPENCODE_V2_DECISION_SETTLED_DETAIL),
+    (0, event_mapper_1.whenNamed)('form.cancelled', 'notification', exports.OPENCODE_V2_DECISION_SETTLED_DETAIL),
+];
+/** The mappers, each stamping the frame's session as the conversation id. */
+exports.OPENCODE_V2_MAPPERS = OPENCODE_V2_BASE_MAPPERS.map((mapper) => (type, payload) => {
+    const mapped = mapper(type, payload);
+    if (!mapped)
+        return null;
+    return { ...mapped, conversationId: mapped.conversationId ?? frameSessionId(payload) };
+});