@boxcrew/cli 0.1.4 → 0.1.6

package/dist/index.js

@@ -4,8 +4,8 @@
 import { Command } from "commander";
 
 // src/commands/login.ts
-import { createInterface } from "readline";
-import open from "open";
+import { createInterface as createInterface2 } from "readline";
+import open2 from "open";
 
 // src/config.ts
 import Conf from "conf";
@@ -17,44 +17,19 @@ var config = new Conf({
 });
 
 // src/auth.ts
+import { createInterface } from "readline";
+import open from "open";
+var DEFAULT_FRONTEND_URL = "https://boxcrew.ai";
 function getAuthToken() {
   if (process.env.BOXCREW_API_KEY) return process.env.BOXCREW_API_KEY;
   return config.get("apiKey") ?? null;
 }
-function requireAuth() {
+async function requireAuth() {
   const token = getAuthToken();
-  if (!token) {
-    console.error(
-      "Not authenticated. Run `bx login` or set the BOXCREW_API_KEY environment variable."
-    );
-    process.exit(1);
-  }
-  return token;
-}
-
-// src/commands/login.ts
-var DEFAULT_FRONTEND_URL = "https://boxcrew.ai";
-function registerLoginCommand(program2) {
-  program2.command("login").description("Authenticate with BoxCrew").option("--api-url <url>", "BoxCrew API URL").option(
-    "--frontend-url <url>",
-    "BoxCrew frontend URL",
-    process.env.BOXCREW_FRONTEND_URL || DEFAULT_FRONTEND_URL
-  ).action(
-    async (options) => {
-      if (options.apiUrl) {
-        config.set("apiUrl", options.apiUrl);
-      }
-      await ensureLoggedIn(options.frontendUrl);
-    }
-  );
-}
-async function ensureLoggedIn(frontendUrl = DEFAULT_FRONTEND_URL) {
-  if (getAuthToken()) {
-    console.log("Already authenticated.");
-    return;
-  }
+  if (token) return token;
+  const frontendUrl = process.env.BOXCREW_FRONTEND_URL || DEFAULT_FRONTEND_URL;
   const authUrl = `${frontendUrl}/cli-auth`;
-  console.log("Opening browser to authenticate...");
+  console.log("Not authenticated. Opening browser to log in...");
   console.log(`If the browser doesn't open, visit: ${authUrl}
 `);
   open(authUrl).catch(() => {
@@ -75,6 +50,49 @@ async function ensureLoggedIn(frontendUrl = DEFAULT_FRONTEND_URL) {
   }
   config.set("apiKey", apiKey);
   console.log("Authenticated successfully!\n");
+  return apiKey;
+}
+
+// src/commands/login.ts
+var DEFAULT_FRONTEND_URL2 = "https://boxcrew.ai";
+function registerLoginCommand(program2) {
+  program2.command("login").description("Authenticate with BoxCrew (or re-authenticate)").option("--api-url <url>", "BoxCrew API URL").option(
+    "--frontend-url <url>",
+    "BoxCrew frontend URL",
+    process.env.BOXCREW_FRONTEND_URL || DEFAULT_FRONTEND_URL2
+  ).action(
+    async (options) => {
+      if (options.apiUrl) {
+        config.set("apiUrl", options.apiUrl);
+      }
+      if (getAuthToken()) {
+        console.log("Already authenticated. To re-authenticate, continue below.\n");
+      }
+      const authUrl = `${options.frontendUrl}/cli-auth`;
+      console.log("Opening browser to authenticate...");
+      console.log(`If the browser doesn't open, visit: ${authUrl}
+`);
+      open2(authUrl).catch(() => {
+      });
+      const rl = createInterface2({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const apiKey = await new Promise((resolve) => {
+        rl.question("Paste your API key: ", (answer) => {
+          rl.close();
+          resolve(answer.trim());
+        });
+      });
+      if (!apiKey.startsWith("bxk_")) {
+        console.error('Invalid API key. Keys should start with "bxk_".');
+        process.exit(1);
+      }
+      config.set("apiKey", apiKey);
+      console.log("\nAuthenticated successfully!");
+      console.log(`API URL: ${config.get("apiUrl")}`);
+    }
+  );
 }
 
 // src/commands/logout.ts
@@ -90,7 +108,7 @@ function getBaseUrl() {
   return process.env.BOXCREW_API_URL || config.get("apiUrl");
 }
 async function apiFetch(path, options = {}) {
-  const token = requireAuth();
+  const token = await requireAuth();
   const baseUrl = getBaseUrl();
   const url = `${baseUrl}${path}`;
   const headers = {
@@ -340,10 +358,37 @@ function registerApiCommand(program2) {
 
 // src/commands/connect.ts
 import { spawn } from "child_process";
-import { createInterface as createInterface2 } from "readline";
+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 {
@@ -406,123 +451,169 @@ 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").option(
-    "--frontend-url <url>",
-    "BoxCrew frontend URL",
-    process.env.BOXCREW_FRONTEND_URL || "https://boxcrew.ai"
-  ).action(async (agentName, options) => {
-    if (!getAuthToken()) {
-      await ensureLoggedIn(options.frontendUrl);
+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;
+  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 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) => {
+    const { messageId, message, sessionId } = msg;
+    const 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
+    });
+    activeProcess = child;
+    const rl = createInterface3({ input: child.stdout });
+    rl.on("line", (line) => {
+      const event = parseStreamJsonLine(line);
+      if (event && sendToServer) {
+        sendToServer({ type: "event", messageId, event });
+      }
+    });
+    child.on("exit", (code) => {
+      if (activeProcess === child) activeProcess = null;
+      if (sendToServer) {
+        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}` });
+      }
+    });
+    child.on("error", (err) => {
+      console.error(`Failed to spawn Claude Code: ${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));
+      }
+    };
+    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;
       }
-      const { messageId, message, sessionId } = msg;
-      const 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
-      });
-      activeProcess = child;
-      const rl = createInterface2({ input: child.stdout });
-      rl.on("line", (line) => {
-        const event = parseStreamJsonLine(line);
-        if (event && sendToServer) {
-          sendToServer({ type: "event", messageId, event });
-        }
-      });
-      child.on("exit", (code) => {
-        if (activeProcess === child) activeProcess = null;
-        if (sendToServer) {
-          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}` });
-        }
-      });
-      child.on("error", (err) => {
-        console.error(`Failed to spawn Claude Code: ${err.message}`);
-        sendToServer?.({ type: "error", messageId, error: `Failed to spawn: ${err.message}` });
-      });
-    };
-    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);
+      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);
     };
-    connect();
+    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 Claude Code instance to a BoxCrew agent.").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
+      }
+    });
+    child.unref();
+    console.log(`Agent "${config2.agent_name}" is online.`);
+    console.log(`Logs: ${logFile}`);
+  });
+  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.4",
+  "version": "0.1.6",
   "description": "BoxCrew CLI — manage your agents from the terminal",
   "type": "module",
   "bin": {