@jingyi0605/codingns 0.1.0

package/node_modules/@codingns/session-sync-core/dist/providers/opencode.js

@@ -0,0 +1,745 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { ensureText, nextTimestamp, normalizeWorkspacePath, sliceHistory } from "./utils.js";
+import { buildMessageRawRef, buildSessionRawStoreRef, firstValidNumber, normalizeOpenCodeMessageEnvelopes, parseSessionIdFromRawStoreRef, readInteger, toIsoTimestamp, toJsonRecord, workspaceMatches } from "./opencode-shared.js";
+const DEFAULT_DATA_DIR = join(homedir(), ".local", "share", "opencode");
+const DEFAULT_REQUEST_TIMEOUT_MS = 10_000;
+const DEFAULT_POLL_INTERVAL_MS = 800;
+const MIN_POLL_INTERVAL_MS = 200;
+const DEFAULT_SERVER_PAGE_LIMIT = 100;
+const TIMEOUT_WARNING_THRESHOLD_MS = 15_000;
+const MAX_CONSECUTIVE_TIMEOUTS = 5;
+export class OpenCodeAdapter {
+    options;
+    providerId = "opencode";
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async detectSessions(workspacePath, options) {
+        const discovery = await this.detectSessionsDetailed(workspacePath, options);
+        return discovery.sessions;
+    }
+    async detectSessionsDetailed(workspacePath, options) {
+        const targetPath = normalizeWorkspacePath(workspacePath);
+        const knownSessions = (options?.knownSessions ?? []).filter((session) => session.provider === this.providerId &&
+            workspaceMatches(targetPath, normalizeWorkspacePath(session.workspacePath)));
+        const serverDiscovery = await this.tryDetectSessionsFromServer(targetPath, knownSessions);
+        if (serverDiscovery) {
+            return serverDiscovery;
+        }
+        const rows = this.withReadonlyDb((db) => {
+            return db.prepare(`SELECT
+           s.id AS id,
+           s.parent_id AS parent_id,
+           s.directory AS directory,
+           s.title AS title,
+           s.time_created AS time_created,
+           s.time_updated AS time_updated,
+           s.time_archived AS time_archived,
+           COALESCE(stats.message_count, 0) AS message_count,
+           stats.last_message_time_ms AS last_message_time_ms
+         FROM session s
+         LEFT JOIN (
+           SELECT
+             session_id,
+             COUNT(*) AS message_count,
+             MAX(COALESCE(time_updated, time_created)) AS last_message_time_ms
+           FROM message
+           GROUP BY session_id
+         ) AS stats
+           ON stats.session_id = s.id`).all();
+        });
+        return {
+            sessions: rows
+                .map((row) => this.normalizeSqliteSessionSummaryRow(row))
+                .filter((summary) => summary !== null)
+                .filter((summary) => workspaceMatches(targetPath, normalizeWorkspacePath(summary.workspacePath)))
+                .sort((left, right) => (right.lastMessageAt ?? "").localeCompare(left.lastMessageAt ?? "")),
+            isComplete: true
+        };
+    }
+    async readRecentSessionHistory(providerSessionId, rawStoreRef, _totalMessageCount, limit) {
+        return this.readSessionHistory(providerSessionId, rawStoreRef, null, limit, "backward");
+    }
+    async readSessionHistory(providerSessionId, rawStoreRef, cursor, limit, direction = "forward") {
+        const sessionId = this.resolveSessionId(providerSessionId, rawStoreRef);
+        const serverMessages = await this.tryReadSessionMessagesFromServer(sessionId);
+        const messages = serverMessages ?? this.readSessionMessagesFromSqlite(sessionId);
+        return sliceHistory(messages, cursor, limit, direction);
+    }
+    subscribeSession(providerSessionId, rawStoreRef, cursor, limit, onEvent) {
+        const sessionId = this.resolveSessionId(providerSessionId, rawStoreRef);
+        const pollIntervalMs = this.resolvePollIntervalMs();
+        const normalizedRawStoreRef = buildSessionRawStoreRef(sessionId);
+        let currentCursor = cursor;
+        let closed = false;
+        let inFlight = false;
+        const timer = setInterval(() => {
+            if (closed || inFlight) {
+                return;
+            }
+            inFlight = true;
+            void this.readSessionHistory(sessionId, normalizedRawStoreRef, currentCursor, limit, "forward")
+                .then(async (page) => {
+                if (page.messages.length === 0) {
+                    return;
+                }
+                currentCursor = page.cursor;
+                await onEvent({
+                    messages: page.messages,
+                    cursor: page.cursor
+                });
+            })
+                .catch(() => {
+                return;
+            })
+                .finally(() => {
+                inFlight = false;
+            });
+        }, pollIntervalMs);
+        return {
+            close() {
+                closed = true;
+                clearInterval(timer);
+            }
+        };
+    }
+    async resumeSession(providerSessionId, rawStoreRef) {
+        const sessionId = this.resolveSessionId(providerSessionId, rawStoreRef);
+        if (!(await this.tryAssertSessionExistsOnServer(sessionId))) {
+            this.assertSessionExistsOnSqlite(sessionId);
+        }
+        return {
+            provider: this.providerId,
+            providerSessionId: sessionId,
+            resumedAt: nextTimestamp(),
+            rawStoreRef: buildSessionRawStoreRef(sessionId)
+        };
+    }
+    async startSession(workspacePath, options) {
+        const session = await this.createSessionOnServer(workspacePath);
+        if (options.initialPrompt?.trim()) {
+            await this.postTextPrompt(session.id, options.initialPrompt.trim());
+        }
+        const summary = await this.readSessionSummaryFromServer(session.id)
+            .catch(() => null);
+        const sessionSummary = summary ?? this.normalizeServerSessionSummary(session, new Map()) ?? {
+            provider: this.providerId,
+            providerSessionId: session.id,
+            title: ensureText(session.title).trim() || session.id,
+            workspacePath,
+            rawStoreRef: buildSessionRawStoreRef(session.id),
+            isArchived: false,
+            lastMessageAt: nextTimestamp(),
+            messageCount: options.initialPrompt?.trim() ? 1 : 0,
+            parentProviderSessionId: null,
+            isSubagent: false,
+            subagentLabel: null
+        };
+        return {
+            session: sessionSummary,
+            initialCursor: null
+        };
+    }
+    async sendMessage(providerSessionId, rawStoreRef, content, clientRequestId) {
+        const sessionId = this.resolveSessionId(providerSessionId, rawStoreRef);
+        const trimmed = content.trim();
+        if (!trimmed) {
+            throw new Error("INVALID_INPUT");
+        }
+        const acceptedAt = nextTimestamp();
+        await this.postTextPrompt(sessionId, trimmed);
+        const message = await this.findAcceptedUserMessage(sessionId, trimmed)
+            ?? buildSyntheticAcceptedMessage(sessionId, trimmed, acceptedAt);
+        return {
+            acceptedAt,
+            clientRequestId,
+            message
+        };
+    }
+    async readSessionTitle(providerSessionId, rawStoreRef) {
+        const sessionId = this.resolveSessionId(providerSessionId, rawStoreRef);
+        const serverTitle = await this.tryReadSessionTitleFromServer(sessionId);
+        if (serverTitle) {
+            return serverTitle;
+        }
+        const row = this.withReadonlyDb((db) => {
+            return db.prepare(`SELECT title FROM session WHERE id = ? LIMIT 1`).get(sessionId);
+        });
+        if (!row) {
+            throw new Error("PROVIDER_SESSION_NOT_FOUND");
+        }
+        const title = ensureText(row.title).trim();
+        return title || sessionId;
+    }
+    async renameSessionTitle(providerSessionId, rawStoreRef, title) {
+        const sessionId = this.resolveSessionId(providerSessionId, rawStoreRef);
+        const nextTitle = title.trim();
+        if (!nextTitle) {
+            throw new Error("INVALID_INPUT");
+        }
+        const response = await this.fetchJson(`/session/${encodeURIComponent(sessionId)}`, {
+            method: "PATCH",
+            headers: {
+                "content-type": "application/json"
+            },
+            body: JSON.stringify({
+                title: nextTitle
+            })
+        });
+        return ensureText(response.data.title).trim() || nextTitle;
+    }
+    async updateSessionArchiveState(_providerSessionId, _rawStoreRef, _isArchived) {
+        throw new Error("OPENCODE_ARCHIVE_NOT_SUPPORTED");
+    }
+    getProviderCapabilities() {
+        return {
+            provider: this.providerId,
+            canStartSession: true,
+            canResumeSession: true,
+            canSendMessage: true,
+            inRunInputMode: "none",
+            supportsSubagents: true,
+            supportsInterrupt: true,
+            supportsStructuredToolCalls: true,
+            supportsTokenUsage: false,
+            supportsAttachments: false,
+            supportsPermissionPrompt: false,
+            supportsCheckpoint: false,
+            supportsTodo: true,
+            supportsSessionDiff: true,
+            supportsPermissionRequests: true,
+            supportsSessionFork: true,
+            supportsSessionShare: true,
+            supportsAsyncPrompt: true,
+            supportsNativeAgents: true,
+            limitations: [
+                "当前 OpenCode 先以 server 为主链路；server 不可达时只对历史读取做 sqlite 只读兜底。",
+                "附件上传、权限回复和分享管理还没有接到当前 UI。"
+            ]
+        };
+    }
+    async getSessionCapabilities() {
+        return this.getProviderCapabilities();
+    }
+    async tryDetectSessionsFromServer(targetPath, knownSessions) {
+        try {
+            const response = await this.fetchJson("/session", {
+                query: {
+                    directory: targetPath || undefined,
+                    roots: "true"
+                }
+            });
+            const ids = response.data
+                .map((session) => ensureText(session.id).trim())
+                .filter((value) => value.length > 0);
+            const metadata = this.readSessionMetadata(ids);
+            const serverSessions = response.data
+                .map((session) => this.normalizeServerSessionSummary(session, metadata))
+                .filter((summary) => summary !== null)
+                .filter((summary) => workspaceMatches(targetPath, normalizeWorkspacePath(summary.workspacePath)))
+                .sort((left, right) => (right.lastMessageAt ?? "").localeCompare(left.lastMessageAt ?? ""));
+            const mergedSessions = new Map(serverSessions.map((session) => [session.providerSessionId, session]));
+            const missingKnownSessions = knownSessions.filter((session) => !mergedSessions.has(session.providerSessionId));
+            let isComplete = true;
+            if (missingKnownSessions.length > 0) {
+                const recoveredSessions = this.readSessionSummariesByIds(missingKnownSessions.map((session) => session.providerSessionId), targetPath);
+                if (recoveredSessions === null) {
+                    isComplete = false;
+                }
+                else if (recoveredSessions.length > 0) {
+                    isComplete = false;
+                    for (const session of recoveredSessions) {
+                        if (!mergedSessions.has(session.providerSessionId)) {
+                            mergedSessions.set(session.providerSessionId, session);
+                        }
+                    }
+                }
+            }
+            return {
+                sessions: [...mergedSessions.values()].sort((left, right) => (right.lastMessageAt ?? "").localeCompare(left.lastMessageAt ?? "")),
+                isComplete
+            };
+        }
+        catch (error) {
+            if (isServerUnavailableError(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async tryReadSessionMessagesFromServer(sessionId) {
+        try {
+            return await this.readSessionMessagesFromServer(sessionId);
+        }
+        catch (error) {
+            if (isServerUnavailableError(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async readSessionMessagesFromServer(sessionId) {
+        const envelopes = [];
+        let before = null;
+        while (true) {
+            const response = await this.fetchJson(`/session/${encodeURIComponent(sessionId)}/message`, {
+                query: {
+                    limit: String(DEFAULT_SERVER_PAGE_LIMIT),
+                    before: before ?? undefined
+                }
+            });
+            envelopes.push(...response.data);
+            const nextCursor = response.headers.get("x-next-cursor");
+            if (!nextCursor) {
+                break;
+            }
+            before = nextCursor;
+        }
+        return normalizeOpenCodeMessageEnvelopes(sessionId, sessionId, envelopes);
+    }
+    async createSessionOnServer(workspacePath) {
+        const response = await this.fetchJson("/session", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json"
+            },
+            query: {
+                directory: workspacePath
+            },
+            body: JSON.stringify({})
+        });
+        const sessionId = ensureText(response.data.id).trim();
+        if (!sessionId) {
+            throw new Error("PROVIDER_SESSION_ID_REQUIRED");
+        }
+        return {
+            id: sessionId,
+            title: response.data.title
+        };
+    }
+    async postTextPrompt(sessionId, text) {
+        await this.fetchJson(`/session/${encodeURIComponent(sessionId)}/message`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json"
+            },
+            body: JSON.stringify({
+                parts: [
+                    {
+                        type: "text",
+                        text
+                    }
+                ]
+            })
+        });
+    }
+    async findAcceptedUserMessage(sessionId, content) {
+        try {
+            const response = await this.fetchJson(`/session/${encodeURIComponent(sessionId)}/message`, {
+                query: {
+                    limit: "20"
+                }
+            });
+            const messages = normalizeOpenCodeMessageEnvelopes(sessionId, sessionId, response.data.reverse());
+            const trimmed = content.trim();
+            for (let index = messages.length - 1; index >= 0; index -= 1) {
+                const message = messages[index];
+                if (message?.role === "user"
+                    && message.content.trim() === trimmed) {
+                    return message;
+                }
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async readSessionSummaryFromServer(sessionId) {
+        const response = await this.fetchJson(`/session/${encodeURIComponent(sessionId)}`);
+        const metadata = this.readSessionMetadata([sessionId]);
+        return this.normalizeServerSessionSummary(response.data, metadata);
+    }
+    async tryReadSessionTitleFromServer(sessionId) {
+        try {
+            const response = await this.fetchJson(`/session/${encodeURIComponent(sessionId)}`);
+            const title = ensureText(response.data.title).trim();
+            return title || sessionId;
+        }
+        catch (error) {
+            if (isServerUnavailableError(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async tryAssertSessionExistsOnServer(sessionId) {
+        try {
+            await this.fetchJson(`/session/${encodeURIComponent(sessionId)}`);
+            return true;
+        }
+        catch (error) {
+            if (isServerUnavailableError(error)) {
+                return false;
+            }
+            if (error instanceof Error && error.message === "PROVIDER_SESSION_NOT_FOUND") {
+                throw error;
+            }
+            throw error;
+        }
+    }
+    async resolveBaseUrl(refresh = false) {
+        const resolved = this.options.baseUrlResolver
+            ? await this.options.baseUrlResolver({ refresh })
+            : this.options.baseUrl?.trim();
+        if (!resolved) {
+            throw new Error("SERVER_UNAVAILABLE");
+        }
+        return resolved.trim().replace(/\/+$/, "");
+    }
+    resolveDbPath() {
+        const configuredPath = this.options.dbPath?.trim();
+        if (configuredPath) {
+            return configuredPath;
+        }
+        const dataDir = this.options.dataDir?.trim() || DEFAULT_DATA_DIR;
+        return join(dataDir, "opencode.db");
+    }
+    resolvePollIntervalMs() {
+        const configured = this.options.pollIntervalMs;
+        if (!Number.isFinite(configured)) {
+            return DEFAULT_POLL_INTERVAL_MS;
+        }
+        return Math.max(MIN_POLL_INTERVAL_MS, Math.floor(configured));
+    }
+    resolveRequestTimeoutMs() {
+        const configured = this.options.requestTimeoutMs;
+        if (!Number.isFinite(configured)) {
+            return DEFAULT_REQUEST_TIMEOUT_MS;
+        }
+        return Math.max(1_000, Math.floor(configured));
+    }
+    async fetchJson(pathname, input = {}) {
+        return this.fetchJsonWithRetry(pathname, input, false);
+    }
+    async fetchJsonWithRetry(pathname, input, refresh, timeoutState = createTimeoutRetryState()) {
+        const url = new URL(pathname, `${await this.resolveBaseUrl(refresh)}/`);
+        if (input.query) {
+            for (const [key, value] of Object.entries(input.query)) {
+                if (value) {
+                    url.searchParams.set(key, value);
+                }
+            }
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => {
+            controller.abort();
+        }, this.resolveRequestTimeoutMs());
+        let response;
+        try {
+            response = await fetch(url, {
+                method: input.method ?? "GET",
+                headers: input.headers,
+                body: input.body,
+                signal: controller.signal
+            });
+        }
+        catch (error) {
+            clearTimeout(timer);
+            if (error instanceof Error && error.name === "AbortError") {
+                const nextTimeoutState = advanceTimeoutRetryState(timeoutState);
+                if (!shouldSurfaceTimeout(nextTimeoutState)) {
+                    if (!refresh && this.options.baseUrlResolver) {
+                        return this.fetchJsonWithRetry(pathname, input, true, nextTimeoutState);
+                    }
+                    return this.fetchJsonWithRetry(pathname, input, refresh, nextTimeoutState);
+                }
+                throw new Error("SERVER_TIMEOUT");
+            }
+            if (!refresh && this.options.baseUrlResolver) {
+                return this.fetchJsonWithRetry(pathname, input, true, timeoutState);
+            }
+            throw new Error("SERVER_UNAVAILABLE");
+        }
+        clearTimeout(timer);
+        if (!response.ok) {
+            const detail = await safeReadResponseText(response);
+            const mapped = mapOpenCodeHttpError(response.status, detail);
+            if (!refresh && isServerUnavailableError(mapped) && this.options.baseUrlResolver) {
+                return this.fetchJsonWithRetry(pathname, input, true);
+            }
+            throw mapped;
+        }
+        const text = await response.text();
+        return {
+            data: text.length > 0 ? JSON.parse(text) : undefined,
+            headers: response.headers
+        };
+    }
+    withReadonlyDb(run) {
+        const dbPath = this.resolveDbPath();
+        if (!existsSync(dbPath)) {
+            throw new Error("OPENCODE_DB_NOT_FOUND");
+        }
+        let db = null;
+        try {
+            db = new DatabaseSync(dbPath, { open: true, readOnly: true });
+            return run(db);
+        }
+        finally {
+            db?.close();
+        }
+    }
+    resolveSessionId(providerSessionId, rawStoreRef) {
+        const explicit = providerSessionId.trim();
+        if (explicit.length > 0) {
+            return explicit;
+        }
+        const parsed = parseSessionIdFromRawStoreRef(rawStoreRef);
+        if (parsed) {
+            return parsed;
+        }
+        throw new Error("PROVIDER_SESSION_ID_REQUIRED");
+    }
+    assertSessionExistsOnSqlite(sessionId) {
+        const row = this.withReadonlyDb((db) => {
+            return db.prepare(`SELECT EXISTS(SELECT 1 FROM session WHERE id = ?) AS session_exists`).get(sessionId);
+        });
+        const exists = readInteger(row?.session_exists);
+        if (exists !== 1) {
+            throw new Error("PROVIDER_SESSION_NOT_FOUND");
+        }
+    }
+    normalizeSqliteSessionSummaryRow(row) {
+        const sessionId = ensureText(row.id).trim();
+        if (!sessionId) {
+            return null;
+        }
+        const workspacePath = ensureText(row.directory).trim();
+        const summaryUpdatedAtMs = firstValidNumber(row.last_message_time_ms, row.time_updated, row.time_created);
+        const lastMessageAt = toIsoTimestamp(summaryUpdatedAtMs, null);
+        const title = ensureText(row.title).trim() || sessionId;
+        const parentProviderSessionId = ensureText(row.parent_id).trim() || null;
+        const isArchived = row.time_archived !== null && row.time_archived !== undefined;
+        return {
+            provider: this.providerId,
+            providerSessionId: sessionId,
+            title,
+            workspacePath,
+            rawStoreRef: buildSessionRawStoreRef(sessionId),
+            isArchived,
+            lastMessageAt,
+            messageCount: Math.max(0, readInteger(row.message_count) ?? 0),
+            parentProviderSessionId,
+            isSubagent: Boolean(parentProviderSessionId),
+            subagentLabel: null
+        };
+    }
+    normalizeServerSessionSummary(session, metadataById) {
+        const sessionId = ensureText(session.id).trim();
+        if (!sessionId) {
+            return null;
+        }
+        const metadata = metadataById.get(sessionId);
+        const time = toJsonRecord(session.time);
+        const summaryUpdatedAtMs = firstValidNumber(time?.updated, time?.created);
+        const parentProviderSessionId = ensureText(session.parentID).trim()
+            || ensureText(session.parent_id).trim()
+            || metadata?.parentProviderSessionId
+            || null;
+        const workspacePath = ensureText(session.directory).trim();
+        return {
+            provider: this.providerId,
+            providerSessionId: sessionId,
+            title: ensureText(session.title).trim() || sessionId,
+            workspacePath,
+            rawStoreRef: buildSessionRawStoreRef(sessionId),
+            isArchived: metadata?.isArchived ?? false,
+            lastMessageAt: toIsoTimestamp(summaryUpdatedAtMs, null),
+            messageCount: metadata?.messageCount ?? 0,
+            parentProviderSessionId,
+            isSubagent: Boolean(parentProviderSessionId),
+            subagentLabel: null
+        };
+    }
+    readSessionMetadata(sessionIds) {
+        if (sessionIds.length === 0 || !existsSync(this.resolveDbPath())) {
+            return new Map();
+        }
+        return this.withReadonlyDb((db) => {
+            const placeholders = sessionIds.map(() => "?").join(", ");
+            const rows = db.prepare(`SELECT
+           s.id AS id,
+           s.parent_id AS parent_id,
+           s.time_archived AS time_archived,
+           COALESCE(stats.message_count, 0) AS message_count
+         FROM session s
+         LEFT JOIN (
+           SELECT session_id, COUNT(*) AS message_count
+           FROM message
+           GROUP BY session_id
+         ) AS stats
+           ON stats.session_id = s.id
+         WHERE s.id IN (${placeholders})`).all(...sessionIds);
+            return new Map(rows
+                .map((row) => {
+                const sessionId = ensureText(row.id).trim();
+                if (!sessionId) {
+                    return null;
+                }
+                return [
+                    sessionId,
+                    {
+                        parentProviderSessionId: ensureText(row.parent_id).trim() || null,
+                        isArchived: row.time_archived !== null && row.time_archived !== undefined,
+                        messageCount: Math.max(0, readInteger(row.message_count) ?? 0)
+                    }
+                ];
+            })
+                .filter((entry) => entry !== null));
+        });
+    }
+    readSessionSummariesByIds(sessionIds, targetPath) {
+        if (sessionIds.length === 0) {
+            return [];
+        }
+        if (!existsSync(this.resolveDbPath())) {
+            return null;
+        }
+        return this.withReadonlyDb((db) => {
+            const placeholders = sessionIds.map(() => "?").join(", ");
+            const rows = db.prepare(`SELECT
+           s.id AS id,
+           s.parent_id AS parent_id,
+           s.directory AS directory,
+           s.title AS title,
+           s.time_created AS time_created,
+           s.time_updated AS time_updated,
+           s.time_archived AS time_archived,
+           COALESCE(stats.message_count, 0) AS message_count,
+           stats.last_message_time_ms AS last_message_time_ms
+         FROM session s
+         LEFT JOIN (
+           SELECT
+             session_id,
+             COUNT(*) AS message_count,
+             MAX(COALESCE(time_updated, time_created)) AS last_message_time_ms
+           FROM message
+           GROUP BY session_id
+         ) AS stats
+           ON stats.session_id = s.id
+         WHERE s.id IN (${placeholders})`).all(...sessionIds);
+            return rows
+                .map((row) => this.normalizeSqliteSessionSummaryRow(row))
+                .filter((summary) => summary !== null)
+                .filter((summary) => workspaceMatches(targetPath, normalizeWorkspacePath(summary.workspacePath)));
+        });
+    }
+    readSessionMessagesFromSqlite(sessionId) {
+        this.assertSessionExistsOnSqlite(sessionId);
+        const rows = this.withReadonlyDb((db) => {
+            return db.prepare(`SELECT
+           p.id AS part_id,
+           p.message_id AS message_id,
+           p.time_created AS part_time_created,
+           p.data AS part_data,
+           m.time_created AS message_time_created,
+           m.data AS message_data
+         FROM part p
+         INNER JOIN message m
+           ON m.id = p.message_id
+         WHERE p.session_id = ?
+         ORDER BY p.time_created ASC, p.rowid ASC`).all(sessionId);
+        });
+        const envelopes = rows.reduce((map, row) => {
+            const messageId = ensureText(row.message_id).trim();
+            const partId = ensureText(row.part_id).trim();
+            const messagePayload = toJsonRecord(row.message_data);
+            const partPayload = toJsonRecord(row.part_data);
+            if (!messageId || !partId || !messagePayload || !partPayload) {
+                return map;
+            }
+            const existing = map.get(messageId) ?? {
+                info: {
+                    ...messagePayload,
+                    id: messageId,
+                    sessionID: sessionId,
+                    time: {
+                        ...(toJsonRecord(messagePayload.time) ?? {}),
+                        created: firstValidNumber(row.message_time_created) ?? undefined
+                    }
+                },
+                parts: []
+            };
+            const parts = Array.isArray(existing.parts) ? existing.parts : [];
+            parts.push({
+                ...partPayload,
+                id: partId,
+                sessionID: sessionId,
+                messageID: messageId
+            });
+            existing.parts = parts;
+            map.set(messageId, existing);
+            return map;
+        }, new Map());
+        return normalizeOpenCodeMessageEnvelopes(sessionId, sessionId, [...envelopes.values()]);
+    }
+}
+function buildSyntheticAcceptedMessage(sessionId, content, timestamp) {
+    const rawRef = `${buildMessageRawRef(sessionId, `accepted-${Date.parse(timestamp)}`)}#synthetic`;
+    return {
+        messageId: `opencode-accepted-${Date.parse(timestamp)}`,
+        provider: "opencode",
+        providerSessionId: sessionId,
+        role: "user",
+        kind: "text",
+        content,
+        toolCall: null,
+        timestamp,
+        sequence: 1,
+        rawRef
+    };
+}
+function mapOpenCodeHttpError(statusCode, detail) {
+    if (statusCode === 404) {
+        return new Error("PROVIDER_SESSION_NOT_FOUND");
+    }
+    if (statusCode >= 500) {
+        return new Error("SERVER_UNAVAILABLE");
+    }
+    if (statusCode === 409 && /active|running|busy/i.test(detail)) {
+        return new Error("ACTIVE_RUN_EXISTS");
+    }
+    return new Error(detail || `OPENCODE_HTTP_${statusCode}`);
+}
+async function safeReadResponseText(response) {
+    try {
+        return (await response.text()).trim();
+    }
+    catch {
+        return "";
+    }
+}
+function isServerUnavailableError(error) {
+    return error instanceof Error && error.message === "SERVER_UNAVAILABLE";
+}
+function createTimeoutRetryState() {
+    return {
+        startedAtMs: Date.now(),
+        timeoutCount: 0
+    };
+}
+function advanceTimeoutRetryState(state) {
+    return {
+        startedAtMs: state.startedAtMs,
+        timeoutCount: state.timeoutCount + 1
+    };
+}
+function shouldSurfaceTimeout(state) {
+    return (state.timeoutCount >= MAX_CONSECUTIVE_TIMEOUTS
+        || Date.now() - state.startedAtMs >= TIMEOUT_WARNING_THRESHOLD_MS);
+}
+//# sourceMappingURL=opencode.js.map