openclaw-server 0.1.0

package/src/server.ts

@@ -0,0 +1,108 @@
+import express from "express";
+import type { ServerConfig } from "./config.js";
+import { loadPack } from "./core/pack-loader.js";
+import { ReplyEngine } from "./core/reply-engine.js";
+import { SessionStore } from "./core/session-store.js";
+import { registerAdminRoutes } from "./routes/admin.js";
+import { registerChatCompletionsRoute } from "./routes/chat-completions.js";
+import { registerHealthRoute } from "./routes/health.js";
+import { registerModelsRoute } from "./routes/models.js";
+import { registerResponsesRoute } from "./routes/responses.js";
+import { registerTaskRoutes } from "./routes/tasks.js";
+import { RuntimeStats, type RuntimeStatsSnapshot } from "./runtime-stats.js";
+import { TaskBotService } from "./tasks/service.js";
+import { TaskStore } from "./tasks/store.js";
+import type { LoadedPack } from "./types.js";
+import { OpenMeteoWeatherProvider } from "./weather/open-meteo-provider.js";
+import { WeatherService } from "./weather/service.js";
+import type { WeatherProvider } from "./weather/types.js";
+
+export type AppContextDeps = {
+  weatherProvider?: WeatherProvider;
+};
+
+export type AppContext = {
+  config: ServerConfig;
+  pack: LoadedPack;
+  sessionStore: SessionStore;
+  replyEngine: ReplyEngine;
+  stats: RuntimeStats;
+  taskService: TaskBotService;
+  weatherService: WeatherService;
+  reloadPack: () => Promise<void>;
+  snapshotStats: () => RuntimeStatsSnapshot;
+  recordAuthFailure: () => void;
+  recordCompletion: (params: { stream: boolean; finishReason: "stop" | "tool_calls" }) => void;
+  dispose: () => void;
+};
+
+export async function createAppContext(
+  config: ServerConfig,
+  deps: AppContextDeps = {},
+): Promise<AppContext> {
+  const sessionStore = new SessionStore(config.sessionLogPath);
+  const stats = new RuntimeStats();
+  const initialPack = await loadPack(config.packDir);
+  const taskStore = new TaskStore(config.taskDbPath, config.taskTimezone);
+  const taskService = new TaskBotService(taskStore, config.taskReminderPollMs, config.taskTimezone);
+  const weatherService = new WeatherService(
+    deps.weatherProvider ?? new OpenMeteoWeatherProvider(),
+  );
+  taskService.start();
+
+  let context: AppContext;
+  context = {
+    config,
+    pack: initialPack,
+    sessionStore,
+    replyEngine: new ReplyEngine(initialPack, sessionStore),
+    stats,
+    taskService,
+    weatherService,
+    recordAuthFailure: (): void => {
+      stats.recordAuthFailure();
+    },
+    recordCompletion: (params: { stream: boolean; finishReason: "stop" | "tool_calls" }): void => {
+      stats.recordCompletion(params);
+    },
+    snapshotStats: (): RuntimeStatsSnapshot => stats.snapshot(context.pack, sessionStore),
+    reloadPack: async (): Promise<void> => {
+      const nextPack = await loadPack(config.packDir);
+      context.pack = nextPack;
+      context.replyEngine = new ReplyEngine(nextPack, sessionStore);
+      stats.recordReload();
+    },
+    dispose: (): void => {
+      taskService.stop();
+    },
+  };
+
+  return context;
+}
+
+export function createApp(context: AppContext) {
+  const app = express();
+  app.disable("x-powered-by");
+  app.use(express.json({ limit: "2mb" }));
+
+  registerHealthRoute(app);
+  registerModelsRoute(app, context);
+  registerChatCompletionsRoute(app, context);
+  registerResponsesRoute(app, context);
+  registerTaskRoutes(app, context);
+  registerAdminRoutes(app, context);
+
+  app.use(
+    (error: unknown, _req: express.Request, res: express.Response, _next: express.NextFunction) => {
+      const message = error instanceof Error ? error.message : "internal error";
+      res.status(500).json({
+        error: {
+          message,
+          type: "api_error",
+        },
+      });
+    },
+  );
+
+  return app;
+}

