@csdwd/ai-teams-server 0.1.5 → 0.3.0

package/dist/index.js

@@ -2,8 +2,9 @@
 
 // src/index.ts
 import os from "node:os";
-import path from "node:path";
-import fs from "node:fs";
+import path2 from "node:path";
+import fs2 from "node:fs";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import Fastify from "fastify";
 import swagger from "@fastify/swagger";
@@ -230,6 +231,171 @@ function parseEncryptionKey(hex) {
   return key;
 }
 
+// ../../packages/shared/dist/daemon.js
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+function readPidFile(pidFile) {
+  try {
+    const content = fs.readFileSync(pidFile, "utf-8").trim();
+    const pid = Number(content);
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function writePidFile(pidFile, pid) {
+  fs.mkdirSync(path.dirname(pidFile), { recursive: true });
+  fs.writeFileSync(pidFile, String(pid), "utf-8");
+}
+function removePidFile(pidFile) {
+  try {
+    fs.unlinkSync(pidFile);
+  } catch {
+  }
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function spawnWorker(script, args, logDir) {
+  fs.mkdirSync(logDir, { recursive: true });
+  const logFile = path.join(logDir, "worker.log");
+  const logStream = fs.openSync(logFile, "a");
+  const child = spawn(process.execPath, [script, ...args], {
+    stdio: ["ignore", logStream, logStream],
+    env: {
+      ...process.env,
+      __AI_TEAMS_DAEMON_WORKER: "1",
+      __AI_TEAMS_DAEMON_WATCHDOG: void 0
+    }
+  });
+  fs.closeSync(logStream);
+  return child;
+}
+var MAX_RESTARTS_PER_MINUTE = 10;
+var RESTART_DELAY_MS = 3e3;
+async function runWatchdog(opts) {
+  const { name, pidFile, logDir, workerScript, workerArgs } = opts;
+  writePidFile(pidFile, process.pid);
+  let restartTimestamps = [];
+  function cleanupAndExit(code) {
+    removePidFile(pidFile);
+    process.exit(code);
+  }
+  let worker = null;
+  let shuttingDown = false;
+  function shutdown() {
+    if (shuttingDown)
+      return;
+    shuttingDown = true;
+    if (worker)
+      worker.kill("SIGTERM");
+  }
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+  while (!shuttingDown) {
+    await new Promise((resolve) => {
+      worker = spawnWorker(workerScript, workerArgs, logDir);
+      worker.on("exit", (code, signal) => {
+        worker = null;
+        if (shuttingDown) {
+          cleanupAndExit(0);
+        }
+        if (code === 0) {
+          console.log(`${name}: worker exited cleanly, daemon stopping.`);
+          cleanupAndExit(0);
+        }
+        const now = Date.now();
+        restartTimestamps = restartTimestamps.filter((t) => now - t < 6e4);
+        restartTimestamps.push(now);
+        if (restartTimestamps.length > MAX_RESTARTS_PER_MINUTE) {
+          console.error(`${name}: exceeded ${MAX_RESTARTS_PER_MINUTE} restarts/minute, daemon stopping.`);
+          cleanupAndExit(1);
+        }
+        console.log(`${name}: worker crashed (code=${code}, signal=${signal}), restarting in ${RESTART_DELAY_MS}ms...`);
+        setTimeout(resolve, RESTART_DELAY_MS);
+      });
+    });
+  }
+  cleanupAndExit(0);
+}
+function getDaemonStatus(pidFile) {
+  const pid = readPidFile(pidFile);
+  if (pid === null) {
+    return { running: false, pid: null };
+  }
+  if (isProcessRunning(pid)) {
+    return { running: true, pid };
+  }
+  removePidFile(pidFile);
+  return { running: false, pid: null };
+}
+async function stopDaemon(pidFile) {
+  const pid = readPidFile(pidFile);
+  if (pid === null) {
+    console.log("Not running (no PID file found).");
+    return;
+  }
+  if (!isProcessRunning(pid)) {
+    removePidFile(pidFile);
+    console.log("Not running (stale PID file cleaned).");
+    return;
+  }
+  process.kill(pid, "SIGTERM");
+  for (let i = 0; i < 20; i++) {
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    if (!isProcessRunning(pid)) {
+      removePidFile(pidFile);
+      console.log(`Stopped (PID ${pid}).`);
+      return;
+    }
+  }
+  process.kill(pid, "SIGKILL");
+  removePidFile(pidFile);
+  console.log(`Force killed (PID ${pid}).`);
+}
+function daemonize(opts) {
+  if (process.env.__AI_TEAMS_DAEMON_WORKER === "1") {
+    return opts.run();
+  }
+  if (process.env.__AI_TEAMS_DAEMON_WATCHDOG === "1") {
+    return runWatchdog({
+      name: opts.name,
+      pidFile: opts.pidFile,
+      logDir: path.dirname(opts.logFile),
+      workerScript: process.argv[1],
+      workerArgs: process.argv.slice(2)
+    });
+  }
+  fs.mkdirSync(path.dirname(opts.logFile), { recursive: true });
+  const child = spawn(process.execPath, [process.argv[1], ...process.argv.slice(2)], {
+    detached: true,
+    stdio: ["ignore", "ignore", "ignore"],
+    env: {
+      ...process.env,
+      __AI_TEAMS_DAEMON_WATCHDOG: "1"
+    }
+  });
+  child.unref();
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      const pid = readPidFile(opts.pidFile);
+      if (pid) {
+        console.log(`${opts.name} started (PID ${pid})`);
+      } else {
+        console.error(`${opts.name}: failed to start \u2014 PID file not found.`);
+      }
+      resolve();
+      process.exit(pid ? 0 : 1);
+    }, 500);
+  });
+}
+
 // src/db.ts
 import { DatabaseSync } from "node:sqlite";
 import pg from "pg";
