swayrouter 1.0.0

package/cli/src/runtime/discover.js

@@ -0,0 +1,153 @@
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { execFileSync } = require("node:child_process");
+
+const INSTALL_MANIFEST = ".swayrouter-install.json";
+const REGISTRATION_FILE = "install.json";
+const LEGACY_BUNDLED_ERROR = "This bundled npm installation is no longer supported. Reinstall from a source checkout or prepare it with Docker.";
+
+function defaultDataDir() {
+  if (process.env.DATA_DIR && !(process.platform === "win32" && /^\//.test(process.env.DATA_DIR))) {
+    return process.env.DATA_DIR;
+  }
+  return process.platform === "win32"
+    ? path.join(process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"), ".swayrouter")
+    : path.join(os.homedir(), ".swayrouter");
+}
+
+function candidateInstallDirs() {
+  const dirs = [];
+  if (process.env.SWAY_ROUTER_DIR) dirs.push(process.env.SWAY_ROUTER_DIR);
+  if (process.platform === "win32") {
+    dirs.push(path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local"), "SwayRouter"));
+  } else {
+    dirs.push(path.join(os.homedir(), ".local", "share", "swayrouter"));
+    dirs.push("/opt/swayrouter");
+  }
+  return dirs;
+}
+
+function readJson(file) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function readDotEnv(file) {
+  const values = {};
+  try {
+    for (const line of fs.readFileSync(file, "utf8").split(/\r?\n/)) {
+      const match = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)\s*$/);
+      if (!match) continue;
+      let value = match[2];
+      if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) {
+        value = value.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\").replace(/\$\$/g, "$");
+      } else if (value.startsWith("'") && value.endsWith("'") && value.length >= 2) {
+        value = value.slice(1, -1);
+      } else {
+        value = value.replace(/\s+#.*$/, "").trim();
+      }
+      values[match[1]] = value;
+    }
+  } catch {}
+  return values;
+}
+
+function fileExists(file) {
+  try { return fs.statSync(file).isFile(); } catch { return false; }
+}
+
+function dirExists(dir) {
+  try { return fs.statSync(dir).isDirectory(); } catch { return false; }
+}
+
+function inspectDirectory(dir, manifest = null) {
+  if (!dir || !dirExists(dir)) return null;
+  const resolved = path.resolve(dir);
+  const localManifest = manifest || readJson(path.join(resolved, INSTALL_MANIFEST));
+  if (localManifest?.mode === "bundled") throw new Error(LEGACY_BUNDLED_ERROR);
+
+  const composeFile = localManifest?.composeFile && fileExists(localManifest.composeFile)
+    ? localManifest.composeFile
+    : (fileExists(path.join(resolved, "docker-compose.yml")) ? path.join(resolved, "docker-compose.yml") : null);
+  const sourceFile = fileExists(path.join(resolved, "src", "server.ts")) ? path.join(resolved, "src", "server.ts") : null;
+  const binaryNames = process.platform === "win32" ? ["swayrouter.exe"] : ["swayrouter"];
+  const binaryFile = binaryNames.map((name) => path.join(resolved, name)).find(fileExists) || null;
+  if (!composeFile && !sourceFile && !binaryFile && !localManifest) return null;
+  const mode = localManifest?.mode || (composeFile ? "docker" : binaryFile && !sourceFile ? "binary" : "native");
+  const manifestDataDir = localManifest?.dataDir;
+  const dataDir = manifestDataDir && !String(manifestDataDir).startsWith("docker-volume:")
+    ? manifestDataDir
+    : defaultDataDir();
+  return {
+    mode,
+    installDir: resolved,
+    composeFile,
+    sourceFile,
+    binaryFile,
+    dataDir,
+    env: mode === "docker" ? {} : readDotEnv(path.join(resolved, ".env")),
+    dockerVolume: manifestDataDir && String(manifestDataDir).startsWith("docker-volume:")
+      ? String(manifestDataDir).slice("docker-volume:".length)
+      : null,
+    port: Number(localManifest?.port) || 14045,
+    host: localManifest?.host || "127.0.0.1",
+    manifest: localManifest,
+  };
+}
+
+function loadRegisteredInstallation() {
+  const registration = readJson(path.join(defaultDataDir(), REGISTRATION_FILE));
+  if (!registration?.installDir) return null;
+  return inspectDirectory(registration.installDir, registration);
+}
+
+function findCommand(command) {
+  try {
+    const resolver = process.platform === "win32" ? "where.exe" : "which";
+    return execFileSync(resolver, [command], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true }).split(/\r?\n/)[0].trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+function discoverInstall({ dir, cliDirectory } = {}) {
+  const explicit = dir || process.env.SWAY_ROUTER_DIR;
+  if (explicit) return inspectDirectory(explicit);
+
+  const registered = loadRegisteredInstallation();
+  if (registered) return registered;
+
+  const repositoryRoot = path.resolve(cliDirectory || path.join(__dirname, "..", "..", ".."));
+  const local = inspectDirectory(repositoryRoot);
+  if (local) return local;
+
+  const binaryNames = process.platform === "win32" ? ["swayrouter.exe"] : ["swayrouter"];
+  const siblingCandidates = [
+    ...binaryNames.map((name) => path.join(cliDirectory || path.join(__dirname, "..", "..", ".."), name)),
+    ...binaryNames.map((name) => path.join(__dirname, "..", "..", name)),
+  ];
+  for (const binary of siblingCandidates) {
+    if (fileExists(binary)) return inspectDirectory(path.dirname(binary));
+  }
+
+  for (const candidate of candidateInstallDirs()) {
+    const found = inspectDirectory(candidate);
+    if (found) return found;
+  }
+  return null;
+}
+
+module.exports = {
+  INSTALL_MANIFEST,
+  LEGACY_BUNDLED_ERROR,
+  defaultDataDir,
+  findCommand,
+  readDotEnv,
+  inspectDirectory,
+  discoverInstall,
+};

package/cli/src/runtime/lifecycle.js

@@ -0,0 +1,333 @@
+const fs = require("node:fs");
+const http = require("node:http");
+const os = require("node:os");
+const path = require("node:path");
+const { spawn, execFileSync } = require("node:child_process");
+const { findCommand } = require("./discover");
+
+const DEFAULT_PORT = 14045;
+const READY_PATH = "/api/health/ready";
+
+function localHost(host) {
+  return !host || host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
+}
+
+function waitForReady(port, {
+  host = "127.0.0.1",
+  pathName = READY_PATH,
+  timeoutMs = 30000,
+  intervalMs = 250,
+} = {}) {
+  const targetHost = localHost(host);
+  const deadline = Date.now() + timeoutMs;
+  return new Promise((resolve) => {
+    let finished = false;
+    let timer = null;
+    const finish = (ready) => {
+      if (finished) return;
+      finished = true;
+      if (timer) clearTimeout(timer);
+      resolve(ready);
+    };
+    const attempt = () => {
+      if (finished) return;
+      if (Date.now() >= deadline) return finish(false);
+      let attemptFinished = false;
+      const request = http.get({
+        host: targetHost,
+        port,
+        path: pathName,
+        timeout: Math.min(1000, Math.max(100, deadline - Date.now())),
+        headers: { accept: "application/json" },
+      }, (response) => {
+        response.resume();
+        const ready = response.statusCode >= 200 && response.statusCode < 300;
+        response.once("end", () => {
+          if (attemptFinished) return;
+          attemptFinished = true;
+          if (ready) finish(true);
+          else schedule();
+        });
+      });
+      const retry = () => {
+        if (attemptFinished) return;
+        attemptFinished = true;
+        request.destroy();
+        schedule();
+      };
+      request.once("error", retry);
+      request.once("timeout", retry);
+    };
+    const schedule = () => {
+      if (finished) return;
+      if (Date.now() >= deadline) return finish(false);
+      timer = setTimeout(attempt, intervalMs);
+    };
+    attempt();
+  });
+}
+
+function composeArguments(installation, args) {
+  const composeFile = installation.composeFile || path.join(installation.installDir, "docker-compose.yml");
+  return ["compose", "-f", composeFile, "--project-directory", installation.installDir, ...args];
+}
+
+function runDocker(installation, args, { stdio = "inherit" } = {}) {
+  const compose = findCommand("docker");
+  if (!compose) throw new Error("Docker is not installed or is not available on PATH");
+  return spawn(compose, composeArguments(installation, args), {
+    stdio,
+    windowsHide: true,
+  });
+}
+
+function runDockerSync(installation, args) {
+  const compose = findCommand("docker");
+  if (!compose) throw new Error("Docker is not installed or is not available on PATH");
+  return execFileSync(compose, composeArguments(installation, args), {
+    encoding: "utf8",
+    windowsHide: true,
+    stdio: "pipe",
+  });
+}
+
+function buildNativeEnv(installation, { host, port } = {}, baseEnv = process.env) {
+  const targetPort = Number(port || installation.port || DEFAULT_PORT);
+  const targetHost = host || installation.host || "127.0.0.1";
+  const env = {
+    ...baseEnv,
+    ...(installation.env || {}),
+    NODE_ENV: installation.env?.NODE_ENV || baseEnv.NODE_ENV || "production",
+    PORT: String(targetPort),
+    HOSTNAME: targetHost,
+  };
+  if (installation.dataDir && !String(installation.dataDir).startsWith("docker-volume:")) {
+    env.DATA_DIR = installation.dataDir;
+  }
+  return env;
+}
+
+function spawnNative(installation, { host, port, showLog = false, detached = false } = {}) {
+  const targetPort = Number(port || installation.port || DEFAULT_PORT);
+  const isBinary = installation.mode === "binary";
+  const command = isBinary ? installation.binaryFile : findCommand("bun");
+  if (!command) {
+    throw new Error(isBinary
+      ? "Compiled Sway Router binary was not found"
+      : "Bun is required to run a native source installation");
+  }
+  const args = isBinary
+    ? []
+    : ["--dns-result-order=ipv4first", "--max-old-space-size=6144", installation.sourceFile];
+  const stdio = detached ? "ignore" : "inherit";
+  const env = buildNativeEnv(installation, { host, port: targetPort });
+  const child = spawn(command, args, {
+    cwd: installation.installDir,
+    detached,
+    windowsHide: true,
+    stdio,
+    env,
+  });
+  if (detached) child.unref();
+  return child;
+}
+
+function dataDirectory(installation) {
+  if (installation.dataDir && !String(installation.dataDir).startsWith("docker-volume:")) return installation.dataDir;
+  return path.join(process.platform === "win32"
+    ? (process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"))
+    : os.homedir(), ".swayrouter");
+}
+
+function pidFile(installation) {
+  return path.join(dataDirectory(installation), "runtime", "swayrouter.pid");
+}
+
+function readPidRecord(installation) {
+  try {
+    const text = fs.readFileSync(pidFile(installation), "utf8").trim();
+    if (!text) return null;
+    if (text.startsWith("{")) {
+      const record = JSON.parse(text);
+      return Number.isInteger(record.pid) && record.pid > 0 ? record : null;
+    }
+    const pid = Number.parseInt(text, 10);
+    return Number.isInteger(pid) && pid > 0 ? { pid, legacy: true } : null;
+  } catch {
+    return null;
+  }
+}
+
+function readPid(installation) {
+  return readPidRecord(installation)?.pid || null;
+}
+
+function writePid(installation, pid) {
+  const file = pidFile(installation);
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  const record = {
+    pid,
+    installDir: path.resolve(installation.installDir),
+    executable: installation.binaryFile || installation.sourceFile,
+    startedAt: new Date().toISOString(),
+  };
+  fs.writeFileSync(file, `${JSON.stringify(record)}\n`, { mode: 0o600 });
+  if (process.platform !== "win32") fs.chmodSync(file, 0o600);
+}
+
+function removePid(installation) {
+  try { fs.rmSync(pidFile(installation), { force: true }); } catch {}
+}
+
+function processAlive(pid) {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+function ownsProcess(installation, record) {
+  if (!record || record.legacy || !processAlive(record.pid)) return false;
+  const expectedInstallDir = path.resolve(installation.installDir).toLowerCase();
+  const storedInstallDir = record.installDir
+    ? path.resolve(record.installDir).toLowerCase()
+    : "";
+  if (!storedInstallDir || storedInstallDir !== expectedInstallDir) return false;
+
+  const expectedExecutable = installation.mode === "binary"
+    ? installation.binaryFile
+    : installation.sourceFile;
+  if (!expectedExecutable || !record.executable) return false;
+  return path.resolve(record.executable).toLowerCase()
+    === path.resolve(expectedExecutable).toLowerCase();
+}
+
+function stopNative(installation) {
+  const stored = readPidRecord(installation);
+  const record = ownsProcess(installation, stored) ? stored : null;
+  if (!record || !processAlive(record.pid)) {
+    if (stored) removePid(installation);
+    return { stopped: false, reason: "no managed process" };
+  }
+  if (!ownsProcess(installation, record)) {
+    return { stopped: false, reason: "managed PID does not belong to this installation", pid: record.pid };
+  }
+  try {
+    if (process.platform === "win32") {
+      execFileSync("taskkill.exe", ["/F", "/T", "/PID", String(record.pid)], { stdio: "ignore", windowsHide: true });
+    } else {
+      try { process.kill(-record.pid, "SIGTERM"); } catch { process.kill(record.pid, "SIGTERM"); }
+    }
+  } catch {
+    try { process.kill(record.pid, "SIGTERM"); } catch {}
+  }
+  removePid(installation);
+  return { stopped: true, pid: record.pid };
+}
+
+function waitForProcessOrReady(child, port, host) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (callback, value) => {
+      if (settled) return;
+      settled = true;
+      child.removeListener("error", onError);
+      child.removeListener("close", onClose);
+      callback(value);
+    };
+    const onError = (error) => finish(reject, error);
+    const onClose = (code, signal) => finish(reject, new Error(`Sway Router exited before readiness (code=${code ?? "unknown"}, signal=${signal || "none"})`));
+    child.once("error", onError);
+    child.once("close", onClose);
+    waitForReady(port, { host }).then((ready) => {
+      if (ready) finish(resolve, true);
+      else finish(reject, new Error(`Sway Router did not become ready on port ${port}`));
+    });
+  });
+}
+
+async function start(installation, { background = false, showLog = false, port, host } = {}) {
+  const targetPort = Number(port || installation.port || DEFAULT_PORT);
+  const targetHost = localHost(host || installation.host);
+  if (status(installation).running) throw new Error("Sway Router is already running; stop it before starting again");
+
+  if (installation.mode === "docker") {
+    const child = runDocker(installation, background ? ["up", "-d"] : ["up"]);
+    if (background) {
+      await new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("close", (code) => code === 0 ? resolve() : reject(new Error(`Docker Compose exited with ${code}`)));
+      });
+      if (!await waitForReady(targetPort, { host: targetHost })) {
+        throw new Error(`Sway Router did not become ready on port ${targetPort}`);
+      }
+    } else {
+      await waitForProcessOrReady(child, targetPort, targetHost);
+    }
+    return { port: targetPort, background, ready: true, child };
+  }
+
+  const child = spawnNative(installation, { host, port: targetPort, showLog, detached: background });
+  if (!child.pid) throw new Error("Sway Router process did not start");
+  writePid(installation, child.pid);
+  child.once("error", () => removePid(installation));
+  child.once("close", () => removePid(installation));
+  try {
+    const ready = await waitForReady(targetPort, { host: targetHost });
+    if (!ready) throw new Error(`Sway Router did not become ready on port ${targetPort}`);
+  } catch (error) {
+    stopNative(installation);
+    throw error;
+  }
+  return { port: targetPort, background, ready: true, child };
+}
+
+function stop(installation) {
+  if (installation.mode === "docker") {
+    try {
+      runDockerSync(installation, ["down", "--remove-orphans"]);
+      return { stopped: true };
+    } catch (error) {
+      throw new Error(`Docker Compose stop failed: ${error.message}`);
+    }
+  }
+  return stopNative(installation);
+}
+
+function parseDockerStatus(output) {
+  const text = String(output || "").trim();
+  if (!text || text === "[]") return { running: false, detail: "stopped" };
+  try {
+    const parsed = JSON.parse(text);
+    const records = Array.isArray(parsed) ? parsed : [parsed];
+    const running = records.some((record) => {
+      const state = String(record?.State || record?.state || record?.Status || record?.status || "").toLowerCase();
+      return state === "running" || state.startsWith("up") || state.includes("running");
+    });
+    return { running, detail: text };
+  } catch {
+    return { running: /\brunning\b|\bup\b/i.test(text), detail: text };
+  }
+}
+
+function status(installation) {
+  if (installation.mode === "docker") {
+    try { return parseDockerStatus(runDockerSync(installation, ["ps", "--format", "json"])); }
+    catch (error) { return { running: false, detail: error.message }; }
+  }
+  const stored = readPidRecord(installation);
+  if (ownsProcess(installation, stored)) return { running: true, pid: stored.pid };
+  return { running: false, pid: stored?.pid || null };
+}
+
+module.exports = {
+  waitForReady,
+  start,
+  stop,
+  status,
+  spawnNative,
+  runDocker,
+  runDockerSync,
+  buildNativeEnv,
+  pidFile,
+  readPid,
+  parseDockerStatus,
+  writePid,
+};