premanmcp 1.1.11 → 1.1.13

package/bin/shared.js

@@ -14,6 +14,7 @@ import {
   readFileSync,
   realpathSync,
   rmSync,
+  statSync,
   writeFileSync,
   mkdirSync,
 } from "node:fs";
@@ -107,6 +108,19 @@ export function pathPremanOwner() {
       if (isEphemeralBin(realPath)) continue;
       const owner = owningPackage(realPath);
       if (owner) return owner;
+      // Only a symlink resolves to the file inside the package. npm on Windows
+      // installs `preman.cmd`, and pnpm installs a launcher shim on every
+      // platform, both of which are real files that merely *name* the target --
+      // so realpath ends at the shim, no manifest is found above it, and a
+      // perfectly good global install was reported as not owning `preman`. The
+      // cost of that wrong answer is the hook and every printed instruction
+      // switching to `npm exec -y premanmcp@latest --`, which re-resolves the
+      // package from the network on every git push.
+      const named = shimTarget(realPath);
+      if (named) {
+        const shimOwner = owningPackage(named);
+        if (shimOwner) return shimOwner;
+      }
     } catch {
       // A dangling link or an unreadable manifest: try the next match.
     }
@@ -114,6 +128,24 @@ export function pathPremanOwner() {
   return "";
 }
 
+/** The path a launcher shim points at, or "" if this is not one. */
+function shimTarget(shimPath) {
+  try {
+    // A real bundle is megabytes; a shim is a few hundred bytes. The cap is
+    // what keeps this from reading an executable into memory to look for paths.
+    if (statSync(shimPath).size > 16 * 1024) return "";
+    const body = readFileSync(shimPath, "utf8");
+    // Covers npm's .cmd and its shell wrapper, and pnpm's, all of which name
+    // the entry point relative to the shim or absolutely.
+    const match = body.match(/["']?([^"'\s]*node_modules[/\\][^"'\s]+\.(?:js|mjs|cjs))["']?/);
+    if (!match) return "";
+    const target = match[1].replace(/^%~dp0/, "").replace(/^\$basedir/, "");
+    return realpathSync(path.resolve(path.dirname(shimPath), target));
+  } catch {
+    return "";
+  }
+}
+
 export function cliInvocation() {
   return (_invocation ||=
     pathPremanOwner() === "premanmcp" ? "preman" : "npm exec -y premanmcp@latest --");
@@ -208,6 +240,26 @@ export function readStoredCredentials() {
 export function saveStoredCredentials(creds) {
   mkdirSync(CREDENTIALS_DIR, { recursive: true, mode: 0o700 });
   writeFileSync(CREDENTIALS_FILE, `${JSON.stringify(creds, null, 2)}\n`, { mode: 0o600 });
+  warnIfModesAreDecorative();
+}
+
+/**
+ * Say so where 0600 does not mean 0600.
+ *
+ * Windows ignores the POSIX mode bits entirely, so the file holding a live
+ * pm_live_ key inherits whatever the parent directory grants -- which under a
+ * roaming or shared profile can be other accounts on the machine. The mode is
+ * still passed, because it costs nothing and is correct everywhere else; what
+ * was missing is anyone being told that on this platform it is decorative.
+ */
+let modeWarningShown = false;
+function warnIfModesAreDecorative() {
+  if (process.platform !== "win32" || modeWarningShown) return;
+  modeWarningShown = true;
+  process.stdout.write(
+    `Note: ${CREDENTIALS_FILE} holds an API key, and Windows does not apply the\n` +
+      `  owner-only permissions PreMan asks for. Keep this profile to yourself.\n`
+  );
 }
 
 /** Forget the stored key. Returns whether there was one. */
@@ -371,15 +423,124 @@ export function openUrl(url, { app = "" } = {}) {
       detached: true,
       shell: process.platform === "win32",
     });
+    // spawn reports a missing opener through an asynchronous 'error' event, not
+    // a throw, so this try/catch never saw it and an EventEmitter with no
+    // 'error' listener rethrows: a Linux box without `xdg-open` took the whole
+    // process down from `login --browser`, from the integration flows, and from
+    // /app inside a session. Headless boxes and locked-down shells are normal,
+    // so this is the expected case rather than a fault.
+    child.once("error", () => {});
     child.unref();
     return true;
   } catch {
-    // Headless boxes and locked-down shells are normal.
     return false;
   }
 }
 
