wyxrouter 0.4.71

package/src/lib/db/schema.js

@@ -0,0 +1,157 @@
+// Latest schema version — bumped when a migration is added in ./migrations/
+export const SCHEMA_VERSION = 1;
+
+export const PRAGMA_SQL = `
+PRAGMA journal_mode = WAL;
+PRAGMA synchronous = NORMAL;
+PRAGMA temp_store = MEMORY;
+PRAGMA mmap_size = 30000000;
+PRAGMA cache_size = -64000;
+PRAGMA foreign_keys = ON;
+PRAGMA busy_timeout = 5000;
+`;
+
+// Declarative current schema. Used by syncSchemaFromTables() to
+// auto-add missing tables/columns/indexes after versioned migrations.
+// For destructive changes (drop/rename/type-change), write a migration file.
+export const TABLES = {
+  _meta: {
+    columns: {
+      key: "TEXT PRIMARY KEY",
+      value: "TEXT NOT NULL",
+    },
+  },
+  settings: {
+    columns: {
+      id: "INTEGER PRIMARY KEY CHECK (id = 1)",
+      data: "TEXT NOT NULL",
+    },
+  },
+  providerConnections: {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      provider: "TEXT NOT NULL",
+      authType: "TEXT NOT NULL",
+      name: "TEXT",
+      email: "TEXT",
+      priority: "INTEGER",
+      isActive: "INTEGER DEFAULT 1",
+      data: "TEXT NOT NULL",
+      createdAt: "TEXT NOT NULL",
+      updatedAt: "TEXT NOT NULL",
+    },
+    indexes: [
+      "CREATE INDEX IF NOT EXISTS idx_pc_provider ON providerConnections(provider)",
+      "CREATE INDEX IF NOT EXISTS idx_pc_provider_active ON providerConnections(provider, isActive)",
+      "CREATE INDEX IF NOT EXISTS idx_pc_priority ON providerConnections(provider, priority)",
+    ],
+  },
+  providerNodes: {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      type: "TEXT",
+      name: "TEXT",
+      data: "TEXT NOT NULL",
+      createdAt: "TEXT NOT NULL",
+      updatedAt: "TEXT NOT NULL",
+    },
+    indexes: ["CREATE INDEX IF NOT EXISTS idx_pn_type ON providerNodes(type)"],
+  },
+  proxyPools: {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      isActive: "INTEGER DEFAULT 1",
+      testStatus: "TEXT",
+      data: "TEXT NOT NULL",
+      createdAt: "TEXT NOT NULL",
+      updatedAt: "TEXT NOT NULL",
+    },
+    indexes: [
+      "CREATE INDEX IF NOT EXISTS idx_pp_active ON proxyPools(isActive)",
+      "CREATE INDEX IF NOT EXISTS idx_pp_status ON proxyPools(testStatus)",
+    ],
+  },
+  apiKeys: {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      key: "TEXT UNIQUE NOT NULL",
+      name: "TEXT",
+      machineId: "TEXT",
+      isActive: "INTEGER DEFAULT 1",
+      createdAt: "TEXT NOT NULL",
+    },
+    indexes: ["CREATE INDEX IF NOT EXISTS idx_ak_key ON apiKeys(key)"],
+  },
+  combos: {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      name: "TEXT UNIQUE NOT NULL",
+      kind: "TEXT",
+      models: "TEXT NOT NULL",
+      createdAt: "TEXT NOT NULL",
+      updatedAt: "TEXT NOT NULL",
+    },
+    indexes: ["CREATE INDEX IF NOT EXISTS idx_combo_name ON combos(name)"],
+  },
+  kv: {
+    columns: {
+      scope: "TEXT NOT NULL",
+      key: "TEXT NOT NULL",
+      value: "TEXT NOT NULL",
+    },
+    primaryKey: "PRIMARY KEY (scope, key)",
+    indexes: ["CREATE INDEX IF NOT EXISTS idx_kv_scope ON kv(scope)"],
+  },
+  usageHistory: {
+    columns: {
+      id: "INTEGER PRIMARY KEY AUTOINCREMENT",
+      timestamp: "TEXT NOT NULL",
+      provider: "TEXT",
+      model: "TEXT",
+      connectionId: "TEXT",
+      apiKey: "TEXT",
+      endpoint: "TEXT",
+      promptTokens: "INTEGER DEFAULT 0",
+      completionTokens: "INTEGER DEFAULT 0",
+      cost: "REAL DEFAULT 0",
+      status: "TEXT",
+      tokens: "TEXT",
+      meta: "TEXT",
+    },
+    indexes: [
+      "CREATE INDEX IF NOT EXISTS idx_uh_ts ON usageHistory(timestamp DESC)",
+      "CREATE INDEX IF NOT EXISTS idx_uh_provider ON usageHistory(provider)",
+      "CREATE INDEX IF NOT EXISTS idx_uh_model ON usageHistory(model)",
+      "CREATE INDEX IF NOT EXISTS idx_uh_conn ON usageHistory(connectionId)",
+    ],
+  },
+  usageDaily: {
+    columns: {
+      dateKey: "TEXT PRIMARY KEY",
+      data: "TEXT NOT NULL",
+    },
+  },
+  requestDetails: {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      timestamp: "TEXT NOT NULL",
+      provider: "TEXT",
+      model: "TEXT",
+      connectionId: "TEXT",
+      status: "TEXT",
+      data: "TEXT NOT NULL",
+    },
+    indexes: [
+      "CREATE INDEX IF NOT EXISTS idx_rd_ts ON requestDetails(timestamp DESC)",
+      "CREATE INDEX IF NOT EXISTS idx_rd_provider ON requestDetails(provider)",
+      "CREATE INDEX IF NOT EXISTS idx_rd_model ON requestDetails(model)",
+      "CREATE INDEX IF NOT EXISTS idx_rd_conn ON requestDetails(connectionId)",
+    ],
+  },
+};
+
+export function buildCreateTableSql(name, def) {
+  const cols = Object.entries(def.columns).map(([k, v]) => `${k} ${v}`);
+  if (def.primaryKey) cols.push(def.primaryKey);
+  return `CREATE TABLE IF NOT EXISTS ${name} (${cols.join(", ")})`;
+}