package/src/tasks/chat-integration.ts

@@ -0,0 +1,70 @@
+import { createHash } from "node:crypto";
+import type { EngineResult, NormalizedTurn } from "../types.js";
+import type { TaskBotService, TaskMessageInspection } from "./service.js";
+import type { TaskChatResult } from "./types.js";
+
+function firstUserText(turn: NormalizedTurn): string {
+  return turn.history.find((message) => message.role === "user")?.text ?? turn.userText;
+}
+
+export function resolveTaskUserId(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 `chat:${digest}`;
+}
+
+export function inspectTaskMessage(params: {
+  taskService: TaskBotService;
+  turn: NormalizedTurn;
+  explicitUser?: string;
+  now?: string;
+}): { userId: string; inspection: TaskMessageInspection } {
+  const userId = resolveTaskUserId(params.turn, params.explicitUser);
+  const inspection = params.taskService.inspectMessage({
+    userId,
+    text: params.turn.userText,
+    now: params.now,
+  });
+  return { userId, inspection };
+}
+
+export function buildTaskEngineResult(params: {
+  turn: NormalizedTurn;
+  taskResult: TaskChatResult;
+}): EngineResult {
+  return {
+    model: params.turn.model,
+    sessionId: params.turn.sessionId,
+    text: params.taskResult.reply,
+    finishReason: "stop",
+    matchedIntentId: `task.${params.taskResult.intent}`,
+    templateId: `task.${params.taskResult.intent}`,
+  };
+}
+
+export function respondToTaskMessage(params: {
+  taskService: TaskBotService;
+  turn: NormalizedTurn;
+  explicitUser?: string;
+  now?: string;
+}): EngineResult | undefined {
+  const { userId, inspection } = inspectTaskMessage(params);
+  if (!inspection.shouldHandle) {
+    return undefined;
+  }
+
+  const taskResult = params.taskService.processMessage({
+    userId,
+    text: params.turn.userText,
+    now: params.now,
+  });
+
+  return buildTaskEngineResult({
+    turn: params.turn,
+    taskResult,
+  });
+}

package/src/tasks/service.ts

