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

package/src/storage.test.ts

@@ -0,0 +1,692 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createClawChatStore, getClawChatStore, resetClawChatStoreForTest } from "./storage.ts";
+
+const tempRoots: string[] = [];
+
+function tempDbPath(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-clawchat-storage-"));
+  tempRoots.push(dir);
+  return path.join(dir, "clawchat.sqlite");
+}
+
+function readSqliteRows(dbPath: string, sql: string): Record<string, unknown>[] {
+  const db = new DatabaseSync(dbPath, { readOnly: true });
+  try {
+    return db.prepare(sql).all() as Record<string, unknown>[];
+  } finally {
+    db.close();
+  }
+}
+
+afterEach(() => {
+  vi.useRealTimers();
+  resetClawChatStoreForTest();
+  for (const dir of tempRoots.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe("clawchat sqlite storage", () => {
+  it("migrates connection metadata without creating legacy profile cache tables", () => {
+    const dbPath = tempDbPath();
+    const store = createClawChatStore({ dbPath });
+
+    store.initialize();
+    store.close();
+
+    expect(readSqliteRows(dbPath, "PRAGMA table_info(connections)").map((row) => row.name)).toEqual(
+      expect.arrayContaining(["resolved_device_id", "delivery_mode"]),
+    );
+    expect(
+      readSqliteRows(
+        dbPath,
+        "SELECT name FROM sqlite_master WHERE type = 'table' AND name LIKE 'clawchat_%' ORDER BY name",
+      ).map((row) => row.name),
+    ).toEqual(
+      expect.arrayContaining([
+        "clawchat_conversation_members",
+        "clawchat_conversations",
+      ]),
+    );
+    expect(
+      readSqliteRows(
+        dbPath,
+        "SELECT name FROM sqlite_master WHERE type = 'table' AND name IN ('clawchat_profiles', 'clawchat_user_profiles', 'clawchat_group_profiles') ORDER BY name",
+      ),
+    ).toEqual([]);
+  });
+
+  it("does not expose legacy profile helper methods", () => {
+    const store = createClawChatStore({ dbPath: tempDbPath() });
+
+    expect("upsertProfile" in store).toBe(false);
+    expect("upsertMinimalProfile" in store).toBe(false);
+    expect("upsertAgentProfile" in store).toBe(false);
+    expect("upsertGroupProfile" in store).toBe(false);
+    expect("upsertUserProfile" in store).toBe(false);
+    expect("profileExists" in store).toBe(false);
+    expect("getProfile" in store).toBe(false);
+
+    store.close();
+  });
+
+  it("initializes schema and records activation/message/connection/tool rows", () => {
+    const store = createClawChatStore({ dbPath: tempDbPath() });
+
+    expect(store.listAppliedMigrations()).toEqual([
+      { version: 1, name: "initial_schema" },
+      { version: 2, name: "message_idempotency" },
+      { version: 3, name: "activation_bootstrap" },
+      { version: 4, name: "activation_owner_user_id" },
+      { version: 5, name: "conversation_cache" },
+    ]);
+
+    store.upsertActivation({
+      platform: "openclaw",
+      accountId: "default",
+      userId: "user-old",
+      ownerUserId: "owner-old",
+      accessToken: "token-old",
+      refreshToken: "refresh-old",
+      activatedAt: 1000,
+      loginMethod: "login",
+    });
+    store.upsertActivation({
+      platform: "openclaw",
+      accountId: "default",
+      userId: " user-new ",
+      ownerUserId: " owner-new ",
+      accessToken: "token-new",
+      refreshToken: null,
+      activatedAt: 2000,
+      loginMethod: "login",
+    });
+
+    expect(store.getActivationForTest("openclaw", "default")).toMatchObject({
+      user_id: "user-new",
+      owner_user_id: "owner-new",
+      access_token: null,
+      refresh_token: null,
+      activated_at: 2000,
+      updated_at: 2000,
+    });
+
+    store.insertMessage({
+      platform: "openclaw",
+      accountId: "default",
+      kind: "message",
+      direction: "outbound",
+      eventType: "message.send",
+      traceId: "trace-1",
+      chatId: "chat-1",
+      messageId: "msg-1",
+      text: "hello",
+      raw: { ok: true },
+      createdAt: 3000,
+    });
+
+    expect(store.listMessagesForTest()).toMatchObject([
+      { kind: "message", direction: "outbound", message_id: "msg-1", text: "hello" },
+    ]);
+
+    const connectionId = store.startConnection({
+      platform: "openclaw",
+      accountId: "default",
+      attempt: 1,
+      reconnectCount: 0,
+      connectStartedAt: 1000,
+    });
+    expect(connectionId).toEqual(expect.any(Number));
+    store.markConnectSent(connectionId, { at: 1100 });
+    store.markConnectionReady(connectionId, {
+      at: 1200,
+      resolvedDeviceId: "device-resolved",
+      deliveryMode: "realtime",
+    });
+    store.finishConnection(connectionId, { state: "disconnected", disconnectedAt: 1300 });
+
+    expect(store.listConnectionsForTest()).toMatchObject([
+      {
+        state: "disconnected",
+        connect_started_at: 1000,
+        connect_sent_at: 1100,
+        ready_at: 1200,
+        disconnected_at: 1300,
+        resolved_device_id: "device-resolved",
+        delivery_mode: "realtime",
+      },
+    ]);
+
+    store.recordToolCall({
+      platform: "openclaw",
+      accountId: "default",
+      toolName: "clawchat_get_account_profile",
+      args: { include: "profile" },
+      result: { id: "user-new" },
+      error: null,
+      startedAt: 4000,
+      endedAt: 4250,
+    });
+
+    expect(store.listToolCallsForTest()).toMatchObject([
+      { tool_name: "clawchat_get_account_profile", duration_ms: 250, error: null },
+    ]);
+
+    store.close();
+  });
+
+  it("preserves connection ready metadata when omitted on later ready updates", () => {
+    const store = createClawChatStore({ dbPath: tempDbPath() });
+    const connectionId = store.startConnection({
+      platform: "openclaw",
+      accountId: "default",
+      connectStartedAt: 1000,
+    });
+
+    store.markConnectionReady(connectionId, {
+      at: 1100,
+      resolvedDeviceId: "device-one",
+      deliveryMode: "realtime",
+    });
+    store.markConnectionReady(connectionId, { at: 1200 });
+
+    expect(store.listConnectionsForTest()).toMatchObject([
+      {
+        ready_at: 1200,
+        resolved_device_id: "device-one",
+        delivery_mode: "realtime",
+      },
+    ]);
+
+    store.close();
+  });
+
+  it("atomically claims actual messages by account direction and message_id", () => {
+    const store = createClawChatStore({ dbPath: tempDbPath() });
+
+    expect(store.listAppliedMigrations()).toEqual([
+      { version: 1, name: "initial_schema" },
+      { version: 2, name: "message_idempotency" },
+      { version: 3, name: "activation_bootstrap" },
+      { version: 4, name: "activation_owner_user_id" },
+      { version: 5, name: "conversation_cache" },
+    ]);
+
+    const first = store.claimMessageOnce({
+      platform: "openclaw",
+      accountId: "default",
+      kind: "message",
+      direction: "inbound",
+      eventType: "message.send",
+      traceId: "trace-1",
+      chatId: "chat-1",
+      messageId: "msg-unique",
+      text: "first",
+      raw: { ok: true },
+      createdAt: 3000,
+    });
+    const duplicate = store.claimMessageOnce({
+      platform: "openclaw",
+      accountId: "default",
+      kind: "message",
+      direction: "inbound",
+      eventType: "message.send",
+      traceId: "trace-2",
+      chatId: "chat-1",
+      messageId: "msg-unique",
+      text: "duplicate",
+      raw: { ok: true },
+      createdAt: 4000,
+    });
+    const outboundSameId = store.claimMessageOnce({
+      platform: "openclaw",
+      accountId: "default",
+      kind: "message",
+      direction: "outbound",
+      eventType: "message.reply",
+      traceId: "trace-outbound",
+      chatId: "chat-1",
+      messageId: "msg-unique",
+      text: "outbound",
+      raw: { ok: true },
+      createdAt: 4500,
+    });
+    const thinking = store.insertMessage({
+      platform: "openclaw",
+      accountId: "default",
+      kind: "thinking",
+      direction: "outbound",
+      eventType: "message.send",
+      traceId: "trace-thinking",
+      chatId: "chat-1",
+      messageId: "msg-unique",
+      text: "reasoning",
+      raw: { ok: true },
+      createdAt: 5000,
+    });
+
+    expect(first).toBe(true);
+    expect(duplicate).toBe(false);
+    expect(outboundSameId).toBe(true);
+    expect(thinking).toBe(true);
+    expect(store.listMessagesForTest()).toMatchObject([
+      { kind: "message", direction: "inbound", message_id: "msg-unique", text: "first" },
+      { kind: "message", direction: "outbound", message_id: "msg-unique", text: "outbound" },
+      { kind: "thinking", message_id: "msg-unique", text: "reasoning" },
+    ]);
+
+    store.close();
+  });
+
+  it("recreates the singleton when a later caller provides a different database path", () => {
+    const firstPath = tempDbPath();
+    const secondPath = tempDbPath();
+
+    const first = getClawChatStore({ dbPath: firstPath });
+    const second = getClawChatStore({ dbPath: secondPath });
+
+    expect(second.dbPath).toBe(secondPath);
+    expect(second).not.toBe(first);
+  });
+
+  it("stores pending activation bootstrap conversation and marks it sent conditionally", () => {
+    const store = createClawChatStore({ dbPath: tempDbPath() });
+    const bootstrapStore = store as typeof store & {
+      claimPendingActivationBootstrap(input: {
+        platform: string;
+        accountId: string;
+      }): { conversationId: string } | null;
+      markActivationBootstrapSent(input: {
+        platform: string;
+        accountId: string;
+        conversationId: string;
+      }): boolean | null;
+      releaseActivationBootstrapClaim(input: {
+        platform: string;
+        accountId: string;
+        conversationId: string;
+      }): boolean | null;
+    };
+
+    store.upsertActivation({
+      platform: "openclaw",
+      accountId: "default",
+      userId: "user-old",
+      accessToken: "token-old",
+      refreshToken: "refresh-old",
+      conversationId: "conv-old",
+      activatedAt: 1000,
+      loginMethod: "login",
+    });
+
+    expect(store.getActivationForTest("openclaw", "default")).toMatchObject({
+      conversation_id: "conv-old",
+      bootstrap_sent: 0,
+    });
+    expect(store.getActivationConversation({ platform: "openclaw", accountId: "default" })).toMatchObject({
+      conversationId: "conv-old",
+      conversationType: null,
+    });
+    expect(
+      bootstrapStore.claimPendingActivationBootstrap({ platform: "openclaw", accountId: "default" }),
+    ).toEqual({
+      conversationId: "conv-old",
+    });
+    expect(
+      bootstrapStore.claimPendingActivationBootstrap({ platform: "openclaw", accountId: "default" }),
+    ).toBeNull();
+    expect(
+      bootstrapStore.releaseActivationBootstrapClaim({
+        platform: "openclaw",
+        accountId: "default",
+        conversationId: "conv-other",
+      }),
+    ).toBe(false);
+    expect(
+      bootstrapStore.releaseActivationBootstrapClaim({
+        platform: "openclaw",
+        accountId: "default",
+        conversationId: "conv-old",
+      }),
+    ).toBe(true);
+    expect(
+      bootstrapStore.claimPendingActivationBootstrap({ platform: "openclaw", accountId: "default" }),
+    ).toEqual({
+      conversationId: "conv-old",
+    });
+    expect(
+      bootstrapStore.markActivationBootstrapSent({
+        platform: "openclaw",
+        accountId: "default",
+        conversationId: "conv-other",
+      }),
+    ).toBe(false);
+    expect(
+      bootstrapStore.markActivationBootstrapSent({
+        platform: "openclaw",
+        accountId: "default",
+        conversationId: "conv-old",
+      }),
+    ).toBe(true);
+    expect(
+      bootstrapStore.claimPendingActivationBootstrap({ platform: "openclaw", accountId: "default" }),
+    ).toBeNull();
+    expect(store.getActivationForTest("openclaw", "default")).toMatchObject({
+      conversation_id: "conv-old",
+      bootstrap_sent: 1,
+    });
+
+    store.upsertActivation({
+      platform: "openclaw",
+      accountId: "default",
+      userId: "user-new",
+      accessToken: "token-new",
+      refreshToken: null,
+      conversationId: "conv-new",
+      activatedAt: 2000,
+      loginMethod: "login",
+    });
+
+    expect(store.getActivationForTest("openclaw", "default")).toMatchObject({
+      conversation_id: "conv-new",
+      bootstrap_sent: 0,
+      updated_at: 2000,
+    });
+    expect(store.getActivationConversation({ platform: "openclaw", accountId: "default" })).toMatchObject({
+      conversationId: "conv-new",
+    });
+    expect(
+      bootstrapStore.claimPendingActivationBootstrap({ platform: "openclaw", accountId: "default" }),
+    ).toEqual({
+      conversationId: "conv-new",
+    });
+
+    store.close();
+  });
+
+  it("reclaims stale activation bootstrap claims after the timeout", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(10_000);
+    const store = createClawChatStore({ dbPath: tempDbPath() });
+    const bootstrapStore = store as typeof store & {
+      claimPendingActivationBootstrap(input: {
+        platform: string;
+        accountId: string;
+        staleClaimMs?: number;
+      }): { conversationId: string } | null;
+    };
+
+    store.upsertActivation({
+      platform: "openclaw",
+      accountId: "default",
+      userId: "user-new",
+      conversationId: "conv-stale",
+      activatedAt: 10_000,
+      loginMethod: "login",
+    });
+
+    expect(
+      bootstrapStore.claimPendingActivationBootstrap({
+        platform: "openclaw",
+        accountId: "default",
+        staleClaimMs: 1000,
+      }),
+    ).toEqual({ conversationId: "conv-stale" });
+    expect(
+      bootstrapStore.claimPendingActivationBootstrap({
+        platform: "openclaw",
+        accountId: "default",
+        staleClaimMs: 1000,
+      }),
+    ).toBeNull();
+
+    vi.setSystemTime(11_001);
+    expect(
+      bootstrapStore.claimPendingActivationBootstrap({
+        platform: "openclaw",
+        accountId: "default",
+        staleClaimMs: 1000,
+      }),
+    ).toEqual({ conversationId: "conv-stale" });
+
+    store.close();
+  });
+
+  it("upserts message-path conversation summaries without members or profiles", () => {
+    const store = createClawChatStore({ dbPath: tempDbPath() });
+
+    store.upsertConversationSummary({
+      platform: "openclaw",
+      accountId: "default",
+      conversationId: "conv-summary",
+      conversationType: "direct",
+      metadataVersion: 3,
+      lastSeenAt: 3000,
+      raw: { source: "message" },
+    });
+
+    expect(store.listCachedConversationIds({ platform: "openclaw", accountId: "default", limit: 10 })).toEqual([
+      "conv-summary",
+    ]);
+    expect(store.listConversationCacheForTest("clawchat_conversations")).toMatchObject([
+      {
+        conversation_id: "conv-summary",
+        conversation_type: "direct",
+        metadata_version: 3,
+        last_seen_at: 3000,
+      },
+    ]);
+    expect(store.listConversationCacheForTest("clawchat_conversation_members")).toEqual([]);
+
+    store.close();
+  });
+
+  it("upserts full conversation details and replaces members only for complete snapshots", () => {
+    const store = createClawChatStore({ dbPath: tempDbPath() });
+
+    store.upsertConversationDetails({
+      platform: "openclaw",
+      accountId: "default",
+      conversationId: "group-1",
+      conversationType: "group",
+      metadataVersion: 7,
+      lastSeenAt: 5000,
+      lastRefreshedAt: 5100,
+      raw: { id: "group-1" },
+      members: [
+        { userId: "user-a", role: "owner", raw: { role: "owner" }, lastSeenAt: 5001 },
+        { userId: "user-b", role: "member", raw: { role: "member" }, lastSeenAt: 5002 },
+      ],
+      membersComplete: true,
+    });
+    store.upsertConversationDetails({
+      platform: "openclaw",
+      accountId: "default",
+      conversationId: "group-1",
+      conversationType: "group",
+      lastSeenAt: 6000,
+      members: [{ userId: "user-c", role: "guest" }],
+      membersComplete: false,
+    });
+
+    expect(store.listConversationCacheForTest("clawchat_conversation_members")).toMatchObject([
+      { conversation_id: "group-1", user_id: "user-a", role: "owner" },
+      { conversation_id: "group-1", user_id: "user-b", role: "member" },
+    ]);
+
+    store.upsertConversationDetails({
+      platform: "openclaw",
+      accountId: "default",
+      conversationId: "group-1",
+      members: [{ userId: "user-c", role: "guest" }],
+      membersComplete: true,
+    });
+
+    expect(store.listConversationCacheForTest("clawchat_conversation_members")).toMatchObject([
+      { conversation_id: "group-1", user_id: "user-c", role: "guest" },
+    ]);
+
+    store.close();
+  });
+
+  it("preserves omitted cache fields and clears explicit null cache fields", () => {
+    const store = createClawChatStore({ dbPath: tempDbPath() });
+
+    store.upsertConversationDetails({
+      platform: "openclaw",
+      accountId: "default",
+      conversationId: "cache-clear",
+      conversationType: "group",
+      metadataVersion: 4,
+      raw: { old: "conversation" },
+    });
+
+    expect(store.listConversationCacheForTest("clawchat_conversations")).toMatchObject([
+      { conversation_type: "group", metadata_version: 4, raw_json: JSON.stringify({ old: "conversation" }) },
+    ]);
+
+    store.upsertConversationDetails({
+      platform: "openclaw",
+      accountId: "default",
+      conversationId: "cache-clear",
+      conversationType: null,
+      metadataVersion: null,
+      raw: null,
+    });
+
+    expect(store.listConversationCacheForTest("clawchat_conversations")).toMatchObject([
+      { conversation_type: null, metadata_version: null, raw_json: null },
+    ]);
+
+    store.close();
+  });
+
+  it("preserves omitted cache timestamps and clears explicit null cache timestamps", () => {
+    const store = createClawChatStore({ dbPath: tempDbPath() });
+
+    store.upsertConversationDetails({
+      platform: "openclaw",
+      accountId: "default",
+      conversationId: "cache-timestamps",
+      lastSeenAt: 1000,
+      lastRefreshedAt: 1100,
+    });
+
+    expect(store.listConversationCacheForTest("clawchat_conversations")).toMatchObject([
+      { last_seen_at: 1000, last_refreshed_at: 1100 },
+    ]);
+
+    store.upsertConversationDetails({
+      platform: "openclaw",
+      accountId: "default",
+      conversationId: "cache-timestamps",
+      lastSeenAt: null,
+      lastRefreshedAt: null,
+    });
+
+    expect(store.listConversationCacheForTest("clawchat_conversations")).toMatchObject([
+      { last_seen_at: null, last_refreshed_at: null },
+    ]);
+
+    store.close();
+  });
+
+  it("deletes conversation cache without deleting messages", () => {
+    const store = createClawChatStore({ dbPath: tempDbPath() });
+
+    store.upsertConversationDetails({
+      platform: "openclaw",
+      accountId: "default",
+      conversationId: "group-delete",
+      conversationType: "group",
+      members: [{ userId: "user-keep", role: "member" }],
+      membersComplete: true,
+    });
+    store.insertMessage({
+      platform: "openclaw",
+      accountId: "default",
+      kind: "message",
+      direction: "inbound",
+      eventType: "message.send",
+      chatId: "group-delete",
+      messageId: "msg-keep",
+      text: "keep me",
+      createdAt: 7000,
+    });
+
+    store.deleteConversationCache({ platform: "openclaw", accountId: "default", conversationId: "group-delete" });
+
+    expect(store.listConversationCacheForTest("clawchat_conversations")).toEqual([]);
+    expect(store.listConversationCacheForTest("clawchat_conversation_members")).toEqual([]);
+    expect(store.listMessagesForTest()).toMatchObject([{ chat_id: "group-delete", message_id: "msg-keep" }]);
+
+    store.close();
+  });
+
+  it("lists cached conversation ids by latest seen time with a limit", () => {
+    const store = createClawChatStore({ dbPath: tempDbPath() });
+
+    store.upsertConversationSummary({
+      platform: "openclaw",
+      accountId: "default",
+      conversationId: "old",
+      lastSeenAt: 1000,
+    });
+    store.upsertConversationSummary({
+      platform: "openclaw",
+      accountId: "default",
+      conversationId: "new",
+      lastSeenAt: 3000,
+    });
+    store.upsertConversationSummary({
+      platform: "openclaw",
+      accountId: "default",
+      conversationId: "middle",
+      lastSeenAt: 2000,
+    });
+
+    expect(store.listCachedConversationIds({ platform: "openclaw", accountId: "default", limit: 2 })).toEqual([
+      "new",
+      "middle",
+    ]);
+
+    store.close();
+  });
+
+  it("gets one cached conversation metadata row by id", () => {
+    const store = createClawChatStore({ dbPath: tempDbPath() });
+
+    store.upsertConversationSummary({
+      platform: "openclaw",
+      accountId: "default",
+      conversationId: "group-meta",
+      conversationType: "group",
+      metadataVersion: 9,
+      lastSeenAt: 4000,
+      lastRefreshedAt: 4100,
+    });
+
+    expect(store.getCachedConversation({
+      platform: "openclaw",
+      accountId: "default",
+      conversationId: "group-meta",
+    })).toMatchObject({
+      conversationId: "group-meta",
+      conversationType: "group",
+      metadataVersion: 9,
+      lastSeenAt: 4000,
+      lastRefreshedAt: 4100,
+    });
+    expect(store.getCachedConversation({
+      platform: "openclaw",
+      accountId: "default",
+      conversationId: "missing",
+    })).toBeNull();
+
+    store.close();
+  });
+});