@juvio15/pi-cliproxyapi-provider 0.0.0-stage → 0.1.1

package/src/extension/oauth.ts

@@ -0,0 +1,203 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+
+import {
+  pollOAuthStatus,
+  startOAuth,
+  submitOAuthCallback,
+} from "../core/index.ts";
+import { completeFrom } from "./completions.ts";
+import { MANAGEMENT_KEY_ENV } from "./usage.ts";
+import type { UsageTracker } from "./usage.ts";
+
+export interface RegisterOAuthLoginOptions {
+  providerId: string;
+  tracker: UsageTracker;
+  /** Refreshes the model catalog the way /cliproxyapi-refresh does. */
+  refresh: (ctx: ExtensionContext) => Promise<void>;
+}
+
+/** Built-in CLIProxyAPI login providers. Plugins can add more ids. */
+const LOGIN_PROVIDERS = [
+  "claude",
+  "codex",
+  "antigravity",
+  "kimi",
+  "kimi-ai",
+  "xai",
+  "devin",
+  "meta",
+] as const;
+
+const KNOWN_PROVIDERS = `${LOGIN_PROVIDERS.join(", ")}, or a plugin provider id`;
+
+const PROVIDER_WITH_SPACE = /\s/u;
+
+/** The provider argument, or a picked one when bare with a UI. `undefined` means the picker was cancelled. */
+const chooseProvider = async (
+  args: string,
+  ctx: ExtensionContext
+): Promise<string | undefined> => {
+  const provider = args.trim();
+
+  if (provider || !ctx.hasUI) {
+    return provider;
+  }
+
+  return await ctx.ui.select("CLIProxyAPI account provider", [
+    ...LOGIN_PROVIDERS,
+  ]);
+};
+
+/**
+ * Registers /cliproxyapi-login <provider>: starts an upstream account login
+ * on the CLIProxyAPI server, asks for the browser's redirect URL, submits
+ * it, and waits for the server to finish the credential exchange.
+ */
+export const registerOAuthLogin = (
+  pi: ExtensionAPI,
+  options: RegisterOAuthLoginOptions
+): void => {
+  pi.registerCommand("cliproxyapi-login", {
+    description: `Add an upstream account to CLIProxyAPI (/cliproxyapi-login <provider>: ${KNOWN_PROVIDERS}).`,
+    getArgumentCompletions: (prefix) => completeFrom(LOGIN_PROVIDERS, prefix),
+    handler: async (args, ctx) => {
+      // Check the setup first, so the picker never opens for a login that cannot run.
+      if (!options.tracker.hasManagementKey()) {
+        ctx.ui.notify(
+          `CLIProxyAPI management key is not set. Set ${MANAGEMENT_KEY_ENV} or add "managementKey" to cliproxyapi.json, then run /cliproxyapi-login again.`,
+          "error"
+        );
+
+        return;
+      }
+
+      const access = options.tracker.managementAccess();
+
+      if (!access) {
+        ctx.ui.notify(
+          `CLIProxyAPI is not configured. Run /login ${options.providerId} first.`,
+          "error"
+        );
+
+        return;
+      }
+
+      const provider = await chooseProvider(args, ctx);
+
+      if (provider === undefined) {
+        return;
+      }
+
+      if (!provider || PROVIDER_WITH_SPACE.test(provider)) {
+        ctx.ui.notify(
+          `Usage: /cliproxyapi-login <provider> (${KNOWN_PROVIDERS})`,
+          "error"
+        );
+
+        return;
+      }
+
+      const { baseUrl, managementKey } = access;
+      const { signal } = ctx;
+
+      try {
+        const start = await startOAuth({
+          baseUrl,
+          managementKey,
+          provider,
+          signal,
+        });
+
+        ctx.ui.notify(
+          `Open this URL in a browser to sign in to ${provider}:\n${start.url}`,
+          "info"
+        );
+
+        if (start.flow === "device") {
+          // Device logins (Kimi, xAI, Meta) never redirect back: the server
+          // polls the provider itself, so only the status needs polling.
+          if (start.userCode) {
+            ctx.ui.notify(`Enter this code: ${start.userCode}`, "info");
+          }
+        } else {
+          const redirectUrl = await ctx.ui.input(
+            `Paste the full redirect URL for ${provider}`,
+            "http://127.0.0.1/callback?code=...&state=...",
+            signal ? { signal } : undefined
+          );
+
+          if (!redirectUrl?.trim()) {
+            ctx.ui.notify(
+              `CLIProxyAPI login for ${provider} was cancelled.`,
+              "warning"
+            );
+
+            return;
+          }
+
+          await submitOAuthCallback({
+            baseUrl,
+            managementKey,
+            provider,
+            redirectUrl: redirectUrl.trim(),
+            signal,
+          });
+        }
+
+        ctx.ui.notify(
+          `Completing the ${provider} login with CLIProxyAPI...`,
+          "info"
+        );
+
+        const result = await pollOAuthStatus({
+          baseUrl,
+          managementKey,
+          signal,
+          state: start.state,
+        });
+
+        if (result.status !== "ok") {
+          ctx.ui.notify(
+            `CLIProxyAPI login for ${provider} failed: ${result.error ?? "the server reported an error"}`,
+            "error"
+          );
+
+          return;
+        }
+
+        try {
+          await options.refresh(ctx);
+        } catch (error) {
+          ctx.ui.notify(
+            `Added the ${provider} account to CLIProxyAPI, but refreshing models failed: ${error instanceof Error ? error.message : String(error)}`,
+            "warning"
+          );
+
+          return;
+        }
+
+        ctx.ui.notify(
+          `Added the ${provider} account to CLIProxyAPI and refreshed the model catalog.`,
+          "info"
+        );
+      } catch (error) {
+        if (signal?.aborted) {
+          ctx.ui.notify(
+            `CLIProxyAPI login for ${provider} was cancelled.`,
+            "warning"
+          );
+
+          return;
+        }
+
+        ctx.ui.notify(
+          `CLIProxyAPI login for ${provider} failed: ${error instanceof Error ? error.message : String(error)}`,
+          "error"
+        );
+      }
+    },
+  });
+};