package/src/lib/db/version.js

@@ -0,0 +1,21 @@
+import fs from "node:fs";
+import path from "node:path";
+
+let cachedVersion = null;
+
+export function getAppVersion() {
+  if (cachedVersion) return cachedVersion;
+  try {
+    const pkgPath = path.join(process.cwd(), "package.json");
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    cachedVersion = pkg.version || "0.0.0";
+  } catch {
+    cachedVersion = "0.0.0";
+  }
+  return cachedVersion;
+}
+
+export function timestampSlug(date = new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}-${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
+}

package/src/lib/disabledModelsDb.js

@@ -0,0 +1,4 @@
+// Shim → re-export from new SQLite-based DB layer (src/lib/db/)
+export {
+  getDisabledModels, getDisabledByProvider, disableModels, enableModels,
+} from "@/lib/db/index.js";

package/src/lib/localDb.js

@@ -0,0 +1,21 @@
+// Shim → re-export from new SQLite-based DB layer (src/lib/db/)
+// Kept for backward compatibility with existing imports.
+export {
+  getSettings, updateSettings, isCloudEnabled, getCloudUrl,
+  getProviderConnections, getProviderConnectionById,
+  createProviderConnection, updateProviderConnection,
+  deleteProviderConnection, deleteProviderConnectionsByProvider,
+  reorderProviderConnections, cleanupProviderConnections,
+  getProviderNodes, getProviderNodeById,
+  createProviderNode, updateProviderNode, deleteProviderNode,
+  getProxyPools, getProxyPoolById,
+  createProxyPool, updateProxyPool, deleteProxyPool,
+  getApiKeys, getApiKeyById, createApiKey, updateApiKey, deleteApiKey, validateApiKey,
+  getCombos, getComboById, getComboByName,
+  createCombo, updateCombo, deleteCombo,
+  getModelAliases, setModelAlias, deleteModelAlias,
+  getCustomModels, addCustomModel, deleteCustomModel,
+  getMitmAlias, setMitmAliasAll,
+  getPricing, getPricingForModel, updatePricing, resetPricing, resetAllPricing,
+  exportDb, importDb,
+} from "./db/index.js";

