blackriver-gateway 3.8.46

package/src/lib/idempotencyLayer.ts

@@ -0,0 +1,105 @@
+/**
+ * Idempotency Layer — Phase 9.2
+ *
+ * In-memory deduplication of requests with the same idempotency key.
+ * If a request with the same key arrives within 5 seconds, returns
+ * the cached response instead of making a new API call.
+ *
+ * Headers: X-Request-Id or Idempotency-Key
+ *
+ * @module lib/idempotencyLayer
+ */
+
+import { getSettings } from "@/lib/localDb";
+
+const DEFAULT_WINDOW_MS = 5000;
+
+/** @type {Map<string, { response: object, status: number, expiresAt: number }>} */
+const idempotencyStore = new Map();
+
+// Periodic cleanup every 30s
+let cleanupInterval;
+
+function ensureCleanup() {
+  if (cleanupInterval) return;
+  cleanupInterval = setInterval(() => {
+    const now = Date.now();
+    for (const [key, entry] of idempotencyStore) {
+      if (now >= entry.expiresAt) {
+        idempotencyStore.delete(key);
+      }
+    }
+  }, 30000);
+  // Don't prevent process exit
+  if (cleanupInterval.unref) cleanupInterval.unref();
+}
+
+/**
+ * Extract idempotency key from request headers.
+ * @param {Headers|object} headers
+ * @returns {string|null}
+ */
+export function getIdempotencyKey(headers) {
+  if (!headers) return null;
+  const get = typeof headers.get === "function" ? (k) => headers.get(k) : (k) => headers[k];
+  return get("idempotency-key") || get("x-request-id") || null;
+}
+
+/**
+ * Check if a response exists for the given idempotency key.
+ * @param {string} key
+ * @returns {{ response: object, status: number }|null}
+ */
+export function checkIdempotency(key) {
+  if (!key) return null;
+  const entry = idempotencyStore.get(key);
+  if (!entry) return null;
+  if (Date.now() >= entry.expiresAt) {
+    idempotencyStore.delete(key);
+    return null;
+  }
+  return { response: entry.response, status: entry.status };
+}
+
+/**
+ * Save a response for idempotency dedup.
+ * @param {string} key
+ * @param {object} response - Response body to cache
+ * @param {number} status - HTTP status code
+ * @param {number} [windowMs=5000] - Dedup window in ms
+ */
+export function saveIdempotency(key, response, status, windowMs = DEFAULT_WINDOW_MS) {
+  if (!key) return;
+  ensureCleanup();
+  idempotencyStore.set(key, {
+    response,
+    status,
+    expiresAt: Date.now() + windowMs,
+  });
+}
+
+/**
+ * Get current idempotency store stats.
+ */
+export async function getIdempotencyStats() {
+  let windowMs = DEFAULT_WINDOW_MS;
+  try {
+    const settings = await getSettings();
+    if (typeof settings.idempotencyWindowMs === "number" && settings.idempotencyWindowMs > 0) {
+      windowMs = settings.idempotencyWindowMs;
+    }
+  } catch {
+    // Fallback to default if settings unavailable
+  }
+  return {
+    activeKeys: idempotencyStore.size,
+    windowMs,
+  };
+}
+
+/**
+ * Clear all idempotency entries (for testing).
+ */
+export function clearIdempotency() {
+  idempotencyStore.clear();
+}

package/src/lib/images/imageRouteModel.ts

