vforclaude2 0.3.87

package/src/mitm/paths.js

@@ -0,0 +1,16 @@
+const path = require("path");
+const os = require("os");
+
+// Single source of truth for data directory — matches localDb.js logic
+function getDataDir() {
+  if (process.env.DATA_DIR) return process.env.DATA_DIR;
+  if (process.platform === "win32") {
+    return path.join(process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"), "9router");
+  }
+  return path.join(os.homedir(), ".vforclaude");
+}
+
+const DATA_DIR = getDataDir();
+const MITM_DIR = path.join(DATA_DIR, "mitm");
+
+module.exports = { DATA_DIR, MITM_DIR };

package/src/mitm/server.js

@@ -0,0 +1,233 @@
+const https = require("https");
+const fs = require("fs");
+const path = require("path");
+const dns = require("dns");
+const { promisify } = require("util");
+const { log, err } = require("./logger");
+const { TARGET_HOSTS, URL_PATTERNS, getToolForHost } = require("./config");
+const { DATA_DIR, MITM_DIR } = require("./paths");
+const { getCertForDomain } = require("./cert/generate");
+
+const DB_FILE = path.join(DATA_DIR, "db.json");
+const LOCAL_PORT = 443;
+const ENABLE_FILE_LOG = false;
+const LOG_DIR = path.join(DATA_DIR, "logs", "mitm");
+const INTERNAL_REQUEST_HEADER = { name: "x-request-source", value: "local" };
+
+if (ENABLE_FILE_LOG && !fs.existsSync(LOG_DIR)) fs.mkdirSync(LOG_DIR, { recursive: true });
+
+// Load handlers — dev/ overrides handlers/ for private implementations
+function loadHandler(name) {
+  try { return require(`./dev/${name}`); } catch {}
+  return require(`./handlers/${name}`);
+}
+
+const handlers = {
+  antigravity: loadHandler("antigravity"),
+  copilot: loadHandler("copilot"),
+  kiro: loadHandler("kiro"),
+  cursor: loadHandler("cursor"),
+};
+
+// ── SSL / SNI ─────────────────────────────────────────────────
+
+const certCache = new Map();
+
+function sniCallback(servername, cb) {
+  try {
+    if (certCache.has(servername)) return cb(null, certCache.get(servername));
+    const certData = getCertForDomain(servername);
+    if (!certData) return cb(new Error(`Failed to generate cert for ${servername}`));
+    const ctx = require("tls").createSecureContext({ key: certData.key, cert: certData.cert });
+    certCache.set(servername, ctx);
+    log(`🔐 Cert generated: ${servername}`);
+    cb(null, ctx);
+  } catch (e) {
+    err(`SNI error for ${servername}: ${e.message}`);
+    cb(e);
+  }
+}
+
+let sslOptions;
+try {
+  sslOptions = {
+    key: fs.readFileSync(path.join(MITM_DIR, "rootCA.key")),
+    cert: fs.readFileSync(path.join(MITM_DIR, "rootCA.crt")),
+    SNICallback: sniCallback
+  };
+} catch (e) {
+  err(`Root CA not found: ${e.message}`);
+  process.exit(1);
+}
+
+// ── Helpers ───────────────────────────────────────────────────
+
+const cachedTargetIPs = {};
+const CACHE_TTL_MS = 5 * 60 * 1000;
+
+async function resolveTargetIP(hostname) {
+  const cached = cachedTargetIPs[hostname];
+  if (cached && Date.now() - cached.ts < CACHE_TTL_MS) return cached.ip;
+  const resolver = new dns.Resolver();
+  resolver.setServers(["8.8.8.8"]);
+  const resolve4 = promisify(resolver.resolve4.bind(resolver));
+  const addresses = await resolve4(hostname);
+  cachedTargetIPs[hostname] = { ip: addresses[0], ts: Date.now() };
+  return cachedTargetIPs[hostname].ip;
+}
+
+function collectBodyRaw(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", chunk => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+
+// Extract model from URL path (Gemini), body (OpenAI/Anthropic), or Kiro conversationState
+function extractModel(url, body) {
+  const urlMatch = url.match(/\/models\/([^/:]+)/);
+  if (urlMatch) return urlMatch[1];
+  try {
+    const parsed = JSON.parse(body.toString());
+    if (parsed.conversationState) {
+      return parsed.conversationState.currentMessage?.userInputMessage?.modelId || null;
+    }
+    return parsed.model || null;
+  } catch { return null; }
+}
+
+function getMappedModel(tool, model) {
+  if (!model) return null;
+  try {
+    if (!fs.existsSync(DB_FILE)) return null;
+    const db = JSON.parse(fs.readFileSync(DB_FILE, "utf-8"));
+    const aliases = db.mitmAlias?.[tool];
+    if (!aliases) return null;
+    if (aliases[model]) return aliases[model];
+    // Prefix match fallback
+    const prefixKey = Object.keys(aliases).find(k => k && aliases[k] && (model.startsWith(k) || k.startsWith(model)));
+    return prefixKey ? aliases[prefixKey] : null;
+  } catch { return null; }
+}
+
+function saveRequestLog(url, bodyBuffer) {
+  if (!ENABLE_FILE_LOG) return;
+  try {
+    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+    const slug = url.replace(/[^a-zA-Z0-9]/g, "_").substring(0, 60);
+    const body = JSON.parse(bodyBuffer.toString());
+    fs.writeFileSync(path.join(LOG_DIR, `${ts}_${slug}.json`), JSON.stringify(body, null, 2));
+  } catch { /* ignore */ }
+}
+
+/**
+ * Forward request to real upstream.
+ * Optional onResponse(rawBuffer) callback — if provided, tees the response
+ * so it's both forwarded to client AND passed to the callback for inspection.
+ */
+async function passthrough(req, res, bodyBuffer, onResponse) {
+  const targetHost = (req.headers.host || TARGET_HOSTS[0]).split(":")[0];
+  const targetIP = await resolveTargetIP(targetHost);
+
+  const forwardReq = https.request({
+    hostname: targetIP,
+    port: 443,
+    path: req.url,
+    method: req.method,
+    headers: { ...req.headers, host: targetHost },
+    servername: targetHost,
+    rejectUnauthorized: false
+  }, (forwardRes) => {
+    res.writeHead(forwardRes.statusCode, forwardRes.headers);
+
+    if (!onResponse) {
+      forwardRes.pipe(res);
+      return;
+    }
+
+    // Tee: forward to client AND buffer for callback
+    const chunks = [];
+    forwardRes.on("data", chunk => { chunks.push(chunk); res.write(chunk); });
+    forwardRes.on("end", () => {
+      res.end();
+      try { onResponse(Buffer.concat(chunks), forwardRes.headers); } catch { /* ignore */ }
+    });
+  });
+
+  forwardReq.on("error", (e) => {
+    err(`Passthrough error: ${e.message}`);
+    if (!res.headersSent) res.writeHead(502);
+    res.end("Bad Gateway");
+  });
+
+  if (bodyBuffer.length > 0) forwardReq.write(bodyBuffer);
+  forwardReq.end();
+}
+
+// ── Request handler ───────────────────────────────────────────
+
+const server = https.createServer(sslOptions, async (req, res) => {
+  try {
+    if (req.url === "/_mitm_health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true, pid: process.pid }));
+      return;
+    }
+
+    const bodyBuffer = await collectBodyRaw(req);
+    if (bodyBuffer.length > 0) saveRequestLog(req.url, bodyBuffer);
+
+    // Anti-loop: skip requests from 9Router
+    if (req.headers[INTERNAL_REQUEST_HEADER.name] === INTERNAL_REQUEST_HEADER.value) {
+      return passthrough(req, res, bodyBuffer);
+    }
+
+    const tool = getToolForHost(req.headers.host);
+    if (!tool) return passthrough(req, res, bodyBuffer);
+
+    const patterns = URL_PATTERNS[tool] || [];
+    const isChat = patterns.some(p => req.url.includes(p));
+    if (!isChat) return passthrough(req, res, bodyBuffer);
+
+    log(`🔍 [${tool}] url=${req.url} | bodyLen=${bodyBuffer.length}`);
+
+    // Cursor uses binary proto — model extraction not possible at this layer.
+    // Delegate directly to handler which decodes proto internally.
+    if (tool === "cursor") {
+      log(`⚡ intercept | cursor | proto`);
+      return handlers[tool].intercept(req, res, bodyBuffer, null, passthrough);
+    }
+
+    const model = extractModel(req.url, bodyBuffer);
+    log(`🔍 [${tool}] model="${model}"`);
+
+    const mappedModel = getMappedModel(tool, model);
+    if (!mappedModel) {
+      log(`⏩ passthrough | no mapping | ${tool} | ${model || "unknown"}`);
+      return passthrough(req, res, bodyBuffer);
+    }
+
+    log(`⚡ intercept | ${tool} | ${model} → ${mappedModel}`);
+    return handlers[tool].intercept(req, res, bodyBuffer, mappedModel, passthrough);
+  } catch (e) {
+    err(`Unhandled error: ${e.message}`);
+    if (!res.headersSent) res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: { message: e.message, type: "mitm_error" } }));
+  }
+});
+
+server.listen(LOCAL_PORT, () => log(`🚀 Server ready on :${LOCAL_PORT}`));
+
+server.on("error", (e) => {
+  if (e.code === "EADDRINUSE") err(`Port ${LOCAL_PORT} already in use`);
+  else if (e.code === "EACCES") err(`Permission denied for port ${LOCAL_PORT}`);
+  else err(e.message);
+  process.exit(1);
+});
+
+const shutdown = () => server.close(() => process.exit(0));
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);
+if (process.platform === "win32") process.on("SIGBREAK", shutdown);

