@pitboss/cli 0.1.3 → 0.2.0

package/README.md

@@ -38,7 +38,7 @@ relai login --invite inv_<code> --api <https://your-relai-host>
 If you're standing one up yourself, see the [main repo](https://github.com/phillipsio/relai) for setup; then:
 
 ```bash
-relai init   # guided setup — saves config to ~/.config/relai/config.json
+relai init   # guided setup — saves config to ~/.config/pitboss/config.json
 ```
 
 After either path, `relai init` / `relai login` prints a ready-to-paste `mcpServers` block — drop it into your project's `.mcp.json` (or `~/.claude.json`) so your AI agent (Claude Code, Cursor, Copilot, etc.) can use the relai tools directly.
@@ -117,16 +117,16 @@ relai token revoke <tokenId>        Revoke a specific token
 
 ## Multi-identity
 
-Set `RELAI_CONFIG_DIR` to override the config location and run multiple agent identities side by side from one machine:
+Set `PITBOSS_CONFIG_DIR` to override the config location and run multiple agent identities side by side from one machine:
 
 ```bash
-export RELAI_CONFIG_DIR=/tmp/relai-coworker
+export PITBOSS_CONFIG_DIR=/tmp/relai-coworker
 relai login --invite inv_<...>
 ```
 
 ## Config
 