@@ -0,0 +1,320 @@
+import {
+  formatLocalDateTime,
+  isConfirmation,
+  parseReminderPreference,
+  parseTaskAction,
+  parseTaskDraft,
+  parseTaskQuery,
+  summarizeScope,
+} from "./time-parser.js";
+import { TaskStore } from "./store.js";
+import type {
+  ParsedTaskAction,
+  ParsedTaskDraft,
+  ReminderSummary,
+  TaskChatResult,
+  TaskScope,
+  TaskStats,
+  TaskSummary,
+} from "./types.js";
+
+function renderTaskLine(task: TaskSummary): string {
+  return `- ${task.title}（${task.dueAtText}）`;
+}
+
+function resolveNow(now?: string): Date {
+  if (!now) {
+    return new Date();
+  }
+  const parsed = new Date(now);
+  if (Number.isNaN(parsed.getTime())) {
+    return new Date();
+  }
+  return parsed;
+}
+
+export type TaskMessageInspection = {
+  shouldHandle: boolean;
+  reason:
+    | "conversation"
+    | "query"
+    | "action"
+    | "draft_ready"
+    | "draft_missing_time"
+    | "draft_missing_title"
+    | "no_match";
+  queryScope?: TaskScope;
+  actionKind?: ParsedTaskAction["kind"];
+  draftKind?: ParsedTaskDraft["kind"];
+  title?: string;
+  dueAtText?: string;
+};
+
+export class TaskBotService {
+  private timer: NodeJS.Timeout | undefined;
+
+  constructor(
+    private readonly store: TaskStore,
+    private readonly pollMs: number,
+    private readonly timeZone: string,
+  ) {}
+
+  start(): void {
+    if (this.pollMs <= 0 || this.timer) {
+      return;
+    }
+    this.timer = setInterval(() => {
+      this.dispatchDueReminders();
+    }, this.pollMs);
+    this.timer.unref();
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = undefined;
+    }
+    this.store.close();
+  }
+
+  inspectMessage(params: { userId: string; text: string; now?: string }): TaskMessageInspection {
+    const now = resolveNow(params.now);
+    const conversation = this.store.getConversation(params.userId);
+    if (conversation) {
+      return {
+        shouldHandle: true,
+        reason: "conversation",
+        title: conversation.title,
+        dueAtText: formatLocalDateTime(new Date(conversation.dueAt), this.timeZone),
+      };
+    }
+
+    const scope = parseTaskQuery(params.text);
+    if (scope) {
+      return {
+        shouldHandle: true,
+        reason: "query",
+        queryScope: scope,
+      };
+    }
+
+    const action = parseTaskAction(params.text);
+    if (action) {
+      return {
+        shouldHandle: true,
+        reason: "action",
+        actionKind: action.kind,
+      };
+    }
+
+    const draft = parseTaskDraft(params.text, now, this.timeZone);
+    if (!draft) {
+      return {
+        shouldHandle: false,
+        reason: "no_match",
+      };
+    }
+
+    return {
+      shouldHandle: true,
+      reason:
+        draft.kind === "ready"
+          ? "draft_ready"
+          : draft.kind === "missing_time"
+            ? "draft_missing_time"
+            : "draft_missing_title",
+      draftKind: draft.kind,
+      title: "title" in draft ? draft.title : undefined,
+      dueAtText: draft.kind === "ready" ? formatLocalDateTime(draft.dueAt, this.timeZone) : undefined,
+    };
+  }
+
+  shouldHandleMessage(params: { userId: string; text: string; now?: string }): boolean {
+    return this.inspectMessage(params).shouldHandle;
+  }
+
+  dispatchDueReminders(now?: string): number {
+    return this.store.dispatchDueReminders(resolveNow(now));
+  }
+
+  listTasks(userId: string, scope: TaskScope, now?: string): TaskSummary[] {
+    return this.store.listTasks(userId, scope, resolveNow(now));
+  }
+
+  listPendingReminders(userId: string, now?: string): ReminderSummary[] {
+    const current = resolveNow(now);
+    this.store.dispatchDueReminders(current);
+    return this.store.listPendingReminders(userId);
+  }
+
+  getStats(userId: string, now?: string): TaskStats {
+    return this.store.getStats(userId, resolveNow(now));
+  }
+
+  processMessage(params: { userId: string; text: string; now?: string }): TaskChatResult {
+    const now = resolveNow(params.now);
+    this.store.dispatchDueReminders(now);
+
+    const session = this.store.getConversation(params.userId);
+    if (session) {
+      if (/^(取消|算了)$/u.test(params.text.trim())) {
+        this.store.clearConversation(params.userId);
+        return {
+          reply: `已取消任务草稿「${session.title}」。`,
+          intent: "task_action",
+        };
+      }
+
+      const reminder = parseReminderPreference(params.text);
+      if (reminder || isConfirmation(params.text)) {
+        const offsetMinutes = reminder ? reminder.offsetMinutes : 0;
+        const task = this.store.createTask({
+          userId: params.userId,
+          title: session.title,
+          sourceText: session.sourceText,
+          dueAt: new Date(session.dueAt),
+          reminderOffsetMinutes: offsetMinutes,
+          now,
+        });
+        this.store.clearConversation(params.userId);
+        const reminderText =
+          offsetMinutes === null
+            ? "不提醒"
+            : offsetMinutes === 0
+              ? "到点提醒"
+              : `提前 ${offsetMinutes} 分钟提醒`;
+        return {
+          reply: `已创建任务「${task.title}」，时间：${task.dueAtText}，提醒：${reminderText}。`,
+          intent: "task_created",
+          task,
+        };
+      }
+
+      return {
+        reply: `任务草稿「${session.title}」时间为 ${formatLocalDateTime(new Date(session.dueAt), this.timeZone)}。请回复：提前15分钟提醒 / 到点提醒 / 不用提醒 / 取消。`,
+        intent: "clarify",
+      };
+    }
+
+    const scope = parseTaskQuery(params.text);
+    if (scope) {
+      const tasks = this.store.listTasks(params.userId, scope, now);
+      if (tasks.length === 0) {
+        return {
+          reply: `${summarizeScope(scope)}还没有待办任务。`,
+          intent: "task_query",
+          tasks,
+        };
+      }
+      const lines = tasks.slice(0, 5).map(renderTaskLine).join("\n");
+      return {
+        reply: `${summarizeScope(scope)}共有 ${tasks.length} 个待办任务：\n${lines}`,
+        intent: "task_query",
+        tasks,
+      };
+    }
+
+    const action = parseTaskAction(params.text);
+    if (action) {
+      const actionable = this.store.findActionableTasks(params.userId);
+      if (actionable.length === 0) {
+        return {
+          reply: "当前没有等待处理的提醒任务。",
+          intent: "clarify",
+        };
+      }
+      if (actionable.length > 1) {
+        return {
+          reply: `当前有多个待处理提醒：${actionable.map((task) => task.title).join("、")}。请先在任务列表中确认后再处理。`,
+          intent: "clarify",
+          tasks: actionable,
+        };
+      }
+
+      const currentTask = actionable[0];
+      if (action.kind === "done") {
+        const task = this.store.markTaskDone(currentTask.id, now);
+        return {
+          reply: `任务「${currentTask.title}」已标记完成。`,
+          intent: "task_action",
+          task: task ?? currentTask,
+        };
+      }
+      if (action.kind === "cancel") {
+        const task = this.store.cancelTask(currentTask.id, now);
+        return {
+          reply: `任务「${currentTask.title}」已取消。`,
+          intent: "task_action",
+          task: task ?? currentTask,
+        };
+      }
+
+      const task = this.store.snoozeTask(currentTask.id, action.minutes, now);
+      return {
+        reply: `任务「${currentTask.title}」已延后 ${action.minutes} 分钟，新的时间为 ${task?.dueAtText ?? currentTask.dueAtText}。`,
+        intent: "task_action",
+        task: task ?? currentTask,
+      };
+    }
+
+    const draft = parseTaskDraft(params.text, now, this.timeZone);
+    if (draft?.kind === "missing_time") {
+      return {
+        reply: `我识别到了任务「${draft.title}」，但时间还不够明确。请补充具体时间，例如：明天下午3点。`,
+        intent: "clarify",
+      };
+    }
+    if (draft?.kind === "missing_title") {
+      return {
+        reply: "我识别到了时间，但还缺少任务内容。请补充要做什么。",
+        intent: "clarify",
+      };
+    }
+    if (draft?.kind === "ready") {
+      if (draft.reminderOffsetMinutes !== undefined) {
+        const task = this.store.createTask({
+          userId: params.userId,
+          title: draft.title,
+          sourceText: params.text,
+          dueAt: draft.dueAt,
+          reminderOffsetMinutes: draft.reminderOffsetMinutes,
+          now,
+        });
+        const reminderText =
+          draft.reminderOffsetMinutes === null
+            ? "不提醒"
+            : draft.reminderOffsetMinutes === 0
+              ? "到点提醒"
+              : `提前 ${draft.reminderOffsetMinutes} 分钟提醒`;
+        return {
+          reply: `已创建任务「${task.title}」，时间：${task.dueAtText}，提醒：${reminderText}。`,
+          intent: "task_created",
+          task,
+        };
+      }
+
+      this.store.upsertConversation({
+        userId: params.userId,
+        sourceText: params.text,
+        title: draft.title,
+        dueAt: draft.dueAt,
+        reminderOffsetMinutes: null,
+        now,
+      });
+      return {
+        reply: `已创建任务草稿「${draft.title}」，时间：${formatLocalDateTime(draft.dueAt, this.timeZone)}，需要提醒吗？可回复：提前15分钟提醒 / 到点提醒 / 不用提醒 / 确认。`,
+        intent: "draft_created",
+      };
+    }
+
+    const reminders = this.store.listPendingReminders(params.userId);
+    const reminderHint = reminders.length
+      ? ` 当前有 ${reminders.length} 条待处理提醒，可回复：完成 / 延后10分钟 / 取消。`
+      : "";
+    return {
+      reply: `我目前支持创建任务、设置提醒、查询今天/明天/本周任务，以及处理提醒。示例：明天下午3点开会。${reminderHint}`,
+      intent: "help",
+      reminders,
+    };
+  }
+}