+/**
+ * Piped answers, read as a stream and kept in order.
+ *
+ * A readline interface built per prompt consumed the line it was handed and
+ * then threw away everything readline had already buffered behind it, so piped
+ * input survived exactly one question. `printf 'sure\nn\n' | preman onboard`
+ * spent "sure" on the first prompt, lost the "n" with the interface, and every
+ * later prompt fell through to its default -- and the defaults are yes. A
+ * script written to decline things accepted them instead, the git hook
+ * included, and it did so silently.
+ *
+ * Lines are therefore consumed from stdin directly and queued. stdin is only
+ * referenced while a prompt is actually outstanding: holding it open would
+ * leave a finished run waiting on a writer that has nothing left to say, and
+ * unreferencing it permanently would let the process exit mid-walk on a
+ * question it had already drawn.
+ */
+let pipedAnswers = null;
+
+function pipedReader() {
+  if (pipedAnswers) return pipedAnswers;
+
+  const ready = [];
+  const waiting = [];
+  const state = { ended: false, held: false };
+  let buffer = "";
+
+  const hold = (on) => {
+    if (state.held === on) return;
+    const fn = on ? process.stdin.ref : process.stdin.unref;
+    if (typeof fn === "function") {
+      fn.call(process.stdin);
+      state.held = on;
+    }
+  };
+
+  const deliver = (value) => {
+    const next = waiting.shift();
+    if (!next) {
+      ready.push(value);
+      return;
+    }
+    next(value);
+    if (!waiting.length) hold(false);
+  };
+
+  const end = () => {
+    if (state.ended) return;
+    state.ended = true;
+    if (buffer.length) deliver(buffer);
+    buffer = "";
+    while (waiting.length) waiting.shift()("");
+    hold(false);
+  };
+
+  // Nothing read stdin before now, so an already-ended stream will not emit
+  // 'end' again and every take() would wait on a line that cannot arrive.
+  if (process.stdin.readableEnded || process.stdin.destroyed) state.ended = true;
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (chunk) => {
+    buffer += chunk;
+    let cut = buffer.indexOf("\n");
+    while (cut !== -1) {
+      deliver(buffer.slice(0, cut).replace(/\r$/, ""));
+      buffer = buffer.slice(cut + 1);
+      cut = buffer.indexOf("\n");
+    }
+  });
+  process.stdin.once("end", end);
+  process.stdin.once("error", end);
+  hold(false);
+
+  pipedAnswers = {
+    take() {
+      if (ready.length) return Promise.resolve(ready.shift());
+      if (state.ended) return Promise.resolve("");
+      hold(true);
+      return new Promise((resolve) => waiting.push(resolve));
+    },
+  };
+  return pipedAnswers;
+}
+
 export async function promptText(question) {
+  // Piped input is answered from the queue and nowhere else. Testing
+  // `readableEnded` first looked like the same thing and was not: a pipe
+  // delivers every answer in one write and then closes, so by the second
+  // question the stream has ended while its remaining lines are still sitting
+  // in the queue unread -- and this returned "" on top of them. It only showed
+  // up where something slow sat between two prompts, which is why the walk hit
+  // it and a tight loop of prompts did not: the account check is an HTTP round
+  // trip, and during it stdin ends. The prompt after it was the confirmation
+  // before creating an account, so a piped "n" was read as the default, and
+  // the default is yes.
+  if (!process.stdin.isTTY) {
+    process.stdout.write(question);
+    const answer = await pipedReader().take();
+    // A piped answer is never echoed back, so without this the next thing
+    // written lands on the prompt line and reads as one broken sentence:
+    // `Email: [preman] Email is required.`
+    process.stdout.write(`${answer}\n`);
+    return answer.trim();
+  }
+
   // A stream that has already ended will never deliver a line, and readline does
   // not emit 'close' for an 'end' that happened before the interface existed --
   // so the second prompt after stdin ran out resolved nothing, kept nothing
@@ -390,7 +551,17 @@ export async function promptText(question) {
     process.stdout.write(`${question}\n`);
     return "";
   }
+
   const rl = createInterface({ input: process.stdin, output: process.stdout });
+  // Readline owns raw mode while it has a question open, so ^C never reaches
+  // Node as a signal: the prompt resolved empty, empty is the step's default,
+  // and the default is yes. Interrupting a question used to accept it.
+  const interrupt = () => {
+    process.stdout.write("\n");
+    rl.close();
+    process.exit(130);
+  };
+  rl.once("SIGINT", interrupt);
   try {
     // An exhausted or closed stdin never answers, and rl.question waits for an
     // answer that cannot come. That is how a run given fewer answers than it had
@@ -403,6 +574,7 @@ export async function promptText(question) {
     ]);
     return answer.trim();
   } finally {
+    rl.off("SIGINT", interrupt);
     rl.close();
   }
 }
