premanmcp 1.0.0 → 1.0.1

package/bin/api_tools.js

@@ -9,7 +9,13 @@
 
 import { readFileSync } from "node:fs";
 
-import { callBackendJson, cliInvocation, makeArgs, resolveApiKey } from "./shared.js";
+import {
+  callBackendJson,
+  cliInvocation,
+  describeFailure,
+  makeArgs,
+  resolveApiKey,
+} from "./shared.js";
 import { printPlayground } from "./desktop.js";
 
 export const ENDPOINTS_HELP = `
@@ -61,22 +67,6 @@ const TOOL_ROUTES = {
   share_endpoints_with_ui: { method: "POST", path: "/cli/playground-session" },
 };
 
-/**
- * A failure a person can act on.
- *
- * FastAPI's `detail` is often an object, and interpolating one straight into a
- * template gives `[object Object]` — which is what a retired route reported for
- * a day, hiding both its status and its remedy.
- */
-function describeFailure(result) {
-  const detail = result.detail ?? result.message ?? result.raw;
-  if (typeof detail === "string" && detail) return detail;
-  if (detail && typeof detail === "object") {
-    return detail.message || detail.code || JSON.stringify(detail);
-  }
-  return "backend error";
-}
-
 export async function callTool(args, tool, toolArguments) {
   const token = resolveApiKey(args);
   if (!token) {

package/bin/cli.js

@@ -38,7 +38,12 @@ import { STATUS_HELP, statusCommand } from "./status.js";
 import { HOOK_HELP, hookCommand, installHook, scheduleHookRepair } from "./hook.js";
 import { RUNNER_HELP, runnerCommand } from "./runner.js";
 import { VERIFY_HELP, verifyCommand } from "./verify.js";
-import { DESKTOP_HELP, installDesktopCommand, openDesktopSignedIn } from "./desktop.js";
+import {
+  DESKTOP_HELP,
+  desktopAppRunning,
+  installDesktopCommand,
+  openDesktopSignedIn,
+} from "./desktop.js";
 import { ACCOUNT_HELP, doctorCommand, loginBrowser, logoutCommand, watchCommand } from "./account.js";
 import {
   CREDENTIALS_FILE,
@@ -150,7 +155,18 @@ Email: ${creds.user_email || "unknown"}
 Backend: ${creds.backend_url}
 API key: ${creds.api_key}
 Saved to: ${CREDENTIALS_FILE}
-
+`);
+  // `authenticateTerminal` has already left the session for the app to pick up,
+  // but only a launch reads it. Signing in here while the app is open otherwise
+  // changes nothing on screen, and the window carries on showing the previous
+  // account with no sign that a different one is now signed in.
+  if (desktopAppRunning()) {
+    process.stdout.write(
+      `\nPreMan is open and still signed in as before.\n` +
+        `  Quit and reopen it to switch${creds.user_email ? ` to ${creds.user_email}` : ""}.\n`
+    );
+  }
+  process.stdout.write(`
 You can now run:
   ${cli} connect
 `);

package/bin/desktop.js

@@ -103,6 +103,53 @@ export function desktopAppInstalled(destination = "/Applications") {
   return process.platform === "darwin" && existsSync(installedAppPath(destination));
 }
 
