switchboard-router 0.6.3 → 0.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchboard-router",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "Switchboard CLI — local AI routing gateway (install: npm i -g switchboard-router; run: switchboard)",
   "bin": {
     "switchboard": "./cli.js"

package/src/cli/cliOptions.js

@@ -0,0 +1,139 @@
+const DEFAULT_PORT = 20128;
+const DEFAULT_HOST = "127.0.0.1";
+const COMMANDS = new Set(["start", "status", "stop", "restart", "help", "version"]);
+
+function isLoopbackHost(value) {
+  const normalized = String(value).toLowerCase();
+  return normalized === "localhost" || normalized === "::1" || normalized === "[::1]" || /^127(?:\.\d{1,3}){3}$/.test(normalized);
+}
+
+function requireValue(argv, index, option) {
+  const value = argv[index + 1];
+  if (!value || value.startsWith("-")) {
+    throw new Error(`${option} requires a value`);
+  }
+  return value;
+}
+
+function parsePort(value) {
+  if (!/^\d+$/.test(String(value))) {
+    throw new Error("--port must be between 1 and 65535");
+  }
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535) {
+    throw new Error("--port must be between 1 and 65535");
+  }
+  return parsed;
+}
+
+function parseHost(value) {
+  const host = String(value).trim();
+  if (!host || /\s|\/|:\/\//.test(host)) {
+    throw new Error("--host must be a hostname or IP address");
+  }
+  return host;
+}
+
+function parseCliArgs(argv, defaults = {}) {
+  const args = [...argv];
+  let command = "start";
+  if (args[0] && !args[0].startsWith("-")) {
+    command = args.shift();
+    if (!COMMANDS.has(command)) throw new Error(`Unknown command: ${command}`);
+  }
+
+  const parsed = {
+    command,
+    port: defaults.port || DEFAULT_PORT,
+    host: defaults.host || DEFAULT_HOST,
+    showLog: false,
+    trayMode: false,
+    skipUpdate: false,
+    noBrowser: false,
+    json: false,
+    help: command === "help",
+    version: command === "version",
+    portProvided: false,
+    hostProvided: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--port" || arg === "-p") {
+      parsed.port = parsePort(requireValue(args, i, arg));
+      parsed.portProvided = true;
+      i++;
+    } else if (arg === "--host" || arg === "-H") {
+      parsed.host = parseHost(requireValue(args, i, arg));
+      parsed.hostProvided = true;
+      i++;
+    } else if (arg === "--no-browser" || arg === "-n") {
+      parsed.noBrowser = true;
+    } else if (arg === "--log" || arg === "-l") {
+      parsed.showLog = true;
+    } else if (arg === "--tray" || arg === "-t") {
+      parsed.trayMode = true;
+    } else if (arg === "--skip-update") {
+      parsed.skipUpdate = true;
+    } else if (arg === "--json") {
+      parsed.json = true;
+    } else if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+    } else if (arg === "--version" || arg === "-v") {
+      parsed.version = true;
+    } else {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+
+  if (parsed.json && command !== "status") {
+    throw new Error("--json is only valid with the status command");
+  }
+  if (["status", "stop"].includes(command)) {
+    const invalid = [parsed.showLog && "--log", parsed.trayMode && "--tray", parsed.skipUpdate && "--skip-update", parsed.noBrowser && "--no-browser"].filter(Boolean);
+    if (invalid.length) throw new Error(`${invalid.join(", ")} is not valid with the ${command} command`);
+  }
+  return parsed;
+}
+
+function formatHelp({ version = "unknown", defaultPort = DEFAULT_PORT, defaultHost = DEFAULT_HOST } = {}) {
+  return `Switchboard ${version}
+
+Usage:
+  switchboard [start] [options]   Start Switchboard (default)
+  switchboard status [options]   Show server, version, PID, and ownership status
+  switchboard stop [options]     Stop the owned Switchboard instance gracefully
+  switchboard restart [options]  Gracefully stop, then start Switchboard
+
+Lifecycle:
+  In the terminal, press Ctrl+C to stop gracefully.
+  In tray mode, choose Quit. You can always use "switchboard stop" if the icon is unavailable.
+  A second start never kills an unrelated listener; use "switchboard status" to diagnose conflicts.
+
+Options:
+  -p, --port <port>   Server port (default: ${defaultPort})
+  -H, --host <host>   Bind host (default: ${defaultHost})
+  -l, --log           Stream server logs while retaining crash diagnostics
+  -t, --tray          Run with the system-tray control surface
+  -n, --no-browser    Compatibility flag; browsers open only when explicitly selected
+      --skip-update   Skip the startup update check
+      --json          Machine-readable output for "switchboard status"
+  -h, --help          Show this help
+  -v, --version       Show the version
+
+Examples:
+  switchboard
+  switchboard --tray
+  switchboard status
+  switchboard restart --port ${defaultPort}
+  switchboard stop
+`;
+}
+
+module.exports = {
+  DEFAULT_HOST,
+  DEFAULT_PORT,
+  formatHelp,
+  isLoopbackHost,
+  parseCliArgs,
+};

