wyxrouter 0.4.71

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

@@ -0,0 +1,213 @@
+"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 getDroidDir = () => path.join(os.homedir(), ".factory");
+const getDroidSettingsPath = () => path.join(getDroidDir(), "settings.json");
+
+// Check if droid CLI is installed (via which/where or config file exists)
+const checkDroidInstalled = async () => {
+  try {
+    const isWindows = os.platform() === "win32";
+    const command = isWindows ? "where droid" : "which droid";
+    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(getDroidSettingsPath());
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// Read current settings.json
+const readSettings = async () => {
+  try {
+    const settingsPath = getDroidSettingsPath();
+    const content = await fs.readFile(settingsPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+};
+
+// Check if settings has 9Router customModels
+const has9RouterConfig = (settings) => {
+  if (!settings || !settings.customModels) return false;
+  return settings.customModels.some(m => m.id?.startsWith("custom:9Router"));
+};
+
+// GET - Check droid CLI and read current settings
+export async function GET() {
+  try {
+    const isInstalled = await checkDroidInstalled();
+    
+    if (!isInstalled) {
+      return NextResponse.json({
+        installed: false,
+        settings: null,
+        message: "Factory Droid CLI is not installed",
+      });
+    }
+
+    const settings = await readSettings();
+
+    return NextResponse.json({
+      installed: true,
+      settings,
+      has9Router: has9RouterConfig(settings),
+      settingsPath: getDroidSettingsPath(),
+    });
+  } catch (error) {
+    console.log("Error checking droid settings:", error);
+    return NextResponse.json({ error: "Failed to check droid settings" }, { status: 500 });
+  }
+}
+
+// POST - Update 9Router customModels (merge with existing settings)
+// Accepts either `model` (string, legacy single-model) or `models` (array of strings, multi-model)
+// Also accepts `activeModel` to set which model is active/primary
+export async function POST(request) {
+  try {
+    const { baseUrl, apiKey, model, models, activeModel } = await request.json();
+    
+    // Accept either `models` (array) or `model` (string, legacy)
+    const modelsArray = Array.isArray(models) ? models.slice() : (typeof model === "string" ? [model] : []);
+    
+    if (!baseUrl || modelsArray.length === 0) {
+      return NextResponse.json({ error: "baseUrl and at least one model are required" }, { status: 400 });
+    }
+
+    const droidDir = getDroidDir();
+    const settingsPath = getDroidSettingsPath();
+
+    // Ensure directory exists
+    await fs.mkdir(droidDir, { recursive: true });
+
+    // Read existing settings or create new
+    let settings = {};
+    try {
+      const existingSettings = await fs.readFile(settingsPath, "utf-8");
+      settings = JSON.parse(existingSettings);
+    } catch { /* No existing settings */ }
+
+    // Ensure customModels array exists
+    if (!settings.customModels) {
+      settings.customModels = [];
+    }
+
+    // Remove all existing 9Router configs
+    settings.customModels = settings.customModels.filter(m => !m.id?.startsWith("custom:9Router"));
+
+    // Normalize baseUrl to ensure /v1 suffix
+    const normalizedBaseUrl = baseUrl.endsWith("/v1") ? baseUrl : `${baseUrl}/v1`;
+    const keyToUse = apiKey || "your_api_key";
+
+    // Determine active model: prefer explicit activeModel, else first of modelsArray
+    // If activeModel is explicitly empty string, no model will be set as default
+    let defaultIndex = 0;
+    if (typeof activeModel === "string") {
+      if (activeModel === "") {
+        defaultIndex = -1; // signal: don't set a default
+      } else {
+        const idx = modelsArray.indexOf(activeModel);
+        defaultIndex = idx >= 0 ? idx : 0;
+      }
+    }
+
+    // Add entries for all requested models
+    // The first one (index 0) will be the default if defaultIndex >= 0
+    for (let i = 0; i < modelsArray.length; i++) {
+      const m = modelsArray[i];
+      if (!m || typeof m !== "string") continue;
+      settings.customModels.push({
+        model: m,
+        id: `custom:9Router-${i}`,
+        index: i,
+        baseUrl: normalizedBaseUrl,
+        apiKey: keyToUse,
+        displayName: m,
+        maxOutputTokens: 131072,
+        noImageSupport: false,
+        provider: "openai",
+      });
+    }
+
+    // Set default model if applicable
+    if (defaultIndex >= 0 && settings.customModels[defaultIndex]) {
+      // Reorder so the default comes first
+      const [defaultEntry] = settings.customModels.splice(defaultIndex, 1);
+      settings.customModels.unshift({ ...defaultEntry, index: 0 });
+      // Re-index the rest
+      settings.customModels.forEach((m, i) => { m.index = i; });
+    }
+
+    // Write settings
+    await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+
+    return NextResponse.json({
+      success: true,
+      message: "Factory Droid settings applied successfully!",
+      settingsPath,
+    });
+  } catch (error) {
+    console.log("Error updating droid settings:", error);
+    return NextResponse.json({ error: "Failed to update droid settings" }, { status: 500 });
+  }
+}
+
+// DELETE - Remove 9Router customModels only (keep other settings)
+export async function DELETE() {
+  try {
+    const settingsPath = getDroidSettingsPath();
+
+    // Read existing settings
+    let settings = {};
+    try {
+      const existingSettings = await fs.readFile(settingsPath, "utf-8");
+      settings = JSON.parse(existingSettings);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return NextResponse.json({
+          success: true,
+          message: "No settings file to reset",
+        });
+      }
+      throw error;
+    }
+
+    // Remove 9Router customModels
+    if (settings.customModels) {
+      settings.customModels = settings.customModels.filter(m => !m.id?.startsWith("custom:9Router"));
+      
+      // Remove customModels array if empty
+      if (settings.customModels.length === 0) {
+        delete settings.customModels;
+      }
+    }
+
+    // Write updated settings
+    await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+
+    return NextResponse.json({
+      success: true,
+      message: "9Router settings removed successfully",
+    });
+  } catch (error) {
+    console.log("Error resetting droid settings:", error);
+    return NextResponse.json({ error: "Failed to reset droid settings" }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,175 @@
+"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 PROVIDER_NAME = "9router";
+const API_KEY_ENV = "OPENAI_API_KEY";
+
+const getHermesDir = () => path.join(os.homedir(), ".hermes");
+const getHermesConfigPath = () => path.join(getHermesDir(), "config.yaml");
+const getHermesEnvPath = () => path.join(getHermesDir(), ".env");
+
+// Match top-level "model:" block (until next non-indented, non-empty line)
+const MODEL_BLOCK_RE = /^model:[ \t]*\r?\n((?:[ \t]+.*\r?\n?|[ \t]*\r?\n)*)/m;
+
+const buildModelBlock = (model, baseUrl) =>
+  `model:\n  default: "${model}"\n  provider: "custom"\n  base_url: "${baseUrl}"\n`;
+
+// Parse current model block back to fields (best-effort, simple key:value)
+const parseModelBlock = (yaml) => {
+  const match = yaml.match(MODEL_BLOCK_RE);
+  if (!match) return null;
+  const body = match[1] || "";
+  const get = (key) => {
+    const m = body.match(new RegExp(`^[ \\t]+${key}:[ \\t]*["']?([^"'\\r\\n]+)["']?`, "m"));
+    return m ? m[1].trim() : null;
+  };
+  return {
+    default: get("default"),
+    provider: get("provider"),
+    base_url: get("base_url"),
+  };
+};
+
+const upsertModelBlock = (yaml, newBlock) => {
+  if (MODEL_BLOCK_RE.test(yaml)) return yaml.replace(MODEL_BLOCK_RE, newBlock);
+  return yaml.length > 0 ? `${newBlock}\n${yaml}` : newBlock;
+};
+
+const removeModelBlock = (yaml) => yaml.replace(MODEL_BLOCK_RE, "").replace(/^\n+/, "");
+
+// .env helpers — upsert/remove single KEY=VALUE line
+const upsertEnvVar = (envText, key, value) => {
+  const re = new RegExp(`^${key}=.*$`, "m");
+  const line = `${key}=${value}`;
+  if (re.test(envText)) return envText.replace(re, line);
+  return envText.length > 0 && !envText.endsWith("\n") ? `${envText}\n${line}\n` : `${envText}${line}\n`;
+};
+
+const removeEnvVar = (envText, key) => {
+  const re = new RegExp(`^${key}=.*\\r?\\n?`, "m");
+  return envText.replace(re, "");
+};
+
+const checkHermesInstalled = async () => {
+  try {
+    const isWindows = os.platform() === "win32";
+    const command = isWindows ? "where hermes" : "which hermes";
+    await execAsync(command, { windowsHide: true });
+    return true;
+  } catch {
+    try {
+      await fs.access(getHermesConfigPath());
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+const readConfigYaml = async () => {
+  try {
+    return await fs.readFile(getHermesConfigPath(), "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") return "";
+    throw error;
+  }
+};
+
+const readEnvFile = async () => {
+  try {
+    return await fs.readFile(getHermesEnvPath(), "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") return "";
+    throw error;
+  }
+};
+
+// Detect 9router by base_url containing localhost/127.0.0.1 or matching tunnel URL
+const has9RouterConfig = (modelCfg) => {
+  if (!modelCfg?.base_url) return false;
+  return modelCfg.provider === "custom" && /localhost|127\.0\.0\.1|0\.0\.0\.0/.test(modelCfg.base_url);
+};
+
+export async function GET() {
+  try {
+    const installed = await checkHermesInstalled();
+    if (!installed) {
+      return NextResponse.json({ installed: false, settings: null, message: "Hermes Agent is not installed" });
+    }
+    const yaml = await readConfigYaml();
+    const model = parseModelBlock(yaml);
+    return NextResponse.json({
+      installed: true,
+      settings: { model },
+      has9Router: has9RouterConfig(model),
+      configPath: getHermesConfigPath(),
+    });
+  } catch (error) {
+    console.log("Error checking hermes settings:", error);
+    return NextResponse.json({ error: "Failed to check hermes settings" }, { status: 500 });
+  }
+}
+
+export async function POST(request) {
+  try {
+    const { baseUrl, apiKey, model } = await request.json();
+    if (!baseUrl || !model) {
+      return NextResponse.json({ error: "baseUrl and model are required" }, { status: 400 });
+    }
+
+    const dir = getHermesDir();
+    await fs.mkdir(dir, { recursive: true });
+
+    const normalizedBaseUrl = baseUrl.endsWith("/v1") ? baseUrl : `${baseUrl}/v1`;
+
+    // Update config.yaml — replace/insert model: block, keep everything else
+    const existingYaml = await readConfigYaml();
+    const newYaml = upsertModelBlock(existingYaml, buildModelBlock(model, normalizedBaseUrl));
+    await fs.writeFile(getHermesConfigPath(), newYaml);
+
+    // Update .env — upsert OPENAI_API_KEY only when caller provides one
+    if (apiKey) {
+      const existingEnv = await readEnvFile();
+      const newEnv = upsertEnvVar(existingEnv, API_KEY_ENV, apiKey);
+      await fs.writeFile(getHermesEnvPath(), newEnv);
+    }
+
+    return NextResponse.json({
+      success: true,
+      message: "Hermes settings applied successfully!",
+      configPath: getHermesConfigPath(),
+    });
+  } catch (error) {
+    console.log("Error updating hermes settings:", error);
+    return NextResponse.json({ error: "Failed to update hermes settings" }, { status: 500 });
+  }
+}
+
+export async function DELETE() {
+  try {
+    const configPath = getHermesConfigPath();
+    let yaml = "";
+    try {
+      yaml = await fs.readFile(configPath, "utf-8");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return NextResponse.json({ success: true, message: "No config file to reset" });
+      }
+      throw error;
+    }
+    const newYaml = removeModelBlock(yaml);
+    await fs.writeFile(configPath, newYaml);
+    return NextResponse.json({ success: true, message: `${PROVIDER_NAME} model block removed` });
+  } catch (error) {
+    console.log("Error resetting hermes settings:", error);
+    return NextResponse.json({ error: "Failed to reset hermes settings" }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,216 @@
+"use server";
+
+import { NextResponse } from "next/server";
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { parseTOML, stringifyTOML } from "confbox";
+
+const execAsync = promisify(exec);
+
+const getJcodeConfigDir = () => path.join(os.homedir(), ".jcode");
+const getConfigPath = () => path.join(getJcodeConfigDir(), "config.toml");
+
+const getProviderEnvPath = () => {
+  const configDir = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+  return path.join(configDir, "jcode", "provider-9router.env");
+};
+
+const checkJcodeInstalled = async () => {
+  try {
+    const isWindows = os.platform() === "win32";
+    const command = isWindows ? "where jcode" : "which jcode";
+    await execAsync(command, { windowsHide: true });
+    return true;
+  } catch {
+    try {
+      await fs.access(getJcodeConfigDir());
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+const readConfig = async () => {
+  try {
+    const configPath = getConfigPath();
+    const content = await fs.readFile(configPath, "utf-8");
+    return parseTOML(content);
+  } catch (error) {
+    return { providers: {} };
+  }
+};
+
+const has9RouterConfig = (config) => {
+  if (!config || !config.providers) return false;
+
+  const providers = config.providers;
+
+  if (providers["9router"]) return true;
+
+  for (const [name, provider] of Object.entries(providers)) {
+    if (provider.base_url && provider.base_url.includes("localhost:20128")) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+const writeConfig = async (config) => {
+  const configPath = getConfigPath();
+  const content = stringifyTOML(config);
+  await fs.writeFile(configPath, content, "utf-8");
+};
+
+const readProviderEnv = async () => {
+  try {
+    const envPath = getProviderEnvPath();
+    const content = await fs.readFile(envPath, "utf-8");
+    const env = {};
+
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+
+      const eqIndex = trimmed.indexOf("=");
+      if (eqIndex > 0) {
+        const key = trimmed.slice(0, eqIndex).trim();
+        let value = trimmed.slice(eqIndex + 1).trim();
+
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+          value = value.slice(1, -1);
+        }
+
+        env[key] = value;
+      }
+    }
+
+    return env;
+  } catch {
+    return {};
+  }
+};
+
+const writeProviderEnv = async (env) => {
+  const envPath = getProviderEnvPath();
+  let content = "# jcode provider environment variables\n";
+
+  for (const [key, value] of Object.entries(env)) {
+    content += `${key}="${value}"\n`;
+  }
+
+  await fs.writeFile(envPath, content, "utf-8");
+};
+
+export async function GET() {
+  const isInstalled = await checkJcodeInstalled();
+
+  if (!isInstalled) {
+    return NextResponse.json({
+      installed: false,
+      message: "jcode not installed. Install via: curl -fsSL https://raw.githubusercontent.com/1jehuang/jcode/master/scripts/install.sh | bash",
+    });
+  }
+
+  const config = await readConfig();
+  const has9Router = has9RouterConfig(config);
+
+  return NextResponse.json({
+    installed: true,
+    config,
+    has9Router,
+    configPath: getConfigPath(),
+  });
+}
+
+export async function POST(request) {
+  try {
+    const { baseUrl, apiKey, models } = await request.json();
+
+    if (!baseUrl || !apiKey) {
+      return NextResponse.json(
+        { error: "baseUrl and apiKey are required" },
+        { status: 400 }
+      );
+    }
+
+    const normalizedBaseUrl = baseUrl.endsWith("/v1")
+      ? baseUrl
+      : `${baseUrl}/v1`;
+
+    let config = await readConfig();
+
+    if (!config.providers) {
+      config.providers = {};
+    }
+
+    config.providers["9router"] = {
+      type: "openai-compatible",
+      base_url: normalizedBaseUrl,
+      auth: "bearer",
+      api_key_env: "JCODE_9ROUTER_API_KEY",
+      env_file: "provider-9router.env",
+      default_model: models && models.length > 0 ? models[0] : "cc/claude-opus-4-7",
+      requires_api_key: true,
+    };
+
+    const configDir = getJcodeConfigDir();
+    await fs.mkdir(configDir, { recursive: true });
+
+    await writeConfig(config);
+
+    const xdgConfigDir = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+    const jcodeConfigDir = path.join(xdgConfigDir, "jcode");
+    await fs.mkdir(jcodeConfigDir, { recursive: true });
+
+    const env = await readProviderEnv();
+    env.JCODE_9ROUTER_API_KEY = apiKey;
+    await writeProviderEnv(env);
+
+    return NextResponse.json({
+      success: true,
+      message: "jcode configured successfully. Use: jcode --provider-profile 9router",
+      configPath: getConfigPath(),
+    });
+  } catch (error) {
+    console.error("Error configuring jcode:", error);
+    return NextResponse.json(
+      { error: error.message },
+      { status: 500 }
+    );
+  }
+}
+
+export async function DELETE() {
+  try {
+    const config = await readConfig();
+
+    if (!config.providers) {
+      return NextResponse.json({ success: true, message: "No configuration to remove" });
+    }
+
+    delete config.providers["9router"];
+
+    await writeConfig(config);
+
+    const env = await readProviderEnv();
+    delete env.JCODE_9ROUTER_API_KEY;
+    await writeProviderEnv(env);
+
+    return NextResponse.json({
+      success: true,
+      message: "9router configuration removed from jcode",
+    });
+  } catch (error) {
+    console.error("Error removing jcode configuration:", error);
+    return NextResponse.json(
+      { error: error.message },
+      { status: 500 }
+    );
+  }
+}