@openchamber/web 1.11.5 → 1.11.6

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\//);
+  });
+});

package/server/lib/opencode/plugin-routes.js

@@ -0,0 +1,373 @@
+import fs from 'fs';
+import os from 'os';
+
+import { getNpmInfo as defaultGetNpmInfo } from './npm-registry.js';
+import { isExactSemver as defaultIsExactSemver, isPathSpec as defaultIsPathSpec, parseNpmSpec as defaultParseNpmSpec, parsePathSpec as defaultParsePathSpec } from './plugin-spec.js';
+
+const ENTRY_EXISTS_CODES = new Set(['ENTRY_EXISTS', 'EEXIST']);
+const FILE_EXISTS_CODES = new Set(['FILE_EXISTS', 'EEXIST']);
+const NOT_FOUND_CODES = new Set(['NOT_FOUND', 'ENOENT']);
+const BAD_REQUEST_CODES = new Set(['INVALID_FILENAME', 'INVALID_SCOPE', 'INVALID_SPEC', 'EINVAL']);
+
+export const registerPluginRoutes = (app, dependencies) => {
+  const {
+    resolveOptionalProjectDirectory,
+    refreshOpenCodeAfterConfigChange,
+    clientReloadDelayMs,
+    listPluginEntries,
+    getPluginEntry,
+    createPluginEntry,
+    updatePluginEntry,
+    deletePluginEntry,
+    listPluginDirFiles,
+    readPluginDirFile,
+    writePluginDirFile,
+    deletePluginDirFile,
+    encodePluginId,
+    decodePluginId,
+    getNpmInfo = defaultGetNpmInfo,
+    parseNpmSpec = defaultParseNpmSpec,
+    parsePathSpec = defaultParsePathSpec,
+    isExactSemver = defaultIsExactSemver,
+    isPathSpec = defaultIsPathSpec,
+  } = dependencies;
+
+  const parsedKindForSpec = (spec) => (isPathSpec(spec) ? 'path' : 'npm');
+
+  const resolveDirectory = async (req, res) => {
+    const { directory, error } = await resolveOptionalProjectDirectory(req);
+    if (error) {
+      res.status(400).json({ error });
+      return null;
+    }
+    return directory || null;
+  };
+
+  const successPayload = (message) => ({
+    success: true,
+    requiresReload: true,
+    message,
+    reloadDelayMs: clientReloadDelayMs,
+    reloadFailed: false,
+    warning: undefined,
+  });
+
+  const completePluginMutation = async (res, operation, _noun, applyChange) => {
+    applyChange();
+
+    const pastTense = operation.replace(/ion$/, 'ed').replace(/update$/, 'updated');
+
+    try {
+      await refreshOpenCodeAfterConfigChange(`plugin ${operation}`);
+      return res.json(successPayload(`Plugin ${pastTense}. Reloading interface…`));
+    } catch (error) {
+      console.error(`[API:plugin ${operation}] Reload failed after config write:`, error);
+      return res.json({
+        success: true,
+        requiresReload: false,
+        message: `Plugin ${pastTense}, but OpenCode reload failed.`,
+        reloadDelayMs: clientReloadDelayMs,
+        reloadFailed: true,
+        warning: error.message || 'OpenCode reload failed after plugin config changed',
+      });
+    }
+  };
+
+  const validateEntryId = (id) => {
+    const decoded = decodePluginId(id);
+    if (decoded.prefix !== 'config') {
+      const error = new Error('Plugin entry not found');
+      error.code = 'NOT_FOUND';
+      throw error;
+    }
+  };
+
+  const validateFileId = (id) => {
+    const decoded = decodePluginId(id);
+    if (decoded.prefix !== 'file') {
+      const error = new Error('Plugin file not found');
+      error.code = 'NOT_FOUND';
+      throw error;
+    }
+  };
+
+  const handlePluginError = (res, error, fallbackMessage, context, existsKind = null) => {
+    const code = error?.code;
+    if ((existsKind === 'entry' && ENTRY_EXISTS_CODES.has(code)) || (existsKind === 'file' && FILE_EXISTS_CODES.has(code))) {
+      return res.status(409).json({ error: error.message });
+    }
+    if (NOT_FOUND_CODES.has(code)) {
+      return res.status(404).json({ error: error.message });
+    }
+    if (BAD_REQUEST_CODES.has(code)) {
+      return res.status(400).json({ error: error.message });
+    }
+
+    console.error(context, error);
+    return res.status(500).json({ error: fallbackMessage });
+  };
+
+  app.get('/api/config/plugins', async (req, res) => {
+    try {
+      const directory = await resolveDirectory(req, res);
+      if (directory === null && res.headersSent) return;
+
+      res.json({
+        entries: listPluginEntries(directory),
+        files: listPluginDirFiles(directory),
+      });
+    } catch (error) {
+      console.error('[API:GET /api/config/plugins] Failed:', error);
+      res.status(500).json({ error: 'Failed to list plugins' });
+    }
+  });
+
+  app.get('/api/config/plugins/registry', async (req, res) => {
+    try {
+      const { directory, error: directoryError } = await resolveOptionalProjectDirectory(req);
+      if (directoryError) {
+        return res.status(400).json({ error: directoryError });
+      }
+      const rawSpecs = (req.query.specs || '').toString();
+      const specs = rawSpecs
+        ? rawSpecs.split(',').map((spec) => {
+          try {
+            return decodeURIComponent(spec);
+          } catch {
+            return spec;
+          }
+        }).filter((spec) => spec.length > 0)
+        : [];
+      const uniqueSpecs = Array.from(new Set(specs));
+      if (uniqueSpecs.length > 100) {
+        return res.status(400).json({ error: 'too many specs' });
+      }
+
+      const refresh = req.query.refresh === 'true';
+      const npmJobs = new Map();
+      const malformedSpecs = new Set();
+
+      for (const spec of uniqueSpecs) {
+        if (parsedKindForSpec(spec) !== 'npm') continue;
+
+        const parsed = parseNpmSpec(spec);
+        if (parsed.malformed) {
+          malformedSpecs.add(spec);
+          continue;
+        }
+
+        const job = npmJobs.get(parsed.name) || { specs: [], parsedBySpec: new Map() };
+        job.specs.push(spec);
+        job.parsedBySpec.set(spec, parsed);
+        npmJobs.set(parsed.name, job);
+      }
+
+      const npmInfoByName = new Map();
+      await Promise.all(Array.from(npmJobs.keys()).map(async (name) => {
+        npmInfoByName.set(name, await getNpmInfo(name, { forceRefresh: refresh }));
+      }));
+
+      const results = [];
+      for (const spec of uniqueSpecs) {
+        if (malformedSpecs.has(spec)) {
+          results.push({ kind: 'npm-malformed', spec, error: 'Spec syntax is malformed' });
+          continue;
+        }
+
+        if (parsedKindForSpec(spec) === 'path') {
+          const { absolutePath } = parsePathSpec(spec, { homedir: os.homedir(), cwd: directory || os.homedir() });
+          try {
+            fs.statSync(absolutePath);
+          } catch {
+            results.push({ kind: 'path-missing', spec, absolutePath });
+            continue;
+          }
+
+          try {
+            fs.accessSync(absolutePath, fs.constants.R_OK);
+            results.push({ kind: 'path-ok', spec, absolutePath });
+          } catch {
+            results.push({ kind: 'path-unreadable', spec, absolutePath });
+          }
+          continue;
+        }
+
+        const parsed = parseNpmSpec(spec);
+        const info = npmInfoByName.get(parsed.name);
+        if (!info.ok) {
+          if (info.status === 404) {
+            results.push({ kind: 'npm-missing-package', spec, name: parsed.name, error: info.error });
+            continue;
+          }
+
+          results.push({ kind: 'npm-network', spec, error: info.status === 'network' ? info.error : `Registry returned ${info.status}` });
+          continue;
+        }
+
+        const currentVersion = parsed.version;
+        if (currentVersion !== null && isExactSemver(currentVersion) && !info.versions.includes(currentVersion)) {
+          results.push({
+            kind: 'npm-missing-version',
+            spec,
+            name: parsed.name,
+            currentVersion,
+            latestVersion: info.latest,
+            versions: info.versions,
+          });
+          continue;
+        }
+
+        results.push({
+          kind: 'npm-ok',
+          spec,
+          name: parsed.name,
+          currentVersion,
+          latestVersion: info.latest,
+          versions: info.versions,
+          hasUpdate: currentVersion !== null && isExactSemver(currentVersion) && currentVersion !== info.latest,
+        });
+      }
+
+      return res.json({ results });
+    } catch (error) {
+      console.error('[API:GET /api/config/plugins/registry]', error);
+      return res.status(500).json({ error: 'Failed to query npm registry' });
+    }
+  });
+
+  app.get('/api/config/plugins/entry/:id', async (req, res) => {
+    try {
+      const directory = await resolveDirectory(req, res);
+      if (directory === null && res.headersSent) return;
+      validateEntryId(req.params.id);
+
+      const entry = getPluginEntry(req.params.id, directory);
+      if (!entry) {
+        return res.status(404).json({ error: 'Plugin entry not found' });
+      }
+      return res.json(entry);
+    } catch (error) {
+      return handlePluginError(res, error, 'Failed to get plugin entry', '[API:GET /api/config/plugins/entry/:id] Failed:');
+    }
+  });
+
+  app.post('/api/config/plugins/entry', async (req, res) => {
+    try {
+      const directory = await resolveDirectory(req, res);
+      if (directory === null && res.headersSent) return;
+
+      await completePluginMutation(res, 'entry creation', 'entry', () => {
+        createPluginEntry({
+          spec: req.body?.spec,
+          options: req.body?.options,
+          scope: req.body?.scope,
+        }, directory);
+      });
+    } catch (error) {
+      return handlePluginError(res, error, 'Failed to create plugin entry', '[API:POST /api/config/plugins/entry] Failed:', 'entry');
+    }
+  });
+
+  app.patch('/api/config/plugins/entry/:id', async (req, res) => {
+    try {
+      const directory = await resolveDirectory(req, res);
+      if (directory === null && res.headersSent) return;
+      validateEntryId(req.params.id);
+
+      await completePluginMutation(res, 'entry update', 'entry', () => {
+        updatePluginEntry(req.params.id, {
+          spec: req.body?.spec,
+          options: req.body?.options,
+        }, directory);
+      });
+    } catch (error) {
+      return handlePluginError(res, error, 'Failed to update plugin entry', '[API:PATCH /api/config/plugins/entry/:id] Failed:', 'entry');
+    }
+  });
+
+  app.delete('/api/config/plugins/entry/:id', async (req, res) => {
+    try {
+      const directory = await resolveDirectory(req, res);
+      if (directory === null && res.headersSent) return;
+      validateEntryId(req.params.id);
+
+      await completePluginMutation(res, 'entry deletion', 'entry', () => {
+        deletePluginEntry(req.params.id, directory);
+      });
+    } catch (error) {
+      return handlePluginError(res, error, 'Failed to delete plugin entry', '[API:DELETE /api/config/plugins/entry/:id] Failed:', 'entry');
+    }
+  });
+
+  app.get('/api/config/plugins/file/:id', async (req, res) => {
+    try {
+      const directory = await resolveDirectory(req, res);
+      if (directory === null && res.headersSent) return;
+      validateFileId(req.params.id);
+
+      const file = readPluginDirFile(req.params.id, directory);
+      if (!file) {
+        return res.status(404).json({ error: 'Plugin file not found' });
+      }
+      return res.json(file);
+    } catch (error) {
+      return handlePluginError(res, error, 'Failed to read plugin file', '[API:GET /api/config/plugins/file/:id] Failed:');
+    }
+  });
+
+  app.post('/api/config/plugins/file', async (req, res) => {
+    try {
+      const directory = await resolveDirectory(req, res);
+      if (directory === null && res.headersSent) return;
+      const id = encodePluginId('file', `${req.body?.scope || 'user'}:${req.body?.fileName || ''}`);
+
+      await completePluginMutation(res, 'file creation', 'file', () => {
+        validateFileId(id);
+        writePluginDirFile({
+          fileName: req.body?.fileName,
+          content: req.body?.content,
+          scope: req.body?.scope,
+        }, directory);
+      });
+    } catch (error) {
+      return handlePluginError(res, error, 'Failed to create plugin file', '[API:POST /api/config/plugins/file] Failed:', 'file');
+    }
+  });
+
+  app.put('/api/config/plugins/file/:id', async (req, res) => {
+    try {
+      const directory = await resolveDirectory(req, res);
+      if (directory === null && res.headersSent) return;
+      validateFileId(req.params.id);
+
+      const existing = readPluginDirFile(req.params.id, directory);
+      if (!existing) {
+        return res.status(404).json({ error: 'Plugin file not found' });
+      }
+
+      await completePluginMutation(res, 'file update', 'file', () => {
+        writePluginDirFile({
+          fileName: existing.fileName,
+          content: req.body?.content,
+          scope: existing.scope,
+        }, directory, { overwrite: true });
+      });
+    } catch (error) {
+      return handlePluginError(res, error, 'Failed to update plugin file', '[API:PUT /api/config/plugins/file/:id] Failed:', 'file');
+    }
+  });
+
+  app.delete('/api/config/plugins/file/:id', async (req, res) => {
+    try {
+      const directory = await resolveDirectory(req, res);
+      if (directory === null && res.headersSent) return;
+      validateFileId(req.params.id);
+
+      await completePluginMutation(res, 'file deletion', 'file', () => {
+        deletePluginDirFile(req.params.id, directory);
+      });
+    } catch (error) {
+      return handlePluginError(res, error, 'Failed to delete plugin file', '[API:DELETE /api/config/plugins/file/:id] Failed:', 'file');
+    }
+  });
+};