package/src/extension/pause.ts

@@ -0,0 +1,126 @@
+/* oxlint-disable eslint/no-await-in-loop -- Pause polling must read each setting change before the next timed wait. */
+import { setTimeout as delay } from "node:timers/promises";
+
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+} from "@earendil-works/pi-coding-agent";
+
+import { loadCliproxyConfig, saveCliproxyConfig } from "./config.ts";
+
+const POLL_INTERVAL_MS = 200;
+
+export class PauseController {
+  private enabled: boolean;
+  private pauseStartedAt: number | undefined;
+  private pausedDuration = 0;
+
+  constructor(enabled = false) {
+    this.enabled = enabled;
+
+    if (enabled) {
+      this.pauseStartedAt = Date.now();
+    }
+  }
+
+  setEnabled(enabled: boolean, now = Date.now()): void {
+    if (enabled === this.enabled) {
+      return;
+    }
+
+    if (enabled) {
+      this.pauseStartedAt = now;
+    } else if (this.pauseStartedAt !== undefined) {
+      this.pausedDuration += Math.max(0, now - this.pauseStartedAt);
+      this.pauseStartedAt = undefined;
+    }
+
+    this.enabled = enabled;
+  }
+
+  isEnabled(): boolean {
+    return this.enabled;
+  }
+
+  getPausedDuration(now = Date.now()): number {
+    return (
+      this.pausedDuration +
+      (this.pauseStartedAt === undefined
+        ? 0
+        : Math.max(0, now - this.pauseStartedAt))
+    );
+  }
+
+  getElapsed(start: number, pausedAtStart: number, now = Date.now()): number {
+    return Math.max(
+      0,
+      now - start - Math.max(0, this.getPausedDuration(now) - pausedAtStart)
+    );
+  }
+}
+
+export const waitForPauseToEnd = async (
+  agentDir: string,
+  pause: PauseController,
+  signal?: AbortSignal
+): Promise<void> => {
+  while (true) {
+    signal?.throwIfAborted();
+
+    try {
+      pause.setEnabled(loadCliproxyConfig(agentDir).pause ?? false);
+    } catch {
+      // Keep the last in-memory setting when the configuration cannot be read.
+    }
+
+    if (!pause.isEnabled()) {
+      return;
+    }
+
+    await delay(POLL_INTERVAL_MS);
+  }
+};
+
+export const registerPause = (
+  pi: ExtensionAPI,
+  agentDir: string,
+  pause: PauseController
+): void => {
+  const setPause = (
+    enabled: boolean,
+    args: string,
+    ctx: ExtensionCommandContext
+  ): void => {
+    if (args.trim()) {
+      ctx.ui.notify(`Usage: /${enabled ? "pause" : "continue"}`, "error");
+
+      return;
+    }
+
+    try {
+      saveCliproxyConfig(agentDir, { pause: enabled });
+      pause.setEnabled(enabled);
+      ctx.ui.notify(
+        enabled ? "Requests are paused." : "Requests are continued.",
+        "info"
+      );
+    } catch (error) {
+      ctx.ui.notify(
+        `Failed to save pause mode: ${error instanceof Error ? error.message : String(error)}`,
+        "error"
+      );
+    }
+  };
+
+  pi.registerCommand("pause", {
+    description: "Pause provider requests until /continue is used.",
+    handler: (args, ctx) => Promise.resolve(setPause(true, args, ctx)),
+  });
+  pi.registerCommand("continue", {
+    description: "Continue provider requests paused by /pause.",
+    handler: (args, ctx) => Promise.resolve(setPause(false, args, ctx)),
+  });
+  pi.on("before_provider_request", async (_event, ctx) => {
+    await waitForPauseToEnd(agentDir, pause, ctx.signal);
+  });
+};

