@thevinci/web 1.0.0

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

@@ -0,0 +1,71 @@
+export const createOpenCodeResolutionRuntime = (dependencies) => {
+  const {
+    path,
+    resolveOpencodeCliPath,
+    applyOpencodeBinaryFromSettings,
+    ensureOpencodeCliEnv,
+    resolveManagedOpenCodeLaunchSpec,
+    getResolvedState,
+    setResolvedOpencodeBinarySource,
+  } = dependencies;
+
+  const getOpenCodeResolutionSnapshot = async (settings) => {
+    const configured = typeof settings?.opencodeBinary === 'string' ? settings.opencodeBinary : null;
+
+    const { resolvedOpencodeBinarySource: previousSource } = getResolvedState();
+    const detectedNow = resolveOpencodeCliPath();
+    const { resolvedOpencodeBinarySource: rawDetectedSourceNow } = getResolvedState();
+    setResolvedOpencodeBinarySource(previousSource);
+
+    await applyOpencodeBinaryFromSettings();
+    ensureOpencodeCliEnv();
+
+    const {
+      resolvedOpencodeBinary,
+      resolvedOpencodeBinarySource,
+      useWslForOpencode,
+      resolvedWslBinary,
+      resolvedWslOpencodePath,
+      resolvedWslDistro,
+      resolvedNodeBinary,
+      resolvedBunBinary,
+    } = getResolvedState();
+
+    const resolved = resolvedOpencodeBinary || null;
+    const source = resolvedOpencodeBinarySource || null;
+    const detectedSourceNow =
+      detectedNow &&
+      resolved &&
+      detectedNow === resolved &&
+      rawDetectedSourceNow === 'env' &&
+      source &&
+      source !== 'env'
+        ? source
+        : rawDetectedSourceNow;
+    const launchSpec = resolved && !useWslForOpencode
+      ? resolveManagedOpenCodeLaunchSpec(resolved)
+      : null;
+
+    return {
+      configured,
+      resolved,
+      resolvedDir: resolved ? path.dirname(resolved) : null,
+      source,
+      detectedNow,
+      detectedSourceNow,
+      launchBinary: launchSpec?.binary || null,
+      launchArgs: launchSpec?.args || [],
+      launchWrapperType: launchSpec?.wrapperType || null,
+      viaWsl: useWslForOpencode,
+      wslBinary: resolvedWslBinary || null,
+      wslPath: resolvedWslOpencodePath || null,
+      wslDistro: resolvedWslDistro || null,
+      node: resolvedNodeBinary || null,
+      bun: resolvedBunBinary || null,
+    };
+  };
+
+  return {
+    getOpenCodeResolutionSnapshot,
+  };
+};

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

@@ -0,0 +1,100 @@
+/**
+ * Shared PATH heuristics and merge utilities for server and Electron runtimes.
+ *
+ * The heuristic decides whether the current process.env.PATH looks like it was
+ * configured by the user (or their session manager) vs. a minimal system default.
+ * When the PATH looks user-configured we keep it; otherwise we prefer the login
+ * shell PATH which typically has the full toolchain.
+ */
+
+const TOOLCHAIN_SEGMENTS = [
+  '/opt/homebrew/',
+  '/opt/pkg/',
+  '/opt/pmk/',
+  '/snap/',
+];
+
+const TOOLCHAIN_BASENAMES = new Set([
+  '.cargo',
+  '.bun',
+  '.nvm',
+  '.pyenv',
+  '.rbenv',
+  '.sdkman',
+  '.asdf',
+  '.volta',
+  '.fnm',
+  '.local',
+  '.opencode',
+  'node_modules',
+]);
+
+/**
+ * Returns true when `value` (a PATH string) contains at least one segment that
+ * suggests the PATH was configured by the user or their session manager rather
+ * than being a bare system default.
+ *
+ * @param {string} value  - The PATH string to inspect.
+ * @param {string} home   - The user's home directory (os.homedir()).
+ * @param {string} delim  - The PATH delimiter (':' on POSIX, ';' on Windows).
+ */
+export function pathLooksUserConfigured(value, home, delim) {
+  if (typeof value !== 'string' || !value) {
+    return false;
+  }
+
+  const normalizedHome = typeof home === 'string' ? home.replaceAll('\\', '/') : '';
+  const homeWithSep = normalizedHome ? normalizedHome + '/' : '';
+
+  return value.split(delim).some((segment) => {
+    if (!segment) return false;
+    const normalizedSegment = segment.replaceAll('\\', '/');
+
+    // Any path under the user's home directory.
+    if (normalizedHome && (normalizedSegment === normalizedHome || normalizedSegment.startsWith(homeWithSep))) {
+      return true;
+    }
+
+    // Well-known package-manager / toolchain prefixes.
+    if (TOOLCHAIN_SEGMENTS.some((prefix) => normalizedSegment.startsWith(prefix))) {
+      return true;
+    }
+
+    // Well-known dot-directories inside home (e.g. ~/.cargo/bin).
+    const parts = normalizedSegment.split('/').filter(Boolean);
+    if (parts.some((part) => TOOLCHAIN_BASENAMES.has(part))) {
+      return true;
+    }
+
+    return false;
+  });
+}
+
+/**
+ * Merges two PATH strings, deduplicating segments while preserving the order of
+ * `primary` and appending any segments from `fallback` that are not already
+ * present.
+ *
+ * @param {string} primary  - The preferred PATH (e.g. user-configured or login shell).
+ * @param {string} fallback - The secondary PATH to fill gaps from.
+ * @param {string} delim    - The PATH delimiter.
+ */
+export function mergePathValues(primary, fallback, delim) {
+  const seen = new Set();
+  const result = [];
+
+  const addSegments = (value) => {
+    if (typeof value !== 'string' || !value) return;
+    for (const segment of value.split(delim)) {
+      if (segment && !seen.has(segment)) {
+        seen.add(segment);
+        result.push(segment);
+      }
+    }
+  };
+
+  addSegments(primary);
+  addSegments(fallback);
+
+  return result.join(delim);
+}

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

