@statechange/ssh-tunnel-manager 0.1.0

package/dist/app.mjs

@@ -0,0 +1,563 @@
+import { createRequire } from "module"; const require = createRequire(import.meta.url);
+
+// src/app/main.ts
+import { app, Tray, Menu, BrowserWindow, ipcMain, nativeImage } from "electron";
+import { join as join3, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/core/config.ts
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var BASE_DIR = join(homedir(), ".ssh-tunnels");
+var CONFIG_PATH = join(BASE_DIR, "config.json");
+var PIDS_DIR = join(BASE_DIR, "pids");
+var HISTORY_DIR = join(BASE_DIR, "history");
+function getConfigPath() {
+  return CONFIG_PATH;
+}
+function getPidsDir() {
+  return PIDS_DIR;
+}
+function getHistoryDir() {
+  return HISTORY_DIR;
+}
+async function ensureDirs() {
+  await mkdir(BASE_DIR, { recursive: true });
+  await mkdir(PIDS_DIR, { recursive: true });
+  await mkdir(HISTORY_DIR, { recursive: true });
+}
+async function readConfig() {
+  await ensureDirs();
+  try {
+    const raw = await readFile(CONFIG_PATH, "utf-8");
+    const parsed = JSON.parse(raw);
+    return validateConfig(parsed);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      const defaultConfig = { tunnels: [] };
+      await writeConfig(defaultConfig);
+      return defaultConfig;
+    }
+    throw err;
+  }
+}
+async function writeConfig(config) {
+  await ensureDirs();
+  await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function validateConfig(data) {
+  if (!data || typeof data !== "object") {
+    throw new Error("Invalid config: expected an object");
+  }
+  const obj = data;
+  if (!Array.isArray(obj.tunnels)) {
+    throw new Error("Invalid config: expected tunnels array");
+  }
+  for (const t of obj.tunnels) {
+    if (!t.id || typeof t.id !== "string") throw new Error("Invalid tunnel: missing id");
+    if (!t.host || typeof t.host !== "string") throw new Error(`Invalid tunnel ${t.id}: missing host`);
+    if (typeof t.localPort !== "number") throw new Error(`Invalid tunnel ${t.id}: missing localPort`);
+    if (!t.remoteHost || typeof t.remoteHost !== "string") throw new Error(`Invalid tunnel ${t.id}: missing remoteHost`);
+    if (typeof t.remotePort !== "number") throw new Error(`Invalid tunnel ${t.id}: missing remotePort`);
+  }
+  return data;
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+
+// src/core/tunnel.ts
+import { spawn } from "node:child_process";
+import { readFile as readFile2, writeFile as writeFile2, unlink } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import { createConnection } from "node:net";
+function pidFilePath(id) {
+  return join2(getPidsDir(), `${id}.pid`);
+}
+function logFilePath(id) {
+  return join2(getHistoryDir(), `${id}.log`);
+}
+async function readPid(id) {
+  try {
+    const raw = await readFile2(pidFilePath(id), "utf-8");
+    const pid = parseInt(raw.trim(), 10);
+    return isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function probePort(port, host = "127.0.0.1", timeoutMs = 1e3) {
+  return new Promise((resolve) => {
+    const socket = createConnection({ port, host, timeout: timeoutMs });
+    socket.on("connect", () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.on("error", () => {
+      socket.destroy();
+      resolve(false);
+    });
+    socket.on("timeout", () => {
+      socket.destroy();
+      resolve(false);
+    });
+  });
+}
+async function getTunnelStatus(tunnel) {
+  const pid = await readPid(tunnel.id);
+  const alive = pid !== null && isProcessAlive(pid);
+  const portOpen = alive ? await probePort(tunnel.localPort) : false;
+  return {
+    id: tunnel.id,
+    name: tunnel.name,
+    enabled: tunnel.enabled,
+    pid,
+    alive,
+    portOpen,
+    localPort: tunnel.localPort,
+    remoteHost: tunnel.remoteHost,
+    remotePort: tunnel.remotePort,
+    host: tunnel.host
+  };
+}
+async function startTunnel(tunnel) {
+  const args = [
+    "-N",
+    // No remote command
+    "-L",
+    `${tunnel.localPort}:${tunnel.remoteHost}:${tunnel.remotePort}`,
+    "-o",
+    "ServerAliveInterval=30",
+    "-o",
+    "ServerAliveCountMax=3",
+    "-o",
+    "ExitOnForwardFailure=yes",
+    "-o",
+    "StrictHostKeyChecking=accept-new"
+  ];
+  if (tunnel.user) {
+    args.push("-l", tunnel.user);
+  }
+  if (tunnel.sshPort && tunnel.sshPort !== 22) {
+    args.push("-p", String(tunnel.sshPort));
+  }
+  if (tunnel.identityFile) {
+    const expandedPath = tunnel.identityFile.replace(/^~/, process.env.HOME || "");
+    args.push("-i", expandedPath);
+  }
+  if (tunnel.extraArgs) {
+    args.push(...tunnel.extraArgs);
+  }
+  args.push(tunnel.host);
+  const { openSync } = await import("node:fs");
+  const logFd = openSync(logFilePath(tunnel.id), "a");
+  const child = spawn("ssh", args, {
+    detached: true,
+    stdio: ["ignore", logFd, logFd]
+  });
+  const { closeSync } = await import("node:fs");
+  closeSync(logFd);
+  child.unref();
+  if (child.pid === void 0) {
+    throw new Error(`Failed to start tunnel ${tunnel.id}`);
+  }
+  await writeFile2(pidFilePath(tunnel.id), String(child.pid), "utf-8");
+  return child.pid;
+}
+async function stopTunnel(id) {
+  const pid = await readPid(id);
+  if (pid === null) return;
+  if (isProcessAlive(pid)) {
+    const treeKill = (await import("tree-kill")).default;
+    await new Promise((resolve, reject) => {
+      treeKill(pid, "SIGTERM", (err) => {
+        if (err) {
+          treeKill(pid, "SIGKILL", () => resolve());
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+  try {
+    await unlink(pidFilePath(id));
+  } catch {
+  }
+}
+async function cleanStalePid(id) {
+  const pid = await readPid(id);
+  if (pid !== null && !isProcessAlive(pid)) {
+    try {
+      await unlink(pidFilePath(id));
+    } catch {
+    }
+  }
+}
+
+// src/core/sync.ts
+async function sync(config) {
+  const cfg = config ?? await readConfig();
+  const result = {
+    started: [],
+    stopped: [],
+    alreadyRunning: [],
+    alreadyStopped: [],
+    errors: []
+  };
+  for (const tunnel of cfg.tunnels) {
+    try {
+      await cleanStalePid(tunnel.id);
+      const status = await getTunnelStatus(tunnel);
+      if (tunnel.enabled) {
+        if (status.alive && status.portOpen) {
+          result.alreadyRunning.push(tunnel.id);
+        } else {
+          if (status.alive && !status.portOpen) {
+            await stopTunnel(tunnel.id);
+          }
+          await startTunnel(tunnel);
+          result.started.push(tunnel.id);
+        }
+      } else {
+        if (status.alive) {
+          await stopTunnel(tunnel.id);
+          result.stopped.push(tunnel.id);
+        } else {
+          result.alreadyStopped.push(tunnel.id);
+        }
+      }
+    } catch (err) {
+      result.errors.push({
+        id: tunnel.id,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return result;
+}
+async function getStatus(config) {
+  const cfg = config ?? await readConfig();
+  const statuses = [];
+  for (const tunnel of cfg.tunnels) {
+    await cleanStalePid(tunnel.id);
+    statuses.push(await getTunnelStatus(tunnel));
+  }
+  return statuses;
+}
+
+// src/core/watch.ts
+import { watch as chokidarWatch } from "chokidar";
+function watchConfig(options) {
+  const configPath = getConfigPath();
+  const debounceMs = options?.debounceMs ?? 500;
+  let debounceTimer = null;
+  let syncing = false;
+  const doSync = async () => {
+    if (syncing) return;
+    syncing = true;
+    try {
+      const result = await sync();
+      options?.onSync?.(result);
+    } catch (err) {
+      options?.onError?.(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      syncing = false;
+    }
+  };
+  const watcher = chokidarWatch(configPath, {
+    persistent: true,
+    ignoreInitial: true
+  });
+  watcher.on("change", () => {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(doSync, debounceMs);
+  });
+  return {
+    close: async () => {
+      if (debounceTimer) clearTimeout(debounceTimer);
+      await watcher.close();
+    }
+  };
+}
+
+// src/app/main.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var tray = null;
+var addWindow = null;
+var configWatcher = null;
+var syncTimer = null;
+var currentStatuses = [];
+function buildPng(width, height, rgba) {
+  function crc32(buf) {
+    let c = 4294967295;
+    for (let i = 0; i < buf.length; i++) {
+      c ^= buf[i];
+      for (let j = 0; j < 8; j++) c = c >>> 1 ^ (c & 1 ? 3988292384 : 0);
+    }
+    return (c ^ 4294967295) >>> 0;
+  }
+  function adler32(buf) {
+    let a = 1, b = 0;
+    for (let i = 0; i < buf.length; i++) {
+      a = (a + buf[i]) % 65521;
+      b = (b + a) % 65521;
+    }
+    return (b << 16 | a) >>> 0;
+  }
+  function chunk(type, data) {
+    const len = Buffer.alloc(4);
+    len.writeUInt32BE(data.length);
+    const typeAndData = Buffer.concat([Buffer.from(type, "ascii"), data]);
+    const crc = Buffer.alloc(4);
+    crc.writeUInt32BE(crc32(typeAndData));
+    return Buffer.concat([len, typeAndData, crc]);
+  }
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(width, 0);
+  ihdr.writeUInt32BE(height, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 6;
+  ihdr[10] = 0;
+  ihdr[11] = 0;
+  ihdr[12] = 0;
+  const rowSize = width * 4 + 1;
+  const rawData = Buffer.alloc(rowSize * height);
+  for (let y = 0; y < height; y++) {
+    rawData[y * rowSize] = 0;
+    rgba.copy(rawData, y * rowSize + 1, y * width * 4, (y + 1) * width * 4);
+  }
+  const blocks = [];
+  const maxBlock = 65535;
+  for (let offset = 0; offset < rawData.length; offset += maxBlock) {
+    const end = Math.min(offset + maxBlock, rawData.length);
+    const isLast = end === rawData.length;
+    const blockData = rawData.subarray(offset, end);
+    const header = Buffer.alloc(5);
+    header[0] = isLast ? 1 : 0;
+    header.writeUInt16LE(blockData.length, 1);
+    header.writeUInt16LE(~blockData.length & 65535, 3);
+    blocks.push(header, blockData);
+  }
+  const deflateData = Buffer.concat(blocks);
+  const zlibHeader = Buffer.from([120, 1]);
+  const adler = Buffer.alloc(4);
+  adler.writeUInt32BE(adler32(rawData));
+  const compressedData = Buffer.concat([zlibHeader, deflateData, adler]);
+  const signature = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+  const iend = chunk("IEND", Buffer.alloc(0));
+  return Buffer.concat([signature, chunk("IHDR", ihdr), chunk("IDAT", compressedData), iend]);
+}
+function createTrayIcon(state) {
+  const size = 32;
+  const colors = {
+    green: [52, 199, 89],
+    yellow: [255, 149, 0],
+    red: [255, 59, 48]
+  };
+  const [r, g, b] = colors[state];
+  const cx = size / 2;
+  const cy = size / 2;
+  const radius = 8;
+  const rgba = Buffer.alloc(size * size * 4, 0);
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      const dx = x - cx;
+      const dy = y - cy;
+      const dist = Math.sqrt(dx * dx + dy * dy);
+      if (dist <= radius) {
+        const alpha = dist > radius - 1 ? Math.max(0, Math.round((radius - dist) * 255)) : 255;
+        const offset = (y * size + x) * 4;
+        rgba[offset] = r;
+        rgba[offset + 1] = g;
+        rgba[offset + 2] = b;
+        rgba[offset + 3] = alpha;
+      }
+    }
+  }
+  const png = buildPng(size, size, rgba);
+  return nativeImage.createFromBuffer(png, { scaleFactor: 2 });
+}
+function getTrayState() {
+  const enabled = currentStatuses.filter((s) => s.enabled);
+  if (enabled.length === 0) return "green";
+  const allRunning = enabled.every((s) => s.alive && s.portOpen);
+  if (allRunning) return "green";
+  const anyRunning = enabled.some((s) => s.alive && s.portOpen);
+  return anyRunning ? "yellow" : "red";
+}
+async function refreshStatuses() {
+  try {
+    currentStatuses = await getStatus();
+  } catch {
+    currentStatuses = [];
+  }
+}
+async function buildTrayMenu() {
+  await refreshStatuses();
+  const tunnelItems = currentStatuses.map((s) => ({
+    label: `${s.alive && s.portOpen ? "\u25CF" : "\u25CB"} ${s.name} \u2014 :${s.localPort} \u2192 ${s.remoteHost}:${s.remotePort}`,
+    type: "checkbox",
+    checked: s.enabled,
+    click: async () => {
+      const config = await readConfig();
+      const tunnel = config.tunnels.find((t) => t.id === s.id);
+      if (tunnel) {
+        tunnel.enabled = !tunnel.enabled;
+        await writeConfig(config);
+        await sync(config);
+        if (tunnel.enabled) {
+          await new Promise((r) => setTimeout(r, 2e3));
+        }
+        await updateTray();
+      }
+    }
+  }));
+  if (tunnelItems.length === 0) {
+    tunnelItems.push({
+      label: "No tunnels configured",
+      enabled: false
+    });
+  }
+  return Menu.buildFromTemplate([
+    ...tunnelItems,
+    { type: "separator" },
+    {
+      label: "Add Tunnel...",
+      click: () => openAddWindow()
+    },
+    {
+      label: "Sync Now",
+      click: async () => {
+        await sync();
+        await updateTray();
+      }
+    },
+    { type: "separator" },
+    {
+      label: `Config: ${getConfigPath()}`,
+      enabled: false
+    },
+    { type: "separator" },
+    {
+      label: "Quit",
+      click: () => {
+        app.quit();
+      }
+    }
+  ]);
+}
+async function updateTray() {
+  if (!tray) return;
+  const menu = await buildTrayMenu();
+  tray.setContextMenu(menu);
+  tray.setImage(createTrayIcon(getTrayState()));
+  const enabled = currentStatuses.filter((s) => s.enabled);
+  const running = enabled.filter((s) => s.alive && s.portOpen);
+  tray.setToolTip(`SSH Tunnels: ${running.length}/${enabled.length} running`);
+}
+function openAddWindow() {
+  if (addWindow) {
+    addWindow.focus();
+    return;
+  }
+  addWindow = new BrowserWindow({
+    width: 480,
+    height: 520,
+    resizable: false,
+    minimizable: false,
+    maximizable: false,
+    title: "Add SSH Tunnel",
+    webPreferences: {
+      preload: join3(__dirname, "preload.js"),
+      contextIsolation: true,
+      nodeIntegration: false
+    }
+  });
+  addWindow.loadFile(join3(__dirname, "..", "renderer", "add-tunnel.html"));
+  addWindow.on("closed", () => {
+    addWindow = null;
+  });
+}
+ipcMain.handle("get-statuses", async () => {
+  await refreshStatuses();
+  return currentStatuses;
+});
+ipcMain.handle("add-tunnel", async (_event, tunnelData) => {
+  console.log("IPC add-tunnel received:", JSON.stringify(tunnelData));
+  const config = await readConfig();
+  const id = slugify(tunnelData.name);
+  if (config.tunnels.some((t) => t.id === id)) {
+    throw new Error(`Tunnel with id '${id}' already exists`);
+  }
+  const tunnel = {
+    ...tunnelData,
+    id,
+    extraArgs: []
+  };
+  config.tunnels.push(tunnel);
+  await writeConfig(config);
+  if (tunnel.enabled) {
+    await sync(config);
+  }
+  await updateTray();
+  return tunnel;
+});
+ipcMain.handle("toggle-tunnel", async (_event, id) => {
+  const config = await readConfig();
+  const tunnel = config.tunnels.find((t) => t.id === id);
+  if (!tunnel) throw new Error(`Tunnel '${id}' not found`);
+  tunnel.enabled = !tunnel.enabled;
+  await writeConfig(config);
+  await sync(config);
+  await updateTray();
+  return tunnel.enabled;
+});
+ipcMain.handle("remove-tunnel", async (_event, id) => {
+  const config = await readConfig();
+  const idx = config.tunnels.findIndex((t) => t.id === id);
+  if (idx === -1) throw new Error(`Tunnel '${id}' not found`);
+  config.tunnels.splice(idx, 1);
+  await writeConfig(config);
+  await stopTunnel(id);
+  await updateTray();
+});
+app.dock?.hide();
+app.whenReady().then(async () => {
+  tray = new Tray(createTrayIcon("yellow"));
+  tray.setToolTip("SSH Tunnels \u2014 loading...");
+  tray.on("mouse-down", async () => {
+    await updateTray();
+  });
+  await updateTray();
+  configWatcher = watchConfig({
+    onSync: async () => {
+      await updateTray();
+    },
+    onError: (err) => {
+      console.error("Config watch error:", err);
+    }
+  });
+  syncTimer = setInterval(async () => {
+    try {
+      await sync();
+      await updateTray();
+    } catch (err) {
+      console.error("Periodic sync error:", err);
+    }
+  }, 3e4);
+});
+app.on("before-quit", async () => {
+  if (configWatcher) await configWatcher.close();
+  if (syncTimer) clearInterval(syncTimer);
+});
+app.on("window-all-closed", () => {
+});