@hivefloor/cli 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Errr0rr404
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,77 @@
-# Temporary Holding Version
+# @hivefloor/cli
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Connect your coding agents to [Hivefloor](https://hivefloor.worldofz.info): one floor that shows every agent on your machines (Claude Code, Codex, Cursor, Gemini CLI, Grok CLI), what each is working on, who is waiting for you, and what they cost in tokens. Agents also get task tools (claim, update, complete) over MCP.
+
+The package installs one command, `hivefloor`. Node.js 22 or later.
+
+## Quick start
+
+```bash
+npx @hivefloor/cli connect
+```
+
+It prints a short code and opens your browser to approve this computer on Hivefloor (sign in there; the CLI never sees your password). Then it sets up the hooks and the background service. Your running agents show up on the Floor within a minute.
+
+Install once instead of using `npx`:
+
+```bash
+npm i -g @hivefloor/cli
+hivefloor connect
+```
+
+Headless box with no browser: run `connect --no-open`, then open the printed link on any device where you are signed in.
+
+## Commands
+
+```
+hivefloor <command> [options]
+npx @hivefloor/cli <command> [options]   (no install)
+
+  connect      Connect this computer once: every agent on it shows up (Claude profiles, Codex, ...)
+                 --host URL   --name NAME   --no-open   --no-service   --yes
+                 --agent | --tool claude|codex|cursor|gemini|grok|other   connect one agent for one repo (MCP and tasks) instead
+  disconnect   Remove everything connect added, the machine on the server included (--tool <name> for one agent tool)
+  status       This machine and its service; the per-repo agent, its projects and live sessions
+  service      run: the background service (started by your OS; you rarely run it by hand)
+  link         Link this repo to another project (--project ID | --new NAME [--path PREFIX])
+  token        Print the stored token for shell use (--reveal to print to a terminal)
+  mcp          Stdio MCP server that proxies to Hivefloor (for tools without HTTP header support)
+  hook         <tool> <event>: the hook runner the tools call (reads JSON on stdin)
+  help         Show this help
+  --version    Print the version
+```
+
+The default server is `https://hivefloor.worldofz.info`; use `--host` or the `HIVEFLOOR_URL` environment variable for another one.
+
+## What `connect` changes on your computer
+
+- `~/.config/hivefloor/` (`%APPDATA%\hivefloor\` on Windows): `machine.json` with the machine token (mode 0600, user-only ACL on Windows), a copy of this CLI that the hooks and the service run, and a small event spool and service log.
+- Hooks in each Claude Code profile's `settings.json` and, if Codex is present, in its `hooks.json` and `config.toml`. Every entry is marked as Hivefloor's.
+- A user-level background service: a launchd agent on macOS, a systemd user unit on Linux, a Scheduled Task on Windows. Skip it with `--no-service`.
+
+`hivefloor disconnect` removes all of it and tells the server to delete the machine. Nothing is installed with administrator rights.
+
+## Privacy: what is sent to the server
+
+Only to the Hivefloor server you connect to (the default host or `--host`), over HTTPS, with the machine token. There is no telemetry and no third-party service.
+
+- **Connecting:** the machine name (your hostname unless you pass `--name`), OS and CLI version.
+- **Hook events** (when an agent starts or ends a session, you submit a prompt, the agent stops, waits for you, or starts or stops a subagent): the tool, the event name, the session id, the model name, the git remote, branch and subfolder of the working directory, and for a stop or subagent event the first line of the agent's last message, with secrets masked and cut to 140 characters. A subagent's type and its short description (140 characters) are sent too. Your prompt text, file contents, tool inputs and outputs, and full transcripts are not sent.
+- **Heartbeat** (about every 30 seconds): OS, CLI version, memory total and use, load average, and token and cost counters per agent profile. The counters are numbers read from the `usage` fields of your local Claude Code and Codex session files from the last 24 hours; message text is never read into what is sent.
+- **Discovery** (about every minute): for each agent tool found running, its name, a profile key (for example `default` or `work`), a label such as `Claude Max (work)` (from the plan name in the profile's credentials file; no email, no token), the model, and how many agent processes are alive. No command lines, paths or prompts.
+- **`link`, `--agent` mode and `mcp`:** the same repo details as above, and your tool's MCP calls to the server's `/mcp` endpoint.
+
+The machine token stays on your computer (the file above, or the OS keychain in `--agent` mode) and is sent only to the host it was issued for.
+
+## Troubleshooting
+
+- `hivefloor status` shows the machine, whether the service is alive and the last heartbeat.
+- The service log is in the config directory above (`service.log`).
+- The hooks never print and always exit 0, so they cannot break your agent.
+
+## Links
+
+- Source and issues: https://github.com/Errr0rr404/hivefloor
+- Docs: https://hivefloor.worldofz.info
+
+MIT License.

package/dist/chunk-2IMJECYD.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+// src/tools.ts
+import fs from "fs";
+import path from "path";
+var REAL_TOOLS = ["claude", "codex", "cursor", "gemini", "grok"];
+var TOOL_LABEL = {
+  claude: "Claude Code",
+  codex: "Codex",
+  cursor: "Cursor",
+  gemini: "Gemini CLI",
+  grok: "Grok CLI",
+  other: "Other"
+};
+var BINARIES = {
+  claude: ["claude"],
+  codex: ["codex"],
+  cursor: ["cursor-agent", "agent"],
+  gemini: ["gemini"],
+  grok: ["grok"]
+};
+function isTool(s) {
+  return s === "other" || REAL_TOOLS.includes(s);
+}
+function findBin(name, env) {
+  const exts = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+  for (const dir of (env.PATH ?? "").split(path.delimiter)) {
+    if (!dir) continue;
+    for (const ext of exts) {
+      const p = path.join(dir, name + ext);
+      try {
+        if (fs.statSync(p).isFile()) {
+          fs.accessSync(p, fs.constants.X_OK);
+          return p;
+        }
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function detectTools(env) {
+  const found = [];
+  for (const tool of REAL_TOOLS) {
+    for (const name of BINARIES[tool]) {
+      const bin = findBin(name, env);
+      if (bin) {
+        found.push({ tool, bin });
+        break;
+      }
+    }
+  }
+  return found;
+}
+function toolFromEnv(env) {
+  if (env.GROK_SESSION_ID) return "grok";
+  if (env.CLAUDECODE || env.CLAUDE_CODE_ENTRYPOINT) return "claude";
+  if (env.CODEX_SANDBOX || env.CODEX_SESSION_ID || env.CODEX_THREAD_ID || env.CODEX_CI) return "codex";
+  if (env.CURSOR_AGENT || env.CURSOR_TRACE_ID || env.CURSOR_SESSION_ID) return "cursor";
+  if (env.GEMINI_CLI || env.GEMINI_SESSION_ID) return "gemini";
+  return void 0;
+}
+
+export {
+  REAL_TOOLS,
+  TOOL_LABEL,
+  isTool,
+  findBin,
+  detectTools,
+  toolFromEnv
+};

package/dist/chunk-3IMV5EHP.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import {
+  atomicWrite,
+  configDir,
+  isRecord,
+  machineFile,
+  readText,
+  serviceStateFile
+} from "./chunk-WNDUGQDX.js";
+
+// src/machine.ts
+import fs from "fs";
+import os from "os";
+function readMachine() {
+  const text = readText(machineFile());
+  if (!text) return void 0;
+  try {
+    const j = JSON.parse(text);
+    if (!isRecord(j) || typeof j.token !== "string" || typeof j.host !== "string" || !isRecord(j.machine)) return void 0;
+    const inst = isRecord(j.installed) ? j.installed : {};
+    return {
+      version: 1,
+      host: j.host,
+      machine: { id: String(j.machine.id ?? ""), name: String(j.machine.name ?? "") },
+      token: j.token,
+      connected_at: typeof j.connected_at === "string" ? j.connected_at : "",
+      ...j.revoked === true ? { revoked: true } : {},
+      installed: {
+        claude_dirs: Array.isArray(inst.claude_dirs) ? inst.claude_dirs.filter((x) => typeof x === "string") : [],
+        ...typeof inst.codex_dir === "string" ? { codex_dir: inst.codex_dir } : {},
+        ...isRecord(inst.service) && typeof inst.service.file === "string" && (inst.service.kind === "launchd" || inst.service.kind === "systemd" || inst.service.kind === "windows") ? { service: { kind: inst.service.kind, file: inst.service.file } } : {}
+      }
+    };
+  } catch {
+    return void 0;
+  }
+}
+function writeMachine(m) {
+  const dir = configDir();
+  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs.chmodSync(dir, 448);
+  try {
+    if (fs.lstatSync(machineFile()).isSymbolicLink()) {
+      throw new Error(`${machineFile()} is a symbolic link; the machine token is not written through links. Remove the link and run connect again.`);
+    }
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
+  atomicWrite(machineFile(), JSON.stringify(m, null, 2) + "\n", 384);
+}
+var removeMachineFile = () => fs.rmSync(machineFile(), { force: true });
+async function secureWindowsMachine(run, username = os.userInfo().username) {
+  if (!username) {
+    removeMachineFile();
+    throw new Error("could not determine the Windows user; the machine token was not kept");
+  }
+  const dir = configDir();
+  const d = await run("icacls", [dir, "/inheritance:r", "/grant:r", `${username}:(OI)(CI)F`]);
+  if (d.code === 0) {
+    const f = await run("icacls", [machineFile(), "/inheritance:r", "/grant:r", `${username}:F`]);
+    if (f.code === 0) return;
+  }
+  removeMachineFile();
+  throw new Error("could not restrict the Hivefloor config to your Windows user with icacls; the machine token was not kept");
+}
+var SERVICE_ALIVE_MS = 9e4;
+function readServiceState() {
+  const text = readText(serviceStateFile());
+  if (!text) return void 0;
+  try {
+    const j = JSON.parse(text);
+    if (isRecord(j) && typeof j.beat === "number" && typeof j.pid === "number") return j;
+  } catch {
+  }
+  return void 0;
+}
+function writeServiceState(s) {
+  atomicWrite(serviceStateFile(), JSON.stringify(s) + "\n", 384);
+}
+var serviceAlive = (nowMs) => {
+  const s = readServiceState();
+  return s !== void 0 && nowMs - s.beat < SERVICE_ALIVE_MS;
+};
+
+export {
+  readMachine,
+  writeMachine,
+  removeMachineFile,
+  secureWindowsMachine,
+  SERVICE_ALIVE_MS,
+  readServiceState,
+  writeServiceState,
+  serviceAlive
+};

package/dist/chunk-76HDATOB.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+import {
+  RC_LINE,
+  addRcLine,
+  hasRcLine,
+  installClaude,
+  installCodex,
+  installCursor,
+  installGemini,
+  installGrok,
+  rcFileFor,
+  updateManifest
+} from "./chunk-YCZ7XJJF.js";
+import {
+  readMachine
+} from "./chunk-3IMV5EHP.js";
+import {
+  deviceLogin
+} from "./chunk-WO7NALQO.js";
+import {
+  detectRepo
+} from "./chunk-CWEEIRW2.js";
+import {
+  REAL_TOOLS,
+  TOOL_LABEL,
+  detectTools,
+  findBin,
+  isTool,
+  toolFromEnv
+} from "./chunk-2IMJECYD.js";
+import {
+  checkUnknownFlags,
+  flagStr
+} from "./chunk-TKMIV7BG.js";
+import {
+  saveToken
+} from "./chunk-Q2TS3GT3.js";
+import {
+  VERSION
+} from "./chunk-WLHRUZTR.js";
+import {
+  ApiError
+} from "./chunk-PY74LT2W.js";
+import {
+  ConfigError
+} from "./chunk-WNDUGQDX.js";
+import {
+  CLI_BIN_NAME,
+  CLI_INSTALL_COMMAND,
+  cliNpxCommand,
+  hostFromEnv,
+  machineName,
+  normalizeHost
+} from "./chunk-ZYRPQPGL.js";
+
+// src/connect.ts
+var INSTALLERS = {
+  claude: installClaude,
+  codex: installCodex,
+  cursor: installCursor,
+  gemini: installGemini,
+  grok: installGrok
+};
+function resolveHost(p, ctx) {
+  const h = flagStr(p, "host");
+  return h ? normalizeHost(h) : hostFromEnv(ctx.env);
+}
+async function chooseTool(ctx, p) {
+  const detected = detectTools(ctx.env).map((d) => d.tool);
+  const flag = flagStr(p, "tool");
+  if (flag !== void 0) {
+    if (!isTool(flag)) throw new ApiError(0, "invalid", `Unknown tool "${flag}". Use one of: ${[...REAL_TOOLS, "other"].join(", ")}.`);
+    return { tool: flag, others: detected.filter((t) => t !== flag) };
+  }
+  const hint = toolFromEnv(ctx.env);
+  let tool = hint ?? detected[0] ?? "other";
+  if (!hint && detected.length > 1 && ctx.stdoutIsTTY && !p.flags.yes) {
+    const answer = (await ctx.ask(`Which tool should this agent be? (${detected.join(", ")}) [${tool}]: `)).trim().toLowerCase();
+    if (isTool(answer)) tool = answer;
+  }
+  return { tool, others: detected.filter((t) => t !== tool) };
+}
+async function connectAgent(ctx, p) {
+  const host = resolveHost(p, ctx);
+  const { tool, others } = await chooseTool(ctx, p);
+  const repo = await detectRepo(ctx.cwd);
+  ctx.out(`Connecting ${TOOL_LABEL[tool]} on ${machineName()} to ${host}
+`);
+  if (repo) ctx.out(`Repo: ${repo.remote}${repo.branch ? ` (${repo.branch})` : ""}${repo.path ? ` in ${repo.path}` : ""}
+`);
+  else ctx.out("No git remote here: the agent will use your default project.\n");
+  const request = {
+    client: { tool, machine: machineName(), os: process.platform, cli_version: VERSION },
+    ...repo ? { repo: { remote: repo.remote, ...repo.branch ? { branch: repo.branch } : {}, ...repo.path ? { path: repo.path } : {} } } : {}
+  };
+  const canOpen = !p.flags["no-open"] && (process.platform !== "linux" || Boolean(ctx.env.DISPLAY || ctx.env.WAYLAND_DISPLAY));
+  const result = await deviceLogin(ctx, { host, request, openBrowser: canOpen });
+  const storage = await saveToken(host, tool, result.token, { agent: result.agent, project: result.project });
+  const rc = rcFileFor(ctx.env);
+  let rcInstalled = rc !== void 0 && hasRcLine(rc);
+  let rcAdded;
+  if (rc && !rcInstalled && tool !== "other") {
+    let yes = Boolean(p.flags.yes);
+    if (!yes && ctx.stdoutIsTTY) yes = /^y(es)?$/i.test((await ctx.ask(`Add this line to ${rc} so your tools can read the token?
+  ${RC_LINE}
+Add it? [y/N] `)).trim());
+    if (yes) {
+      addRcLine(rc);
+      rcInstalled = true;
+      rcAdded = rc;
+      updateManifest((m) => {
+        if (!m.rc.includes(rc)) m.rc.push(rc);
+      });
+    }
+  }
+  const machine = readMachine();
+  const ownsHooks = machine !== void 0 && !machine.revoked;
+  const lines = [];
+  const warnings = [];
+  const mcpUrl = `${host}/mcp`;
+  if (tool === "other") {
+    lines.push(`MCP server: ${mcpUrl} (streamable HTTP), header "Authorization: Bearer <token>" (run: ${cliNpxCommand("token --reveal")})`);
+    lines.push("The agent shows up the first time it calls a tool.");
+  } else {
+    try {
+      const r = await INSTALLERS[tool]({
+        ctx,
+        mcpUrl,
+        token: result.token,
+        useEnvToken: rcInstalled,
+        noCli: Boolean(p.flags["no-cli"]),
+        skipHooks: ownsHooks,
+        onMcpRegistered: (mcp) => {
+          updateManifest((m) => {
+            m.tools[tool] = { mcp, host };
+          });
+        }
+      });
+      lines.push(...r.report.lines);
+      warnings.push(...r.report.warnings);
+      updateManifest((m) => {
+        m.tools[tool] = { mcp: r.mcp, host };
+      });
+    } catch (e) {
+      if (!(e instanceof ConfigError)) throw e;
+      warnings.push(e.message);
+    }
+  }
+  if (rcAdded) lines.push(`Shell: added the token export to ${rcAdded}`);
+  if (!findBin(CLI_BIN_NAME, ctx.env) && tool !== "other") warnings.push(`"${CLI_BIN_NAME}" is not on your PATH, so the hooks cannot run it. Install it once: ${CLI_INSTALL_COMMAND}`);
+  ctx.out(`
+Connected as ${result.agent.name} to project ${result.project.name} (${result.project.key}).
+`);
+  ctx.out(`Token stored in ${storage === "keychain" ? "the OS keychain" : "~/.config/hivefloor/credentials.json (mode 0600)"}.
+`);
+  for (const l of lines) ctx.out(`  ${l}
+`);
+  for (const w of warnings) ctx.out(`  note: ${w}
+`);
+  if (others.length > 0) ctx.out(`Also installed: ${others.join(", ")}. Connect each with: ${cliNpxCommand("connect --tool <name>")}
+`);
+  ctx.out(`Undo everything with: ${cliNpxCommand("disconnect")}
+`);
+  return 0;
+}
+var CONNECT_FLAGS = /* @__PURE__ */ new Set(["host", "name", "no-open", "no-service", "yes", "y", "agent", "tool", "no-cli", "help", "h"]);
+async function connect(ctx, p) {
+  const unknown = checkUnknownFlags(p, CONNECT_FLAGS);
+  if (unknown) {
+    ctx.err(`hivefloor: unknown flag "--${unknown}". Run "hivefloor help".
+`);
+    return 2;
+  }
+  if (p.flags.agent || p.flags.tool !== void 0) return connectAgent(ctx, p);
+  return (await import("./machine-connect-I3OZCTUZ.js")).connectMachine(ctx, p);
+}
+
+export {
+  resolveHost,
+  connectAgent,
+  connect
+};

package/dist/chunk-CWEEIRW2.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import {
+  formatRemote,
+  normalizeRemote,
+  runCmd
+} from "./chunk-ZYRPQPGL.js";
+
+// src/git.ts
+function remoteOf(url) {
+  const n = normalizeRemote(url);
+  return n ? formatRemote(n) : void 0;
+}
+async function git(cwd, args) {
+  const r = await runCmd("git", args, { cwd, timeoutMs: 2e3, env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" } });
+  return r.code === 0 ? r.stdout.trim() : void 0;
+}
+async function detectRepo(cwd) {
+  const [origin, upstream, branch, prefix] = await Promise.all([
+    git(cwd, ["remote", "get-url", "origin"]),
+    git(cwd, ["remote", "get-url", "upstream"]),
+    git(cwd, ["symbolic-ref", "--short", "-q", "HEAD"]),
+    git(cwd, ["rev-parse", "--show-prefix"])
+  ]);
+  const remote = origin ? remoteOf(origin) : void 0;
+  if (!remote) return void 0;
+  const path = prefix?.replace(/\/+$/, "");
+  const up = upstream ? remoteOf(upstream) : void 0;
+  return {
+    remote,
+    ...branch ? { branch } : {},
+    ...path ? { path } : {},
+    ...up && up.toLowerCase() !== remote.toLowerCase() ? { upstream: up } : {}
+  };
+}
+
+export {
+  detectRepo
+};

package/dist/chunk-JCLWCMEM.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+// src/hookclock.ts
+var HARD_EXIT_MS = 4e3;
+
+export {
+  HARD_EXIT_MS
+};

package/dist/chunk-K3NQKI34.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/chunk-MMWX62ZU.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import {
+  isTool
+} from "./chunk-2IMJECYD.js";
+import {
+  flagStr
+} from "./chunk-TKMIV7BG.js";
+import {
+  defaultHost,
+  loadToken
+} from "./chunk-Q2TS3GT3.js";
+import {
+  hostFromEnv,
+  normalizeHost
+} from "./chunk-ZYRPQPGL.js";
+
+// src/session.ts
+async function resolveSession(ctx, p) {
+  const flagHost = flagStr(p, "host");
+  const host = flagHost ? normalizeHost(flagHost) : ctx.env.HIVEFLOOR_URL ? hostFromEnv(ctx.env) : defaultHost() ?? hostFromEnv(ctx.env);
+  const toolFlag = flagStr(p, "tool");
+  const t = await loadToken(host, toolFlag && isTool(toolFlag) ? toolFlag : void 0);
+  if (t) return { host, token: t.token, tool: t.tool };
+  if (ctx.env.HIVEFLOOR_TOKEN) return { host, token: ctx.env.HIVEFLOOR_TOKEN, tool: toolFlag ?? "other" };
+  return void 0;
+}
+
+export {
+  resolveSession
+};

package/dist/chunk-NCRQGIJY.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+import {
+  home,
+  isRecord,
+  readText
+} from "./chunk-WNDUGQDX.js";
+import {
+  PROFILE_KEY_RE
+} from "./chunk-ZYRPQPGL.js";
+
+// src/profiles.ts
+import fs from "fs";
+import path from "path";
+function profileKeyOf(tool, dir, homeDir = home()) {
+  const std = tool === "claude" ? path.join(homeDir, ".claude") : path.join(homeDir, ".codex");
+  if (path.resolve(dir) === path.resolve(std)) return "default";
+  let base = path.basename(path.resolve(dir)).toLowerCase().replace(/^\.+/, "");
+  base = base.replace(new RegExp(`^${tool}[-_.]?`), "").replace(new RegExp(`[-_.]?${tool}$`), "");
+  base = base.replace(/[^a-z0-9._-]+/g, "-").replace(/^[^a-z0-9]+/, "").slice(0, 40);
+  return PROFILE_KEY_RE.test(base) ? base : "profile";
+}
+function profileKeys(tool, dirs, homeDir = home()) {
+  const out = /* @__PURE__ */ new Map();
+  const used = /* @__PURE__ */ new Set();
+  for (const d of dirs) {
+    out.set(d, uniqueProfileKey(profileKeyOf(tool, d, homeDir), used));
+  }
+  return out;
+}
+function uniqueProfileKey(base, used) {
+  const stem = base.replace(/-\d+$/, "");
+  let k = base;
+  for (let n = 2; used.has(k); n++) {
+    const suf = `-${n}`;
+    k = `${stem.slice(0, Math.max(0, 40 - suf.length))}${suf}`;
+  }
+  used.add(k);
+  return k;
+}
+var RC_FILES = [".zshrc", ".zprofile", ".zshenv", ".bashrc", ".bash_profile", ".profile", ".config/fish/config.fish"];
+function claudeDirsFromRc(homeDir = home()) {
+  const found = [];
+  for (const rel of RC_FILES) {
+    const text = readText0(path.join(homeDir, rel));
+    if (!text) continue;
+    for (const line of text.split("\n")) {
+      if (/^\s*#/.test(line)) continue;
+      for (const m of line.matchAll(/CLAUDE_CONFIG_DIR(?:=|\s+)(?:"([^"\n]+)"|'([^'\n]+)'|([^\s"'`;&|)]+))/g)) {
+        const raw = (m[1] ?? m[2] ?? m[3] ?? "").trim();
+        const dir = expand(raw, homeDir);
+        if (dir && isDir(dir)) found.push(dir);
+      }
+    }
+  }
+  return found;
+}
+function isDir(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function readText0(file) {
+  try {
+    return readText(file);
+  } catch {
+    return void 0;
+  }
+}
+function expand(raw, homeDir) {
+  let s = raw.replace(/^~(?=\/|$)/, homeDir).replace(/\$\{?HOME\}?/g, homeDir);
+  if (/[$`]/.test(s) || !path.isAbsolute(s)) return void 0;
+  s = path.resolve(s);
+  return s;
+}
+function claudeSiblingDirs(homeDir = home()) {
+  const out = [];
+  let names = [];
+  try {
+    names = fs.readdirSync(homeDir);
+  } catch {
+    return out;
+  }
+  for (const n of names) {
+    if (!n.startsWith(".claude") || n === ".claude.json" || n.endsWith(".bak")) continue;
+    const dir = path.join(homeDir, n);
+    try {
+      if (!fs.statSync(dir).isDirectory()) continue;
+      if (fs.existsSync(path.join(dir, "settings.json")) || fs.existsSync(path.join(dir, ".claude.json"))) out.push(dir);
+    } catch {
+    }
+  }
+  return out;
+}
+function claudeConfigDirs(fromProcesses, homeDir = home()) {
+  const all = [path.join(homeDir, ".claude"), ...fromProcesses, ...claudeDirsFromRc(homeDir), ...claudeSiblingDirs(homeDir)];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const d of all) {
+    const r = path.resolve(d);
+    if (seen.has(r)) continue;
+    seen.add(r);
+    out.push(r);
+  }
+  return out;
+}
+function codexConfigDir(env = process.env) {
+  return env.CODEX_HOME ? path.resolve(env.CODEX_HOME) : path.join(home(), ".codex");
+}
+var PLAN = { max: "Max", pro: "Pro", team: "Team", enterprise: "Enterprise", free: "Free" };
+function claudeLabel(dir, key) {
+  let plan;
+  try {
+    const j = JSON.parse(fs.readFileSync(path.join(dir, ".credentials.json"), "utf8"));
+    const oauth = isRecord(j) ? j.claudeAiOauth : void 0;
+    const t = isRecord(oauth) ? oauth.subscriptionType : void 0;
+    if (typeof t === "string") plan = PLAN[t.toLowerCase()];
+  } catch {
+  }
+  return `Claude${plan ? ` ${plan}` : ""} (${key})`;
+}
+function codexLabel(dir) {
+  try {
+    const j = JSON.parse(fs.readFileSync(path.join(dir, "auth.json"), "utf8"));
+    const mode = isRecord(j) && typeof j.auth_mode === "string" ? j.auth_mode.toLowerCase() : "";
+    if (mode === "chatgpt") return "Codex (ChatGPT)";
+    if (mode === "apikey" || mode === "api_key") return "Codex (API key)";
+  } catch {
+  }
+  return "Codex";
+}
+
+export {
+  profileKeyOf,
+  profileKeys,
+  uniqueProfileKey,
+  claudeDirsFromRc,
+  claudeConfigDirs,
+  codexConfigDir,
+  claudeLabel,
+  codexLabel
+};