@csdwd/ai-teams-server 0.1.5 → 0.2.0

package/dist/index.js

@@ -4,6 +4,7 @@
 import os from "node:os";
 import path from "node:path";
 import fs from "node:fs";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import Fastify from "fastify";
 import swagger from "@fastify/swagger";
@@ -373,6 +374,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 +629,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 +994,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 +1818,8 @@ function createInMemoryStateStore() {
     taskQueues: /* @__PURE__ */ new Map(),
     mainTaskQueues: /* @__PURE__ */ new Map(),
     sharedTaskQueue: [],
-    sharedQueueCursor: 0
+    sharedQueueCursor: 0,
+    scheduleJobs: /* @__PURE__ */ new Map()
   };
 }
 
@@ -1705,6 +1869,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) {
@@ -1794,6 +1993,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()],
@@ -2204,6 +2426,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 +2657,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);
       }
@@ -2321,7 +2703,7 @@ if (isCli) {
   getArgValue2 = getArgValue;
   const args = process.argv.slice(2);
   if (args.includes("--version") || args.includes("-v")) {
-    console.log("0.1.5");
+    console.log("0.2.0");
     process.exit(0);
   }
   if (args.includes("--help") || args.includes("-h")) {
@@ -2334,6 +2716,7 @@ if (isCli) {
   --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)
@@ -2346,6 +2729,7 @@ if (isCli) {
   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");
@@ -2353,6 +2737,7 @@ if (isCli) {
   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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@csdwd/ai-teams-server",
-  "version": "0.1.5",
+  "version": "0.2.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"