aptunnel 1.0.0

package/src/lib/platform.js

@@ -0,0 +1,225 @@
+import { spawnSync, spawn } from 'child_process';
+import { readFileSync, existsSync } from 'fs';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+
+const execAsync = promisify(exec);
+
+/**
+ * Detect the current operating system.
+ * @returns {'linux' | 'macos' | 'windows' | 'wsl'}
+ */
+export function detectOS() {
+  if (process.platform === 'win32') return 'windows';
+
+  if (process.platform === 'linux') {
+    // WSL detection: /proc/version contains "microsoft" or "WSL"
+    try {
+      const version = readFileSync('/proc/version', 'utf8').toLowerCase();
+      if (version.includes('microsoft') || version.includes('wsl')) {
+        return 'wsl';
+      }
+    } catch {
+      // /proc/version not readable — treat as regular Linux
+    }
+    return 'linux';
+  }
+
+  if (process.platform === 'darwin') return 'macos';
+
+  return 'linux'; // fallback
+}
+
+/**
+ * Check if a port is currently in use.
+ * @param {number} port
+ * @returns {{ inUse: boolean, pid: number | null }}
+ */
+export function isPortInUse(port) {
+  const os = detectOS();
+
+  if (os === 'windows') {
+    const result = spawnSync('netstat', ['-ano'], { encoding: 'utf8' });
+    if (result.status !== 0 || !result.stdout) return { inUse: false, pid: null };
+
+    const lines = result.stdout.split('\n');
+    for (const line of lines) {
+      if (line.includes(`:${port}`) && (line.includes('LISTENING') || line.includes('ESTABLISHED'))) {
+        const parts = line.trim().split(/\s+/);
+        const pid = parseInt(parts[parts.length - 1], 10);
+        return { inUse: true, pid: isNaN(pid) ? null : pid };
+      }
+    }
+    return { inUse: false, pid: null };
+  }
+
+  // Linux / macOS / WSL
+  const result = spawnSync('lsof', ['-ti', `:${port}`], { encoding: 'utf8' });
+  if (result.status !== 0 || !result.stdout.trim()) {
+    return { inUse: false, pid: null };
+  }
+
+  const pid = parseInt(result.stdout.trim().split('\n')[0], 10);
+  return { inUse: true, pid: isNaN(pid) ? null : pid };
+}
+
+/**
+ * Get info about a running process by PID.
+ * @param {number} pid
+ * @returns {{ running: boolean, command: string | null }}
+ */
+export function getProcessInfo(pid) {
+  const os = detectOS();
+
+  if (os === 'windows') {
+    // tasklist is available on all Windows versions; wmic is deprecated/removed in modern Windows.
+    const result = spawnSync(
+      'tasklist',
+      ['/FI', `PID eq ${pid}`, '/NH', '/FO', 'CSV'],
+      { encoding: 'utf8' }
+    );
+    if (result.status !== 0 || !result.stdout.trim()) return { running: false, command: null };
+    // tasklist outputs "INFO: No tasks..." when PID not found; CSV lines otherwise.
+    const lines = result.stdout.trim().split('\n')
+      .filter(l => l.trim() && !l.toLowerCase().startsWith('info'));
+    if (lines.length === 0) return { running: false, command: null };
+    return { running: true, command: lines[0].trim() };
+  }
+
+  // Linux / macOS / WSL
+  const result = spawnSync('ps', ['-p', String(pid), '-o', 'args='], { encoding: 'utf8' });
+  if (result.status !== 0 || !result.stdout.trim()) {
+    return { running: false, command: null };
+  }
+  return { running: true, command: result.stdout.trim() };
+}
+
+/**
+ * Kill a process by PID.
+ * @param {number} pid
+ */
+export function killProcess(pid) {
+  const os = detectOS();
+
+  if (os === 'windows') {
+    spawnSync('taskkill', ['/PID', String(pid), '/F'], { encoding: 'utf8' });
+    return;
+  }
+
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch {
+    // Process may already be gone — ignore
+  }
+}
+
+/**
+ * Get how long a process has been running.
+ * @param {number} pid
+ * @returns {{ hours: number, minutes: number, seconds: number } | null}
+ */
+export function getProcessUptime(pid) {
+  const os = detectOS();
+
+  if (os === 'windows') {
+    // Use PowerShell to get process start time (wmic is deprecated/removed in modern Windows).
+    const result = spawnSync(
+      'powershell',
+      ['-NoProfile', '-NonInteractive', '-Command',
+       `$p = Get-Process -Id ${pid} -ErrorAction SilentlyContinue; if ($p) { $p.StartTime.ToUniversalTime().ToString('o') }`],
+      { encoding: 'utf8' }
+    );
+    if (result.status !== 0 || !result.stdout.trim()) return null;
+    const startDate = new Date(result.stdout.trim());
+    if (isNaN(startDate.getTime())) return null;
+    return computeUptime(startDate);
+  }
+
+  // Linux / macOS — both use `ps -o lstart=`
+  // NOTE: Never use `date -d` (GNU only). We use `new Date()` to parse.
+  const result = spawnSync('ps', ['-o', 'lstart=', '-p', String(pid)], { encoding: 'utf8' });
+  if (result.status !== 0 || !result.stdout.trim()) return null;
+
+  const startDate = new Date(result.stdout.trim());
+  if (isNaN(startDate.getTime())) return null;
+
+  return computeUptime(startDate);
+}
+
+function computeUptime(startDate) {
+  const diffMs = Date.now() - startDate.getTime();
+  if (diffMs < 0) return null;
+
+  const totalSeconds = Math.floor(diffMs / 1000);
+  const hours   = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+  return { hours, minutes, seconds };
+}
+
+/**
+ * Format uptime as "HHhMMmSSs" string.
+ * @param {{ hours: number, minutes: number, seconds: number } | null} uptime
+ * @returns {string}
+ */
+export function formatUptime(uptime) {
+  if (!uptime) return '-';
+  const h = String(uptime.hours).padStart(2, '0');
+  const m = String(uptime.minutes).padStart(2, '0');
+  const s = String(uptime.seconds).padStart(2, '0');
+  return `${h}h${m}m${s}s`;
+}
+
+/**
+ * Open a URL in the system browser.
+ * @param {string} url
+ */
+export function openUrl(url) {
+  const os = detectOS();
+
+  if (os === 'macos') {
+    spawn('open', [url], { detached: true, stdio: 'ignore' }).unref();
+    return;
+  }
+
+  if (os === 'windows') {
+    spawn('cmd', ['/c', 'start', url], { detached: true, stdio: 'ignore' }).unref();
+    return;
+  }
+
+  if (os === 'wsl') {
+    // Try wslview first, fall back to cmd.exe
+    const which = spawnSync('which', ['wslview'], { encoding: 'utf8' });
+    if (which.status === 0) {
+      spawn('wslview', [url], { detached: true, stdio: 'ignore' }).unref();
+    } else {
+      spawn('cmd.exe', ['/c', 'start', url], { detached: true, stdio: 'ignore' }).unref();
+    }
+    return;
+  }
+
+  // Linux
+  spawn('xdg-open', [url], { detached: true, stdio: 'ignore' }).unref();
+}
+
+/**
+ * Install instructions per OS for a missing tool.
+ * @param {'aptible'} tool
+ * @returns {string}
+ */
+export function installInstructions(tool) {
+  const os = detectOS();
+
+  if (tool === 'aptible') {
+    if (os === 'macos') {
+      return 'Install Aptible CLI:\n  brew install aptible/aptible/aptible\n  or: https://www.aptible.com/docs/cli';
+    }
+    if (os === 'windows' || os === 'wsl') {
+      return 'Install Aptible CLI:\n  Download from: https://www.aptible.com/docs/cli\n  or use WSL with the Linux install method';
+    }
+    // Linux
+    return 'Install Aptible CLI:\n  curl -s https://toolbelt.aptible.com/install.sh | bash\n  or: https://www.aptible.com/docs/cli';
+  }
+
+  return `Please install ${tool} and try again.`;
+}

