@herbertgao/pi-extensions 2026.9.10 → 2026.9.12

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

@@ -0,0 +1,165 @@
+/**
+ * Cursor OAuth authentication via PKCE.
+ *
+ * Flow:
+ * 1. Generate PKCE verifier + challenge
+ * 2. Open browser to cursor.com/loginDeepControl
+ * 3. Poll api2.cursor.sh/auth/poll until tokens arrive
+ * 4. Refresh via api2.cursor.sh/auth/exchange_user_api_key
+ *
+ * Based on https://github.com/ephraimduncan/opencode-cursor by Ephraim Duncan.
+ */
+
+const CURSOR_LOGIN_URL = "https://cursor.com/loginDeepControl";
+const CURSOR_POLL_URL = "https://api2.cursor.sh/auth/poll";
+const CURSOR_REFRESH_URL = "https://api2.cursor.sh/auth/exchange_user_api_key";
+
+const POLL_MAX_ATTEMPTS = 150;
+const POLL_BASE_DELAY = 1000;
+const POLL_MAX_DELAY = 10_000;
+const POLL_BACKOFF_MULTIPLIER = 1.2;
+
+// ── PKCE ──
+
+async function generatePKCE(): Promise<{ verifier: string; challenge: string }> {
+  const verifierBytes = new Uint8Array(96);
+  crypto.getRandomValues(verifierBytes);
+  const verifier = Buffer.from(verifierBytes).toString("base64url");
+
+  const data = new TextEncoder().encode(verifier);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const challenge = Buffer.from(hashBuffer).toString("base64url");
+
+  return { verifier, challenge };
+}
+
+// ── Login params ──
+
+export interface CursorAuthParams {
+  verifier: string;
+  challenge: string;
+  uuid: string;
+  loginUrl: string;
+}
+
+export async function generateCursorAuthParams(): Promise<CursorAuthParams> {
+  const { verifier, challenge } = await generatePKCE();
+  const uuid = crypto.randomUUID();
+
+  const params = new URLSearchParams({
+    challenge,
+    uuid,
+    mode: "login",
+    redirectTarget: "cli",
+  });
+
+  const loginUrl = `${CURSOR_LOGIN_URL}?${params.toString()}`;
+  return { verifier, challenge, uuid, loginUrl };
+}
+
+// ── Poll for auth completion ──
+
+export async function pollCursorAuth(
+  uuid: string,
+  verifier: string,
+): Promise<{ accessToken: string; refreshToken: string }> {
+  let delay = POLL_BASE_DELAY;
+  let consecutiveErrors = 0;
+
+  for (let attempt = 0; attempt < POLL_MAX_ATTEMPTS; attempt++) {
+    await new Promise((r) => setTimeout(r, delay));
+
+    try {
+      const response = await fetch(
+        `${CURSOR_POLL_URL}?uuid=${uuid}&verifier=${verifier}`,
+      );
+
+      if (response.status === 404) {
+        consecutiveErrors = 0;
+        delay = Math.min(delay * POLL_BACKOFF_MULTIPLIER, POLL_MAX_DELAY);
+        continue;
+      }
+
+      if (response.ok) {
+        const data = (await response.json()) as {
+          accessToken: string;
+          refreshToken: string;
+        };
+        return {
+          accessToken: data.accessToken,
+          refreshToken: data.refreshToken,
+        };
+      }
+
+      throw new Error(`Poll failed: ${response.status}`);
+    } catch (err) {
+      consecutiveErrors++;
+      if (consecutiveErrors >= 3) {
+        throw new Error(
+          "Too many consecutive errors during Cursor auth polling",
+        );
+      }
+    }
+  }
+
+  throw new Error("Cursor authentication polling timeout");
+}
+
+// ── Token refresh ──
+
+export interface CursorCredentials {
+  access: string;
+  refresh: string;
+  expires: number;
+}
+
+export async function refreshCursorToken(
+  refreshToken: string,
+): Promise<CursorCredentials> {
+  const response = await fetch(CURSOR_REFRESH_URL, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${refreshToken}`,
+      "Content-Type": "application/json",
+    },
+    body: "{}",
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Cursor token refresh failed: ${error}`);
+  }
+
+  const data = (await response.json()) as {
+    accessToken: string;
+    refreshToken: string;
+  };
+
+  return {
+    access: data.accessToken,
+    refresh: data.refreshToken || refreshToken,
+    expires: getTokenExpiry(data.accessToken),
+  };
+}
+
+// ── JWT expiry extraction ──
+
+export function getTokenExpiry(token: string): number {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3 || !parts[1]) {
+      return Date.now() + 3600 * 1000;
+    }
+    const decoded = JSON.parse(
+      atob(parts[1].replace(/-/g, "+").replace(/_/g, "/")),
+    );
+    if (
+      decoded &&
+      typeof decoded === "object" &&
+      typeof decoded.exp === "number"
+    ) {
+      return decoded.exp * 1000 - 5 * 60 * 1000;
+    }
+  } catch {}
+  return Date.now() + 3600 * 1000;
+}