@@ -373,6 +539,25 @@ async function initDb(db) {
       webhook_url  TEXT NOT NULL
     )
   `);
+  await db.run(`
+    CREATE TABLE IF NOT EXISTS schedules (
+      id              TEXT PRIMARY KEY,
+      name            TEXT NOT NULL,
+      cron_expr       TEXT NOT NULL,
+      enabled         INTEGER NOT NULL DEFAULT 1,
+      target_mode     TEXT NOT NULL DEFAULT 'queue',
+      target_agents   TEXT NOT NULL DEFAULT '[]',
+      prompt          TEXT NOT NULL,
+      workspace       TEXT,
+      timeout_sec     INTEGER,
+      priority        INTEGER NOT NULL DEFAULT 0,
+      required_labels TEXT DEFAULT '[]',
+      last_run_at     TEXT,
+      next_run_at     TEXT,
+      created_at      TEXT NOT NULL,
+      updated_at      TEXT NOT NULL
+    )
+  `);
 }
 async function hydrateState(db, state, defaultTimeoutSec, maxLogChunksPerTask) {
   const employeeRows = await db.all("SELECT payload_json FROM employees");
@@ -609,6 +794,90 @@ function taskToDbValues(task) {
 function toSnakeCase(str) {
   return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 }
+var SCHEDULE_COLUMNS = [
+  "id",
+  "name",
+  "cron_expr",
+  "enabled",
+  "target_mode",
+  "target_agents",
+  "prompt",
+  "workspace",
+  "timeout_sec",
+  "priority",
+  "required_labels",
+  "last_run_at",
+  "next_run_at",
+  "created_at",
+  "updated_at"
+];
+var SCHEDULE_PLACEHOLDERS = SCHEDULE_COLUMNS.map((_, i) => `$${i + 1}`).join(", ");
+var SCHEDULE_UPDATE_SET = SCHEDULE_COLUMNS.slice(1).map((col) => `${col} = excluded.${col}`).join(", ");
+function dbRowToSchedule(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    cronExpr: row.cron_expr,
+    enabled: row.enabled === 1,
+    targetMode: row.target_mode,
+    targetAgents: JSON.parse(row.target_agents || "[]"),
+    prompt: row.prompt,
+    workspace: row.workspace,
+    timeoutSec: row.timeout_sec,
+    priority: row.priority,
+    requiredLabels: row.required_labels ? JSON.parse(row.required_labels) : null,
+    lastRunAt: row.last_run_at,
+    nextRunAt: row.next_run_at,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function scheduleToDbValues(s) {
+  return [
+    s.id,
+    s.name,
+    s.cronExpr,
+    s.enabled ? 1 : 0,
+    s.targetMode,
+    JSON.stringify(s.targetAgents),
+    s.prompt,
+    s.workspace,
+    s.timeoutSec,
+    s.priority,
+    s.requiredLabels ? JSON.stringify(s.requiredLabels) : null,
+    s.lastRunAt,
+    s.nextRunAt,
+    s.createdAt,
+    s.updatedAt
+  ];
+}
+async function upsertSchedule(db, schedule) {
+  await db.run(
+    `INSERT INTO schedules (${SCHEDULE_COLUMNS.join(", ")}) VALUES (${SCHEDULE_PLACEHOLDERS}) ON CONFLICT(id) DO UPDATE SET ${SCHEDULE_UPDATE_SET}`,
+    scheduleToDbValues(schedule)
+  );
+}
+async function getAllSchedules(db) {
+  const rows = await db.all("SELECT * FROM schedules ORDER BY created_at");
+  return rows.map(dbRowToSchedule);
+}
+async function getScheduleById(db, id) {
+  const row = await db.get("SELECT * FROM schedules WHERE id = $1", [id]);
+  return row ? dbRowToSchedule(row) : void 0;
+}
+async function deleteScheduleRow(db, id) {
+  const row = await db.get("SELECT id FROM schedules WHERE id = $1", [id]);
+  if (!row) return false;
+  await db.run("DELETE FROM schedules WHERE id = $1", [id]);
+  return true;
+}
+async function updateScheduleFields(db, id, fields) {
+  const existing = await getScheduleById(db, id);
+  if (!existing) return void 0;
+  const updated = { ...existing, ...fields, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  await upsertSchedule(db, updated);
+  return updated;
+}
 
 // src/schemas.ts
 var errorResponseSchema = {
@@ -890,6 +1159,65 @@ function parseWebhookUrl(value) {
   }
   return url.toString();
 }
+var createScheduleRequestSchema = {
+  type: "object",
+  required: ["name", "cron", "prompt"],
+  properties: {
+    name: { type: "string", minLength: 1 },
+    cron: { type: "string", minLength: 9 },
+    enabled: { type: "boolean", default: true },
+    targetMode: { type: "string", enum: ["queue", "direct", "broadcast"], default: "queue" },
+    targetAgents: { type: "array", items: { type: "string" } },
+    prompt: { type: "string", minLength: 1 },
+    workspace: { type: "string" },
+    timeoutSec: { type: "number", minimum: 1 },
+    priority: { type: "integer", minimum: 0, maximum: 3, default: 0 },
+    requiredLabels: { type: "array", items: { type: "string" } }
+  }
+};
+var updateScheduleRequestSchema = {
+  type: "object",
+  properties: {
+    name: { type: "string", minLength: 1 },
+    cron: { type: "string", minLength: 9 },
+    enabled: { type: "boolean" },
+    targetMode: { type: "string", enum: ["queue", "direct", "broadcast"] },
+    targetAgents: { type: "array", items: { type: "string" } },
+    prompt: { type: "string", minLength: 1 },
+    workspace: { type: "string" },
+    timeoutSec: { type: "number", minimum: 1 },
+    priority: { type: "integer", minimum: 0, maximum: 3 },
+    requiredLabels: { type: "array", items: { type: "string" } }
+  }
+};
+var scheduleResponseSchema = {
+  type: "object",
+  required: ["id", "name", "cron", "enabled", "targetMode", "prompt", "createdAt", "updatedAt"],
+  properties: {
+    id: { type: "string" },
+    name: { type: "string" },
+    cron: { type: "string" },
+    enabled: { type: "boolean" },
+    targetMode: { type: "string", enum: ["queue", "direct", "broadcast"] },
+    targetAgents: { type: "array", items: { type: "string" } },
+    prompt: { type: "string" },
+    workspace: { type: "string" },
+    timeoutSec: { type: "number" },
+    priority: { type: "integer" },
+    requiredLabels: { type: "array", items: { type: "string" } },
+    lastRunAt: { type: "string" },
+    nextRunAt: { type: "string" },
+    createdAt: { type: "string" },
+    updatedAt: { type: "string" }
+  }
+};
+var scheduleListResponseSchema = {
+  type: "object",
+  required: ["schedules"],
+  properties: {
+    schedules: { type: "array", items: scheduleResponseSchema }
+  }
+};
 
 // src/dispatch.ts
 import { createHmac, randomUUID } from "node:crypto";
@@ -1655,7 +1983,8 @@ function createInMemoryStateStore() {
     taskQueues: /* @__PURE__ */ new Map(),
     mainTaskQueues: /* @__PURE__ */ new Map(),
     sharedTaskQueue: [],
-    sharedQueueCursor: 0
+    sharedQueueCursor: 0,
+    scheduleJobs: /* @__PURE__ */ new Map()
   };
 }
 
@@ -1705,6 +2034,41 @@ function createEncryptor(encryptionKeyHex) {
   };
 }
 
+// src/scheduler.ts
+import { CronJob } from "cron";
+function startScheduleJob(schedule, dispatchFn, jobs, onFire) {
+  const atAgents = schedule.targetMode === "queue" ? "queue" : schedule.targetMode === "broadcast" ? "all" : schedule.targetAgents;
+  const job = new CronJob(
+    schedule.cronExpr,
+    () => {
+      dispatchFn(
+        {
+          type: "command.dispatch",
+          atAgents,
+          prompt: schedule.prompt,
+          workspace: schedule.workspace ?? void 0,
+          timeoutSec: schedule.timeoutSec ?? void 0
+        },
+        null,
+        void 0,
+        schedule.priority,
+        schedule.requiredLabels
+      );
+      onFire(schedule.id);
+    },
+    null,
+    true
+  );
+  jobs.set(schedule.id, job);
+}
+function stopScheduleJob(jobs, scheduleId) {
+  const job = jobs.get(scheduleId);
+  if (job) {
+    job.stop();
+    jobs.delete(scheduleId);
+  }
+}
+
 // src/index.ts
 var DEFAULT_PORT = 3789;
 function isAuthorized(authToken, rawUrl, headers) {
@@ -1720,8 +2084,8 @@ async function createAiTeamsServer(options) {
   const defaultTimeoutSec = options.defaultTimeoutSec ?? 1800;
   const disconnectGraceMs = options.disconnectGraceMs ?? 15e3;
   const maxLogChunksPerTask = options.maxLogChunksPerTask ?? 400;
-  const dataDir = options.dataDir ?? path.join(process.cwd(), "data");
-  const dbPath = options.dbPath ?? path.join(dataDir, "ai-teams.db");
+  const dataDir = options.dataDir ?? path2.join(process.cwd(), "data");
+  const dbPath = options.dbPath ?? path2.join(dataDir, "ai-teams.db");
   let closing = false;
   const state = createInMemoryStateStore();
   const db = await createDatabaseFromEnv({
@@ -1736,13 +2100,13 @@ async function createAiTeamsServer(options) {
   const logDir = options.logDir || process.env.LOG_DIR;
   let loggerConfig = { level: logLevel };
   if (logDir && options.logger !== false) {
-    fs.mkdirSync(logDir, { recursive: true });
+    fs2.mkdirSync(logDir, { recursive: true });
     loggerConfig = {
       level: logLevel,
       transport: {
         targets: [
           { target: "pino/file", options: { destination: 1 }, level: logLevel },
-          { target: "pino/file", options: { destination: path.join(logDir, "server.log") }, level: logLevel }
+          { target: "pino/file", options: { destination: path2.join(logDir, "server.log") }, level: logLevel }
         ]
       }
     };
@@ -1775,8 +2139,8 @@ async function createAiTeamsServer(options) {
     },
     staticCSP: true
   });
-  const webDir = path.join(path.dirname(fileURLToPath(import.meta.url)), "web");
-  if (fs.existsSync(webDir)) {
+  const webDir = path2.join(path2.dirname(fileURLToPath(import.meta.url)), "web");
+  if (fs2.existsSync(webDir)) {
     await app.register(fastifyStatic, { root: webDir, prefix: "/" });
     app.setNotFoundHandler((_, reply) => {
       reply.sendFile("index.html");
@@ -1794,6 +2158,29 @@ async function createAiTeamsServer(options) {
     encryptor: createEncryptor(process.env.AI_TEAMS_ENCRYPTION_KEY)
   };
   const { dispatchLeaderCommand, handleAgentMessage, handleLeaderMessage, cancelTaskById } = createDispatch(dispatchCtx);
+  const scheduleDispatchFn = (message, webhookUrl, cliConfig, priority, requiredLabels) => {
+    return dispatchLeaderCommand(message, webhookUrl, cliConfig, priority, requiredLabels);
+  };
+  async function onScheduleFire(scheduleId) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const job = state.scheduleJobs.get(scheduleId);
+    const nextRun = job?.nextDate()?.toISO() ?? null;
+    await updateScheduleFields(db, scheduleId, { lastRunAt: now, nextRunAt: nextRun });
+  }
+  async function loadAndStartSchedules() {
+    const schedules = await getAllSchedules(db);
+    for (const schedule of schedules) {
+      if (schedule.enabled) {
+        try {
+          startScheduleJob(schedule, scheduleDispatchFn, state.scheduleJobs, onScheduleFire);
+        } catch (err) {
+          app.log.error({ scheduleId: schedule.id, cronExpr: schedule.cronExpr, err }, "Failed to start schedule");
+        }
+      }
+    }
+    app.log.info({ count: schedules.filter((s) => s.enabled).length }, "Schedules loaded");
+  }
+  await loadAndStartSchedules();
   function buildSnapshot() {
     return {
       employees: [...state.employees.values()],
@@ -1864,19 +2251,19 @@ async function createAiTeamsServer(options) {
       return { employeeId, workspace: null, activeSessionId: null, sessions: [] };
     }
     const encodedPath = workspace.replace(/\//g, "-");
-    const claudeProjectsDir = path.join(os.homedir(), ".claude", "projects", encodedPath);
+    const claudeProjectsDir = path2.join(os.homedir(), ".claude", "projects", encodedPath);
     let entries;
     try {
-      entries = fs.readdirSync(claudeProjectsDir, { withFileTypes: true });
+      entries = fs2.readdirSync(claudeProjectsDir, { withFileTypes: true });
     } catch {
       return { employeeId, workspace, activeSessionId: null, sessions: [] };
     }
     const jsonlFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).sort((a, b) => b.name.localeCompare(a.name));
     const sessions = jsonlFiles.map((entry) => {
-      const filePath = path.join(claudeProjectsDir, entry.name);
-      const stat = fs.statSync(filePath);
+      const filePath = path2.join(claudeProjectsDir, entry.name);
+      const stat = fs2.statSync(filePath);
       const sessionId = entry.name.replace(/\.jsonl$/, "");
-      const content = fs.readFileSync(filePath, "utf8");
+      const content = fs2.readFileSync(filePath, "utf8");
       const lines = content.split("\n").filter(Boolean);
       const lineCount = lines.length;
       let firstUserMessage = null;
@@ -1889,9 +2276,9 @@ async function createAiTeamsServer(options) {
       return { id: sessionId, sizeBytes: stat.size, modifiedAt: stat.mtime.toISOString(), lineCount, firstUserMessage, latestUserMessage };
     });
     let activeSessionId = null;
-    const agentStatePath = path.join(workspace, ".ai-teams", "agents", employeeId, "session-state.json");
+    const agentStatePath = path2.join(workspace, ".ai-teams", "agents", employeeId, "session-state.json");
     try {
-      const raw = fs.readFileSync(agentStatePath, "utf8");
+      const raw = fs2.readFileSync(agentStatePath, "utf8");
       activeSessionId = JSON.parse(raw).claudeSessionId ?? null;
     } catch {
     }
@@ -1902,7 +2289,7 @@ async function createAiTeamsServer(options) {
     if (request.url.startsWith("/ws/") || request.url.startsWith("/docs")) {
       return;
     }
-    const ext = path.extname(request.url.split("?")[0]);
+    const ext = path2.extname(request.url.split("?")[0]);
     if (request.url === "/" || staticExts.has(ext)) {
       return;
     }
@@ -2204,6 +2591,163 @@ async function createAiTeamsServer(options) {
       return { deleted: true };
     }
   );
+  app.get(
+    "/api/schedules",
+    {
+      schema: {
+        tags: ["schedules"],
+        summary: "List all schedules",
+        response: { 200: scheduleListResponseSchema, 401: errorResponseSchema }
+      }
+    },
+    async () => {
+      const schedules = await getAllSchedules(db);
+      return { schedules };
+    }
+  );
+  app.get(
+    "/api/schedules/:scheduleId",
+    {
+      schema: {
+        tags: ["schedules"],
+        summary: "Get a schedule by ID",
+        params: { type: "object", required: ["scheduleId"], properties: { scheduleId: { type: "string", minLength: 1 } } },
+        response: { 200: scheduleResponseSchema, 404: errorResponseSchema, 401: errorResponseSchema }
+      }
+    },
+    async (request, reply) => {
+      const schedule = await getScheduleById(db, request.params.scheduleId);
+      if (!schedule) return reply.code(404).send({ error: "Schedule not found." });
+      return schedule;
+    }
+  );
+  app.post(
+    "/api/schedules",
+    {
+      schema: {
+        tags: ["schedules"],
+        summary: "Create a schedule",
+        body: createScheduleRequestSchema,
+        response: { 201: scheduleResponseSchema, 400: errorResponseSchema, 401: errorResponseSchema }
+      }
+    },
+    async (request, reply) => {
+      const body = request.body;
+      const id = randomUUID2();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const schedule = {
+        id,
+        name: body.name,
+        cronExpr: body.cron,
+        enabled: body.enabled ?? true,
+        targetMode: body.targetMode ?? "queue",
+        targetAgents: body.targetAgents ?? [],
+        prompt: body.prompt,
+        workspace: body.workspace ?? null,
+        timeoutSec: body.timeoutSec ?? null,
+        priority: body.priority ?? 0,
+        requiredLabels: body.requiredLabels ?? null,
+        lastRunAt: null,
+        nextRunAt: null,
+        createdAt: now,
+        updatedAt: now
+      };
+      try {
+        if (schedule.enabled) {
+          startScheduleJob(schedule, scheduleDispatchFn, state.scheduleJobs, onScheduleFire);
+          schedule.nextRunAt = state.scheduleJobs.get(id)?.nextDate()?.toISO() ?? null;
+        }
+        await upsertSchedule(db, schedule);
+        return reply.code(201).send(schedule);
+      } catch (err) {
+        stopScheduleJob(state.scheduleJobs, id);
+        return reply.code(400).send({ error: err instanceof Error ? err.message : "Invalid schedule." });
+      }
+    }
+  );
+  app.patch(
+    "/api/schedules/:scheduleId",
+    {
+      schema: {
+        tags: ["schedules"],
+        summary: "Update a schedule",
+        params: { type: "object", required: ["scheduleId"], properties: { scheduleId: { type: "string", minLength: 1 } } },
+        body: updateScheduleRequestSchema,
+        response: { 200: scheduleResponseSchema, 404: errorResponseSchema, 401: errorResponseSchema }
+      }
+    },
+    async (request, reply) => {
+      const existing = await getScheduleById(db, request.params.scheduleId);
+      if (!existing) return reply.code(404).send({ error: "Schedule not found." });
+      const fields = {};
+      if (request.body.name !== void 0) fields.name = request.body.name;
+      if (request.body.cron !== void 0) fields.cronExpr = request.body.cron;
+      if (request.body.enabled !== void 0) fields.enabled = request.body.enabled;
+      if (request.body.targetMode !== void 0) fields.targetMode = request.body.targetMode;
+      if (request.body.targetAgents !== void 0) fields.targetAgents = request.body.targetAgents;
+      if (request.body.prompt !== void 0) fields.prompt = request.body.prompt;
+      if (request.body.workspace !== void 0) fields.workspace = request.body.workspace;
+      if (request.body.timeoutSec !== void 0) fields.timeoutSec = request.body.timeoutSec;
+      if (request.body.priority !== void 0) fields.priority = request.body.priority;
+      if (request.body.requiredLabels !== void 0) fields.requiredLabels = request.body.requiredLabels;
+      const updated = await updateScheduleFields(db, request.params.scheduleId, fields);
+      if (!updated) return reply.code(404).send({ error: "Schedule not found." });
+      stopScheduleJob(state.scheduleJobs, request.params.scheduleId);
+      if (updated.enabled) {
+        startScheduleJob(updated, scheduleDispatchFn, state.scheduleJobs, onScheduleFire);
+        updated.nextRunAt = state.scheduleJobs.get(request.params.scheduleId)?.nextDate()?.toISO() ?? null;
+        await updateScheduleFields(db, request.params.scheduleId, { nextRunAt: updated.nextRunAt });
+      }
+      return updated;
+    }
+  );
+  app.delete(
+    "/api/schedules/:scheduleId",
+    {
+      schema: {
+        tags: ["schedules"],
+        summary: "Delete a schedule",
+        params: { type: "object", required: ["scheduleId"], properties: { scheduleId: { type: "string", minLength: 1 } } },
+        response: {
+          200: { type: "object", required: ["deleted"], properties: { deleted: { type: "boolean" } } },
+          404: errorResponseSchema,
+          401: errorResponseSchema
+        }
+      }
+    },
+    async (request, reply) => {
+      stopScheduleJob(state.scheduleJobs, request.params.scheduleId);
+      const deleted = await deleteScheduleRow(db, request.params.scheduleId);
+      if (!deleted) return reply.code(404).send({ error: "Schedule not found." });
+      return { deleted: true };
+    }
+  );
+  app.post(
+    "/api/schedules/:scheduleId/trigger",
+    {
+      schema: {
+        tags: ["schedules"],
+        summary: "Manually trigger a schedule",
+        params: { type: "object", required: ["scheduleId"], properties: { scheduleId: { type: "string", minLength: 1 } } },
+        response: { 200: scheduleResponseSchema, 404: errorResponseSchema, 401: errorResponseSchema }
+      }
+    },
+    async (request, reply) => {
+      const schedule = await getScheduleById(db, request.params.scheduleId);
+      if (!schedule) return reply.code(404).send({ error: "Schedule not found." });
+      const atAgents = schedule.targetMode === "queue" ? "queue" : schedule.targetMode === "broadcast" ? "all" : schedule.targetAgents;
+      const result = dispatchLeaderCommand(
+        { type: "command.dispatch", atAgents, prompt: schedule.prompt, workspace: schedule.workspace ?? void 0, timeoutSec: schedule.timeoutSec ?? void 0 },
+        null,
+        void 0,
+        schedule.priority,
+        schedule.requiredLabels
+      );
+      if (!result.ok) return reply.code(400).send({ error: result.message });
+      await onScheduleFire(request.params.scheduleId);
+      return await getScheduleById(db, request.params.scheduleId);
+    }
+  );
   app.get("/ws/agent", { websocket: true }, (socket, request) => {
     if (!isAuthorized(options.authToken, request.url, request.headers)) {
       socket.close(1008, "unauthorized");
@@ -2278,6 +2822,9 @@ async function createAiTeamsServer(options) {
     buildSnapshot,
     close: async () => {
       closing = true;
+      for (const job of state.scheduleJobs.values()) {
+        job.stop();
+      }
       for (const timer of state.taskTimeouts.values()) {
         clearTimeout(timer);
       }
@@ -2311,62 +2858,125 @@ async function startServer(options = readOptionsFromEnv()) {
   await server.app.listen({ port: options.port ?? DEFAULT_PORT, host: options.host ?? "0.0.0.0" });
   return server;
 }
-var isCli = process.argv[1] && fs.realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
+var isCli = process.argv[1] && fs2.realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
 if (isCli) {
   let getArgValue = function(name) {
     const idx = args.indexOf(name);
     if (idx === -1) return void 0;
     return args[idx + 1];
+  }, resolveDataDir = function() {
+    return getArgValue("--data-dir") || process.env.DATA_DIR || path2.join(process.cwd(), "data");
+  }, resolvePidFile = function() {
+    return path2.join(resolveDataDir(), ".ai-teams-server.pid");
+  }, resolveLogDir = function() {
+    return getArgValue("--log-dir") || process.env.LOG_DIR || path2.join(resolveDataDir(), "logs");
+  }, applyCliArgsToEnv = function() {
+    const cliToken = getArgValue("--token");
+    const cliPort = getArgValue("--port");
+    const cliHost = getArgValue("--host");
+    const cliDataDir = getArgValue("--data-dir");
+    const cliDatabaseUrl = getArgValue("--database-url");
+    const cliDbPath = getArgValue("--db-path");
+    const cliLogLevel = getArgValue("--log-level");
+    const cliLogDir = getArgValue("--log-dir");
+    if (cliToken) process.env.AI_TEAMS_AUTH_TOKEN = cliToken;
+    if (cliPort) process.env.AI_TEAMS_SERVER_PORT = cliPort;
+    if (cliHost) process.env.HOST = cliHost;
+    if (cliDataDir) process.env.DATA_DIR = cliDataDir;
+    if (cliDatabaseUrl) process.env.DATABASE_URL = cliDatabaseUrl;
+    if (cliDbPath) process.env.DB_PATH = cliDbPath;
+    if (cliLogLevel) process.env.LOG_LEVEL = cliLogLevel;
+    if (cliLogDir) process.env.LOG_DIR = cliLogDir;
   };
-  getArgValue2 = getArgValue;
+  getArgValue2 = getArgValue, resolveDataDir2 = resolveDataDir, resolvePidFile2 = resolvePidFile, resolveLogDir2 = resolveLogDir, applyCliArgsToEnv2 = applyCliArgsToEnv;
   const args = process.argv.slice(2);
   if (args.includes("--version") || args.includes("-v")) {
-    console.log("0.1.5");
+    console.log("0.3.0");
     process.exit(0);
   }
   if (args.includes("--help") || args.includes("-h")) {
     console.log(`ai-teams-server \u2014 AI Teams \u4E2D\u592E\u670D\u52A1\u5668
 
