@thevinci/web 1.0.0

package/server/lib/opencode/lifecycle.test.js

@@ -0,0 +1,240 @@
+import { EventEmitter } from 'node:events';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const spawnMock = vi.fn();
+
+vi.mock('node:child_process', () => ({
+  spawn: spawnMock,
+  spawnSync: vi.fn(),
+}));
+
+const { createOpenCodeLifecycleRuntime } = await import('./lifecycle.js');
+
+const originalOpencodeBinary = process.env.OPENCODE_BINARY;
+const originalPath = process.env.PATH;
+
+afterEach(() => {
+  spawnMock.mockReset();
+  if (typeof originalOpencodeBinary === 'string') {
+    process.env.OPENCODE_BINARY = originalOpencodeBinary;
+  } else {
+    delete process.env.OPENCODE_BINARY;
+  }
+
+  if (typeof originalPath === 'string') {
+    process.env.PATH = originalPath;
+  } else {
+    delete process.env.PATH;
+  }
+});
+
+const createMockChild = () => {
+  const child = new EventEmitter();
+  child.stdout = new EventEmitter();
+  child.stderr = new EventEmitter();
+  child.exitCode = null;
+  child.signalCode = null;
+  child.pid = 12345;
+  child.kill = vi.fn(() => {
+    child.signalCode = 'SIGTERM';
+    queueMicrotask(() => child.emit('close', null, 'SIGTERM'));
+    return true;
+  });
+  return child;
+};
+
+const createRuntime = (overrides = {}) => {
+  const state = {
+    openCodeWorkingDirectory: '/tmp/project',
+    openCodeProcess: null,
+    openCodePort: null,
+    openCodeBaseUrl: null,
+    currentRestartPromise: null,
+    isRestartingOpenCode: false,
+    openCodeApiPrefix: '',
+    openCodeApiPrefixDetected: false,
+    openCodeApiDetectionTimer: null,
+    lastOpenCodeError: null,
+    isOpenCodeReady: false,
+    openCodeNotReadySince: 0,
+    isExternalOpenCode: false,
+    isShuttingDown: false,
+    healthCheckInterval: null,
+    expressApp: null,
+    useWslForOpencode: false,
+    resolvedWslBinary: null,
+    resolvedWslOpencodePath: null,
+    resolvedWslDistro: null,
+  };
+
+  return createOpenCodeLifecycleRuntime({
+    state,
+    env: {
+      ENV_CONFIGURED_OPENCODE_PORT: 45678,
+      ENV_CONFIGURED_OPENCODE_HOST: null,
+      ENV_EFFECTIVE_PORT: 3001,
+      ENV_CONFIGURED_OPENCODE_HOSTNAME: '127.0.0.1',
+      ENV_SKIP_OPENCODE_START: false,
+    },
+    syncToHmrState: vi.fn(),
+    syncFromHmrState: vi.fn(),
+    getOpenCodeAuthHeaders: () => ({}),
+    buildOpenCodeUrl: (route) => `http://127.0.0.1:45678${route}`,
+    waitForReady: vi.fn(async () => true),
+    normalizeApiPrefix: vi.fn(() => ''),
+    applyOpencodeBinaryFromSettings: vi.fn(async () => null),
+    ensureOpencodeCliEnv: vi.fn(),
+    ensureLocalOpenCodeServerPassword: vi.fn(async () => 'password'),
+    buildWslExecArgs: vi.fn((args) => args),
+    resolveWslExecutablePath: vi.fn(),
+    resolveManagedOpenCodeLaunchSpec: vi.fn((binary) => ({ binary, args: [], wrapperType: null })),
+    setOpenCodePort: vi.fn((port) => {
+      state.openCodePort = port;
+    }),
+    setDetectedOpenCodeApiPrefix: vi.fn(),
+    setupProxy: vi.fn(),
+    ensureOpenCodeApiPrefix: vi.fn(),
+    clearResolvedOpenCodeBinary: vi.fn(),
+    buildAugmentedPath: vi.fn(() => '/home/user/.bun/bin:/usr/local/bin:/usr/bin'),
+    buildManagedOpenCodePath: vi.fn(() => '/home/user/.bun/bin:/usr/local/bin:/usr/bin'),
+    getManagedOpenCodeShellEnvSnapshot: vi.fn(() => ({
+      PATH: '/home/user/.bun/bin:/usr/local/bin:/usr/bin',
+      SHELL_ONLY: 'yes',
+      OPENCODE_SERVER_PASSWORD: 'shell-password',
+    })),
+    ...overrides,
+  });
+};
+
+describe('OpenCode lifecycle', () => {
+  it('launches managed OpenCode with the managed PATH', async () => {
+    delete process.env.OPENCODE_BINARY;
+    const child = createMockChild();
+    spawnMock.mockImplementationOnce(() => {
+      queueMicrotask(() => {
+        child.stdout.emit('data', 'opencode server listening on http://127.0.0.1:45678\n');
+      });
+      return child;
+    });
+
+    const runtime = createRuntime();
+    const server = await runtime.startOpenCode();
+    const [binary, args, options] = spawnMock.mock.calls[0];
+
+    expect(binary).toBe('opencode');
+    expect(args).toEqual(['serve', '--hostname', '127.0.0.1', '--port', '45678']);
+    expect(options.env.PATH).toBe('/home/user/.bun/bin:/usr/local/bin:/usr/bin');
+    expect(options.env.SHELL_ONLY).toBe('yes');
+    expect(options.env.OPENCODE_SERVER_PASSWORD).toBe('password');
+
+    await server.close();
+  });
+
+  it('falls back to buildAugmentedPath when buildManagedOpenCodePath is not provided', async () => {
+    delete process.env.OPENCODE_BINARY;
+    const child = createMockChild();
+    spawnMock.mockImplementationOnce(() => {
+      queueMicrotask(() => {
+        child.stdout.emit('data', 'opencode server listening on http://127.0.0.1:45678\n');
+      });
+      return child;
+    });
+
+    const runtime = createRuntime({
+      buildManagedOpenCodePath: undefined,
+      buildAugmentedPath: vi.fn(() => '/home/user/.cargo/bin:/usr/local/bin'),
+    });
+    const server = await runtime.startOpenCode();
+    const [, , options] = spawnMock.mock.calls[0];
+
+    expect(options.env.PATH).toBe('/home/user/.cargo/bin:/usr/local/bin');
+
+    await server.close();
+  });
+
+  it('falls back to process.env.PATH when neither build function is provided', async () => {
+    delete process.env.OPENCODE_BINARY;
+    process.env.PATH = '/usr/bin:/bin';
+    const child = createMockChild();
+    spawnMock.mockImplementationOnce(() => {
+      queueMicrotask(() => {
+        child.stdout.emit('data', 'opencode server listening on http://127.0.0.1:45678\n');
+      });
+      return child;
+    });
+
+    const runtime = createRuntime({
+      buildManagedOpenCodePath: undefined,
+      buildAugmentedPath: undefined,
+    });
+    const server = await runtime.startOpenCode();
+    const [, , options] = spawnMock.mock.calls[0];
+
+    expect(options.env.PATH).toBe('/usr/bin:/bin');
+
+    await server.close();
+  });
+
+  it('reports the binary when managed OpenCode exits before becoming ready', async () => {
+    delete process.env.OPENCODE_BINARY;
+    const firstChild = createMockChild();
+    const secondChild = createMockChild();
+    spawnMock.mockImplementationOnce(() => {
+      queueMicrotask(() => {
+        firstChild.emit('exit', null, 'SIGTERM');
+      });
+      return firstChild;
+    });
+    spawnMock.mockImplementationOnce(() => {
+      queueMicrotask(() => {
+        secondChild.emit('exit', null, 'SIGTERM');
+      });
+      return secondChild;
+    });
+
+    const runtime = createRuntime();
+
+    await expect(runtime.startOpenCode()).rejects.toThrow('OpenCode process exited before serving with signal SIGTERM. Binary used: opencode. No stdout/stderr captured');
+    expect(spawnMock).toHaveBeenCalledTimes(2);
+  });
+
+  it('does not retry managed startup when the configured OpenCode binary is invalid', async () => {
+    delete process.env.OPENCODE_BINARY;
+    const error = new Error('Configured OpenCode binary not found: /missing/opencode');
+    error.code = 'OPENCODE_BINARY_INVALID';
+    const applyOpencodeBinaryFromSettings = vi.fn(async () => {
+      throw error;
+    });
+
+    const runtime = createRuntime({ applyOpencodeBinaryFromSettings });
+
+    await expect(runtime.startOpenCode()).rejects.toThrow('Configured OpenCode binary not found: /missing/opencode');
+    expect(applyOpencodeBinaryFromSettings).toHaveBeenCalledTimes(1);
+    expect(applyOpencodeBinaryFromSettings).toHaveBeenCalledWith({ strict: true });
+    expect(spawnMock).not.toHaveBeenCalled();
+  });
+
+  it('retries managed OpenCode startup once after a pre-ready exit', async () => {
+    delete process.env.OPENCODE_BINARY;
+    const firstChild = createMockChild();
+    const secondChild = createMockChild();
+    spawnMock.mockImplementationOnce(() => {
+      queueMicrotask(() => {
+        firstChild.emit('exit', null, 'SIGTERM');
+      });
+      return firstChild;
+    });
+    spawnMock.mockImplementationOnce(() => {
+      queueMicrotask(() => {
+        secondChild.stdout.emit('data', 'opencode server listening on http://127.0.0.1:45678\n');
+      });
+      return secondChild;
+    });
+
+    const runtime = createRuntime();
+    const server = await runtime.startOpenCode();
+
+    expect(spawnMock).toHaveBeenCalledTimes(2);
+    await server.close();
+  });
+});

