swayrouter 1.0.0

package/src/routes/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");
+
+    const stripped = content.replace(/,(\s*[}\]])/g, "$1");
+    return JSON.parse(stripped);
+  } catch (error) {
+    return null;
+  }
+};
+
+const hasSwayRouterConfig = (auth) => {
+  if (!auth) return false;
+  const entry = auth["openai-compatible"] || auth["swayrouter"];
+  if (!entry) return false;
+  const baseUrl = entry.baseUrl || entry.baseURL || "";
+  return baseUrl.includes("localhost") || baseUrl.includes("127.0.0.1") || baseUrl.includes("swayrouter");
+};
+
+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) : [] },
+      hasSwayRouter: hasSwayRouterConfig(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));
+
+    try {
+      const vscode = (await readJson(getVscodeSettingsPath())) || {};
+      vscode["kilocode.customProvider"] = { name: "Sway Router", baseURL: normalizedBaseUrl, apiKey };
+      vscode["kilocode.defaultModel"] = model;
+      await fs.writeFile(getVscodeSettingsPath(), JSON.stringify(vscode, null, 2));
+    } catch {                                     }
+
+    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["swayrouter"];
+    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 {              }
+
+    return NextResponse.json({ success: true, message: "Sway Router 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/routes/api/cli-tools/model-mappings/route.js

@@ -0,0 +1,43 @@
+import { NextResponse } from "next/server";
+import { getSettings, updateSettings } from "@/lib/localDb";
+
+const TOOL_ID = /^[a-z0-9_-]{1,64}$/i;
+
+function sanitize(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const out = {};
+  for (const [toolId, snapshot] of Object.entries(value)) {
+    if (!TOOL_ID.test(toolId) || !snapshot || typeof snapshot !== "object") continue;
+    const entries = Array.isArray(snapshot.entries) ? snapshot.entries.map((entry) => ({
+      sourceModel: typeof entry?.sourceModel === "string" ? entry.sourceModel.trim().slice(0, 512) : "",
+      targetModel: typeof entry?.targetModel === "string" ? entry.targetModel.trim().slice(0, 512) : "",
+      enabled: entry?.enabled !== false,
+    })).filter((entry) => entry.sourceModel && entry.targetModel).slice(0, 256) : [];
+    out[toolId] = { enabled: snapshot.enabled !== false, entries };
+  }
+  return out;
+}
+
+export async function GET() {
+  const settings = await getSettings();
+  return NextResponse.json({ mappings: settings.cliModelMappings || {} });
+}
+
+export async function PUT(request) {
+  try {
+    const body = await request.json();
+    const mappings = sanitize(body?.mappings);
+    await updateSettings({ cliModelMappings: mappings });
+    return NextResponse.json({ mappings });
+  } catch {
+    return NextResponse.json({ error: "Invalid model mappings" }, { status: 400 });
+  }
+}
+
+export async function DELETE() {
+  await updateSettings({ cliModelMappings: {} });
+  return NextResponse.json({ mappings: {} });
+}
+
+export const dynamic = "force-dynamic";
+export const revalidate = 0;

package/src/routes/api/cli-tools/omp-settings/route.js

@@ -0,0 +1,266 @@
+"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";
+import { parseYAML, stringifyYAML } from "confbox";
+
+const execAsync = promisify(exec);
+
+const getOmpDir = () => path.join(os.homedir(), ".omp", "agent");
+const getModelsPath = () => path.join(getOmpDir(), "models.yml");
+const getOmpBinPath = () => path.join(os.homedir(), ".bun", "bin", "omp.exe");
+
+const SWAY_ROUTER_MATCH_HOSTS = [
+  "127.0.0.1:14045",
+  "localhost:14045",
+  "localhost",
+  "127.0.0.1",
+];
+const SWAY_ROUTER_URL_HOST_RE = /^(?:127\.0\.0\.1|localhost)(?::14045)?$/;
+
+function isSwayRouterBaseUrl(baseUrl) {
+  if (typeof baseUrl !== "string" || !baseUrl) return false;
+  try {
+    const u = new URL(baseUrl);
+    return (
+      u.pathname.endsWith("/v1") &&
+      (SWAY_ROUTER_URL_HOST_RE.test(u.host) || SWAY_ROUTER_MATCH_HOSTS.includes(u.host))
+    );
+  } catch {
+    return false;
+  }
+}
+
+const setNestedSection = (obj, dottedKey, value) => {
+  const keys = dottedKey.split(".");
+  let cur = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    if (cur[keys[i]] == null || typeof cur[keys[i]] !== "object") {
+      cur[keys[i]] = {};
+    }
+    cur = cur[keys[i]];
+  }
+  cur[keys[keys.length - 1]] = value;
+};
+
+const deleteNestedSection = (obj, dottedKey) => {
+  const keys = dottedKey.split(".");
+  let cur = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    cur = cur?.[keys[i]];
+    if (cur == null) return;
+  }
+  delete cur[keys[keys.length - 1]];
+};
+
+const checkOmpInstalled = async () => {
+  try {
+    await fs.access(getOmpBinPath());
+    return true;
+  } catch {
+    try {
+      const isWindows = os.platform() === "win32";
+      const command = isWindows ? "where omp" : "which omp";
+      await execAsync(command, { windowsHide: true });
+      return true;
+    } catch {
+      try {
+        await fs.access(getModelsPath());
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  }
+};
+
+const readModels = async () => {
+  try {
+    const content = await fs.readFile(getModelsPath(), "utf-8");
+    const parsed = parseYAML(content);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+};
+
+let cachedVersion;
+
+const getOmpVersion = async () => {
+  if (cachedVersion !== undefined) return cachedVersion;
+  cachedVersion = null;
+  try {
+    const { stdout } = await execAsync("omp --version", { windowsHide: true });
+    cachedVersion = String(stdout).trim().split("\n")[0] || null;
+  } catch {
+    cachedVersion = null;
+  }
+  return cachedVersion;
+};
+
+const providerPointsAtRouter = (provider) => {
+  if (!provider || typeof provider !== "object") return false;
+  return isSwayRouterBaseUrl(provider.baseUrl);
+};
+
+const isFromCloudflare = (req) =>
+  req.headers.get("cf-connecting-ip") !== null ||
+  (req.headers.get("cf-ray") ?? "").length > 0;
+
+const hasFamilyIpHeader = (req) => {
+  try {
+    const fwd = req.headers.get("x-forwarded-for") || "";
+    const rightmost = fwd.split(",").pop().trim();
+    if (ipHeaderIsIp(rightmost)) return true;
+    const realIp = req.headers.get("x-real-ip") || "";
+    return ipHeaderIsIp(realIp);
+  } catch {
+    return false;
+  }
+};
+
+const ipHeaderIsIp = (value) =>
+  /^\d+\.\d+\.\d+\.\d+$/.test(value) || /^[0-9a-f:]+$/i.test(value);
+
+const isLocalRequest = (request) => {
+  if (isFromCloudflare(request) || hasFamilyIpHeader(request)) return false;
+  const url = request.headers.get("host") || "";
+  const host = url.split(":").shift().toLowerCase();
+  return host === "localhost" || host === "127.0.0.1" || host === "";
+};
+
+export async function GET(request) {
+  try {
+    const installed = await checkOmpInstalled();
+    const config = await readModels();
+    const version = await getOmpVersion();
+
+    if (!installed) {
+      return NextResponse.json({
+        installed: false,
+        config: null,
+        models: null,
+        version,
+        message: "OMP (oh-my-pi) is not installed",
+      });
+    }
+
+    const provider = config?.providers?.swayrouter ?? null;
+    const hasSwayRouter = providerPointsAtRouter(provider);
+
+    return NextResponse.json({
+      installed: true,
+      config: config ? stringifyYAML(config) : null,
+      hasSwayRouter,
+      connected: hasSwayRouter,
+      configPath: getModelsPath(),
+      version,
+    });
+  } catch (error) {
+    console.log("Error checking omp settings:", error);
+    return NextResponse.json({ error: "Failed to check omp settings" }, { status: 500 });
+  }
+}
+
+export async function POST(request, { params }) {
+  try {
+    const collection = await request.json();
+    const { baseUrl, apiKey, models } = collection || {};
+    const selectedModels = Array.isArray(models)
+      ? [...new Set(models.filter((value) => typeof value === "string" && value.trim()).map((value) => value.trim()))]
+      : [];
+    const configuredApiKey = typeof apiKey === "string" ? apiKey.trim() : "";
+
+    if (!isLocalRequest(request)) {
+      return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+    }
+
+    if (!baseUrl) {
+      return NextResponse.json({ error: "baseUrl is required" }, { status: 400 });
+    }
+
+    const ompDir = getOmpDir();
+    const modelsPath = getModelsPath();
+    await fs.mkdir(ompDir, { recursive: true });
+
+    let parsed = {};
+    try {
+      const existing = await readModels();
+      parsed = existing ?? {};
+    } catch {              }
+
+    const normalizedBaseUrl = baseUrl.includes("/v1")
+      ? baseUrl
+      : `${baseUrl.replace(/\/$/, "")}/v1`;
+
+    const provider = {
+      baseUrl: normalizedBaseUrl,
+      api: "openai-completions",
+      ...(configuredApiKey ? { apiKey: configuredApiKey } : { auth: "none" }),
+      discovery: { type: "openai-models-list" },
+      ...(selectedModels.length
+        ? {
+            models: selectedModels.map((id) => ({
+              id,
+              name: id,
+            })),
+          }
+        : {}),
+    };
+    setNestedSection(parsed, "providers.swayrouter", provider);
+
+    const content = stringifyYAML(parsed);
+    await fs.writeFile(modelsPath, content);
+
+    return NextResponse.json({
+      success: true,
+      message: "OMP settings applied successfully!",
+      configPath: modelsPath,
+    });
+  } catch (error) {
+    console.log("Error updating omp settings:", error);
+    return NextResponse.json({ error: "Failed to update omp settings" }, { status: 500 });
+  }
+}
+
+export async function DELETE(request) {
+  try {
+    const modelsPath = getModelsPath();
+
+    let parsed;
+    try {
+      parsed = await readModels();
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return NextResponse.json({ success: true, message: "No config file to reset" });
+      }
+      throw error;
+    }
+
+    if (!parsed || typeof parsed !== "object") {
+      return NextResponse.json({ success: true, message: "No config file to reset" });
+    }
+
+    deleteNestedSection(parsed, "providers.swayrouter");
+
+    if (parsed.providers && Object.keys(parsed.providers).length === 0) {
+      delete parsed.providers;
+    }
+
+    const content = stringifyYAML(parsed);
+    await fs.writeFile(modelsPath, content);
+
+    return NextResponse.json({
+      success: true,
+      message: "Sway Router settings removed successfully",
+    });
+  } catch (error) {
+    console.log("Error resetting omp settings:", error);
+    return NextResponse.json({ error: "Failed to reset omp settings" }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,243 @@
+"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");
+
+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");
+
+    const stripped = content.replace(/,(\s*[}\]])/g, "$1");
+    return JSON.parse(stripped);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+
+    return null;
+  }
+};
+
+const hasSwayRouterConfig = (config) => {
+  if (!config?.provider) return false;
+  return !!config.provider["swayrouter"];
+};
+
+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?.["swayrouter"];
+    const modelMap = providerConfig?.models || {};
+
+    return NextResponse.json({
+      installed: true,
+      config,
+      hasSwayRouter: hasSwayRouterConfig(config),
+      configPath: getConfigPath(),
+        opencode: {
+          models: Object.keys(modelMap),
+          activeModel: config?.model?.startsWith("swayrouter/") ? config.model.replace(/^swayrouter\//, "") : 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 });
+  }
+}
+
+export async function POST(request) {
+  try {
+    const { baseUrl, apiKey, model, models, activeModel, subagentModel } = await request.json();
+
+    const modelsArray = Array.isArray(models) ? models.slice() : (typeof model === "string" ? [model] : []);
+
+    if (!baseUrl) {
+      return NextResponse.json({ error: "baseUrl is required" }, { status: 400 });
+    }
+
+    const configDir = getConfigDir();
+    const configPath = getConfigPath();
+
+    await fs.mkdir(configDir, { recursive: true });
+
+    let config = {};
+    try {
+      const existing = await fs.readFile(configPath, "utf-8");
+      config = JSON.parse(existing);
+    } catch {                          }
+
+    const normalizedBaseUrl = baseUrl.endsWith("/v1") ? baseUrl : `${baseUrl}/v1`;
+    const keyToUse = apiKey || "sk_swayrouter";
+    const effectiveSubagentModel = subagentModel || modelsArray[0];
+
+    if (!config.provider) config.provider = {};
+
+    const existingProvider = config.provider["swayrouter"] || { npm: "@ai-sdk/openai-compatible", options: {}, models: {} };
+
+    existingProvider.options = {
+      ...existingProvider.options,
+      baseURL: normalizedBaseUrl,
+      apiKey: keyToUse,
+    };
+    existingProvider.models = existingProvider.models || {};
+    for (const m of modelsArray) {
+      if (!m || typeof m !== "string") continue;
+      existingProvider.models[m] = { name: m, modalities: { input: ["text", "image"], output: ["text"] } };
+    }
+    config.provider["swayrouter"] = existingProvider;
+
+    const finalActive = activeModel || modelsArray[0];
+    if (activeModel === "") {
+      if (config.model?.startsWith("swayrouter/")) delete config.model;
+    } else if (finalActive) {
+      config.model = `swayrouter/${finalActive}`;
+    }
+
+    if (effectiveSubagentModel) {
+      if (!config.agent) config.agent = {};
+      config.agent.explorer = {
+        description: "Fast explorer subagent for codebase exploration",
+        mode: "subagent",
+        model: `swayrouter/${effectiveSubagentModel}`,
+      };
+    } else if (config.agent?.explorer?.model?.startsWith("swayrouter/")) {
+      delete config.agent.explorer;
+      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: "OpenCode settings applied successfully!",
+      configPath,
+    });
+  } catch (error) {
+    console.log("Error applying opencode settings:", error);
+    return NextResponse.json({ error: "Failed to apply settings" }, { status: 500 });
+  }
+}
+
+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) {
+
+      if (config.model?.startsWith("swayrouter/")) {
+        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 });
+  }
+}
+
+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 (modelToRemove && config.provider?.["swayrouter"]?.models) {
+      delete config.provider["swayrouter"].models[modelToRemove];
+
+      if (Object.keys(config.provider["swayrouter"].models).length === 0) {
+        delete config.provider["swayrouter"];
+        if (config.model?.startsWith("swayrouter/")) delete config.model;
+      } else if (config.model === `swayrouter/${modelToRemove}`) {
+
+        const remainingModels = Object.keys(config.provider["swayrouter"].models);
+        config.model = `swayrouter/${remainingModels[0]}`;
+      }
+    } else {
+
+      if (config.provider) delete config.provider["swayrouter"];
+      if (config.model?.startsWith("swayrouter/")) delete config.model;
+    }
+
+    if (config.agent?.explorer?.model?.startsWith("swayrouter/")) {
+      delete config.agent.explorer;
+
+      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` : "Sway Router settings removed from OpenCode",
+    });
+  } catch (error) {
+    console.log("Error resetting opencode settings:", error);
+    return NextResponse.json({ error: "Failed to reset opencode settings" }, { status: 500 });
+  }
+}