@brutalsystems/muster 0.7.18 → 0.7.19

package/dist/identity-cli.js

@@ -1,7 +1,7 @@
 import { identityAuthState } from "./identity-auth.js";
 import { IdentityError, identityDirExists, identityMetaSchema, identityNameSchema, identityPath, listIdentities, readIdentity, writeIdentity, } from "./identity-store.js";
 import { removeStoredToken, writeStoredToken, } from "./identity-token.js";
-import { captureClaudeToken, redactToken, } from "./identity-login.js";
+import { captureClaudeToken, redactToken, resolveOnPath, } from "./identity-login.js";
 /**
  * The one-time login for each agent. Muster never performs it: each is an
  * interactive OAuth flow, and a command that appeared to do it for you would be
@@ -25,7 +25,12 @@ export async function setupIdentity(opts) {
     // a codex or opencode identity, where the credential is an auth file the
     // agent's own login writes into the template, it has exactly one effect: a new
     // way to fail. Refused where the operator types it.
-    if (opts.tokenEnv && opts.agent !== "claude")
+    // Checked against undefined, not truthiness: `--token-env ""` is falsy, so a
+    // truthiness test let an empty name past every guard and then dropped it,
+    // leaving the identity on neither credential route without saying so (#69).
+    if (opts.tokenEnv !== undefined && opts.tokenEnv.trim() === "")
+        throw new IdentityError(opts.name, "--token-env takes the name of an environment variable holding the token, not the token and not an empty value");
+    if (opts.tokenEnv !== undefined && opts.agent !== "claude")
         throw new IdentityError(name, `--token-env applies only to a claude identity; ${opts.agent} authenticates from an auth file in the template, and a token variable here would only add a way for the launch to fail`);
     // Distinguish "no such identity" from "an identity that is there but unusable".
     // Overwriting the second would silently repurpose a directory that still holds
@@ -150,24 +155,30 @@ export async function interactiveSetup(opts) {
             stored: false,
             note: `Run this once, then check with \`muster identities\`:\n\n    ${created.login}\n`,
         };
+    // Asked before anything is spawned, so "could not be started" is a fact about
+    // the filesystem rather than an inference from what the child printed. That
+    // inference was platform-dependent: a missing executable emits nothing under
+    // macOS and an error into the pty under Linux (#69).
+    if (!(await resolveOnPath("claude", opts.env ?? process.env)))
+        throw new IdentityError(opts.name, "`claude` is not on PATH, so the login could not be started; nothing was changed");
     write(`Running: claude setup-token\n${"─".repeat(50)}\n`);
     const result = await captureClaudeToken({
         dir: created.path,
         env: opts.env ?? process.env,
         onData: write,
-        ...(opts.stdin ? { stdin: opts.stdin } : {}),
+        stdin: opts.stdin,
     });
     write(`${"─".repeat(50)}\n`);
     // Checked BEFORE the token branch, deliberately: a login that failed writes
     // no credential even if something token-shaped went past on the way down.
     //
-    // This is also the case where the child never started at all. node-pty does
-    // not throw for a missing executable — it exits 1 having emitted zero bytes —
-    // so an operator with no `claude` on PATH used to be told Muster could not
-    // parse output that never existed, with no identity name and no hint that
-    // nothing had run. The child's own output is the error here, whatever it was.
+    // Two different events land here and they need different explanations. node-pty
+    // does not throw for a missing executable — it exits 1 having emitted zero
+    // bytes — which is exactly the exit shape of a login that failed on its own or
+    // that the operator interrupted. The exit code cannot tell them apart; whether
+    // anything was ever printed can (#69).
     if (result.exitCode !== 0)
-        throw new IdentityError(opts.name, `\`claude setup-token\` failed (exit ${result.exitCode}) and no credential was stored; its own output above is the error. If nothing was printed above it could not be started at all — check that \`claude\` is on PATH.`);
+        throw new IdentityError(opts.name, `\`claude setup-token\` ended without storing a credential (exit ${result.exitCode}); its own output above is the error. If you interrupted it, nothing was stored and nothing was changed.`);
     if (result.token) {
         const { clearedRoute } = await storeIdentityToken({
             home: opts.home,

package/dist/identity-login.js

@@ -1,3 +1,28 @@
+import { access, constants } from "node:fs/promises";
+import { delimiter, join } from "node:path";
+/**
+ * Where `name` is on PATH, or undefined. The same lookup `tmuxExecutable` does,
+ * and the reason the login asks it: whether a child "could not be started" has
+ * to be decided before spawning, not inferred from what it printed. node-pty
+ * does not throw for a missing executable — it exits 1, emitting nothing on
+ * macOS and an error into the pty on Linux, so output was never the discriminator
+ * it appeared to be (#69).
+ */
+export async function resolveOnPath(name, env) {
+    for (const dir of (env.PATH ?? "").split(delimiter)) {
+        if (!dir)
+            continue;
+        const candidate = join(dir, name);
+        try {
+            await access(candidate, constants.X_OK);
+            return candidate;
+        }
+        catch {
+            // Not here, or not executable. Keep looking.
+        }
+    }
+    return undefined;
+}
 /**
  * A Claude long-lived OAuth token, as `claude setup-token` prints it. The length
  * floor is what separates a real token from the literal word in help text.
@@ -257,8 +282,8 @@ function attachInput(pty, input, signals) {
  * status quo.
  */
 export async function captureClaudeToken(opts) {
-    const module = await import("node-pty");
-    const pty = module.spawn("claude", ["setup-token"], {
+    const spawn = opts.spawn ?? (await import("node-pty")).spawn;
+    const pty = spawn("claude", ["setup-token"], {
         cwd: opts.dir,
         env: { ...opts.env, CLAUDE_CONFIG_DIR: opts.dir },
         name: "xterm-256color",
@@ -278,7 +303,7 @@ export async function captureClaudeToken(opts) {
     // up before rethrowing, and enters raw mode last of all.
     let detachInput = () => { };
     try {
-        detachInput = attachInput(pty, opts.stdin ?? process.stdin, opts.signals ?? process);
+        detachInput = attachInput(pty, opts.stdin, opts.signals ?? process);
         const filter = createTokenFilter(opts.onData);
         const dataSub = pty.onData((chunk) => filter.push(chunk));
         const exitCode = await new Promise((resolve) => {

package/dist/muster.js

@@ -247,13 +247,21 @@ async function main() {
                 // year-long token to disk on the machine the operator explicitly asked
                 // to keep no credential at rest, while never recording the variable
                 // they named.
-                if (tokenEnv)
+                if (tokenEnv !== undefined && agent !== "claude")
+                    // Not the mutual-exclusion message: for codex and opencode
+                    // `--interactive` captures nothing and `--token-env` does not apply
+                    // at all, so describing them as two routes to choose between would
+                    // be describing Claude's behaviour at a different agent (#69).
+                    throw new IdentityError(identity, `--token-env applies only to a claude identity; ${agent} authenticates from an auth file in the template, and a token variable here would only add a way for the launch to fail`);
+                if (tokenEnv !== undefined)
                     throw new IdentityError(identity, "--interactive and --token-env are the two mutually exclusive credential routes: --interactive runs the login and stores a token in the identity, --token-env records the name of a variable to read one from instead. Pass one, not both.");
                 const result = await interactiveSetup({
                     home: musterHome(),
                     name: identity,
                     agent: agent,
                     isTTY: Boolean(process.stdin.isTTY),
+                    // The one place the operator's real keyboard is named.
+                    stdin: process.stdin,
                 });
                 process.stdout.write(`\n${result.note}\n`);
                 return;
@@ -265,7 +273,7 @@ async function main() {
                 home: musterHome(),
                 name: identity,
                 agent: agent,
-                ...(tokenEnv ? { tokenEnv } : {}),
+                ...(tokenEnv !== undefined ? { tokenEnv } : {}),
             })) + "\n");
         }
         else if (command === "identities") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brutalsystems/muster",
-  "version": "0.7.18",
+  "version": "0.7.19",
   "description": "Launch instructed, reachable local agent sessions",
   "type": "module",
   "engines": {
@@ -12,7 +12,8 @@
   "scripts": {
     "build": "tsc && node scripts/prepare-bin.mjs",
     "test": "vitest run",
-    "check": "npm test && node scripts/check-tarball.mjs",
+    "typecheck": "tsc -p tsconfig.check.json",
+    "check": "npm run typecheck && npm test && node scripts/check-tarball.mjs",
     "test:contract": "MUSTER_CONTRACT=1 vitest run test/contract.test.ts",
     "postinstall": "node scripts/prepare-pty.mjs",
     "pretest": "npm run build",