@newbase-clawchat/openclaw-clawchat 2026.5.12-2 → 2026.5.12-21

package/dist/src/storage.js

@@ -0,0 +1,636 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
+const DB_FILENAME = "clawchat.sqlite";
+const DEFAULT_BOOTSTRAP_CLAIM_STALE_MS = 5 * 60 * 1000;
+const MIGRATIONS = [
+    {
+        version: 1,
+        name: "initial_schema",
+        sql: `
+CREATE TABLE IF NOT EXISTS schema_migrations (
+  version INTEGER PRIMARY KEY,
+  name TEXT NOT NULL,
+  applied_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS clawchat_messages (
+  id INTEGER PRIMARY KEY,
+  platform TEXT NOT NULL,
+  account_id TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  direction TEXT NOT NULL,
+  event_type TEXT NOT NULL,
+  trace_id TEXT,
+  chat_id TEXT,
+  message_id TEXT,
+  text TEXT,
+  raw_json TEXT,
+  created_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS activations (
+  platform TEXT NOT NULL,
+  account_id TEXT NOT NULL,
+  user_id TEXT,
+  access_token TEXT,
+  refresh_token TEXT,
+  activated_at INTEGER NOT NULL,
+  login_method TEXT,
+  updated_at INTEGER NOT NULL,
+  PRIMARY KEY (platform, account_id)
+);
+
+CREATE TABLE IF NOT EXISTS connections (
+  id INTEGER PRIMARY KEY,
+  platform TEXT NOT NULL,
+  account_id TEXT NOT NULL,
+  attempt INTEGER,
+  reconnect_count INTEGER,
+  state TEXT NOT NULL,
+  connect_started_at INTEGER,
+  connect_sent_at INTEGER,
+  ready_at INTEGER,
+  disconnected_at INTEGER,
+  close_code INTEGER,
+  close_reason TEXT,
+  error TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS tool_calls (
+  id INTEGER PRIMARY KEY,
+  platform TEXT NOT NULL,
+  account_id TEXT,
+  tool_name TEXT NOT NULL,
+  args_json TEXT,
+  result_json TEXT,
+  error TEXT,
+  started_at INTEGER NOT NULL,
+  ended_at INTEGER,
+  duration_ms INTEGER,
+  created_at INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_clawchat_messages_chat_created
+  ON clawchat_messages(chat_id, created_at);
+CREATE INDEX IF NOT EXISTS idx_clawchat_messages_message_id
+  ON clawchat_messages(message_id);
+CREATE INDEX IF NOT EXISTS idx_connections_account_created
+  ON connections(platform, account_id, created_at);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_name_created
+  ON tool_calls(tool_name, created_at);
+`,
+    },
+    {
+        version: 2,
+        name: "message_idempotency",
+        sql: `
+CREATE UNIQUE INDEX IF NOT EXISTS idx_clawchat_messages_message_unique
+  ON clawchat_messages(account_id, direction, kind, message_id)
+  WHERE kind = 'message' AND message_id IS NOT NULL;
+`,
+    },
+    {
+        version: 3,
+        name: "activation_bootstrap",
+        sql: `
+ALTER TABLE activations ADD COLUMN conversation_id TEXT;
+ALTER TABLE activations ADD COLUMN bootstrap_sent INTEGER NOT NULL DEFAULT 1;
+ALTER TABLE activations ADD COLUMN bootstrap_claimed_at INTEGER;
+UPDATE activations SET access_token = NULL, refresh_token = NULL;
+`,
+    },
+    {
+        version: 4,
+        name: "activation_owner_user_id",
+        sql: `
+ALTER TABLE activations ADD COLUMN owner_user_id TEXT;
+`,
+    },
+    {
+        version: 5,
+        name: "conversation_cache",
+        sql: `
+ALTER TABLE connections ADD COLUMN resolved_device_id TEXT;
+ALTER TABLE connections ADD COLUMN delivery_mode TEXT;
+
+CREATE TABLE IF NOT EXISTS clawchat_conversations (
+  platform TEXT NOT NULL,
+  account_id TEXT NOT NULL,
+  conversation_id TEXT NOT NULL,
+  conversation_type TEXT,
+  metadata_version INTEGER,
+  last_seen_at INTEGER,
+  last_refreshed_at INTEGER,
+  raw_json TEXT,
+  PRIMARY KEY (platform, account_id, conversation_id)
+);
+
+CREATE TABLE IF NOT EXISTS clawchat_conversation_members (
+  platform TEXT NOT NULL,
+  account_id TEXT NOT NULL,
+  conversation_id TEXT NOT NULL,
+  user_id TEXT NOT NULL,
+  role TEXT,
+  raw_json TEXT,
+  last_seen_at INTEGER,
+  PRIMARY KEY (platform, account_id, conversation_id, user_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_clawchat_conversations_seen
+  ON clawchat_conversations(platform, account_id, last_seen_at);
+`,
+    },
+];
+function fallbackDbPath() {
+    const home = process.env.OPENCLAW_HOME || path.join(os.homedir(), ".openclaw");
+    return path.join(home, DB_FILENAME);
+}
+export function clawChatDbPathForStateDir(stateDir) {
+    return path.join(stateDir, DB_FILENAME);
+}
+export function defaultDbPath() {
+    try {
+        return clawChatDbPathForStateDir(resolveStateDir());
+    }
+    catch {
+        return fallbackDbPath();
+    }
+}
+function toNullableString(value) {
+    return typeof value === "string" ? value : value == null ? null : String(value);
+}
+function toJson(value) {
+    if (value === undefined)
+        return null;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return null;
+    }
+}
+function toCacheJson(value) {
+    if (value == null)
+        return null;
+    return toJson(value);
+}
+function hasOwn(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key) ? 1 : 0;
+}
+function safeErrorMessage(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return message
+        .replace(/(access[_-]?token["'\s:=]+)[^"'\s,}]+/gi, "$1[REDACTED]")
+        .replace(/(refresh[_-]?token["'\s:=]+)[^"'\s,}]+/gi, "$1[REDACTED]")
+        .replace(/(authorization["'\s:=]+bearer\s+)[^"'\s,}]+/gi, "$1[REDACTED]");
+}
+export class ClawChatStore {
+    dbPath;
+    log;
+    db = null;
+    initialized = false;
+    disabled = false;
+    constructor(options = {}) {
+        this.dbPath = options.dbPath ?? defaultDbPath();
+        this.log = options.log;
+    }
+    initialize() {
+        this.ensureInitialized();
+    }
+    listAppliedMigrations() {
+        return this.read(() => this.requireDb()
+            .prepare("SELECT version, name FROM schema_migrations ORDER BY version")
+            .all()) ?? [];
+    }
+    upsertActivation(input) {
+        this.write(() => {
+            const now = input.activatedAt ?? Date.now();
+            const conversationId = input.conversationId?.trim() || null;
+            const userId = input.userId?.trim() || null;
+            const ownerUserId = input.ownerUserId?.trim() || null;
+            this.requireDb()
+                .prepare(`INSERT INTO activations(
+            platform, account_id, user_id, owner_user_id, access_token, refresh_token,
+            activated_at, login_method, conversation_id, bootstrap_sent,
+            bootstrap_claimed_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT(platform, account_id) DO UPDATE SET
+            user_id = excluded.user_id,
+            owner_user_id = excluded.owner_user_id,
+            access_token = NULL,
+            refresh_token = NULL,
+            activated_at = excluded.activated_at,
+            login_method = excluded.login_method,
+            conversation_id = excluded.conversation_id,
+            bootstrap_sent = excluded.bootstrap_sent,
+            bootstrap_claimed_at = NULL,
+            updated_at = excluded.updated_at`)
+                .run(input.platform, input.accountId, userId, ownerUserId, null, null, now, input.loginMethod ?? null, conversationId, conversationId ? 0 : 1, null, now);
+            if (conversationId) {
+                this.upsertConversationSummaryInDb({
+                    platform: input.platform,
+                    accountId: input.accountId,
+                    conversationId,
+                    lastSeenAt: now,
+                });
+            }
+        });
+    }
+    upsertConversationSummary(input) {
+        this.write(() => {
+            this.upsertConversationSummaryInDb(input);
+        });
+    }
+    upsertConversationDetails(input) {
+        this.write(() => {
+            const db = this.requireDb();
+            db.exec("BEGIN");
+            try {
+                this.upsertConversationSummaryInDb(input);
+                if (input.membersComplete) {
+                    db.prepare(`DELETE FROM clawchat_conversation_members
+            WHERE platform = ? AND account_id = ? AND conversation_id = ?`).run(input.platform, input.accountId, input.conversationId);
+                    for (const member of input.members ?? []) {
+                        db.prepare(`INSERT INTO clawchat_conversation_members(
+                platform, account_id, conversation_id, user_id, role, raw_json, last_seen_at
+              ) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(input.platform, input.accountId, input.conversationId, member.userId, member.role ?? null, toJson(member.raw), member.lastSeenAt ?? null);
+                    }
+                }
+                db.exec("COMMIT");
+            }
+            catch (err) {
+                db.exec("ROLLBACK");
+                throw err;
+            }
+        });
+    }
+    deleteConversationCache(input) {
+        this.write(() => {
+            const db = this.requireDb();
+            db.prepare(`DELETE FROM clawchat_conversation_members
+        WHERE platform = ? AND account_id = ? AND conversation_id = ?`).run(input.platform, input.accountId, input.conversationId);
+            db.prepare(`DELETE FROM clawchat_conversations
+        WHERE platform = ? AND account_id = ? AND conversation_id = ?`).run(input.platform, input.accountId, input.conversationId);
+        });
+    }
+    listCachedConversationIds(input) {
+        const limit = Math.min(100, Math.max(0, Math.trunc(input.limit ?? 50)));
+        return this.read(() => this.requireDb()
+            .prepare(`SELECT conversation_id FROM clawchat_conversations
+          WHERE platform = ? AND account_id = ?
+          ORDER BY last_seen_at DESC, conversation_id ASC
+          LIMIT ?`)
+            .all(input.platform, input.accountId, limit)
+            .map((row) => String(row.conversation_id))) ?? [];
+    }
+    getCachedConversation(input) {
+        return this.read(() => {
+            const row = this.requireDb()
+                .prepare(`SELECT conversation_id, conversation_type, metadata_version, last_seen_at, last_refreshed_at
+          FROM clawchat_conversations
+          WHERE platform = ? AND account_id = ? AND conversation_id = ?`)
+                .get(input.platform, input.accountId, input.conversationId);
+            if (typeof row?.conversation_id !== "string")
+                return null;
+            return {
+                conversationId: row.conversation_id,
+                conversationType: typeof row.conversation_type === "string" ? row.conversation_type : null,
+                metadataVersion: typeof row.metadata_version === "number" ? row.metadata_version : null,
+                lastSeenAt: typeof row.last_seen_at === "number" ? row.last_seen_at : null,
+                lastRefreshedAt: typeof row.last_refreshed_at === "number" ? row.last_refreshed_at : null,
+            };
+        }) ?? null;
+    }
+    getActivationConversation(input) {
+        return this.read(() => {
+            const row = this.requireDb()
+                .prepare(`SELECT
+            a.conversation_id,
+            c.conversation_type,
+            c.metadata_version,
+            c.last_seen_at,
+            c.last_refreshed_at
+          FROM activations a
+          LEFT JOIN clawchat_conversations c
+            ON c.platform = a.platform
+            AND c.account_id = a.account_id
+            AND c.conversation_id = a.conversation_id
+          WHERE a.platform = ?
+            AND a.account_id = ?
+            AND a.conversation_id IS NOT NULL
+            AND a.conversation_id <> ''`)
+                .get(input.platform, input.accountId);
+            if (typeof row?.conversation_id !== "string")
+                return null;
+            return {
+                conversationId: row.conversation_id,
+                conversationType: typeof row.conversation_type === "string" ? row.conversation_type : null,
+                metadataVersion: typeof row.metadata_version === "number" ? row.metadata_version : null,
+                lastSeenAt: typeof row.last_seen_at === "number" ? row.last_seen_at : null,
+                lastRefreshedAt: typeof row.last_refreshed_at === "number" ? row.last_refreshed_at : null,
+            };
+        }) ?? null;
+    }
+    claimPendingActivationBootstrap(input) {
+        return this.write(() => {
+            const now = Date.now();
+            const staleMs = Math.max(0, input.staleClaimMs ?? DEFAULT_BOOTSTRAP_CLAIM_STALE_MS);
+            const staleBefore = now - staleMs;
+            const row = this.requireDb()
+                .prepare(`UPDATE activations SET
+            bootstrap_claimed_at = ?, updated_at = ?
+          WHERE platform = ?
+            AND account_id = ?
+            AND conversation_id IS NOT NULL
+            AND conversation_id <> ''
+            AND bootstrap_sent = 0
+            AND (bootstrap_claimed_at IS NULL OR bootstrap_claimed_at <= ?)
+          RETURNING conversation_id`)
+                .get(now, now, input.platform, input.accountId, staleBefore);
+            const conversationId = row?.conversation_id;
+            return typeof conversationId === "string" && conversationId.length > 0
+                ? { conversationId }
+                : null;
+        }) ?? null;
+    }
+    releaseActivationBootstrapClaim(input) {
+        return this.write(() => {
+            const now = Date.now();
+            const result = this.requireDb()
+                .prepare(`UPDATE activations SET
+            bootstrap_claimed_at = NULL,
+            updated_at = ?
+          WHERE platform = ?
+            AND account_id = ?
+            AND conversation_id = ?
+            AND bootstrap_sent = 0
+            AND bootstrap_claimed_at IS NOT NULL`)
+                .run(now, input.platform, input.accountId, input.conversationId);
+            return result.changes > 0;
+        });
+    }
+    markActivationBootstrapSent(input) {
+        return this.write(() => {
+            const now = Date.now();
+            const result = this.requireDb()
+                .prepare(`UPDATE activations SET
+            bootstrap_sent = 1,
+            bootstrap_claimed_at = NULL,
+            updated_at = ?
+          WHERE platform = ?
+            AND account_id = ?
+            AND conversation_id = ?
+            AND bootstrap_sent = 0
+            AND bootstrap_claimed_at IS NOT NULL`)
+                .run(now, input.platform, input.accountId, input.conversationId);
+            return result.changes > 0;
+        });
+    }
+    insertMessage(input) {
+        return this.write(() => {
+            this.requireDb()
+                .prepare(`INSERT INTO clawchat_messages(
+            platform, account_id, kind, direction, event_type, trace_id, chat_id,
+            message_id, text, raw_json, created_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(input.platform, input.accountId, input.kind, input.direction, input.eventType, input.traceId ?? null, input.chatId ?? null, input.messageId ?? null, input.text ?? null, toJson(input.raw), input.createdAt ?? Date.now());
+            return true;
+        });
+    }
+    claimMessageOnce(input) {
+        return this.write(() => {
+            const result = this.requireDb()
+                .prepare(`INSERT OR IGNORE INTO clawchat_messages(
+            platform, account_id, kind, direction, event_type, trace_id, chat_id,
+            message_id, text, raw_json, created_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(input.platform, input.accountId, input.kind, input.direction, input.eventType, input.traceId ?? null, input.chatId ?? null, input.messageId ?? null, input.text ?? null, toJson(input.raw), input.createdAt ?? Date.now());
+            return result.changes > 0;
+        });
+    }
+    updateMessageByIdentity(input) {
+        this.write(() => {
+            this.requireDb()
+                .prepare(`UPDATE clawchat_messages SET
+            event_type = ?, trace_id = ?, chat_id = ?, text = ?, raw_json = ?
+          WHERE account_id = ? AND kind = ? AND direction = ? AND message_id = ?`)
+                .run(input.eventType, input.traceId ?? null, input.chatId ?? null, input.text ?? null, toJson(input.raw), input.accountId, input.kind, input.direction, input.messageId);
+        });
+    }
+    startConnection(input) {
+        return this.write(() => {
+            const now = input.connectStartedAt ?? Date.now();
+            const result = this.requireDb()
+                .prepare(`INSERT INTO connections(
+            platform, account_id, attempt, reconnect_count, state,
+            connect_started_at, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(input.platform, input.accountId, input.attempt ?? null, input.reconnectCount ?? null, "connecting", now, now, now);
+            return Number(result.lastInsertRowid);
+        }) ?? null;
+    }
+    markConnectSent(connectionId, options = {}) {
+        if (typeof connectionId !== "number")
+            return;
+        this.updateConnectionTime(connectionId, "connect_sent_at", options.at ?? Date.now());
+    }
+    markConnectionReady(connectionId, options = {}) {
+        if (typeof connectionId !== "number")
+            return;
+        this.write(() => {
+            const now = options.at ?? Date.now();
+            this.requireDb()
+                .prepare(`UPDATE connections SET
+            state = ?,
+            ready_at = ?,
+            resolved_device_id = CASE WHEN ? THEN ? ELSE resolved_device_id END,
+            delivery_mode = CASE WHEN ? THEN ? ELSE delivery_mode END,
+            updated_at = ?
+          WHERE id = ?`)
+                .run("ready", now, hasOwn(options, "resolvedDeviceId"), options.resolvedDeviceId ?? null, hasOwn(options, "deliveryMode"), options.deliveryMode ?? null, now, connectionId);
+        });
+    }
+    finishConnection(connectionId, input) {
+        if (typeof connectionId !== "number")
+            return;
+        this.write(() => {
+            const now = input.disconnectedAt ?? Date.now();
+            this.requireDb()
+                .prepare(`UPDATE connections SET
+            state = ?, disconnected_at = ?, close_code = ?, close_reason = ?, error = ?, updated_at = ?
+          WHERE id = ?`)
+                .run(input.state, now, input.closeCode ?? null, input.closeReason ?? null, input.error ?? null, now, connectionId);
+        });
+    }
+    recordToolCall(input) {
+        this.write(() => {
+            const startedAt = input.startedAt ?? Date.now();
+            const endedAt = input.endedAt ?? null;
+            const durationMs = endedAt == null ? null : Math.max(0, endedAt - startedAt);
+            this.requireDb()
+                .prepare(`INSERT INTO tool_calls(
+            platform, account_id, tool_name, args_json, result_json, error,
+            started_at, ended_at, duration_ms, created_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(input.platform, input.accountId ?? null, input.toolName, toJson(input.args), toJson(input.result), toNullableString(input.error), startedAt, endedAt, durationMs, startedAt);
+        });
+    }
+    getActivationForTest(platform, accountId) {
+        return this.read(() => this.requireDb()
+            .prepare("SELECT * FROM activations WHERE platform = ? AND account_id = ?")
+            .get(platform, accountId)) ?? null;
+    }
+    listMessagesForTest() {
+        return this.read(() => this.requireDb()
+            .prepare("SELECT * FROM clawchat_messages ORDER BY id")
+            .all()) ?? [];
+    }
+    listConnectionsForTest() {
+        return this.read(() => this.requireDb().prepare("SELECT * FROM connections ORDER BY id").all()) ?? [];
+    }
+    listToolCallsForTest() {
+        return this.read(() => this.requireDb().prepare("SELECT * FROM tool_calls ORDER BY id").all()) ?? [];
+    }
+    listConversationCacheForTest(table) {
+        if (![
+            "clawchat_conversations",
+            "clawchat_conversation_members",
+        ].includes(table)) {
+            throw new Error(`unsupported conversation cache table: ${table}`);
+        }
+        return this.read(() => this.requireDb().prepare(`SELECT * FROM ${table} ORDER BY rowid`).all()) ?? [];
+    }
+    close() {
+        this.db?.close();
+        this.db = null;
+        this.initialized = false;
+    }
+    updateConnectionTime(connectionId, field, at) {
+        this.write(() => {
+            this.requireDb()
+                .prepare(`UPDATE connections SET ${field} = ?, updated_at = ? WHERE id = ?`)
+                .run(at, at, connectionId);
+        });
+    }
+    upsertConversationSummaryInDb(input) {
+        this.requireDb()
+            .prepare(`INSERT INTO clawchat_conversations(
+          platform, account_id, conversation_id, conversation_type, metadata_version,
+          last_seen_at, last_refreshed_at, raw_json
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(platform, account_id, conversation_id) DO UPDATE SET
+          conversation_type = CASE WHEN ? THEN excluded.conversation_type ELSE clawchat_conversations.conversation_type END,
+          metadata_version = CASE WHEN ? THEN excluded.metadata_version ELSE clawchat_conversations.metadata_version END,
+          last_seen_at = CASE WHEN ? THEN excluded.last_seen_at ELSE clawchat_conversations.last_seen_at END,
+          last_refreshed_at = CASE WHEN ? THEN excluded.last_refreshed_at ELSE clawchat_conversations.last_refreshed_at END,
+          raw_json = CASE WHEN ? THEN excluded.raw_json ELSE clawchat_conversations.raw_json END`)
+            .run(input.platform, input.accountId, input.conversationId, input.conversationType ?? null, input.metadataVersion ?? null, input.lastSeenAt ?? null, input.lastRefreshedAt ?? null, toCacheJson(input.raw), hasOwn(input, "conversationType"), hasOwn(input, "metadataVersion"), hasOwn(input, "lastSeenAt"), hasOwn(input, "lastRefreshedAt"), hasOwn(input, "raw"));
+    }
+    read(fn) {
+        if (!this.ensureInitialized())
+            return null;
+        try {
+            return fn();
+        }
+        catch (err) {
+            this.logFailure("openclaw-clawchat sqlite read failed", err);
+            return null;
+        }
+    }
+    write(fn) {
+        if (!this.ensureInitialized())
+            return null;
+        try {
+            return fn();
+        }
+        catch (err) {
+            this.logFailure("openclaw-clawchat sqlite write failed", err);
+            return null;
+        }
+    }
+    ensureInitialized() {
+        if (this.disabled)
+            return false;
+        if (this.initialized)
+            return true;
+        try {
+            fs.mkdirSync(path.dirname(this.dbPath), { recursive: true });
+            this.db = new DatabaseSync(this.dbPath);
+            this.db.exec("PRAGMA journal_mode=WAL");
+            try {
+                fs.chmodSync(this.dbPath, 0o600);
+            }
+            catch {
+                // Best effort only; permissions vary by platform/filesystem.
+            }
+            this.applyMigrations();
+            this.initialized = true;
+            return true;
+        }
+        catch (err) {
+            this.disabled = true;
+            this.logFailure("openclaw-clawchat sqlite disabled after initialization failure", err);
+            try {
+                this.db?.close();
+            }
+            catch {
+                // best effort
+            }
+            this.db = null;
+            return false;
+        }
+    }
+    applyMigrations() {
+        const db = this.requireDb();
+        db.exec(`CREATE TABLE IF NOT EXISTS schema_migrations (
+        version INTEGER PRIMARY KEY,
+        name TEXT NOT NULL,
+        applied_at INTEGER NOT NULL
+      )`);
+        const hasMigration = db.prepare("SELECT 1 FROM schema_migrations WHERE version = ?");
+        const insertMigration = db.prepare("INSERT INTO schema_migrations(version, name, applied_at) VALUES (?, ?, ?)");
+        for (const migration of MIGRATIONS) {
+            if (hasMigration.get(migration.version))
+                continue;
+            db.exec("BEGIN");
+            try {
+                db.exec(migration.sql);
+                insertMigration.run(migration.version, migration.name, Date.now());
+                db.exec("COMMIT");
+            }
+            catch (err) {
+                db.exec("ROLLBACK");
+                throw err;
+            }
+        }
+    }
+    requireDb() {
+        if (!this.db)
+            throw new Error("clawchat sqlite database is not open");
+        return this.db;
+    }
+    logFailure(prefix, err) {
+        this.log?.error?.(`${prefix}: ${safeErrorMessage(err)}`);
+    }
+}
+let singleton = null;
+export function createClawChatStore(options = {}) {
+    return new ClawChatStore(options);
+}
+export function getClawChatStore(options = {}) {
+    const dbPath = options.dbPath ?? defaultDbPath();
+    if (!singleton || singleton.dbPath !== dbPath) {
+        singleton?.close();
+        singleton = createClawChatStore({ ...options, dbPath });
+    }
+    return singleton;
+}
+export function resetClawChatStoreForTest() {
+    singleton?.close();
+    singleton = null;
+}