agent-loft 0.2.30 → 0.2.31

package/src/core/tasks.ts

@@ -0,0 +1,281 @@
+// 定时任务：到点让 agent 按一段提示词干活，结果回到一条对话里；agent 自己判断要不要提醒用户。
+//
+// 和「定时发送」（scheduled.ts）的区别：那个是替用户把一条消息晚点发出去，一次性；这个可以周期运行，
+// 每次都带着「这是定时任务、没事就别打扰用户」的说明，结果按 agent 的判断决定推不推送。
+//
+// 按人隔离：每个任务记着主人（owner，用户 id），网页接口和 agent 的工具都只碰得到自己的。
+// 到点时还要再核对一次主人和对话（见 task-runner.ts）。这里只管存取和算时间，不依赖 hub。
+import crypto from "node:crypto";
+import path from "node:path";
+import { EventEmitter } from "node:events";
+import { dataDir, readJson, writeJsonAtomic } from "../home.js";
+import { describeSchedule, nextRun, normalizeSchedule, type TaskSchedule } from "./task-schedule.js";
+import type { ConversationMode } from "./types.js";
+
+/**
+ * 结果回到哪：
+ *   conv：一条已有的对话（agent 在对话里帮你建的，默认回到那条对话），模式 / agent / 目录都跟着那条对话；
+ *   dedicated：任务自己的对话，第一次运行时新建（key 记下来，之后续用），模式等按任务里的设置。
+ */
+export type TaskTarget = { kind: "conv"; key: string } | { kind: "dedicated"; key?: string };
+
+export type TaskRunStatus = "running" | "notified" | "silent" | "error" | "skipped" | "interrupted";
+
+export type TaskRun = {
+  id: string;
+  at: number;
+  endedAt?: number;
+  status: TaskRunStatus;
+  /** 跳过 / 出错的原因，或者「手动运行」 */
+  note?: string;
+  convKey?: string;
+  /** 回复开头一句，列表里显示 */
+  preview?: string;
+};
+
+export type Task = {
+  id: string;
+  owner: string;
+  title: string;
+  prompt: string;
+  schedule: TaskSchedule;
+  /** smart：只在需要时提醒（agent 判断）；always：每次都提醒 */
+  notify: "smart" | "always";
+  target: TaskTarget;
+  /** 专用对话的设置（target 是 conv 时不用，以那条对话为准） */
+  agent: string;
+  cwd?: string;
+  mode: ConversationMode;
+  model?: string;
+  effort?: string;
+  enabled: boolean;
+  createdAt: number;
+  updatedAt: number;
+  /** 谁建的：用户在页面上建的，还是 agent 在对话里建的 */
+  createdBy: "user" | "agent";
+  nextRunAt?: number;
+  /** 最近的在前 */
+  runs: TaskRun[];
+};
+
+/** 每人最多几个任务（暂停的也算） */
+export const TASKS_PER_USER = 30;
+const RUNS_KEPT = 20;
+export const PROMPT_MAX = 4000;
+export const TITLE_MAX = 60;
+
+export const taskEvents = new EventEmitter<{ changed: [owner: string] }>();
+
+const storePath = path.join(dataDir, "tasks.json");
+let cache: Task[] | null = null;
+
+function load(): Task[] {
+  cache ??= readJson<Task[]>(storePath, []).filter((t) => t && typeof t.id === "string" && typeof t.owner === "string" && t.schedule);
+  return cache;
+}
+
+function save(owner?: string): void {
+  writeJsonAtomic(storePath, load());
+  if (owner) taskEvents.emit("changed", owner);
+}
+
+export function resetTasksForTest(): void {
+  cache = null;
+}
+
+// ---------- 查询 ----------
+
+export function allTasks(): Task[] {
+  return load();
+}
+
+export function listTasks(owner: string): Task[] {
+  return load()
+    .filter((t) => t.owner === owner)
+    .sort((a, b) => b.createdAt - a.createdAt);
+}
+
+/** 只认主人：别人的任务一律当不存在 */
+export function getTask(owner: string, id: string): Task | undefined {
+  return load().find((t) => t.id === id && t.owner === owner);
+}
+
+export function findTask(id: string): Task | undefined {
+  return load().find((t) => t.id === id);
+}
+
+// ---------- 增删改 ----------
+
+export type TaskInput = {
+  title?: unknown;
+  prompt?: unknown;
+  schedule?: unknown;
+  notify?: unknown;
+  target?: unknown;
+  agent?: unknown;
+  cwd?: unknown;
+  mode?: unknown;
+  model?: unknown;
+  effort?: unknown;
+  enabled?: unknown;
+};
+
+const str = (v: unknown) => (typeof v === "string" ? v.trim() : "");
+
+function cleanTitle(v: unknown, prompt: string): string {
+  const t = str(v).replace(/\s+/g, " ");
+  return (t || prompt.replace(/\s+/g, " ")).slice(0, TITLE_MAX);
+}
+
+function cleanPrompt(v: unknown): string {
+  const p = str(v);
+  if (!p) throw new Error("要写清楚让 agent 做什么");
+  if (p.length > PROMPT_MAX) throw new Error(`提示词最多 ${PROMPT_MAX} 字`);
+  return p;
+}
+
+function cleanTarget(v: unknown, prev?: TaskTarget): TaskTarget {
+  const r = (v ?? {}) as Record<string, unknown>;
+  if (r.kind === "conv" && typeof r.key === "string" && r.key) return { kind: "conv", key: r.key };
+  // 改成专用对话时沿用之前那条专用对话
+  return prev?.kind === "dedicated" ? prev : { kind: "dedicated" };
+}
+
+export function createTask(owner: string, input: TaskInput, by: "user" | "agent", now = Date.now()): Task {
+  if (listTasks(owner).length >= TASKS_PER_USER) throw new Error(`每人最多 ${TASKS_PER_USER} 个定时任务，先删掉几个不用的`);
+  const prompt = cleanPrompt(input.prompt);
+  const schedule = normalizeSchedule(input.schedule, now);
+  const agent = str(input.agent) || "claude";
+  const task: Task = {
+    id: `t_${crypto.randomBytes(5).toString("hex")}`,
+    owner,
+    title: cleanTitle(input.title, prompt),
+    prompt,
+    schedule,
+    notify: input.notify === "always" ? "always" : "smart",
+    target: cleanTarget(input.target),
+    agent,
+    ...(str(input.cwd) ? { cwd: str(input.cwd) } : {}),
+    mode: input.mode === "work" ? "work" : "chat",
+    ...(str(input.model) ? { model: str(input.model) } : {}),
+    ...(str(input.effort) ? { effort: str(input.effort) } : {}),
+    enabled: input.enabled !== false,
+    createdAt: now,
+    updatedAt: now,
+    createdBy: by,
+    runs: [],
+  };
+  task.nextRunAt = task.enabled ? nextRun(schedule, now) : undefined;
+  load().push(task);
+  save(owner);
+  return task;
+}
+
+/** 只改给了的字段。改了频率或重新启用都重算下次时间 */
+export function updateTask(owner: string, id: string, patch: TaskInput, now = Date.now()): Task {
+  const task = getTask(owner, id);
+  if (!task) throw new Error("这个任务不存在");
+  const next: Task = { ...task };
+  if (patch.prompt !== undefined) next.prompt = cleanPrompt(patch.prompt);
+  if (patch.title !== undefined) next.title = cleanTitle(patch.title, next.prompt);
+  if (patch.schedule !== undefined) next.schedule = normalizeSchedule(patch.schedule, now);
+  if (patch.notify !== undefined) next.notify = patch.notify === "always" ? "always" : "smart";
+  if (patch.target !== undefined) next.target = cleanTarget(patch.target, task.target);
+  if (patch.agent !== undefined && str(patch.agent)) next.agent = str(patch.agent);
+  if (patch.cwd !== undefined) {
+    if (str(patch.cwd)) next.cwd = str(patch.cwd);
+    else delete next.cwd;
+  }
+  if (patch.mode !== undefined) next.mode = patch.mode === "work" ? "work" : "chat";
+  for (const k of ["model", "effort"] as const) {
+    if (patch[k] === undefined) continue;
+    if (str(patch[k])) next[k] = str(patch[k]);
+    else delete next[k];
+  }
+  if (patch.enabled !== undefined) next.enabled = patch.enabled !== false;
+  // 专用对话的 agent / 目录 / 模式变了：旧的那条对话对不上了，下次新开一条
+  if (
+    next.target.kind === "dedicated" &&
+    next.target.key &&
+    (next.agent !== task.agent || next.cwd !== task.cwd || next.mode !== task.mode)
+  ) {
+    next.target = { kind: "dedicated" };
+  }
+  next.updatedAt = now;
+  next.nextRunAt = next.enabled ? nextRun(next.schedule, now) : undefined;
+  // 「一次」的时间已经过了还要启用：没有下一次
+  if (next.enabled && next.nextRunAt === undefined) throw new Error("这个任务已经没有下一次运行时间了，改一下时间");
+  // 整个换成 next：Object.assign 不会删掉 next 里去掉了的字段（清空目录 / 模型时）
+  for (const k of Object.keys(task) as (keyof Task)[]) if (!(k in next) || next[k] === undefined) delete task[k];
+  Object.assign(task, next);
+  save(owner);
+  return task;
+}
+
+export function deleteTask(owner: string, id: string): Task | undefined {
+  const list = load();
+  const i = list.findIndex((t) => t.id === id && t.owner === owner);
+  if (i < 0) return undefined;
+  const [removed] = list.splice(i, 1);
+  save(owner);
+  return removed;
+}
+
+/** 删用户时：他的任务一起删掉，不转给管理员 */
+export function deleteUserTasks(owner: string): number {
+  const list = load();
+  const kept = list.filter((t) => t.owner !== owner);
+  const n = list.length - kept.length;
+  if (n === 0) return 0;
+  cache = kept;
+  save(owner);
+  return n;
+}
+
+// ---------- 运行记录（task-runner 用） ----------
+
+/** 暂停并说明原因（对话被删了、换了主人……） */
+export function pauseTask(task: Task, note: string, now = Date.now()): void {
+  task.enabled = false;
+  delete task.nextRunAt;
+  pushRun(task, { id: runId(), at: now, endedAt: now, status: "skipped", note });
+}
+
+export function runId(): string {
+  return `r_${crypto.randomBytes(4).toString("hex")}`;
+}
+
+/** 记一条运行（最新的在前，留最近 RUNS_KEPT 条）并落盘 */
+export function pushRun(task: Task, run: TaskRun): TaskRun {
+  task.runs = [run, ...task.runs.filter((r) => r.id !== run.id)].slice(0, RUNS_KEPT);
+  save(task.owner);
+  return run;
+}
+
+export function finishRun(taskId: string, id: string, patch: Partial<TaskRun>): Task | undefined {
+  const task = findTask(taskId);
+  const run = task?.runs.find((r) => r.id === id);
+  if (!task || !run) return undefined;
+  Object.assign(run, patch);
+  save(task.owner);
+  return task;
+}
+
+/** 到点了：算出再下一次（「一次」跑完就停用） */
+export function advance(task: Task, now = Date.now()): void {
+  task.nextRunAt = nextRun(task.schedule, now);
+  if (task.nextRunAt === undefined) task.enabled = false;
+  save(task.owner);
+}
+
+export function persistTask(task: Task): void {
+  save(task.owner);
+}
+
+// ---------- 给页面 / agent 看的 ----------
+
+export type TaskView = Task & { summary: string };
+
+export function viewOf(task: Task): TaskView {
+  return { ...task, summary: describeSchedule(task.schedule) };
+}

