commandmate 0.42.2 → 0.43.0

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

@@ -0,0 +1,421 @@
+"use strict";
+/**
+ * Writing OpenCode V2's replies into conversation history (Issue #2940,
+ * Epic #2370 Phase 2's transcript, brought forward).
+ *
+ * Before this, the screen scraper was the only writer of an `opencode-v2`
+ * reply, and it never wrote one: its completion test is the home screen's
+ * composer placeholder (`Ask anything…`), which OpenCode V2 draws only before
+ * the first prompt. So History held the user's prompts and none of the
+ * answers.
+ *
+ * ## Pull on the turn's end, not a reassembled stream
+ *
+ * The SSE stream does carry the reply (`session.text.started|delta|ended`,
+ * `session.reasoning.*`, `session.tool.*`), but this reads it from
+ * `GET /api/session/{id}/message` instead, once the stream says the turn is
+ * over (`session.execution.succeeded` / `failed` / `interrupted`):
+ *
+ *  - the document is the finished turn as the server stored it — no delta to
+ *    reassemble, no frame whose loss corrupts a row, and nothing held in
+ *    memory between frames;
+ *  - it is idempotent by construction: every turn is keyed on its user
+ *    message's id, so a repeated end-of-turn frame, a reconnect or two turns
+ *    ending close together write each turn once;
+ *  - and it recovers what the stream missed. A turn that ended while the
+ *    connection was down is in the document the next time any turn of the
+ *    session ends.
+ *
+ * ## One turn in the document
+ *
+ * Measured on 2.0.18 (`tests/fixtures/opencode-v2-history-2940`): messages are
+ * typed, and one turn is a `user` message, then one `assistant` message per
+ * model step (a tool-calling turn has several), then an `idle` message with the
+ * turn's `outcome`. Assistant messages carry no parent id, so the turn is
+ * recovered from the order alone: a turn opens at its `user` message and is
+ * closed by the `idle` that follows, or by the next `user` message. A turn that
+ * is still open is not written — the next end-of-turn reads it again.
+ *
+ * ## One row, one writer
+ *
+ * The row is `assistant` / `normal`, keyed `oc-turn:<user message id>` — the
+ * same key family v1's reader uses (`opencodeTurnRequestId`), so every surface
+ * that recognises an agent-authored turn recognises this one. The scraper
+ * stands down while the subscription is live
+ * (`isOpencodeV2StructuredHistoryLive`, via `lib/polling/structured-history-gate`).
+ *
+ * The body is rendered by v1's `renderOpencodeTurn` from the same part shape,
+ * so the text, the folded reasoning and the one-line tool summary look exactly
+ * like an OpenCode (v1) reply (#2041 / #2234 / #2272).
+ *
+ * ## The model that answered
+ *
+ * The same read also names the model of the newest assistant message
+ * (Issue #2964, {@link readLatestOpencodeV2AssistantModel}) and latches it
+ * where v1's hook-borne model goes, since no `session.*` frame carries one.
+ *
+ * ## Nothing here throws
+ *
+ * A failed fetch or write costs the row, never the subscription: the state the
+ * stream publishes is independent of it, and the scraper is no worse off than
+ * before. Database imports are dynamic for the reason v1's `./history` gives.
+ *
+ * @module lib/hooks/sources/opencode-v2/history
+ */
+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.MAX_OPENCODE_V2_SYNCED_TURNS = exports.MAX_OPENCODE_V2_HISTORY_PAGES = exports.OPENCODE_V2_TURN_END_EVENT_TYPES = void 0;
+exports.isOpencodeV2TurnEndEventType = isOpencodeV2TurnEndEventType;
+exports.readOpencodeV2ContentPart = readOpencodeV2ContentPart;
+exports.buildOpencodeV2TurnsFromMessages = buildOpencodeV2TurnsFromMessages;
+exports.readLatestOpencodeV2AssistantModel = readLatestOpencodeV2AssistantModel;
+exports.resetOpencodeV2HistoryQueue = resetOpencodeV2HistoryQueue;
+exports.syncOpencodeV2History = syncOpencodeV2History;
+const logger_1 = require("../../../../lib/logger");
+const agent_event_state_1 = require("../../../../lib/session/agent-event-state");
+const agent_transcript_1 = require("../../../../types/agent-transcript");
+const event_mapper_1 = require("../event-mapper");
+const transcript_1 = require("../opencode/transcript");
+const client_1 = require("./client");
+const secrets_1 = require("./secrets");
+const tool_id_1 = require("./tool-id");
+const logger = (0, logger_1.createLogger)('lib/hooks/sources/opencode-v2/history');
+/** The stream events after which a turn's reply is read (Issue #2940). */
+exports.OPENCODE_V2_TURN_END_EVENT_TYPES = [
+    'session.execution.succeeded',
+    'session.execution.failed',
+    'session.execution.interrupted',
+];
+/** Whether a frame `type` ends a turn. */
+function isOpencodeV2TurnEndEventType(type) {
+    return type !== null && exports.OPENCODE_V2_TURN_END_EVENT_TYPES.includes(type);
+}
+/**
+ * Pages read, newest first, while looking for the newest turn's `user`
+ * message. A turn is one assistant message per model step, so one page of
+ * {@link OPENCODE_V2_MESSAGES_PAGE_SIZE} covers all but a very long tool loop;
+ * the bound keeps a session that never shows a `user` message from being read
+ * to the end.
+ */
+exports.MAX_OPENCODE_V2_HISTORY_PAGES = 5;
+/** Cap on turns one sync writes, newest kept. */
+exports.MAX_OPENCODE_V2_SYNCED_TURNS = 50;
+function readFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function createdAtOf(message) {
+    const time = (0, event_mapper_1.isPlainObject)(message.time) ? message.time : null;
+    return readFiniteNumber(time?.created) ?? 0;
+}
+/**
+ * One element of an assistant message's `content`, as v1's part shape.
+ *
+ * v2's content items have no id of their own (a tool item's `id` is the
+ * provider's call id), so the slot is `<message id>#<index>`, which is stable
+ * across re-reads of the same stored message.
+ */
+function readOpencodeV2ContentPart(messageId, index, item) {
+    if (!(0, event_mapper_1.isPlainObject)(item))
+        return null;
+    const type = (0, event_mapper_1.readStringField)(item, 'type');
+    if (!type)
+        return null;
+    const state = (0, event_mapper_1.isPlainObject)(item.state) ? item.state : null;
+    return {
+        id: `${messageId}#${index}`,
+        messageId,
+        type,
+        text: typeof item.text === 'string' ? item.text : null,
+        tool: type === 'tool' ? (0, event_mapper_1.readStringField)(item, 'name') : null,
+        status: state ? (0, event_mapper_1.readStringField)(state, 'status') : null,
+        title: state ? (0, event_mapper_1.readStringField)(state, 'title') : null,
+        error: state
+            ? ((0, event_mapper_1.readStringField)(state, 'error') ?? (0, event_mapper_1.readNestedString)(state, ['error', 'message']))
+            : null,
+    };
+}
+/**
+ * Rebuild the turns of a session from `GET /api/session/{id}/message` entries.
+ *
+ * Order-agnostic: the entries are sorted oldest first by `time.created` (the
+ * id, which is time-ordered, breaks ties), so a desc page, an asc page or
+ * several pages concatenated give the same turns. Assistant messages before the
+ * first `user` message belong to a turn whose head is outside what was read,
+ * and are dropped rather than attached to nothing.
+ *
+ * Pure: no fetch, no database.
+ */
+function buildOpencodeV2TurnsFromMessages(entries, sessionId) {
+    const messages = entries
+        .filter(event_mapper_1.isPlainObject)
+        .filter((message) => (0, event_mapper_1.readStringField)(message, 'id') !== null)
+        .map((message, index) => ({ message, index }))
+        .sort((a, b) => {
+        const byTime = createdAtOf(a.message) - createdAtOf(b.message);
+        if (byTime !== 0)
+            return byTime;
+        const aId = (0, event_mapper_1.readStringField)(a.message, 'id') ?? '';
+        const bId = (0, event_mapper_1.readStringField)(b.message, 'id') ?? '';
+        return aId < bId ? -1 : aId > bId ? 1 : a.index - b.index;
+    })
+        .map(({ message }) => message);
+    const turns = [];
+    let open = null;
+    const close = (closed) => {
+        if (open)
+            turns.push({ ...open, closed });
+        open = null;
+    };
+    for (const message of messages) {
+        const id = (0, event_mapper_1.readStringField)(message, 'id');
+        const type = (0, event_mapper_1.readStringField)(message, 'type');
+        if (type === 'user') {
+            close(true);
+            open = {
+                accumulator: (0, transcript_1.createOpencodeTurn)(sessionId, id, createdAtOf(message)),
+                completedAt: null,
+            };
+            continue;
+        }
+        if (!open)
+            continue;
+        const current = open;
+        if (type === 'idle') {
+            close(true);
+            continue;
+        }
+        if (type !== 'assistant')
+            continue;
+        current.accumulator.assistantMessageIds.add(id);
+        const content = Array.isArray(message.content) ? message.content : [];
+        content.forEach((item, index) => {
+            const part = readOpencodeV2ContentPart(id, index, item);
+            if (part)
+                (0, transcript_1.addOpencodePart)(current.accumulator, part);
+        });
+        const time = (0, event_mapper_1.isPlainObject)(message.time) ? message.time : null;
+        const finished = readFiniteNumber(time?.completed) ?? readFiniteNumber(time?.created);
+        if (finished !== null && finished > (current.completedAt ?? 0))
+            current.completedAt = finished;
+    }
+    close(false);
+    return turns;
+}
+/**
+ * The model the newest assistant message was answered by, or null
+ * (Issue #2964).
+ *
+ * `assistant.model` is `{ id, providerID }` (measured on 2.0.18,
+ * `tests/fixtures/opencode-v2-history-2940`). Only `id` is returned — v1's
+ * `frameModel` rule (#1783): every other tool reports the bare model, and
+ * `opencode/longcat-…` would make this one the odd one out.
+ *
+ * The reply, not the session's setting: Phase 0 saw a session created over the
+ * API run on a different model from the TUI's default, so the model worth
+ * showing is the one that actually answered. Newest by `time.created`, the id
+ * breaking ties, the order {@link buildOpencodeV2TurnsFromMessages} uses. An
+ * assistant message without a model id is skipped, not read as "unknown".
+ *
+ * Pure: no fetch, no state.
+ */
+function readLatestOpencodeV2AssistantModel(entries) {
+    let latest = null;
+    for (const entry of entries) {
+        if (!(0, event_mapper_1.isPlainObject)(entry) || (0, event_mapper_1.readStringField)(entry, 'type') !== 'assistant')
+            continue;
+        const model = (0, event_mapper_1.readNestedString)(entry, ['model', 'id']);
+        if (model === null)
+            continue;
+        const at = createdAtOf(entry);
+        const id = (0, event_mapper_1.readStringField)(entry, 'id') ?? '';
+        if (latest === null || at > latest.at || (at === latest.at && id > latest.id)) {
+            latest = { at, id, model };
+        }
+    }
+    return latest?.model ?? null;
+}
+/**
+ * One sync at a time per instance, on `globalThis` for #1736's reason. Two turn
+ * ends close together would otherwise race the existence check and insert the
+ * same turn twice.
+ */
+const queue = (globalThis.__opencodeV2HistoryQueue ??= new Map());
+/** Forget queued syncs. Test seam. */
+function resetOpencodeV2HistoryQueue() {
+    queue.clear();
+}
+function serialize(key, work) {
+    const previous = queue.get(key) ?? Promise.resolve();
+    const result = previous.then(work, work);
+    const settled = result.then(() => undefined, () => undefined);
+    queue.set(key, settled);
+    void settled.then(() => {
+        if (queue.get(key) === settled)
+            queue.delete(key);
+    });
+    return result;
+}
+/** Read newest-first pages until the newest turn's `user` message is in view. */
+async function readRecentMessages(port, password, sessionId) {
+    const entries = [];
+    let cursor = null;
+    for (let page = 0; page < exports.MAX_OPENCODE_V2_HISTORY_PAGES; page += 1) {
+        const result = await (0, client_1.fetchOpencodeV2SessionMessagesPage)(port, password, sessionId, cursor);
+        if (result === null)
+            return page === 0 ? null : entries;
+        entries.push(...result.data);
+        const sawUser = result.data.some((entry) => (0, event_mapper_1.isPlainObject)(entry) && (0, event_mapper_1.readStringField)(entry, 'type') === 'user');
+        if (sawUser || result.next === null || result.data.length === 0)
+            break;
+        cursor = result.next;
+    }
+    return entries;
+}
+/**
+ * Write one rendered turn, unless its row is already there.
+ *
+ * @returns Whether a row was written
+ */
+async function writeOpencodeV2Turn(target, rendered, timestampMs) {
+    const instanceId = target.instanceId ?? target.cliToolId;
+    if (rendered.body.length === 0) {
+        logger.info('opencode-v2-history-turn-empty', {
+            worktreeId: target.worktreeId,
+            instanceId,
+            sessionId: rendered.sessionId,
+        });
+        return false;
+    }
+    if (rendered.unknownPartTypes.length > 0) {
+        logger.info('opencode-v2-history-unknown-parts', {
+            worktreeId: target.worktreeId,
+            instanceId,
+            sessionId: rendered.sessionId,
+            partTypes: rendered.unknownPartTypes,
+        });
+    }
+    const requestId = (0, agent_transcript_1.opencodeTurnRequestId)(rendered.userMessageId);
+    const [{ getDbInstance }, { createMessage, findMessageByRequestId }, { broadcastMessage }] = 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/ws-server'))),
+    ]);
+    const db = getDbInstance();
+    if (findMessageByRequestId(db, target.worktreeId, requestId))
+        return false;
+    const message = createMessage(db, {
+        worktreeId: target.worktreeId,
+        role: 'assistant',
+        content: rendered.body,
+        messageType: 'normal',
+        timestamp: new Date(timestampMs > 0 ? timestampMs : Date.now()),
+        cliToolId: target.cliToolId,
+        instanceId,
+        requestId,
+    });
+    broadcastMessage('message', { worktreeId: target.worktreeId, message });
+    logger.info('opencode-v2-history-turn-saved', {
+        worktreeId: target.worktreeId,
+        instanceId,
+        sessionId: rendered.sessionId,
+        requestId,
+        bodyLength: rendered.body.length,
+        textParts: rendered.textParts,
+        toolParts: rendered.toolParts,
+    });
+    return true;
+}
+/**
+ * Record every closed turn of a session that History does not have yet.
+ *
+ * Called when the instance's stream says a turn of `sessionId` ended. Never
+ * throws; a failure is logged and costs only the rows.
+ *
+ * @param target - The instance the stream belongs to
+ * @param port - Its server
+ * @param sessionId - `ses_…` from the end-of-turn frame
+ * @returns How many rows were written
+ */
+function syncOpencodeV2History(target, port, sessionId) {
+    return serialize((0, secrets_1.opencodeV2KeyOf)(target), async () => {
+        const instanceId = target.instanceId ?? target.cliToolId;
+        try {
+            const password = (0, secrets_1.readOpencodeV2Password)(target);
+            if (password === null) {
+                logger.info('opencode-v2-history-unavailable', {
+                    worktreeId: target.worktreeId,
+                    instanceId,
+                    reason: 'password-file-missing',
+                });
+                return 0;
+            }
+            const entries = await readRecentMessages(port, password, sessionId);
+            if (entries === null) {
+                logger.warn('opencode-v2-history-unavailable', {
+                    worktreeId: target.worktreeId,
+                    instanceId,
+                    port,
+                    sessionId,
+                    reason: 'messages-unreadable',
+                });
+                return 0;
+            }
+            // Issue #2964: the model that answered, onto the hook latch the UI and
+            // `capture --json` read. Before the rows, so a failed write cannot cost it.
+            (0, agent_event_state_1.recordAgentReportedModel)(target.worktreeId, tool_id_1.OPENCODE_V2_CLI_TOOL_ID, target.instanceId ?? tool_id_1.OPENCODE_V2_CLI_TOOL_ID, readLatestOpencodeV2AssistantModel(entries));
+            const closed = buildOpencodeV2TurnsFromMessages(entries, sessionId).filter((turn) => turn.closed);
+            const kept = closed.slice(-exports.MAX_OPENCODE_V2_SYNCED_TURNS);
+            let written = 0;
+            // Oldest first, so the rows go in in conversation order.
+            for (const turn of kept) {
+                const rendered = (0, transcript_1.renderOpencodeTurn)(turn.accumulator);
+                const at = Math.max(turn.accumulator.startedAt, turn.completedAt ?? 0);
+                if (await writeOpencodeV2Turn(target, rendered, at))
+                    written += 1;
+            }
+            return written;
+        }
+        catch (error) {
+            logger.error('opencode-v2-history-sync-failed', {
+                worktreeId: target.worktreeId,
+                instanceId,
+                port,
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return 0;
+        }
+    });
+}