@openchambery/web 1.17.1-beta.7 → 1.17.1-beta.8

package/server/lib/ngrok-tunnel.js

@@ -1,343 +0,0 @@
-import { spawn, spawnSync } from 'child_process';
-import {
-  createExecutableSearchEnv,
-  resolveExecutableLaunchTarget,
-} from './tunnels/executable-search.js';
-import { getTunnelDependencyInstallInfo } from './tunnels/install-help.js';
-import { TUNNEL_PROVIDER_NGROK } from './tunnels/types.js';
-
-const DEFAULT_STARTUP_TIMEOUT_MS = 30000;
-const NGROK_API_URL = 'http://127.0.0.1:4040/api/tunnels';
-const NGROK_PUBLIC_URL_REGEX = /https:\/\/[^\s"']+/i;
-const NGROK_AUTHTOKEN_HELP = 'Run: ngrok config add-authtoken <your-ngrok-token>';
-const getNgrokInstallInfo = () => getTunnelDependencyInstallInfo(TUNNEL_PROVIDER_NGROK);
-
-export async function checkNgrokAvailable() {
-  const target = resolveExecutableLaunchTarget('ngrok');
-  if (target) {
-    try {
-      const result = spawnSync(target.command, ['version'], {
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-        windowsHide: true,
-        env: target.env,
-      });
-      if (result.status === 0) {
-        return { available: true, path: target.command, version: result.stdout.trim() || result.stderr.trim() };
-      }
-    } catch {
-      // Ignore and report unavailable below.
-    }
-  }
-  return { available: false, path: null, version: null };
-}
-
-export async function checkNgrokAuthtokenConfigured(ngrokPath = null) {
-  if (typeof process.env.NGROK_AUTHTOKEN === 'string' && process.env.NGROK_AUTHTOKEN.trim().length > 0) {
-    return { configured: true, detail: 'NGROK_AUTHTOKEN is set.' };
-  }
-
-  const target = ngrokPath
-    ? { command: ngrokPath, env: createExecutableSearchEnv() }
-    : resolveExecutableLaunchTarget('ngrok');
-  if (!target) {
-    return { configured: false, detail: getNgrokInstallInfo().message };
-  }
-
-  try {
-    const result = spawnSync(target.command, ['config', 'check'], {
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-      windowsHide: true,
-      env: target.env,
-    });
-    const output = `${result.stdout || ''}${result.stderr || ''}`.trim();
-    if (result.status === 0) {
-      return { configured: true, detail: output || 'ngrok config is valid.' };
-    }
-    return { configured: false, detail: output || NGROK_AUTHTOKEN_HELP };
-  } catch (error) {
-    return {
-      configured: false,
-      detail: error instanceof Error ? error.message : String(error),
-    };
-  }
-}
-
-export async function checkNgrokApiReachability({ fetchImpl = globalThis.fetch, timeoutMs = 5000 } = {}) {
-  if (typeof fetchImpl !== 'function') {
-    return { reachable: false, status: null, error: 'Fetch API is unavailable in this runtime.' };
-  }
-
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const response = await fetchImpl('https://api.ngrok.com/', {
-      method: 'GET',
-      signal: controller.signal,
-    });
-    return { reachable: true, status: response.status, error: null };
-  } catch (error) {
-    return {
-      reachable: false,
-      status: null,
-      error: error instanceof Error ? error.message : String(error),
-    };
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-
-const spawnNgrok = (args, resolvedBinaryPath = 'ngrok') => spawn(resolvedBinaryPath, args, {
-  stdio: ['ignore', 'pipe', 'pipe'],
-  windowsHide: true,
-  env: createExecutableSearchEnv(),
-  killSignal: 'SIGINT',
-});
-
-const normalizeNgrokPublicUrl = (value) => {
-  if (typeof value !== 'string' || value.trim().length === 0) {
-    return null;
-  }
-  const trimmed = value.trim();
-  try {
-    const parsed = new URL(trimmed);
-    if (parsed.protocol === 'https:' && parsed.hostname.includes('ngrok')) {
-      return parsed.toString().replace(/\/$/, '');
-    }
-  } catch {
-    return null;
-  }
-  return null;
-};
-
-export function extractNgrokPublicUrlFromText(text) {
-  if (typeof text !== 'string' || text.trim().length === 0) {
-    return null;
-  }
-
-  const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-  for (const line of lines) {
-    try {
-      const parsed = JSON.parse(line);
-      const parsedUrl = normalizeNgrokPublicUrl(parsed?.url) || normalizeNgrokPublicUrl(parsed?.public_url);
-      if (parsedUrl) {
-        return parsedUrl;
-      }
-    } catch {
-      // ngrok may emit non-JSON diagnostics even when log-format=json.
-    }
-
-    const match = line.match(NGROK_PUBLIC_URL_REGEX);
-    const matchedUrl = normalizeNgrokPublicUrl(match?.[0]);
-    if (matchedUrl) {
-      return matchedUrl;
-    }
-  }
-
-  return null;
-}
-
-const normalizeNgrokDiagnosticText = (value) => {
-  if (typeof value !== 'string') {
-    return '';
-  }
-  return value
-    .replace(/\r/g, '')
-    .split('\n')
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .join(' ')
-    .replace(/\s+/g, ' ')
-    .trim();
-};
-
-export const summarizeNgrokOutput = (lines) => {
-  const nonEmptyLines = Array.isArray(lines)
-    ? lines.map((line) => String(line || '').trim()).filter(Boolean)
-    : [];
-  if (nonEmptyLines.length === 0) {
-    return '';
-  }
-
-  for (const line of [...nonEmptyLines].reverse()) {
-    try {
-      const parsed = JSON.parse(line);
-      const level = typeof parsed?.lvl === 'string' ? parsed.lvl.toLowerCase() : '';
-      if (level !== 'eror' && level !== 'error' && level !== 'crit') {
-        continue;
-      }
-      const err = normalizeNgrokDiagnosticText(parsed?.err);
-      if (err && err !== '<nil>') {
-        return err;
-      }
-    } catch {
-      // Not a JSON ngrok log line.
-    }
-  }
-
-  for (const line of [...nonEmptyLines].reverse()) {
-    try {
-      const parsed = JSON.parse(line);
-      const err = normalizeNgrokDiagnosticText(parsed?.err);
-      if (err && err !== '<nil>' && !/context canceled/i.test(err)) {
-        return err;
-      }
-      const msg = normalizeNgrokDiagnosticText(parsed?.msg);
-      if (msg && /failed|error|invalid|auth/i.test(msg)) {
-        return msg;
-      }
-    } catch {
-      // Not a JSON ngrok log line.
-    }
-  }
-
-  const errorLines = nonEmptyLines
-    .filter((line) => /^ERROR:/i.test(line))
-    .map((line) => normalizeNgrokDiagnosticText(line.replace(/^ERROR:\s*/i, '')))
-    .filter(Boolean);
-  if (errorLines.length > 0) {
-    return errorLines.slice(0, 4).join(' ');
-  }
-
-  const lastLine = [...nonEmptyLines].reverse().find((line) => line.trim().length > 0);
-  if (!lastLine) {
-    return '';
-  }
-  try {
-    const parsed = JSON.parse(lastLine);
-    if (typeof parsed?.err === 'string' && parsed.err.trim().length > 0) {
-      return normalizeNgrokDiagnosticText(parsed.err);
-    }
-    if (typeof parsed?.msg === 'string' && parsed.msg.trim().length > 0) {
-      return normalizeNgrokDiagnosticText(parsed.msg);
-    }
-  } catch {
-    // Fall through to plain text output.
-  }
-  return normalizeNgrokDiagnosticText(lastLine);
-};
-
-const appendNgrokOutputSummary = (message, lines) => {
-  const summary = summarizeNgrokOutput(lines);
-  return summary ? `${message}: ${summary}` : message;
-};
-
-async function fetchNgrokPublicUrl(fetchImpl = globalThis.fetch) {
-  if (typeof fetchImpl !== 'function') {
-    return null;
-  }
-  try {
-    const response = await fetchImpl(NGROK_API_URL, { method: 'GET' });
-    if (!response.ok) {
-      return null;
-    }
-    const payload = await response.json();
-    const tunnels = Array.isArray(payload?.tunnels) ? payload.tunnels : [];
-    const httpsTunnel = tunnels.find((entry) => entry?.proto === 'https' && normalizeNgrokPublicUrl(entry?.public_url));
-    const fallbackTunnel = tunnels.find((entry) => normalizeNgrokPublicUrl(entry?.public_url));
-    return normalizeNgrokPublicUrl(httpsTunnel?.public_url) || normalizeNgrokPublicUrl(fallbackTunnel?.public_url);
-  } catch {
-    return null;
-  }
-}
-
-export async function startNgrokQuickTunnel({ port }) {
-  const ngrokCheck = await checkNgrokAvailable();
-  if (!ngrokCheck.available) {
-    throw new Error(getNgrokInstallInfo().message);
-  }
-
-  const authtokenCheck = await checkNgrokAuthtokenConfigured(ngrokCheck.path);
-  if (!authtokenCheck.configured) {
-    throw new Error(`ngrok authtoken is not configured. ${authtokenCheck.detail || NGROK_AUTHTOKEN_HELP}`);
-  }
-
-  if (!Number.isFinite(port)) {
-    throw new Error('A local port is required to start an ngrok tunnel');
-  }
-
-  const child = spawnNgrok(['http', '--log=stdout', '--log-format=json', `127.0.0.1:${port}`], ngrokCheck.path);
-  let publicUrl = null;
-  const recentOutput = [];
-
-  const captureOutput = (chunk) => {
-    const text = chunk.toString('utf8');
-    const parsedUrl = extractNgrokPublicUrlFromText(text);
-    if (parsedUrl) {
-      publicUrl = parsedUrl;
-    }
-
-    for (const line of text.split(/\r?\n/)) {
-      const trimmed = line.trim();
-      if (!trimmed) {
-        continue;
-      }
-      recentOutput.push(trimmed);
-      if (recentOutput.length > 200) {
-        recentOutput.shift();
-      }
-    }
-    return text;
-  };
-
-  child.stdout.on('data', (chunk) => {
-    captureOutput(chunk);
-  });
-
-  child.stderr.on('data', (chunk) => {
-    const text = captureOutput(chunk);
-    process.stderr.write(text);
-  });
-
-  await new Promise((resolve, reject) => {
-    let settled = false;
-    const finish = (handler, value) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      clearTimeout(timeout);
-      clearInterval(checkReady);
-      child.off('error', onError);
-      child.off('exit', onExit);
-      handler(value);
-    };
-
-    const timeout = setTimeout(() => {
-      try { child.kill('SIGINT'); } catch { /* ignore */ }
-      finish(reject, new Error(appendNgrokOutputSummary('Ngrok tunnel URL not received within 30 seconds', recentOutput)));
-    }, DEFAULT_STARTUP_TIMEOUT_MS);
-
-    const checkReady = setInterval(async () => {
-      publicUrl = publicUrl || await fetchNgrokPublicUrl();
-      if (publicUrl) {
-        finish(resolve, null);
-      }
-    }, 250);
-
-    const onError = (error) => {
-      finish(reject, new Error(`Ngrok failed to start: ${error.message}`));
-    };
-
-    const onExit = (code) => {
-      finish(reject, new Error(appendNgrokOutputSummary(`Ngrok exited while starting (code ${code ?? 'unknown'})`, recentOutput)));
-    };
-
-    child.once('error', onError);
-    child.once('exit', onExit);
-  });
-
-  return {
-    mode: 'quick',
-    stop: () => {
-      try {
-        child.kill('SIGINT');
-      } catch {
-        // Ignore.
-      }
-    },
-    process: child,
-    getPublicUrl: () => publicUrl,
-  };
-}

package/server/lib/ngrok-tunnel.test.js

@@ -1,50 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-
-import {
-  extractNgrokPublicUrlFromText,
-  summarizeNgrokOutput,
-} from './ngrok-tunnel.js';
-
-describe('extractNgrokPublicUrlFromText', () => {
-  it('extracts public URL from ngrok JSON logs', () => {
-    const url = extractNgrokPublicUrlFromText('{"lvl":"info","msg":"started tunnel","url":"https://demo.ngrok-free.app"}\n');
-
-    expect(url).toBe('https://demo.ngrok-free.app');
-  });
-
-  it('extracts public URL from ngrok text output', () => {
-    const url = extractNgrokPublicUrlFromText('Forwarding https://demo.ngrok-free.app -> http://127.0.0.1:3000');
-
-    expect(url).toBe('https://demo.ngrok-free.app');
-  });
-
-  it('ignores non-ngrok URLs', () => {
-    const url = extractNgrokPublicUrlFromText('{"url":"https://example.com"}\n');
-
-    expect(url).toBeNull();
-  });
-});
-
-describe('summarizeNgrokOutput', () => {
-  it('prefers actionable JSON error details over trailing help text', () => {
-    const summary = summarizeNgrokOutput([
-      '{"err":"authentication failed: Your ngrok-agent version \\"3.3.1\\" is too old. The minimum supported agent version for your account is \\"3.20.0\\".\\r\\n\\r\\nERR_NGROK_121\\r\\n","lvl":"crit","msg":"command failed"}',
-      'NAME:',
-      '  http - start an HTTP tunnel',
-    ]);
-
-    expect(summary).toContain('Your ngrok-agent version "3.3.1" is too old');
-    expect(summary).toContain('ERR_NGROK_121');
-  });
-
-  it('skips bare ERROR lines and keeps the useful error text', () => {
-    const summary = summarizeNgrokOutput([
-      'ERROR:',
-      'ERROR:  authentication failed',
-      'ERROR:',
-      'ERROR:  ERR_NGROK_121',
-    ]);
-
-    expect(summary).toBe('authentication failed ERR_NGROK_121');
-  });
-});

package/server/lib/tunnels/DOCUMENTATION.md

@@ -1,21 +0,0 @@
-# Tunnels Module Documentation
-
-## Purpose
-This module contains tunnel provider orchestration for OpenChamber, including provider registry/service wiring, managed remote token config lifecycle, and tunnel HTTP route registration.
-
-## Entrypoints and structure
-- `packages/web/server/lib/tunnels/index.js`: tunnel service orchestration.
-- `packages/web/server/lib/tunnels/executable-search.js`: cross-platform executable discovery, including Windows Store app aliases.
-- `packages/web/server/lib/tunnels/registry.js`: provider registry.
-- `packages/web/server/lib/tunnels/managed-config.js`: managed remote tunnel token/preset persistence runtime.
-- `packages/web/server/lib/tunnels/install-help.js`: provider/platform install command metadata for missing tunnel dependencies.
-- `packages/web/server/lib/tunnels/routes.js`: tunnel API route registration and request orchestration runtime.
-- `packages/web/server/lib/tunnels/types.js`: tunnel constants, normalization, and shared type helpers.
-- `packages/web/server/lib/tunnels/providers/cloudflare.js`: Cloudflare tunnel provider implementation.
-- `packages/web/server/lib/tunnels/providers/ngrok.js`: Ngrok quick tunnel provider implementation.
-
-## Public exports (routes.js)
-- `createTunnelRoutesRuntime(dependencies)`: creates tunnel routes runtime and helpers.
-- Returned API:
-  - `registerRoutes(app)`
-  - `startTunnelWithNormalizedRequest(request)`

package/server/lib/tunnels/executable-search.js

@@ -1,140 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-
-const getEnvValue = (env, keys) => {
-  for (const key of keys) {
-    const value = env?.[key];
-    if (typeof value === 'string' && value.trim().length > 0) {
-      return value;
-    }
-  }
-  return '';
-};
-
-const normalizeSearchDirectoryKey = (directory, platform) => {
-  const trimmed = typeof directory === 'string' ? directory.trim() : '';
-  return platform === 'win32' ? trimmed.toLowerCase() : trimmed;
-};
-
-const getWindowsAppsDirectory = (env) => {
-  const localAppData = getEnvValue(env, ['LOCALAPPDATA', 'LocalAppData', 'localappdata']);
-  if (localAppData) {
-    return path.win32.join(localAppData, 'Microsoft', 'WindowsApps');
-  }
-
-  const userProfile = getEnvValue(env, ['USERPROFILE', 'UserProfile', 'userprofile']);
-  if (userProfile) {
-    return path.win32.join(userProfile, 'AppData', 'Local', 'Microsoft', 'WindowsApps');
-  }
-
-  return path.win32.join(os.homedir(), 'AppData', 'Local', 'Microsoft', 'WindowsApps');
-};
-
-export function getExecutableSearchDirectories({ env = process.env, platform = process.platform } = {}) {
-  const delimiter = platform === 'win32' ? ';' : ':';
-  const pathValue = getEnvValue(env, ['PATH', 'Path', 'path']);
-  const directories = pathValue.split(delimiter).map((entry) => entry.trim()).filter(Boolean);
-
-  if (platform === 'win32') {
-    directories.push(getWindowsAppsDirectory(env));
-  }
-
-  const seen = new Set();
-  const unique = [];
-  for (const directory of directories) {
-    const key = normalizeSearchDirectoryKey(directory, platform);
-    if (!key || seen.has(key)) {
-      continue;
-    }
-    seen.add(key);
-    unique.push(directory);
-  }
-
-  return unique;
-}
-
-export function createExecutableSearchEnv({ env = process.env, platform = process.platform } = {}) {
-  const delimiter = platform === 'win32' ? ';' : ':';
-  const pathValue = getExecutableSearchDirectories({ env, platform }).join(delimiter);
-  const nextEnv = { ...env };
-
-  if (platform === 'win32') {
-    nextEnv.PATH = pathValue;
-    nextEnv.Path = pathValue;
-    nextEnv.path = pathValue;
-  } else {
-    nextEnv.PATH = pathValue;
-  }
-
-  return nextEnv;
-}
-
-const getExecutableExtensions = ({ env = process.env, platform = process.platform } = {}) => {
-  if (platform !== 'win32') {
-    return [''];
-  }
-
-  return (env.PATHEXT || env.PathExt || env.pathext || '.EXE;.CMD;.BAT;.COM')
-    .split(';')
-    .map((ext) => ext.trim().toLowerCase())
-    .filter(Boolean)
-    .map((ext) => (ext.startsWith('.') ? ext : `.${ext}`));
-};
-
-export function findExecutableOnPath(command, {
-  env = process.env,
-  platform = process.platform,
-  fsLike = fs,
-} = {}) {
-  if (typeof command !== 'string' || command.trim().length === 0) {
-    return null;
-  }
-
-  const pathApi = platform === 'win32' ? path.win32 : path;
-  const directories = getExecutableSearchDirectories({ env, platform });
-  const extensions = getExecutableExtensions({ env, platform });
-  const commandName = command.trim();
-
-  for (const directory of directories) {
-    for (const extension of extensions) {
-      const fileName = platform === 'win32' ? `${commandName}${extension}` : commandName;
-      const candidate = pathApi.join(directory, fileName);
-      try {
-        const stats = fsLike.statSync(candidate);
-        if (!stats.isFile()) {
-          continue;
-        }
-        if (platform !== 'win32') {
-          try {
-            fsLike.accessSync(candidate, fs.constants.X_OK);
-          } catch {
-            continue;
-          }
-        }
-        return candidate;
-      } catch {
-        continue;
-      }
-    }
-  }
-
-  return null;
-}
-
-export function resolveExecutableLaunchTarget(command, options = {}) {
-  const platform = options.platform || process.platform;
-  const resolvedPath = findExecutableOnPath(command, { ...options, platform });
-  const env = createExecutableSearchEnv({ env: options.env || process.env, platform });
-  if (resolvedPath) {
-    return { command: resolvedPath, env };
-  }
-
-  // Windows Store app execution aliases are launchable through CreateProcess
-  // but can reject fs.stat/fs.access with EACCES. Let the version probe decide.
-  if (platform === 'win32' && typeof command === 'string' && command.trim().length > 0) {
-    return { command: command.trim(), env };
-  }
-
-  return null;
-}

package/server/lib/tunnels/executable-search.test.js

@@ -1,96 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-
-import {
-  createExecutableSearchEnv,
-  findExecutableOnPath,
-  getExecutableSearchDirectories,
-  resolveExecutableLaunchTarget,
-} from './executable-search.js';
-
-describe('getExecutableSearchDirectories', () => {
-  it('adds the WindowsApps app-alias directory on Windows', () => {
-    const directories = getExecutableSearchDirectories({
-      platform: 'win32',
-      env: {
-        PATH: 'C:\\Tools',
-        LOCALAPPDATA: 'C:\\Users\\Ada\\AppData\\Local',
-      },
-    });
-
-    expect(directories).toContain('C:\\Users\\Ada\\AppData\\Local\\Microsoft\\WindowsApps');
-  });
-
-  it('reads Windows Path casing when PATH is not present', () => {
-    const directories = getExecutableSearchDirectories({
-      platform: 'win32',
-      env: {
-        Path: 'C:\\Tools;C:\\MoreTools',
-        LOCALAPPDATA: 'C:\\Users\\Ada\\AppData\\Local',
-      },
-    });
-
-    expect(directories[0]).toBe('C:\\Tools');
-    expect(directories[1]).toBe('C:\\MoreTools');
-  });
-});
-
-describe('findExecutableOnPath', () => {
-  it('finds Windows Store app execution aliases even when PATH omits WindowsApps', () => {
-    const aliasPath = 'C:\\Users\\Ada\\AppData\\Local\\Microsoft\\WindowsApps\\ngrok.exe';
-    const fsLike = {
-      statSync: (candidate) => {
-        if (candidate === aliasPath) {
-          return { isFile: () => true };
-        }
-        throw new Error('not found');
-      },
-      accessSync: () => {},
-    };
-
-    const resolved = findExecutableOnPath('ngrok', {
-      platform: 'win32',
-      env: {
-        PATH: 'C:\\Tools',
-        LOCALAPPDATA: 'C:\\Users\\Ada\\AppData\\Local',
-        PATHEXT: '.EXE;.CMD',
-      },
-      fsLike,
-    });
-
-    expect(resolved).toBe(aliasPath);
-  });
-});
-
-describe('resolveExecutableLaunchTarget', () => {
-  it('returns a Windows launch target with WindowsApps on PATH when stat lookup fails', () => {
-    const target = resolveExecutableLaunchTarget('ngrok', {
-      platform: 'win32',
-      env: {
-        PATH: 'C:\\Windows\\System32',
-        LOCALAPPDATA: 'C:\\Users\\Ada\\AppData\\Local',
-      },
-      fsLike: {
-        statSync: () => { throw new Error('EACCES'); },
-        accessSync: () => {},
-      },
-    });
-
-    expect(target?.command).toBe('ngrok');
-    expect(target?.env.Path).toContain('C:\\Users\\Ada\\AppData\\Local\\Microsoft\\WindowsApps');
-  });
-});
-
-describe('createExecutableSearchEnv', () => {
-  it('keeps Windows PATH variants in sync', () => {
-    const env = createExecutableSearchEnv({
-      platform: 'win32',
-      env: {
-        PATH: 'C:\\Windows\\System32',
-        LOCALAPPDATA: 'C:\\Users\\Ada\\AppData\\Local',
-      },
-    });
-
-    expect(env.PATH).toBe(env.Path);
-    expect(env.path).toBe(env.Path);
-  });
-});