package/server/lib/opencode/mcp.js

@@ -0,0 +1,278 @@
+import fs from 'fs';
+import path from 'path';
+import {
+  CONFIG_FILE,
+  AGENT_SCOPE,
+  readConfigFile,
+  readConfigLayers,
+  getJsonEntrySource,
+  getJsonWriteTarget,
+  writeConfig,
+} from './shared.js';
+
+// ============== MCP CONFIG HELPERS ==============
+
+/**
+ * Validate MCP server name
+ */
+function validateMcpName(name) {
+  if (!name || typeof name !== 'string') {
+    throw new Error('MCP server name is required');
+  }
+  if (!/^[a-z0-9][a-z0-9_-]*[a-z0-9]$|^[a-z0-9]$/.test(name)) {
+    throw new Error('MCP server name must be lowercase alphanumeric with hyphens/underscores');
+  }
+}
+
+/**
+ * List all MCP server configs from user-level opencode.json
+ */
+function resolveMcpScopeFromPath(layers, sourcePath) {
+  if (!sourcePath) return null;
+  return sourcePath === layers.paths.projectPath ? AGENT_SCOPE.PROJECT : AGENT_SCOPE.USER;
+}
+
+function ensureProjectMcpConfigPath(workingDirectory) {
+  const configDir = path.join(workingDirectory, '.opencode');
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  return path.join(configDir, 'opencode.json');
+}
+
+function listMcpConfigs(workingDirectory) {
+  const layers = readConfigLayers(workingDirectory);
+  const mcp = layers?.mergedConfig?.mcp || {};
+
+  return Object.entries(mcp)
+    .filter(([, entry]) => entry && typeof entry === 'object' && !Array.isArray(entry))
+    .map(([name, entry]) => {
+      const source = getJsonEntrySource(layers, 'mcp', name);
+      return {
+        name,
+        ...buildMcpEntry(entry),
+        scope: resolveMcpScopeFromPath(layers, source.path),
+      };
+    });
+}
+
+/**
+ * Get a single MCP server config by name
+ */
+function getMcpConfig(name, workingDirectory) {
+  const layers = readConfigLayers(workingDirectory);
+  const entry = layers?.mergedConfig?.mcp?.[name];
+
+  if (!entry) {
+    return null;
+  }
+  const source = getJsonEntrySource(layers, 'mcp', name);
+  return {
+    name,
+    ...buildMcpEntry(entry),
+    scope: resolveMcpScopeFromPath(layers, source.path),
+  };
+}
+
+/**
+ * Create a new MCP server config entry
+ */
+function createMcpConfig(name, mcpConfig, workingDirectory, scope) {
+  validateMcpName(name);
+
+  const layers = readConfigLayers(workingDirectory);
+  const source = getJsonEntrySource(layers, 'mcp', name);
+  if (source.exists) {
+    throw new Error(`MCP server "${name}" already exists`);
+  }
+
+  let targetPath = CONFIG_FILE;
+  let config = {};
+
+  if (scope === AGENT_SCOPE.PROJECT) {
+    if (!workingDirectory) {
+      throw new Error('Project scope requires working directory');
+    }
+    targetPath = ensureProjectMcpConfigPath(workingDirectory);
+    config = fs.existsSync(targetPath) ? readConfigFile(targetPath) : {};
+  } else {
+    const jsonTarget = getJsonWriteTarget(layers, AGENT_SCOPE.USER);
+    targetPath = jsonTarget.path || CONFIG_FILE;
+    config = jsonTarget.config || {};
+  }
+
+  if (!config.mcp || typeof config.mcp !== 'object' || Array.isArray(config.mcp)) {
+    config.mcp = {};
+  }
+
+  const { name: _ignoredName, ...entryData } = mcpConfig;
+  config.mcp[name] = buildMcpEntry(entryData);
+
+  writeConfig(config, targetPath);
+  console.log(`Created MCP server config: ${name}`);
+}
+
+/**
+ * Update an existing MCP server config entry
+ */
+function updateMcpConfig(name, updates, workingDirectory) {
+  const layers = readConfigLayers(workingDirectory);
+  const source = getJsonEntrySource(layers, 'mcp', name);
+
+  if (!source.exists) {
+    throw new Error(`MCP server "${name}" not found`);
+  }
+
+  const targetPath = source.path || CONFIG_FILE;
+  const config = source.config || (fs.existsSync(targetPath) ? readConfigFile(targetPath) : {});
+
+  if (!config.mcp || typeof config.mcp !== 'object' || Array.isArray(config.mcp)) {
+    config.mcp = {};
+  }
+
+  const existing = config.mcp[name];
+  const { name: _ignoredName, ...updateData } = updates;
+
+  config.mcp[name] = buildMcpEntry({ ...existing, ...updateData });
+
+  writeConfig(config, targetPath);
+  console.log(`Updated MCP server config: ${name}`);
+}
+
+/**
+ * Delete an MCP server config entry
+ */
+function deleteMcpConfig(name, workingDirectory) {
+  const layers = readConfigLayers(workingDirectory);
+  const source = getJsonEntrySource(layers, 'mcp', name);
+  const targetPath = source.path || CONFIG_FILE;
+  const config = source.config || (fs.existsSync(targetPath) ? readConfigFile(targetPath) : {});
+
+  if (!config.mcp || typeof config.mcp !== 'object' || config.mcp[name] === undefined) {
+    throw new Error(`MCP server "${name}" not found`);
+  }
+
+  delete config.mcp[name];
+
+  if (Object.keys(config.mcp).length === 0) {
+    delete config.mcp;
+  }
+
+  writeConfig(config, targetPath);
+  console.log(`Deleted MCP server config: ${name}`);
+}
+
+/**
+ * Build a clean MCP entry object, omitting undefined/null values
+ */
+function buildMcpEntry(data) {
+  const entry = (data && typeof data === 'object' && !Array.isArray(data))
+    ? { ...data }
+    : {};
+
+  delete entry.name;
+  delete entry.scope;
+
+  // type is required
+  entry.type = data.type === 'remote' ? 'remote' : 'local';
+
+  if (entry.type === 'local') {
+    // command must be a non-empty array of strings
+    if (Array.isArray(data.command) && data.command.length > 0) {
+      entry.command = data.command.map(String);
+    } else {
+      delete entry.command;
+    }
+
+    delete entry.url;
+    delete entry.headers;
+    delete entry.oauth;
+    delete entry.timeout;
+  } else {
+    // remote: url required
+    if (data.url && typeof data.url === 'string') {
+      entry.url = data.url.trim();
+    } else {
+      delete entry.url;
+    }
+
+    delete entry.command;
+
+    if (data.headers && typeof data.headers === 'object' && !Array.isArray(data.headers)) {
+      const cleaned = {};
+      for (const [k, v] of Object.entries(data.headers)) {
+        if (k && v !== undefined && v !== null) {
+          cleaned[k] = String(v);
+        }
+      }
+      if (Object.keys(cleaned).length > 0) {
+        entry.headers = cleaned;
+      } else {
+        delete entry.headers;
+      }
+    } else if (data.headers === undefined) {
+      delete entry.headers;
+    }
+
+    if (data.oauth === false) {
+      entry.oauth = false;
+    } else if (data.oauth && typeof data.oauth === 'object' && !Array.isArray(data.oauth)) {
+      const oauth = {};
+      if (typeof data.oauth.clientId === 'string' && data.oauth.clientId.trim()) {
+        oauth.clientId = data.oauth.clientId.trim();
+      }
+      if (typeof data.oauth.clientSecret === 'string' && data.oauth.clientSecret.trim()) {
+        oauth.clientSecret = data.oauth.clientSecret.trim();
+      }
+      if (typeof data.oauth.scope === 'string' && data.oauth.scope.trim()) {
+        oauth.scope = data.oauth.scope.trim();
+      }
+      if (typeof data.oauth.redirectUri === 'string' && data.oauth.redirectUri.trim()) {
+        oauth.redirectUri = data.oauth.redirectUri.trim();
+      }
+      if (Object.keys(oauth).length > 0) {
+        entry.oauth = oauth;
+      } else {
+        delete entry.oauth;
+      }
+    } else if (data.oauth === undefined) {
+      delete entry.oauth;
+    }
+
+    if (typeof data.timeout === 'number' && Number.isFinite(data.timeout) && data.timeout > 0) {
+      entry.timeout = data.timeout;
+    } else if (data.timeout === undefined || data.timeout === null || data.timeout === '') {
+      delete entry.timeout;
+    }
+  }
+
+  // environment: flat Record<string, string>
+  if (data.environment && typeof data.environment === 'object' && !Array.isArray(data.environment)) {
+    const cleaned = {};
+    for (const [k, v] of Object.entries(data.environment)) {
+      if (k && v !== undefined && v !== null) {
+        cleaned[k] = String(v);
+      }
+    }
+    if (Object.keys(cleaned).length > 0) {
+      entry.environment = cleaned;
+    } else {
+      delete entry.environment;
+    }
+  } else if (data.environment === undefined) {
+    delete entry.environment;
+  }
+
+  // enabled defaults to true
+  entry.enabled = data.enabled !== false;
+
+  return entry;
+}
+
+export {
+  listMcpConfigs,
+  getMcpConfig,
+  createMcpConfig,
+  updateMcpConfig,
+  deleteMcpConfig,
+};

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

