@openchambery/web 1.19.22-beta.1 → 2.0.0-beta.10

package/server/lib/opencode/config-entity-routes.js

@@ -2,9 +2,62 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { parse as parseJsonc } from 'jsonc-parser';
-import { createOpencodeClient } from '@opencode-ai/sdk/v2';
+import { OpenCode } from '@opencode/client';
 import { projectProviderCatalog } from './provider-catalog.js';
 
+// Compose official v2 provider.list + model.list (+ optional default) into the
+// catalog shape consumed by projectProviderCatalog. Missing arrays are failure.
+const composeV2ProviderCatalogSource = (providers, models, defaultModel) => {
+  if (!Array.isArray(providers) || !Array.isArray(models)) return null;
+
+  const modelsByProvider = new Map();
+  for (const model of models) {
+    if (!model || typeof model !== 'object') continue;
+    const providerID = typeof model.providerID === 'string' ? model.providerID : '';
+    // ModelInfo.id is the external model id used in generate/session refs.
+    // ModelInfo.modelID is a separate internal field and must not be preferred.
+    const modelID = typeof model.id === 'string' && model.id
+      ? model.id
+      : (typeof model.modelID === 'string' ? model.modelID : '');
+    if (!providerID || !modelID) continue;
+    if (!modelsByProvider.has(providerID)) modelsByProvider.set(providerID, Object.create(null));
+    const entry = { id: modelID };
+    if (typeof model.name === 'string' && model.name) entry.name = model.name;
+    if (typeof model.family === 'string' && model.family) entry.family = model.family;
+    if (model.limit && typeof model.limit === 'object') entry.limit = model.limit;
+    if (model.capabilities) entry.capabilities = model.capabilities;
+    // v2 cost is a tier array; v2 variants are `{ id }[]`. Projection owns the safe shape.
+    if (model.cost && typeof model.cost === 'object') entry.cost = model.cost;
+    if (model.variants && typeof model.variants === 'object') entry.variants = model.variants;
+    if (typeof model.time?.released === 'number' && Number.isFinite(model.time.released)) {
+      entry.release_date = new Date(model.time.released).toISOString().slice(0, 10);
+    }
+    modelsByProvider.get(providerID)[modelID] = entry;
+  }
+
+  const list = [];
+  for (const provider of providers) {
+    if (!provider || typeof provider.id !== 'string' || !provider.id) continue;
+    list.push({
+      id: provider.id,
+      name: typeof provider.name === 'string' && provider.name ? provider.name : provider.id,
+      models: modelsByProvider.get(provider.id) || Object.create(null),
+    });
+  }
+
+  const defaults = Object.create(null);
+  const defaultModelID = typeof defaultModel?.id === 'string' && defaultModel.id
+    ? defaultModel.id
+    : (typeof defaultModel?.modelID === 'string' ? defaultModel.modelID : '');
+  if (defaultModel && typeof defaultModel.providerID === 'string' && defaultModelID) {
+    defaults[defaultModel.providerID] = defaultModelID;
+  }
+  return { providers: list, default: defaults };
+};
+
+const createOpenCodeClient = ({ baseUrl, headers, fetch: fetchImpl }) =>
+  OpenCode.make({ baseUrl, headers, fetch: fetchImpl });
+
 const MAX_GLOBAL_CONFIG_SIZE = 2 * 1024 * 1024;
 const GLOBAL_CONFIG_FILES = {
   opencode: ['opencode.json', 'opencode.jsonc'],
@@ -81,10 +134,10 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
   const {
     resolveProjectDirectory,
     resolveOptionalProjectDirectory,
-    refreshOpenCodeAfterConfigChange,
-    clientReloadDelayMs,
+    waitForOpenCodeReady,
     getAgentSources,
     getAgentConfig,
+    listDisabledAgentOverrides,
     createAgent,
     updateAgent,
     deleteAgent,
@@ -115,25 +168,43 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
       if (!directory) {
         return res.status(400).json({ error });
       }
-      const client = createOpencodeClient({
+      // Gate on managed-OpenCode readiness like the generic proxy: without this
+      // the SDK hits an upstream that is still starting (or a stale orphan from
+      // a nodemon restart) and gets HTML/401 back, surfacing as a spurious 502.
+      if (typeof waitForOpenCodeReady === 'function') {
+        await waitForOpenCodeReady(20_000, 200);
+      }
+      const client = createOpenCodeClient({
         baseUrl: buildOpenCodeUrl('/', '').replace(/\/$/, ''),
-        directory,
         headers: getOpenCodeAuthHeaders(),
-        fetch: (request) => fetch(request, { signal: AbortSignal.timeout(8_000) }),
+        // Forward the full init: the SDK carries Authorization in init.headers.
+        // Dropping init (the old `(request) => fetch(request, { signal })` shape)
+        // silently stripped auth and produced spurious upstream 401s.
+        fetch: (request, init) => fetch(request, { ...init, signal: AbortSignal.timeout(8_000) }),
       });
-      const response = await client.config.providers({ directory });
-      if (response?.error || response?.data === undefined) {
+      const location = { directory };
+      const [providersResult, modelsResult, defaultResult] = await Promise.all([
+        client.provider.list({ location }),
+        client.model.list({ location }),
+        client.model.default({ location }),
+      ]);
+      const source = composeV2ProviderCatalogSource(
+        providersResult?.data,
+        modelsResult?.data,
+        defaultResult?.data,
+      );
+      if (!source) {
         console.error('Provider catalog upstream response failed');
         return res.status(502).json({ error: 'Provider catalog is unavailable' });
       }
-      const catalog = projectProviderCatalog(response?.data);
+      const catalog = projectProviderCatalog(source);
       if (!catalog.ok) {
         console.error('Provider catalog upstream response is malformed');
         return res.status(502).json({ error: 'Provider catalog is unavailable' });
       }
       return res.json(catalog.value);
-    } catch {
-      console.error('Provider catalog request failed');
+    } catch (catalogError) {
+      console.error('Provider catalog request failed', catalogError?.reason ? `(${catalogError.reason})` : catalogError?.message ?? catalogError);
       return res.status(502).json({ error: 'Provider catalog is unavailable' });
     }
   });
@@ -191,7 +262,8 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
         target: req.params.target,
         fileName: target.fileName,
         content,
-        requiresManualRestart: true,
+        requiresManualRestart: req.params.target !== 'opencode',
+        application: req.params.target === 'opencode' ? 'watch' : 'manual',
       });
     } catch (error) {
       console.error('Failed to write global configuration:', error);
@@ -199,29 +271,9 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
     }
   });
 