package/src/core/types.ts

@@ -188,6 +188,8 @@ export type SessionOptions = {
   };
   /** 模式换过、这个 agent 会话还不知道：换不了系统提示的 agent（Codex）要在第一条消息里说一声 */
   announceMode?: boolean;
+  /** 给 agent 定时任务工具（core/tasks-mcp.ts）：替谁、在哪条对话里管理。只有有主人的对话才给 */
+  tasks?: { userId: string; convKey: string };
 };
 
 export type ConversationMode = "chat" | "work";

package/src/main.ts

@@ -11,6 +11,8 @@ import { startWeb, stopWeb } from "./channels/web/server.js";
 import { home } from "./home.js";
 import { startMemoryCurator } from "./core/memory-curator.js";
 import { startScheduler, stopScheduler } from "./core/scheduled.js";
+import { startTaskRunner, stopTaskRunner } from "./core/task-runner.js";
+import { startTasksBridge, stopTasksBridge } from "./core/tasks-bridge.js";
 
 async function startDriver(id: "claude" | "codex"): Promise<void> {
   const driver = hub.driver(id);
@@ -52,6 +54,9 @@ async function main(): Promise<void> {
     hub.send(m.key, { text: m.text, attachments: [] }, { channel: "schedule", channelId: "schedule", name: "定时发送" });
     hub.emitEvent(m.key, { type: "meta" });
   });
