@camerontaylor/paseo-server 0.11.0-beta.1.fork.1 → 0.11.0-beta.3.fork.1

package/dist/server/builtin-plugins/codex-usage-source/server/usage.ts

@@ -1,8 +1,11 @@
-import { readFile } from "node:fs/promises";
+import { discoverOmp, piAuthPath, readHarness, readJson, type StoreLookup } from "./stores.js";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import {
   balanceToneFromRemaining,
+  hashAccountKey,
+  unavailable,
+  type UsageAccount,
   toneFromUsedPct,
   windowFromUsedPct,
   type UsageReport,
@@ -32,33 +35,82 @@ const responseSchema = z.object({
   credits: z.object({ balance: number.optional() }).nullish(),
 });
 
+interface Auth {
+  token: string;
+  accountId?: string;
+  idToken?: string;
+  expires?: number;
+}
+
+type RoutedInput = Extract<CodexUsageInput, { route: unknown }>;
+
+export async function discover(lookup: StoreLookup = {}): Promise<UsageAccount[]> {
+  const env = lookup.env ?? process.env;
+  const home = lookup.home ?? homedir();
+  const paths = [
+    ...(env.CODEX_HOME ? [join(env.CODEX_HOME, "auth.json")] : []),
+    join(home, ".codex", "auth.json"),
+  ];
+  const candidates: RoutedInput[] = [...new Set(paths)].map((path) => ({
+    route: { store: "codex", path },
+  }));
+  candidates.push(
+    {
+      route: {
+        store: "opencode",
+        path: join(env.XDG_DATA_HOME || join(home, ".local", "share"), "opencode", "auth.json"),
+      },
+    },
+    { route: { store: "pi", path: piAuthPath(lookup) } },
+    ...discoverOmp(lookup).map((route) => ({ route })),
+  );
+  const present: UsageAccount[] = [];
+  for (const input of candidates) {
+    const auth = await readAuth(input, lookup);
+    if (auth) present.push({ ...accountIdentity(auth, input), input });
+  }
+  return present;
+}
+
 export async function readAuth(
-  input: CodexUsageInput,
-): Promise<{ token: string; accountId?: string; idToken?: string } | null> {
-  let candidates: string[];
+  input: CodexUsageInput | Record<string, never>,
+  lookup: StoreLookup = {},
+): Promise<Auth | null> {
   if ("providerId" in input) {
-    candidates = input.codexHome ? [join(input.codexHome, "auth.json")] : [];
-  } else {
-    candidates = [
-      ...(process.env["CODEX_HOME"] ? [join(process.env["CODEX_HOME"], "auth.json")] : []),
-      join(homedir(), ".config", "codex", "auth.json"),
-      join(homedir(), ".codex", "auth.json"),
-    ];
+    if (!input.codexHome) return null;
+    return readAuth(
+      { route: { store: "codex", path: join(input.codexHome, "auth.json") } },
+      lookup,
+    );
   }
-  for (const path of candidates) {
-    try {
-      const auth = authSchema.parse(JSON.parse(await readFile(path, "utf8")));
-      if (auth.tokens?.access_token)
-        return {
-          token: auth.tokens.access_token,
-          accountId: auth.tokens.account_id,
-          idToken: auth.tokens.id_token,
-        };
-    } catch {
-      continue;
+  if (!("route" in input)) {
+    const env = lookup.env ?? process.env;
+    const home = lookup.home ?? homedir();
+    const paths = [
+      ...(env.CODEX_HOME ? [join(env.CODEX_HOME, "auth.json")] : []),
+      join(home, ".config", "codex", "auth.json"),
+      join(home, ".codex", "auth.json"),
+    ];
+    for (const path of new Set(paths)) {
+      const auth = await readAuth({ route: { store: "codex", path } }, lookup);
+      if (auth) return auth;
     }
+    return null;
+  }
+  const route = input.route;
+  if (route.store !== "codex") {
+    const oauth = await readHarness(route, lookup);
+    return oauth
+      ? { token: oauth.access, accountId: oauth.accountId, expires: oauth.expires }
+      : null;
   }
-  return null;
+  const auth = authSchema.safeParse(await readJson(route.path));
+  if (!auth.success || !auth.data.tokens?.access_token) return null;
+  return {
+    token: auth.data.tokens.access_token,
+    accountId: auth.data.tokens.account_id,
+    idToken: auth.data.tokens.id_token,
+  };
 }
 
 function usageWindow(
@@ -78,9 +130,17 @@ function usageWindow(
 export async function fetchUsage(
   input: CodexUsageInput,
   fetchApi: typeof fetch = fetch,
+  lookup: StoreLookup = {},
 ): Promise<UsageReport> {
-  const auth = await readAuth(input);
-  if (!auth) return { status: "unavailable", windows: [] };
+  const auth = await readAuth(input, lookup);
+  if (!auth) throw new Error("Codex login store no longer exists");
+  const refreshedBy = "route" in input ? input.route.store : "codex";
+  if (auth.expires !== undefined && auth.expires <= (lookup.now ?? Date.now)())
+    return unavailable({
+      kind: "expired",
+      expiresAt: new Date(auth.expires).toISOString(),
+      refreshedBy,
+    });
   const headers: Record<string, string> = {
     Authorization: `Bearer ${auth.token}`,
     Accept: "application/json",
@@ -92,10 +152,10 @@ export async function fetchUsage(
     signal: AbortSignal.timeout(15_000),
   });
   if (response.status === 401 || response.status === 403)
-    return { status: "unavailable", windows: [] };
+    return unavailable({ kind: "rejected", status: response.status, refreshedBy });
   if (!response.ok) throw new Error(`Codex usage API returned ${response.status}`);
   const text = await response.text();
-  if (text.trim().startsWith("<")) return { status: "unavailable", windows: [] };
+  if (text.trim().startsWith("<")) throw new Error("Codex usage API returned HTML");
   const usage = responseSchema.parse(JSON.parse(text));
   const windows = [
     usageWindow(
@@ -156,10 +216,7 @@ function claimString(value: unknown): string | null {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
 
-export async function identify(input: CodexUsageInput) {
-  if ("providerId" in input) return { key: `provider.${input.providerId}`, label: input.label };
-  const auth = await readAuth(input);
-  if (!auth) return null;
+function accountIdentity(auth: Auth, input: RoutedInput): { key: string; label?: string } {
   const access = jwtClaims(auth.token);
   const id = jwtClaims(auth.idToken);
   const accessAuth = claimObject(access, "https://api.openai.com/auth");
@@ -169,11 +226,24 @@ export async function identify(input: CodexUsageInput) {
     claimString(accessAuth?.["chatgpt_account_id"]) ??
     claimString(access?.["chatgpt_account_id"]) ??
     claimString(idAuth?.["chatgpt_account_id"]);
-  if (!key) return null;
+
   const label =
     claimString(claimObject(access, "https://api.openai.com/profile")?.["email"]) ??
     claimString(access?.["email"]) ??
     claimString(claimObject(id, "https://api.openai.com/profile")?.["email"]) ??
     claimString(id?.["email"]);
-  return { key, ...(label ? { label } : {}) };
+  return { key: key ?? hashAccountKey(JSON.stringify(input.route)), ...(label ? { label } : {}) };
+}
+
+export async function identify(
+  input: CodexUsageInput | Record<string, never>,
+  lookup: StoreLookup = {},
+) {
+  if ("providerId" in input) return { key: `provider.${input.providerId}`, label: input.label };
+  const auth = await readAuth(input, lookup);
+  if (!auth) return null;
+  if ("route" in input) return accountIdentity(auth, { route: input.route });
+  return accountIdentity(auth, {
+    route: { store: "codex", path: join(lookup.home ?? homedir(), ".codex", "auth.json") },
+  });
 }

package/dist/server/builtin-plugins/codex-usage-source/shared/input.ts

@@ -1,6 +1,17 @@
 import { z } from "zod";
+
+export const routeSchema = z.discriminatedUnion("store", [
+  z.object({ store: z.enum(["codex", "opencode", "pi"]), path: z.string().min(1) }).strict(),
+  z
+    .object({
+      store: z.literal("omp"),
+      path: z.string().min(1),
+      credentialId: z.number().int().positive(),
+    })
+    .strict(),
+]);
 export const inputSchema = z.union([
-  z.strictObject({}),
+  z.object({ route: routeSchema }).strict(),
   z.strictObject({
     providerId: z.string().min(1),
     label: z.string(),

package/dist/server/builtin-plugins/copilot-usage-source/index.server.ts

@@ -1,6 +1,6 @@
 import type { PluginServerContext } from "@camerontaylor/paseo-plugin/server";
 import { inputSchema } from "./shared/input.js";
-import { fetchUsage, identify } from "./server/usage.js";
+import { fetchUsage, discover } from "./server/usage.js";
 
 export default function contribute(server: PluginServerContext) {
   server.registerUsageSource({
@@ -8,8 +8,7 @@ export default function contribute(server: PluginServerContext) {
     label: "GitHub Copilot",
     icon: "icon.svg",
     input: inputSchema,
-    discover: async () => [{}],
-    identify,
+    discover: () => discover(),
     fetch: fetchUsage,
   });
   return () => {};

package/dist/server/builtin-plugins/copilot-usage-source/server/usage.ts

@@ -1,10 +1,11 @@
 import type { UsageInput } from "../shared/input.js";
-import { existsSync, promises as fs } from "node:fs";
+import { promises as fs } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { z } from "zod";
 import {
-  unavailableUsage,
+  unavailable,
+  type UsageAccount,
   type UsageReport,
   type UsageDetail,
 } from "@camerontaylor/paseo-plugin/server/usage";
@@ -19,39 +20,64 @@ const CopilotUsageResponseSchema = z.object({
   quota_reset_date: ApiOptionalStringSchema,
 });
 
-async function readGithubCliToken(): Promise<string | null> {
-  const candidates: string[] = [];
-  if (process.env["APPDATA"]) {
-    candidates.push(join(process.env["APPDATA"], "GitHub CLI", "hosts.yml"));
+type RoutedInput = Extract<UsageInput, { store: string }>;
+
+async function readToken(input: RoutedInput): Promise<string | undefined> {
+  if (input.store === "env") return process.env[input.locator];
+  try {
+    const raw = await fs.readFile(input.locator, "utf8");
+    return raw.match(/oauth_token:\s*["']?([a-zA-Z0-9_-]+)["']?/)?.[1];
+  } catch {
+    return undefined;
   }
-  candidates.push(join(homedir(), ".config", "gh", "hosts.yml"));
+}
 
-  for (const path of candidates) {
-    if (!existsSync(path)) continue;
-    try {
-      const raw = await fs.readFile(path, "utf8");
-      const match = raw.match(/oauth_token:\s*["']?([a-zA-Z0-9_-]+)["']?/);
-      if (match?.[1]) return match[1];
-    } catch {
-      continue;
-    }
+export async function discover(): Promise<UsageAccount[]> {
+  const candidates: RoutedInput[] = ["COPILOT_TOKEN", "GITHUB_TOKEN", "GITHUB_PAT"].map(
+    (locator) => ({ store: "env", locator }),
+  );
+  if (process.env.APPDATA)
+    candidates.push({
+      store: "file",
+      locator: join(process.env.APPDATA, "GitHub CLI", "hosts.yml"),
+    });
+  candidates.push({ store: "file", locator: join(homedir(), ".config", "gh", "hosts.yml") });
+  for (const input of candidates) if (await readToken(input)) return [{ key: "default", input }];
+  return [];
+}
+
+async function readDefaultToken(): Promise<string | undefined> {
+  for (const locator of ["COPILOT_TOKEN", "GITHUB_TOKEN", "GITHUB_PAT"]) {
+    const token = process.env[locator];
+    if (token) return token;
+  }
+  const paths = [
+    ...(process.env.APPDATA ? [join(process.env.APPDATA, "GitHub CLI", "hosts.yml")] : []),
+    join(homedir(), ".config", "gh", "hosts.yml"),
+  ];
+  for (const locator of paths) {
+    const token = await readToken({ store: "file", locator });
+    if (token) return token;
   }
-  return null;
+  return undefined;
 }
 
 export async function fetchUsage(
   input: UsageInput,
   fetchApi: typeof fetch = fetch,
 ): Promise<UsageReport> {
-  const token =
-    "providerId" in input
-      ? input.accessToken
-      : process.env["COPILOT_TOKEN"] ||
-        process.env["GITHUB_TOKEN"] ||
-        process.env["GITHUB_PAT"] ||
-        (await readGithubCliToken());
-
-  if (!token) return unavailableUsage();
+  let token: string | undefined;
+  if ("providerId" in input) token = input.accessToken;
+  else if ("store" in input) token = await readToken(input);
+  else token = await readDefaultToken();
+  if (!token) {
+    if ("providerId" in input)
+      return unavailable({
+        kind: "no_quota",
+        detail: "No Copilot token is configured for this provider account.",
+      });
+    throw new Error("Copilot login store no longer exists");
+  }
 
   const res = await fetchApi("https://api.github.com/copilot_internal/user", {
     signal: AbortSignal.timeout(15_000),
@@ -65,9 +91,9 @@ export async function fetchUsage(
     },
   });
 
-  if (!res.ok) {
-    return unavailableUsage();
-  }
+  if (res.status === 401 || res.status === 403)
+    return unavailable({ kind: "rejected", status: res.status });
+  if (!res.ok) throw new Error(`Copilot usage API returned ${res.status}`);
 
   const resp = CopilotUsageResponseSchema.parse(await res.json());
   const details: UsageDetail[] = resp.quota_reset_date
@@ -83,12 +109,11 @@ export async function fetchUsage(
   };
 }
 
-export async function identify(input: UsageInput = {}) {
+export async function identify(input: UsageInput | Record<string, never> = {}) {
   if ("providerId" in input) return { key: `provider.${input.providerId}`, label: input.label };
   const token =
-    process.env["COPILOT_TOKEN"] ||
-    process.env["GITHUB_TOKEN"] ||
-    process.env["GITHUB_PAT"] ||
-    (await readGithubCliToken());
+    "store" in input
+      ? await readToken({ store: input.store, locator: input.locator })
+      : await readDefaultToken();
   return token ? { key: "default" } : null;
 }

package/dist/server/builtin-plugins/copilot-usage-source/shared/input.ts

@@ -1,6 +1,12 @@
 import { z } from "zod";
+
 export const inputSchema = z.union([
-  z.strictObject({}),
+  z
+    .object({
+      store: z.enum(["env", "file"]),
+      locator: z.string().min(1),
+    })
+    .strict(),
   z.strictObject({
     providerId: z.string().min(1),
     label: z.string(),

package/dist/server/builtin-plugins/cursor-usage-source/index.server.ts

@@ -1,6 +1,6 @@
 import type { PluginServerContext } from "@camerontaylor/paseo-plugin/server";
 import { inputSchema } from "./shared/input.js";
-import { fetchUsage, identify } from "./server/usage.js";
+import { fetchUsage, discover } from "./server/usage.js";
 
 export default function contribute(server: PluginServerContext) {
   server.registerUsageSource({
@@ -8,8 +8,7 @@ export default function contribute(server: PluginServerContext) {
     label: "Cursor",
     icon: "icon.svg",
     input: inputSchema,
-    discover: async () => [{}],
-    identify,
+    discover: () => discover(),
     fetch: fetchUsage,
   });
   return () => {};

package/dist/server/builtin-plugins/cursor-usage-source/server/usage.ts

@@ -7,7 +7,8 @@ import { z } from "zod";
 import {
   toneFromUsedPct,
   usedPctOf,
-  unavailableUsage,
+  unavailable,
+  type UsageAccount,
   type UsageReport,
   type UsageBalance,
 } from "@camerontaylor/paseo-plugin/server/usage";
@@ -114,24 +115,7 @@ function cursorTokenFromDb(db: CursorStateDatabase): string | null {
   return null;
 }
 
-async function readCursorTokenFromSqlite(homeDir: string): Promise<string | null> {
-  const dbPaths: string[] = [];
-  if (process.env["APPDATA"]) {
-    dbPaths.push(join(process.env["APPDATA"], "Cursor", "User", "globalStorage", "state.vscdb"));
-  }
-  dbPaths.push(
-    join(
-      homeDir,
-      "Library",
-      "Application Support",
-      "Cursor",
-      "User",
-      "globalStorage",
-      "state.vscdb",
-    ),
-  );
-  dbPaths.push(join(homeDir, ".config", "Cursor", "User", "globalStorage", "state.vscdb"));
-
+async function readCursorTokenFromSqlite(path: string): Promise<string | null> {
   // Held in a variable so TypeScript skips module resolution: @types/node@20 has no
   // node:sqlite typings yet, while the runtime (Node 22+ / Electron) provides it.
   const sqliteSpecifier: string = "node:sqlite";
@@ -142,24 +126,19 @@ async function readCursorTokenFromSqlite(homeDir: string): Promise<string | null
     return null; // runtime without node:sqlite
   }
 
-  for (const path of dbPaths) {
-    if (!existsSync(path)) continue;
-    let db: CursorStateDatabase | undefined;
-    try {
-      db = new sqlite.DatabaseSync(path, { readOnly: true });
-      const token = cursorTokenFromDb(db);
-      if (token) return token;
-    } catch {
-      // Locked, permission, corrupt, or schema failures try the next candidate.
-    } finally {
-      db?.close();
-    }
+  if (!existsSync(path)) return null;
+  let db: CursorStateDatabase | undefined;
+  try {
+    db = new sqlite.DatabaseSync(path, { readOnly: true });
+    return cursorTokenFromDb(db);
+  } catch {
+    return null;
+  } finally {
+    db?.close();
   }
-  return null;
 }
 
-async function readCursorTokenFromAuthJson(homeDir: string): Promise<string | null> {
-  const path = join(homeDir, ".config", "cursor", "auth.json");
+async function readCursorTokenFromAuthJson(path: string): Promise<string | null> {
   if (!existsSync(path)) return null;
   try {
     const parsed = CursorAuthStatusSchema.parse(JSON.parse(await readFile(path, "utf8")));
@@ -173,16 +152,8 @@ export async function fetchUsage(
   input: UsageInput,
   fetchApi: typeof fetch = fetch,
 ): Promise<UsageReport> {
-  void input;
-  const homeDir = homedir();
-
-  const token =
-    process.env["CURSOR_ACCESS_TOKEN"] ||
-    process.env["CURSOR_TOKEN"] ||
-    (await readCursorTokenFromSqlite(homeDir)) ||
-    (await readCursorTokenFromAuthJson(homeDir));
-
-  if (!token) return unavailableUsage();
+  const token = await readToken(input);
+  if (!token) throw new Error("Cursor login store no longer exists");
 
   const res = await fetchApi(
     "https://api2.cursor.sh/aiserver.v1.DashboardService/GetCurrentPeriodUsage",
@@ -198,9 +169,9 @@ export async function fetchUsage(
     },
   );
 
-  if (!res.ok) {
-    return unavailableUsage();
-  }
+  if (res.status === 401 || res.status === 403)
+    return unavailable({ kind: "rejected", status: res.status });
+  if (!res.ok) throw new Error(`Cursor usage API returned ${res.status}`);
 
   const resp = CursorUsageResponseSchema.parse(await res.json());
   const billingCycleEnd = parseCursorBillingCycleTimestamp(resp.billingCycleEnd);
@@ -230,12 +201,40 @@ export async function fetchUsage(
   };
 }
 
-export async function identify() {
-  const home = homedir();
+async function readToken(input: UsageInput): Promise<string | undefined> {
+  if (input.store === "env") return process.env[input.locator];
   const token =
-    process.env["CURSOR_ACCESS_TOKEN"] ||
-    process.env["CURSOR_TOKEN"] ||
-    (await readCursorTokenFromSqlite(home)) ||
-    (await readCursorTokenFromAuthJson(home));
-  return token ? { key: "default" } : null;
+    input.store === "sqlite"
+      ? await readCursorTokenFromSqlite(input.locator)
+      : await readCursorTokenFromAuthJson(input.locator);
+  return token ?? undefined;
+}
+export async function discover(): Promise<UsageAccount[]> {
+  const home = homedir();
+  const candidates: UsageInput[] = ["CURSOR_ACCESS_TOKEN", "CURSOR_TOKEN"].map((locator) => ({
+    store: "env",
+    locator,
+  }));
+  if (process.env.APPDATA)
+    candidates.push({
+      store: "sqlite",
+      locator: join(process.env.APPDATA, "Cursor", "User", "globalStorage", "state.vscdb"),
+    });
+  candidates.push(
+    ...[
+      join(
+        home,
+        "Library",
+        "Application Support",
+        "Cursor",
+        "User",
+        "globalStorage",
+        "state.vscdb",
+      ),
+      join(home, ".config", "Cursor", "User", "globalStorage", "state.vscdb"),
+    ].map((locator) => ({ store: "sqlite" as const, locator })),
+    { store: "file", locator: join(home, ".config", "cursor", "auth.json") },
+  );
+  for (const input of candidates) if (await readToken(input)) return [{ key: "default", input }];
+  return [];
 }

package/dist/server/builtin-plugins/cursor-usage-source/shared/input.ts

@@ -1,4 +1,8 @@
 import { z } from "zod";
-export const inputSchema = z.object({}).strict();
-
+export const inputSchema = z
+  .object({
+    store: z.enum(["env", "file", "sqlite"]),
+    locator: z.string().min(1),
+  })
+  .strict();
 export type UsageInput = z.infer<typeof inputSchema>;

package/dist/server/builtin-plugins/grok-usage-source/index.server.ts

@@ -1,6 +1,6 @@
 import type { PluginServerContext } from "@camerontaylor/paseo-plugin/server";
 import { inputSchema } from "./shared/input.js";
-import { fetchUsage, identify } from "./server/usage.js";
+import { fetchUsage, discover } from "./server/usage.js";
 
 export default function contribute(server: PluginServerContext) {
   server.registerUsageSource({
@@ -8,8 +8,7 @@ export default function contribute(server: PluginServerContext) {
     label: "Grok",
     icon: "icon.svg",
     input: inputSchema,
-    discover: async () => [{}],
-    identify,
+    discover: () => discover(),
     fetch: fetchUsage,
   });
   return () => {};

package/dist/server/builtin-plugins/grok-usage-source/server/usage.ts

@@ -1,12 +1,13 @@
 import type { UsageInput } from "../shared/input.js";
-import { existsSync, promises as fs } from "node:fs";
+import { promises as fs } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { z } from "zod";
 import {
   toneFromUsedPct,
   usedPctOf,
-  unavailableUsage,
+  unavailable,
+  type UsageAccount,
   windowFromUsedPct,
   type UsageReport,
   type UsageWindow,
@@ -109,23 +110,8 @@ export async function fetchUsage(
   input: UsageInput,
   fetchApi: typeof fetch = fetch,
 ): Promise<UsageReport> {
-  void input;
-  const homeDir = homedir();
-
-  async function readGrokToken(): Promise<string | null> {
-    // homeDir override is for tests: Windows os.homedir() ignores $HOME (uses USERPROFILE).
-    const path = join(homeDir ?? homedir(), ".grok", "auth.json");
-    if (!existsSync(path)) return null;
-    try {
-      return extractGrokTokenFromAuth(JSON.parse(await fs.readFile(path, "utf8")));
-    } catch {
-      return null;
-    }
-  }
-
-  const token = process.env["GROK_API_KEY"] || process.env["GROK_TOKEN"] || (await readGrokToken());
-
-  if (!token) return unavailableUsage();
+  const token = await readToken(input);
+  if (!token) throw new Error("Grok login store no longer exists");
 
   // The Grok CLI's /usage uses ?format=credits; without it, unified-billing accounts
   // get a zeroed legacy monthly shape (monthlyLimit.val 0) instead of real usage.
@@ -138,9 +124,9 @@ export async function fetchUsage(
     },
   });
 
-  if (!res.ok) {
-    return unavailableUsage();
-  }
+  if (res.status === 401 || res.status === 403)
+    return unavailable({ kind: "rejected", status: res.status });
+  if (!res.ok) throw new Error(`Grok usage API returned ${res.status}`);
 
   const resp = GrokUsageResponseSchema.parse(await res.json());
   const balance = grokMonthlyCreditBalance(resp);
@@ -155,12 +141,22 @@ export async function fetchUsage(
   };
 }
 
-export async function identify() {
-  if (process.env["GROK_API_KEY"] || process.env["GROK_TOKEN"]) return { key: "default" };
+async function readToken(input: UsageInput): Promise<string | undefined> {
+  if (input.store === "env") return process.env[input.locator];
   try {
-    const auth = JSON.parse(await fs.readFile(join(homedir(), ".grok", "auth.json"), "utf8"));
-    return extractGrokTokenFromAuth(auth) ? { key: "default" } : null;
+    return (
+      extractGrokTokenFromAuth(JSON.parse(await fs.readFile(input.locator, "utf8"))) ?? undefined
+    );
   } catch {
-    return null;
+    return undefined;
   }
 }
+export async function discover(): Promise<UsageAccount[]> {
+  const candidates: UsageInput[] = ["GROK_API_KEY", "GROK_TOKEN"].map((locator) => ({
+    store: "env",
+    locator,
+  }));
+  candidates.push({ store: "file", locator: join(homedir(), ".grok", "auth.json") });
+  for (const input of candidates) if (await readToken(input)) return [{ key: "default", input }];
+  return [];
+}

package/dist/server/builtin-plugins/grok-usage-source/shared/input.ts

@@ -1,4 +1,8 @@
 import { z } from "zod";
-export const inputSchema = z.object({}).strict();
-
+export const inputSchema = z
+  .object({
+    store: z.enum(["env", "file"]),
+    locator: z.string().min(1),
+  })
+  .strict();
 export type UsageInput = z.infer<typeof inputSchema>;