@ebrindley/build 0.0.0-stage → 2026.11.14-rc.1

package/dist/chunk-NXZ3DURF.js

@@ -0,0 +1,257 @@
+// src/core/cleanup/provider-temp-cleanup.ts
+import { lstat, readdir, realpath, rm, rmdir, stat } from "fs/promises";
+import { join, resolve } from "path";
+var LARGE_RECLAMATION_THRESHOLD_BYTES = 1024 * 1024 * 1024;
+var TOP_OFFENDERS_LIMIT = 10;
+function defaultProviderTempRoots() {
+  const uid = process.getuid?.() ?? 501;
+  const roots = [];
+  roots.push(`/private/tmp/claude-${uid}`);
+  roots.push("/private/tmp/claude-mcp-npm-cache");
+  return roots;
+}
+var ALLOWED_ROOT_PREFIXES = [
+  "/tmp",
+  "/private/tmp",
+  "/var/folders",
+  "/private/var/folders"
+];
+function isAllowedRootPrefix(path, options = {}) {
+  return ALLOWED_ROOT_PREFIXES.some(
+    (prefix) => options.allowExactRoot && path === prefix || path.startsWith(`${prefix}/`)
+  );
+}
+async function validateProviderTempRoot(root, options = {}) {
+  const resolved = resolve(root);
+  if (!isAllowedRootPrefix(resolved, options)) {
+    return {
+      valid: false,
+      resolved,
+      reason: `Refused to operate on root outside ${ALLOWED_ROOT_PREFIXES.join(", ")}`
+    };
+  }
+  try {
+    const rootStats = await lstat(resolved);
+    if (rootStats.isSymbolicLink()) {
+      return {
+        valid: false,
+        resolved,
+        reason: "Refused to operate on symlinked root"
+      };
+    }
+    const canonical = await realpath(resolved);
+    if (!isAllowedRootPrefix(canonical, options)) {
+      return {
+        valid: false,
+        resolved,
+        reason: `Refused to operate on root resolving outside ${ALLOWED_ROOT_PREFIXES.join(", ")}`
+      };
+    }
+  } catch {
+  }
+  return { valid: true, resolved };
+}
+async function walkDirectory(dir, nowMs) {
+  const files = [];
+  const errors = [];
+  async function walk(currentDir) {
+    let entries;
+    try {
+      entries = await readdir(currentDir);
+    } catch (err) {
+      errors.push(`readdir ${currentDir}: ${err instanceof Error ? err.message : String(err)}`);
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry);
+      try {
+        const stats = await lstat(fullPath);
+        if (stats.isSymbolicLink()) {
+          continue;
+        }
+        if (stats.isDirectory()) {
+          await walk(fullPath);
+          continue;
+        }
+        if (stats.isFile()) {
+          const ageMs = nowMs - stats.mtimeMs;
+          const ageHours = ageMs / (1e3 * 60 * 60);
+          files.push({
+            path: fullPath,
+            sizeBytes: stats.size,
+            ageHours,
+            isDirectory: false
+          });
+        }
+      } catch (err) {
+        errors.push(`stat ${fullPath}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+  await walk(dir);
+  return { files, errors };
+}
+async function removeEmptyDirs(dir) {
+  let removed = 0;
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return 0;
+  }
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    try {
+      const stats = await lstat(fullPath);
+      if (stats.isDirectory() && !stats.isSymbolicLink()) {
+        removed += await removeEmptyDirs(fullPath);
+      }
+    } catch {
+    }
+  }
+  try {
+    const remaining = await readdir(dir);
+    if (remaining.length === 0) {
+      await rmdir(dir);
+      removed++;
+    }
+  } catch {
+  }
+  return removed;
+}
+async function scanRoot(root, maxAgeHours) {
+  const validation = await validateProviderTempRoot(root);
+  const resolved = validation.resolved;
+  if (!validation.valid) {
+    return {
+      result: {
+        root: resolved,
+        exists: false,
+        totalFiles: 0,
+        totalSizeBytes: 0,
+        deletableFiles: 0,
+        deletableSizeBytes: 0,
+        topOffenders: [],
+        skipped: 0
+      },
+      files: [],
+      errors: [validation.reason ?? "Invalid root"]
+    };
+  }
+  try {
+    await stat(resolved);
+  } catch {
+    return {
+      result: {
+        root: resolved,
+        exists: false,
+        totalFiles: 0,
+        totalSizeBytes: 0,
+        deletableFiles: 0,
+        deletableSizeBytes: 0,
+        topOffenders: [],
+        skipped: 0
+      },
+      files: [],
+      errors: []
+    };
+  }
+  const nowMs = Date.now();
+  const { files, errors } = await walkDirectory(resolved, nowMs);
+  const totalFiles = files.length;
+  const totalSizeBytes = files.reduce((sum, f) => sum + f.sizeBytes, 0);
+  const deletable = files.filter((f) => f.ageHours >= maxAgeHours);
+  const deletableFiles = deletable.length;
+  const deletableSizeBytes = deletable.reduce((sum, f) => sum + f.sizeBytes, 0);
+  const skipped = totalFiles - deletableFiles;
+  const topOffenders = [...files].sort((a, b) => b.sizeBytes - a.sizeBytes).slice(0, TOP_OFFENDERS_LIMIT);
+  return {
+    result: {
+      root: resolved,
+      exists: true,
+      totalFiles,
+      totalSizeBytes,
+      deletableFiles,
+      deletableSizeBytes,
+      topOffenders,
+      skipped
+    },
+    files,
+    errors
+  };
+}
+async function cleanProviderTemp(config, options) {
+  const report = {
+    mode: options.dryRun ? "dry-run" : "executed",
+    roots: [],
+    totals: {
+      scannedFiles: 0,
+      deletedFiles: 0,
+      freedBytes: 0,
+      skippedFiles: 0
+    },
+    errors: []
+  };
+  for (const root of config.roots) {
+    const validation = await validateProviderTempRoot(root);
+    if (!validation.valid) {
+      report.errors.push(`${validation.reason}: ${validation.resolved}`);
+      continue;
+    }
+    const { result, files, errors } = await scanRoot(validation.resolved, config.maxAgeHours);
+    report.roots.push(result);
+    report.errors.push(...errors);
+    report.totals.scannedFiles += result.totalFiles;
+    report.totals.skippedFiles += result.skipped;
+    if (!result.exists || result.deletableFiles === 0) {
+      continue;
+    }
+    if (options.dryRun) {
+      report.totals.deletedFiles += result.deletableFiles;
+      report.totals.freedBytes += result.deletableSizeBytes;
+      continue;
+    }
+    const deletable = files.filter((f) => f.ageHours >= config.maxAgeHours);
+    let deletedCount = 0;
+    let freedBytes = 0;
+    for (const file of deletable) {
+      try {
+        await rm(file.path, { force: true });
+        deletedCount++;
+        freedBytes += file.sizeBytes;
+      } catch (err) {
+        report.errors.push(
+          `delete ${file.path}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    try {
+      const entries = await readdir(validation.resolved);
+      for (const entry of entries) {
+        const subdir = join(validation.resolved, entry);
+        const stats = await lstat(subdir);
+        if (stats.isDirectory() && !stats.isSymbolicLink()) {
+          await removeEmptyDirs(subdir);
+        }
+      }
+    } catch {
+    }
+    report.totals.deletedFiles += deletedCount;
+    report.totals.freedBytes += freedBytes;
+  }
+  if (!options.quiet && !options.dryRun && report.totals.freedBytes >= LARGE_RECLAMATION_THRESHOLD_BYTES) {
+    const gbFreed = (report.totals.freedBytes / (1024 * 1024 * 1024)).toFixed(1);
+    report.errors.push(
+      `WARNING: Large reclamation detected (${gbFreed} GB freed). Check provider temp generation rate.`
+    );
+  }
+  return report;
+}
+
+export {
+  defaultProviderTempRoots,
+  validateProviderTempRoot,
+  scanRoot,
+  cleanProviderTemp
+};
+//# sourceMappingURL=chunk-NXZ3DURF.js.map

package/dist/chunk-NY7VYMMY.js

@@ -0,0 +1,220 @@
+import {
+  createGrokCliChildEnv,
+  parseGrokCliVersion,
+  shouldEmitGrokModelArg
+} from "./chunk-CBZHP756.js";
+import {
+  resolveProviderCliCommand
+} from "./chunk-KKQKWAMF.js";
+
+// src/core/providers/grok/model-catalog.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import path from "path";
+var MAX_CATALOG_BYTES = 8 * 1024 * 1024;
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function positiveInt(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : void 0;
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function resolveGrokCatalogPath(env) {
+  const explicit = env.GROK_HOME?.trim();
+  const home = explicit || path.join(env.HOME?.trim() || homedir(), ".grok");
+  return path.join(home, "models_cache.json");
+}
+function readEffortLevels(info) {
+  if (info.supports_reasoning_effort === false || !Array.isArray(info.reasoning_efforts)) {
+    return void 0;
+  }
+  const levels = info.reasoning_efforts.flatMap((level) => {
+    const id = typeof level === "string" ? level : record(level)?.id ?? record(level)?.value;
+    const text = nonEmptyString(id);
+    return text ? [text] : [];
+  });
+  return levels.length ? [...new Set(levels)] : void 0;
+}
+function parseGrokModelCatalog(value) {
+  const models = record(value)?.models;
+  const entries = Array.isArray(models) ? models.map((raw) => [void 0, raw]) : Object.entries(record(models) ?? {});
+  const rows = /* @__PURE__ */ new Map();
+  for (const [key, raw] of entries) {
+    const info = record(record(raw)?.info);
+    const id = nonEmptyString(info?.id) ?? nonEmptyString(key);
+    if (!info || !id || id.length > 256 || /\s/.test(id)) continue;
+    const levels = readEffortLevels(info);
+    const defaultEffort = nonEmptyString(info.reasoning_effort);
+    const windows = Array.isArray(info.context_windows) ? info.context_windows.flatMap((item) => positiveInt(item) ?? []) : [];
+    const contextWindow = positiveInt(info.context_window);
+    const maxContextWindow = windows.length ? Math.max(...windows) : void 0;
+    const maxOutputTokens = positiveInt(info.max_completion_tokens);
+    const name = nonEmptyString(info.name);
+    const description = nonEmptyString(info.description);
+    rows.set(id, {
+      id,
+      hidden: info.hidden === true,
+      ...name ? { name } : {},
+      ...description ? { description } : {},
+      ...typeof info.supported_in_api === "boolean" ? { supportedInApi: info.supported_in_api } : {},
+      ...levels ? { reasoningEffortLevels: levels } : {},
+      ...levels && defaultEffort && levels.includes(defaultEffort) ? { defaultReasoningEffort: defaultEffort } : {},
+      ...contextWindow ? { contextWindow } : {},
+      ...maxContextWindow ? { maxContextWindow } : {},
+      ...maxOutputTokens ? { maxOutputTokens } : {}
+    });
+  }
+  return [...rows.values()];
+}
+function readGrokModelCatalog(env) {
+  try {
+    const text = readFileSync(resolveGrokCatalogPath(env), "utf8");
+    if (text.length > MAX_CATALOG_BYTES) return [];
+    return parseGrokModelCatalog(JSON.parse(text));
+  } catch {
+    return [];
+  }
+}
+
+// src/core/providers/grok/model-discovery.ts
+var DEFAULT_MODEL_LINE = /^Default model:\s*(\S+)/i;
+var AVAILABLE_HEADER = /^Available models:/i;
+var MODEL_ROW = /^[\s>*-]+(\S+)(?:\s|$)/;
+function stripAnsi(text) {
+  return text.replace(new RegExp(String.raw`\x1B\[[0-?]*[ -/]*[@-~]`, "g"), "");
+}
+function parseGrokModelsStdout(stdout) {
+  const result = { modelIds: [] };
+  if (!stdout || stdout.trim().length === 0) return result;
+  const lines = stripAnsi(stdout).split(/\r?\n/);
+  let inAvailable = false;
+  for (const rawLine of lines) {
+    const line = rawLine.trimEnd();
+    if (!line.trim()) {
+      continue;
+    }
+    const defaultMatch = DEFAULT_MODEL_LINE.exec(line);
+    if (defaultMatch) {
+      result.defaultModel = defaultMatch[1];
+      continue;
+    }
+    if (AVAILABLE_HEADER.test(line)) {
+      inAvailable = true;
+      continue;
+    }
+    if (!inAvailable) continue;
+    const rowMatch = MODEL_ROW.exec(line);
+    if (!rowMatch) continue;
+    const id = rowMatch[1];
+    if (!id) continue;
+    if (/^[A-Z]/.test(id) && /\s/.test(line.slice(rowMatch[0].length))) {
+      continue;
+    }
+    if (!result.modelIds.includes(id)) {
+      result.modelIds.push(id);
+    }
+  }
+  return result;
+}
+async function probeGrokModelsFromCli(options = {}) {
+  const timeoutMs = options.timeoutMs ?? 1e4;
+  let parsed = { modelIds: [] };
+  let cliVersion;
+  const env = createGrokCliChildEnv(options.env);
+  try {
+    const { execa } = await import("execa");
+    const { command, prefixArgs } = options.cliCommand ?? resolveProviderCliCommand("grok");
+    const modelsResult = await execa(command, [...prefixArgs, "models"], {
+      reject: false,
+      timeout: timeoutMs,
+      stdio: "pipe",
+      env,
+      extendEnv: false
+    });
+    parsed = parseGrokModelsStdout(String(modelsResult.stdout ?? ""));
+    try {
+      const versionResult = await execa(command, [...prefixArgs, "--version"], {
+        reject: false,
+        timeout: timeoutMs,
+        stdio: "pipe",
+        env,
+        extendEnv: false
+      });
+      cliVersion = parseGrokCliVersion(
+        `${String(versionResult.stdout ?? "")}
+${String(versionResult.stderr ?? "")}`
+      );
+    } catch {
+    }
+  } catch {
+  }
+  if (parsed.modelIds.length > 0) {
+    const listed = new Set(parsed.modelIds);
+    return {
+      discoveryStatus: "discovered",
+      defaultModel: parsed.defaultModel,
+      modelIds: parsed.modelIds,
+      // The text list stays the membership authority; the catalog only enriches it.
+      catalog: readGrokModelCatalog(env).filter((entry) => listed.has(entry.id)),
+      ...cliVersion ? { cliVersion } : {}
+    };
+  }
+  return {
+    discoveryStatus: "unavailable",
+    modelIds: [],
+    catalog: [],
+    ...cliVersion ? { cliVersion } : {}
+  };
+}
+function buildGrokModelSelection(modelInput, discovery) {
+  const normalizedInput = modelInput.trim();
+  const emitModelArg = shouldEmitGrokModelArg(normalizedInput);
+  const nativeDefault = discovery.defaultModel ?? null;
+  const effectiveModel = emitModelArg ? normalizedInput : nativeDefault ?? "auto";
+  let selectedModelAvailable = null;
+  if (discovery.discoveryStatus === "discovered") {
+    if (emitModelArg) {
+      selectedModelAvailable = discovery.modelIds.includes(normalizedInput);
+    } else if (nativeDefault !== null) {
+      selectedModelAvailable = discovery.modelIds.includes(nativeDefault);
+    }
+  }
+  return {
+    modelInput: normalizedInput,
+    effectiveModel,
+    nativeDefault,
+    emitModelArg,
+    emittedModel: emitModelArg ? normalizedInput : null,
+    cliVersion: discovery.cliVersion ?? null,
+    discoveryStatus: discovery.discoveryStatus,
+    availableModels: [...discovery.modelIds],
+    catalog: [...discovery.catalog],
+    selectedModelAvailable
+  };
+}
+async function resolveGrokModelSelection(input) {
+  const discovery = await probeGrokModelsFromCli({ env: input.env, cliCommand: input.cliCommand });
+  return buildGrokModelSelection(input.modelInput, discovery);
+}
+async function resolveGrokReasoningEffortLookupModel(modelInput, env) {
+  const normalized = modelInput?.trim() ?? "";
+  if (shouldEmitGrokModelArg(normalized)) {
+    return normalized;
+  }
+  const selection = await resolveGrokModelSelection({
+    modelInput: normalized || "auto",
+    ...env ? { env } : {}
+  });
+  if (selection.discoveryStatus !== "discovered") {
+    return normalized || "auto";
+  }
+  return selection.effectiveModel;
+}
+
+export {
+  resolveGrokModelSelection,
+  resolveGrokReasoningEffortLookupModel
+};
+//# sourceMappingURL=chunk-NY7VYMMY.js.map

package/dist/chunk-NZ4AOB7R.js

@@ -0,0 +1,127 @@
+import {
+  emitTelemetryFallbackWarning
+} from "./chunk-BQJOGAWT.js";
+import {
+  shouldRequireNativeSqlite
+} from "./chunk-ZR3DRTPS.js";
+import {
+  NATIVE_SQLITE_INITIALIZATION_MARKER
+} from "./chunk-TAJPCXSB.js";
+
+// src/telemetry/sqlite-wrapper.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var NativeDatabase = null;
+var requireNativeSqlite = shouldRequireNativeSqlite();
+var reportNativeSqliteFailure = (phase, error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  const diagnostic = `${NATIVE_SQLITE_INITIALIZATION_MARKER} (${phase}): ${message}`;
+  if (requireNativeSqlite) {
+    throw new Error(`${diagnostic}. Set BUILD_SQLITE_REQUIRE_NATIVE=0 to allow shim fallback.`);
+  }
+  emitTelemetryFallbackWarning(`${diagnostic}. Falling back to in-memory shim.`);
+};
+try {
+  const required = require2("better-sqlite3");
+  try {
+    const test = new required(":memory:");
+    test.close();
+    NativeDatabase = required;
+  } catch (err) {
+    reportNativeSqliteFailure("self-test", err);
+    NativeDatabase = null;
+  }
+} catch (err) {
+  reportNativeSqliteFailure("module_load", err);
+  NativeDatabase = null;
+}
+function normalizeSqlPreview(sql) {
+  return sql.replace(/\s+/g, " ").trim().slice(0, 160);
+}
+function isMutatingSql(sql) {
+  const normalized = sql.trim().toUpperCase();
+  return /^(INSERT|UPDATE|DELETE|REPLACE|CREATE|ALTER|DROP|BEGIN|COMMIT|ROLLBACK|SAVEPOINT|RELEASE|VACUUM|ANALYZE|ATTACH|DETACH)\b/.test(
+    normalized
+  );
+}
+var InMemoryStatement = class {
+  sql;
+  db;
+  constructor(sql, db) {
+    this.sql = sql;
+    this.db = db;
+  }
+  run(..._args) {
+    if (isMutatingSql(this.sql)) {
+      this.db.reportDroppedWrite("statement.run", this.sql);
+    }
+    return { changes: 0 };
+  }
+  get(...args) {
+    const sel = /SELECT \* FROM\s+([a-z_]+)/i.exec(this.sql);
+    if (sel?.[1] && args.length > 0) {
+      const table = sel[1];
+      const key = args[0];
+      if (key !== void 0 && table in this.db) {
+        const map = this.db[table];
+        if (map && typeof map.get === "function") {
+          return map.get(key) ?? null;
+        }
+      }
+    }
+    return null;
+  }
+  all(..._args) {
+    return [];
+  }
+};
+var InMemoryDatabase = class {
+  droppedWriteWarnings = /* @__PURE__ */ new Set();
+  model_invocations = /* @__PURE__ */ new Map();
+  registry_snapshots = /* @__PURE__ */ new Map();
+  enriched_invocations = /* @__PURE__ */ new Map();
+  usage_evidence = /* @__PURE__ */ new Map();
+  cost_evaluations = /* @__PURE__ */ new Map();
+  aggregates_hourly = /* @__PURE__ */ new Map();
+  pragma(_p) {
+    return null;
+  }
+  exec(sql) {
+    if (isMutatingSql(sql)) {
+      this.reportDroppedWrite("exec", sql);
+    }
+    return;
+  }
+  prepare(sql) {
+    return new InMemoryStatement(sql, this);
+  }
+  transaction(fn) {
+    return () => fn();
+  }
+  close() {
+  }
+  reportDroppedWrite(operation, sql) {
+    const preview = normalizeSqlPreview(sql);
+    const warningKey = `${operation}:${preview}`;
+    if (this.droppedWriteWarnings.has(warningKey)) {
+      return;
+    }
+    this.droppedWriteWarnings.add(warningKey);
+    emitTelemetryFallbackWarning(
+      `[sqlite-wrapper] better-sqlite3 unavailable; in-memory fallback dropped ${operation} write: ${preview}`
+    );
+  }
+};
+var __sqliteWrapperTestUtils = {
+  InMemoryDatabase,
+  isMutatingSql,
+  normalizeSqlPreview
+};
+var DatabaseImpl = NativeDatabase ?? InMemoryDatabase;
+var sqlite_wrapper_default = DatabaseImpl;
+
+export {
+  __sqliteWrapperTestUtils,
+  sqlite_wrapper_default
+};
+//# sourceMappingURL=chunk-NZ4AOB7R.js.map