@jameslovespancakes/pi-plus 1.0.11 → 1.0.12

package/src/domains/setup/index.ts

@@ -35,37 +35,37 @@ async function inspect(ctx: any): Promise<Feature[]> {
 
   /* subscriptions */
   const providers = accountProviders();
-  const accountSummary: string[] = [];
-  let anySignedIn = false;
-  for (const provider of providers) {
-    // pi holds the primary credential itself; the adapter only knows about the
-    // extra pooled accounts. Being signed in at all is what makes this usable.
-    let primary = false;
+  const accountStates = await Promise.all(providers.map(async (provider) => {
+    const primaryAuth = Promise.resolve()
+      .then(() => ctx.modelRegistry.getProviderAuth(provider.id))
+      .then((result: any) => !!result?.auth?.apiKey)
+      .catch(() => false);
     try {
-      primary = !!(await ctx.modelRegistry.getProviderAuth(provider.id))?.auth?.apiKey;
-    } catch { /* provider not configured */ }
-
-    try {
-      const accounts = await provider.list();
-      const routing = provider.routing ? await provider.routing.get() : "n/a";
+      const [primary, accounts, routing] = await Promise.all([
+        primaryAuth,
+        provider.list(),
+        provider.routing?.get(),
+      ]);
+      const signedIn = primary || accounts.length > 0;
       const pooled = accounts.length + (primary ? 1 : 0);
-      anySignedIn ||= primary || accounts.length > 0;
-      accountSummary.push(
-        primary || accounts.length > 0
-          ? `${provider.id}: ${pooled} account(s), routing=${routing}`
+      return {
+        signedIn,
+        summary: signedIn
+          ? `${provider.id}: ${pooled} account(s), routing=${routing ?? "n/a"}`
           : `${provider.id}: not signed in`,
-      );
+      };
     } catch {
-      accountSummary.push(`${provider.id}: unreadable`);
+      return { signedIn: await primaryAuth, summary: `${provider.id}: unreadable` };
     }
-  }
+  }));
+  const anySignedIn = accountStates.some((state) => state.signedIn);
   features.push({
     name: "Subscriptions",
     ready: anySignedIn,
-    detail: accountSummary.join("; ") || "no account providers registered",
-    commands: ["/account", "/account <provider> add", "/routing standard|optimal", "/usage"],
-    setup: anySignedIn ? undefined : "/account anthropic add",
-    open: "/account",
+    detail: accountStates.map((state) => state.summary).join("; ") || "no account providers registered",
+    commands: ["/accounts", "/accounts add <provider>", "/routing sequential|quota-aware", "/usage"],
+    setup: anySignedIn ? undefined : "/accounts add anthropic",
+    open: "/accounts",
   });
 
   /* benchmarks */

package/src/domains/subscriptions/accounts-picker.ts

@@ -2,14 +2,7 @@ import type { Component } from "@earendil-works/pi-tui";
 import { hasTruecolor, levelColor } from "../../ui/format.ts";
 import type { AccountProvider, ManagedAccount } from "../../core/accounts/registry.ts";
 
-/**
- * The `/accounts` list.
- *
- * Mirrors the provider picker: an inline SettingsList inside pi's own rule
- * chrome, toggled in place so nothing redraws the screen. Rows are grouped by
- * provider, because an account label alone ("Personal") does not say which
- * subscription it belongs to.
- */
+/** Inline account picker grouped by provider. */
 
 export type AccountState = "enabled" | "disabled";
 
@@ -36,28 +29,25 @@ export interface AccountRow {
   detail?: string;
 }
 
-/** Flattens every provider's accounts into one ordered list. */
+/** Flattens provider accounts while loading providers in parallel. */
 export async function accountRows(providers: AccountProvider[]): Promise<AccountRow[]> {
-  const rows: AccountRow[] = [];
-  for (const provider of providers) {
-    let accounts: ManagedAccount[] = [];
+  const groups = await Promise.all(providers.map(async (provider) => {
+    let accounts: ManagedAccount[];
     try {
       accounts = await provider.list();
     } catch {
-      continue; // A provider that cannot enumerate is simply not shown.
+      return [];
     }
-    for (const account of accounts) {
-      rows.push({
-        id: `${provider.id}:${account.id}`,
-        providerId: provider.id,
-        providerLabel: provider.label,
-        label: account.label,
-        state: account.enabled ? "enabled" : "disabled",
-        detail: account.primary ? "primary" : undefined,
-      });
-    }
-  }
-  return rows;
+    return accounts.map((account) => ({
+      id: `${provider.id}:${account.id}`,
+      providerId: provider.id,
+      providerLabel: provider.label,
+      label: account.label,
+      state: account.enabled ? "enabled" as const : "disabled" as const,
+      detail: account.primary ? "primary" : undefined,
+    }));
+  }));
+  return groups.flat();
 }
 
 function labelFor(theme: any, row: AccountRow): string {
@@ -79,13 +69,7 @@ function framed(theme: any, list: any, title: string): Component {
   } as Component;
 }
 
-/**
- * What closing the picker asked for.
- *
- * The wizards run AFTER the picker closes rather than inside it, so they can
- * use pi's ordinary select/input prompts instead of being reimplemented as
- * nested TUI components.
- */
+/** Wizard requested when the picker closes. */
 export type PickerAction = { kind: "add" } | { kind: "rename" } | undefined;
 
 /** Action row ids are namespaced so they cannot collide with an account id. */
@@ -94,8 +78,7 @@ const RENAME_ID = "__action_rename";
 
 export interface AccountPickerDeps {
   rows: () => Promise<AccountRow[]>;
-  /** Applies a toggle and returns the resulting state. Synchronous so the
-   *  label, dot and value all change in one render. */
+  /** Applies a toggle synchronously for one-render updates. */
   toggle: (providerId: string, accountId: string) => AccountState;
 }
 
@@ -118,9 +101,7 @@ export async function openAccountsPicker(ctx: any, deps: AccountPickerDeps): Pro
       description: row.detail,
     }));
 