-\u7528\u6CD5: ai-teams-server [\u9009\u9879]
+\u7528\u6CD5: ai-teams-server <command> [\u9009\u9879]
+
+\u547D\u4EE4:
+  start [\u9009\u9879]          \u540E\u53F0\u542F\u52A8\u5B88\u62A4\u8FDB\u7A0B
+  stop                  \u505C\u6B62\u5B88\u62A4\u8FDB\u7A0B
+  restart [\u9009\u9879]        \u91CD\u542F\u5B88\u62A4\u8FDB\u7A0B
+  status                \u67E5\u770B\u8FD0\u884C\u72B6\u6001
 
 \u9009\u9879:
   --token <token>       \u8BA4\u8BC1 Token (\u5FC5\u586B\uFF0C\u6216\u8BBE AI_TEAMS_AUTH_TOKEN)
   --port <port>         \u670D\u52A1\u7AEF\u53E3 (\u9ED8\u8BA4 3789)
   --host <host>         \u7ED1\u5B9A\u5730\u5740 (\u9ED8\u8BA4 0.0.0.0)
   --data-dir <dir>      \u6570\u636E\u76EE\u5F55
+  --database-url <url>  PostgreSQL \u8FDE\u63A5\u5B57\u7B26\u4E32 (\u8BBE\u7F6E\u540E\u4F7F\u7528 PostgreSQL \u800C\u975E SQLite)
   --db-path <path>      \u6570\u636E\u5E93\u8DEF\u5F84
   --log-level <level>   \u65E5\u5FD7\u7EA7\u522B trace/debug/info/warn/error (\u9ED8\u8BA4 info)
   --log-dir <dir>       \u65E5\u5FD7\u6587\u4EF6\u76EE\u5F55 (\u4E0D\u8BBE\u5219\u4EC5\u8F93\u51FA\u5230 stdout)
   -v, --version         \u663E\u793A\u7248\u672C\u53F7
   -h, --help            \u663E\u793A\u5E2E\u52A9
