@jameslovespancakes/pi-plus 1.0.0 → 1.0.1

package/src/domains/subscriptions/providers/anthropic.ts

@@ -1,149 +1,149 @@
-import { randomUUID } from "node:crypto";
-import type { AccountContext, AccountProvider, ManagedAccount, RoutingMode } from "../../../core/accounts/registry.ts";
-import { authorize, exchange } from "../../../core/anthropic/oauth.ts";
-import {
-  getRoutingMode,
-  loadAccounts,
-  saveAccount,
-  setRoutingMode,
-  type RoutingMode as StoreRoutingMode,
-} from "../../../core/anthropic/store.ts";
-
-/**
- * Anthropic adapter.
- *
- * pi itself holds one Anthropic credential; the additional accounts live in
- * our own store and tokens are swapped per request. Everything
- * provider-specific lives here so `/accounts` and `/routing` stay generic.
- *
- * This used to read through `vendor/anthropic.ts`, which loaded the cortexkit
- * package. That package was removed when the provider was extracted, so every
- * call here threw and the account list silently came back empty. It now uses
- * the extracted store directly.
- */
-
-/** The registry's vocabulary maps onto the store's routing modes. */
-const MODE_TO_STORE: Record<RoutingMode, StoreRoutingMode> = {
-  standard: "main-first",
-  optimal: "sticky-balanced",
-};
-
-function fromStoreMode(mode: string): RoutingMode {
-  return mode === "sticky-balanced" ? "optimal" : "standard";
-}
-
-async function authenticate(ctx: AccountContext): Promise<{ access: string; refresh: string; expires: number } | undefined> {
-  const auth = await authorize("max");
-
-  try {
-    await ctx.openBrowser(auth.url);
-  } catch {
-    ctx.ui.notify(`Open this authorization URL:\n${auth.url}`, "warning");
-  }
-
-  const callback = await ctx.ui.input("Claude OAuth", "Paste the callback URL or authorization code");
-  if (!callback) return undefined;
-
-  const result = await exchange(callback, auth.verifier, auth.redirectUri, auth.state);
-  if (result.type !== "success") {
-    throw new Error(`Claude OAuth exchange failed: ${result.reason}`);
-  }
-  return { access: result.access, refresh: result.refresh, expires: result.expires };
-}
-
-export const anthropicAccounts: AccountProvider = {
-  id: "anthropic",
-  label: "Claude",
-
-  async list(): Promise<ManagedAccount[]> {
-    const storage = loadAccounts();
-    return (storage?.accounts ?? [])
-      .filter((account) => account.type === "oauth")
-      .map((account) => ({
-        id: account.id,
-        label: account.label ?? account.id.slice(0, 8),
-        enabled: account.enabled !== false,
-        expiresAt: typeof account.expires === "number" ? account.expires : undefined,
-      }));
-  },
-
-  async add(ctx, label): Promise<string | undefined> {
-    const proceed = await ctx.ui.confirm(
-      "Add Claude account",
-      "Use a different authorized Anthropic account in the browser. Continue?",
-    );
-    if (!proceed) return undefined;
-
-    const result = await authenticate(ctx);
-    if (!result) return undefined;
-
-    const now = Date.now();
-    saveAccount({
-      id: randomUUID(),
-      label,
-      type: "oauth",
-      enabled: true,
-      access: result.access,
-      refresh: result.refresh,
-      expires: result.expires,
-      addedAt: now,
-      lastRefreshedAt: now,
-      authLineageId: randomUUID(),
-    });
-    return label;
-  },
-
-  async reauth(ctx, accountId): Promise<string | undefined> {
-    const storage = loadAccounts();
-    const account = storage?.accounts.find(
-      (candidate) => candidate.id === accountId || candidate.label === accountId,
-    );
-    if (!account || account.type !== "oauth") {
-      throw new Error(`OAuth account “${accountId}” not found.`);
-    }
-
-    const result = await authenticate(ctx);
-    if (!result) return undefined;
-
-    saveAccount({
-      ...account,
-      access: result.access,
-      refresh: result.refresh,
-      expires: result.expires,
-      lastRefreshedAt: Date.now(),
-      authLineageId: randomUUID(),
-    });
-    return account.label ?? account.id;
-  },
-
-  async setEnabled(accountId: string, enabled: boolean): Promise<void> {
-    const storage = loadAccounts();
-    const account = storage?.accounts.find((candidate) => candidate.id === accountId);
-    if (!account) throw new Error(`Account “${accountId}” not found.`);
-    // Credentials are preserved; only the eligibility flag changes, so a
-    // disabled account can be re-enabled without another OAuth round trip.
-    saveAccount({ ...account, enabled });
-  },
-
-  async rename(accountId: string, label: string): Promise<void> {
-    const account = loadAccounts()?.accounts.find((candidate) => candidate.id === accountId);
-    if (!account) throw new Error(`Account “${accountId}” not found.`);
-    saveAccount({ ...account, label });
-  },
-
-  routing: {
-    async get(): Promise<RoutingMode> {
-      return fromStoreMode(getRoutingMode(loadAccounts()));
-    },
-    async set(mode: RoutingMode): Promise<RoutingMode> {
-      setRoutingMode(MODE_TO_STORE[mode]);
-      return mode;
-    },
-    describe(mode: RoutingMode): string {
-      return mode === "optimal"
-        ? "Balances sessions across subscriptions using remaining quota and time until reset. "
-          + "Keeps session caches sticky; migrates on confirmed exhaustion."
-        : "Main subscription first, then eligible fallbacks.";
-    },
-  },
-};
+import { randomUUID } from "node:crypto";
+import type { AccountContext, AccountProvider, ManagedAccount, RoutingMode } from "../../../core/accounts/registry.ts";
+import { authorize, exchange } from "../../../core/anthropic/oauth.ts";
+import {
+  getRoutingMode,
+  loadAccounts,
+  saveAccount,
+  setRoutingMode,
+  type RoutingMode as StoreRoutingMode,
+} from "../../../core/anthropic/store.ts";
+
+/**
+ * Anthropic adapter.
+ *
+ * pi itself holds one Anthropic credential; the additional accounts live in
+ * our own store and tokens are swapped per request. Everything
+ * provider-specific lives here so `/accounts` and `/routing` stay generic.
+ *
+ * This used to read through `vendor/anthropic.ts`, which loaded the cortexkit
+ * package. That package was removed when the provider was extracted, so every
+ * call here threw and the account list silently came back empty. It now uses
+ * the extracted store directly.
+ */
+
+/** The registry's vocabulary maps onto the store's routing modes. */
+const MODE_TO_STORE: Record<RoutingMode, StoreRoutingMode> = {
+  standard: "main-first",
+  optimal: "sticky-balanced",
+};
+
+function fromStoreMode(mode: string): RoutingMode {
+  return mode === "sticky-balanced" ? "optimal" : "standard";
+}
+
+async function authenticate(ctx: AccountContext): Promise<{ access: string; refresh: string; expires: number } | undefined> {
+  const auth = await authorize("max");
+
+  try {
+    await ctx.openBrowser(auth.url);
+  } catch {
+    ctx.ui.notify(`Open this authorization URL:\n${auth.url}`, "warning");
+  }
+
+  const callback = await ctx.ui.input("Claude OAuth", "Paste the callback URL or authorization code");
+  if (!callback) return undefined;
+
+  const result = await exchange(callback, auth.verifier, auth.redirectUri, auth.state);
+  if (result.type !== "success") {
+    throw new Error(`Claude OAuth exchange failed: ${result.reason}`);
+  }
+  return { access: result.access, refresh: result.refresh, expires: result.expires };
+}
+
+export const anthropicAccounts: AccountProvider = {
+  id: "anthropic",
+  label: "Claude",
+
+  async list(): Promise<ManagedAccount[]> {
+    const storage = loadAccounts();
+    return (storage?.accounts ?? [])
+      .filter((account) => account.type === "oauth")
+      .map((account) => ({
+        id: account.id,
+        label: account.label ?? account.id.slice(0, 8),
+        enabled: account.enabled !== false,
+        expiresAt: typeof account.expires === "number" ? account.expires : undefined,
+      }));
+  },
+
+  async add(ctx, label): Promise<string | undefined> {
+    const proceed = await ctx.ui.confirm(
+      "Add Claude account",
+      "Use a different authorized Anthropic account in the browser. Continue?",
+    );
+    if (!proceed) return undefined;
+
+    const result = await authenticate(ctx);
+    if (!result) return undefined;
+
+    const now = Date.now();
+    saveAccount({
+      id: randomUUID(),
+      label,
+      type: "oauth",
+      enabled: true,
+      access: result.access,
+      refresh: result.refresh,
+      expires: result.expires,
+      addedAt: now,
+      lastRefreshedAt: now,
+      authLineageId: randomUUID(),
+    });
+    return label;
+  },
+
+  async reauth(ctx, accountId): Promise<string | undefined> {
+    const storage = loadAccounts();
+    const account = storage?.accounts.find(
+      (candidate) => candidate.id === accountId || candidate.label === accountId,
+    );
+    if (!account || account.type !== "oauth") {
+      throw new Error(`OAuth account “${accountId}” not found.`);
+    }
+
+    const result = await authenticate(ctx);
+    if (!result) return undefined;
+
+    saveAccount({
+      ...account,
+      access: result.access,
+      refresh: result.refresh,
+      expires: result.expires,
+      lastRefreshedAt: Date.now(),
+      authLineageId: randomUUID(),
+    });
+    return account.label ?? account.id;
+  },
+
+  async setEnabled(accountId: string, enabled: boolean): Promise<void> {
+    const storage = loadAccounts();
+    const account = storage?.accounts.find((candidate) => candidate.id === accountId);
+    if (!account) throw new Error(`Account “${accountId}” not found.`);
+    // Credentials are preserved; only the eligibility flag changes, so a
+    // disabled account can be re-enabled without another OAuth round trip.
+    saveAccount({ ...account, enabled });
+  },
+
+  async rename(accountId: string, label: string): Promise<void> {
+    const account = loadAccounts()?.accounts.find((candidate) => candidate.id === accountId);
+    if (!account) throw new Error(`Account “${accountId}” not found.`);
+    saveAccount({ ...account, label });
+  },
+
+  routing: {
+    async get(): Promise<RoutingMode> {
+      return fromStoreMode(getRoutingMode(loadAccounts()));
+    },
+    async set(mode: RoutingMode): Promise<RoutingMode> {
+      setRoutingMode(MODE_TO_STORE[mode]);
+      return mode;
+    },
+    describe(mode: RoutingMode): string {
+      return mode === "optimal"
+        ? "Balances sessions across subscriptions using remaining quota and time until reset. "
+          + "Keeps session caches sticky; migrates on confirmed exhaustion."
+        : "Main subscription first, then eligible fallbacks.";
+    },
+  },
+};

