nexus-agents 2.56.0 → 2.57.0

package/dist/registry-command-S46JJ2SX.js

@@ -0,0 +1,580 @@
+import {
+  DEFAULT_MODEL_CAPABILITIES,
+  ModelCapabilitySchema,
+  createLogger,
+  getModelCapabilities
+} from "./chunk-R2Y57PM3.js";
+import "./chunk-CLYZ7FWP.js";
+import "./chunk-UP2VWCW5.js";
+
+// src/cli/registry-command.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/config/capability-discovery.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join as join2 } from "path";
+import { z } from "zod";
+
+// src/config/capability-overlay.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { parse as parseYaml } from "yaml";
+var OVERLAY_ENV_VAR = "NEXUS_MODEL_REGISTRY_OVERLAY";
+var OVERLAY_MAX_BYTES = 1 * 1024 * 1024;
+function defaultOverlayPath() {
+  return join(homedir(), ".nexus-agents", "models.yaml");
+}
+function resolveOverlayPath(env = process.env) {
+  const override = env[OVERLAY_ENV_VAR];
+  if (override !== void 0 && override !== "") return override;
+  return defaultOverlayPath();
+}
+function loadCapabilityOverlay(pathOrEnv, logger) {
+  const log = logger ?? createLogger({ component: "capability-overlay" });
+  const path = resolvePath(pathOrEnv);
+  if (!existsSync(path)) {
+    return { entries: [], rejections: [], path, status: "missing" };
+  }
+  const sizeStatus = checkSize(path, log);
+  if (sizeStatus !== void 0) return sizeStatus;
+  const bodyResult = readBody(path, log);
+  if ("result" in bodyResult) return bodyResult.result;
+  const body = bodyResult.body;
+  if (body === "") {
+    log.info("Model registry overlay file is empty", { path });
+    return { entries: [], rejections: [], path, status: "empty" };
+  }
+  const parseResult = parseBody(body, path, log);
+  if ("result" in parseResult) return parseResult.result;
+  const parsed = parseResult.parsed;
+  const rawEntries = extractEntries(parsed);
+  if (rawEntries === void 0) {
+    log.warn("Model registry overlay has unrecognized shape; treated as empty", {
+      path
+    });
+    return {
+      entries: [],
+      rejections: [{ index: -1, reason: "Expected array or { models: [...] }" }],
+      path,
+      status: "malformed"
+    };
+  }
+  const { entries, rejections } = validateEntries(rawEntries, log, path);
+  return { entries, rejections, path, status: "loaded" };
+}
+function resolvePath(pathOrEnv) {
+  if (typeof pathOrEnv === "string") return pathOrEnv;
+  if (pathOrEnv !== void 0) return resolveOverlayPath(pathOrEnv);
+  return resolveOverlayPath();
+}
+function readBody(path, log) {
+  try {
+    return { body: readFileSync(path, "utf-8").trim() };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.warn("Model registry overlay file read failed; treated as empty", {
+      path,
+      errorMessage: message
+    });
+    return {
+      result: {
+        entries: [],
+        rejections: [{ index: -1, reason: `file read error: ${message}` }],
+        path,
+        status: "malformed"
+      }
+    };
+  }
+}
+function parseBody(body, path, log) {
+  try {
+    return { parsed: parseYaml(body) };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.warn("Model registry overlay YAML parse failed; treated as empty", {
+      path,
+      errorMessage: message
+    });
+    return {
+      result: {
+        entries: [],
+        rejections: [{ index: -1, reason: `YAML parse error: ${message}` }],
+        path,
+        status: "malformed"
+      }
+    };
+  }
+}
+function checkSize(path, log) {
+  let size;
+  try {
+    size = statSync(path).size;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.warn("Model registry overlay statSync failed; treated as missing", {
+      path,
+      errorMessage: message
+    });
+    return { entries: [], rejections: [], path, status: "missing" };
+  }
+  if (size <= OVERLAY_MAX_BYTES) return void 0;
+  log.warn("Model registry overlay exceeds size cap; refusing to load", {
+    path,
+    size,
+    maxBytes: OVERLAY_MAX_BYTES
+  });
+  return {
+    entries: [],
+    rejections: [
+      {
+        index: -1,
+        reason: `file size ${String(size)} exceeds cap ${String(OVERLAY_MAX_BYTES)}`
+      }
+    ],
+    path,
+    status: "too-large"
+  };
+}
+function extractIdForError(raw) {
+  if (raw === null || typeof raw !== "object" || !("id" in raw)) return void 0;
+  const idValue = raw.id;
+  if (typeof idValue === "string" && idValue !== "") return idValue;
+  return void 0;
+}
+function extractEntries(parsed) {
+  if (Array.isArray(parsed)) return parsed;
+  if (parsed !== null && typeof parsed === "object") {
+    const obj = parsed;
+    if (Array.isArray(obj.models)) return obj.models;
+  }
+  return void 0;
+}
+function validateEntries(rawEntries, log, path) {
+  const entries = [];
+  const rejections = [];
+  for (let i = 0; i < rawEntries.length; i++) {
+    const raw = rawEntries[i];
+    const idCandidate = extractIdForError(raw);
+    const parsed = ModelCapabilitySchema.safeParse(raw);
+    if (!parsed.success) {
+      const rejection = {
+        index: i,
+        ...idCandidate !== void 0 && idCandidate !== "" ? { id: idCandidate } : {},
+        reason: parsed.error.message
+      };
+      rejections.push(rejection);
+      log.warn("Model registry overlay entry rejected by schema", {
+        path,
+        index: i,
+        id: idCandidate,
+        errorMessage: parsed.error.message
+      });
+      continue;
+    }
+    entries.push(parsed.data);
+  }
+  return { entries, rejections };
+}
+
+// src/config/capability-discovery.ts
+var GeneratedProvenanceSchema = z.object({
+  source: z.enum(["models.dev", "litellm"]),
+  fetchedAt: z.string(),
+  upstreamUrl: z.string()
+});
+var GeneratedModelEntrySchema = z.object({
+  id: z.string().min(1),
+  displayName: z.string().min(1),
+  provider: z.string().min(1),
+  contextWindow: z.number().int().positive(),
+  pricing: z.object({
+    inputPer1M: z.number().nonnegative(),
+    outputPer1M: z.number().nonnegative()
+  }).optional(),
+  maxOutputTokens: z.number().int().positive().optional(),
+  deprecated: z.boolean().optional(),
+  provenance: GeneratedProvenanceSchema
+});
+var GeneratedRegistrySchema = z.object({
+  version: z.literal(1),
+  generatedAt: z.string(),
+  entryCount: z.number().int().nonnegative(),
+  entries: z.array(GeneratedModelEntrySchema)
+});
+var LEGACY_200K_DEFAULT = { contextWindow: 2e5 };
+var FAIL_CLOSED_DEFAULT = { contextWindow: 8192 };
+var CapabilityDiscovery = class {
+  canonical;
+  generated;
+  overlay;
+  fallback;
+  logger;
+  generatedById;
+  constructor(config = {}) {
+    this.canonical = config.canonical ?? DEFAULT_MODEL_CAPABILITIES;
+    this.generated = config.generated ?? null;
+    this.overlay = config.overlay ?? [];
+    this.fallback = config.conservativeDefault ?? LEGACY_200K_DEFAULT;
+    this.logger = config.logger ?? createLogger({ component: "capability-discovery" });
+    this.generatedById = /* @__PURE__ */ new Map();
+    if (this.generated !== null) {
+      for (const entry of this.generated.entries) {
+        this.generatedById.set(entry.id, entry);
+      }
+    }
+  }
+  /** Synchronously resolve a model id through the four-tier chain. */
+  resolve(modelId) {
+    const t3 = this.lookupOverlay(modelId);
+    if (t3 !== void 0) return this.fromCanonical("t3", t3);
+    const t1 = this.lookupCanonical(modelId);
+    if (t1 !== void 0) return this.fromCanonical("t1", t1);
+    const t2 = this.lookupGenerated(modelId);
+    if (t2 !== void 0) return this.fromGenerated("t2", t2);
+    return this.fromFallback(modelId);
+  }
+  /** Exposes the configured fallback for testing / doctor command. */
+  getConservativeDefault() {
+    return this.fallback;
+  }
+  /** Count of entries per tier — used by `registry doctor` (#2179). */
+  getTierCounts() {
+    return {
+      t3: this.overlay.length,
+      t1: this.canonical.models.length,
+      t2: this.generatedById.size,
+      t4: 0
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Tier lookups
+  // -------------------------------------------------------------------------
+  lookupOverlay(modelId) {
+    return this.overlay.find((m) => m.id === modelId);
+  }
+  lookupCanonical(modelId) {
+    return getModelCapabilities(modelId, this.canonical);
+  }
+  lookupGenerated(modelId) {
+    const direct = this.generatedById.get(modelId);
+    if (direct !== void 0) return direct;
+    for (const candidate of buildAliasCandidates(modelId)) {
+      const hit = this.generatedById.get(candidate);
+      if (hit !== void 0) return hit;
+    }
+    return void 0;
+  }
+  // -------------------------------------------------------------------------
+  // Result shaping
+  // -------------------------------------------------------------------------
+  fromCanonical(tier, entry) {
+    const base = {
+      tier,
+      id: entry.id,
+      displayName: entry.displayName,
+      provider: entry.provider,
+      contextWindow: entry.contextWindow,
+      canonical: entry,
+      ...entry.pricing !== void 0 ? { pricing: entry.pricing } : {},
+      ...entry.maxOutputTokens !== void 0 ? { maxOutputTokens: entry.maxOutputTokens } : {},
+      ...entry.deprecated !== void 0 ? { deprecated: entry.deprecated } : {}
+    };
+    return base;
+  }
+  fromGenerated(tier, entry) {
+    return {
+      tier,
+      id: entry.id,
+      displayName: entry.displayName,
+      provider: entry.provider,
+      contextWindow: entry.contextWindow,
+      provenance: entry.provenance,
+      ...entry.pricing !== void 0 ? { pricing: entry.pricing } : {},
+      ...entry.maxOutputTokens !== void 0 ? { maxOutputTokens: entry.maxOutputTokens } : {},
+      ...entry.deprecated !== void 0 ? { deprecated: entry.deprecated } : {}
+    };
+  }
+  fromFallback(modelId) {
+    this.logger.warn("Model resolved at T4 conservative default", {
+      modelId,
+      contextWindow: this.fallback.contextWindow
+    });
+    return {
+      tier: "t4",
+      id: modelId,
+      displayName: modelId,
+      provider: "unknown",
+      contextWindow: this.fallback.contextWindow,
+      ...this.fallback.maxOutputTokens !== void 0 ? { maxOutputTokens: this.fallback.maxOutputTokens } : {}
+    };
+  }
+};
+var KNOWN_PROVIDER_PREFIXES = [
+  "amazon-bedrock",
+  "google-vertex",
+  "azure-openai",
+  "openrouter",
+  "anthropic",
+  "openai",
+  "google",
+  "deepseek"
+];
+function buildAliasCandidates(modelId) {
+  const seen = /* @__PURE__ */ new Set([modelId]);
+  for (const prefix of KNOWN_PROVIDER_PREFIXES) {
+    seen.add(`${prefix}/${modelId}`);
+  }
+  const slash = modelId.indexOf("/");
+  if (slash !== -1) {
+    const tail = modelId.slice(slash + 1);
+    for (const prefix of KNOWN_PROVIDER_PREFIXES) {
+      seen.add(`${prefix}/${tail}`);
+    }
+  }
+  seen.delete(modelId);
+  return [...seen];
+}
+function defaultGeneratedRegistryPath() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  return join2(here, "model-registry.generated.json");
+}
+function loadBundledGeneratedRegistry(path = defaultGeneratedRegistryPath(), logger) {
+  const log = logger ?? createLogger({ component: "capability-discovery" });
+  if (!existsSync2(path)) {
+    log.warn("T2 generated registry file missing; falling back to T1 + T4", { path });
+    return null;
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync2(path, "utf-8"));
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    log.warn("T2 generated registry JSON parse failed; falling back to T1 + T4", {
+      path,
+      errorMessage: error.message
+    });
+    return null;
+  }
+  const parsed = GeneratedRegistrySchema.safeParse(raw);
+  if (!parsed.success) {
+    log.warn("T2 generated registry schema validation failed; falling back to T1 + T4", {
+      path,
+      errorMessage: parsed.error.message
+    });
+    return null;
+  }
+  return parsed.data;
+}
+var globalDiscovery;
+function getCapabilityDiscovery() {
+  globalDiscovery ??= new CapabilityDiscovery({
+    generated: loadBundledGeneratedRegistry(),
+    overlay: loadCapabilityOverlay().entries,
+    // Fail-closed default (#2177): unknown models get 8 K context and a
+    // structured warn instead of the silent 200 K fall-through the legacy
+    // getModelContextWindow used to return.
+    conservativeDefault: FAIL_CLOSED_DEFAULT
+  });
+  return globalDiscovery;
+}
+
+// src/cli/registry-command.ts
+var VALID_SUBCOMMANDS = ["doctor", "refresh"];
+function isValidRegistrySubcommand(v) {
+  return v !== void 0 && VALID_SUBCOMMANDS.includes(v);
+}
+async function registryCommand(subcommand, options = {}) {
+  if (subcommand === "doctor") return doctorCommand(options);
+  return refreshCommand(options);
+}
+function doctorCommand(options) {
+  const report = buildDoctorReport(options);
+  if (options.json === true) {
+    return { text: JSON.stringify(report, null, 2), exitCode: 0 };
+  }
+  return { text: formatDoctorReport(report), exitCode: 0 };
+}
+function buildDoctorReport(options) {
+  const bundledPath = defaultGeneratedRegistryPath();
+  const bundled = loadBundledGeneratedRegistry(bundledPath);
+  const overlay = loadCapabilityOverlay(options.overlayPath ?? process.env);
+  const discovery = getCapabilityDiscovery();
+  const fallback = discovery.getConservativeDefault();
+  return {
+    tierCounts: discovery.getTierCounts(),
+    bundled: {
+      path: bundledPath,
+      present: bundled !== null,
+      entryCount: bundled !== null ? bundled.entryCount : null,
+      generatedAt: bundled !== null ? bundled.generatedAt : null
+    },
+    overlay: {
+      path: overlay.path,
+      status: overlay.status,
+      entryCount: overlay.entries.length,
+      rejections: overlay.rejections.map((r) => ({
+        index: r.index,
+        ...r.id !== void 0 ? { id: r.id } : {},
+        reason: r.reason
+      })),
+      envOverride: process.env[OVERLAY_ENV_VAR]
+    },
+    conservativeDefault: {
+      contextWindow: fallback.contextWindow,
+      maxOutputTokens: fallback.maxOutputTokens ?? null
+    }
+  };
+}
+function formatDoctorReport(r) {
+  const lines = [];
+  lines.push("nexus-agents registry doctor");
+  lines.push("============================");
+  lines.push("");
+  lines.push("Tier counts (T3 overlay \u2192 T1 canonical \u2192 T2 bundled \u2192 T4 fallback):");
+  lines.push(`  T3 overlay   : ${String(r.tierCounts.t3)}`);
+  lines.push(`  T1 canonical : ${String(r.tierCounts.t1)}`);
+  lines.push(`  T2 bundled   : ${String(r.tierCounts.t2)}`);
+  lines.push("");
+  lines.push("T2 bundled registry:");
+  lines.push(`  path        : ${r.bundled.path}`);
+  lines.push(`  present     : ${r.bundled.present ? "yes" : "no (using T1 + T4 only)"}`);
+  if (r.bundled.present) {
+    lines.push(`  entryCount  : ${String(r.bundled.entryCount ?? "?")}`);
+    lines.push(`  generatedAt : ${r.bundled.generatedAt ?? "?"}`);
+  }
+  lines.push("");
+  lines.push("T3 user overlay:");
+  lines.push(`  path        : ${r.overlay.path}`);
+  lines.push(`  status      : ${r.overlay.status}`);
+  lines.push(`  entryCount  : ${String(r.overlay.entryCount)}`);
+  lines.push(`  env override: ${r.overlay.envOverride ?? "(not set)"}`);
+  if (r.overlay.rejections.length > 0) {
+    lines.push("  rejections  :");
+    for (const rej of r.overlay.rejections) {
+      const idPart = rej.id !== void 0 ? ` id=${rej.id}` : "";
+      lines.push(`    - [${String(rej.index)}]${idPart} ${rej.reason}`);
+    }
+  }
+  lines.push("");
+  lines.push("T4 conservative default (for unknown ids):");
+  lines.push(`  contextWindow : ${String(r.conservativeDefault.contextWindow)}`);
+  if (r.conservativeDefault.maxOutputTokens !== null) {
+    lines.push(`  maxOutputTokens: ${String(r.conservativeDefault.maxOutputTokens)}`);
+  }
+  return lines.join("\n");
+}
+var MAX_REFRESH_BYTES = 5 * 1024 * 1024;
+function missingSourceResult() {
+  return {
+    text: [
+      "registry refresh requires --source=<url>.",
+      "",
+      "The url should point at a model-registry.generated.json file with a",
+      "matching <url>.sha256 sidecar (single line containing the SHA256 hash).",
+      "",
+      "A signed GitHub release artifact is a planned default but not wired yet;",
+      `that is tracked in #2180. Use --source=<your-mirror-url> in the meantime.`
+    ].join("\n"),
+    exitCode: 2
+  };
+}
+async function fetchAndVerify(source, fetchImpl) {
+  const body = await fetchWithCap(source, fetchImpl);
+  if (!body.ok || body.body === void 0) {
+    return { text: `Failed to fetch ${source}: ${body.error ?? "unknown"}`, exitCode: 1 };
+  }
+  const sha = await fetchWithCap(`${source}.sha256`, fetchImpl);
+  if (!sha.ok || sha.body === void 0) {
+    return {
+      text: `Failed to fetch ${source}.sha256 for integrity check: ${sha.error ?? "unknown"}`,
+      exitCode: 1
+    };
+  }
+  const expected = sha.body.trim().split(/\s+/)[0] ?? "";
+  if (expected === "") {
+    return { text: `SHA256 sidecar at ${source}.sha256 is empty`, exitCode: 1 };
+  }
+  const actual = createHash("sha256").update(body.body, "utf-8").digest("hex");
+  if (actual.toLowerCase() !== expected.toLowerCase()) {
+    return {
+      text: `SHA256 mismatch: expected ${expected}, got ${actual}. Aborting write.`,
+      exitCode: 1
+    };
+  }
+  return { body: body.body, sha256: actual };
+}
+function formatRefreshReport(verb, source, artifact, dest, extraTail = []) {
+  return [
+    `registry refresh${verb.startsWith("would") ? " --dry-run" : ""}`,
+    `source   : ${source}`,
+    `sha256   : ${artifact.sha256} (verified)`,
+    `bytes    : ${String(artifact.body.length)}`,
+    `${verb}: ${dest}`,
+    ...extraTail
+  ].join("\n");
+}
+async function refreshCommand(options) {
+  const source = options.source;
+  if (source === void 0 || source === "") return missingSourceResult();
+  const artifact = await fetchAndVerify(source, options.fetchImpl ?? fetch);
+  if ("text" in artifact) return artifact;
+  const dest = options.destPath ?? join3(homedir2(), ".nexus-agents", "model-registry.generated.json");
+  if (options.dryRun === true) {
+    return { text: formatRefreshReport("would write to", source, artifact, dest), exitCode: 0 };
+  }
+  mkdirSync(dirname2(dest), { recursive: true });
+  writeFileSync(dest, artifact.body, "utf-8");
+  return {
+    text: formatRefreshReport("wrote to", source, artifact, dest, [
+      "",
+      "The refreshed file takes precedence over the bundled registry on the next",
+      "run. Restart any running CLI / MCP server for the change to take effect."
+    ]),
+    exitCode: 0
+  };
+}
+async function fetchWithCap(url, fetchImpl) {
+  try {
+    const response = await fetchImpl(url, { signal: AbortSignal.timeout(3e4) });
+    if (!response.ok) {
+      return { ok: false, error: `HTTP ${String(response.status)}` };
+    }
+    const body = await response.text();
+    if (body.length > MAX_REFRESH_BYTES) {
+      return {
+        ok: false,
+        error: `payload ${String(body.length)} bytes exceeds cap ${String(MAX_REFRESH_BYTES)}`
+      };
+    }
+    return { ok: true, body };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: message };
+  }
+}
+function formatRegistryUsage() {
+  return [
+    "Usage:",
+    "  nexus-agents registry doctor [--json]",
+    "      Inspect the four-tier capability discovery state.",
+    "",
+    "  nexus-agents registry refresh --source=<url> [--dry-run]",
+    "      Download a signed model-registry.generated.json from <url>,",
+    "      SHA256-verify against <url>.sha256, and write to:",
+    `      ${join3(homedir2(), ".nexus-agents", "model-registry.generated.json")}`,
+    "",
+    `Overlay path (T3) is ${defaultOverlayPath()} by default,`,
+    `or whatever ${OVERLAY_ENV_VAR} points to. Overlay max size is ${String(OVERLAY_MAX_BYTES)} bytes.`
+  ].join("\n");
+}
+export {
+  formatRegistryUsage,
+  isValidRegistrySubcommand,
+  registryCommand
+};
+//# sourceMappingURL=registry-command-S46JJ2SX.js.map