package/node_modules/pi-multi-account/cursor/bridge-handle.ts

@@ -0,0 +1,155 @@
+/**
+ * The handle around one bridge child process.
+ *
+ * Cursor talks over a long-lived HTTP/2 stream, and the conversation is genuinely
+ * bidirectional: while the model streams its answer, Cursor keeps asking us for blobs and we
+ * keep answering on the same pipe. So the pipe can be closed from our side — a cancelled turn,
+ * a session teardown, a compaction that starts a new conversation — while replies to Cursor's
+ * requests are still in flight.
+ *
+ * A write into a closed pipe does not fail where it is written. Node reports
+ * ERR_STREAM_WRITE_AFTER_END on a later tick, as an `error` event on the stream, which walks
+ * straight past the try/catch at the call site and, with no listener, becomes an
+ * uncaughtException that takes Pi down with it. That is exactly what happened after a
+ * compaction closed the bridge and Cursor asked for one more blob.
+ *
+ * Hence two rules, both enforced here rather than at each of the dozen call sites:
+ *   - once ended, the handle is not alive and silently drops writes;
+ *   - every stream we own carries an error listener, so nothing the bridge does can ever
+ *     surface as an uncaught exception in the host process.
+ */
+
+export interface BridgeStreams {
+  stdin: {
+    write(chunk: Uint8Array): unknown;
+    end(): unknown;
+    on(event: "error", listener: (error: Error) => void): unknown;
+    readonly writableEnded?: boolean;
+    readonly destroyed?: boolean;
+  } | null;
+  stdout: {
+    on(event: "data" | "error", listener: (payload: never) => void): unknown;
+  } | null;
+  on(event: "exit" | "error", listener: (payload: never) => void): unknown;
+  kill(signal?: NodeJS.Signals | number): unknown;
+}
+
+export interface BridgeHandle {
+  proc: { kill(signal?: NodeJS.Signals | number): unknown };
+  readonly alive: boolean;
+  write(data: Uint8Array): void;
+  end(): void;
+  destroy(): void;
+  onData(cb: (chunk: Buffer) => void): void;
+  onClose(cb: (code: number) => void): void;
+}
+
+/** Length-prefix a frame the way the bridge process expects it. */
+export function lpEncode(data: Uint8Array): Buffer {
+  const buf = Buffer.alloc(4 + data.length);
+  buf.writeUInt32BE(data.length, 0);
+  buf.set(data, 4);
+  return buf;
+}
+
+export function createBridgeHandle(
+  proc: BridgeStreams,
+  hooks: { debug?: (event: string, data: Record<string, unknown>) => void } = {},
+): BridgeHandle {
+  const debug = hooks.debug ?? (() => {});
+  const cbs = {
+    data: null as ((chunk: Buffer) => void) | null,
+    close: null as ((code: number) => void) | null,
+  };
+
+  let exited = false;
+  let ended = false;
+  let exitCode = 1;
+
+  // The safety net. A late write, a broken pipe, a bridge that could not be spawned at all —
+  // none of them may reach the host's uncaughtException handler.
+  proc.stdin?.on("error", (error: Error) => {
+    debug("bridge.stdin_error", { error: String(error) });
+  });
+  proc.stdout?.on("error", ((error: Error) => {
+    debug("bridge.stdout_error", { error: String(error) });
+  }) as never);
+  proc.on("error", ((error: Error) => {
+    debug("bridge.process_error", { error: String(error) });
+  }) as never);
+
+  let pending = Buffer.alloc(0);
+  proc.stdout?.on("data", ((chunk: Buffer) => {
+    pending = Buffer.concat([pending, chunk]);
+    while (pending.length >= 4) {
+      const len = pending.readUInt32BE(0);
+      if (pending.length < 4 + len) break;
+      const payload = pending.subarray(4, 4 + len);
+      pending = pending.subarray(4 + len);
+      cbs.data?.(Buffer.from(payload));
+    }
+  }) as never);
+
+  proc.on("exit", ((code: number | null) => {
+    exited = true;
+    exitCode = code ?? 1;
+    debug("bridge.exit", { exitCode });
+    cbs.close?.(exitCode);
+  }) as never);
+
+  const writable = (): boolean => {
+    if (exited || ended) return false;
+    const stdin = proc.stdin;
+    if (!stdin) return false;
+    return !stdin.writableEnded && !stdin.destroyed;
+  };
+
+  const end = (): void => {
+    if (ended) return;
+    if (writable()) {
+      try {
+        proc.stdin!.write(lpEncode(new Uint8Array(0)));
+        proc.stdin!.end();
+      } catch (error) {
+        debug("bridge.end_failed", { error: String(error) });
+      }
+    }
+    ended = true;
+  };
+
+  return {
+    proc,
+    // Ended counts as dead: a caller that asks `alive` is deciding whether to keep talking on
+    // this pipe, and the answer for a pipe we closed ourselves is no.
+    get alive() { return !exited && !ended; },
+    write(data: Uint8Array) {
+      if (!writable()) {
+        debug("bridge.write_after_end", { bytes: data.length, exited, ended });
+        return;
+      }
+      try {
+        proc.stdin!.write(lpEncode(data));
+      } catch (error) {
+        debug("bridge.write_failed", { error: String(error) });
+      }
+    },
+    end,
+    destroy() {
+      end();
+      if (exited) return;
+      try {
+        proc.kill();
+      } catch (error) {
+        debug("bridge.kill_failed", { error: String(error) });
+      }
+    },
+    onData(cb: (chunk: Buffer) => void) { cbs.data = cb; },
+    onClose(cb: (code: number) => void) {
+      if (exited) {
+        queueMicrotask(() => cb(exitCode));
+      } else {
+        cbs.close = cb;
+      }
+    },
+  };
+}