package/src/domains/subscriptions/providers/codex.ts

@@ -1,148 +1,148 @@
-import { randomUUID } from "node:crypto";
-import type { AccountContext, AccountProvider, ManagedAccount, RoutingMode } from "../../../core/accounts/registry.ts";
-import { authorizeCodex, exchangeCodex } from "../../../core/codex/oauth.ts";
-import {
-  claimsOf,
-  loadCodexAccounts,
-  saveCodexAccount,
-  saveCodexAccounts,
-  type CodexAccount,
-} from "../../../core/codex/store.ts";
-
-/**
- * Codex adapter.
- *
- * Structurally the same as the Anthropic one, with two differences that come
- * from the provider rather than from us:
- *   - quota arrives only through response headers, so there is no poll;
- *   - every request must carry the account's `chatgpt-account-id`, so the
- *     account id is stored alongside the tokens rather than derived later.
- */
-
-async function authenticate(ctx: AccountContext) {
-  const auth = await authorizeCodex();
-
-  try {
-    await ctx.openBrowser(auth.url);
-  } catch {
-    ctx.ui.notify(`Open this authorization URL:\n${auth.url}`, "warning");
-  }
-
-  const callback = await ctx.ui.input("Codex OAuth", "Paste the callback URL or authorization code");
-  if (!callback) return undefined;
-
-  return exchangeCodex(callback, auth.verifier, auth.redirectUri, auth.state);
-}
-
-function describePlan(account: CodexAccount): string {
-  return account.plan ? `${account.label ?? account.id.slice(0, 8)} (${account.plan})` : (account.label ?? account.id.slice(0, 8));
-}
-
-export const codexAccounts: AccountProvider = {
-  id: "openai-codex",
-  label: "Codex",
-
-  async list(): Promise<ManagedAccount[]> {
-    return loadCodexAccounts().accounts.map((account) => ({
-      id: account.id,
-      label: describePlan(account),
-      enabled: account.enabled !== false,
-      expiresAt: typeof account.expires === "number" ? account.expires : undefined,
-    }));
-  },
-
-  async add(ctx, label): Promise<string | undefined> {
-    const proceed = await ctx.ui.confirm(
-      "Add Codex account",
-      "Sign in with a DIFFERENT ChatGPT account in the browser. Continue?",
-    );
-    if (!proceed) return undefined;
-
-    const tokens = await authenticate(ctx);
-    if (!tokens) return undefined;
-
-    const claims = claimsOf(tokens.access);
-
-    // Adding the same ChatGPT account twice gives routing two entries backed by
-    // one quota pool, which looks like capacity that does not exist.
-    const existing = loadCodexAccounts().accounts.find(
-      (a) => claims.accountId && a.accountId === claims.accountId,
-    );
-    if (existing) {
-      throw new Error(
-        `That ChatGPT account is already added as “${existing.label ?? existing.id.slice(0, 8)}”. `
-        + "Use the browser's account switcher to sign in as a different account.",
-      );
-    }
-
-    const now = Date.now();
-    saveCodexAccount({
-      id: randomUUID(),
-      label,
-      enabled: true,
-      access: tokens.access,
-      refresh: tokens.refresh,
-      expires: tokens.expires,
-      accountId: claims.accountId,
-      plan: claims.plan,
-      addedAt: now,
-      lastRefreshedAt: now,
-    });
-    return label;
-  },
-
-  async reauth(ctx, accountId): Promise<string | undefined> {
-    const account = loadCodexAccounts().accounts.find(
-      (a) => a.id === accountId || a.label === accountId,
-    );
-    if (!account) throw new Error(`Codex account “${accountId}” not found.`);
-
-    const tokens = await authenticate(ctx);
-    if (!tokens) return undefined;
-
-    const claims = claimsOf(tokens.access);
-    saveCodexAccount({
-      ...account,
-      access: tokens.access,
-      refresh: tokens.refresh,
-      expires: tokens.expires,
-      accountId: claims.accountId ?? account.accountId,
-      plan: claims.plan ?? account.plan,
-      lastRefreshedAt: Date.now(),
-    });
-    return account.label ?? account.id;
-  },
-
-  async setEnabled(accountId: string, enabled: boolean): Promise<void> {
-    const storage = loadCodexAccounts();
-    const account = storage.accounts.find((a) => a.id === accountId);
-    if (!account) throw new Error(`Account “${accountId}” not found.`);
-    account.enabled = enabled;
-    saveCodexAccounts(storage);
-  },
-
-  async rename(accountId: string, label: string): Promise<void> {
-    const storage = loadCodexAccounts();
-    const account = storage.accounts.find((a) => a.id === accountId);
-    if (!account) throw new Error(`Account “${accountId}” not found.`);
-    account.label = label;
-    saveCodexAccounts(storage);
-  },
-
-  routing: {
-    async get(): Promise<RoutingMode> {
-      return loadCodexAccounts().routing?.mode === "optimal" ? "optimal" : "standard";
-    },
-    async set(mode: RoutingMode): Promise<RoutingMode> {
-      const storage = loadCodexAccounts();
-      storage.routing = { ...(storage.routing ?? {}), mode };
-      saveCodexAccounts(storage);
-      return mode;
-    },
-    describe(mode: RoutingMode): string {
-      return mode === "optimal"
-        ? "Balances across Codex subscriptions using remaining quota and time until reset."
-        : "Main Codex subscription first, then eligible fallbacks.";
-    },
-  },
-};
+import { randomUUID } from "node:crypto";
+import type { AccountContext, AccountProvider, ManagedAccount, RoutingMode } from "../../../core/accounts/registry.ts";
+import { authorizeCodex, exchangeCodex } from "../../../core/codex/oauth.ts";
+import {
+  claimsOf,
+  loadCodexAccounts,
+  saveCodexAccount,
+  saveCodexAccounts,
+  type CodexAccount,
+} from "../../../core/codex/store.ts";
+
+/**
+ * Codex adapter.
+ *
+ * Structurally the same as the Anthropic one, with two differences that come
+ * from the provider rather than from us:
+ *   - quota arrives only through response headers, so there is no poll;
+ *   - every request must carry the account's `chatgpt-account-id`, so the
+ *     account id is stored alongside the tokens rather than derived later.
+ */
+
+async function authenticate(ctx: AccountContext) {
+  const auth = await authorizeCodex();
+
+  try {
+    await ctx.openBrowser(auth.url);
+  } catch {
+    ctx.ui.notify(`Open this authorization URL:\n${auth.url}`, "warning");
+  }
+
+  const callback = await ctx.ui.input("Codex OAuth", "Paste the callback URL or authorization code");
+  if (!callback) return undefined;
+
+  return exchangeCodex(callback, auth.verifier, auth.redirectUri, auth.state);
+}
+
+function describePlan(account: CodexAccount): string {
+  return account.plan ? `${account.label ?? account.id.slice(0, 8)} (${account.plan})` : (account.label ?? account.id.slice(0, 8));
+}
+
+export const codexAccounts: AccountProvider = {
+  id: "openai-codex",
+  label: "Codex",
+
+  async list(): Promise<ManagedAccount[]> {
+    return loadCodexAccounts().accounts.map((account) => ({
+      id: account.id,
+      label: describePlan(account),
+      enabled: account.enabled !== false,
+      expiresAt: typeof account.expires === "number" ? account.expires : undefined,
+    }));
+  },
+
+  async add(ctx, label): Promise<string | undefined> {
+    const proceed = await ctx.ui.confirm(
+      "Add Codex account",
+      "Sign in with a DIFFERENT ChatGPT account in the browser. Continue?",
+    );
+    if (!proceed) return undefined;
+
+    const tokens = await authenticate(ctx);
+    if (!tokens) return undefined;
+
+    const claims = claimsOf(tokens.access);
+
+    // Adding the same ChatGPT account twice gives routing two entries backed by
+    // one quota pool, which looks like capacity that does not exist.
+    const existing = loadCodexAccounts().accounts.find(
+      (a) => claims.accountId && a.accountId === claims.accountId,
+    );
+    if (existing) {
+      throw new Error(
+        `That ChatGPT account is already added as “${existing.label ?? existing.id.slice(0, 8)}”. `
+        + "Use the browser's account switcher to sign in as a different account.",
+      );
+    }
+
+    const now = Date.now();
+    saveCodexAccount({
+      id: randomUUID(),
+      label,
+      enabled: true,
+      access: tokens.access,
+      refresh: tokens.refresh,
+      expires: tokens.expires,
+      accountId: claims.accountId,
+      plan: claims.plan,
+      addedAt: now,
+      lastRefreshedAt: now,
+    });
+    return label;
+  },
+
+  async reauth(ctx, accountId): Promise<string | undefined> {
+    const account = loadCodexAccounts().accounts.find(
+      (a) => a.id === accountId || a.label === accountId,
+    );
+    if (!account) throw new Error(`Codex account “${accountId}” not found.`);
+
+    const tokens = await authenticate(ctx);
+    if (!tokens) return undefined;
+
+    const claims = claimsOf(tokens.access);
+    saveCodexAccount({
+      ...account,
+      access: tokens.access,
+      refresh: tokens.refresh,
+      expires: tokens.expires,
+      accountId: claims.accountId ?? account.accountId,
+      plan: claims.plan ?? account.plan,
+      lastRefreshedAt: Date.now(),
+    });
+    return account.label ?? account.id;
+  },
+
+  async setEnabled(accountId: string, enabled: boolean): Promise<void> {
+    const storage = loadCodexAccounts();
+    const account = storage.accounts.find((a) => a.id === accountId);
+    if (!account) throw new Error(`Account “${accountId}” not found.`);
+    account.enabled = enabled;
+    saveCodexAccounts(storage);
+  },
+
+  async rename(accountId: string, label: string): Promise<void> {
+    const storage = loadCodexAccounts();
+    const account = storage.accounts.find((a) => a.id === accountId);
+    if (!account) throw new Error(`Account “${accountId}” not found.`);
+    account.label = label;
+    saveCodexAccounts(storage);
+  },
+
+  routing: {
+    async get(): Promise<RoutingMode> {
+      return loadCodexAccounts().routing?.mode === "optimal" ? "optimal" : "standard";
+    },
+    async set(mode: RoutingMode): Promise<RoutingMode> {
+      const storage = loadCodexAccounts();
+      storage.routing = { ...(storage.routing ?? {}), mode };
+      saveCodexAccounts(storage);
+      return mode;
+    },
+    describe(mode: RoutingMode): string {
+      return mode === "optimal"
+        ? "Balances across Codex subscriptions using remaining quota and time until reset."
+        : "Main Codex subscription first, then eligible fallbacks.";
+    },
+  },
+};