package/src/models/index.js

@@ -0,0 +1,35 @@
+// Database Models - Export all from localDb
+export {
+  getProviderConnections,
+  getProviderConnectionById,
+  createProviderConnection,
+  updateProviderConnection,
+  deleteProviderConnection,
+  getProviderNodes,
+  getProviderNodeById,
+  createProviderNode,
+  updateProviderNode,
+  deleteProviderNode,
+  getProxyPools,
+  getProxyPoolById,
+  createProxyPool,
+  updateProxyPool,
+  deleteProxyPool,
+  deleteProviderConnectionsByProvider,
+  getCombos,
+  getComboById,
+  getComboByName,
+  createCombo,
+  updateCombo,
+  deleteCombo,
+  getModelAliases,
+  setModelAlias,
+  deleteModelAlias,
+  getMitmAlias,
+  setMitmAliasAll,
+  getApiKeys,
+  createApiKey,
+  deleteApiKey,
+  validateApiKey,
+  isCloudEnabled,
+} from "@/lib/localDb";

package/src/proxy.js

@@ -0,0 +1,5 @@
+export { proxy } from "./dashboardGuard";
+
+export const config = {
+  matcher: ["/", "/dashboard/:path*"],
+};

package/src/server-init.js

@@ -0,0 +1,17 @@
+import initializeApp from "./shared/services/initializeApp.js";
+
+async function startServer() {
+  console.log("Starting server...");
+  
+  try {
+    await initializeApp();
+    console.log("Server initialized");
+  } catch (error) {
+    console.log("Error initializing server:", error);
+    process.exit(1);
+  }
+}
+
+startServer().catch(console.log);
+
+export default startServer;

