swayrouter 1.0.0

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

@@ -0,0 +1,220 @@
+"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 { parseTOML, stringifyTOML } from "confbox";
+
+const execAsync = promisify(exec);
+
+const getCodexDir = () => path.join(os.homedir(), ".codex");
+const getCodexConfigPath = () => path.join(getCodexDir(), "config.toml");
+const getCodexAuthPath = () => path.join(getCodexDir(), "auth.json");
+
+const parsedToWritable = (obj) => obj ?? {};
+
+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 checkCodexInstalled = async () => {
+  try {
+    const isWindows = os.platform() === "win32";
+    const command = isWindows ? "where codex" : "which codex";
+    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(getCodexConfigPath());
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+const readConfig = async () => {
+  try {
+    const configPath = getCodexConfigPath();
+    const content = await fs.readFile(configPath, "utf-8");
+    return content;
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+};
+
+const hasSwayRouterConfig = (config) => {
+  if (!config) return false;
+  return config.includes("model_provider = \"swayrouter\"") || config.includes("[model_providers.swayrouter]");
+};
+
+export async function GET() {
+  try {
+    const isInstalled = await checkCodexInstalled();
+
+    if (!isInstalled) {
+      return NextResponse.json({
+        installed: false,
+        config: null,
+        message: "Codex CLI is not installed",
+      });
+    }
+
+    const config = await readConfig();
+
+    return NextResponse.json({
+      installed: true,
+      config,
+      hasSwayRouter: hasSwayRouterConfig(config),
+      configPath: getCodexConfigPath(),
+    });
+  } catch (error) {
+    console.log("Error checking codex settings:", error);
+    return NextResponse.json({ error: "Failed to check codex settings" }, { status: 500 });
+  }
+}
+
+export async function POST(request) {
+  try {
+    const { baseUrl, apiKey, model, subagentModel } = await request.json();
+
+    if (!baseUrl) {
+      return NextResponse.json({ error: "baseUrl is required" }, { status: 400 });
+    }
+
+    const codexDir = getCodexDir();
+    const configPath = getCodexConfigPath();
+
+    await fs.mkdir(codexDir, { recursive: true });
+
+    let parsed = {};
+    try {
+      const existingConfig = await fs.readFile(configPath, "utf-8");
+      parsed = parsedToWritable(parseTOML(existingConfig));
+    } catch {                          }
+
+    if (model) {
+      parsed.model = model;
+      parsed.model_provider = "swayrouter";
+    }
+
+    const normalizedBaseUrl = baseUrl.endsWith("/v1") ? baseUrl : `${baseUrl}/v1`;
+    setNestedSection(parsed, "model_providers.swayrouter", {
+      name: "Sway Router",
+      base_url: normalizedBaseUrl,
+      wire_api: "responses",
+    });
+
+    if (subagentModel) {
+      setNestedSection(parsed, "agents.subagent", { model: subagentModel });
+    } else if (model && parsed.agents?.subagent?.model === undefined) {
+      setNestedSection(parsed, "agents.subagent", { model });
+    } else if (!model && parsed.agents?.subagent?.model === "") {
+      deleteNestedSection(parsed, "agents.subagent");
+    }
+
+    const configContent = stringifyTOML(parsed);
+    await fs.writeFile(configPath, configContent);
+
+    const authPath = getCodexAuthPath();
+    let authData = {};
+    try {
+      const existingAuth = await fs.readFile(authPath, "utf-8");
+      authData = JSON.parse(existingAuth);
+    } catch {                        }
+
+    if (apiKey) {
+      authData.OPENAI_API_KEY = apiKey;
+      authData.auth_mode = "apikey";
+      await fs.writeFile(authPath, JSON.stringify(authData, null, 2));
+    }
+
+    return NextResponse.json({
+      success: true,
+      message: "Codex settings applied successfully!",
+      configPath,
+    });
+  } catch (error) {
+    console.log("Error updating codex settings:", error);
+    return NextResponse.json({ error: "Failed to update codex settings" }, { status: 500 });
+  }
+}
+
+export async function DELETE() {
+  try {
+    const configPath = getCodexConfigPath();
+
+    let parsed = {};
+    try {
+      const existingConfig = await fs.readFile(configPath, "utf-8");
+      parsed = parsedToWritable(parseTOML(existingConfig));
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return NextResponse.json({
+          success: true,
+          message: "No config file to reset",
+        });
+      }
+      throw error;
+    }
+
+    if (parsed.model_provider === "swayrouter") {
+      delete parsed.model;
+      delete parsed.model_provider;
+    }
+
+    deleteNestedSection(parsed, "model_providers.swayrouter");
+
+    deleteNestedSection(parsed, "agents.subagent");
+
+    const configContent = stringifyTOML(parsed);
+    await fs.writeFile(configPath, configContent);
+
+    const authPath = getCodexAuthPath();
+    try {
+      const existingAuth = await fs.readFile(authPath, "utf-8");
+      const authData = JSON.parse(existingAuth);
+      delete authData.OPENAI_API_KEY;
+      delete authData.auth_mode;
+
+      if (Object.keys(authData).length === 0) {
+        await fs.unlink(authPath);
+      } else {
+        await fs.writeFile(authPath, JSON.stringify(authData, null, 2));
+      }
+    } catch {                    }
+
+    return NextResponse.json({
+      success: true,
+      message: "Sway Router settings removed successfully",
+    });
+  } catch (error) {
+    console.log("Error resetting codex settings:", error);
+    return NextResponse.json({ error: "Failed to reset codex settings" }, { status: 500 });
+  }
+}

package/src/routes/api/cli-tools/cowork-mcp-registry/route.js

@@ -0,0 +1,80 @@
+"use server";
+
+import { NextResponse } from "next/server";
+import { logRouteError, publicError } from "@/lib/errors/publicError";
+
+const REGISTRY_ERROR = publicError("provider", "Unable to load MCP registry");
+
+const REGISTRY_URL = "https://api.anthropic.com/mcp-registry/v0/servers";
+const VISIBILITY = "commercial,gsuite,gsuite-google";
+const CACHE_TTL_MS = 60 * 60 * 1000;
+const G_KEY = "__swayrouterCoworkMcpRegistryCache";
+
+function gcache() {
+  if (!globalThis[G_KEY]) globalThis[G_KEY] = { ts: 0, data: null };
+  return globalThis[G_KEY];
+}
+
+function isDirectConnect(url) {
+  if (!url || typeof url !== "string") return false;
+  if (/^https?:\/\/[^/]*\bmcp\.claude\.com\b/i.test(url)) return false;
+  if (/^https?:\/\/api\.anthropic\.com\/mcp\b/i.test(url)) return false;
+  if (/[<{]/.test(url)) return false;
+  return /^https:\/\//i.test(url);
+}
+
+async function fetchAll() {
+  const out = [];
+  let cursor = "";
+  for (let i = 0; i < 20; i++) {
+    const url = `${REGISTRY_URL}?limit=500&visibility=${VISIBILITY}${cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""}`;
+    const r = await fetch(url, { headers: { accept: "application/json" } });
+    if (!r.ok) break;
+    const j = await r.json();
+    for (const item of j.servers || []) {
+      const s = item.server || {};
+      const meta = item._meta?.["com.anthropic.api/mcp-registry"] || {};
+      const remote = (s.remotes || [])[0];
+      if (!remote?.url || !isDirectConnect(remote.url)) continue;
+      if (meta.requiredFields?.length) continue;
+      const transport = remote.type === "sse" ? "sse" : "http";
+      const toolNames = Array.isArray(meta.toolNames) ? meta.toolNames : [];
+      out.push({
+        name: s.name,
+        slug: meta.slug || s.name,
+        title: s.title || meta.displayName || s.name,
+        description: s.description || meta.oneLiner || "",
+        url: remote.url,
+        transport,
+        oauth: !meta.isAuthless,
+        toolNames,
+        toolCount: toolNames.length,
+        iconUrl: meta.iconUrl || null,
+      });
+    }
+    cursor = j.metadata?.nextCursor;
+    if (!cursor) break;
+  }
+
+  const seen = new Set();
+  return out.filter((s) => (seen.has(s.url) ? false : (seen.add(s.url), true)));
+}
+
+export async function GET(request) {
+  const { searchParams } = new URL(request.url);
+  const force = searchParams.get("refresh") === "1";
+  const cache = gcache();
+  if (!force && cache.data && Date.now() - cache.ts < CACHE_TTL_MS) {
+    return NextResponse.json({ cached: true, ...cache.data });
+  }
+  try {
+    const servers = await fetchAll();
+    const data = { servers, total: servers.length };
+    cache.ts = Date.now();
+    cache.data = data;
+    return NextResponse.json({ cached: false, ...data });
+  } catch (e) {
+    logRouteError("CoworkMcpRegistry", e);
+    return NextResponse.json({ error: REGISTRY_ERROR, servers: [], total: 0 }, { status: 500 });
+  }
+}

package/src/routes/api/cli-tools/cowork-mcp-tools/route.js

@@ -0,0 +1,96 @@
+"use server";
+
+import { NextResponse } from "next/server";
+import { logRouteError, publicError } from "@/lib/errors/publicError";
+
+const MCP_TOOLS_ERROR = publicError("provider", "Unable to load MCP tools");
+
+const TIMEOUT_MS = 8000;
+
+async function probeMcp(url) {
+  const headers = {
+    "Content-Type": "application/json",
+    "Accept": "application/json, text/event-stream",
+    "MCP-Protocol-Version": "2025-06-18",
+  };
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), TIMEOUT_MS);
+  try {
+
+    const initRes = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        jsonrpc: "2.0", id: 1, method: "initialize",
+        params: { protocolVersion: "2025-06-18", capabilities: {}, clientInfo: { name: "swayrouter", version: "1" } },
+      }),
+      signal: ac.signal,
+    });
+    if (initRes.status === 401 || initRes.status === 403) {
+      return { requiresAuth: true, tools: [] };
+    }
+    if (!initRes.ok) {
+      return { error: `init ${initRes.status}`, tools: [] };
+    }
+    const sessionId = initRes.headers.get("mcp-session-id") || "";
+    await initRes.text().catch(() => {});
+
+    const listHeaders = { ...headers };
+    if (sessionId) listHeaders["mcp-session-id"] = sessionId;
+
+    await fetch(url, {
+      method: "POST",
+      headers: listHeaders,
+      body: JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized", params: {} }),
+      signal: ac.signal,
+    }).catch(() => {});
+
+    const listRes = await fetch(url, {
+      method: "POST",
+      headers: listHeaders,
+      body: JSON.stringify({ jsonrpc: "2.0", id: 2, method: "tools/list" }),
+      signal: ac.signal,
+    });
+    if (listRes.status === 401 || listRes.status === 403) {
+      return { requiresAuth: true, tools: [] };
+    }
+    const ct = listRes.headers.get("content-type") || "";
+    let parsed;
+    if (ct.includes("text/event-stream")) {
+
+      const text = await listRes.text();
+      const dataLines = text.split("\n").filter((l) => l.startsWith("data:"));
+      for (const line of dataLines) {
+        try {
+          const obj = JSON.parse(line.replace(/^data:\s*/, ""));
+          if (obj?.id === 2 && obj.result) { parsed = obj; break; }
+        } catch {            }
+      }
+    } else {
+      parsed = await listRes.json().catch(() => null);
+    }
+    const tools = parsed?.result?.tools || [];
+    return {
+      tools: tools.map((t) => ({ name: t.name, description: t.description || "" })),
+    };
+  } catch (e) {
+    logRouteError("CoworkMcpToolsProbe", e);
+    return { error: e.name === "AbortError" ? "timeout" : MCP_TOOLS_ERROR, tools: [] };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function POST(request) {
+  try {
+    const { url } = await request.json();
+    if (!url || typeof url !== "string") {
+      return NextResponse.json({ error: "url required" }, { status: 400 });
+    }
+    const result = await probeMcp(url);
+    return NextResponse.json(result);
+  } catch (e) {
+    logRouteError("CoworkMcpTools", e);
+    return NextResponse.json({ error: MCP_TOOLS_ERROR, tools: [] }, { status: 500 });
+  }
+}