package/src/extension/prices.ts

@@ -0,0 +1,205 @@
+import path from "node:path";
+
+import { Type } from "typebox";
+import type { Static } from "typebox";
+
+import {
+  costCatalogFromPrices,
+  DEFAULT_COSTS_URL,
+  fetchCostsConditional,
+  resolvePrices,
+} from "../core/index.ts";
+import type { CostCatalog } from "../core/index.ts";
+import { readJsonMemo, writeJsonAtomic } from "./files.ts";
+
+export const PRICES_FILE_NAME = "cliproxyapi-prices.json";
+
+/** models.dev prices change rarely, so they are revalidated at most once a day. */
+export const PRICES_TTL_MS = 24 * 60 * 60 * 1000;
+
+const MINUTE_MS = 60_000;
+const HOUR_MS = 60 * MINUTE_MS;
+const DAY_MS = 24 * HOUR_MS;
+
+const RateFields = {
+  cacheRead: Type.Number(),
+  cacheWrite: Type.Number(),
+  input: Type.Number(),
+  output: Type.Number(),
+};
+
+/** pi-ai's ModelCost. pi does not expose pi-ai's model-schema module to extensions, and typecheck holds this to ModelCost where the file feeds costCatalogFromPrices. */
+const ModelCostSchema = Type.Object({
+  ...RateFields,
+  tiers: Type.Optional(
+    Type.Array(Type.Object({ ...RateFields, inputTokensAbove: Type.Number() }))
+  ),
+});
+
+const PricesFileSchema = Type.Object({
+  etag: Type.Optional(Type.String()),
+  fetchedAt: Type.Number(),
+  prices: Type.Record(
+    Type.String(),
+    Type.Union([
+      Type.Null(),
+      Type.Object({
+        fast: Type.Optional(ModelCostSchema),
+        standard: ModelCostSchema,
+      }),
+    ])
+  ),
+  source: Type.String(),
+});
+
+type PricesFile = Static<typeof PricesFileSchema>;
+
+export interface PriceCacheOptions {
+  agentDir: string;
+  /** Defaults to models.dev's api.json. */
+  costsUrl?: string;
+  fetchFn?: typeof fetch;
+  now?: () => number;
+}
+
+export interface PriceLoad {
+  catalog: CostCatalog;
+  /** Set when models.dev failed. The text is ready to show the user. */
+  warning?: string;
+}
+
+export interface PriceCacheInfo {
+  fetchedAt?: number;
+  etag?: string;
+  /** Catalog ids that have a price. */
+  count: number;
+}
+
+const plural = (count: number, unit: string): string =>
+  `${count} ${unit}${count === 1 ? "" : "s"}`;
+
+/** "less than a minute", "5 minutes", "25 hours", "3 days". */
+export const formatAge = (ageMs: number): string => {
+  if (ageMs < MINUTE_MS) {
+    return "less than a minute";
+  }
+
+  if (ageMs < HOUR_MS) {
+    return plural(Math.floor(ageMs / MINUTE_MS), "minute");
+  }
+
+  if (ageMs < 2 * DAY_MS) {
+    return plural(Math.floor(ageMs / HOUR_MS), "hour");
+  }
+
+  return plural(Math.floor(ageMs / DAY_MS), "day");
+};
+
+/**
+ * Keeps the models.dev prices of the catalog's ids in
+ * `<agentDir>/cliproxyapi-prices.json`. Prices under 24 h old are used without
+ * a request. Older ones are revalidated with If-None-Match, so an unchanged
+ * catalog costs one 304 instead of a 5.9 MB download and parse.
+ */
+export class PriceCache {
+  private readonly filePath: string;
+  private readonly costsUrl: string;
+  private readonly fetchFn: typeof fetch | undefined;
+  private readonly now: () => number;
+
+  constructor(options: PriceCacheOptions) {
+    this.filePath = path.join(options.agentDir, PRICES_FILE_NAME);
+    this.costsUrl = options.costsUrl ?? DEFAULT_COSTS_URL;
+    this.fetchFn = options.fetchFn;
+    this.now = options.now ?? Date.now;
+  }
+
+  /** Prices for these catalog ids, fetching only when needed. Never throws for a models.dev failure. */
+  async load(ids: readonly string[], signal?: AbortSignal): Promise<PriceLoad> {
+    const file = this.read();
+    const now = this.now();
+
+    const complete =
+      file?.source === this.costsUrl && ids.every((id) => id in file.prices);
+
+    // A 304 cannot price an id the file lacks, so only a complete file is revalidated.
+    const revalidating = complete ? file : undefined;
+
+    if (revalidating) {
+      const age = now - revalidating.fetchedAt;
+
+      if (age >= 0 && age < PRICES_TTL_MS) {
+        return { catalog: costCatalogFromPrices(revalidating.prices) };
+      }
+    }
+
+    const result = await fetchCostsConditional({
+      etag: revalidating?.etag,
+      fetch: this.fetchFn,
+      signal,
+      url: this.costsUrl,
+    });
+
+    if (result.status === "fresh") {
+      const prices = resolvePrices(ids, result.costs);
+      this.write({ etag: result.etag, fetchedAt: now, prices });
+
+      return { catalog: costCatalogFromPrices(prices) };
+    }
+
+    if (result.status === "not-modified" && revalidating) {
+      this.write({ ...revalidating, fetchedAt: now });
+
+      return { catalog: costCatalogFromPrices(revalidating.prices) };
+    }
+
+    const reason = result.status === "failed" ? result.reason : "HTTP 304";
+
+    if (!file) {
+      return {
+        catalog: costCatalogFromPrices({}),
+        warning: `Couldn't load prices from models.dev (${reason}). Costs show $0 until prices load.`,
+      };
+    }
+
+    return {
+      catalog: costCatalogFromPrices(file.prices),
+      warning: `Couldn't update prices from models.dev (${reason}). Using prices from ${formatAge(Math.max(0, now - file.fetchedAt))} ago.`,
+    };
+  }
+
+  /** The prices on disk, without any request. Undefined before the first successful load. */
+  cached(): CostCatalog | undefined {
+    const file = this.read();
+
+    return file ? costCatalogFromPrices(file.prices) : undefined;
+  }
+
+  /** For /cliproxyapi-status. Undefined before the first successful load. */
+  describe(): PriceCacheInfo | undefined {
+    const file = this.read();
+
+    if (!file) {
+      return undefined;
+    }
+
+    return {
+      count: Object.values(file.prices).filter(Boolean).length,
+      etag: file.etag,
+      fetchedAt: file.fetchedAt,
+    };
+  }
+
+  /** A missing or damaged file reads as no prices, so the next load fetches and rewrites it. */
+  private read(): PricesFile | undefined {
+    try {
+      return readJsonMemo(this.filePath, PricesFileSchema);
+    } catch {
+      return undefined;
+    }
+  }
+
+  private write(file: Omit<PricesFile, "source">): void {
+    writeJsonAtomic(this.filePath, { ...file, source: this.costsUrl });
+  }
+}

package/src/extension/prompt-cache.ts

@@ -0,0 +1,17 @@
+import type { ModelPromptCache } from "@earendil-works/pi-ai";
+import { getBuiltinModels } from "@earendil-works/pi-ai/providers/all";
+
+const LIFETIMES = new Map<string, ModelPromptCache | undefined>(
+  getBuiltinModels("anthropic").map((model) => [model.id, model.promptCache])
+);
+
+/** pi-ai's own Anthropic lifetimes, matched on the id or its segment after the last "/". */
+export const anthropicPromptCache = (
+  id: string
+): ModelPromptCache | undefined => {
+  const modelId = id.trim().toLowerCase();
+  const segment = modelId.slice(modelId.lastIndexOf("/") + 1);
+  const lifetimes = LIFETIMES.get(modelId) ?? LIFETIMES.get(segment);
+
+  return lifetimes ? { ...lifetimes } : undefined;
+};