@clawling/clawchat-plugin-openclaw 2026.5.12-28

package/src/scripts.test.ts

@@ -0,0 +1,85 @@
+import fs from "node:fs";
+import { describe, expect, it } from "vitest";
+
+const root = new URL("../", import.meta.url);
+
+function readRootFile(name: string): string {
+  return fs.readFileSync(new URL(name, root), "utf8");
+}
+
+describe("OpenClaw packaging scripts", () => {
+  it("packages the npm tarball and uploads it to the R2 openclaw prefix", () => {
+    const script = readRootFile("scripts/package_openclaw_plugin.sh");
+
+    expect(script).toMatch(/npm pack --silent --pack-destination "\$SCRIPT_DIR"/);
+    expect(script).toContain('REPO_ROOT="$(cd -- "$SCRIPT_DIR/.." && pwd)"');
+    expect(script).toContain('R2_ENV_FILE="${R2_ENV_FILE:-$SCRIPT_DIR/.env.r2}"');
+    expect(script).toContain('set -a; source "$R2_ENV_FILE"; set +a');
+    expect(script).toContain(': "${AWS_ACCESS_KEY_ID:?missing in $R2_ENV_FILE}"');
+    expect(script).toContain(': "${AWS_SECRET_ACCESS_KEY:?missing in $R2_ENV_FILE}"');
+    expect(script).toContain(': "${R2_ENDPOINT:?missing in $R2_ENV_FILE}"');
+    expect(script).toContain(': "${R2_BUCKET:?missing in $R2_ENV_FILE}"');
+    expect(script).not.toContain("f8eeaffb6f81ffd82b59c24d4ff797c9");
+    expect(script).not.toContain("587f8d4aa485a70f6e984a9efa7e609a86e4ef02d56a6682d9d7a9509913b8cb");
+    expect(script).toContain("OBJECT_KEY=\"openclaw/${TARGET_NAME}\"");
+    expect(script).toContain("LATEST_OBJECT_KEY=\"openclaw/newbase-clawchat-clawchat-plugin-openclaw-latest.tgz\"");
+    expect(script).toContain("https://plugin.clawling.chat/${OBJECT_KEY}");
+    expect(script).toContain("https://plugin.clawling.chat/${LATEST_OBJECT_KEY}");
+    expect(script).toMatch(/aws s3 cp[\s\S]*--content-type application\/gzip/);
+    expect(script).toMatch(/aws s3 cp[\s\S]*"s3:\/\/\$\{R2_BUCKET\}\/\$\{LATEST_OBJECT_KEY\}"/);
+  });
+
+  it("keeps the local R2 env file out of git", () => {
+    const gitignore = readRootFile(".gitignore");
+
+    expect(gitignore).toMatch(/^\.env\.r2$/m);
+  });
+
+  it("keeps generated npm package tarballs out of git", () => {
+    const gitignore = readRootFile(".gitignore");
+
+    expect(gitignore).toMatch(/^\*\.tgz$/m);
+  });
+
+  it("publishes a local R2 env example without real credentials", () => {
+    const example = readRootFile("scripts/.env.r2.example");
+
+    expect(example).toContain("AWS_ACCESS_KEY_ID=replace-me");
+    expect(example).toContain("AWS_SECRET_ACCESS_KEY=replace-me");
+    expect(example).toContain("AWS_DEFAULT_REGION=auto");
+    expect(example).toContain("R2_ENDPOINT=https://a47044dea9e3fc23ed4a68da66ab005a.r2.cloudflarestorage.com");
+    expect(example).toContain("R2_BUCKET=clawchat-test");
+    expect(example).not.toContain("f8eeaffb6f81ffd82b59c24d4ff797c9");
+    expect(example).not.toContain("587f8d4aa485a70f6e984a9efa7e609a86e4ef02d56a6682d9d7a9509913b8cb");
+  });
+
+  it("downloads the R2 tarball and installs it through openclaw", () => {
+    const script = readRootFile("scripts/install_openclaw.sh");
+
+    expect(script).toContain("PUBLIC_BASE_URL=\"https://plugin.clawling.chat\"");
+    expect(script).toContain("PACKAGE_BASENAME=\"newbase-clawchat-clawchat-plugin-openclaw\"");
+    expect(script).toContain("DEFAULT_TGZ=\"${PACKAGE_BASENAME}-latest.tgz\"");
+    expect(script).toContain("CLAWCHAT_PLUGIN_REF=\"${1:-latest}\"");
+    expect(script).toContain('case "$CLAWCHAT_PLUGIN_REF" in');
+    expect(script).toContain("CLAWCHAT_PLUGIN_URL=\"${PUBLIC_BASE_URL}/openclaw/${PACKAGE_BASENAME}-${CLAWCHAT_PLUGIN_REF}.tgz\"");
+    expect(script).not.toContain("require(\"./package.json\")");
+    expect(script).not.toContain("command -v node");
+    expect(script).toContain("curl -fL \"$CLAWCHAT_PLUGIN_URL\" -o \"$CLAWCHAT_PLUGIN_TGZ\"");
+    expect(script).toContain('cleanup_plugin_tgz()');
+    expect(script).toContain('trap cleanup_plugin_tgz EXIT');
+    expect(script).toContain('rm -f "$CLAWCHAT_PLUGIN_TGZ"');
+    expect(script).toContain("openclaw plugins install \"$CLAWCHAT_PLUGIN_TGZ\" --force");
+  });
+
+  it("publishes a version-pinned OpenClaw installer script", () => {
+    const script = readRootFile("scripts/install_openclaw-2026.5.4-3.sh");
+
+    expect(script).toContain("PUBLIC_BASE_URL=\"https://plugin.clawling.chat\"");
+    expect(script).toContain('CLAWCHAT_PLUGIN_REF="2026.5.4-3"');
+    expect(script).toContain("newbase-clawchat-clawchat-plugin-openclaw-2026.5.4-3.tgz");
+    expect(script).not.toContain('CLAWCHAT_PLUGIN_REF="${1:-latest}"');
+    expect(script).toContain("curl -fL \"$CLAWCHAT_PLUGIN_URL\" -o \"$CLAWCHAT_PLUGIN_TGZ\"");
+    expect(script).toContain('trap cleanup_plugin_tgz EXIT');
+    expect(script).toContain("openclaw plugins install \"$CLAWCHAT_PLUGIN_TGZ\" --force");
+  });
+});

