@kevin5251984/guild 0.2.20 → 0.2.22

package/src/router.ts

@@ -1,5 +1,6 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import type { IncomingMessage, ServerResponse } from "node:http";
+import { extname } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { LibraryKind, ModelRef, ModelsFile } from "@guild/protocol";
 import {
@@ -24,6 +25,8 @@ import {
   getBotDetail,
   getLiveTurn,
   abortLiveTurn,
+  pauseLiveTurn,
+  continueLiveTurn,
   healthPayload,
   importSkills,
   mergeModelsFile,
@@ -64,6 +67,30 @@ import { hostGit, hostList, hostRead, hostTree } from "./host-browse.ts";
 import { listHostSkills } from "./host-skills.ts";
 import { listHostAgents } from "./host-agents.ts";
 import { generatedDir, isSafeGeneratedName } from "./image-gen.ts";
+import {
+  createCronJob,
+  fireCronJob,
+  pauseCronJob,
+  publicCronJob,
+  removeCronJob,
+  resumeCronJob,
+} from "./cron.ts";
+import {
+  allowedWorkspaceWritePath,
+  resolveToolPath,
+  workspaceFromEnv,
+} from "./harness.ts";
+
+const LOCAL_IMAGE_CAP = 12 * 1024 * 1024;
+
+function localImageType(path: string): string | null {
+  const ext = extname(path).toLowerCase();
+  if (ext === ".png") return "image/png";
+  if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
+  if (ext === ".gif") return "image/gif";
+  if (ext === ".webp") return "image/webp";
+  return null;
+}
 
 const PUBLIC = fileURLToPath(new URL("./public/", import.meta.url));
 
@@ -271,7 +298,8 @@ function modelRefFrom(value: unknown): ModelRef | null {
   const provider = str(rec, "provider").trim();
   const model = str(rec, "model").trim();
   if (!provider || !model) return null;
-  return { provider, model };
+  const reasoning = str(rec, "reasoning").trim();
+  return reasoning ? { provider, model, reasoning } : { provider, model };
 }
 
 function strList(record: Record<string, unknown>, key: string): string[] {
@@ -388,6 +416,38 @@ export async function handleRequest(
       return;
     }
 
+    if (method === "GET" && path === "/local") {
+      const raw = requestUrl(req).searchParams.get("p") || "";
+      const type = localImageType(raw);
+      if (!raw.startsWith("/") || raw.includes("\0") || raw.includes("..") || !type) {
+        json(res, 404, { error: "not_found", path });
+        return;
+      }
+      const target = resolveToolPath(raw);
+      if (!allowedWorkspaceWritePath(target, workspaceFromEnv(env), store.dataDir)) {
+        json(res, 404, { error: "not_found", path });
+        return;
+      }
+      if (!existsSync(target)) {
+        json(res, 404, { error: "not_found", path });
+        return;
+      }
+      const st = statSync(target);
+      if (!st.isFile() || st.size > LOCAL_IMAGE_CAP) {
+        json(res, 404, { error: "not_found", path });
+        return;
+      }
+      const bytes = readFileSync(target);
+      res.writeHead(200, {
+        "content-type": type,
+        "content-length": bytes.length,
+        "cache-control": "private, max-age=60",
+        "x-content-type-options": "nosniff",
+      });
+      res.end(bytes);
+      return;
+    }
+
     if (method === "GET" && path.startsWith("/generated/")) {
       const name = decodeURIComponent(path.slice("/generated/".length));
       if (!isSafeGeneratedName(name)) {
@@ -441,6 +501,45 @@ export async function handleRequest(
       return;
     }
 
+    if (path === "/cron" && method === "GET") {
+      const room = requestUrl(req).searchParams.get("room") || "";
+      json(res, 200, {
+        jobs: store.listCronJobs(room || undefined).map(publicCronJob),
+      });
+      return;
+    }
+    if (path === "/cron" && method === "POST") {
+      const body = asRecord(await readJson(req));
+      const job = createCronJob(store, {
+        roomId: str(body, "roomId") || str(body, "room_id"),
+        botId: str(body, "botId") || str(body, "bot_id"),
+        prompt: str(body, "prompt"),
+        schedule: str(body, "schedule"),
+        name: str(body, "name"),
+      });
+      json(res, 201, publicCronJob(job));
+      return;
+    }
+    const cronAct = path.match(/^\/cron\/([^/]+)\/(pause|resume|run)$/);
+    if (cronAct && method === "POST") {
+      const id = decodeURIComponent(cronAct[1]);
+      if (cronAct[2] === "pause") {
+        json(res, 200, publicCronJob(pauseCronJob(store, id)));
+        return;
+      }
+      if (cronAct[2] === "resume") {
+        json(res, 200, publicCronJob(resumeCronJob(store, id)));
+        return;
+      }
+      json(res, 200, await fireCronJob(store, id, env));
+      return;
+    }
+    const cronOne = path.match(/^\/cron\/([^/]+)$/);
+    if (cronOne && method === "DELETE") {
+      json(res, 200, removeCronJob(store, decodeURIComponent(cronOne[1])));
+      return;
+    }
+
     if (method === "GET" && (path === "/bots" || path === "/bench")) {
       json(res, 200, listBench(store));
       return;
@@ -709,6 +808,66 @@ export async function handleRequest(
       return;
     }
 
+    const channelPause = path.match(/^\/channels\/([^/]+)\/pause$/);
+    if (channelPause && method === "POST") {
+      const body = asRecord(await readJson(req));
+      json(
+        res,
+        200,
+        pauseLiveTurn(
+          store,
+          decodeURIComponent(channelPause[1]),
+          str(body, "botId") || undefined,
+        ),
+      );
+      return;
+    }
+    const dmPause = path.match(/^\/dms\/([^/]+)\/pause$/);
+    if (dmPause && method === "POST") {
+      const room = openDm(store, decodeURIComponent(dmPause[1]));
+      const body = asRecord(await readJson(req));
+      json(
+        res,
+        200,
+        pauseLiveTurn(store, room.id, str(body, "botId") || undefined),
+      );
+      return;
+    }
+
+    const channelContinue = path.match(/^\/channels\/([^/]+)\/continue$/);
+    if (channelContinue && method === "POST") {
+      const body = asRecord(await readJson(req));
+      json(
+        res,
+        200,
+        await continueLiveTurn(
+          store,
+          decodeURIComponent(channelContinue[1]),
+          str(body, "botId"),
+          env,
+          extras,
+        ),
+      );
+      return;
+    }
+    const dmContinue = path.match(/^\/dms\/([^/]+)\/continue$/);
+    if (dmContinue && method === "POST") {
+      const room = openDm(store, decodeURIComponent(dmContinue[1]));
+      const body = asRecord(await readJson(req));
+      json(
+        res,
+        200,
+        await continueLiveTurn(
+          store,
+          room.id,
+          str(body, "botId"),
+          env,
+          extras,
+        ),
+      );
+      return;
+    }
+
     const channelSteer = path.match(/^\/channels\/([^/]+)\/steer$/);
     if (channelSteer && method === "POST") {
       const body = asRecord(await readJson(req));

package/src/store.ts

@@ -10,7 +10,7 @@ import type { TrajectoryDraft, TrajectoryEvent } from "./trajectory.ts";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
-import { closeGuildDb, openGuildDb, type GuildDb } from "./db.ts";
+import { closeGuildDb, openGuildDb, type CronJobRow, type GuildDb } from "./db.ts";
 import type {
   Bot,
   ChatAttachment,
@@ -101,6 +101,9 @@ export type LiveTurn = {
   startedAt?: string;
   /** Full-ish tool history for Trajectory. Stripped from GET /live. */
   traces?: LiveTrace[];
+  /** Seat assignment text, kept so Continue can resume after Pause. */
+  asked?: string;
+  paused?: boolean;
 };
 
 export class GuildStore {
@@ -366,7 +369,6 @@ export class GuildStore {
   beginTurn(roomId: string, botIds: string[] = [""]): AbortSignal {
     const controller = new AbortController();
     const ids = botIds.length ? botIds : [""];
-    for (const botId of ids) this.bindBotAbort(roomId, botId, controller);
     this.turnGroups.set(controller.signal, {
       roomId,
       botIds: new Set(ids),
@@ -375,43 +377,54 @@ export class GuildStore {
     return controller.signal;
   }
 
+  /**
+   * Per-seat AbortController, child of the turn group. Pause/Stop one bot
+   * without taking the rest of the wave down.
+   */
+  armBotTurn(roomId: string, botId: string, parent: AbortSignal): AbortSignal {
+    const controller = new AbortController();
+    const onParent = () => {
+      if (!controller.signal.aborted) controller.abort();
+    };
+    if (parent.aborted) onParent();
+    else parent.addEventListener("abort", onParent, { once: true });
+    this.bindBotAbort(roomId, botId, controller);
+    const group = this.turnGroups.get(parent);
+    if (group && group.roomId === roomId) group.botIds.add(botId);
+    return controller.signal;
+  }
+
   adoptTurn(roomId: string, botId: string, signal: AbortSignal): void {
     const group = this.turnGroups.get(signal);
     if (!group || group.roomId !== roomId) return;
-    this.bindBotAbort(roomId, botId, group.controller);
     group.botIds.add(botId);
   }
 
+  private dropBotLive(roomId: string, botId: string): boolean {
+    const live = this.liveTurns.get(roomId);
+    const steers = this.pendingSteers.get(roomId);
+    const room = this.botAborts.get(roomId);
+    const hadLive = Boolean(live?.delete(botId));
+    steers?.delete(botId);
+    room?.delete(botId);
+    if (live && live.size === 0) this.liveTurns.delete(roomId);
+    if (steers && steers.size === 0) this.pendingSteers.delete(roomId);
+    if (room && room.size === 0) this.botAborts.delete(roomId);
+    for (const [sig, group] of this.turnGroups) {
+      if (group.roomId !== roomId || !group.botIds.has(botId)) continue;
+      group.botIds.delete(botId);
+      if (group.botIds.size === 0) this.turnGroups.delete(sig);
+    }
+    return hadLive;
+  }
+
   abortTurn(roomId: string, botId?: string): boolean {
     if (botId) {
-      const room = this.botAborts.get(roomId);
-      const controller = room?.get(botId);
-      if (!controller) {
-        const live = this.liveTurns.get(roomId);
-        const steers = this.pendingSteers.get(roomId);
-        const hadLive = Boolean(live?.delete(botId));
-        steers?.delete(botId);
-        if (live && live.size === 0) this.liveTurns.delete(roomId);
-        if (steers && steers.size === 0) this.pendingSteers.delete(roomId);
-        this.spillTrajectoryIfIdle(roomId);
-        return hadLive;
-      }
-      const group = this.turnGroups.get(controller.signal);
-      const ids = group ? [...group.botIds] : [botId];
-      this.turnGroups.delete(controller.signal);
-      const live = this.liveTurns.get(roomId);
-      const steers = this.pendingSteers.get(roomId);
-      for (const id of ids) {
-        room?.delete(id);
-        live?.delete(id);
-        steers?.delete(id);
-      }
-      if (room && room.size === 0) this.botAborts.delete(roomId);
-      if (live && live.size === 0) this.liveTurns.delete(roomId);
-      if (steers && steers.size === 0) this.pendingSteers.delete(roomId);
-      if (!controller.signal.aborted) controller.abort();
+      const controller = this.botAborts.get(roomId)?.get(botId);
+      const hadLive = this.dropBotLive(roomId, botId);
+      if (controller && !controller.signal.aborted) controller.abort();
       this.spillTrajectoryIfIdle(roomId);
-      return true;
+      return hadLive || Boolean(controller);
     }
     const room = this.botAborts.get(roomId);
     this.botAborts.delete(roomId);
@@ -419,10 +432,18 @@ export class GuildStore {
     this.pendingSteers.delete(roomId);
     let aborted = false;
     const seen = new Set<AbortController>();
+    for (const [sig, group] of [...this.turnGroups]) {
+      if (group.roomId !== roomId) continue;
+      this.turnGroups.delete(sig);
+      if (!group.controller.signal.aborted) {
+        group.controller.abort();
+        aborted = true;
+      }
+      seen.add(group.controller);
+    }
     for (const controller of room?.values() ?? []) {
       if (seen.has(controller)) continue;
       seen.add(controller);
-      this.turnGroups.delete(controller.signal);
       if (!controller.signal.aborted) {
         controller.abort();
         aborted = true;
@@ -432,6 +453,37 @@ export class GuildStore {
     return aborted || Boolean(room);
   }
 
+  pauseTurn(roomId: string, botId?: string): boolean {
+    const ids = botId
+      ? [botId]
+      : [...(this.liveTurns.get(roomId)?.keys() ?? [])];
+    let any = false;
+    for (const id of ids) {
+      if (!id) continue;
+      const live = this.getLiveBotTurn(roomId, id);
+      if (!live) continue;
+      const traces = (live.traces || []).map((tr) =>
+        tr.running ? { ...tr, running: false, text: tr.text || "paused" } : tr,
+      );
+      const steps = (live.steps || []).map((step) =>
+        step.running ? { ...step, running: false } : step,
+      );
+      this.setLiveTurn(roomId, {
+        ...live,
+        traces,
+        steps,
+        paused: true,
+      });
+      const controller = this.botAborts.get(roomId)?.get(id);
+      this.botAborts.get(roomId)?.delete(id);
+      const room = this.botAborts.get(roomId);
+      if (room && room.size === 0) this.botAborts.delete(roomId);
+      if (controller && !controller.signal.aborted) controller.abort();
+      any = true;
+    }
+    return any;
+  }
+
   endTurn(roomId: string, signal?: AbortSignal): void {
     const group = signal ? this.turnGroups.get(signal) : undefined;
     if (group) {
@@ -440,7 +492,11 @@ export class GuildStore {
       const live = this.liveTurns.get(roomId);
       const steers = this.pendingSteers.get(roomId);
       for (const botId of group.botIds) {
-        if (room?.get(botId) === group.controller) room.delete(botId);
+        if (live?.get(botId)?.paused) {
+          room?.delete(botId);
+          continue;
+        }
+        room?.delete(botId);
         live?.delete(botId);
         steers?.delete(botId);
       }
@@ -449,8 +505,14 @@ export class GuildStore {
       if (steers && steers.size === 0) this.pendingSteers.delete(roomId);
       if (!group.controller.signal.aborted) group.controller.abort();
     } else {
+      const live = this.liveTurns.get(roomId);
+      const kept = new Map<string, LiveTurn>();
+      for (const [id, turn] of live ?? []) {
+        if (turn.paused) kept.set(id, turn);
+      }
       this.botAborts.delete(roomId);
-      this.clearLiveTurn(roomId);
+      if (kept.size) this.liveTurns.set(roomId, kept);
+      else this.clearLiveTurn(roomId);
     }
     this.spillTrajectoryIfIdle(roomId);
   }
@@ -1267,6 +1329,27 @@ export class GuildStore {
     if (!this.getRoom(roomId)) throw new StoreError(404, "room not found");
     this.db.writeCompact(roomId, compact);
   }
+
+  listCronJobs(roomId?: string) {
+    if (roomId && !this.getRoom(roomId)) throw new StoreError(404, "room not found");
+    return this.db.listCronJobs(roomId);
+  }
+
+  getCronJob(id: string) {
+    const job = this.db.getCronJob(id);
+    if (!job) throw new StoreError(404, "cron job not found");
+    return job;
+  }
+
+  writeCronJob(job: CronJobRow): void {
+    if (!this.getRoom(job.roomId)) throw new StoreError(404, "room not found");
+    if (!this.getBot(job.botId)) throw new StoreError(400, "bot not found");
+    this.db.upsertCronJob(job);
+  }
+
+  deleteCronJob(id: string): boolean {
+    return this.db.deleteCronJob(id);
+  }
 }
 
 function normalizePortrait(raw: string | null | undefined): string | undefined {

package/src/subagent.ts

@@ -373,6 +373,9 @@ export async function spawnSubagent(input: {
       allowWrite: child.allowWrite,
       sandbox: child.sandbox,
       workspace: input.ctx.workspace,
+      roomId: input.ctx.roomId,
+      botId: input.ctx.botId,
+      cronRun: input.ctx.cronRun,
       dispatch: input.ctx.dispatch,
       signal: input.ctx.signal,
     },

package/src/tools.ts

@@ -78,6 +78,12 @@ export type ToolContext = {
   ) => Promise<ToolOutcome>;
   /** Devin-style background spawn handles for this turn. Same Map across dispatch clones. */
   spawnHandles?: Map<string, SpawnHandle>;
+  /** Channel or DM this turn is in. Cron jobs default here. */
+  roomId?: string;
+  /** Seat running this turn. cronjob create defaults here. */
+  botId?: string;
+  /** Hermes: cron child sessions cannot manage cron. */
+  cronRun?: boolean;
 };
 
 export type SpawnHandle = {
@@ -191,6 +197,33 @@ export function guildTools(
       (tool) => tool.name !== "image_gen" && tool.name !== "browser",
     );
   }
+  if (!ctx.cronRun) {
+    tools.push({
+      name: "cronjob",
+      description:
+        "Schedule a later hall turn (Hermes cronjob). Fresh @handle turn with a self-contained prompt. Actions: create, list, pause, resume, run, remove. schedule may be natural language (每10分鐘, 10分鐘後, 每天9點, in 30 minutes, every 2h, 0 9 * * *, ISO). Split when vs task: schedule is the time phrase, prompt is the work. bot_id defaults to this seat. Do not create cron jobs from a cron run.",
+      parameters: Type.Object({
+        action: Type.String({
+          description: "create | list | pause | resume | run | remove",
+        }),
+        schedule: Type.Optional(
+          Type.String({
+            description:
+              "Natural language or Hermes form: 每10分鐘, in 30m, every 2h, 每天9點, 0 9 * * *, ISO",
+          }),
+        ),
+        prompt: Type.Optional(
+          Type.String({ description: "Self-contained task for the seat" }),
+        ),
+        name: Type.Optional(Type.String({ description: "Short job name" })),
+        job_id: Type.Optional(Type.String({ description: "Job id or name" })),
+        bot_id: Type.Optional(Type.String({ description: "Seat to run" })),
+        room_id: Type.Optional(
+          Type.String({ description: "Room id. Defaults to this hall." }),
+        ),
+      }),
+    });
+  }
   tools.push({
     name: "skill",
     description: `Load a staffed skill's full instructions by name.${available}`,
@@ -387,6 +420,21 @@ function openaiParameters(name: string): {
       required: ["prompt"],
     };
   }
+  if (name === "cronjob") {
+    return {
+      type: "object",
+      properties: {
+        action: { type: "string", description: "create | list | pause | resume | run | remove" },
+        schedule: { type: "string" },
+        prompt: { type: "string" },
+        name: { type: "string" },
+        job_id: { type: "string" },
+        bot_id: { type: "string" },
+        room_id: { type: "string" },
+      },
+      required: ["action"],
+    };
+  }
   if (name === "browser") {
     return {
       type: "object",
@@ -437,6 +485,7 @@ export const BUILTIN_TOOL_NAMES = [
   "read_spawn",
   "image_gen",
   "browser",
+  "cronjob",
 ] as const;
 
 export async function executeTool(
@@ -512,6 +561,12 @@ export async function builtinExecute(
         env: ctx.env,
       });
     }
+    if (name === "cronjob") {
+      return {
+        text: "cronjob needs guildd (the cron plugin)",
+        isError: true,
+      };
+    }
     if (name === "browser") {
       const { runBrowser } = await import("./browser.ts");
       return runBrowser(args, {
@@ -817,7 +872,7 @@ export function nextToolRound(round: number): ToolRoundPhase {
 }
 
 export const TOOL_SYSTEM = `You ARE already running on the user's local computer (Guild, same design as Pi / DeepSeek Harness).
-Tools: run, read, write, list, skill, spawn, image_gen, browser, plus any connected MCP tools (names start with mcp__).
+Tools: run, read, write, list, skill, spawn, image_gen, browser, cronjob, plus any connected MCP tools (names start with mcp__).
 You can inspect RAM, disk, CPU, processes, files, and run shell commands.
 Never say you cannot access this machine. Never tell the user to run the command themselves.
 When the question is about this computer, call tools first, then answer with evidence from the output.
@@ -827,4 +882,5 @@ You stay coordinator. Spawn is the specialist, not a last resort (Devin run_suba
 Independent tool calls in one round also run in parallel — fire several reads/searches together.
 Check the [exit code: N] marker on every run result; investigate failures before moving on. Prefer the workdir argument over cd.
 To follow a staffed skill, call skill with its exact name (or slug) before applying it. Relative paths in a skill resolve against that skill's base directory.
+When the user asks to 排程 / schedule a later hall turn — including natural-language times like 每10分鐘, 10分鐘後, tomorrow 9am — call cronjob create. schedule is the time phrase; prompt is the self-contained task (the job will not see this live turn). bot_id defaults to you. Also accepts in 30m, every 2h, 0 9 * * *, ISO. A cron run cannot create more cron jobs.
 Prefer small commands. macOS RAM: sysctl hw.memsize ; memory_pressure. Disk: df -h.`;

package/vendor/protocol/src/index.ts

@@ -6,7 +6,12 @@ export type HealthResponse = {
 
 export type BotStatus = "bench" | "staffed" | "running" | "retired";
 
-export type ModelRef = { provider: string; model: string };
+export type ModelRef = {
+  provider: string;
+  model: string;
+  /** Seat-specific effort. Missing → that model's catalog default. */
+  reasoning?: string;
+};
 
 export type LibraryKind =
   | "souls"
@@ -169,7 +174,7 @@ export type AuxRole =
 
 export type ModelsFile = {
   default?: ModelRef | null;
-  /** Last chosen effort string (catalog-defined: low, high, xhigh, …). */
+  /** Guild-default effort when a seat has no `model.reasoning`. */
   reasoning?: string;
   fast?: boolean;
   aux?: Partial<Record<AuxRole, ModelRef | null>>;