@csdwd/ai-teams-server 0.2.0 → 0.3.0

package/dist/index.js

@@ -2,8 +2,8 @@
 
 // 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";
@@ -231,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";
@@ -1919,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({
@@ -1935,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 }
         ]
       }
     };
@@ -1974,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");
@@ -2086,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;
@@ -2111,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 {
     }
@@ -2124,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;
     }
@@ -2693,23 +2858,52 @@ 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.2.0");
+    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)
@@ -2722,36 +2916,67 @@ if (isCli) {
   --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 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;
-  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.2.0",
+  "version": "0.3.0",
   "description": "AI Teams central server — Fastify HTTP + WebSocket server for task dispatch, employee management, and web UI",
   "type": "module",
   "bin": {