-    // Actions live as rows rather than hidden keystrokes, so they are
-    // discoverable. A single-entry `values` makes Enter fire onChange without
-    // the row appearing to cycle through anything.
+    // Single-value action rows trigger onChange without cycling.
     items.push({
       id: ADD_ID,
       label: theme.fg("accent", "+ Add account"),

package/src/domains/subscriptions/accounts.ts

@@ -35,8 +35,10 @@ async function openBrowser(pi: ExtensionAPI, url: string): Promise<void> {
 function bridge(pi: ExtensionAPI, ctx: any): AccountContext {
   return {
     hasUI: ctx.hasUI,
+    signal: ctx.signal,
     ui: {
       input: (title, placeholder) => ctx.ui.input(title, placeholder),
+      select: (title, options) => ctx.ui.select(title, options),
       confirm: (title, message) => ctx.ui.confirm(title, message),
       notify: (message, type) => ctx.ui.notify(message, type ?? "info"),
     },
@@ -58,34 +60,34 @@ async function listAll(ctx: any): Promise<void> {
     return;
   }
 
-  const blocks: string[] = [];
-  for (const provider of providers) {
+  const blocks = await Promise.all(providers.map(async (provider): Promise<string[]> => {
     try {
-      const accounts = await provider.list();
-      const routing = provider.routing ? ` · routing: ${await provider.routing.get()}` : "";
-      blocks.push(
+      const [accounts, mode] = await Promise.all([
+        provider.list(),
+        provider.routing?.get(),
+      ]);
+      const routing = mode ? ` · routing: ${mode}` : "";
+      return [
         `${provider.label} (${provider.id})${routing}`,
         ...(accounts.length > 0
           ? accounts.map((account) => `  ${describe(account)}`)
-          : [`  no additional accounts, add one with /account ${provider.id} add`]),
-      );
+          : [`  no additional accounts, add one with /accounts add ${provider.id}`]),
+      ];
     } catch (error) {
-      blocks.push(`${provider.label} (${provider.id}): ${error instanceof Error ? error.message : String(error)}`);
+      return [`${provider.label} (${provider.id}): ${error instanceof Error ? error.message : String(error)}`];
     }
-  }
-  ctx.ui.notify(blocks.join("\n"), "info");
+  }));
+  ctx.ui.notify(blocks.flat().join("\n"), "info");
 }
 
-
-
 async function pickAccount(ctx: any, provider: AccountProvider): Promise<string | undefined> {
   const accounts = await provider.list();
   if (accounts.length === 0) {
-    ctx.ui.notify(`No ${provider.label} accounts yet. Add one with /account ${provider.id} add.`, "info");
+    ctx.ui.notify(`No ${provider.label} accounts yet. Add one with /accounts add ${provider.id}.`, "info");
     return undefined;
   }
   if (!ctx.hasUI) {
-    ctx.ui.notify(`Specify an account: /account ${provider.id} reauth <label>`, "warning");
+    ctx.ui.notify(`Choose an account with /accounts reauth ${provider.id}.`, "warning");
     return undefined;
   }
 
@@ -96,19 +98,15 @@ async function pickAccount(ctx: any, provider: AccountProvider): Promise<string
 }
 
 export function registerAccountCommands(pi: ExtensionAPI): void {
-  /** Toggles one account and returns the state it ended in. */
   const toggle = (providerId: string, accountId: string): AccountState => {
     const provider = accountProvider(providerId);
     if (!provider?.setEnabled) throw new Error(`${providerId} accounts cannot be disabled.`);
     const next = pendingState.get(`${providerId}:${accountId}`) === "enabled" ? "disabled" : "enabled";
     pendingState.set(`${providerId}:${accountId}`, next);
-    // Adapters persist asynchronously; the picker needs the answer now, so the
-    // write is fired off and failures surface as a notification.
     void provider.setEnabled(accountId, next === "enabled").catch(() => {});
     return next;
   };
 
-  /** Mirror of on-disk state, so the synchronous toggle can answer instantly. */
   const pendingState = new Map<string, AccountState>();
 
   const rows = async () => {
@@ -118,8 +116,7 @@ export function registerAccountCommands(pi: ExtensionAPI): void {
     return list;
   };
 
-  /** Adds an account: choose provider, name it, authorize. */
-  async function addAccount(ctx: any, providerId?: string): Promise<void> {
+  async function addAccount(ctx: any, providerId?: string, requestedLabel?: string): Promise<void> {
     if (!ctx.hasUI) {
       ctx.ui.notify("Adding an account requires interactive Pi mode.", "error");
       return;
@@ -144,7 +141,8 @@ export function registerAccountCommands(pi: ExtensionAPI): void {
     }
     if (!provider) return;
 
-    const label = await ctx.ui.input(`${provider.label} account name`, "Work, Personal, etc.");
+    const label = requestedLabel?.trim()
+      || await ctx.ui.input(`${provider.label} account name`, "Work, Personal, etc.");
     if (!label?.trim()) return;
 
     try {
@@ -155,7 +153,6 @@ export function registerAccountCommands(pi: ExtensionAPI): void {
     }
   }
 
-  /** Rename wizard: pick an account, type a new name. */
   async function renameAccount(ctx: any): Promise<void> {
     if (!ctx.hasUI) {
       ctx.ui.notify("Renaming an account requires interactive Pi mode.", "error");
@@ -179,7 +176,6 @@ export function registerAccountCommands(pi: ExtensionAPI): void {
 
     const provider = accountProvider(row.providerId);
     try {
-      // Row ids are "<providerId>:<accountId>"; strip the prefix.
       await provider!.rename!(row.id.slice(row.providerId.length + 1), next.trim());
       ctx.ui.notify(`Renamed to “${next.trim()}”.`, "info");
     } catch (error) {
@@ -202,15 +198,15 @@ export function registerAccountCommands(pi: ExtensionAPI): void {
         .map((id) => ({ value: `${parts[0]} ${id}`, label: id }));
     },
     handler: async (args, ctx) => {
-      const [action, providerId] = args.trim().split(/\s+/).filter(Boolean);
+      const [action, providerId, ...rest] = args.trim().split(/\s+/).filter(Boolean);
 
-      if (action === "add") return addAccount(ctx, providerId);
+      if (action === "add") return addAccount(ctx, providerId, rest.join(" ") || undefined);
       if (action === "rename") return renameAccount(ctx);
 
       if (action === "reauth") {
         const provider = providerId ? accountProvider(providerId) : accountProviders()[0];
         if (!provider) { ctx.ui.notify("No subscription providers are registered.", "error"); return; }
-        const target = await pickAccount(ctx, provider);
+        const target = rest.join(" ") || await pickAccount(ctx, provider);
         if (!target) return;
         try {
           const done = await provider.reauth(bridge(pi, ctx), target);
@@ -226,11 +222,9 @@ export function registerAccountCommands(pi: ExtensionAPI): void {
         return;
       }
 
-      // Bare /accounts: the picker interactively, plain text headless.
       if (!ctx.hasUI) return listAll(ctx);
 
-      // The picker closes to run a wizard, then reopens so the result is
-      // visible immediately. Bounded so a misbehaving action cannot spin.
+      // Reopen after each wizard so changes appear immediately.
       for (let step = 0; step < 24; step++) {
         const requested = await openAccountsPicker(ctx, { rows, toggle });
         if (!requested) return;

package/src/domains/subscriptions/footer.ts

@@ -4,20 +4,55 @@ import { refreshUsage, startPolling, stopPolling, subscribe, usageState } from "
 import { renderUsageLines, usageSummaryText } from "../../ui/usage-bars.ts";
 import { formatTokens, sanitize } from "../../ui/format.ts";
 
-/**
- * Single-line session footer (no working-directory line) with the subscription
- * bars rendered directly underneath it.
- *
- * The footer no longer owns the poll loop; it subscribes to usage-service and
- * re-renders on change. That is what lets non-UI consumers get fresh data.
- */
+/** Compact session footer with shared subscription usage bars. */
 
-const SUBSCRIPTION_PROVIDERS = new Set(["anthropic", "openai-codex", "kimi-coding"]);
+const SUBSCRIPTION_PROVIDERS = new Set(["anthropic", "openai-codex", "kimi-coding", "xai"]);
+
+interface SessionTotals {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  cost: number;
+  latestHitRate?: number;
+}
+
+function usageFor(entry: any): any {
+  if (entry.type === "message") {
+    return entry.message.role === "assistant" || entry.message.role === "toolResult" ? entry.message.usage : undefined;
+  }
+  return entry.type === "branch_summary" || entry.type === "compaction" ? entry.usage : undefined;
+}
+
+function sumSessionUsage(entries: any[]): SessionTotals {
+  const totals: SessionTotals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+  for (const entry of entries) {
+    const usage = usageFor(entry);
+    if (!usage) continue;
+    totals.input += usage.input ?? 0;
+    totals.output += usage.output ?? 0;
+    totals.cacheRead += usage.cacheRead ?? 0;
+    totals.cacheWrite += usage.cacheWrite ?? 0;
+    totals.cost += usage.cost?.total ?? 0;
+    if (entry.type === "message" && entry.message.role === "assistant") {
+      const prompt = (usage.input ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+      totals.latestHitRate = prompt > 0 ? ((usage.cacheRead ?? 0) / prompt) * 100 : undefined;
+    }
+  }
+  return totals;
+}
+
+function usageSignature(entries: any[]): string {
+  const last = entries.at(-1);
+  const usage = last ? usageFor(last) : undefined;
+  return [entries.length, last?.id, usage?.input, usage?.output, usage?.cacheRead, usage?.cacheWrite, usage?.cost?.total].join(":");
+}
 
 export function registerFooter(pi: ExtensionAPI): void {
   let showUsage = true;
   let requestRender: (() => void) | undefined;
   let unsubscribe: (() => void) | undefined;
+  let cachedUsage: { signature: string; totals: SessionTotals } | undefined;
 
   const apply = (ctx: any) => {
     if (!ctx.hasUI) return;
@@ -34,28 +69,12 @@ export function registerFooter(pi: ExtensionAPI): void {
           const width = Math.max(1, Math.floor(Number(rawWidth) || 0));
           const lines: string[] = [];
 
-          let input = 0;
-          let output = 0;
-          let cacheRead = 0;
-          let cacheWrite = 0;
-          let cost = 0;
-          let latestHitRate: number | undefined;
-
-          for (const entry of ctx.sessionManager.getEntries()) {
-            const usage = entry.type === "message"
-              ? (entry.message.role === "assistant" || entry.message.role === "toolResult" ? entry.message.usage : undefined)
-              : (entry.type === "branch_summary" || entry.type === "compaction" ? entry.usage : undefined);
-            if (!usage) continue;
-            input += usage.input ?? 0;
-            output += usage.output ?? 0;
-            cacheRead += usage.cacheRead ?? 0;
-            cacheWrite += usage.cacheWrite ?? 0;
-            cost += usage.cost?.total ?? 0;
-            if (entry.type === "message" && entry.message.role === "assistant") {
-              const prompt = (usage.input ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
-              latestHitRate = prompt > 0 ? ((usage.cacheRead ?? 0) / prompt) * 100 : undefined;
-            }
+          const entries = ctx.sessionManager.getEntries();
+          const signature = usageSignature(entries);
+          if (cachedUsage?.signature !== signature) {
+            cachedUsage = { signature, totals: sumSessionUsage(entries) };
           }
+          const { input, output, cacheRead, cacheWrite, cost, latestHitRate } = cachedUsage.totals;
 
           const parts: string[] = [];
           if (input) parts.push(`↑${formatTokens(input)}`);

package/src/domains/subscriptions/index.ts

@@ -1,40 +1,24 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { registerAccountProvider } from "../../core/accounts/registry.ts";
 import { anthropicAccounts } from "./providers/anthropic.ts";
-import { codexAccounts } from "./providers/codex.ts";
+import { codexAccounts, registerCodexProvider } from "./providers/codex.ts";
+import { kimiAccounts, KIMI_SPEC, xaiAccounts, XAI_SPEC } from "./providers/hosted.ts";
+import { registerPooledOAuthProvider } from "./providers/oauth-pool.ts";
 import { registerAnthropicProvider } from "./provider.ts";
 import { registerAccountCommands } from "./accounts.ts";
 import { registerRoutingCommands } from "./routing.ts";
 import { registerFooter } from "./footer.ts";
 
-/**
- * Subscriptions domain: Claude OAuth accounts, routing mode, and the quota HUD.
- *
- * This replaces the old `claude-multi-account.ts` + `compact-footer.ts` pair.
- * Account and routing commands are provider-agnostic: `/account <provider>` and
- * `/routing` dispatch through core/accounts/registry.ts, so adding a second
- * provider means writing one adapter, not new commands.
- * Authentication and model catalogue are separate concerns here; they were only
- * ever colocated because they shared an OAuth token.
- *
- * Relationship to @cortexkit/pi-anthropic-auth:
- *   That package stays installed and keeps ownership of the Anthropic provider,
- *   its stream implementation, and its own commands (/claude-account,
- *   /claude-routing, /claude-quota, ...). Absorbing it fully was evaluated and
- *   rejected, because its `dist/commands.js` exports only `registerCommands(pi)` as a
- *   unit, so taking over individual commands would mean copying ~130 lines of
- *   provider/model specs that drift on every vendor upgrade. This domain adds
- *   the multi-account surface the vendor does not provide, and everything it
- *   touches goes through src/vendor/anthropic.ts.
- */
+/** Registers subscription providers, pooled accounts, routing, and usage UI. */
 export default function subscriptions(pi: ExtensionAPI) {
-  // Adapters register first so the generic commands can see them.
-  registerAccountProvider(anthropicAccounts);
-  registerAccountProvider(codexAccounts);
+  for (const provider of [anthropicAccounts, codexAccounts, kimiAccounts, xaiAccounts]) {
+    registerAccountProvider(provider);
+  }
 
-  // Own the Anthropic provider unless explicitly told to defer to cortexkit.
-  // PI_PLUS_VENDOR_ANTHROPIC=1 restores the vendored package.
-  if (process.env.PI_PLUS_VENDOR_ANTHROPIC !== "1") registerAnthropicProvider(pi);
+  registerAnthropicProvider(pi);
+  registerCodexProvider(pi);
+  registerPooledOAuthProvider(pi, KIMI_SPEC);
+  registerPooledOAuthProvider(pi, XAI_SPEC);
 
   registerAccountCommands(pi);
   registerRoutingCommands(pi);