premanmcp 1.0.1 → 1.0.3

package/bin/desktop.js

@@ -133,9 +133,16 @@ export function desktopAppRunning(destination = "/Applications") {
  * installed. A copy that ignores the request keeps running and the caller says
  * so rather than escalating.
  */
+// Longer than the app allows its own shutdown, which is fifteen seconds of
+// waiting for the runner's last calls to PreMan. Giving up first is not a
+// neutral act: what follows is a launch, and a launch that lands while the old
+// instance still holds the single-instance lock is delivered to that instance
+// rather than starting a new one.
+const QUIT_TIMEOUT_MS = 20_000;
+
 export async function quitDesktopApp({
   destination = "/Applications",
-  timeoutMs = 8_000,
+  timeoutMs = QUIT_TIMEOUT_MS,
   sleep = defaultSleep,
 } = {}) {
   if (!desktopAppRunning(destination)) return "not-running";
@@ -230,6 +237,7 @@ export async function openDesktopSignedIn(
     // exercised without a real app on the machine running the tests.
     isRunning = desktopAppRunning,
     quit = quitDesktopApp,
+    launch = defaultLaunch,
   } = {}
 ) {
   if (!desktopAppInstalled(destination)) {
@@ -241,9 +249,18 @@ export async function openDesktopSignedIn(
     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();
+
+  // Asked to go and still here. Launching now does not start anything: the old
+  // instance holds the single-instance lock until it actually exits, so the
+  // launch reaches it as a second-instance and it re-shows the window it was in
+  // the middle of dismantling -- which is how onboarding ended on a black
+  // rectangle. Nothing here can hurry it, and the session on disk is what the
+  // next launch adopts, so saying so beats making it worse.
+  if (wasRunning && restartIfRunning && !restarted) {
+    return { state: "opened-already-running", handoff: handoff.state };
+  }
+
+  launch(destination);
   if (handoff.state !== "written") return { state: "opened", handoff: handoff.state };
 
   if (wasRunning && !restarted) {
@@ -266,6 +283,14 @@ export async function openDesktopSignedIn(
 
 const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
+// The bundle path rather than the name: `open -a PreMan` asks LaunchServices,
+// which may well pick a different copy than the one just installed.
+const defaultLaunch = (destination) =>
+  spawn("open", ["-a", installedAppPath(destination)], {
+    stdio: "ignore",
+    detached: true,
+  }).unref();
+
 /**
  * Open a Playground session URL in PreMan.app on macOS when it is installed.
  * Windows/Linux (and Mac without the app) get the website URL printed instead.

package/bin/integrations.js

@@ -15,8 +15,10 @@
  */
 
 import { describeCheckout, explainNoCheckout, resolveCheckout } from "./repo.js";
+import { desktopAppInstalled, writeDesktopSession } from "./desktop.js";
 import {
   DEFAULT_BACKEND,
+  askWhileWaiting,
   assertOk,
   backendUrl,
   callBackendJson,
@@ -115,37 +117,58 @@ export class Unrecoverable extends Error {}
  * Returns the truthy value from ``check``, or null on timeout. Ordinary
  * exceptions are swallowed and retried; :class:`Unrecoverable` stops the wait.
  */
+const NOT_ANSWERED = Symbol("not answered");
+
 async function waitFor(
   label,
   check,
-  { hint = "", hintAfterMs = 60000, timeoutMs = POLL_TIMEOUT_MS } = {}
+  { hint = "", hintAfterMs = 60000, timeoutMs = POLL_TIMEOUT_MS, escape = null } = {}
 ) {
   const startedAt = Date.now();
   const deadline = startedAt + timeoutMs;
   let hinted = false;
+  let asked = null;
   process.stdout.write(`Waiting for ${label}`);
-  while (Date.now() < deadline) {
-    try {
-      const done = await check();
-      if (done) {
-        process.stdout.write(" done.\n");
-        return done;
+  try {
+    while (Date.now() < deadline) {
+      try {
+        const done = await check();
+        if (done) {
+          process.stdout.write(asked ? "\n" : " done.\n");
+          return done;
+        }
+      } catch (err) {
+        if (err instanceof Unrecoverable) {
+          process.stdout.write("\n");
+          throw err;
+        }
+        /* keep waiting; the customer is elsewhere */
       }
-    } catch (err) {
-      if (err instanceof Unrecoverable) {
-        process.stdout.write("\n");
-        throw err;
+      // A minute of dots is indistinguishable from a hang, and the reason this
+      // waits forever is usually something the customer can act on.
+      if (hint && !hinted && Date.now() - startedAt > hintAfterMs) {
+        hinted = true;
+        process.stdout.write(`\n${hint}\n`);
+        // Dots and a question cannot share a line. Once there is something to
+        // answer, the answering is the whole of what this is doing.
+        if (escape) asked = askWhileWaiting(escape.question);
+        else process.stdout.write("Still waiting");
+      }
+      if (!asked) process.stdout.write(".");
+      // Polling carries on underneath the question, so an install that lands
+      // while it is on the screen still ends this the way it should.
+      const answer = await Promise.race([
+        new Promise((resolve) => setTimeout(() => resolve(NOT_ANSWERED), POLL_INTERVAL_MS)),
+        asked ? asked.reply : new Promise(() => {}),
+      ]);
+      if (answer !== NOT_ANSWERED) {
+        escape.answer = typeof answer === "string" ? answer : "";
+        return null;
       }
-      /* keep waiting; the customer is elsewhere */
-    }
-    // A minute of dots is indistinguishable from a hang, and the reason this
-    // waits forever is usually something the customer can act on.
-    if (hint && !hinted && Date.now() - startedAt > hintAfterMs) {
-      hinted = true;
-      process.stdout.write(`\n${hint}\nStill waiting`);
     }
-    process.stdout.write(".");
-    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  } finally {
+    // Whichever side won, the question goes when the wait does.
+    asked?.cancel();
   }
   process.stdout.write("\n");
   return null;
@@ -254,7 +277,7 @@ export async function awsCommand(args) {
 // GitHub
 // ---------------------------------------------------------------------------
 
-export async function githubCommand(args) {
+export async function githubCommand(args, { ensureDesktopApp = null } = {}) {
   const token = requireKey(args);
 
   // This route answers with a bare array; callBackendJson exposes it as `list`.
@@ -265,15 +288,24 @@ export async function githubCommand(args) {
 
   const seen = new Set((await listRepos()).map((r) => r.id));
 
-  // `return_to: "desktop"` because the person who ran this is in a terminal and
-  // the CLI is already polling for the installation. The web return 302s the
-  // tab into the hosted dashboard � an app they did not ask for, on whichever
-  // environment owns the App's setup URL. The desktop return finishes on a page
-  // that offers PreMan and says the tab may be closed, which is all the browser
-  // still has to do here.
+  // The desktop return is the right ending for a run started in a terminal: the
+  // CLI is already polling for the installation, and the web return 302s the
+  // tab into the hosted dashboard — an app they did not ask for, on whichever
+  // environment owns the App's setup URL.
+  //
+  // What it must never be is unconditional. That page's only action is a
+  // preman:// link, and a machine with no app answers one with a system dialog
+  // reading "There is no application set to open the URL preman://open". That is
+  // where a first run actually ended, every time: the app installs at the end of
+  // this walk and GitHub is asked about in the middle, so by the time this link
+  // was minted there had never been an app. A caller may put one there first;
+  // without one, the web return is the only ending that leads anywhere.
+  const hasDesktopApp = ensureDesktopApp
+    ? await ensureDesktopApp()
+    : desktopAppInstalled(args.value("--dest", "/Applications"));
   const started = await callBackendJson(args, "POST", "/integrations/github/app/install", {
     token,
-    json: { return_to: "desktop" },
+    json: { return_to: hasDesktopApp ? "desktop" : "web" },
   });
   assertOk(started, "start GitHub install");
 
@@ -290,37 +322,64 @@ export async function githubCommand(args) {
   // a success carrying no repositories means the App is installed and sharing
   // nothing — two dead ends that are indistinguishable from the repository list.
   let refresh = null;
-  const done = await waitFor(
-    "the installation",
-    async () => {
-      // Installing the App and having repositories appear are two events: the
-      // callback records the installation, and a refresh materialises the repos.
-      // Polling the repo list alone waits for something that may never arrive on
-      // its own.
-      refresh = await callBackendJson(args, "POST", "/integrations/github/app/refresh", {
-        token,
-        json: {},
-      });
-      // Compare against what existed before, so a user who already had repos
-      // connected is not told they are done the moment polling starts.
-      const fresh = (await listRepos()).filter((r) => !seen.has(r.id));
-      return fresh.length ? fresh : null;
-    },
-    {
-      timeoutMs: Number(process.env.PREMAN_GITHUB_POLL_MS) || GITHUB_POLL_TIMEOUT_MS,
-      hintAfterMs: 20000,
-      hint: "Still nothing from GitHub — confirm a repository to come back here.",
-    }
-  );
+  const lookForRepos = async () => {
+    // Installing the App and having repositories appear are two events: the
+    // callback records the installation, and a refresh materialises the repos.
+    // Polling the repo list alone waits for something that may never arrive on
+    // its own.
+    refresh = await callBackendJson(args, "POST", "/integrations/github/app/refresh", {
+      token,
+      json: {},
+    });
+    // Compare against what existed before, so a user who already had repos
+    // connected is not told they are done the moment polling starts.
+    const fresh = (await listRepos()).filter((r) => !seen.has(r.id));
+    return fresh.length ? fresh : null;
+  };
+
+  // Waiting is the right default, because the install usually lands inside it.
+  // What it cannot be is the only thing on offer. Somebody who picked no
+  // repository, or installed onto an organisation where an owner has to approve
+  // it first, is watching dots for an event that is not coming, and the only
+  // way out of that was to guess that Ctrl-C here was safe.
+  const escape = {
+    question:
+      "Have you saved the repository selection on GitHub? [y/n, or Enter to keep waiting]: ",
+    answer: null,
+  };
+  let done = await waitFor("the installation", lookForRepos, {
+    timeoutMs: Number(process.env.PREMAN_GITHUB_POLL_MS) || GITHUB_POLL_TIMEOUT_MS,
+    hintAfterMs: Number(process.env.PREMAN_GITHUB_HINT_MS) || 20000,
+    hint: "Still nothing from GitHub — confirm a repository to come back here.",
+    escape,
+  });
+
+  // A yes buys one more look, not one more minute. The callback lands while the
+  // question is still on the screen often enough to be worth asking again, and
+  // if it has not by now, more dots will not change that.
+  if (!done && affirmative(escape.answer)) {
+    done = await lookForRepos().catch(() => null);
+  }
 
   if (!done) {
-    process.stdout.write(githubHandOff(args, refresh));
+    process.stdout.write(githubHandOff(args, refresh, escape.answer));
     return;
   }
   connected(`GitHub connected: ${done.length} repository(ies).`);
   for (const repo of done.slice(0, 5)) process.stdout.write(`  - ${repo.repo_url}\n`);
 }
 
+/**
+ * Whether a free-text reply means yes.
+ *
+ * Silence is not consent anywhere else in this walk and it is not here either:
+ * only an explicit yes counts, and everything else is left for later.
+ */
+function affirmative(answer) {
+  const said = (answer || "").trim().toLowerCase();
+  return said === "y" || said === "yes";
+}
+
 /**
  * Stop waiting, and name the dead end instead of the timeout.
  *
@@ -328,7 +387,16 @@ export async function githubCommand(args) {
  * finishes in the browser whether this process is watching or not, and the two
  * ways it can complete and still leave PreMan with nothing are both actionable.
  */
-function githubHandOff(args, refresh) {
+function githubHandOff(args, refresh, answer = null) {
+  // A no is a decision, not a dead end. Reporting it as one would be telling
+  // somebody that something went wrong immediately after they said they had
+  // simply not done it yet.
+  if (answer !== null && !affirmative(answer)) {
+    return (
+      `Left for later, and nothing here is broken.\n` +
+      `  Connect it whenever you like with '${cliInvocation()} github'.\n`
+    );
+  }
   const installed = Boolean(refresh?.ok) && Number(refresh.installations_refreshed || 0) > 0;
   if (installed) {
     return (
@@ -590,6 +658,12 @@ async function askStep(question, { assumeYes, canGoBack, defaultYes = true }) {
  * only step that asks nothing: by then every decision is made, and a download is
  * something to leave running, not something to make someone watch first.
  *
+ * With one exception, and it is not a preference. Connecting a repository ends
+ * with GitHub handing the browser back through a preman:// link, and a machine
+ * with no app answers that with a system dialog rather than a window. So saying
+ * yes to the repository pulls the download forward to just before it; saying no
+ * leaves the order exactly as described above.
+ *
  * The steps themselves live in connect/guide.js, which is also what
  * `preman connect --guide` runs. Two walks that asked the same questions in
  * different words with different defaults was the thing worth deleting.
@@ -631,6 +705,43 @@ export async function onboardCommand(
   // is said in one place rather than before PreMan has looked at the code.
   const checkout = await resolveCheckout(args, resolveApiKey(args));
 
+  // What the app install did, once, shared by the step that needs an app to
+  // exist and the step that owns installing one.
+  //
+  // GitHub's callback ends on a page whose only action is a preman:// link, and
+  // the app is the last step of this walk — so a first run always handed GitHub
+  // back to a machine with nothing to open it with, and macOS said so in a
+  // dialog. The download moves in front of that step when it is needed and stays
+  // where it was when it is not: someone who declines the repository never
+  // reaches this, and still gets the app at the end.
+  //
+  // Memoised because it is a hundred megabytes and both callers want the same
+  // copy of it. Answers whether there is now an app on this machine, which is
+  // the only part either caller can act on.
+  let desktopInstall = null;
+  const installedNow = (result) => result?.state === "installed" || result?.state === "current";
+  const ensureDesktopApp = async ({ onInstalled } = {}) => {
+    const already = desktopPrecheck(args);
+    if (already?.state === "installed") return true;
+    // --no-desktop, or a platform with no build. Nothing to install here, and so
+    // nothing that could ever answer a preman:// link either.
+    if (already) return false;
+    if (!desktopInstall) {
+      process.stdout.write(
+        "Getting the PreMan app first, so GitHub has somewhere to hand you back to.\n"
+      );
+      desktopInstall = await runDesktopInstall(args, {
+        install: () => installDesktop([...commandArgs], onInstalled ? { onInstalled } : undefined),
+      });
+      // Handed the session the moment it lands, before anything can launch it.
+      // The app reads one only when it starts, and the callback's deep link is a
+      // start — without this it opens on a login screen for an account signed in
+      // ninety seconds ago.
+      if (installedNow(desktopInstall)) writeDesktopSession(creds);
+    }
+    return installedNow(desktopInstall);
+  };
+
   const steps = [
     {
       // No question. Everything below is a decision about code PreMan has not
@@ -672,7 +783,7 @@ export async function onboardCommand(
         return `Connect ${checkout.slug} so PreMan can open pull requests for the ${found} endpoint${found === 1 ? "" : "s"} it just mapped?`;
       },
       run: async () => {
-        await githubCommand(args);
+        await githubCommand(args, { ensureDesktopApp });
         // Finishing the App install is not the same as this repository being
         // connected: the install shares whichever repositories the customer
         // picked, which may not include this one. Re-asking is the difference
@@ -783,66 +894,55 @@ export async function onboardCommand(
   // and someone who already has the app does not watch it download again — both
   // of which happened when the check came after.
   const desktop = desktopPrecheck(args);
-  if (desktop?.state === "installed") {
+  if (desktop?.state === "installed" || !desktop) {
     steps.push({
       name: "Desktop app",
-      // Nothing to download, which is the point of this branch. It is not a
-      // reason to stop at the sentence: the step exists to leave the customer
-      // looking at PreMan, so the one run with nothing to install was also the
-      // only run that opened nothing, and it closed by sending someone to a
-      // website instead of the app already sitting on their machine.
+      // No question. See offerDesktop in connect/guide.js for why the ask went
+      // away; `--no-desktop` is the way past it.
+      //
+      // Installing and launching used to be one thing here, which is why the one
+      // run with nothing to install was also the only run that opened nothing: it
+      // stopped at the sentence and sent someone to a website instead of the app
+      // already sitting on their machine. They are two things now, and the
+      // install may have happened further up the walk, so this step is the launch
+      // and ensureDesktopApp decides whether anything is left to download.
       run: async () => {
-        process.stdout.write(`${MARK.ok()} PreMan desktop app already installed.\n`);
-        const stopOpening = showOpeningDesktop();
+        // Said only when this walk did not just download it. After an install of
+        // our own, announcing that it is already installed is the walk telling
+        // somebody about their own last thirty seconds.
+        if (!desktopInstall && desktopPrecheck(args)?.state === "installed") {
+          process.stdout.write(`${MARK.ok()} PreMan desktop app already installed.\n`);
+        }
+        let stopOpening = null;
         try {
+          const ready = await ensureDesktopApp({
+            onInstalled: () => {
+              stopOpening ??= showOpeningDesktop();
+            },
+          });
+          if (!ready) {
+            if (desktopInstall?.state === "unsupported") {
+              // Not a failure: the download link has already been printed, and
+              // the account this step exists to create is finished either way.
+              process.stdout.write("Sign in there with the account you just used.\n");
+            }
+            // A failed install already said so through runDesktopInstall, and its
+            // state is what keeps this out of the summary as a skip.
+            return desktopInstall || { state: "skipped" };
+          }
+          stopOpening ??= showOpeningDesktop();
           return {
+            ...(desktopInstall || {}),
+            // Onboarding installs *and* hands the fresh session over, so the app
+            // opens already signed in rather than on a login screen for the
+            // account created ninety seconds ago.
             appOpened: await showDesktopSignedIn(openDesktopSignedIn, args, creds, stopOpening),
           };
         } finally {
-          stopOpening();
+          stopOpening?.();
         }
       },
     });
-  } else if (!desktop) {
-    steps.push({
-      name: "Desktop app",
-      // No question. See offerDesktop in connect/guide.js for why the ask went
-      // away; `--no-desktop` is the way past it.
-      run: () =>
-        runDesktopInstall(args, {
-          // Onboarding installs *and* hands the fresh session over, so the app
-          // opens already signed in rather than on a login screen for the
-          // account created ninety seconds ago.
-          install: async () => {
-            let stopOpening = null;
-            try {
-              const installed = await installDesktop([...commandArgs], {
-                onInstalled: () => {
-                  stopOpening ??= showOpeningDesktop();
-                },
-              });
-              if (installed?.state === "unsupported") {
-                // Not a failure: the download link has already been printed, and
-                // the account this step exists to create is finished either way.
-                process.stdout.write("Sign in there with the account you just used.\n");
-                return installed;
-              }
-              stopOpening ??= showOpeningDesktop();
-              return {
-                ...installed,
-                appOpened: await showDesktopSignedIn(
-                  openDesktopSignedIn,
-                  args,
-                  creds,
-                  stopOpening
-                ),
-              };
-            } finally {
-              stopOpening?.();
-            }
-          },
-        }),
-    });
   }
 
   // Outcome per step rather than three lists, so revisiting a step replaces its

package/bin/shared.js

@@ -321,6 +321,48 @@ export async function promptText(question) {
   }
 }
 
+/**
+ * Ask a question that whatever we are waiting for may answer first.
+ *
+ * Returns the reply and a `cancel` for when it arrives too late to matter. A
+ * plain promptText cannot be raced: abandoning its promise leaves the readline
+ * interface open, an open interface holds stdin, and stdin holds the process
+ * open with it -- so a wait that ended on its own would sit there afterwards on
+ * a question nobody needed answering.
+ *
+ * Where there is no terminal there is nobody to ask, so the reply is a promise
+ * that never settles. A race is then decided entirely by the other side, which
+ * is how an unattended run goes on behaving like one.
+ */
+export function askWhileWaiting(question) {
+  const nobodyThere =
+    !process.stdin.isTTY || process.stdin.readableEnded || process.stdin.destroyed;
+  if (nobodyThere) return { reply: new Promise(() => {}), cancel: () => {} };
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  let cancelled = false;
+  let settle = null;
+  const reply = new Promise((resolve) => {
+    settle = (value) => {
+      if (settle.done) return;
+      settle.done = true;
+      resolve(value);
+    };
+  });
+  rl.question(question).then(
+    (value) => settle(value.trim()),
+    () => settle("")
+  );
+  rl.once("close", () => settle(cancelled ? null : ""));
+  return {
+    reply,
+    cancel: () => {
+      cancelled = true;
+      rl.close();
+    },
+  };
+}
+
 export async function promptSecret(question) {
   if (!process.stdin.isTTY || !process.stdin.setRawMode) {
     return promptText(question);

package/bin/verify.js

@@ -27,7 +27,7 @@ import { changedFilesForPush, readChangedFiles, readPushRefsFromStdin, repoRoot
 import { missingMountPrefix, resolveLocalTarget } from "./detect.js";
 import { formatDashboardLink, formatPushLink } from "./link.js";
 import { createReporter } from "./progress.js";
-import { backendUrl, callBackendJson, cliInvocation, frontendUrl, makeArgs, nowMs, resolveApiKey } from "./shared.js";
+import { backendUrl, callBackendJson, cliInvocation, describeFailure, frontendUrl, makeArgs, nowMs, resolveApiKey } from "./shared.js";
 
 export const VERIFY_HELP = `
 Verify options:
@@ -250,7 +250,11 @@ async function fetchInventory(args, token) {
     if (!result.ok) {
       return {
         endpoints,
-        error: result.detail || `status ${result.status_code}`,
+        // FastAPI answers a rejected request with an object, and a validation
+        // error with an array of them. Interpolated straight into the skip
+        // line, both read as "[object Object]" -- which is what every push
+        // against a backend that said no has printed.
+        error: describeFailure(result, `status ${result.status_code}`),
       };
     }
 

package/package.json

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

package/dist/auth_flow_ui.d.ts

@@ -1,38 +0,0 @@
-/**
- * Auth flow endpoints (signup, verify OTP, login, resend OTP) with JSON schemas
- * for share_endpoints_with_ui / agent-sessions push.
- */
-export type AuthFlowEndpoint = {
-    method: string;
-    path_template: string;
-    description: string;
-    tags: string[];
-    source_file: string;
-    request_body_schema: Record<string, unknown>;
-    response_schema: Record<string, unknown>;
-    mcp_tool?: string;
-};
-/** Core auth endpoints aligned with routes/auth/routes.py and user_auth_* MCP tools. */
-export declare function buildAuthFlowEndpoints(): AuthFlowEndpoint[];
-export type ShareAuthFlowResult = {
-    session_id: string;
-    url: string;
-    endpoint_count: number;
-    user_id: number | null;
-    auto_discoverable: boolean;
-    upstream_base_url: string;
-    endpoints: AuthFlowEndpoint[];
-    ui: {
-        url: string;
-        note: string;
-    };
-    related_tools: string[];
-};
-export declare function shareAuthFlowToUi(opts: {
-    backendUrl: string;
-    frontendUrl: string;
-    upstreamBaseUrl?: string;
-    sessionId?: string;
-    intent?: string;
-    apiKey?: string;
-}): Promise<ShareAuthFlowResult>;

package/dist/auth_flow_ui.js

@@ -1,170 +0,0 @@
-/**
- * Auth flow endpoints (signup, verify OTP, login, resend OTP) with JSON schemas
- * for share_endpoints_with_ui / agent-sessions push.
- */
-const EMAIL_PROP = { type: "string", format: "email", description: "User email" };
-const PASSWORD_PROP = {
-    type: "string",
-    minLength: 6,
-    description: "Password (min 6 characters on the server)",
-};
-const OTP_PROP = { type: "string", description: "6-digit code from email" };
-const TOKEN_RESPONSE = {
-    type: "object",
-    properties: {
-        access_token: { type: "string", description: "JWT bearer token" },
-        token_type: { type: "string", enum: ["bearer"] },
-        user: {
-            type: "object",
-            properties: {
-                id: { type: "string" },
-                email: { type: "string", format: "email" },
-            },
-            required: ["id", "email"],
-        },
-    },
-    required: ["access_token", "token_type", "user"],
-};
-const OTP_SENT_RESPONSE = {
-    type: "object",
-    properties: {
-        message: { type: "string" },
-        email_sent: { type: "boolean" },
-    },
-    required: ["message", "email_sent"],
-};
-/** Core auth endpoints aligned with routes/auth/routes.py and user_auth_* MCP tools. */
-export function buildAuthFlowEndpoints() {
-    return [
-        {
-            method: "POST",
-            path_template: "/auth/signup",
-            description: "Register with email and password. Sends OTP to email; next: verify-otp.",
-            tags: ["auth", "signup"],
-            source_file: "routes/auth/routes.py",
-            mcp_tool: "user_auth_signup",
-            request_body_schema: {
-                type: "object",
-                properties: { email: EMAIL_PROP, password: PASSWORD_PROP },
-                required: ["email", "password"],
-                additionalProperties: false,
-            },
-            response_schema: {
-                type: "object",
-                properties: {
-                    message: { type: "string" },
-                    user_id: { type: "string" },
-                    email: { type: "string", format: "email" },
-                    email_sent: { type: "boolean" },
-                },
-                required: ["message", "user_id", "email", "email_sent"],
-            },
-        },
-        {
-            method: "POST",
-            path_template: "/auth/verify-otp",
-            description: "Verify email OTP after signup; returns JWT access_token.",
-            tags: ["auth", "otp"],
-            source_file: "routes/auth/routes.py",
-            mcp_tool: "user_auth_verify_otp",
-            request_body_schema: {
-                type: "object",
-                properties: { email: EMAIL_PROP, otp: OTP_PROP },
-                required: ["email", "otp"],
-                additionalProperties: false,
-            },
-            response_schema: TOKEN_RESPONSE,
-        },
-        {
-            method: "POST",
-            path_template: "/auth/login",
-            description: "Login with email and password. Returns access_token if email is verified.",
-            tags: ["auth", "login"],
-            source_file: "routes/auth/routes.py",
-            mcp_tool: "user_auth_login",
-            request_body_schema: {
-                type: "object",
-                properties: { email: EMAIL_PROP, password: PASSWORD_PROP },
-                required: ["email", "password"],
-                additionalProperties: false,
-            },
-            response_schema: TOKEN_RESPONSE,
-        },
-        {
-            method: "POST",
-            path_template: "/auth/resend-otp",
-            description: "Send (resend) verification OTP to email.",
-            tags: ["auth", "otp"],
-            source_file: "routes/auth/routes.py",
-            mcp_tool: "user_auth_resend_otp",
-            request_body_schema: {
-                type: "object",
-                properties: { email: EMAIL_PROP },
-                required: ["email"],
-                additionalProperties: false,
-            },
-            response_schema: OTP_SENT_RESPONSE,
-        },
-    ];
-}
-export async function shareAuthFlowToUi(opts) {
-    const backend = opts.backendUrl.replace(/\/+$/, "");
-    const frontend = opts.frontendUrl.replace(/\/+$/, "");
-    const apiKey = opts.apiKey?.trim();
-    if (!apiKey) {
-        throw new Error("PreMan authentication required. Run preman_login first so auth-flow sessions can stream to your dashboard.");
-    }
-    const upstream = (opts.upstreamBaseUrl || backend).replace(/\/+$/, "") || backend;
-    const sessionId = opts.sessionId?.trim() || crypto.randomUUID();
-    const endpoints = buildAuthFlowEndpoints().map((ep) => ({
-        ...ep,
-        base_url: upstream,
-    }));
-    const resp = await fetch(`${backend}/agent-sessions/${encodeURIComponent(sessionId)}/endpoints`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            Accept: "application/json",
-            Authorization: `Bearer ${apiKey}`,
-        },
-        body: JSON.stringify({
-            endpoints,
-            upstream_base_url: upstream,
-            intent: opts.intent || "Auth flow: signup, verify OTP, login, resend OTP",
-            client_label: "premanmcp",
-        }),
-    });
-    const text = await resp.text();
-    let body = {};
-    try {
-        body = text ? JSON.parse(text) : {};
-    }
-    catch {
-        throw new Error(`Agent session push failed: ${resp.status} ${text.slice(0, 500)}`);
-    }
-    if (!resp.ok) {
-        throw new Error(String(body.detail ?? body.error ?? `Agent session push failed: ${resp.status}`));
-    }
-    const sid = String(body.id ?? sessionId);
-    const url = `${frontend}/try?session=${encodeURIComponent(sid)}`;
-    return {
-        session_id: sid,
-        url,
-        endpoint_count: Number(body.endpoint_count ?? endpoints.length),
-        user_id: typeof body.user_id === "number" ? body.user_id : null,
-        auto_discoverable: Boolean(body.auto_discoverable),
-        upstream_base_url: upstream,
-        endpoints: buildAuthFlowEndpoints(),
-        ui: {
-            url,
-            note: "Open in Cursor Agent Browser or the Playground session list. Test signup → verify-otp → login, or resend-otp. " +
-                "Schemas are prefilled from routes/auth Pydantic models.",
-        },
-        related_tools: [
-            "user_auth_signup",
-            "user_auth_verify_otp",
-            "user_auth_login",
-            "user_auth_resend_otp",
-        ],
-    };
-}

package/dist/mcp-preview-panel.d.ts

@@ -1,30 +0,0 @@
-export declare const MCP_PREVIEW_RESOURCE_URI = "ui://preman/mcp-preview";
-export declare const RESOURCE_URI_META_KEY = "ui/resourceUri";
-export declare function escapeHtmlAttr(s: string): string;
-export declare function escapeHtmlText(s: string): string;
-export interface PreviewTool {
-    name?: string;
-    description?: string;
-    inputSchema?: unknown;
-    _endpoint_ref?: {
-        method?: string;
-        path_template?: string;
-        tags?: string[];
-        source?: string;
-    };
-}
-export interface PreviewPayload {
-    intent?: string | string[];
-    selection_method?: string | string[];
-    rationale?: string | string[] | Record<string, string>;
-    selected_count?: number;
-    spec_preview?: {
-        upstream_base_url?: string | string[];
-        tools?: PreviewTool[];
-    };
-}
-export declare function buildConversionPanelHtml(data: PreviewPayload): string;
-export declare function writeMcpPreviewFile(panelHtml: string): Promise<{
-    absolutePath: string;
-    fileUrl: string;
-}>;

package/dist/mcp-preview-panel.js

@@ -1,166 +0,0 @@
-/**
- * Two-pane HTML for mcp_preview — shared by the MCP stdio server and
- * scripts/emit-mcp-preview.mjs (browser tab fallback when Cursor does not render mcp-app).
- */
-import fs from "node:fs/promises";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-export const MCP_PREVIEW_RESOURCE_URI = "ui://preman/mcp-preview";
-export const RESOURCE_URI_META_KEY = "ui/resourceUri";
-export function escapeHtmlAttr(s) {
-    return s.replace(/&/g, "&").replace(/"/g, """);
-}
-export function escapeHtmlText(s) {
-    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-export function buildConversionPanelHtml(data) {
-    const toStr = (v) => {
-        if (v == null)
-            return "";
-        if (Array.isArray(v))
-            return v.filter((x) => x != null).map((x) => String(x)).join("; ");
-        if (typeof v === "object") {
-            try {
-                return Object.entries(v)
-                    .map(([k, val]) => `${k}: ${val == null ? "" : String(val)}`)
-                    .join(" · ");
-            }
-            catch {
-                try {
-                    return JSON.stringify(v);
-                }
-                catch {
-                    return String(v);
-                }
-            }
-        }
-        return String(v);
-    };
-    const intent = toStr(data.intent).trim() || "(unspecified)";
-    const method = toStr(data.selection_method).trim() || "unknown";
-    const rationale = toStr(data.rationale).trim();
-    const upstream = toStr(data.spec_preview?.upstream_base_url).trim();
-    const tools = Array.isArray(data.spec_preview?.tools) ? data.spec_preview.tools : [];
-    const selectedCount = typeof data.selected_count === "number" ? data.selected_count : tools.length;
-    const linkKey = (m, p) => `${(m || "").toUpperCase()} ${p || ""}`.trim();
-    const endpointRows = tools
-        .map((t) => {
-        const ref = t._endpoint_ref ?? {};
-        const m = (ref.method ?? "").toUpperCase();
-        const p = ref.path_template ?? "";
-        const key = linkKey(m, p);
-        const tags = Array.isArray(ref.tags) && ref.tags.length > 0 ? ref.tags.join(", ") : "";
-        return `
-        <div class="row" data-link="${escapeHtmlAttr(key)}">
-          <div class="row-head">
-            <span class="method ${escapeHtmlAttr(m)}">${escapeHtmlText(m)}</span>
-            <span class="path">${escapeHtmlText(p)}</span>
-          </div>
-          ${tags ? `<div class="row-meta">tags: ${escapeHtmlText(tags)}</div>` : ""}
-        </div>`;
-    })
-        .join("");
-    const toolRows = tools
-        .map((t) => {
-        const ref = t._endpoint_ref ?? {};
-        const key = linkKey(ref.method, ref.path_template);
-        const schemaJson = (() => {
-            try {
-                return JSON.stringify(t.inputSchema ?? {}, null, 2);
-            }
-            catch {
-                return "{}";
-            }
-        })();
-        return `
-        <div class="row" data-link="${escapeHtmlAttr(key)}">
-          <div class="tool-name">${escapeHtmlText(t.name ?? "(unnamed)")}</div>
-          ${t.description ? `<div class="tool-desc">${escapeHtmlText(t.description)}</div>` : ""}
-          <pre class="tool-schema">${escapeHtmlText(schemaJson)}</pre>
-        </div>`;
-    })
-        .join("");
-    const empty = tools.length === 0
-        ? `<div class="empty">No matching endpoints. Try a different intent or run <code>verify_endpoints_live</code> first.</div>`
-        : "";
-    return `<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="UTF-8" />
-<meta name="viewport" content="width=device-width, initial-scale=1.0" />
-<title>PreMan · MCP Preview</title>
-<style>
-  :root { color-scheme: light dark; --bg:#0d1117; --bg2:#161b22; --border:#30363d; --fg:#e6edf3; --muted:#8b949e; --accent:#58a6ff; --green:#2ea043; --orange:#bf8700; --red:#cf222e; --purple:#8957e5; }
-  * { margin:0; padding:0; box-sizing:border-box; }
-  html, body { height:100%; background:var(--bg); color:var(--fg); font-family:-apple-system,BlinkMacSystemFont,sans-serif; font-size:13px; }
-  body { display:flex; flex-direction:column; overflow:hidden; }
-  header { padding:10px 14px; border-bottom:1px solid var(--border); background:var(--bg2); flex-shrink:0; }
-  header h1 { font-size:13px; font-weight:600; color:var(--accent); }
-  header .meta { font-size:11px; color:var(--muted); margin-top:3px; }
-  header .meta strong { color:var(--fg); font-weight:600; }
-  header .rationale { font-size:11px; color:var(--muted); margin-top:5px; font-style:italic; max-width:900px; }
-  .columns { flex:1; display:grid; grid-template-columns:1fr 1fr; gap:1px; background:var(--border); overflow:hidden; min-height:0; }
-  .col { background:var(--bg); overflow-y:auto; }
-  .col-header { padding:7px 12px; font-size:10px; font-weight:700; letter-spacing:0.06em; text-transform:uppercase; color:var(--muted); border-bottom:1px solid var(--border); position:sticky; top:0; background:var(--bg2); z-index:1; }
-  .row { padding:9px 12px; border-bottom:1px solid var(--border); transition:background 0.1s; }
-  .row:last-child { border-bottom:none; }
-  .row:hover, .row.linked { background:rgba(88,166,255,0.08); }
-  .row-head { display:flex; align-items:center; gap:8px; }
-  .row-meta { font-size:10px; color:var(--muted); margin-top:3px; padding-left:56px; }
-  .method { display:inline-block; min-width:48px; text-align:center; padding:2px 6px; border-radius:3px; font-weight:700; font-size:10px; color:white; font-family:SFMono-Regular,Consolas,monospace; }
-  .method.GET{background:var(--accent);} .method.POST{background:var(--green);} .method.PATCH{background:var(--orange);} .method.PUT{background:var(--purple);} .method.DELETE{background:var(--red);}
-  .path { font-family:SFMono-Regular,Consolas,monospace; font-size:12px; word-break:break-all; }
-  .tool-name { font-family:SFMono-Regular,Consolas,monospace; font-size:12px; font-weight:600; color:var(--accent); }
-  .tool-desc { font-size:11px; color:var(--muted); margin-top:3px; line-height:1.4; }
-  .tool-schema { font-family:SFMono-Regular,Consolas,monospace; font-size:10px; background:var(--bg2); padding:6px 8px; border-radius:3px; margin-top:6px; white-space:pre-wrap; word-break:break-all; max-height:120px; overflow-y:auto; line-height:1.4; color:var(--muted); }
-  .empty { padding:24px; text-align:center; color:var(--muted); font-style:italic; }
-  .empty code { font-family:SFMono-Regular,Consolas,monospace; color:var(--accent); background:var(--bg2); padding:1px 5px; border-radius:3px; font-style:normal; }
-  footer { padding:8px 14px; border-top:1px solid var(--border); background:var(--bg2); display:flex; gap:10px; align-items:center; flex-shrink:0; font-size:11px; color:var(--muted); }
-  footer .upstream { font-family:SFMono-Regular,Consolas,monospace; color:var(--accent); }
-  footer .deploy-hint { margin-left:auto; }
-  footer .deploy-hint code { font-family:SFMono-Regular,Consolas,monospace; color:var(--fg); background:var(--bg); padding:2px 6px; border-radius:3px; }
-</style>
-</head>
-<body>
-  <header>
-    <h1>API → MCP Conversion preview</h1>
-    <div class="meta">
-      Intent: <strong>${escapeHtmlText(intent)}</strong> · Selected <strong>${selectedCount}</strong> endpoint${selectedCount === 1 ? "" : "s"} · Method: ${escapeHtmlText(method)}
-    </div>
-    ${rationale ? `<div class="rationale">${escapeHtmlText(rationale)}</div>` : ""}
-  </header>
-  <main class="columns">
-    <div class="col">
-      <div class="col-header">Your API endpoints (${tools.length})</div>
-      ${endpointRows}${tools.length === 0 ? empty : ""}
-    </div>
-    <div class="col">
-      <div class="col-header">Generated MCP tools (${tools.length})</div>
-      ${toolRows}${tools.length === 0 ? empty : ""}
-    </div>
-  </main>
-  <footer>
-    <span>Upstream: <span class="upstream">${escapeHtmlText(upstream || "(not set)")}</span></span>
-    <span class="deploy-hint">Next: ask the agent to call <code>mcp_deploy</code></span>
-  </footer>
-  <script>
-    document.querySelectorAll('.row[data-link]').forEach(row => {
-      const key = row.getAttribute('data-link');
-      if (!key) return;
-      const matches = () => document.querySelectorAll('[data-link="' + CSS.escape(key) + '"]');
-      row.addEventListener('mouseenter', () => matches().forEach(r => r.classList.add('linked')));
-      row.addEventListener('mouseleave', () => matches().forEach(r => r.classList.remove('linked')));
-    });
-  </script>
-</body>
-</html>`;
-}
-export async function writeMcpPreviewFile(panelHtml) {
-    const outPath = path.join(process.cwd(), "preman-mcp", "mcp-preview-last.html");
-    await fs.mkdir(path.dirname(outPath), { recursive: true });
-    await fs.writeFile(outPath, panelHtml, "utf8");
-    return {
-        absolutePath: outPath,
-        fileUrl: pathToFileURL(outPath).href,
-    };
-}

package/dist/user_auth_flow.d.ts

@@ -1,11 +0,0 @@
-/**
- * App user auth (JWT) — tools that call the FastAPI backend at PREMAN_BACKEND /auth/*.
- * Separate from preman_login (device flow + pm_live_ API key). No API key is required
- * for these tools; for JWT-protected routes, pass the access_token from login/verify.
- */
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-/**
- * Register MCP tools for routes/auth (email, OTP, password, JWT).
- * Proxies to the same process as preman-local (PREMAN_BACKEND, e.g. http://127.0.0.1:8000).
- */
-export declare function registerUserAuthFlowTools(server: McpServer, backendUrl: string): void;

package/dist/user_auth_flow.js

@@ -1,279 +0,0 @@
-import { z } from "zod";
-function toolError(message, code = "backend_error", hints) {
-    const payload = { error: message, error_code: code };
-    if (hints)
-        payload._agent_hints = hints;
-    return {
-        content: [{ type: "text", text: JSON.stringify(payload) }],
-        isError: true,
-    };
-}
-function jsonOk(obj) {
-    return { content: [{ type: "text", text: JSON.stringify(obj) }] };
-}
-function normalizeBase(backendUrl) {
-    return backendUrl.replace(/\/+$/, "");
-}
-async function callAuthJson(base, method, path, opts) {
-    const url = new URL(path.startsWith("/") ? path.slice(1) : path, `${base}/`);
-    if (opts?.query) {
-        for (const [k, v] of Object.entries(opts.query)) {
-            if (v != null && v !== "")
-                url.searchParams.set(k, v);
-        }
-    }
-    const headers = { Accept: "application/json" };
-    const hasBody = opts?.json != null && (method === "POST" || method === "PUT" || method === "PATCH" || method === "DELETE");
-    if (hasBody) {
-        headers["Content-Type"] = "application/json";
-    }
-    if (opts?.token) {
-        headers.Authorization = `Bearer ${opts.token.trim()}`;
-    }
-    const init = { method, headers };
-    if (hasBody && opts?.json) {
-        init.body = JSON.stringify(opts.json);
-    }
-    const resp = await fetch(url, init);
-    const text = await resp.text();
-    let parsed;
-    try {
-        parsed = text ? JSON.parse(text) : {};
-    }
-    catch {
-        parsed = { raw: text };
-    }
-    const body = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
-        ? parsed
-        : { value: parsed };
-    return {
-        status_code: resp.status,
-        ok: resp.ok,
-        ...body,
-    };
-}
-/**
- * Register MCP tools for routes/auth (email, OTP, password, JWT).
- * Proxies to the same process as preman-local (PREMAN_BACKEND, e.g. http://127.0.0.1:8000).
- */
-export function registerUserAuthFlowTools(server, backendUrl) {
-    const base = normalizeBase(backendUrl);
-    server.tool("user_auth_start_signup", "Start signup with email only. Sends an OTP; next call user_auth_set_password with email, OTP, and new password. Uses POST /auth/start-signup on PREMAN_BACKEND (no API key). If the backend does not support this endpoint yet, use user_auth_signup instead.", {
-        email: z.string().describe("User email"),
-    }, async (args) => {
-        try {
-            const r = await callAuthJson(base, "POST", "/auth/start-signup", {
-                json: { email: args.email },
-            });
-            if (!r.ok) {
-                if (r.status_code === 404) {
-                    return toolError("This backend does not support email-only signup yet. Use user_auth_signup with email and password, then user_auth_verify_otp.", "backend_error", {
-                        next_actions: ["Call user_auth_signup with email and password.", "Then call user_auth_verify_otp with the email code."],
-                        related_tools: ["user_auth_signup", "user_auth_verify_otp"],
-                    });
-                }
-                return toolError(String(r.detail ?? r.message ?? "start signup failed"), r.status_code === 400 ? "invalid_input" : "backend_error", {
-                    next_actions: ["If email exists, use user_auth_login or user_auth_resend_otp."],
-                    related_tools: ["user_auth_set_password", "user_auth_login"],
-                });
-            }
-            return jsonOk(r);
-        }
-        catch (e) {
-            const m = e instanceof Error ? e.message : String(e);
-            return toolError(m, "backend_error", {
-                next_actions: ["Ensure PREMAN_BACKEND is running and JWT_SECRET is set on the server."],
-            });
-        }
-    });
-    server.tool("user_auth_signup", "Register with email and password. Sends an OTP; next call user_auth_verify_otp. Uses POST /auth/signup on PREMAN_BACKEND (no API key).", {
-        email: z.string().describe("User email"),
-        password: z.string().describe("Password (min 6 characters on the server)"),
-    }, async (args) => {
-        try {
-            const r = await callAuthJson(base, "POST", "/auth/signup", {
-                json: { email: args.email, password: args.password },
-            });
-            if (!r.ok) {
-                return toolError(String(r.detail ?? r.message ?? "signup failed"), r.status_code === 400 ? "invalid_input" : "backend_error", {
-                    next_actions: ["If email exists, use user_auth_login or user_auth_resend_otp."],
-                    related_tools: ["user_auth_verify_otp", "user_auth_login"],
-                });
-            }
-            return jsonOk(r);
-        }
-        catch (e) {
-            const m = e instanceof Error ? e.message : String(e);
-            return toolError(m, "backend_error", {
-                next_actions: ["Ensure PREMAN_BACKEND is running and JWT_SECRET is set on the server."],
-            });
-        }
-    });
-    server.tool("user_auth_verify_otp", "Verify the email OTP and receive access_token (JWT). POST /auth/verify-otp.", { email: z.string(), otp: z.string().describe("6-digit code from email") }, async (args) => {
-        try {
-            const r = await callAuthJson(base, "POST", "/auth/verify-otp", {
-                json: { email: args.email, otp: args.otp },
-            });
-            if (!r.ok) {
-                return toolError(String(r.detail ?? "verify failed"), "auth_required", {
-                    next_actions: ["Request a new code with user_auth_resend_otp if expired."],
-                    related_tools: ["user_auth_resend_otp", "user_auth_signup"],
-                });
-            }
-            return jsonOk(r);
-        }
-        catch (e) {
-            return toolError(e instanceof Error ? e.message : String(e), "backend_error");
-        }
-    });
-    server.tool("user_auth_login", "Login with email and password. Returns access_token if email is verified. POST /auth/login.", { email: z.string(), password: z.string() }, async (args) => {
-        try {
-            const r = await callAuthJson(base, "POST", "/auth/login", {
-                json: { email: args.email, password: args.password },
-            });
-            if (!r.ok) {
-                const sc = r.status_code;
-                const code = sc === 403 || sc === 401 ? "auth_required" : "backend_error";
-                return toolError(String(r.detail ?? "login failed"), code, {
-                    next_actions: [
-                        "If 403 email not verified: use user_auth_verify_otp or user_auth_resend_otp.",
-                        "If 403 migrated account: use user_auth_forgot_password or user_auth_set_password flow.",
-                    ],
-                    related_tools: ["user_auth_verify_otp", "user_auth_needs_password", "user_auth_set_password"],
-                });
-            }
-            return jsonOk(r);
-        }
-        catch (e) {
-            return toolError(e instanceof Error ? e.message : String(e), "backend_error");
-        }
-    });
-    server.tool("user_auth_needs_password", "Check if an account must set a password (e.g. migrated user). GET /auth/needs-password?email=", { email: z.string().optional().describe("Email to check; omit to return false/false from server") }, async (args) => {
-        try {
-            const r = await callAuthJson(base, "GET", "/auth/needs-password", {
-                query: { email: args.email },
-            });
-            if (!r.ok) {
-                return toolError(String(r.detail ?? "request failed"), "backend_error");
-            }
-            return jsonOk(r);
-        }
-        catch (e) {
-            return toolError(e instanceof Error ? e.message : String(e), "backend_error");
-        }
-    });
-    server.tool("user_auth_resend_otp", "Resend verification OTP. POST /auth/resend-otp with { email }.", { email: z.string() }, async (args) => {
-        try {
-            const r = await callAuthJson(base, "POST", "/auth/resend-otp", {
-                json: { email: args.email },
-            });
-            if (!r.ok) {
-                return toolError(String(r.detail ?? "resend failed"), "invalid_input");
-            }
-            return jsonOk(r);
-        }
-        catch (e) {
-            return toolError(e instanceof Error ? e.message : String(e), "backend_error");
-        }
-    });
-    server.tool("user_auth_forgot_password", "Request password reset OTP. POST /auth/forgot-password with { email }.", { email: z.string() }, async (args) => {
-        try {
-            const r = await callAuthJson(base, "POST", "/auth/forgot-password", {
-                json: { email: args.email },
-            });
-            if (!r.ok) {
-                return toolError(String(r.detail ?? "forgot failed"), "backend_error");
-            }
-            return jsonOk(r);
-        }
-        catch (e) {
-            return toolError(e instanceof Error ? e.message : String(e), "backend_error");
-        }
-    });
-    server.tool("user_auth_set_password", "Set a new password using OTP (migrated / forgot flow). Returns access_token. POST /auth/set-password.", {
-        email: z.string(),
-        otp: z.string(),
-        new_password: z.string().min(6),
-    }, async (args) => {
-        try {
-            const r = await callAuthJson(base, "POST", "/auth/set-password", {
-                json: {
-                    email: args.email,
-                    otp: args.otp,
-                    new_password: args.new_password,
-                },
-            });
-            if (!r.ok) {
-                return toolError(String(r.detail ?? "set password failed"), "auth_required", {
-                    next_actions: ["Request a new OTP with user_auth_forgot_password or user_auth_resend_otp."],
-                    related_tools: ["user_auth_forgot_password"],
-                });
-            }
-            return jsonOk(r);
-        }
-        catch (e) {
-            return toolError(e instanceof Error ? e.message : String(e), "backend_error");
-        }
-    });
-    server.tool("user_auth_me", "Current user profile (JWT). GET /auth/me with Authorization: Bearer access_token from login/verify.", {
-        access_token: z.string().describe("JWT from user_auth_login or user_auth_verify_otp"),
-    }, async (args) => {
-        try {
-            const r = await callAuthJson(base, "GET", "/auth/me", {
-                token: args.access_token,
-            });
-            if (!r.ok) {
-                return toolError(String(r.detail ?? "unauthorized"), "auth_required", {
-                    next_actions: ["Call user_auth_login to obtain a fresh access_token."],
-                    related_tools: ["user_auth_login"],
-                });
-            }
-            return jsonOk(r);
-        }
-        catch (e) {
-            return toolError(e instanceof Error ? e.message : String(e), "backend_error");
-        }
-    });
-    server.tool("user_auth_change_password", "Change password for the signed-in user. POST /auth/change-password with JWT.", {
-        access_token: z.string(),
-        current_password: z.string(),
-        new_password: z.string().min(6),
-    }, async (args) => {
-        try {
-            const r = await callAuthJson(base, "POST", "/auth/change-password", {
-                token: args.access_token,
-                json: {
-                    current_password: args.current_password,
-                    new_password: args.new_password,
-                },
-            });
-            if (!r.ok) {
-                return toolError(String(r.detail ?? "change password failed"), r.status_code === 401 ? "auth_required" : "invalid_input", {
-                    related_tools: ["user_auth_login", "user_auth_me"],
-                });
-            }
-            return jsonOk(r);
-        }
-        catch (e) {
-            return toolError(e instanceof Error ? e.message : String(e), "backend_error");
-        }
-    });
-    server.tool("user_auth_delete_account", "Delete the current account. DELETE /auth/me with JWT. Irreversible.", {
-        access_token: z.string().describe("JWT from user_auth_login or user_auth_verify_otp"),
-    }, async (args) => {
-        try {
-            const r = await callAuthJson(base, "DELETE", "/auth/me", {
-                token: args.access_token,
-            });
-            if (!r.ok) {
-                return toolError(String(r.detail ?? "delete failed"), "auth_required", {
-                    related_tools: ["user_auth_login"],
-                });
-            }
-            return jsonOk(r);
-        }
-        catch (e) {
-            return toolError(e instanceof Error ? e.message : String(e), "backend_error");
-        }
-    });
-}