@thevinci/web 1.0.0

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

@@ -0,0 +1,116 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { createOpenCodeEnvRuntime } from './env-runtime.js';
+
+const originalOpencodeBinary = process.env.OPENCODE_BINARY;
+const originalPlatform = process.platform;
+const tempDirs = [];
+const itIf = (condition) => condition ? it : it.skip;
+
+const createTempDir = (prefix) => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  tempDirs.push(dir);
+  return dir;
+};
+
+const setPlatform = (platform) => {
+  Object.defineProperty(process, 'platform', {
+    value: platform,
+  });
+};
+
+afterEach(() => {
+  Object.defineProperty(process, 'platform', {
+    value: originalPlatform,
+  });
+
+  for (const dir of tempDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+
+  if (typeof originalOpencodeBinary === 'string') {
+    process.env.OPENCODE_BINARY = originalOpencodeBinary;
+    return;
+  }
+  delete process.env.OPENCODE_BINARY;
+});
+
+const createRuntime = (settings) => {
+  const state = {
+    cachedLoginShellEnvSnapshot: null,
+    resolvedOpencodeBinary: null,
+    resolvedOpencodeBinarySource: null,
+    useWslForOpencode: false,
+    resolvedWslBinary: null,
+    resolvedWslOpencodePath: null,
+    resolvedWslDistro: null,
+    resolvedNodeBinary: null,
+    resolvedBunBinary: null,
+    managedOpenCodeShellEnvSnapshot: null,
+  };
+
+  const runtime = createOpenCodeEnvRuntime({
+    state,
+    normalizeDirectoryPath: (value) => value,
+    readSettingsFromDiskMigrated: async () => settings,
+    ENV_CONFIGURED_OPENCODE_WSL_DISTRO: null,
+  });
+
+  return { runtime, state };
+};
+
+describe('OpenCode env runtime', () => {
+  it('throws a specific error for a missing configured OpenCode binary in strict mode', async () => {
+    const { runtime } = createRuntime({ opencodeBinary: '/missing/opencode' });
+
+    await expect(runtime.applyOpencodeBinaryFromSettings({ strict: true })).rejects.toMatchObject({
+      code: 'OPENCODE_BINARY_INVALID',
+      message: expect.stringContaining('Configured OpenCode binary not found: /missing/opencode'),
+    });
+  });
+
+  it('throws a specific error for a configured directory without an executable CLI in strict mode', async () => {
+    const dir = createTempDir('vinci-opencode-dir-');
+    const { runtime } = createRuntime({ opencodeBinary: dir });
+
+    await expect(runtime.applyOpencodeBinaryFromSettings({ strict: true })).rejects.toMatchObject({
+      code: 'OPENCODE_BINARY_INVALID',
+      message: expect.stringContaining('Configured OpenCode binary directory does not contain an executable'),
+    });
+  });
+
+  it('applies a valid configured executable OpenCode binary', async () => {
+    const dir = createTempDir('vinci-opencode-bin-');
+    const binary = path.join(dir, 'opencode');
+    fs.writeFileSync(binary, '#!/bin/sh\nexit 0\n');
+    fs.chmodSync(binary, 0o755);
+    const { runtime, state } = createRuntime({ opencodeBinary: binary });
+
+    await expect(runtime.applyOpencodeBinaryFromSettings({ strict: true })).resolves.toBe(binary);
+    expect(process.env.OPENCODE_BINARY).toBe(binary);
+    expect(state.resolvedOpencodeBinary).toBe(binary);
+    expect(state.resolvedOpencodeBinarySource).toBe('settings');
+  });
+
+  itIf(process.platform === 'darwin')('rejects known macOS OpenCode app bundle executable paths', async () => {
+    const { runtime } = createRuntime({ opencodeBinary: '/Applications/OpenCode.app/Contents/MacOS/OpenCode' });
+
+    await expect(runtime.applyOpencodeBinaryFromSettings({ strict: true })).rejects.toMatchObject({
+      code: 'OPENCODE_BINARY_INVALID',
+      message: expect.stringContaining('macOS desktop app bundle'),
+    });
+  });
+
+  it('does not classify failed WSL resolution as an invalid configured binary in strict mode', async () => {
+    setPlatform('win32');
+    const { runtime } = createRuntime({ opencodeBinary: 'wsl:/usr/local/bin/opencode' });
+
+    const rejection = runtime.applyOpencodeBinaryFromSettings({ strict: true });
+
+    await expect(rejection).rejects.toThrow('uses WSL');
+    const error = await rejection.catch((caught) => caught);
+    expect(error.code).toBeUndefined();
+  });
+});

package/server/lib/opencode/feature-routes-runtime.js

@@ -0,0 +1,244 @@
+import { registerFsRoutes } from '../fs/routes.js';
+import { registerQuotaRoutes } from '../quota/routes.js';
+import { registerGitHubRoutes } from '../github/routes.js';
+import { registerGitRoutes } from '../git/routes.js';
+import { registerMagicPromptRoutes } from '../magic-prompts/routes.js';
+import { registerSessionFoldersRoutes } from '../session-folders/routes.js';
+import { registerConfigEntityRoutes } from './config-entity-routes.js';
+import { registerSettingsUtilityRoutes } from './core-routes.js';
+import { registerProjectIconRoutes } from './project-icon-routes.js';
+import { registerScheduledTaskRoutes } from '../scheduled-tasks/routes.js';
+import { registerSkillRoutes } from './skill-routes.js';
+import { registerOpenCodeRoutes } from './routes.js';
+
+export const createFeatureRoutesRuntime = (dependencies) => {
+  const {
+    clientReloadDelayMs,
+  } = dependencies;
+
+  let quotaProviders = null;
+  const getQuotaProviders = async () => {
+    if (!quotaProviders) {
+      quotaProviders = await import('../quota/index.js');
+    }
+    return quotaProviders;
+  };
+
+  const registerRoutes = async (app, routeDependencies) => {
+    const {
+      crypto,
+      fs,
+      os,
+      path,
+      fsPromises,
+      spawn,
+      resolveGitBinaryForSpawn,
+      createFsSearchRuntime,
+      vinciDataDir,
+      vinciUserConfigRoot,
+      normalizeDirectoryPath,
+      resolveProjectDirectory,
+      resolveOptionalProjectDirectory,
+      validateDirectoryPath,
+      readCustomThemesFromDisk,
+      refreshOpenCodeAfterConfigChange,
+      getOpenCodeResolutionSnapshot,
+      formatSettingsResponse,
+      readSettingsFromDisk,
+      readSettingsFromDiskMigrated,
+      persistSettings,
+      sanitizeProjects,
+      sanitizeSkillCatalogs,
+      isUnsafeSkillRelativePath,
+      buildOpenCodeUrl,
+      getOpenCodeAuthHeaders,
+      getOpenCodePort,
+      buildAugmentedPath,
+      projectConfigRuntime,
+      scheduledTasksRuntime,
+      getVinciEventClients,
+      writeSseEvent,
+    } = routeDependencies;
+
+    const { getProviderSources, removeProviderConfig } = await import('./index.js');
+
+    registerSettingsUtilityRoutes(app, {
+      readCustomThemesFromDisk,
+      refreshOpenCodeAfterConfigChange,
+      clientReloadDelayMs,
+    });
+
+    registerOpenCodeRoutes(app, {
+      crypto,
+      clientReloadDelayMs,
+      getOpenCodeResolutionSnapshot,
+      formatSettingsResponse,
+      readSettingsFromDisk,
+      readSettingsFromDiskMigrated,
+      persistSettings,
+      sanitizeProjects,
+      validateDirectoryPath,
+      resolveProjectDirectory,
+      getProviderSources,
+      removeProviderConfig,
+      refreshOpenCodeAfterConfigChange,
+      buildOpenCodeUrl,
+      getOpenCodeAuthHeaders,
+    });
+
+    registerProjectIconRoutes(app, {
+      fsPromises,
+      path,
+      crypto,
+      vinciDataDir,
+      sanitizeProjects,
+      readSettingsFromDiskMigrated,
+      persistSettings,
+      createFsSearchRuntime,
+      spawn,
+      resolveGitBinaryForSpawn,
+    });
+
+    registerScheduledTaskRoutes(app, {
+      readSettingsFromDiskMigrated,
+      sanitizeProjects,
+      projectConfigRuntime,
+      scheduledTasksRuntime,
+      getVinciEventClients,
+      writeSseEvent,
+    });
+
+    const {
+      getAgentSources,
+      getAgentConfig,
+      createAgent,
+      updateAgent,
+      deleteAgent,
+      getCommandSources,
+      createCommand,
+      updateCommand,
+      deleteCommand,
+      listMcpConfigs,
+      getMcpConfig,
+      createMcpConfig,
+      updateMcpConfig,
+      deleteMcpConfig,
+    } = await import('./index.js');
+
+    registerConfigEntityRoutes(app, {
+      resolveProjectDirectory,
+      resolveOptionalProjectDirectory,
+      refreshOpenCodeAfterConfigChange,
+      clientReloadDelayMs,
+      getAgentSources,
+      getAgentConfig,
+      createAgent,
+      updateAgent,
+      deleteAgent,
+      getCommandSources,
+      createCommand,
+      updateCommand,
+      deleteCommand,
+      listMcpConfigs,
+      getMcpConfig,
+      createMcpConfig,
+      updateMcpConfig,
+      deleteMcpConfig,
+    });
+
+    const {
+      getSkillSources,
+      discoverSkills,
+      createSkill,
+      updateSkill,
+      deleteSkill,
+      readSkillSupportingFile,
+      writeSkillSupportingFile,
+      deleteSkillSupportingFile,
+      SKILL_SCOPE,
+      SKILL_DIR,
+    } = await import('./index.js');
+
+    const {
+      getCuratedSkillsSources,
+      getCacheKey,
+      getCachedScan,
+      setCachedScan,
+      parseSkillRepoSource,
+      scanSkillsRepository,
+      installSkillsFromRepository,
+      scanClawdHubPage,
+      installSkillsFromClawdHub,
+      isClawdHubSource,
+    } = await import('../skills-catalog/index.js');
+    const { getProfiles, getProfile } = await import('../git/index.js');
+
+    registerSkillRoutes(app, {
+      fs,
+      path,
+      os,
+      resolveProjectDirectory,
+      resolveOptionalProjectDirectory,
+      readSettingsFromDisk,
+      sanitizeSkillCatalogs,
+      isUnsafeSkillRelativePath,
+      refreshOpenCodeAfterConfigChange,
+      clientReloadDelayMs,
+      buildOpenCodeUrl,
+      getOpenCodeAuthHeaders,
+      getOpenCodePort,
+      getSkillSources,
+      discoverSkills,
+      createSkill,
+      updateSkill,
+      deleteSkill,
+      readSkillSupportingFile,
+      writeSkillSupportingFile,
+      deleteSkillSupportingFile,
+      SKILL_SCOPE,
+      SKILL_DIR,
+      getCuratedSkillsSources,
+      getCacheKey,
+      getCachedScan,
+      setCachedScan,
+      parseSkillRepoSource,
+      scanSkillsRepository,
+      installSkillsFromRepository,
+      scanClawdHubPage,
+      installSkillsFromClawdHub,
+      isClawdHubSource,
+      getProfiles,
+      getProfile,
+    });
+
+    registerQuotaRoutes(app, { getQuotaProviders });
+    registerGitHubRoutes(app);
+    registerGitRoutes(app);
+    registerMagicPromptRoutes(app, {
+      fsPromises,
+      path,
+      vinciDataDir,
+    });
+    registerSessionFoldersRoutes(app, {
+      fsPromises,
+      path,
+      vinciDataDir,
+    });
+    registerFsRoutes(app, {
+      os,
+      path,
+      fsPromises,
+      spawn,
+      crypto,
+      normalizeDirectoryPath,
+      resolveProjectDirectory,
+      buildAugmentedPath,
+      resolveGitBinaryForSpawn,
+      vinciUserConfigRoot,
+    });
+  };
+
+  return {
+    registerRoutes,
+  };
+};

package/server/lib/opencode/hmr-state-runtime.js

@@ -0,0 +1,85 @@
+export const createHmrStateRuntime = (dependencies) => {
+  const {
+    globalThisLike,
+    os,
+    processLike,
+    stateKey,
+  } = dependencies;
+
+  const getOrCreateHmrState = () => {
+    if (!globalThisLike[stateKey]) {
+      globalThisLike[stateKey] = {
+        openCodeProcess: null,
+        openCodePort: null,
+        openCodeWorkingDirectory: os.homedir(),
+        isShuttingDown: false,
+        signalsAttached: false,
+        userProvidedOpenCodePassword: undefined,
+        openCodeAuthPassword: null,
+        openCodeAuthSource: null,
+      };
+    }
+    return globalThisLike[stateKey];
+  };
+
+  const ensureUserProvidedOpenCodePassword = (hmrState) => {
+    if (typeof hmrState.userProvidedOpenCodePassword !== 'undefined') {
+      return;
+    }
+    const initialPassword = typeof processLike.env.OPENCODE_SERVER_PASSWORD === 'string'
+      ? processLike.env.OPENCODE_SERVER_PASSWORD.trim()
+      : '';
+    hmrState.userProvidedOpenCodePassword = initialPassword || null;
+  };
+
+  const getUserProvidedOpenCodePassword = (hmrState) => (
+    typeof hmrState.userProvidedOpenCodePassword === 'string' && hmrState.userProvidedOpenCodePassword.length > 0
+      ? hmrState.userProvidedOpenCodePassword
+      : null
+  );
+
+  const resolveOpenCodeAuthFromState = ({ hmrState, userProvidedOpenCodePassword }) => ({
+    openCodeAuthPassword:
+      typeof hmrState.openCodeAuthPassword === 'string' && hmrState.openCodeAuthPassword.length > 0
+        ? hmrState.openCodeAuthPassword
+        : userProvidedOpenCodePassword,
+    openCodeAuthSource:
+      typeof hmrState.openCodeAuthSource === 'string' && hmrState.openCodeAuthSource.length > 0
+        ? hmrState.openCodeAuthSource
+        : (userProvidedOpenCodePassword ? 'user-env' : null),
+  });
+
+  const syncStateFromRuntime = (hmrState, runtime) => {
+    hmrState.openCodeProcess = runtime.openCodeProcess;
+    hmrState.openCodePort = runtime.openCodePort;
+    hmrState.openCodeBaseUrl = runtime.openCodeBaseUrl;
+    hmrState.isShuttingDown = runtime.isShuttingDown;
+    hmrState.signalsAttached = runtime.signalsAttached;
+    hmrState.openCodeWorkingDirectory = runtime.openCodeWorkingDirectory;
+    hmrState.openCodeAuthPassword = runtime.openCodeAuthPassword;
+    hmrState.openCodeAuthSource = runtime.openCodeAuthSource;
+  };
+
+  const restoreRuntimeFromState = ({ hmrState, userProvidedOpenCodePassword }) => {
+    const auth = resolveOpenCodeAuthFromState({ hmrState, userProvidedOpenCodePassword });
+    return {
+      openCodeProcess: hmrState.openCodeProcess,
+      openCodePort: hmrState.openCodePort,
+      openCodeBaseUrl: hmrState.openCodeBaseUrl ?? null,
+      isShuttingDown: hmrState.isShuttingDown,
+      signalsAttached: hmrState.signalsAttached,
+      openCodeWorkingDirectory: hmrState.openCodeWorkingDirectory,
+      openCodeAuthPassword: auth.openCodeAuthPassword,
+      openCodeAuthSource: auth.openCodeAuthSource,
+    };
+  };
+
+  return {
+    getOrCreateHmrState,
+    ensureUserProvidedOpenCodePassword,
+    getUserProvidedOpenCodePassword,
+    resolveOpenCodeAuthFromState,
+    syncStateFromRuntime,
+    restoreRuntimeFromState,
+  };
+};

package/server/lib/opencode/index.js

@@ -0,0 +1,66 @@
+export {
+  AGENT_DIR,
+  COMMAND_DIR,
+  SKILL_DIR,
+  CONFIG_FILE,
+  AGENT_SCOPE,
+  COMMAND_SCOPE,
+  SKILL_SCOPE,
+  readConfig,
+  writeConfig,
+  readSkillSupportingFile,
+  writeSkillSupportingFile,
+  deleteSkillSupportingFile,
+} from './shared.js';
+
+export {
+  getAgentScope,
+  getAgentPermissionSource,
+  getAgentSources,
+  getAgentConfig,
+  createAgent,
+  updateAgent,
+  deleteAgent,
+} from './agents.js';
+
+export {
+  getCommandScope,
+  getCommandSources,
+  createCommand,
+  updateCommand,
+  deleteCommand,
+} from './commands.js';
+
+export {
+  getSkillSources,
+  getSkillScope,
+  discoverSkills,
+  createSkill,
+  updateSkill,
+  deleteSkill,
+} from './skills.js';
+
+export {
+  getProviderSources,
+  removeProviderConfig,
+} from './providers.js';
+
+export {
+  readAuthFile,
+  writeAuthFile,
+  removeProviderAuth,
+  getProviderAuth,
+  listProviderAuths,
+  AUTH_FILE,
+  OPENCODE_DATA_DIR,
+} from './auth.js';
+
+export { createUiAuth } from '../ui-auth/ui-auth.js';
+
+export {
+  listMcpConfigs,
+  getMcpConfig,
+  createMcpConfig,
+  updateMcpConfig,
+  deleteMcpConfig,
+} from './mcp.js';