package/node_modules/pi-multi-account/cursor/conversation-registry.ts

@@ -0,0 +1,104 @@
+/**
+ * Where a Cursor conversation lives between requests.
+ *
+ * Cursor is stateful: once we hold a checkpoint for a conversation, the bridge replays that
+ * checkpoint instead of the message list Pi sent, and Cursor answers from its own copy of the
+ * history. That is fine while Pi and Cursor agree on what the history is — and wrong the moment
+ * Pi compacts, because Pi's short summary never reaches Cursor and Cursor's `usedTokens` keeps
+ * reporting the full pre-compaction size back to Pi.
+ *
+ * So the registry owns two things: the stored conversations, and a per-conversation generation
+ * counter. Bumping the generation mints a new Cursor conversation id, which is how a compaction
+ * is made to actually take effect — the checkpoint is dropped AND the old server-side
+ * conversation is left behind rather than resumed under the same id.
+ *
+ * It is a separate module from proxy.ts on purpose: proxy.ts pulls in generated protobuf code
+ * with non-erasable `enum`s, which Node's type stripping refuses to load, so nothing in it can
+ * be unit-tested directly.
+ */
+import { createHash } from "node:crypto";
+
+export interface StoredConversation {
+  conversationId: string;
+  checkpoint: Uint8Array | null;
+  sessionScoped: boolean;
+  blobStore: Map<string, Uint8Array>;
+  lastAccessMs: number;
+  /**
+   * How many completed turns of Pi's transcript this conversation has actually seen. Cursor
+   * answers from its own copy of the history, so anything that happened while the session was
+   * on another provider is invisible to it — and rotation moves the session between accounts
+   * constantly. See {@link isStaleForTranscript}.
+   */
+  turnsCovered: number;
+}
+
+/**
+ * Has the session moved on without Cursor?
+ *
+ * Between two consecutive requests on this conversation the transcript grows by at most one
+ * completed turn — the one we just answered. A bigger jump means turns were completed
+ * somewhere Cursor never saw: a failover to another provider and back, a branch, another
+ * client. Its checkpoint is then a conversation with a hole in it, and resuming from it hands
+ * the model a past that is missing whatever happened while it was away.
+ *
+ * Rebuilding costs tokens; resuming a stale checkpoint costs correctness, silently. So the
+ * doubt is resolved toward rebuilding.
+ */
+export function isStaleForTranscript(stored: StoredConversation, completedTurns: number): boolean {
+  if (!stored.checkpoint) return false;
+  return completedTurns > stored.turnsCovered + 1;
+}
+
+export const conversationStates = new Map<string, StoredConversation>();
+
+/** How many times this conversation has been restarted (compaction, mostly). */
+const conversationGenerations = new Map<string, number>();
+
+export function deriveBridgeKeyFromSessionId(sessionId: string): string {
+  return createHash("sha256").update(`bridge:${sessionId}`).digest("hex").slice(0, 16);
+}
+
+export function deriveConversationKeyFromSessionId(sessionId: string): string {
+  return createHash("sha256").update(`conv:${sessionId}`).digest("hex").slice(0, 16);
+}
+
+export function conversationGeneration(convKey: string): number {
+  return conversationGenerations.get(convKey) ?? 0;
+}
+
+/**
+ * Stable per (conversation, generation) so a retried request rejoins the same Cursor
+ * conversation, while a post-compaction request starts a new one.
+ */
+export function deterministicConversationId(convKey: string, generation = conversationGeneration(convKey)): string {
+  const seed = generation > 0 ? `cursor-conv-id:${convKey}#${generation}` : `cursor-conv-id:${convKey}`;
+  const hex = createHash("sha256").update(seed).digest("hex").slice(0, 32);
+  return [
+    hex.slice(0, 8), hex.slice(8, 12),
+    `4${hex.slice(13, 16)}`,
+    `${(0x8 | (parseInt(hex[16], 16) & 0x3)).toString(16)}${hex.slice(17, 20)}`,
+    hex.slice(20, 32),
+  ].join("-");
+}
+
+/**
+ * Forget everything Cursor is holding for this conversation and move to a fresh id.
+ * Returns whether a conversation was actually stored, for logging.
+ */
+export function forgetConversation(convKey: string): boolean {
+  const existed = conversationStates.delete(convKey);
+  conversationGenerations.set(convKey, conversationGeneration(convKey) + 1);
+  return existed;
+}
+
+/** Drop a conversation for good — the session itself is gone, so its generation is noise. */
+export function dropConversation(convKey: string): boolean {
+  conversationGenerations.delete(convKey);
+  return conversationStates.delete(convKey);
+}
+
+export function clearConversationRegistry(): void {
+  conversationStates.clear();
+  conversationGenerations.clear();
+}