@hivefloor/cli 0.1.4 → 0.1.8

package/dist/{chunk-PDXYOREI.js → chunk-QLMLB7RB.js}

@@ -1,4 +1,9 @@
 #!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
+import {
+  userBinDirs
+} from "./chunk-XAXKZ572.js";
 import {
   atomicWrite,
   atomicWriteUtf16,
@@ -8,11 +13,15 @@ import {
   isRecord,
   readText,
   removeFile
-} from "./chunk-VNCQFFQO.js";
+} from "./chunk-XPGL7VYE.js";
+import {
+  normalizeHost,
+  runCmd,
+  sameOrigin
+} from "./chunk-QGULSOQ2.js";
 import {
-  cliNpxCommand,
-  runCmd
-} from "./chunk-ZC2DAKB5.js";
+  cliNpxCommand
+} from "./chunk-HWBUESB4.js";
 
 // src/service/units.ts
 import os from "os";
@@ -23,8 +32,11 @@ var SCHTASKS_TASK = "Hivefloor Machine";
 var xml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 var sdEscape = (s) => s.replace(/(["\\$])/g, "\\$1").replace(/%/g, "%%");
 var sdQuote = (s) => /^[\w@+=:,./-]+$/.test(s) ? s : `"${sdEscape(s)}"`;
+function unitPath(plan, system, homeDir = home()) {
+  if (/[\r\n\0]/.test(homeDir)) throw new Error("refusing to write a service unit: HOME contains a control character");
+  return [path.dirname(plan.node), ...userBinDirs(homeDir), ...system].filter((d, i, a) => a.indexOf(d) === i).join(":");
+}
 function launchdPlist(plan) {
-  const bin = path.dirname(plan.node);
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -50,7 +62,7 @@ function launchdPlist(plan) {
   <key>EnvironmentVariables</key>
   <dict>
     <key>PATH</key>
-    <string>${xml(`${bin}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin`)}</string>
+    <string>${xml(unitPath(plan, ["/usr/bin", "/bin", "/usr/sbin", "/sbin"]))}</string>
   </dict>
   <key>StandardOutPath</key>
   <string>/dev/null</string>
@@ -62,14 +74,14 @@ function launchdPlist(plan) {
 }
 function systemdUnit(plan) {
   return `[Unit]
-Description=Hivefloor machine service
+Description=HiveFloor machine service
 After=network-online.target
 
 [Service]
 ExecStart=${sdQuote(plan.node)} ${sdQuote(plan.script)} service run
 Restart=on-failure
 RestartSec=30
-Environment="PATH=${sdEscape(`${path.dirname(plan.node)}:/usr/local/bin:/usr/bin:/bin`)}"
+Environment="PATH=${sdEscape(unitPath(plan, ["/usr/bin", "/bin"]))}"
 
 [Install]
 WantedBy=default.target
@@ -91,7 +103,7 @@ function windowsTaskXml(plan, user) {
   return `<?xml version="1.0" encoding="UTF-16"?>
 <Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
   <RegistrationInfo>
-    <Description>Hivefloor machine service</Description>
+    <Description>HiveFloor machine service</Description>
   </RegistrationInfo>
   <Triggers>
     <LogonTrigger>
@@ -215,8 +227,13 @@ async function uninstallService(svc, run, uid) {
 }
 
 // src/credentials.ts
+import { createHash } from "crypto";
 import fs from "fs";
-var SERVICE = "hivefloor";
+var KEYCHAIN_SERVICE = "hivefloor";
+var TOKEN_FP_HEX = 16;
+function tokenFingerprint(token) {
+  return createHash("sha256").update(token, "utf8").digest("hex").slice(0, TOKEN_FP_HEX);
+}
 var realKeyring = async () => {
   if (process.env.HIVEFLOOR_KEYRING === "0") return void 0;
   try {
@@ -227,6 +244,19 @@ var realKeyring = async () => {
 };
 var loadKeyring = realKeyring;
 var account = (host, tool) => `${host}#${tool}`;
+function canonicalHost(host) {
+  try {
+    return normalizeHost(host);
+  } catch {
+    return void 0;
+  }
+}
+function hostKey(creds, host) {
+  const want = canonicalHost(host);
+  if (want === void 0) return creds.hosts[host] ? host : void 0;
+  if (creds.hosts[want]) return want;
+  return Object.keys(creds.hosts).find((k) => k === want || sameOrigin(k, want));
+}
 function readCredentials() {
   const text = readText(credentialsFile());
   const empty = { version: 1, hosts: {} };
@@ -256,33 +286,53 @@ function writeCredentials(c) {
   }
   atomicWrite(file, JSON.stringify(c, null, 2) + "\n", 384);
 }
+var windowsAclError = () => new Error("could not restrict the HiveFloor config to your Windows user with icacls; the token was not kept");
 async function secureWindowsCredentials(run, username) {
   if (!username) throw new Error("could not determine the Windows user; the token was not kept");
   const dir = prepareConfigDir();
   const d = await run("icacls", [dir, "/inheritance:r", "/grant:r", `${username}:(OI)(CI)F`]);
-  if (d.code !== 0) throw new Error("could not restrict the Hivefloor config to your Windows user with icacls; the token was not kept");
+  if (d.code !== 0) throw windowsAclError();
+}
+async function secureWindowsCredentialsFile(run, username) {
+  const f = await run("icacls", [credentialsFile(), "/inheritance:r", "/grant:r", `${username}:F`]);
+  if (f.code !== 0) throw windowsAclError();
 }
 async function saveToken(host, tool, token, meta = {}, opts = {}) {
   const creds = readCredentials();
-  const h = creds.hosts[host] ??= { tools: {} };
+  const key = hostKey(creds, host) ?? canonicalHost(host) ?? host;
+  const h = creds.hosts[key] ??= { tools: {} };
   let storage = "file";
   const kr = await loadKeyring();
   if (kr) {
     try {
-      const entry = new kr.Entry(SERVICE, account(host, tool));
+      const entry = new kr.Entry(KEYCHAIN_SERVICE, account(key, tool));
       entry.setPassword(token);
       if (entry.getPassword() === token) storage = "keychain";
     } catch {
       storage = "file";
     }
   }
-  if (storage === "file" && (opts.platform ?? process.platform) === "win32") {
-    await secureWindowsCredentials(opts.run ?? runCmd, opts.username ?? windowsUser(process.env));
+  const winFile = storage === "file" && (opts.platform ?? process.platform) === "win32";
+  const run = opts.run ?? runCmd;
+  const username = opts.username ?? windowsUser(process.env);
+  if (winFile) {
+    await secureWindowsCredentials(run, username);
   }
+  const previous = winFile ? readText(credentialsFile()) : void 0;
   h.tools[tool] = { ...storage === "keychain" ? { keychain: true } : { token }, ...meta, saved_at: (/* @__PURE__ */ new Date()).toISOString() };
   h.last_tool = tool;
-  creds.default_host = host;
+  h.token_fp = tokenFingerprint(token);
+  creds.default_host = key;
   writeCredentials(creds);
+  if (winFile) {
+    try {
+      await secureWindowsCredentialsFile(run, username);
+    } catch (e) {
+      if (previous === void 0) fs.rmSync(credentialsFile(), { force: true });
+      else atomicWrite(credentialsFile(), previous, 384);
+      throw e;
+    }
+  }
   return storage;
 }
 function pickTool(h, tool) {
@@ -291,8 +341,10 @@ function pickTool(h, tool) {
   return Object.keys(h.tools)[0];
 }
 async function loadToken(host, tool) {
-  const h = readCredentials().hosts[host];
-  if (!h) return void 0;
+  const creds = readCredentials();
+  const key = hostKey(creds, host);
+  const h = key ? creds.hosts[key] : void 0;
+  if (!key || !h) return void 0;
   const t = pickTool(h, tool);
   const c = t ? h.tools[t] : void 0;
   if (!t || !c) return void 0;
@@ -301,7 +353,7 @@ async function loadToken(host, tool) {
     const kr = await loadKeyring();
     if (!kr) return void 0;
     try {
-      const v = new kr.Entry(SERVICE, account(host, t)).getPassword();
+      const v = new kr.Entry(KEYCHAIN_SERVICE, account(key, t)).getPassword();
       if (v) return { token: v, tool: t };
     } catch {
     }
@@ -312,34 +364,57 @@ function defaultHost() {
   const c = readCredentials();
   return c.default_host && c.hosts[c.default_host] ? c.default_host : Object.keys(c.hosts)[0];
 }
+function deletedKeychainEntry(kr, host, tool) {
+  try {
+    const e = new kr.Entry(KEYCHAIN_SERVICE, account(host, tool));
+    let dropped;
+    if (e.deletePassword) dropped = e.deletePassword();
+    else if (e.deleteCredential) dropped = e.deleteCredential();
+    else return false;
+    if (dropped !== false) return true;
+    try {
+      const still = e.getPassword();
+      return still === null || still === void 0;
+    } catch {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+}
 async function deleteCredentials(host, tool) {
   const creds = readCredentials();
   const kr = await loadKeyring();
-  let n = 0;
+  let removed = 0;
+  const leftover = [];
   for (const [h, hc] of Object.entries(creds.hosts)) {
-    if (host && h !== host) continue;
+    if (host && h !== host && !sameOrigin(h, host)) continue;
+    let removedHere = 0;
     for (const [t, c] of Object.entries(hc.tools)) {
       if (tool && t !== tool) continue;
-      if (c.keychain && kr) {
-        try {
-          const e = new kr.Entry(SERVICE, account(h, t));
-          if (e.deletePassword) e.deletePassword();
-          else e.deleteCredential?.();
-        } catch {
-        }
+      if (c.keychain && !(kr && deletedKeychainEntry(kr, h, t))) {
+        leftover.push(account(h, t));
+        continue;
       }
       delete hc.tools[t];
-      n += 1;
+      removed += 1;
+      removedHere += 1;
     }
+    if (removedHere === 0) continue;
     if (hc.last_tool && !hc.tools[hc.last_tool]) hc.last_tool = Object.keys(hc.tools)[0];
     if (Object.keys(hc.tools).length === 0) delete creds.hosts[h];
+    else {
+      const last = hc.last_tool ? hc.tools[hc.last_tool] : void 0;
+      if (last?.token) hc.token_fp = tokenFingerprint(last.token);
+      else delete hc.token_fp;
+    }
   }
   if (creds.default_host && !creds.hosts[creds.default_host]) creds.default_host = Object.keys(creds.hosts)[0];
-  if (n > 0) {
+  if (removed > 0) {
     if (Object.keys(creds.hosts).length === 0) fs.rmSync(credentialsFile(), { force: true });
     else writeCredentials(creds);
   }
-  return n;
+  return { removed, leftover };
 }
 
 export {
@@ -348,6 +423,10 @@ export {
   installService,
   windowsServiceStatus,
   uninstallService,
+  KEYCHAIN_SERVICE,
+  TOKEN_FP_HEX,
+  tokenFingerprint,
+  hostKey,
   readCredentials,
   saveToken,
   loadToken,

package/dist/{chunk-TKMIV7BG.js → chunk-QPAFN47B.js}

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
 
 // src/args.ts
-var BOOLEAN = /* @__PURE__ */ new Set(["no-open", "yes", "y", "reveal", "help", "h", "json", "no-cli", "agent", "no-service"]);
+var BOOLEAN = /* @__PURE__ */ new Set(["no-open", "yes", "y", "reveal", "help", "h", "json", "no-cli", "agent", "no-service", "permission-prompt", "full", "no-full"]);
 function parseArgs(argv) {
   const positionals = [];
   const flags = {};

package/dist/chunk-SBOEAOHD.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
+
+// src/service/control/private.ts
+import fs from "fs";
+var uid = () => typeof process.getuid === "function" ? process.getuid() : void 0;
+function ensurePrivateDir(dir) {
+  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  if (process.platform !== "win32") fs.chmodSync(dir, 448);
+}
+function privateDirTrouble(dir) {
+  let st;
+  try {
+    st = fs.lstatSync(dir);
+  } catch {
+    return `${dir} does not exist`;
+  }
+  if (st.isSymbolicLink() || !st.isDirectory()) return `${dir} is not a plain folder`;
+  if (process.platform === "win32") return void 0;
+  if (uid() !== void 0 && st.uid !== uid()) return `${dir} is owned by another user`;
+  if ((st.mode & 63) !== 0) return `${dir} is open to group or others`;
+  return void 0;
+}
+function privateFileTrouble(file) {
+  let st;
+  try {
+    st = fs.lstatSync(file);
+  } catch {
+    return `${file} does not exist`;
+  }
+  if (st.isSymbolicLink() || !st.isFile()) return `${file} is not a regular file`;
+  if (process.platform === "win32") return void 0;
+  if (uid() !== void 0 && st.uid !== uid()) return `${file} is owned by another user`;
+  if ((st.mode & 63) !== 0) return `${file} is open to group or others`;
+  return void 0;
+}
+function safeName(id) {
+  const s = id.replace(/[^A-Za-z0-9_.-]/g, "_").replace(/^\.+/, "_").slice(0, 120);
+  return s === "" ? "_" : s;
+}
+
+export {
+  ensurePrivateDir,
+  privateDirTrouble,
+  privateFileTrouble,
+  safeName
+};

package/dist/{chunk-SD65CIIY.js → chunk-TIR4CV3P.js}

@@ -1,57 +1,69 @@
 #!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
 import {
   deviceLogin
-} from "./chunk-R5KDI4WI.js";
+} from "./chunk-FPJNGKT5.js";
 import {
   RC_LINE,
   addRcLine,
   hasRcLine,
-  installClaude,
-  installCodex,
   installCursor,
   installGemini,
   installGrok,
-  rcFileFor,
+  rcFileFor
+} from "./chunk-QBBKGORP.js";
+import {
+  emptyReport,
+  envTokenSharedWith,
+  installClaude,
+  installCodex,
+  readManifest,
+  toolReadsEnvToken,
   updateManifest
-} from "./chunk-QHYZBHXO.js";
+} from "./chunk-X2KH6AR4.js";
 import {
   detectRepo
-} from "./chunk-2BSA7LFD.js";
+} from "./chunk-BLLPDPTL.js";
 import {
-  REAL_TOOLS,
-  TOOL_LABEL,
-  detectTools,
-  findBin,
-  isTool,
-  toolFromEnv
-} from "./chunk-2IMJECYD.js";
+  defaultHost,
+  loadToken,
+  saveToken
+} from "./chunk-QLMLB7RB.js";
 import {
   checkUnknownFlags,
   flagStr
-} from "./chunk-TKMIV7BG.js";
-import {
-  saveToken
-} from "./chunk-PDXYOREI.js";
+} from "./chunk-QPAFN47B.js";
 import {
   VERSION
-} from "./chunk-DNG5CRT3.js";
+} from "./chunk-K2IRTZH5.js";
 import {
   readMachine
-} from "./chunk-T7TG6WA4.js";
+} from "./chunk-LX5A25O6.js";
 import {
   ApiError
-} from "./chunk-PY74LT2W.js";
+} from "./chunk-NRJONTFT.js";
+import {
+  ConfigError,
+  REAL_TOOLS,
+  TOOL_LABEL,
+  detectTools,
+  findBin,
+  isTool,
+  toolFromEnv
+} from "./chunk-XPGL7VYE.js";
 import {
-  ConfigError
-} from "./chunk-VNCQFFQO.js";
+  hostFromEnv,
+  hostFromFlag,
+  machineName,
+  normalizeHost,
+  sameOrigin
+} from "./chunk-QGULSOQ2.js";
 import {
   CLI_BIN_NAME,
   CLI_INSTALL_COMMAND,
-  cliNpxCommand,
-  hostFromEnv,
-  machineName,
-  normalizeHost
-} from "./chunk-ZC2DAKB5.js";
+  cliNpxCommand
+} from "./chunk-HWBUESB4.js";
 
 // src/connect.ts
 var INSTALLERS = {
@@ -61,9 +73,59 @@ var INSTALLERS = {
   gemini: installGemini,
   grok: installGrok
 };
+async function freezeForeignEnvTools(ctx, host, tool, noCli) {
+  const report = emptyReport();
+  const manifest = readManifest();
+  for (const [name, entry] of Object.entries(manifest.tools)) {
+    const real = REAL_TOOLS.find((t) => t === name);
+    if (!real || real === tool || !entry || !toolReadsEnvToken(name, entry, true)) continue;
+    const owner = entry.host;
+    if (typeof owner !== "string" || owner.trim() === "") {
+      throw new ApiError(
+        0,
+        "manifest",
+        `${TOOL_LABEL[real]} reads HIVEFLOOR_TOKEN, but its manifest entry has no host. Reconnect it with ${cliNpxCommand(`connect --tool ${real}`)} so the shell token is not sent to the wrong server.`
+      );
+    }
+    if (sameOrigin(owner, host)) continue;
+    const stored = await loadToken(owner, real);
+    if (!stored) {
+      throw new ApiError(
+        0,
+        "token",
+        `${TOOL_LABEL[real]} on ${owner} reads HIVEFLOOR_TOKEN, which would now be the token for ${host}, and no stored token is left for it. Run ${cliNpxCommand(`connect --host ${owner} --tool ${real}`)} again.`
+      );
+    }
+    const r = await INSTALLERS[real]({
+      ctx,
+      mcpUrl: `${normalizeHost(owner)}/mcp`,
+      token: stored.token,
+      useEnvToken: false,
+      requireStoredToken: true,
+      noCli,
+      mcpOnly: true,
+      onMcpRegistered: (mcp) => {
+        updateManifest((m) => {
+          m.tools[real] = { mcp, host: owner, envToken: false };
+        });
+      }
+    });
+    updateManifest((m) => {
+      m.tools[real] = { mcp: r.mcp, host: owner, envToken: false };
+    });
+    report.lines.push(...r.report.lines);
+    report.warnings.push(...r.report.warnings);
+    report.warnings.push(`${TOOL_LABEL[real]} on ${owner} now stores its own token, so HIVEFLOOR_TOKEN is not sent there.`);
+  }
+  return report;
+}
 function resolveHost(p, ctx) {
   const h = flagStr(p, "host");
-  return h ? normalizeHost(h) : hostFromEnv(ctx.env);
+  return h ? hostFromFlag(ctx, h) : hostFromEnv(ctx.env);
+}
+function shellExportFollowsHost(env, host) {
+  if (!env.HIVEFLOOR_URL) return true;
+  return sameOrigin(env.HIVEFLOOR_URL, host);
 }
 async function chooseTool(ctx, p) {
   const detected = detectTools(ctx.env).map((d) => d.tool);
@@ -95,7 +157,6 @@ async function connectAgent(ctx, p) {
   };
   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;
@@ -118,34 +179,57 @@ Add it? [y/N] `)).trim());
   const lines = [];
   const warnings = [];
   const mcpUrl = `${host}/mcp`;
+  const exportFollowsHost = shellExportFollowsHost(ctx.env, host);
+  const previousHost = defaultHost();
+  const shared = envTokenSharedWith(host, tool, rcInstalled);
+  const allowEnv = rcInstalled && exportFollowsHost && (previousHost === void 0 || sameOrigin(previousHost, host)) && shared;
+  if (rcInstalled && !shared) {
+    try {
+      const frozen = await freezeForeignEnvTools(ctx, host, tool, Boolean(p.flags["no-cli"]));
+      lines.push(...frozen.lines);
+      warnings.push(...frozen.warnings);
+    } catch (e) {
+      if (e instanceof ConfigError) {
+        throw new ApiError(0, "config", `${e.message} Left the other host's tool config in place and did not finish connecting ${host}.`);
+      }
+      throw e;
+    }
+  }
   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 {
+    let mcpRegistered = false;
     try {
       const r = await INSTALLERS[tool]({
         ctx,
         mcpUrl,
         token: result.token,
-        useEnvToken: rcInstalled,
+        useEnvToken: allowEnv,
+        requireStoredToken: rcInstalled && !allowEnv,
         noCli: Boolean(p.flags["no-cli"]),
         skipHooks: ownsHooks,
         onMcpRegistered: (mcp) => {
+          mcpRegistered = true;
           updateManifest((m) => {
-            m.tools[tool] = { mcp, host };
+            m.tools[tool] = { mcp, host, envToken: allowEnv };
           });
         }
       });
       lines.push(...r.report.lines);
       warnings.push(...r.report.warnings);
       updateManifest((m) => {
-        m.tools[tool] = { mcp: r.mcp, host };
+        m.tools[tool] = { mcp: r.mcp, host, envToken: allowEnv };
       });
     } catch (e) {
       if (!(e instanceof ConfigError)) throw e;
+      if (!mcpRegistered) {
+        throw new ApiError(0, "config", `${e.message} Did not finish connecting ${host}; the default host is unchanged.`);
+      }
       warnings.push(e.message);
     }
   }
+  const storage = await saveToken(host, tool, result.token, { agent: result.agent, project: result.project });
   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(`
@@ -172,7 +256,7 @@ async function connect(ctx, p) {
     return 2;
   }
   if (p.flags.agent || p.flags.tool !== void 0) return connectAgent(ctx, p);
-  return (await import("./machine-connect-BYHZRRRB.js")).connectMachine(ctx, p);
+  return (await import("./machine-connect-KEI4BRWF.js")).connectMachine(ctx, p);
 }
 
 export {