@thevinci/web 1.0.0

package/server/lib/opencode/server-startup-runtime.js

@@ -0,0 +1,156 @@
+export const createServerStartupRuntime = (dependencies) => {
+  const {
+    process,
+    crypto,
+    server,
+    normalizeTunnelBootstrapTtlMs,
+    readSettingsFromDiskMigrated,
+    tunnelAuthController,
+    startTunnelWithNormalizedRequest,
+    gracefulShutdown,
+    getSignalsAttached,
+    setSignalsAttached,
+    syncToHmrState,
+    TUNNEL_MODE_QUICK,
+    TUNNEL_MODE_MANAGED_LOCAL,
+    TUNNEL_MODE_MANAGED_REMOTE,
+  } = dependencies;
+
+  const resolveBindHost = (host) =>
+    host
+    || (typeof process.env.VINCI_HOST === 'string' && process.env.VINCI_HOST.trim().length > 0
+      ? process.env.VINCI_HOST.trim()
+      : '127.0.0.1');
+
+  const startListeningAndMaybeTunnel = async ({
+    port,
+    bindHost,
+    startupTunnelRequest,
+    onTunnelReady,
+  }) => {
+    let activePort = port;
+
+    await new Promise((resolve, reject) => {
+      const onError = (error) => {
+        server.off('error', onError);
+        reject(error);
+      };
+      server.once('error', onError);
+      const onListening = async () => {
+        server.off('error', onError);
+        try {
+          const addressInfo = server.address();
+          activePort = typeof addressInfo === 'object' && addressInfo ? addressInfo.port : port;
+
+          if (typeof process.send === 'function') {
+            if (!process.connected) {
+              throw new Error('Vinci startup IPC channel disconnected before ready notification');
+            }
+
+            await new Promise((resolveReadyNotification, rejectReadyNotification) => {
+              try {
+                process.send({ type: 'vinci:ready', port: activePort }, (error) => {
+                  if (error) {
+                    rejectReadyNotification(error);
+                    return;
+                  }
+                  resolveReadyNotification();
+                });
+              } catch (error) {
+                rejectReadyNotification(error);
+              }
+            });
+          }
+
+          const displayHost = (bindHost === '0.0.0.0' || bindHost === '::' || bindHost === '[::]')
+            ? 'localhost'
+            : (bindHost.includes(':') ? `[${bindHost}]` : bindHost);
+          console.log(`Vinci server listening on ${bindHost}:${activePort}`);
+          console.log(`Health check: http://${displayHost}:${activePort}/health`);
+          console.log(`Web interface: http://${displayHost}:${activePort}`);
+
+          if (startupTunnelRequest) {
+            const startupModeLabel = startupTunnelRequest.mode === TUNNEL_MODE_QUICK
+              ? 'Quick Tunnel'
+              : (startupTunnelRequest.mode === TUNNEL_MODE_MANAGED_LOCAL
+                ? 'Managed Local Tunnel'
+                : (startupTunnelRequest.mode === TUNNEL_MODE_MANAGED_REMOTE ? 'Managed Remote Tunnel' : 'Tunnel'));
+            console.log(`\nInitializing ${startupModeLabel} for provider '${startupTunnelRequest.provider}'...`);
+            try {
+              const { publicUrl, mode } = await startTunnelWithNormalizedRequest({
+                provider: startupTunnelRequest.provider,
+                mode: startupTunnelRequest.mode,
+                intent: startupTunnelRequest.intent,
+                hostname: startupTunnelRequest.hostname,
+                token: startupTunnelRequest.token,
+                configPath: startupTunnelRequest.configPath,
+                selectedPresetId: '',
+                selectedPresetName: '',
+              });
+              if (publicUrl) {
+                tunnelAuthController.setActiveTunnel({
+                  tunnelId: crypto.randomUUID(),
+                  publicUrl,
+                  mode,
+                });
+                const settings = await readSettingsFromDiskMigrated();
+                const bootstrapTtlMs = settings?.tunnelBootstrapTtlMs === null
+                  ? null
+                  : normalizeTunnelBootstrapTtlMs(settings?.tunnelBootstrapTtlMs);
+                const bootstrapToken = tunnelAuthController.issueBootstrapToken({ ttlMs: bootstrapTtlMs });
+                const connectUrl = `${publicUrl.replace(/\/$/, '')}/connect?t=${encodeURIComponent(bootstrapToken.token)}`;
+                if (onTunnelReady) {
+                  onTunnelReady(publicUrl, connectUrl);
+                } else {
+                  console.log(`\n🌐 Tunnel URL: ${connectUrl}`);
+                  console.log('🔑 One-time connect link (expires after first use)\n');
+                }
+              } else if (onTunnelReady) {
+                onTunnelReady(publicUrl, null);
+              }
+            } catch (error) {
+              console.error(`Failed to start tunnel: ${error.message}`);
+              console.log('Continuing without tunnel...');
+            }
+          }
+
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      };
+
+      server.listen(port, bindHost, onListening);
+    });
+
+    return { activePort };
+  };
+
+  const attachProcessHandlers = ({ attachSignals }) => {
+    if (attachSignals && !getSignalsAttached()) {
+      const handleSignal = async () => {
+        await gracefulShutdown();
+      };
+      process.on('SIGTERM', handleSignal);
+      process.on('SIGINT', handleSignal);
+      process.on('SIGQUIT', handleSignal);
+      setSignalsAttached(true);
+      syncToHmrState();
+    }
+
+    process.on('unhandledRejection', (reason, promise) => {
+      console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+    });
+
+    process.on('uncaughtException', (error) => {
+      console.error('Uncaught Exception:', error);
+      gracefulShutdown();
+    });
+  };
+
+  return {
+    resolveBindHost,
+    startListeningAndMaybeTunnel,
+    attachProcessHandlers,
+  };
+};

package/server/lib/opencode/server-utils-runtime.js

@@ -0,0 +1,168 @@
+import { registerOpenCodeProxy } from './proxy.js';
+import { pathLooksUserConfigured, mergePathValues } from './path-utils.js';
+
+export const createServerUtilsRuntime = (dependencies) => {
+  const {
+    fs,
+    os,
+    path,
+    process,
+    openCodeReadyGraceMs,
+    longRequestTimeoutMs,
+    getRuntime,
+    getOpenCodeAuthHeaders,
+    buildOpenCodeUrl,
+    ensureOpenCodeApiPrefix,
+    getUiNotificationClients,
+    getOpenCodePort,
+    setOpenCodePortState,
+    syncToHmrState,
+    markOpenCodeNotReady,
+    setOpenCodeNotReadySince,
+    clearLastOpenCodeError,
+    getLoginShellPath,
+  } = dependencies;
+
+  const setOpenCodePort = (port) => {
+    if (!Number.isFinite(port) || port <= 0) {
+      return;
+    }
+
+    const numericPort = Math.trunc(port);
+    const currentPort = getOpenCodePort();
+    const portChanged = currentPort !== numericPort;
+
+    if (portChanged || currentPort === null) {
+      setOpenCodePortState(numericPort);
+      syncToHmrState();
+      console.log(`Detected OpenCode port: ${numericPort}`);
+
+      if (portChanged) {
+        markOpenCodeNotReady();
+      }
+      setOpenCodeNotReadySince(Date.now());
+    }
+
+    clearLastOpenCodeError();
+  };
+
+  const waitForOpenCodePort = async (timeoutMs = 15000) => {
+    if (getOpenCodePort() !== null) {
+      return getOpenCodePort();
+    }
+
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      if (getOpenCodePort() !== null) {
+        return getOpenCodePort();
+      }
+    }
+
+    throw new Error('Timed out waiting for OpenCode port');
+  };
+
+  const buildAugmentedPath = () => {
+    const currentPath = process.env.PATH || '';
+    const loginShellPath = getLoginShellPath();
+    const home = os.homedir();
+    const currentPathLooksUserConfigured = pathLooksUserConfigured(currentPath, home, path.delimiter);
+    const primaryPath = currentPathLooksUserConfigured ? currentPath : loginShellPath;
+    const fallbackPath = currentPathLooksUserConfigured ? loginShellPath : currentPath;
+
+    return mergePathValues(primaryPath, fallbackPath, path.delimiter);
+  };
+
+  const buildManagedOpenCodePath = () => {
+    const currentPath = process.env.PATH || '';
+    const loginShellPath = getLoginShellPath();
+
+    return mergePathValues(loginShellPath || '', currentPath, path.delimiter);
+  };
+
+  const parseSseDataPayload = (block) => {
+    if (!block || typeof block !== 'string') {
+      return null;
+    }
+    const dataLines = block
+      .split('\n')
+      .filter((line) => line.startsWith('data:'))
+      .map((line) => line.slice(5).replace(/^\s/, ''));
+
+    if (dataLines.length === 0) {
+      return null;
+    }
+
+    const payloadText = dataLines.join('\n').trim();
+    if (!payloadText) {
+      return null;
+    }
+
+    try {
+      const parsed = JSON.parse(payloadText);
+      if (
+        parsed &&
+        typeof parsed === 'object' &&
+        typeof parsed.payload === 'object' &&
+        parsed.payload !== null
+      ) {
+        return parsed.payload;
+      }
+      return parsed;
+    } catch {
+      return null;
+    }
+  };
+
+  const fetchArraySnapshot = async (route, invalidMessage) => {
+    if (!getOpenCodePort()) {
+      throw new Error('OpenCode port is not available');
+    }
+
+    const response = await fetch(buildOpenCodeUrl(route), {
+      method: 'GET',
+      headers: { Accept: 'application/json', ...getOpenCodeAuthHeaders() },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch ${invalidMessage} (status ${response.status})`);
+    }
+
+    const payload = await response.json().catch(() => null);
+    if (!Array.isArray(payload)) {
+      throw new Error(`Invalid ${invalidMessage} payload from OpenCode`);
+    }
+    return payload;
+  };
+
+  const fetchAgentsSnapshot = () => fetchArraySnapshot('/agent', 'agents snapshot');
+  const fetchProvidersSnapshot = () => fetchArraySnapshot('/provider', 'providers snapshot');
+  const fetchModelsSnapshot = () => fetchArraySnapshot('/model', 'models snapshot');
+
+  const setupProxy = (app) => {
+    registerOpenCodeProxy(app, {
+      fs,
+      os,
+      path,
+      OPEN_CODE_READY_GRACE_MS: openCodeReadyGraceMs,
+      LONG_REQUEST_TIMEOUT_MS: longRequestTimeoutMs,
+      getRuntime,
+      getOpenCodeAuthHeaders,
+      buildOpenCodeUrl,
+      ensureOpenCodeApiPrefix,
+      getUiNotificationClients,
+    });
+  };
+
+  return {
+    setOpenCodePort,
+    waitForOpenCodePort,
+    buildAugmentedPath,
+    buildManagedOpenCodePath,
+    parseSseDataPayload,
+    fetchAgentsSnapshot,
+    fetchProvidersSnapshot,
+    fetchModelsSnapshot,
+    setupProxy,
+  };
+};

package/server/lib/opencode/server-utils-runtime.test.js

@@ -0,0 +1,135 @@
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { createServerUtilsRuntime } from './server-utils-runtime.js';
+
+const originalPath = process.env.PATH;
+
+afterEach(() => {
+  if (originalPath === undefined) {
+    delete process.env.PATH;
+    return;
+  }
+
+  process.env.PATH = originalPath;
+});
+
+const createRuntime = (loginShellPath) => createServerUtilsRuntime({
+  fs: {},
+  os,
+  path,
+  process,
+  openCodeReadyGraceMs: 0,
+  longRequestTimeoutMs: 0,
+  getRuntime: () => ({}),
+  getOpenCodeAuthHeaders: () => ({}),
+  buildOpenCodeUrl: (route) => route,
+  ensureOpenCodeApiPrefix: () => {},
+  getUiNotificationClients: () => new Set(),
+  getOpenCodePort: () => null,
+  setOpenCodePortState: () => {},
+  syncToHmrState: () => {},
+  markOpenCodeNotReady: () => {},
+  setOpenCodeNotReadySince: () => {},
+  clearLastOpenCodeError: () => {},
+  getLoginShellPath: () => loginShellPath,
+});
+
+describe('server utils runtime', () => {
+  it('prefers shell PATH for managed OpenCode before appending process-only entries', () => {
+    const home = os.homedir();
+    const currentPath = [
+      path.join(home, '.opencode', 'bin'),
+      path.join(home, '.bun', 'bin'),
+      path.join(home, 'Library', 'pnpm'),
+      '/opt/homebrew/bin',
+      '/usr/bin',
+    ].join(path.delimiter);
+    process.env.PATH = currentPath;
+
+    const runtime = createRuntime([
+      path.join(home, '.opencode', 'bin'),
+      path.join(home, '.bun', 'bin'),
+      '/opt/homebrew/bin',
+      '/usr/bin',
+      path.join(home, '.cargo', 'bin'),
+    ].join(path.delimiter));
+
+    expect(runtime.buildManagedOpenCodePath()).toBe([
+      path.join(home, '.opencode', 'bin'),
+      path.join(home, '.bun', 'bin'),
+      '/opt/homebrew/bin',
+      '/usr/bin',
+      path.join(home, '.cargo', 'bin'),
+      path.join(home, 'Library', 'pnpm'),
+    ].join(path.delimiter));
+  });
+
+  it('uses login shell PATH for managed OpenCode when process PATH is minimal', () => {
+    const home = os.homedir();
+    const loginShellPath = [
+      path.join(home, '.opencode', 'bin'),
+      path.join(home, '.bun', 'bin'),
+      '/opt/homebrew/bin',
+      '/usr/bin',
+    ].join(path.delimiter);
+    process.env.PATH = ['/usr/local/bin', '/usr/bin', '/bin'].join(path.delimiter);
+
+    const runtime = createRuntime(loginShellPath);
+
+    // Should prefer login shell PATH but merge in any process entries not already present.
+    expect(runtime.buildManagedOpenCodePath()).toBe([
+      path.join(home, '.opencode', 'bin'),
+      path.join(home, '.bun', 'bin'),
+      '/opt/homebrew/bin',
+      '/usr/bin',
+      '/usr/local/bin',
+      '/bin',
+    ].join(path.delimiter));
+  });
+
+  it('preserves user-configured process PATH order before appending shell-only entries', () => {
+    const home = os.homedir();
+    process.env.PATH = [
+      path.join(home, '.bun', 'bin'),
+      path.join(home, 'Library', 'pnpm'),
+      '/opt/homebrew/bin',
+      '/usr/bin',
+    ].join(path.delimiter);
+
+    const runtime = createRuntime([
+      path.join(home, '.bun', 'bin'),
+      '/opt/homebrew/bin',
+      path.join(home, '.cargo', 'bin'),
+      '/usr/bin',
+    ].join(path.delimiter));
+
+    expect(runtime.buildAugmentedPath()).toBe([
+      path.join(home, '.bun', 'bin'),
+      path.join(home, 'Library', 'pnpm'),
+      '/opt/homebrew/bin',
+      '/usr/bin',
+      path.join(home, '.cargo', 'bin'),
+    ].join(path.delimiter));
+  });
+
+  it('prefers login shell PATH when current process PATH is minimal', () => {
+    const home = os.homedir();
+    process.env.PATH = ['/usr/local/bin', '/usr/bin', '/bin'].join(path.delimiter);
+
+    const runtime = createRuntime([
+      path.join(home, '.bun', 'bin'),
+      '/opt/homebrew/bin',
+      '/usr/bin',
+    ].join(path.delimiter));
+
+    expect(runtime.buildAugmentedPath()).toBe([
+      path.join(home, '.bun', 'bin'),
+      '/opt/homebrew/bin',
+      '/usr/bin',
+      '/usr/local/bin',
+      '/bin',
+    ].join(path.delimiter));
+  });
+});