package/src/shared/components/Avatar.js

@@ -0,0 +1,88 @@
+"use client";
+
+import { cn } from "@/shared/utils/cn";
+
+export default function Avatar({
+  src,
+  alt = "Avatar",
+  name,
+  size = "md",
+  className,
+}) {
+  const sizes = {
+    xs: "size-6 text-xs",
+    sm: "size-8 text-sm",
+    md: "size-10 text-base",
+    lg: "size-12 text-lg",
+    xl: "size-16 text-xl",
+  };
+
+  // Get initials from name
+  const getInitials = (name) => {
+    if (!name) return "?";
+    const parts = name.split(" ");
+    if (parts.length >= 2) {
+      return `${parts[0][0]}${parts[1][0]}`.toUpperCase();
+    }
+    return name.substring(0, 2).toUpperCase();
+  };
+
+  // Generate color from name
+  const getColorFromName = (name) => {
+    if (!name) return "bg-primary";
+    const colors = [
+      "bg-red-500",
+      "bg-orange-500",
+      "bg-amber-500",
+      "bg-yellow-500",
+      "bg-lime-500",
+      "bg-green-500",
+      "bg-emerald-500",
+      "bg-teal-500",
+      "bg-cyan-500",
+      "bg-sky-500",
+      "bg-blue-500",
+      "bg-indigo-500",
+      "bg-violet-500",
+      "bg-purple-500",
+      "bg-fuchsia-500",
+      "bg-pink-500",
+      "bg-rose-500",
+    ];
+    const index = name.charCodeAt(0) % colors.length;
+    return colors[index];
+  };
+
+  if (src) {
+    return (
+      <div
+        className={cn(
+          "rounded-full bg-cover bg-center bg-no-repeat",
+          "ring-2 ring-white dark:ring-surface-dark shadow-sm",
+          sizes[size],
+          className
+        )}
+        style={{ backgroundImage: `url(${src})` }}
+        role="img"
+        aria-label={alt}
+      />
+    );
+  }
+
+  return (
+    <div
+      className={cn(
+        "rounded-full flex items-center justify-center font-semibold text-white",
+        "ring-2 ring-white dark:ring-surface-dark shadow-sm",
+        sizes[size],
+        getColorFromName(name),
+        className
+      )}
+      role="img"
+      aria-label={alt}
+    >
+      {getInitials(name)}
+    </div>
+  );
+}
+

