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

package/src/extension/completions.ts

@@ -0,0 +1,20 @@
+import type { RegisteredCommand } from "@earendil-works/pi-coding-agent";
+
+/** pi's AutocompleteItem, taken from the command type so pi-tui stays an indirect dependency. */
+export type AutocompleteItem = NonNullable<
+  Awaited<ReturnType<NonNullable<RegisteredCommand["getArgumentCompletions"]>>>
+>[number];
+
+/** Completes a command argument from `values` by case-insensitive prefix, or `null` when nothing matches. */
+export const completeFrom = (
+  values: readonly string[],
+  prefix: string
+): AutocompleteItem[] | null => {
+  const needle = prefix.trim().toLowerCase();
+
+  const items = [...new Set(values)].flatMap((value) =>
+    value.toLowerCase().startsWith(needle) ? [{ label: value, value }] : []
+  );
+
+  return items.length > 0 ? items : null;
+};

package/src/extension/config.ts

@@ -0,0 +1,314 @@
+import path from "node:path";
+
+import type { OAuthCredentials } from "@earendil-works/pi-ai";
+import { readStoredCredential } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+
+import { DEFAULT_BASE_URL, resolveConnection } from "../core/index.ts";
+import type {
+  CliproxyModel,
+  ConnectionValues,
+  ResolvedConnection,
+  ThoughtSummary,
+} from "../core/index.ts";
+import {
+  memoByFile,
+  readJsonFile,
+  readJsonMemo,
+  writeJsonAtomic,
+} from "./files.ts";
+
+export const CONFIG_FILE_NAME = "cliproxyapi.json";
+export const MODELS_CACHE_FILE_NAME = "cliproxyapi-provider-models.json";
+export const DEFAULT_PROVIDER_ID = "cliproxyapi";
+export const DEFAULT_PROVIDER_NAME = "CLIProxyAPI";
+export const CREDENTIAL_TTL_MS = 100 * 365 * 24 * 60 * 60 * 1000;
+
+export interface CliproxyConfig extends ConnectionValues {
+  providerId?: string;
+  providerName?: string;
+  fast?: boolean;
+  pause?: boolean;
+  /** CLIProxyAPI management key. Unlocks the usage footer and account-wide hiding. */
+  managementKey?: string;
+  thinkingDisplay?: Readonly<Record<string, ThoughtSummary>>;
+  searchModel?: string;
+}
+
+export interface ModelsCache {
+  baseUrl: string;
+  fast: boolean;
+  fastModelIds: string[];
+  fetchedAt: number;
+  models: CliproxyModel[];
+}
+
+export interface ExtensionIdentity {
+  providerId: string;
+  providerName: string;
+}
+
+export interface ResolveExtensionConnectionOptions {
+  agentDir: string;
+  env: Readonly<Record<string, string | undefined>>;
+  providerId: string;
+  stored?: ConnectionValues;
+}
+
+const firstNonEmpty = (
+  ...values: (string | undefined)[]
+): string | undefined => {
+  for (const value of values) {
+    const trimmed = value?.trim();
+
+    if (trimmed) {
+      return trimmed;
+    }
+  }
+
+  return undefined;
+};
+
+const OptionalString = Type.Optional(Type.String());
+
+const ConfigFileSchema = Type.Object({
+  apiKey: OptionalString,
+  baseUrl: OptionalString,
+  fast: Type.Optional(Type.Boolean()),
+  managementKey: OptionalString,
+  pause: Type.Optional(Type.Boolean()),
+  providerId: OptionalString,
+  providerName: OptionalString,
+  searchModel: OptionalString,
+  thinkingDisplay: Type.Optional(
+    Type.Record(
+      Type.String(),
+      Type.Union([Type.Literal("summarized"), Type.Literal("omitted")])
+    )
+  ),
+});
+
+const RefreshMetaSchema = Type.Object({ baseUrl: OptionalString });
+
+const SettingsFileSchema = Type.Object({
+  defaultModel: OptionalString,
+  defaultProvider: OptionalString,
+});
+
+const ModelsCacheFileSchema = Type.Object({
+  baseUrl: Type.String(),
+  fast: Type.Boolean(),
+  fastModelIds: Type.Array(Type.String()),
+  fetchedAt: Type.Optional(Type.Number()),
+  models: Type.Array(Type.Unknown()),
+});
+
+const nonEmpty = (value: string | undefined): string | undefined =>
+  value?.trim() || undefined;
+
+/** Read on every request, so it comes from the file memo. The result is a fresh object callers may change. */
+export const loadCliproxyConfig = (agentDir: string): CliproxyConfig => {
+  const value = readJsonMemo(
+    path.join(agentDir, CONFIG_FILE_NAME),
+    ConfigFileSchema
+  );
+
+  if (!value) {
+    return {};
+  }
+
+  return {
+    apiKey: nonEmpty(value.apiKey),
+    baseUrl: nonEmpty(value.baseUrl),
+    fast: value.fast,
+    managementKey: nonEmpty(value.managementKey),
+    pause: value.pause,
+    providerId: nonEmpty(value.providerId),
+    providerName: nonEmpty(value.providerName),
+    searchModel: nonEmpty(value.searchModel),
+    thinkingDisplay: { ...value.thinkingDisplay },
+  };
+};
+
+export const saveCliproxyConfig = (
+  agentDir: string,
+  update: Partial<CliproxyConfig>
+): void => {
+  writeJsonAtomic(path.join(agentDir, CONFIG_FILE_NAME), {
+    ...loadCliproxyConfig(agentDir),
+    ...update,
+  });
+};
+
+export const resolveIdentity = (
+  agentDir: string,
+  env: Readonly<Record<string, string | undefined>> = process.env
+): ExtensionIdentity => {
+  const config = loadCliproxyConfig(agentDir);
+
+  return {
+    providerId:
+      firstNonEmpty(
+        env.CLIPROXYAPI_PROVIDER_ID,
+        config.providerId,
+        DEFAULT_PROVIDER_ID
+      ) ?? DEFAULT_PROVIDER_ID,
+    providerName:
+      firstNonEmpty(
+        env.CLIPROXYAPI_PROVIDER_NAME,
+        config.providerName,
+        DEFAULT_PROVIDER_NAME
+      ) ?? DEFAULT_PROVIDER_NAME,
+  };
+};
+
+export const decodeRefreshMeta = (
+  refresh: string | undefined
+): ConnectionValues => {
+  if (!refresh?.trim()) {
+    return {};
+  }
+
+  try {
+    const value: unknown = JSON.parse(refresh);
+
+    return Value.Check(RefreshMetaSchema, value)
+      ? { baseUrl: nonEmpty(value.baseUrl) }
+      : {};
+  } catch {
+    return {};
+  }
+};
+
+export const buildOAuthCredentials = (
+  baseUrl: string,
+  apiKey: string
+): OAuthCredentials => ({
+  access: apiKey,
+  expires: Date.now() + CREDENTIAL_TTL_MS,
+  refresh: JSON.stringify({ baseUrl }),
+});
+
+export const loadStoredConnection = (
+  agentDir: string,
+  providerId: string
+): ConnectionValues => {
+  try {
+    const authPath = path.join(agentDir, "auth.json");
+
+    const credential = memoByFile(
+      authPath,
+      () => readStoredCredential(providerId, authPath),
+      providerId
+    );
+
+    if (credential?.type === "oauth" && credential.access.trim()) {
+      return {
+        apiKey: credential.access.trim(),
+        ...decodeRefreshMeta(credential.refresh),
+      };
+    }
+
+    if (credential?.type === "api_key" && credential.key?.trim()) {
+      return { apiKey: credential.key.trim() };
+    }
+  } catch {
+    return {};
+  }
+
+  return {};
+};
+
+export const resolveExtensionConnection = (
+  options: ResolveExtensionConnectionOptions
+): ResolvedConnection | null => {
+  const stored =
+    options.stored ??
+    loadStoredConnection(options.agentDir, options.providerId);
+
+  return resolveConnection(
+    options.env,
+    loadCliproxyConfig(options.agentDir),
+    stored
+  );
+};
+
+export const isModelReferencedAsDefault = (
+  agentDir: string,
+  providerId: string,
+  modelId: string
+): boolean => {
+  try {
+    const settings = readJsonFile(
+      path.join(agentDir, "settings.json"),
+      SettingsFileSchema
+    );
+
+    const defaultModel = nonEmpty(settings?.defaultModel);
+    const defaultProvider = nonEmpty(settings?.defaultProvider);
+
+    if (!defaultModel) {
+      return false;
+    }
+
+    return (
+      defaultModel === `${providerId}/${modelId}` ||
+      defaultModel === `${providerId}:${modelId}` ||
+      (defaultModel === modelId &&
+        (!defaultProvider || defaultProvider === providerId))
+    );
+  } catch {
+    return false;
+  }
+};
+
+export const defaultConnectionBaseUrl = (
+  agentDir: string,
+  providerId: string,
+  env: Readonly<Record<string, string | undefined>> = process.env
+): string =>
+  firstNonEmpty(
+    env.CLIPROXYAPI_BASE_URL,
+    loadCliproxyConfig(agentDir).baseUrl,
+    loadStoredConnection(agentDir, providerId).baseUrl,
+    DEFAULT_BASE_URL
+  ) ?? DEFAULT_BASE_URL;
+
+export const loadModelsCache = (
+  agentDir: string,
+  baseUrl: string,
+  fast: boolean
+): ModelsCache | undefined => {
+  try {
+    const value = readJsonFile(
+      path.join(agentDir, MODELS_CACHE_FILE_NAME),
+      ModelsCacheFileSchema
+    );
+
+    if (value?.baseUrl !== baseUrl || value.fast !== fast) {
+      return undefined;
+    }
+
+    return {
+      baseUrl,
+      fast,
+      fastModelIds: value.fastModelIds.filter((id) => id.trim()),
+      fetchedAt: value.fetchedAt ?? 0,
+      // SAFETY: This cache is written only from core's CliproxyModel mapping. Invalid JSON shapes are rejected by the provider refresh.
+      models: value.models as CliproxyModel[],
+    };
+  } catch {
+    return undefined;
+  }
+};
+
+export const saveModelsCache = (
+  agentDir: string,
+  cache: Omit<ModelsCache, "fetchedAt"> & { fetchedAt?: number }
+): void => {
+  writeJsonAtomic(path.join(agentDir, MODELS_CACHE_FILE_NAME), {
+    ...cache,
+    fetchedAt: cache.fetchedAt ?? Date.now(),
+  });
+};

