@jingyi0605/codingns 0.8.0 → 0.8.5

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

@@ -0,0 +1,1191 @@
+import { existsSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { ensureText, nextTimestamp, normalizeWorkspacePath, sliceHistory } from "./utils.js";
+import { buildMessageRawRef, normalizeOpenCodePartMessage, buildSessionRawStoreRef, firstValidNumber, normalizeOpenCodeMessageEnvelopes, parseSessionIdFromRawStoreRef, readInteger, toIsoTimestamp, toJsonRecord, workspaceMatches } from "./opencode-shared.js";
+import { createOpenCodeMessagePermissionOptions } from "./opencode-permissions.js";
+import { loadDatabaseSync } from "../sqlite/node-sqlite.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;
+const OPENCODE_SUBMIT_TIMEOUT_AMBIGUOUS = "OPENCODE_SUBMIT_TIMEOUT_AMBIGUOUS";
+const OPENCODE_DISCOVERY_CACHE_MAX_AGE_MS = 3_000;
+const OPENCODE_DISCOVERY_CACHE_LIMIT = 32;
+export class OpenCodeAdapter {
+    options;
+    providerId = "opencode";
+    discoveryCache = new Map();
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async detectSessions(workspacePath, options) {
+        const discovery = await this.detectSessionsDetailed(workspacePath, options);
+        return discovery.sessions;
+    }
+    async detectSessionsDetailed(workspacePath, options) {
+        const startedAt = Date.now();
+        const targetPath = normalizeWorkspacePath(workspacePath);
+        const cacheKey = targetPath || "__all__";
+        const cached = this.discoveryCache.get(cacheKey);
+        if (cached && Date.now() - cached.cachedAt <= OPENCODE_DISCOVERY_CACHE_MAX_AGE_MS) {
+            this.touchDiscoveryCache(cacheKey, cached.result);
+            return cached.result;
+        }
+        const knownSessions = (options?.knownSessions ?? []).filter((session) => session.provider === this.providerId &&
+            workspaceMatches(targetPath, normalizeWorkspacePath(session.workspacePath)));
+        const serverDiscovery = await this.tryDetectSessionsFromServer(targetPath, knownSessions);
+        if (serverDiscovery) {
+            const sessions = [...serverDiscovery.sessions].sort((left, right) => (right.lastMessageAt ?? "").localeCompare(left.lastMessageAt ?? ""));
+            const diagnostic = {
+                provider: this.providerId,
+                status: serverDiscovery.isComplete ? "success" : "partial",
+                durationMs: Date.now() - startedAt,
+                sessionCount: sessions.length,
+                isComplete: serverDiscovery.isComplete,
+                errorMessage: null,
+                scannedFiles: 0,
+                skippedByMtimeSize: 0,
+                parsedFiles: 0,
+                bytesRead: 0
+            };
+            const result = {
+                ...serverDiscovery,
+                sessions,
+                providerDiagnostics: [diagnostic]
+            };
+            this.touchDiscoveryCache(cacheKey, result);
+            return result;
+        }
+        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();
+        });
+        const 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 ?? ""));
+        const diagnostic = {
+            provider: this.providerId,
+            status: "success",
+            durationMs: Date.now() - startedAt,
+            sessionCount: sessions.length,
+            isComplete: true,
+            errorMessage: null,
+            scannedFiles: 0,
+            skippedByMtimeSize: 0,
+            parsedFiles: 0,
+            bytesRead: 0
+        };
+        const result = {
+            sessions,
+            isComplete: true,
+            providerDiagnostics: [diagnostic]
+        };
+        this.touchDiscoveryCache(cacheKey, result);
+        return result;
+    }
+    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);
+        const initialPrompt = options.initialPrompt?.trim() ?? "";
+        const acceptedAt = initialPrompt ? nextTimestamp() : null;
+        if (initialPrompt) {
+            try {
+                await this.postTextPrompt(session.id, initialPrompt, undefined, workspacePath);
+            }
+            catch (error) {
+                if (!isOpenCodeSubmitTimeoutAmbiguous(error)
+                    || !(await this.findAcceptedUserMessage(session.id, initialPrompt, acceptedAt, workspacePath))) {
+                    throw error;
+                }
+            }
+        }
+        const summary = await this.readSessionSummaryFromServer(session.id, workspacePath)
+            .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
+        };
+        this.discoveryCache.clear();
+        return {
+            session: sessionSummary,
+            initialCursor: null
+        };
+    }
+    async forkSession(providerSessionId, rawWorkspacePath, options) {
+        const sourceSessionId = this.resolveSessionId(providerSessionId, options.rawStoreRef);
+        const workspacePath = rawWorkspacePath.trim() || rawWorkspacePath;
+        if (options.sourceType === "message" && !(options.sourceMessageId?.trim())) {
+            throw new Error("FORK_SOURCE_MESSAGE_ID_REQUIRED");
+        }
+        const forked = this.cloneSessionFromSqlite({
+            sourceSessionId,
+            workspacePath,
+            sourceType: options.sourceType,
+            sourceMessageId: options.sourceMessageId?.trim() || null,
+            sourceMessageSnapshot: options.sourceMessageSnapshot ?? null
+        });
+        this.discoveryCache.clear();
+        return {
+            session: {
+                provider: this.providerId,
+                providerSessionId: forked.providerSessionId,
+                title: forked.title,
+                workspacePath,
+                rawStoreRef: buildSessionRawStoreRef(forked.providerSessionId),
+                isArchived: false,
+                lastMessageAt: forked.lastMessageAt,
+                messageCount: forked.inheritedPrefixMessageCount,
+                parentProviderSessionId: null,
+                isSubagent: false,
+                subagentLabel: null
+            },
+            forkMethod: options.sourceType === "session" ? "native_session_fork" : "native_message_fork",
+            forkSourceType: options.sourceType,
+            inheritedPrefixMessageCount: forked.inheritedPrefixMessageCount,
+            providerSourceMessageId: forked.providerSourceMessageId
+        };
+    }
+    async sendMessage(providerSessionId, rawStoreRef, content, clientRequestId, permissionMode) {
+        const sessionId = this.resolveSessionId(providerSessionId, rawStoreRef);
+        const trimmed = content.trim();
+        if (!trimmed) {
+            throw new Error("INVALID_INPUT");
+        }
+        const acceptedAt = nextTimestamp();
+        try {
+            await this.postTextPrompt(sessionId, trimmed, permissionMode);
+        }
+        catch (error) {
+            if (!isOpenCodeSubmitTimeoutAmbiguous(error)) {
+                throw error;
+            }
+            const acceptedMessage = await this.findAcceptedUserMessage(sessionId, trimmed, acceptedAt);
+            if (!acceptedMessage) {
+                throw error;
+            }
+            this.discoveryCache.clear();
+            return {
+                acceptedAt: acceptedMessage.timestamp,
+                clientRequestId,
+                message: acceptedMessage
+            };
+        }
+        const message = await this.findAcceptedUserMessage(sessionId, trimmed, acceptedAt)
+            ?? buildSyntheticAcceptedMessage(sessionId, trimmed, acceptedAt);
+        const resolvedAcceptedAt = message.timestamp || acceptedAt;
+        this.discoveryCache.clear();
+        return {
+            acceptedAt: resolvedAcceptedAt,
+            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();
+        if (title) {
+            return title;
+        }
+        return this.readFirstUserMessageTitleFromSqlite(sessionId) || 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
+            })
+        });
+        this.discoveryCache.clear();
+        return ensureText(response.data.title).trim() || nextTitle;
+    }
+    async updateSessionArchiveState(_providerSessionId, _rawStoreRef, _isArchived) {
+        throw new Error("OPENCODE_ARCHIVE_NOT_SUPPORTED");
+    }
+    async deleteSession(providerSessionId, rawStoreRef) {
+        const sessionId = this.resolveSessionId(providerSessionId, rawStoreRef);
+        let deleted = false;
+        try {
+            await this.fetchJson(`/session/${encodeURIComponent(sessionId)}`, {
+                method: "DELETE"
+            });
+            deleted = true;
+        }
+        catch (error) {
+            if (!(error instanceof Error)
+                || (error.message !== "SERVER_UNAVAILABLE"
+                    && error.message !== "SERVER_TIMEOUT"
+                    && error.message !== "PROVIDER_SESSION_NOT_FOUND"
+                    && !error.message.startsWith("OPENCODE_HTTP_"))) {
+                throw error;
+            }
+        }
+        const deletedFromSqlite = this.withWritableDb((db) => {
+            const partChanges = Number(db.prepare("DELETE FROM part WHERE session_id = ?").run(sessionId).changes);
+            const messageChanges = Number(db.prepare("DELETE FROM message WHERE session_id = ?").run(sessionId).changes);
+            const sessionChanges = Number(db.prepare("DELETE FROM session WHERE id = ?").run(sessionId).changes);
+            return partChanges + messageChanges + sessionChanges;
+        });
+        this.discoveryCache.clear();
+        if (!deleted && deletedFromSqlite === 0) {
+            throw new Error("PROVIDER_SESSION_NOT_FOUND");
+        }
+    }
+    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,
+            supportsSessionDelete: true,
+            supportsSessionShare: true,
+            supportsAsyncPrompt: true,
+            supportsNativeAgents: true,
+            limitations: [
+                "当前 OpenCode 先以 server 为主链路；server 不可达时只对历史读取做 sqlite 只读兜底。",
+                "附件上传、权限回复和分享管理还没有接到当前 UI。"
+            ]
+        };
+    }
+    async getSessionCapabilities() {
+        return this.getProviderCapabilities();
+    }
+    touchDiscoveryCache(cacheKey, result) {
+        this.discoveryCache.delete(cacheKey);
+        this.discoveryCache.set(cacheKey, {
+            cachedAt: Date.now(),
+            result
+        });
+        while (this.discoveryCache.size > OPENCODE_DISCOVERY_CACHE_LIMIT) {
+            const oldestKey = this.discoveryCache.keys().next().value;
+            if (!oldestKey) {
+                break;
+            }
+            this.discoveryCache.delete(oldestKey);
+        }
+    }
+    async tryDetectSessionsFromServer(targetPath, knownSessions) {
+        try {
+            const response = await this.fetchJson("/session", {
+                workspacePath: targetPath,
+                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) || isServerTimeoutError(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", {
+            workspacePath,
+            method: "POST",
+            headers: {
+                "content-type": "application/json"
+            },
+            query: {
+                directory: workspacePath
+            },
+            body: JSON.stringify({
+                directory: workspacePath
+            })
+        });
+        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, permissionMode, workspacePath) {
+        await this.fetchJson(`/session/${encodeURIComponent(sessionId)}/message`, {
+            workspacePath,
+            method: "POST",
+            headers: {
+                "content-type": "application/json"
+            },
+            timeoutErrorMessage: OPENCODE_SUBMIT_TIMEOUT_AMBIGUOUS,
+            body: JSON.stringify({
+                ...createOpenCodeMessagePermissionOptions(permissionMode),
+                parts: [
+                    {
+                        type: "text",
+                        text
+                    }
+                ]
+            })
+        });
+    }
+    async findAcceptedUserMessage(sessionId, content, minTimestamp = null, workspacePath) {
+        try {
+            const response = await this.fetchJson(`/session/${encodeURIComponent(sessionId)}/message`, {
+                query: {
+                    limit: "20"
+                },
+                workspacePath
+            });
+            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
+                    && isTimestampOnOrAfter(message.timestamp, minTimestamp)) {
+                    return message;
+                }
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async readSessionSummaryFromServer(sessionId, workspacePath) {
+        const response = await this.fetchJson(`/session/${encodeURIComponent(sessionId)}`, {
+            workspacePath
+        });
+        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, workspacePath = null) {
+        const resolved = this.options.baseUrlResolver
+            ? await this.options.baseUrlResolver({ refresh, workspacePath })
+            : 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));
+    }
+    cloneSessionFromSqlite(input) {
+        const forkedSessionId = `ses_${randomUUID().replaceAll("-", "")}`;
+        const nowMs = Date.now();
+        return this.withWritableDb((db) => {
+            const sourceSession = db.prepare(`SELECT
+           id,
+           project_id,
+           parent_id,
+           slug,
+           directory,
+           title,
+           version,
+           share_url,
+           summary_additions,
+           summary_deletions,
+           summary_files,
+           summary_diffs,
+           revert,
+           permission,
+           time_created,
+           time_updated,
+           time_compacting,
+           time_archived,
+           workspace_id
+         FROM session
+         WHERE id = ?
+         LIMIT 1`).get(input.sourceSessionId);
+            if (!sourceSession) {
+                throw new Error("PROVIDER_SESSION_NOT_FOUND");
+            }
+            const sourceMessageRows = db.prepare(`SELECT id, time_created, time_updated, data
+         FROM message
+         WHERE session_id = ?
+         ORDER BY COALESCE(time_updated, time_created), time_created, id`).all(input.sourceSessionId);
+            const readPartRows = db.prepare(`SELECT id, message_id, time_created, time_updated, data
+         FROM part
+         WHERE session_id = ? AND message_id = ?
+         ORDER BY COALESCE(time_updated, time_created), time_created, id`);
+            const insertSession = db.prepare(`INSERT INTO session (
+           id,
+           project_id,
+           parent_id,
+           slug,
+           directory,
+           title,
+           version,
+           share_url,
+           summary_additions,
+           summary_deletions,
+           summary_files,
+           summary_diffs,
+           revert,
+           permission,
+           time_created,
+           time_updated,
+           time_compacting,
+           time_archived,
+           workspace_id
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+            const insertMessage = db.prepare(`INSERT INTO message (
+           id,
+           session_id,
+           time_created,
+           time_updated,
+           data
+         ) VALUES (?, ?, ?, ?, ?)`);
+            const insertPart = db.prepare(`INSERT INTO part (
+           id,
+           message_id,
+           session_id,
+           time_created,
+           time_updated,
+           data
+         ) VALUES (?, ?, ?, ?, ?, ?)`);
+            let derivedTitle = null;
+            insertSession.run(forkedSessionId, ensureText(sourceSession.project_id).trim() || "global", null, buildForkSlug(ensureText(sourceSession.slug).trim(), forkedSessionId), input.workspacePath, "", ensureText(sourceSession.version).trim() || "v1", ensureNullableText(sourceSession.share_url), readInteger(sourceSession.summary_additions), readInteger(sourceSession.summary_deletions), readInteger(sourceSession.summary_files), ensureNullableText(sourceSession.summary_diffs), ensureNullableText(sourceSession.revert), ensureNullableText(sourceSession.permission), readInteger(sourceSession.time_created) ?? nowMs, nowMs, readInteger(sourceSession.time_compacting), null, ensureNullableText(sourceSession.workspace_id));
+            let inheritedPrefixMessageCount = 0;
+            let providerSourceMessageId = null;
+            let lastMessageAtMs = firstValidNumber(sourceSession.time_updated, sourceSession.time_created);
+            let reachedAnchor = false;
+            for (const messageRow of sourceMessageRows) {
+                const sourceMessageRowId = ensureText(messageRow.id).trim();
+                if (!sourceMessageRowId) {
+                    continue;
+                }
+                const partRows = readPartRows.all(input.sourceSessionId, sourceMessageRowId);
+                const includedPartRows = [];
+                for (const partRow of partRows) {
+                    const sourcePartId = ensureText(partRow.id).trim();
+                    if (!sourcePartId) {
+                        continue;
+                    }
+                    includedPartRows.push(partRow);
+                    const normalized = normalizeOpenCodePartMessage({
+                        sessionId: input.sourceSessionId,
+                        providerSessionId: input.sourceSessionId,
+                        partId: sourcePartId,
+                        messageId: sourceMessageRowId,
+                        partPayload: toJsonRecord(partRow.data) ?? {},
+                        messagePayload: toJsonRecord(messageRow.data) ?? {},
+                        defaultTimestamp: toIsoTimestamp(firstValidNumber(partRow.time_created, messageRow.time_created, messageRow.time_updated), null) ?? nextTimestamp()
+                    });
+                    if (normalized) {
+                        inheritedPrefixMessageCount += 1;
+                        lastMessageAtMs = Date.parse(normalized.timestamp);
+                        if (derivedTitle === null) {
+                            derivedTitle = resolveOpenCodeMessageTitle(normalized);
+                        }
+                    }
+                    if (input.sourceType === "message" && normalized?.messageId === input.sourceMessageId) {
+                        providerSourceMessageId = sourcePartId;
+                        if (input.sourceMessageSnapshot) {
+                            includedPartRows[includedPartRows.length - 1] = {
+                                ...partRow,
+                                data: applyOpenCodeForkSourceSnapshot(toJsonRecord(partRow.data) ?? {}, input.sourceMessageSnapshot)
+                            };
+                        }
+                        reachedAnchor = true;
+                        break;
+                    }
+                }
+                if (includedPartRows.length === 0) {
+                    continue;
+                }
+                const forkedMessageId = randomUUID();
+                insertMessage.run(forkedMessageId, forkedSessionId, readInteger(messageRow.time_created) ?? nowMs, readInteger(messageRow.time_updated) ?? readInteger(messageRow.time_created) ?? nowMs, JSON.stringify(toJsonRecord(messageRow.data) ?? {}));
+                for (const partRow of includedPartRows) {
+                    insertPart.run(randomUUID(), forkedMessageId, forkedSessionId, readInteger(partRow.time_created) ?? nowMs, readInteger(partRow.time_updated) ?? readInteger(partRow.time_created) ?? nowMs, JSON.stringify(toJsonRecord(partRow.data) ?? {}));
+                }
+                if (reachedAnchor) {
+                    break;
+                }
+            }
+            if (input.sourceType === "message" && !reachedAnchor) {
+                throw new Error("FORK_SOURCE_MESSAGE_NOT_FOUND");
+            }
+            const resolvedTitle = derivedTitle ?? "";
+            db.prepare("UPDATE session SET title = ? WHERE id = ?").run(resolvedTitle, forkedSessionId);
+            return {
+                providerSessionId: forkedSessionId,
+                title: resolvedTitle,
+                lastMessageAt: toIsoTimestamp(lastMessageAtMs, nextTimestamp()),
+                inheritedPrefixMessageCount,
+                providerSourceMessageId
+            };
+        });
+    }
+    readFirstUserMessageTitleFromSqlite(sessionId) {
+        return this.withReadonlyDb((db) => {
+            const rows = db.prepare(`SELECT
+           message.id AS message_id,
+           message.time_created AS message_time_created,
+           message.time_updated AS message_time_updated,
+           message.data AS message_data,
+           part.id AS part_id,
+           part.time_created AS part_time_created,
+           part.time_updated AS part_time_updated,
+           part.data AS part_data
+         FROM message
+         INNER JOIN part
+           ON part.message_id = message.id
+          AND part.session_id = message.session_id
+         WHERE message.session_id = ?
+         ORDER BY COALESCE(part.time_updated, part.time_created, message.time_updated, message.time_created),
+                  COALESCE(part.time_created, message.time_created),
+                  message.id,
+                  part.id`).all(sessionId);
+            for (const row of rows) {
+                const messageId = ensureText(row.message_id).trim();
+                const partId = ensureText(row.part_id).trim();
+                if (!messageId || !partId) {
+                    continue;
+                }
+                const normalized = normalizeOpenCodePartMessage({
+                    sessionId,
+                    providerSessionId: sessionId,
+                    messageId,
+                    partId,
+                    messagePayload: toJsonRecord(row.message_data) ?? {},
+                    partPayload: toJsonRecord(row.part_data) ?? {},
+                    defaultTimestamp: toIsoTimestamp(firstValidNumber(row.part_time_created, row.part_time_updated, row.message_time_created, row.message_time_updated), null) ?? nextTimestamp()
+                });
+                const title = normalized ? resolveOpenCodeMessageTitle(normalized) : null;
+                if (title) {
+                    return title;
+                }
+            }
+            return null;
+        });
+    }
+    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, input.workspacePath ?? null)}/`);
+        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") {
+                if (!isTimeoutRetryableMethod(input.method)) {
+                    throw new Error(input.timeoutErrorMessage ?? "SERVER_TIMEOUT");
+                }
+                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");
+        }
+        const DatabaseSync = loadDatabaseSync();
+        let db = null;
+        try {
+            db = new DatabaseSync(dbPath, { open: true, readOnly: true });
+            return run(db);
+        }
+        finally {
+            db?.close();
+        }
+    }
+    withWritableDb(run) {
+        const dbPath = this.resolveDbPath();
+        if (!existsSync(dbPath)) {
+            throw new Error("OPENCODE_DB_NOT_FOUND");
+        }
+        const DatabaseSync = loadDatabaseSync();
+        let db = null;
+        try {
+            db = new DatabaseSync(dbPath, { open: true });
+            db.exec("BEGIN IMMEDIATE");
+            const result = run(db);
+            db.exec("COMMIT");
+            return result;
+        }
+        catch (error) {
+            try {
+                db?.exec("ROLLBACK");
+            }
+            catch {
+                // 这里优先保留原始异常，回滚失败只做吞吐。
+            }
+            throw error;
+        }
+        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 ensureNullableText(value) {
+    const normalized = ensureText(value).trim();
+    return normalized || null;
+}
+function resolveOpenCodeMessageTitle(message) {
+    if (message.role !== "user" || message.kind !== "text") {
+        return null;
+    }
+    const title = message.content.trim().replace(/\s+/g, " ");
+    return title || null;
+}
+function buildForkSlug(sourceSlug, forkedSessionId) {
+    const base = sourceSlug.trim() || "session";
+    const suffix = forkedSessionId.slice(0, 8);
+    return `${base}-fork-${suffix}`;
+}
+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}`);
+}
+function applyOpenCodeForkSourceSnapshot(partPayload, snapshot) {
+    if (!snapshot) {
+        return partPayload;
+    }
+    const nextPart = { ...partPayload };
+    const targetKey = typeof nextPart.text === "string"
+        ? "text"
+        : typeof nextPart.content === "string"
+            ? "content"
+            : typeof nextPart.message === "string"
+                ? "message"
+                : snapshot.kind === "thinking"
+                    ? "thinking"
+                    : "text";
+    nextPart[targetKey] = snapshot.content;
+    return nextPart;
+}
+async function safeReadResponseText(response) {
+    try {
+        return (await response.text()).trim();
+    }
+    catch {
+        return "";
+    }
+}
+function isServerUnavailableError(error) {
+    return error instanceof Error && error.message === "SERVER_UNAVAILABLE";
+}
+function isServerTimeoutError(error) {
+    return error instanceof Error && error.message === "SERVER_TIMEOUT";
+}
+function createTimeoutRetryState() {
+    return {
+        startedAtMs: Date.now(),
+        timeoutCount: 0
+    };
+}
+function advanceTimeoutRetryState(state) {
+    return {
+        startedAtMs: state.startedAtMs,
+        timeoutCount: state.timeoutCount + 1
+    };
+}
+function isTimeoutRetryableMethod(method) {
+    const normalized = (method ?? "GET").trim().toUpperCase();
+    return normalized === "GET" || normalized === "HEAD" || normalized === "OPTIONS";
+}
+function shouldSurfaceTimeout(state) {
+    return (state.timeoutCount >= MAX_CONSECUTIVE_TIMEOUTS
+        || Date.now() - state.startedAtMs >= TIMEOUT_WARNING_THRESHOLD_MS);
+}
+function isOpenCodeSubmitTimeoutAmbiguous(error) {
+    return error instanceof Error && error.message === OPENCODE_SUBMIT_TIMEOUT_AMBIGUOUS;
+}
+function isTimestampOnOrAfter(timestamp, minTimestamp) {
+    if (!minTimestamp) {
+        return true;
+    }
+    const timestampMs = Date.parse(timestamp);
+    const minTimestampMs = Date.parse(minTimestamp);
+    if (!Number.isFinite(timestampMs) || !Number.isFinite(minTimestampMs)) {
+        return timestamp >= minTimestamp;
+    }
+    return timestampMs >= minTimestampMs;
+}
+//# sourceMappingURL=opencode.js.map