@vantran-se/openchamber-web 1.24.4 → 2.0.2

package/server/lib/opencode/mcp.js

@@ -9,8 +9,19 @@ import {
   getJsonWriteTarget,
   writeConfig,
 } from './shared.js';
+import {
+  toMcpEntity,
+  readLayeredMcpEntries,
+  writeMcpEntry,
+  deleteMcpEntry,
+} from './config-v2.js';
 
 // ============== MCP CONFIG HELPERS ==============
+//
+// OpenCode 2 keeps servers under `mcp.servers`; v1 kept them directly under
+// `mcp`. OpenChamber reads both and always writes `mcp.servers` with the v2
+// entry shape (`disabled`, `timeout: {catalog, execution}`, snake_case OAuth,
+// required `type`).
 
 /**
  * Validate MCP server name
@@ -24,9 +35,6 @@ function validateMcpName(name) {
   }
 }
 
-/**
- * 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;
@@ -40,20 +48,23 @@ function ensureProjectMcpConfigPath(workingDirectory) {
   return path.join(configDir, 'opencode.json');
 }
 
+/** Same precedence as `getJsonEntrySource`: custom > project > user. */
+function readMcpEntriesAcrossLayers(layers) {
+  return readLayeredMcpEntries([layers?.userConfig, layers?.projectConfig, layers?.customConfig]);
+}
+
 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),