-`~/.config/relai/config.json` (or `$RELAI_CONFIG_DIR/config.json`):
+`~/.config/pitboss/config.json` (or `$PITBOSS_CONFIG_DIR/config.json`):
 
 ```json
 {

package/dist/cli.js

@@ -18010,14 +18010,46 @@ var dist_default7 = createPrompt((config, done) => {
 // src/config.ts
 import { homedir } from "node:os";
 import { join, dirname } from "node:path";
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync, existsSync, renameSync } from "node:fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync, existsSync, renameSync, rmSync as rmSync2, lstatSync, statSync } from "node:fs";
 import { randomBytes } from "node:crypto";
+var configDirOverride = () => process.env.PITBOSS_CONFIG_DIR || process.env.RELAI_CONFIG_DIR || void 0;
+function configDir() {
+  return configDirOverride() ?? join(homedir(), ".config", "pitboss");
+}
 function configPath() {
-  const dir = process.env.RELAI_CONFIG_DIR ?? join(homedir(), ".config", "relai");
-  return join(dir, "config.json");
+  return join(configDir(), "config.json");
+}
+function legacyHomePath(name) {
+  return join(homedir(), ".config", "relai", name);
+}
+var configOverridden = () => configDirOverride() !== void 0;
+var warnedFor = /* @__PURE__ */ new Set();
+function readableFrom(current, legacy, overridden) {
+  if (overridden || existsSync(current) || !existsSync(legacy)) return current;
+  if (!warnedFor.has(legacy)) {
+    warnedFor.add(legacy);
+    console.error(`pitboss: reading ${legacy}; the next write moves it to ${current}.`);
+  }
+  return legacy;
+}
+function retireLegacy(legacy, current, overridden) {
+  if (overridden) return;
+  try {
+    const found = lstatSync(legacy, { throwIfNoEntry: false });
+    if (!found) return;
+    const [a, b] = [statSync(dirname(legacy)), statSync(dirname(current))];
+    if (a.dev === b.dev && a.ino === b.ino) return;
+    rmSync2(legacy);
+  } catch (err) {
+    if (err.code === "ENOENT") return;
+    console.error(`pitboss: could not remove ${legacy} (${String(err)}); it may still hold a token, delete it by hand.`);
+  }
+}
+function configFileInUse() {
+  return readableFrom(configPath(), legacyHomePath("config.json"), configOverridden());
 }
 function readConfig() {
-  const file = configPath();
+  const file = configFileInUse();
   if (!existsSync(file)) return null;
   try {
     const raw = JSON.parse(readFileSync2(file, "utf-8"));
@@ -18029,10 +18061,12 @@ function readConfig() {
 }
 function writeConfig(config) {
   const file = configPath();
+  const migrating = !existsSync(file);
   mkdirSync(dirname(file), { recursive: true });
   const tmp = `${file}.relai-${randomBytes(8).toString("hex")}`;
   writeFileSync2(tmp, JSON.stringify(config, null, 2), { mode: 384, flag: "wx" });
   renameSync(tmp, file);
+  if (migrating) retireLegacy(legacyHomePath("config.json"), file, configOverridden());
   return file;
 }
 function requireConfig() {
@@ -18896,7 +18930,7 @@ function runtimeTargets(workerType, { home, repo: repo2 }) {
     case "gpt":
       return [join2(home, ".codex", "mcp.json")];
     case "mcp":
-      return [join2(home, ".config", "relai", "config.json")];
+      return [join2(home, ".config", "pitboss", "config.json")];
     // A person, not a runtime. Nothing to configure.
     case "human":
       return [];
@@ -19123,12 +19157,12 @@ import { homedir as homedir3 } from "node:os";
 import { join as join3, resolve, dirname as dirname2 } from "node:path";
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "node:fs";
 import { createHash } from "node:crypto";
+var stateOverridden = () => Boolean(process.env.PITBOSS_AGENTS_STATE || process.env.RELAI_AGENTS_STATE);
 function statePath() {
-  if (process.env.RELAI_AGENTS_STATE) return process.env.RELAI_AGENTS_STATE;
-  return join3(homedir3(), ".config", "relai", "agents.json");
+  return process.env.PITBOSS_AGENTS_STATE || process.env.RELAI_AGENTS_STATE || join3(homedir3(), ".config", "pitboss", "agents.json");
 }
 function readAgentsState() {
-  const p = statePath();
+  const p = readableFrom(statePath(), legacyHomePath("agents.json"), stateOverridden());
   if (!existsSync3(p)) return { agents: [] };
   try {
     const raw = JSON.parse(readFileSync4(p, "utf-8"));
@@ -19140,8 +19174,10 @@ function readAgentsState() {
 }
 function writeAgentsState(state) {
   const p = statePath();
+  const migrating = !existsSync3(p);
   mkdirSync2(dirname2(p), { recursive: true });
   writeFileSync3(p, JSON.stringify(state, null, 2));
+  if (migrating) retireLegacy(legacyHomePath("agents.json"), p, stateOverridden());
 }
 function hashToken(token2) {
   return createHash("sha256").update(token2).digest("hex").slice(0, 16);
@@ -19242,7 +19278,8 @@ async function loginCommand(opts) {
   if (existing && opts.invite) {
     console.log(source_default.yellow(`
 Already logged in as ${source_default.bold(existing.agentName)} (${existing.agentId})`));
-    console.log(source_default.dim("Delete ~/.config/relai/config.json to re-login.\n"));
+    console.log(source_default.dim(`Delete ${configFileInUse()} to re-login.
+`));
     return;
   }
   const apiUrl = opts.api ?? await dist_default6({ message: "API URL", default: "http://localhost:3010" });
@@ -19581,7 +19618,8 @@ async function run(opts) {
       role: invite.role,
       specialization: invite.specialization ?? void 0,
       workerType: invite.workerType,
-      domains: invite.domains ?? []
+      domains: invite.domains ?? [],
+      .../^[^\p{Cc}\p{Cf}\u2028\u2029\u0085]{1,1024}$/u.test(root) ? { repoPath: root } : {}
     });
     if (accepted.status !== 201) {
       const said = accepted.payload?.error?.message;

package/dist/mcp.js

@@ -9766,10 +9766,6 @@ var require_content_type = __commonJS({
 });
 
 // ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.6.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/sse.js
-var sse_exports = {};
-__export(sse_exports, {
-  SSEServerTransport: () => SSEServerTransport
-});
 import { randomUUID } from "node:crypto";
 var import_raw_body, import_content_type, MAXIMUM_MESSAGE_SIZE, SSEServerTransport;
 var init_sse = __esm({
@@ -9888,6 +9884,106 @@ data: ${JSON.stringify(message)}
   }
 });
 
+// ../mcp-server/src/http-auth.ts
+var http_auth_exports = {};
+__export(http_auth_exports, {
+  isAuthorizedBearer: () => isAuthorizedBearer,
+  isBlankCredential: () => isBlankCredential,
+  resolveHttpCredential: () => resolveHttpCredential
+});
+import { createHash, timingSafeEqual } from "node:crypto";
+function sha256(value) {
+  return createHash("sha256").update(value, "utf8").digest();
+}
+function isBlankCredential(value) {
+  return value.trim().length === 0;
+}
+function isAuthorizedBearer(authHeader, credential) {
+  if (isBlankCredential(credential) || !authHeader) return false;
+  const spaceIndex = authHeader.indexOf(" ");
+  if (spaceIndex === -1) return false;
+  if (authHeader.slice(0, spaceIndex).toLowerCase() !== "bearer") return false;
+  const token = authHeader.slice(spaceIndex + 1);
+  return timingSafeEqual(sha256(token), sha256(credential));
+}
+function resolveHttpCredential(mcpHttpToken, ownerMode, ownerToken, apiSecret) {
+  if (mcpHttpToken) return mcpHttpToken;
+  return (ownerMode ? ownerToken : apiSecret) ?? "";
+}
+var init_http_auth = __esm({
+  "../mcp-server/src/http-auth.ts"() {
+    "use strict";
+  }
+});
+
+// ../mcp-server/src/http-transport.ts
+var http_transport_exports = {};
+__export(http_transport_exports, {
+  createHttpRequestListener: () => createHttpRequestListener
+});
+function createHttpRequestListener(server2, credential) {
+  let current;
+  let takeoverQueue = Promise.resolve();
+  function detach(transport) {
+    transport.onclose = void 0;
+    transport.onerror = void 0;
+    transport.onmessage = void 0;
+  }
+  async function takeOver(res) {
+    const replaced = current;
+    current = void 0;
+    if (replaced) {
+      detach(replaced);
+      try {
+        await replaced.close();
+      } catch {
+      }
+    }
+    const transport = new SSEServerTransport("/messages", res);
+    try {
+      await server2.connect(transport);
+      current = transport;
+    } catch (err) {
+      detach(transport);
+      console.error("[relai-mcp] failed to establish SSE connection:", err instanceof Error ? err.message : err);
+      if (!res.headersSent) {
+        res.writeHead(500, { "content-type": "application/json" }).end(JSON.stringify({ error: { code: "connect_failed", message: "Failed to establish SSE connection" } }));
+      }
+    }
+  }
+  return async (req, res) => {
+    if (!isAuthorizedBearer(req.headers.authorization, credential)) {
+      console.error(`[relai-mcp] rejected unauthenticated HTTP request: ${req.method} ${req.url}`);
+      res.writeHead(401, { "content-type": "application/json", "www-authenticate": "Bearer" }).end(UNAUTHORIZED_BODY);
+      return;
+    }
+    const path = (req.url ?? "").split("?")[0];
+    if (req.method === "GET" && path === "/sse") {
+      const attempt = takeoverQueue.then(() => takeOver(res), () => takeOver(res));
+      takeoverQueue = attempt;
+      await attempt;
+    } else if (req.method === "POST" && path === "/messages") {
+      res.writeHead(501, { "content-type": "application/json" }).end(NOT_IMPLEMENTED_BODY);
+    } else {
+      res.writeHead(404).end();
+    }
+  };
+}
+var UNAUTHORIZED_BODY, NOT_IMPLEMENTED_BODY;
+var init_http_transport = __esm({
+  "../mcp-server/src/http-transport.ts"() {
+    "use strict";
+    init_sse();
+    init_http_auth();
+    UNAUTHORIZED_BODY = JSON.stringify({
+      error: { code: "unauthorized", message: "Missing or invalid bearer token" }
+    });
+    NOT_IMPLEMENTED_BODY = JSON.stringify({
+      error: { code: "not_implemented", message: "This server does not yet process incoming tool-call messages" }
+    });
+  }
+});
+
 // ../mcp-server/src/index.ts
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
@@ -12177,6 +12273,12 @@ var ApiClient = class {
       `/agents/${agentId}/tokens`
     );
   }
+  deleteAgent(agentId) {
+    return this.request("DELETE", `/agents/${agentId}`);
+  }
+  revokeToken(tokenId) {
+    return this.request("DELETE", `/tokens/${tokenId}`);
+  }
   listInvites(repoId) {
     return this.request(
       "GET",
@@ -12824,7 +12926,39 @@ ${version.body}`
     // Additive, never a swap: an owner-scoped agent is still an agent and needs
     // everything above. buildOperatorTools assumes no agent identity, and its
     // create_task bypasses propose/commit.