@@ -0,0 +1,71 @@
+import path from 'node:path';
+import os from 'node:os';
+import { describe, expect, it } from 'vitest';
+
+import { pathLooksUserConfigured, mergePathValues } from './path-utils.js';
+
+const home = os.homedir();
+const delim = path.delimiter;
+
+describe('pathLooksUserConfigured', () => {
+  it('returns false for empty or non-string values', () => {
+    expect(pathLooksUserConfigured('', home, delim)).toBe(false);
+    expect(pathLooksUserConfigured(null, home, delim)).toBe(false);
+    expect(pathLooksUserConfigured(undefined, home, delim)).toBe(false);
+    expect(pathLooksUserConfigured(42, home, delim)).toBe(false);
+  });
+
+  it('returns false for minimal system PATH', () => {
+    expect(pathLooksUserConfigured('/usr/local/bin:/usr/bin:/bin', home, delim)).toBe(false);
+  });
+
+  it('detects paths under home directory', () => {
+    expect(pathLooksUserConfigured(`${home}/.bun/bin:/usr/bin`, home, delim)).toBe(true);
+    expect(pathLooksUserConfigured(`${home}/.local/bin:/usr/bin`, home, delim)).toBe(true);
+  });
+
+  it('detects home directory itself', () => {
+    expect(pathLooksUserConfigured(`${home}:/usr/bin`, home, delim)).toBe(true);
+  });
+
+  it('detects well-known package manager prefixes', () => {
+    expect(pathLooksUserConfigured('/opt/homebrew/bin:/usr/bin', home, delim)).toBe(true);
+    expect(pathLooksUserConfigured('/opt/pkg/bin:/usr/bin', home, delim)).toBe(true);
+    expect(pathLooksUserConfigured('/snap/bin:/usr/bin', home, delim)).toBe(true);
+  });
+
+  it('detects well-known dot-directory basenames', () => {
+    expect(pathLooksUserConfigured('/some/path/.cargo/bin:/usr/bin', home, delim)).toBe(true);
+    expect(pathLooksUserConfigured('/some/path/.nvm/versions/node/v20/bin:/usr/bin', home, delim)).toBe(true);
+    expect(pathLooksUserConfigured('/some/path/.pyenv/shims:/usr/bin', home, delim)).toBe(true);
+    expect(pathLooksUserConfigured('/some/path/.opencode/bin:/usr/bin', home, delim)).toBe(true);
+  });
+
+  it('detects Windows home and toolchain paths', () => {
+    const windowsHome = 'C:\\Users\\agent';
+    expect(pathLooksUserConfigured('C:\\Users\\agent\\.bun\\bin;C:\\Windows\\System32', windowsHome, ';')).toBe(true);
+    expect(pathLooksUserConfigured('C:\\tools\\.cargo\\bin;C:\\Windows\\System32', windowsHome, ';')).toBe(true);
+  });
+});
+
+describe('mergePathValues', () => {
+  it('returns empty string for empty inputs', () => {
+    expect(mergePathValues('', '', delim)).toBe('');
+  });
+
+  it('returns primary when fallback is empty', () => {
+    expect(mergePathValues('/a:/b', '', delim)).toBe('/a:/b');
+  });
+
+  it('returns fallback when primary is empty', () => {
+    expect(mergePathValues('', '/a:/b', delim)).toBe('/a:/b');
+  });
+
+  it('deduplicates segments, preserving primary order', () => {
+    expect(mergePathValues('/a:/b:/c', '/b:/d:/a', delim)).toBe('/a:/b:/c:/d');
+  });
+
+  it('appends all fallback segments when no overlap', () => {
+    expect(mergePathValues('/a:/b', '/c:/d', delim)).toBe('/a:/b:/c:/d');
+  });
+});

