npm - @boxcrew/cli - Versions diffs - 0.1.0 - Mend

@boxcrew/cli 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/index.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ #!/usr/bin/env node

package/dist/index.js ADDED Viewed

@@ -0,0 +1,605 @@
+#!/usr/bin/env node
+// src/index.ts
+import { Command } from "commander";
+// src/commands/login.ts
+import { createInterface } from "readline";
+import { createServer } from "http";
+import open from "open";
+// src/config.ts
+import Conf from "conf";
+var config = new Conf({
+  projectName: "boxcrew",
+  defaults: {
+    apiUrl: "https://api.boxcrew.ai"
+  }
+});
+// src/commands/login.ts
+var DEFAULT_FRONTEND_URL = "https://boxcrew.ai";
+var LOGIN_TIMEOUT_MS = 5 * 60 * 1e3;
+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
+  ).option("--paste", "Use paste-based login (for headless environments)").action(
+    async (options) => {
+      if (options.apiUrl) {
+        config.set("apiUrl", options.apiUrl);
+      }
+      if (options.paste) {
+        await pasteLogin();
+      } else {
+        await browserLogin(options.frontendUrl);
+      }
+    }
+  );
+}
+async function pasteLogin() {
+  console.log(
+    "Create an API key in the BoxCrew dashboard (Settings > API Keys),"
+  );
+  console.log("then paste it below.\n");
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const apiKey = await new Promise((resolve) => {
+    rl.question("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! Credentials stored.");
+  console.log(`API URL: ${config.get("apiUrl")}`);
+}
+async function browserLogin(frontendUrl) {
+  return new Promise((resolve, reject) => {
+    const server = createServer((req, res) => {
+      const url = new URL(req.url || "/", `http://localhost`);
+      if (url.pathname === "/callback") {
+        const key = url.searchParams.get("key");
+        if (key && key.startsWith("bxk_")) {
+          config.set("apiKey", key);
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+            <!DOCTYPE html>
+            <html>
+              <head><title>BoxCrew CLI</title></head>
+              <body style="font-family: system-ui, sans-serif; display: flex; justify-content: center; align-items: center; min-height: 100vh; margin: 0; background: #0a0a0a; color: #fafafa;">
+                <div style="text-align: center;">
+                  <h2>Authenticated!</h2>
+                  <p>You can close this tab and return to your terminal.</p>
+                </div>
+              </body>
+            </html>
+          `);
+          console.log("\nAuthenticated successfully! Credentials stored.");
+          console.log(`API URL: ${config.get("apiUrl")}`);
+          server.close();
+          clearTimeout(timeout);
+          resolve();
+        } else {
+          res.writeHead(400, { "Content-Type": "text/plain" });
+          res.end("Invalid key");
+        }
+      } else {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not found");
+      }
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("Failed to start local server"));
+        return;
+      }
+      const port = addr.port;
+      const authUrl = `${frontendUrl}/cli-auth?port=${port}`;
+      console.log("Opening browser to authenticate...");
+      console.log(`If the browser doesn't open, visit: ${authUrl}
+`);
+      console.log("Waiting for authentication...");
+      open(authUrl).catch(() => {
+      });
+    });
+    const timeout = setTimeout(() => {
+      console.error(
+        '\nLogin timed out. Use "bx login --paste" to authenticate manually.'
+      );
+      server.close();
+      process.exit(1);
+    }, LOGIN_TIMEOUT_MS);
+  });
+}
+// src/commands/logout.ts
+function registerLogoutCommand(program2) {
+  program2.command("logout").description("Remove stored credentials").action(() => {
+    config.delete("apiKey");
+    console.log("Credentials removed.");
+  });
+}
+// src/auth.ts
+function getAuthToken() {
+  if (process.env.BOXCREW_API_KEY) return process.env.BOXCREW_API_KEY;
+  return config.get("apiKey") ?? null;
+}
+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/client.ts
+function getBaseUrl() {
+  return process.env.BOXCREW_API_URL || config.get("apiUrl");
+}
+async function apiFetch(path, options = {}) {
+  const token = requireAuth();
+  const baseUrl = getBaseUrl();
+  const url = `${baseUrl}${path}`;
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    ...options.headers ?? {}
+  };
+  if (options.body && typeof options.body === "string" && !headers["Content-Type"]) {
+    headers["Content-Type"] = "application/json";
+  }
+  const response = await fetch(url, {
+    ...options,
+    headers
+  });
+  return response;
+}
+async function apiFetchJson(path, options = {}) {
+  const response = await apiFetch(path, options);
+  if (!response.ok) {
+    const text = await response.text();
+    let message;
+    try {
+      const json = JSON.parse(text);
+      message = json.message || json.error || text;
+    } catch {
+      message = text;
+    }
+    console.error(`API error (${response.status}): ${message}`);
+    process.exit(1);
+  }
+  return response.json();
+}
+// src/commands/agents.ts
+var TRANSIENT_CODES = [
+  "ETIMEDOUT",
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "UND_ERR_CONNECT_TIMEOUT"
+];
+function isTransientError(err) {
+  if (!(err instanceof Error)) return false;
+  const code = err.code;
+  if (code && TRANSIENT_CODES.includes(code)) return true;
+  if (err instanceof TypeError && /terminated|network/i.test(err.message))
+    return true;
+  return false;
+}
+function registerAgentsCommands(program2) {
+  const agents = program2.command("agents").description("Manage agents");
+  agents.command("list").description("List all agents").action(async () => {
+    const data = await apiFetchJson("/agents");
+    if (data.length === 0) {
+      console.log("No agents found.");
+      return;
+    }
+    console.log("");
+    for (const agent of data) {
+      const model = agent.model ? ` (${agent.model})` : "";
+      console.log(`  ${agent.name}  ${agent.runtime}${model}`);
+    }
+    console.log("");
+  });
+  agents.command("create <name>").description("Create a new agent").option("-r, --runtime <runtime>", "Agent runtime", "claude-code").option("-m, --model <model>", "Model override").option("-i, --instructions <text>", "Agent instructions").action(
+    async (name, options) => {
+      const body = {
+        name,
+        runtime: options.runtime
+      };
+      if (options.model) body.model = options.model;
+      if (options.instructions) body.instructions = options.instructions;
+      const agent = await apiFetchJson("/agents", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      console.log(`Agent "${agent.name}" created (${agent.runtime}).`);
+    }
+  );
+  agents.command("delete <name>").description("Delete an agent").action(async (name) => {
+    const allAgents = await apiFetchJson("/agents");
+    const agent = allAgents.find((a) => a.name === name);
+    if (!agent) {
+      console.error(`Agent "${name}" not found.`);
+      process.exit(1);
+    }
+    const response = await apiFetch(`/agents/${agent.id}`, {
+      method: "DELETE"
+    });
+    if (!response.ok) {
+      console.error(`Failed to delete agent: ${response.statusText}`);
+      process.exit(1);
+    }
+    console.log(`Agent "${name}" deleted.`);
+  });
+  agents.command("chat <name> <message>").description("Send a message to an agent (streaming)").action(async (name, message) => {
+    const MAX_RETRIES = 1;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        const response = await apiFetch(`/agents/${name}/chat`, {
+          method: "POST",
+          body: JSON.stringify({ message })
+        });
+        if (!response.ok) {
+          const text = await response.text();
+          console.error(`Chat error (${response.status}): ${text}`);
+          process.exit(1);
+        }
+        if (!response.body) {
+          console.error("No response body");
+          process.exit(1);
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let receivedText = false;
+        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) {
+            if (!line.startsWith("data: ")) continue;
+            const jsonStr = line.slice(6);
+            if (!jsonStr || jsonStr === "[DONE]") continue;
+            try {
+              const event = JSON.parse(jsonStr);
+              if (event.type === "response.output_text.delta" && event.delta) {
+                receivedText = true;
+                process.stdout.write(event.delta);
+              } else if (event.type === "response.completed") {
+                process.stdout.write("\n");
+              }
+            } catch {
+            }
+          }
+        }
+        if (!receivedText) {
+          console.error("No response from agent. Try again.");
+          process.exit(1);
+        }
+        break;
+      } catch (err) {
+        if (attempt < MAX_RETRIES && isTransientError(err)) {
+          console.error("\nConnection lost. Retrying...");
+          continue;
+        }
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`
+Connection error: ${msg}`);
+        process.exit(1);
+      }
+    }
+  });
+}
+// src/commands/keys.ts
+function registerKeysCommands(program2) {
+  const keys = program2.command("keys").description("Manage API keys");
+  keys.command("list").description("List all API keys").action(async () => {
+    const data = await apiFetchJson("/api-keys");
+    if (data.length === 0) {
+      console.log("No API keys found.");
+      return;
+    }
+    console.log("");
+    for (const key of data) {
+      const lastUsed = key.lastUsedAt ? `last used ${new Date(key.lastUsedAt).toLocaleDateString()}` : "never used";
+      const expires = key.expiresAt ? `expires ${new Date(key.expiresAt).toLocaleDateString()}` : "no expiry";
+      console.log(
+        `  ${key.keyPrefix}...  ${key.name}  (${lastUsed}, ${expires})`
+      );
+      console.log(`  ID: ${key.id}`);
+      console.log("");
+    }
+  });
+  keys.command("create").description("Create a new API key").requiredOption("-n, --name <name>", "Key name").option("-e, --expires <date>", "Expiration date (ISO 8601)").action(async (options) => {
+    const body = { name: options.name };
+    if (options.expires) body.expiresAt = options.expires;
+    const data = await apiFetchJson("/api-keys", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    console.log("");
+    console.log("API key created successfully!");
+    console.log("");
+    console.log(`  ${data.key}`);
+    console.log("");
+    console.log(
+      "Store this key securely \u2014 it will not be shown again."
+    );
+  });
+  keys.command("revoke <id>").description("Revoke an API key").action(async (id) => {
+    const response = await apiFetch(`/api-keys/${id}`, {
+      method: "DELETE"
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      console.error(`Failed to revoke key: ${text}`);
+      process.exit(1);
+    }
+    console.log("API key revoked.");
+  });
+}
+// src/commands/api.ts
+function registerApiCommand(program2) {
+  program2.command("api <method> <path>").description("Make a raw API request (like gh api)").option("-d, --data <json>", "JSON request body").option("-H, --header <header...>", "Additional headers (key:value)").action(
+    async (method, path, options) => {
+      const init = {
+        method: method.toUpperCase()
+      };
+      if (options.data) {
+        init.body = options.data;
+      }
+      if (options.header) {
+        const extra = {};
+        for (const h of options.header) {
+          const colonIdx = h.indexOf(":");
+          if (colonIdx === -1) {
+            console.error(`Invalid header format: "${h}". Use "key:value".`);
+            process.exit(1);
+          }
+          extra[h.slice(0, colonIdx).trim()] = h.slice(colonIdx + 1).trim();
+        }
+        init.headers = extra;
+      }
+      const apiPath = path.startsWith("/") ? path : `/${path}`;
+      const response = await apiFetch(apiPath, init);
+      const contentType = response.headers.get("content-type") ?? "";
+      const text = await response.text();
+      if (contentType.includes("json") && text) {
+        try {
+          const json = JSON.parse(text);
+          console.log(JSON.stringify(json, null, 2));
+        } catch {
+          process.stdout.write(text);
+        }
+      } else if (text) {
+        process.stdout.write(text);
+      }
+      if (!response.ok) {
+        process.exit(1);
+      }
+    }
+  );
+}
+// src/commands/connect.ts
+import { spawn } from "child_process";
+import { createInterface as createInterface2 } from "readline";
+import WebSocket from "ws";
+var RECONNECT_BASE_MS = 1e3;
+var RECONNECT_MAX_MS = 3e4;
+function parseStreamJsonLine(line) {
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  const type = obj?.type;
+  if (type === "system" && obj.subtype === "init" && obj.session_id) {
+    return { kind: "session_id", sessionId: obj.session_id };
+  }
+  if (type === "assistant") {
+    const content = obj.message?.content;
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        if (block.type === "text" && block.text) {
+          return { kind: "text", text: block.text };
+        }
+      }
+    }
+    if (obj.session_id) {
+      return { kind: "session_id", sessionId: obj.session_id };
+    }
+    return { kind: "raw", raw: obj, rawType: "assistant" };
+  }
+  if (type === "content_block_delta") {
+    const delta = obj.delta;
+    if (delta?.type === "text_delta" && delta.text) {
+      return { kind: "text", text: delta.text };
+    }
+    if (delta?.type === "thinking_delta" && delta.thinking) {
+      return { kind: "raw", raw: { type: "content_block_delta", delta }, rawType: "thinking" };
+    }
+    if (delta?.type === "input_json_delta") {
+      return { kind: "raw", raw: obj, rawType: "tool_use" };
+    }
+  }
+  if (type === "content_block_start") {
+    const cb = obj.content_block;
+    if (cb?.type === "tool_use") return { kind: "raw", raw: obj, rawType: "tool_use" };
+    if (cb?.type === "thinking") return { kind: "raw", raw: obj, rawType: "thinking" };
+  }
+  if (type === "content_block_stop") {
+    return { kind: "raw", raw: obj, rawType: "content_block_stop" };
+  }
+  if (type === "message_start" && obj.message?.id) {
+    return { kind: "session_id", sessionId: obj.message.id };
+  }
+  if (type === "message_stop") {
+    return { kind: "done" };
+  }
+  if (type === "result") {
+    if (obj.session_id) {
+      return { kind: "session_id", sessionId: obj.session_id };
+    }
+    return { kind: "done" };
+  }
+  if (type) {
+    return { kind: "raw", raw: obj, rawType: type };
+  }
+  return null;
+}
+function registerConnectCommand(program2) {
+  program2.command("connect <agent-name>").description(
+    "Connect a local Claude Code instance to a BoxCrew agent.\nRequires authentication \u2014 run `bx login` first."
+  ).option("--claude-path <path>", "Path to claude CLI binary", "claude").action(async (agentName, options) => {
+    console.log(`Fetching connection config for agent "${agentName}"...`);
+    const config2 = await apiFetchJson(
+      `/agents/${encodeURIComponent(agentName)}/connection-config`
+    );
+    const wsUrl = config2.websocket_url;
+    console.log(`Agent: ${config2.agent_name} (${config2.agent_id.slice(0, 8)}...)`);
+    console.log(`Proxy: ${config2.proxy_base_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;
+      }
+      const { messageId, message, sessionId } = msg;
+      console.log(`
+Chat ${messageId.slice(0, 8)}: ${message.slice(0, 120)}${message.length > 120 ? "..." : ""}`);
+      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 });
+        }
+      });
+      if (child.stderr) {
+        const stderrRl = createInterface2({ input: child.stderr });
+        stderrRl.on("line", (line) => {
+          if (line.trim()) console.error(`  [claude] ${line}`);
+        });
+      }
+      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 = () => {
+      console.log("Connecting to BoxCrew...");
+      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("Connected. Waiting for messages...");
+      });
+      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) {
+          console.log(`Stopping chat ${msg.messageId.slice(0, 8)}...`);
+          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("WebSocket 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);
+    };
+    connect();
+  });
+}
+// src/index.ts
+var program = new Command().name("bx").description("BoxCrew CLI \u2014 manage your agents from the terminal").version("0.1.0");
+registerLoginCommand(program);
+registerLogoutCommand(program);
+registerAgentsCommands(program);
+registerKeysCommands(program);
+registerApiCommand(program);
+registerConnectCommand(program);
+program.parse();

package/package.json ADDED Viewed

@@ -0,0 +1,35 @@
+{
+  "name": "@boxcrew/cli",
+  "version": "0.1.0",
+  "description": "BoxCrew CLI — manage your agents from the terminal",
+  "type": "module",
+  "bin": {
+    "bx": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "chalk": "^5.4.0",
+    "commander": "^13.0.0",
+    "conf": "^13.0.0",
+    "eventsource-parser": "^3.0.0",
+    "open": "^10.0.0",
+    "ora": "^8.0.0",
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.18.1",
+    "tsup": "^8.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.7.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}