+
+\u4E0D\u5E26\u547D\u4EE4\u76F4\u63A5\u8FD0\u884C\u65F6\u4E3A\u524D\u53F0\u6A21\u5F0F\u3002
 `);
     process.exit(0);
   }
-  const cliToken = getArgValue("--token");
-  const cliPort = getArgValue("--port");
-  const cliHost = getArgValue("--host");
-  const cliDataDir = getArgValue("--data-dir");
-  const cliDbPath = getArgValue("--db-path");
-  const cliLogLevel = getArgValue("--log-level");
-  const cliLogDir = getArgValue("--log-dir");
-  if (cliToken) process.env.AI_TEAMS_AUTH_TOKEN = cliToken;
-  if (cliPort) process.env.AI_TEAMS_SERVER_PORT = cliPort;
-  if (cliHost) process.env.HOST = cliHost;
-  if (cliDataDir) process.env.DATA_DIR = cliDataDir;
-  if (cliDbPath) process.env.DB_PATH = cliDbPath;
-  if (cliLogLevel) process.env.LOG_LEVEL = cliLogLevel;
-  if (cliLogDir) process.env.LOG_DIR = cliLogDir;
-  const options = readOptionsFromEnv();
-  if (!options.authToken) {
-    console.error("\u9519\u8BEF: \u9700\u8981\u8BA4\u8BC1 Token\u3002\u4F7F\u7528 --token <token> \u6216\u8BBE\u7F6E AI_TEAMS_AUTH_TOKEN \u73AF\u5883\u53D8\u91CF\u3002");
-    process.exit(1);
+  const subcommand = args[0];
+  if (subcommand === "start" || subcommand === "restart") {
+    void (async () => {
+      if (subcommand === "restart") {
+        const status = getDaemonStatus(resolvePidFile());
+        if (status.running) {
+          await stopDaemon(resolvePidFile());
+        }
+      }
+      applyCliArgsToEnv();
+      if (!process.env.AI_TEAMS_AUTH_TOKEN) {
+        console.error("\u9519\u8BEF: \u9700\u8981\u8BA4\u8BC1 Token\u3002\u4F7F\u7528 --token <token> \u6216\u8BBE\u7F6E AI_TEAMS_AUTH_TOKEN \u73AF\u5883\u53D8\u91CF\u3002");
+        process.exit(1);
+      }
+      if (!process.env.LOG_DIR) {
+        process.env.LOG_DIR = resolveLogDir();
+      }
+      await daemonize({
+        name: "ai-teams-server",
+        pidFile: resolvePidFile(),
+        logFile: path2.join(resolveLogDir(), "server.log"),
+        run: async () => {
+          await startServer(readOptionsFromEnv());
+        }
+      });
+    })();
+  } else if (subcommand === "stop") {
+    void (async () => {
+      await stopDaemon(resolvePidFile());
+    })();
+  } else if (subcommand === "status") {
+    const status = getDaemonStatus(resolvePidFile());
+    if (status.running) {
+      console.log(`ai-teams-server is running (PID ${status.pid})`);
+      console.log(`Log: ${path2.join(resolveLogDir(), "server.log")}`);
+    } else {
+      console.log("ai-teams-server is not running.");
+    }
+  } else {
+    applyCliArgsToEnv();
+    const options = readOptionsFromEnv();
+    if (!options.authToken) {
+      console.error("\u9519\u8BEF: \u9700\u8981\u8BA4\u8BC1 Token\u3002\u4F7F\u7528 --token <token> \u6216\u8BBE\u7F6E AI_TEAMS_AUTH_TOKEN \u73AF\u5883\u53D8\u91CF\u3002");
+      process.exit(1);
+    }
+    startServer(options).catch((error) => {
+      console.error(error);
+      process.exit(1);
+    });
   }
-  startServer(options).catch((error) => {
-    console.error(error);
-    process.exit(1);
-  });
 }
 var getArgValue2;
+var resolveDataDir2;
+var resolvePidFile2;
+var resolveLogDir2;
+var applyCliArgsToEnv2;
 export {
   createAiTeamsServer,
   readOptionsFromEnv,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@csdwd/ai-teams-server",
-  "version": "0.1.5",
+  "version": "0.3.0",
   "description": "AI Teams central server — Fastify HTTP + WebSocket server for task dispatch, employee management, and web UI",
   "type": "module",
   "bin": {
@@ -20,6 +20,7 @@
     "@fastify/swagger": "^9.7.0",
     "@fastify/swagger-ui": "^5.2.5",
     "@fastify/websocket": "^11.0.0",
+    "cron": "^4.4.0",
     "fastify": "^5.2.0",
     "pg": "^8.20.0",
     "ws": "^8.18.3"