-  // Build the response for a config mutation based on whether OpenCode actually
-  // reloaded the change. When connected to an external OpenCode server that
-  // OpenChamber cannot restart, the change is persisted to disk but the running
-  // server will not serve it until the user restarts that server. We must not
-  // report a clean "reloading" success in that case, otherwise the UI silently
-  // reverts the edit to the stale value on the next refresh.
-  const buildConfigMutationResponse = (refreshResult, { liveMessage, manualRestartMessage }) => {
-    if (refreshResult && refreshResult.external) {
-      return {
-        success: true,
-        requiresReload: false,
-        requiresManualRestart: true,
-        message: manualRestartMessage,
-      };
-    }
-
-    return {
-      success: true,
-      requiresReload: true,
-      message: liveMessage,
-      reloadDelayMs: clientReloadDelayMs,
-    };
-  };
+  // A receipt confirms persistence, not runtime activation. V2 watches local
+  // configuration; domain events confirm changes without rebuilding locations.
+  const configSaved = () => ({ success: true, requiresReload: false, application: 'watch' });
 
   const readMutationBody = (req) => (
     req.body && typeof req.body === 'object' && !Array.isArray(req.body) ? req.body : {}
@@ -230,24 +282,7 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
   const completeMcpMutation = async (res, action, name, applyChange) => {
     applyChange();
 
-    try {
-      await refreshOpenCodeAfterConfigChange(`mcp ${action}`);
-      return res.json({
-        success: true,
-        requiresReload: true,
-        message: `MCP server "${name}" ${action}d. Reloading interface…`,
-        reloadDelayMs: clientReloadDelayMs,
-      });
-    } catch (error) {
-      console.error(`[API:MCP ${action}] Reload failed after config write:`, error);
-      return res.json({
-        success: true,
-        requiresReload: false,
-        reloadFailed: true,
-        message: `MCP server "${name}" ${action}d, but OpenCode reload failed.`,
-        warning: error.message || 'OpenCode reload failed after the MCP configuration changed',
-      });
-    }
+    return res.json({ ...configSaved(), message: `MCP server "${name}" ${action}d.` });
   };
 
   app.post('/api/config/agents/metadata', async (req, res) => {
@@ -277,7 +312,10 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
           sources,
         };
       }
-      return res.json({ agents });
+      const disabled = typeof listDisabledAgentOverrides === 'function'
+        ? listDisabledAgentOverrides(directory)
+        : [];
+      return res.json(disabled.length > 0 ? { agents, disabled } : { agents });
     } catch (error) {
       console.error('Failed to get agent metadata batch:', error);
       return res.status(500).json({ error: 'Failed to get agent configuration metadata' });
@@ -337,15 +375,11 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
       console.log('[Server] Creating agent');
 
       createAgent(agentName, config, directory, scope);
-      const refreshResult = await refreshOpenCodeAfterConfigChange('agent creation', {
-        agentName
-      });
-
-      res.json(buildConfigMutationResponse(refreshResult, {
-        liveMessage: `Agent ${agentName} created successfully. Reloading interface…`,
-        manualRestartMessage: `Agent ${agentName} saved. Restart your connected OpenCode server to apply the change.`,
-      }));
+      res.json(configSaved());
     } catch (error) {
+      if (error?.code === 'drop-confirmation') {
+        return res.status(409).json({ code: 'drop-confirmation', dropped: error.dropped, error: error.message });
+      }
       console.error('Failed to create agent');
       res.status(500).json({ error: error.message || 'Failed to create agent' });
     }