package/src/shared/components/Badge.js

@@ -0,0 +1,55 @@
+"use client";
+
+import { cn } from "@/shared/utils/cn";
+
+const variants = {
+  default: "bg-black/5 dark:bg-white/10 text-text-muted",
+  primary: "bg-primary/10 text-primary",
+  success: "bg-green-500/10 text-green-600 dark:text-green-400",
+  warning: "bg-yellow-500/10 text-yellow-600 dark:text-yellow-400",
+  error: "bg-red-500/10 text-red-600 dark:text-red-400",
+  info: "bg-blue-500/10 text-blue-600 dark:text-blue-400",
+};
+
+const sizes = {
+  sm: "px-2 py-0.5 text-[10px]",
+  md: "px-2.5 py-1 text-xs",
+  lg: "px-3 py-1.5 text-sm",
+};
+
+export default function Badge({
+  children,
+  variant = "default",
+  size = "md",
+  dot = false,
+  icon,
+  className,
+}) {
+  return (
+    <span
+      className={cn(
+        "inline-flex items-center gap-1.5 rounded-full font-semibold",
+        variants[variant],
+        sizes[size],
+        className
+      )}
+    >
+      {dot && (
+        <span
+          className={cn(
+            "size-1.5 rounded-full",
+            variant === "success" && "bg-green-500",
+            variant === "warning" && "bg-yellow-500",
+            variant === "error" && "bg-red-500",
+            variant === "info" && "bg-blue-500",
+            variant === "primary" && "bg-primary",
+            variant === "default" && "bg-gray-500"
+          )}
+        />
+      )}
+      {icon && <span className="material-symbols-outlined text-[14px]">{icon}</span>}
+      {children}
+    </span>
+  );
+}
+

package/src/shared/components/Button.js

@@ -0,0 +1,56 @@
+"use client";
+
+import { cn } from "@/shared/utils/cn";
+
+const variants = {
+  primary: "bg-gradient-to-b from-primary to-primary-hover text-white shadow-sm",
+  secondary: "bg-white dark:bg-white/10 border border-black/10 dark:border-white/10 text-text-main hover:bg-black/5 dark:hover:bg-white/5",
+  outline: "border border-black/15 dark:border-white/15 text-text-main hover:bg-black/5",
+  ghost: "text-text-muted hover:bg-black/5 dark:hover:bg-white/5 hover:text-text-main",
+  danger: "bg-red-500 text-white hover:bg-red-600 shadow-sm",
+};
+
+const sizes = {
+  sm: "h-7 px-3 text-xs rounded-md",
+  md: "h-9 px-4 text-sm rounded-lg",
+  lg: "h-11 px-6 text-sm rounded-lg",
+};
+
+export default function Button({
+  children,
+  variant = "primary",
+  size = "md",
+  icon,
+  iconRight,
+  disabled = false,
+  loading = false,
+  fullWidth = false,
+  className,
+  ...props
+}) {
+  return (
+    <button
+      className={cn(
+        "inline-flex items-center justify-center gap-2 font-medium transition-all duration-200 cursor-pointer",
+        "active:scale-[0.99] disabled:opacity-50 disabled:cursor-not-allowed disabled:active:scale-100",
+        variants[variant],
+        sizes[size],
+        fullWidth && "w-full",
+        className
+      )}
+      disabled={disabled || loading}
+      {...props}
+    >
+      {loading ? (
+        <span className="material-symbols-outlined animate-spin text-[18px]">progress_activity</span>
+      ) : icon ? (
+        <span className="material-symbols-outlined text-[18px]">{icon}</span>
+      ) : null}
+      {children}
+      {iconRight && !loading && (
+        <span className="material-symbols-outlined text-[18px]">{iconRight}</span>
+      )}
+    </button>
+  );
+}
+

