conduit-mobile 0.1.0

package/src/server/tunnel.js

@@ -0,0 +1,131 @@
+import { spawn, execSync } from 'child_process';
+import { existsSync, mkdirSync, chmodSync, createWriteStream, unlinkSync } from 'fs';
+import { get } from 'https';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const CACHE_DIR = join(homedir(), '.conduit');
+const BIN_NAME  = process.platform === 'win32' ? 'cloudflared.exe' : 'cloudflared';
+const BIN_PATH  = join(CACHE_DIR, BIN_NAME);
+
+// ── Locate cloudflared ────────────────────────────────────────────────────────
+
+function findOnPath() {
+  try {
+    execSync(process.platform === 'win32' ? 'where cloudflared' : 'which cloudflared',
+      { stdio: 'ignore' });
+    return 'cloudflared';
+  } catch {
+    return null;
+  }
+}
+
+function getDownloadInfo() {
+  const cpu = process.arch === 'arm64' ? 'arm64' : 'amd64';
+  switch (process.platform) {
+    case 'win32':
+      return { url: `https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-windows-${cpu}.exe`, tgz: false };
+    case 'darwin':
+      return { url: `https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-darwin-${cpu}.tgz`, tgz: true };
+    default:
+      return { url: `https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-${cpu}`, tgz: false };
+  }
+}
+
+// Follow redirects and return the response stream
+function httpGet(url) {
+  return new Promise((resolve, reject) => {
+    get(url, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        httpGet(res.headers.location).then(resolve, reject);
+        return;
+      }
+      resolve(res);
+    }).on('error', reject);
+  });
+}
+
+function downloadTo(url, dest) {
+  return new Promise(async (resolve, reject) => {
+    try {
+      const res = await httpGet(url);
+      const file = createWriteStream(dest);
+      res.pipe(file);
+      file.on('finish', () => file.close(resolve));
+      file.on('error', reject);
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
+
+async function downloadCloudflared() {
+  if (!existsSync(CACHE_DIR)) mkdirSync(CACHE_DIR, { recursive: true });
+
+  const { url, tgz } = getDownloadInfo();
+  process.stdout.write('  Downloading cloudflared... ');
+
+  try {
+    if (tgz) {
+      const tmp = BIN_PATH + '.tgz';
+      await downloadTo(url, tmp);
+      await new Promise((resolve, reject) => {
+        const child = spawn('tar', ['-xzf', tmp, '-C', CACHE_DIR], { stdio: 'ignore' });
+        child.on('close', (code) => {
+          try { unlinkSync(tmp); } catch {}
+          code === 0 ? resolve() : reject(new Error('tar failed'));
+        });
+      });
+    } else {
+      await downloadTo(url, BIN_PATH);
+    }
+
+    if (process.platform !== 'win32') chmodSync(BIN_PATH, 0o755);
+    console.log('done.');
+    return BIN_PATH;
+  } catch {
+    try { if (existsSync(BIN_PATH)) unlinkSync(BIN_PATH); } catch {}
+    console.log('failed.');
+    return null;
+  }
+}
+
+async function resolveCloudflared() {
+  const onPath = findOnPath();
+  if (onPath) return onPath;
+  if (existsSync(BIN_PATH)) return BIN_PATH;
+  return downloadCloudflared();
+}
+
+// ── Tunnel ────────────────────────────────────────────────────────────────────
+
+export async function startTunnel(port) {
+  const bin = await resolveCloudflared();
+  if (!bin) return null;
+
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(bin, ['tunnel', '--url', `http://localhost:${port}`], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    } catch {
+      resolve(null);
+      return;
+    }
+
+    const timeout = setTimeout(() => resolve(null), 15000);
+
+    function tryParse(line) {
+      const match = line.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/);
+      if (match) {
+        clearTimeout(timeout);
+        resolve(match[0]);
+      }
+    }
+
+    child.stderr.on('data', (d) => tryParse(d.toString()));
+    child.stdout.on('data', (d) => tryParse(d.toString()));
+    child.on('error', () => { clearTimeout(timeout); resolve(null); });
+  });
+}

package/src/server/wakelock.js

@@ -0,0 +1,107 @@
+// Prevent the system from sleeping while the server is running.
+// On Windows this also covers lid-close (changes the action to "Do nothing").
+// Everything is restored automatically on exit.
+
+import { exec, spawn } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+
+// GUIDs for the Windows power buttons/lid subgroup
+const LID_SUBGROUP = '4f971e89-eebd-4455-a8de-9e59040e7347';
+const LID_ACTION   = '5ca83367-6e45-459f-a27b-476b1d01c936';
+
+let release = null;
+
+export async function acquireWakeLock() {
+  try {
+    if      (process.platform === 'win32')  release = await windows();
+    else if (process.platform === 'darwin') release = await macos();
+    else                                    release = await linux();
+
+    if (release) {
+      console.log('  Sleep + lid-close prevented while server is running.');
+      for (const sig of ['exit', 'SIGINT', 'SIGTERM', 'SIGHUP']) {
+        process.on(sig, () => { release?.(); release = null; });
+      }
+    }
+  } catch {
+    // Best-effort — never crash the server over this
+  }
+}
+
+// ── Windows ───────────────────────────────────────────────────────────────────
+async function windows() {
+  // 1. Read the current AC lid-close action so we can restore it
+  let originalLidAc = '1'; // default: Sleep
+  let originalLidDc = '1';
+  try {
+    const { stdout } = await execAsync(
+      `powercfg /QUERY SCHEME_CURRENT ${LID_SUBGROUP} ${LID_ACTION}`
+    );
+    const acMatch = stdout.match(/Current AC Power Setting Index:\s+(0x[\da-fA-F]+)/);
+    const dcMatch = stdout.match(/Current DC Power Setting Index:\s+(0x[\da-fA-F]+)/);
+    if (acMatch) originalLidAc = parseInt(acMatch[1], 16).toString();
+    if (dcMatch) originalLidDc = parseInt(dcMatch[1], 16).toString();
+  } catch {}
+
+  // 2. Set lid close to "Do nothing" (0) on both AC and battery
+  try {
+    await execAsync(`powercfg /SETACVALUEINDEX SCHEME_CURRENT ${LID_SUBGROUP} ${LID_ACTION} 0`);
+    await execAsync(`powercfg /SETDCVALUEINDEX SCHEME_CURRENT ${LID_SUBGROUP} ${LID_ACTION} 0`);
+    await execAsync('powercfg /SETACTIVE SCHEME_CURRENT');
+  } catch {}
+
+  // 3. Spawn a PowerShell process that holds SetThreadExecutionState (blocks idle sleep)
+  const script = [
+    `$code = 'using System; using System.Runtime.InteropServices;`,
+    `public class WL { [DllImport("kernel32.dll")] public static extern uint STES(uint f); }'`,
+    `Add-Type -TypeDefinition $code -Language CSharp`,
+    `[WL]::STES(0x80000003)`,   // ES_CONTINUOUS | ES_SYSTEM_REQUIRED
+    `while ($true) { Start-Sleep -Seconds 60 }`,
+  ].join('; ');
+
+  const child = spawn('powershell', ['-NoProfile', '-NonInteractive', '-Command', script], {
+    stdio: 'ignore',
+    detached: false,
+  });
+  child.on('error', () => {});
+
+  return () => {
+    // Kill the sleep-prevention process
+    try { child.kill(); } catch {}
+
+    // Restore lid-close action
+    exec(`powercfg /SETACVALUEINDEX SCHEME_CURRENT ${LID_SUBGROUP} ${LID_ACTION} ${originalLidAc}`);
+    exec(`powercfg /SETDCVALUEINDEX SCHEME_CURRENT ${LID_SUBGROUP} ${LID_ACTION} ${originalLidDc}`);
+    exec('powercfg /SETACTIVE SCHEME_CURRENT');
+  };
+}
+
+// ── macOS ─────────────────────────────────────────────────────────────────────
+// caffeinate -i = prevent idle sleep
+// caffeinate -s = prevent system sleep (works with lid closed on AC)
+async function macos() {
+  const child = spawn('caffeinate', ['-i', '-s'], {
+    stdio: 'ignore',
+    detached: false,
+  });
+  child.on('error', () => {});
+  return () => { try { child.kill(); } catch {} };
+}
+
+// ── Linux ─────────────────────────────────────────────────────────────────────
+async function linux() {
+  try {
+    await execAsync('which systemd-inhibit');
+    const child = spawn(
+      'systemd-inhibit',
+      ['--what=sleep:idle:handle-lid-switch', '--who=Conduit',
+       '--why=Terminal server running', 'sleep', 'infinity'],
+      { stdio: 'ignore', detached: false }
+    );
+    child.on('error', () => {});
+    return () => { try { child.kill(); } catch {} };
+  } catch {}
+
+  return null;
+}