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

package/server/lib/tunnels/index.js

@@ -1,179 +0,0 @@
-import {
-  TUNNEL_MODE_QUICK,
-  TUNNEL_PROVIDER_CLOUDFLARE,
-  TunnelServiceError,
-  normalizeTunnelStartRequest,
-  validateTunnelStartRequest,
-} from './types.js';
-import { getTunnelDependencyInstallInfo } from './install-help.js';
-
-export function createTunnelService({
-  registry,
-  getController,
-  setController,
-  getActivePort,
-  onQuickTunnelWarning,
-}) {
-  if (!registry) {
-    throw new Error('Tunnel service requires a provider registry');
-  }
-
-  const resolveActiveMode = () => {
-    const controller = getController();
-    if (!controller || typeof controller.mode !== 'string') {
-      return null;
-    }
-    return controller.mode;
-  };
-
-  const resolveActiveProvider = () => {
-    const controller = getController();
-    if (!controller || typeof controller.provider !== 'string') {
-      return null;
-    }
-    return controller.provider;
-  };
-
-  const stop = () => {
-    const controller = getController();
-    if (!controller) {
-      return false;
-    }
-
-    const providerId = typeof controller.provider === 'string' ? controller.provider : '';
-    const provider = providerId ? registry.get(providerId) : null;
-    if (provider?.stop) {
-      provider.stop(controller);
-    } else {
-      controller.stop?.();
-    }
-    setController(null);
-    return true;
-  };
-
-  const checkAvailability = async (providerId) => {
-    const provider = registry.get(providerId);
-    if (!provider) {
-      throw new TunnelServiceError('provider_unsupported', `Unsupported tunnel provider: ${providerId}`);
-    }
-    const result = await provider.checkAvailability();
-    return result;
-  };
-
-  // Mutex to prevent concurrent tunnel starts from orphaning child processes.
-  let startLock = Promise.resolve();
-
-  const start = async (rawRequest, options = {}) => {
-    let releaseLock;
-    const lockPromise = new Promise((resolve) => { releaseLock = resolve; });
-    const previousLock = startLock;
-    startLock = lockPromise;
-
-    await previousLock;
-
-    try {
-      const request = normalizeTunnelStartRequest(rawRequest);
-      const provider = registry.get(request.provider);
-
-      if (!provider) {
-        throw new TunnelServiceError('provider_unsupported', `Unsupported tunnel provider: ${request.provider}`);
-      }
-
-      validateTunnelStartRequest(request, provider.capabilities);
-
-      let publicUrl = provider.resolvePublicUrl(getController());
-      const activeMode = resolveActiveMode();
-      const activeProvider = resolveActiveProvider();
-
-      if (publicUrl && (activeMode !== request.mode || activeProvider !== request.provider)) {
-        stop();
-        publicUrl = null;
-      }
-
-      if (!publicUrl) {
-        const availability = await provider.checkAvailability();
-        if (!availability?.available) {
-          const missingDependencyMessage = typeof availability?.message === 'string' && availability.message.trim().length > 0
-            ? availability.message
-            : (request.provider === TUNNEL_PROVIDER_CLOUDFLARE
-              ? getTunnelDependencyInstallInfo(TUNNEL_PROVIDER_CLOUDFLARE).message
-              : `Required dependency for provider '${request.provider}' is missing`);
-          throw new TunnelServiceError('missing_dependency', missingDependencyMessage);
-        }
-
-        const activePort = Number.isFinite(getActivePort?.()) ? getActivePort() : null;
-        const originUrl = activePort !== null ? `http://127.0.0.1:${activePort}` : undefined;
-
-        let controller;
-        try {
-          controller = await provider.start(request, {
-            activePort,
-            originUrl,
-            ...options,
-          });
-        } catch (error) {
-          if (error instanceof TunnelServiceError) {
-            throw error;
-          }
-          const message = error instanceof Error && error.message.trim().length > 0
-            ? error.message
-            : 'Failed to start tunnel';
-          throw new TunnelServiceError('startup_failed', message);
-        }
-        controller.provider = request.provider;
-        setController(controller);
-
-        publicUrl = provider.resolvePublicUrl(controller);
-        if (!publicUrl) {
-          stop();
-          throw new TunnelServiceError('startup_failed', 'Tunnel started but no public URL was assigned');
-        }
-
-        if (request.mode === TUNNEL_MODE_QUICK) {
-          onQuickTunnelWarning?.();
-        }
-      }
-
-      return {
-        publicUrl,
-        request,
-        activeMode: request.mode,
-        provider: request.provider,
-        providerMetadata: provider.getMetadata?.(getController()) ?? null,
-      };
-    } finally {
-      releaseLock();
-    }
-  };
-
-  const getPublicUrl = () => {
-    const controller = getController();
-    if (!controller) {
-      return null;
-    }
-    const provider = registry.get(controller.provider);
-    if (!provider) {
-      return controller.getPublicUrl?.() ?? null;
-    }
-    return provider.resolvePublicUrl(controller);
-  };
-
-  const getProviderMetadata = () => {
-    const controller = getController();
-    if (!controller) {
-      return null;
-    }
-    const provider = registry.get(controller.provider);
-    return provider?.getMetadata?.(controller) ?? null;
-  };
-
-  return {
-    start,
-    stop,
-    checkAvailability,
-    getPublicUrl,
-    getProviderMetadata,
-    resolveActiveMode,
-    resolveActiveProvider,
-  };
-}

