offrouter-core 0.2.1 → 0.2.2

package/src/config.ts

@@ -1,505 +0,0 @@
-/**
- * OffRouter V1 user/project config loader.
- * Loads TOML from OFFROUTER_HOME (or ~/.offrouter) with Zod validation.
- * Project .offrouter/config.toml is ignored unless the workspace is trusted.
- */
-import { readdir, readFile } from "node:fs/promises";
-import { homedir as osHomedir } from "node:os";
-import { join, resolve } from "node:path";
-import { parse as parseToml } from "smol-toml";
-import { z } from "zod";
-import type { PolicyConfig } from "./policy.js";
-
-/** Defaults applied when user config omits policy knobs. */
-export interface PolicyDefaults {
-  subscriptionFirst: boolean;
-  allowApiKeyFallback: boolean;
-}
-
-/** Declared provider entry from config (no secrets here). */
-export interface ConfiguredProvider {
-  id: string;
-  enabled: boolean;
-  accounts: ConfiguredAccount[];
-}
-
-/** Named profile overlay loaded from profiles/*.toml. */
-export interface ConfiguredProfile {
-  id: string;
-  deniedProviders?: string[];
-  allowApiKeyFallback?: boolean;
-  subscriptionFirst?: boolean;
-}
-
-/** Single configured account within a provider. */
-export interface ConfiguredAccount {
-  id: string;
-  label?: string;
-}
-
-export interface ConfigWarning {
-  filePath: string;
-  path: string;
-  message: string;
-}
-
-export interface OffRouterConfig {
-  homeDir: string;
-  sources: string[];
-  policy: PolicyConfig;
-  policyDefaults: PolicyDefaults;
-  providers: Record<string, ConfiguredProvider>;
-  profiles: Record<string, ConfiguredProfile>;
-  warnings: ConfigWarning[];
-}
-
-export interface LoadConfigOptions {
-  /** Override process.env (for tests). */
-  env?: NodeJS.ProcessEnv;
-  /** Override os.homedir (for tests). */
-  homedir?: () => string;
-  /** Workspace directory that may contain .offrouter/config.toml. */
-  workspaceDir?: string;
-  /**
-   * Whether the workspace is trusted. Project config is ignored when false
-   * or when workspaceDir is unset.
-   */
-  workspaceTrusted?: boolean;
-}
-
-export interface ResolveHomeOptions {
-  env?: NodeJS.ProcessEnv;
-  homedir?: () => string;
-}
-
-export class ConfigError extends Error {
-  readonly filePath: string;
-  readonly issues: string[];
-
-  constructor(filePath: string, issues: string[], cause?: unknown) {
-    const detail =
-      issues.length > 0 ? issues.join("; ") : "unknown validation error";
-    super(`Invalid OffRouter config in ${filePath}: ${detail}`, {
-      cause,
-    });
-    this.name = "ConfigError";
-    this.filePath = filePath;
-    this.issues = issues;
-  }
-}
-
-type AllowedNode = AllowedShape | "leaf" | "record";
-interface AllowedShape {
-  [key: string]: AllowedNode;
-}
-
-function allowedFromZodShape(shape: z.ZodRawShape): AllowedShape {
-  return Object.fromEntries(
-    Object.keys(shape).map((key) => [key, "leaf" as const]),
-  );
-}
-
-const ProviderConfigShape = {
-  enabled: z.boolean().optional(),
-  accounts: z
-    .array(z.object({ id: z.string().min(1), label: z.string().optional() }).strict())
-    .optional(),
-} satisfies z.ZodRawShape;
-
-const PolicySectionShape = {
-  subscription_first: z.boolean().optional(),
-  allow_api_key_fallback: z.boolean().optional(),
-  allow_third_party_subscription_adapters: z.boolean().optional(),
-  denied_providers: z.array(z.string().min(1)).optional(),
-  near_limit_threshold: z.number().min(0).max(1).optional(),
-} satisfies z.ZodRawShape;
-
-const RootConfigShape = {
-  allowlisted_profiles: z.array(z.string().min(1)).optional(),
-  denied_profile_patterns: z.array(z.string().min(1)).optional(),
-  policy: z.object(PolicySectionShape).strict().optional(),
-  providers: z
-    .record(z.string().min(1), z.object(ProviderConfigShape).strict())
-    .optional(),
-} satisfies z.ZodRawShape;
-
-const ProfileFileShape = {
-  id: z.string().min(1).optional(),
-  denied_providers: z.array(z.string().min(1)).optional(),
-  allow_api_key_fallback: z.boolean().optional(),
-  subscription_first: z.boolean().optional(),
-} satisfies z.ZodRawShape;
-
-const RootConfigSchema = z.object(RootConfigShape).strict();
-const ProfileFileSchema = z.object(ProfileFileShape).strict();
-
-const PROVIDER_ALLOWED: AllowedShape = {
-  ...allowedFromZodShape(ProviderConfigShape),
-  accounts: "leaf",
-};
-const ROOT_ALLOWED: AllowedShape = {
-  ...allowedFromZodShape(RootConfigShape),
-  policy: allowedFromZodShape(PolicySectionShape),
-  providers: "record",
-};
-const PROFILE_ALLOWED: AllowedShape = allowedFromZodShape(ProfileFileShape);
-
-type RootConfig = z.infer<typeof RootConfigSchema>;
-type ProfileFile = z.infer<typeof ProfileFileSchema>;
-
-const DEFAULT_DENIED_PROFILE_PATTERNS = ["*-work"] as const;
-
-/**
- * Safe default config: work profiles denied, nothing allowlisted, no providers.
- */
-export function defaultConfig(homeDir = ""): OffRouterConfig {
-  return {
-    homeDir,
-    sources: [],
-    policy: {
-      allowlistedProfiles: [],
-      deniedProfilePatterns: [...DEFAULT_DENIED_PROFILE_PATTERNS],
-      allowThirdPartySubscriptionAdapters: false,
-      deniedProviders: [],
-    },
-    policyDefaults: {
-      subscriptionFirst: true,
-      allowApiKeyFallback: false,
-    },
-    providers: {},
-    profiles: {},
-    warnings: [],
-  };
-}
-
-export function resolveOffRouterHome(
-  options: ResolveHomeOptions = {},
-): string {
-  const env = options.env ?? process.env;
-  const home = options.homedir ?? osHomedir;
-  const override = env.OFFROUTER_HOME?.trim();
-  if (override) {
-    return resolve(override);
-  }
-  return resolve(join(home(), ".offrouter"));
-}
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function formatZodIssues(error: z.ZodError): string[] {
-  return error.issues.map((issue) => {
-    const path = issue.path.length > 0 ? issue.path.join(".") : "(root)";
-    return `${path}: ${issue.message}`;
-  });
-}
-
-/**
- * Non-Zod path walker that flags keys absent from a schema tree.
- * Uses Zod internals only as type-shape guidance via a parallel known-keys model.
- */
-function collectUnknownKeyWarnings(
-  value: unknown,
-  allowed: AllowedShape,
-  filePath: string,
-  pathPrefix: string,
-): ConfigWarning[] {
-  if (!isPlainObject(value)) {
-    return [];
-  }
-
-  const warnings: ConfigWarning[] = [];
-  for (const key of Object.keys(value)) {
-    const keyPath = pathPrefix ? `${pathPrefix}.${key}` : key;
-    const child = allowed[key];
-    if (child === undefined) {
-      warnings.push({
-        filePath,
-        path: keyPath,
-        message: `Unknown config key "${keyPath}" in ${filePath}`,
-      });
-      continue;
-    }
-    if (child === "leaf") {
-      continue;
-    }
-    if (child === "record") {
-      const recordValue = value[key];
-      if (isPlainObject(recordValue)) {
-        for (const nestedKey of Object.keys(recordValue)) {
-          const nestedPath = `${keyPath}.${nestedKey}`;
-          warnings.push(
-            ...collectUnknownKeyWarnings(
-              recordValue[nestedKey],
-              PROVIDER_ALLOWED,
-              filePath,
-              nestedPath,
-            ),
-          );
-        }
-      }
-      continue;
-    }
-    warnings.push(
-      ...collectUnknownKeyWarnings(value[key], child, filePath, keyPath),
-    );
-  }
-  return warnings;
-}
-
-function parseTomlFile(content: string, filePath: string): unknown {
-  try {
-    return parseToml(content);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new ConfigError(filePath, [`parse error: ${message}`], err);
-  }
-}
-
-function validateRoot(
-  raw: unknown,
-  filePath: string,
-): { data: RootConfig; warnings: ConfigWarning[] } {
-  const warnings = collectUnknownKeyWarnings(raw, ROOT_ALLOWED, filePath, "");
-  // Strip unknown keys before strict Zod parse so warnings ≠ hard failure.
-  const stripped = stripUnknown(raw, ROOT_ALLOWED);
-  const parsed = RootConfigSchema.safeParse(stripped);
-  if (!parsed.success) {
-    throw new ConfigError(filePath, formatZodIssues(parsed.error), parsed.error);
-  }
-  return { data: parsed.data, warnings };
-}
-
-function validateProfile(
-  raw: unknown,
-  filePath: string,
-  fallbackId: string,
-): { data: ConfiguredProfile; warnings: ConfigWarning[] } {
-  const warnings = collectUnknownKeyWarnings(
-    raw,
-    PROFILE_ALLOWED,
-    filePath,
-    "",
-  );
-  const stripped = stripUnknown(raw, PROFILE_ALLOWED);
-  const parsed = ProfileFileSchema.safeParse(stripped);
-  if (!parsed.success) {
-    throw new ConfigError(filePath, formatZodIssues(parsed.error), parsed.error);
-  }
-  const profile: ProfileFile = parsed.data;
-  const data: ConfiguredProfile = {
-    id: profile.id ?? fallbackId,
-  };
-  if (profile.denied_providers !== undefined) {
-    data.deniedProviders = profile.denied_providers;
-  }
-  if (profile.allow_api_key_fallback !== undefined) {
-    data.allowApiKeyFallback = profile.allow_api_key_fallback;
-  }
-  if (profile.subscription_first !== undefined) {
-    data.subscriptionFirst = profile.subscription_first;
-  }
-
-  return {
-    data,
-    warnings,
-  };
-}
-
-function stripUnknown(value: unknown, allowed: AllowedShape): unknown {
-  if (!isPlainObject(value)) {
-    return value;
-  }
-  const out: Record<string, unknown> = {};
-  for (const [key, child] of Object.entries(allowed)) {
-    if (!(key in value)) continue;
-    const v = value[key];
-    if (child === "leaf") {
-      out[key] = v;
-    } else if (child === "record") {
-      if (isPlainObject(v)) {
-        const recordOut: Record<string, unknown> = {};
-        for (const [nestedKey, nestedVal] of Object.entries(v)) {
-          recordOut[nestedKey] = stripUnknown(nestedVal, PROVIDER_ALLOWED);
-        }
-        out[key] = recordOut;
-      } else {
-        out[key] = v;
-      }
-    } else {
-      out[key] = stripUnknown(v, child);
-    }
-  }
-  return out;
-}
-
-function mergeRootInto(
-  target: OffRouterConfig,
-  root: RootConfig,
-  sourcePath: string,
-): void {
-  target.sources.push(sourcePath);
-
-  if (root.allowlisted_profiles) {
-    target.policy.allowlistedProfiles = uniqueStrings([
-      ...target.policy.allowlistedProfiles,
-      ...root.allowlisted_profiles,
-    ]);
-  }
-
-  if (root.denied_profile_patterns) {
-    target.policy.deniedProfilePatterns = uniqueStrings([
-      ...(target.policy.deniedProfilePatterns ?? [
-        ...DEFAULT_DENIED_PROFILE_PATTERNS,
-      ]),
-      ...root.denied_profile_patterns,
-    ]);
-  }
-
-  if (root.policy) {
-    if (root.policy.subscription_first !== undefined) {
-      target.policyDefaults.subscriptionFirst = root.policy.subscription_first;
-    }
-    if (root.policy.allow_api_key_fallback !== undefined) {
-      target.policyDefaults.allowApiKeyFallback =
-        root.policy.allow_api_key_fallback;
-    }
-    if (root.policy.allow_third_party_subscription_adapters !== undefined) {
-      target.policy.allowThirdPartySubscriptionAdapters =
-        root.policy.allow_third_party_subscription_adapters;
-    }
-    if (root.policy.near_limit_threshold !== undefined) {
-      target.policy.nearLimitThreshold = root.policy.near_limit_threshold;
-    }
-    if (root.policy.denied_providers) {
-      target.policy.deniedProviders = uniqueStrings([
-        ...(target.policy.deniedProviders ?? []),
-        ...root.policy.denied_providers,
-      ]);
-    }
-  }
-
-  if (root.providers) {
-    for (const [id, provider] of Object.entries(root.providers)) {
-      const accounts: ConfiguredAccount[] = provider.accounts
-        ? provider.accounts.map((a: { id: string; label?: string }) => ({ id: a.id, label: a.label }))
-        : [{ id }];
-      target.providers[id] = {
-        id,
-        enabled: provider.enabled ?? true,
-        accounts,
-      };
-    }
-  }
-}
-
-function uniqueStrings(values: string[]): string[] {
-  return [...new Set(values)];
-}
-
-async function readOptionalFile(path: string): Promise<string | null> {
-  try {
-    return await readFile(path, "utf8");
-  } catch (err) {
-    if (
-      err &&
-      typeof err === "object" &&
-      "code" in err &&
-      (err as { code?: string }).code === "ENOENT"
-    ) {
-      return null;
-    }
-    throw err;
-  }
-}
-
-async function loadRootFile(
-  filePath: string,
-  target: OffRouterConfig,
-): Promise<void> {
-  const content = await readOptionalFile(filePath);
-  if (content === null) {
-    return;
-  }
-  // Empty file is valid and means no overrides.
-  if (content.trim() === "") {
-    target.sources.push(filePath);
-    return;
-  }
-  const raw = parseTomlFile(content, filePath);
-  const { data, warnings } = validateRoot(raw, filePath);
-  target.warnings.push(...warnings);
-  mergeRootInto(target, data, filePath);
-}
-
-async function loadProfileDir(
-  dirPath: string,
-  target: OffRouterConfig,
-): Promise<void> {
-  let entries: string[];
-  try {
-    entries = await readdir(dirPath);
-  } catch (err) {
-    if (
-      err &&
-      typeof err === "object" &&
-      "code" in err &&
-      (err as { code?: string }).code === "ENOENT"
-    ) {
-      return;
-    }
-    throw err;
-  }
-
-  const tomlFiles = entries
-    .filter((name) => name.endsWith(".toml"))
-    .sort((a, b) => a.localeCompare(b));
-
-  for (const name of tomlFiles) {
-    const filePath = join(dirPath, name);
-    const content = await readFile(filePath, "utf8");
-    const raw =
-      content.trim() === "" ? {} : parseTomlFile(content, filePath);
-    const fallbackId = name.replace(/\.toml$/i, "");
-    const { data, warnings } = validateProfile(raw, filePath, fallbackId);
-    target.warnings.push(...warnings);
-    target.sources.push(filePath);
-    if (target.profiles[data.id]) {
-      target.warnings.push({
-        filePath,
-        path: `profiles.${data.id}`,
-        message: `Duplicate profile id "${data.id}" in ${filePath}; later profile file overwrote an earlier definition.`,
-      });
-    }
-    target.profiles[data.id] = data;
-  }
-}
-
-/**
- * Load OffRouter configuration.
- *
- * Resolution order:
- * 1. defaults (deny *-work, empty allowlist, no providers)
- * 2. `$OFFROUTER_HOME/config.toml` or `~/.offrouter/config.toml`
- * 3. `$OFFROUTER_HOME/profiles/*.toml`
- * 4. `<workspace>/.offrouter/config.toml` only when workspaceTrusted
- */
-export async function loadConfig(
-  options: LoadConfigOptions = {},
-): Promise<OffRouterConfig> {
-  const homeDir = resolveOffRouterHome(options);
-  const config = defaultConfig(homeDir);
-
-  await loadRootFile(join(homeDir, "config.toml"), config);
-  await loadProfileDir(join(homeDir, "profiles"), config);
-
-  if (options.workspaceDir && options.workspaceTrusted) {
-    await loadRootFile(
-      join(options.workspaceDir, ".offrouter", "config.toml"),
-      config,
-    );
-  }
-
-  return config;
-}