package/src/cli/menus/settings.js

@@ -18,14 +18,14 @@ const COLORS = {
  * there is no dashboard login, password or OIDC to manage here.
  * @param {Array<string>} breadcrumb - Breadcrumb path
  */
-async function showSettingsMenu(breadcrumb = []) {
+async function showSettingsMenu(breadcrumb = [], { port = 20128, networkExposed = false } = {}) {
   await showMenuWithBack({
     title: "⚙️  Settings",
     breadcrumb,
     headerContent: async (data) => {
       const lines = [];
 
-      lines.push(`  Endpoint: http://localhost:20128/v1 ${COLORS.dim}(local only)${COLORS.reset}`);
+      lines.push(`  Endpoint: http://localhost:${port}/v1 ${COLORS.dim}(${networkExposed ? "network-exposed" : "local only"})${COLORS.reset}`);
 
       // RTK section
       const rtkOn = data?.settings?.rtkEnabled !== false;

package/src/cli/processManager.js

@@ -0,0 +1,186 @@
+const fs = require("fs");
+const path = require("path");
+const { execFileSync, execSync } = require("child_process");
+
+function normalizePath(value) {
+  try { return path.resolve(value); } catch { return ""; }
+}
+
+function tokenizeCommand(command) {
+  const tokens = [];
+  let token = "";
+  let quote = "";
+  for (const char of String(command)) {
+    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 (token) tokens.push(token);
+  return tokens;
+}
+
+function matchesRecordedProcess({ command, cwd, expectedPath }) {
+  if (!expectedPath || !command) return false;
+  const expected = normalizePath(expectedPath);
+  const tokens = tokenizeCommand(command);
+  const scriptIndex = tokens.findIndex((token) => {
+    if (!token) return false;
+    if (path.isAbsolute(token)) return normalizePath(token) === expected;
+    return !!cwd && normalizePath(path.join(cwd, token)) === expected;
+  });
+  const runtimeName = path.basename(tokens[0] || "").toLowerCase();
+  const isNodeRuntime = runtimeName === "node" || runtimeName === "node.exe" || runtimeName === path.basename(process.execPath).toLowerCase();
+  if (isNodeRuntime && scriptIndex > 0 && tokens.slice(1, scriptIndex).every((token) => token.startsWith("-"))) {
+    return true;
+  }
+
+  const expectedName = path.basename(expectedPath);
+  const isBundledServer = expectedName === "server.js" || expectedName === "custom-server.js";
+  if (!isBundledServer || !/^next-server(?:\s|\(|$)/.test(command.trim())) return false;
+
+  return !!cwd && normalizePath(cwd) === normalizePath(path.dirname(expectedPath));
+}
+
+function getProcessCommand(pid) {
+  try {
+    if (process.platform === "win32") {
+      return execFileSync("powershell", [
+        "-NonInteractive", "-NoProfile", "-Command",
+        `(Get-CimInstance Win32_Process -Filter 'ProcessId = ${Number(pid)}').CommandLine`,
+      ], { encoding: "utf8", windowsHide: true, timeout: 3000 }).trim();
+    }
+    return execFileSync("ps", ["-p", String(Number(pid)), "-o", "command="], {
+      encoding: "utf8",
+      timeout: 3000,
+    }).trim();
+  } catch { return ""; }
+}
+
+function getProcessCwd(pid) {
+  try {
+    if (process.platform === "linux") return fs.readlinkSync(`/proc/${Number(pid)}/cwd`);
+    if (process.platform === "win32") return "";
+    const output = execFileSync("lsof", ["-a", "-p", String(Number(pid)), "-d", "cwd", "-Fn"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 3000,
+    });
+    const cwdLine = output.split(/\r?\n/).find((line) => line.startsWith("n"));
+    return cwdLine ? cwdLine.slice(1) : "";
+  } catch { return ""; }
+}
+
+function processMatchesRecordedPath(pid, expectedPath) {
+  const command = getProcessCommand(pid);
+  if (matchesRecordedProcess({ command, cwd: "", expectedPath })) return true;
+  return matchesRecordedProcess({ command, cwd: getProcessCwd(pid), expectedPath });
+}
+
+function findListeningPids(port) {
+  const numericPort = Number(port);
+  if (!Number.isInteger(numericPort) || numericPort < 1 || numericPort > 65535) return [];
+  try {
+    if (process.platform === "win32") {
+      const output = execFileSync("powershell", [
+        "-NonInteractive", "-NoProfile", "-Command",
+        `Get-NetTCPConnection -LocalPort ${numericPort} -State Listen -ErrorAction SilentlyContinue | Select-Object -ExpandProperty OwningProcess`,
+      ], { encoding: "utf8", windowsHide: true, timeout: 5000 });
+      return output.split(/\s+/).map(Number).filter((pid) => Number.isInteger(pid) && pid > 1);
+    }
+    const output = execFileSync("lsof", [`-tiTCP:${numericPort}`, "-sTCP:LISTEN"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5000,
+    });
+    return output.split(/\s+/).map(Number).filter((pid) => Number.isInteger(pid) && pid > 1);
+  } catch { return []; }
+}
+
+function isPidAlive(pid) {
+  try { process.kill(Number(pid), 0); return true; } catch (error) { return error?.code === "EPERM"; }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function acquireLifecycleLock(dataDir, { instanceId, timeoutMs = 10000 } = {}) {
+  const lockDir = path.join(dataDir, "runtime", "lifecycle.lock");
+  const ownerFile = path.join(lockDir, "owner.json");
+  const deadline = Date.now() + timeoutMs;
+  fs.mkdirSync(path.dirname(lockDir), { recursive: true });
+
+  while (Date.now() < deadline) {
+    try {
+      fs.mkdirSync(lockDir);
+      fs.writeFileSync(ownerFile, JSON.stringify({ pid: process.pid, instanceId, createdAt: Date.now() }), { mode: 0o600 });
+      return () => {
+        try {
+          const owner = JSON.parse(fs.readFileSync(ownerFile, "utf8"));
+          if (owner.instanceId === instanceId) fs.rmSync(lockDir, { recursive: true, force: true });
+        } catch { /* lock already released */ }
+      };
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+      let owner = null;
+      try { owner = JSON.parse(fs.readFileSync(ownerFile, "utf8")); } catch { /* incomplete or stale lock */ }
+      let ageMs = 0;
+      try { ageMs = Date.now() - fs.statSync(lockDir).mtimeMs; } catch { /* retry */ }
+      const stale = owner?.pid ? !isPidAlive(owner.pid) : ageMs > 1000;
+      if (stale) {
+        try { fs.rmSync(lockDir, { recursive: true, force: true }); } catch { /* another waiter won */ }
+        continue;
+      }
+      await sleep(100);
+    }
+  }
+  throw new Error("Another Switchboard lifecycle operation is still in progress; retry shortly");
+}
+
+async function terminatePid(pid, { timeoutMs = 2000, processGroup = false } = {}) {
+  const numericPid = Number(pid);
+  if (!Number.isInteger(numericPid) || numericPid <= 1 || numericPid === process.pid) return false;
+  const unixTarget = processGroup && process.platform !== "win32" ? -numericPid : numericPid;
+  const targetIsAlive = () => isPidAlive(unixTarget);
+  try {
+    if (process.platform === "win32") {
+      execSync(`taskkill /T /PID ${numericPid}`, { stdio: "ignore", windowsHide: true, timeout: 3000 });
+    } else {
+      process.kill(unixTarget, "SIGTERM");
+    }
+  } catch { /* already stopped or inaccessible */ }
+
+  const deadline = Date.now() + timeoutMs;
+  while (targetIsAlive() && Date.now() < deadline) await sleep(100);
+  if (!targetIsAlive()) return true;
+
+  try {
+    if (process.platform === "win32") {
+      execSync(`taskkill /F /T /PID ${numericPid}`, { stdio: "ignore", windowsHide: true, timeout: 3000 });
+    } else {
+      process.kill(unixTarget, "SIGKILL");
+    }
+  } catch { /* best effort */ }
+  return !targetIsAlive();
+}
+
+module.exports = {
+  acquireLifecycleLock,
+  findListeningPids,
+  getProcessCommand,
+  getProcessCwd,
+  isPidAlive,
+  matchesRecordedProcess,
+  processMatchesRecordedPath,
+  terminatePid,
+};

package/src/cli/serverStatus.js

@@ -0,0 +1,90 @@
+const http = require("http");
+const net = require("net");
+const MAX_RESPONSE_BYTES = 64 * 1024;
+
+function requestJson({ hostname = "127.0.0.1", port, path, timeoutMs = 1000 }) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      resolve(value);
+    };
+    const req = http.request({
+      hostname,
+      port,
+      path,
+      method: "GET",
+      headers: { Accept: "application/json" },
+    }, (res) => {
+      let body = "";
+      res.setEncoding("utf8");
+      res.on("data", (chunk) => {
+        body += chunk;
+        if (Buffer.byteLength(body) > MAX_RESPONSE_BYTES) {
+          res.destroy(new Error("response too large"));
+          finish(null);
+        }
+      });
+      res.on("aborted", () => finish(null));
+      res.on("error", () => finish(null));
+      res.on("end", () => {
+        try {
+          finish({ statusCode: res.statusCode, body: JSON.parse(body) });
+        } catch {
+          finish(null);
+        }
+      });
+    });
+    req.setTimeout(timeoutMs, () => {
+      req.destroy();
+      finish(null);
+    });
+    req.on("error", () => finish(null));
+    req.end();
+  });
+}
+
+function probeTcp(port, timeoutMs = 1000, hostname = "127.0.0.1") {
+  return new Promise((resolve) => {
+    let settled = false;
+    const socket = net.createConnection({ host: hostname, port });
+    const finish = (ready) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve(ready);
+    };
+    socket.setTimeout(timeoutMs, () => finish(false));
+    socket.once("connect", () => finish(true));
+    socket.once("error", () => finish(false));
+  });
+}
+
+async function probeSwitchboard(port, timeoutMs = 1000, hostname = "127.0.0.1") {
+  const response = await requestJson({ hostname, port, path: "/api/mgmt/v1/version", timeoutMs });
+  const data = response?.body?.data;
+  if (response?.statusCode === 200 && data?.name === "switchboard-app") return data;
+
+  // Compatibility with older bundles that predate the management version API.
+  const health = await requestJson({ hostname, port, path: "/api/health", timeoutMs });
+  if (health?.statusCode === 200 && health?.body?.ok === true) {
+    return { name: "switchboard-app", version: null, startedAt: null, legacyHealth: true };
+  }
+  return null;
+}
+
+async function waitForSwitchboard(port, { timeoutMs = 20000, intervalMs = 250, hostname = "127.0.0.1", acceptTcpFallback = null } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const status = await probeSwitchboard(port, Math.min(1000, intervalMs * 2), hostname);
+    if (status) return status;
+    if (acceptTcpFallback && await probeTcp(port, Math.min(1000, intervalMs * 2), hostname) && await acceptTcpFallback()) {
+      return { name: "switchboard-app", version: null, startedAt: null, tcpOnly: true };
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+  return null;
+}
+
+module.exports = { probeSwitchboard, probeTcp, waitForSwitchboard };

package/src/cli/terminalUI.js

@@ -18,9 +18,10 @@ const COLORS = {
 let cachedHeader = "";
 let fetchingHeader = false;
 
-function renderHeader(port, keys) {
+function renderHeader(port, keys, { networkExposed = false } = {}) {
   const lines = [];
-  lines.push(`Endpoint: http://localhost:${port}/v1 ${COLORS.dim}(local only)${COLORS.reset}`);
+  const exposure = networkExposed ? "network-exposed" : "local only";
+  lines.push(`Endpoint: http://localhost:${port}/v1 ${COLORS.dim}(${exposure})${COLORS.reset}`);
   if (!keys || keys.length === 0) {
     lines.push(`Key:      ${COLORS.dim}No API keys yet${COLORS.reset}`);
   } else {
@@ -30,21 +31,21 @@ function renderHeader(port, keys) {
   return lines.join("\n");
 }
 
-async function refreshHeaderBg(port) {
+async function refreshHeaderBg(port, networkExposed) {
   if (fetchingHeader) return;
   fetchingHeader = true;
   try {
     const keysResult = await api.getApiKeys();
     const keys = keysResult.success ? (keysResult.data.keys || []) : [];
-    cachedHeader = renderHeader(port, keys);
+    cachedHeader = renderHeader(port, keys, { networkExposed });
   } finally {
     fetchingHeader = false;
   }
 }
 
-function getHeader(port) {
+function getHeader(port, networkExposed) {
   // Kick off background refresh; return cache (or placeholder on first call).
-  refreshHeaderBg(port);
+  refreshHeaderBg(port, networkExposed);
   return cachedHeader || `Endpoint: http://localhost:${port}/v1\nKey:      ${COLORS.dim}...${COLORS.reset}`;
 }
 
@@ -52,20 +53,20 @@ function getHeader(port) {
  * Start Terminal UI
  * @param {number} port - Server port number
  */
-async function startTerminalUI(port) {
+async function startTerminalUI(port, { networkExposed = false } = {}) {
   // Configure API client
   api.configure({ port });
 
   const basePath = ["Switchboard"];
 
   // Prime header cache before first render
-  await refreshHeaderBg(port);
+  await refreshHeaderBg(port, networkExposed);
 
   // Main menu
   await showMenuWithBack({
     title: "📡 Switchboard Terminal UI",
     breadcrumb: basePath,
-    headerContent: () => getHeader(port),
+    headerContent: () => getHeader(port, networkExposed),
     items: [
       {
         label: "Providers",
@@ -98,7 +99,7 @@ async function startTerminalUI(port) {
       {
         label: "Settings",
         action: async () => {
-          await showSettingsMenu([...basePath, "Settings"]);
+          await showSettingsMenu([...basePath, "Settings"], { port, networkExposed });
           return true;
         }
       }
@@ -107,4 +108,4 @@ async function startTerminalUI(port) {
   });
 }
 
-module.exports = { startTerminalUI };
+module.exports = { renderHeader, startTerminalUI };

package/src/cli/tray/autostart.js

@@ -44,16 +44,16 @@ function getCliJsPath(cliPath) {
  * @param {string} cliPath - Optional path to cli.js (defaults to auto-detect)
  * @returns {boolean} success
  */
-function enableAutoStart(cliPath) {
+function enableAutoStart(cliPath, launchOptions = {}) {
   const platform = process.platform;
 
   if (!["darwin", "win32", "linux"].includes(platform)) return false;
   if (platform === "linux" && !process.env.DISPLAY) return false;
 
   try {
-    if (platform === "darwin") return enableMacOS(cliPath);
-    if (platform === "win32") return enableWindows(cliPath);
-    if (platform === "linux") return enableLinux(cliPath);
+    if (platform === "darwin") return enableMacOS(cliPath, launchOptions);
+    if (platform === "win32") return enableWindows(cliPath, launchOptions);
+    if (platform === "linux") return enableLinux(cliPath, launchOptions);
   } catch (err) {
     // Silent fail — autostart is optional
   }
@@ -138,7 +138,19 @@ function isAgentSelfMacOS() {
   }
 }
 
-function enableMacOS(cliPath) {
+function getLaunchArgs({ port = 20128, host = "127.0.0.1" } = {}) {
+  return ["--tray", "--skip-update", "--port", String(port), "--host", String(host)];
+}
+
+function xmlEscape(value) {
+  return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+
+function quoteDesktopArg(value) {
+  return `"${String(value).replace(/(["\\$])/g, "\\$1")}"`;
+}
+
+function enableMacOS(cliPath, launchOptions) {
   const launchAgentsDir = path.join(os.homedir(), "Library", "LaunchAgents");
   const plistPath = path.join(launchAgentsDir, `${APP_LABEL}.plist`);
 
@@ -158,6 +170,10 @@ function enableMacOS(cliPath) {
   // EnvironmentVariables.PATH explicitly includes node's bin dir so child
   // processes spawned by cli.js (npm install at runtime, etc.) resolve.
   const launchPath = `${path.dirname(nodePath)}:/usr/local/bin:/usr/bin:/bin`;
+  const launchArgs = getLaunchArgs(launchOptions);
+  const plistArgs = [nodePath, routerScript, ...launchArgs]
+    .map((arg) => `        <string>${xmlEscape(arg)}</string>`)
+    .join("\n");
 
   const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -167,10 +183,7 @@ function enableMacOS(cliPath) {
     <string>${APP_LABEL}</string>
     <key>ProgramArguments</key>
     <array>
-        <string>${nodePath}</string>
-        <string>${routerScript}</string>
-        <string>--tray</string>
-        <string>--skip-update</string>
+${plistArgs}
     </array>
     <key>EnvironmentVariables</key>
     <dict>
@@ -236,7 +249,7 @@ function disableMacOS() {
 
 // ============ Windows ============
 
-function enableWindows(cliPath) {
+function enableWindows(cliPath, launchOptions) {
   const startupDir = path.join(process.env.APPDATA || "", "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
   const vbsPath = path.join(startupDir, `${APP_NAME}.vbs`);
 
@@ -245,11 +258,16 @@ function enableWindows(cliPath) {
   const nodePath = process.execPath;
   const routerScript = getCliJsPath(cliPath);
   if (!routerScript) return false;
+  const launchArgs = getLaunchArgs(launchOptions);
+  const vbsCommand = [nodePath, routerScript, ...launchArgs]
+    .map((arg) => `"${String(arg).replace(/"/g, '""')}"`)
+    .join(" ")
+    .replace(/"/g, '""');
 
   // Run node + cli.js directly, hidden window. Avoids the fragile
   // `switchboard.cmd` lookup that depended on the npm prefix path.
   const vbsContent = `Set WshShell = CreateObject("WScript.Shell")
-WshShell.Run """${nodePath}"" ""${routerScript}"" --tray --skip-update", 0, False
+WshShell.Run "${vbsCommand}", 0, False
 `;
   fs.writeFileSync(vbsPath, vbsContent);
   return true;
@@ -265,7 +283,7 @@ function disableWindows() {
 
 // ============ Linux ============
 
-function enableLinux(cliPath) {
+function enableLinux(cliPath, launchOptions) {
   const autostartDir = path.join(os.homedir(), ".config", "autostart");
   const desktopPath = path.join(autostartDir, `${APP_NAME}.desktop`);
 
@@ -277,12 +295,14 @@ function enableLinux(cliPath) {
   const nodePath = process.execPath;
   const routerScript = getCliJsPath(cliPath);
   if (!routerScript) return false;
+  const launchArgs = getLaunchArgs(launchOptions);
+  const execCommand = [nodePath, routerScript, ...launchArgs].map(quoteDesktopArg).join(" ");
 
   const desktopContent = `[Desktop Entry]
 Type=Application
 Name=Switchboard
 Comment=Switchboard API Proxy
-Exec=${nodePath} ${routerScript} --tray --skip-update
+Exec=${execCommand}
 Hidden=false
 NoDisplay=false
 X-GNOME-Autostart-enabled=true
@@ -302,5 +322,6 @@ function disableLinux() {
 module.exports = {
   enableAutoStart,
   disableAutoStart,
-  isAutoStartEnabled
+  isAutoStartEnabled,
+  getLaunchArgs,
 };