wyxrouter 0.4.71

package/src/app/api/cli-tools/all-statuses/route.js

@@ -0,0 +1,46 @@
+"use server";
+
+import { NextResponse } from "next/server";
+import { GET as claudeGet } from "../claude-settings/route";
+import { GET as codexGet } from "../codex-settings/route";
+import { GET as opencodeGet } from "../opencode-settings/route";
+import { GET as droidGet } from "../droid-settings/route";
+import { GET as openclawGet } from "../openclaw-settings/route";
+import { GET as hermesGet } from "../hermes-settings/route";
+import { GET as coworkGet } from "../cowork-settings/route";
+import { GET as copilotGet } from "../copilot-settings/route";
+import { GET as clineGet } from "../cline-settings/route";
+import { GET as kiloGet } from "../kilo-settings/route";
+import { GET as deepseekTuiGet } from "../deepseek-tui-settings/route";
+import { GET as jcodeGet } from "../jcode-settings/route";
+
+const STATUS_GETTERS = {
+  claude: claudeGet,
+  codex: codexGet,
+  opencode: opencodeGet,
+  droid: droidGet,
+  openclaw: openclawGet,
+  hermes: hermesGet,
+  cowork: coworkGet,
+  copilot: copilotGet,
+  cline: clineGet,
+  kilo: kiloGet,
+  "deepseek-tui": deepseekTuiGet,
+  jcode: jcodeGet,
+};
+
+// Batch endpoint: gather all CLI tool statuses in one round-trip
+export async function GET() {
+  const entries = await Promise.all(
+    Object.entries(STATUS_GETTERS).map(async ([toolId, getter]) => {
+      try {
+        const res = await getter();
+        const data = await res.json();
+        return [toolId, data];
+      } catch {
+        return [toolId, null];
+      }
+    })
+  );
+  return NextResponse.json(Object.fromEntries(entries));
+}

package/src/app/api/cli-tools/antigravity-mitm/alias/route.js

@@ -0,0 +1,53 @@
+"use server";
+
+import { NextResponse } from "next/server";
+import { getMitmAlias, setMitmAliasAll } from "@/models";
+import { getMitmStatus } from "@/mitm/manager";
+import { writeAliasForTool } from "@/lib/mitmAliasCache";
+
+// GET - Get MITM aliases for a tool
+export async function GET(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const toolName = searchParams.get("tool");
+    const aliases = await getMitmAlias(toolName || undefined);
+    return NextResponse.json({ aliases });
+  } catch (error) {
+    console.log("Error fetching MITM aliases:", error.message);
+    return NextResponse.json({ error: "Failed to fetch aliases" }, { status: 500 });
+  }
+}
+
+// PUT - Save MITM aliases for a specific tool
+export async function PUT(request) {
+  try {
+    const { tool, mappings } = await request.json();
+
+    if (!tool || !mappings || typeof mappings !== "object") {
+      return NextResponse.json({ error: "tool and mappings required" }, { status: 400 });
+    }
+
+    // Check if DNS is enabled for this tool
+    const status = await getMitmStatus();
+    if (!status.dnsStatus || !status.dnsStatus[tool]) {
+      return NextResponse.json(
+        { error: `DNS must be enabled for ${tool} before editing model mappings` },
+        { status: 403 }
+      );
+    }
+
+    const filtered = {};
+    for (const [alias, model] of Object.entries(mappings)) {
+      if (model && model.trim()) {
+        filtered[alias] = model.trim();
+      }
+    }
+
+    await setMitmAliasAll(tool, filtered);
+    writeAliasForTool(tool, filtered);
+    return NextResponse.json({ success: true, aliases: filtered });
+  } catch (error) {
+    console.log("Error saving MITM aliases:", error.message);
+    return NextResponse.json({ error: "Failed to save aliases" }, { status: 500 });
+  }
+}

package/src/app/api/cli-tools/antigravity-mitm/route.js