@@ -645,9 +817,10 @@ function authSessionFrom(result, email) {
 }
 
 async function verifyUnconfirmedAccount(args, email) {
-  process.stdout.write("This email exists but is not verified. Sending a new OTP.\n");
+  process.stdout.write("This account still needs its email verified. Sending a new code.\n");
   const resend = await callBackendJson(args, "POST", "/auth/resend-otp", { json: { email } });
   assertOk(resend, "resend OTP");
+  if (!reportCodeSent(resend, "New code sent. Check your email.")) throw undeliveredCode();
   const otp = await promptText("Verification code: ");
   const verified = await callBackendJson(args, "POST", "/auth/verify-otp", { json: { email, otp } });
   assertOk(verified, "verify OTP");
@@ -703,7 +876,7 @@ async function createAccountFromTerminal(args, email) {
   });
 
   if (signup.ok) {
-    process.stdout.write("Verification code sent. Check your email.\n");
+    if (!reportCodeSent(signup)) throw undeliveredCode();
     const otp = await promptText("Verification code: ");
     return completeWithCode(args, email, otp, password);
   }
@@ -722,7 +895,7 @@ async function createAccountFromTerminal(args, email) {
     json: { email, password: legacyPassword },
   });
   assertOk(legacySignup, "signup");
-  process.stdout.write("Verification code sent. Check your email.\n");
+  if (!reportCodeSent(legacySignup)) throw undeliveredCode();
   const otp = await promptText("Verification code: ");
   const verified = await callBackendJson(args, "POST", "/auth/verify-otp", {
     json: { email, otp },
@@ -731,6 +904,79 @@ async function createAccountFromTerminal(args, email) {
   return authSessionFrom(verified, email);
 }
 
+/** Read the address back before an account exists on it. */
+async function confirmNewAccount(email) {
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const answer = (await promptText(`No PreMan account for ${email}. Create one? [Y/n]: `))
+      .trim()
+      .toLowerCase();
+    if (answer === "" || answer === "y" || answer === "yes") return true;
+    if (answer === "n" || answer === "no") return false;
+    process.stdout.write("  Please answer y or n.\n");
+  }
+  return false;
+}
+
+/**
+ * The stored key, if it is for this backend and the backend still honours it.
+ *
+ * Revoked and stale keys have to fall through to a real sign-in rather than
+ * being handed back, or the walk would carry on to the steps that need a
+ * working key and fail at each of them in turn.
+ */
+async function reusableCredentials(args) {
+  const stored = readStoredCredentials();
+  if (!stored?.api_key) return null;
+  if (stored.backend_url && stored.backend_url !== backendUrl(args)) return null;
+  const wanted = args.value("--email", "").trim().toLowerCase();
+  if (wanted && String(stored.user_email || "").toLowerCase() !== wanted) return null;
+  if (args.has("--relogin")) return null;
+
+  try {
+    const status = await callBackendJson(args, "GET", "/cli/status", { token: stored.api_key });
+    return status.ok ? stored : null;
+  } catch {
+    // Offline or a backend that is down is not evidence the key is bad, but it
+    // is also not a sign-in, and prompting for an email we cannot check is
+    // worse than saying what actually happened.
+    return null;
+  }
+}
+
+/**
+ * Say whether a code is actually on its way.
+ *
+ * The backend reports delivery in `email_sent` and answers 200 either way, so
+ * every one of these lines used to send somebody to an inbox that was never
+ * going to receive anything -- including on any deployment with no sender
+ * configured, where the code only ever reached the server log. The dashboard
+ * has read this field since it existed; the terminal never did.
+ */
+function reportCodeSent(result, sent = "Verification code sent. Check your email.") {
+  // Only ever present on a deployment that has deliberately switched it on,
+  // which is how dev stays usable without a mail sender.
+  if (result?.dev_otp) {
+    process.stdout.write(`Verification code (dev): ${result.dev_otp}\n`);
+    return true;
+  }
+  if (result?.email_sent === false) {
+    process.stdout.write(
+      "PreMan could not send the code — the email service rejected it.\n" +
+        "  Nothing is wrong with your account. Try again shortly, or contact support.\n"
+    );
+    return false;
+  }
+  process.stdout.write(`${sent}\n`);
+  return true;
+}
+
+/** The reason a code never went out, phrased as something to do about it. */
+function undeliveredCode() {
+  return new Error(
+    "PreMan could not email a verification code, so there is nothing to enter. Try again shortly."
+  );
+}
+
 /**
  * Get a usable pm_live_ key: an explicit one, or by logging in / signing up
  * right here in the terminal. Always persists to ~/.preman/credentials.json.
@@ -758,8 +1004,26 @@ export async function authenticateTerminal(args) {
     return creds;
   }
 
-  const email = (args.value("--email", "") || await promptText("Email: ")).trim().toLowerCase();
+  // A key is minted per call, so a second `onboard` used to leave a second
+  // `PreMan MCP CLI (host)` key behind and ask for an email and a code to do
+  // it. Re-running setup is ordinary -- it is how anyone re-checks their own
+  // machine -- so a credential that still answers is the answer.
+  const reusable = await reusableCredentials(args);
+  if (reusable) {
+    process.stdout.write(`Already signed in as ${reusable.user_email}.\n`);
+    return reusable;
+  }
+
+  const supplied = args.value("--email", "");
+  const email = (supplied || (await promptText("Email: "))).trim().toLowerCase();
   if (!email) throw new Error("Email is required.");
+  // Nothing downstream validates this and the backend takes what it is given,
+  // so a mistyped address became an account with a code sent to somebody
+  // else's inbox. Deliberately permissive: the only job here is to catch the
+  // shapes that cannot be an address at all.
+  if (!/^[^\s@]+@[^\s@.]+\.[^\s@]+$/.test(email)) {
+    throw new Error(`${email} does not look like an email address.`);
+  }
 
   process.stdout.write(`Checking PreMan account for ${email}...\n`);
   const account = await callBackendJson(args, "GET", "/auth/needs-password", { query: { email } });
@@ -768,14 +1032,22 @@ export async function authenticateTerminal(args) {
   let session = { access_token: "", user: { email } };
 
   if (!account.exists) {
-    process.stdout.write("No PreMan account found. Creating one now.\n");
+    // Creating the account was the silent half of a fork the customer never
+    // chose: one typo in the domain and the next prompt asked for a code that
+    // had gone to an address they do not own, with an account left behind on
+    // it. The address is worth reading back before any of that happens.
+    if (!args.has("--yes") && !supplied && !(await confirmNewAccount(email))) {
+      throw new Error("Stopped before creating an account. Run it again with the right address.");
+    }
+    process.stdout.write(`No PreMan account found for ${email}. Creating one now.\n`);
     session = await createAccountFromTerminal(args, email);
   } else if (account.needs_password) {
     // No password on this account, so a code is the only way in.
     const password = await optionalPassword(args);
-    process.stdout.write("Sending a sign-in code to your email.\n");
+    process.stdout.write("This account signs in with an email code.\n");
     const resend = await callBackendJson(args, "POST", "/auth/resend-otp", { json: { email } });
     assertOk(resend, "resend OTP");
+    if (!reportCodeSent(resend, "Sign-in code sent. Check your email.")) throw undeliveredCode();
     const otp = await promptText("Verification code: ");
     session = await completeWithCode(args, email, otp, password);
   } else {
@@ -783,14 +1055,20 @@ export async function authenticateTerminal(args) {
     if (!password) {
       const resend = await callBackendJson(args, "POST", "/auth/resend-otp", { json: { email } });
       assertOk(resend, "resend OTP");
-      process.stdout.write("Sign-in code sent. Check your email.\n");
+      if (!reportCodeSent(resend, "Sign-in code sent. Check your email.")) throw undeliveredCode();
       const otp = await promptText("Verification code: ");
       session = await completeWithCode(args, email, otp, "");
     } else {
       const login = await callBackendJson(args, "POST", "/auth/login", {
         json: { email, password },
       });
-      if (!login.ok && login.status_code === 403 && String(login.detail || "").toLowerCase().includes("not verified")) {
+      // The backend now names this case in a `code` field. The prose test stays
+      // as the fallback, because a customer on an older deployment still has to
+      // be able to get past an unverified account.
+      const unverified =
+        login.code === "email_not_verified" ||
+        /not verified/i.test(describeFailure(login, ""));
+      if (!login.ok && login.status_code === 403 && unverified) {
         session = await verifyUnconfirmedAccount(args, email);
       } else {
         assertOk(login, "login");
@@ -882,6 +1160,49 @@ export function resolveApiKey(args) {
 export const LAUNCHER_COMMAND = "npm";
 export const LAUNCHER_ARGS = ["exec", "-y", "premanmcp@latest", "--"];
 
+/**
+ * How this platform has to be told to start the server.
+ *
+ * `npm` on Windows is `npm.cmd`, and a batch file is not an executable: a host
+ * that spawns the command directly -- which is what every MCP host does, none
+ * of them go through a shell -- fails with EINVAL before any of this code runs.
+ * The config therefore has to name the interpreter, and `cmd /c` is the form
+ * every Windows host accepts. Nothing changes anywhere else, so the constants
+ * stay the plain answer they have always been.
+ *
+ * The verifier reads this too. It used to compare the written command against
+ * LAUNCHER_COMMAND, which on Windows would have meant warning about a config
+ * that was right and accepting one that could not start.
+ */
+export function launcherFor(platform = process.platform) {
+  if (platform === "win32") {
+    return { command: "cmd", args: ["/c", LAUNCHER_COMMAND, ...LAUNCHER_ARGS] };
+  }
+  return { command: LAUNCHER_COMMAND, args: [...LAUNCHER_ARGS] };
+}
+
+/**
+ * The oldest Node that can run this CLI, checked wherever it is about to matter.
+ *
+ * `engines` in package.json is advice: npm prints a warning and installs
+ * anyway, so it stops nobody. The real floor is `fetch`, which arrived in Node
+ * 18 and which every backend call goes through -- on Node 16 the first of them
+ * dies with `fetch is not defined`, a message that names nothing a customer
+ * could act on and appears several steps into a walk rather than at the start.
+ * Only the MCP server preflight checked this; every other command did not.
+ */
+export const MIN_NODE_MAJOR = 18;
+
+export function nodeTooOld() {
+  const major = Number(process.versions.node.split(".")[0]);
+  if (!Number.isFinite(major) || major >= MIN_NODE_MAJOR) return "";
+  return (
+    `PreMan needs Node ${MIN_NODE_MAJOR} or newer. This is Node ${process.versions.node}.\n` +
+    `  Upgrade Node, then run the same command again.\n` +
+    `  With nvm: nvm install ${MIN_NODE_MAJOR} && nvm use ${MIN_NODE_MAJOR}\n`
+  );
+}
+
 export function buildServerConfig(args, { pairCode = "", codingAgent = "" } = {}) {
   const env = {
     PREMAN_BACKEND: backendUrl(args),
@@ -892,9 +1213,5 @@ export function buildServerConfig(args, { pairCode = "", codingAgent = "" } = {}
   if (pairCode) env.PREMAN_PAIR_CODE = pairCode;
   if (codingAgent) env.PREMAN_CODING_AGENT = codingAgent;
 
-  return {
-    command: LAUNCHER_COMMAND,
-    args: [...LAUNCHER_ARGS],
-    env,
-  };
+  return { ...launcherFor(), env };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "premanmcp",
-  "version": "1.1.11",
+  "version": "1.1.13",
   "description": "PreMan CLI and stdio proxy for PreMan's hosted MCP server",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "test:proxy": "node --test scripts/smoke-proxy.mjs",
     "test:connect": "node scripts/smoke-connect.mjs",
     "test:connect-heartbeat": "node scripts/smoke-connect-heartbeat.mjs",
-    "test:node": "node --test --test-timeout=90000 scripts/smoke-account.mjs scripts/smoke-agent-session.mjs scripts/smoke-agent-dock.mjs scripts/smoke-terminal-lifecycle.mjs scripts/smoke-cli-entrypoint.mjs scripts/smoke-cli-update.mjs scripts/smoke-launcher-config.mjs scripts/smoke-runner.mjs scripts/smoke-eval.mjs scripts/smoke-eval-run-watch.mjs scripts/smoke-eval-behaviors.mjs scripts/smoke-eval-runtime.mjs scripts/smoke-eval-entry.mjs scripts/smoke-eval-entry-placeholder.mjs scripts/smoke-eval-discover.mjs scripts/smoke-eval-templates.mjs scripts/smoke-eval-approval-record.mjs scripts/smoke-repo-config.mjs scripts/smoke-onboard.mjs scripts/smoke-onboard-opening.mjs scripts/smoke-local-detect.mjs scripts/smoke-agent-target.mjs scripts/smoke-prepush-hook.mjs scripts/smoke-cli-identity.mjs scripts/smoke-runner-heartbeat.mjs scripts/smoke-verify-prepush.mjs scripts/smoke-push-diff.mjs scripts/smoke-progress-reporter.mjs scripts/smoke-verify-plan.mjs scripts/smoke-install-desktop.mjs scripts/smoke-desktop-session.mjs scripts/smoke-api-tools.mjs scripts/smoke-tests-workbench.mjs scripts/smoke-bin-scope.mjs scripts/smoke-shared-errors.mjs scripts/smoke-process-title.mjs scripts/smoke-predict.mjs",
+    "test:node": "node --test --test-timeout=90000 scripts/smoke-account.mjs scripts/smoke-agent-session.mjs scripts/smoke-agent-dock.mjs scripts/smoke-terminal-lifecycle.mjs scripts/smoke-cli-entrypoint.mjs scripts/smoke-cli-update.mjs scripts/smoke-launcher-config.mjs scripts/smoke-runner.mjs scripts/smoke-eval.mjs scripts/smoke-eval-start.mjs scripts/smoke-eval-run-watch.mjs scripts/smoke-eval-behaviors.mjs scripts/smoke-eval-runtime.mjs scripts/smoke-eval-entry.mjs scripts/smoke-eval-entry-placeholder.mjs scripts/smoke-eval-discover.mjs scripts/smoke-eval-templates.mjs scripts/smoke-eval-approval-record.mjs scripts/smoke-repo-config.mjs scripts/smoke-onboard.mjs scripts/smoke-onboard-opening.mjs scripts/smoke-local-detect.mjs scripts/smoke-agent-target.mjs scripts/smoke-prepush-hook.mjs scripts/smoke-cli-identity.mjs scripts/smoke-runner-heartbeat.mjs scripts/smoke-verify-prepush.mjs scripts/smoke-push-diff.mjs scripts/smoke-progress-reporter.mjs scripts/smoke-verify-plan.mjs scripts/smoke-install-desktop.mjs scripts/smoke-desktop-session.mjs scripts/smoke-api-tools.mjs scripts/smoke-tests-workbench.mjs scripts/smoke-bin-scope.mjs scripts/smoke-shared-errors.mjs scripts/smoke-prompts.mjs scripts/smoke-process-title.mjs scripts/smoke-predict.mjs",
     "test:dmg": "node --test --test-timeout=300000 scripts/smoke-install-desktop-volume.mjs"
   },
   "devDependencies": {