swayrouter 1.0.0

package/cli/cli.js

@@ -0,0 +1,388 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const path = require("node:path");
+const pkg = require("../package.json");
+const { discoverInstall } = require("./src/runtime/discover");
+const lifecycle = require("./src/runtime/lifecycle");
+const { runMenu, dashboardUrl, runTrayHost, startTrayHost } = require("./src/runtime/runMenu");
+const { checkForUpdate } = require("./src/runtime/update");
+const { withProgress } = require("./src/cli/utils/display");
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  if (args[0] === "xai" && args[1] === "video") {
+    const { run } = require("./src/cli/commands/xaiVideo");
+    run(args.slice(2))
+      .then((code) => process.exit(code))
+      .catch((error) => {
+        process.stderr.write(`Error: ${error?.message || error}\n`);
+        process.exit(1);
+      });
+  } else {
+    main(args).catch((error) => {
+      reportFatalError(error);
+      process.exitCode = 1;
+    });
+  }
+}
+
+function reportFatalError(error) {
+  const message = String(error?.message || error || "Unknown error").replace(/[\r\n]+/g, " ").slice(0, 1000);
+  process.stderr.write(`Error: ${message}\n`);
+
+  const logPath = process.env.SWAYROUTER_AUTOSTART_LOG;
+  if (!logPath) return;
+  try {
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    fs.appendFileSync(logPath, `${new Date().toISOString()} Startup failed: ${message}\n`);
+  } catch {}
+}
+
+function usage() {
+  console.log(`
+Usage: swayrouter [command] [options]
+
+Start and manage an already prepared Sway Router runtime.
+
+Commands:
+  start                    Start the router attached to this terminal
+  status                   Show status and dashboard URL
+  restart                  Restart the router
+  stop                     Stop the router
+  menu                     Open the menu without starting the router
+  xai video ...            Generate a video through the running router
+
+Start options:
+  -b, --background         Start detached and keep a system tray when supported
+  -t, --tray               Start detached with a persistent system tray host
+  -f, --foreground         Keep the router attached to this terminal
+  -l, --log                Show native server logs
+  --skip-update            Skip the registry version check
+
+Runtime options:
+  -p, --port PORT          Override the native port
+  -H, --host HOST          Override the native host
+  --dir PATH               Use a specific installation directory
+  -h, --help               Show this help
+  -v, --version            Show version
+
+Examples:
+  swayrouter                   Start in the background and open the control menu
+  swayrouter start             Start the router attached to this terminal
+  swayrouter start -b          Start in the background with the system tray
+  swayrouter status            Check whether it is running
+  swayrouter stop              Stop it safely
+`);
+}
+
+function parseArgs(argv) {
+  const options = {
+    command: null,
+    port: null,
+    host: null,
+    dir: null,
+    noBrowser: false,
+    showLog: false,
+    skipUpdate: false,
+    foreground: false,
+    background: false,
+    tray: false,
+    open: false,
+    status: false,
+    stop: false,
+    help: false,
+    version: false,
+  };
+  const commands = new Set(["start", "status", "restart", "stop", "menu"]);
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const rawArg = argv[index];
+    const equalsIndex = rawArg.startsWith("--") ? rawArg.indexOf("=") : -1;
+    const arg = equalsIndex > -1 ? rawArg.slice(0, equalsIndex) : rawArg;
+    const inlineValue = equalsIndex > -1 ? rawArg.slice(equalsIndex + 1) : undefined;
+
+    if (!options.command && !arg.startsWith("-")) {
+      if (commands.has(arg)) {
+        options.command = arg;
+        continue;
+      }
+      if (arg === "xai") {
+        throw new Error("xai video must be invoked as `swayrouter xai video ...`");
+      }
+      throw new Error(`unknown command: ${arg}`);
+    }
+    if (options.command && !arg.startsWith("-")) {
+      throw new Error(`unexpected argument: ${arg}`);
+    }
+
+    const next = () => {
+      if (inlineValue !== undefined) return inlineValue;
+      if (index + 1 >= argv.length) throw new Error(`${arg} requires a value`);
+      index += 1;
+      return argv[index];
+    };
+
+    switch (arg) {
+      case "--port":
+      case "-p": {
+        const value = Number.parseInt(next(), 10);
+        if (!Number.isInteger(value) || value < 1 || value > 65535) {
+          throw new Error("port must be an integer between 1 and 65535");
+        }
+        options.port = value;
+        break;
+      }
+      case "--host":
+      case "-H":
+        options.host = next();
+        break;
+      case "--dir":
+        options.dir = next();
+        break;
+      case "--no-browser":
+      case "-n":
+        options.noBrowser = true;
+        break;
+      case "--log":
+      case "-l":
+        options.showLog = true;
+        break;
+      case "--foreground":
+      case "-f":
+        options.foreground = true;
+        break;
+      case "--background":
+      case "-b":
+        options.background = true;
+        break;
+      case "--tray":
+      case "-t":
+        options.background = true;
+        options.tray = true;
+        break;
+      case "--status":
+        options.status = true;
+        break;
+      case "--stop":
+        options.stop = true;
+        break;
+      case "--skip-update":
+        options.skipUpdate = true;
+        break;
+      case "--help":
+      case "-h":
+        options.help = true;
+        break;
+      case "--version":
+      case "-v":
+        options.version = true;
+        break;
+      default:
+        throw new Error(`unknown option: ${arg}`);
+    }
+  }
+
+  if (options.command === "status") options.status = true;
+  if (options.command === "stop") options.stop = true;
+  if (options.command === "open") options.open = true;
+  return options;
+}
+
+function commandFor(options) {
+  if (options.status) return "status";
+  if (options.stop) return "stop";
+  return options.command || "start";
+}
+
+function isDefaultMenuInvocation(options) {
+  return options.command === null
+    && !options.foreground
+    && !options.background
+    && !options.tray
+    && !options.status
+    && !options.stop;
+}
+
+function assertStartMode(options) {
+  if (options.foreground && options.background) {
+    throw new Error("choose either --foreground or --background, not both");
+  }
+}
+
+function resolveInstallation(options) {
+  const installation = discoverInstall({
+    dir: options.dir,
+    cliDirectory: path.resolve(__dirname, ".."),
+  });
+  if (!installation) return null;
+  if (options.port && installation.mode === "docker" && options.port !== 14045) {
+    throw new Error("Docker Compose uses the fixed port 14045; --port overrides are supported only for native mode");
+  }
+  if (options.host && installation.mode === "docker") {
+    throw new Error("--host is supported only for native mode; Docker Compose listens on 127.0.0.1:14045");
+  }
+  if (options.port) installation.port = options.port;
+  if (options.host) installation.host = options.host;
+  return installation;
+}
+
+async function startForeground(installation, options) {
+  const result = await withProgress("Starting Sway Router", (progress) => {
+    progress.update(35, "Starting Sway Router");
+    return lifecycle.start(installation, {
+      background: false,
+      showLog: options.showLog,
+      port: options.port,
+      host: options.host,
+    });
+  }, { doneMessage: "Sway Router started" });
+  const url = dashboardUrl(installation, result.port);
+  console.log(`Sway Router is running at ${url}`);
+  console.log("Press Ctrl+C to stop the router gracefully.");
+  await new Promise((resolve) => {
+    const stop = () => {
+      try { lifecycle.stop(installation); } catch {}
+      resolve();
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+}
+
+async function startBackground(installation, options) {
+  const result = await withProgress("Starting Sway Router", (progress) => {
+    progress.update(35, "Starting Sway Router");
+    return lifecycle.start(installation, {
+      background: true,
+      showLog: options.showLog,
+      port: options.port,
+      host: options.host,
+    });
+  }, { doneMessage: "Sway Router started" });
+  const url = dashboardUrl(installation, result.port);
+  const tray = startTrayHost(installation, result.port);
+  console.log(`Sway Router is running in the background at ${url}${tray ? " with the tray enabled" : ""}`);
+}
+
+async function startRuntime(installation, options) {
+  assertStartMode(options);
+  if (options.tray) {
+    await runTrayHost(installation, options);
+    return;
+  }
+  if (options.background) {
+    await startBackground(installation, options);
+    return;
+  }
+  await startForeground(installation, options);
+}
+
+async function startDefaultMenu(installation, options, updateInfo) {
+  const current = lifecycle.status(installation);
+  let port = Number(options.port || installation.port || 14045);
+
+  if (current.running) {
+    console.log(`Sway Router is already running at ${dashboardUrl(installation, port)}`);
+  } else {
+    const result = await withProgress("Starting Sway Router", (progress) => {
+      progress.update(35, "Starting Sway Router");
+      return lifecycle.start(installation, {
+        background: true,
+        showLog: options.showLog,
+        port: options.port,
+        host: options.host,
+      });
+    }, { doneMessage: "Sway Router started" });
+    port = result.port;
+    console.log(`Sway Router is running in the background at ${dashboardUrl(installation, port)}`);
+  }
+
+  await runMenu(installation, { ...options, port, updateInfo });
+}
+
+function showRuntimeStatus(installation, status, port) {
+  console.log("Sway Router");
+  console.log(`  Status: ${status.running ? "running" : "stopped"}`);
+  console.log(`  Current Version: v${pkg.version}`);
+  console.log(`  Mode: ${installation.mode}`);
+  console.log(`  Dashboard: ${dashboardUrl(installation, port)}`);
+  if (status.pid) console.log(`  PID: ${status.pid}`);
+}
+
+async function main(argv) {
+  const options = parseArgs(argv);
+  if (options.help) {
+    usage();
+    return;
+  }
+  if (options.version) {
+    console.log(pkg.version);
+    return;
+  }
+
+  const command = commandFor(options);
+  const installation = resolveInstallation(options);
+  if (!installation) {
+    if (command === "status") {
+      console.log("Sway Router is not prepared.");
+      console.log("Prepare the Sway Router runtime and installation metadata first.");
+      return;
+    }
+    if (command === "stop") {
+      console.log("Sway Router was not prepared; nothing to stop.");
+      return;
+    }
+    throw new Error("Sway Router is not prepared. Prepare the runtime and installation metadata first.");
+  }
+
+  const status = lifecycle.status(installation);
+  if (command === "status") {
+    showRuntimeStatus(installation, status, options.port);
+    return;
+  }
+  if (command === "stop") {
+    const result = await withProgress("Stopping Sway Router", () => lifecycle.stop(installation), {
+      doneMessage: "Sway Router stopped",
+    });
+    console.log(result.stopped ? "Sway Router stopped." : "Sway Router was not running.");
+    return;
+  }
+
+  const updateInfo = !options.skipUpdate && (command === "start" || command === "restart" || command === "menu")
+    ? await checkForUpdate()
+    : null;
+  if (updateInfo?.updateAvailable && !updateInfo.updateSupported) {
+    console.log(`Sway Router v${updateInfo.latestVersion} is available, but this installation cannot self-update.`);
+  }
+  if (updateInfo?.updateAvailable && updateInfo.updateSupported && command !== "menu" && !isDefaultMenuInvocation(options)) {
+    console.log(`Sway Router v${updateInfo.latestVersion} is available. Run \'swayrouter\' to update from the menu.`);
+  }
+  if (command === "restart") {
+    if (status.running) {
+      await withProgress("Stopping Sway Router", () => lifecycle.stop(installation), {
+        doneMessage: "Sway Router stopped",
+      });
+    }
+    await startRuntime(installation, options);
+    return;
+  }
+  if (command === "menu") {
+    await runMenu(installation, { ...options, updateInfo });
+    return;
+  }
+  if (isDefaultMenuInvocation(options)) {
+    await startDefaultMenu(installation, options, updateInfo);
+    return;
+  }
+  await startRuntime(installation, options);
+}
+
+module.exports = {
+  commandFor,
+  isDefaultMenuInvocation,
+  main,
+  parseArgs,
+  resolveInstallation,
+  usage,
+};

package/cli/package.json

@@ -0,0 +1,4 @@
+{
+  "private": true,
+  "type": "commonjs"
+}

package/cli/src/cli/commands/xaiVideo.js

@@ -0,0 +1,280 @@
+const http = require("http");
+const https = require("https");
+const fs = require("fs");
+const path = require("path");
+
+const DEFAULT_PORT = 14045;
+const DEFAULT_HOST = "127.0.0.1";
+const DEFAULT_MODEL = "xai/grok-imagine-video";
+const DEFAULT_TIMEOUT_SEC = 600;
+const DEFAULT_POLL_INTERVAL_MS = 5000;
+
+const TERMINAL_STATUSES = new Set(["done", "failed", "completed", "error", "expired", "cancelled"]);
+const FAILED_STATUSES = new Set(["failed", "error", "expired", "cancelled"]);
+
+const HELP = `
+Usage: swayrouter xai video --prompt "..." [options]
+
+Generate a Grok Imagine video via your local Sway Router gateway
+(requires a connected xAI account — Grok Build OAuth or API key).
+
+Options:
+  --prompt <text>         Video description (required)
+  --output <file>         Output MP4 path (default: video.mp4)
+  --model <id>            Model (default: ${DEFAULT_MODEL})
+  --duration <seconds>    Video duration
+  --aspect-ratio <ratio>  e.g. 16:9, 9:16, 1:1
+  --resolution <res>      480p | 720p | 1080p
+  --image <path-or-url>   Image input for image-to-video
+  --timeout <seconds>     Max wait for the job (default: ${DEFAULT_TIMEOUT_SEC})
+  --port <port>           Gateway port (default: ${DEFAULT_PORT})
+  --host <host>           Gateway host (default: ${DEFAULT_HOST})
+  --api-key <key>         Sway Router API key (or env SWAYROUTER_API_KEY)
+  -h, --help              Show this help
+`;
+
+function sanitizeText(text) {
+  return String(text ?? "").replace(/Bearer\s+[A-Za-z0-9._~+/=-]{8,}/gi, "Bearer [redacted]");
+}
+
+function parseArgs(argv) {
+  const opts = {
+    model: DEFAULT_MODEL,
+    output: "video.mp4",
+    timeoutSec: DEFAULT_TIMEOUT_SEC,
+    port: DEFAULT_PORT,
+    host: DEFAULT_HOST,
+    apiKey: process.env.SWAYROUTER_API_KEY || null,
+    pollIntervalMs: DEFAULT_POLL_INTERVAL_MS,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const next = () => argv[++i];
+    if (a === "--prompt") opts.prompt = next();
+    else if (a === "--output" || a === "-o") opts.output = next();
+    else if (a === "--model") opts.model = next();
+    else if (a === "--duration") opts.duration = parseInt(next(), 10);
+    else if (a === "--aspect-ratio") opts.aspectRatio = next();
+    else if (a === "--resolution") opts.resolution = next();
+    else if (a === "--image") opts.image = next();
+    else if (a === "--timeout") opts.timeoutSec = parseInt(next(), 10) || DEFAULT_TIMEOUT_SEC;
+    else if (a === "--port" || a === "-p") opts.port = parseInt(next(), 10) || DEFAULT_PORT;
+    else if (a === "--host" || a === "-H") opts.host = next() || DEFAULT_HOST;
+    else if (a === "--api-key") opts.apiKey = next();
+    else if (a === "--poll-interval-ms") opts.pollIntervalMs = parseInt(next(), 10) || DEFAULT_POLL_INTERVAL_MS;
+    else if (a === "-h" || a === "--help") opts.help = true;
+    else {
+      throw new Error(`Unknown option: ${a}`);
+    }
+  }
+  return opts;
+}
+
+function imageInputToUrl(input) {
+  if (/^(https?:|data:)/i.test(input)) return input;
+  const buf = fs.readFileSync(input);
+  const ext = path.extname(input).toLowerCase();
+  const mime = ext === ".png" ? "image/png" : ext === ".webp" ? "image/webp" : "image/jpeg";
+  return `data:${mime};base64,${buf.toString("base64")}`;
+}
+
+function gatewayRequest({ host, port, apiKey, method, reqPath, body, signal }) {
+  return new Promise((resolve, reject) => {
+    const payload = body ? JSON.stringify(body) : null;
+    const headers = { Accept: "application/json" };
+    if (payload) {
+      headers["Content-Type"] = "application/json";
+      headers["Content-Length"] = Buffer.byteLength(payload);
+    }
+    if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+
+    const req = http.request({ hostname: host, port, path: reqPath, method, headers, signal }, (res) => {
+      let data = "";
+      res.on("data", (c) => (data += c));
+      res.on("end", () => {
+        let parsed = null;
+        try { parsed = data ? JSON.parse(data) : null; } catch {                }
+        resolve({ status: res.statusCode, headers: res.headers, body: parsed, raw: data });
+      });
+    });
+    req.on("error", reject);
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+
+const sleep = (ms, signal) =>
+  new Promise((resolve, reject) => {
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener?.("abort", () => { clearTimeout(t); reject(new Error("aborted")); }, { once: true });
+  });
+
+async function pollUntilDone({ host, port, apiKey, requestId, connectionId, timeoutSec, pollIntervalMs, signal, onProgress }) {
+  const deadline = Date.now() + timeoutSec * 1000;
+  while (true) {
+    if (signal?.aborted) throw new Error("aborted");
+    if (Date.now() > deadline) {
+      throw new Error(`Timed out after ${timeoutSec}s waiting for video job ${requestId}`);
+    }
+
+    const res = await gatewayRequestWithConnection({ host, port, apiKey, requestId, connectionId, signal });
+    if (res.status === 200 && res.body) {
+      const status = String(res.body.status || "").toLowerCase();
+      onProgress?.(status || "pending", res.body.progress);
+      if (FAILED_STATUSES.has(status)) {
+        const msg = res.body.error?.message || res.body.error || "video generation failed";
+        throw new Error(`Job ${requestId} failed: ${sanitizeText(typeof msg === "string" ? msg : JSON.stringify(msg))}`);
+      }
+      if (TERMINAL_STATUSES.has(status)) return res.body;
+    } else if (res.status >= 400 && res.status !== 429 && res.status !== 503) {
+      throw new Error(`Polling failed (HTTP ${res.status}): ${sanitizeText(res.raw?.slice(0, 300))}`);
+    }
+    await sleep(pollIntervalMs, signal);
+  }
+}
+
+function gatewayRequestWithConnection({ host, port, apiKey, requestId, connectionId, signal }) {
+  return new Promise((resolve, reject) => {
+    const headers = { Accept: "application/json" };
+    if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+    if (connectionId) headers["x-connection-id"] = connectionId;
+    const req = http.request(
+      { hostname: host, port, path: `/v1/videos/${encodeURIComponent(requestId)}`, method: "GET", headers, signal },
+      (res) => {
+        let data = "";
+        res.on("data", (c) => (data += c));
+        res.on("end", () => {
+          let parsed = null;
+          try { parsed = data ? JSON.parse(data) : null; } catch {                }
+          resolve({ status: res.statusCode, body: parsed, raw: data });
+        });
+      }
+    );
+    req.on("error", reject);
+    req.end();
+  });
+}
+
+async function downloadToFile(url, outputPath, { signal } = {}) {
+  const partPath = `${outputPath}.part`;
+  await new Promise((resolve, reject) => {
+    const cleanupAnd = (fn) => (err) => {
+      try { fs.unlinkSync(partPath); } catch {                       }
+      fn(err);
+    };
+    const get = (target, redirectsLeft) => {
+      const mod = target.startsWith("https:") ? https : http;
+      const req = mod.get(target, { signal }, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location && redirectsLeft > 0) {
+          res.resume();
+          return get(new URL(res.headers.location, target).toString(), redirectsLeft - 1);
+        }
+        if (res.statusCode !== 200) {
+          res.resume();
+          return cleanupAnd(reject)(new Error(`Download failed: HTTP ${res.statusCode}`));
+        }
+        const out = fs.createWriteStream(partPath);
+        res.pipe(out);
+        out.on("finish", () => out.close(resolve));
+        out.on("error", cleanupAnd(reject));
+        res.on("error", cleanupAnd(reject));
+      });
+      req.on("error", cleanupAnd(reject));
+    };
+    get(url, 5);
+  });
+  fs.renameSync(partPath, outputPath);
+}
+
+async function run(argv) {
+  let opts;
+  try {
+    opts = parseArgs(argv);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    console.log(HELP);
+    return 1;
+  }
+  if (opts.help) {
+    console.log(HELP);
+    return 0;
+  }
+  if (!opts.prompt) {
+    console.error("Error: --prompt is required");
+    console.log(HELP);
+    return 1;
+  }
+
+  const controller = new AbortController();
+  const partPath = `${opts.output}.part`;
+  const onSigint = () => {
+    controller.abort();
+    try { fs.unlinkSync(partPath); } catch {              }
+    console.error("\nCancelled");
+    process.exit(130);
+  };
+  process.on("SIGINT", onSigint);
+
+  try {
+    const body = { model: opts.model, prompt: opts.prompt };
+    if (opts.duration) body.duration = opts.duration;
+    if (opts.aspectRatio) body.aspect_ratio = opts.aspectRatio;
+    if (opts.resolution) body.resolution = opts.resolution;
+    if (opts.image) body.image = { url: imageInputToUrl(opts.image) };
+
+    console.log(`Requesting video (${opts.model})…`);
+    const create = await gatewayRequest({
+      host: opts.host, port: opts.port, apiKey: opts.apiKey,
+      method: "POST", reqPath: "/v1/videos/generations", body, signal: controller.signal,
+    });
+
+    if (create.status !== 200 || !create.body?.request_id) {
+      const detail = create.body?.error?.message || create.body?.error || create.raw || `HTTP ${create.status}`;
+      console.error(`Error: Create failed: ${sanitizeText(typeof detail === "string" ? detail : JSON.stringify(detail)).slice(0, 500)}`);
+      if (create.status === 400 && /No credentials/i.test(String(detail))) {
+        console.error("   Connect an xAI account first: dashboard → Providers → xAI (Grok).");
+      }
+      return 1;
+    }
+
+    const requestId = create.body.request_id;
+    const connectionId = create.headers["x-swayrouter-connection-id"] || null;
+    console.log(`Job accepted: ${requestId}`);
+
+    let lastLine = "";
+    const result = await pollUntilDone({
+      host: opts.host, port: opts.port, apiKey: opts.apiKey,
+      requestId, connectionId,
+      timeoutSec: opts.timeoutSec, pollIntervalMs: opts.pollIntervalMs,
+      signal: controller.signal,
+      onProgress: (status, progress) => {
+        const line = `${status}${Number.isFinite(progress) ? ` ${progress}%` : ""}`;
+        if (line !== lastLine) {
+          lastLine = line;
+          if (process.stdout.isTTY) process.stdout.write(`\r\x1b[K${line}`);
+          else console.log(line);
+        }
+      },
+    });
+    if (process.stdout.isTTY) process.stdout.write("\n");
+
+    const videoUrl = result.video?.url || result.video?.file_output?.public_url;
+    if (!videoUrl) {
+      console.error("Error: Job finished but no video URL was returned");
+      return 1;
+    }
+
+    console.log("Downloading…");
+    await downloadToFile(videoUrl, opts.output, { signal: controller.signal });
+    console.log(`Saved ${opts.output}`);
+    return 0;
+  } catch (err) {
+    if (process.stdout.isTTY) process.stdout.write("\n");
+    console.error(`Error: ${sanitizeText(err?.message || String(err))}`);
+    return 1;
+  } finally {
+    process.removeListener("SIGINT", onSigint);
+  }
+}
+
+module.exports = { run, parseArgs, pollUntilDone, downloadToFile, imageInputToUrl, sanitizeText };