package/src/storage.test.ts

@@ -0,0 +1,560 @@
+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(), "clawchat-plugin-openclaw-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", () => {
+    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 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("preserves activation tokens when migrating bootstrap columns", () => {
+    const dbPath = tempDbPath();
+    const db = new DatabaseSync(dbPath);
+    try {
+      db.exec(`
+        CREATE TABLE schema_migrations (
+          version INTEGER PRIMARY KEY,
+          name TEXT NOT NULL,
+          applied_at INTEGER NOT NULL
+        );
+        CREATE TABLE 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 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 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 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
+        );
+        INSERT INTO schema_migrations(version, name, applied_at)
+          VALUES (1, 'initial_schema', 1), (2, 'message_idempotency', 2);
+        INSERT INTO activations(
+          platform, account_id, user_id, access_token, refresh_token,
+          activated_at, login_method, updated_at
+        ) VALUES (
+          'openclaw', 'default', 'user-old', 'access-old', 'refresh-old',
+          1000, 'login', 1000
+        );
+      `);
+    } finally {
+      db.close();
+    }
+
+    const store = createClawChatStore({ dbPath });
+    store.initialize();
+
+    expect(store.getActivationForTest("openclaw", "default")).toMatchObject({
+      access_token: "access-old",
+      refresh_token: "refresh-old",
+      conversation_id: null,
+      bootstrap_sent: 1,
+    });
+  });
+
+  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: "connection_metadata" },
+      { version: 6, name: "message_ack_status" },
+    ]);
+
+    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: "token-new",
+      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", send_status: "pending" },
+    ]);
+    expect(
+      store.markMessageAcknowledged({
+        accountId: "default",
+        kind: "message",
+        direction: "outbound",
+        messageId: "msg-1",
+        protocolMessageId: "srv-msg-1",
+        ackedAt: 3100,
+      }),
+    ).toBe(true);
+    expect(store.listMessagesForTest()).toMatchObject([
+      {
+        kind: "message",
+        direction: "outbound",
+        message_id: "msg-1",
+        send_status: "acknowledged",
+        protocol_message_id: "srv-msg-1",
+        acked_at: 3100,
+      },
+    ]);
+
+    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: "connection_metadata" },
+      { version: 6, name: "message_ack_status" },
+    ]);
+
+    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();
+  });
+
+});