package/src/tasks/store.test.ts

@@ -0,0 +1,183 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { TaskStore } from "./store.js";
+
+function createStore(): TaskStore {
+  return new TaskStore(":memory:", "Asia/Shanghai");
+}
+
+function createTimeZoneStore(timeZone: string): TaskStore {
+  return new TaskStore(":memory:", timeZone);
+}
+
+describe("task store", () => {
+  const stores: TaskStore[] = [];
+
+  afterEach(() => {
+    for (const store of stores.splice(0)) {
+      store.close();
+    }
+  });
+
+  it("filters scoped task lists in SQLite instead of in-process", () => {
+    const store = createStore();
+    stores.push(store);
+
+    const createdAt = new Date("2026-03-12T09:00:00+08:00");
+    const overdue = store.createTask({
+      userId: "u1",
+      title: "补昨天的日报",
+      sourceText: "昨天的日报",
+      dueAt: new Date("2026-03-12T08:30:00+08:00"),
+      reminderOffsetMinutes: null,
+      now: createdAt,
+    });
+    store.createTask({
+      userId: "u1",
+      title: "今天站会",
+      sourceText: "今天站会",
+      dueAt: new Date("2026-03-12T10:00:00+08:00"),
+      reminderOffsetMinutes: null,
+      now: createdAt,
+    });
+    store.createTask({
+      userId: "u1",
+      title: "明天开会",
+      sourceText: "明天开会",
+      dueAt: new Date("2026-03-13T09:00:00+08:00"),
+      reminderOffsetMinutes: null,
+      now: createdAt,
+    });
+    const done = store.createTask({
+      userId: "u1",
+      title: "已经完成的任务",
+      sourceText: "完成任务",
+      dueAt: new Date("2026-03-12T11:00:00+08:00"),
+      reminderOffsetMinutes: null,
+      now: createdAt,
+    });
+    store.markTaskDone(done.id, new Date("2026-03-12T11:30:00+08:00"));
+    const cancelled = store.createTask({
+      userId: "u1",
+      title: "取消的任务",
+      sourceText: "取消任务",
+      dueAt: new Date("2026-03-12T16:00:00+08:00"),
+      reminderOffsetMinutes: null,
+      now: createdAt,
+    });
+    store.cancelTask(cancelled.id, new Date("2026-03-12T12:00:00+08:00"));
+    store.createTask({
+      userId: "u2",
+      title: "别人的任务",
+      sourceText: "别人的任务",
+      dueAt: new Date("2026-03-12T15:00:00+08:00"),
+      reminderOffsetMinutes: null,
+      now: createdAt,
+    });
+
+    expect(
+      store
+        .listTasks("u1", "today", new Date("2026-03-12T09:30:00+08:00"))
+        .map((task) => task.title),
+    ).toEqual(["补昨天的日报", "今天站会"]);
+    expect(store.listTasks("u1", "tomorrow", createdAt).map((task) => task.title)).toEqual([
+      "明天开会",
+    ]);
+    expect(
+      store
+        .listTasks("u1", "overdue", new Date("2026-03-12T09:30:00+08:00"))
+        .map((task) => task.id),
+    ).toEqual([overdue.id]);
+    expect(store.listTasks("u1", "all", createdAt).map((task) => task.title)).toEqual([
+      "补昨天的日报",
+      "今天站会",
+      "已经完成的任务",
+      "取消的任务",
+      "明天开会",
+    ]);
+  });
+
+  it("aggregates task stats in SQL and keeps pending reminder counts accurate", () => {
+    const store = createStore();
+    stores.push(store);
+
+    const createdAt = new Date("2026-03-12T09:00:00+08:00");
+    store.createTask({
+      userId: "u1",
+      title: "准备上线",
+      sourceText: "准备上线",
+      dueAt: new Date("2026-03-12T10:00:00+08:00"),
+      reminderOffsetMinutes: null,
+      now: createdAt,
+    });
+    const reminderTask = store.createTask({
+      userId: "u1",
+      title: "客户会议",
+      sourceText: "客户会议",
+      dueAt: new Date("2026-03-12T12:30:00+08:00"),
+      reminderOffsetMinutes: 30,
+      now: createdAt,
+    });
+    const doneTask = store.createTask({
+      userId: "u1",
+      title: "写周报",
+      sourceText: "写周报",
+      dueAt: new Date("2026-03-12T11:00:00+08:00"),
+      reminderOffsetMinutes: null,
+      now: createdAt,
+    });
+    store.markTaskDone(doneTask.id, new Date("2026-03-12T11:05:00+08:00"));
+    const cancelledTask = store.createTask({
+      userId: "u1",
+      title: "取消预约",
+      sourceText: "取消预约",
+      dueAt: new Date("2026-03-13T09:00:00+08:00"),
+      reminderOffsetMinutes: null,
+      now: createdAt,
+    });
+    store.cancelTask(cancelledTask.id, new Date("2026-03-12T11:10:00+08:00"));
+
+    expect(store.dispatchDueReminders(new Date("2026-03-12T12:00:00+08:00"))).toBe(1);
+
+    expect(store.getStats("u1", new Date("2026-03-12T12:00:00+08:00"))).toMatchObject({
+      totalTasks: 4,
+      scheduledTasks: 2,
+      doneTasks: 1,
+      cancelledTasks: 1,
+      overdueTasks: 1,
+      todayTasks: 3,
+      todayDoneTasks: 1,
+      pendingReminders: 1,
+    });
+
+    store.markTaskDone(reminderTask.id, new Date("2026-03-12T12:10:00+08:00"));
+
+    expect(store.getStats("u1", new Date("2026-03-12T12:10:00+08:00")).pendingReminders).toBe(0);
+  });
+
+  it("uses the configured timezone for task scope boundaries and rendering", () => {
+    const store = createTimeZoneStore("America/Los_Angeles");
+    stores.push(store);
+
+    const now = new Date("2026-03-12T19:00:00.000Z");
+    store.createTask({
+      userId: "u1",
+      title: "本地昨天深夜",
+      sourceText: "昨天深夜",
+      dueAt: new Date("2026-03-12T06:30:00.000Z"),
+      reminderOffsetMinutes: null,
+      now,
+    });
+    store.createTask({
+      userId: "u1",
+      title: "本地今天凌晨",
+      sourceText: "今天凌晨",
+      dueAt: new Date("2026-03-12T07:30:00.000Z"),
+      reminderOffsetMinutes: null,
+      now,
+    });
+
+    const tasks = store.listTasks("u1", "today", now);
+    expect(tasks.map((task) => task.title)).toEqual(["本地今天凌晨"]);
+    expect(tasks[0]?.dueAtText).toBe("2026-03-12 00:30");
+  });
+});