@core-workspace/infoflow-openclaw-plugin 2026.3.8

package/src/utils/store/message-store.ts

@@ -0,0 +1,295 @@
+/**
+ * SQLite-backed persistent store for sent message IDs.
+ * Records messageid + msgseqid for every outbound message so that
+ * recall (撤回) can look up any sub-message, including those from split sends.
+ *
+ * Uses Node 22+ built-in `node:sqlite` (DatabaseSync, synchronous API).
+ */
+
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import type { DatabaseSync } from "node:sqlite";
+import { coreEvents, type SentMessageEvent } from "../../events.js";
+import { getInfoflowRuntime } from "../../runtime.js";
+import type { InfoflowMessageContentItem } from "../../types.js";
+
+const require = createRequire(import.meta.url);
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const DB_FILENAME = "sent-messages.db";
+const AUTO_CLEANUP_DAYS = 7;
+const AUTO_CLEANUP_MS = AUTO_CLEANUP_DAYS * 24 * 60 * 60 * 1000;
+
+// ---------------------------------------------------------------------------
+// DB singleton (lazy-init)
+// ---------------------------------------------------------------------------
+
+let db: DatabaseSync | null = null;
+
+function resolveDbPath(): string {
+  const env = process.env;
+  const stateDir = getInfoflowRuntime().state.resolveStateDir(env, os.homedir);
+  return path.join(stateDir, "infoflow", DB_FILENAME);
+}
+
+function getDb(): DatabaseSync {
+  if (db) return db;
+
+  const dbPath = resolveDbPath();
+  const dir = path.dirname(dbPath);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+
+  const sqlite = require("node:sqlite") as typeof import("node:sqlite");
+  db = new sqlite.DatabaseSync(dbPath);
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sent_messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      account_id TEXT NOT NULL,
+      target TEXT NOT NULL,
+      from_id TEXT NOT NULL DEFAULT '',
+      messageid TEXT NOT NULL,
+      msgseqid TEXT NOT NULL DEFAULT '',
+      digest TEXT NOT NULL DEFAULT '',
+      sent_at INTEGER NOT NULL
+    );
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_target_sent
+      ON sent_messages(account_id, target, sent_at DESC);
+  `);
+
+  // Migration: add from_id column to existing databases
+  try {
+    db.exec(`ALTER TABLE sent_messages ADD COLUMN from_id TEXT NOT NULL DEFAULT ''`);
+  } catch {
+    // Column already exists — ignore
+  }
+
+  return db;
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export type SentMessageRecord = {
+  target: string;
+  from: string;
+  messageid: string;
+  msgseqid: string;
+  digest: string;
+  sentAt: number;
+};
+
+/**
+ * Records a sent message. Also runs auto-cleanup of old records.
+ * Synchronous (DatabaseSync); failures are swallowed so sending is never blocked.
+ */
+export function recordSentMessage(accountId: string, record: SentMessageRecord): void {
+  try {
+    const d = getDb();
+    d.prepare(
+      `INSERT INTO sent_messages (account_id, target, from_id, messageid, msgseqid, digest, sent_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    ).run(
+      accountId,
+      record.target,
+      record.from,
+      record.messageid,
+      record.msgseqid,
+      record.digest,
+      record.sentAt,
+    );
+
+    // Auto-cleanup: delete records older than 7 days
+    const cutoff = Date.now() - AUTO_CLEANUP_MS;
+    d.prepare(`DELETE FROM sent_messages WHERE sent_at < ? AND account_id = ?`).run(
+      cutoff,
+      accountId,
+    );
+  } catch {
+    // Silently ignore — do not block sending
+  }
+}
+
+/**
+ * Queries the most recent N sent messages for a given target, ordered by sent_at DESC.
+ */
+export function querySentMessages(
+  accountId: string,
+  params: { target: string; count: number },
+): SentMessageRecord[] {
+  const d = getDb();
+  const rows = d
+    .prepare(
+      `SELECT target, from_id, messageid, msgseqid, digest, sent_at
+       FROM sent_messages
+       WHERE account_id = ? AND target = ?
+       ORDER BY sent_at DESC
+       LIMIT ?`,
+    )
+    .all(accountId, params.target, params.count) as Array<{
+    target: string;
+    from_id: string;
+    messageid: string;
+    msgseqid: string;
+    digest: string;
+    sent_at: number;
+  }>;
+
+  return rows.map((r) => ({
+    target: r.target,
+    from: r.from_id,
+    messageid: r.messageid,
+    msgseqid: r.msgseqid,
+    digest: r.digest,
+    sentAt: r.sent_at,
+  }));
+}
+
+/**
+ * Finds a single sent message by messageid.
+ */
+export function findSentMessage(
+  accountId: string,
+  messageid: string,
+): SentMessageRecord | undefined {
+  const d = getDb();
+  const row = d
+    .prepare(
+      `SELECT target, from_id, messageid, msgseqid, digest, sent_at
+       FROM sent_messages
+       WHERE account_id = ? AND messageid = ?
+       LIMIT 1`,
+    )
+    .get(accountId, messageid) as
+    | {
+        target: string;
+        from_id: string;
+        messageid: string;
+        msgseqid: string;
+        digest: string;
+        sent_at: number;
+      }
+    | undefined;
+
+  if (!row) return undefined;
+  return {
+    target: row.target,
+    from: row.from_id,
+    messageid: row.messageid,
+    msgseqid: row.msgseqid,
+    digest: row.digest,
+    sentAt: row.sent_at,
+  };
+}
+
+/**
+ * Removes recalled messages from the store by their messageids.
+ */
+export function removeRecalledMessages(accountId: string, messageids: string[]): void {
+  if (messageids.length === 0) return;
+  const d = getDb();
+  const placeholders = messageids.map(() => "?").join(",");
+  d.prepare(
+    `DELETE FROM sent_messages WHERE account_id = ? AND messageid IN (${placeholders})`,
+  ).run(accountId, ...messageids);
+}
+
+// ---------------------------------------------------------------------------
+// From-ID builder
+// ---------------------------------------------------------------------------
+
+/** Builds a `from` identifier for self-sent (agent) messages. */
+export function buildAgentFrom(appAgentId: number | undefined): string {
+  return appAgentId != null ? `agent:${appAgentId}` : "agent:unknown";
+}
+
+// ---------------------------------------------------------------------------
+// Digest builder
+// ---------------------------------------------------------------------------
+
+const DIGEST_MAX_LEN = 100;
+
+/**
+ * Builds a short digest string from message contents.
+ * - Text/markdown/link: first 100 chars, truncated with "…"
+ * - Image only: "image"
+ * - Empty: ""
+ */
+export function buildMessageDigest(contents: InfoflowMessageContentItem[]): string {
+  const textParts: string[] = [];
+  let hasImage = false;
+
+  for (const item of contents) {
+    const type = item.type.toLowerCase();
+    if (type === "text" || type === "md" || type === "markdown") {
+      textParts.push(item.content);
+    } else if (type === "link") {
+      textParts.push(item.content);
+    } else if (type === "image") {
+      hasImage = true;
+    }
+  }
+
+  const merged = textParts.join(" ").trim();
+  if (merged) {
+    return merged.length > DIGEST_MAX_LEN ? merged.slice(0, DIGEST_MAX_LEN) + "…" : merged;
+  }
+  if (hasImage) return "image";
+  return "";
+}
+
+// ---------------------------------------------------------------------------
+// Test-only exports (@internal)
+// ---------------------------------------------------------------------------
+
+/** @internal — Close and reset the DB singleton. Only use in tests. */
+export function _resetStore(): void {
+  if (db) {
+    try {
+      db.close();
+    } catch {
+      // ignore
+    }
+    db = null;
+  }
+}
+
+/** @internal — Override the DB instance for testing. */
+export function _setDb(next: DatabaseSync): void {
+  db = next;
+}
+
+// ---------------------------------------------------------------------------
+// Event subscription — auto-record sent messages from core
+// ---------------------------------------------------------------------------
+
+function handleSentEvent(event: SentMessageEvent): void {
+  try {
+    recordSentMessage(event.accountId, {
+      target: event.target,
+      from: event.from,
+      messageid: event.messageid,
+      msgseqid: event.msgseqid,
+      digest: buildMessageDigest(event.contents),
+      sentAt: event.sentAt,
+    });
+  } catch {
+    // Do not propagate — store failures must never break core
+  }
+}
+
+/**
+ * Register store listeners on the core event bus.
+ * Called once during plugin initialization.
+ */
+export function registerStoreListeners(): void {
+  coreEvents.on("message:sent", handleSentEvent);
+}

