zevairouter 1.0.0

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

@@ -0,0 +1,131 @@
+"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(), ".local", "share", "kilo");
+const getAuthPath = () => path.join(getDataDir(), "auth.json");
+const getVscodeSettingsPath = () => path.join(os.homedir(), ".config", "Code", "User", "settings.json");
+
+const checkInstalled = async () => {
+  try {
+    const isWindows = os.platform() === "win32";
+    const command = isWindows ? "where kilo" : "which kilo";
+    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(getAuthPath());
+      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 = (auth) => {
+  if (!auth) return false;
+  const entry = auth["openai-compatible"] || auth["9router"];
+  if (!entry) return false;
+  const baseUrl = entry.baseUrl || entry.baseURL || "";
+  return 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: "Kilo Code CLI is not installed" });
+    }
+    const auth = await readJson(getAuthPath());
+    return NextResponse.json({
+      installed: true,
+      settings: { auth: auth ? Object.keys(auth) : [] },
+      has9Router: has9RouterConfig(auth),
+      authPath: getAuthPath(),
+    });
+  } catch (error) {
+    console.log("Error checking kilo settings:", error);
+    return NextResponse.json({ error: "Failed to check kilo 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 });
+
+    const normalizedBaseUrl = baseUrl.endsWith("/v1") ? baseUrl : `${baseUrl}/v1`;
+
+    const auth = (await readJson(getAuthPath())) || {};
+    auth["openai-compatible"] = {
+      type: "api-key",
+      apiKey,
+      baseUrl: normalizedBaseUrl,
+      model,
+    };
+    await fs.writeFile(getAuthPath(), JSON.stringify(auth, null, 2));
+
+    // Best-effort: update VS Code extension settings
+    try {
+      const vscode = (await readJson(getVscodeSettingsPath())) || {};
+      vscode["kilocode.customProvider"] = { name: "9Router", baseURL: normalizedBaseUrl, apiKey };
+      vscode["kilocode.defaultModel"] = model;
+      await fs.writeFile(getVscodeSettingsPath(), JSON.stringify(vscode, null, 2));
+    } catch { /* VS Code settings not writable */ }
+
+    return NextResponse.json({ success: true, message: "Kilo Code settings applied successfully!", authPath: getAuthPath() });
+  } catch (error) {
+    console.log("Error updating kilo settings:", error);
+    return NextResponse.json({ error: "Failed to update kilo settings" }, { status: 500 });
+  }
+}
+
+export async function DELETE() {
+  try {
+    const auth = await readJson(getAuthPath());
+    if (!auth) {
+      return NextResponse.json({ success: true, message: "No settings file to reset" });
+    }
+    delete auth["openai-compatible"];
+    delete auth["9router"];
+    await fs.writeFile(getAuthPath(), JSON.stringify(auth, null, 2));
+
+    try {
+      const vscode = await readJson(getVscodeSettingsPath());
+      if (vscode) {
+        delete vscode["kilocode.customProvider"];
+        delete vscode["kilocode.defaultModel"];
+        await fs.writeFile(getVscodeSettingsPath(), JSON.stringify(vscode, null, 2));
+      }
+    } catch { /* ignore */ }
+
+    return NextResponse.json({ success: true, message: "9Router settings removed from Kilo Code" });
+  } catch (error) {
+    console.log("Error resetting kilo settings:", error);
+    return NextResponse.json({ error: "Failed to reset kilo settings" }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,292 @@
+"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);
+
+// OpenClaw 2026.5.x writes agents[].model as either a plain string
+// (legacy) or as an object `{ primary, fallbacks }`. Normalize to the
+// string id so downstream consumers can call `.startsWith()` safely.
+const resolveAgentModel = (m) => {
+  if (typeof m === "string") return m;
+  if (m && typeof m === "object") return m.primary ?? "";
+  return "";
+};
+
+const getOpenClawDir = () => path.join(os.homedir(), ".openclaw");
+const getOpenClawSettingsPath = () => path.join(getOpenClawDir(), "openclaw.json");
+
+// Check if openclaw CLI is installed (via which/where or config file exists)
+const checkOpenClawInstalled = async () => {
+  try {
+    const isWindows = os.platform() === "win32";
+    const command = isWindows ? "where openclaw" : "which openclaw";
+    // On Windows, inject %APPDATA%\npm into PATH so npm global packages are found
+    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(getOpenClawSettingsPath());
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// Read current settings.json
+const readSettings = async () => {
+  try {
+    const settingsPath = getOpenClawSettingsPath();
+    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 config
+const has9RouterConfig = (settings) => {
+  if (!settings || !settings.models || !settings.models.providers) return false;
+  return !!settings.models.providers["9router"];
+};
+
+// Read per-agent models.json and return current model id (without "9router/" prefix)
+const readAgentModel = async (agentDir) => {
+  try {
+    const modelsPath = path.join(agentDir, "models.json");
+    const content = await fs.readFile(modelsPath, "utf-8");
+    const data = JSON.parse(content);
+    const models = data?.providers?.["9router"]?.models;
+    return models?.[0]?.id || null;
+  } catch {
+    return null;
+  }
+};
+
+// GET - Check openclaw CLI and read current settings
+export async function GET() {
+  try {
+    const isInstalled = await checkOpenClawInstalled();
+    
+    if (!isInstalled) {
+      return NextResponse.json({
+        installed: false,
+        settings: null,
+        message: "Open Claw CLI is not installed",
+      });
+    }
+
+    const settings = await readSettings();
+
+    // Enrich agents list with current per-agent model from models.json.
+    // Coerce agent.model to its string id when OpenClaw stores it as
+    // `{ primary, fallbacks }` so downstream `.startsWith()` calls work.
+    const agentList = settings?.agents?.list || [];
+    const enrichedAgents = await Promise.all(
+      agentList.map(async (agent) => {
+        const agentModel = agent.agentDir ? await readAgentModel(agent.agentDir) : null;
+        return { ...agent, model: resolveAgentModel(agent.model), currentModel: agentModel };
+      })
+    );
+
+    return NextResponse.json({
+      installed: true,
+      settings,
+      agents: enrichedAgents,
+      has9Router: has9RouterConfig(settings),
+      settingsPath: getOpenClawSettingsPath(),
+    });
+  } catch (error) {
+    console.log("Error checking openclaw settings:", error);
+    return NextResponse.json({ error: "Failed to check openclaw settings" }, { status: 500 });
+  }
+}
+
+// Write per-agent models.json
+const writeAgentModels = async (agentDir, model, baseUrl, apiKey) => {
+  await fs.mkdir(agentDir, { recursive: true });
+  const modelsPath = path.join(agentDir, "models.json");
+  let existing = {};
+  try {
+    const content = await fs.readFile(modelsPath, "utf-8");
+    existing = JSON.parse(content);
+  } catch { /* No existing */ }
+
+  if (!existing.providers) existing.providers = {};
+  existing.providers["9router"] = {
+    baseUrl,
+    apiKey: apiKey || "your_api_key",
+    api: "openai-completions",
+    models: [{ id: model, name: model.split("/").pop() || model }],
+  };
+  await fs.writeFile(modelsPath, JSON.stringify(existing, null, 2));
+};
+
+// POST - Update 9Router settings (merge with existing settings)
+export async function POST(request) {
+  try {
+    // agentModels: { [agentId]: modelId } for per-agent override
+    const { baseUrl, apiKey, model, agentModels = {} } = await request.json();
+    
+    if (!baseUrl || !model) {
+      return NextResponse.json({ error: "baseUrl and model are required" }, { status: 400 });
+    }
+
+    const openclawDir = getOpenClawDir();
+    const settingsPath = getOpenClawSettingsPath();
+
+    await fs.mkdir(openclawDir, { recursive: true });
+
+    let settings = {};
+    try {
+      const existingSettings = await fs.readFile(settingsPath, "utf-8");
+      settings = JSON.parse(existingSettings);
+    } catch { /* No existing settings */ }
+
+    if (!settings.agents) settings.agents = {};
+    if (!settings.agents.defaults) settings.agents.defaults = {};
+    if (!settings.agents.defaults.model) settings.agents.defaults.model = {};
+    if (!settings.agents.defaults.models) settings.agents.defaults.models = {};
+    if (!settings.models) settings.models = {};
+    if (!settings.models.providers) settings.models.providers = {};
+
+    const normalizedBaseUrl = baseUrl.endsWith("/v1") ? baseUrl : `${baseUrl}/v1`;
+    const fullModelId = `9router/${model}`;
+
+    // Remove all old 9router/* entries from agents.defaults.models
+    Object.keys(settings.agents.defaults.models)
+      .filter((k) => k.startsWith("9router/"))
+      .forEach((k) => { delete settings.agents.defaults.models[k]; });
+
+    // Update default model
+    settings.agents.defaults.model.primary = fullModelId;
+
+    // Collect all unique models (default + per-agent)
+    const allModelIds = new Set([model]);
+    Object.values(agentModels).forEach((m) => { if (m) allModelIds.add(m); });
+
+    // Add fresh 9router models to allowlist
+    allModelIds.forEach((m) => {
+      settings.agents.defaults.models[`9router/${m}`] = {};
+    });
+
+    // Remove old 9router model from each agent in agents.list. The
+    // model field may be a plain string or `{ primary, fallbacks }`.
+    if (settings.agents.list) {
+      settings.agents.list = settings.agents.list.map((agent) => {
+        if (resolveAgentModel(agent.model).startsWith("9router/")) {
+          const { model: _, ...rest } = agent;
+          return rest;
+        }
+        return agent;
+      });
+    }
+
+    // Update models.providers.9router with all models
+    settings.models.providers["9router"] = {
+      baseUrl: normalizedBaseUrl,
+      apiKey: apiKey || "your_api_key",
+      api: "openai-completions",
+      models: [...allModelIds].map((m) => ({ id: m, name: m.split("/").pop() || m })),
+    };
+
+    // Set per-agent model in agents.list and write models.json
+    if (settings.agents.list) {
+      settings.agents.list = settings.agents.list.map((agent) => {
+        const agentModel = agentModels[agent.id];
+        if (agentModel) return { ...agent, model: `9router/${agentModel}` };
+        return agent;
+      });
+
+      // Write per-agent models.json for agents with agentDir
+      await Promise.all(
+        settings.agents.list.map(async (agent) => {
+          if (!agent.agentDir) return;
+          const agentModel = agentModels[agent.id];
+          const modelToWrite = agentModel || model; // fallback to default
+          await writeAgentModels(agent.agentDir, modelToWrite, normalizedBaseUrl, apiKey);
+        })
+      );
+    }
+
+    await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+
+    return NextResponse.json({
+      success: true,
+      message: "Open Claw settings applied successfully!",
+      settingsPath,
+    });
+  } catch (error) {
+    console.log("Error updating openclaw settings:", error);
+    return NextResponse.json({ error: "Failed to update openclaw settings" }, { status: 500 });
+  }
+}
+
+// DELETE - Remove 9Router settings only (keep other settings)
+export async function DELETE() {
+  try {
+    const settingsPath = getOpenClawSettingsPath();
+
+    // 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 from models.providers
+    if (settings.models && settings.models.providers) {
+      delete settings.models.providers["9router"];
+      
+      // Remove providers object if empty
+      if (Object.keys(settings.models.providers).length === 0) {
+        delete settings.models.providers;
+      }
+    }
+
+    // Remove 9router models from agents.defaults.models allowlist
+    if (settings.agents?.defaults?.models) {
+      const keysToRemove = Object.keys(settings.agents.defaults.models).filter((k) => k.startsWith("9router/"));
+      for (const key of keysToRemove) {
+        delete settings.agents.defaults.models[key];
+      }
+      if (Object.keys(settings.agents.defaults.models).length === 0) {
+        delete settings.agents.defaults.models;
+      }
+    }
+
+    // Reset agents.defaults.model.primary if it uses 9router
+    if (settings.agents?.defaults?.model?.primary?.startsWith("9router/")) {
+      delete settings.agents.defaults.model.primary;
+    }
+
+    // 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 openclaw settings:", error);
+    return NextResponse.json({ error: "Failed to reset openclaw settings" }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,259 @@
+"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 getConfigDir = () => path.join(os.homedir(), ".config", "opencode");
+const getConfigPath = () => path.join(getConfigDir(), "opencode.json");
+
+// Check if opencode CLI is installed (via which/where or config file exists)
+const checkOpenCodeInstalled = async () => {
+  try {
+    const isWindows = os.platform() === "win32";
+    const command = isWindows ? "where opencode" : "which opencode";
+    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(getConfigPath());
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+const readConfig = async () => {
+  try {
+    const content = await fs.readFile(getConfigPath(), "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+};
+
+const has9RouterConfig = (config) => {
+  if (!config?.provider) return false;
+  return !!config.provider["9router"];
+};
+
+// GET - Check opencode CLI and read current settings
+export async function GET() {
+  try {
+    const isInstalled = await checkOpenCodeInstalled();
+
+    if (!isInstalled) {
+      return NextResponse.json({
+        installed: false,
+        config: null,
+        message: "OpenCode CLI is not installed",
+      });
+    }
+
+    const config = await readConfig();
+    const providerConfig = config?.provider?.["9router"];
+    const modelMap = providerConfig?.models || {};
+
+    return NextResponse.json({
+      installed: true,
+      config,
+      has9Router: has9RouterConfig(config),
+      configPath: getConfigPath(),
+        opencode: {
+          models: Object.keys(modelMap),
+          activeModel: config?.model?.startsWith("9router/") ? config.model.replace(/^9router\//, "") : null,
+          baseURL: providerConfig?.options?.baseURL || null,
+        },
+    });
+  } catch (error) {
+    console.log("Error checking opencode settings:", error);
+    return NextResponse.json({ error: "Failed to check opencode settings" }, { status: 500 });
+  }
+}
+
+// POST - Apply 9Router as openai-compatible provider (multi-model support)
+export async function POST(request) {
+  try {
+    const { baseUrl, apiKey, model, models, activeModel, subagentModel } = await request.json();
+
+    // Accept either `model` (string, legacy) or `models` (array of strings)
+    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 configDir = getConfigDir();
+    const configPath = getConfigPath();
+
+    await fs.mkdir(configDir, { recursive: true });
+
+    // Read existing config or start fresh
+    let config = {};
+    try {
+      const existing = await fs.readFile(configPath, "utf-8");
+      config = JSON.parse(existing);
+    } catch { /* No existing config */ }
+
+    const normalizedBaseUrl = baseUrl.endsWith("/v1") ? baseUrl : `${baseUrl}/v1`;
+    const keyToUse = apiKey || "sk_9router";
+    const effectiveSubagentModel = subagentModel || modelsArray[0];
+
+    // Ensure provider object
+    if (!config.provider) config.provider = {};
+
+    // Preserve any existing 9router provider entry and its models
+    const existingProvider = config.provider["9router"] || { npm: "@ai-sdk/openai-compatible", options: {}, models: {} };
+
+    // Merge options (overwrite baseURL/apiKey)
+    existingProvider.options = {
+      ...existingProvider.options,
+      baseURL: normalizedBaseUrl,
+      apiKey: keyToUse,
+    };
+
+    // Ensure models map exists
+    existingProvider.models = existingProvider.models || {};
+
+    // Add or update entries for all requested models
+    for (const m of modelsArray) {
+      if (!m || typeof m !== "string") continue;
+      existingProvider.models[m] = { name: m, modalities: { input: ["text", "image"], output: ["text"] } };
+    }
+
+    // Save merged provider back
+    config.provider["9router"] = existingProvider;
+
+    // Set the active model: prefer explicit activeModel, else first of modelsArray
+    // If activeModel is explicitly empty string, clear the model
+    if (activeModel === "") {
+      config.model = "";
+    } else {
+      const finalActive = activeModel || modelsArray[0];
+      if (finalActive) {
+        config.model = `9router/${finalActive}`;
+      }
+    }
+
+    // Add subagent configuration
+    if (!config.agent) config.agent = {};
+    config.agent.explorer = {
+      description: "Fast explorer subagent for codebase exploration",
+      mode: "subagent",
+      model: `9router/${effectiveSubagentModel}`,
+    };
+
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+
+    return NextResponse.json({
+      success: true,
+      message: "OpenCode settings applied successfully!",
+      configPath,
+    });
+  } catch (error) {
+    console.log("Error applying opencode settings:", error);
+    return NextResponse.json({ error: "Failed to apply settings" }, { status: 500 });
+  }
+}
+
+// PATCH - Update specific settings (e.g., clear active model)
+export async function PATCH(request) {
+  try {
+    const { clearActiveModel } = await request.json();
+    const configPath = getConfigPath();
+
+    let config = {};
+    try {
+      const existing = await fs.readFile(configPath, "utf-8");
+      config = JSON.parse(existing);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return NextResponse.json({ success: true, message: "No config file found" });
+      }
+      throw error;
+    }
+
+    if (clearActiveModel === true) {
+      // Clear active model but keep models in the list
+      if (config.model?.startsWith("9router/")) {
+        config.model = "";
+      }
+    }
+
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+
+    return NextResponse.json({
+      success: true,
+      message: "Settings updated",
+    });
+  } catch (error) {
+    console.log("Error patching opencode settings:", error);
+    return NextResponse.json({ error: "Failed to patch settings" }, { status: 500 });
+  }
+}
+
+// DELETE - Remove 9Router provider or specific models from config
+export async function DELETE(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const modelToRemove = searchParams.get("model");
+    const configPath = getConfigPath();
+
+    let config = {};
+    try {
+      const existing = await fs.readFile(configPath, "utf-8");
+      config = JSON.parse(existing);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return NextResponse.json({ success: true, message: "No config file to reset" });
+      }
+      throw error;
+    }
+
+    // If specific model provided, remove just that model
+    if (modelToRemove && config.provider?.["9router"]?.models) {
+      delete config.provider["9router"].models[modelToRemove];
+      
+      // If no models left, remove the provider
+      if (Object.keys(config.provider["9router"].models).length === 0) {
+        delete config.provider["9router"];
+        if (config.model?.startsWith("9router/")) delete config.model;
+      } else if (config.model === `9router/${modelToRemove}`) {
+        // If removed model was active, switch to first remaining model
+        const remainingModels = Object.keys(config.provider["9router"].models);
+        config.model = `9router/${remainingModels[0]}`;
+      }
+    } else {
+      // No specific model - remove entire 9router provider
+      if (config.provider) delete config.provider["9router"];
+      if (config.model?.startsWith("9router/")) delete config.model;
+    }
+
+    // Remove subagent configuration
+    if (config.agent?.explorer?.model?.startsWith("9router/")) {
+      delete config.agent.explorer;
+      // Clean up empty agent object
+      if (Object.keys(config.agent).length === 0) delete config.agent;
+    }
+
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+
+    return NextResponse.json({
+      success: true,
+      message: modelToRemove ? `Model "${modelToRemove}" removed` : "9Router settings removed from OpenCode",
+    });
+  } catch (error) {
+    console.log("Error resetting opencode settings:", error);
+    return NextResponse.json({ error: "Failed to reset opencode settings" }, { status: 500 });
+  }
+}