package/server/lib/tunnels/index.test.js

@@ -1,93 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-
-import { createTunnelService } from './index.js';
-import {
-  TUNNEL_INTENT_EPHEMERAL_PUBLIC,
-  TUNNEL_MODE_QUICK,
-  TUNNEL_PROVIDER_CLOUDFLARE,
-  TUNNEL_PROVIDER_NGROK,
-} from './types.js';
-
-const createProvider = ({ provider, start, stop, resolvePublicUrl }) => ({
-  id: provider,
-  capabilities: {
-    provider,
-    modes: [{ key: TUNNEL_MODE_QUICK, intent: TUNNEL_INTENT_EPHEMERAL_PUBLIC }],
-  },
-  checkAvailability: async () => ({ available: true }),
-  start,
-  stop,
-  resolvePublicUrl: resolvePublicUrl || ((controller) => controller?.getPublicUrl?.() ?? null),
-});
-
-const createRegistry = (providers) => ({
-  get: (providerId) => providers[providerId] ?? null,
-});
-
-describe('createTunnelService', () => {
-  it('returns provider startup errors to route callers', async () => {
-    let controller = null;
-    const provider = createProvider({
-      provider: TUNNEL_PROVIDER_NGROK,
-      start: async () => {
-        throw new Error('ngrok authtoken is not configured');
-      },
-    });
-    const service = createTunnelService({
-      registry: createRegistry({ [TUNNEL_PROVIDER_NGROK]: provider }),
-      getController: () => controller,
-      setController: (next) => { controller = next; },
-      getActivePort: () => 3000,
-    });
-
-    try {
-      await service.start({ provider: TUNNEL_PROVIDER_NGROK, mode: TUNNEL_MODE_QUICK });
-      throw new Error('Expected service.start to fail');
-    } catch (error) {
-      expect(error.name).toBe('TunnelServiceError');
-      expect(error.code).toBe('startup_failed');
-      expect(error.message).toBe('ngrok authtoken is not configured');
-    }
-  });
-
-  it('replaces an active quick tunnel when the provider changes', async () => {
-    let stopped = false;
-    let ngrokStarted = false;
-    let controller = {
-      provider: TUNNEL_PROVIDER_CLOUDFLARE,
-      mode: TUNNEL_MODE_QUICK,
-      stop: () => { stopped = true; },
-      getPublicUrl: () => 'https://cloudflare.example',
-    };
-    const cloudflareProvider = createProvider({
-      provider: TUNNEL_PROVIDER_CLOUDFLARE,
-      start: async () => controller,
-    });
-    const ngrokProvider = createProvider({
-      provider: TUNNEL_PROVIDER_NGROK,
-      start: async () => {
-        ngrokStarted = true;
-        return {
-          mode: TUNNEL_MODE_QUICK,
-          getPublicUrl: () => 'https://demo.ngrok-free.app',
-        };
-      },
-    });
-    const service = createTunnelService({
-      registry: createRegistry({
-        [TUNNEL_PROVIDER_CLOUDFLARE]: cloudflareProvider,
-        [TUNNEL_PROVIDER_NGROK]: ngrokProvider,
-      }),
-      getController: () => controller,
-      setController: (next) => { controller = next; },
-      getActivePort: () => 3000,
-    });
-
-    const result = await service.start({ provider: TUNNEL_PROVIDER_NGROK, mode: TUNNEL_MODE_QUICK });
-
-    expect(stopped).toBe(true);
-    expect(ngrokStarted).toBe(true);
-    expect(result.provider).toBe(TUNNEL_PROVIDER_NGROK);
-    expect(result.publicUrl).toBe('https://demo.ngrok-free.app');
-  });
-});

