@herbertgao/pi-extensions 2026.9.9 → 2026.9.11

package/node_modules/pi-multi-account/cursor/cursor-shared.ts

@@ -0,0 +1,192 @@
+/**
+ * Multi-account surface for the Cursor provider.
+ *
+ * The single-account extension (`index.ts`) keeps ONE module-level access token and
+ * registers ONE provider called `cursor`. Rotation needs N providers — `cursor`,
+ * `cursor-account-2`, ... — that share one local proxy while each authenticates as its
+ * own Cursor subscription.
+ *
+ * The account is carried by the request itself: every slot's `getApiKey` returns THAT
+ * slot's access token, Pi puts it in the `Authorization` header of the call to the local
+ * proxy, and the proxy hands the very same token to Cursor. Nothing is cached between
+ * requests, so a failover mid-session takes effect on the next call instead of silently
+ * re-using the spent account's token.
+ *
+ * Consumed by pi-multi-account's `cursor-bridge.ts`.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { cursorPayloadStream } from "../provider-payload-stream.ts";
+import {
+  generateCursorAuthParams,
+  getTokenExpiry,
+  pollCursorAuth,
+  refreshCursorToken,
+} from "./auth.ts";
+import { FALLBACK_MODELS, modelConfig, processModels } from "./index.ts";
+import { getCursorModels, startProxy, type CursorModel } from "./proxy.ts";
+
+export const CURSOR_BASE = "cursor";
+
+/** Resolves the stored access token for a provider id (reads the host's auth.json). */
+type TokenResolver = (providerId: string) => Promise<string>;
+
+type AuthEntryLike = {
+  type?: string;
+  access?: string;
+  refresh?: string;
+  expires?: number;
+};
+
+type RegisterOptions = {
+  /**
+   * Host guard that refuses a login when the SAME real Cursor account is already stored
+   * in another slot. Throwing here is correct: two slots on one account is not a rotation,
+   * it is one account that would be benched twice.
+   */
+  rejectDuplicateLogin?: (slot: string, credentials: AuthEntryLike) => AuthEntryLike;
+  /** Called with the real catalog once a token can read it, so the host can re-register. */
+  onModelsDiscovered?: (models: CursorModel[]) => void;
+};
+
+// `var`, deliberately: these are hoisted, so even a caller that reaches this module while it
+// is still initializing (a concurrent import) sees `undefined` instead of a temporal-dead-zone
+// crash. The module is shared by every account slot and must never be the reason a session
+// loses Cursor.
+// eslint-disable-next-line no-var
+var proxyPromise: Promise<number> | undefined;
+// eslint-disable-next-line no-var
+var tokenResolver: TokenResolver | undefined;
+
+/**
+ * The bearer token Pi attached to this proxy call, i.e. the identity of the slot that
+ * made it. `cursor-proxy` is the single-account extension's placeholder and carries no
+ * identity, so it is treated as absent.
+ */
+function bearerFromRequest(req?: {
+  headers?: Record<string, string | string[] | undefined>;
+}): string | undefined {
+  const raw = req?.headers?.authorization;
+  const header = Array.isArray(raw) ? raw[0] : raw;
+  if (typeof header !== "string") return undefined;
+  const match = /^Bearer\s+(.+)$/i.exec(header.trim());
+  const token = match?.[1]?.trim();
+  if (!token || token === "cursor-proxy") return undefined;
+  return token;
+}
+
+/**
+ * Start (once) the shared local proxy. Idempotent: later calls only refresh the fallback
+ * resolver and return the port already bound, so every slot registers against one port.
+ */
+export async function ensureCursorProxy(resolve: TokenResolver): Promise<number> {
+  tokenResolver = resolve;
+  proxyPromise ??= startProxy(async (req) => {
+    const fromRequest = bearerFromRequest(req);
+    if (fromRequest) return fromRequest;
+    // No usable token on the request (a legacy placeholder, or a caller that sends none):
+    // fall back to the base slot's stored credential rather than failing the call.
+    const fallback = (await tokenResolver?.(CURSOR_BASE)) ?? "";
+    if (!fallback) {
+      throw new Error(
+        "No Cursor account is logged in for this request. Run /login and pick a cursor slot.",
+      );
+    }
+    return fallback;
+  });
+  return proxyPromise;
+}
+
+function displayName(id: string): string {
+  return id === CURSOR_BASE ? "Cursor" : `Cursor (${id})`;
+}
+
+async function discoverModels(
+  accessToken: string,
+  onModelsDiscovered?: (models: CursorModel[]) => void,
+): Promise<void> {
+  if (!onModelsDiscovered) return;
+  try {
+    const discovered = await getCursorModels(accessToken);
+    if (discovered.length > 0) onModelsDiscovered(discovered);
+  } catch {
+    // Catalog discovery is an enhancement over FALLBACK_MODELS. A login must never fail
+    // because Cursor's model list could not be read.
+  }
+}
+
+/**
+ * Register one Cursor account slot as its own Pi provider.
+ *
+ * Safe to call repeatedly for the same id — that is how a freshly discovered catalog
+ * replaces the fallback list.
+ */
+export function registerCursorProvider(
+  pi: ExtensionAPI,
+  id: string,
+  proxyPort: number,
+  rawModels: CursorModel[] = FALLBACK_MODELS,
+  options: RegisterOptions = {},
+): void {
+  const name = displayName(id);
+  const models = processModels(rawModels).map(modelConfig);
+
+  (pi as any).registerProvider(id, {
+    name,
+    baseUrl: `http://127.0.0.1:${proxyPort}/v1`,
+    api: "openai-completions",
+    streamSimple: cursorPayloadStream,
+    models,
+    oauth: {
+      name,
+      isSubscription: true,
+
+      async login(callbacks: any): Promise<AuthEntryLike> {
+        const { verifier, uuid, loginUrl } = await generateCursorAuthParams();
+        callbacks.onAuth({ url: loginUrl });
+        const { accessToken, refreshToken } = await pollCursorAuth(uuid, verifier);
+        const credentials: AuthEntryLike = {
+          type: "oauth",
+          access: accessToken,
+          refresh: refreshToken,
+          expires: getTokenExpiry(accessToken),
+        };
+        // Reject BEFORE the catalog call: a duplicate must cost nothing and change nothing.
+        const verified = options.rejectDuplicateLogin
+          ? options.rejectDuplicateLogin(id, credentials)
+          : credentials;
+        await discoverModels(accessToken, options.onModelsDiscovered);
+        return verified;
+      },
+
+      async refreshToken(credentials: AuthEntryLike): Promise<AuthEntryLike> {
+        const refreshed = await refreshCursorToken(credentials.refresh as string);
+        await discoverModels(refreshed.access, options.onModelsDiscovered);
+        return { type: "oauth", ...refreshed };
+      },
+
+      /**
+       * THIS slot's token, not a shared placeholder — it is what tells the proxy which
+       * Cursor account the request belongs to.
+       */
+      getApiKey(credentials: AuthEntryLike): string {
+        return credentials.access ?? "";
+      },
+    },
+  });
+}
+
+export { FALLBACK_MODELS };
+
+/**
+ * Read the account's real model catalog.
+ *
+ * THROWS the underlying error: callers (login, refresh, startup discovery) each decide
+ * whether a failed catalog read is fatal — swallowing it here left every layer above
+ * guessing why the fallback list was still in effect.
+ */
+export async function discoverCursorModels(
+  accessToken: string,
+): Promise<CursorModel[]> {
+  return getCursorModels(accessToken);
+}

