@csdwd/ai-teams-agent 0.1.0

package/dist/index.js

@@ -0,0 +1,1114 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { fileURLToPath } from "node:url";
+import WebSocket2 from "ws";
+
+// src/config.ts
+import path2 from "node:path";
+
+// src/setup.ts
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+var CONFIG_DIR = path.join(os.homedir(), ".ai-teams");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+function loadConfigFile() {
+  try {
+    const raw = fs.readFileSync(CONFIG_FILE, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveConfigFile(config) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+}
+async function runSetup(existing) {
+  const rl = createInterface({ input, output });
+  console.log("");
+  console.log("  AI Teams Agent \u914D\u7F6E");
+  console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log("");
+  const serverUrl = await rl.question(`  \u670D\u52A1\u5668\u5730\u5740 [${existing?.serverUrl ?? "ws://localhost:3789"}]: `);
+  const authToken = await rl.question(`  \u8BA4\u8BC1 Token${existing ? " [******]" : ""}: `);
+  const employeeId = await rl.question(`  \u5458\u5DE5 ID [${existing?.employeeId ?? "emp_local"}]: `);
+  const employeeName = await rl.question(`  \u5458\u5DE5\u540D\u79F0 [${existing?.employeeName ?? "Local Agent"}]: `);
+  const workspace = await rl.question(`  \u5DE5\u4F5C\u76EE\u5F55 [${existing?.workspace ?? process.cwd()}]: `);
+  const runnerMode = await rl.question(`  Runner \u6A21\u5F0F (claude/fake) [${existing?.runnerMode ?? "claude"}]: `);
+  rl.close();
+  const config = {
+    serverUrl: serverUrl.trim() || existing?.serverUrl || "ws://localhost:3789",
+    authToken: authToken.trim() || existing?.authToken || "",
+    employeeId: employeeId.trim() || existing?.employeeId || "emp_local",
+    employeeName: employeeName.trim() || existing?.employeeName || "Local Agent",
+    workspace: workspace.trim() || existing?.workspace || process.cwd(),
+    runnerMode: runnerMode.trim() || existing?.runnerMode || "claude"
+  };
+  saveConfigFile(config);
+  console.log("");
+  console.log(`  \u2713 \u914D\u7F6E\u5DF2\u4FDD\u5B58\u5230 ${CONFIG_FILE}`);
+  return config;
+}
+
+// src/config.ts
+var fileConfig = loadConfigFile();
+var SERVER_PORT = process.env.AI_TEAMS_SERVER_PORT || "3789";
+var SERVER_URL = process.env.SERVER_URL || fileConfig?.serverUrl || `ws://localhost:${SERVER_PORT}`;
+var AUTH_TOKEN = process.env.AI_TEAMS_AUTH_TOKEN || fileConfig?.authToken || "";
+var EMPLOYEE_ID = process.env.EMPLOYEE_ID || fileConfig?.employeeId || "emp_local";
+var EMPLOYEE_NAME = process.env.EMPLOYEE_NAME || fileConfig?.employeeName || "Local Agent";
+var EMPLOYEE_LABELS = process.env.EMPLOYEE_LABELS?.split(",").map((item) => item.trim()).filter(Boolean) ?? [];
+var RECONNECT_MS = Number(process.env.RECONNECT_MS) || 5e3;
+var RUNNER_MODE = process.env.RUNNER_MODE || fileConfig?.runnerMode || "claude";
+var DEFAULT_WORKSPACE = process.env.DEFAULT_WORKSPACE || fileConfig?.workspace || process.cwd();
+var MAX_BUFFERED_MESSAGES = Number(process.env.AGENT_BUFFER_LIMIT) || 400;
+var MAX_ERROR_TAIL = 16e3;
+var CLAUDE_MISSING_CONVERSATION_PATTERN = /No conversation found with session ID/i;
+var AGENT_RECORDS_DIR = process.env.AGENT_RECORDS_DIR || path2.join(DEFAULT_WORKSPACE, ".ai-teams", "agents", EMPLOYEE_ID);
+var STATE_FILE = process.env.AGENT_STATE_FILE || path2.join(AGENT_RECORDS_DIR, "session-state.json");
+var LEGACY_STATE_FILE = path2.join(process.cwd(), `.agent-state.${EMPLOYEE_ID}.json`);
+var DAILY_RECORDS_DIR = path2.join(AGENT_RECORDS_DIR, "daily");
+var HOOKS_DIR = path2.join(AGENT_RECORDS_DIR, "hooks");
+var CLAUDE_HOOK_SCRIPT = path2.join(HOOKS_DIR, "claude-session-recorder.cjs");
+var CLAUDE_HOOK_SETTINGS = path2.join(HOOKS_DIR, "claude-hooks.settings.json");
+var CLAUDE_HOOKS_ENABLED = process.env.CLAUDE_HOOKS_ENABLED !== "false";
+var WORKSPACE_CLAUDE_MD = path2.join(DEFAULT_WORKSPACE, "CLAUDE.md");
+var CLAUDE_MD_SECTION_START = "<!-- AI_TEAMS_AGENT_RULES_START -->";
+var CLAUDE_MD_SECTION_END = "<!-- AI_TEAMS_AGENT_RULES_END -->";
+
+// src/state.ts
+import fs2 from "node:fs";
+import path3 from "node:path";
+import { randomUUID } from "node:crypto";
+function loadState() {
+  try {
+    const content = fs2.readFileSync(STATE_FILE, "utf8");
+    const parsed = JSON.parse(content);
+    return {
+      claudeSessionId: parsed.claudeSessionId || randomUUID(),
+      sessionReady: parsed.sessionReady ?? false
+    };
+  } catch {
+    const legacyState = loadLegacyState();
+    if (legacyState) {
+      persistState(legacyState);
+      return legacyState;
+    }
+    const state = { claudeSessionId: randomUUID(), sessionReady: false };
+    persistState(state);
+    return state;
+  }
+}
+function loadLegacyState() {
+  if (process.env.AGENT_STATE_FILE || LEGACY_STATE_FILE === STATE_FILE || !fs2.existsSync(LEGACY_STATE_FILE)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(fs2.readFileSync(LEGACY_STATE_FILE, "utf8"));
+    return {
+      claudeSessionId: parsed.claudeSessionId || randomUUID(),
+      sessionReady: parsed.sessionReady ?? false
+    };
+  } catch {
+    return null;
+  }
+}
+function persistState(state) {
+  fs2.mkdirSync(path3.dirname(STATE_FILE), { recursive: true });
+  fs2.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+function resetClaudeSession() {
+  const state = { claudeSessionId: randomUUID(), sessionReady: false };
+  persistState(state);
+  return state;
+}
+
+// src/records.ts
+import fs3 from "node:fs";
+import path4 from "node:path";
+
+// src/claude-hook-script.ts
+var CLAUDE_HOOK_SCRIPT_CONTENT = `#!/usr/bin/env node
+const fs = require("node:fs");
+const path = require("node:path");
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let content = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      content += chunk;
+    });
+    process.stdin.on("end", () => resolve(content));
+  });
+}
+
+function dateKey() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+function timestamp() {
+  return new Date().toLocaleString();
+}
+
+function safeLine(value) {
+  return String(value ?? "").replace(/\\n/g, " ").trim();
+}
+
+function truncate(value, max = 1200) {
+  const text = safeLine(value);
+  return text.length > max ? text.slice(0, max) + "..." : text;
+}
+
+function describeTool(input) {
+  if (!input.tool_name) {
+    return "";
+  }
+  const toolInput = input.tool_input || {};
+  if (input.tool_name === "Bash" && toolInput.command) {
+    return " - " + input.tool_name + ": " + truncate(toolInput.command, 500);
+  }
+  const filePath = toolInput.file_path || toolInput.path;
+  if (filePath) {
+    return " - " + input.tool_name + ": " + filePath;
+  }
+  return " - " + input.tool_name;
+}
+
+(async () => {
+  try {
+    const raw = await readStdin();
+    const input = raw ? JSON.parse(raw) : {};
+    const recordDir = process.env.AI_TEAMS_RECORD_DIR;
+    if (!recordDir) {
+      process.exit(0);
+    }
+
+    const dailyDir = path.join(recordDir, "daily");
+    fs.mkdirSync(dailyDir, { recursive: true });
+    const filePath = path.join(dailyDir, dateKey() + ".md");
+    if (!fs.existsSync(filePath)) {
+      fs.writeFileSync(filePath, "# " + process.env.AI_TEAMS_AGENT_NAME + " Daily Activity - " + dateKey() + "\\n\\n");
+    }
+
+    const event = input.hook_event_name || "Unknown";
+    const lines = [
+      "### " + timestamp() + " Claude Hook: " + event,
+      "- Agent: " + process.env.AI_TEAMS_AGENT_NAME + " (" + process.env.AI_TEAMS_AGENT_ID + ")",
+      "- Task ID: " + (process.env.AI_TEAMS_TASK_ID || "none"),
+      "- Target mode: " + (process.env.AI_TEAMS_TASK_TARGET_MODE || "unknown"),
+      "- Managed session: " + (process.env.AI_TEAMS_TASK_SESSION_ID || "unknown"),
+      "- Claude hook session: " + (input.session_id || "unknown"),
+      "- CWD: " + (input.cwd || "unknown"),
+      input.transcript_path ? "- Transcript: " + input.transcript_path : "",
+      describeTool(input),
+      input.prompt ? "- Prompt: " + truncate(input.prompt) : "",
+      input.last_assistant_message ? "- Last assistant message: " + truncate(input.last_assistant_message) : "",
+      input.error ? "- Error: " + truncate(input.error) : "",
+      input.reason ? "- Reason: " + input.reason : "",
+      input.compact_summary ? "- Compact summary: " + truncate(input.compact_summary) : "",
+      "",
+    ].filter(Boolean);
+
+    fs.appendFileSync(filePath, lines.join("\\n") + "\\n");
+    process.exit(0);
+  } catch (error) {
+    process.stderr.write(String(error && error.stack ? error.stack : error));
+    process.exit(0);
+  }
+})();
+`;
+
+// src/records.ts
+function localTimestamp() {
+  return (/* @__PURE__ */ new Date()).toLocaleString();
+}
+function localDateKey() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function appendDailyRecord(markdown) {
+  fs3.mkdirSync(DAILY_RECORDS_DIR, { recursive: true });
+  const filePath = path4.join(DAILY_RECORDS_DIR, `${localDateKey()}.md`);
+  if (!fs3.existsSync(filePath)) {
+    fs3.writeFileSync(filePath, `# ${EMPLOYEE_NAME} Daily Activity - ${localDateKey()}
+
+`);
+  }
+  fs3.appendFileSync(filePath, markdown);
+}
+function formatPromptForRecord(prompt) {
+  return prompt.trim().replace(/\n/g, "\n  ");
+}
+function recordTaskStart(task, prompt, workspace) {
+  appendDailyRecord(
+    [
+      `## ${localTimestamp()} Task Started`,
+      `- Agent: ${EMPLOYEE_NAME} (${EMPLOYEE_ID})`,
+      `- Task ID: ${task.taskId}`,
+      `- Target mode: ${task.targetMode}`,
+      `- Claude session: ${task.claudeSessionId}`,
+      `- Workspace: ${workspace || DEFAULT_WORKSPACE}`,
+      `- Prompt:`,
+      `  ${formatPromptForRecord(prompt)}`,
+      ""
+    ].join("\n")
+  );
+}
+function recordTaskFinish(task, status, detail) {
+  appendDailyRecord(
+    [
+      `## ${localTimestamp()} Task ${status}`,
+      `- Agent: ${EMPLOYEE_NAME} (${EMPLOYEE_ID})`,
+      `- Task ID: ${task.taskId}`,
+      `- Target mode: ${task.targetMode}`,
+      `- Claude session: ${task.claudeSessionId}`,
+      typeof detail === "undefined" ? "" : `- Detail: ${String(detail).replace(/\n/g, " ")}`,
+      ""
+    ].filter(Boolean).join("\n")
+  );
+}
+function ensureWorkspaceClaudeMd() {
+  fs3.mkdirSync(DEFAULT_WORKSPACE, { recursive: true });
+  const section = buildWorkspaceClaudeSection();
+  const current = fs3.existsSync(WORKSPACE_CLAUDE_MD) ? fs3.readFileSync(WORKSPACE_CLAUDE_MD, "utf8") : "";
+  const startIndex = current.indexOf(CLAUDE_MD_SECTION_START);
+  const endIndex = current.indexOf(CLAUDE_MD_SECTION_END);
+  if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+    const next2 = `${current.slice(0, startIndex).trimEnd()}
+
+${section}
+
+${current.slice(endIndex + CLAUDE_MD_SECTION_END.length).trimStart()}`;
+    fs3.writeFileSync(WORKSPACE_CLAUDE_MD, next2.trimEnd() + "\n");
+    return;
+  }
+  const next = current.trim() ? `${current.trimEnd()}
+
+${section}
+` : `${section}
+`;
+  fs3.writeFileSync(WORKSPACE_CLAUDE_MD, next);
+}
+function buildWorkspaceClaudeSection() {
+  return [
+    CLAUDE_MD_SECTION_START,
+    "## AI Teams Agent Operating Rules",
+    "",
+    `- Agent identity: ${EMPLOYEE_NAME} (${EMPLOYEE_ID}).`,
+    `- Default workspace: \`${DEFAULT_WORKSPACE}\`.`,
+    `- Default managed session state: \`${STATE_FILE}\`.`,
+    `- Daily memory files: \`${path4.join(DAILY_RECORDS_DIR, "YYYY-MM-DD.md")}\`.`,
+    `- Claude hook settings: \`${CLAUDE_HOOK_SETTINGS}\`.`,
+    "",
+    "### Conversation Responsibility",
+    "",
+    "- Treat direct `@Agent` or explicitly selected-Agent messages as this Agent's long-running default conversation.",
+    "- Keep continuity for direct Agent conversations by using the managed default session state.",
+    "- Treat queue tasks as isolated execution jobs; use their task-specific session context and avoid assuming they update the default conversation unless explicitly requested.",
+    "- When reporting back, summarize what changed, what was verified, and any remaining risks.",
+    "",
+    "### Memory And State Rules",
+    "",
+    "- At the start of a direct Agent conversation, read the most recent daily memory files before acting when continuity, prior decisions, or current workspace state could matter.",
+    "- Read today's memory file first, then recent previous days only as needed. Do not bulk-load all history unless the task asks for a retrospective.",
+    "- Use the daily memory files to understand what this Agent did, which tasks completed, which tools ran, and what unresolved work remains.",
+    "- Append durable observations through the AI Teams recorder and Claude hooks; avoid hand-editing generated hook records unless correcting an obvious mistake.",
+    "- Do not store secrets, tokens, private credentials, or sensitive user data in daily memory files.",
+    "",
+    "### Files Managed By AI Teams",
+    "",
+    "- `.ai-teams/agents/<EMPLOYEE_ID>/session-state.json` stores the default Claude session id for this Agent.",
+    "- `.ai-teams/agents/<EMPLOYEE_ID>/daily/` stores Markdown activity memory by date.",
+    "- `.ai-teams/agents/<EMPLOYEE_ID>/hooks/` stores generated Claude Code hook scripts and settings.",
+    "- These files are runtime state, not source code. Do not delete them unless explicitly asked to reset Agent memory.",
+    CLAUDE_MD_SECTION_END
+  ].join("\n");
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function ensureClaudeHookFiles() {
+  if (!CLAUDE_HOOKS_ENABLED) {
+    return;
+  }
+  fs3.mkdirSync(HOOKS_DIR, { recursive: true });
+  fs3.writeFileSync(CLAUDE_HOOK_SCRIPT, CLAUDE_HOOK_SCRIPT_CONTENT);
+  fs3.chmodSync(CLAUDE_HOOK_SCRIPT, 493);
+  fs3.writeFileSync(CLAUDE_HOOK_SETTINGS, JSON.stringify(buildClaudeHookSettings(), null, 2));
+}
+function buildHookCommand() {
+  return `${shellQuote(process.execPath)} ${shellQuote(CLAUDE_HOOK_SCRIPT)}`;
+}
+function buildClaudeHookSettings() {
+  const hook = {
+    type: "command",
+    command: buildHookCommand(),
+    timeout: 10
+  };
+  return {
+    hooks: {
+      SessionStart: [{ matcher: "*", hooks: [hook] }],
+      UserPromptSubmit: [{ matcher: "*", hooks: [hook] }],
+      PostToolUse: [{ matcher: "*", hooks: [hook] }],
+      Stop: [{ matcher: "*", hooks: [hook] }],
+      StopFailure: [{ matcher: "*", hooks: [hook] }],
+      SessionEnd: [{ matcher: "*", hooks: [hook] }],
+      PostCompact: [{ matcher: "*", hooks: [hook] }]
+    }
+  };
+}
+
+// src/runner.ts
+import { spawn } from "node:child_process";
+import fs4 from "node:fs";
+import os2 from "node:os";
+import path5 from "node:path";
+import readline from "node:readline";
+function resolveWorkspace(raw) {
+  if (!raw || !raw.trim()) {
+    return DEFAULT_WORKSPACE;
+  }
+  let resolved = raw.trim();
+  if (resolved.startsWith("~")) {
+    resolved = path5.join(os2.homedir(), resolved.slice(1));
+  }
+  if (!path5.isAbsolute(resolved)) {
+    resolved = path5.join(DEFAULT_WORKSPACE, resolved);
+  }
+  if (!fs4.existsSync(resolved)) {
+    fs4.mkdirSync(resolved, { recursive: true });
+  }
+  return resolved;
+}
+function handleClaudeJsonLine(taskId, line, findActiveTask2, emitOutput2) {
+  if (!line.trim()) {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    emitOutput2(taskId, "stdout", `${line}
+`);
+    return;
+  }
+  if (parsed.type === "stream_event") {
+    const event = parsed.event;
+    if (event?.type === "content_block_delta" && event.delta?.type === "text_delta" && event.delta.text) {
+      const task = findActiveTask2(taskId);
+      if (task) {
+        task.sawStreamText = true;
+        task.summary.push(event.delta.text);
+      }
+      emitOutput2(taskId, "stdout", event.delta.text);
+    }
+    return;
+  }
+  if (parsed.type === "assistant" && Array.isArray(parsed.message?.content)) {
+    const task = findActiveTask2(taskId);
+    if (task?.sawStreamText) {
+      return;
+    }
+    for (const block of parsed.message.content) {
+      if (block.type === "text" && block.text) {
+        task?.summary.push(block.text);
+        emitOutput2(taskId, "stdout", `${block.text}
+`);
+      }
+      if (block.type === "tool_use" && block.name) {
+        emitOutput2(taskId, "stdout", `[tool] ${block.name}
+`);
+      }
+    }
+    return;
+  }
+  if (parsed.type === "result" && typeof parsed.result === "string") {
+    const task = findActiveTask2(taskId);
+    if (task?.sawStreamText) {
+      emitOutput2(taskId, "stdout", formatClaudeDoneNode(parsed));
+      return;
+    }
+    task?.summary.push(parsed.result);
+    emitOutput2(taskId, "stdout", formatClaudeDoneNode(parsed));
+    extractMetrics(taskId, parsed, findActiveTask2);
+  }
+}
+function formatClaudeDoneNode(node) {
+  const lines = ["\n[done] Claude result"];
+  for (const key of ["subtype", "session_id", "duration_ms", "duration_api_ms", "num_turns", "total_cost_usd"]) {
+    const value = node[key];
+    if (value !== void 0 && value !== null) {
+      lines.push(`[done] ${key}: ${String(value)}`);
+    }
+  }
+  const usage = node.usage;
+  if (usage && typeof usage === "object") {
+    lines.push(`[done] usage: ${JSON.stringify(usage)}`);
+  }
+  const result = typeof node.result === "string" ? node.result.trim() : "";
+  if (result) {
+    lines.push(`[done] result: ${result}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function extractMetrics(taskId, node, findActiveTask2) {
+  const task = findActiveTask2(taskId);
+  if (!task) return;
+  if (typeof node.duration_ms === "number") task.resultMetrics.durationMs = node.duration_ms;
+  if (typeof node.duration_api_ms === "number") task.resultMetrics.durationApiMs = node.duration_api_ms;
+  if (typeof node.num_turns === "number") task.resultMetrics.numTurns = node.num_turns;
+  if (typeof node.total_cost_usd === "number") task.resultMetrics.totalCostUsd = node.total_cost_usd;
+  const usage = node.usage;
+  if (usage && typeof usage === "object") {
+    const u = usage;
+    if (typeof u.input_tokens === "number") task.resultMetrics.usageInputTokens = u.input_tokens;
+    if (typeof u.output_tokens === "number") task.resultMetrics.usageOutputTokens = u.output_tokens;
+    if (typeof u.cache_read_input_tokens === "number") task.resultMetrics.usageCacheReadTokens = u.cache_read_input_tokens;
+    if (typeof u.cache_creation_input_tokens === "number") task.resultMetrics.usageCacheCreationTokens = u.cache_creation_input_tokens;
+  }
+}
+function buildClaudeArgs(prompt, task, agentState2) {
+  ensureWorkspaceClaudeMd();
+  ensureClaudeHookFiles();
+  const cfg = task.cliConfig;
+  const args = [
+    "-p",
+    "--output-format",
+    "stream-json",
+    "--include-partial-messages",
+    "--verbose",
+    "--dangerously-skip-permissions"
+  ];
+  if (cfg?.model) {
+    args.push("--model", cfg.model);
+  }
+  if (cfg?.maxTurns) {
+    args.push("--max-turns", String(cfg.maxTurns));
+  }
+  if (cfg?.systemPrompt) {
+    args.push("--system-prompt", cfg.systemPrompt);
+  }
+  if (cfg?.appendSystemPrompt) {
+    args.push("--append-system-prompt", cfg.appendSystemPrompt);
+  }
+  if (cfg?.allowedTools && cfg.allowedTools.length > 0) {
+    for (const tool of cfg.allowedTools) {
+      args.push("--allowedTools", tool);
+    }
+  }
+  if (cfg?.disallowedTools && cfg.disallowedTools.length > 0) {
+    for (const tool of cfg.disallowedTools) {
+      args.push("--disallowedTools", tool);
+    }
+  }
+  if (cfg?.extraArgs) {
+    args.push(...cfg.extraArgs);
+  }
+  if (CLAUDE_HOOKS_ENABLED) {
+    args.push("--settings", CLAUDE_HOOK_SETTINGS);
+  }
+  if (task.targetMode === "queue") {
+    args.push("--session-id", task.claudeSessionId);
+  } else if (agentState2.sessionReady) {
+    args.push("--resume", agentState2.claudeSessionId);
+  } else {
+    args.push("--session-id", agentState2.claudeSessionId);
+  }
+  args.push(prompt);
+  return args;
+}
+function shouldRetryWithFreshClaudeSession(taskId, exitCode, findActiveTask2) {
+  const task = findActiveTask2(taskId);
+  return exitCode !== 0 && task !== null && task.targetMode !== "queue" && !task.cancelRequested && !task.retriedWithFreshSession && CLAUDE_MISSING_CONVERSATION_PATTERN.test(task.stderrTail);
+}
+function runFakeTask(taskId, prompt, deps) {
+  const { findActiveTask: findActiveTask2, send: send3, emitOutput: emitOutput2, finishTask: finishTask2 } = deps;
+  const task = findActiveTask2(taskId);
+  send3({ type: "task.started", taskId, pid: process.pid, sessionId: task?.claudeSessionId ?? null });
+  const steps = [
+    `\u6536\u5230\u4EFB\u52A1\uFF1A${prompt}
+`,
+    "\u5206\u6790\u4EFB\u52A1\u4E0A\u4E0B\u6587...\n",
+    "\u6267\u884C\u6A21\u62DF\u6B65\u9AA4 1/3...\n",
+    "\u6267\u884C\u6A21\u62DF\u6B65\u9AA4 2/3...\n",
+    "\u6267\u884C\u6A21\u62DF\u6B65\u9AA4 3/3...\n"
+  ];
+  let index = 0;
+  const timer = setInterval(() => {
+    const current = findActiveTask2(taskId);
+    if (!current) {
+      clearInterval(timer);
+      return;
+    }
+    if (index >= steps.length) {
+      clearInterval(timer);
+      finishTask2(taskId, "completed", 0);
+      return;
+    }
+    const chunk = steps[index];
+    current.summary.push(chunk);
+    emitOutput2(taskId, "stdout", chunk);
+    index += 1;
+  }, 800);
+}
+function runClaudeTask(taskId, prompt, workspace, deps) {
+  const {
+    findActiveTask: findActiveTask2,
+    send: send3,
+    emitOutput: emitOutput2,
+    emitStderr: emitStderr2,
+    finishTask: finishTask2,
+    getAgentState,
+    setAgentState
+  } = deps;
+  const currentTask = findActiveTask2(taskId);
+  if (!currentTask) {
+    return;
+  }
+  const agentState2 = getAgentState();
+  const args = buildClaudeArgs(prompt, currentTask, agentState2);
+  const resolvedWorkspace = resolveWorkspace(workspace);
+  const child = spawn("claude", args, {
+    cwd: resolvedWorkspace,
+    env: {
+      ...process.env,
+      AI_TEAMS_AGENT_ID: EMPLOYEE_ID,
+      AI_TEAMS_AGENT_NAME: EMPLOYEE_NAME,
+      AI_TEAMS_RECORD_DIR: AGENT_RECORDS_DIR,
+      AI_TEAMS_DEFAULT_WORKSPACE: DEFAULT_WORKSPACE,
+      AI_TEAMS_DEFAULT_SESSION_ID: agentState2.claudeSessionId,
+      AI_TEAMS_TASK_ID: currentTask.taskId,
+      AI_TEAMS_TASK_TARGET_MODE: currentTask.targetMode,
+      AI_TEAMS_TASK_SESSION_ID: currentTask.claudeSessionId,
+      AI_TEAMS_TASK_PROMPT: prompt,
+      AI_TEAMS_TASK_WORKSPACE: resolvedWorkspace
+    },
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const taskStillActive = findActiveTask2(taskId);
+  if (!taskStillActive) {
+    child.kill("SIGTERM");
+    return;
+  }
+  if (taskStillActive.cancelRequested) {
+    child.kill("SIGTERM");
+    return;
+  }
+  currentTask.generation += 1;
+  currentTask.child = child;
+  send3({ type: "task.started", taskId, pid: child.pid ?? 0, sessionId: currentTask.claudeSessionId });
+  const stdoutReader = readline.createInterface({ input: child.stdout });
+  stdoutReader.on("line", (line) => {
+    handleClaudeJsonLine(taskId, line, findActiveTask2, emitOutput2);
+  });
+  child.stderr.on("data", (chunk) => {
+    emitStderr2(taskId, chunk.toString());
+  });
+  child.on("error", (error) => {
+    finishTask2(taskId, "failed", error.message);
+  });
+  child.on("close", (code) => {
+    const task = findActiveTask2(taskId);
+    if (!task && code === null) {
+      return;
+    }
+    if (task?.cancelRequested) {
+      finishTask2(taskId, "cancelled");
+      return;
+    }
+    if (code === 0) {
+      finishTask2(taskId, "completed", 0);
+      return;
+    }
+    if (shouldRetryWithFreshClaudeSession(taskId, code, findActiveTask2)) {
+      const fresh = findActiveTask2(taskId);
+      if (!fresh) return;
+      if (fresh.cancelRequested) {
+        finishTask2(taskId, "cancelled");
+        return;
+      }
+      fresh.retriedWithFreshSession = true;
+      fresh.stderrTail = "";
+      fresh.sawStreamText = false;
+      fresh.child = null;
+      const newState = resetClaudeSession();
+      setAgentState(newState);
+      fresh.claudeSessionId = newState.claudeSessionId;
+      emitOutput2(taskId, "stdout", "\n[agent] Claude resume session was missing. Starting a new session and retrying this task.\n");
+      runClaudeTask(taskId, prompt, workspace, deps);
+      return;
+    }
+    finishTask2(taskId, "failed", `Claude CLI \u9000\u51FA\u7801 ${code ?? "unknown"}`);
+  });
+}
+
+// src/connection.ts
+import crypto from "node:crypto";
+import os3 from "node:os";
+import WebSocket from "ws";
+
+// ../../packages/shared/dist/index.js
+var ProtocolError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ProtocolError";
+  }
+};
+function parseJsonMessage(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new ProtocolError("Message is not valid JSON.");
+  }
+}
+function parseServerToEmployeeMessage(value) {
+  const message = objectValue(value, "message");
+  const type = stringField(message, "type");
+  if (type === "task.dispatch") {
+    return {
+      type,
+      taskId: nonEmptyStringField(message, "taskId"),
+      leaderCommandId: nonEmptyStringField(message, "leaderCommandId"),
+      employeeId: nonEmptyStringField(message, "employeeId"),
+      targetMode: taskTargetModeField(message, "targetMode"),
+      prompt: nonEmptyStringField(message, "prompt"),
+      workspace: nullableStringField(message, "workspace"),
+      timeoutSec: positiveNumberField(message, "timeoutSec"),
+      cliConfig: optionalCliConfigField(message, "cliConfig")
+    };
+  }
+  if (type === "task.cancel") {
+    return { type, taskId: nonEmptyStringField(message, "taskId") };
+  }
+  throw new ProtocolError(`Unsupported server-to-employee message type: ${type}`);
+}
+function objectValue(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new ProtocolError(`${label} must be an object.`);
+  }
+  return value;
+}
+function stringField(record, key) {
+  const value = record[key];
+  if (typeof value !== "string") {
+    throw new ProtocolError(`${key} must be a string.`);
+  }
+  return value;
+}
+function nonEmptyStringField(record, key) {
+  const value = stringField(record, key).trim();
+  if (!value) {
+    throw new ProtocolError(`${key} must not be empty.`);
+  }
+  return value;
+}
+function nullableStringField(record, key) {
+  const value = record[key];
+  if (value === null) {
+    return null;
+  }
+  if (typeof value !== "string") {
+    throw new ProtocolError(`${key} must be a string or null.`);
+  }
+  return value;
+}
+function taskTargetModeField(record, key) {
+  const value = record[key];
+  if (value === "queue" || value === "direct" || value === "broadcast") {
+    return value;
+  }
+  throw new ProtocolError(`${key} must be queue, direct, or broadcast.`);
+}
+function positiveNumberField(record, key) {
+  const value = record[key];
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    throw new ProtocolError(`${key} must be a positive number.`);
+  }
+  return value;
+}
+function optionalCliConfigField(record, key) {
+  const value = record[key];
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new ProtocolError(`${key} must be an object or null.`);
+  }
+  return value;
+}
+function isEncryptedEnvelope(value) {
+  return typeof value === "object" && value !== null && value.encrypted === true && typeof value.iv === "string" && typeof value.ciphertext === "string" && typeof value.tag === "string";
+}
+function parseEncryptionKey(hex) {
+  const key = Buffer.from(hex, "hex");
+  if (key.length !== 32) {
+    throw new Error("AI_TEAMS_ENCRYPTION_KEY must be 32 bytes (64 hex characters).");
+  }
+  return key;
+}
+
+// src/connection.ts
+var ALGORITHM = "aes-256-gcm";
+var IV_LENGTH = 12;
+var TAG_LENGTH = 16;
+var encryptionKeyHex = process.env.AI_TEAMS_ENCRYPTION_KEY;
+var encryptionKey = encryptionKeyHex ? parseEncryptionKey(encryptionKeyHex) : null;
+function encrypt(plainText) {
+  if (!encryptionKey) return plainText;
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const cipher = crypto.createCipheriv(ALGORITHM, encryptionKey, iv, { authTagLength: TAG_LENGTH });
+  const encrypted = Buffer.concat([cipher.update(plainText, "utf8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return JSON.stringify({
+    encrypted: true,
+    iv: iv.toString("base64"),
+    ciphertext: encrypted.toString("base64"),
+    tag: tag.toString("base64")
+  });
+}
+function decrypt(raw) {
+  if (!encryptionKey) return raw;
+  const parsed = JSON.parse(raw);
+  if (!isEncryptedEnvelope(parsed)) return raw;
+  const iv = Buffer.from(parsed.iv, "base64");
+  const ciphertext = Buffer.from(parsed.ciphertext, "base64");
+  const tag = Buffer.from(parsed.tag, "base64");
+  const decipher = crypto.createDecipheriv(ALGORITHM, encryptionKey, iv, { authTagLength: TAG_LENGTH });
+  decipher.setAuthTag(tag);
+  return decipher.update(ciphertext) + decipher.final("utf8");
+}
+function buildAgentWsUrl() {
+  const url = new URL("/ws/agent", SERVER_URL);
+  url.searchParams.set("token", AUTH_TOKEN);
+  return url.toString();
+}
+function isTaskMessage(payload) {
+  return payload.type.startsWith("task.");
+}
+function send(state, payload) {
+  if (state.socket && state.socket.readyState === WebSocket.OPEN) {
+    state.socket.send(encrypt(JSON.stringify(payload)));
+    return;
+  }
+  if (isTaskMessage(payload)) {
+    state.bufferedMessages.push(payload);
+    if (state.bufferedMessages.length > MAX_BUFFERED_MESSAGES) {
+      state.bufferedMessages = state.bufferedMessages.slice(-MAX_BUFFERED_MESSAGES);
+    }
+  }
+}
+function flushBufferedMessages(state) {
+  if (!state.socket || state.socket.readyState !== WebSocket.OPEN || state.bufferedMessages.length === 0) {
+    return;
+  }
+  const messages = state.bufferedMessages;
+  state.bufferedMessages = [];
+  for (const message of messages) {
+    state.socket.send(encrypt(JSON.stringify(message)));
+  }
+}
+function startHeartbeat(state) {
+  if (state.heartbeatTimer) {
+    clearInterval(state.heartbeatTimer);
+  }
+  state.heartbeatTimer = setInterval(() => {
+    send(state, { type: "agent.heartbeat", employeeId: EMPLOYEE_ID });
+  }, 1e4);
+}
+function scheduleReconnect(state, connectFn) {
+  if (state.reconnectTimer) {
+    return;
+  }
+  state.reconnectTimer = setTimeout(() => {
+    state.reconnectTimer = null;
+    connectFn();
+  }, RECONNECT_MS);
+}
+function registerAgent(state, mainTask2, queueTask2) {
+  send(state, {
+    type: "agent.register",
+    employeeId: EMPLOYEE_ID,
+    name: EMPLOYEE_NAME,
+    machineId: EMPLOYEE_ID,
+    hostname: os3.hostname(),
+    labels: EMPLOYEE_LABELS,
+    activeMainTaskId: mainTask2?.taskId ?? null,
+    activeQueueTaskId: queueTask2?.taskId ?? null,
+    lastOutputSeq: Math.max(mainTask2?.seq ?? 0, queueTask2?.seq ?? 0)
+  });
+}
+function requestTask(state) {
+  send(state, { type: "agent.request_task", employeeId: EMPLOYEE_ID });
+}
+function connect(state, getMainTask, getQueueTask, onMessage) {
+  if (!AUTH_TOKEN) {
+    console.error("[agent] AI_TEAMS_AUTH_TOKEN is required.");
+    process.exit(1);
+  }
+  state.socket = new WebSocket(buildAgentWsUrl());
+  state.socket.on("open", () => {
+    console.log(`[agent:${EMPLOYEE_ID}] connected to ${SERVER_URL}`);
+    registerAgent(state, getMainTask(), getQueueTask());
+    flushBufferedMessages(state);
+    requestTask(state);
+    startHeartbeat(state);
+  });
+  state.socket.on("message", (raw) => {
+    try {
+      const decrypted = decrypt(raw.toString());
+      const message = parseServerToEmployeeMessage(parseJsonMessage(decrypted));
+      onMessage(message);
+    } catch (error) {
+      console.error(`[agent:${EMPLOYEE_ID}] invalid server message`, error);
+    }
+  });
+  state.socket.on("close", () => {
+    console.log(`[agent:${EMPLOYEE_ID}] disconnected, reconnecting in ${RECONNECT_MS}ms...`);
+    scheduleReconnect(state, () => connect(state, getMainTask, getQueueTask, onMessage));
+  });
+  state.socket.on("error", (error) => {
+    console.error(`[agent:${EMPLOYEE_ID}] websocket error`, error.message);
+  });
+}
+
+// src/index.ts
+var mainTask = null;
+var queueTask = null;
+var agentState = loadState();
+var connState = {
+  socket: null,
+  reconnectTimer: null,
+  heartbeatTimer: null,
+  bufferedMessages: []
+};
+function findActiveTask(taskId) {
+  if (mainTask?.taskId === taskId) return mainTask;
+  if (queueTask?.taskId === taskId) return queueTask;
+  return null;
+}
+function slotForTargetMode(mode) {
+  if (mode === "queue") {
+    return { get: () => queueTask, set: (t) => {
+      queueTask = t;
+    } };
+  }
+  return { get: () => mainTask, set: (t) => {
+    mainTask = t;
+  } };
+}
+function send2(payload) {
+  send(connState, payload);
+}
+function emitOutput(taskId, stream, content) {
+  const task = findActiveTask(taskId);
+  if (!task || !content) return;
+  task.seq += 1;
+  send2({
+    type: "task.output",
+    taskId,
+    stream,
+    seq: task.seq,
+    content
+  });
+}
+function emitStderr(taskId, content) {
+  const task = findActiveTask(taskId);
+  if (!task || !content) return;
+  task.stderrTail = `${task.stderrTail}${content}`.slice(-MAX_ERROR_TAIL);
+  emitOutput(taskId, "stderr", content);
+}
+function requestTask2() {
+  send2({ type: "agent.request_task", employeeId: EMPLOYEE_ID });
+}
+function finishTask(taskId, status, payload) {
+  const current = findActiveTask(taskId);
+  if (!current) return;
+  const slot = slotForTargetMode(current.targetMode);
+  slot.set(null);
+  recordTaskFinish(current, status, payload);
+  if (status === "completed") {
+    if (current.targetMode !== "queue") {
+      agentState.sessionReady = true;
+      persistState(agentState);
+    }
+    send2({
+      type: "task.completed",
+      taskId,
+      exitCode: typeof payload === "number" ? payload : 0,
+      summary: current.summary.join("").trim().slice(0, 8e3) || "Claude \u5DF2\u5B8C\u6210\u4EFB\u52A1\u3002",
+      ...current.resultMetrics
+    });
+    if (current.targetMode === "queue") requestTask2();
+    return;
+  }
+  if (status === "cancelled") {
+    send2({ type: "task.cancelled", taskId });
+    if (current.targetMode === "queue") requestTask2();
+    return;
+  }
+  send2({
+    type: "task.failed",
+    taskId,
+    error: typeof payload === "string" ? payload : "\u4EFB\u52A1\u6267\u884C\u5931\u8D25\u3002"
+  });
+  if (current.targetMode === "queue") requestTask2();
+}
+var runnerDeps = {
+  findActiveTask,
+  emitOutput,
+  emitStderr,
+  finishTask,
+  send: send2,
+  getAgentState: () => agentState,
+  setAgentState: (state) => {
+    agentState = state;
+  }
+};
+function startTask(message) {
+  const slot = slotForTargetMode(message.targetMode);
+  if (slot.get()) {
+    send2({
+      type: "task.failed",
+      taskId: message.taskId,
+      error: `\u5458\u5DE5\u5F53\u524D\u5FD9\u788C\uFF0C${message.targetMode === "queue" ? "\u961F\u5217" : "\u4E3B"}\u4EFB\u52A1\u69FD\u6B63\u5728\u6267\u884C\u4EFB\u52A1 ${slot.get().taskId}\u3002`
+    });
+    return;
+  }
+  const task = {
+    taskId: message.taskId,
+    seq: 0,
+    child: null,
+    summary: [],
+    cancelRequested: false,
+    sawStreamText: false,
+    stderrTail: "",
+    retriedWithFreshSession: false,
+    generation: 0,
+    targetMode: message.targetMode,
+    claudeSessionId: message.targetMode === "queue" ? randomUUID2() : agentState.claudeSessionId,
+    cliConfig: message.cliConfig ?? null,
+    resultMetrics: {}
+  };
+  slot.set(task);
+  send2({ type: "task.accepted", taskId: message.taskId });
+  recordTaskStart(task, message.prompt, message.workspace);
+  if (RUNNER_MODE === "fake") {
+    runFakeTask(message.taskId, message.prompt, runnerDeps);
+    return;
+  }
+  runClaudeTask(message.taskId, message.prompt, message.workspace, runnerDeps);
+}
+function cancelTask(taskId) {
+  const task = findActiveTask(taskId);
+  if (!task) return;
+  task.cancelRequested = true;
+  if (task.child) {
+    const gen = task.generation;
+    task.child.kill("SIGTERM");
+    setTimeout(() => {
+      const t = findActiveTask(taskId);
+      if (t && t.generation === gen && t.child) t.child.kill("SIGKILL");
+    }, 3e3);
+  } else {
+    finishTask(taskId, "cancelled");
+  }
+}
+function handleServerMessage(message) {
+  if (message.type === "task.dispatch") {
+    startTask(message);
+    return;
+  }
+  cancelTask(message.taskId);
+}
+function connect2() {
+  connect(connState, () => mainTask, () => queueTask, handleServerMessage);
+}
+var shuttingDown = false;
+function gracefulShutdown(signal) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  console.log(`[agent:${EMPLOYEE_ID}] received ${signal}, shutting down...`);
+  for (const task of [mainTask, queueTask]) {
+    if (!task) continue;
+    task.cancelRequested = true;
+    task.child?.kill("SIGTERM");
+    send2({ type: "task.cancelled", taskId: task.taskId });
+  }
+  setTimeout(() => {
+    for (const task of [mainTask, queueTask]) {
+      task?.child?.kill("SIGKILL");
+    }
+  }, 2e3);
+  if (connState.reconnectTimer) clearTimeout(connState.reconnectTimer);
+  if (connState.heartbeatTimer) clearInterval(connState.heartbeatTimer);
+  if (connState.socket && connState.socket.readyState === WebSocket2.OPEN) {
+    connState.socket.close(1e3, "agent shutting down");
+  }
+  setTimeout(() => process.exit(0), 500);
+}
+process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
+process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+var isCli = process.argv[1] === fileURLToPath(import.meta.url);
+if (isCli) {
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`ai-teams-agent \u2014 AI Teams \u5458\u5DE5\u4EE3\u7406
+
+\u7528\u6CD5: ai-teams-agent [\u9009\u9879]
+
+\u9009\u9879:
+  --server <url>        \u670D\u52A1\u5668\u5730\u5740
+  --token <token>       \u8BA4\u8BC1 Token
+  --id <id>             \u5458\u5DE5 ID
+  --name <name>         \u5458\u5DE5\u540D\u79F0
+  --workspace <dir>     \u5DE5\u4F5C\u76EE\u5F55
+  --runner <mode>       Runner \u6A21\u5F0F (claude/fake)
+  --config              \u91CD\u65B0\u8FD0\u884C\u914D\u7F6E\u5411\u5BFC
+  -h, --help            \u663E\u793A\u5E2E\u52A9
+`);
+    process.exit(0);
+  }
+  if (args.includes("--config")) {
+    void runSetup(loadConfigFile()).then(() => {
+      console.log("  \u2713 \u91CD\u65B0\u914D\u7F6E\u5B8C\u6210\uFF0C\u8BF7\u91CD\u65B0\u542F\u52A8 agent\u3002");
+      process.exit(0);
+    });
+  } else {
+    void (async () => {
+      const fileConfig2 = loadConfigFile();
+      const hasEnvConfig = process.env.AI_TEAMS_AUTH_TOKEN || process.env.SERVER_URL;
+      if (!fileConfig2 && !hasEnvConfig) {
+        console.log("\n  \u26A0 \u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\u4E14\u672A\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF\uFF0C\u542F\u52A8\u914D\u7F6E\u5411\u5BFC...\n");
+        await runSetup(null);
+      }
+      function getArgValue(name) {
+        const idx = args.indexOf(name);
+        if (idx === -1) return void 0;
+        return args[idx + 1];
+      }
+      const cliServer = getArgValue("--server");
+      const cliToken = getArgValue("--token");
+      const cliId = getArgValue("--id");
+      const cliName = getArgValue("--name");
+      const cliWorkspace = getArgValue("--workspace");
+      const cliRunner = getArgValue("--runner");
+      if (cliServer) process.env.SERVER_URL = cliServer;
+      if (cliToken) process.env.AI_TEAMS_AUTH_TOKEN = cliToken;
+      if (cliId) process.env.EMPLOYEE_ID = cliId;
+      if (cliName) process.env.EMPLOYEE_NAME = cliName;
+      if (cliWorkspace) process.env.DEFAULT_WORKSPACE = cliWorkspace;
+      if (cliRunner) process.env.RUNNER_MODE = cliRunner;
+      console.log(`  \u2713 \u6B63\u5728\u8FDE\u63A5\u670D\u52A1\u5668...`);
+      connect2();
+    })();
+  }
+}
+export {
+  connect2 as connect
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@csdwd/ai-teams-agent",
+  "version": "0.1.0",
+  "description": "AI Teams agent — connects to server via WebSocket, spawns Claude CLI to execute tasks",
+  "type": "module",
+  "bin": {
+    "ai-teams-agent": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "node ../../scripts/build-bundle.js agent",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@ai-teams/shared": "workspace:*",
+    "@types/node": "^24.5.2",
+    "@types/ws": "^8.5.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/siliconbeat/ai-teams.git",
+    "directory": "apps/agent"
+  },
+  "license": "MIT",
+  "keywords": [
+    "ai-teams",
+    "ai-agent",
+    "claude",
+    "websocket"
+  ]
+}