package/server/lib/tunnels/install-help.js

@@ -1,56 +0,0 @@
-import {
-  TUNNEL_PROVIDER_CLOUDFLARE,
-  TUNNEL_PROVIDER_NGROK,
-} from './types.js';
-
-const PROVIDER_INSTALL_INFO = {
-  [TUNNEL_PROVIDER_CLOUDFLARE]: {
-    dependency: 'cloudflared',
-    installUrl: 'https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflared/downloads/',
-    commands: {
-      darwin: 'brew install cloudflared',
-      win32: 'winget install --id Cloudflare.cloudflared',
-      linux: 'Download cloudflared from https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflared/downloads/',
-    },
-  },
-  [TUNNEL_PROVIDER_NGROK]: {
-    dependency: 'ngrok',
-    installUrl: 'https://ngrok.com/download',
-    commands: {
-      darwin: 'brew install ngrok',
-      win32: 'winget install ngrok -s msstore',
-      linux: 'Download ngrok from https://ngrok.com/download',
-    },
-  },
-};
-
-const normalizeInstallPlatform = (platform) => {
-  if (platform === 'darwin' || platform === 'win32' || platform === 'linux') {
-    return platform;
-  }
-  return 'linux';
-};
-
-const createMissingDependencyMessage = ({ dependency, installCommand }) => {
-  if (installCommand.startsWith('Download ')) {
-    return `${dependency} is not installed. ${installCommand}`;
-  }
-  return `${dependency} is not installed. Install it with: ${installCommand}`;
-};
-
-export function getTunnelDependencyInstallInfo(provider, platform = process.platform) {
-  const providerInfo = PROVIDER_INSTALL_INFO[provider] || PROVIDER_INSTALL_INFO[TUNNEL_PROVIDER_CLOUDFLARE];
-  const normalizedPlatform = normalizeInstallPlatform(platform);
-  const installCommand = providerInfo.commands[normalizedPlatform] || providerInfo.commands.linux;
-
-  return {
-    dependency: providerInfo.dependency,
-    installCommand,
-    installUrl: providerInfo.installUrl,
-    platform: normalizedPlatform,
-    message: createMissingDependencyMessage({
-      dependency: providerInfo.dependency,
-      installCommand,
-    }),
-  };
-}

package/server/lib/tunnels/install-help.test.js

@@ -1,31 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-
-import { getTunnelDependencyInstallInfo } from './install-help.js';
-import {
-  TUNNEL_PROVIDER_CLOUDFLARE,
-  TUNNEL_PROVIDER_NGROK,
-} from './types.js';
-
-describe('getTunnelDependencyInstallInfo', () => {
-  it('returns Windows cloudflared winget guidance', () => {
-    const info = getTunnelDependencyInstallInfo(TUNNEL_PROVIDER_CLOUDFLARE, 'win32');
-
-    expect(info.dependency).toBe('cloudflared');
-    expect(info.installCommand).toBe('winget install --id Cloudflare.cloudflared');
-    expect(info.message).toContain('Cloudflare.cloudflared');
-  });
-
-  it('returns Windows ngrok winget guidance', () => {
-    const info = getTunnelDependencyInstallInfo(TUNNEL_PROVIDER_NGROK, 'win32');
-
-    expect(info.dependency).toBe('ngrok');
-    expect(info.installCommand).toBe('winget install ngrok -s msstore');
-    expect(info.message).toContain('ngrok -s msstore');
-  });
-
-  it('keeps macOS Homebrew guidance', () => {
-    const info = getTunnelDependencyInstallInfo(TUNNEL_PROVIDER_CLOUDFLARE, 'darwin');
-
-    expect(info.installCommand).toBe('brew install cloudflared');
-  });
-});

package/server/lib/tunnels/managed-config.js