package/src/lib/mcp/stdioSseBridge.js

@@ -0,0 +1,198 @@
+// Inline stdio<->SSE bridge for MCP. Spawns one child per plugin on demand,
+// broadcasts JSON-RPC frames over SSE, accepts client messages via HTTP POST.
+
+const { spawn } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { LOCAL_STDIO_PLUGINS, ALLOWED_MCP_COMMANDS } = require("@/shared/constants/coworkPlugins");
+const { DATA_DIR } = require("@/lib/dataDir");
+
+const CUSTOM_FILE = path.join(DATA_DIR, "mcp", "customPlugins.json");
+
+const G_KEY = "__9routerMcpBridges";
+const MAX_TEXT_CHARS = 50000;
+const COLLAPSE_THRESHOLD = 30;
+const COLLAPSE_KEEP_HEAD = 10;
+const COLLAPSE_KEEP_TAIL = 5;
+
+// Drop noise nodes, collapse repeated siblings, hard-truncate. Preserve [ref=eXX].
+function smartFilterText(text) {
+  if (typeof text !== "string" || text.length < 2000) return text;
+  let out = text;
+  out = out.replace(/^\s*-\s*generic:?\s*$/gm, "");
+  out = out.replace(/^\s*-\s*text:\s*""\s*$/gm, "");
+  out = collapseRepeated(out);
+  if (out.length > MAX_TEXT_CHARS) {
+    const head = out.slice(0, MAX_TEXT_CHARS - 300);
+    out = `${head}\n\n... [truncated ${text.length - head.length} chars by 9router bridge. Page is large; ask user to scroll/navigate to a specific section, or click an element with the refs shown above]`;
+  }
+  return out;
+}
+
+// Group consecutive lines sharing the same leading indent + role prefix; collapse if >= COLLAPSE_THRESHOLD.
+function collapseRepeated(text) {
+  const lines = text.split("\n");
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const m = line.match(/^(\s*)-\s*([a-zA-Z]+)\b/);
+    if (!m) { out.push(line); i++; continue; }
+    const indent = m[1];
+    const role = m[2];
+    let j = i;
+    while (j < lines.length) {
+      const ln = lines[j];
+      const mm = ln.match(/^(\s*)-\s*([a-zA-Z]+)\b/);
+      if (mm && mm[1] === indent && mm[2] === role) { j++; continue; }
+      if (ln.startsWith(`${indent} `) || ln.startsWith(`${indent}\t`)) { j++; continue; }
+      break;
+    }
+    const groupLen = j - i;
+    if (groupLen >= COLLAPSE_THRESHOLD) {
+      const headEnd = findNthSiblingEnd(lines, i, indent, role, COLLAPSE_KEEP_HEAD);
+      const tailStart = findLastNSiblingStart(lines, j, indent, role, COLLAPSE_KEEP_TAIL);
+      for (let k = i; k < headEnd; k++) out.push(lines[k]);
+      out.push(`${indent}... [${groupLen - COLLAPSE_KEEP_HEAD - COLLAPSE_KEEP_TAIL} similar "${role}" items omitted by 9router bridge]`);
+      for (let k = tailStart; k < j; k++) out.push(lines[k]);
+    } else {
+      for (let k = i; k < j; k++) out.push(lines[k]);
+    }
+    i = j;
+  }
+  return out.join("\n");
+}
+
+function findNthSiblingEnd(lines, start, indent, role, n) {
+  let count = 0;
+  for (let k = start; k < lines.length; k++) {
+    const mm = lines[k].match(/^(\s*)-\s*([a-zA-Z]+)\b/);
+    if (mm && mm[1] === indent && mm[2] === role) {
+      count++;
+      if (count > n) return k;
+    }
+  }
+  return lines.length;
+}
+
+function findLastNSiblingStart(lines, end, indent, role, n) {
+  const positions = [];
+  for (let k = 0; k < end; k++) {
+    const mm = lines[k].match(/^(\s*)-\s*([a-zA-Z]+)\b/);
+    if (mm && mm[1] === indent && mm[2] === role) positions.push(k);
+  }
+  return positions.length > n ? positions[positions.length - n] : end;
+}
+
+// Apply filter to JSON-RPC tool/result content text blocks only.
+function filterFrame(line) {
+  try {
+    const msg = JSON.parse(line);
+    const content = msg?.result?.content;
+    if (!Array.isArray(content)) return line;
+    let mutated = false;
+    for (const item of content) {
+      if (item?.type === "text" && typeof item.text === "string") {
+        const filtered = smartFilterText(item.text);
+        if (filtered !== item.text) { item.text = filtered; mutated = true; }
+      }
+    }
+    return mutated ? JSON.stringify(msg) : line;
+  } catch { return line; }
+}
+const getStore = () => {
+  if (!globalThis[G_KEY]) globalThis[G_KEY] = new Map();
+  return globalThis[G_KEY];
+};
+
+const getCustomStore = () => {
+  if (!globalThis.__9routerCustomPlugins) globalThis.__9routerCustomPlugins = new Map();
+  return globalThis.__9routerCustomPlugins;
+};
+
+function isAllowedCommand(cmd) {
+  const bin = path.basename(String(cmd || ""));
+  return ALLOWED_MCP_COMMANDS.has(bin);
+}
+
+function registerCustomPlugin(def) {
+  if (!isAllowedCommand(def?.command)) {
+    throw new Error(`Blocked: command '${def?.command}' not in MCP allowlist`);
+  }
+  getCustomStore().set(def.name, def);
+}
+
+function findPlugin(name) {
+  const fromMem = getCustomStore().get(name) || LOCAL_STDIO_PLUGINS.find((p) => p.name === name);
+  if (fromMem) return fromMem;
+  // Lazy-load custom plugins from disk (survives app restart); re-validate allowlist.
+  try {
+    const list = JSON.parse(fs.readFileSync(CUSTOM_FILE, "utf-8"));
+    const def = Array.isArray(list) ? list.find((p) => p.name === name && p.command) : null;
+    if (def && isAllowedCommand(def.command)) { getCustomStore().set(def.name, def); return def; }
+  } catch { /* file missing or invalid */ }
+  return null;
+}
+
+function getOrSpawn(name) {
+  const store = getStore();
+  let entry = store.get(name);
+  if (entry?.proc && !entry.proc.killed && entry.proc.exitCode === null) return entry;
+
+  const plugin = findPlugin(name);
+  if (!plugin) throw new Error(`Unknown local plugin: ${name}`);
+
+  const proc = spawn(plugin.command, plugin.args, { stdio: ["pipe", "pipe", "pipe"], env: process.env });
+  entry = { proc, sessions: new Map(), buffer: "" };
+  store.set(name, entry);
+
+  // Parse newline-delimited JSON-RPC from child stdout, broadcast to all sessions.
+  proc.stdout.on("data", (chunk) => {
+    entry.buffer += chunk.toString("utf8");
+    let idx;
+    while ((idx = entry.buffer.indexOf("\n")) >= 0) {
+      const raw = entry.buffer.slice(0, idx).trim();
+      entry.buffer = entry.buffer.slice(idx + 1);
+      if (!raw) continue;
+      const line = filterFrame(raw);
+      for (const send of entry.sessions.values()) {
+        try { send(`event: message\ndata: ${line}\n\n`); } catch { /* ignore broken pipe */ }
+      }
+    }
+  });
+
+  proc.stderr.on("data", (d) => console.log(`[mcp:${name}]`, d.toString().trim()));
+  proc.on("exit", (code) => {
+    console.log(`[mcp:${name}] exited`, code);
+    store.delete(name);
+  });
+
+  return entry;
+}
+
+function registerSession(name, sendFn) {
+  const entry = getOrSpawn(name);
+  const sid = crypto.randomUUID();
+  entry.sessions.set(sid, sendFn);
+  return sid;
+}
+
+function unregisterSession(name, sid) {
+  const entry = getStore().get(name);
+  if (!entry) return;
+  entry.sessions.delete(sid);
+}
+
+function sendToChild(name, jsonRpc) {
+  const entry = getStore().get(name);
+  if (!entry?.proc?.stdin?.writable) throw new Error(`Bridge not running: ${name}`);
+  entry.proc.stdin.write(`${JSON.stringify(jsonRpc)}\n`);
+}
+
+function isRunning(name) {
+  const entry = getStore().get(name);
+  return !!(entry?.proc && !entry.proc.killed && entry.proc.exitCode === null);
+}
+
+module.exports = { getOrSpawn, registerSession, unregisterSession, sendToChild, isRunning, findPlugin, registerCustomPlugin };