-    ...opts.ownerScoped ? buildProvisioningTools(client) : []
+    ...opts.ownerScoped ? [...buildProvisioningTools(client, { credentialMinting: true }), ...buildAgentManagementTools(client, agentId)] : []
+  ];
+}
+function buildAgentManagementTools(client, selfId) {
+  const text = (value) => ({ content: [{ type: "text", text: JSON.stringify(value, null, 2) }] });
+  return [
+    {
+      name: "remove_agent",
+      description: "Permanently delete one of the owner's agents, with its tokens. Cannot be undone: the agent has to be invited again to come back. Use list_agents to find the id. You cannot remove yourself, and a repo's only orchestrator cannot be removed.",
+      inputSchema: external_exports.object({ agentId: external_exports.string().min(1).describe("The agent to delete.") }),
+      handler: async (input) => {
+        if (input.agentId === selfId) {
+          return { content: [{ type: "text", text: "Refused: you cannot remove yourself." }], isError: true };
+        }
+        await client.deleteAgent(input.agentId);
+        return text({ removed: input.agentId });
+      }
+    },
+    {
+      name: "list_tokens",
+      description: "List an agent's tokens: id, createdAt, lastUsedAt, revokedAt, whether each is owner-scoped, and which one is current. Never the token itself. Use it before revoke_token.",
+      inputSchema: external_exports.object({ agentId: external_exports.string().min(1).describe("Whose tokens to list.") }),
+      handler: async (input) => text({ tokens: await client.listAgentTokens(input.agentId) })
+    },
+    {
+      name: "revoke_token",
+      description: "Revoke one token by id, so whatever holds it stops working at once. The agent itself stays; it needs a new token or invite to reconnect. Revoking your own current token ends this session.",
+      inputSchema: external_exports.object({ tokenId: external_exports.string().min(1).describe("From list_tokens.") }),
+      handler: async (input) => {
+        await client.revokeToken(input.tokenId);
+        return text({ revoked: input.tokenId });
+      }
+    }
   ];
 }
 function selectTools(client, config) {
@@ -12879,11 +13013,7 @@ function buildProvisioningTools(client, opts = {}) {
         return { content: [{ type: "text", text: JSON.stringify({ repo }, null, 2) }] };
       }
     },