@@ -363,15 +397,14 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
       console.log('[Server] Updating agent');
 
       updateAgent(agentName, updates, directory);
-      const refreshResult = await refreshOpenCodeAfterConfigChange('agent update');
 
       console.log('[Server] Agent updated successfully');
 
-      res.json(buildConfigMutationResponse(refreshResult, {
-        liveMessage: `Agent ${agentName} updated successfully. Reloading interface…`,
-        manualRestartMessage: `Agent ${agentName} saved. Restart your connected OpenCode server to apply the change.`,
-      }));
+      res.json(configSaved());
     } catch (error) {
+      if (error?.code === 'drop-confirmation') {
+        return res.status(409).json({ code: 'drop-confirmation', dropped: error.dropped, error: error.message });
+      }
       console.error('[Server] Failed to update agent');
       res.status(500).json({ error: error.message || 'Failed to update agent' });
     }
@@ -387,12 +420,7 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
 
       const scope = req.body?.scope;
       deleteAgent(agentName, directory, scope);
-      const refreshResult = await refreshOpenCodeAfterConfigChange('agent deletion');
-
-      res.json(buildConfigMutationResponse(refreshResult, {
-        liveMessage: `Agent ${agentName} deleted successfully. Reloading interface…`,
-        manualRestartMessage: `Agent ${agentName} deleted. Restart your connected OpenCode server to apply the change.`,
-      }));
+      res.json(configSaved());
     } catch (error) {
       console.error('Failed to delete agent');
       res.status(500).json({ error: error.message || 'Failed to delete agent' });
@@ -500,14 +528,22 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
         if (!getOpenCodePort()) {
           return res.json({ commands: [] });
         }
-        const client = createOpencodeClient({
+        const client = createOpenCodeClient({
           baseUrl: buildOpenCodeUrl('/', '').replace(/\/$/, ''),
-          directory,
           headers: getOpenCodeAuthHeaders(),
-          fetch: (request) => fetch(request, { signal: AbortSignal.timeout(8_000) }),
+          fetch: (request, init) => fetch(request, {
+            ...init,
+            signal: init?.signal
+              ? AbortSignal.any([init.signal, AbortSignal.timeout(8_000)])
+              : AbortSignal.timeout(8_000),
+          }),
         });
-        const response = await client.command.list({ directory });
-        const commands = Array.isArray(response?.data) ? response.data : [];
+        const response = await client.command.list({ location: { directory } });
+        if (!Array.isArray(response?.data)) {
+          console.error('Command catalog upstream response failed');
+          return res.status(502).json({ error: 'Command catalog is unavailable' });
+        }
+        const commands = response.data;
         return res.json({
           commands: commands
             .filter((command) => command?.source !== 'skill')
@@ -598,16 +634,7 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
       console.log('[Server] Creating command');
 
       createCommand(commandName, config, directory, scope);
-      await refreshOpenCodeAfterConfigChange('command creation', {
-        commandName
-      });
-
-      res.json({
-        success: true,
-        requiresReload: true,
-        message: `Command ${commandName} created successfully. Reloading interface…`,
-        reloadDelayMs: clientReloadDelayMs,
-      });
+      res.json(configSaved());
     } catch (error) {
       console.error('Failed to create command');
       res.status(500).json({ error: error.message || 'Failed to create command' });
@@ -626,16 +653,10 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
       console.log('[Server] Updating command');
 
       updateCommand(commandName, updates, directory);
-      await refreshOpenCodeAfterConfigChange('command update');
 
       console.log('[Server] Command updated successfully');
 
-      res.json({
-        success: true,
-        requiresReload: true,
-        message: `Command ${commandName} updated successfully. Reloading interface…`,
-        reloadDelayMs: clientReloadDelayMs,
-      });
+      res.json(configSaved());
     } catch (error) {
       console.error('[Server] Failed to update command');
       res.status(500).json({ error: error.message || 'Failed to update command' });
@@ -651,14 +672,7 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
       }
 
       deleteCommand(commandName, directory);
-      await refreshOpenCodeAfterConfigChange('command deletion');
-
-      res.json({
-        success: true,
-        requiresReload: true,
-        message: `Command ${commandName} deleted successfully. Reloading interface…`,
-        reloadDelayMs: clientReloadDelayMs,
-      });
+      res.json(configSaved());
     } catch (error) {
       console.error('Failed to delete command');
       res.status(500).json({ error: error.message || 'Failed to delete command' });

package/server/lib/opencode/config-entity-routes.test.js

@@ -5,10 +5,11 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 
-vi.mock('@opencode-ai/sdk/v2', () => ({ createOpencodeClient: vi.fn() }));
+vi.mock('@opencode/client', () => ({ OpenCode: { make: vi.fn() } }));
 
-const { createOpencodeClient } = await import('@opencode-ai/sdk/v2');
+const { OpenCode } = await import('@opencode/client');
 const { registerConfigEntityRoutes } = await import('./config-entity-routes.js');
+const createOpencodeClient = OpenCode.make;
 
 beforeEach(() => {
   createOpencodeClient.mockReset();
@@ -49,7 +50,50 @@ const createDependencies = (getCommandSources, configDirectory, getAgentSources
   getOpenCodePort: () => 4096,
 });
 
+describe('V2 configuration persistence', () => {
+  it.each(['agents', 'commands', 'mcp'])('%s CRUD never restarts or reloads OpenCode', async (entity) => {
+    const dependencies = createDependencies(vi.fn());
+    dependencies.refreshOpenCodeAfterConfigChange.mockRejectedValue(new Error('must not manage the service'));
+    const app = express();
+    app.use(express.json());
+    registerConfigEntityRoutes(app, dependencies);
+    for (const method of ['post', 'patch', 'delete']) {
+      const response = await request(app)[method](`/api/config/${entity}/example?directory=%2Frepo`)
+        .send({ name: 'example', scope: 'project', type: 'local', command: ['example'] });
+      expect(response.status).toBe(200);
+      expect(response.body).toMatchObject({ success: true, requiresReload: false, application: 'watch' });
+      expect(response.body.requiresManualRestart).not.toBe(true);
+    }
+    expect(dependencies.refreshOpenCodeAfterConfigChange).not.toHaveBeenCalled();
+  });
+});
+
 describe('config entity command metadata route', () => {
+  it('preserves real SDK authentication and request options when fetching the catalog', async () => {
+    const { OpenCode: realOpenCode } = await vi.importActual('@opencode/client');
+    createOpencodeClient.mockImplementation(realOpenCode.make);
+    const upstream = vi.spyOn(globalThis, 'fetch').mockImplementation(async (_input, init) => {
+      if (new Headers(init?.headers).get('Authorization') !== 'Basic example') {
+        return new Response('Unauthorized', { status: 401 });
+      }
+      return Response.json({ data: [{ name: 'review', description: 'Review changes' }] });
+    });
+    try {
+      const app = express();
+      app.use(express.json());
+      registerConfigEntityRoutes(app, createDependencies(() => ({ md: { exists: false }, json: { exists: false } })));
+      const response = await request(app).post('/api/config/commands/metadata').send({ catalog: true });
+      expect(response.status).toBe(200);
+      expect(response.body.commands).toEqual([expect.objectContaining({ name: 'review' })]);
+      const [url, init] = upstream.mock.calls[0];
+      expect(new URL(url).pathname).toBe('/api/command');
+      expect(init.method).toBe('GET');
+      expect(init.signal).toBeInstanceOf(AbortSignal);
+    } finally {
+      upstream.mockRestore();
+    }
+  });
+
   it('returns metadata for many commands through one request', async () => {
     const app = express();
     app.use(express.json());
@@ -100,9 +144,9 @@ describe('config entity command metadata route', () => {
 
     expect(createOpencodeClient).toHaveBeenCalledWith(expect.objectContaining({
       baseUrl: 'http://opencode-upstream:4096',
-      directory: '/repo',
       headers: { Authorization: 'Basic example' },
     }));
+    expect(createOpencodeClient.mock.calls[0][0].directory).toBeUndefined();
     expect(response.body.commands).toEqual([
       expect.objectContaining({ name: 'markdown', reference: markdownPath, description: `${'😀'.repeat(160)}…`, scope: 'project', isBuiltIn: false }),
       expect.objectContaining({ name: 'json', reference: 'json', description: 'JSON command', scope: 'project', isBuiltIn: false }),
@@ -149,14 +193,35 @@ describe('config entity command metadata route', () => {
       { name: 'long-path', reference: 'long-path' },
     ]);
   });
+
+  it('returns 502 when the command catalog is not an array instead of an empty success', async () => {
+    const app = express();
+    app.use(express.json());
+    createOpencodeClient.mockReturnValue({
+      command: { list: vi.fn(async () => ({ data: { commands: [] } })) },
+    });
+    registerConfigEntityRoutes(app, createDependencies(vi.fn()));
+
+    const response = await request(app)
+      .post('/api/config/commands/metadata?directory=%2Frepo')
+      .send({ catalog: true })
+      .expect(502);
+    expect(response.body).toEqual({ error: 'Command catalog is unavailable' });
+  });
 });
 
 describe('provider catalog route', () => {
   it('uses the resolved directory, OpenCode auth, SDK providers call, and explicit catalog route', async () => {
     const app = express();
     const resolveProjectDirectory = vi.fn(async () => ({ directory: '/project/from-header' }));
-    const providers = vi.fn(async () => ({ data: { providers: [], default: {} } }));
-    createOpencodeClient.mockReturnValue({ config: { providers } });
+    const location = { directory: '/project/from-header' };
+    const providers = vi.fn(async () => ({ data: [] }));
+    const models = vi.fn(async () => ({ data: [] }));
+    const modelDefault = vi.fn(async () => ({ data: null }));
+    createOpencodeClient.mockReturnValue({
+      provider: { list: providers },
+      model: { list: models, default: modelDefault },
+    });
     registerConfigEntityRoutes(app, {
       ...createDependencies(vi.fn()),
       resolveProjectDirectory,
@@ -171,22 +236,94 @@ describe('provider catalog route', () => {
     expect(resolveProjectDirectory).toHaveBeenCalledWith(expect.objectContaining({ query: { directory: '/repo' } }));
     expect(createOpencodeClient).toHaveBeenCalledWith(expect.objectContaining({
       baseUrl: 'http://opencode-upstream:4096',
-      directory: '/project/from-header',
       headers: { Authorization: 'Basic example' },
       fetch: expect.any(Function),
     }));
-    expect(providers).toHaveBeenCalledWith({ directory: '/project/from-header' });
+    expect(createOpencodeClient.mock.calls[0][0].directory).toBeUndefined();
+    expect(providers).toHaveBeenCalledWith({ location });
+    expect(models).toHaveBeenCalledWith({ location });
+    expect(modelDefault).toHaveBeenCalledWith({ location });
     expect(response.body).toEqual({ schemaVersion: 1, providers: [], default: {}, partial: false });
   });
 
+  it('projects ModelInfo.id as the catalog model id and default', async () => {
+    const app = express();
+    createOpencodeClient.mockReturnValue({
+      provider: { list: vi.fn(async () => ({ data: [{ id: 'openai', name: 'OpenAI' }] })) },
+      model: {
+        list: vi.fn(async () => ({
+          data: [{
+            id: 'gpt-5.4-mini',
+            modelID: 'internal-pack',
+            providerID: 'openai',
+            name: 'GPT-5.4 Mini',
+          }],
+        })),
+        default: vi.fn(async () => ({
+          data: { id: 'gpt-5.4-mini', modelID: 'internal-pack', providerID: 'openai', name: 'GPT-5.4 Mini' },
+        })),
+      },
+    });
+    registerConfigEntityRoutes(app, createDependencies(vi.fn()));
+
+    const response = await request(app).get('/api/config/catalog/providers').expect(200);
+    expect(response.body.providers).toEqual([{
+      id: 'openai',
+      name: 'OpenAI',
+      models: { 'gpt-5.4-mini': { id: 'gpt-5.4-mini', name: 'GPT-5.4 Mini' } },
+    }]);
+    expect(response.body.default).toEqual({ openai: 'gpt-5.4-mini' });
+    expect(JSON.stringify(response.body)).not.toContain('internal-pack');
+  });
+
+  it('projects v2 thinking variants into the provider catalog and strips request payloads', async () => {
+    const app = express();
+    createOpencodeClient.mockReturnValue({
+      provider: { list: vi.fn(async () => ({ data: [{ id: 'openai', name: 'OpenAI' }] })) },
+      model: {
+        list: vi.fn(async () => ({
+          data: [{
+            id: 'gpt-5.4',
+            modelID: 'internal-pack',
+            providerID: 'openai',
+            name: 'GPT 5.4',
+            capabilities: { tools: true, input: ['text', 'image'], output: ['text'] },
+            variants: [
+              { id: 'low', settings: { reasoningEffort: 'low', apiKey: 'variant-settings-sentinel' } },
+              { id: 'high', headers: { Authorization: 'variant-headers-sentinel' }, body: { store: false } },
+            ],
+          }],
+        })),
+        default: vi.fn(async () => ({ data: null })),
+      },
+    });
+    registerConfigEntityRoutes(app, createDependencies(vi.fn()));
+
+    const response = await request(app).get('/api/config/catalog/providers').expect(200);
+    expect(response.body.providers[0].models['gpt-5.4'].variants).toEqual({ low: {}, high: {} });
+    expect(response.body.providers[0].models['gpt-5.4'].capabilities).toEqual({
+      toolcall: true,
+      input: { text: true, image: true },
+      output: { text: true },
+    });
+    expect(JSON.stringify(response.body)).not.toContain('sentinel');
+    expect(JSON.stringify(response.body)).not.toContain('internal-pack');
+  });
+
   it('returns 502 for SDK failure and malformed catalog responses', async () => {
     const app = express();
-    createOpencodeClient.mockReturnValue({ config: { providers: vi.fn(async () => ({ data: { providers: {} } })) } });
+    createOpencodeClient.mockReturnValue({
+      provider: { list: vi.fn(async () => ({ data: {} })) },
+      model: { list: vi.fn(async () => ({ data: [] })), default: vi.fn(async () => ({ data: null })) },
+    });
     registerConfigEntityRoutes(app, createDependencies(vi.fn()));
     await request(app).get('/api/config/catalog/providers').expect(502);
 
     const failingApp = express();
-    createOpencodeClient.mockReturnValue({ config: { providers: vi.fn(async () => { throw new Error('upstream unavailable'); }) } });
+    createOpencodeClient.mockReturnValue({
+      provider: { list: vi.fn(async () => { throw new Error('upstream unavailable'); }) },
+      model: { list: vi.fn(async () => ({ data: [] })), default: vi.fn(async () => ({ data: null })) },
+    });
     registerConfigEntityRoutes(failingApp, createDependencies(vi.fn()));
     await request(failingApp).get('/api/config/catalog/providers').expect(502);
   });
@@ -194,7 +331,8 @@ describe('provider catalog route', () => {
   it('returns 502 for SDK error envelopes that include data', async () => {
     const app = express();
     createOpencodeClient.mockReturnValue({
-      config: { providers: vi.fn(async () => ({ error: { message: 'upstream sentinel' }, data: { providers: [], default: {} } })) },
+      provider: { list: vi.fn(async () => { throw new Error('upstream sentinel'); }) },
+      model: { list: vi.fn(async () => ({ data: [] })), default: vi.fn(async () => ({ data: null })) },
     });
     registerConfigEntityRoutes(app, createDependencies(vi.fn()));
 

package/server/lib/opencode/config-hot-reload.integration.test.js

@@ -0,0 +1,105 @@
+import { test, expect } from 'vitest';
+import { OpenCode } from '@opencode/client';
+import { spawn } from 'node:child_process';
+import { once } from 'node:events';
+import { randomBytes } from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+// Opt-in, isolated real V2 server. No user config, credentials, model calls,
+// shared service registration, or npm plugin installs are used.
+test.skipIf(!process.env.OPENCHAMBER_TEST_OPENCODE_BINARY)('V2 applies credentials, global config and plugin changes in the same process', async () => {
+  const temporary = path.join(os.tmpdir(), 'opencode');
+  await fs.mkdir(temporary, { recursive: true });
+  const root = await fs.mkdtemp(path.join(temporary, 'config-hot-reload-'));
+  const config = path.join(root, 'config', 'opencode');
+  const directory = path.join(root, 'project');
+  await fs.mkdir(config, { recursive: true });
+  await fs.mkdir(directory, { recursive: true });
+  const password = randomBytes(24).toString('hex');
+  const child = spawn(process.env.OPENCHAMBER_TEST_OPENCODE_BINARY, ['serve', '--hostname', '127.0.0.1', '--port', '0'], {
+    cwd: directory,
+    env: {
+      PATH: process.env.PATH,
+      HOME: root,
+      TMPDIR: temporary,
+      XDG_CONFIG_HOME: path.join(root, 'config'),
+      XDG_DATA_HOME: path.join(root, 'data'),
+      XDG_STATE_HOME: path.join(root, 'state'),
+      XDG_CACHE_HOME: path.join(root, 'cache'),
+      OPENCODE_CONFIG_DIR: config,
+      OPENCODE_SERVER_PASSWORD: password,
+      OPENCODE_DISABLE_MODELS_FETCH: '1',
+    },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  let output = '';
+  let spawnError;
+  child.on('error', (error) => { spawnError = error; });
+  child.stdout.on('data', (data) => { output = (output + data).slice(-8192); });
+  child.stderr.on('data', () => undefined);
+  const closed = once(child, 'close').catch(() => undefined);
+  const until = async (read, accepts, label) => {
+    const deadline = Date.now() + 20_000;
+    while (Date.now() < deadline) {
+      if (spawnError) throw spawnError;
+      if (child.exitCode !== null) throw new Error(`Isolated OpenCode exited during ${label}`);
+      const value = await read();
+      if (accepts(value)) return value;
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    throw new Error(`Timed out waiting for ${label}`);
+  };
+  const write = async (info) => {
+    const file = path.join(config, 'opencode.json');
+    await fs.writeFile(`${file}.tmp`, JSON.stringify(info));
+    await fs.rename(`${file}.tmp`, file);
+  };
+  try {
+    const origin = await until(
+      async () => output.match(/(?:server listening on|opencode server listening on) (http:\/\/[^\s]+)/)?.[1],
+      Boolean, 'listener',
+    );
+    const client = OpenCode.make({
+      baseUrl: origin,
+      headers: { Authorization: `Basic ${Buffer.from(`opencode:${password}`).toString('base64')}` },
+      fetch: (input, init) => fetch(input, { ...init, signal: AbortSignal.timeout(15_000) }),
+    });
+    const location = { directory };
+    await client.command.list({ location });
+    const pid = child.pid;
+    const commands = { 'hot-reload-probe': { template: 'Do not execute anything.', description: 'one' } };
+    await write({ commands });
+    await until(() => client.command.list({ location }), (result) => result.data.some((entry) => entry.name === 'hot-reload-probe'), 'global command create');
+    await write({ commands: { 'hot-reload-probe': { ...commands['hot-reload-probe'], description: 'two' } } });
+    await until(() => client.command.list({ location }), (result) => result.data.some((entry) => entry.name === 'hot-reload-probe' && entry.description === 'two'), 'command update');
+
+    await write({ commands, plugins: ['*', '-opencode.config.command'] });
+    await until(() => client.command.list({ location }), (result) => !result.data.some((entry) => entry.name === 'hot-reload-probe'), 'plugin disable');
+    await write({ commands });
+    await until(() => client.command.list({ location }), (result) => result.data.some((entry) => entry.name === 'hot-reload-probe'), 'plugin re-enable');
+
+    await client.integration.connect.key({ integrationID: 'anthropic', key: 'isolated-test-placeholder', location });
+    const integration = await until(() => client.integration.get({ integrationID: 'anthropic', location }),
+      (result) => result.data.connections.some((connection) => connection.type === 'credential'), 'credential connection');
+    for (const connection of integration.data.connections) {
+      if (connection.type === 'credential') await client.credential.remove({ credentialID: connection.id });
+    }
+    await until(() => client.integration.get({ integrationID: 'anthropic', location }),
+      (result) => result.data.connections.length === 0, 'credential removal');
+    await write({ commands, mcp: { servers: { 'hot-reload-mcp': { type: 'local', command: ['unused-test-command'], disabled: true } } } });
+    await until(() => client.mcp.list({ location }), (result) => result.data.some((server) => server.name === 'hot-reload-mcp'), 'MCP config add');
+    await write({});
+    await until(() => client.mcp.list({ location }), (result) => !result.data.some((server) => server.name === 'hot-reload-mcp'), 'MCP config removal');
+    await until(() => client.command.list({ location }), (result) => !result.data.some((entry) => entry.name === 'hot-reload-probe'), 'command removal');
+    expect(child.pid).toBe(pid);
+    expect(child.exitCode).toBeNull();
+  } finally {
+    child.kill('SIGTERM');
+    const kill = setTimeout(() => child.kill('SIGKILL'), 5000);
+    await closed;
+    clearTimeout(kill);
+    await fs.rm(root, { recursive: true, force: true });
+  }
+}, 120_000);