package/node_modules/pi-multi-account/cursor/h2-bridge.mjs

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+/**
+ * Dumb HTTP/2 bidirectional pipe for Cursor gRPC.
+ *
+ * Originally from https://github.com/ephraimduncan/opencode-cursor by Ephraim Duncan (MIT).
+ *
+ * Bun's node:http2 is broken. This Node script acts as a transparent
+ * HTTP/2 proxy: it opens a single bidirectional stream and ferries
+ * raw bytes between the parent process (via stdin/stdout) and Cursor.
+ *
+ * Protocol (length-prefixed framing over stdin/stdout):
+ *   [4 bytes big-endian length][payload]
+ *
+ * First message on stdin is JSON config:
+ *   { "accessToken": "...", "url": "...", "path": "...", "unary": false }
+ *
+ * When unary=true, the bridge uses application/proto (raw protobuf) instead
+ * of application/connect+proto (Connect streaming). The single stdin message
+ * is written as the request body and the stream is ended immediately.
+ * After config, subsequent stdin messages are raw bytes to write to the H2 stream.
+ * H2 response data is written to stdout using the same length-prefixed framing.
+ */
+import http2 from "node:http2";
+import crypto from "node:crypto";
+
+const CURSOR_CLIENT_VERSION = "cli-2026.01.09-231024f";
+
+/** Write one length-prefixed message to stdout. */
+function writeMessage(data) {
+  const lenBuf = Buffer.alloc(4);
+  lenBuf.writeUInt32BE(data.length, 0);
+  process.stdout.write(lenBuf);
+  process.stdout.write(data);
+}
+
+// --- Buffered stdin reader ---
+
+let stdinBuf = Buffer.alloc(0);
+let stdinResolve = null;
+let stdinEnded = false;
+
+process.stdin.on("data", (chunk) => {
+  stdinBuf = Buffer.concat([stdinBuf, chunk]);
+  if (stdinResolve) {
+    const r = stdinResolve;
+    stdinResolve = null;
+    r();
+  }
+});
+
+process.stdin.on("end", () => {
+  stdinEnded = true;
+  if (stdinResolve) {
+    const r = stdinResolve;
+    stdinResolve = null;
+    r();
+  }
+});
+
+function waitForData() {
+  return new Promise((resolve) => { stdinResolve = resolve; });
+}
+
+async function readExact(n) {
+  while (stdinBuf.length < n) {
+    if (stdinEnded) return null;
+    await waitForData();
+  }
+  const result = stdinBuf.subarray(0, n);
+  stdinBuf = stdinBuf.subarray(n);
+  return Buffer.from(result);
+}
+
+async function readMessage() {
+  const lenBuf = await readExact(4);
+  if (!lenBuf) return null;
+  const len = lenBuf.readUInt32BE(0);
+  if (len === 0) return Buffer.alloc(0);
+  return readExact(len);
+}
+
+// --- Main ---
+
+const configBuf = await readMessage();
+if (!configBuf) process.exit(1);
+
+const config = JSON.parse(configBuf.toString("utf8"));
+const { accessToken, url, path: rpcPath, unary } = config;
+
+const client = http2.connect(url || "https://api2.cursor.sh");
+
+// Guard against initial connection failure. Reset on any h2 activity
+// so long-running agent conversations (with tool call round-trips) survive.
+let timeout = setTimeout(killBridge, 30_000);
+
+function resetTimeout() {
+  clearTimeout(timeout);
+  timeout = setTimeout(killBridge, 120_000);
+}
+
+function killBridge() {
+  clearTimeout(timeout);
+  client.destroy();
+  process.exit(1);
+}
+
+client.on("error", () => {
+  clearTimeout(timeout);
+  process.exit(1);
+});
+
+const headers = {
+  ":method": "POST",
+  ":path": rpcPath || "/agent.v1.AgentService/Run",
+  "content-type": unary ? "application/proto" : "application/connect+proto",
+  te: "trailers",
+  authorization: `Bearer ${accessToken}`,
+  "x-ghost-mode": "true",
+  "x-cursor-client-version": CURSOR_CLIENT_VERSION,
+  "x-cursor-client-type": "cli",
+  "x-request-id": crypto.randomUUID(),
+};
+if (!unary) {
+  headers["connect-protocol-version"] = "1";
+}
+const h2Stream = client.request(headers);
+
+// Forward H2 response data → stdout (length-prefixed)
+h2Stream.on("data", (chunk) => {
+  resetTimeout();
+  writeMessage(chunk);
+});
+
+h2Stream.on("end", () => {
+  clearTimeout(timeout);
+  client.close();
+  // Give stdout time to flush
+  setTimeout(() => process.exit(0), 100);
+});
+
+h2Stream.on("error", () => {
+  clearTimeout(timeout);
+  client.close();
+  process.exit(1);
+});
+
+// Forward stdin → H2 stream (after config message)
+if (unary) {
+  // Unary mode: read a single body message, write it, and end the stream.
+  const body = await readMessage();
+  if (body && body.length > 0 && !h2Stream.closed && !h2Stream.destroyed) {
+    h2Stream.end(body);
+  } else {
+    h2Stream.end();
+  }
+} else {
+  // Streaming mode: forward all stdin messages as Connect frames.
+  (async () => {
+    while (true) {
+      const msg = await readMessage();
+      if (!msg || msg.length === 0) {
+        // EOF or zero-length = done writing
+        break;
+      }
+      if (!h2Stream.closed && !h2Stream.destroyed) {
+        resetTimeout();
+        h2Stream.write(msg);
+      }
+    }
+
+    if (!h2Stream.closed && !h2Stream.destroyed) {
+      h2Stream.end();
+    }
+  })();
+}