@boxcrew/cli 0.1.5 → 0.1.7

package/dist/index.js

@@ -359,9 +359,36 @@ function registerApiCommand(program2) {
 // src/commands/connect.ts
 import { spawn } from "child_process";
 import { createInterface as createInterface3 } from "readline";
+import { openSync, mkdirSync, existsSync, writeFileSync, readFileSync, unlinkSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
 import WebSocket from "ws";
 var RECONNECT_BASE_MS = 1e3;
 var RECONNECT_MAX_MS = 3e4;
+function getStateDir() {
+  const dir = join(homedir(), ".boxcrew");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function getPidFile(agentName) {
+  return join(getStateDir(), `${agentName}.pid`);
+}
+function getLogFile(agentName) {
+  return join(getStateDir(), `${agentName}.log`);
+}
+function readPid(agentName) {
+  const pidFile = getPidFile(agentName);
+  if (!existsSync(pidFile)) return null;
+  const pid = parseInt(readFileSync(pidFile, "utf-8").trim(), 10);
+  if (isNaN(pid)) return null;
+  try {
+    process.kill(pid, 0);
+    return pid;
+  } catch {
+    unlinkSync(pidFile);
+    return null;
+  }
+}
 function parseStreamJsonLine(line) {
   let obj;
   try {
@@ -424,35 +451,118 @@ function parseStreamJsonLine(line) {
   }
   return null;
 }
-function registerConnectCommand(program2) {
-  program2.command("connect <agent-name>").description("Connect a local Claude Code instance to a BoxCrew agent.").option("--claude-path <path>", "Path to claude CLI binary", "claude").action(async (agentName, options) => {
-    const config2 = await apiFetchJson(
-      `/agents/${encodeURIComponent(agentName)}/connection-config`
-    );
-    const wsUrl = config2.websocket_url;
-    const claudePath = options.claudePath;
-    let activeProcess = null;
-    let sendToServer = null;
-    let reconnectAttempt = 0;
-    let shouldReconnect = true;
-    const handleChat = (msg) => {
-      if (activeProcess) {
-        activeProcess.kill("SIGTERM");
-        activeProcess = null;
+function parseOpenCodeLine(line) {
+  let event;
+  try {
+    event = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (event.type === "text" && event.part?.type === "text" && event.part.text) {
+    return { kind: "text", text: event.part.text };
+  }
+  if (event.type) {
+    return { kind: "raw", raw: event, rawType: event.type };
+  }
+  return null;
+}
+function parseOpenClawOutput(stdout) {
+  try {
+    const firstBrace = stdout.indexOf("{");
+    if (firstBrace === -1) {
+      return [{ kind: "text", text: stdout.trim() || "No response" }];
+    }
+    const response = JSON.parse(stdout.slice(firstBrace));
+    const events = [];
+    events.push({ kind: "raw", raw: response, rawType: "openclaw_response" });
+    const sessionId = response.meta?.agentMeta?.sessionId;
+    if (sessionId) {
+      events.push({ kind: "session_id", sessionId });
+    }
+    const payloads = response.payloads;
+    if (Array.isArray(payloads)) {
+      const texts = payloads.map((p) => p.text).filter((t) => typeof t === "string" && t.length > 0);
+      if (texts.length > 0) {
+        events.push({ kind: "text", text: texts.join("\n\n") });
+      } else {
+        events.push({ kind: "text", text: "No response" });
       }
-      const { messageId, message, sessionId } = msg;
-      const args = ["-p", message, "--output-format", "stream-json", "--verbose"];
+    } else {
+      events.push({ kind: "text", text: "No response" });
+    }
+    return events;
+  } catch {
+    return [{ kind: "text", text: stdout.trim() || "No response" }];
+  }
+}
+function runDaemon(agentName) {
+  const wsUrl = process.env._BX_WS_URL;
+  const claudePath = process.env._BX_CLAUDE_PATH || "claude";
+  const agentDisplayName = process.env._BX_AGENT_NAME || agentName;
+  const runtime = process.env._BX_RUNTIME || "claude-code";
+  if (!wsUrl) {
+    console.error("Missing _BX_WS_URL");
+    process.exit(1);
+  }
+  writeFileSync(getPidFile(agentName), String(process.pid));
+  let activeProcess = null;
+  let sendToServer = null;
+  let reconnectAttempt = 0;
+  let shouldReconnect = true;
+  const handleChat = (msg) => {
+    if (activeProcess) {
+      activeProcess.kill("SIGTERM");
+      activeProcess = null;
+    }
+    const { messageId, message, sessionId } = msg;
+    const childEnv = { ...process.env };
+    delete childEnv.CLAUDECODE;
+    let cmd;
+    let args;
+    if (runtime === "opencode") {
+      cmd = "opencode";
+      args = ["run", "--format", "json"];
+    } else if (runtime === "openclaw") {
+      cmd = "openclaw";
+      args = ["agent", "--message", message, "--json", "--agent", "main", "--timeout", "300"];
+    } else {
+      cmd = claudePath;
+      args = ["-p", message, "--output-format", "stream-json", "--verbose"];
       if (sessionId) args.push("--resume", sessionId);
-      const childEnv = { ...process.env };
-      delete childEnv.CLAUDECODE;
-      const child = spawn(claudePath, args, {
-        stdio: ["ignore", "pipe", "pipe"],
-        env: childEnv
+    }
+    const child = spawn(cmd, args, {
+      stdio: [runtime === "opencode" ? "pipe" : "ignore", "pipe", "pipe"],
+      env: childEnv
+    });
+    activeProcess = child;
+    if (runtime === "opencode" && child.stdin) {
+      child.stdin.write(message);
+      child.stdin.end();
+    }
+    if (runtime === "openclaw") {
+      let stdout = "";
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk.toString();
       });
-      activeProcess = child;
+      child.on("exit", (code) => {
+        if (activeProcess === child) activeProcess = null;
+        if (sendToServer) {
+          const events = parseOpenClawOutput(stdout);
+          for (const event of events) {
+            sendToServer({ type: "event", messageId, event });
+          }
+          sendToServer({ type: "event", messageId, event: { kind: "done" } });
+        }
+        if (code && code !== 0) {
+          console.error(`OpenClaw exited with code ${code}`);
+          sendToServer?.({ type: "error", messageId, error: `OpenClaw exited with code ${code}` });
+        }
+      });
+    } else {
+      const parseLine = runtime === "opencode" ? parseOpenCodeLine : parseStreamJsonLine;
       const rl = createInterface3({ input: child.stdout });
       rl.on("line", (line) => {
-        const event = parseStreamJsonLine(line);
+        const event = parseLine(line);
         if (event && sendToServer) {
           sendToServer({ type: "event", messageId, event });
         }
@@ -463,77 +573,146 @@ function registerConnectCommand(program2) {
           sendToServer({ type: "event", messageId, event: { kind: "done" } });
         }
         if (code && code !== 0) {
-          console.error(`Claude Code exited with code ${code}`);
-          sendToServer?.({ type: "error", messageId, error: `Claude Code exited with code ${code}` });
+          console.error(`${runtime} exited with code ${code}`);
+          sendToServer?.({ type: "error", messageId, error: `${runtime} exited with code ${code}` });
         }
       });
-      child.on("error", (err) => {
-        console.error(`Failed to spawn Claude Code: ${err.message}`);
-        sendToServer?.({ type: "error", messageId, error: `Failed to spawn: ${err.message}` });
-      });
+    }
+    child.on("error", (err) => {
+      console.error(`Failed to spawn ${runtime}: ${err.message}`);
+      sendToServer?.({ type: "error", messageId, error: `Failed to spawn: ${err.message}` });
+    });
+  };
+  const cleanup = () => {
+    try {
+      unlinkSync(getPidFile(agentName));
+    } catch {
+    }
+  };
+  const connect = () => {
+    const ws = new WebSocket(wsUrl);
+    const send = (msg) => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify(msg));
+      }
     };
-    const connect = () => {
-      const ws = new WebSocket(wsUrl);
-      const send = (msg) => {
-        if (ws.readyState === WebSocket.OPEN) {
-          ws.send(JSON.stringify(msg));
-        }
-      };
-      ws.on("open", () => {
-        reconnectAttempt = 0;
-        sendToServer = send;
-        console.log(`Agent "${config2.agent_name}" is online. Press Ctrl+C to disconnect.`);
-      });
-      ws.on("message", (data) => {
-        let msg;
-        try {
-          msg = JSON.parse(data.toString());
-        } catch {
-          return;
-        }
-        if (msg.type === "ping") {
-          send({ type: "pong" });
-          return;
-        }
-        if (msg.type === "stop" && activeProcess) {
-          activeProcess.kill("SIGINT");
-          return;
-        }
-        if (msg.type === "chat") {
-          handleChat(msg);
-        }
-      });
-      ws.on("close", () => {
-        sendToServer = null;
-        if (activeProcess) {
-          activeProcess.kill("SIGTERM");
-          activeProcess = null;
-        }
-        if (shouldReconnect) {
-          const delay = Math.min(
-            RECONNECT_BASE_MS * Math.pow(2, reconnectAttempt),
-            RECONNECT_MAX_MS
-          );
-          reconnectAttempt++;
-          console.log(`Disconnected. Reconnecting in ${delay / 1e3}s...`);
-          setTimeout(connect, delay);
-        }
-      });
-      ws.on("error", (err) => {
-        console.error("Connection error:", err.message);
-      });
-      const shutdown = () => {
-        shouldReconnect = false;
-        if (activeProcess) activeProcess.kill("SIGTERM");
-        ws.close();
-        process.exit(0);
-      };
-      process.removeAllListeners("SIGINT");
-      process.removeAllListeners("SIGTERM");
-      process.on("SIGINT", shutdown);
-      process.on("SIGTERM", shutdown);
+    ws.on("open", () => {
+      reconnectAttempt = 0;
+      sendToServer = send;
+      console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Connected`);
+    });
+    ws.on("message", (data) => {
+      let msg;
+      try {
+        msg = JSON.parse(data.toString());
+      } catch {
+        return;
+      }
+      if (msg.type === "ping") {
+        send({ type: "pong" });
+        return;
+      }
+      if (msg.type === "stop" && activeProcess) {
+        activeProcess.kill("SIGINT");
+        return;
+      }
+      if (msg.type === "chat") {
+        handleChat(msg);
+      }
+    });
+    ws.on("close", () => {
+      sendToServer = null;
+      if (activeProcess) {
+        activeProcess.kill("SIGTERM");
+        activeProcess = null;
+      }
+      if (shouldReconnect) {
+        const delay = Math.min(
+          RECONNECT_BASE_MS * Math.pow(2, reconnectAttempt),
+          RECONNECT_MAX_MS
+        );
+        reconnectAttempt++;
+        console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Disconnected. Reconnecting in ${delay / 1e3}s...`);
+        setTimeout(connect, delay);
+      }
+    });
+    ws.on("error", (err) => {
+      console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] Error: ${err.message}`);
+    });
+    const shutdown = () => {
+      shouldReconnect = false;
+      if (activeProcess) activeProcess.kill("SIGTERM");
+      ws.close();
+      cleanup();
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  };
+  connect();
+}
+function registerConnectCommand(program2) {
+  program2.command("_daemon <agent-name>", { hidden: true }).action((agentName) => {
+    runDaemon(agentName);
+  });
+  program2.command("connect <agent-name>").description("Connect a local agent to BoxCrew.").option("--claude-path <path>", "Path to claude CLI binary", "claude").action(async (agentName, options) => {
+    const existingPid = readPid(agentName);
+    if (existingPid) {
+      console.log(`Agent "${agentName}" is already connected (PID ${existingPid}).`);
+      return;
+    }
+    const config2 = await apiFetchJson(
+      `/agents/${encodeURIComponent(agentName)}/connection-config`
+    );
+    const logFile = getLogFile(agentName);
+    const logFd = openSync(logFile, "a");
+    const child = spawn(process.argv[0], [process.argv[1], "_daemon", agentName], {
+      detached: true,
+      stdio: ["ignore", logFd, logFd],
+      env: {
+        ...process.env,
+        _BX_WS_URL: config2.websocket_url,
+        _BX_CLAUDE_PATH: options.claudePath,
+        _BX_AGENT_NAME: config2.agent_name,
+        _BX_RUNTIME: config2.runtime
+      }
+    });
+    child.unref();
+    const runtimeNames = {
+      "claude-code": "Claude Code",
+      "opencode": "OpenCode",
+      "openclaw": "OpenClaw"
     };
-    connect();
+    const runtimeDisplay = runtimeNames[config2.runtime] || config2.runtime;
+    const cwd = process.cwd();
+    const home = homedir();
+    const shortLog = logFile.startsWith(home) ? "~" + logFile.slice(home.length) : logFile;
+    console.log("");
+    console.log(`  Agent "${config2.agent_name}" is online.`);
+    console.log("");
+    console.log(`  Runtime:   ${runtimeDisplay}`);
+    console.log(`  Directory: ${cwd}`);
+    console.log(`  Logs:      ${shortLog}`);
+    console.log("");
+    console.log(`  To disconnect: npx @boxcrew/cli disconnect ${agentName}`);
+    console.log("");
+  });
+  program2.command("disconnect <agent-name>").description("Disconnect a local agent.").action((agentName) => {
+    const pid = readPid(agentName);
+    if (!pid) {
+      console.log(`Agent "${agentName}" is not connected.`);
+      return;
+    }
+    try {
+      process.kill(pid, "SIGTERM");
+      try {
+        unlinkSync(getPidFile(agentName));
+      } catch {
+      }
+      console.log(`Agent "${agentName}" disconnected.`);
+    } catch {
+      console.error(`Failed to stop process ${pid}.`);
+    }
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boxcrew/cli",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "BoxCrew CLI — manage your agents from the terminal",
   "type": "module",
   "bin": {