package/src/utils/token-adapter.ts

@@ -0,0 +1,90 @@
+/**
+ * SDK Adapter Layer: wraps SDK TokenManager for token management.
+ * Each appKey gets its own adapter instance (multi-account isolation).
+ *
+ * Design decision: Only use SDK TokenManager, NOT HTTPClient, because:
+ * - SDK HTTPClient uses http:// but plugin requires https://
+ * - Plugin needs raw response text for large integer precision (>2^53)
+ * - Plugin needs manual JSON construction for group recall
+ *
+ * HTTP requests continue using fetch in send.ts.
+ */
+
+import { ConfigManager, TokenManager } from "@core-workspace/infoflow-sdk-nodejs";
+
+/**
+ * Ensures apiHost uses HTTPS for security (secrets in transit).
+ * Allows HTTP only for localhost/127.0.0.1 (local development).
+ * (Inlined from send.ts to avoid circular dependency)
+ */
+function ensureHttps(apiHost: string): string {
+  if (apiHost.startsWith("http://")) {
+    const url = new URL(apiHost);
+    const isLocal = url.hostname === "localhost" || url.hostname === "127.0.0.1";
+    if (!isLocal) {
+      return apiHost.replace(/^http:/, "https:");
+    }
+  }
+  return apiHost;
+}
+
+// Module-level instance cache (keyed by appKey for multi-account isolation)
+const adapterCache = new Map<string, InfoflowSDKAdapter>();
+
+export type SDKAdapterParams = {
+  apiHost: string;
+  appKey: string;
+  appSecret: string;
+};
+
+/**
+ * Gets or creates an SDK adapter for the given appKey.
+ * Adapter instances are cached per appKey to reuse SDK TokenManager's
+ * internal token cache and Promise lock.
+ */
+export function getOrCreateAdapter(params: SDKAdapterParams): InfoflowSDKAdapter {
+  const existing = adapterCache.get(params.appKey);
+  if (existing) {
+    return existing;
+  }
+
+  const adapter = new InfoflowSDKAdapter(params);
+  adapterCache.set(params.appKey, adapter);
+  return adapter;
+}
+
+/**
+ * SDK adapter wrapping TokenManager for a single appKey.
+ */
+export class InfoflowSDKAdapter {
+  private tokenManager: TokenManager;
+
+  constructor(params: SDKAdapterParams) {
+    // SDK ConfigManager expects pure domain (e.g. "apiin.im.baidu.com"),
+    // but plugin's apiHost is a full URL (e.g. "https://apiin.im.baidu.com").
+    // Extract the host portion.
+    const apiUrl = ensureHttps(params.apiHost);
+    const domain = new URL(apiUrl).host;
+
+    const configManager = new ConfigManager({
+      appId: params.appKey,
+      appSecret: params.appSecret,
+      apiDomain: domain,
+    });
+
+    this.tokenManager = new TokenManager(configManager);
+  }
+
+  /**
+   * Gets an access token via SDK TokenManager.
+   * Handles caching, MD5 signing, concurrency safety, and early refresh internally.
+   */
+  async getToken(): Promise<string> {
+    return this.tokenManager.getAccessToken();
+  }
+}
+
+/** @internal — Resets all adapter instances. Only use in tests. */
+export function _resetAdapters(): void {
+  adapterCache.clear();
+}