package/src/shared/components/Card.js

@@ -0,0 +1,122 @@
+"use client";
+
+import { cn } from "@/shared/utils/cn";
+
+export default function Card({
+  children,
+  title,
+  subtitle,
+  icon,
+  action,
+  padding = "md",
+  hover = false,
+  className,
+  ...props
+}) {
+  const paddings = {
+    none: "",
+    xs: "p-3",
+    sm: "p-4",
+    md: "p-6",
+    lg: "p-8",
+  };
+
+  return (
+    <div
+      className={cn(
+        "bg-surface",
+        "border border-black/5 dark:border-white/5",
+        "rounded-lg shadow-sm",
+        hover && "hover:shadow-md hover:border-primary/30 transition-all cursor-pointer",
+        paddings[padding],
+        className
+      )}
+      {...props}
+    >
+      {(title || action) && (
+        <div className="flex items-center justify-between mb-4">
+          <div className="flex items-center gap-3">
+            {icon && (
+              <div className="p-2 rounded-lg bg-bg text-text-muted">
+                <span className="material-symbols-outlined text-[20px]">{icon}</span>
+              </div>
+            )}
+            <div>
+              {title && (
+                <h3 className="text-text-main font-semibold">{title}</h3>
+              )}
+              {subtitle && (
+                <p className="text-sm text-text-muted">{subtitle}</p>
+              )}
+            </div>
+          </div>
+          {action}
+        </div>
+      )}
+      {children}
+    </div>
+  );
+}
+
+// Sub-component: Bordered section inside Card
+Card.Section = function CardSection({ children, className, ...props }) {
+  return (
+    <div
+      className={cn(
+        "p-4 rounded-lg",
+        "bg-black/[0.02] dark:bg-white/[0.02]",
+        "border border-black/5 dark:border-white/5",
+        className
+      )}
+      {...props}
+    >
+      {children}
+    </div>
+  );
+};
+
+// Sub-component: Hoverable row inside Card
+Card.Row = function CardRow({ children, className, ...props }) {
+  return (
+    <div
+      className={cn(
+        "p-3 -mx-3 px-3 transition-colors",
+        "border-b border-black/5 dark:border-white/5 last:border-b-0",
+        "hover:bg-black/[0.02] dark:hover:bg-white/[0.02]",
+        className
+      )}
+      {...props}
+    >
+      {children}
+    </div>
+  );
+};
+
+// Sub-component: List item with hover actions (macOS style)
+Card.ListItem = function CardListItem({ 
+  children, 
+  actions,
+  className, 
+  ...props 
+}) {
+  return (
+    <div
+      className={cn(
+        "group flex items-center justify-between p-3 -mx-3 px-3",
+        "border-b border-black/[0.03] dark:border-white/[0.03] last:border-b-0",
+        "hover:bg-black/[0.02] dark:hover:bg-white/[0.02]",
+        "transition-colors",
+        className
+      )}
+      {...props}
+    >
+      <div className="flex-1 min-w-0">{children}</div>
+      {actions && (
+        <div className="flex items-center gap-1 opacity-0 group-hover:opacity-100 transition-opacity">
+          {actions}
+        </div>
+      )}
+    </div>
+  );
+};
+