@@ -0,0 +1,202 @@
+import { NextResponse } from "next/server";
+import {
+  getMitmStatus,
+  startServer,
+  stopServer,
+  enableToolDNS,
+  disableToolDNS,
+  trustCert,
+  getCachedPassword,
+  setCachedPassword,
+  loadEncryptedPassword,
+  isSudoPasswordRequired,
+  initDbHooks,
+} from "@/mitm/manager";
+import { getSettings, updateSettings } from "@/lib/localDb";
+
+initDbHooks(getSettings, updateSettings);
+
+const DEFAULT_MITM_ROUTER_BASE = "http://localhost:20128";
+
+function normalizeMitmRouterBaseUrlInput(input) {
+  if (input == null || String(input).trim() === "") {
+    return DEFAULT_MITM_ROUTER_BASE;
+  }
+  const t = String(input).trim().replace(/\/+$/, "");
+  let u;
+  try {
+    u = new URL(t);
+  } catch {
+    throw new Error("Invalid MITM router URL");
+  }
+  if (u.protocol !== "http:" && u.protocol !== "https:") {
+    throw new Error("MITM router URL must use http or https");
+  }
+  return t;
+}
+
+const isWin = process.platform === "win32";
+
+function getPassword(provided) {
+  return provided || getCachedPassword() || null;
+}
+
+function requiresSudoPassword(pwd) {
+  return !isWin && !pwd && isSudoPasswordRequired();
+}
+
+function checkIsAdmin() {
+  if (isWin) {
+    try {
+      require("child_process").execSync("net session >nul 2>&1", { windowsHide: true });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return typeof process.getuid === "function" && process.getuid() === 0;
+}
+
+function checkPrivilege(pwd) {
+  if (checkIsAdmin()) return true;
+  if (isWin) return false;
+  if (!isSudoPasswordRequired()) return true;
+  return !!pwd;
+}
+
+// GET - Full MITM status (server + per-tool DNS)
+export async function GET() {
+  try {
+    const status = await getMitmStatus();
+    const settings = await getSettings();
+    const hasCachedPassword = !!getCachedPassword() || !!(await loadEncryptedPassword());
+    return NextResponse.json({
+      running: status.running,
+      pid: status.pid || null,
+      certExists: status.certExists || false,
+      certTrusted: status.certTrusted || false,
+      dnsStatus: status.dnsStatus || {},
+      hasCachedPassword,
+      isWin,
+      needsSudoPassword: !isWin && !hasCachedPassword && isSudoPasswordRequired(),
+      isAdmin: checkIsAdmin(),
+      mitmRouterBaseUrl:
+        (settings.mitmRouterBaseUrl && String(settings.mitmRouterBaseUrl).trim()) ||
+        DEFAULT_MITM_ROUTER_BASE,
+    });
+  } catch (error) {
+    console.log("Error getting MITM status:", error.message);
+    return NextResponse.json({ error: "Failed to get MITM status" }, { status: 500 });
+  }
+}
+
+// POST - Start MITM server (cert + server, no DNS)
+export async function POST(request) {
+  try {
+    const { apiKey, sudoPassword, mitmRouterBaseUrl, forceKillPort443 } = await request.json();
+    const pwd = getPassword(sudoPassword) || await loadEncryptedPassword() || "";
+
+    if (!apiKey || requiresSudoPassword(pwd)) {
+      return NextResponse.json(
+        { error: !apiKey ? "Missing apiKey" : "Missing sudoPassword" },
+        { status: 400 }
+      );
+    }
+
+    if (!checkPrivilege(pwd)) {
+      return NextResponse.json(
+        { error: isWin ? "Administrator required — restart 9Router as Administrator" : "Root or sudo password required to start MITM" },
+        { status: 403 }
+      );
+    }
+
+    if (mitmRouterBaseUrl !== undefined && mitmRouterBaseUrl !== null) {
+      try {
+        const normalized = normalizeMitmRouterBaseUrlInput(mitmRouterBaseUrl);
+        await updateSettings({ mitmRouterBaseUrl: normalized });
+      } catch (e) {
+        return NextResponse.json(
+          { error: e.message || "Invalid MITM router URL" },
+          { status: 400 },
+        );
+      }
+    }
+
+    const result = await startServer(apiKey, pwd, !!forceKillPort443);
+    if (!isWin) setCachedPassword(pwd);
+
+    return NextResponse.json({ success: true, running: result.running, pid: result.pid });
+  } catch (error) {
+    console.log("Error starting MITM server:", error.message);
+    if (error.code === "PORT_443_BUSY") {
+      return NextResponse.json(
+        { error: error.message, code: "PORT_443_BUSY", portOwner: error.portOwner },
+        { status: 409 }
+      );
+    }
+    return NextResponse.json({ error: error.message || "Failed to start MITM server" }, { status: 500 });
+  }
+}
+
+// DELETE - Stop MITM server (removes all DNS first, then kills server)
+export async function DELETE(request) {
+  try {
+    const body = await request.json().catch(() => ({}));
+    const { sudoPassword } = body;
+    const pwd = getPassword(sudoPassword) || await loadEncryptedPassword() || "";
+
+    if (requiresSudoPassword(pwd)) {
+      return NextResponse.json({ error: "Missing sudoPassword" }, { status: 400 });
+    }
+
+    await stopServer(pwd);
+    if (!isWin && sudoPassword) setCachedPassword(sudoPassword);
+
+    return NextResponse.json({ success: true, running: false });
+  } catch (error) {
+    console.log("Error stopping MITM server:", error.message);
+    return NextResponse.json({ error: error.message || "Failed to stop MITM server" }, { status: 500 });
+  }
+}
+
+// PATCH - Toggle DNS for a specific tool (enable/disable)
+export async function PATCH(request) {
+  try {
+    const { tool, action, sudoPassword } = await request.json();
+    const pwd = getPassword(sudoPassword) || await loadEncryptedPassword() || "";
+
+    if (!tool || !action) {
+      return NextResponse.json({ error: "tool and action required" }, { status: 400 });
+    }
+    if (requiresSudoPassword(pwd)) {
+      return NextResponse.json({ error: "Missing sudoPassword" }, { status: 400 });
+    }
+    if (!checkPrivilege(pwd)) {
+      return NextResponse.json(
+        { error: isWin ? "Administrator required — restart 9Router as Administrator" : "Root or sudo password required to modify DNS" },
+        { status: 403 }
+      );
+    }
+
+    if (action === "enable") {
+      await enableToolDNS(tool, pwd);
+    } else if (action === "disable") {
+      await disableToolDNS(tool, pwd);
+    } else if (action === "trust-cert") {
+      await trustCert(pwd);
+      if (!isWin && sudoPassword) setCachedPassword(sudoPassword);
+      const status = await getMitmStatus();
+      return NextResponse.json({ success: true, certTrusted: status.certTrusted });
+    } else {
+      return NextResponse.json({ error: "action must be enable, disable, or trust-cert" }, { status: 400 });
+    }
+
+    if (!isWin && sudoPassword) setCachedPassword(sudoPassword);
+
+    const status = await getMitmStatus();
+    return NextResponse.json({ success: true, dnsStatus: status.dnsStatus });
+  } catch (error) {
+    console.log("Error toggling DNS:", error.message);
+    return NextResponse.json({ error: error.message || "Failed to toggle DNS" }, { status: 500 });
+  }
+}

package/src/app/api/cli-tools/claude-settings/route.js

@@ -0,0 +1,203 @@
+"use server";
+
+import { NextResponse } from "next/server";
+import { exec } from "child_process";
+import { promisify } from "util";
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+
+const execAsync = promisify(exec);
+
+// Get claude settings path based on OS
+const getClaudeSettingsPath = () => {
+  const homeDir = os.homedir();
+  return path.join(homeDir, ".claude", "settings.json");
+};
+
+
+// Check if claude CLI is installed (via which/where or config file exists)
+const checkClaudeInstalled = async () => {
+  try {
+    const isWindows = os.platform() === "win32";
+    const command = isWindows ? "where claude" : "which claude";
+    const env = isWindows
+      ? { ...process.env, PATH: `${process.env.APPDATA}\\npm;${process.env.PATH}` }
+      : process.env;
+    await execAsync(command, { windowsHide: true, env });
+    return true;
+  } catch {
+    try {
+      await fs.access(getClaudeSettingsPath());
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// Read current settings
+const readSettings = async () => {
+  try {
+    const settingsPath = getClaudeSettingsPath();
+    const content = await fs.readFile(settingsPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+};
+
+// GET - Check claude CLI and read current settings
+export async function GET() {
+  try {
+    const isInstalled = await checkClaudeInstalled();
+    
+    if (!isInstalled) {
+      return NextResponse.json({
+        installed: false,
+        settings: null,
+        message: "Claude CLI is not installed",
+      });
+    }
+
+    const settings = await readSettings();
+    const has9Router = !!(settings?.env?.ANTHROPIC_BASE_URL);
+
+    return NextResponse.json({
+      installed: true,
+      settings: settings,
+      has9Router: has9Router,
+      settingsPath: getClaudeSettingsPath(),
+    });
+  } catch (error) {
+    console.log("Error checking claude settings:", error);
+    return NextResponse.json(
+      { error: "Failed to check claude settings" },
+      { status: 500 }
+    );
+  }
+}
+
+// POST - Backup old fields and write new settings
+export async function POST(request) {
+  try {
+    const { env } = await request.json();
+    
+    if (!env || typeof env !== "object") {
+      return NextResponse.json(
+        { error: "Invalid env object" },
+        { status: 400 }
+      );
+    }
+
+    const settingsPath = getClaudeSettingsPath();
+    const claudeDir = path.dirname(settingsPath);
+
+    // Ensure .claude directory exists
+    await fs.mkdir(claudeDir, { recursive: true });
+
+    // Read current settings
+    let currentSettings = {};
+    try {
+      const content = await fs.readFile(settingsPath, "utf-8");
+      currentSettings = JSON.parse(content);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+
+    // Normalize ANTHROPIC_BASE_URL to ensure /v1 suffix
+    if (env.ANTHROPIC_BASE_URL) {
+      env.ANTHROPIC_BASE_URL = env.ANTHROPIC_BASE_URL.endsWith("/v1") 
+        ? env.ANTHROPIC_BASE_URL 
+        : `${env.ANTHROPIC_BASE_URL}/v1`;
+    }
+
+    // Merge new env with existing settings
+    const newSettings = {
+      ...currentSettings,
+      hasCompletedOnboarding: true,
+      env: {
+        ...(currentSettings.env || {}),
+        ...env,
+      },
+    };
+
+    // Write new settings
+    await fs.writeFile(settingsPath, JSON.stringify(newSettings, null, 2));
+
+    return NextResponse.json({
+      success: true,
+      message: "Settings updated successfully",
+    });
+  } catch (error) {
+    console.log("Error updating claude settings:", error);
+    return NextResponse.json(
+      { error: "Failed to update claude settings" },
+      { status: 500 }
+    );
+  }
+}
+
+// Fields to remove when resetting
+const RESET_ENV_KEYS = [
+  "ANTHROPIC_BASE_URL",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+  "API_TIMEOUT_MS",
+];
+
+// DELETE - Reset settings (remove env fields)
+export async function DELETE() {
+  try {
+    const settingsPath = getClaudeSettingsPath();
+
+    // Read current settings
+    let currentSettings = {};
+    try {
+      const content = await fs.readFile(settingsPath, "utf-8");
+      currentSettings = JSON.parse(content);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return NextResponse.json({
+          success: true,
+          message: "No settings file to reset",
+        });
+      }
+      throw error;
+    }
+
+    // Remove specified env fields
+    if (currentSettings.env) {
+      RESET_ENV_KEYS.forEach((key) => {
+        delete currentSettings.env[key];
+      });
+      
+      // Clean up empty env object
+      if (Object.keys(currentSettings.env).length === 0) {
+        delete currentSettings.env;
+      }
+    }
+
+    // Write updated settings
+    await fs.writeFile(settingsPath, JSON.stringify(currentSettings, null, 2));
+
+    return NextResponse.json({
+      success: true,
+      message: "Settings reset successfully",
+    });
+  } catch (error) {
+    console.log("Error resetting claude settings:", error);
+    return NextResponse.json(
+      { error: "Failed to reset claude settings" },
+      { status: 500 }
+    );
+  }
+}
+

package/src/app/api/cli-tools/cline-settings/route.js

@@ -0,0 +1,133 @@
+"use server";
+
+import { NextResponse } from "next/server";
+import { exec } from "child_process";
+import { promisify } from "util";
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+
+const execAsync = promisify(exec);
+
+const getDataDir = () => path.join(os.homedir(), ".cline", "data");
+const getGlobalStatePath = () => path.join(getDataDir(), "globalState.json");
+const getSecretsPath = () => path.join(getDataDir(), "secrets.json");
+
+const checkInstalled = async () => {
+  try {
+    const isWindows = os.platform() === "win32";
+    const command = isWindows ? "where cline" : "which cline";
+    const env = isWindows
+      ? { ...process.env, PATH: `${process.env.APPDATA}\\npm;${process.env.PATH}` }
+      : process.env;
+    await execAsync(command, { windowsHide: true, env });
+    return true;
+  } catch {
+    try {
+      await fs.access(getGlobalStatePath());
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+const readJson = async (filePath) => {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+};
+
+const has9RouterConfig = (globalState) => {
+  if (!globalState) return false;
+  const isOpenAi =
+    globalState.actModeApiProvider === "openai" || globalState.planModeApiProvider === "openai";
+  const baseUrl = globalState.openAiBaseUrl || "";
+  return isOpenAi && (baseUrl.includes("localhost") || baseUrl.includes("127.0.0.1") || baseUrl.includes("9router"));
+};
+
+export async function GET() {
+  try {
+    const installed = await checkInstalled();
+    if (!installed) {
+      return NextResponse.json({ installed: false, settings: null, message: "Cline CLI is not installed" });
+    }
+    const globalState = await readJson(getGlobalStatePath());
+    return NextResponse.json({
+      installed: true,
+      settings: {
+        actModeApiProvider: globalState?.actModeApiProvider,
+        planModeApiProvider: globalState?.planModeApiProvider,
+        openAiBaseUrl: globalState?.openAiBaseUrl,
+        openAiModelId: globalState?.openAiModelId,
+      },
+      has9Router: has9RouterConfig(globalState),
+      globalStatePath: getGlobalStatePath(),
+    });
+  } catch (error) {
+    console.log("Error checking cline settings:", error);
+    return NextResponse.json({ error: "Failed to check cline settings" }, { status: 500 });
+  }
+}
+
+export async function POST(request) {
+  try {
+    const { baseUrl, apiKey, model } = await request.json();
+    if (!baseUrl || !apiKey || !model) {
+      return NextResponse.json({ error: "baseUrl, apiKey and model are required" }, { status: 400 });
+    }
+
+    await fs.mkdir(getDataDir(), { recursive: true });
+
+    // Cline expects base WITHOUT /v1
+    const normalizedBaseUrl = baseUrl.endsWith("/v1") ? baseUrl.slice(0, -3) : baseUrl;
+
+    const globalState = (await readJson(getGlobalStatePath())) || {};
+    globalState.actModeApiProvider = "openai";
+    globalState.planModeApiProvider = "openai";
+    globalState.openAiBaseUrl = normalizedBaseUrl;
+    globalState.openAiModelId = model;
+    globalState.planModeOpenAiModelId = model;
+    await fs.writeFile(getGlobalStatePath(), JSON.stringify(globalState, null, 2));
+
+    const secrets = (await readJson(getSecretsPath())) || {};
+    secrets.openAiApiKey = apiKey;
+    await fs.writeFile(getSecretsPath(), JSON.stringify(secrets, null, 2));
+
+    return NextResponse.json({ success: true, message: "Cline settings applied successfully!", globalStatePath: getGlobalStatePath() });
+  } catch (error) {
+    console.log("Error updating cline settings:", error);
+    return NextResponse.json({ error: "Failed to update cline settings" }, { status: 500 });
+  }
+}
+
+export async function DELETE() {
+  try {
+    const globalState = await readJson(getGlobalStatePath());
+    if (!globalState) {
+      return NextResponse.json({ success: true, message: "No settings file to reset" });
+    }
+
+    if (globalState.actModeApiProvider === "openai") {
+      delete globalState.openAiBaseUrl;
+      delete globalState.openAiModelId;
+      delete globalState.planModeOpenAiModelId;
+      globalState.actModeApiProvider = "cline";
+      globalState.planModeApiProvider = "cline";
+    }
+    await fs.writeFile(getGlobalStatePath(), JSON.stringify(globalState, null, 2));
+
+    const secrets = (await readJson(getSecretsPath())) || {};
+    delete secrets.openAiApiKey;
+    await fs.writeFile(getSecretsPath(), JSON.stringify(secrets, null, 2));
+
+    return NextResponse.json({ success: true, message: "9Router settings removed from Cline" });
+  } catch (error) {
+    console.log("Error resetting cline settings:", error);
+    return NextResponse.json({ error: "Failed to reset cline settings" }, { status: 500 });
+  }
+}

package/src/app/api/cli-tools/codex-gateway/accounts/route.js

@@ -0,0 +1,16 @@
+import { NextResponse } from "next/server";
+import { listCodexGatewayAccounts } from "@/sse/services/codexGateway.js";
+
+export const dynamic = "force-dynamic";
+
+export async function GET() {
+  try {
+    const data = await listCodexGatewayAccounts();
+    return NextResponse.json(data, {
+      headers: { "Cache-Control": "no-store" },
+    });
+  } catch (error) {
+    console.log("Error listing Codex gateway accounts:", error);
+    return NextResponse.json({ error: "Failed to list Codex gateway accounts" }, { status: 500 });
+  }
+}