+/**
+ * Is a copy of the app already up?
+ *
+ * This decides whether a handoff is possible at all. `open` on a running app
+ * raises the window it already has instead of starting a process, and the
+ * session file is only read at launch -- so a running app cannot take up a
+ * session no matter how long the CLI waits for it to. Without this check the
+ * CLI waited out the full timeout and then reported the failure as though the
+ * app were merely old, which left people looking at whichever account the app
+ * was already showing with nothing to explain it.
+ *
+ * Matched on the bundle's own executable directory. The helper processes live
+ * under `Contents/Frameworks/...` and so do not match, which keeps this to the
+ * one process whose launch reads the file.
+ */
+export function desktopAppRunning(destination = "/Applications") {
+  if (process.platform !== "darwin") return false;
+  const binary = path.join(installedAppPath(destination), "Contents", "MacOS");
+  const found = spawnSync("pgrep", ["-f", binary], { encoding: "utf8" });
+  return found.status === 0 && String(found.stdout || "").trim() !== "";
+}
+
+/**
+ * Ask the app to quit, and wait for it to actually be gone.
+ *
+ * Only ever a graceful `quit`: this runs while someone is watching a setup walk,
+ * and a tool that kills an app to save three seconds is not one people leave
+ * installed. A copy that ignores the request keeps running and the caller says
+ * so rather than escalating.
+ */
+export async function quitDesktopApp({
+  destination = "/Applications",
+  timeoutMs = 8_000,
+  sleep = defaultSleep,
+} = {}) {
+  if (!desktopAppRunning(destination)) return "not-running";
+  spawnSync("osascript", ["-e", `quit app "${APP_NAME.replace(/\.app$/i, "")}"`], {
+    stdio: "ignore",
+  });
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    await sleep(250);
+    if (!desktopAppRunning(destination)) return "quit";
+  }
+  return "still-running";
+}
+
 /**
  * Hand the account the CLI just signed in to over to the desktop app.
  *
@@ -165,28 +212,56 @@ export function clearDesktopSession() {
  * all would otherwise be reported as signed in while the customer looks at a
  * login screen. The file is left behind on timeout -- it expires on its own, and
  * a slow first launch can still find it.
+ *
+ * An app that is already running is the one case where waiting cannot help,
+ * because only a launch reads the file. `restartIfRunning` is how a caller whose
+ * whole purpose is to leave someone signed in asks for the restart that makes
+ * the handoff possible; callers that are only opening a window leave it off and
+ * get told the session was not taken up.
  */
 export async function openDesktopSignedIn(
   creds,
-  { destination = "/Applications", waitMs = 12_000, sleep = defaultSleep } = {}
+  {
+    destination = "/Applications",
+    waitMs = 12_000,
+    sleep = defaultSleep,
+    restartIfRunning = false,
+    // Injected the same way `sleep` is, so the running/quitting branches can be
+    // exercised without a real app on the machine running the tests.
+    isRunning = desktopAppRunning,
+    quit = quitDesktopApp,
+  } = {}
 ) {
   if (!desktopAppInstalled(destination)) {
     return { state: "not-installed" };
   }
+  const wasRunning = isRunning(destination);
+  let restarted = false;
+  if (wasRunning && restartIfRunning) {
+    restarted = (await quit({ destination, sleep })) === "quit";
+  }
   const handoff = writeDesktopSession(creds);
   // The bundle path rather than the name: `open -a PreMan` asks LaunchServices,
   // which may well pick a different copy than the one just installed.
   spawn("open", ["-a", installedAppPath(destination)], { stdio: "ignore", detached: true }).unref();
   if (handoff.state !== "written") return { state: "opened", handoff: handoff.state };
 
+  if (wasRunning && !restarted) {
+    // Nothing is going to read the file, so the timeout would only be a slower
+    // way to reach this same answer. The session is deliberately left on disk:
+    // it is what the next launch adopts, which is exactly what the customer is
+    // about to be told to do.
+    return { state: "opened-already-running", handoff: handoff.state };
+  }
+
   const deadline = Date.now() + waitMs;
   while (Date.now() < deadline) {
     await sleep(500);
     if (!existsSync(DESKTOP_SESSION_FILE)) {
-      return { state: "opened-signed-in", handoff: handoff.state };
+      return { state: "opened-signed-in", handoff: handoff.state, restarted };
     }
   }
-  return { state: "opened-not-adopted", handoff: handoff.state };
+  return { state: "opened-not-adopted", handoff: handoff.state, restarted };
 }
 
 const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

package/bin/integrations.js