package/src/lib/mitmAliasCache.js

@@ -0,0 +1,46 @@
+// JSON cache for mitmAlias — read by standalone MITM server (no SQLite native binding).
+// Source of truth = SQLite kv['mitmAlias']. JSON is a read-replica synced on app start
+// and after every UI write.
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+const DATA_DIR = process.env.DATA_DIR
+  || (process.platform === "win32"
+    ? path.join(process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"), "9router")
+    : path.join(os.homedir(), ".9router"));
+
+const CACHE_FILE = path.join(DATA_DIR, "mitm", "aliases.json");
+
+function writeAtomic(data) {
+  const dir = path.dirname(CACHE_FILE);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmp = `${CACHE_FILE}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(data, null, 2), "utf8");
+  fs.renameSync(tmp, CACHE_FILE);
+}
+
+// Sync entire mitmAlias map from DB → JSON file
+export async function syncToJson() {
+  try {
+    const { getMitmAlias } = await import("@/lib/db/repos/aliasRepo.js");
+    const all = await getMitmAlias();
+    writeAtomic(all || {});
+  } catch (e) {
+    console.log("[mitmAliasCache] sync failed:", e.message);
+  }
+}
+
+// Update cache for a single tool after UI saves to DB
+export function writeAliasForTool(tool, mappings) {
+  try {
+    let current = {};
+    if (fs.existsSync(CACHE_FILE)) {
+      try { current = JSON.parse(fs.readFileSync(CACHE_FILE, "utf8")); } catch { /* corrupted → reset */ }
+    }
+    current[tool] = mappings || {};
+    writeAtomic(current);
+  } catch (e) {
+    console.log("[mitmAliasCache] write failed:", e.message);
+  }
+}

package/src/lib/network/connectionProxy.js

@@ -0,0 +1,160 @@
+import { getProxyPoolById } from "@/models";
+
+// Safely normalize any value into a trimmed string.
+function normalizeString(value) {
+  if (value === undefined || value === null) return "";
+  return String(value).trim();
+}
+
+/**
+ * Normalize legacy proxy configuration.
+ */
+function normalizeLegacyProxy(providerSpecificData = {}) {
+  const connectionProxyEnabled =
+    providerSpecificData?.connectionProxyEnabled === true;
+
+  const connectionProxyUrl = normalizeString(
+    providerSpecificData?.connectionProxyUrl
+  );
+
+  const connectionNoProxy = normalizeString(
+    providerSpecificData?.connectionNoProxy
+  );
+
+  return {
+    connectionProxyEnabled,
+    connectionProxyUrl,
+    connectionNoProxy,
+  };
+}
+
+/**
+ * Resolve final proxy configuration.
+ *
+ * Priority:
+ * 1. Proxy Pool
+ * 2. Legacy Proxy
+ * 3. No Proxy
+ */
+export async function resolveConnectionProxyConfig(
+  providerSpecificData = {}
+) {
+  try {
+    const proxyPoolIdRaw = normalizeString(
+      providerSpecificData?.proxyPoolId
+    );
+
+    // "__none__" means explicitly disabled
+    const proxyPoolId =
+      proxyPoolIdRaw === "__none__" ? "" : proxyPoolIdRaw;
+
+    const legacy = normalizeLegacyProxy(providerSpecificData);
+
+    /**
+     * -----------------------------
+     * Proxy Pool Resolution
+     * -----------------------------
+     */
+    if (proxyPoolId) {
+      const proxyPool = await getProxyPoolById(proxyPoolId);
+
+      const proxyUrl = normalizeString(proxyPool?.proxyUrl);
+      const noProxy = normalizeString(proxyPool?.noProxy);
+
+      const isValidPool =
+        proxyPool &&
+        proxyPool.isActive === true &&
+        proxyUrl;
+
+      if (isValidPool) {
+        /**
+         * Vercel/Cloudflare relay proxies use base URL rewriting
+         * instead of HTTP_PROXY environment variables.
+         */
+        if (proxyPool.type === "vercel" || proxyPool.type === "cloudflare" || proxyPool.type === "deno") {
+          return {
+            source: proxyPool.type,
+
+            proxyPoolId,
+            proxyPool,
+
+            connectionProxyEnabled: false,
+            connectionProxyUrl: "",
+            connectionNoProxy: noProxy,
+
+            strictProxy: proxyPool.strictProxy === true,
+
+            vercelRelayUrl: proxyUrl, // Still mapped to vercelRelayUrl in the unified payload since they use the exact same header spec
+          };
+        }
+
+        /**
+         * Standard proxy pool
+         */
+        return {
+          source: "pool",
+
+          proxyPoolId,
+          proxyPool,
+
+          connectionProxyEnabled: true,
+          connectionProxyUrl: proxyUrl,
+          connectionNoProxy: noProxy,
+
+          strictProxy: proxyPool.strictProxy === true,
+        };
+      }
+    }
+
+    /**
+     * -----------------------------
+     * Legacy Proxy Fallback
+     * -----------------------------
+     */
+    if (
+      legacy.connectionProxyEnabled &&
+      legacy.connectionProxyUrl
+    ) {
+      return {
+        source: "legacy",
+
+        proxyPoolId: proxyPoolId || null,
+        proxyPool: null,
+
+        ...legacy,
+      };
+    }
+
+    /**
+     * -----------------------------
+     * No Proxy Config
+     * -----------------------------
+     */
+    return {
+      source: "none",
+
+      proxyPoolId: proxyPoolId || null,
+      proxyPool: null,
+
+      ...legacy,
+    };
+  } catch (error) {
+    console.error(
+      "[resolveConnectionProxyConfig] Failed to resolve proxy config:",
+      error
+    );
+
+    return {
+      source: "error",
+
+      proxyPoolId: null,
+      proxyPool: null,
+
+      connectionProxyEnabled: false,
+      connectionProxyUrl: "",
+      connectionNoProxy: "",
+
+      strictProxy: false,
+    };
+  }
+}

package/src/lib/network/initOutboundProxy.js

@@ -0,0 +1,25 @@
+import { getSettings } from "@/lib/localDb";
+import { applyOutboundProxyEnv } from "@/lib/network/outboundProxy";
+
+let initialized = false;
+
+export async function ensureOutboundProxyInitialized() {
+  if (initialized) return true;
+
+  try {
+    const settings = await getSettings();
+    applyOutboundProxyEnv(settings);
+    initialized = true;
+  } catch (error) {
+    console.error("[ServerInit] Error initializing outbound proxy:", error);
+  }
+
+  return initialized;
+}
+
+// Defer init so HTTP server accepts connections first
+setImmediate(() => {
+  ensureOutboundProxyInitialized().catch(console.log);
+});
+
+export default ensureOutboundProxyInitialized;