package/src/extension/fast.ts

@@ -0,0 +1,81 @@
+import { saveCliproxyConfig } from "./config.ts";
+
+/** Global Fast preference plus the capability set advertised by CLIProxyAPI. */
+export class FastModeController {
+  private supportedModelIds = new Set<string>();
+  private enabled: boolean;
+
+  constructor(enabled: boolean) {
+    this.enabled = enabled;
+  }
+
+  setEnabled(enabled: boolean): void {
+    this.enabled = enabled;
+  }
+
+  setSupportedModelIds(modelIds: Iterable<string>): void {
+    this.supportedModelIds = new Set(
+      [...modelIds].flatMap((id) => {
+        const trimmed = id.trim();
+
+        return trimmed ? [trimmed] : [];
+      })
+    );
+  }
+
+  isEnabled = (): boolean => this.enabled;
+
+  isModelSupported(modelId: string): boolean {
+    return this.supportedModelIds.has(modelId.trim());
+  }
+
+  isEffectiveFor(modelId: string): boolean {
+    return this.enabled && this.isModelSupported(modelId);
+  }
+}
+
+export interface ToggleFastModeOptions {
+  agentDir: string;
+  fast: FastModeController;
+  notify: (message: string, level?: "info" | "warning" | "error") => void;
+  refresh: () => Promise<void>;
+}
+
+/** Toggle request behavior immediately, then refresh Fast pricing in place. */
+export const toggleFastMode = async (
+  options: ToggleFastModeOptions
+): Promise<boolean | undefined> => {
+  const previous = options.fast.isEnabled();
+  const enabled = !previous;
+  options.fast.setEnabled(enabled);
+
+  try {
+    saveCliproxyConfig(options.agentDir, { fast: enabled });
+    await options.refresh();
+  } catch (error) {
+    options.fast.setEnabled(previous);
+    saveCliproxyConfig(options.agentDir, { fast: previous });
+
+    try {
+      await options.refresh();
+    } catch {
+      // The original refresh error is more useful than a secondary rollback error.
+    }
+
+    options.notify(
+      `Failed to refresh Fast pricing: ${error instanceof Error ? error.message : String(error)}`,
+      "warning"
+    );
+
+    return undefined;
+  }
+
+  options.notify(
+    enabled
+      ? "Fast mode is enabled globally."
+      : "Fast mode is disabled globally.",
+    "info"
+  );
+
+  return enabled;
+};

