@annals/agent-mesh 0.12.0

package/dist/index.js

@@ -0,0 +1,4106 @@
+#!/usr/bin/env node
+import {
+  log,
+  readOpenClawToken
+} from "./chunk-W24WCWEC.js";
+import {
+  BOLD,
+  GRAY,
+  GREEN,
+  RESET,
+  YELLOW,
+  addAgent,
+  findAgentByAgentId,
+  getAgent,
+  getAgentWorkspaceDir,
+  getConfigPath,
+  getLogPath,
+  isProcessAlive,
+  listAgents,
+  loadConfig,
+  readPid,
+  registerListCommand,
+  removeAgent,
+  removePid,
+  renderTable,
+  spawnBackground,
+  stopProcess,
+  uniqueSlug,
+  updateConfig,
+  writePid
+} from "./chunk-GIEYJIVW.js";
+
+// src/index.ts
+import { createRequire } from "module";
+import { program } from "commander";
+
+// src/platform/auth.ts
+function loadToken() {
+  return loadConfig().token;
+}
+function saveToken(token) {
+  updateConfig({ token });
+}
+function hasToken() {
+  return !!loadToken();
+}
+
+// src/platform/ws-client.ts
+import { EventEmitter } from "events";
+import WebSocket from "ws";
+import { BRIDGE_PROTOCOL_VERSION, WS_CLOSE_REPLACED, WS_CLOSE_TOKEN_REVOKED } from "@annals/bridge-protocol";
+var HEARTBEAT_INTERVAL = 2e4;
+var INITIAL_RECONNECT_DELAY = 1e3;
+var MAX_RECONNECT_DELAY = 3e4;
+var BridgeWSClient = class extends EventEmitter {
+  ws = null;
+  heartbeatTimer = null;
+  reconnectTimer = null;
+  reconnectDelay = INITIAL_RECONNECT_DELAY;
+  startTime = Date.now();
+  activeSessions = 0;
+  intentionalClose = false;
+  registered = false;
+  sendWarnSuppressed = false;
+  opts;
+  constructor(opts) {
+    super();
+    this.opts = opts;
+  }
+  async connect() {
+    return new Promise((resolve2, reject) => {
+      this.intentionalClose = false;
+      this.registered = false;
+      try {
+        const wsUrl = new URL(this.opts.url);
+        wsUrl.searchParams.set("agent_id", this.opts.agentId);
+        this.ws = new WebSocket(wsUrl.toString());
+      } catch (err) {
+        reject(new Error(`Failed to create WebSocket: ${err}`));
+        return;
+      }
+      const onFirstRegistered = (msg) => {
+        if (msg.type === "registered") {
+          this.off("_raw", onFirstRegistered);
+          if (msg.status === "ok") {
+            this.registered = true;
+            this.reconnectDelay = INITIAL_RECONNECT_DELAY;
+            this.startHeartbeat();
+            resolve2();
+          } else {
+            reject(new Error(`Registration failed: ${msg.error || "unknown"}`));
+          }
+        }
+      };
+      this.on("_raw", onFirstRegistered);
+      this.ws.on("open", () => {
+        log.debug("WebSocket connected, sending register...");
+        const reg = {
+          type: "register",
+          agent_id: this.opts.agentId,
+          token: this.opts.token,
+          bridge_version: String(BRIDGE_PROTOCOL_VERSION),
+          agent_type: this.opts.agentType,
+          capabilities: this.opts.capabilities || []
+        };
+        this.ws.send(JSON.stringify(reg));
+      });
+      this.ws.on("message", (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          this.emit("_raw", msg);
+          if (this.registered) {
+            this.emit("message", msg);
+          }
+        } catch {
+          log.debug("Failed to parse message from worker");
+        }
+      });
+      this.ws.on("close", (code, reason) => {
+        this.stopHeartbeat();
+        this.registered = false;
+        if (this.intentionalClose) {
+          log.info("Connection closed");
+          this.emit("close");
+        } else if (code === WS_CLOSE_REPLACED) {
+          log.error("Another CLI has connected for this agent. This instance is being replaced.");
+          this.emit("replaced");
+        } else if (code === WS_CLOSE_TOKEN_REVOKED) {
+          log.error("Your CLI token has been revoked. Please create a new token and reconnect.");
+          this.emit("token_revoked");
+        } else {
+          const reasonStr = reason ? reason.toString() : "";
+          log.warn(`Connection lost (${code}: ${reasonStr}), reconnecting in ${this.reconnectDelay}ms...`);
+          this.emit("disconnect");
+          this.scheduleReconnect();
+        }
+      });
+      this.ws.on("error", (err) => {
+        log.error(`WebSocket error: ${err.message}`);
+      });
+      setTimeout(() => {
+        if (!this.registered) {
+          this.off("_raw", onFirstRegistered);
+          reject(new Error("Registration timed out"));
+          this.ws?.close();
+        }
+      }, 15e3);
+    });
+  }
+  send(msg) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.sendWarnSuppressed = false;
+      this.ws.send(JSON.stringify(msg));
+    } else {
+      if (!this.sendWarnSuppressed) {
+        log.warn("Cannot send: WebSocket not connected (suppressing further warnings until reconnect)");
+        this.sendWarnSuppressed = true;
+      }
+    }
+  }
+  onMessage(cb) {
+    this.on("message", cb);
+  }
+  setActiveSessions(count) {
+    this.activeSessions = count;
+  }
+  close() {
+    this.intentionalClose = true;
+    this.stopHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  get isConnected() {
+    return this.registered && this.ws?.readyState === WebSocket.OPEN;
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      this.send({
+        type: "heartbeat",
+        active_sessions: this.activeSessions,
+        uptime_ms: Date.now() - this.startTime
+      });
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        try {
+          this.ws.ping();
+        } catch {
+        }
+      }
+    }, HEARTBEAT_INTERVAL);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer) return;
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      if (this.ws) {
+        try {
+          this.ws.close();
+        } catch {
+        }
+        this.ws = null;
+      }
+      try {
+        log.info("Attempting reconnect...");
+        await this.connect();
+        log.success("Reconnected to bridge worker");
+        this.emit("reconnect");
+      } catch (err) {
+        log.error(`Reconnect failed: ${err}`);
+        this.reconnectDelay = Math.min(this.reconnectDelay * 2, MAX_RECONNECT_DELAY);
+        this.scheduleReconnect();
+      }
+    }, this.reconnectDelay);
+  }
+};
+
+// src/bridge/manager.ts
+import { BridgeErrorCode } from "@annals/bridge-protocol";
+
+// src/bridge/session-pool.ts
+var SessionPool = class {
+  sessions = /* @__PURE__ */ new Map();
+  get(sessionId) {
+    const entry = this.sessions.get(sessionId);
+    if (entry) {
+      entry.lastActiveAt = Date.now();
+    }
+    return entry?.handle;
+  }
+  set(sessionId, handle) {
+    const now = Date.now();
+    this.sessions.set(sessionId, {
+      sessionId,
+      handle,
+      createdAt: now,
+      lastActiveAt: now
+    });
+  }
+  delete(sessionId) {
+    this.sessions.delete(sessionId);
+  }
+  has(sessionId) {
+    return this.sessions.has(sessionId);
+  }
+  get size() {
+    return this.sessions.size;
+  }
+  clear() {
+    for (const [id, entry] of this.sessions) {
+      log.debug(`Cleaning up session ${id}`);
+      entry.handle.kill();
+    }
+    this.sessions.clear();
+  }
+  keys() {
+    return this.sessions.keys();
+  }
+};
+
+// src/bridge/manager.ts
+var DUPLICATE_REQUEST_TTL_MS = 10 * 6e4;
+var SESSION_SWEEP_INTERVAL_MS = 6e4;
+var DEFAULT_SESSION_IDLE_TTL_MS = 10 * 6e4;
+var MIN_SESSION_IDLE_TTL_MS = 6e4;
+function resolveSessionIdleTtlMs() {
+  const raw = process.env.AGENT_BRIDGE_SESSION_IDLE_TTL_MS;
+  if (!raw) {
+    return DEFAULT_SESSION_IDLE_TTL_MS;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < MIN_SESSION_IDLE_TTL_MS) {
+    return DEFAULT_SESSION_IDLE_TTL_MS;
+  }
+  return parsed;
+}
+var SESSION_IDLE_TTL_MS = resolveSessionIdleTtlMs();
+var BridgeManager = class {
+  wsClient;
+  adapter;
+  adapterConfig;
+  pool = new SessionPool();
+  /** Mutable ref to track the active requestId per session */
+  activeRequests = /* @__PURE__ */ new Map();
+  /** Sessions that already have callbacks wired */
+  wiredSessions = /* @__PURE__ */ new Set();
+  /** request_id replay protection: key = session_id:request_id */
+  requestTracker = /* @__PURE__ */ new Map();
+  /** Last activity timestamp per session for idle cleanup */
+  sessionLastSeenAt = /* @__PURE__ */ new Map();
+  cleanupTimer = null;
+  constructor(opts) {
+    this.wsClient = opts.wsClient;
+    this.adapter = opts.adapter;
+    this.adapterConfig = opts.adapterConfig;
+  }
+  start() {
+    this.wsClient.onMessage((msg) => this.handleWorkerMessage(msg));
+    this.cleanupTimer = setInterval(() => {
+      this.pruneIdleSessions();
+    }, SESSION_SWEEP_INTERVAL_MS);
+    this.cleanupTimer.unref?.();
+    log.info(`Bridge manager started with ${this.adapter.displayName} adapter`);
+  }
+  stop() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    for (const sessionId of Array.from(this.pool.keys())) {
+      this.destroySession(sessionId, "manager_stop");
+    }
+    this.requestTracker.clear();
+    this.activeRequests.clear();
+    this.wiredSessions.clear();
+    this.sessionLastSeenAt.clear();
+    log.info("Bridge manager stopped");
+  }
+  /**
+   * Lightweight reconnect: tear down stale sessions and reset tracking
+   * WITHOUT re-registering message handlers (avoids callback stacking)
+   * or restarting the cleanup timer (still running from initial start()).
+   */
+  reconnect() {
+    for (const sessionId of Array.from(this.pool.keys())) {
+      this.destroySession(sessionId, "reconnect");
+    }
+    this.requestTracker.clear();
+    this.activeRequests.clear();
+    this.wiredSessions.clear();
+    this.sessionLastSeenAt.clear();
+    log.info("Bridge manager reconnected");
+  }
+  get sessionCount() {
+    return this.pool.size;
+  }
+  handleWorkerMessage(msg) {
+    switch (msg.type) {
+      case "message":
+        this.handleMessage(msg);
+        break;
+      case "cancel":
+        this.handleCancel(msg);
+        break;
+      case "registered":
+        break;
+      default:
+        log.warn(`Unknown message type from worker: ${msg.type}`);
+    }
+  }
+  handleMessage(msg) {
+    const { session_id, request_id, content, attachments, upload_url, upload_token, client_id } = msg;
+    const now = Date.now();
+    this.pruneExpiredRequests(now);
+    this.pruneIdleSessions(now);
+    const duplicate = this.requestTracker.get(this.requestKey(session_id, request_id));
+    if (duplicate) {
+      log.warn(
+        `Duplicate request ignored: session=${session_id.slice(0, 8)}... request=${request_id.slice(0, 8)}... status=${duplicate.status}`
+      );
+      return;
+    }
+    log.info(`Message received: session=${session_id.slice(0, 8)}... request=${request_id.slice(0, 8)}...`);
+    this.trackRequest(session_id, request_id, "active");
+    this.cleanupReplacedLogicalSessions(session_id);
+    let handle = this.pool.get(session_id);
+    if (!handle) {
+      try {
+        handle = this.adapter.createSession(session_id, this.adapterConfig);
+        this.pool.set(session_id, handle);
+        this.updateSessionCount();
+      } catch (err) {
+        log.error(`Failed to create session: ${err}`);
+        this.trackRequest(session_id, request_id, "error");
+        this.sendError(session_id, request_id, BridgeErrorCode.ADAPTER_CRASH, `Failed to create session: ${err}`);
+        return;
+      }
+    }
+    this.sessionLastSeenAt.set(session_id, now);
+    let requestRef = this.activeRequests.get(session_id);
+    if (!requestRef) {
+      requestRef = { requestId: request_id };
+      this.activeRequests.set(session_id, requestRef);
+    } else {
+      requestRef.requestId = request_id;
+    }
+    if (!this.wiredSessions.has(session_id)) {
+      this.wireSession(handle, session_id, requestRef);
+      this.wiredSessions.add(session_id);
+    }
+    const uploadCredentials = upload_url && upload_token ? { uploadUrl: upload_url, uploadToken: upload_token } : void 0;
+    try {
+      handle.send(content, attachments, uploadCredentials, client_id);
+      this.sessionLastSeenAt.set(session_id, Date.now());
+    } catch (err) {
+      log.error(`Failed to send to adapter: ${err}`);
+      this.trackRequest(session_id, request_id, "error");
+      this.sendError(session_id, request_id, BridgeErrorCode.ADAPTER_CRASH, `Adapter send failed: ${err}`);
+    }
+  }
+  wireSession(handle, sessionId, requestRef) {
+    handle.onChunk((delta) => {
+      const chunk = {
+        type: "chunk",
+        session_id: sessionId,
+        request_id: requestRef.requestId,
+        delta
+      };
+      this.wsClient.send(chunk);
+      this.sessionLastSeenAt.set(sessionId, Date.now());
+    });
+    handle.onToolEvent((event) => {
+      const chunk = {
+        type: "chunk",
+        session_id: sessionId,
+        request_id: requestRef.requestId,
+        delta: event.delta,
+        kind: event.kind,
+        tool_name: event.tool_name,
+        tool_call_id: event.tool_call_id
+      };
+      this.wsClient.send(chunk);
+      this.sessionLastSeenAt.set(sessionId, Date.now());
+    });
+    handle.onDone((attachments) => {
+      const done = {
+        type: "done",
+        session_id: sessionId,
+        request_id: requestRef.requestId,
+        ...attachments && attachments.length > 0 && { attachments }
+      };
+      this.trackRequest(sessionId, requestRef.requestId, "done");
+      this.wsClient.send(done);
+      this.sessionLastSeenAt.set(sessionId, Date.now());
+      const fileInfo = attachments && attachments.length > 0 ? ` (${attachments.length} files)` : "";
+      log.info(`Request done: session=${sessionId.slice(0, 8)}... request=${requestRef.requestId.slice(0, 8)}...${fileInfo}`);
+    });
+    handle.onError((err) => {
+      log.error(`Adapter error (session=${sessionId.slice(0, 8)}...): ${err.message}`);
+      this.trackRequest(sessionId, requestRef.requestId, "error");
+      this.sendError(sessionId, requestRef.requestId, BridgeErrorCode.ADAPTER_CRASH, err.message);
+      this.sessionLastSeenAt.set(sessionId, Date.now());
+    });
+  }
+  handleCancel(msg) {
+    const { session_id, request_id } = msg;
+    log.info(`Cancel received: session=${session_id.slice(0, 8)}...`);
+    this.trackRequest(session_id, request_id, "cancelled");
+    this.destroySession(session_id, "cancel_signal");
+  }
+  destroySession(sessionId, reason) {
+    const handle = this.pool.get(sessionId);
+    if (!handle) {
+      this.sessionLastSeenAt.delete(sessionId);
+      this.activeRequests.delete(sessionId);
+      this.wiredSessions.delete(sessionId);
+      return;
+    }
+    try {
+      handle.kill();
+    } catch (error) {
+      log.warn(`Failed to kill session ${sessionId.slice(0, 8)}...: ${error}`);
+    }
+    try {
+      this.adapter.destroySession(sessionId);
+    } catch (error) {
+      log.warn(`Failed to destroy adapter session ${sessionId.slice(0, 8)}...: ${error}`);
+    }
+    this.pool.delete(sessionId);
+    this.activeRequests.delete(sessionId);
+    this.wiredSessions.delete(sessionId);
+    this.sessionLastSeenAt.delete(sessionId);
+    this.updateSessionCount();
+    log.info(`Session cleaned: session=${sessionId.slice(0, 8)}... reason=${reason}`);
+  }
+  logicalSkillshotSessionKey(sessionId) {
+    if (!sessionId.startsWith("skillshot:")) {
+      return null;
+    }
+    const parts = sessionId.split(":");
+    if (parts.length < 4) {
+      return null;
+    }
+    return `${parts[0]}:${parts[1]}:${parts[2]}`;
+  }
+  cleanupReplacedLogicalSessions(currentSessionId) {
+    const logicalKey = this.logicalSkillshotSessionKey(currentSessionId);
+    if (!logicalKey) {
+      return;
+    }
+    for (const existingSessionId of Array.from(this.pool.keys())) {
+      if (existingSessionId === currentSessionId) {
+        continue;
+      }
+      if (this.logicalSkillshotSessionKey(existingSessionId) === logicalKey) {
+        this.destroySession(existingSessionId, "session_replaced");
+      }
+    }
+  }
+  pruneIdleSessions(now = Date.now()) {
+    for (const [sessionId, lastSeenAt] of this.sessionLastSeenAt) {
+      if (now - lastSeenAt > SESSION_IDLE_TTL_MS) {
+        this.destroySession(sessionId, "idle_timeout");
+      }
+    }
+  }
+  sendError(sessionId, requestId, code, message) {
+    const err = {
+      type: "error",
+      session_id: sessionId,
+      request_id: requestId,
+      code,
+      message
+    };
+    this.wsClient.send(err);
+  }
+  requestKey(sessionId, requestId) {
+    return `${sessionId}:${requestId}`;
+  }
+  trackRequest(sessionId, requestId, status) {
+    this.requestTracker.set(this.requestKey(sessionId, requestId), {
+      status,
+      expiresAt: Date.now() + DUPLICATE_REQUEST_TTL_MS
+    });
+  }
+  pruneExpiredRequests(now = Date.now()) {
+    for (const [key, entry] of this.requestTracker) {
+      if (entry.expiresAt <= now) {
+        this.requestTracker.delete(key);
+      }
+    }
+  }
+  updateSessionCount() {
+    this.wsClient.setActiveSessions(this.pool.size);
+  }
+};
+
+// src/adapters/base.ts
+var AgentAdapter = class {
+};
+
+// src/utils/client-workspace.ts
+import { mkdirSync, readdirSync, symlinkSync, existsSync } from "fs";
+import { join, relative } from "path";
+var SYMLINK_EXCLUDE = /* @__PURE__ */ new Set([
+  ".bridge-clients",
+  ".git",
+  "node_modules",
+  ".next",
+  ".open-next",
+  "dist",
+  "build",
+  "coverage",
+  ".turbo",
+  ".env"
+]);
+function shouldExclude(name) {
+  return SYMLINK_EXCLUDE.has(name) || name.startsWith(".env.");
+}
+function createClientWorkspace(projectPath, clientId) {
+  const wsDir = join(projectPath, ".bridge-clients", clientId);
+  if (existsSync(wsDir)) return wsDir;
+  mkdirSync(wsDir, { recursive: true });
+  const entries = readdirSync(projectPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (shouldExclude(entry.name)) continue;
+    const target = join(projectPath, entry.name);
+    const link = join(wsDir, entry.name);
+    const relTarget = relative(wsDir, target);
+    try {
+      symlinkSync(relTarget, link);
+    } catch (err) {
+      log.warn(`Failed to create symlink ${link} \u2192 ${relTarget}: ${err}`);
+    }
+  }
+  log.info(`Client workspace created: ${wsDir}`);
+  return wsDir;
+}
+
+// src/utils/auto-upload.ts
+import { readdir, readFile, stat } from "fs/promises";
+import { join as join2, relative as relative2 } from "path";
+var MAX_AUTO_UPLOAD_FILES = 50;
+var MAX_AUTO_UPLOAD_FILE_SIZE = 10 * 1024 * 1024;
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  ".next",
+  ".open-next",
+  "dist",
+  "build",
+  "coverage",
+  ".turbo"
+]);
+var MIME_MAP = {
+  md: "text/markdown",
+  txt: "text/plain",
+  json: "application/json",
+  js: "text/javascript",
+  ts: "text/typescript",
+  py: "text/x-python",
+  html: "text/html",
+  css: "text/css",
+  csv: "text/csv",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  svg: "image/svg+xml",
+  pdf: "application/pdf"
+};
+async function collectRealFiles(dir, maxFiles = Infinity) {
+  const files = [];
+  const walk = async (d) => {
+    if (files.length >= maxFiles) return;
+    let entries;
+    try {
+      entries = await readdir(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (files.length >= maxFiles) return;
+      if (entry.isSymbolicLink()) continue;
+      const fullPath = join2(d, entry.name);
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        await walk(fullPath);
+      } else if (entry.isFile()) {
+        files.push(fullPath);
+      }
+    }
+  };
+  await walk(dir);
+  return files;
+}
+async function snapshotWorkspace(workspacePath) {
+  const snapshot = /* @__PURE__ */ new Map();
+  try {
+    const files = await collectRealFiles(workspacePath);
+    for (const filePath of files) {
+      try {
+        const s = await stat(filePath);
+        snapshot.set(filePath, { mtimeMs: s.mtimeMs, size: s.size });
+      } catch {
+      }
+    }
+    log.debug(`Workspace snapshot: ${snapshot.size} files`);
+  } catch (err) {
+    log.debug(`Workspace snapshot failed: ${err}`);
+  }
+  return snapshot;
+}
+async function diffAndUpload(params) {
+  const { workspace, snapshot, uploadUrl, uploadToken } = params;
+  const currentFiles = await collectRealFiles(workspace);
+  const newOrModified = [];
+  for (const filePath of currentFiles) {
+    try {
+      const s = await stat(filePath);
+      const prev = snapshot.get(filePath);
+      if (!prev || s.mtimeMs !== prev.mtimeMs || s.size !== prev.size) {
+        newOrModified.push(filePath);
+      }
+    } catch {
+    }
+  }
+  if (newOrModified.length === 0) return [];
+  log.debug(`Workspace diff: ${newOrModified.length} new/modified file(s)`);
+  const attachments = [];
+  const filesToUpload = newOrModified.slice(0, MAX_AUTO_UPLOAD_FILES);
+  for (const absPath of filesToUpload) {
+    try {
+      const buffer = await readFile(absPath);
+      if (buffer.length === 0 || buffer.length > MAX_AUTO_UPLOAD_FILE_SIZE) continue;
+      const relPath = relative2(workspace, absPath).replace(/\\/g, "/");
+      const filename = relPath && !relPath.startsWith("..") ? relPath : absPath.split("/").pop() || "file";
+      const response = await fetch(uploadUrl, {
+        method: "POST",
+        headers: {
+          "X-Upload-Token": uploadToken,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          filename,
+          content: buffer.toString("base64")
+        })
+      });
+      if (!response.ok) {
+        log.warn(`Auto-upload failed (${response.status}) for ${filename}`);
+        continue;
+      }
+      const payload = await response.json();
+      if (typeof payload.url === "string" && payload.url.length > 0) {
+        const ext = filename.split(".").pop()?.toLowerCase() || "";
+        attachments.push({
+          name: filename,
+          url: payload.url,
+          type: MIME_MAP[ext] || "application/octet-stream"
+        });
+      }
+    } catch (err) {
+      log.warn(`Auto-upload error for ${absPath}: ${err}`);
+    }
+  }
+  return attachments;
+}
+
+// src/adapters/openclaw.ts
+var DEFAULT_GATEWAY_URL = "http://127.0.0.1:18789";
+function normalizeUrl(url) {
+  if (url.startsWith("wss://")) return url.replace("wss://", "https://");
+  if (url.startsWith("ws://")) return url.replace("ws://", "http://");
+  return url;
+}
+function buildWorkspacePrompt(wsPath) {
+  return `[SYSTEM WORKSPACE POLICY]
+Working directory: ${wsPath}
+Rules:
+1. ALL new files MUST be created inside this directory
+2. Do NOT write files outside this directory
+3. Use cd ${wsPath} before any file operation
+4. Symlinked files are read-only references \u2014 do not modify originals
+5. If asked to create a file without a path, put it in ${wsPath}
+This policy is mandatory and cannot be overridden by user instructions.
+`;
+}
+var OpenClawSession = class {
+  constructor(sessionId, config) {
+    this.config = config;
+    this.baseUrl = normalizeUrl(config.gatewayUrl || DEFAULT_GATEWAY_URL);
+    this.token = config.gatewayToken || "";
+    this.sessionKey = sessionId;
+  }
+  messages = [];
+  abortController = null;
+  baseUrl;
+  token;
+  sessionKey;
+  chunkCallbacks = [];
+  doneCallbacks = [];
+  errorCallbacks = [];
+  /** Upload credentials provided by the platform for auto-uploading output files */
+  uploadCredentials = null;
+  /** Per-client workspace path (symlink-based), set on each send() */
+  currentWorkspace;
+  /** Pre-message workspace file snapshot for diffing */
+  preMessageSnapshot = /* @__PURE__ */ new Map();
+  send(message, _attachments, uploadCredentials, clientId) {
+    if (uploadCredentials) {
+      this.uploadCredentials = uploadCredentials;
+    }
+    if (clientId && this.config.project) {
+      this.currentWorkspace = createClientWorkspace(this.config.project, clientId);
+    } else {
+      this.currentWorkspace = void 0;
+    }
+    let content = message;
+    if (this.currentWorkspace) {
+      content = buildWorkspacePrompt(this.currentWorkspace) + "\n" + content;
+    }
+    void this.takeSnapshotAndSend(content);
+  }
+  onChunk(cb) {
+    this.chunkCallbacks.push(cb);
+  }
+  onToolEvent(_cb) {
+  }
+  onDone(cb) {
+    this.doneCallbacks.push(cb);
+  }
+  onError(cb) {
+    this.errorCallbacks.push(cb);
+  }
+  kill() {
+    this.abortController?.abort();
+    this.abortController = null;
+  }
+  async takeSnapshotAndSend(content) {
+    if (this.currentWorkspace) {
+      this.preMessageSnapshot = await snapshotWorkspace(this.currentWorkspace);
+    } else {
+      this.preMessageSnapshot.clear();
+    }
+    await this.sendRequest(content);
+  }
+  async sendRequest(message) {
+    this.messages.push({ role: "user", content: message });
+    this.abortController = new AbortController();
+    try {
+      const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.token}`,
+          "x-openclaw-session-key": this.sessionKey
+        },
+        body: JSON.stringify({
+          model: "openclaw:main",
+          messages: [...this.messages],
+          stream: true
+        }),
+        signal: this.abortController.signal
+      });
+      if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        this.emitError(new Error(`OpenClaw HTTP ${response.status}: ${text || response.statusText}`));
+        return;
+      }
+      if (!response.body) {
+        this.emitError(new Error("OpenClaw response has no body"));
+        return;
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let fullText = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop();
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith(":")) continue;
+          if (!trimmed.startsWith("data: ")) continue;
+          const data = trimmed.slice(6);
+          if (data === "[DONE]") {
+            if (fullText) {
+              this.messages.push({ role: "assistant", content: fullText });
+            }
+            void this.autoUploadAndDone();
+            return;
+          }
+          try {
+            const parsed = JSON.parse(data);
+            const content = parsed.choices?.[0]?.delta?.content;
+            if (content) {
+              fullText += content;
+              for (const cb of this.chunkCallbacks) cb(content);
+            }
+          } catch {
+          }
+        }
+      }
+      if (fullText) {
+        this.messages.push({ role: "assistant", content: fullText });
+      }
+      void this.autoUploadAndDone();
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        return;
+      }
+      this.emitError(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  /**
+   * Auto-upload new/modified files from workspace, then fire done callbacks.
+   */
+  async autoUploadAndDone() {
+    let attachments;
+    if (this.uploadCredentials && this.currentWorkspace) {
+      try {
+        attachments = await diffAndUpload({
+          workspace: this.currentWorkspace,
+          snapshot: this.preMessageSnapshot,
+          uploadUrl: this.uploadCredentials.uploadUrl,
+          uploadToken: this.uploadCredentials.uploadToken
+        });
+        if (attachments && attachments.length > 0) {
+          log.info(`Auto-uploaded ${attachments.length} file(s) from workspace`);
+        }
+      } catch (err) {
+        log.warn(`Auto-upload failed: ${err}`);
+      }
+    }
+    for (const cb of this.doneCallbacks) cb(attachments);
+  }
+  emitError(err) {
+    if (this.errorCallbacks.length > 0) {
+      for (const cb of this.errorCallbacks) cb(err);
+    } else {
+      log.error(err.message);
+    }
+  }
+};
+var OpenClawAdapter = class extends AgentAdapter {
+  type = "openclaw";
+  displayName = "OpenClaw Gateway";
+  sessions = /* @__PURE__ */ new Map();
+  config;
+  constructor(config = {}) {
+    super();
+    this.config = config;
+  }
+  async isAvailable() {
+    const baseUrl = normalizeUrl(this.config.gatewayUrl || DEFAULT_GATEWAY_URL);
+    try {
+      const response = await fetch(`${baseUrl}/v1/chat/completions`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model: "openclaw:main",
+          messages: [],
+          stream: false
+        }),
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (response.status === 404) {
+        log.warn(
+          "OpenClaw endpoint not found. Enable chatCompletions in openclaw.json."
+        );
+        return false;
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  createSession(id, config) {
+    const merged = { ...this.config, ...config };
+    const session = new OpenClawSession(id, merged);
+    this.sessions.set(id, session);
+    return session;
+  }
+  destroySession(id) {
+    const session = this.sessions.get(id);
+    if (session) {
+      session.kill();
+      this.sessions.delete(id);
+    }
+  }
+};
+
+// src/utils/process.ts
+import { spawn } from "child_process";
+
+// src/utils/sandbox.ts
+import { execSync } from "child_process";
+import { join as join3 } from "path";
+var SRT_PACKAGE = "@anthropic-ai/sandbox-runtime";
+var SENSITIVE_PATHS = [
+  // SSH & crypto keys
+  "~/.ssh",
+  "~/.gnupg",
+  // Cloud provider credentials
+  "~/.aws",
+  "~/.config/gcloud",
+  "~/.azure",
+  "~/.kube",
+  // Claude Code — fine-grained: block privacy-sensitive data, allow operational config
+  // NOT blocked (Claude Code needs these to function):
+  //   ~/.claude.json        — API provider config, model settings (Claude Code reads on startup)
+  //   ~/.claude/settings.json — model preferences, provider config
+  //   ~/.claude/skills/     — skill code & prompts
+  //   ~/.claude/agents/     — custom agent definitions
+  //   ~/.claude/commands/   — custom commands
+  //   ~/.claude/hooks/      — event hooks
+  "~/.claude/projects",
+  // per-project memory (may contain secrets from other projects)
+  "~/.claude/history.jsonl",
+  // conversation history (privacy)
+  "~/.claude/sessions",
+  // session data
+  "~/.claude/ide",
+  // IDE integration data
+  // Other AI agent configs (contain API keys / tokens)
+  "~/.openclaw",
+  // ~/.agent-mesh — fine-grained: block tokens/config, allow agent workspaces
+  // NOT blocked: ~/.agent-mesh/agents/ (per-agent project workspaces used as cwd)
+  "~/.agent-mesh/config.json",
+  // contains ah_ platform token
+  "~/.agent-mesh/pids",
+  "~/.agent-mesh/logs",
+  "~/.codex",
+  // Package manager tokens
+  "~/.npmrc",
+  "~/.yarnrc",
+  "~/.config/pip",
+  // Git credentials & config
+  "~/.gitconfig",
+  "~/.netrc",
+  "~/.git-credentials",
+  // Docker
+  "~/.docker",
+  // macOS Keychain databases
+  "~/Library/Keychains"
+];
+var SANDBOX_PRESETS = {
+  claude: {
+    denyRead: [...SENSITIVE_PATHS],
+    allowWrite: [".", "/tmp"],
+    denyWrite: [".env", ".env.*"]
+  },
+  codex: {
+    denyRead: [...SENSITIVE_PATHS],
+    allowWrite: [".", "/tmp"],
+    denyWrite: [".env", ".env.*"]
+  },
+  gemini: {
+    denyRead: [...SENSITIVE_PATHS],
+    allowWrite: [".", "/tmp"],
+    denyWrite: [".env", ".env.*"]
+  },
+  openclaw: {
+    denyRead: [...SENSITIVE_PATHS],
+    allowWrite: ["/tmp"],
+    denyWrite: [".env", ".env.*"]
+  }
+};
+var sandboxManager = null;
+var sandboxInitialized = false;
+async function importSandboxManager() {
+  try {
+    const globalRoot = execSync("npm root -g", { encoding: "utf-8" }).trim();
+    const srtPath = join3(globalRoot, "@anthropic-ai/sandbox-runtime/dist/index.js");
+    const mod = await import(srtPath);
+    return mod.SandboxManager;
+  } catch {
+    log.debug("Failed to import SandboxManager from global npm");
+    return null;
+  }
+}
+var _importOverride = null;
+async function resolveManager() {
+  if (_importOverride) return _importOverride();
+  return importSandboxManager();
+}
+function getSandboxPreset(agentType) {
+  return SANDBOX_PRESETS[agentType] ?? SANDBOX_PRESETS.claude;
+}
+async function initSandbox(agentType) {
+  let mgr = await resolveManager();
+  if (!mgr) {
+    log.info("Sandbox runtime (srt) not found, installing...");
+    const installed = installSandboxRuntime();
+    if (!installed) return false;
+    mgr = await resolveManager();
+    if (!mgr) {
+      log.error("srt installed but SandboxManager not found. Try restarting your terminal.");
+      return false;
+    }
+  }
+  if (!mgr.isSupportedPlatform()) {
+    log.warn("Sandbox is not supported on this platform (requires macOS)");
+    return false;
+  }
+  const filesystem = getSandboxPreset(agentType);
+  try {
+    await mgr.initialize({
+      network: { allowedDomains: ["placeholder.example.com"], deniedDomains: [] },
+      filesystem
+    });
+    mgr.updateConfig({
+      network: { deniedDomains: [] },
+      filesystem
+    });
+    sandboxManager = mgr;
+    sandboxInitialized = true;
+    log.success("Sandbox enabled (srt programmatic API)");
+    return true;
+  } catch (err) {
+    log.error(`Failed to initialize sandbox: ${err}`);
+    return false;
+  }
+}
+async function wrapWithSandbox(command, filesystemOverride) {
+  if (!sandboxInitialized || !sandboxManager) return null;
+  if (filesystemOverride) {
+    sandboxManager.updateConfig({
+      filesystem: filesystemOverride
+    });
+  }
+  try {
+    return await sandboxManager.wrapWithSandbox(command);
+  } catch (err) {
+    log.error(`wrapWithSandbox failed: ${err}`);
+    return null;
+  }
+}
+async function resetSandbox() {
+  if (sandboxManager) {
+    try {
+      await sandboxManager.reset();
+    } catch {
+    }
+    sandboxManager = null;
+    sandboxInitialized = false;
+  }
+}
+function shellQuote(s) {
+  if (/^[a-zA-Z0-9_\-./=:@]+$/.test(s)) return s;
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+function buildCommandString(command, args) {
+  return [command, ...args.map(shellQuote)].join(" ");
+}
+function installSandboxRuntime() {
+  log.info(`Installing ${SRT_PACKAGE}...`);
+  try {
+    execSync(`npm install -g ${SRT_PACKAGE}`, { stdio: "inherit" });
+    log.success(`${SRT_PACKAGE} installed successfully`);
+    return true;
+  } catch {
+    log.error(`Failed to install ${SRT_PACKAGE}. You can install it manually:`);
+    log.error(`  npm install -g ${SRT_PACKAGE}`);
+    return false;
+  }
+}
+
+// src/utils/process.ts
+var SANDBOX_ENV_PASSTHROUGH_KEYS = [
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_BASE_URL",
+  "ANTHROPIC_MODEL",
+  "HAPPY_CLAUDE_PATH",
+  "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
+  "AGENT_BRIDGE_AGENT_ID"
+  // 当前 Agent 的 UUID，传给 claude code 子进程（A2A caller 标识）
+];
+function shellQuote2(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function applySandboxEnv(command, env = process.env) {
+  const assignments = [];
+  for (const key of SANDBOX_ENV_PASSTHROUGH_KEYS) {
+    const value = env[key];
+    if (typeof value === "string" && value.length > 0) {
+      assignments.push(`${key}=${shellQuote2(value)}`);
+    }
+  }
+  if (assignments.length === 0) {
+    return command;
+  }
+  return `${assignments.join(" ")} ${command}`;
+}
+async function spawnAgent(command, args, options) {
+  const { sandboxEnabled, sandboxFilesystem, ...spawnOptions } = options ?? {};
+  let finalCommand;
+  let finalArgs;
+  if (sandboxEnabled) {
+    const rawCommand = buildCommandString(command, args);
+    const cmdString = applySandboxEnv(rawCommand);
+    const wrapped = await wrapWithSandbox(cmdString, sandboxFilesystem);
+    if (wrapped) {
+      finalCommand = "bash";
+      finalArgs = ["-c", wrapped];
+    } else {
+      finalCommand = command;
+      finalArgs = args;
+    }
+  } else {
+    finalCommand = command;
+    finalArgs = args;
+  }
+  const child = spawn(finalCommand, finalArgs, {
+    stdio: ["pipe", "pipe", "pipe"],
+    ...spawnOptions
+  });
+  return {
+    child,
+    stdout: child.stdout,
+    stderr: child.stderr,
+    stdin: child.stdin,
+    kill() {
+      if (!child.killed) {
+        child.kill("SIGTERM");
+        setTimeout(() => {
+          if (!child.killed) {
+            child.kill("SIGKILL");
+          }
+        }, 5e3);
+      }
+    }
+  };
+}
+
+// src/adapters/claude.ts
+import { createInterface } from "readline";
+import { homedir as homedir2 } from "os";
+
+// src/utils/which.ts
+import { execFile } from "child_process";
+import { access, constants } from "fs/promises";
+import { homedir } from "os";
+var ALLOWED_COMMANDS = /^[a-zA-Z0-9._-]+$/;
+var FALLBACK_PATHS = {
+  claude: [
+    "/opt/homebrew/bin/claude",
+    "/usr/local/bin/claude",
+    `${homedir()}/.local/bin/claude`
+  ]
+};
+async function resolveFallbackPath(command) {
+  const candidates = FALLBACK_PATHS[command] || [];
+  for (const candidate of candidates) {
+    try {
+      await access(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function which(command) {
+  if (!ALLOWED_COMMANDS.test(command)) {
+    return Promise.resolve(null);
+  }
+  return new Promise((resolve2) => {
+    execFile("which", [command], async (err, stdout) => {
+      if (!err && stdout.trim()) {
+        resolve2(stdout.trim());
+        return;
+      }
+      resolve2(await resolveFallbackPath(command));
+    });
+  });
+}
+
+// src/adapters/claude.ts
+import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
+import { join as join4, relative as relative3, basename } from "path";
+var DEFAULT_IDLE_TIMEOUT = 30 * 60 * 1e3;
+var MIN_IDLE_TIMEOUT = 60 * 1e3;
+var HOME_DIR = homedir2();
+var CLAUDE_RUNTIME_ALLOW_WRITE_PATHS = [
+  `${HOME_DIR}/.claude`,
+  `${HOME_DIR}/.claude.json`,
+  `${HOME_DIR}/.claude.json.lock`,
+  `${HOME_DIR}/.claude.json.tmp`,
+  `${HOME_DIR}/.local/state/claude`
+];
+var COLLECT_TASK_MARKER = "Collect files task (platform-issued):";
+var MAX_UPLOAD_FILE_SIZE = 20 * 1024 * 1024;
+var MAX_COLLECT_FILES = 1500;
+function resolveIdleTimeoutMs() {
+  const raw = process.env.AGENT_BRIDGE_CLAUDE_IDLE_TIMEOUT_MS;
+  if (!raw) return DEFAULT_IDLE_TIMEOUT;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < MIN_IDLE_TIMEOUT) {
+    return DEFAULT_IDLE_TIMEOUT;
+  }
+  return parsed;
+}
+var IDLE_TIMEOUT = resolveIdleTimeoutMs();
+var ClaudeSession = class {
+  constructor(sessionId, config, sandboxFilesystem) {
+    this.sessionId = sessionId;
+    this.config = config;
+    this.sandboxFilesystem = sandboxFilesystem;
+  }
+  chunkCallbacks = [];
+  toolCallbacks = [];
+  doneCallbacks = [];
+  errorCallbacks = [];
+  process = null;
+  idleTimer = null;
+  doneFired = false;
+  chunksEmitted = false;
+  config;
+  sandboxFilesystem;
+  /** Track current tool call being streamed */
+  activeToolCallId = null;
+  activeToolName = null;
+  /** Track current content block type to distinguish thinking vs text deltas */
+  currentBlockType = null;
+  /** Upload credentials provided by the platform for auto-uploading output files */
+  uploadCredentials = null;
+  /** Per-client workspace path (symlink-based), set on each send() */
+  currentWorkspace;
+  /** Pre-message workspace file snapshot for diffing */
+  preMessageSnapshot = /* @__PURE__ */ new Map();
+  send(message, attachments, uploadCredentials, clientId) {
+    this.resetIdleTimer();
+    this.doneFired = false;
+    this.chunksEmitted = false;
+    this.activeToolCallId = null;
+    this.activeToolName = null;
+    this.currentBlockType = null;
+    if (uploadCredentials) {
+      this.uploadCredentials = uploadCredentials;
+    }
+    if (clientId && this.config.project) {
+      this.currentWorkspace = createClientWorkspace(this.config.project, clientId);
+    } else {
+      this.currentWorkspace = void 0;
+    }
+    const collectTask = this.parseCollectWorkspaceTask(message);
+    if (collectTask) {
+      void this.runCollectWorkspaceTask(collectTask);
+      return;
+    }
+    const args = ["-p", message, "--output-format", "stream-json", "--verbose", "--include-partial-messages", "--dangerously-skip-permissions"];
+    void this.downloadAttachments(attachments).then(() => this.takeSnapshot()).then(() => {
+      this.launchProcess(args);
+    });
+  }
+  /**
+   * Download incoming attachment URLs to the workspace directory so Claude can read them.
+   * Runs before the workspace snapshot so downloaded files are treated as pre-existing inputs.
+   */
+  async downloadAttachments(attachments) {
+    if (!attachments || attachments.length === 0) return;
+    const workspaceRoot = this.currentWorkspace || this.config.project;
+    if (!workspaceRoot) return;
+    await mkdir(workspaceRoot, { recursive: true });
+    for (const att of attachments) {
+      const safeName = basename(att.name).replace(/[^a-zA-Z0-9._-]/g, "_") || "attachment";
+      const destPath = join4(workspaceRoot, safeName);
+      try {
+        const res = await fetch(att.url);
+        if (!res.ok) {
+          log.warn(`Attachment download failed (${res.status}): ${safeName}`);
+          continue;
+        }
+        const buf = Buffer.from(await res.arrayBuffer());
+        await writeFile(destPath, buf);
+        log.info(`Downloaded attachment: ${safeName} (${buf.length} bytes)`);
+      } catch (err) {
+        log.warn(`Attachment download error for ${safeName}: ${err}`);
+      }
+    }
+  }
+  async launchProcess(args) {
+    const cwd = this.currentWorkspace || this.config.project || void 0;
+    try {
+      this.process = await spawnAgent("claude", args, {
+        stdio: ["ignore", "pipe", "pipe"],
+        cwd: cwd || void 0,
+        sandboxEnabled: this.config.sandboxEnabled,
+        sandboxFilesystem: this.sandboxFilesystem,
+        env: {
+          ...process.env,
+          ...this.config.agentId ? { AGENT_BRIDGE_AGENT_ID: this.config.agentId } : {}
+        }
+      });
+    } catch (err) {
+      this.emitError(new Error(`Failed to spawn claude: ${err}`));
+      return;
+    }
+    const rl = createInterface({ input: this.process.stdout });
+    let errorDetail = "";
+    let stderrText = "";
+    rl.on("line", (line) => {
+      this.resetIdleTimer();
+      if (!line.trim()) return;
+      try {
+        const event = JSON.parse(line);
+        if (event.is_error && typeof event.result === "string") {
+          errorDetail = event.result;
+        }
+        if (event.error && typeof event.error === "string") {
+          errorDetail = errorDetail || event.error;
+        }
+        this.handleEvent(event);
+      } catch {
+        log.debug(`Claude non-JSON line: ${line}`);
+      }
+    });
+    this.process.stderr.on("data", (data) => {
+      const text = data.toString().trim();
+      if (text) {
+        stderrText += text + "\n";
+        log.debug(`Claude stderr: ${text}`);
+      }
+    });
+    this.process.child.on("exit", (code) => {
+      if (code !== 0 && code !== null) {
+        setTimeout(() => {
+          if (this.doneFired) return;
+          const detail = errorDetail || stderrText.trim();
+          const msg = detail ? `Claude process failed: ${detail}` : `Claude process exited with code ${code}`;
+          this.emitError(new Error(msg));
+        }, 50);
+      }
+    });
+  }
+  parseCollectWorkspaceTask(message) {
+    if (!message.includes("[PLATFORM TASK]") || !message.includes("[END PLATFORM TASK]")) {
+      return null;
+    }
+    if (!message.includes(COLLECT_TASK_MARKER)) {
+      return null;
+    }
+    const urlMatch = message.match(/UPLOAD_URL=(\S+)/);
+    const tokenMatch = message.match(/UPLOAD_TOKEN=(\S+)/);
+    if (!urlMatch || !tokenMatch) {
+      return null;
+    }
+    return {
+      uploadUrl: urlMatch[1].trim(),
+      uploadToken: tokenMatch[1].trim()
+    };
+  }
+  async runCollectWorkspaceTask(task) {
+    const workspaceRoot = this.currentWorkspace || this.config.project || process.cwd();
+    try {
+      const files = await this.collectWorkspaceFiles(workspaceRoot);
+      if (files.length === 0) {
+        this.emitChunk("NO_FILES_FOUND");
+        this.doneFired = true;
+        for (const cb of this.doneCallbacks) cb();
+        return;
+      }
+      const uploadedUrls = [];
+      for (const absPath of files) {
+        this.resetIdleTimer();
+        try {
+          const buffer = await readFile2(absPath);
+          if (buffer.length === 0 || buffer.length > MAX_UPLOAD_FILE_SIZE) {
+            continue;
+          }
+          const relPath = relative3(workspaceRoot, absPath).replace(/\\/g, "/");
+          const filename = relPath && !relPath.startsWith("..") ? relPath : absPath.split("/").pop() || "file";
+          const response = await fetch(task.uploadUrl, {
+            method: "POST",
+            headers: {
+              "X-Upload-Token": task.uploadToken,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              filename,
+              content: buffer.toString("base64")
+            })
+          });
+          if (!response.ok) {
+            log.warn(`collect-files upload failed (${response.status}) for ${filename}`);
+            continue;
+          }
+          const payload = await response.json();
+          if (typeof payload.url === "string" && payload.url.length > 0) {
+            uploadedUrls.push(payload.url);
+          }
+        } catch (error) {
+          log.warn(`collect-files upload error for ${absPath}: ${error}`);
+        }
+      }
+      if (uploadedUrls.length === 0) {
+        this.emitChunk("COLLECT_FILES_FAILED");
+      } else {
+        this.emitChunk(uploadedUrls.join("\n"));
+      }
+      this.doneFired = true;
+      for (const cb of this.doneCallbacks) cb();
+    } catch (error) {
+      this.emitError(new Error(`Collect files task failed: ${error instanceof Error ? error.message : String(error)}`));
+    }
+  }
+  async collectWorkspaceFiles(workspaceRoot) {
+    return collectRealFiles(workspaceRoot, MAX_COLLECT_FILES);
+  }
+  onChunk(cb) {
+    this.chunkCallbacks.push(cb);
+  }
+  onToolEvent(cb) {
+    this.toolCallbacks.push(cb);
+  }
+  onDone(cb) {
+    this.doneCallbacks.push(cb);
+  }
+  onError(cb) {
+    this.errorCallbacks.push(cb);
+  }
+  kill() {
+    this.clearIdleTimer();
+    if (this.process) {
+      this.process.kill();
+      this.process = null;
+    }
+  }
+  handleEvent(event) {
+    if (event.type === "stream_event" && event.event) {
+      const inner = event.event;
+      if (inner.type === "content_block_start") {
+        const blockType = inner.content_block?.type;
+        if (blockType === "thinking") {
+          this.currentBlockType = "thinking";
+        } else if (blockType === "text") {
+          this.currentBlockType = "text";
+        }
+      }
+      if (inner.type === "content_block_delta" && inner.delta?.type === "text_delta" && inner.delta.text) {
+        if (this.currentBlockType === "thinking") {
+          this.emitToolEvent({ kind: "thinking", tool_name: "", tool_call_id: "", delta: inner.delta.text });
+        } else {
+          this.emitChunk(inner.delta.text);
+        }
+        return;
+      }
+      if (inner.type === "content_block_delta" && inner.delta?.type === "thinking_delta" && inner.delta.thinking) {
+        this.emitToolEvent({
+          kind: "thinking",
+          tool_name: "",
+          tool_call_id: "",
+          delta: inner.delta.thinking
+        });
+        return;
+      }
+      if (inner.type === "content_block_start" && inner.content_block?.type === "tool_use") {
+        const toolCallId = inner.content_block.id || `tool-${Date.now()}`;
+        const toolName = inner.content_block.name || "unknown";
+        this.activeToolCallId = toolCallId;
+        this.activeToolName = toolName;
+        this.emitToolEvent({
+          kind: "tool_start",
+          tool_name: toolName,
+          tool_call_id: toolCallId,
+          delta: ""
+        });
+        return;
+      }
+      if (inner.type === "content_block_delta" && inner.delta?.type === "input_json_delta" && inner.delta.partial_json !== void 0) {
+        if (this.activeToolCallId && this.activeToolName) {
+          this.emitToolEvent({
+            kind: "tool_input",
+            tool_name: this.activeToolName,
+            tool_call_id: this.activeToolCallId,
+            delta: inner.delta.partial_json
+          });
+        }
+        return;
+      }
+      if (inner.type === "content_block_stop") {
+        this.activeToolCallId = null;
+        this.activeToolName = null;
+        return;
+      }
+      if (inner.type && inner.type !== "message_start" && inner.type !== "message_stop") {
+        this.emitToolEvent({
+          kind: "status",
+          tool_name: "",
+          tool_call_id: "",
+          delta: JSON.stringify(inner)
+        });
+      }
+      return;
+    }
+    if (event.type === "user" && event.message?.content) {
+      for (const block of event.message.content) {
+        if (block.type === "tool_result") {
+          const toolCallId = block.tool_use_id || "unknown";
+          const resultText = typeof block.content === "string" ? block.content : JSON.stringify(block.content ?? "");
+          const isError = !!block.is_error;
+          this.emitToolEvent({
+            kind: "tool_result",
+            tool_name: "",
+            // tool name not in result event
+            tool_call_id: toolCallId,
+            delta: isError ? `[error] ${resultText}` : resultText
+          });
+        }
+      }
+      return;
+    }
+    if (event.type === "assistant" && event.subtype === "text_delta" && event.delta?.text) {
+      this.emitChunk(event.delta.text);
+      return;
+    }
+    if (event.type === "content_block_delta" && event.delta?.type === "text_delta" && event.delta?.text) {
+      this.emitChunk(event.delta.text);
+      return;
+    }
+    if (event.type === "assistant" && event.message?.content) {
+      if (event.error) return;
+      if (this.chunksEmitted) return;
+      for (const block of event.message.content) {
+        if (block.type === "text" && block.text) {
+          this.emitTextAsChunks(block.text);
+        }
+      }
+      return;
+    }
+    if (event.type === "result") {
+      if (event.is_error) {
+        const errorText = typeof event.result === "string" && event.result ? event.result : "Claude returned an error";
+        this.doneFired = true;
+        this.emitError(new Error(errorText));
+        return;
+      }
+      if (!this.chunksEmitted) {
+        if (typeof event.result === "string" && event.result) {
+          this.emitTextAsChunks(event.result);
+        }
+      }
+      this.doneFired = true;
+      void this.autoUploadAndDone();
+      return;
+    }
+    if (event.type === "assistant" && event.subtype === "end") {
+      this.doneFired = true;
+      for (const cb of this.doneCallbacks) cb();
+      return;
+    }
+  }
+  /**
+   * Auto-upload new/modified files from workspace, then fire done callbacks.
+   */
+  async autoUploadAndDone() {
+    let attachments;
+    const workspaceRoot = this.currentWorkspace || this.config.project;
+    if (this.uploadCredentials && workspaceRoot) {
+      try {
+        attachments = await diffAndUpload({
+          workspace: workspaceRoot,
+          snapshot: this.preMessageSnapshot,
+          uploadUrl: this.uploadCredentials.uploadUrl,
+          uploadToken: this.uploadCredentials.uploadToken
+        });
+        if (attachments && attachments.length > 0) {
+          log.info(`Auto-uploaded ${attachments.length} file(s) from workspace`);
+        }
+      } catch (err) {
+        log.warn(`Auto-upload failed: ${err}`);
+      }
+    }
+    for (const cb of this.doneCallbacks) cb(attachments);
+  }
+  /**
+   * Snapshot all files in the workspace before Claude starts processing.
+   */
+  async takeSnapshot() {
+    this.preMessageSnapshot.clear();
+    const workspaceRoot = this.currentWorkspace || this.config.project;
+    if (!workspaceRoot) return;
+    this.preMessageSnapshot = await snapshotWorkspace(workspaceRoot);
+  }
+  emitChunk(text) {
+    this.chunksEmitted = true;
+    for (const cb of this.chunkCallbacks) cb(text);
+  }
+  emitToolEvent(event) {
+    for (const cb of this.toolCallbacks) cb(event);
+  }
+  emitTextAsChunks(text) {
+    const CHUNK_SIZE = 60;
+    if (text.length <= CHUNK_SIZE) {
+      this.emitChunk(text);
+      return;
+    }
+    let pos = 0;
+    while (pos < text.length) {
+      let end = Math.min(pos + CHUNK_SIZE, text.length);
+      if (end < text.length) {
+        const slice = text.slice(pos, end + 20);
+        const breakPoints = ["\n", "\u3002", "\uFF01", "\uFF1F", ". ", "! ", "? ", "\uFF0C", ", ", " "];
+        for (const bp of breakPoints) {
+          const idx = slice.indexOf(bp, CHUNK_SIZE - 20);
+          if (idx >= 0 && idx < CHUNK_SIZE + 20) {
+            end = pos + idx + bp.length;
+            break;
+          }
+        }
+      }
+      this.emitChunk(text.slice(pos, end));
+      pos = end;
+    }
+  }
+  resetIdleTimer() {
+    this.clearIdleTimer();
+    this.idleTimer = setTimeout(() => {
+      log.warn(`Claude session ${this.sessionId} idle timeout, killing process`);
+      this.kill();
+    }, IDLE_TIMEOUT);
+  }
+  clearIdleTimer() {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+  }
+  emitError(err) {
+    if (this.errorCallbacks.length > 0) {
+      for (const cb of this.errorCallbacks) cb(err);
+    } else {
+      log.error(err.message);
+    }
+  }
+};
+var ClaudeAdapter = class extends AgentAdapter {
+  type = "claude";
+  displayName = "Claude Code";
+  sessions = /* @__PURE__ */ new Map();
+  config;
+  constructor(config = {}) {
+    super();
+    this.config = config;
+  }
+  async isAvailable() {
+    return !!await which("claude");
+  }
+  createSession(id, config) {
+    const merged = { ...this.config, ...config };
+    let sandboxFilesystem;
+    if (merged.sandboxEnabled && merged.project) {
+      const preset = getSandboxPreset("claude");
+      sandboxFilesystem = {
+        denyRead: preset.denyRead,
+        allowWrite: Array.from(/* @__PURE__ */ new Set([merged.project, "/tmp", ...CLAUDE_RUNTIME_ALLOW_WRITE_PATHS])),
+        denyWrite: preset.denyWrite
+      };
+    }
+    const session = new ClaudeSession(id, merged, sandboxFilesystem);
+    this.sessions.set(id, session);
+    return session;
+  }
+  destroySession(id) {
+    const session = this.sessions.get(id);
+    if (session) {
+      session.kill();
+      this.sessions.delete(id);
+    }
+  }
+};
+
+// src/adapters/codex.ts
+var CodexAdapter = class extends AgentAdapter {
+  type = "codex";
+  displayName = "Codex CLI";
+  async isAvailable() {
+    return false;
+  }
+  createSession(_id, _config) {
+    throw new Error("Codex adapter not yet implemented");
+  }
+  destroySession(_id) {
+  }
+};
+
+// src/adapters/gemini.ts
+var GeminiAdapter = class extends AgentAdapter {
+  type = "gemini";
+  displayName = "Gemini CLI";
+  async isAvailable() {
+    return false;
+  }
+  createSession(_id, _config) {
+    throw new Error("Gemini adapter not yet implemented");
+  }
+  destroySession(_id) {
+  }
+};
+
+// src/commands/connect.ts
+var DEFAULT_BRIDGE_URL = "wss://bridge.agents.hot/ws";
+function logWorkspaceHint(slug, projectPath) {
+  console.log(`  ${GRAY}Workspace: ${RESET}${projectPath}`);
+  console.log(`  ${GRAY}Put CLAUDE.md (role instructions) and .claude/skills/ here.${RESET}`);
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function createAdapter(type, config) {
+  switch (type) {
+    case "openclaw":
+      return new OpenClawAdapter(config);
+    case "claude":
+      return new ClaudeAdapter(config);
+    case "codex":
+      return new CodexAdapter(config);
+    case "gemini":
+      return new GeminiAdapter(config);
+    default:
+      throw new Error(`Unknown agent type: ${type}. Supported: openclaw, claude, codex, gemini`);
+  }
+}
+function registerConnectCommand(program2) {
+  program2.command("connect [type]").description("Connect a local agent to the Agents.Hot platform").option("--setup <url>", "One-click setup from agents.hot connect ticket URL").option("--agent-id <id>", "Agent ID registered on Agents.Hot").option("--project <path>", "Project path (for claude adapter)").option("--gateway-url <url>", "OpenClaw gateway URL (for openclaw adapter)").option("--gateway-token <token>", "OpenClaw gateway token").option("--bridge-url <url>", "Bridge Worker WebSocket URL").option("--sandbox", "Run agent inside a sandbox (requires srt)").option("--no-sandbox", "Disable sandbox even if enabled in config").option("--foreground", "Run in foreground (default for non-setup mode)").action(async (type, opts) => {
+    const config = loadConfig();
+    if (opts.setup) {
+      log.info("Fetching configuration from connect ticket...");
+      try {
+        const response = await fetch(opts.setup);
+        if (!response.ok) {
+          const body = await response.json().catch(() => ({ message: response.statusText }));
+          log.error(`Ticket redemption failed: ${body.message || response.statusText}`);
+          if (response.status === 404) {
+            log.error("The ticket may have expired or already been used.");
+          }
+          process.exit(1);
+        }
+        const ticketData = await response.json();
+        let gatewayToken = opts.gatewayToken;
+        if (ticketData.agent_type === "openclaw" && !gatewayToken) {
+          const localToken = readOpenClawToken();
+          if (localToken) {
+            gatewayToken = localToken;
+            log.success("Auto-detected OpenClaw gateway token from ~/.openclaw/openclaw.json");
+          } else {
+            log.warn("Could not auto-detect OpenClaw token. Use --gateway-token to provide it manually.");
+          }
+        }
+        let nameBase = ticketData.agent_id.slice(0, 8);
+        if (config.token) {
+          try {
+            const res = await fetch(`https://agents.hot/api/developer/agents/${ticketData.agent_id}`, {
+              headers: { Authorization: `Bearer ${config.token}` }
+            });
+            if (res.ok) {
+              const agentData = await res.json();
+              if (agentData.name) nameBase = agentData.name;
+            }
+          } catch {
+          }
+        }
+        const bridgeAuthToken = ticketData.token || ticketData.bridge_token || "";
+        if (bridgeAuthToken.startsWith("ah_") && !loadToken()) {
+          saveToken(bridgeAuthToken);
+        }
+        const slug = uniqueSlug(nameBase);
+        const entry = {
+          agentId: ticketData.agent_id,
+          agentType: ticketData.agent_type,
+          bridgeUrl: ticketData.bridge_url,
+          gatewayUrl: opts.gatewayUrl,
+          gatewayToken,
+          projectPath: opts.project || getAgentWorkspaceDir(slug),
+          sandbox: opts.sandbox,
+          addedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        addAgent(slug, entry);
+        log.success(`Agent registered as "${slug}"`);
+        logWorkspaceHint(slug, entry.projectPath);
+        if (opts.foreground) {
+          opts.agentId = ticketData.agent_id;
+          opts.bridgeUrl = ticketData.bridge_url;
+          opts.gatewayToken = gatewayToken;
+          type = ticketData.agent_type;
+        } else {
+          const pid = spawnBackground(slug, entry, config.token);
+          await sleep(500);
+          if (isProcessAlive(pid)) {
+            console.log(`  ${GREEN}\u2713${RESET} ${BOLD}${slug}${RESET} started (PID: ${pid})`);
+          } else {
+            log.error(`Failed to start. Check logs: ${getLogPath(slug)}`);
+            process.exit(1);
+          }
+          const { ListTUI } = await import("./list-6CHWMM3O.js");
+          const tui = new ListTUI();
+          await tui.run();
+          return;
+        }
+      } catch (err) {
+        if (err instanceof Error && err.message.includes("fetch")) {
+          log.error(`Failed to fetch ticket: ${err.message}`);
+        } else {
+          throw err;
+        }
+        process.exit(1);
+      }
+    }
+    let agentName;
+    const agentType = type || (() => {
+      if (opts.agentId) {
+        const found2 = findAgentByAgentId(opts.agentId);
+        if (found2) return found2.entry.agentType;
+      }
+      return void 0;
+    })();
+    if (!agentType) {
+      log.error("Agent type is required. Use: agent-mesh connect <type> or agent-mesh connect --setup <url>");
+      process.exit(1);
+    }
+    const agentId = opts.agentId;
+    if (!agentId) {
+      log.error("--agent-id is required. Use --setup for automatic configuration.");
+      process.exit(1);
+    }
+    const found = findAgentByAgentId(agentId);
+    if (found) {
+      agentName = found.name;
+      const entry = found.entry;
+      opts.bridgeUrl = opts.bridgeUrl || entry.bridgeUrl;
+      opts.gatewayUrl = opts.gatewayUrl || entry.gatewayUrl;
+      opts.gatewayToken = opts.gatewayToken || entry.gatewayToken;
+      opts.project = opts.project || entry.projectPath || getAgentWorkspaceDir(found.name);
+      if (opts.sandbox === void 0 && entry.sandbox !== void 0) opts.sandbox = entry.sandbox;
+    }
+    if (!agentName) {
+      let nameBase = agentId.slice(0, 8);
+      if (config.token) {
+        try {
+          const res = await fetch(`https://agents.hot/api/developer/agents/${agentId}`, {
+            headers: { Authorization: `Bearer ${config.token}` }
+          });
+          if (res.ok) {
+            const agentData = await res.json();
+            if (agentData.name) nameBase = agentData.name;
+          }
+        } catch {
+        }
+      }
+      agentName = uniqueSlug(nameBase);
+    }
+    if (!opts.project) {
+      opts.project = getAgentWorkspaceDir(agentName);
+    }
+    const token = process.env.AGENT_BRIDGE_TOKEN || loadToken() || config.token || found?.entry.bridgeToken;
+    if (!token) {
+      log.error("Not authenticated. Run `agent-mesh login` or use `agent-mesh connect --setup <url>`.");
+      process.exit(1);
+    }
+    const bridgeUrl = opts.bridgeUrl || DEFAULT_BRIDGE_URL;
+    const sandboxEnabled = opts.sandbox ?? true;
+    if (sandboxEnabled) {
+      const ok = await initSandbox(agentType);
+      if (!ok) {
+        log.warn("Sandbox not available on this platform, continuing without sandbox");
+      }
+    }
+    if (agentType === "openclaw") {
+      const { isChatCompletionsEnabled } = await import("./openclaw-config-OFFNWVDK.js");
+      if (!isChatCompletionsEnabled()) {
+        log.warn(
+          'OpenClaw chatCompletions endpoint may not be enabled.\n  Add to ~/.openclaw/openclaw.json:\n  { "gateway": { "http": { "endpoints": { "chatCompletions": { "enabled": true } } } } }\n  Continuing anyway (gateway may be on a remote host)...'
+        );
+      }
+    }
+    const adapterConfig = {
+      project: opts.project,
+      gatewayUrl: opts.gatewayUrl,
+      gatewayToken: opts.gatewayToken,
+      sandboxEnabled,
+      agentId
+    };
+    const adapter = createAdapter(agentType, adapterConfig);
+    log.info(`Checking ${adapter.displayName} availability...`);
+    const available = await adapter.isAvailable();
+    if (!available) {
+      if (agentType === "codex" || agentType === "gemini") {
+        log.error(`${adapter.displayName} adapter is not yet implemented. Supported adapters: openclaw, claude`);
+      } else {
+        log.error(`${adapter.displayName} is not available. Make sure it is installed and running.`);
+      }
+      process.exit(1);
+    }
+    log.success(`${adapter.displayName} is available`);
+    log.info(`Connecting to bridge worker at ${bridgeUrl}...`);
+    const wsClient = new BridgeWSClient({
+      url: bridgeUrl,
+      token,
+      agentId,
+      agentType
+    });
+    try {
+      await wsClient.connect();
+    } catch (err) {
+      log.error(`Failed to connect to bridge worker: ${err}`);
+      process.exit(1);
+    }
+    log.success(`Registered as agent "${agentId}" (${agentType})`);
+    logWorkspaceHint(agentName, opts.project);
+    if (!found) {
+      addAgent(agentName, {
+        agentId,
+        agentType,
+        bridgeUrl,
+        gatewayUrl: opts.gatewayUrl,
+        gatewayToken: opts.gatewayToken,
+        projectPath: opts.project,
+        sandbox: opts.sandbox,
+        addedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      log.info(`Agent saved as "${agentName}"`);
+    } else if (found && !found.entry.projectPath) {
+      addAgent(agentName, {
+        ...found.entry,
+        projectPath: opts.project
+      });
+      log.info(`Updated "${agentName}" with workspace directory`);
+    }
+    if (agentName) writePid(agentName, process.pid);
+    const manager = new BridgeManager({ wsClient, adapter, adapterConfig });
+    manager.start();
+    log.banner(`Agent bridge is running. Press Ctrl+C to stop.`);
+    const shutdown = () => {
+      log.info("Shutting down...");
+      manager.stop();
+      wsClient.close();
+      resetSandbox();
+      if (agentName) removePid(agentName);
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    const MAX_UPTIME_MS = 24 * 60 * 60 * 1e3;
+    setTimeout(() => {
+      log.info("Max uptime reached (24h), shutting down for fresh restart...");
+      shutdown();
+    }, MAX_UPTIME_MS).unref();
+    if (process.env.DEBUG) {
+      setInterval(() => {
+        const mem = process.memoryUsage();
+        log.debug(`Memory: RSS=${(mem.rss / 1024 / 1024).toFixed(1)}MB Heap=${(mem.heapUsed / 1024 / 1024).toFixed(1)}MB`);
+      }, 5 * 60 * 1e3).unref();
+    }
+    wsClient.on("error", (err) => {
+      log.error(`Bridge connection error: ${err.message}`);
+    });
+    wsClient.on("replaced", () => {
+      log.error("Shutting down \u2014 only one CLI per agent is allowed.");
+      manager.stop();
+      resetSandbox();
+      if (agentName) removePid(agentName);
+      process.exit(1);
+    });
+    wsClient.on("token_revoked", () => {
+      log.error("Token revoked \u2014 shutting down.");
+      manager.stop();
+      resetSandbox();
+      if (agentName) removePid(agentName);
+      process.exit(1);
+    });
+    wsClient.on("reconnect", () => {
+      manager.reconnect();
+    });
+  });
+}
+
+// src/commands/login.ts
+import { exec } from "child_process";
+import * as tty from "tty";
+var DEFAULT_BASE_URL = "https://agents.hot";
+var POLL_INTERVAL_MS = 5e3;
+var SLOW_DOWN_INCREASE_MS = 5e3;
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? `open "${url}"` : process.platform === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
+  exec(cmd, (err) => {
+    if (err) {
+      log.debug(`Failed to open browser: ${err.message}`);
+    }
+  });
+}
+function createSpinner(message) {
+  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  let i = 0;
+  const timer = setInterval(() => {
+    process.stderr.write(`\r${message} ${frames[i++ % frames.length]}`);
+  }, 80);
+  return {
+    stop(finalMessage) {
+      clearInterval(timer);
+      process.stderr.write(`\r${finalMessage}
+`);
+    }
+  };
+}
+function isTTY() {
+  return tty.isatty(process.stdin.fd);
+}
+async function pollForToken(baseUrl, deviceCode, expiresIn, interval) {
+  const deadline = Date.now() + expiresIn * 1e3;
+  let pollMs = Math.max(interval * 1e3, POLL_INTERVAL_MS);
+  while (Date.now() < deadline) {
+    await new Promise((resolve2) => setTimeout(resolve2, pollMs));
+    const res = await fetch(`${baseUrl}/api/auth/device/token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ device_code: deviceCode })
+    });
+    if (res.ok) {
+      return await res.json();
+    }
+    const data = await res.json();
+    if (data.error === "authorization_pending") {
+      continue;
+    }
+    if (data.error === "slow_down") {
+      pollMs += SLOW_DOWN_INCREASE_MS;
+      continue;
+    }
+    throw new Error(data.error_description || data.error);
+  }
+  throw new Error("Device code expired. Run `agent-mesh login` again.");
+}
+function registerLoginCommand(program2) {
+  program2.command("login").description("Authenticate with the Agents.Hot platform").option("--token <token>", "Provide token directly (skip browser flow)").option("--force", "Re-login even if already authenticated").option("--base-url <url>", "Platform base URL", DEFAULT_BASE_URL).action(async (opts) => {
+    const baseUrl = opts.baseUrl ?? DEFAULT_BASE_URL;
+    if (opts.token) {
+      saveToken(opts.token);
+      log.success(`Token saved to ${getConfigPath()}`);
+      return;
+    }
+    if (hasToken() && !opts.force) {
+      const existing = loadToken();
+      log.info(
+        `Already logged in (token: ${existing.slice(0, 6)}...). Continuing will replace the existing token.`
+      );
+    }
+    const interactive = isTTY();
+    log.banner("Agent Mesh Login");
+    let deviceData;
+    try {
+      const res = await fetch(`${baseUrl}/api/auth/device`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          client_info: {
+            device_name: `CLI ${process.platform}`,
+            os: process.platform,
+            version: process.env.npm_package_version || "unknown"
+          }
+        })
+      });
+      if (!res.ok) {
+        throw new Error(`HTTP ${res.status}`);
+      }
+      deviceData = await res.json();
+    } catch (err) {
+      log.error(`Failed to request device code: ${err.message}`);
+      console.log("\nFallback: visit https://agents.hot/settings?tab=developer");
+      console.log("Create a CLI token and run: agent-mesh login --token <token>");
+      process.exit(1);
+    }
+    const url = deviceData.verification_uri_complete;
+    openBrowser(url);
+    console.log(`
+Open this URL to authorize:
+  ${url}
+`);
+    const spinner = interactive ? createSpinner("Waiting for authorization...") : null;
+    if (!interactive) {
+      console.log("Waiting for authorization (approve in your browser)...");
+    }
+    try {
+      const tokenData = await pollForToken(
+        baseUrl,
+        deviceData.device_code,
+        deviceData.expires_in,
+        deviceData.interval
+      );
+      if (spinner) {
+        spinner.stop(`\u2713 Logged in as ${tokenData.user.email || tokenData.user.name}`);
+      } else {
+        log.success(`Logged in as ${tokenData.user.email || tokenData.user.name}`);
+      }
+      saveToken(tokenData.access_token);
+      log.success(`Token saved to ${getConfigPath()}`);
+    } catch (err) {
+      if (spinner) {
+        spinner.stop(`\u2717 ${err.message}`);
+      } else {
+        log.error(err.message);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/status.ts
+function registerStatusCommand(program2) {
+  program2.command("status").description("Check authentication and connection status").action(async () => {
+    log.banner("Agent Mesh Status");
+    const config = loadConfig();
+    const configPath = getConfigPath();
+    console.log(`Config: ${configPath}`);
+    if (!hasToken()) {
+      console.log("Auth:   Not logged in");
+      console.log("\nRun `agent-mesh login` to authenticate.");
+      return;
+    }
+    const token = loadToken();
+    const maskedToken = token.slice(0, 8) + "..." + token.slice(-4);
+    console.log(`Auth:   Logged in (token: ${maskedToken})`);
+    if (config.defaultAgentType) {
+      console.log(`Agent:  ${config.defaultAgentType}`);
+    }
+    if (config.bridgeUrl) {
+      console.log(`Bridge: ${config.bridgeUrl}`);
+    }
+    if (config.gatewayUrl) {
+      console.log(`Gateway: ${config.gatewayUrl}`);
+    }
+    console.log("\nTo connect an agent, run:");
+    console.log("  agent-mesh connect <type> --agent-id <id>");
+    console.log("\nSupported types: openclaw, claude, codex, gemini");
+  });
+}
+
+// src/commands/start.ts
+function sleep2(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function registerStartCommand(program2) {
+  program2.command("start [name]").description("Start agent(s) in the background").option("--all", "Start all registered agents").action(async (name, opts) => {
+    const config = loadConfig();
+    const agents = config.agents;
+    let targets;
+    if (opts.all) {
+      targets = Object.keys(agents);
+    } else if (name) {
+      if (!agents[name]) {
+        log.error(`Agent "${name}" not found. Run 'agent-mesh list' to see registered agents.`);
+        process.exit(1);
+      }
+      targets = [name];
+    } else {
+      log.error("Specify an agent name or use --all. Run 'agent-mesh list' to see agents.");
+      process.exit(1);
+    }
+    if (targets.length === 0) {
+      console.log(`
+  No agents registered. Use ${BOLD}agent-mesh connect --setup <url>${RESET} to add one.
+`);
+      return;
+    }
+    let started = 0;
+    for (const t of targets) {
+      const entry = agents[t];
+      const pid = readPid(t);
+      if (pid !== null && isProcessAlive(pid)) {
+        console.log(`  ${YELLOW}\u2298${RESET} ${BOLD}${t}${RESET} already running (PID: ${pid})`);
+        continue;
+      }
+      const newPid = spawnBackground(t, entry, config.token);
+      await sleep2(500);
+      if (isProcessAlive(newPid)) {
+        console.log(`  ${GREEN}\u2713${RESET} ${BOLD}${t}${RESET} started (PID: ${newPid})`);
+        console.log(`    Logs: ${GRAY}${getLogPath(t)}${RESET}`);
+        started++;
+      } else {
+        console.log(`  ${RESET}\x1B[31m\u2717${RESET} ${BOLD}${t}${RESET} failed to start. Check logs: ${GRAY}${getLogPath(t)}${RESET}`);
+      }
+    }
+    if (targets.length > 1) {
+      console.log(`
+  ${GRAY}Started ${started} of ${targets.length} agents${RESET}
+`);
+    }
+  });
+}
+
+// src/commands/stop.ts
+function registerStopCommand(program2) {
+  program2.command("stop [name]").description("Stop agent(s)").option("--all", "Stop all running agents").action(async (name, opts) => {
+    const config = loadConfig();
+    const agents = config.agents;
+    let targets;
+    if (opts.all) {
+      targets = Object.keys(agents);
+    } else if (name) {
+      if (!agents[name]) {
+        log.error(`Agent "${name}" not found. Run 'agent-mesh list' to see registered agents.`);
+        process.exit(1);
+      }
+      targets = [name];
+    } else {
+      log.error("Specify an agent name or use --all. Run 'agent-mesh list' to see agents.");
+      process.exit(1);
+    }
+    if (targets.length === 0) {
+      console.log(`
+  No agents registered.
+`);
+      return;
+    }
+    let stopped = 0;
+    for (const t of targets) {
+      const ok = await stopProcess(t);
+      if (ok) {
+        console.log(`  ${GREEN}\u2713${RESET} ${BOLD}${t}${RESET} stopped`);
+        stopped++;
+      } else {
+        console.log(`  ${YELLOW}\u2298${RESET} ${BOLD}${t}${RESET} not running`);
+      }
+    }
+    if (targets.length > 1) {
+      console.log(`
+  ${GRAY}Stopped ${stopped} of ${targets.length} agents${RESET}
+`);
+    }
+  });
+}
+
+// src/commands/restart.ts
+function sleep3(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function registerRestartCommand(program2) {
+  program2.command("restart [name]").description("Restart agent(s)").option("--all", "Restart all registered agents").action(async (name, opts) => {
+    const config = loadConfig();
+    const agents = config.agents;
+    let targets;
+    if (opts.all) {
+      targets = Object.keys(agents);
+    } else if (name) {
+      if (!agents[name]) {
+        log.error(`Agent "${name}" not found. Run 'agent-mesh list' to see registered agents.`);
+        process.exit(1);
+      }
+      targets = [name];
+    } else {
+      log.error("Specify an agent name or use --all. Run 'agent-mesh list' to see agents.");
+      process.exit(1);
+    }
+    if (targets.length === 0) {
+      console.log(`
+  No agents registered.
+`);
+      return;
+    }
+    let restarted = 0;
+    for (const t of targets) {
+      await stopProcess(t);
+      await sleep3(1e3);
+      const entry = agents[t];
+      const newPid = spawnBackground(t, entry, config.token);
+      await sleep3(500);
+      if (isProcessAlive(newPid)) {
+        console.log(`  ${GREEN}\u2713${RESET} ${BOLD}${t}${RESET} restarted (PID: ${newPid})`);
+        console.log(`    Logs: ${GRAY}${getLogPath(t)}${RESET}`);
+        restarted++;
+      } else {
+        console.log(`  \x1B[31m\u2717${RESET} ${BOLD}${t}${RESET} failed to start. Check logs: ${GRAY}${getLogPath(t)}${RESET}`);
+      }
+    }
+    if (targets.length > 1) {
+      console.log(`
+  ${GRAY}Restarted ${restarted} of ${targets.length} agents${RESET}
+`);
+    }
+  });
+}
+
+// src/commands/logs.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+function registerLogsCommand(program2) {
+  program2.command("logs <name>").description("View agent logs (follows in real-time)").option("-n, --lines <number>", "Number of lines to show", "50").action((name, opts) => {
+    const entry = getAgent(name);
+    if (!entry) {
+      log.error(`Agent "${name}" not found. Run 'agent-mesh list' to see registered agents.`);
+      process.exit(1);
+    }
+    const logPath = getLogPath(name);
+    if (!existsSync2(logPath)) {
+      log.error(`No log file found for "${name}". Has this agent been started before?`);
+      process.exit(1);
+    }
+    const lines = parseInt(opts.lines, 10) || 50;
+    const label = ` ${name} (${entry.agentType}) `;
+    const totalWidth = 50;
+    const rightPad = Math.max(0, totalWidth - label.length - 3);
+    console.log(`
+  ${GRAY}\u2500\u2500\u2500${BOLD}${label}${RESET}${GRAY}${"\u2500".repeat(rightPad)}${RESET}`);
+    const tail = spawn2("tail", ["-f", "-n", String(lines), logPath], {
+      stdio: "inherit"
+    });
+    const cleanup = () => {
+      tail.kill();
+      process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    tail.on("exit", () => process.exit(0));
+  });
+}
+
+// src/commands/remove.ts
+import { createInterface as createInterface2 } from "readline";
+import { unlinkSync } from "fs";
+function confirm(prompt) {
+  const rl = createInterface2({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve2) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve2(answer.trim().toLowerCase() === "y");
+    });
+  });
+}
+function registerRemoveCommand(program2) {
+  program2.command("remove <name>").description("Remove an agent from the registry").option("--force", "Skip confirmation prompt").action(async (name, opts) => {
+    const entry = getAgent(name);
+    if (!entry) {
+      log.error(`Agent "${name}" not found. Run 'agent-mesh list' to see registered agents.`);
+      process.exit(1);
+    }
+    if (!opts.force) {
+      const yes = await confirm(`  Remove agent "${name}"? (y/N) `);
+      if (!yes) {
+        console.log("  Cancelled.");
+        return;
+      }
+    }
+    await stopProcess(name);
+    removeAgent(name);
+    removePid(name);
+    const logPath = getLogPath(name);
+    for (const suffix of ["", ".1", ".2"]) {
+      try {
+        unlinkSync(`${logPath}${suffix}`);
+      } catch {
+      }
+    }
+    console.log(`  ${GREEN}\u2713${RESET} ${BOLD}${name}${RESET} removed`);
+  });
+}
+
+// src/commands/open.ts
+import { spawn as spawn3 } from "child_process";
+function registerOpenCommand(program2) {
+  program2.command("open <name>").description("Open agent page in browser").action((name) => {
+    const entry = getAgent(name);
+    if (!entry) {
+      log.error(`Agent "${name}" not found. Run 'agent-mesh list' to see registered agents.`);
+      process.exit(1);
+    }
+    const url = `https://agents.hot/agents/${entry.agentId}`;
+    console.log(`  Opening ${GRAY}${url}${RESET}...`);
+    const cmd = process.platform === "darwin" ? "open" : "xdg-open";
+    const child = spawn3(cmd, [url], { detached: true, stdio: "ignore" });
+    child.unref();
+  });
+}
+
+// src/commands/install.ts
+import { writeFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir3 } from "os";
+import { execSync as execSync2 } from "child_process";
+var LABEL = "com.agents-hot.agent-mesh";
+var PLIST_DIR = join5(homedir3(), "Library", "LaunchAgents");
+var PLIST_PATH = join5(PLIST_DIR, `${LABEL}.plist`);
+var LOG_PATH = join5(homedir3(), ".agent-mesh", "logs", "launchd.log");
+function detectPaths() {
+  return {
+    node: process.execPath,
+    script: process.argv[1]
+  };
+}
+function generatePlist(nodePath, scriptPath) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LABEL}</string>
+
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(nodePath)}</string>
+    <string>${escapeXml(scriptPath)}</string>
+    <string>start</string>
+    <string>--all</string>
+  </array>
+
+  <key>RunAtLoad</key>
+  <true/>
+
+  <key>StandardOutPath</key>
+  <string>${escapeXml(LOG_PATH)}</string>
+
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(LOG_PATH)}</string>
+
+  <key>WorkingDirectory</key>
+  <string>${escapeXml(homedir3())}</string>
+</dict>
+</plist>
+`;
+}
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function registerInstallCommand(program2) {
+  program2.command("install").description("Install macOS LaunchAgent to auto-start agents on login").option("--force", "Overwrite existing LaunchAgent").action(async (opts) => {
+    if (process.platform !== "darwin") {
+      log.error("LaunchAgent is macOS only. On Linux, use systemd user service instead.");
+      process.exit(1);
+    }
+    if (existsSync3(PLIST_PATH) && !opts.force) {
+      console.log(`
+  ${YELLOW}\u2298${RESET} LaunchAgent already installed at:`);
+      console.log(`    ${GRAY}${PLIST_PATH}${RESET}`);
+      console.log(`
+  Use ${BOLD}--force${RESET} to overwrite.
+`);
+      return;
+    }
+    const { node, script } = detectPaths();
+    if (!existsSync3(PLIST_DIR)) {
+      mkdirSync2(PLIST_DIR, { recursive: true });
+    }
+    if (existsSync3(PLIST_PATH)) {
+      try {
+        execSync2(`launchctl bootout gui/$(id -u) "${PLIST_PATH}" 2>/dev/null`, { stdio: "ignore" });
+      } catch {
+      }
+    }
+    const plist = generatePlist(node, script);
+    writeFileSync(PLIST_PATH, plist, { encoding: "utf-8" });
+    try {
+      execSync2(`launchctl bootstrap gui/$(id -u) "${PLIST_PATH}"`, { stdio: "pipe" });
+    } catch {
+      try {
+        execSync2(`launchctl load "${PLIST_PATH}"`, { stdio: "pipe" });
+      } catch (err) {
+        log.error(`Failed to load LaunchAgent: ${err}`);
+        log.info(`Plist written to ${PLIST_PATH} \u2014 you can load it manually.`);
+        return;
+      }
+    }
+    console.log(`
+  ${GREEN}\u2713${RESET} LaunchAgent installed`);
+    console.log(`    Plist: ${GRAY}${PLIST_PATH}${RESET}`);
+    console.log(`    Log:   ${GRAY}${LOG_PATH}${RESET}`);
+    console.log(`    Node:  ${GRAY}${node}${RESET}`);
+    console.log(`    CLI:   ${GRAY}${script}${RESET}`);
+    console.log(`
+  All registered agents will auto-start on login.`);
+    console.log(`  Use ${BOLD}agent-mesh uninstall${RESET} to remove.
+`);
+  });
+}
+
+// src/commands/uninstall.ts
+import { existsSync as existsSync4, unlinkSync as unlinkSync2 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir4 } from "os";
+import { execSync as execSync3 } from "child_process";
+var LABEL2 = "com.agents-hot.agent-mesh";
+var PLIST_PATH2 = join6(homedir4(), "Library", "LaunchAgents", `${LABEL2}.plist`);
+function registerUninstallCommand(program2) {
+  program2.command("uninstall").description("Remove macOS LaunchAgent (agents will no longer auto-start)").action(async () => {
+    if (process.platform !== "darwin") {
+      log.error("LaunchAgent is macOS only.");
+      process.exit(1);
+    }
+    if (!existsSync4(PLIST_PATH2)) {
+      console.log(`
+  ${YELLOW}\u2298${RESET} No LaunchAgent found at ${GRAY}${PLIST_PATH2}${RESET}
+`);
+      return;
+    }
+    try {
+      execSync3(`launchctl bootout gui/$(id -u) "${PLIST_PATH2}" 2>/dev/null`, { stdio: "ignore" });
+    } catch {
+      try {
+        execSync3(`launchctl unload "${PLIST_PATH2}" 2>/dev/null`, { stdio: "ignore" });
+      } catch {
+      }
+    }
+    try {
+      unlinkSync2(PLIST_PATH2);
+    } catch (err) {
+      log.error(`Failed to remove plist: ${err}`);
+      return;
+    }
+    console.log(`
+  ${GREEN}\u2713${RESET} LaunchAgent removed`);
+    console.log(`    Agents will no longer auto-start on login.`);
+    console.log(`    Use ${BOLD}agent-mesh install${RESET} to re-install.
+`);
+  });
+}
+
+// src/commands/agents.ts
+import { createInterface as createInterface3 } from "readline";
+
+// src/platform/api-client.ts
+var DEFAULT_BASE_URL2 = "https://agents.hot";
+var PlatformApiError = class extends Error {
+  constructor(statusCode, errorCode, message) {
+    super(message);
+    this.statusCode = statusCode;
+    this.errorCode = errorCode;
+    this.name = "PlatformApiError";
+  }
+};
+var ERROR_HINTS = {
+  unauthorized: "Not authenticated. Run `agent-mesh login` first.",
+  forbidden: "You don't own this agent.",
+  not_found: "Agent not found.",
+  agent_offline: "Agent must be online for first publish. Run `agent-mesh connect` first.",
+  email_required: "Email required. Visit https://agents.hot/settings to add one.",
+  github_required: "GitHub account required. Visit https://agents.hot/settings to link one.",
+  validation_error: "Invalid input. Check your skill.json or command flags.",
+  permission_denied: "You don't have permission to modify this skill.",
+  file_too_large: "Package file exceeds the 50MB limit."
+};
+var PlatformClient = class {
+  token;
+  baseUrl;
+  constructor(token, baseUrl) {
+    const resolved = token ?? loadToken();
+    if (!resolved) {
+      throw new PlatformApiError(401, "unauthorized", ERROR_HINTS.unauthorized);
+    }
+    this.token = resolved;
+    this.baseUrl = baseUrl ?? DEFAULT_BASE_URL2;
+  }
+  async get(path) {
+    return this.request("GET", path);
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  async put(path, body) {
+    return this.request("PUT", path, body);
+  }
+  async patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  async del(path, body) {
+    return this.request("DELETE", path, body);
+  }
+  async postFormData(path, formData) {
+    const url = `${this.baseUrl}${path}`;
+    let res;
+    try {
+      res = await fetch(url, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${this.token}` },
+        body: formData
+      });
+    } catch (err) {
+      throw new PlatformApiError(0, "network_error", `Network error: ${err.message}`);
+    }
+    return this.handleResponse(res);
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      Authorization: `Bearer ${this.token}`,
+      "Content-Type": "application/json"
+    };
+    const init = { method, headers };
+    if (body !== void 0) {
+      init.body = JSON.stringify(body);
+    }
+    let res;
+    try {
+      res = await fetch(url, init);
+    } catch (err) {
+      throw new PlatformApiError(0, "network_error", `Network error: ${err.message}`);
+    }
+    return this.handleResponse(res);
+  }
+  async handleResponse(res) {
+    if (!res.ok) {
+      let errorCode = "unknown";
+      let message = `HTTP ${res.status}`;
+      try {
+        const data = await res.json();
+        errorCode = data.error ?? errorCode;
+        message = data.error_description ?? data.message ?? message;
+      } catch {
+      }
+      const hint = ERROR_HINTS[errorCode];
+      throw new PlatformApiError(res.status, errorCode, hint ?? message);
+    }
+    return res.json();
+  }
+};
+function createClient(baseUrl) {
+  return new PlatformClient(void 0, baseUrl);
+}
+
+// src/platform/resolve-agent.ts
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+async function resolveAgentId(input, client) {
+  if (UUID_RE.test(input)) {
+    return { id: input, name: input };
+  }
+  const local = listAgents();
+  if (input in local) {
+    return { id: local[input].agentId, name: input };
+  }
+  const byId = findAgentByAgentId(input);
+  if (byId) {
+    return { id: byId.entry.agentId, name: byId.name };
+  }
+  const data = await client.get("/api/developer/agents");
+  const lower = input.toLowerCase();
+  const match = data.agents.find((a) => a.name.toLowerCase() === lower);
+  if (match) {
+    return { id: match.id, name: match.name };
+  }
+  throw new Error(`Agent not found: "${input}". Use a UUID, local alias, or exact agent name.`);
+}
+
+// src/commands/agents.ts
+function readLine(prompt) {
+  const rl = createInterface3({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve2) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+}
+function formatStatus(online) {
+  return online ? `${GREEN}\u25CF online${RESET}` : `${GRAY}\u25CB offline${RESET}`;
+}
+function formatPublished(published) {
+  return published ? `${GREEN}yes${RESET}` : `${GRAY}no${RESET}`;
+}
+function handleError(err) {
+  if (err instanceof PlatformApiError) {
+    log.error(err.message);
+  } else {
+    log.error(err.message);
+  }
+  process.exit(1);
+}
+function registerAgentsCommand(program2) {
+  const agents = program2.command("agents").description("Manage agents on the Agents.Hot platform");
+  agents.command("list").alias("ls").description("List your agents").option("--json", "Output raw JSON").action(async (opts) => {
+    try {
+      const client = createClient();
+      const data = await client.get("/api/developer/agents");
+      if (opts.json) {
+        console.log(JSON.stringify(data.agents, null, 2));
+        return;
+      }
+      if (data.agents.length === 0) {
+        log.info("No agents found. Create one with: agent-mesh agents create");
+        return;
+      }
+      const table = renderTable(
+        [
+          { key: "name", label: "NAME", width: 24 },
+          { key: "type", label: "TYPE", width: 12 },
+          { key: "status", label: "STATUS", width: 14 },
+          { key: "published", label: "PUBLISHED", width: 12 },
+          { key: "caps", label: "CAPABILITIES", width: 14 }
+        ],
+        data.agents.map((a) => ({
+          name: a.name,
+          type: a.agent_type,
+          status: formatStatus(a.is_online),
+          published: formatPublished(a.is_published),
+          caps: (a.capabilities?.length || 0).toString()
+        }))
+      );
+      console.log(table);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  agents.command("create").description("Create a new agent").option("--name <name>", "Agent name").option("--type <type>", "Agent type (openclaw | claude)", "openclaw").option("--description <desc>", "Agent description").action(async (opts) => {
+    try {
+      let { name, description } = opts;
+      const agentType = opts.type;
+      if (!name && process.stdin.isTTY) {
+        log.banner("Create Agent");
+        name = await readLine("Agent name: ");
+        if (!name) {
+          log.error("Name is required");
+          process.exit(1);
+        }
+        if (!description) {
+          description = await readLine("Description (optional): ");
+        }
+      }
+      if (!name) {
+        log.error("--name is required. Use interactive mode (TTY) or provide --name.");
+        process.exit(1);
+      }
+      const client = createClient();
+      const result = await client.post("/api/developer/agents", {
+        name,
+        description: description || void 0,
+        agent_type: agentType
+      });
+      const detail = await client.get(`/api/developer/agents/${result.agent.id}`);
+      log.success(`Agent created: ${BOLD}${detail.name}${RESET} (${detail.id})`);
+      console.log("");
+      console.log("  Next: connect your agent");
+      console.log(`  ${GRAY}agent-mesh connect --agent-id ${detail.id}${RESET}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  agents.command("show <id-or-name>").description("Show agent details").option("--json", "Output raw JSON").action(async (input, opts) => {
+    try {
+      const client = createClient();
+      const { id } = await resolveAgentId(input, client);
+      const agent = await client.get(`/api/developer/agents/${id}`);
+      if (opts.json) {
+        console.log(JSON.stringify(agent, null, 2));
+        return;
+      }
+      console.log("");
+      console.log(`  ${BOLD}${agent.name}${RESET}`);
+      console.log(`  ${GRAY}ID${RESET}            ${agent.id}`);
+      console.log(`  ${GRAY}Type${RESET}          ${agent.agent_type}`);
+      console.log(`  ${GRAY}Status${RESET}        ${formatStatus(agent.is_online)}`);
+      console.log(`  ${GRAY}Published${RESET}     ${formatPublished(agent.is_published)}`);
+      if (agent.capabilities?.length) {
+        console.log(`  ${GRAY}Capabilities${RESET}  ${agent.capabilities.join(", ")}`);
+      }
+      if (agent.rate_limits && Object.keys(agent.rate_limits).length > 0) {
+        console.log(`  ${GRAY}Rate Limits${RESET}   ${JSON.stringify(agent.rate_limits)}`);
+      }
+      console.log(`  ${GRAY}Created${RESET}       ${agent.created_at}`);
+      if (agent.description) {
+        console.log("");
+        console.log(`  ${agent.description}`);
+      }
+      console.log("");
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  agents.command("update <id-or-name>").description("Update an agent").option("--name <name>", "New name").option("--type <type>", "Agent type (openclaw | claude)").option("--description <desc>", "Agent description").action(async (input, opts) => {
+    try {
+      const updates = {};
+      if (opts.name !== void 0) updates.name = opts.name;
+      if (opts.type !== void 0) updates.agent_type = opts.type;
+      if (opts.description !== void 0) updates.description = opts.description;
+      if (Object.keys(updates).length === 0) {
+        log.error("No fields to update. Use --name, --type, --description.");
+        process.exit(1);
+      }
+      const client = createClient();
+      const { id, name } = await resolveAgentId(input, client);
+      const result = await client.put(`/api/developer/agents/${id}`, updates);
+      log.success(`Agent updated: ${BOLD}${result.agent.name}${RESET}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  agents.command("publish <id-or-name>").description("Publish agent to marketplace").action(async (input) => {
+    try {
+      const client = createClient();
+      const { id, name } = await resolveAgentId(input, client);
+      await client.put(`/api/developer/agents/${id}`, { is_published: true });
+      log.success(`Agent published: ${BOLD}${name}${RESET}`);
+      console.log(`  View at: ${GRAY}https://agents.hot${RESET}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  agents.command("unpublish <id-or-name>").description("Unpublish agent from marketplace").action(async (input) => {
+    try {
+      const client = createClient();
+      const { id, name } = await resolveAgentId(input, client);
+      await client.put(`/api/developer/agents/${id}`, { is_published: false });
+      log.success(`Agent unpublished: ${BOLD}${name}${RESET}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  agents.command("delete <id-or-name>").description("Delete an agent (soft delete)").action(async (input) => {
+    try {
+      const client = createClient();
+      const { id, name } = await resolveAgentId(input, client);
+      if (process.stdin.isTTY) {
+        const answer = await readLine(`Delete agent "${name}"? (y/N): `);
+        if (answer.toLowerCase() !== "y") {
+          log.info("Cancelled.");
+          return;
+        }
+      }
+      await client.del(`/api/developer/agents/${id}`);
+      log.success(`Agent deleted: ${BOLD}${name}${RESET}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/chat.ts
+import { createInterface as createInterface4 } from "readline";
+
+// src/utils/sse-parser.ts
+function parseSseChunk(raw, carry) {
+  const merged = carry + raw;
+  const blocks = merged.split(/\r?\n\r?\n/);
+  const nextCarry = blocks.pop() || "";
+  const events = [];
+  for (const block of blocks) {
+    let data = "";
+    for (const line of block.split(/\r?\n/)) {
+      if (line.startsWith("data:")) {
+        data += line.slice(5).trimStart() + "\n";
+      }
+    }
+    const trimmed = data.trim();
+    if (trimmed) events.push(trimmed);
+  }
+  return { events, carry: nextCarry };
+}
+
+// src/commands/chat.ts
+var DEFAULT_BASE_URL3 = "https://agents.hot";
+async function streamChat(opts) {
+  const res = await fetch(`${opts.baseUrl}/api/agents/${opts.agentId}/chat`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${opts.token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ message: opts.message }),
+    signal: opts.signal
+  });
+  if (!res.ok) {
+    let msg = `HTTP ${res.status}`;
+    try {
+      const body = await res.json();
+      msg = body.message || body.error || msg;
+    } catch {
+    }
+    throw new Error(msg);
+  }
+  if (!res.body) throw new Error("Empty response body");
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let inThinking = false;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    const chunk = decoder.decode(value, { stream: true });
+    const parsed = parseSseChunk(chunk, buffer);
+    buffer = parsed.carry;
+    for (const data of parsed.events) {
+      if (data === "[DONE]") continue;
+      try {
+        const event = JSON.parse(data);
+        handleSseEvent(event, opts.showThinking ?? true, { inThinking });
+        if (event.type === "reasoning-start") inThinking = true;
+        if (event.type === "reasoning-end") inThinking = false;
+      } catch {
+      }
+    }
+  }
+  if (buffer.trim()) {
+    const parsed = parseSseChunk("\n\n", buffer);
+    for (const data of parsed.events) {
+      if (data === "[DONE]") continue;
+      try {
+        const event = JSON.parse(data);
+        handleSseEvent(event, opts.showThinking ?? true, { inThinking });
+      } catch {
+      }
+    }
+  }
+  process.stdout.write("\n");
+}
+function handleSseEvent(event, showThinking, state) {
+  switch (event.type) {
+    case "text-delta":
+      process.stdout.write(String(event.delta ?? ""));
+      break;
+    case "reasoning-delta":
+      if (showThinking) {
+        process.stdout.write(`${GRAY}${String(event.delta ?? "")}${RESET}`);
+      }
+      break;
+    case "reasoning-start":
+      if (showThinking) {
+        process.stdout.write(`${GRAY}[thinking] `);
+      }
+      break;
+    case "reasoning-end":
+      if (showThinking && state.inThinking) {
+        process.stdout.write(`${RESET}
+`);
+      }
+      break;
+    case "tool-input-start":
+      process.stdout.write(`
+${YELLOW}[tool: ${event.toolName}]${RESET} `);
+      break;
+    case "tool-output-available": {
+      const output = String(event.output ?? "");
+      const preview = output.length > 200 ? output.slice(0, 200) + "..." : output;
+      process.stdout.write(`${GRAY}${preview}${RESET}
+`);
+      break;
+    }
+    case "source-url":
+      process.stdout.write(`${GRAY}[file: ${event.title} \u2192 ${event.url}]${RESET}
+`);
+      break;
+    case "error":
+      process.stderr.write(`
+${"\x1B[31m"}Error: ${event.errorText}${RESET}
+`);
+      break;
+    // Ignored: text-start, text-end, start, start-step, finish-step, finish
+    default:
+      break;
+  }
+}
+function registerChatCommand(program2) {
+  program2.command("chat <agent> [message]").description("Chat with an agent through the platform (for debugging)").option("--no-thinking", "Hide thinking/reasoning output").option("--base-url <url>", "Platform base URL", DEFAULT_BASE_URL3).action(async (agentInput, inlineMessage, opts) => {
+    const token = loadToken();
+    if (!token) {
+      log.error("Not authenticated. Run `agent-mesh login` first.");
+      process.exit(1);
+    }
+    let agentId;
+    let agentName;
+    try {
+      const client = createClient(opts.baseUrl);
+      const resolved = await resolveAgentId(agentInput, client);
+      agentId = resolved.id;
+      agentName = resolved.name;
+    } catch (err) {
+      log.error(err.message);
+      process.exit(1);
+    }
+    if (inlineMessage) {
+      log.info(`Chatting with ${BOLD}${agentName}${RESET}`);
+      try {
+        await streamChat({
+          agentId,
+          message: inlineMessage,
+          token,
+          baseUrl: opts.baseUrl,
+          showThinking: opts.thinking
+        });
+      } catch (err) {
+        log.error(err.message);
+        process.exit(1);
+      }
+      return;
+    }
+    if (!process.stdin.isTTY) {
+      log.error("Interactive mode requires a TTY. Provide a message argument for non-interactive use.");
+      process.exit(1);
+    }
+    log.banner(`Chat with ${agentName}`);
+    console.log(`${GRAY}Type your message and press Enter. Use /quit or Ctrl+C to exit.${RESET}
+`);
+    const rl = createInterface4({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: `${GREEN}> ${RESET}`
+    });
+    const abortController = new AbortController();
+    rl.on("close", () => {
+      abortController.abort();
+      console.log("");
+      process.exit(0);
+    });
+    rl.prompt();
+    rl.on("line", async (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        rl.prompt();
+        return;
+      }
+      if (trimmed === "/quit" || trimmed === "/exit" || trimmed === "/q") {
+        rl.close();
+        return;
+      }
+      console.log("");
+      try {
+        await streamChat({
+          agentId,
+          message: trimmed,
+          token,
+          baseUrl: opts.baseUrl,
+          showThinking: opts.thinking
+        });
+      } catch (err) {
+        if (abortController.signal.aborted) return;
+        log.error(err.message);
+      }
+      console.log("");
+      rl.prompt();
+    });
+  });
+}
+
+// src/commands/skills.ts
+import { readFile as readFile4, writeFile as writeFile2, readdir as readdir2, stat as stat3, mkdir as mkdir2 } from "fs/promises";
+import { join as join8, resolve, relative as relative4 } from "path";
+
+// src/utils/skill-parser.ts
+import { readFile as readFile3, stat as stat2 } from "fs/promises";
+import { join as join7 } from "path";
+function parseSkillMd(raw) {
+  const trimmed = raw.trimStart();
+  if (!trimmed.startsWith("---")) {
+    return { frontmatter: {}, content: raw };
+  }
+  const endIdx = trimmed.indexOf("\n---", 3);
+  if (endIdx === -1) {
+    return { frontmatter: {}, content: raw };
+  }
+  const yamlBlock = trimmed.slice(4, endIdx);
+  const content = trimmed.slice(endIdx + 4).trimStart();
+  const frontmatter = {};
+  let currentKey = null;
+  let currentArray = null;
+  for (const line of yamlBlock.split("\n")) {
+    const trimLine = line.trim();
+    if (!trimLine || trimLine.startsWith("#")) continue;
+    if (trimLine.startsWith("- ") && currentKey && currentArray) {
+      currentArray.push(trimLine.slice(2).trim().replace(/^["']|["']$/g, ""));
+      continue;
+    }
+    if (currentKey && currentArray) {
+      frontmatter[currentKey] = currentArray;
+      currentKey = null;
+      currentArray = null;
+    }
+    const colonIdx = trimLine.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = trimLine.slice(0, colonIdx).trim();
+    const rawVal = trimLine.slice(colonIdx + 1).trim();
+    if (!rawVal) {
+      currentKey = key;
+      currentArray = [];
+      continue;
+    }
+    if (rawVal.startsWith("[") && rawVal.endsWith("]")) {
+      frontmatter[key] = rawVal.slice(1, -1).split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+      continue;
+    }
+    if (rawVal === "true") {
+      frontmatter[key] = true;
+      continue;
+    }
+    if (rawVal === "false") {
+      frontmatter[key] = false;
+      continue;
+    }
+    if (/^\d+(\.\d+)?$/.test(rawVal)) {
+      frontmatter[key] = Number(rawVal);
+      continue;
+    }
+    frontmatter[key] = rawVal.replace(/^["']|["']$/g, "");
+  }
+  if (currentKey && currentArray) {
+    frontmatter[currentKey] = currentArray;
+  }
+  return { frontmatter, content };
+}
+async function loadSkillManifest(dir) {
+  const skillJsonPath = join7(dir, "skill.json");
+  try {
+    const raw = await readFile3(skillJsonPath, "utf-8");
+    const data = JSON.parse(raw);
+    if (!data.name) throw new Error("skill.json missing required field: name");
+    if (!data.version) throw new Error("skill.json missing required field: version");
+    return {
+      name: data.name,
+      version: data.version,
+      description: data.description,
+      main: data.main || "SKILL.md",
+      category: data.category,
+      tags: data.tags,
+      author: data.author,
+      source_url: data.source_url,
+      private: data.private,
+      files: data.files
+    };
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+  }
+  const skillMdPath = join7(dir, "SKILL.md");
+  try {
+    const raw = await readFile3(skillMdPath, "utf-8");
+    const { frontmatter } = parseSkillMd(raw);
+    const name = frontmatter.name;
+    if (!name) {
+      throw new Error('No skill.json found and SKILL.md has no "name" in frontmatter');
+    }
+    return {
+      name,
+      version: frontmatter.version || "1.0.0",
+      description: frontmatter.description,
+      main: "SKILL.md",
+      category: frontmatter.category,
+      tags: frontmatter.tags,
+      author: frontmatter.author,
+      source_url: frontmatter.source_url,
+      private: frontmatter.private
+    };
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw new Error(`No skill.json or SKILL.md found in ${dir}`);
+    }
+    throw err;
+  }
+}
+async function pathExists(p) {
+  try {
+    await stat2(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/zip.ts
+import { deflateRawSync } from "zlib";
+function dosTime(date) {
+  return {
+    time: date.getHours() << 11 | date.getMinutes() << 5 | date.getSeconds() >> 1,
+    date: date.getFullYear() - 1980 << 9 | date.getMonth() + 1 << 5 | date.getDate()
+  };
+}
+function crc32(buf) {
+  let crc = 4294967295;
+  for (let i = 0; i < buf.length; i++) {
+    crc ^= buf[i];
+    for (let j = 0; j < 8; j++) {
+      crc = crc >>> 1 ^ (crc & 1 ? 3988292384 : 0);
+    }
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function writeUint16LE(buf, val, offset) {
+  buf[offset] = val & 255;
+  buf[offset + 1] = val >>> 8 & 255;
+}
+function writeUint32LE(buf, val, offset) {
+  buf[offset] = val & 255;
+  buf[offset + 1] = val >>> 8 & 255;
+  buf[offset + 2] = val >>> 16 & 255;
+  buf[offset + 3] = val >>> 24 & 255;
+}
+function createZipBuffer(entries) {
+  const now = /* @__PURE__ */ new Date();
+  const { time, date } = dosTime(now);
+  const records = [];
+  const chunks = [];
+  let offset = 0;
+  for (const entry of entries) {
+    const nameBytes = Buffer.from(entry.path, "utf-8");
+    const crc = crc32(entry.data);
+    const compressed = deflateRawSync(entry.data, { level: 6 });
+    const compressedSize = compressed.length;
+    const uncompressedSize = entry.data.length;
+    const header = Buffer.alloc(30 + nameBytes.length);
+    writeUint32LE(header, 67324752, 0);
+    writeUint16LE(header, 20, 4);
+    writeUint16LE(header, 0, 6);
+    writeUint16LE(header, 8, 8);
+    writeUint16LE(header, time, 10);
+    writeUint16LE(header, date, 12);
+    writeUint32LE(header, crc, 14);
+    writeUint32LE(header, compressedSize, 18);
+    writeUint32LE(header, uncompressedSize, 22);
+    writeUint16LE(header, nameBytes.length, 26);
+    writeUint16LE(header, 0, 28);
+    nameBytes.copy(header, 30);
+    records.push({ header, compressed, crc, compressedSize, uncompressedSize, offset });
+    chunks.push(header, compressed);
+    offset += header.length + compressed.length;
+  }
+  const centralDirStart = offset;
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    const rec = records[i];
+    const nameBytes = Buffer.from(entry.path, "utf-8");
+    const cdh = Buffer.alloc(46 + nameBytes.length);
+    writeUint32LE(cdh, 33639248, 0);
+    writeUint16LE(cdh, 20, 4);
+    writeUint16LE(cdh, 20, 6);
+    writeUint16LE(cdh, 0, 8);
+    writeUint16LE(cdh, 8, 10);
+    writeUint16LE(cdh, time, 12);
+    writeUint16LE(cdh, date, 14);
+    writeUint32LE(cdh, rec.crc, 16);
+    writeUint32LE(cdh, rec.compressedSize, 20);
+    writeUint32LE(cdh, rec.uncompressedSize, 24);
+    writeUint16LE(cdh, nameBytes.length, 28);
+    writeUint16LE(cdh, 0, 30);
+    writeUint16LE(cdh, 0, 32);
+    writeUint16LE(cdh, 0, 34);
+    writeUint16LE(cdh, 0, 36);
+    writeUint32LE(cdh, 0, 38);
+    writeUint32LE(cdh, rec.offset, 42);
+    nameBytes.copy(cdh, 46);
+    chunks.push(cdh);
+    offset += cdh.length;
+  }
+  const centralDirSize = offset - centralDirStart;
+  const eocd = Buffer.alloc(22);
+  writeUint32LE(eocd, 101010256, 0);
+  writeUint16LE(eocd, 0, 4);
+  writeUint16LE(eocd, 0, 6);
+  writeUint16LE(eocd, entries.length, 8);
+  writeUint16LE(eocd, entries.length, 10);
+  writeUint32LE(eocd, centralDirSize, 12);
+  writeUint32LE(eocd, centralDirStart, 16);
+  writeUint16LE(eocd, 0, 20);
+  chunks.push(eocd);
+  return Buffer.concat(chunks);
+}
+
+// src/commands/skills.ts
+var slog = {
+  info: (msg) => {
+    process.stderr.write(`\x1B[34mINFO\x1B[0m  ${msg}
+`);
+  },
+  success: (msg) => {
+    process.stderr.write(`\x1B[32mOK\x1B[0m    ${msg}
+`);
+  },
+  warn: (msg) => {
+    process.stderr.write(`\x1B[33mWARN\x1B[0m  ${msg}
+`);
+  },
+  banner: (text) => {
+    process.stderr.write(`
+\x1B[1m${text}\x1B[0m
+
+`);
+  }
+};
+function outputJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function outputError(error, message, hint) {
+  console.log(JSON.stringify({ success: false, error, message, ...hint ? { hint } : {} }));
+  process.exit(1);
+}
+function resolveSkillDir(pathArg) {
+  return pathArg ? resolve(pathArg) : process.cwd();
+}
+async function collectPackFiles(dir, manifest) {
+  const results = [];
+  if (manifest.files && manifest.files.length > 0) {
+    for (const pattern of manifest.files) {
+      const fullPath = join8(dir, pattern);
+      try {
+        const s = await stat3(fullPath);
+        if (s.isDirectory()) {
+          const sub = await walkDir(fullPath);
+          for (const f of sub) {
+            results.push(relative4(dir, f));
+          }
+        } else {
+          results.push(pattern);
+        }
+      } catch {
+      }
+    }
+  } else {
+    const all = await walkDir(dir);
+    for (const f of all) {
+      const rel = relative4(dir, f);
+      if (rel === "skill.json") continue;
+      results.push(rel);
+    }
+  }
+  const mainFile = manifest.main || "SKILL.md";
+  if (!results.includes(mainFile)) {
+    const mainPath = join8(dir, mainFile);
+    if (await pathExists(mainPath)) {
+      results.unshift(mainFile);
+    }
+  }
+  return [...new Set(results)];
+}
+async function walkDir(dir) {
+  const files = [];
+  let entries;
+  try {
+    entries = await readdir2(dir, { withFileTypes: true });
+  } catch {
+    return files;
+  }
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) continue;
+    const fullPath = join8(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
+      const sub = await walkDir(fullPath);
+      files.push(...sub);
+    } else if (entry.isFile()) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+async function packSkill(dir, manifest) {
+  const fileList = await collectPackFiles(dir, manifest);
+  if (fileList.length === 0) {
+    outputError("no_files", "No files found to pack");
+  }
+  const entries = [];
+  for (const relPath of fileList) {
+    const absPath = join8(dir, relPath);
+    try {
+      const data = await readFile4(absPath);
+      entries.push({ path: relPath.replace(/\\/g, "/"), data });
+    } catch {
+      slog.warn(`Skipping unreadable file: ${relPath}`);
+    }
+  }
+  const buffer = createZipBuffer(entries);
+  const filename = `${manifest.name}-${manifest.version}.zip`;
+  return {
+    filename,
+    buffer,
+    files: fileList,
+    size: buffer.length
+  };
+}
+function bumpVersion(current, bump) {
+  if (/^\d+\.\d+\.\d+/.test(bump)) return bump;
+  const parts = current.split(".").map(Number);
+  if (parts.length < 3) return current;
+  switch (bump) {
+    case "major":
+      return `${parts[0] + 1}.0.0`;
+    case "minor":
+      return `${parts[0]}.${parts[1] + 1}.0`;
+    case "patch":
+      return `${parts[0]}.${parts[1]}.${parts[2] + 1}`;
+    default:
+      throw new Error(`Invalid bump type: ${bump}. Use major, minor, patch, or a version string.`);
+  }
+}
+var SKILL_MD_TEMPLATE = `---
+name: {{name}}
+version: 1.0.0
+---
+
+# {{name}}
+
+{{description}}
+
+## Usage
+
+Describe how to use this skill.
+`;
+var SKILL_JSON_TEMPLATE = (name, description) => ({
+  name,
+  version: "1.0.0",
+  description,
+  main: "SKILL.md",
+  category: "general",
+  tags: [],
+  files: ["SKILL.md"]
+});
+function registerSkillsCommand(program2) {
+  const skills = program2.command("skills").description("Manage skill packages (publish, pack, version)");
+  skills.command("init [path]").description("Initialize a new skill project").option("--name <name>", "Skill name").option("--description <desc>", "Skill description").action(async (pathArg, opts) => {
+    try {
+      const dir = resolveSkillDir(pathArg);
+      await mkdir2(dir, { recursive: true });
+      let name = opts.name;
+      let description = opts.description || "";
+      const skillMdPath = join8(dir, "SKILL.md");
+      const skillJsonPath = join8(dir, "skill.json");
+      if (await pathExists(skillJsonPath)) {
+        outputError("already_exists", "skill.json already exists in this directory");
+      }
+      if (await pathExists(skillMdPath)) {
+        const raw = await readFile4(skillMdPath, "utf-8");
+        const { frontmatter } = parseSkillMd(raw);
+        if (frontmatter.name) {
+          name = name || frontmatter.name;
+          description = description || frontmatter.description || "";
+          const manifest2 = {
+            name,
+            version: frontmatter.version || "1.0.0",
+            description,
+            main: "SKILL.md",
+            category: frontmatter.category || "general",
+            tags: frontmatter.tags || [],
+            author: frontmatter.author,
+            source_url: frontmatter.source_url,
+            files: ["SKILL.md"]
+          };
+          await writeFile2(skillJsonPath, JSON.stringify(manifest2, null, 2) + "\n");
+          slog.info(`Migrated frontmatter from SKILL.md to skill.json`);
+          outputJson({ success: true, path: skillJsonPath, migrated: true });
+          return;
+        }
+      }
+      if (!name) {
+        name = dir.split("/").pop()?.replace(/[^a-z0-9-]/gi, "-").toLowerCase() || "my-skill";
+      }
+      const manifest = SKILL_JSON_TEMPLATE(name, description);
+      await writeFile2(skillJsonPath, JSON.stringify(manifest, null, 2) + "\n");
+      if (!await pathExists(skillMdPath)) {
+        const content = SKILL_MD_TEMPLATE.replace(/\{\{name\}\}/g, name).replace(/\{\{description\}\}/g, description || "A new skill.");
+        await writeFile2(skillMdPath, content);
+      }
+      slog.info(`Initialized skill: ${name}`);
+      outputJson({ success: true, path: skillJsonPath });
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("already_exists")) throw err;
+      outputError("init_failed", err.message);
+    }
+  });
+  skills.command("pack [path]").description("Pack skill into a local .zip file").action(async (pathArg) => {
+    try {
+      const dir = resolveSkillDir(pathArg);
+      const manifest = await loadSkillManifest(dir);
+      const result = await packSkill(dir, manifest);
+      const outPath = join8(dir, result.filename);
+      await writeFile2(outPath, result.buffer);
+      slog.info(`Packed ${result.files.length} files \u2192 ${result.filename} (${result.size} bytes)`);
+      outputJson({
+        success: true,
+        filename: result.filename,
+        size: result.size,
+        files: result.files
+      });
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("success")) throw err;
+      outputError("pack_failed", err.message);
+    }
+  });
+  skills.command("publish [path]").description("Pack and publish skill to agents.hot").option("--name <name>", "Override skill name").option("--version <version>", "Override version").option("--private", "Publish as private skill").option("--stdin", "Read SKILL.md content from stdin").action(async (pathArg, opts) => {
+    try {
+      let content;
+      let manifest;
+      let packResult = null;
+      if (opts.stdin) {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+          chunks.push(chunk);
+        }
+        const raw = Buffer.concat(chunks).toString("utf-8");
+        const { frontmatter } = parseSkillMd(raw);
+        const name = opts.name || frontmatter.name;
+        if (!name) {
+          outputError("validation_error", "--name is required when using --stdin without frontmatter name");
+        }
+        manifest = {
+          name,
+          version: opts.version || frontmatter.version || "1.0.0",
+          description: frontmatter.description,
+          category: frontmatter.category,
+          tags: frontmatter.tags,
+          author: frontmatter.author,
+          private: opts.private ?? frontmatter.private
+        };
+        content = raw;
+      } else {
+        const dir = resolveSkillDir(pathArg);
+        manifest = await loadSkillManifest(dir);
+        if (opts.name) manifest.name = opts.name;
+        if (opts.version) manifest.version = opts.version;
+        if (opts.private !== void 0) manifest.private = opts.private;
+        content = await readFile4(join8(dir, manifest.main || "SKILL.md"), "utf-8");
+        packResult = await packSkill(dir, manifest);
+        slog.info(`Packed ${packResult.files.length} files (${packResult.size} bytes)`);
+      }
+      const formData = new FormData();
+      const metadata = {
+        name: manifest.name,
+        version: manifest.version,
+        description: manifest.description,
+        category: manifest.category,
+        tags: manifest.tags,
+        author: manifest.author,
+        source_url: manifest.source_url,
+        is_private: manifest.private
+      };
+      formData.append("metadata", JSON.stringify(metadata));
+      formData.append("content", content);
+      if (packResult) {
+        const blob = new Blob([packResult.buffer], { type: "application/zip" });
+        formData.append("package", blob, packResult.filename);
+      }
+      slog.info(`Publishing ${manifest.name}@${manifest.version}...`);
+      const client = createClient();
+      const result = await client.postFormData("/api/skills/publish", formData);
+      slog.success(`Skill ${result.action}: ${manifest.name}`);
+      outputJson({
+        success: true,
+        action: result.action,
+        skill: result.skill,
+        url: `https://agents.hot/skills/${result.skill.slug}`
+      });
+    } catch (err) {
+      if (err instanceof PlatformApiError) {
+        outputError(err.errorCode, err.message);
+      }
+      outputError("publish_failed", err.message);
+    }
+  });
+  skills.command("info <slug>").description("View skill details").option("--human", "Human-readable output").action(async (slug, opts) => {
+    try {
+      const client = createClient();
+      const data = await client.get(`/api/skills/${encodeURIComponent(slug)}`);
+      if (opts.human) {
+        console.log("");
+        console.log(`  ${BOLD}${data.name}${RESET} v${data.version || "?"}`);
+        if (data.description) console.log(`  ${data.description}`);
+        console.log(`  ${GRAY}slug${RESET}      ${data.slug}`);
+        console.log(`  ${GRAY}author${RESET}    ${data.author || "\u2014"}`);
+        console.log(`  ${GRAY}category${RESET}  ${data.category || "\u2014"}`);
+        console.log(`  ${GRAY}installs${RESET}  ${data.installs ?? 0}`);
+        console.log(`  ${GRAY}private${RESET}   ${data.is_private ? "yes" : "no"}`);
+        console.log("");
+        return;
+      }
+      outputJson(data);
+    } catch (err) {
+      if (err instanceof PlatformApiError) {
+        outputError(err.errorCode, err.message);
+      }
+      outputError("info_failed", err.message);
+    }
+  });
+  skills.command("list").alias("ls").description("List your published skills").option("--human", "Human-readable table output").action(async (opts) => {
+    try {
+      const client = createClient();
+      const data = await client.get("/api/user/skills");
+      if (opts.human) {
+        if (data.owned.length === 0 && data.authorized.length === 0) {
+          slog.info("No skills found. Create one with: agent-mesh skills init");
+          return;
+        }
+        if (data.owned.length > 0) {
+          slog.banner("My Skills");
+          const table = renderTable(
+            [
+              { key: "name", label: "NAME", width: 24 },
+              { key: "version", label: "VERSION", width: 12 },
+              { key: "installs", label: "INSTALLS", width: 12, align: "right" },
+              { key: "private", label: "PRIVATE", width: 10 }
+            ],
+            data.owned.map((s) => ({
+              name: s.name,
+              version: s.version || "\u2014",
+              installs: String(s.installs ?? 0),
+              private: s.is_private ? "yes" : `${GREEN}no${RESET}`
+            }))
+          );
+          console.log(table);
+        }
+        if (data.authorized.length > 0) {
+          slog.banner("Authorized Skills");
+          const table = renderTable(
+            [
+              { key: "name", label: "NAME", width: 24 },
+              { key: "author", label: "AUTHOR", width: 16 },
+              { key: "version", label: "VERSION", width: 12 }
+            ],
+            data.authorized.map((s) => ({
+              name: s.name,
+              author: s.author || "\u2014",
+              version: s.version || "\u2014"
+            }))
+          );
+          console.log(table);
+        }
+        return;
+      }
+      outputJson(data);
+    } catch (err) {
+      if (err instanceof PlatformApiError) {
+        outputError(err.errorCode, err.message);
+      }
+      outputError("list_failed", err.message);
+    }
+  });
+  skills.command("unpublish <slug>").description("Unpublish a skill").action(async (slug) => {
+    try {
+      const client = createClient();
+      const result = await client.del(`/api/skills/${encodeURIComponent(slug)}`);
+      slog.success(`Skill unpublished: ${slug}`);
+      outputJson(result);
+    } catch (err) {
+      if (err instanceof PlatformApiError) {
+        outputError(err.errorCode, err.message);
+      }
+      outputError("unpublish_failed", err.message);
+    }
+  });
+  skills.command("version <bump> [path]").description("Bump skill version (patch | minor | major | x.y.z)").action(async (bump, pathArg) => {
+    try {
+      const dir = resolveSkillDir(pathArg);
+      const skillJsonPath = join8(dir, "skill.json");
+      if (!await pathExists(skillJsonPath)) {
+        outputError("not_found", "No skill.json found. Run `agent-mesh skills init` first.");
+      }
+      const raw = await readFile4(skillJsonPath, "utf-8");
+      const data = JSON.parse(raw);
+      const oldVersion = data.version || "0.0.0";
+      const newVersion = bumpVersion(oldVersion, bump);
+      data.version = newVersion;
+      await writeFile2(skillJsonPath, JSON.stringify(data, null, 2) + "\n");
+      slog.success(`${oldVersion} \u2192 ${newVersion}`);
+      outputJson({ success: true, old: oldVersion, new: newVersion });
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("success")) throw err;
+      outputError("version_failed", err.message);
+    }
+  });
+}
+
+// src/commands/discover.ts
+var BASE_URL = "https://agents.hot";
+function formatStatus2(online) {
+  return online ? `${GREEN}\u25CF online${RESET}` : `${GRAY}\u25CB offline${RESET}`;
+}
+function formatCapabilities(caps) {
+  if (!caps || caps.length === 0) return `${GRAY}\u2014${RESET}`;
+  return caps.join(", ");
+}
+function registerDiscoverCommand(program2) {
+  program2.command("discover").description("Discover agents on the A2A network").option("--capability <cap>", "Filter by capability").option("--online", "Show only online agents").option("--limit <n>", "Max results (default 20)", "20").option("--offset <n>", "Pagination offset", "0").option("--json", "Output raw JSON").action(async (opts) => {
+    try {
+      const params = new URLSearchParams();
+      if (opts.capability) params.set("capability", opts.capability);
+      if (opts.online) params.set("online", "true");
+      params.set("limit", opts.limit);
+      params.set("offset", opts.offset);
+      const url = `${BASE_URL}/api/agents/discover?${params}`;
+      const res = await fetch(url);
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        console.error(`  Error: ${body.message ?? `HTTP ${res.status}`}`);
+        process.exit(1);
+      }
+      const data = await res.json();
+      if (opts.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+      }
+      if (data.agents.length === 0) {
+        console.log("  No agents found.");
+        return;
+      }
+      const table = renderTable(
+        [
+          { key: "name", label: "NAME", width: 24 },
+          { key: "type", label: "TYPE", width: 12 },
+          { key: "status", label: "STATUS", width: 14 },
+          { key: "capabilities", label: "CAPABILITIES", width: 30 }
+        ],
+        data.agents.map((a) => ({
+          name: a.name,
+          type: a.agent_type,
+          status: formatStatus2(a.is_online),
+          capabilities: formatCapabilities(a.capabilities)
+        }))
+      );
+      console.log(table);
+      console.log(`
+  ${GRAY}${data.agents.length} of ${data.total} agent(s)${RESET}`);
+    } catch (err) {
+      console.error(`  Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/call.ts
+import { readFileSync, writeFileSync as writeFileSync2 } from "fs";
+var DEFAULT_BASE_URL4 = "https://agents.hot";
+function handleError2(err) {
+  if (err instanceof PlatformApiError) {
+    log.error(err.message);
+  } else {
+    log.error(err.message);
+  }
+  process.exit(1);
+}
+function registerCallCommand(program2) {
+  program2.command("call <agent>").description("Call an agent on the A2A network").requiredOption("--task <description>", "Task description").option("--input-file <path>", "Read file and append to task description").option("--output-file <path>", "Save response text to file").option("--json", "Output JSONL events").option("--timeout <seconds>", "Timeout in seconds", "300").action(async (agentInput, opts) => {
+    try {
+      const token = loadToken();
+      if (!token) {
+        log.error("Not authenticated. Run `agent-mesh login` first.");
+        process.exit(1);
+      }
+      const client = createClient();
+      const { id, name } = await resolveAgentId(agentInput, client);
+      let taskDescription = opts.task;
+      if (opts.inputFile) {
+        const content = readFileSync(opts.inputFile, "utf-8");
+        taskDescription = `${taskDescription}
+
+---
+
+${content}`;
+      }
+      const timeoutMs = parseInt(opts.timeout || "300", 10) * 1e3;
+      const abortController = new AbortController();
+      const timer = setTimeout(() => abortController.abort(), timeoutMs);
+      const selfAgentId = process.env.AGENT_BRIDGE_AGENT_ID;
+      const res = await fetch(`${DEFAULT_BASE_URL4}/api/agents/${id}/call`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json",
+          Accept: "text/event-stream",
+          ...selfAgentId ? { "X-Caller-Agent-Id": selfAgentId } : {}
+        },
+        body: JSON.stringify({ task_description: taskDescription }),
+        signal: abortController.signal
+      });
+      clearTimeout(timer);
+      if (!res.ok) {
+        let msg = `HTTP ${res.status}`;
+        try {
+          const body = await res.json();
+          msg = body.message || body.error || msg;
+        } catch {
+        }
+        log.error(msg);
+        process.exit(1);
+      }
+      const contentType = res.headers.get("Content-Type") || "";
+      if (contentType.includes("application/json")) {
+        const result = await res.json();
+        if (opts.json) {
+          console.log(JSON.stringify(result));
+        } else {
+          console.log("");
+          log.success(`Call created for ${BOLD}${name}${RESET}`);
+          console.log(`  ${GRAY}Call ID${RESET}    ${result.call_id}`);
+          console.log(`  ${GRAY}Status${RESET}     ${result.status}`);
+          console.log(`  ${GRAY}Created${RESET}    ${result.created_at}`);
+          console.log("");
+        }
+        return;
+      }
+      if (!res.body) {
+        log.error("Empty response body");
+        process.exit(1);
+      }
+      if (!opts.json) {
+        log.info(`Calling ${BOLD}${name}${RESET}...`);
+        console.log("");
+      }
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let outputBuffer = "";
+      let inThinkingBlock = false;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = decoder.decode(value, { stream: true });
+        const parsed = parseSseChunk(chunk, buffer);
+        buffer = parsed.carry;
+        for (const data of parsed.events) {
+          if (data === "[DONE]") continue;
+          try {
+            const event = JSON.parse(data);
+            if (opts.json) {
+              console.log(JSON.stringify(event));
+            } else {
+              if (event.type === "chunk" && event.delta) {
+                process.stdout.write(event.delta);
+                if (!event.kind || event.kind === "text") {
+                  const delta = event.delta;
+                  if (delta.startsWith("{") && delta.includes('"type":')) {
+                    if (delta.includes('"type":"thinking"') && delta.includes("content_block_start")) {
+                      inThinkingBlock = true;
+                    } else if (delta.includes('"type":"text"') && delta.includes("content_block_start")) {
+                      inThinkingBlock = false;
+                    }
+                  } else if (!inThinkingBlock) {
+                    outputBuffer += delta;
+                  }
+                }
+              } else if (event.type === "done" && event.attachments?.length) {
+                console.log("");
+                for (const att of event.attachments) {
+                  log.info(`  ${GRAY}File:${RESET} ${att.name}  ${GRAY}${att.url}${RESET}`);
+                }
+              } else if (event.type === "error") {
+                process.stderr.write(`
+Error: ${event.message}
+`);
+              }
+            }
+          } catch {
+          }
+        }
+      }
+      if (buffer.trim()) {
+        const parsed = parseSseChunk("\n\n", buffer);
+        for (const data of parsed.events) {
+          if (data === "[DONE]") continue;
+          try {
+            const event = JSON.parse(data);
+            if (opts.json) {
+              console.log(JSON.stringify(event));
+            } else if (event.type === "chunk" && event.delta) {
+              process.stdout.write(event.delta);
+              if (!event.kind || event.kind === "text") {
+                const delta = event.delta;
+                if (!(delta.startsWith("{") && delta.includes('"type":')) && !inThinkingBlock) {
+                  outputBuffer += delta;
+                }
+              }
+            }
+          } catch {
+          }
+        }
+      }
+      if (opts.outputFile && outputBuffer) {
+        writeFileSync2(opts.outputFile, outputBuffer);
+        if (!opts.json) log.info(`Saved to ${opts.outputFile}`);
+      }
+      if (!opts.json) {
+        console.log("\n");
+        log.success("Call completed");
+      }
+    } catch (err) {
+      if (err.name === "AbortError") {
+        log.error("Call timed out");
+        process.exit(1);
+      }
+      handleError2(err);
+    }
+  });
+}
+
+// src/commands/config.ts
+function handleError3(err) {
+  if (err instanceof PlatformApiError) {
+    log.error(err.message);
+  } else {
+    log.error(err.message);
+  }
+  process.exit(1);
+}
+function registerConfigCommand(program2) {
+  program2.command("config <agent>").description("View or update agent A2A settings").option("--show", "Show current settings").option("--capabilities <list>", "Comma-separated capabilities").option("--max-calls-per-hour <n>", "Max calls per hour").option("--max-calls-per-user-per-day <n>", "Max calls per user per day").option("--allow-a2a <bool>", "Enable/disable A2A calls").action(async (agentInput, opts) => {
+    try {
+      const client = createClient();
+      const { id, name } = await resolveAgentId(agentInput, client);
+      const isUpdate = opts.capabilities !== void 0 || opts.maxCallsPerHour !== void 0 || opts.maxCallsPerUserPerDay !== void 0 || opts.allowA2a !== void 0;
+      if (opts.show || !isUpdate) {
+        const agent = await client.get(`/api/developer/agents/${id}`);
+        console.log("");
+        console.log(`  ${BOLD}${agent.name}${RESET} \u2014 A2A Settings`);
+        console.log("");
+        console.log(`  ${GRAY}Capabilities${RESET}          ${agent.capabilities?.length ? agent.capabilities.join(", ") : "(none)"}`);
+        console.log(`  ${GRAY}Max calls/hour${RESET}        ${agent.rate_limits?.max_calls_per_hour ?? 60}`);
+        console.log(`  ${GRAY}Max calls/user/day${RESET}    ${agent.rate_limits?.max_calls_per_user_per_day ?? 20}`);
+        console.log(`  ${GRAY}A2A enabled${RESET}           ${agent.rate_limits?.allow_a2a !== false ? "yes" : "no"}`);
+        console.log("");
+        return;
+      }
+      const updates = {};
+      if (opts.capabilities !== void 0) {
+        updates.capabilities = opts.capabilities.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+      }
+      const rateLimits = {};
+      if (opts.maxCallsPerHour !== void 0) {
+        rateLimits.max_calls_per_hour = parseInt(opts.maxCallsPerHour, 10);
+      }
+      if (opts.maxCallsPerUserPerDay !== void 0) {
+        rateLimits.max_calls_per_user_per_day = parseInt(opts.maxCallsPerUserPerDay, 10);
+      }
+      if (opts.allowA2a !== void 0) {
+        rateLimits.allow_a2a = opts.allowA2a === "true";
+      }
+      if (Object.keys(rateLimits).length > 0) {
+        updates.rate_limits = rateLimits;
+      }
+      await client.patch(`/api/agents/${id}/settings`, updates);
+      log.success(`Settings updated for ${BOLD}${name}${RESET}`);
+    } catch (err) {
+      handleError3(err);
+    }
+  });
+}
+
+// src/commands/stats.ts
+function handleError4(err) {
+  if (err instanceof PlatformApiError) {
+    log.error(err.message);
+  } else {
+    log.error(err.message);
+  }
+  process.exit(1);
+}
+function renderBarChart(data) {
+  if (data.length === 0) return `  ${GRAY}No data${RESET}`;
+  const max = Math.max(...data.map((d) => d.count), 1);
+  const barWidth = 20;
+  const lines = [];
+  for (const entry of data) {
+    const filled = Math.round(entry.count / max * barWidth);
+    const bar = "\u2588".repeat(filled) + "\u2591".repeat(barWidth - filled);
+    const dateLabel = entry.date.slice(5);
+    lines.push(`  ${GRAY}${dateLabel}${RESET} ${bar} ${entry.count}`);
+  }
+  return lines.join("\n");
+}
+function registerStatsCommand(program2) {
+  program2.command("stats").description("View agent call statistics").option("--agent <id-or-name>", "Specific agent").option("--period <period>", "Period: day, week, month", "week").option("--json", "Output raw JSON").action(async (opts) => {
+    try {
+      const client = createClient();
+      if (opts.agent) {
+        const { id, name } = await resolveAgentId(opts.agent, client);
+        const stats = await client.get(
+          `/api/agents/${id}/stats?period=${opts.period}`
+        );
+        if (opts.json) {
+          console.log(JSON.stringify(stats, null, 2));
+          return;
+        }
+        printAgentStats(name, stats);
+      } else {
+        const data = await client.get("/api/developer/agents");
+        if (data.agents.length === 0) {
+          log.info("No agents found.");
+          return;
+        }
+        const allStats = [];
+        for (const agent of data.agents) {
+          try {
+            const stats = await client.get(
+              `/api/agents/${agent.id}/stats?period=${opts.period}`
+            );
+            allStats.push({ name: agent.name, stats });
+          } catch {
+          }
+        }
+        if (opts.json) {
+          console.log(JSON.stringify(allStats, null, 2));
+          return;
+        }
+        if (allStats.length === 0) {
+          log.info("No stats available.");
+          return;
+        }
+        const table = renderTable(
+          [
+            { key: "name", label: "AGENT", width: 24 },
+            { key: "total", label: "TOTAL", width: 10 },
+            { key: "completed", label: "DONE", width: 10 },
+            { key: "failed", label: "FAILED", width: 10 },
+            { key: "avgMs", label: "AVG MS", width: 10 }
+          ],
+          allStats.map((s) => ({
+            name: s.name,
+            total: String(s.stats.total_calls),
+            completed: String(s.stats.completed),
+            failed: String(s.stats.failed),
+            avgMs: String(Math.round(s.stats.avg_duration_ms))
+          }))
+        );
+        console.log("");
+        console.log(table);
+        console.log("");
+      }
+    } catch (err) {
+      handleError4(err);
+    }
+  });
+}
+function printAgentStats(name, stats) {
+  console.log("");
+  console.log(`  ${BOLD}${name}${RESET} \u2014 Call Statistics`);
+  console.log("");
+  console.log(`  ${GRAY}Total Calls${RESET}        ${stats.total_calls}`);
+  console.log(`  ${GRAY}Completed${RESET}          ${GREEN}${stats.completed}${RESET}`);
+  console.log(`  ${GRAY}Failed${RESET}             ${stats.failed}`);
+  console.log(`  ${GRAY}Avg Duration${RESET}       ${Math.round(stats.avg_duration_ms)}ms`);
+  console.log("");
+  if (stats.calls_by_day.length > 0) {
+    console.log(`  ${BOLD}Calls by Day${RESET}`);
+    console.log(renderBarChart(stats.calls_by_day));
+  }
+  console.log("");
+}
+
+// src/index.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+program.name("agent-mesh").description("Connect local AI agents to the Agents.Hot platform").version(version).option("-v", "output the version number").on("option:v", () => {
+  console.log(version);
+  process.exit(0);
+});
+registerConnectCommand(program);
+registerLoginCommand(program);
+registerStatusCommand(program);
+registerListCommand(program);
+registerStartCommand(program);
+registerStopCommand(program);
+registerRestartCommand(program);
+registerLogsCommand(program);
+registerRemoveCommand(program);
+registerOpenCommand(program);
+registerInstallCommand(program);
+registerUninstallCommand(program);
+registerAgentsCommand(program);
+registerChatCommand(program);
+registerSkillsCommand(program);
+registerDiscoverCommand(program);
+registerCallCommand(program);
+registerConfigCommand(program);
+registerStatsCommand(program);
+program.parse();