-    // invite_agent mints a bearer credential, and agent mode reaches a headless
-    // `claude --print --dangerously-skip-permissions` loop where nothing
-    // confirms a call. Before this, no agent-mode tool took a repoId from the
-    // model at all, so the model's reach was one repo even when the credential
-    // reached every repo the owner owns.
+    // Mints a bearer credential: owner mode and the god credential only.
     ...opts.credentialMinting ? [{
       name: "invite_agent",
       description: "Authorise a new agent to join one of your repos. This does NOT create the agent: it mints a single-use, expiring invite code and returns the exact command that redeems it. Two ways to finish. If you have a shell on the machine that agent will run on, create its working directory and run the command there. If you do not, give the user the command to paste. Either way the redeem is INTERACTIVE: `login` prompts for the agent name and specialization and does not yet read them from the invite, so expect to answer two questions and do not run it anywhere it cannot reach a terminal. The code is the only secret here and it is worthless once redeemed, which is why this is an invite rather than a token: a token would be long-lived and would sit in this conversation. Set workerType to the runtime that agent actually is, or it joins labelled 'human' and routing treats it wrongly.",
@@ -12907,8 +13037,8 @@ function buildProvisioningTools(client, opts = {}) {
             text: JSON.stringify({
               invite,
               code,
-              redeemCommand: `RELAI_CONFIG_DIR=~/.config/relai/${slot} pitboss login --api ${client.apiUrl} --invite ${code}${workerTypeFlag}`,
-              nextStep: "Run redeemCommand in the directory that agent will work from, or give it to the user to paste there. It will ask for an agent name and a specialization. The code is single-use and expires. One machine holds one identity per config dir, which is why the command sets RELAI_CONFIG_DIR \u2014 drop it and a machine that already has an agent will report success without redeeming anything."
+              redeemCommand: `PITBOSS_CONFIG_DIR=~/.config/pitboss/${slot} RELAI_CONFIG_DIR=~/.config/pitboss/${slot} pitboss login --api ${client.apiUrl} --invite ${code}${workerTypeFlag}`,
+              nextStep: "Run redeemCommand in the directory that agent will work from, or give it to the user to paste there. It will ask for an agent name and a specialization. The code is single-use and expires. One machine holds one identity per config dir, which is why the command sets the config dir \u2014 drop it and a machine that already has an agent will report success without redeeming anything."
             }, null, 2)
           }]
         };
