@openchamber/web 1.11.5 → 1.11.7

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

@@ -51,6 +51,30 @@ export const createOpenCodeEnvRuntime = (deps) => {
     }
   };
 
+  const resolveWindowsExecutablePath = (candidate) => {
+    if (process.platform !== 'win32' || typeof candidate !== 'string' || candidate.trim().length === 0) {
+      return candidate;
+    }
+
+    const trimmed = candidate.trim();
+    const ext = path.extname(trimmed).toLowerCase();
+    if (ext) {
+      return isExecutable(trimmed) ? trimmed : null;
+    }
+
+    const pathExt = process.env.PATHEXT || process.env.PathExt || '.COM;.EXE;.BAT;.CMD';
+    for (const rawExt of pathExt.split(';')) {
+      const normalizedExt = rawExt.trim();
+      if (!normalizedExt) continue;
+      const withExt = `${trimmed}${normalizedExt.startsWith('.') ? normalizedExt : `.${normalizedExt}`}`;
+      if (isExecutable(withExt)) {
+        return withExt;
+      }
+    }
+
+    return isExecutable(trimmed) ? trimmed : null;
+  };
+
   const searchPathFor = (binaryName) => {
     const trimmed = typeof binaryName === 'string' ? binaryName.trim() : '';
     if (!trimmed) {
@@ -59,7 +83,7 @@ export const createOpenCodeEnvRuntime = (deps) => {
 
     const current = process.env.PATH || '';
     const parts = current.split(path.delimiter).filter(Boolean);
-    const candidateNames = [trimmed];
+    const candidateNames = [];
 
     if (process.platform === 'win32' && !path.extname(trimmed)) {
       const pathExt = process.env.PATHEXT || process.env.PathExt || '.COM;.EXE;.BAT;.CMD';
@@ -73,6 +97,8 @@ export const createOpenCodeEnvRuntime = (deps) => {
       }
     }
 
+    candidateNames.push(trimmed);
+
     for (const dir of parts) {
       for (const candidateName of candidateNames) {
         const candidate = path.join(dir, candidateName);
@@ -649,6 +675,9 @@ export const createOpenCodeEnvRuntime = (deps) => {
     if (!trimmed) {
       return null;
     }
+    if (process.platform === 'win32') {
+      return resolveWindowsExecutablePath(trimmed);
+    }
     return isExecutable(trimmed) ? trimmed : null;
   };
 
@@ -669,10 +698,20 @@ export const createOpenCodeEnvRuntime = (deps) => {
       return null;
     }
 
+    const packageShim = path.join(nodeModulesDir, 'opencode-ai', 'bin', 'opencode.exe');
+    if (isExecutable(packageShim)) {
+      return packageShim;
+    }
+
     for (const packageName of getWindowsNativeOpencodePackageNames()) {
-      const candidate = path.join(nodeModulesDir, packageName, 'bin', 'opencode.exe');
-      if (isExecutable(candidate)) {
-        return candidate;
+      const candidates = [
+        path.join(nodeModulesDir, packageName, 'bin', 'opencode.exe'),
+        path.join(nodeModulesDir, 'opencode-ai', 'node_modules', packageName, 'bin', 'opencode.exe'),
+      ];
+      for (const candidate of candidates) {
+        if (isExecutable(candidate)) {
+          return candidate;
+        }
       }
     }
 
@@ -816,6 +855,15 @@ export const createOpenCodeEnvRuntime = (deps) => {
 
       const directBinary = normalizeExecutableCandidate(candidate);
       if (directBinary) {
+        const directExt = path.extname(directBinary).toLowerCase();
+        if (WINDOWS_BATCH_EXTENSIONS.has(directExt)) {
+          return {
+            binary: process.env.ComSpec || 'cmd.exe',
+            args: ['/d', '/s', '/c', 'call', directBinary],
+            wrapperType: 'cmd-wrapper',
+          };
+        }
+
         return {
           binary: directBinary,
           args: [],

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

@@ -5,6 +5,11 @@ import { afterEach, describe, expect, it } from 'vitest';
 import { createOpenCodeEnvRuntime } from './env-runtime.js';
 
 const originalOpencodeBinary = process.env.OPENCODE_BINARY;
+const originalComSpec = process.env.ComSpec;
+const originalPath = process.env.PATH;
+const originalSystemRoot = process.env.SystemRoot;
+const originalWslBinary = process.env.WSL_BINARY;
+const originalOpenChamberWslBinary = process.env.OPENCHAMBER_WSL_BINARY;
 const originalPlatform = process.platform;
 const tempDirs = [];
 const itIf = (condition) => condition ? it : it.skip;
@@ -32,9 +37,39 @@ afterEach(() => {
 
   if (typeof originalOpencodeBinary === 'string') {
     process.env.OPENCODE_BINARY = originalOpencodeBinary;
-    return;
+  } else {
+    delete process.env.OPENCODE_BINARY;
+  }
+
+  if (typeof originalComSpec === 'string') {
+    process.env.ComSpec = originalComSpec;
+  } else {
+    delete process.env.ComSpec;
+  }
+
+  if (typeof originalPath === 'string') {
+    process.env.PATH = originalPath;
+  } else {
+    delete process.env.PATH;
+  }
+
+  if (typeof originalSystemRoot === 'string') {
+    process.env.SystemRoot = originalSystemRoot;
+  } else {
+    delete process.env.SystemRoot;
+  }
+
+  if (typeof originalWslBinary === 'string') {
+    process.env.WSL_BINARY = originalWslBinary;
+  } else {
+    delete process.env.WSL_BINARY;
+  }
+
+  if (typeof originalOpenChamberWslBinary === 'string') {
+    process.env.OPENCHAMBER_WSL_BINARY = originalOpenChamberWslBinary;
+  } else {
+    delete process.env.OPENCHAMBER_WSL_BINARY;
   }
-  delete process.env.OPENCODE_BINARY;
 });
 
 const createRuntime = (settings) => {
@@ -103,14 +138,55 @@ describe('OpenCode env runtime', () => {
     });
   });
 
-  it('does not classify failed WSL resolution as an invalid configured binary in strict mode', async () => {
+  it('does not classify WSL settings as a native invalid configured binary in strict mode', async () => {
     setPlatform('win32');
+    const dir = createTempDir('openchamber-no-wsl-');
+    process.env.PATH = dir;
+    process.env.SystemRoot = dir;
+    process.env.WSL_BINARY = path.join(dir, 'missing-wsl.exe');
+    process.env.OPENCHAMBER_WSL_BINARY = path.join(dir, 'missing-openchamber-wsl.exe');
     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();
+    try {
+      await rejection;
+      expect(runtime.resolveManagedOpenCodeLaunchSpec('opencode').wrapperType).not.toBe('cmd-wrapper');
+    } catch (error) {
+      expect(error.message).toContain('uses WSL');
+      expect(error.code).toBeUndefined();
+    }
+  });
+
+  it('launches Windows cmd shims through cmd call without embedded quotes', () => {
+    setPlatform('win32');
+    process.env.ComSpec = 'C:\\Windows\\System32\\cmd.exe';
+    const dir = createTempDir('openchamber-opencode-cmd-');
+    const shim = path.join(dir, 'opencode.cmd');
+    fs.writeFileSync(shim, '@echo off\r\nexit /b 0\r\n');
+    const { runtime } = createRuntime({});
+
+    expect(runtime.resolveManagedOpenCodeLaunchSpec(shim)).toEqual({
+      binary: 'C:\\Windows\\System32\\cmd.exe',
+      args: ['/d', '/s', '/c', 'call', shim],
+      wrapperType: 'cmd-wrapper',
+    });
+  });
+
+  it('resolves npm OpenCode cmd shims to the packaged Windows executable', () => {
+    setPlatform('win32');
+    const npmDir = createTempDir('openchamber-opencode-npm-');
+    const shim = path.join(npmDir, 'opencode.cmd');
+    const nativeBinary = path.join(npmDir, 'node_modules', 'opencode-ai', 'bin', 'opencode.exe');
+    fs.mkdirSync(path.dirname(nativeBinary), { recursive: true });
+    fs.writeFileSync(nativeBinary, '');
+    fs.writeFileSync(shim, '@ECHO off\r\n"%dp0%\\node_modules\\opencode-ai\\bin\\opencode.exe" %*\r\n');
+    const { runtime } = createRuntime({});
+
+    expect(runtime.resolveManagedOpenCodeLaunchSpec(shim)).toEqual({
+      binary: nativeBinary,
+      args: [],
+      wrapperType: 'native-wrapper',
+    });
   });
 });

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

@@ -9,6 +9,9 @@ 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 { registerPluginRoutes } from './plugin-routes.js';
+import { getNpmInfo, clearCache as clearNpmCache } from './npm-registry.js';
+import { parseNpmSpec, parsePathSpec, isExactSemver } from './plugin-spec.js';
 import { registerOpenCodeRoutes } from './routes.js';
 
 export const createFeatureRoutesRuntime = (dependencies) => {
@@ -129,6 +132,17 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       updateSnippet,
       deleteSnippet,
       expandSnippets,
+      listPluginEntries,
+      getPluginEntry,
+      createPluginEntry,
+      updatePluginEntry,
+      deletePluginEntry,
+      listPluginDirFiles,
+      readPluginDirFile,
+      writePluginDirFile,
+      deletePluginDirFile,
+      encodePluginId,
+      decodePluginId,
     } = await import('./index.js');
 
     registerConfigEntityRoutes(app, {
@@ -158,6 +172,27 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       expandSnippets,
     });
 
+    registerPluginRoutes(app, {
+      resolveOptionalProjectDirectory,
+      refreshOpenCodeAfterConfigChange,
+      clientReloadDelayMs,
+      listPluginEntries,
+      getPluginEntry,
+      createPluginEntry,
+      updatePluginEntry,
+      deletePluginEntry,
+      listPluginDirFiles,
+      readPluginDirFile,
+      writePluginDirFile,
+      deletePluginDirFile,
+      encodePluginId,
+      decodePluginId,
+      getNpmInfo,
+      parseNpmSpec,
+      parsePathSpec,
+      isExactSemver,
+    });
+
     const {
       getSkillSources,
       discoverSkills,

package/server/lib/opencode/index.js

@@ -66,6 +66,22 @@ export {
   deleteMcpConfig,
 } from './mcp.js';
 
+export {
+  listPluginEntries,
+  getPluginEntry,
+  createPluginEntry,
+  updatePluginEntry,
+  deletePluginEntry,
+  listPluginDirFiles,
+  readPluginDirFile,
+  writePluginDirFile,
+  deletePluginDirFile,
+  encodePluginId,
+  decodePluginId,
+  parsePluginRaw,
+  serializePluginEntry,
+} from './plugins.js';
+
 export {
   listSnippets,
   getSnippet,
@@ -74,3 +90,6 @@ export {
   deleteSnippet,
   expandSnippets,
 } from './snippets.js';
+
+export { getNpmInfo, lookupNpmPackage, clearCache as clearNpmCache } from './npm-registry.js';
+export { parseNpmSpec, parsePathSpec, isExactSemver } from './plugin-spec.js';

package/server/lib/opencode/npm-registry.js

@@ -0,0 +1,157 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+export const NPM_CACHE_TTL_MS = 3_600_000;
+export const NPM_FETCH_TIMEOUT_MS = 5_000;
+export const NPM_REGISTRY_BASE = 'https://registry.npmjs.org';
+
+/**
+ * @typedef {Object} NpmPackagePayload
+ * @property {true} ok
+ * @property {string|null} latest
+ * @property {string[]} versions
+ * @property {Record<string, string>} distTags
+ *
+ * @typedef {Object} NpmLookupError
+ * @property {false} ok
+ * @property {number|'network'} status
+ * @property {string} error
+ *
+ * @typedef {NpmPackagePayload | NpmLookupError} NpmLookupResult
+ * @typedef {{ forceRefresh?: boolean }} NpmInfoOptions
+ * @typedef {{ fetchedAt: number, payload: NpmLookupResult }} CacheEntry
+ */
+
+/** @type {Map<string, CacheEntry>} */
+const _cache = new Map();
+
+/** @type {Map<string, Promise<NpmLookupResult>>} */
+const _inFlight = new Map();
+
+/** @type {string | null} */
+let _userAgent = null;
+
+function _getPackageJsonPath() {
+  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(__dirname, '..', '..', '..', '..', '..', 'package.json');
+}
+
+function _getUserAgent() {
+  if (_userAgent) return _userAgent;
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(_getPackageJsonPath(), 'utf8'));
+    _userAgent = `openchamber-server/${typeof pkg.version === 'string' ? pkg.version : '0.0.0'}`;
+  } catch {
+    _userAgent = 'openchamber-server/dev';
+  }
+
+  return _userAgent;
+}
+
+function encodeName(name) {
+  return encodeURIComponent(name).replace(/^%40/, '@');
+}
+
+function parseDistTags(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return {};
+  }
+
+  return Object.fromEntries(
+    Object.entries(value)
+      .filter((entry) => typeof entry[1] === 'string'),
+  );
+}
+
+function parseVersions(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return [];
+  }
+
+  return Object.keys(value);
+}
+
+function cacheResult(name, payload) {
+  if (payload.ok || payload.status === 404) {
+    _cache.set(name, { fetchedAt: Date.now(), payload });
+  }
+}
+
+/**
+ * Fetch package metadata directly from the npm registry.
+ *
+ * @param {string} name npm package name
+ * @returns {Promise<NpmLookupResult>}
+ */
+export async function lookupNpmPackage(name) {
+  try {
+    const response = await fetch(`${NPM_REGISTRY_BASE}/${encodeName(name)}`, {
+      headers: {
+        'User-Agent': _getUserAgent(),
+        Accept: 'application/json',
+      },
+      signal: AbortSignal.timeout(NPM_FETCH_TIMEOUT_MS),
+    });
+
+    if (response.ok) {
+      const data = await response.json();
+      const distTags = parseDistTags(data?.['dist-tags']);
+      return {
+        ok: true,
+        latest: distTags.latest ?? null,
+        versions: parseVersions(data?.versions),
+        distTags,
+      };
+    }
+
+    if (response.status === 404) {
+      return { ok: false, status: 404, error: 'Package not found' };
+    }
+
+    return { ok: false, status: response.status, error: `Registry returned ${response.status}` };
+  } catch (error) {
+    return { ok: false, status: 'network', error: String(error?.message ?? error) };
+  }
+}
+
+/**
+ * Fetch package metadata with TTL cache and in-flight request deduplication.
+ *
+ * @param {string} name npm package name
+ * @param {NpmInfoOptions} [options]
+ * @returns {Promise<NpmLookupResult>}
+ */
+export async function getNpmInfo(name, options = {}) {
+  const { forceRefresh = false } = options;
+  const cached = _cache.get(name);
+  if (cached && !forceRefresh && Date.now() - cached.fetchedAt < NPM_CACHE_TTL_MS) {
+    return cached.payload;
+  }
+
+  const existing = _inFlight.get(name);
+  if (existing && !forceRefresh) {
+    return existing;
+  }
+
+  const lookup = (async () => {
+    const result = await lookupNpmPackage(name);
+    cacheResult(name, result);
+    return result;
+  })();
+
+  _inFlight.set(name, lookup);
+  try {
+    return await lookup;
+  } finally {
+    if (_inFlight.get(name) === lookup) {
+      _inFlight.delete(name);
+    }
+  }
+}
+
+export function clearCache() {
+  _cache.clear();
+  _inFlight.clear();
+}

package/server/lib/opencode/npm-registry.test.js

@@ -0,0 +1,179 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test';
+import * as npm from './npm-registry.js';
+
+const originalFetch = globalThis.fetch;
+const originalDateNow = Date.now;
+
+let fetchMock;
+
+function jsonResponse(body, status = 200) {
+  return Promise.resolve(new Response(JSON.stringify(body), {
+    status,
+    headers: { 'content-type': 'application/json' },
+  }));
+}
+
+describe('npm registry client', () => {
+  beforeEach(() => {
+    npm.clearCache();
+    Date.now = originalDateNow;
+    fetchMock = mock(() => jsonResponse({}));
+    globalThis.fetch = fetchMock;
+  });
+
+  afterEach(() => {
+    npm.clearCache();
+    globalThis.fetch = originalFetch;
+    Date.now = originalDateNow;
+  });
+
+  test('200 success returns latest versions and dist tags', async () => {
+    fetchMock.mockImplementation(() => jsonResponse({
+      'dist-tags': { latest: '1.2.0' },
+      versions: { '1.0.0': {}, '1.2.0': {} },
+    }));
+
+    const result = await npm.lookupNpmPackage('foo');
+
+    expect(result).toEqual({
+      ok: true,
+      latest: '1.2.0',
+      versions: ['1.0.0', '1.2.0'],
+      distTags: { latest: '1.2.0' },
+    });
+  });
+
+  test('200 success handles missing dist-tags and versions', async () => {
+    fetchMock.mockImplementation(() => jsonResponse({}));
+
+    const result = await npm.lookupNpmPackage('foo');
+
+    expect(result).toEqual({ ok: true, latest: null, versions: [], distTags: {} });
+  });
+
+  test('404 returns package not found', async () => {
+    fetchMock.mockImplementation(() => jsonResponse({}, 404));
+
+    const result = await npm.lookupNpmPackage('missing');
+
+    expect(result).toEqual({ ok: false, status: 404, error: 'Package not found' });
+  });
+
+  test('500 returns registry error', async () => {
+    fetchMock.mockImplementation(() => jsonResponse({}, 500));
+
+    const result = await npm.lookupNpmPackage('foo');
+
+    expect(result).toEqual({ ok: false, status: 500, error: 'Registry returned 500' });
+  });
+
+  test('network error returns network status', async () => {
+    fetchMock.mockImplementation(() => Promise.reject(new Error('socket closed')));
+
+    const result = await npm.lookupNpmPackage('foo');
+
+    expect(result.ok).toBe(false);
+    expect(result.status).toBe('network');
+    expect(result.error).toBe('socket closed');
+  });
+
+  test('timeout plumbs AbortSignal to fetch', async () => {
+    fetchMock.mockImplementation((_url, init) => {
+      expect(init.signal).toBeInstanceOf(AbortSignal);
+      return Promise.reject(new DOMException('The operation was aborted.', 'AbortError'));
+    });
+
+    const result = await npm.lookupNpmPackage('foo');
+
+    expect(result.ok).toBe(false);
+    expect(result.status).toBe('network');
+    expect(result.error).toContain('aborted');
+  });
+
+  test('cache hit reuses definitive success', async () => {
+    fetchMock.mockImplementation(() => jsonResponse({ 'dist-tags': { latest: '1.0.0' }, versions: { '1.0.0': {} } }));
+
+    const first = await npm.getNpmInfo('foo');
+    const second = await npm.getNpmInfo('foo');
+
+    expect(first).toEqual(second);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  test('cache miss after ttl fetches again', async () => {
+    let now = 1_000;
+    Date.now = mock(() => now);
+    fetchMock.mockImplementation(() => jsonResponse({ versions: {} }));
+
+    await npm.getNpmInfo('foo');
+    now += 3_600_001;
+    await npm.getNpmInfo('foo');
+
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
+  test('forceRefresh bypasses cache', async () => {
+    fetchMock.mockImplementation(() => jsonResponse({ versions: {} }));
+
+    await npm.getNpmInfo('foo');
+    await npm.getNpmInfo('foo', { forceRefresh: true });
+
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
+  test('in-flight requests dedup by package name', async () => {
+    let release;
+    const wait = new Promise((resolve) => {
+      release = resolve;
+    });
+    fetchMock.mockImplementation(async () => {
+      await wait;
+      return new Response(JSON.stringify({ versions: { '1.0.0': {} } }), { status: 200 });
+    });
+
+    const requests = Promise.all([
+      npm.getNpmInfo('foo'),
+      npm.getNpmInfo('foo'),
+      npm.getNpmInfo('foo'),
+    ]);
+    release();
+    const results = await requests;
+
+    expect(results.every((result) => result.ok)).toBe(true);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  test('network failure is not cached', async () => {
+    fetchMock
+      .mockImplementationOnce(() => Promise.reject(new Error('down')))
+      .mockImplementationOnce(() => jsonResponse({ versions: {} }));
+
+    const first = await npm.getNpmInfo('foo');
+    const second = await npm.getNpmInfo('foo');
+
+    expect(first.status).toBe('network');
+    expect(second.ok).toBe(true);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
+  test('404 is cached', async () => {
+    fetchMock.mockImplementation(() => jsonResponse({}, 404));
+
+    await npm.getNpmInfo('missing');
+    await npm.getNpmInfo('missing');
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  test('scoped names encode slash in registry url', async () => {
+    await npm.getNpmInfo('@scope/pkg');
+
+    expect(fetchMock.mock.calls[0][0]).toBe('https://registry.npmjs.org/@scope%2Fpkg');
+  });
+
+  test('user-agent header is present', async () => {
+    await npm.getNpmInfo('foo');
+
+    expect(fetchMock.mock.calls[0][1].headers['User-Agent']).toMatch(/^openchamber-server\//);
+  });
+});