package/server/lib/opencode/project-directory-runtime.js

@@ -0,0 +1,124 @@
+export const createProjectDirectoryRuntime = (dependencies) => {
+  const {
+    fsPromises,
+    path,
+    normalizeDirectoryPath,
+    readSettingsFromDiskMigrated,
+    getReadSettingsFromDiskMigrated,
+    sanitizeProjects,
+  } = dependencies;
+
+  const resolveDirectoryCandidate = (value) => {
+    if (typeof value !== 'string') {
+      return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return null;
+    }
+    const normalized = normalizeDirectoryPath(trimmed);
+    return path.resolve(normalized);
+  };
+
+  const validateDirectoryPath = async (candidate) => {
+    const resolved = resolveDirectoryCandidate(candidate);
+    if (!resolved) {
+      return { ok: false, error: 'Directory parameter is required' };
+    }
+    try {
+      const stats = await fsPromises.stat(resolved);
+      if (!stats.isDirectory()) {
+        return { ok: false, error: 'Specified path is not a directory' };
+      }
+      return { ok: true, directory: resolved };
+    } catch (error) {
+      const err = error;
+      if (err && typeof err === 'object' && err.code === 'ENOENT') {
+        return { ok: false, error: 'Directory not found' };
+      }
+      if (err && typeof err === 'object' && err.code === 'EACCES') {
+        return { ok: false, error: 'Access to directory denied' };
+      }
+      return { ok: false, error: 'Failed to validate directory' };
+    }
+  };
+
+  const resolveProjectDirectory = async (req) => {
+    const headerDirectory = typeof req.get === 'function' ? req.get('x-opencode-directory') : null;
+    const queryDirectory = Array.isArray(req.query?.directory)
+      ? req.query.directory[0]
+      : req.query?.directory;
+    const requested = headerDirectory || queryDirectory || null;
+
+    if (requested) {
+      const validated = await validateDirectoryPath(requested);
+      if (!validated.ok) {
+        return { directory: null, error: validated.error };
+      }
+      return { directory: validated.directory, error: null };
+    }
+
+    const readSettings = typeof getReadSettingsFromDiskMigrated === 'function'
+      ? getReadSettingsFromDiskMigrated()
+      : readSettingsFromDiskMigrated;
+    const settings = await readSettings();
+
+    // `lastDirectory` reflects the directory the UI is currently browsing —
+    // useDirectoryStore.setDirectory() persists it on every navigation.
+    // Prefer it over activeProjectId, because the user may have navigated
+    // away from the project that was last "clicked" in the sidebar (e.g. via
+    // `go to parent`, directory picker, or a deep link), leaving
+    // activeProjectId stale. Fetches scoped to the stale project would 400
+    // with "Path is outside of active workspace".
+    if (typeof settings.lastDirectory === 'string' && settings.lastDirectory.trim()) {
+      const validated = await validateDirectoryPath(settings.lastDirectory);
+      if (validated.ok) {
+        return { directory: validated.directory, error: null };
+      }
+    }
+
+    const projects = sanitizeProjects(settings.projects) || [];
+    if (projects.length === 0) {
+      return { directory: null, error: 'Directory parameter or active project is required' };
+    }
+
+    const activeId = typeof settings.activeProjectId === 'string' ? settings.activeProjectId : '';
+    const active = projects.find((project) => project.id === activeId) || projects[0];
+    if (!active || !active.path) {
+      return { directory: null, error: 'Directory parameter or active project is required' };
+    }
+
+    const validated = await validateDirectoryPath(active.path);
+    if (!validated.ok) {
+      return { directory: null, error: validated.error };
+    }
+
+    return { directory: validated.directory, error: null };
+  };
+
+  const resolveOptionalProjectDirectory = async (req) => {
+    const headerDirectory = typeof req.get === 'function' ? req.get('x-opencode-directory') : null;
+    const queryDirectory = Array.isArray(req.query?.directory)
+      ? req.query.directory[0]
+      : req.query?.directory;
+    const requested = headerDirectory || queryDirectory || null;
+
+    if (!requested) {
+      return { directory: null, error: null };
+    }
+
+    const validated = await validateDirectoryPath(requested);
+    if (!validated.ok) {
+      return { directory: null, error: validated.error };
+    }
+
+    return { directory: validated.directory, error: null };
+  };
+
+  return {
+    resolveDirectoryCandidate,
+    validateDirectoryPath,
+    resolveProjectDirectory,
+    resolveOptionalProjectDirectory,
+  };
+};