package/src/lib/process-manager.js

@@ -0,0 +1,119 @@
+import { readFileSync, writeFileSync, existsSync, unlinkSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { getProcessInfo, getProcessUptime } from './platform.js';
+
+// Allow tests to redirect temp files to an isolated directory
+function getTempDir() {
+  return process.env.APTUNNEL_TEMP_DIR ?? tmpdir();
+}
+
+// ─── Path helpers ─────────────────────────────────────────────────────────────
+
+export function pidFilePath(identifier)  { return join(getTempDir(), `aptunnel-${identifier}.pid`); }
+export function logFilePath(identifier)  { return join(getTempDir(), `aptunnel-${identifier}.log`); }
+export function connFilePath(identifier) { return join(getTempDir(), `aptunnel-${identifier}.conn.json`); }
+
+// ─── PID management ───────────────────────────────────────────────────────────
+
+export function savePid(identifier, pid) {
+  writeFileSync(pidFilePath(identifier), String(pid), { mode: 0o600 });
+}
+
+export function readPid(identifier) {
+  const path = pidFilePath(identifier);
+  if (!existsSync(path)) return null;
+  const val = parseInt(readFileSync(path, 'utf8').trim(), 10);
+  return isNaN(val) ? null : val;
+}
+
+export function removePid(identifier) {
+  const path = pidFilePath(identifier);
+  if (existsSync(path)) unlinkSync(path);
+}
+
+/**
+ * Check if the process for an identifier is still alive.
+ * @param {string} identifier
+ * @returns {boolean}
+ */
+export function isRunning(identifier) {
+  const pid = readPid(identifier);
+  if (!pid) return false;
+  const info = getProcessInfo(pid);
+  return info.running;
+}
+
+// ─── Connection info ──────────────────────────────────────────────────────────
+
+/**
+ * @param {string} identifier
+ * @param {{ url: string, host: string, port: number, user: string, password: string, dbName: string }} info
+ */
+export function saveConnectionInfo(identifier, info) {
+  writeFileSync(connFilePath(identifier), JSON.stringify(info, null, 2), { mode: 0o600 });
+}
+
+/**
+ * @param {string} identifier
+ * @returns {object | null}
+ */
+export function readConnectionInfo(identifier) {
+  const path = connFilePath(identifier);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function removeConnectionInfo(identifier) {
+  const path = connFilePath(identifier);
+  if (existsSync(path)) unlinkSync(path);
+}
+
+// ─── Global state ─────────────────────────────────────────────────────────────
+
+/**
+ * Scan /tmp for all aptunnel-*.pid files and return status for each.
+ * @returns {{ identifier: string, pid: number, running: boolean, uptime: object | null, conn: object | null }[]}
+ */
+export function getAllRunningTunnels() {
+  let files;
+  try {
+    files = readdirSync(getTempDir());
+  } catch {
+    return [];
+  }
+
+  return files
+    .filter(f => f.startsWith('aptunnel-') && f.endsWith('.pid'))
+    .map((f) => {
+      const identifier = f.replace(/^aptunnel-/, '').replace(/\.pid$/, '');
+      const pid = readPid(identifier);
+      if (!pid) return null;
+
+      const info = getProcessInfo(pid);
+      const uptime = info.running ? getProcessUptime(pid) : null;
+      const conn   = readConnectionInfo(identifier);
+
+      return { identifier, pid, running: info.running, uptime, conn };
+    })
+    .filter(Boolean);
+}
+
+/**
+ * Clean up PID + conn files for a given identifier.
+ */
+export function cleanup(identifier) {
+  removePid(identifier);
+  removeConnectionInfo(identifier);
+}
+
+/**
+ * Sanitize a db handle/alias into a safe identifier for filenames.
+ */
+export function toIdentifier(str) {
+  return str.replace(/[^a-zA-Z0-9-_]/g, '-');
+}

package/src/templates/config.yaml

@@ -0,0 +1,17 @@
+# aptunnel configuration — generated by `aptunnel init`
+# Edit manually or use `aptunnel config` commands.
+version: 1
+
+credentials:
+  email: ""
+  # Password is stored separately in ~/.aptunnel/.credentials (mode 600)
+
+defaults:
+  environment: ""
+  lifetime: 7d
+
+environments: {}
+
+tunnel_defaults:
+  start_port: 55550
+  port_increment: 1