@@ -0,0 +1,168 @@
+/**
+ * Shared model resolution for the image routes (#3214 / #3215).
+ *
+ * `/v1/images/generations` and `/v1/images/edits` must resolve a requested model the
+ * same way, and as close as practical to how chat routing resolves models:
+ *
+ *   1. Bare combo / alias name with no slash (`image`) — resolved to the combo's single
+ *      image target, then that target is itself prefix-resolved. Bare combos intentionally
+ *      override built-in image aliases with the same name.
+ *   2. Built-in image model id / alias (`cgpt-web/...`, `gpt-image-1`, …) — untouched.
+ *   3. Custom provider *prefix* form (`myImg/gpt-image-2`) — rewritten to the internal
+ *      `<nodeId>/<model>` id (#3205 did this inline in the generations route only).
+ *
+ * Anything that does not match falls through unchanged, so existing built-in and
+ * already-internal ids keep working.
+ */
+import { parseImageModel } from "@omniroute/open-sse/config/imageRegistry.ts";
+import { resolveComboTargets } from "@omniroute/open-sse/services/combo.ts";
+
+import { getComboByName, getCombos } from "@/lib/db/combos";
+import { getProviderNodes } from "@/lib/db/providers";
+
+/**
+ * Rewrite a `prefix/model` custom image model to its internal `<nodeId>/<model>` form.
+ * Returns the original string when no openai-compatible node prefix matches (so built-in
+ * and already-internal ids pass through). Mirrors `src/sse/services/model.ts` (match on
+ * `node.prefix` OR `node.id`).
+ */
+export async function resolveImageModelPrefix(modelStr: string): Promise<string> {
+  if (typeof modelStr !== "string") return modelStr;
+  const slash = modelStr.indexOf("/");
+  if (slash <= 0) return modelStr;
+
+  const prefixPart = modelStr.slice(0, slash);
+  const rest = modelStr.slice(slash + 1);
+  if (!rest) return modelStr;
+
+  try {
+    const nodes = await getProviderNodes({ type: "openai-compatible" });
+    // node.id (internal UUID) is already a valid internal id; only rewrite when a
+    // user-defined prefix differs from the node id.
+    const matched = nodes.find((node: { prefix?: unknown }) => node.prefix === prefixPart);
+    if (matched && typeof matched.id === "string" && matched.id && matched.id !== prefixPart) {
+      return `${matched.id}/${rest}`;
+    }
+  } catch {
+    // DB unavailable (pre-migration / tests) — leave the model untouched.
+  }
+  return modelStr;
+}
+
+/**
+ * Resolve a bare combo/alias name (e.g. `image`) to its first image model target's
+ * model string, or null when the name is not a combo / has no usable target.
+ */
+export async function resolveSingleImageComboTarget(name: string): Promise<string | null> {
+  if (typeof name !== "string" || !name.trim()) return null;
+  try {
+    const combo = await getComboByName(name);
+    if (!combo) return null;
+    const allCombos = await getCombos();
+    const targets = resolveComboTargets(combo as never, allCombos as never);
+    const first = targets.find(
+      (t: { modelStr?: unknown }) =>
+        typeof t?.modelStr === "string" && (t.modelStr as string).trim()
+    );
+    return (first?.modelStr as string) ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Full image-route model resolver. See module header for the resolution order.
+ */
+export async function resolveImageRouteModel(modelStr: string): Promise<string> {
+  if (typeof modelStr !== "string" || !modelStr.trim()) return modelStr;
+  const parsedModel = parseImageModel(modelStr);
+  const hasSlash = modelStr.includes("/");
+
+  // 1. Bare model name: resolve to its single combo target when safe.
+  //    Codex bare models are reserved to avoid shadowing `gpt-5.5`-style aliases used
+  //    across image + responses flows.
+  if (!hasSlash) {
+    if (parsedModel.provider === "codex") return modelStr;
+
+    const target = await resolveSingleImageComboTarget(modelStr);
+    if (target && target !== modelStr) return resolveImageModelPrefix(target);
+  }
+
+  // 2. Built-in image model (alias or provider/model) — leave untouched.
+  if (parsedModel.provider) return modelStr;
+
+  if (!modelStr.includes("/")) return modelStr;
+
+  // 3. Custom provider prefix form — rewrite to internal `<nodeId>/<model>`.
+  return resolveImageModelPrefix(modelStr);
+}
+
+interface ParsedImageEditInput {
+  prompt: string;
+  model: string | null;
+  size: string | null;
+  responseFormat: string | null;
+  imageBytes: Buffer | null;
+  imageMime: string | null;
+}
+
+/** Parse a `data:<mime>;base64,<data>` URL into raw bytes + mime, or null when invalid. */
+export function parseDataUrl(value: unknown): { bytes: Buffer; mime: string } | null {
+  if (typeof value !== "string") return null;
+  const match = /^data:([^;,]+)?(;base64)?,(.*)$/s.exec(value.trim());
+  if (!match) return null;
+  const mime = match[1] || "image/png";
+  const isBase64 = Boolean(match[2]);
+  const payload = match[3] ?? "";
+  try {
+    const bytes = isBase64
+      ? Buffer.from(payload, "base64")
+      : Buffer.from(decodeURIComponent(payload), "utf8");
+    if (bytes.length === 0) return null;
+    return { bytes, mime };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract an OpenAI-compatible image-edit payload from a JSON body. Some clients send
+ * edit input as JSON with data-URL images instead of multipart/form-data; accept the
+ * common shapes (`image: "data:..."`, `images: [{ image_url: "data:..." }]` or
+ * `images: ["data:..."]`) and surface the same fields the multipart reader produces.
+ */
+export function extractImageEditInputFromJson(body: unknown): ParsedImageEditInput {
+  const obj = (body && typeof body === "object" ? body : {}) as Record<string, unknown>;
+  const str = (v: unknown): string | null => (typeof v === "string" && v.trim() ? v.trim() : null);
+
+  const prompt = typeof obj.prompt === "string" ? obj.prompt.trim() : "";
+  const model = str(obj.model);
+  const size = str(obj.size);
+  const responseFormat = str(obj.response_format);
+
+  const candidates: unknown[] = [];
+  if (obj.image !== undefined) candidates.push(obj.image);
+  const images = obj.images;
+  if (Array.isArray(images)) {
+    for (const entry of images) {
+      if (typeof entry === "string") candidates.push(entry);
+      else if (entry && typeof entry === "object") {
+        const e = entry as Record<string, unknown>;
+        candidates.push(e.image_url ?? e.url ?? e.b64_json);
+      }
+    }
+  }
+
+  let imageBytes: Buffer | null = null;
+  let imageMime: string | null = null;
+  for (const candidate of candidates) {
+    const parsed = parseDataUrl(candidate);
+    if (parsed) {
+      imageBytes = parsed.bytes;
+      imageMime = parsed.mime;
+      break;
+    }
+  }
+
+  return { prompt, model, size, responseFormat, imageBytes, imageMime };
+}

package/src/lib/initCloudSync.ts

@@ -0,0 +1,52 @@
+import initializeCloudSync from "@/shared/services/initializeCloudSync";
+import { startBudgetResetJob } from "@/lib/jobs/budgetResetJob";
+import { startModelSyncScheduler } from "@/shared/services/modelSyncScheduler";
+
+// Initialize runtime background sync services once per server process.
+let initialized = false;
+
+function isAutomatedTestProcess(
+  env: NodeJS.ProcessEnv = process.env,
+  argv: string[] = process.argv
+): boolean {
+  return (
+    env.NODE_ENV === "test" || env.VITEST !== undefined || argv.some((arg) => arg.includes("test"))
+  );
+}
+
+export function shouldSkipCloudSyncInitialization(
+  env: NodeJS.ProcessEnv = process.env,
+  argv: string[] = process.argv
+): boolean {
+  if (env.NEXT_PHASE === "phase-production-build") {
+    return true;
+  }
+
+  const raw = env.OMNIROUTE_DISABLE_BACKGROUND_SERVICES;
+  if (raw && new Set(["1", "true", "yes", "on"]).has(raw.trim().toLowerCase())) {
+    return true;
+  }
+
+  return isAutomatedTestProcess(env, argv) && env.OMNIROUTE_ENABLE_RUNTIME_BACKGROUND_TASKS !== "1";
+}
+
+export async function ensureCloudSyncInitialized() {
+  if (shouldSkipCloudSyncInitialization()) {
+    return false;
+  }
+  if (!initialized) {
+    try {
+      const { initTokenHealthCheck } = await import("@/lib/tokenHealthCheck");
+      initTokenHealthCheck();
+      await initializeCloudSync();
+      startModelSyncScheduler();
+      startBudgetResetJob();
+      initialized = true;
+    } catch (error) {
+      console.error("[ServerInit] Error initializing background sync services:", error);
+    }
+  }
+  return initialized;
+}
+
+export default ensureCloudSyncInitialized;

package/src/lib/inspector/agentBridgeMaintenanceApi.ts

@@ -0,0 +1,70 @@
+/**
+ * Client-side fetch helpers for the AgentBridge maintenance & diagnostics card.
+ *
+ * These drive backend routes that already shipped but had no UI:
+ *   - GET  /api/tools/agent-bridge/diagnose  (#4093, Gap 12) — capture self-test
+ *   - DELETE /api/tools/agent-bridge/cert    (#4084, Gap 9)  — untrust the root CA
+ *   - POST /api/tools/agent-bridge/repair    (#4084, Gap 7)  — undo orphaned state
+ *   - GET/POST /api/tools/agent-bridge/config (#4094, Gap 4) — portable config
+ *
+ * Kept DOM-free (the download/upload glue lives in the component) so the
+ * request/response/error handling is unit-testable by stubbing global.fetch.
+ * Types are imported type-only from the server modules so this client bundle
+ * never pulls their DB dependencies.
+ */
+import type { DiagnosticReport } from "@/mitm/inspector/diagnostics";
+import type { AgentBridgeConfig, ImportResult } from "@/lib/inspector/configPortability";
+
+export interface DiagnoseResult extends DiagnosticReport {
+  /** The port the diagnose route probed (echoed back for display). */
+  port: number;
+}
+
+/** Extract the sanitized server error message, falling back to the status. */
+async function errorMessage(res: Response): Promise<string> {
+  const body = (await res.json().catch(() => null)) as { error?: { message?: string } } | null;
+  return body?.error?.message ?? `HTTP ${res.status}`;
+}
+
+async function requestJson<T>(url: string, init?: RequestInit): Promise<T> {
+  const res = await fetch(url, init);
+  if (!res.ok) throw new Error(await errorMessage(res));
+  return (await res.json()) as T;
+}
+
+/** Run the capture-pipeline self-test (server/cert/dns reachability). */
+export function runDiagnose(): Promise<DiagnoseResult> {
+  return requestJson<DiagnoseResult>("/api/tools/agent-bridge/diagnose");
+}
+
+/** Untrust + remove the MITM root CA from the OS store (explicit, idempotent). */
+export function removeCaCert(): Promise<{ trusted: boolean }> {
+  return requestJson<{ ok: boolean; trusted: boolean }>("/api/tools/agent-bridge/cert", {
+    method: "DELETE",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({}),
+  });
+}
+
+/** Undo orphaned system state (DNS spoof, root CA, system proxy) after a crash. */
+export function repairMitmState(): Promise<{ repaired: string[] }> {
+  return requestJson<{ ok: boolean; repaired: string[] }>("/api/tools/agent-bridge/repair", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({}),
+  });
+}
+
+/** Read the portable AgentBridge config blob (bypass + hosts + mappings). */
+export function fetchAgentBridgeConfig(): Promise<AgentBridgeConfig> {
+  return requestJson<AgentBridgeConfig>("/api/tools/agent-bridge/config");
+}
+
+/** Import a previously-exported config; returns how many of each were applied. */
+export function importAgentBridgeConfig(config: AgentBridgeConfig): Promise<ImportResult> {
+  return requestJson<{ ok: boolean } & ImportResult>("/api/tools/agent-bridge/config", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(config),
+  });
+}

package/src/lib/inspector/captureState.ts

@@ -0,0 +1,90 @@
+/**
+ * Runtime state for Traffic Inspector capture modes.
+ *
+ * Held in module-level variables (process-singleton). Survives across route
+ * handler calls for the lifetime of the process.
+ *
+ * Exported mutation functions are the single write path so all route handlers
+ * stay stateless.
+ */
+
+import type { HttpProxyServerHandle } from "@/mitm/inspector/httpProxyServer";
+import type { PreviousState } from "@/mitm/inspector/systemProxyConfig";
+
+// ── HTTP Proxy ──────────────────────────────────────────────────────────────
+
+let httpProxyHandle: HttpProxyServerHandle | null = null;
+
+export function getHttpProxyHandle(): HttpProxyServerHandle | null {
+  return httpProxyHandle;
+}
+
+export function setHttpProxyHandle(handle: HttpProxyServerHandle | null): void {
+  httpProxyHandle = handle;
+}
+
+// ── System Proxy ────────────────────────────────────────────────────────────
+
+interface SystemProxyState {
+  applied: boolean;
+  port: number | null;
+  guardUntil: string | null;  // ISO 8601
+  previousState: PreviousState | null;
+}
+
+let systemProxyState: SystemProxyState = {
+  applied: false,
+  port: null,
+  guardUntil: null,
+  previousState: null,
+};
+
+let guardTimer: ReturnType<typeof setTimeout> | null = null;
+
+export function getSystemProxyState(): Readonly<SystemProxyState> {
+  return { ...systemProxyState };
+}
+
+export function setSystemProxyApplied(
+  port: number,
+  previousState: PreviousState,
+  guardMinutes: number
+): void {
+  if (guardTimer) clearTimeout(guardTimer);
+
+  const guardUntil = new Date(Date.now() + guardMinutes * 60_000).toISOString();
+  systemProxyState = { applied: true, port, guardUntil, previousState };
+
+  guardTimer = setTimeout(
+    () => {
+      // Auto-revert after guard period — fire-and-forget.
+      // Import lazily to avoid circular deps at module load.
+      import("@/mitm/inspector/systemProxyConfig").then(({ revert }) => {
+        const ps = systemProxyState.previousState;
+        systemProxyState = { applied: false, port: null, guardUntil: null, previousState: null };
+        if (ps) revert(ps).catch(() => {/* best-effort */});
+      }).catch(() => {/* best-effort */});
+    },
+    guardMinutes * 60_000
+  );
+}
+
+export function clearSystemProxy(): void {
+  if (guardTimer) {
+    clearTimeout(guardTimer);
+    guardTimer = null;
+  }
+  systemProxyState = { applied: false, port: null, guardUntil: null, previousState: null };
+}
+
+// ── TLS Intercept ───────────────────────────────────────────────────────────
+
+let tlsInterceptEnabled = process.env.INSPECTOR_TLS_INTERCEPT === "true";
+
+export function isTlsInterceptEnabled(): boolean {
+  return tlsInterceptEnabled;
+}
+
+export function setTlsIntercept(enabled: boolean): void {
+  tlsInterceptEnabled = enabled;
+}

package/src/lib/inspector/configPortability.ts

@@ -0,0 +1,86 @@
+/**
+ * Portable AgentBridge configuration (Gap 4).
+ *
+ * Serialises the operator-tunable AgentBridge state — user bypass patterns,
+ * custom hosts, and per-agent model mappings — into a versioned JSON blob so a
+ * setup can be replicated across machines (ProxyBridge ships the same
+ * import/export-rules portability). Defaults (bank/gov/okta bypass, etc.) live
+ * in code and are intentionally NOT exported, so importing never duplicates or
+ * fights them.
+ */
+import { z } from "zod";
+import { getUserBypassPatterns, replaceUserBypassPatterns } from "@/lib/db/agentBridgeBypass";
+import { listCustomHosts, addCustomHost } from "@/lib/db/inspectorCustomHosts";
+import { getMappingsForAgent, setMappings } from "@/lib/db/agentBridgeMappings";
+import { ALL_TARGETS } from "@/mitm/targets/index";
+
+export const AgentBridgeConfigSchema = z.object({
+  version: z.literal(1),
+  bypassPatterns: z.array(z.string()),
+  customHosts: z.array(
+    z.object({
+      host: z.string().min(1),
+      kind: z.enum(["llm", "app", "custom"]).default("custom"),
+      label: z.string().nullable().optional(),
+    })
+  ),
+  agentMappings: z.record(
+    z.string(),
+    z.array(z.object({ source: z.string(), target: z.string() }))
+  ),
+});
+
+export type AgentBridgeConfig = z.infer<typeof AgentBridgeConfigSchema>;
+
+/** Read the current operator-tunable AgentBridge state into a portable blob. */
+export function exportConfig(): AgentBridgeConfig {
+  const customHosts = listCustomHosts().map((h) => ({
+    host: h.host,
+    kind: (h.kind as "llm" | "app" | "custom") ?? "custom",
+    label: h.label ?? null,
+  }));
+
+  const agentMappings: Record<string, Array<{ source: string; target: string }>> = {};
+  for (const target of ALL_TARGETS) {
+    const rows = getMappingsForAgent(target.id);
+    if (rows.length > 0) {
+      agentMappings[target.id] = rows.map((r) => ({
+        source: r.source_model,
+        target: r.target_model,
+      }));
+    }
+  }
+
+  return {
+    version: 1,
+    bypassPatterns: getUserBypassPatterns(),
+    customHosts,
+    agentMappings,
+  };
+}
+
+export interface ImportResult {
+  bypassPatterns: number;
+  customHosts: number;
+  agents: number;
+}
+
+/** Apply a validated config to the DB. Bypass + mappings replace wholesale;
+ * custom hosts are added idempotently (INSERT OR IGNORE). */
+export function importConfig(config: AgentBridgeConfig): ImportResult {
+  replaceUserBypassPatterns(config.bypassPatterns);
+
+  for (const h of config.customHosts) {
+    addCustomHost(h.host, h.kind, h.label ?? undefined);
+  }
+
+  for (const [agentId, mappings] of Object.entries(config.agentMappings)) {
+    setMappings(agentId, mappings);
+  }
+
+  return {
+    bypassPatterns: config.bypassPatterns.length,
+    customHosts: config.customHosts.length,
+    agents: Object.keys(config.agentMappings).length,
+  };
+}