offrouter-cli 0.2.1 → 0.3.0

package/src/commands/models.ts

@@ -1,168 +0,0 @@
-import type { Command } from "commander";
-import { loadConfig, BUILTIN_PROVIDERS } from "offrouter-core";
-import { formatConfigError, type CliConfigError } from "./config-error.js";
-import { writeJson, writeText } from "./output.js";
-import type { CommandContext } from "./init.js";
-import { readCatalogCache, resolveCacheDir } from "../catalog-cache.js";
-import type { CachedModelFamily } from "../catalog-cache.js";
-
-/**
- * A single model entry in the merged output.
- * source: "builtin" from core package, "cached" from remote catalog, "config" from profile config.
- */
-export interface ModelEntry {
-  providerId: string;
-  modelId: string;
-  displayName?: string;
-  family?: string;
-  source: "builtin" | "cached" | "config";
-}
-
-function builtinToEntries(): ModelEntry[] {
-  const entries: ModelEntry[] = [];
-  for (const provider of BUILTIN_PROVIDERS) {
-    for (const model of provider.knownModels) {
-      entries.push({
-        providerId: provider.providerId,
-        modelId: model.modelId,
-        displayName: model.displayName,
-        family: model.family,
-        source: "builtin",
-      });
-    }
-  }
-  return entries;
-}
-
-function cachedToEntries(cached: { families: CachedModelFamily[] }): ModelEntry[] {
-  return cached.families.map((f) => ({
-    providerId: f.providerId,
-    modelId: f.modelId,
-    displayName: f.displayName,
-    family: f.family,
-    source: "cached" as const,
-  }));
-}
-
-/**
- * Merge builtin and cached model entries.
- * Cached models with the same (providerId, modelId) override builtin entries.
- * Config provider entries are appended separately.
- */
-function mergeModels(
-  builtin: ModelEntry[],
-  cached: ModelEntry[],
-  config: ModelEntry[],
-): ModelEntry[] {
-  // Build a set of (providerId,modelId) from cached entries that override builtin
-  const cachedKeys = new Set<string>();
-  for (const entry of cached) {
-    cachedKeys.add(`${entry.providerId}:${entry.modelId}`);
-  }
-
-  // Filter builtin entries that are not overridden by cached
-  const merged = builtin.filter(
-    (b) => !cachedKeys.has(`${b.providerId}:${b.modelId}`),
-  );
-
-  // Add all cached entries
-  merged.push(...cached);
-
-  // Add config entries (providers from config.toml)
-  // Config entries with same (providerId, modelId) override both builtin and cached
-  const mergedKeys = new Set<string>();
-  for (const entry of merged) {
-    mergedKeys.add(`${entry.providerId}:${entry.modelId}`);
-  }
-  for (const entry of config) {
-    if (!mergedKeys.has(`${entry.providerId}:${entry.modelId}`)) {
-      merged.push(entry);
-    }
-  }
-
-  return merged;
-}
-
-export function registerModelsCommand(
-  program: Command,
-  ctx: () => CommandContext,
-): void {
-  program
-    .command("models")
-    .description(
-      "List known models from builtin catalog, cached remote catalog, and config",
-    )
-    .option("--json", "Emit JSON", false)
-    .action(async (opts: { json?: boolean }) => {
-      const { env, cwd, stdout } = ctx();
-
-      // 1. Builtin models from offrouter-core
-      const builtinEntries = builtinToEntries();
-
-      // 2. Cached models from remote catalog (if available)
-      let cachedEntries: ModelEntry[] = [];
-      const cacheDir = resolveCacheDir(env);
-      const cachedData = readCatalogCache(cacheDir);
-      if (cachedData) {
-        cachedEntries = cachedToEntries(cachedData);
-      }
-
-      // 3. Config providers
-      let configEntries: ModelEntry[] = [];
-      let configError: CliConfigError | null = null;
-      try {
-        const config = await loadConfig({ env, workspaceDir: cwd });
-        configEntries = Object.keys(config.providers)
-          .sort()
-          .map((providerId) => ({
-            providerId,
-            modelId: "*",
-            source: "config" as const,
-          }));
-      } catch (err) {
-        configError = formatConfigError(err);
-      }
-
-      // Merge: cached overrides builtin (same providerId+modelId), config appended
-      const models = mergeModels(builtinEntries, cachedEntries, configEntries);
-
-      if (opts.json) {
-        writeJson(stdout, {
-          models,
-          builtinCount: builtinEntries.length,
-          cachedCount: cachedEntries.length,
-          configCount: configEntries.length,
-          configError,
-        });
-        return;
-      }
-      if (configError) {
-        writeText(stdout, `Config error: ${configError.message}`);
-        return;
-      }
-      if (models.length === 0) {
-        writeText(
-          stdout,
-          "No models available.",
-        );
-        return;
-      }
-      // Group by source for display
-      const builtinModels = models.filter((m) => m.source === "builtin");
-      const cachedModels = models.filter((m) => m.source === "cached");
-      const configProviderIds = models.filter((m) => m.source === "config");
-
-      writeText(stdout, `Models (${models.length} total):`);
-      writeText(stdout, `  Built-in: ${builtinModels.length} models`);
-      writeText(stdout, `  Cached: ${cachedModels.length} models`);
-      writeText(stdout, `  Config providers: ${configProviderIds.length}`);
-      writeText(stdout, "");
-      for (const m of models) {
-        const name = m.displayName ? `${m.displayName} (${m.modelId})` : m.modelId;
-        writeText(
-          stdout,
-          `  ${m.providerId}/${name} (${m.source})`,
-        );
-      }
-    });
-}