+  // 定时任务：agent 用的工具通道先开，再开始按点运行（停机期间错过的补跑）
+  startTasksBridge();
+  startTaskRunner();
   // 先查一遍 agent 装没装、登没登录，网页打开时新对话里就只列出能用的
   void agentHealth().catch(() => {});
 
@@ -71,6 +76,9 @@ async function main(): Promise<void> {
     stopFeishu();
     await stopWeb();
     await hub.shutdown().catch(() => {});
+    // hub 收尾时会把正在跑的定时任务记成中断，所以放在它后面
+    stopTaskRunner();
+    stopTasksBridge();
     flushStore();
     process.exit(0);
   };

package/src/mcp/tasks-server.ts

@@ -0,0 +1,206 @@
+// 定时任务工具的 MCP 服务（stdio）：给 agent 用的 list / create / update / delete。
+//
+// 这里只是个传话的：每次调用原样转给主进程（core/tasks-bridge.ts，经 unix socket），带上拉起时
+// 定死的用户、对话和签名（见 core/tasks-mcp.ts）。校验、授权卡、真正的增删改都在主进程里做。
+//
+// 和记忆工具一样只实现 MCP 里用得到的那一小块；stdout 只能写协议消息，日志一律走 stderr。
+import net from "node:net";
+
+const socketPath = process.env.AGENT_LOFT_TASKS_SOCKET ?? "";
+const caller = {
+  user: process.env.AGENT_LOFT_TASKS_USER ?? "",
+  conv: process.env.AGENT_LOFT_TASKS_CONV ?? "",
+  sig: process.env.AGENT_LOFT_TASKS_SIG ?? "",
+};
+const tz = process.env.AGENT_LOFT_TZ || "服务端本地时区";
+
+type Request = { jsonrpc: "2.0"; id?: string | number | null; method: string; params?: Record<string, unknown> };
+
+const SCHEDULE = {
+  type: "object",
+  description:
+    `什么时候运行，时间一律按 ${tz} 解释。kind 选一种：` +
+    "once（一次：at 写「YYYY-MM-DD HH:MM」，或者 in_minutes 写多少分钟后）、" +
+    "daily（每天 time）、weekdays（工作日 time）、weekly（每周 days 的 time，days 里 0=周日…6=周六）、" +
+    "monthly（每月 day 日的 time）、hourly（每 every 小时一次，在第 minute 分）、cron（5 段 cron 表达式 expr）。" +
+    "time 写「HH:MM」。两次运行至少隔 15 分钟。",
+  properties: {
+    kind: { type: "string", enum: ["once", "daily", "weekdays", "weekly", "monthly", "hourly", "cron"] },
+    at: { type: "string", description: "once：运行时间，「YYYY-MM-DD HH:MM」" },
+    in_minutes: { type: "number", description: "once：多少分钟之后（和 at 二选一）" },
+    time: { type: "string", description: "daily / weekdays / weekly / monthly：几点，「HH:MM」" },
+    days: { type: "array", items: { type: "integer" }, description: "weekly：星期几，0=周日 … 6=周六" },
+    day: { type: "integer", description: "monthly：几号（1-31）" },
+    every: { type: "integer", description: "hourly：每几小时（1-23）" },
+    minute: { type: "integer", description: "hourly：第几分（0-59）" },
+    expr: { type: "string", description: "cron：分 时 日 月 周" },
+  },
+  required: ["kind"],
+  additionalProperties: false,
+};
+
+const TOOLS = [
+  {
+    name: "list_tasks",
+    description: "列出用户的定时任务（id、名称、频率、下次运行时间、最近一次结果），同时返回现在的时间。改、删任务之前先用它拿到 id。",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: { title: "查看定时任务", readOnlyHint: true, openWorldHint: false },
+  },
+  {
+    name: "create_task",
+    description:
+      "给用户建一个定时任务：到点 agent 会收到 prompt 并照着做，结果默认回到当前这条对话。用户说「每天 / 每周 / 明早 / 两小时后帮我……」时用。" +
+      "notify 默认 smart：每次运行时由 agent 自己判断有没有需要告诉用户的事，没有就不提醒（适合「有更新才告诉我」）；always：每次都提醒。" +
+      "prompt 要写成到点时独立可执行的完整指令（那时用户不在，不能再问他），需要对比时写清楚怎么判断（比如「和上次的结果比」「新版本号大于当前版本才算更新」）。" +
+      "调用后会弹授权卡给用户确认，确认了才会建。",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "简短的名称，比如「检查 agent-loft 更新」" },
+        prompt: { type: "string", description: "到点时发给 agent 的完整指令" },
+        schedule: SCHEDULE,
+        notify: { type: "string", enum: ["smart", "always"], description: "smart：有需要才提醒（默认）；always：每次都提醒" },
+        reply_to: {
+          type: "string",
+          enum: ["this_conversation", "dedicated"],
+          description: "this_conversation：结果回到当前对话（默认）；dedicated：给任务单独开一条对话（可以指定 mode）",
+        },
+        mode: { type: "string", enum: ["chat", "work"], description: "dedicated 时用：chat 只能联网搜索、开销小（默认）；work 能执行命令、读写本机文件" },
+      },
+      required: ["prompt", "schedule"],
+      additionalProperties: false,
+    },
+    annotations: { title: "新建定时任务", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+  },
+  {
+    name: "update_task",
+    description: "修改用户的一个定时任务：改名称、提示词、频率、提醒方式，或者暂停 / 恢复（enabled）。只给要改的字段。除了暂停以外的修改会弹授权卡让用户确认。",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "任务 id（list_tasks 里的），形如 t_1a2b3c4d5e" },
+        title: { type: "string" },
+        prompt: { type: "string" },
+        schedule: SCHEDULE,
+        notify: { type: "string", enum: ["smart", "always"] },
+        enabled: { type: "boolean", description: "false 暂停，true 恢复" },
+      },
+      required: ["id"],
+      additionalProperties: false,
+    },
+    annotations: { title: "修改定时任务", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+  },
+  {
+    name: "delete_task",
+    description: "删掉用户的一个定时任务（用户要求删除 / 取消时用；只是暂时不想运行的话用 update_task 暂停）。会弹授权卡让用户确认。",
+    inputSchema: {
+      type: "object",
+      properties: { id: { type: "string", description: "任务 id" } },
+      required: ["id"],
+      additionalProperties: false,
+    },
+    annotations: { title: "删除定时任务", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+  },
+];
+
+function text(t: string, isError = false) {
+  return { content: [{ type: "text", text: t }], ...(isError ? { isError: true } : {}) };
+}
+
+/** 转给主进程，等它回一行 JSON */
+function forward(tool: string, args: Record<string, unknown>): Promise<{ text: string; isError?: boolean }> {
+  return new Promise((resolve) => {
+    if (!socketPath || !caller.user || !caller.conv) {
+      resolve({ text: "定时任务工具没有正确配置（缺少用户或对话）。", isError: true });
+      return;
+    }
+    const sock = net.createConnection(socketPath);
+    let buf = "";
+    let done = false;
+    const finish = (r: { text: string; isError?: boolean }) => {
+      if (done) return;
+      done = true;
+      sock.destroy();
+      resolve(r);
+    };
+    sock.setEncoding("utf8");
+    sock.on("connect", () => sock.write(`${JSON.stringify({ ...caller, tool, args })}\n`));
+    sock.on("data", (chunk: string) => {
+      buf += chunk;
+      const n = buf.indexOf("\n");
+      if (n < 0) return;
+      try {
+        const res = JSON.parse(buf.slice(0, n)) as { text?: string; isError?: boolean };
+        finish({ text: String(res.text ?? ""), ...(res.isError ? { isError: true } : {}) });
+      } catch {
+        finish({ text: "agent-loft 返回的内容看不懂。", isError: true });
+      }
+    });
+    sock.on("error", (err) => finish({ text: `连不上 agent-loft（${err.message}）。它可能刚重启过，开个新会话再试。`, isError: true }));
+    sock.on("close", () => finish({ text: "agent-loft 断开了连接。", isError: true }));
+  });
+}
+
+async function handle(req: Request): Promise<unknown> {
+  switch (req.method) {
+    case "initialize":
+      return {
+        protocolVersion: typeof req.params?.protocolVersion === "string" ? req.params.protocolVersion : "2025-06-18",
+        capabilities: { tools: {} },
+        serverInfo: { name: "agent-loft-tasks", version: "1.0.0" },
+      };
+    case "ping":
+      return {};
+    case "tools/list":
+      return { tools: TOOLS };
+    case "tools/call": {
+      const params = req.params ?? {};
+      const name = String(params.name ?? "");
+      if (!TOOLS.some((t) => t.name === name)) return text(`没有工具 ${name}`, true);
+      const res = await forward(name, (params.arguments as Record<string, unknown> | undefined) ?? {});
+      return text(res.text, !!res.isError);
+    }
+    default:
+      throw Object.assign(new Error(`不支持 ${req.method}`), { code: -32601 });
+  }
+}
+
+function reply(message: unknown): void {
+  process.stdout.write(`${JSON.stringify(message)}\n`);
+}
+
+function onLine(line: string): void {
+  if (!line.trim()) return;
+  let req: Request;
+  try {
+    req = JSON.parse(line) as Request;
+  } catch {
+    reply({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "JSON 解析失败" } });
+    return;
+  }
+  const isRequest = req.id !== undefined && req.id !== null;
+  // 不按顺序等：一个调用在等授权卡的时候，ping 之类照样要回
+  handle(req).then(
+    (result) => {
+      if (isRequest) reply({ jsonrpc: "2.0", id: req.id, result });
+    },
+    (err) => {
+      if (!isRequest) return;
+      const code = (err as { code?: number }).code ?? -32603;
+      reply({ jsonrpc: "2.0", id: req.id, error: { code, message: err instanceof Error ? err.message : String(err) } });
+    },
+  );
+}
+
+let buf = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk: string) => {
+  buf += chunk;
+  let n: number;
+  while ((n = buf.indexOf("\n")) >= 0) {
+    const line = buf.slice(0, n);
+    buf = buf.slice(n + 1);
+    onLine(line);
+  }
+});
+process.stdin.on("end", () => process.exit(0));