@@ -13439,7 +13569,7 @@ var {
   OWNER_ID,
   TRANSPORT = "stdio"
 } = process.env;
-var OWNER_MODE = Boolean(API_OWNER_TOKEN);
+var OWNER_MODE = Boolean(API_OWNER_TOKEN?.trim());
 if (OWNER_MODE) {
   if (!OWNER_ID || !OWNER_ID.startsWith("usr_")) {
     console.error("[relai-mcp] owner mode requires OWNER_ID (a 'usr_\u2026' id) alongside API_OWNER_TOKEN");
@@ -13449,7 +13579,7 @@ if (OWNER_MODE) {
     "[relai-mcp] owner mode: API_OWNER_TOKEN is a god-key credential \u2014 keep this server off the open internet (localhost bind + authenticating reverse proxy only)."
   );
 } else {
-  if (!API_SECRET) {
+  if (!API_SECRET?.trim()) {
     console.error("[relai-mcp] API_SECRET is required");
     process.exit(1);
   }
@@ -13559,20 +13689,20 @@ async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
   } else if (TRANSPORT === "http") {
-    const { SSEServerTransport: SSEServerTransport2 } = await Promise.resolve().then(() => (init_sse(), sse_exports));
     const http = await import("node:http");
+    const { createHttpRequestListener: createHttpRequestListener2 } = await Promise.resolve().then(() => (init_http_transport(), http_transport_exports));
+    const { resolveHttpCredential: resolveHttpCredential2, isBlankCredential: isBlankCredential2 } = await Promise.resolve().then(() => (init_http_auth(), http_auth_exports));
     const port = Number(process.env.MCP_PORT ?? 3001);
     const host = process.env.MCP_HOST ?? "127.0.0.1";
-    const httpServer = http.createServer(async (req, res) => {
-      if (req.method === "GET" && req.url === "/sse") {
-        const transport = new SSEServerTransport2("/messages", res);
-        await server.connect(transport);
-      } else if (req.method === "POST" && req.url === "/messages") {
-        res.writeHead(200).end();
-      } else {
-        res.writeHead(404).end();
-      }
-    });
+    const credential = resolveHttpCredential2(process.env.MCP_HTTP_TOKEN, OWNER_MODE, API_OWNER_TOKEN, API_SECRET);
+    if (isBlankCredential2(credential)) {
+      console.error(
+        "[relai-mcp] the HTTP transport credential (MCP_HTTP_TOKEN, API_SECRET, or API_OWNER_TOKEN) is empty or whitespace \u2014 refusing to start with a credential that would lock out every client"
+      );
+      process.exit(1);
+    }
+    const listener = createHttpRequestListener2(server, credential);
+    const httpServer = http.createServer(listener);
     httpServer.listen(port, host, () => {
       console.error(`[relai-mcp] HTTP/SSE transport listening on ${host}:${port}`);
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pitboss/cli",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "private": false,
   "description": "Connect your coding agents to a pitboss instance",
   "keywords": [