@jameslovespancakes/pi-plus 1.0.0 → 1.0.1

package/src/core/policy/policy.ts

@@ -1,183 +1,183 @@
-import { readConfig, updateConfig } from "../config.ts";
-
-/**
- * Approval policy for model selection.
- *
- * Subscription providers are free to use. Metered providers (OpenRouter and
- * anything else that bills per token) require an explicit approval before a
- * request is allowed to leave the machine.
- */
-
-export interface PolicyFile {
-  autoApprove: string[];
-  requireApproval: string[];
-  deny: string[];
-}
-
-const DEFAULT_POLICY: PolicyFile = {
-  autoApprove: ["anthropic/*", "openai-codex/*"],
-  requireApproval: ["openrouter/*", "google/*", "openai/*", "xai/*"],
-  deny: [],
-};
-
-export type Decision =
-  | { allowed: true; reason: "auto" | "approved" }
-  | { allowed: false; reason: "denied" | "needs-approval"; message: string };
-
-const approvals = new Map<string, number>();
-
-export function loadPolicy(): PolicyFile {
-  return readConfig().policy;
-}
-
-export function savePolicy(next: PolicyFile): void {
-  updateConfig((config) => {
-    config.policy = {
-      autoApprove: next.autoApprove ?? DEFAULT_POLICY.autoApprove,
-      requireApproval: next.requireApproval ?? DEFAULT_POLICY.requireApproval,
-      deny: next.deny ?? DEFAULT_POLICY.deny,
-    };
-  });
-}
-
-function matches(pattern: string, value: string): boolean {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-  return new RegExp(`^${escaped}$`).test(value);
-}
-
-function matchesAny(patterns: string[], value: string): boolean {
-  return patterns.some((pattern) => matches(pattern, value));
-}
-
-/**
- * Provider ids that require approval, derived from the policy patterns so the
- * toggle list always reflects the configured file rather than a hardcoded set.
- */
-export function gatedProviders(): string[] {
-  const names = loadPolicy().requireApproval
-    .map((pattern) => pattern.split("/")[0])
-    .filter((name) => name && !name.includes("*"));
-  return [...new Set(names)].sort();
-}
-
-export type ProviderState = "auto" | "approved" | "blocked" | "denied";
-
-/** How the policy currently treats a provider, for display and toggling. */
-export function providerState(provider: string): ProviderState {
-  const current = loadPolicy();
-  if (matchesAny(current.deny, `${provider}/*`) || matchesAny(current.deny, provider)) return "denied";
-  if (matchesAny(current.requireApproval, `${provider}/*`)) {
-    return isApproved(provider) ? "approved" : "blocked";
-  }
-  return "auto";
-}
-
-/**
- * Flips whether a provider may be used.
- *
- * Auto-approved providers are moved into `requireApproval` so the switch is
- * reversible; gated ones just gain or lose their session grant. Denied
- * providers are left alone; `deny` is an explicit, deliberate block.
- */
-export function toggleProvider(provider: string): ProviderState {
-  const state = providerState(provider);
-  if (state === "denied") return state;
-
-  if (state === "auto") {
-    const current = loadPolicy();
-    savePolicy({
-      ...current,
-      autoApprove: current.autoApprove.filter((pattern) => !matches(pattern, `${provider}/*`) && pattern !== `${provider}/*`),
-      requireApproval: [...new Set([...current.requireApproval, `${provider}/*`])],
-    });
-    revoke(provider);
-    return "blocked";
-  }
-
-  if (state === "approved") {
-    revoke(provider);
-    return "blocked";
-  }
-
-  approve(provider);
-  return "approved";
-}
-
-/** Grant approval for a provider until `untilMs` (omitted means this session). */
-export function approve(provider: string, durationMs?: number): void {
-  approvals.set(provider, durationMs ? Date.now() + durationMs : Number.MAX_SAFE_INTEGER);
-}
-
-export function revoke(provider: string): void {
-  approvals.delete(provider);
-}
-
-export function isApproved(provider: string): boolean {
-  const until = approvals.get(provider);
-  return until !== undefined && Date.now() < until;
-}
-
-/** Flips a provider's approval and reports the resulting state. */
-export function toggleApproval(provider: string): boolean {
-  if (isApproved(provider)) {
-    revoke(provider);
-    return false;
-  }
-  approve(provider);
-  return true;
-}
-
-export interface ProviderApproval {
-  provider: string;
-  approved: boolean;
-  until?: number;
-}
-
-/** Current approval state for every gated provider, for display. */
-export function approvalStates(): ProviderApproval[] {
-  return gatedProviders().map((provider) => {
-    const until = approvals.get(provider);
-    const approved = until !== undefined && Date.now() < until;
-    return { provider, approved, until: approved && until !== Number.MAX_SAFE_INTEGER ? until : undefined };
-  });
-}
-
-export function checkModel(provider: string, modelId: string): Decision {
-  const current = loadPolicy();
-  const ref = `${provider}/${modelId}`;
-
-  if (matchesAny(current.deny, ref) || matchesAny(current.deny, `${provider}/*`)) {
-    return { allowed: false, reason: "denied", message: `${ref} is denied by model policy.` };
-  }
-  if (matchesAny(current.autoApprove, ref)) return { allowed: true, reason: "auto" };
-
-  const gated = matchesAny(current.requireApproval, ref);
-  if (!gated) return { allowed: true, reason: "auto" };
-
-  if (!isApproved(provider)) {
-    return {
-      allowed: false,
-      reason: "needs-approval",
-      message:
-        `${ref} is a metered (pay-per-token) model and is not approved in this session. `
-        + `Use a subscription model such as anthropic/* or openai-codex/*, or ask the user to run `
-        + `/provider approve ${provider}.`,
-    };
-  }
-
-  return { allowed: true, reason: "approved" };
-}
-
-export function policySummary(): string {
-  const current = loadPolicy();
-  const active = approvalStates()
-    .filter((entry) => entry.approved)
-    .map((entry) => `${entry.provider}${entry.until ? ` (until ${new Date(entry.until).toLocaleTimeString()})` : " (session)"}`);
-  return [
-    "Model approval policy",
-    `  auto-approved:    ${current.autoApprove.join(", ") || "none"}`,
-    `  needs approval:   ${current.requireApproval.join(", ") || "none"}`,
-    `  denied:           ${current.deny.join(", ") || "none"}`,
-    `  approved now:     ${active.join(", ") || "none"}`,
-  ].join("\n");
-}
+import { readConfig, updateConfig } from "../config.ts";
+
+/**
+ * Approval policy for model selection.
+ *
+ * Subscription providers are free to use. Metered providers (OpenRouter and
+ * anything else that bills per token) require an explicit approval before a
+ * request is allowed to leave the machine.
+ */
+
+export interface PolicyFile {
+  autoApprove: string[];
+  requireApproval: string[];
+  deny: string[];
+}
+
+const DEFAULT_POLICY: PolicyFile = {
+  autoApprove: ["anthropic/*", "openai-codex/*"],
+  requireApproval: ["openrouter/*", "google/*", "openai/*", "xai/*"],
+  deny: [],
+};
+
+export type Decision =
+  | { allowed: true; reason: "auto" | "approved" }
+  | { allowed: false; reason: "denied" | "needs-approval"; message: string };
+
+const approvals = new Map<string, number>();
+
+export function loadPolicy(): PolicyFile {
+  return readConfig().policy;
+}
+
+export function savePolicy(next: PolicyFile): void {
+  updateConfig((config) => {
+    config.policy = {
+      autoApprove: next.autoApprove ?? DEFAULT_POLICY.autoApprove,
+      requireApproval: next.requireApproval ?? DEFAULT_POLICY.requireApproval,
+      deny: next.deny ?? DEFAULT_POLICY.deny,
+    };
+  });
+}
+
+function matches(pattern: string, value: string): boolean {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`).test(value);
+}
+
+function matchesAny(patterns: string[], value: string): boolean {
+  return patterns.some((pattern) => matches(pattern, value));
+}
+
+/**
+ * Provider ids that require approval, derived from the policy patterns so the
+ * toggle list always reflects the configured file rather than a hardcoded set.
+ */
+export function gatedProviders(): string[] {
+  const names = loadPolicy().requireApproval
+    .map((pattern) => pattern.split("/")[0])
+    .filter((name) => name && !name.includes("*"));
+  return [...new Set(names)].sort();
+}
+
+export type ProviderState = "auto" | "approved" | "blocked" | "denied";
+
+/** How the policy currently treats a provider, for display and toggling. */
+export function providerState(provider: string): ProviderState {
+  const current = loadPolicy();
+  if (matchesAny(current.deny, `${provider}/*`) || matchesAny(current.deny, provider)) return "denied";
+  if (matchesAny(current.requireApproval, `${provider}/*`)) {
+    return isApproved(provider) ? "approved" : "blocked";
+  }
+  return "auto";
+}
+
+/**
+ * Flips whether a provider may be used.
+ *
+ * Auto-approved providers are moved into `requireApproval` so the switch is
+ * reversible; gated ones just gain or lose their session grant. Denied
+ * providers are left alone; `deny` is an explicit, deliberate block.
+ */
+export function toggleProvider(provider: string): ProviderState {
+  const state = providerState(provider);
+  if (state === "denied") return state;
+
+  if (state === "auto") {
+    const current = loadPolicy();
+    savePolicy({
+      ...current,
+      autoApprove: current.autoApprove.filter((pattern) => !matches(pattern, `${provider}/*`) && pattern !== `${provider}/*`),
+      requireApproval: [...new Set([...current.requireApproval, `${provider}/*`])],
+    });
+    revoke(provider);
+    return "blocked";
+  }
+
+  if (state === "approved") {
+    revoke(provider);
+    return "blocked";
+  }
+
+  approve(provider);
+  return "approved";
+}
+
+/** Grant approval for a provider until `untilMs` (omitted means this session). */
+export function approve(provider: string, durationMs?: number): void {
+  approvals.set(provider, durationMs ? Date.now() + durationMs : Number.MAX_SAFE_INTEGER);
+}
+
+export function revoke(provider: string): void {
+  approvals.delete(provider);
+}
+
+export function isApproved(provider: string): boolean {
+  const until = approvals.get(provider);
+  return until !== undefined && Date.now() < until;
+}
+
+/** Flips a provider's approval and reports the resulting state. */
+export function toggleApproval(provider: string): boolean {
+  if (isApproved(provider)) {
+    revoke(provider);
+    return false;
+  }
+  approve(provider);
+  return true;
+}
+
+export interface ProviderApproval {
+  provider: string;
+  approved: boolean;
+  until?: number;
+}
+
+/** Current approval state for every gated provider, for display. */
+export function approvalStates(): ProviderApproval[] {
+  return gatedProviders().map((provider) => {
+    const until = approvals.get(provider);
+    const approved = until !== undefined && Date.now() < until;
+    return { provider, approved, until: approved && until !== Number.MAX_SAFE_INTEGER ? until : undefined };
+  });
+}
+
+export function checkModel(provider: string, modelId: string): Decision {
+  const current = loadPolicy();
+  const ref = `${provider}/${modelId}`;
+
+  if (matchesAny(current.deny, ref) || matchesAny(current.deny, `${provider}/*`)) {
+    return { allowed: false, reason: "denied", message: `${ref} is denied by model policy.` };
+  }
+  if (matchesAny(current.autoApprove, ref)) return { allowed: true, reason: "auto" };
+
+  const gated = matchesAny(current.requireApproval, ref);
+  if (!gated) return { allowed: true, reason: "auto" };
+
+  if (!isApproved(provider)) {
+    return {
+      allowed: false,
+      reason: "needs-approval",
+      message:
+        `${ref} is a metered (pay-per-token) model and is not approved in this session. `
+        + `Use a subscription model such as anthropic/* or openai-codex/*, or ask the user to run `
+        + `/provider approve ${provider}.`,
+    };
+  }
+
+  return { allowed: true, reason: "approved" };
+}
+
+export function policySummary(): string {
+  const current = loadPolicy();
+  const active = approvalStates()
+    .filter((entry) => entry.approved)
+    .map((entry) => `${entry.provider}${entry.until ? ` (until ${new Date(entry.until).toLocaleTimeString()})` : " (session)"}`);
+  return [
+    "Model approval policy",
+    `  auto-approved:    ${current.autoApprove.join(", ") || "none"}`,
+    `  needs approval:   ${current.requireApproval.join(", ") || "none"}`,
+    `  denied:           ${current.deny.join(", ") || "none"}`,
+    `  approved now:     ${active.join(", ") || "none"}`,
+  ].join("\n");
+}

package/src/core/quota/pool.ts

@@ -1,64 +1,64 @@
-export type UsageRow = {
-  group: string;
-  label: string;
-  remaining: number;
-  resetAt?: number;
-  checkedAt?: number;
-  stale?: boolean;
-  capacity?: number;
-};
-
-/*
- * How old a usage sample may be and still be poolable.
- *
- * This was 6 minutes when every refresh fetched the usage endpoint live.
- * Quota now comes from response headers, backed by a poll at most once per
- * 10 minutes, so a 6 minute bound marked idle accounts stale almost all the
- * time. It must stay comfortably above that poll interval; the underlying
- * windows are 5 hours and 7 days, so a sample minutes old is still accurate.
- */
-export const CLAUDE_FRESH_MS = 12 * 60_000;
-export const isClaudeAccount = (row: UsageRow) => row.group.startsWith("Claude ") && !row.group.startsWith("Claude pool ×");
-export const isFresh = (row: UsageRow, now = Date.now()) => !row.stale && !!row.checkedAt
-  && now - row.checkedAt < CLAUDE_FRESH_MS && (!row.resetAt || row.resetAt > now);
-
-/** Percent of combined capacity, not a claim that quota transfers between accounts.
- * Without published capacities this is explicitly an equal-account estimate.
- */
-export function combinedWindow(rows: UsageRow[], label: string, expected: number, now = Date.now(), allowPartial = false) {
-  const matching = rows.filter((r) => isClaudeAccount(r) && r.label === label && isFresh(r, now));
-  const partial = matching.length !== expected;
-  if (!expected || !matching.length || (partial && !allowPartial)) return undefined;
-  const weighted = matching.every((r) => typeof r.capacity === "number" && r.capacity > 0);
-  const total = matching.reduce((sum, r) => sum + (weighted ? r.capacity! : 1), 0);
-  const remaining = matching.reduce((sum, r) => sum + r.remaining * (weighted ? r.capacity! : 1), 0) / total;
-  const resets = matching.map((r) => r.resetAt).filter((t): t is number => !!t && t > now);
-  return { label, remaining, resetAt: resets.length ? Math.min(...resets) : undefined, estimated: !weighted, partial };
-}
-
-export function scopedLabels(rows: UsageRow[], modelId?: string): string[] {
-  const labels = [...new Set(rows.filter(isClaudeAccount).map((r) => r.label).filter((l) => l.startsWith("7d ")))];
-  const model = modelId?.toLowerCase() ?? "";
-  return labels.sort((a, b) => Number(matchesScope(b, model)) - Number(matchesScope(a, model)) || a.localeCompare(b));
-}
-
-function matchesScope(label: string, model: string): boolean {
-  const family = label.slice(3).toLowerCase();
-  return model.includes(family) || (family === "fable" && model.includes("mythos"));
-}
-
-/** An account must pass ALL applicable windows; independent averages cannot answer this. */
-export function poolAvailability(rows: UsageRow[], expected: number, modelId?: string, now = Date.now()) {
-  const groups = [...new Set(rows.filter(isClaudeAccount).map((r) => r.group))];
-  let ready = 0;
-  let unknown = Math.max(0, expected - groups.length);
-  for (const group of groups) {
-    const account = rows.filter((r) => r.group === group);
-    const required = ["5h", "7d", ...scopedLabels(account).filter((l) => matchesScope(l, modelId?.toLowerCase() ?? ""))];
-    const windows = required.map((label) => account.find((r) => r.label === label));
-    if (windows.some((r) => r && isFresh(r, now) && r.remaining <= 0)) continue;
-    if (windows.some((r) => !r || !isFresh(r, now))) { unknown++; continue; }
-    ready++;
-  }
-  return { ready, unknown, total: expected };
-}
+export type UsageRow = {
+  group: string;
+  label: string;
+  remaining: number;
+  resetAt?: number;
+  checkedAt?: number;
+  stale?: boolean;
+  capacity?: number;
+};
+
+/*
+ * How old a usage sample may be and still be poolable.
+ *
+ * This was 6 minutes when every refresh fetched the usage endpoint live.
+ * Quota now comes from response headers, backed by a poll at most once per
+ * 10 minutes, so a 6 minute bound marked idle accounts stale almost all the
+ * time. It must stay comfortably above that poll interval; the underlying
+ * windows are 5 hours and 7 days, so a sample minutes old is still accurate.
+ */
+export const CLAUDE_FRESH_MS = 12 * 60_000;
+export const isClaudeAccount = (row: UsageRow) => row.group.startsWith("Claude ") && !row.group.startsWith("Claude pool ×");
+export const isFresh = (row: UsageRow, now = Date.now()) => !row.stale && !!row.checkedAt
+  && now - row.checkedAt < CLAUDE_FRESH_MS && (!row.resetAt || row.resetAt > now);
+
+/** Percent of combined capacity, not a claim that quota transfers between accounts.
+ * Without published capacities this is explicitly an equal-account estimate.
+ */
+export function combinedWindow(rows: UsageRow[], label: string, expected: number, now = Date.now(), allowPartial = false) {
+  const matching = rows.filter((r) => isClaudeAccount(r) && r.label === label && isFresh(r, now));
+  const partial = matching.length !== expected;
+  if (!expected || !matching.length || (partial && !allowPartial)) return undefined;
+  const weighted = matching.every((r) => typeof r.capacity === "number" && r.capacity > 0);
+  const total = matching.reduce((sum, r) => sum + (weighted ? r.capacity! : 1), 0);
+  const remaining = matching.reduce((sum, r) => sum + r.remaining * (weighted ? r.capacity! : 1), 0) / total;
+  const resets = matching.map((r) => r.resetAt).filter((t): t is number => !!t && t > now);
+  return { label, remaining, resetAt: resets.length ? Math.min(...resets) : undefined, estimated: !weighted, partial };
+}
+
+export function scopedLabels(rows: UsageRow[], modelId?: string): string[] {
+  const labels = [...new Set(rows.filter(isClaudeAccount).map((r) => r.label).filter((l) => l.startsWith("7d ")))];
+  const model = modelId?.toLowerCase() ?? "";
+  return labels.sort((a, b) => Number(matchesScope(b, model)) - Number(matchesScope(a, model)) || a.localeCompare(b));
+}
+
+function matchesScope(label: string, model: string): boolean {
+  const family = label.slice(3).toLowerCase();
+  return model.includes(family) || (family === "fable" && model.includes("mythos"));
+}
+
+/** An account must pass ALL applicable windows; independent averages cannot answer this. */
+export function poolAvailability(rows: UsageRow[], expected: number, modelId?: string, now = Date.now()) {
+  const groups = [...new Set(rows.filter(isClaudeAccount).map((r) => r.group))];
+  let ready = 0;
+  let unknown = Math.max(0, expected - groups.length);
+  for (const group of groups) {
+    const account = rows.filter((r) => r.group === group);
+    const required = ["5h", "7d", ...scopedLabels(account).filter((l) => matchesScope(l, modelId?.toLowerCase() ?? ""))];
+    const windows = required.map((label) => account.find((r) => r.label === label));
+    if (windows.some((r) => r && isFresh(r, now) && r.remaining <= 0)) continue;
+    if (windows.some((r) => !r || !isFresh(r, now))) { unknown++; continue; }
+    ready++;
+  }
+  return { ready, unknown, total: expected };
+}