@@ -1,201 +0,0 @@
-export const createManagedTunnelConfigRuntime = (deps) => {
-  const {
-    fsPromises,
-    path,
-    normalizeManagedRemoteTunnelHostname,
-    normalizeManagedRemoteTunnelPresets,
-    constants,
-  } = deps;
-
-  const {
-    CLOUDFLARE_MANAGED_REMOTE_TUNNELS_FILE_PATH,
-    CLOUDFLARE_LEGACY_NAMED_TUNNELS_FILE_PATH,
-    CLOUDFLARE_MANAGED_REMOTE_TUNNELS_VERSION,
-  } = constants;
-
-  let persistManagedRemoteTunnelConfigLock = Promise.resolve();
-
-  const sanitizeManagedRemoteTunnelConfigEntries = (value) => {
-    if (!Array.isArray(value)) {
-      return [];
-    }
-
-    const result = [];
-    const seenIds = new Set();
-    const seenHostnames = new Set();
-    for (const entry of value) {
-      if (!entry || typeof entry !== 'object') {
-        continue;
-      }
-
-      const id = typeof entry.id === 'string' ? entry.id.trim() : '';
-      const name = typeof entry.name === 'string' ? entry.name.trim() : '';
-      const hostname = normalizeManagedRemoteTunnelHostname(entry.hostname);
-      const token = typeof entry.token === 'string' ? entry.token.trim() : '';
-      const updatedAt = Number.isFinite(entry.updatedAt) ? entry.updatedAt : Date.now();
-
-      if (!id || !name || !hostname || !token) {
-        continue;
-      }
-      if (seenIds.has(id) || seenHostnames.has(hostname)) {
-        continue;
-      }
-
-      seenIds.add(id);
-      seenHostnames.add(hostname);
-      result.push({ id, name, hostname, token, updatedAt });
-    }
-
-    return result;
-  };
-
-  const writeManagedRemoteTunnelConfigToDisk = async (data) => {
-    await fsPromises.mkdir(path.dirname(CLOUDFLARE_MANAGED_REMOTE_TUNNELS_FILE_PATH), { recursive: true });
-    await fsPromises.writeFile(CLOUDFLARE_MANAGED_REMOTE_TUNNELS_FILE_PATH, JSON.stringify(data, null, 2), { encoding: 'utf8', mode: 0o600 });
-  };
-
-  const migrateManagedRemoteTunnelConfigFromLegacyFile = async () => {
-    try {
-      const legacyRaw = await fsPromises.readFile(CLOUDFLARE_LEGACY_NAMED_TUNNELS_FILE_PATH, 'utf8');
-      const parsed = JSON.parse(legacyRaw);
-      const tunnels = sanitizeManagedRemoteTunnelConfigEntries(parsed?.tunnels);
-      const migrated = {
-        version: CLOUDFLARE_MANAGED_REMOTE_TUNNELS_VERSION,
-        tunnels,
-      };
-      await writeManagedRemoteTunnelConfigToDisk(migrated);
-      return migrated;
-    } catch (error) {
-      if (error && typeof error === 'object' && error.code === 'ENOENT') {
-        return { version: CLOUDFLARE_MANAGED_REMOTE_TUNNELS_VERSION, tunnels: [] };
-      }
-      console.warn('Failed to migrate legacy named tunnel config file:', error);
-      return { version: CLOUDFLARE_MANAGED_REMOTE_TUNNELS_VERSION, tunnels: [] };
-    }
-  };
-
-  const readManagedRemoteTunnelConfigFromDisk = async () => {
-    try {
-      const raw = await fsPromises.readFile(CLOUDFLARE_MANAGED_REMOTE_TUNNELS_FILE_PATH, 'utf8');
-      const parsed = JSON.parse(raw);
-      if (!parsed || typeof parsed !== 'object') {
-        return { version: CLOUDFLARE_MANAGED_REMOTE_TUNNELS_VERSION, tunnels: [] };
-      }
-
-      return {
-        version: CLOUDFLARE_MANAGED_REMOTE_TUNNELS_VERSION,
-        tunnels: sanitizeManagedRemoteTunnelConfigEntries(parsed.tunnels),
-      };
-    } catch (error) {
-      if (error && typeof error === 'object' && error.code === 'ENOENT') {
-        return migrateManagedRemoteTunnelConfigFromLegacyFile();
-      }
-      console.warn('Failed to read managed remote tunnel config file:', error);
-      return { version: CLOUDFLARE_MANAGED_REMOTE_TUNNELS_VERSION, tunnels: [] };
-    }
-  };
-
-  const updateManagedRemoteTunnelConfig = async (mutate) => {
-    persistManagedRemoteTunnelConfigLock = persistManagedRemoteTunnelConfigLock.then(async () => {
-      const current = await readManagedRemoteTunnelConfigFromDisk();
-      const next = mutate({
-        version: CLOUDFLARE_MANAGED_REMOTE_TUNNELS_VERSION,
-        tunnels: sanitizeManagedRemoteTunnelConfigEntries(current.tunnels),
-      });
-
-      await writeManagedRemoteTunnelConfigToDisk({
-        version: CLOUDFLARE_MANAGED_REMOTE_TUNNELS_VERSION,
-        tunnels: sanitizeManagedRemoteTunnelConfigEntries(next?.tunnels),
-      });
-    });
-
-    return persistManagedRemoteTunnelConfigLock;
-  };
-
-  const syncManagedRemoteTunnelConfigWithPresets = async (presets) => {
-    const sanitizedPresets = normalizeManagedRemoteTunnelPresets(presets) || [];
-
-    await updateManagedRemoteTunnelConfig((current) => {
-      const byId = new Map(current.tunnels.map((entry) => [entry.id, entry]));
-      const byHostname = new Map(current.tunnels.map((entry) => [entry.hostname, entry]));
-
-      const nextTunnels = [];
-      for (const preset of sanitizedPresets) {
-        const existing = byId.get(preset.id) || byHostname.get(preset.hostname) || null;
-        if (!existing) {
-          continue;
-        }
-
-        nextTunnels.push({
-          ...existing,
-          id: preset.id,
-          name: preset.name,
-          hostname: preset.hostname,
-        });
-      }
-
-      return {
-        version: CLOUDFLARE_MANAGED_REMOTE_TUNNELS_VERSION,
-        tunnels: nextTunnels,
-      };
-    });
-  };
-
-  const upsertManagedRemoteTunnelToken = async ({ id, name, hostname, token }) => {
-    if (typeof id !== 'string' || typeof name !== 'string' || typeof hostname !== 'string' || typeof token !== 'string') {
-      return;
-    }
-    const normalizedId = id.trim();
-    const normalizedName = name.trim();
-    const normalizedHostname = normalizeManagedRemoteTunnelHostname(hostname);
-    const normalizedToken = token.trim();
-    if (!normalizedId || !normalizedName || !normalizedHostname || !normalizedToken) {
-      return;
-    }
-
-    await updateManagedRemoteTunnelConfig((current) => {
-      const withoutConflicts = current.tunnels.filter((entry) => entry.id !== normalizedId && entry.hostname !== normalizedHostname);
-      withoutConflicts.push({
-        id: normalizedId,
-        name: normalizedName,
-        hostname: normalizedHostname,
-        token: normalizedToken,
-        updatedAt: Date.now(),
-      });
-
-      return {
-        version: CLOUDFLARE_MANAGED_REMOTE_TUNNELS_VERSION,
-        tunnels: withoutConflicts,
-      };
-    });
-  };
-
-  const resolveManagedRemoteTunnelToken = async ({ presetId, hostname }) => {
-    const normalizedPresetId = typeof presetId === 'string' ? presetId.trim() : '';
-    const normalizedHostname = normalizeManagedRemoteTunnelHostname(hostname);
-    const config = await readManagedRemoteTunnelConfigFromDisk();
-
-    if (normalizedPresetId) {
-      const byId = config.tunnels.find((entry) => entry.id === normalizedPresetId);
-      if (byId?.token) {
-        return byId.token;
-      }
-    }
-
-    if (normalizedHostname) {
-      const byHostname = config.tunnels.find((entry) => entry.hostname === normalizedHostname);
-      if (byHostname?.token) {
-        return byHostname.token;
-      }
-    }
-
-    return '';
-  };
-
-  return {
-    readManagedRemoteTunnelConfigFromDisk,
-    syncManagedRemoteTunnelConfigWithPresets,
-    upsertManagedRemoteTunnelToken,
-    resolveManagedRemoteTunnelToken,
-  };
-};