@@ -0,0 +1,104 @@
+export const createOpenCodeNetworkRuntime = (deps) => {
+  const {
+    state,
+    getOpenCodeAuthHeaders,
+  } = deps;
+
+  const normalizeApiPrefix = (prefix) => {
+    if (!prefix) {
+      return '';
+    }
+
+    if (prefix.includes('://')) {
+      try {
+        const parsed = new URL(prefix);
+        return normalizeApiPrefix(parsed.pathname);
+      } catch {
+        return '';
+      }
+    }
+
+    const trimmed = prefix.trim();
+    if (!trimmed || trimmed === '/') {
+      return '';
+    }
+    const withLeading = trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+    return withLeading.endsWith('/') ? withLeading.slice(0, -1) : withLeading;
+  };
+
+  const waitForReady = async (url, timeoutMs = 10000) => {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      let timeout = null;
+      try {
+        const controller = new AbortController();
+        timeout = setTimeout(() => controller.abort(), 3000);
+        const response = await fetch(`${url.replace(/\/+$/, '')}/global/health`, {
+          method: 'GET',
+          headers: {
+            Accept: 'application/json',
+            ...getOpenCodeAuthHeaders(),
+          },
+          signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        timeout = null;
+
+        if (response.ok) {
+          const body = await response.json().catch(() => null);
+          if (body?.healthy === true) {
+            return true;
+          }
+        }
+      } catch {
+      } finally {
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    return false;
+  };
+
+  const setDetectedOpenCodeApiPrefix = () => {
+    state.openCodeApiPrefix = '';
+    state.openCodeApiPrefixDetected = true;
+    if (state.openCodeApiDetectionTimer) {
+      clearTimeout(state.openCodeApiDetectionTimer);
+      state.openCodeApiDetectionTimer = null;
+    }
+  };
+
+  const buildOpenCodeUrl = (path, prefixOverride) => {
+    if (!state.openCodePort) {
+      throw new Error('OpenCode port is not available');
+    }
+    const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+    const prefix = normalizeApiPrefix(prefixOverride !== undefined ? prefixOverride : '');
+    const fullPath = `${prefix}${normalizedPath}`;
+    const base = state.openCodeBaseUrl ?? `http://localhost:${state.openCodePort}`;
+    return `${base}${fullPath}`;
+  };
+
+  const detectOpenCodeApiPrefix = () => {
+    state.openCodeApiPrefixDetected = true;
+    state.openCodeApiPrefix = '';
+    return true;
+  };
+
+  const ensureOpenCodeApiPrefix = () => detectOpenCodeApiPrefix();
+
+  const scheduleOpenCodeApiDetection = () => {
+    return;
+  };
+
+  return {
+    waitForReady,
+    normalizeApiPrefix,
+    setDetectedOpenCodeApiPrefix,
+    buildOpenCodeUrl,
+    ensureOpenCodeApiPrefix,
+    scheduleOpenCodeApiDetection,
+  };
+};

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

@@ -0,0 +1,37 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { createOpenCodeNetworkRuntime } from './network-runtime.js';
+
+const createRuntime = () => createOpenCodeNetworkRuntime({
+  state: {
+    openCodePort: 4096,
+    openCodeBaseUrl: null,
+    openCodeApiPrefix: '',
+    openCodeApiPrefixDetected: false,
+    openCodeApiDetectionTimer: null,
+  },
+  getOpenCodeAuthHeaders: () => ({}),
+});
+
+describe('OpenCode network runtime', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+
+  it('clears the probe abort timer when readiness fetch rejects', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    vi.stubGlobal('fetch', vi.fn(async () => {
+      throw new Error('offline');
+    }));
+
+    const runtime = createRuntime();
+    const readyPromise = runtime.waitForReady('http://127.0.0.1:4096', 1);
+
+    await vi.advanceTimersByTimeAsync(100);
+    await expect(readyPromise).resolves.toBe(false);
+
+    expect(vi.getTimerCount()).toBe(0);
+  });
+});