swayrouter 1.0.0

package/src/routes/api/chat/tools/shell/route.js

@@ -0,0 +1,228 @@
+"use server";
+
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { NextResponse } from "@/next/server";
+
+const execFileAsync = promisify(execFile);
+const WORKSPACE_ROOT = path.resolve(process.env.SWAY_CHAT_WORKSPACE || process.cwd());
+const MAX_COMMAND_LENGTH = 500;
+const MAX_OUTPUT_LENGTH = 24_000;
+const MAX_FILE_LENGTH = 64_000;
+const COMMAND_TIMEOUT_MS = 8_000;
+const MAX_CODE_LENGTH = 6_000;
+const CODE_TIMEOUT_MS = 10_000;
+
+class ToolInputError extends Error {}
+
+function tokenize(command) {
+  if (typeof command !== "string" || !command.trim()) throw new ToolInputError("Command is required");
+  if (command.length > MAX_COMMAND_LENGTH) throw new ToolInputError(`Command must be ${MAX_COMMAND_LENGTH} characters or fewer`);
+
+  if (/[;&|<>`$()\\]/.test(command)) throw new ToolInputError("Shell operators, substitutions, and backslashes are not supported");
+
+  const tokens = [];
+  let token = "";
+  let quote = "";
+  for (const char of command.trim()) {
+    if (quote) {
+      if (char === quote) quote = "";
+      else token += char;
+    } else if (char === "\"" || char === "'") {
+      quote = char;
+    } else if (/\s/.test(char)) {
+      if (token) { tokens.push(token); token = ""; }
+    } else {
+      token += char;
+    }
+  }
+  if (quote) throw new ToolInputError("Unclosed quote in command");
+  if (token) tokens.push(token);
+  if (!tokens.length) throw new ToolInputError("Command is required");
+  return tokens;
+}
+
+function resolveWorkspacePath(input = ".") {
+  const requested = typeof input === "string" && input.trim() ? input.trim() : ".";
+  const resolved = path.resolve(WORKSPACE_ROOT, requested);
+  const relative = path.relative(WORKSPACE_ROOT, resolved);
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    throw new ToolInputError("Path must stay inside the local workspace");
+  }
+  return resolved;
+}
+
+function isSensitivePath(input) {
+  const normalized = input.replaceAll("\\", "/");
+  return normalized.split("/").some((part) =>
+    /^\.env(?:\.|$)/i.test(part) ||
+    /\.(?:pem|key|p12|pfx)$/i.test(part) ||
+    /^id_(?:rsa|ecdsa|ed25519)$/i.test(part),
+  );
+}
+
+function outputResult(command, output, extra = {}) {
+  const value = String(output || "").trimEnd();
+  return {
+    ok: true,
+    command,
+    cwd: ".",
+    output: value ? value.slice(0, MAX_OUTPUT_LENGTH) : "(no output)",
+    ...(value.length > MAX_OUTPUT_LENGTH ? { truncated: true } : {}),
+    ...extra,
+  };
+}
+
+async function listDirectory(command, args) {
+  const options = args.filter((arg) => arg.startsWith("-"));
+  if (options.some((option) => !/^-{1,2}[al]+$/.test(option))) throw new ToolInputError("Only basic ls/dir display flags are supported");
+  const locations = args.filter((arg) => !arg.startsWith("-"));
+  if (locations.length > 1) throw new ToolInputError("Only one directory may be listed at a time");
+  const location = locations[0] || ".";
+  const target = resolveWorkspacePath(location);
+  const entries = await fs.readdir(target, { withFileTypes: true });
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  const output = entries.map((entry) => `${entry.isDirectory() ? "d" : "f"} ${entry.name}`).join("\n");
+  return outputResult(command, output);
+}
+
+async function readFile(command, args) {
+  if (args.length !== 1) throw new ToolInputError("cat/type accepts exactly one workspace file");
+  if (isSensitivePath(args[0])) throw new ToolInputError("Reading credential files is not allowed");
+  const target = resolveWorkspacePath(args[0]);
+  const stat = await fs.stat(target);
+  if (!stat.isFile()) throw new ToolInputError("The requested path is not a file");
+  if (stat.size > MAX_FILE_LENGTH) throw new ToolInputError(`Files larger than ${MAX_FILE_LENGTH} bytes are not returned`);
+  return outputResult(command, await fs.readFile(target, "utf8"));
+}
+
+async function searchFiles(command, args) {
+  if (!args.length || args[0].startsWith("-")) throw new ToolInputError("rg requires a search pattern");
+  const pattern = args[0];
+  const locations = args.slice(1);
+  if (locations.length > 8 || locations.some((location) => location.startsWith("-"))) {
+    throw new ToolInputError("rg accepts at most eight workspace paths and no flags");
+  }
+  const safeLocations = locations.map((location) => {
+    if (isSensitivePath(location)) throw new ToolInputError("Searching credential paths is not allowed");
+    const resolved = resolveWorkspacePath(location);
+    return path.relative(WORKSPACE_ROOT, resolved) || ".";
+  });
+  const rgArgs = [
+    "--no-config", "--no-heading", "--line-number", "--color", "never",
+    "--glob", "!.env*", "--glob", "!**/*.pem", "--glob", "!**/*.key", "--glob", "!**/id_rsa",
+    "--", pattern, ...safeLocations,
+  ];
+  try {
+    const { stdout, stderr } = await execFileAsync("rg", rgArgs, {
+      cwd: WORKSPACE_ROOT,
+      timeout: COMMAND_TIMEOUT_MS,
+      maxBuffer: MAX_OUTPUT_LENGTH * 2,
+      windowsHide: true,
+      env: { ...process.env, RIPGREP_CONFIG_PATH: "" },
+    });
+    return outputResult(command, [stdout, stderr].filter(Boolean).join("\n"));
+  } catch (error) {
+    if (error?.code === 1) return outputResult(command, "(no matches)");
+    throw new Error(error?.stderr?.trim() || error?.message || "Search failed");
+  }
+}
+
+function validateGitArgs(subcommand, args) {
+  const allow = {
+    status: new Set(["--short", "--porcelain", "--branch"]),
+    diff: new Set(["--stat", "--name-only", "--name-status", "--cached"]),
+    log: new Set(["--oneline", "--decorate", "--all"]),
+    show: new Set(["--stat", "--name-only"]),
+    branch: new Set(["--show-current", "--list"]),
+  };
+  if (!allow[subcommand]) throw new ToolInputError("Only read-only git status/diff/log/show/branch are supported");
+  for (const arg of args) {
+    if (allow[subcommand].has(arg)) continue;
+    if (subcommand === "show" && /^(?:HEAD(?:~\d+)?|[0-9a-f]{7,40})$/i.test(arg)) continue;
+    throw new ToolInputError(`Unsupported git ${subcommand} argument: ${arg}`);
+  }
+}
+
+async function readGit(command, args) {
+  const subcommand = args.shift();
+  if (!subcommand) throw new ToolInputError("git requires a read-only subcommand");
+  validateGitArgs(subcommand, args);
+  const gitArgs = ["--no-pager", subcommand, ...(subcommand === "diff" ? ["--no-ext-diff"] : []), ...args];
+  const { stdout, stderr } = await execFileAsync("git", gitArgs, {
+    cwd: WORKSPACE_ROOT,
+    timeout: COMMAND_TIMEOUT_MS,
+    maxBuffer: MAX_OUTPUT_LENGTH * 2,
+    windowsHide: true,
+    env: { ...process.env, GIT_PAGER: "cat", GIT_TERMINAL_PROMPT: "0" },
+  });
+  return outputResult(command, [stdout, stderr].filter(Boolean).join("\n"));
+}
+
+async function runReadOnlyCommand(command) {
+  const tokens = tokenize(command);
+  const executable = tokens[0].toLowerCase();
+  const args = tokens.slice(1);
+  if (executable === "pwd") {
+    if (args.length) throw new ToolInputError("pwd does not accept arguments");
+    return outputResult(command, ".");
+  }
+  if (executable === "ls" || executable === "dir") return listDirectory(command, args);
+  if (executable === "cat" || executable === "type") return readFile(command, args);
+  if (executable === "rg") return searchFiles(command, args);
+  if (executable === "git") return readGit(command, args);
+  throw new ToolInputError("Only pwd, ls/dir, cat/type, rg, and read-only git commands are supported");
+}
+
+async function runApprovedJavaScript(code) {
+  if (typeof code !== "string" || !code.trim()) throw new ToolInputError("JavaScript code is required");
+  if (code.length > MAX_CODE_LENGTH) throw new ToolInputError(`JavaScript code must be ${MAX_CODE_LENGTH} characters or fewer`);
+
+  const safeEnv = {
+    PATH: process.env.PATH || process.env.Path || "",
+    Path: process.env.Path || process.env.PATH || "",
+    SystemRoot: process.env.SystemRoot || "",
+    TEMP: process.env.TEMP || "",
+    TMP: process.env.TMP || "",
+    NODE_ENV: process.env.NODE_ENV || "production",
+  };
+  try {
+    const { stdout, stderr } = await execFileAsync(process.execPath, ["--eval", code], {
+      cwd: WORKSPACE_ROOT,
+      timeout: CODE_TIMEOUT_MS,
+      maxBuffer: MAX_OUTPUT_LENGTH * 2,
+      windowsHide: true,
+      env: safeEnv,
+    });
+    return outputResult("javascript", [stdout, stderr].filter(Boolean).join("\n"), { runtime: "javascript" });
+  } catch (error) {
+    const message = error?.killed || error?.signal === "SIGTERM"
+      ? "JavaScript execution timed out"
+      : (error?.stderr?.trim() || error?.message || "JavaScript execution failed");
+    throw new Error(message);
+  }
+}
+
+export async function POST(request) {
+  try {
+    const body = await request.json().catch(() => ({}));
+    if (body?.mode === "execute") {
+      if (body.approved !== true) {
+        return NextResponse.json({
+          ok: false,
+          requiresApproval: true,
+          action: "execute_javascript",
+          warning: "This runs JavaScript in the local Sway Router workspace.",
+        }, { status: 409 });
+      }
+      return NextResponse.json(await runApprovedJavaScript(body.code));
+    }
+    const result = await runReadOnlyCommand(body?.command);
+    return NextResponse.json(result);
+  } catch (error) {
+    const status = error instanceof ToolInputError ? 400 : 422;
+    return NextResponse.json({ ok: false, error: error instanceof Error ? error.message : "Shell tool failed" }, { status });
+  }
+}

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

@@ -0,0 +1,37 @@
+"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 hermesGet } from "../hermes-settings/route";
+import { GET as coworkGet } from "../cowork-settings/route";
+import { GET as kiloGet } from "../kilo-settings/route";
+import { GET as grokBuildGet } from "../grok-build-settings/route";
+import { GET as ompGet } from "../omp-settings/route";
+
+const STATUS_GETTERS = {
+  claude: claudeGet,
+  codex: codexGet,
+  opencode: opencodeGet,
+  hermes: hermesGet,
+  cowork: coworkGet,
+  kilo: kiloGet,
+  "grok-build": grokBuildGet,
+  omp: ompGet,
+};
+
+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/routes/api/cli-tools/claude-settings/route.js

@@ -0,0 +1,261 @@
+"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 { DEFAULT_PLUGINS } from "@/shared/constants/coworkPlugins";
+
+const execAsync = promisify(exec);
+
+const EXA_PLUGIN = DEFAULT_PLUGINS.find((p) => p.name === "exa");
+const buildExaMcpEntry = () => ({
+  type: EXA_PLUGIN.transport,
+  url: EXA_PLUGIN.url,
+});
+
+const getClaudeSettingsPath = () => {
+  const homeDir = os.homedir();
+  return path.join(homeDir, ".claude", "settings.json");
+};
+
+const getClaudeJsonPath = () => path.join(os.homedir(), ".claude.json");
+
+const readClaudeJson = async () => {
+  try {
+    const content = await fs.readFile(getClaudeJsonPath(), "utf-8");
+    return JSON.parse(content.replace(/,(\s*[}\]])/g, "$1"));
+  } catch {
+    return null;
+  }
+};
+
+const writeClaudeJsonMcp = async (mcpServers) => {
+  const filePath = getClaudeJsonPath();
+  let data = {};
+  try {
+    data = JSON.parse(await fs.readFile(filePath, "utf-8"));
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  if (mcpServers && Object.keys(mcpServers).length > 0) {
+    data.mcpServers = { ...(data.mcpServers || {}), ...mcpServers };
+  } else if (data.mcpServers) {
+    delete data.mcpServers.exa;
+    if (Object.keys(data.mcpServers).length === 0) delete data.mcpServers;
+  }
+  await fs.writeFile(filePath, JSON.stringify(data, null, 2));
+};
+
+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;
+    }
+  }
+};
+
+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;
+  }
+}
+
+function hasSwayRouterFromSettings(settings) {
+  return isSwayRouterBaseUrl(settings?.env?.ANTHROPIC_BASE_URL);
+}
+
+const readSettings = async () => {
+  try {
+    const settingsPath = getClaudeSettingsPath();
+    const content = await fs.readFile(settingsPath, "utf-8");
+
+    const stripped = content.replace(/,(\s*[}\]])/g, "$1");
+    return JSON.parse(stripped);
+  } catch (error) {
+    return null;
+  }
+};
+
+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 hasSwayRouter = hasSwayRouterFromSettings(settings);
+    const claudeJson = await readClaudeJson();
+
+    return NextResponse.json({
+      installed: true,
+      settings: settings,
+      hasSwayRouter,
+      exaMcpEnabled: !!claudeJson?.mcpServers?.exa,
+      settingsPath: getClaudeSettingsPath(),
+    });
+  } catch (error) {
+    console.log("Error checking claude settings:", error);
+    return NextResponse.json(
+      { error: "Failed to check claude settings" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(request) {
+  try {
+    const { env, exaMcpEnabled, maxContextTokens } = 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);
+
+    await fs.mkdir(claudeDir, { recursive: true });
+
+    let currentSettings = {};
+    try {
+      const content = await fs.readFile(settingsPath, "utf-8");
+      currentSettings = JSON.parse(content);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+
+    if (env.ANTHROPIC_BASE_URL) {
+      env.ANTHROPIC_BASE_URL = env.ANTHROPIC_BASE_URL.endsWith("/v1")
+        ? env.ANTHROPIC_BASE_URL
+        : `${env.ANTHROPIC_BASE_URL}/v1`;
+    }
+
+    const newSettings = {
+      ...currentSettings,
+      hasCompletedOnboarding: true,
+      env: {
+        ...(currentSettings.env || {}),
+        ...env,
+      },
+    };
+
+    if (maxContextTokens) {
+      newSettings.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS = String(maxContextTokens);
+    } else {
+      delete newSettings.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS;
+    }
+
+    await fs.writeFile(settingsPath, JSON.stringify(newSettings, null, 2));
+
+    if (EXA_PLUGIN) {
+      const shouldEnableExa = exaMcpEnabled !== false;
+      await writeClaudeJsonMcp(shouldEnableExa ? { exa: buildExaMcpEntry() } : null);
+    }
+
+    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 }
+    );
+  }
+}
+
+const RESET_ENV_KEYS = [
+  "ANTHROPIC_BASE_URL",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_DEFAULT_FABLE_MODEL",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+  "API_TIMEOUT_MS",
+  "CLAUDE_CODE_MAX_CONTEXT_TOKENS",
+];
+
+export async function DELETE() {
+  try {
+    const settingsPath = getClaudeSettingsPath();
+
+    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;
+    }
+
+    if (currentSettings.env) {
+      RESET_ENV_KEYS.forEach((key) => {
+        delete currentSettings.env[key];
+      });
+
+      if (Object.keys(currentSettings.env).length === 0) {
+        delete currentSettings.env;
+      }
+    }
+
+    await writeClaudeJsonMcp(null);
+
+    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 }
+    );
+  }
+}