swayrouter 1.0.0

package/cli/src/cli/tray/tray.ps1

@@ -0,0 +1,129 @@
+param([string]$IconPath, [string]$Tooltip)
+
+$ErrorActionPreference = "Stop"
+
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+
+public static class WinDpiAwareness {
+  public static IntPtr PerMonitorAwareV2 { get { return new IntPtr(-4); } }
+  public static IntPtr PerMonitorAware { get { return new IntPtr(-3); } }
+
+  [DllImport("user32.dll")]
+  public static extern bool SetProcessDpiAwarenessContext(IntPtr value);
+
+  [DllImport("user32.dll")]
+  public static extern IntPtr SetThreadDpiAwarenessContext(IntPtr value);
+
+  [DllImport("shcore.dll")]
+  public static extern int SetProcessDpiAwareness(int value);
+
+  [DllImport("user32.dll")]
+  public static extern bool SetProcessDPIAware();
+}
+"@
+
+function Enable-HighDpiAwareness {
+  $contexts = @(
+    [WinDpiAwareness]::PerMonitorAwareV2,
+    [WinDpiAwareness]::PerMonitorAware
+  )
+
+  foreach ($context in $contexts) {
+    try {
+      if ([WinDpiAwareness]::SetProcessDpiAwarenessContext($context)) { break }
+    } catch {}
+  }
+
+  try { [WinDpiAwareness]::SetProcessDpiAwareness(2) | Out-Null } catch {}
+  try { [WinDpiAwareness]::SetProcessDPIAware() | Out-Null } catch {}
+
+  foreach ($context in $contexts) {
+    try {
+      $previous = [WinDpiAwareness]::SetThreadDpiAwarenessContext($context)
+      if ($previous -ne [IntPtr]::Zero) { break }
+    } catch {}
+  }
+}
+
+Enable-HighDpiAwareness
+
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+
+[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+[Console]::InputEncoding = [System.Text.Encoding]::UTF8
+$OutputEncoding = [System.Text.Encoding]::UTF8
+
+[System.Windows.Forms.Application]::EnableVisualStyles()
+[System.Windows.Forms.Application]::SetCompatibleTextRenderingDefault($false)
+
+$script:notifyIcon = New-Object System.Windows.Forms.NotifyIcon
+$script:notifyIcon.Icon = New-Object System.Drawing.Icon($IconPath)
+$script:notifyIcon.Text = $Tooltip
+$script:notifyIcon.Visible = $true
+
+$script:menu = New-Object System.Windows.Forms.ContextMenuStrip
+$script:notifyIcon.ContextMenuStrip = $script:menu
+$script:items = @()
+
+function Write-Event($obj) {
+  $json = $obj | ConvertTo-Json -Compress
+  [Console]::Out.WriteLine($json)
+  [Console]::Out.Flush()
+}
+
+function Add-MenuItem($index, $title, $enabled, $checked) {
+  $item = New-Object System.Windows.Forms.ToolStripMenuItem
+  $item.Text = $title
+  $item.Enabled = $enabled
+  $item.Checked = [bool]$checked
+  $idx = $index
+  $item.Add_Click({ Write-Event @{ type = "click"; index = $idx } }.GetNewClosure())
+  $script:menu.Items.Add($item) | Out-Null
+  $script:items += $item
+}
+
+function Update-MenuItem($index, $title, $enabled, $checked) {
+  if ($index -lt $script:items.Count) {
+    $script:items[$index].Text = $title
+    $script:items[$index].Enabled = $enabled
+    $script:items[$index].Checked = [bool]$checked
+  }
+}
+
+function Set-Tooltip($text) {
+
+  if ($text.Length -gt 63) { $text = $text.Substring(0, 63) }
+  $script:notifyIcon.Text = $text
+}
+
+$script:timer = New-Object System.Windows.Forms.Timer
+$script:timer.Interval = 100
+$script:timer.Add_Tick({
+  try {
+    while ([Console]::In.Peek() -ne -1) {
+      $line = [Console]::In.ReadLine()
+      if ([string]::IsNullOrWhiteSpace($line)) { continue }
+      $cmd = $line | ConvertFrom-Json
+      switch ($cmd.action) {
+        "add-item"    { Add-MenuItem $cmd.index $cmd.title $cmd.enabled $cmd.checked }
+        "update-item" { Update-MenuItem $cmd.index $cmd.title $cmd.enabled $cmd.checked }
+        "set-tooltip" { Set-Tooltip $cmd.text }
+        "ready"       { Write-Event @{ type = "ready" } }
+        "kill"        {
+          $script:notifyIcon.Visible = $false
+          $script:notifyIcon.Dispose()
+          [System.Windows.Forms.Application]::Exit()
+        }
+      }
+    }
+  } catch {
+    Write-Event @{ type = "error"; message = $_.Exception.Message }
+  }
+})
+$script:timer.Start()
+
+Write-Event @{ type = "started" }
+[System.Windows.Forms.Application]::Run()

package/cli/src/cli/tray/trayHost.js

@@ -0,0 +1,157 @@
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { execFileSync } = require("node:child_process");
+
+const LOCK_FILE = "swayrouter-tray.json";
+
+function defaultDataDirectory() {
+  return process.platform === "win32"
+    ? path.join(process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"), ".swayrouter")
+    : path.join(os.homedir(), ".swayrouter");
+}
+
+function trayLockPath(installation = {}) {
+  const configured = String(installation.dataDir || "");
+  const dataDir = configured && !configured.startsWith("docker-volume:")
+    ? configured
+    : defaultDataDirectory();
+  return path.join(dataDir, "runtime", LOCK_FILE);
+}
+
+function readLock(lockPath) {
+  try {
+    const record = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+    return Number.isInteger(record?.pid) && record.pid > 0 ? record : null;
+  } catch {
+    return null;
+  }
+}
+
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function removeLockIfOwned(lockPath, pid) {
+  const record = readLock(lockPath);
+  if (record?.pid !== pid) return false;
+  try { fs.rmSync(lockPath, { force: true }); } catch {}
+  return true;
+}
+
+function stopLegacyTrayHosts(installation) {
+  if (process.platform !== "win32") return 0;
+
+  const lockPath = trayLockPath(installation);
+  const activePid = readLock(lockPath)?.pid || 0;
+  const installDir = path.resolve(installation.installDir || process.cwd())
+    .toLowerCase()
+    .replace(/'/g, "''");
+  const script = [
+    `$currentPid = ${process.pid}`,
+    `$activePid = ${activePid}`,
+    `$installDir = '${installDir}'`,
+    "$trayPids = Get-CimInstance Win32_Process | Where-Object {",
+    "  $_.Name -match '^(node|bun)(\\.exe)?$' -and",
+    "  $_.ProcessId -ne $currentPid -and",
+    "  $_.ProcessId -ne $activePid -and",
+    "  $_.CommandLine -and",
+    "  $_.CommandLine.ToLowerInvariant().Contains('--tray') -and",
+    "  $_.CommandLine.ToLowerInvariant().Contains($installDir)",
+    "} | Select-Object -ExpandProperty ProcessId",
+    "$trayPids",
+  ].join("; ");
+
+  let pids = [];
+  try {
+    const output = execFileSync("powershell.exe", ["-NoProfile", "-Command", script], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true,
+    });
+    pids = String(output).split(/\r?\n/)
+      .map((value) => Number.parseInt(value.trim(), 10))
+      .filter((pid) => Number.isInteger(pid) && pid > 0);
+  } catch {
+    return 0;
+  }
+
+  for (const pid of new Set(pids)) {
+    try {
+      execFileSync("taskkill.exe", ["/F", "/T", "/PID", String(pid)], {
+        stdio: "ignore",
+        windowsHide: true,
+      });
+    } catch {}
+  }
+  return new Set(pids).size;
+}
+
+function acquireTrayLock(installation, port) {
+  const lockPath = trayLockPath(installation);
+  fs.mkdirSync(path.dirname(lockPath), { recursive: true, mode: 0o700 });
+
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      const fd = fs.openSync(lockPath, "wx", 0o600);
+      fs.writeFileSync(fd, `${JSON.stringify({
+        pid: process.pid,
+        installDir: path.resolve(installation.installDir || process.cwd()),
+        port: Number(port) || 14045,
+        startedAt: new Date().toISOString(),
+      })}\n`);
+      fs.closeSync(fd);
+
+      let released = false;
+      const release = () => {
+        if (released) return;
+        released = true;
+        process.removeListener("exit", release);
+        removeLockIfOwned(lockPath, process.pid);
+      };
+      process.once("exit", release);
+      return { lockPath, release };
+    } catch (error) {
+      if (error?.code !== "EEXIST") return null;
+      const existing = readLock(lockPath);
+      if (existing?.pid && processAlive(existing.pid)) return null;
+      try { fs.rmSync(lockPath, { force: true }); } catch {}
+    }
+  }
+
+  return null;
+}
+
+async function stopTrayHost(installation) {
+  const lockPath = trayLockPath(installation);
+  const record = readLock(lockPath);
+  if (!record || record.pid === process.pid) return false;
+
+  if (processAlive(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 {}
+
+    const deadline = Date.now() + 2500;
+    while (processAlive(record.pid) && Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+  }
+
+  if (!processAlive(record.pid)) removeLockIfOwned(lockPath, record.pid);
+  return true;
+}
+
+module.exports = { acquireTrayLock, stopLegacyTrayHosts, stopTrayHost, trayLockPath };

package/cli/src/cli/tray/trayWin.js

@@ -0,0 +1,83 @@
+const { spawn } = require("child_process");
+const path = require("path");
+const readline = require("readline");
+
+let psProcess = null;
+let clickHandler = null;
+
+function sendCommand(cmd) {
+  if (psProcess && psProcess.stdin.writable) {
+    psProcess.stdin.write(`${JSON.stringify(cmd)}\n`, "utf8");
+  }
+}
+
+function initWinTray(options) {
+  const { iconPath, tooltip, items, onClick } = options;
+  clickHandler = onClick;
+
+  const scriptPath = path.join(__dirname, "tray.ps1");
+
+  try {
+    psProcess = spawn(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-ExecutionPolicy", "Bypass",
+        "-WindowStyle", "Hidden",
+        "-InputFormat", "Text",
+        "-OutputFormat", "Text",
+        "-File", scriptPath,
+        "-IconPath", iconPath,
+        "-Tooltip", tooltip
+      ],
+      { windowsHide: true, stdio: ["pipe", "pipe", "pipe"] }
+    );
+  } catch (err) {
+    return null;
+  }
+
+  const rl = readline.createInterface({ input: psProcess.stdout });
+  rl.on("line", (line) => {
+    try {
+      const evt = JSON.parse(line);
+      if (evt.type === "click" && clickHandler) {
+        clickHandler(evt.index);
+      }
+    } catch (e) {}
+  });
+
+  psProcess.on("error", () => {});
+  psProcess.stderr.on("data", () => {});
+
+  items.forEach((item, index) => {
+    sendCommand({
+      action: "add-item",
+      index,
+      title: item.title,
+      enabled: item.enabled,
+      checked: item.checked === true,
+    });
+  });
+
+  return {
+    updateItem(index, title, enabled, checked = false) {
+      sendCommand({ action: "update-item", index, title, enabled, checked });
+    },
+    setTooltip(text) {
+      sendCommand({ action: "set-tooltip", text });
+    },
+    kill() {
+      try {
+        sendCommand({ action: "kill" });
+      } catch (e) {}
+      setTimeout(() => {
+        if (psProcess && !psProcess.killed) {
+          try { psProcess.kill(); } catch (e) {}
+        }
+        psProcess = null;
+      }, 300);
+    }
+  };
+}
+
+module.exports = { initWinTray };

package/cli/src/cli/utils/display.js

@@ -0,0 +1,123 @@
+const COLORS = {
+  reset: "\x1b[0m",
+  success: "\x1b[32m",
+  error: "\x1b[31m",
+  warning: "\x1b[33m",
+  info: "\x1b[36m"
+};
+
+function showStatus(message, type = "info") {
+  const labels = {
+    success: "OK",
+    error: "ERROR",
+    warning: "WARN",
+    info: "INFO"
+  };
+
+  const color = COLORS[type] || COLORS.info;
+  const label = labels[type] || labels.info;
+
+  console.log(`${color}${label}${COLORS.reset}  ${message}`);
+}
+
+const PROGRESS_WIDTH = 40;
+
+function formatProgressBar(percent, width = PROGRESS_WIDTH) {
+  const safeWidth = Math.max(1, Math.floor(Number(width) || PROGRESS_WIDTH));
+  const value = Math.max(0, Math.min(100, Math.round(Number(percent) || 0)));
+  const filled = Math.round((value / 100) * safeWidth);
+  return `${"▰".repeat(filled)}${"▱".repeat(safeWidth - filled)} ${String(value).padStart(3, " ")}%`;
+}
+
+function formatActivityBar(step, width = PROGRESS_WIDTH, pulseWidth = 8) {
+  const safeWidth = Math.max(1, Math.floor(Number(width) || PROGRESS_WIDTH));
+  const safePulse = Math.max(1, Math.min(safeWidth, Math.floor(Number(pulseWidth) || 8)));
+  const cycleWidth = Math.max(1, safeWidth - safePulse + 1);
+  const start = ((Math.floor(Number(step) || 0) % cycleWidth) + cycleWidth) % cycleWidth;
+  const track = Array.from({ length: safeWidth }, () => "▱");
+  for (let index = start; index < start + safePulse; index += 1) track[index] = "▰";
+  return `${track.join("")} …`;
+}
+
+function createProgress(label, { stream = process.stdout, intervalMs = 80, indeterminate = false } = {}) {
+  const interactive = Boolean(stream?.isTTY);
+  let current = 10;
+  let target = 92;
+  let message = String(label || "Loading");
+  let timer = null;
+  let active = false;
+  let rendered = false;
+  let activityStep = 0;
+
+  const render = () => {
+    if (!interactive || !active) return;
+    const moveToPreviousFrame = rendered ? "\x1b[1A\r\x1b[2K" : "\r\x1b[2K";
+    const bar = indeterminate ? formatActivityBar(activityStep) : formatProgressBar(current);
+    stream.write(`${moveToPreviousFrame}${message}\n\r\x1b[2K${bar}`);
+    rendered = true;
+  };
+
+  const stopTimer = () => {
+    if (!timer) return;
+    clearInterval(timer);
+    timer = null;
+  };
+
+  return {
+    start() {
+      if (!interactive || active) return;
+      active = true;
+      render();
+      timer = setInterval(() => {
+        if (indeterminate) {
+          activityStep += 1;
+          render();
+          return;
+        }
+        if (current >= target) return;
+        current = Math.min(target, current + 2);
+        render();
+      }, intervalMs);
+      timer.unref?.();
+    },
+    update(percent, nextMessage = message) {
+      target = Math.max(0, Math.min(100, Math.round(Number(percent) || 0)));
+      current = Math.min(current, target);
+      message = String(nextMessage || message);
+      render();
+    },
+    finish(doneMessage = `${label} complete`) {
+      if (!interactive) return;
+      current = 100;
+      target = 100;
+      message = String(doneMessage || label || "Complete");
+      render();
+      stopTimer();
+      active = false;
+      stream.write("\n");
+    },
+    fail() {
+      if (!interactive) return;
+      stopTimer();
+      active = false;
+      if (rendered) stream.write("\x1b[1A\r\x1b[2K\n\r\x1b[2K\n");
+      else stream.write("\r\x1b[2K\n");
+      rendered = false;
+    },
+  };
+}
+
+async function withProgress(label, task, options = {}) {
+  const progress = createProgress(label, options);
+  progress.start();
+  try {
+    const result = await task(progress);
+    progress.finish(options.doneMessage || `${label} complete`);
+    return result;
+  } catch (error) {
+    progress.fail();
+    throw error;
+  }
+}
+
+module.exports = { createProgress, formatActivityBar, formatProgressBar, showStatus, withProgress };

package/cli/src/cli/utils/input.js

@@ -0,0 +1,138 @@
+const readline = require("readline");
+
+const COLORS = {
+  reset: "\x1b[0m",
+  green: "\x1b[32m",
+  red: "\x1b[31m",
+  white: "\x1b[37m"
+};
+
+let rawPrimed = false;
+function primeRawOnce() {
+  if (rawPrimed || !process.stdin.isTTY) return;
+  try {
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.setEncoding("utf8");
+    process.stdin.resume();
+    rawPrimed = true;
+  } catch {}
+}
+
+function suspendRawFor(fn) {
+
+  const wasPrimed = rawPrimed;
+  if (wasPrimed && process.stdin.isTTY) {
+    try { process.stdin.setRawMode(false); } catch {}
+  }
+  return fn().finally(() => {
+    if (wasPrimed && process.stdin.isTTY) {
+      try { process.stdin.setRawMode(true); } catch {}
+      process.stdin.resume();
+    }
+  });
+}
+
+async function prompt(question) {
+  return suspendRawFor(() => new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve((answer || "").trim());
+    });
+  }));
+}
+
+async function select(question, options) {
+  console.log(question);
+  options.forEach((opt, i) => console.log(`  ${i + 1}. ${opt}`));
+  while (true) {
+    const answer = await prompt("\nSelect option (number): ");
+    const num = parseInt(answer, 10);
+    if (!isNaN(num) && num >= 1 && num <= options.length) return num - 1;
+    console.log(`Invalid selection. Please enter a number between 1 and ${options.length}`);
+  }
+}
+
+async function confirm(question) {
+  while (true) {
+    const answer = await prompt(`${question} (y/n): `);
+    const lower = answer.toLowerCase();
+    if (lower === "y" || lower === "yes") return true;
+    if (lower === "n" || lower === "no") return false;
+    console.log("Please answer 'y' or 'n'");
+  }
+}
+
+async function pause(message = "Press Enter to continue...") {
+  return suspendRawFor(() => new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(message, () => { rl.close(); resolve(); });
+  }));
+}
+
+async function selectMenu(title, items, defaultIndex = 0, subtitle = "", headerContent = "", breadcrumb = []) {
+  return new Promise((resolve) => {
+    let selectedIndex = defaultIndex;
+    let isActive = true;
+
+    primeRawOnce();
+    if (!process.stdin.isTTY) { resolve(null); return; }
+
+    const renderMenu = () => {
+      if (!isActive) return;
+      process.stdout.write("\x1b[2J\x1b[H");
+      console.log(title);
+      if (subtitle) console.log(subtitle);
+      if (breadcrumb.length > 0) console.log(breadcrumb.join(" > "));
+      console.log();
+      if (headerContent) { console.log(headerContent); console.log(); }
+
+      items.forEach((item, index) => {
+        const isSelected = index === selectedIndex;
+        if (isSelected) {
+          console.log(`${COLORS.green}> ${item.label}${COLORS.reset}`);
+        } else {
+          console.log(`  ${item.label}`);
+        }
+      });
+    };
+
+    const cleanup = () => {
+      if (!isActive) return;
+      isActive = false;
+      process.stdin.removeListener("keypress", onKeypress);
+      if (rawPrimed && process.stdin.isTTY) {
+        try { process.stdin.setRawMode(false); } catch {}
+      }
+      process.stdin.pause();
+      rawPrimed = false;
+    };
+
+    const move = (delta) => {
+      selectedIndex = (selectedIndex + delta + items.length) % items.length;
+      renderMenu();
+    };
+
+    const onKeypress = (_str, key) => {
+      if (!isActive || !key) return;
+      if (key.name === "up") return move(-1);
+      if (key.name === "down") return move(1);
+      if (key.name === "return") { cleanup(); resolve(selectedIndex); return; }
+      if (key.name === "escape") { cleanup(); resolve(-1); return; }
+      if (key.ctrl && key.name === "c") { cleanup(); resolve(-1); }
+    };
+
+    process.stdin.on("keypress", onKeypress);
+    renderMenu();
+  });
+}
+
+module.exports = {
+  prompt,
+  select,
+  confirm,
+  pause,
+  selectMenu,
+  COLORS
+};