@@ -493,14 +493,32 @@ async function showDesktopSignedIn(openDesktopSignedIn, args, creds, stopOpening
   // The same --dest the install honoured, or the launch would look for the app
   // somewhere it was never copied to.
   const destination = args.value("--dest", "/Applications");
-  const opened = await openDesktopSignedIn(creds, { destination });
+  // This step exists to end with someone looking at PreMan as the account the
+  // walk just signed in to. A copy that is already running only reads a session
+  // when it starts, so restarting it is the difference between doing that and
+  // handing back a window still showing whoever was signed in before.
+  const opened = await openDesktopSignedIn(creds, { destination, restartIfRunning: true });
   stopOpening?.();
+  const email = String(creds?.user_email || creds?.user?.email || "").trim();
   if (opened.state === "opened-signed-in") {
-    process.stdout.write("Opened PreMan, signed in as this account.\n");
+    process.stdout.write(
+      opened.restarted
+        ? "PreMan was already open \u2014 restarted it, signed in as this account.\n"
+        : "Opened PreMan, signed in as this account.\n"
+    );
   } else if (opened.state === "not-installed") {
     process.stdout.write(
       `PreMan is not in ${destination} yet \u2014 open it once installed and sign in.\n`
     );
+  } else if (opened.state === "opened-already-running") {
+    // The window on screen belongs to an earlier session, and nothing about it
+    // says so. Name the account being switched to, and the one action that
+    // completes the switch -- the session is on disk and the next launch takes
+    // it up, so quitting really is all that is left to do.
+    process.stdout.write(
+      `PreMan was already open and kept its previous sign-in.\n` +
+        `  Quit and reopen it to switch${email ? ` to ${email}` : ""}.\n`
+    );
   } else {
     // Either the session could not be handed over or this app is too old to take
     // it up. Say so rather than let the customer wonder why they are looking at

package/bin/shared.js

@@ -430,10 +430,33 @@ export async function callBackendJson(
   };
 }
 
+/**
+ * Turn a backend error body into something a person can act on.
+ *
+ * FastAPI's ``detail`` is a string on a raised HTTPException, an array of
+ * ``{loc, msg}`` objects on a validation error, and occasionally an object with
+ * its own shape. Interpolating it directly renders the two useful cases as
+ * ``[object Object]``, which is how "this route is gone, call /cli/endpoints
+ * instead" reached a customer as `410 [object Object]` -- a remedy the response
+ * carried and the screen never showed.
+ */
+export function describeFailure(result, fallback = "backend error") {
+  const detail = result?.detail ?? result?.message ?? result?.raw;
+  if (typeof detail === "string" && detail) return detail;
+  if (Array.isArray(detail) && detail.length) {
+    return detail.map((item) => item?.msg || JSON.stringify(item)).join("; ");
+  }
+  if (detail && typeof detail === "object") {
+    return detail.message || detail.error || detail.code || JSON.stringify(detail);
+  }
+  return fallback;
+}
+
 export function assertOk(result, action) {
   if (result.ok) return;
-  const detail = result.detail || result.message || result.raw || `${action} failed`;
-  throw new Error(`${action} failed: ${result.status_code} ${detail}`);
+  throw new Error(
+    `${action} failed: ${result.status_code} ${describeFailure(result, `${action} failed`)}`
+  );
 }
 
 function authSessionFrom(result, email) {

package/bin/status.js

@@ -6,7 +6,15 @@
  * section as possibly empty.
  */
 
-import { backendUrl, callBackendJson, cliInvocation, makeArgs, resolveApiKey, truncate } from "./shared.js";
+import {
+  backendUrl,
+  callBackendJson,
+  cliInvocation,
+  describeFailure,
+  makeArgs,
+  resolveApiKey,
+  truncate,
+} from "./shared.js";
 
 export const STATUS_HELP = `
 Status options:
@@ -225,8 +233,10 @@ export async function statusCommand(commandArgs = []) {
   });
 
   if (!result.ok) {
-    const detail = result.detail || result.raw || "request failed";
-    throw new Error(`could not read status from ${backendUrl(args)}: ${result.status_code} ${detail}`);
+    throw new Error(
+      `could not read status from ${backendUrl(args)}: ${result.status_code} ` +
+        describeFailure(result, "request failed")
+    );
   }
 
   const { status_code, ok, ...payload } = result;

package/bin/tests.js

@@ -6,7 +6,13 @@
  * scenarios for one endpoint via `POST /cli/tests/generate`.
  */
 
-import { callBackendJson, cliInvocation, makeArgs, resolveApiKey } from "./shared.js";
+import {
+  callBackendJson,
+  cliInvocation,
+  describeFailure,
+  makeArgs,
+  resolveApiKey,
+} from "./shared.js";
 
 export const TESTS_HELP = `
 Collections tests:
@@ -62,17 +68,7 @@ function printJson(value) {
   process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
 
-function errorDetail(result) {
-  const detail = result.detail;
-  if (typeof detail === "string") return detail;
-  if (Array.isArray(detail)) {
-    return detail.map((item) => item.msg || JSON.stringify(item)).join("; ");
-  }
-  if (detail && typeof detail === "object") {
-    return detail.message || detail.error || JSON.stringify(detail);
-  }
-  return result.message || result.raw || "backend error";
-}
+const errorDetail = (result) => describeFailure(result);
 
 async function workbench(args, method, routePath, { json } = {}) {
   const token = requireKey(args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "premanmcp",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "PreMan CLI and stdio proxy for PreMan's hosted MCP server",
   "type": "module",
   "bin": {