package/src/commands/output.ts

@@ -1,11 +0,0 @@
-export interface IoStreams {
-  write(chunk: string): boolean | void;
-}
-
-export function writeJson(stream: IoStreams, value: unknown): void {
-  stream.write(`${JSON.stringify(value, null, 2)}\n`);
-}
-
-export function writeText(stream: IoStreams, text: string): void {
-  stream.write(text.endsWith("\n") ? text : `${text}\n`);
-}

package/src/commands/profiles.ts

@@ -1,58 +0,0 @@
-import type { Command } from "commander";
-import { loadConfig } from "offrouter-core";
-import { writeJson, writeText } from "./output.js";
-import type { CommandContext } from "./init.js";
-
-export function registerProfilesCommand(
-  program: Command,
-  ctx: () => CommandContext,
-): void {
-  program
-    .command("profiles")
-    .description("List OffRouter profiles and allowlist status")
-    .option("--json", "Emit JSON", false)
-    .action(async (opts: { json?: boolean }) => {
-      const { env, cwd, stdout } = ctx();
-      try {
-        const config = await loadConfig({ env, workspaceDir: cwd });
-        const profiles = Object.values(config.profiles)
-          .map((p) => ({
-            id: p.id,
-            allowlisted: config.policy.allowlistedProfiles.includes(p.id),
-            deniedProviders: p.deniedProviders ?? [],
-          }))
-          .sort((a, b) => a.id.localeCompare(b.id));
-
-        const payload = {
-          allowlistedProfiles: [...config.policy.allowlistedProfiles].sort(),
-          deniedProfilePatterns: [
-            ...(config.policy.deniedProfilePatterns ?? []),
-          ].sort(),
-          profiles,
-        };
-
-        if (opts.json) {
-          writeJson(stdout, payload);
-          return;
-        }
-        writeText(
-          stdout,
-          `Allowlisted: ${payload.allowlistedProfiles.join(", ") || "(none)"}`,
-        );
-        writeText(
-          stdout,
-          `Denied patterns: ${payload.deniedProfilePatterns.join(", ") || "(none)"}`,
-        );
-        for (const p of profiles) {
-          writeText(stdout, `profile ${p.id}: allowlisted=${p.allowlisted}`);
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        if (opts.json) {
-          writeJson(stdout, { error: message, profiles: [] });
-          return;
-        }
-        writeText(stdout, `Failed to load profiles: ${message}`);
-      }
-    });
-}

package/src/commands/proxy.ts

@@ -1,87 +0,0 @@
-import type { Command } from "commander";
-import {
-  createResponsesProxyContext,
-  loadConfig,
-  startResponsesProxy,
-  type HarnessRef,
-} from "offrouter-core";
-import type { CommandContext } from "./init.js";
-
-/**
- * Minimal CLI bridge for the local OpenAI Responses-compatible proxy.
- * Provider discovery (candidates/adapters) lands in a later phase; this starts
- * the transparent gateway with the configured policy so custom-base-URL apps
- * can point at OffRouter today.
- */
-export function registerProxyCommand(
-  program: Command,
-  ctx: () => CommandContext,
-): void {
-  const proxy = program
-    .command("proxy")
-    .description("OffRouter transparent-gateway proxy bridges");
-
-  proxy
-    .command("serve")
-    .description(
-      "Start the local OpenAI Responses-compatible proxy (transparent gateway)",
-    )
-    .option(
-      "-p, --port <port>",
-      "TCP port (default 8787, env OFFROUTER_PROXY_PORT)",
-      (value: string) => Number.parseInt(value, 10),
-    )
-    .option("-H, --host <host>", "Bind host (default 127.0.0.1)")
-    .option(
-      "--profile <profile>",
-      "Harness profile to route as (must be allowlisted; default proxy)",
-    )
-    .action(
-      async (opts: {
-        port?: number;
-        host?: string;
-        profile?: string;
-      }) => {
-        const { env, cwd, stderr } = ctx();
-        const config = await loadConfig({
-          env,
-          workspaceDir: cwd,
-          workspaceTrusted: false,
-        });
-
-        const profile = opts.profile ?? "proxy";
-        const harness: HarnessRef = { kind: "other", profile };
-        const context = createResponsesProxyContext({
-          policy: config.policy,
-          // Provider discovery supplies candidates/adapters in a later phase.
-          candidates: [],
-          adapters: {},
-        });
-
-        const port =
-          opts.port ??
-          Number.parseInt(env.OFFROUTER_PROXY_PORT ?? "8787", 10);
-        const host = opts.host ?? env.OFFROUTER_PROXY_HOST ?? "127.0.0.1";
-        const token = env.OFFROUTER_PROXY_TOKEN;
-
-        const handle = await startResponsesProxy(context, {
-          port,
-          host,
-          token,
-          harness,
-          workspace: { cwd, trusted: true },
-        });
-
-        stderr.write(
-          `OffRouter proxy listening on http://${host}:${handle.port} (profile=${profile})\n`,
-        );
-
-        const shutdown = async (): Promise<void> => {
-          await handle.close();
-          process.exit(0);
-        };
-        process.on("SIGINT", () => void shutdown());
-        process.on("SIGTERM", () => void shutdown());
-      },
-    );
-}

package/src/commands/route.ts

@@ -1,190 +0,0 @@
-import { createHash } from "node:crypto";
-import { join } from "node:path";
-import type { Command } from "commander";
-import {
-  FileUsageStore,
-  loadConfig,
-  resolveOffRouterHome,
-  routeRequest,
-  type HarnessKind,
-  type RouteRequest,
-} from "offrouter-core";
-import { formatConfigError } from "./config-error.js";
-import { writeJson, writeText } from "./output.js";
-import type { CommandContext } from "./init.js";
-
-function harnessKindFromProfile(profile: string): HarnessKind {
-  if (profile.startsWith("claude")) return "claude";
-  if (profile.startsWith("codex")) return "codex";
-  if (profile.startsWith("gemini")) return "gemini";
-  if (profile.startsWith("grok")) return "grok";
-  if (profile.startsWith("cursor")) return "cursor";
-  if (profile.startsWith("pi")) return "pi";
-  return "other";
-}
-
-function buildRequest(
-  prompt: string,
-  profile: string,
-  cwd: string,
-): RouteRequest {
-  const preview = prompt.length > 200 ? `${prompt.slice(0, 200)}...` : prompt;
-  const digest = createHash("sha256").update(prompt).digest("hex");
-  return {
-    protocolVersion: "offrouter.route.v1",
-    requestId: `cli_route_${digest.slice(0, 12)}`,
-    harness: {
-      kind: harnessKindFromProfile(profile),
-      profile,
-    },
-    task: {
-      promptPreview: preview,
-      promptDigest: digest,
-      kind: "explain",
-      risk: "low",
-    },
-    workspace: {
-      cwd,
-      // CLI explain is an explicit local dry run and does not load project config.
-      // Harness adapters will pass real workspace trust when they route live work.
-      trusted: true,
-    },
-    constraints: {
-      subscriptionFirst: true,
-      allowApiKeyFallback: false,
-    },
-  };
-}
-
-export function registerRouteCommand(
-  program: Command,
-  ctx: () => CommandContext,
-): void {
-  const route = program
-    .command("route")
-    .description("Route or explain routing decisions (no live provider calls)");
-
-  route
-    .command("explain")
-    .description("Explain how OffRouter would route a prompt under policy")
-    .argument(
-      "<prompt>",
-      "Prompt text used only for preview + digest (not sent to providers)",
-    )
-    .requiredOption(
-      "--profile <profile>",
-      "Harness profile id (e.g. claude-personal)",
-    )
-    .option("--json", "Emit JSON decision", false)
-    .action(
-      async (prompt: string, opts: { profile: string; json?: boolean }) => {
-        const { env, cwd, stdout } = ctx();
-        const request = buildRequest(prompt, opts.profile, cwd);
-
-        let policyConfig;
-        let config;
-        try {
-          config = await loadConfig({ env, workspaceDir: cwd });
-          policyConfig = config.policy;
-        } catch (err) {
-          const configError = formatConfigError(err);
-          const decision = {
-            protocolVersion: request.protocolVersion,
-            decisionId: `dec_${request.requestId}_config_error`,
-            requestId: request.requestId,
-            route: null,
-            reason: "config_error",
-            explanation: `Invalid OffRouter config: ${configError.message}`,
-            fallbackChain: [],
-            policyDenials: [],
-            confidence: 1,
-            auditSummary: `Blocked config_error profile=${request.harness.profile} digest=${request.task.promptDigest}`,
-            blocked: true,
-            needsConfiguration: false,
-            setupIncomplete: false,
-            setupMessage: null,
-            configError,
-          };
-          if (opts.json) {
-            writeJson(stdout, decision);
-            return;
-          }
-          writeText(
-            stdout,
-            `Cannot route (config_error): ${decision.explanation}`,
-          );
-          return;
-        }
-
-        // No provider catalog in this milestone - empty candidates yield needsConfiguration
-        // or a profile hard block for work/denied profiles.
-        const decision = routeRequest(request, [], policyConfig);
-        const setupIncomplete = decision.needsConfiguration === true;
-
-        // Check near-limit status for configured accounts.
-        let nearLimitWarning: string | null = null;
-        try {
-          const usageStore = new FileUsageStore({
-            filePath: join(
-              resolveOffRouterHome({ env }),
-              "state",
-              "usage.json",
-            ),
-          });
-          const nearAccounts = await usageStore.getNearLimitAccounts(
-            policyConfig.nearLimitThreshold,
-          );
-          if (nearAccounts.length > 0) {
-            nearLimitWarning = `Account ${nearAccounts[0]!.providerId}/${nearAccounts[0]!.accountId} is near its limit (${
-              nearAccounts[0]!.percentRemaining ?? 0
-            }% remaining)`;
-          }
-        } catch {
-          // Non-fatal: if the usage store cannot be read, skip the warning.
-        }
-
-        if (opts.json) {
-          writeJson(stdout, {
-            ...decision,
-            setupIncomplete,
-            setupMessage: setupIncomplete
-              ? "Setup incomplete: configure a subscription, local runtime, or API-key provider, and allowlist a personal profile."
-              : null,
-            ...(nearLimitWarning !== null ? { nearLimitWarning } : {}),
-          });
-          return;
-        }
-
-        if (
-          decision.blocked ||
-          decision.needsConfiguration ||
-          !decision.route
-        ) {
-          writeText(
-            stdout,
-            `Cannot route (${decision.reason}): ${decision.explanation}`,
-          );
-          if (decision.policyDenials && decision.policyDenials.length > 0) {
-            for (const d of decision.policyDenials) {
-              writeText(stdout, `- [${d.code}] ${d.message}`);
-            }
-          }
-          if (setupIncomplete) {
-            writeText(
-              stdout,
-              "Setup incomplete: configure a subscription, local runtime, or API-key provider, and allowlist a personal profile.",
-            );
-          }
-          if (nearLimitWarning !== null) {
-            writeText(stdout, `! ${nearLimitWarning}`);
-          }
-          return;
-        }
-
-        writeText(
-          stdout,
-          `Route: ${decision.route.provider}/${decision.route.model} (${decision.route.authTier}) - ${decision.explanation}`,
-        );
-      },
-    );
-}

package/src/commands/status.ts

@@ -1,139 +0,0 @@
-import type { Command } from "commander";
-import { join } from "node:path";
-import {
-  FileUsageStore,
-  loadConfig,
-  resolveOffRouterHome,
-} from "offrouter-core";
-import { formatConfigError, type CliConfigError } from "./config-error.js";
-import { detectEnvironment, V1_HONESTY_LINE } from "./detection.js";
-import { writeJson, writeText } from "./output.js";
-import type { CommandContext } from "./init.js";
-
-export function registerStatusCommand(
-  program: Command,
-  ctx: () => CommandContext,
-): void {
-  program
-    .command("status")
-    .description("Show OffRouter status")
-    .option("--providers", "Include per-provider readiness detail", false)
-    .option("--json", "Emit JSON", false)
-    .action(async (opts: { providers?: boolean; json?: boolean }) => {
-      const { env, cwd, stdout } = ctx();
-      const detection = await detectEnvironment({ env, cwd });
-
-      let providers: Array<{
-        id: string;
-        enabled: boolean;
-        authTierHints: string[];
-        subscriptionStatus: string;
-        apiKeyReady: boolean;
-        localReady: boolean;
-        limitStatus: string;
-        lastError: string | null;
-        accounts: { accountId: string; label: string; quotaRemaining: number | null; nearLimit: boolean | null }[];
-      }> = [];
-      let configError: CliConfigError | null = null;
-
-      try {
-        const config = await loadConfig({ env, workspaceDir: cwd });
-        const usageStore = new FileUsageStore({
-          filePath: join(resolveOffRouterHome({ env }), "state", "usage.json"),
-        });
-        const allUsage = await usageStore.listAccountUsage();
-        const usageByKey = new Map(
-          allUsage.map((u) => [`${u.providerId}:${u.accountId}`, u]),
-        );
-        providers = Object.values(config.providers)
-          .map((p) => ({
-            id: p.id,
-            enabled: p.enabled,
-            authTierHints: [
-              ...(detection.authTiers.subscription
-                ? (["subscription"] as const)
-                : []),
-              ...(detection.authTiers.local ? (["local"] as const) : []),
-              ...(detection.authTiers["api-key"]
-                ? (["api-key"] as const)
-                : []),
-            ],
-            subscriptionStatus: detection.subscription.status,
-            apiKeyReady: detection.apiKeyReadiness.anyReady,
-            localReady: detection.localRuntime.health !== "unconfigured",
-            limitStatus: detection.limits.status,
-            lastError: detection.lastProviderError,
-            accounts: p.accounts.map((a) => {
-              const snap = usageByKey.get(`${p.id}:${a.id}`);
-              return {
-                accountId: a.id,
-                label: a.label ?? a.id,
-                quotaRemaining: snap?.remaining ?? null,
-                nearLimit: snap?.nearLimit ?? null,
-              };
-            }),
-          }))
-          .sort((a, b) => a.id.localeCompare(b.id));
-      } catch (err) {
-        configError = formatConfigError(err);
-        providers = [];
-      }
-
-      // When no providers are configured, still expose a readiness row for status --providers.
-      if (opts.providers && providers.length === 0) {
-        providers = [
-          {
-            id: "(none-configured)",
-            enabled: false,
-            authTierHints: Object.entries(detection.authTiers)
-              .filter(([, v]) => v)
-              .map(([k]) => k),
-            subscriptionStatus: detection.subscription.status,
-            apiKeyReady: detection.apiKeyReadiness.anyReady,
-            localReady: detection.localRuntime.health !== "unconfigured",
-            limitStatus: detection.limits.status,
-            lastError: detection.lastProviderError,
-            accounts: [],
-          },
-        ];
-      }
-
-      const payload = {
-        honesty: V1_HONESTY_LINE,
-        harnessProfiles: detection.harnessProfiles,
-        authTiers: detection.authTiers,
-        subscription: detection.subscription,
-        apiKeyReadiness: detection.apiKeyReadiness,
-        localRuntime: detection.localRuntime,
-        limits: detection.limits,
-        lastProviderError: detection.lastProviderError,
-        configError,
-        ...(opts.providers ? { providers } : {}),
-      };
-
-      if (opts.json) {
-        writeJson(stdout, payload);
-        return;
-      }
-
-      writeText(stdout, V1_HONESTY_LINE);
-      writeText(
-        stdout,
-        `Subscription: ${detection.subscription.status}; API-key ready: ${detection.apiKeyReadiness.anyReady}; local: ${detection.localRuntime.health}`,
-      );
-      if (opts.providers) {
-        for (const p of providers) {
-          writeText(
-            stdout,
-            `provider ${p.id}: enabled=${p.enabled} subscription=${p.subscriptionStatus} apiKeyReady=${p.apiKeyReady} localReady=${p.localReady} limits=${p.limitStatus}`,
-          );
-          for (const a of p.accounts) {
-            writeText(stdout, `  account ${a.accountId}: ${a.label}`);
-          }
-        }
-      }
-      if (configError) {
-        writeText(stdout, `Config error: ${configError.message}`);
-      }
-    });
-}