-      };
-    });
+  return Array.from(readMcpEntriesAcrossLayers(layers).entries()).map(([name, entry]) => {
+    const source = getJsonEntrySource(layers, 'mcp', name);
+    return {
+      name,
+      ...toMcpEntity(entry.value),
+      scope: resolveMcpScopeFromPath(layers, source.path),
+      sectionKey: source.sectionKey,
+      legacy: Boolean(source.legacy),
+    };
+  });
 }
 
 /**
@@ -61,7 +72,7 @@ function listMcpConfigs(workingDirectory) {
  */
 function getMcpConfig(name, workingDirectory) {
   const layers = readConfigLayers(workingDirectory);
-  const entry = layers?.mergedConfig?.mcp?.[name];
+  const entry = readMcpEntriesAcrossLayers(layers).get(name);
 
   if (!entry) {
     return null;
@@ -69,8 +80,10 @@ function getMcpConfig(name, workingDirectory) {
   const source = getJsonEntrySource(layers, 'mcp', name);
   return {
     name,
-    ...buildMcpEntry(entry),
+    ...toMcpEntity(entry.value),
     scope: resolveMcpScopeFromPath(layers, source.path),
+    sectionKey: source.sectionKey,
+    legacy: Boolean(source.legacy),
   };
 }
 
@@ -81,8 +94,7 @@ function createMcpConfig(name, mcpConfig, workingDirectory, scope) {
   validateMcpName(name);
 
   const layers = readConfigLayers(workingDirectory);
-  const source = getJsonEntrySource(layers, 'mcp', name);
-  if (source.exists) {
+  if (getJsonEntrySource(layers, 'mcp', name).exists) {
     throw new Error(`MCP server "${name}" already exists`);
   }
 
@@ -101,19 +113,17 @@ function createMcpConfig(name, mcpConfig, workingDirectory, scope) {
     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);
+  const { name: _ignoredName, scope: _ignoredScope, ...entryData } = mcpConfig || {};
+  writeMcpEntry(config, name, toMcpEntity(entryData));
 
   writeConfig(config, targetPath);
   console.log(`Created MCP server config: ${name}`);
+  return { path: targetPath };
 }
 
 /**
- * Update an existing MCP server config entry
+ * Update an existing MCP server config entry. A server still stored under the
+ * v1 `mcp.<name>` key is rewritten into `mcp.servers` in the same file.
  */
 function updateMcpConfig(name, updates, workingDirectory) {
   const layers = readConfigLayers(workingDirectory);
@@ -126,17 +136,13 @@ function updateMcpConfig(name, updates, workingDirectory) {
   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 });
+  const existing = toMcpEntity(source.section);
+  const { name: _ignoredName, scope: _ignoredScope, ...updateData } = updates || {};
+  writeMcpEntry(config, name, toMcpEntity({ ...existing, ...updateData }));
 
   writeConfig(config, targetPath);
-  console.log(`Updated MCP server config: ${name}`);
+  console.log(`Updated MCP server config: ${name} (${targetPath})`);
+  return { path: targetPath };
 }
 
 /**
@@ -148,125 +154,13 @@ function deleteMcpConfig(name, workingDirectory) {
   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) {
+  if (!deleteMcpEntry(config, name)) {
     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;
+  return { path: targetPath };
 }
 
 export {

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

@@ -1,3 +1,4 @@
+import { readOpenCodeInfo, isSupportedOpenCodeVersion } from './compatibility.js';
 export const createOpenCodeNetworkRuntime = (deps) => {
   const {
     state,
@@ -46,7 +47,9 @@ export const createOpenCodeNetworkRuntime = (deps) => {
       try {
         const controller = new AbortController();
         timeout = setTimeout(() => controller.abort(), 3000);
-        const response = await fetch(`${url.replace(/\/+$/, '')}/global/health`, {
+        // OpenCode 2.0.8 replaced `/api/health` with `/api/info`: a 200 is the
+        // readiness signal, the payload carries no `healthy` field.
+        const response = await fetch(`${url.replace(/\/+$/, '')}/api/info`, {
           method: 'GET',
           headers: {
             Accept: 'application/json',
@@ -57,12 +60,8 @@ export const createOpenCodeNetworkRuntime = (deps) => {
         clearTimeout(timeout);
         timeout = null;
 
-        if (response.ok) {
-          const body = await response.json().catch(() => null);
-          if (body?.healthy === true) {
-            return true;
-          }
-        }
+        const info = await readOpenCodeInfo(response);
+        if (info && isSupportedOpenCodeVersion(info.version)) return true;
       } catch {
       } finally {
         if (timeout) {

package/server/lib/opencode/openchamber-routes.test.js

@@ -68,9 +68,7 @@ beforeEach(() => {
   packageManager.detectPackageManagerDetails.mockReturnValue({
     packageManager: 'npm',
   });
-  packageManager.getUpdateCommand.mockReturnValue(
-    'npm install -g @vantran-se/openchamber-web@latest --registry=https://registry.npmjs.org',
-  );
+  packageManager.getUpdateCommand.mockReturnValue('npm install -g @openchamber/web@latest');
 });
 
 afterEach(() => {
@@ -266,7 +264,7 @@ describe('OpenChamber foreground update route', () => {
       '--setenv=PATH=/home/syu/.npm-global/bin:/usr/bin:/bin',
       '/bin/sh',
       '-c',
-      "set -eu\nnpm install -g @vantran-se/openchamber-web@latest --registry=https://registry.npmjs.org\nsystemctl --user restart 'openchamber@wsl.service'",
+      "set -eu\nnpm install -g @openchamber/web@latest\nsystemctl --user restart 'openchamber@wsl.service'",
     ], {
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'pipe'],
@@ -335,4 +333,3 @@ describe('OpenChamber web update route on Windows', () => {
     expect(logError).toHaveBeenCalledOnce();
   });
 });
-

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

@@ -3,7 +3,7 @@ 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';
-import { buildDeferredRestartResponse } from './config-mutation-response.js';
+import { buildAppliedResponse } from './config-mutation-response.js';
 
 const ENTRY_EXISTS_CODES = new Set(['ENTRY_EXISTS', 'EEXIST']);
 const FILE_EXISTS_CODES = new Set(['FILE_EXISTS', 'EEXIST']);
@@ -46,8 +46,8 @@ export const registerPluginRoutes = (app, dependencies) => {
     applyChange();
 
     const pastTense = operation.replace(/ion$/, 'ed').replace(/update$/, 'updated');
-    return res.json(buildDeferredRestartResponse(
-      `Plugin ${pastTense}. Restart OpenCode to apply.`,
+    return res.json(buildAppliedResponse(
+      `Plugin ${pastTense}.`,
     ));
   };
 

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

@@ -268,10 +268,7 @@ describe('opencode plugin routes', () => {
 
     expect(response.body).toMatchObject({
       success: true,
-      requiresReload: false,
-      requiresRestart: true,
-      restartDeferred: true,
-      message: 'Plugin entry created. Restart OpenCode to apply.',
+      message: 'Plugin entry created.',
     });
     expect(refreshOpenCodeAfterConfigChange).not.toHaveBeenCalled();
   });
@@ -307,10 +304,7 @@ describe('opencode plugin routes', () => {
 
     expect(response.body.success).toBe(true);
     expect(response.body).toMatchObject({
-      requiresReload: false,
-      requiresRestart: true,
-      restartDeferred: true,
-      message: 'Plugin entry updated. Restart OpenCode to apply.',
+      message: 'Plugin entry updated.',
     });
     const after = await request(app).get('/api/config/plugins').expect(200);
     expect(after.body.entries[0]).toEqual(expect.objectContaining({ spec: 'b', scope: 'user' }));
@@ -329,10 +323,7 @@ describe('opencode plugin routes', () => {
     expect(readJson(userConfigPath).plugin).toBeUndefined();
     expect(response.body).toMatchObject({
       success: true,
-      requiresReload: false,
-      requiresRestart: true,
-      restartDeferred: true,
-      message: 'Plugin entry deleted. Restart OpenCode to apply.',
+      message: 'Plugin entry deleted.',
     });
     expect(refreshOpenCodeAfterConfigChange).not.toHaveBeenCalled();
   });
@@ -342,10 +333,7 @@ describe('opencode plugin routes', () => {
 
     expect(response.body).toMatchObject({
       success: true,
-      requiresReload: false,
-      requiresRestart: true,
-      restartDeferred: true,
-      message: 'Plugin file created. Restart OpenCode to apply.',
+      message: 'Plugin file created.',
     });
     expect(fs.readFileSync(path.join(rootDir, 'plugins', 'test.js'), 'utf8')).toBe('//x');
     expect(refreshOpenCodeAfterConfigChange).not.toHaveBeenCalled();
@@ -375,10 +363,7 @@ describe('opencode plugin routes', () => {
     expect(fs.readFileSync(path.join(rootDir, 'plugins', 'test.js'), 'utf8')).toBe('//y');
     expect(response.body).toMatchObject({
       success: true,
-      requiresReload: false,
-      requiresRestart: true,
-      restartDeferred: true,
-      message: 'Plugin file updated. Restart OpenCode to apply.',
+      message: 'Plugin file updated.',
     });
     expect(refreshOpenCodeAfterConfigChange).not.toHaveBeenCalled();
   });
@@ -393,10 +378,7 @@ describe('opencode plugin routes', () => {
     expect(fs.existsSync(path.join(rootDir, 'plugins', 'test.js'))).toBe(false);
     expect(response.body).toMatchObject({
       success: true,
-      requiresReload: false,
-      requiresRestart: true,
-      restartDeferred: true,
-      message: 'Plugin file deleted. Restart OpenCode to apply.',
+      message: 'Plugin file deleted.',
     });
     expect(refreshOpenCodeAfterConfigChange).not.toHaveBeenCalled();
   });

package/server/lib/opencode/plugins.js

@@ -8,6 +8,11 @@ import {
   writeConfig,
 } from './shared.js';
 import { isPathSpec } from './plugin-spec.js';
+import { PLUGIN_SECTION, toPluginEntity, fromPluginEntity, readPluginList } from './config-v2.js';
+
+// OpenCode 2 reads `plugins` (bare string or `{package, options}`) and still
+// decodes the v1 `plugin` array with its `[spec, options]` tuples. OpenChamber
+// reads both and always writes `plugins` with v2 entries.
 
 const PLUGIN_FILE_NAME_PATTERN = /^[a-z0-9][a-z0-9-_.]*\.(js|ts|mjs|cjs)$/;
 
@@ -77,7 +82,6 @@ function getActiveOpencodeConfigDir() {
 function getActiveUserConfigPaths() {
   const configDir = getActiveOpencodeConfigDir();
   return [
-    path.join(configDir, 'config.json'),
     path.join(configDir, 'opencode.json'),
     path.join(configDir, 'opencode.jsonc'),
   ];
@@ -184,9 +188,12 @@ function getPluginTarget(id, workingDirectory) {
   validateScope(scope);
   const layers = readPluginConfigLayers(workingDirectory);
   const source = configSources(layers).find((candidate) => candidate.scope === scope);
-  const plugin = Array.isArray(source?.config?.plugin) ? source.config.plugin : [];
+  if (!source) {
+    return null;
+  }
+  const plugin = pluginArrayForWrite(source.config);
   const index = plugin.findIndex((raw) => parsePluginRaw(raw).spec === spec);
-  if (!source || index === -1) {
+  if (index === -1) {
     return null;
   }
   return { source, plugin, index };
@@ -203,6 +210,16 @@ function pluginDirForScope(scope, workingDirectory) {
   return path.join(getActiveOpencodeConfigDir(), 'plugins');
 }
 
+/**
+ * The directories OpenCode 2 scans for local plugins in a scope: `plugins/`
+ * (where OpenChamber writes) and the v1 `plugin/`. Each holds `.ts`/`.js`
+ * files and plugin package directories.
+ */
+function pluginDirsForScope(scope, workingDirectory) {
+  const preferred = pluginDirForScope(scope, workingDirectory);
+  return [preferred, path.join(path.dirname(preferred), 'plugin')];
+}
+
 function fileTargetFromId(id, workingDirectory) {
   const decoded = decodePluginId(id);
   if (decoded.prefix !== 'file') {
@@ -231,41 +248,71 @@ function decodePluginId(id) {
   return { prefix: decoded.slice(0, separator), value: decoded.slice(separator + 1) };
 }
 
+/** Accept a v1 string/tuple or a v2 `{package, options}` object. */
 function parsePluginRaw(raw) {
-  if (typeof raw === 'string') {
-    return { spec: validatePluginSpec(raw) };
-  }
-  if (Array.isArray(raw) && raw.length === 2 && isRecord(raw[1])) {
-    return { spec: validatePluginSpec(raw[0]), options: { ...raw[1] } };
+  const entity = toPluginEntity(raw);
+  if (!entity) {
+    throw codedError('Plugin spec must be a string, [string, object], or {package, options}', 'INVALID_SPEC');
   }
-  throw codedError('Plugin spec must be a string or [string, object]', 'INVALID_SPEC');
+  const parsed = { spec: validatePluginSpec(entity.package) };
+  if (hasOptions(entity.options)) parsed.options = { ...entity.options };
+  return parsed;
 }
 
+/** Always v2: a bare string, or `{package, options}`. Never a tuple. */
 function serializePluginEntry(entry) {
   const spec = validatePluginSpec(entry?.spec);
-  if (hasOptions(entry?.options)) {
-    return [spec, { ...entry.options }];
+  const serialized = fromPluginEntity({ package: spec, options: hasOptions(entry?.options) ? entry.options : undefined });
+  if (serialized === null) {
+    throw codedError('Plugin spec must be a non-empty string', 'INVALID_SPEC');
   }
-  return spec;
+  return serialized;
+}
+
+function migratePluginRaw(raw) {
+  try {
+    return serializePluginEntry(parsePluginRaw(raw));
+  } catch {
+    return raw;
+  }
+}
+
+/**
+ * The plugin array a write should target. Prefer the v2 `plugins` key; when the
+ * file only has the v1 `plugin` array, migrate the whole array into `plugins`
+ * in place so the two spellings cannot disagree.
+ */
+function pluginArrayForWrite(config) {
+  const legacy = Array.isArray(config[PLUGIN_SECTION.v1]) ? config[PLUGIN_SECTION.v1] : null;
+  if (!Array.isArray(config[PLUGIN_SECTION.v2])) config[PLUGIN_SECTION.v2] = [];
+  if (legacy) {
+    config[PLUGIN_SECTION.v2] = [
+      // An entry we cannot parse is carried over untouched rather than dropped:
+      // it is the user's config, and losing it would be worse than leaving it
+      // in a shape OpenCode already refuses.
+      ...legacy.map((raw) => migratePluginRaw(raw)),
+      ...config[PLUGIN_SECTION.v2],
+    ];
+    delete config[PLUGIN_SECTION.v1];
+  }
+  return config[PLUGIN_SECTION.v2];
 }
 
 function listPluginEntries(workingDirectory) {
   const layers = readPluginConfigLayers(workingDirectory);
   return configSources(layers).flatMap((source) => {
-    if (!Array.isArray(source.config?.plugin)) {
-      return [];
-    }
-    return source.config.plugin.map((raw) => {
-      const parsed = parsePluginRaw(raw);
-      return {
-        id: encodePluginId('config', `${source.scope}:${parsed.spec}`),
-        spec: parsed.spec,
-        ...(parsed.options !== undefined ? { options: parsed.options } : {}),
+    return readPluginList(source.config).map((item) => {
+      const entry = {
+        id: encodePluginId('config', `${source.scope}:${item.entry.package}`),
+        spec: item.entry.package,
         scope: source.scope,
         kind: 'config',
-        parsedKind: parsedKindForSpec(parsed.spec),
+        parsedKind: parsedKindForSpec(item.entry.package),
         sourcePath: source.filePath,
+        legacy: item.legacy,
       };
+      if (item.entry.options !== undefined) entry.options = item.entry.options;
+      return entry;
     });
   });
 }
@@ -282,8 +329,7 @@ function createPluginEntry(entry, workingDirectory) {
   const layers = readPluginConfigLayers(workingDirectory);
   const existing = configSources(layers).find((source) => (
     source.scope === scope
-    && Array.isArray(source.config?.plugin)
-    && source.config.plugin.some((raw) => parsePluginRaw(raw).spec === spec)
+    && readPluginList(source.config).some((item) => item.entry.package === spec)
   ));
   if (existing) {
     throw codedError(`Plugin "${spec}" already exists`, 'ENTRY_EXISTS');
@@ -299,10 +345,7 @@ function createPluginEntry(entry, workingDirectory) {
     config = layers.paths.customPath ? layers.customConfig : layers.userConfig;
   }
 
-  if (!Array.isArray(config.plugin)) {
-    config.plugin = [];
-  }
-  config.plugin.push(serializePluginEntry({ spec, options: entry.options }));
+  pluginArrayForWrite(config).push(serializePluginEntry({ spec, options: entry.options }));
   writeConfig(config, targetPath);
 }
 
@@ -325,7 +368,7 @@ function deletePluginEntry(id, workingDirectory) {
   }
   target.plugin.splice(target.index, 1);
   if (target.plugin.length === 0) {
-    delete target.source.config.plugin;
+    delete target.source.config[PLUGIN_SECTION.v2];
   }
   writeConfig(target.source.config, target.source.filePath);
 }
@@ -335,21 +378,29 @@ function listPluginDirFiles(workingDirectory) {
   if (workingDirectory) {
     scopes.push(AGENT_SCOPE.PROJECT);
   }
-  return scopes.flatMap((scope) => {
-    const dir = pluginDirForScope(scope, workingDirectory);
+  return scopes.flatMap((scope) => pluginDirsForScope(scope, workingDirectory).flatMap((dir) => {
     if (!fs.existsSync(dir)) {
       return [];
     }
+    const editable = dir === pluginDirForScope(scope, workingDirectory);
     return fs.readdirSync(dir, { withFileTypes: true })
-      .filter((entry) => entry.isFile() && PLUGIN_FILE_NAME_PATTERN.test(entry.name) && !entry.name.includes('..'))
-      .map((entry) => ({
-        id: encodePluginId('file', `${scope}:${entry.name}`),
-        fileName: entry.name,
-        scope,
-        kind: 'file',
-        absolutePath: path.join(dir, entry.name),
-      }));
-  });
+      .filter((entry) => !entry.name.includes('..') && !entry.name.startsWith('.'))
+      .flatMap((entry) => {
+        if (entry.isFile() && PLUGIN_FILE_NAME_PATTERN.test(entry.name)) {
+          // Only files in the v2 `plugins/` directory are editable through
+          // the file id; a v1 `plugin/` file is listed for what it is.
+          return editable
+            ? [{ id: encodePluginId('file', `${scope}:${entry.name}`), fileName: entry.name, scope, kind: 'file', absolutePath: path.join(dir, entry.name) }]
+            : [{ id: encodePluginId('legacy', `${scope}:${entry.name}`), fileName: entry.name, scope, kind: 'package', absolutePath: path.join(dir, entry.name) }];
+        }
+        if (entry.isDirectory()) {
+          // A plugin package (a directory with its own entry point): OpenCode
+          // loads it, OpenChamber only lists it.
+          return [{ id: encodePluginId('package', `${scope}:${entry.name}`), fileName: entry.name, scope, kind: 'package', absolutePath: path.join(dir, entry.name) }];
+        }
+        return [];
+      });
+  }));
 }
 
 function readPluginDirFile(id, workingDirectory) {