@mclawnet/agent 0.2.0 → 0.2.1

package/dist/chunk-YBQQZNRQ.js

@@ -0,0 +1,780 @@
+// src/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir, hostname } from "os";
+var CONFIG_DIR = join(homedir(), ".clawnet");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var DEFAULT_HUB_URL = process.env.CLAWNET_DEFAULT_HUB_URL || "ws://localhost:3000/ws/agent";
+var DEFAULTS = {
+  hubUrl: DEFAULT_HUB_URL,
+  token: "",
+  name: hostname(),
+  backendType: "claude-code"
+};
+function loadConfig(cliOpts = {}) {
+  let fileConfig = {};
+  if (existsSync(CONFIG_FILE)) {
+    try {
+      fileConfig = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    } catch {
+    }
+  }
+  return {
+    hubUrl: cliOpts.hubUrl ?? process.env.CLAWNET_HUB_URL ?? fileConfig.hubUrl ?? DEFAULTS.hubUrl,
+    token: cliOpts.token ?? process.env.CLAWNET_TOKEN ?? fileConfig.token ?? DEFAULTS.token,
+    name: cliOpts.name ?? process.env.CLAWNET_NAME ?? fileConfig.name ?? DEFAULTS.name,
+    backendType: cliOpts.backendType ?? process.env.CLAWNET_BACKEND_TYPE ?? fileConfig.backendType ?? DEFAULTS.backendType
+  };
+}
+function saveConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  let existing = {};
+  if (existsSync(CONFIG_FILE)) {
+    try {
+      existing = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    } catch {
+    }
+  }
+  const merged = { ...existing, ...config };
+  writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2) + "\n");
+}
+
+// src/hub-connection.ts
+import { hostname as osHostname } from "os";
+import WebSocket from "ws";
+import {
+  HEARTBEAT_INTERVAL_MS,
+  DEFAULT_RECONNECT_MS,
+  MAX_RECONNECT_MS,
+  WS_CLOSE_INVALID_TOKEN
+} from "@mclawnet/shared";
+import { listRecoverableSwarms, recoverSwarm, listRoles, loadRole, listRecoverableSwarmIds, deleteSwarmSnapshot } from "@mclawnet/swarm";
+
+// src/fs-handler.ts
+import { readdir } from "fs/promises";
+import { existsSync as existsSync2, readdirSync, statSync, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", "__pycache__", ".next", ".nuxt", ".cache"]);
+async function handleListDir(path) {
+  const target = path || "/";
+  const dirents = await readdir(target, { withFileTypes: true });
+  const entries = dirents.filter((d) => !(d.isDirectory() && SKIP_DIRS.has(d.name))).map((d) => ({
+    name: d.name,
+    type: d.isDirectory() ? "directory" : "file"
+  })).sort((a, b) => {
+    if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+  return { path: target, entries };
+}
+function getClaudeProjectsDir() {
+  return join2(homedir2(), ".claude", "projects");
+}
+function pathToProjectFolder(workDir) {
+  return workDir.replace(/:/g, "-").replace(/[/\\]/g, "-");
+}
+function extractWorkDirFromSessionFile(filePath) {
+  try {
+    const content = readFileSync2(filePath, "utf-8");
+    const lines = content.split("\n").filter((l) => l.trim());
+    for (const line of lines.slice(0, 5)) {
+      try {
+        const data = JSON.parse(line);
+        if (data.cwd) return data.cwd.replace(/\\/g, "/");
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function getWorkDirFromProjectFolder(folderPath, folderName) {
+  try {
+    const files = readdirSync(folderPath);
+    for (const file of files) {
+      if (file.endsWith(".jsonl")) {
+        const workDir = extractWorkDirFromSessionFile(join2(folderPath, file));
+        if (workDir) return workDir;
+      }
+    }
+  } catch {
+  }
+  if (/^[A-Za-z]--/.test(folderName)) {
+    return folderName.replace(/^([A-Za-z])--/, "$1:/").replace(/-/g, "/");
+  }
+  if (folderName.startsWith("-")) {
+    return "/" + folderName.substring(1).replace(/-/g, "/");
+  }
+  return folderName.replace(/-/g, "/");
+}
+async function handleListFolders() {
+  const projectsDir = getClaudeProjectsDir();
+  const folders = [];
+  if (!existsSync2(projectsDir)) return { folders };
+  const entries = readdirSync(projectsDir);
+  for (const entry of entries) {
+    const entryPath = join2(projectsDir, entry);
+    let entryStat;
+    try {
+      entryStat = statSync(entryPath);
+    } catch {
+      continue;
+    }
+    if (!entryStat.isDirectory()) continue;
+    if (entry.includes("--crew-roles-")) continue;
+    const originalPath = getWorkDirFromProjectFolder(entryPath, entry);
+    let sessionCount = 0;
+    let lastModified = entryStat.mtime.getTime();
+    try {
+      const files = readdirSync(entryPath);
+      for (const file of files) {
+        if (file.endsWith(".jsonl")) {
+          sessionCount++;
+          try {
+            const fileStats = statSync(join2(entryPath, file));
+            if (fileStats.mtime.getTime() > lastModified) {
+              lastModified = fileStats.mtime.getTime();
+            }
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+    folders.push({ path: originalPath, sessionCount, lastModified });
+  }
+  folders.sort((a, b) => (b.lastModified ?? 0) - (a.lastModified ?? 0));
+  return { folders };
+}
+async function handleListHistorySessions(workDir) {
+  const projectsDir = getClaudeProjectsDir();
+  const projectFolder = pathToProjectFolder(workDir);
+  const projectPath = join2(projectsDir, projectFolder);
+  if (!existsSync2(projectPath)) {
+    return { workDir, sessions: [] };
+  }
+  const sessions = [];
+  const files = readdirSync(projectPath);
+  for (const file of files) {
+    if (!file.endsWith(".jsonl")) continue;
+    const sessionId = file.replace(".jsonl", "");
+    const filePath = join2(projectPath, file);
+    let fileStats;
+    try {
+      fileStats = statSync(filePath);
+    } catch {
+      continue;
+    }
+    let title = "";
+    let hasUserMessage = false;
+    let customTitle = "";
+    let jsonlSummary = "";
+    try {
+      const content = readFileSync2(filePath, "utf-8");
+      const lines = content.split("\n").filter((l) => l.trim());
+      for (const line of lines) {
+        try {
+          const data = JSON.parse(line);
+          if (!hasUserMessage && data.type === "user" && data.message?.content) {
+            const text = typeof data.message.content === "string" ? data.message.content : data.message.content[0]?.text || "";
+            if (text.trim()) {
+              title = text.substring(0, 100);
+              hasUserMessage = true;
+            }
+          }
+          if (data.type === "custom-title" && data.customTitle) {
+            customTitle = data.customTitle;
+          }
+          if (data.type === "summary" && data.summary) {
+            jsonlSummary = data.summary;
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    if (hasUserMessage) {
+      sessions.push({
+        sessionId,
+        title: customTitle || jsonlSummary || title || sessionId.slice(0, 8),
+        workDir,
+        lastModified: fileStats.mtime.getTime()
+      });
+    }
+  }
+  sessions.sort((a, b) => (b.lastModified ?? 0) - (a.lastModified ?? 0));
+  return { workDir, sessions };
+}
+async function handleLoadSessionHistory(workDir, claudeSessionId) {
+  const projectsDir = getClaudeProjectsDir();
+  const projectFolder = pathToProjectFolder(workDir);
+  const filePath = join2(projectsDir, projectFolder, `${claudeSessionId}.jsonl`);
+  if (!existsSync2(filePath)) {
+    return { messages: [] };
+  }
+  const messages = [];
+  try {
+    const content = readFileSync2(filePath, "utf-8");
+    const lines = content.split("\n").filter((l) => l.trim());
+    for (const line of lines) {
+      try {
+        const data = JSON.parse(line);
+        if (data.type === "user" && data.message?.content) {
+          const blocks = Array.isArray(data.message.content) ? data.message.content : [{ type: "text", text: String(data.message.content) }];
+          const textParts = [];
+          for (const block of blocks) {
+            if (block.type === "text" && block.text?.trim()) {
+              textParts.push(block.text);
+            }
+          }
+          if (textParts.length > 0) {
+            messages.push({ role: "user", content: textParts.join("\n") });
+          }
+          const lastAssistant = messages.length > 0 ? [...messages].reverse().find((m) => m.role === "assistant" && m.toolCalls?.length) : void 0;
+          if (lastAssistant?.toolCalls) {
+            for (const block of blocks) {
+              if (block.type === "tool_result") {
+                const pending = lastAssistant.toolCalls.find((tc) => !tc.output);
+                if (pending) {
+                  pending.output = typeof block.content === "string" ? block.content : Array.isArray(block.content) ? block.content.map((c) => c.text ?? "").join("") : JSON.stringify(block.content);
+                  pending.status = block.is_error ? "error" : "done";
+                }
+              }
+            }
+          }
+        }
+        if (data.type === "assistant" && data.message?.content) {
+          let text = "";
+          const toolCalls = [];
+          let thinking = "";
+          for (const block of data.message.content) {
+            if (block.type === "text") {
+              text += block.text;
+            } else if (block.type === "tool_use") {
+              toolCalls.push({
+                name: block.name,
+                input: typeof block.input === "string" ? block.input : JSON.stringify(block.input, null, 2),
+                status: "done"
+              });
+            } else if (block.type === "thinking") {
+              thinking += block.thinking ?? "";
+            }
+          }
+          messages.push({
+            role: "assistant",
+            content: text,
+            toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+            thinking: thinking || void 0
+          });
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return { messages: messages.slice(-50) };
+}
+
+// src/hub-connection.ts
+import { createLogger } from "@mclawnet/logger";
+var log = createLogger({ module: "agent" });
+var HubConnection = class {
+  ws = null;
+  heartbeatTimer = null;
+  reconnectTimer = null;
+  reconnectDelay;
+  destroyed = false;
+  authState = "pending";
+  hubUrl;
+  token;
+  hostname;
+  version;
+  capabilities;
+  heartbeatInterval;
+  maxReconnectDelay;
+  /** Agent ID assigned by Hub after successful auth */
+  agentId = null;
+  /** Swarm IDs that have been completed/failed — prevents accidental recreation */
+  finishedSwarms = /* @__PURE__ */ new Set();
+  /** Session manager — set after construction via setSessionManager() */
+  sessionManager = null;
+  /** Swarm coordinator — set after construction via setSwarmCoordinator() */
+  swarmCoordinator = null;
+  onMessage;
+  onConnectCb;
+  onDisconnect;
+  onError;
+  constructor(opts) {
+    this.hubUrl = opts.hubUrl;
+    this.token = opts.token;
+    this.hostname = opts.hostname ?? osHostname();
+    this.version = opts.version;
+    this.capabilities = opts.capabilities;
+    this.heartbeatInterval = opts.heartbeatInterval ?? HEARTBEAT_INTERVAL_MS;
+    this.reconnectDelay = opts.reconnectDelay ?? DEFAULT_RECONNECT_MS;
+    this.maxReconnectDelay = opts.maxReconnectDelay ?? MAX_RECONNECT_MS;
+    this.onMessage = opts.onMessage;
+    this.onConnectCb = opts.onConnect;
+    this.onDisconnect = opts.onDisconnect;
+    this.onError = opts.onError;
+  }
+  setSessionManager(manager) {
+    this.sessionManager = manager;
+  }
+  setSwarmCoordinator(coordinator) {
+    this.swarmCoordinator = coordinator;
+  }
+  get readyState() {
+    return this.ws?.readyState ?? WebSocket.CLOSED;
+  }
+  get isConnected() {
+    return this.ws?.readyState === WebSocket.OPEN && this.authState === "authenticated";
+  }
+  connect() {
+    if (this.destroyed) return;
+    this.cleanup();
+    this.authState = "pending";
+    this.ws = new WebSocket(this.hubUrl);
+    this.ws.on("open", () => {
+      this.reconnectDelay = DEFAULT_RECONNECT_MS;
+    });
+    this.ws.on("message", (raw) => {
+      let data;
+      try {
+        data = JSON.parse(raw.toString());
+      } catch {
+        return;
+      }
+      if (this.authState === "pending" && data.type === "auth_required") {
+        this.authState = "authenticating";
+        this.sendRaw({
+          type: "auth",
+          token: this.token,
+          hostname: this.hostname,
+          version: this.version,
+          capabilities: this.capabilities
+        });
+        return;
+      }
+      if (this.authState === "authenticating" && data.type === "registered") {
+        this.authState = "authenticated";
+        this.agentId = data.agentId ?? null;
+        this.startHeartbeat();
+        this.onConnectCb?.(this.agentId);
+        this.tryRecoverSwarms();
+        return;
+      }
+      if (this.authState === "authenticated") {
+        if (this.handleSessionMessage(data)) return;
+        this.onMessage?.(data);
+      }
+    });
+    this.ws.on("close", (code, reason) => {
+      this.stopHeartbeat();
+      this.authState = "pending";
+      this.onDisconnect?.(code, reason.toString());
+      if (code === WS_CLOSE_INVALID_TOKEN) {
+        log.error("auth failed \u2014 not reconnecting, check your token");
+        return;
+      }
+      this.scheduleReconnect();
+    });
+    this.ws.on("error", (err) => {
+      this.onError?.(err);
+    });
+  }
+  send(data) {
+    const msg = data;
+    if (msg.type === "swarm.status" && (msg.swarmStatus === "completed" || msg.swarmStatus === "failed")) {
+      this.finishedSwarms.add(msg.sessionId);
+    }
+    return this.sendRaw(data);
+  }
+  destroy() {
+    this.destroyed = true;
+    this.cleanup();
+  }
+  // ── Session message handling ─────────────────────────────────────
+  handleSessionMessage(msg) {
+    if (msg.type === "fs.list_dir") {
+      handleListDir(msg.path).then((result) => {
+        this.send({ type: "fs.list_dir_result", requestId: msg.requestId, ...result });
+      }).catch((err) => {
+        this.send({
+          type: "fs.list_dir_result",
+          requestId: msg.requestId,
+          path: msg.path || "/",
+          entries: []
+        });
+      });
+      return true;
+    }
+    if (msg.type === "list_folders") {
+      handleListFolders().then((result) => {
+        this.send({ type: "folders_list_result", requestId: msg.requestId, ...result });
+      }).catch(() => {
+        this.send({ type: "folders_list_result", requestId: msg.requestId, folders: [] });
+      });
+      return true;
+    }
+    if (msg.type === "list_history_sessions") {
+      handleListHistorySessions(msg.workDir).then((result) => {
+        this.send({ type: "history_sessions_result", requestId: msg.requestId, ...result });
+      }).catch(() => {
+        this.send({
+          type: "history_sessions_result",
+          requestId: msg.requestId,
+          workDir: msg.workDir,
+          sessions: []
+        });
+      });
+      return true;
+    }
+    if (msg.type === "load_session_history") {
+      handleLoadSessionHistory(msg.workDir, msg.claudeSessionId).then((result) => {
+        this.send({ type: "session_history_result", requestId: msg.requestId, ...result });
+      }).catch(() => {
+        this.send({ type: "session_history_result", requestId: msg.requestId, messages: [] });
+      });
+      return true;
+    }
+    if (msg.type === "list_roles") {
+      const roleNames = listRoles();
+      const roles = roleNames.map((name) => {
+        try {
+          const def = loadRole(name);
+          return {
+            name: def.name,
+            displayName: def.shortName || def.name,
+            description: def.description || "",
+            capabilities: def.capabilities || [],
+            promptBody: def.promptBody || ""
+          };
+        } catch {
+          return { name, displayName: name, description: "", capabilities: [], promptBody: "" };
+        }
+      });
+      this.send({
+        type: "roles_list_result",
+        sessionId: msg.sessionId,
+        roles
+      });
+      return true;
+    }
+    if (msg.type === "swarm.execute" && this.swarmCoordinator) {
+      const { sessionId, content, workDir, targetInstance, crewConfig } = msg;
+      if (this.swarmCoordinator.hasSwarm(sessionId)) {
+        this.swarmCoordinator.handleUserMessage(sessionId, content, targetInstance).catch((err) => {
+          this.send({
+            type: "session.error",
+            sessionId,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
+      } else if (this.finishedSwarms.has(sessionId)) {
+        log.info({ sessionId }, "swarm.execute ignored: swarm already finished");
+        this.send({
+          type: "session.error",
+          sessionId,
+          error: "\u8702\u7FA4\u4EFB\u52A1\u5DF2\u5B8C\u6210\uFF0C\u65E0\u6CD5\u7EE7\u7EED\u64CD\u4F5C\u3002\u8BF7\u521B\u5EFA\u65B0\u7684\u8702\u7FA4\u4EFB\u52A1\u3002"
+        });
+      } else if (crewConfig?.roles) {
+        const roles = crewConfig.roles;
+        this.swarmCoordinator.create(sessionId, { workDir, roles, task: content }).catch((err) => {
+          this.send({
+            type: "session.error",
+            sessionId,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
+      } else {
+        log.info({ sessionId }, "swarm.execute ignored: swarm not found, no config");
+        this.send({
+          type: "session.error",
+          sessionId,
+          error: "\u8702\u7FA4\u4EFB\u52A1\u5DF2\u5B8C\u6210\uFF0C\u65E0\u6CD5\u7EE7\u7EED\u64CD\u4F5C\u3002\u8BF7\u521B\u5EFA\u65B0\u7684\u8702\u7FA4\u4EFB\u52A1\u3002"
+        });
+      }
+      return true;
+    }
+    if (!this.sessionManager) return false;
+    if (msg.type === "abort_execution") {
+      const { sessionId } = msg;
+      if (this.sessionManager?.hasSession(sessionId)) {
+        this.sessionManager.abortSession(sessionId).then(() => {
+          this.send({ type: "execution_aborted", sessionId });
+        }).catch(() => {
+          this.send({ type: "execution_aborted", sessionId });
+        });
+      } else {
+        this.send({ type: "execution_aborted", sessionId });
+      }
+      return true;
+    }
+    if (msg.type === "claude.execute") {
+      const { sessionId, content, workDir, claudeSessionId, useBrainCore } = msg;
+      if (this.sessionManager.hasSession(sessionId)) {
+        this.sessionManager.sendInput(sessionId, content);
+      } else {
+        this.sessionManager.createSession({ sessionId, workDir, resumeId: claudeSessionId, useBrainCore }).then(() => {
+          this.sessionManager.sendInput(sessionId, content);
+        }).catch((err) => {
+          this.send({
+            type: "session.error",
+            sessionId,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
+      }
+      return true;
+    }
+    if (msg.type === "session.create") {
+      this.sessionManager.createSession({
+        sessionId: msg.sessionId,
+        workDir: msg.workDir,
+        resumeId: msg.resumeId
+      }).then((claudeSessionId) => {
+        this.send({
+          type: "session.created",
+          sessionId: msg.sessionId,
+          claudeSessionId
+        });
+      }).catch((err) => {
+        this.send({
+          type: "session.error",
+          sessionId: msg.sessionId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+      return true;
+    }
+    if (msg.type === "session.close") {
+      this.sessionManager.closeSession(msg.sessionId).catch(() => {
+      });
+      return true;
+    }
+    if (msg.type === "claude.input") {
+      this.sessionManager.sendInput(msg.sessionId, msg.content);
+      return true;
+    }
+    return false;
+  }
+  // ── Internal helpers ─────────────────────────────────────────────
+  tryRecoverSwarms() {
+    if (!this.swarmCoordinator) return;
+    try {
+      const allIds = listRecoverableSwarmIds();
+      const snapshots = listRecoverableSwarms();
+      const recoverableIds = new Set(snapshots.map((s) => s.id));
+      for (const id of allIds) {
+        if (!recoverableIds.has(id)) {
+          deleteSwarmSnapshot(id);
+          log.info({ swarmId: id }, "cleaned up non-recoverable swarm snapshot");
+        }
+      }
+      for (const snap of snapshots) {
+        log.info({ swarmId: snap.id }, "recovering swarm");
+        recoverSwarm(this.swarmCoordinator, snap).catch((err) => {
+          log.error({ err, swarmId: snap.id }, "failed to recover swarm");
+        });
+      }
+    } catch (err) {
+      log.error({ err }, "swarm recovery failed");
+    }
+  }
+  sendRaw(data) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return false;
+    this.ws.send(JSON.stringify(data));
+    return true;
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      this.send({ type: "heartbeat", ts: Date.now() });
+    }, this.heartbeatInterval);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  scheduleReconnect() {
+    if (this.destroyed) return;
+    this.reconnectTimer = setTimeout(() => {
+      this.connect();
+    }, this.reconnectDelay);
+    this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
+  }
+  cleanup() {
+    this.stopHeartbeat();
+    this.sessionManager?.closeAll().catch(() => {
+    });
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.removeAllListeners();
+      if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+        this.ws.close();
+      }
+      this.ws = null;
+    }
+  }
+};
+
+// src/session-manager.ts
+var SessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  adapter;
+  onOutput;
+  onTurnComplete;
+  onSessionError;
+  constructor(options) {
+    this.adapter = options.adapter;
+    this.onOutput = options.onOutput;
+    this.onTurnComplete = options.onTurnComplete;
+    this.onSessionError = options.onSessionError;
+  }
+  async createSession(options) {
+    if (this.sessions.has(options.sessionId)) {
+      throw new Error(`Session ${options.sessionId} already exists`);
+    }
+    try {
+      const process2 = await this.adapter.spawn(options);
+      this.sessions.set(options.sessionId, process2);
+      this.adapter.onOutput(process2, (data) => {
+        this.onOutput(options.sessionId, data);
+      });
+      this.adapter.onTurnComplete?.(process2, (info) => {
+        this.onTurnComplete(options.sessionId, info);
+      });
+      this.adapter.onError?.(process2, (error) => {
+        this.onSessionError(options.sessionId, error.message);
+      });
+      return process2.id;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.onSessionError(options.sessionId, message);
+      throw err;
+    }
+  }
+  sendInput(sessionId, input) {
+    const process2 = this.sessions.get(sessionId);
+    if (!process2) {
+      this.onSessionError(sessionId, `No active session: ${sessionId}`);
+      return;
+    }
+    this.adapter.send(process2, input);
+  }
+  async abortSession(sessionId) {
+    const process2 = this.sessions.get(sessionId);
+    if (!process2) return;
+    this.sessions.delete(sessionId);
+    await this.adapter.stop(process2);
+  }
+  async closeSession(sessionId) {
+    const process2 = this.sessions.get(sessionId);
+    if (!process2) return;
+    this.sessions.delete(sessionId);
+    await this.adapter.stop(process2);
+  }
+  async closeAll() {
+    const promises = Array.from(this.sessions.entries()).map(
+      async ([sessionId, process2]) => {
+        this.sessions.delete(sessionId);
+        await this.adapter.stop(process2).catch(() => {
+        });
+      }
+    );
+    await Promise.all(promises);
+  }
+  hasSession(sessionId) {
+    return this.sessions.has(sessionId);
+  }
+  get activeSessionCount() {
+    return this.sessions.size;
+  }
+};
+
+// src/start.ts
+import { SwarmCoordinator, initRoles } from "@mclawnet/swarm";
+import { createLogger as createLogger2 } from "@mclawnet/logger";
+var log2 = createLogger2({ module: "agent" });
+async function startAgent(options) {
+  const config = loadConfig(options.config);
+  if (!config.token) {
+    log2.error("no token configured \u2014 set CLAWNET_TOKEN or use --token");
+    process.exit(1);
+  }
+  log2.info({ backend: options.adapter.type }, "starting agent");
+  log2.info({ hubUrl: config.hubUrl }, "connecting to hub");
+  await initRoles();
+  const hub = new HubConnection({
+    hubUrl: config.hubUrl,
+    token: config.token,
+    hostname: config.name,
+    onConnect: (agentId) => {
+      log2.info({ agentId }, "connected to hub");
+    },
+    onDisconnect: (code, reason) => {
+      log2.info({ code, reason }, "disconnected from hub");
+    },
+    onError: (err) => {
+      log2.error({ err }, "hub connection error");
+    }
+  });
+  let swarmCoordinator;
+  const sessionManager = new SessionManager({
+    adapter: options.adapter,
+    onOutput: (sessionId, data) => {
+      if (swarmCoordinator.handleRoleOutput(sessionId, data)) return;
+      hub.send({
+        type: "claude.output",
+        sessionId,
+        data
+      });
+    },
+    onTurnComplete: (sessionId, info) => {
+      if (swarmCoordinator.handleRoleTurnComplete(sessionId, info)) return;
+      hub.send({
+        type: "claude.turn_complete",
+        sessionId,
+        cost: info.cost,
+        duration: info.duration,
+        contextUsage: info.contextUsage
+      });
+    },
+    onSessionError: (sessionId, error) => {
+      hub.send({
+        type: "session.error",
+        sessionId,
+        error
+      });
+    }
+  });
+  swarmCoordinator = new SwarmCoordinator(sessionManager, hub);
+  hub.setSessionManager(sessionManager);
+  hub.setSwarmCoordinator(swarmCoordinator);
+  const shutdown = async () => {
+    log2.info("shutting down");
+    await sessionManager.closeAll();
+    hub.destroy();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  hub.connect();
+  return { hub, sessionManager, swarmCoordinator };
+}
+
+export {
+  HubConnection,
+  SessionManager,
+  loadConfig,
+  saveConfig,
+  startAgent
+};
+//# sourceMappingURL=chunk-YBQQZNRQ.js.map