@pi-archimedes/mcp 2.5.1 → 2.6.3

package/src/auth-run.ts

@@ -1,11 +1,20 @@
 /**
- * Shared OAuth run (plan-026): the single place that wraps
- * `ServerClient.authenticate` — the SINGLE auth entry point — behind the
- * `BorderedLoader` progress UI (tui.md Pattern 2), the loader's
- * `onAbort` → `AbortController` cancellation, the "Opening browser…"
- * notification for the authorization URL, and the post-auth
- * close+reconnect that re-reads the freshly stored token from the keyring
- * into the Bearer header.
+ * Shared OAuth run: the single place that wraps `ServerClient.authenticate`
+ * — the SINGLE auth entry point — behind a visible status indicator and
+ * the post-auth close+reconnect that re-reads the freshly stored token from
+ * the keyring into the Bearer header.
+ *
+ * Design (fixes the BorderedLoader bug):
+ * - The authorization URL is surfaced via `ctx.ui.notify` BEFORE `open()` is
+ *   called, so the user always sees it (the old BorderedLoader approach
+ *   silently swallowed the notify because the loader re-painted over it).
+ * - Progress is shown via `ctx.ui.setStatus` (non-blocking) instead of a
+ *   custom UI that owns the screen.
+ * - An `onAuthorizationInput` fallback is wired up so remote/headless users
+ *   (where the browser redirect can't reach the local callback server) can
+ *   paste the full callback URL and complete the flow.
+ * - Cancellation is driven by an AbortController tied to the session signal
+ *   (headless) or a separate controller the caller can abort (UI path).
  *
  * Call sites: the `/mcp auth` command (`commands-auth.ts`) and the inline
  * auto-auth's UI branch (`auto-auth.ts`). Each maps the structured
@@ -13,19 +22,17 @@
  * between the two user-visible surfaces.
  */
 import {
-  BorderedLoader,
   type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import open from "open";
 import { recordClientOutcome } from "./metadata-cache.js";
+import type { AuthenticateOptions } from "./auth-flow.js";
 import type { ServerClient, ServerStatus } from "./server-client.js";
 
 /**
  * Outcome of an auth attempt.
  *
- * - `cancelled` — the loader was esc-closed OR the flow rejected with
- *   exactly "OAuth cancelled" (an external abort). Both call sites treat
- *   these identically.
+ * - `cancelled` — the flow was aborted (signal or "OAuth cancelled" error).
  * - `flow-error` — the flow failed for a real reason; `error` carries the
  *   underlying message.
  * - `reconnect-failed` — auth succeeded but close/connect threw; `error`
@@ -52,8 +59,8 @@ export async function openAuthUrl(url: string): Promise<void> {
   try {
     await open(url);
   } catch {
-    // No browser available — swallow; the caller's notification (if any)
-    // still shows the URL so the user can visit it manually.
+    // No browser available — swallow; the caller's notification already
+    // shows the URL so the user can visit it manually.
   }
 }
 
@@ -81,66 +88,70 @@ export async function reconnectAfterAuth(client: ServerClient): Promise<AuthRunO
 }
 
 /**
- * Run `ServerClient.authenticate` behind a `BorderedLoader` (esc aborts
- * the flow; the authorization URL is opened in the browser and announced
- * via an info notification) and, on success, perform the post-auth
- * close+reconnect.
+ * Run `ServerClient.authenticate` with a visible status indicator and an
+ * `onAuthorizationInput` fallback for remote/headless environments.
+ *
+ * - The authorization URL is shown via `ctx.ui.notify` BEFORE `open()` fires,
+ *   so it is always visible regardless of whether the browser opens.
+ * - `ctx.ui.setStatus` tracks progress without owning the screen.
+ * - `ctx.ui.confirm` + `ctx.ui.input` provide a manual-paste path for users
+ *   whose browser redirect cannot reach the local callback server.
+ * - On success the client is closed + reconnected so the fresh token is read
+ *   from the keyring immediately.
  *
- * `ctx` must have a UI — headless callers (print/RPC) run the flow plainly
- * and reuse `openAuthUrl`/`reconnectAfterAuth` (see `autoAuthenticate`).
+ * `ctx` must have a UI — headless callers (print/RPC) use `openAuthUrl` and
+ * `reconnectAfterAuth` directly (see `autoAuthenticate` in `auto-auth.ts`).
  */
 export async function runAuthWithLoader(
   ctx: ExtensionContext,
   client: ServerClient,
   options: {
-    /** Loader label, e.g. `Authenticating <server>… (esc to cancel)`. */
+    /** Status label, e.g. `Authenticating <server>…`. */
     loaderLabel: string;
   },
 ): Promise<AuthRunOutcome> {
-  const controller = new AbortController();
-  type LoaderOutcome =
-    | { kind: "done" }
-    | { kind: "error"; error: string }
-    | null; // null = esc-closed loader
-  const outcome = await ctx.ui.custom<LoaderOutcome>((tui, theme, _keybindings, done) => {
-    const loader = new BorderedLoader(tui, theme, options.loaderLabel);
-    let settled = false;
-    const settle = (value: LoaderOutcome) => {
-      if (!settled) {
-        settled = true;
-        done(value);
-      }
-    };
-    loader.onAbort = () => {
-      controller.abort();
-      settle(null);
+  const statusKey = `mcp-auth-${client.name}`;
+  ctx.ui.setStatus(statusKey, options.loaderLabel);
+
+  try {
+    const opts: AuthenticateOptions = {
+      onAuthorizationUrl: async (url: URL) => {
+        const urlStr = url.toString();
+        // Notify FIRST so the URL is visible before open() fires — the old
+        // BorderedLoader approach re-painted over this notification silently.
+        ctx.ui.notify(
+          `Opening browser for ${client.name}… if it didn't open, visit:\n${urlStr}`,
+          "info",
+        );
+        await openAuthUrl(urlStr);
+      },
+      onAuthorizationInput: async (url: URL, signal: AbortSignal) => {
+        // Fallback for remote/headless: ask the user to paste the callback URL.
+        const urlStr = url.toString();
+        const confirmed = await ctx.ui.confirm(
+          `Authenticate ${client.name}`,
+          `Open this URL in your browser:\n${urlStr}\n\nAfter approving, select Yes to paste the callback URL.`,
+          { signal },
+        );
+        if (!confirmed || signal.aborted) return undefined;
+        return ctx.ui.input(
+          `Complete ${client.name} OAuth`,
+          "Paste the full callback URL from your browser address bar",
+          { signal },
+        );
+      },
     };
-    void client
-      .authenticate({
-        signal: controller.signal,
-        onAuthorizationUrl: async (url: URL) => {
-          await openAuthUrl(url.toString());
-          ctx.ui.notify(
-            `Opening browser… if it didn't open, visit: ${url.toString()}`,
-            "info",
-          );
-        },
-      })
-      .then(
-        () => settle({ kind: "done" }),
-        // An esc-abort already settled `null`; this rejects with
-        // "OAuth cancelled" and is swallowed by the settle guard.
-        (e: unknown) => settle({ kind: "error", error: toMessage(e) }),
-      );
-    return loader;
-  });
-  if (outcome === null) return { kind: "cancelled" };
-  if (outcome.kind === "error") {
-    // A flow aborted from OUTSIDE the loader (agent abort) rejects with
-    // "OAuth cancelled" — that is a cancellation, not a failure.
-    if (outcome.error === "OAuth cancelled") return { kind: "cancelled" };
-    return { kind: "flow-error", error: outcome.error };
-  }
 
-  return reconnectAfterAuth(client);
+    try {
+      await client.authenticate(opts);
+    } catch (e) {
+      const msg = toMessage(e);
+      if (msg === "OAuth cancelled") return { kind: "cancelled" };
+      return { kind: "flow-error", error: msg };
+    }
+
+    return reconnectAfterAuth(client);
+  } finally {
+    ctx.ui.setStatus(statusKey, undefined);
+  }
 }

package/src/auto-auth.test.ts

@@ -4,17 +4,8 @@ import open from "open";
 import { autoAuthenticate, needsAuthToolResult } from "./auto-auth.js";
 import type { ServerClient } from "./server-client.js";
 
-// The real BorderedLoader needs a live TUI; a stub with the same surface
-// (constructor message + onAbort) is enough to drive the auto-auth flow.
 vi.mock("@earendil-works/pi-coding-agent", () => ({
-  BorderedLoader: class {
-    message: string;
-    onAbort?: () => void;
-    constructor(_tui: unknown, _theme: unknown, message: string) {
-      this.message = message;
-    }
-    dispose() {}
-  },
+  getAgentDir: () => `${process.env.TMPDIR ?? "/tmp"}/pi-archimedes-mock-agent`,
 }));
 vi.mock("open", () => ({ default: vi.fn().mockResolvedValue({}) }));
 
@@ -23,10 +14,8 @@ const AUTH_URL = "https://as.example/authorize?state=xyz";
 // ── fakes ────────────────────────────────────────────────────────────────────
 
 interface FakeClientOpts {
-  /** success: resolves; wait: hangs until the signal aborts; throw: rejects with `error`. */
   outcome?: "success" | "wait" | "throw";
   error?: string;
-  /** Status the client reports after close()+connect() (default: "connected"). */
   statusAfterReconnect?: string;
 }
 
@@ -40,7 +29,6 @@ interface FakeClient {
   authenticate: ReturnType<typeof vi.fn>;
 }
 
-/** Minimal needs-auth ServerClient fake — authenticate/close/connect are scripted. */
 function makeFakeClient(opts: FakeClientOpts = {}): FakeClient {
   const client: FakeClient = {
     name: "srv",
@@ -58,7 +46,6 @@ function makeFakeClient(opts: FakeClientOpts = {}): FakeClient {
       if (options?.signal?.aborted) return Promise.reject(new Error("OAuth cancelled"));
       switch (opts.outcome ?? "success") {
         case "wait":
-          // Hangs until the signal aborts — like a browser flow awaiting a callback.
           return new Promise<void>((_resolve, reject) => {
             options?.signal?.addEventListener(
               "abort",
@@ -76,43 +63,17 @@ function makeFakeClient(opts: FakeClientOpts = {}): FakeClient {
   return client;
 }
 
-interface CtxState {
-  notify: ReturnType<typeof vi.fn>;
-  custom: ReturnType<typeof vi.fn>;
-  lastLoader: () => { message: string; onAbort?: () => void } | null;
-}
-
-/** Fake ExtensionContext: custom() runs the factory synchronously and
- *  resolves when done() is first called; the loader is captured. */
-function makeCtx(hasUI: boolean): { ctx: ExtensionContext; state: CtxState } {
-  const state: Omit<CtxState, "lastLoader"> = { notify: vi.fn(), custom: vi.fn() };
-  let lastLoader: { message: string; onAbort?: () => void } | null = null;
-  state.custom.mockImplementation(
-    (factory: (
-      tui: unknown,
-      theme: unknown,
-      keybindings: unknown,
-      done: (result: unknown) => void,
-    ) => unknown) => {
-      let resolve!: (result: unknown) => void;
-      const pending = new Promise<unknown>((r) => (resolve = r));
-      let settled = false;
-      const done = (result: unknown) => {
-        if (!settled) {
-          settled = true;
-          resolve(result);
-        }
-      };
-      lastLoader = factory({}, {}, {}, done) as { message: string; onAbort?: () => void } | null;
-      return pending;
-    },
-  );
+function makeCtx(hasUI: boolean) {
+  const notify = vi.fn();
+  const setStatus = vi.fn();
+  const confirm = vi.fn().mockResolvedValue(false);
+  const input = vi.fn().mockResolvedValue(undefined);
   const ctx = {
     hasUI,
     signal: new AbortController().signal,
-    ui: { notify: state.notify, custom: state.custom },
+    ui: { notify, setStatus, confirm, input },
   } as unknown as ExtensionContext;
-  return { ctx, state: { ...state, lastLoader: () => lastLoader } };
+  return { ctx, notify, setStatus };
 }
 
 // ── needsAuthToolResult ──────────────────────────────────────────────────────
@@ -140,71 +101,52 @@ describe("needsAuthToolResult", () => {
 // ── autoAuthenticate ─────────────────────────────────────────────────────────
 
 describe("autoAuthenticate", () => {
-  it("runs the flow through a BorderedLoader, opens the URL, and reconnects on success", async () => {
+  it("with UI: runs authenticate, shows status, opens browser, reconnects on success", async () => {
     const client = makeFakeClient();
-    const { ctx, state } = makeCtx(true);
+    const { ctx, notify, setStatus } = makeCtx(true);
     const outcome = await autoAuthenticate(ctx, client as unknown as ServerClient);
 
     expect(outcome.proceed).toBe(true);
     expect(outcome.error).toBeUndefined();
-    expect(state.custom).toHaveBeenCalledTimes(1);
-    expect(state.lastLoader()!.message).toContain("srv");
     expect(client.authenticate).toHaveBeenCalledTimes(1);
     const opts = client.authenticate.mock.calls[0]![0] as {
-      signal: AbortSignal;
       onAuthorizationUrl: (u: URL) => Promise<void>;
+      onAuthorizationInput: unknown;
     };
-    expect(opts.signal.aborted).toBe(false);
-    // Authorization URL: open the browser and notify the user of it
+    expect(typeof opts.onAuthorizationInput).toBe("function");
+    // Authorization URL: notify first, then open browser
     await opts.onAuthorizationUrl(new URL(AUTH_URL));
+    expect(notify).toHaveBeenCalledWith(expect.stringContaining(AUTH_URL), "info");
     expect(open).toHaveBeenCalledWith(AUTH_URL);
-    expect(state.notify).toHaveBeenCalledWith(expect.stringContaining(AUTH_URL), "info");
-    // Reconnect to pick up the freshly stored token (mirrors /mcp auth)
+    // Status set + cleared
+    expect(setStatus).toHaveBeenCalledWith(expect.stringContaining("srv"), expect.any(String));
+    expect(setStatus).toHaveBeenLastCalledWith(expect.stringContaining("srv"), undefined);
+    // Reconnect to pick up the freshly stored token
     expect(client.close).toHaveBeenCalledTimes(1);
     expect(client.connect).toHaveBeenCalledTimes(1);
   });
 
-  it("esc aborts the flow, reports cancellation, and does not reconnect", async () => {
-    const client = makeFakeClient({ outcome: "wait" });
-    const { ctx, state } = makeCtx(true);
-    const running = autoAuthenticate(ctx, client as unknown as ServerClient);
-    await vi.waitFor(() => expect(client.authenticate).toHaveBeenCalledTimes(1));
-    const opts = client.authenticate.mock.calls[0]![0] as { signal: AbortSignal };
-    expect(opts.signal.aborted).toBe(false);
-
-    // Simulate Esc in the loader
-    state.lastLoader()!.onAbort!();
-    const outcome = await running;
-
-    expect(opts.signal.aborted).toBe(true);
-    expect(outcome.proceed).toBe(false);
-    expect(outcome.error).toBe("OAuth cancelled");
-    expect(client.close).not.toHaveBeenCalled();
-    expect(client.connect).not.toHaveBeenCalled();
-  });
-
-  it("surfaces flow failures without throwing and without reconnecting", async () => {
+  it("with UI: surfaces flow failures without throwing and without reconnecting", async () => {
     const client = makeFakeClient({ outcome: "throw", error: "token endpoint refused" });
     const { ctx } = makeCtx(true);
     const outcome = await autoAuthenticate(ctx, client as unknown as ServerClient);
     expect(outcome.proceed).toBe(false);
     expect(outcome.error).toBe("token endpoint refused");
     expect(client.close).not.toHaveBeenCalled();
-    expect(client.connect).not.toHaveBeenCalled();
   });
 
-  it("runs headless (no loader) when the context has no UI", async () => {
+  it("headless: runs plainly (no setStatus) when the context has no UI", async () => {
     const client = makeFakeClient();
-    const { ctx, state } = makeCtx(false);
+    const { ctx, setStatus } = makeCtx(false);
     const outcome = await autoAuthenticate(ctx, client as unknown as ServerClient);
     expect(outcome.proceed).toBe(true);
-    expect(state.custom).not.toHaveBeenCalled();
+    expect(setStatus).not.toHaveBeenCalled();
     expect(client.authenticate).toHaveBeenCalledTimes(1);
     expect(client.close).toHaveBeenCalledTimes(1);
     expect(client.connect).toHaveBeenCalledTimes(1);
   });
 
-  it("returns the error headless when the flow fails", async () => {
+  it("headless: returns the error when the flow fails", async () => {
     const client = makeFakeClient({ outcome: "throw", error: "keyring unavailable" });
     const { ctx } = makeCtx(false);
     const outcome = await autoAuthenticate(ctx, client as unknown as ServerClient);

package/src/auto-auth.ts

@@ -9,10 +9,10 @@
  *   telling the user to run `/mcp auth <server>`.
  * - autoAuth enabled: `ServerClient.authenticate` (the SINGLE auth entry
  *   point — never `auth-flow.authenticate` directly) is called inline and the
- *   caller retries the tool call once. A `BorderedLoader` (tui.md Pattern 2,
- *   same pattern as `/mcp auth`) shows progress when the execute context has
- *   UI; esc aborts the flow. Headless contexts run the flow plainly and the
- *   authorization URL is opened directly.
+ *   caller retries the tool call once. `runAuthWithLoader` shows progress,
+ *   notifies the URL, and provides a manual-paste fallback when the execute
+ *   context has UI; headless contexts run the flow plainly and open the URL
+ *   directly.
  *
  * The loader/cancel/reconnect machinery is shared with `/mcp auth` in
  * `auth-run.ts`; this module maps the structured outcome onto the tool's
@@ -94,10 +94,10 @@ function toAutoAuthOutcome(outcome: AuthRunOutcome, serverName: string): AutoAut
 /**
  * Run `ServerClient.authenticate` inline.
  *
- * With a UI context the flow is wrapped in a `BorderedLoader` (same pattern
- * as `/mcp auth`): esc aborts the flow and the cancellation is reported as
- * "OAuth cancelled". Without one (print/RPC mode) the flow runs plainly,
- * tied to the agent's abort signal when streaming.
+ * With a UI context the flow runs through `runAuthWithLoader` (same path as
+ * `/mcp auth`): status shown via setStatus, URL surfaced via notify, manual
+ * paste fallback via confirm+input. Without UI (print/RPC mode) the flow
+ * runs plainly, tied to the agent's abort signal when streaming.
  *
  * On success the client is closed and reconnected so the freshly stored
  * token is re-read into the Bearer header (mirrors `/mcp auth`). Cancellation,