openclaw-server 0.1.0 → 0.2.0

package/src/bookmark-digest/store.ts

@@ -0,0 +1,349 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import Database from "better-sqlite3";
+import type {
+  BookmarkDigestNotification,
+  BookmarkDigestNotificationPayload,
+  BookmarkDigestSubscription,
+} from "./types.js";
+
+type SubscriptionRow = {
+  user_id: string;
+  timezone: string;
+  schedule_hour: number;
+  schedule_minute: number;
+  status: BookmarkDigestSubscription["status"];
+  last_scheduled_slot: string | null;
+  last_digest_signatures_json: string;
+  created_at: string;
+  updated_at: string;
+};
+
+type NotificationRow = {
+  id: string;
+  user_id: string;
+  slot_at: string;
+  message: string;
+  payload_json: string;
+  status: BookmarkDigestNotification["status"];
+  delivered_at: string | null;
+  last_attempt_at: string | null;
+  last_error: string | null;
+  created_at: string;
+  updated_at: string;
+};
+
+function toIsoString(date: Date): string {
+  return date.toISOString();
+}
+
+function parseStringArray(value: string): string[] {
+  try {
+    const parsed = JSON.parse(value);
+    if (!Array.isArray(parsed)) {
+      return [];
+    }
+    return parsed.filter((item): item is string => typeof item === "string");
+  } catch {
+    return [];
+  }
+}
+
+function parsePayload(value: string): BookmarkDigestNotificationPayload {
+  try {
+    const parsed = JSON.parse(value);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const payload = parsed as Partial<BookmarkDigestNotificationPayload>;
+      return {
+        type: "bookmark_digest",
+        userId: typeof payload.userId === "string" ? payload.userId : "",
+        slotAt: typeof payload.slotAt === "string" ? payload.slotAt : "",
+        hasNewArticles: Boolean(payload.hasNewArticles),
+        articles: Array.isArray(payload.articles) ? payload.articles : [],
+        browseUrl: typeof payload.browseUrl === "string" ? payload.browseUrl : undefined,
+      };
+    }
+  } catch {
+    // Fall back to an empty payload when the row is malformed.
+  }
+
+  return {
+    type: "bookmark_digest",
+    userId: "",
+    slotAt: "",
+    hasNewArticles: false,
+    articles: [],
+  };
+}
+
+function mapSubscription(row: SubscriptionRow): BookmarkDigestSubscription {
+  return {
+    userId: row.user_id,
+    timeZone: row.timezone,
+    scheduleHour: row.schedule_hour,
+    scheduleMinute: row.schedule_minute,
+    status: row.status,
+    lastScheduledSlot: row.last_scheduled_slot,
+    lastDigestSignatures: parseStringArray(row.last_digest_signatures_json),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+function mapNotification(row: NotificationRow): BookmarkDigestNotification {
+  return {
+    id: row.id,
+    userId: row.user_id,
+    slotAt: row.slot_at,
+    message: row.message,
+    payload: parsePayload(row.payload_json),
+    status: row.status,
+    deliveredAt: row.delivered_at,
+    lastAttemptAt: row.last_attempt_at,
+    lastError: row.last_error,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+export class BookmarkDigestStore {
+  private readonly db: Database;
+
+  constructor(dbPath: string) {
+    if (dbPath !== ":memory:") {
+      fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+    }
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.db.pragma("synchronous = NORMAL");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS bookmark_digest_subscriptions (
+        user_id TEXT PRIMARY KEY,
+        timezone TEXT NOT NULL,
+        schedule_hour INTEGER NOT NULL,
+        schedule_minute INTEGER NOT NULL,
+        status TEXT NOT NULL,
+        last_scheduled_slot TEXT,
+        last_digest_signatures_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS bookmark_digest_notifications (
+        id TEXT PRIMARY KEY,
+        user_id TEXT NOT NULL,
+        slot_at TEXT NOT NULL,
+        message TEXT NOT NULL,
+        payload_json TEXT NOT NULL,
+        status TEXT NOT NULL,
+        delivered_at TEXT,
+        last_attempt_at TEXT,
+        last_error TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(user_id, slot_at)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_bookmark_digest_subscriptions_status
+        ON bookmark_digest_subscriptions(status);
+      CREATE INDEX IF NOT EXISTS idx_bookmark_digest_notifications_status_slot
+        ON bookmark_digest_notifications(status, slot_at);
+      CREATE INDEX IF NOT EXISTS idx_bookmark_digest_notifications_user_status
+        ON bookmark_digest_notifications(user_id, status);
+    `);
+  }
+
+  close(): void {
+    this.db.close();
+  }
+
+  getSubscription(userId: string): BookmarkDigestSubscription | undefined {
+    const row = this.db
+      .prepare(`SELECT * FROM bookmark_digest_subscriptions WHERE user_id = ?`)
+      .get(userId) as SubscriptionRow | undefined;
+    return row ? mapSubscription(row) : undefined;
+  }
+
+  listActiveSubscriptions(): BookmarkDigestSubscription[] {
+    const rows = this.db
+      .prepare(
+        `SELECT * FROM bookmark_digest_subscriptions
+         WHERE status = 'active'
+         ORDER BY created_at ASC`,
+      )
+      .all() as SubscriptionRow[];
+    return rows.map(mapSubscription);
+  }
+
+  upsertSubscription(params: {
+    userId: string;
+    timeZone: string;
+    scheduleHour: number;
+    scheduleMinute: number;
+    now: Date;
+  }): BookmarkDigestSubscription {
+    const nowIso = toIsoString(params.now);
+    this.db
+      .prepare(
+        `INSERT INTO bookmark_digest_subscriptions (
+          user_id,
+          timezone,
+          schedule_hour,
+          schedule_minute,
+          status,
+          last_scheduled_slot,
+          last_digest_signatures_json,
+          created_at,
+          updated_at
+        ) VALUES (?, ?, ?, ?, 'active', NULL, '[]', ?, ?)
+        ON CONFLICT(user_id) DO UPDATE SET
+          timezone = excluded.timezone,
+          schedule_hour = excluded.schedule_hour,
+          schedule_minute = excluded.schedule_minute,
+          status = 'active',
+          updated_at = excluded.updated_at`,
+      )
+      .run(
+        params.userId,
+        params.timeZone,
+        params.scheduleHour,
+        params.scheduleMinute,
+        nowIso,
+        nowIso,
+      );
+
+    return this.getSubscription(params.userId)!;
+  }
+
+  cancelSubscription(userId: string, now: Date): BookmarkDigestSubscription | undefined {
+    this.db
+      .prepare(
+        `UPDATE bookmark_digest_subscriptions
+         SET status = 'cancelled', updated_at = ?
+         WHERE user_id = ? AND status = 'active'`,
+      )
+      .run(toIsoString(now), userId);
+
+    return this.getSubscription(userId);
+  }
+
+  updateDigestState(params: {
+    userId: string;
+    lastScheduledSlot: string;
+    lastDigestSignatures: string[];
+    now: Date;
+  }): void {
+    this.db
+      .prepare(
+        `UPDATE bookmark_digest_subscriptions
+         SET last_scheduled_slot = ?,
+             last_digest_signatures_json = ?,
+             updated_at = ?
+         WHERE user_id = ?`,
+      )
+      .run(
+        params.lastScheduledSlot,
+        JSON.stringify(params.lastDigestSignatures),
+        toIsoString(params.now),
+        params.userId,
+      );
+  }
+
+  createNotification(params: {
+    userId: string;
+    slotAt: string;
+    message: string;
+    payload: BookmarkDigestNotificationPayload;
+    now: Date;
+  }): BookmarkDigestNotification | undefined {
+    const id = randomUUID();
+    const nowIso = toIsoString(params.now);
+    const result = this.db
+      .prepare(
+        `INSERT OR IGNORE INTO bookmark_digest_notifications (
+          id,
+          user_id,
+          slot_at,
+          message,
+          payload_json,
+          status,
+          created_at,
+          updated_at
+        ) VALUES (?, ?, ?, ?, ?, 'pending', ?, ?)`,
+      )
+      .run(
+        id,
+        params.userId,
+        params.slotAt,
+        params.message,
+        JSON.stringify(params.payload),
+        nowIso,
+        nowIso,
+      );
+
+    if (result.changes === 0) {
+      return undefined;
+    }
+
+    const row = this.db
+      .prepare(`SELECT * FROM bookmark_digest_notifications WHERE id = ?`)
+      .get(id) as NotificationRow | undefined;
+    return row ? mapNotification(row) : undefined;
+  }
+
+  listPendingNotifications(params: {
+    userId?: string;
+    limit?: number;
+  } = {}): BookmarkDigestNotification[] {
+    let query =
+      `SELECT * FROM bookmark_digest_notifications
+       WHERE status = 'pending'`;
+    const args: unknown[] = [];
+
+    if (params.userId) {
+      query += ` AND user_id = ?`;
+      args.push(params.userId);
+    }
+
+    query += ` ORDER BY slot_at ASC, created_at ASC LIMIT ?`;
+    args.push(params.limit ?? 20);
+    const rows = this.db.prepare(query).all(...args) as NotificationRow[];
+    return rows.map(mapNotification);
+  }
+
+  markDelivered(ids: string[], now: Date): number {
+    if (ids.length === 0) {
+      return 0;
+    }
+
+    const nowIso = toIsoString(now);
+    const placeholders = ids.map(() => "?").join(", ");
+    const result = this.db
+      .prepare(
+        `UPDATE bookmark_digest_notifications
+         SET status = 'delivered',
+             delivered_at = ?,
+             last_attempt_at = ?,
+             last_error = NULL,
+             updated_at = ?
+         WHERE id IN (${placeholders}) AND status = 'pending'`,
+      )
+      .run(nowIso, nowIso, nowIso, ...ids);
+    return result.changes;
+  }
+
+  recordDeliveryAttempt(id: string, now: Date, error?: string): void {
+    const nowIso = toIsoString(now);
+    this.db
+      .prepare(
+        `UPDATE bookmark_digest_notifications
+         SET last_attempt_at = ?,
+             last_error = ?,
+             updated_at = ?
+         WHERE id = ?`,
+      )
+      .run(nowIso, error ?? null, nowIso, id);
+  }
+}

package/src/bookmark-digest/types.ts

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import type { BookmarkSearchItem } from "../bookmark-search/types.js";
+
+export type BookmarkDigestSubscriptionStatus = "active" | "cancelled";
+export type BookmarkDigestNotificationStatus = "pending" | "delivered";
+
+export type BookmarkDigestSubscription = {
+  userId: string;
+  timeZone: string;
+  scheduleHour: number;
+  scheduleMinute: number;
+  status: BookmarkDigestSubscriptionStatus;
+  lastScheduledSlot: string | null;
+  lastDigestSignatures: string[];
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type BookmarkDigestNotificationPayload = {
+  type: "bookmark_digest";
+  userId: string;
+  slotAt: string;
+  hasNewArticles: boolean;
+  articles: BookmarkSearchItem[];
+  browseUrl?: string;
+};
+
+export type BookmarkDigestNotification = {
+  id: string;
+  userId: string;
+  slotAt: string;
+  message: string;
+  payload: BookmarkDigestNotificationPayload;
+  status: BookmarkDigestNotificationStatus;
+  deliveredAt: string | null;
+  lastAttemptAt: string | null;
+  lastError: string | null;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type BookmarkDigestMessageInspection = {
+  shouldHandle: boolean;
+  reason: "subscribe" | "cancel" | "status" | "missing_time" | "no_match";
+  scheduleHour?: number;
+  scheduleMinute?: number;
+};
+
+export type BookmarkDigestChatResult = {
+  reply: string;
+  intent: "subscribed" | "cancelled" | "status" | "clarify" | "error";
+  subscription?: BookmarkDigestSubscription;
+};
+
+export const BookmarkDigestPendingQuerySchema = z.object({
+  user: z.string().trim().min(1).optional(),
+  limit: z.coerce.number().int().min(1).max(100).optional(),
+});
+
+export const BookmarkDigestMarkDeliveredSchema = z.object({
+  ids: z.array(z.string().trim().min(1)).min(1).max(100),
+});

package/src/bookmark-search/chat-integration.ts

@@ -0,0 +1,56 @@
+import { createHash } from "node:crypto";
+import type { EngineResult, NormalizedTurn } from "../types.js";
+import type { BookmarkSearchMessageInspection } from "./types.js";
+import type { BookmarkSearchService } from "./service.js";
+
+function firstUserText(turn: NormalizedTurn): string {
+  return turn.history.find((message) => message.role === "user")?.text ?? turn.userText;
+}
+
+export function resolveBookmarkSearchUserId(turn: NormalizedTurn, explicitUser?: string): string {
+  if (explicitUser?.trim()) {
+    return explicitUser.trim();
+  }
+
+  const seed = `${turn.model}\n${firstUserText(turn)}`;
+  const digest = createHash("sha1").update(seed).digest("hex").slice(0, 16);
+  return `search:${digest}`;
+}
+
+export function inspectBookmarkSearchMessage(params: {
+  bookmarkSearchService: BookmarkSearchService;
+  turn: NormalizedTurn;
+  explicitUser?: string;
+}): { userId: string; inspection: BookmarkSearchMessageInspection } {
+  const userId = resolveBookmarkSearchUserId(params.turn, params.explicitUser);
+  const inspection = params.bookmarkSearchService.inspectMessage({
+    userId,
+    text: params.turn.userText,
+  });
+  return { userId, inspection };
+}
+
+export async function respondToBookmarkSearchMessage(params: {
+  bookmarkSearchService: BookmarkSearchService;
+  turn: NormalizedTurn;
+  explicitUser?: string;
+}): Promise<EngineResult | undefined> {
+  const { userId, inspection } = inspectBookmarkSearchMessage(params);
+  if (!inspection.shouldHandle) {
+    return undefined;
+  }
+
+  const result = await params.bookmarkSearchService.processMessage({
+    userId,
+    text: params.turn.userText,
+  });
+
+  return {
+    model: params.turn.model,
+    sessionId: params.turn.sessionId,
+    text: result.reply,
+    finishReason: "stop",
+    matchedIntentId: `bookmark-search.${result.intent}`,
+    templateId: `bookmark-search.${result.intent}`,
+  };
+}

package/src/bookmark-search/parser.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from "vitest";
+import { extractBookmarkSearchQuery, inspectBookmarkSearchQuery } from "./parser.js";
+
+describe("bookmark search parser", () => {
+  it("strips surrounding quotes from direct search queries", () => {
+    expect(extractBookmarkSearchQuery('搜索 "python 教程"')).toBe("python 教程");
+  });
+
+  it("treats a bare keyword as a bookmark search query", () => {
+    expect(inspectBookmarkSearchQuery("百度")).toEqual({
+      shouldHandle: true,
+      reason: "query",
+      action: "search",
+      query: "百度",
+    });
+  });
+
+  it("does not treat greetings as implicit bookmark searches", () => {
+    expect(inspectBookmarkSearchQuery("你好")).toEqual({
+      shouldHandle: false,
+      reason: "no_match",
+    });
+  });
+
+  it("asks for a query when the user only mentions searching bookmarks", () => {
+    expect(inspectBookmarkSearchQuery("帮我在书签篮里搜一下")).toEqual({
+      shouldHandle: true,
+      reason: "query",
+      action: "search",
+      missing: "query",
+    });
+  });
+
+  it("detects latest-article requests", () => {
+    expect(inspectBookmarkSearchQuery("最新文章")).toEqual({
+      shouldHandle: true,
+      reason: "query",
+      action: "latest",
+    });
+  });
+
+  it("detects category-list requests", () => {
+    expect(inspectBookmarkSearchQuery("分类列表")).toEqual({
+      shouldHandle: true,
+      reason: "query",
+      action: "categories",
+    });
+  });
+
+  it("detects category article requests", () => {
+    expect(inspectBookmarkSearchQuery("开发工具分类")).toEqual({
+      shouldHandle: true,
+      reason: "query",
+      action: "category_articles",
+      category: "开发工具",
+    });
+  });
+
+  it("detects category link requests", () => {
+    expect(inspectBookmarkSearchQuery("开发工具常用链接")).toEqual({
+      shouldHandle: true,
+      reason: "query",
+      action: "category_links",
+      category: "开发工具",
+    });
+  });
+});