package/src/extension/files.ts

@@ -0,0 +1,146 @@
+import {
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import path from "node:path";
+
+import type { Static, TSchema } from "typebox";
+import { Value } from "typebox/value";
+
+/** Undefined when the file is missing. Throws, naming the file and field, when it breaks the schema. */
+export const readJsonFile = <Schema extends TSchema>(
+  filePath: string,
+  schema: Schema
+): Static<Schema> | undefined => {
+  let text: string;
+
+  try {
+    text = readFileSync(filePath, "utf-8");
+  } catch (error) {
+    // SAFETY: Node filesystem errors carry the optional code field used to identify a missing file.
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return undefined;
+    }
+
+    throw error;
+  }
+
+  const value: unknown = JSON.parse(text);
+
+  if (Value.Check(schema, value)) {
+    return value;
+  }
+
+  const [first] = Value.Errors(schema, value);
+
+  throw new Error(
+    `Invalid ${path.basename(filePath)} at ${first?.instancePath || "/"}: ${first?.message ?? "unexpected shape"}`
+  );
+};
+
+/** What identifies one version of a file. A rename gives a new inode, so atomic writes always differ. */
+interface FileStamp {
+  ino: number;
+  mtimeMs: number;
+  size: number;
+}
+
+interface MemoEntry {
+  stamp: FileStamp;
+  value: unknown;
+}
+
+/** Tells apart readers of one file: readJsonMemo's schema, or memoByFile's caller key. */
+type MemoKey = TSchema | string;
+
+/** Parsed values per file path, then per reader key. */
+const memo = new Map<string, Map<MemoKey, MemoEntry>>();
+
+const sameStamp = (left: FileStamp, right: FileStamp): boolean =>
+  left.ino === right.ino &&
+  left.mtimeMs === right.mtimeMs &&
+  left.size === right.size;
+
+const remember = <Value, Missing>(
+  filePath: string,
+  key: MemoKey,
+  read: () => Value,
+  missing: () => Missing
+): Value | Missing => {
+  const stats = statSync(filePath, { throwIfNoEntry: false });
+
+  if (!stats) {
+    memo.delete(filePath);
+
+    return missing();
+  }
+
+  const stamp: FileStamp = {
+    ino: stats.ino,
+    mtimeMs: stats.mtimeMs,
+    size: stats.size,
+  };
+
+  const entries = memo.get(filePath) ?? new Map<MemoKey, MemoEntry>();
+  const cached = entries.get(key);
+
+  if (cached && sameStamp(cached.stamp, stamp)) {
+    // SAFETY: Each key is stored only by the reader that owns it, so the value has that reader's type.
+    return cached.value as Value;
+  }
+
+  const value = read();
+  entries.set(key, { stamp, value });
+  memo.set(filePath, entries);
+
+  return value;
+};
+
+/**
+ * Reads and validates a JSON file like readJsonFile, but reuses the last parse
+ * while the file's inode, mtime and size are unchanged, so writes from other
+ * pi processes are still seen. Callers share the returned object and must not
+ * mutate it.
+ */
+export const readJsonMemo = <Schema extends TSchema>(
+  filePath: string,
+  schema: Schema
+): Static<Schema> | undefined =>
+  remember(
+    filePath,
+    schema,
+    () => readJsonFile(filePath, schema),
+    (): undefined => undefined
+  );
+
+/**
+ * Memoizes any reader of one file by the same stamp. `key` separates readers
+ * that pick different parts of the same file. A missing file is never cached,
+ * so `read` then runs every call and decides what a missing file means.
+ */
+export const memoByFile = <Value>(
+  filePath: string,
+  read: () => Value,
+  key = ""
+): Value => remember(filePath, key, read, read);
+
+/**
+ * Writes pretty JSON to `<file>.<pid>.tmp`, then renames it over `file`, so
+ * readers in other pi processes never see a half-written file. Serializes
+ * first, so a value that cannot become JSON leaves the old file untouched.
+ * The file is owner-only (0600) like pi's auth.json, because cliproxyapi.json
+ * holds the API key and management key.
+ */
+const OWNER_ONLY = 0o600;
+
+export const writeJsonAtomic = <Data>(filePath: string, value: Data): void => {
+  const text = `${JSON.stringify(value, null, 2)}\n`;
+  const temporary = `${filePath}.${process.pid}.tmp`;
+  mkdirSync(path.dirname(filePath), { recursive: true });
+  writeFileSync(temporary, text, { encoding: "utf-8", mode: OWNER_ONLY });
+  renameSync(temporary, filePath);
+  memo.delete(filePath);
+};