@openchambery/web 2.0.0-beta.1 → 2.0.0-beta.4

package/server/lib/opencode/agent-document.test.js

@@ -0,0 +1,137 @@
+import { describe, expect, it } from 'vitest';
+
+import { applyNativePatch, convertAgentConfig, inspectAgentConfig, writeAgentDocument } from './agent-document.js';
+
+describe('inspectAgentConfig', () => {
+  it('treats a native file as current', () => {
+    expect(inspectAgentConfig({
+      description: 'Reviewer',
+      mode: 'subagent',
+      model: 'openai/gpt-5#high',
+      hidden: true,
+      color: '#ff6b6b',
+      steps: 5,
+      permissions: [{ action: 'shell', resource: '*', effect: 'ask' }],
+    })).toEqual({ legacy: false, dropped: [] });
+  });
+
+  it('reports fields the next request does not use', () => {
+    const inspection = inspectAgentConfig({
+      temperature: 0.2,
+      top_p: 0.9,
+      options: { reasoningEffort: 'high' },
+      prompt: '{file:./prompt.md}',
+      color: 'red',
+      variant: 'high',
+      extra: true,
+    });
+    expect(inspection.legacy).toBe(true);
+    expect(inspection.dropped).toEqual([
+      { key: 'temperature', reason: 'generation' },
+      { key: 'top_p', reason: 'generation' },
+      { key: 'options', reason: 'unknown' },
+      { key: 'prompt', reason: 'prompt-file' },
+      { key: 'color', reason: 'color' },
+      { key: 'variant', reason: 'variant' },
+      { key: 'extra', reason: 'unknown' },
+    ]);
+  });
+});
+
+describe('convertAgentConfig', () => {
+  it('folds a legacy agent into native markdown fields', () => {
+    const converted = convertAgentConfig({
+      description: 'Reviewer',
+      mode: 'subagent',
+      model: 'openai/gpt-5',
+      variant: 'high',
+      temperature: 0.2,
+      prompt: 'Be careful.',
+      permission: { bash: 'ask', task: 'allow', write: 'deny' },
+      tools: { write: false },
+      maxSteps: 4,
+      disable: true,
+      color: '#112233',
+      request: { body: { temperature: 0.2 } },
+    });
+
+    expect(converted.legacy).toBe(true);
+    expect(converted.body).toBe('Be careful.');
+    expect(converted.frontmatter).toMatchObject({
+      description: 'Reviewer',
+      mode: 'subagent',
+      model: 'openai/gpt-5#high',
+      steps: 4,
+      disabled: true,
+      color: '#112233',
+      request: { body: { temperature: 0.2 } },
+    });
+    expect(converted.frontmatter).not.toHaveProperty('temperature');
+    expect(converted.frontmatter).not.toHaveProperty('hidden');
+    expect(converted.frontmatter.permissions).toEqual(expect.arrayContaining([
+      { action: 'shell', resource: '*', effect: 'ask' },
+      { action: 'subagent', resource: '*', effect: 'allow' },
+      { action: 'edit', resource: '*', effect: 'deny' },
+    ]));
+  });
+});
+
+describe('applyNativePatch', () => {
+  it('patches only the keys present in the update', () => {
+    const next = applyNativePatch({
+      frontmatter: {
+        model: 'openai/gpt-5',
+        hidden: true,
+        permissions: [{ action: 'read', resource: '*', effect: 'allow' }],
+        variant: 'high',
+        temperature: 1,
+      },
+      body: 'old',
+    }, {
+      model: null,
+      hidden: false,
+      permissions: [],
+      system: null,
+      steps: 0,
+    });
+
+    expect(next.body).toBe('');
+    expect(next.frontmatter).toEqual({
+      temperature: 1,
+    });
+  });
+});
+
+describe('writeAgentDocument', () => {
+  it('leaves unmentioned fields alone on a prompt-only patch', () => {
+    const next = writeAgentDocument({
+      frontmatter: {
+        temperature: 1,
+        permission: { bash: 'allow' },
+      },
+      body: 'legacy prompt',
+    }, {
+      system: 'Only the prompt changed.',
+    }, false);
+
+    expect(next.body).toBe('Only the prompt changed.');
+    expect(next.frontmatter.temperature).toBe(1);
+    expect(next.frontmatter.permission).toEqual({ bash: 'allow' });
+  });
+
+  it('drops legacy fields when confirmDrop is true', () => {
+    const next = writeAgentDocument({
+      frontmatter: {
+        temperature: 1,
+        permission: { bash: 'allow' },
+      },
+      body: 'legacy prompt',
+    }, {
+      system: 'Only the prompt changed.',
+    }, true);
+
+    expect(next.body).toBe('Only the prompt changed.');
+    expect(next.frontmatter.temperature).toBeUndefined();
+    expect(next.frontmatter.permission).toEqual({ bash: 'allow' });
+  });
+});

package/server/lib/opencode/agents.js

@@ -16,6 +16,10 @@ import {
   resolvePromptFilePath,
   writePromptFile,
 } from './shared.js';
+import {
+  inspectAgentConfig,
+  writeAgentDocument,
+} from './agent-document.js';
 
 // ============== AGENT SCOPE HELPERS ==============
 
@@ -321,21 +325,100 @@ function getAgentSources(agentName, workingDirectory, lookupCache = createAgentL
     }
   };
 
+  const stored = {};
+  if (jsonSection && typeof jsonSection === 'object') {
+    Object.assign(stored, jsonSection);
+  }
   if (mdExists) {
     const { frontmatter, body } = parseMdFile(mdPath);
     sources.md.fields = Object.keys(frontmatter);
     if (body) {
       sources.md.fields.push('prompt');
     }
+    Object.assign(stored, frontmatter);
+    if (typeof body === 'string' && body.trim()) stored.prompt = body.trim();
   }
 
   if (jsonSection) {
     sources.json.fields = Object.keys(jsonSection);
   }
+  sources.document = inspectAgentConfig(stored);
 
   return sources;
 }
 
+function listDisabledAgentOverrides(workingDirectory) {
+  /** @type {Array<{ name: string, scope: string, description?: string, mode?: string }>} */
+  const found = [];
+  const visit = (directory, scope) => {
+    if (!directory || !fs.existsSync(directory)) return;
+    const walk = (current, prefix) => {
+      let entries = [];
+      try {
+        entries = fs.readdirSync(current, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (found.length >= 200) return;
+        const full = path.join(current, entry.name);
+        if (entry.isDirectory()) {
+          walk(full, prefix ? `${prefix}/${entry.name}` : entry.name);
+          continue;
+        }
+        if (!entry.isFile() || !entry.name.endsWith('.md')) continue;
+        const base = entry.name.slice(0, -3);
+        const name = prefix ? `${prefix}/${base}` : base;
+        let frontmatter = {};
+        try {
+          frontmatter = parseMdFile(full).frontmatter || {};
+        } catch {
+          continue;
+        }
+        if (frontmatter.disabled !== true && frontmatter.disable !== true) continue;
+        found.push({
+          name,
+          scope,
+          ...(typeof frontmatter.description === 'string' ? { description: frontmatter.description } : {}),
+          ...(frontmatter.mode === 'primary' || frontmatter.mode === 'subagent' || frontmatter.mode === 'all'
+            ? { mode: frontmatter.mode }
+            : {}),
+        });
+      }
+    };
+    walk(directory, '');
+  };
+
+  visit(AGENT_DIR, AGENT_SCOPE.USER);
+  if (workingDirectory) {
+    visit(path.join(workingDirectory, '.opencode', 'agents'), AGENT_SCOPE.PROJECT);
+    visit(path.join(workingDirectory, '.opencode', 'agent'), AGENT_SCOPE.PROJECT);
+  }
+  return found;
+}
+
+function nativeWritePath(agentName, workingDirectory, scope, lookupCache) {
+  if (scope === AGENT_SCOPE.PROJECT && workingDirectory) {
+    ensureProjectAgentDir(workingDirectory);
+    return getProjectAgentPath(workingDirectory, agentName);
+  }
+  if (scope === AGENT_SCOPE.USER) {
+    return getUserAgentPath(agentName, lookupCache);
+  }
+  const existing = getAgentWritePath(agentName, workingDirectory, undefined, lookupCache);
+  if (existing.path && fs.existsSync(existing.path)) return existing.path;
+  return getUserAgentPath(agentName, lookupCache);
+}
+
+function writeNativeAgent(agentName, patch, workingDirectory, scope, confirmDrop) {
+  ensureDirs();
+  const lookupCache = createAgentLookupCache();
+  const targetPath = nativeWritePath(agentName, workingDirectory, scope, lookupCache);
+  const existing = fs.existsSync(targetPath) ? parseMdFile(targetPath) : { frontmatter: {}, body: '' };
+  const next = writeAgentDocument(existing, patch && typeof patch === 'object' ? patch : {}, confirmDrop === true);
+  writeMdFile(targetPath, next.frontmatter, next.body);
+}
+
 function getAgentConfig(agentName, workingDirectory, lookupCache = createAgentLookupCache()) {
   const projectPath = workingDirectory ? getProjectAgentPath(workingDirectory, agentName) : null;
   const projectExists = projectPath && fs.existsSync(projectPath);
@@ -409,6 +492,12 @@ function createAgent(agentName, config, workingDirectory, scope) {
     targetScope = AGENT_SCOPE.USER;
   }
 
+  if (config && Object.prototype.hasOwnProperty.call(config, 'native')) {
+    writeNativeAgent(agentName, config.native, workingDirectory, targetScope, config.confirmDrop === true);
+    console.log(`Created new agent: ${agentName} (scope: ${targetScope})`);
+    return;
+  }
+
   const { prompt, scope: _scopeFromConfig, ...rawFrontmatter } = config;
   const frontmatter = Object.fromEntries(
     Object.entries(rawFrontmatter).filter(([, value]) => value !== null && value !== undefined)
@@ -419,6 +508,12 @@ function createAgent(agentName, config, workingDirectory, scope) {
 }
 
 function updateAgent(agentName, updates, workingDirectory) {
+  if (updates && Object.prototype.hasOwnProperty.call(updates, 'native')) {
+    writeNativeAgent(agentName, updates.native, workingDirectory, updates.scope, updates.confirmDrop === true);
+    console.log(`Updated agent: ${agentName}`);
+    return;
+  }
+
   ensureDirs();
   const lookupCache = createAgentLookupCache();
 
@@ -693,6 +788,7 @@ function deleteAgent(agentName, workingDirectory, scope) {
 export {
   getAgentSources,
   getAgentConfig,
+  listDisabledAgentOverrides,
   createAgent,
   updateAgent,
   deleteAgent,

package/server/lib/opencode/auth-state-runtime.js

@@ -81,9 +81,14 @@ export const createOpenCodeAuthStateRuntime = (dependencies) => {
     return generatedPassword;
   };
 
+  // A server OpenChamber does not own (the shared official service) keeps its
+  // own password; adopt it instead of generating one.
+  const adoptOpenCodeServerPassword = (password, source) => setOpenCodeAuthState(password, source);
+
   return {
     getOpenCodeAuthHeaders,
     isOpenCodeConnectionSecure,
     ensureLocalOpenCodeServerPassword,
+    adoptOpenCodeServerPassword,
   };
 };

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

@@ -64,6 +64,7 @@ export const createBootstrapRuntime = (dependencies) => {
       setAutoAcceptSession,
       sessionIndexService,
       sessionIndexSyncRuntime,
+      getCommittedHostMetadata = null,
       transcriptCacheService,
     } = options;
 
@@ -156,6 +157,7 @@ export const createBootstrapRuntime = (dependencies) => {
       getCachedZenModels,
       sessionIndexService,
       sessionIndexSyncRuntime,
+      getCommittedHostMetadata,
       transcriptCacheService,
       express,
     });

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

@@ -14,9 +14,11 @@ const composeV2ProviderCatalogSource = (providers, models, defaultModel) => {
   for (const model of models) {
     if (!model || typeof model !== 'object') continue;
     const providerID = typeof model.providerID === 'string' ? model.providerID : '';
-    const modelID = typeof model.modelID === 'string' && model.modelID
-      ? model.modelID
-      : (typeof model.id === 'string' ? model.id : '');
+    // 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 };
@@ -24,10 +26,9 @@ const composeV2ProviderCatalogSource = (providers, models, defaultModel) => {
     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;
-    if (model.cost && typeof model.cost === 'object' && !Array.isArray(model.cost)) entry.cost = model.cost;
-    if (model.variants && typeof model.variants === 'object' && !Array.isArray(model.variants)) {
-      entry.variants = model.variants;
-    }
+    // 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);
     }
@@ -45,8 +46,11 @@ const composeV2ProviderCatalogSource = (providers, models, defaultModel) => {
   }
 
   const defaults = Object.create(null);
-  if (defaultModel && typeof defaultModel.providerID === 'string' && typeof defaultModel.modelID === 'string') {
-    defaults[defaultModel.providerID] = defaultModel.modelID;
+  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 };
 };
@@ -130,11 +134,10 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
   const {
     resolveProjectDirectory,
     resolveOptionalProjectDirectory,
-    refreshOpenCodeAfterConfigChange,
-    clientReloadDelayMs,
     waitForOpenCodeReady,
     getAgentSources,
     getAgentConfig,
+    listDisabledAgentOverrides,
     createAgent,
     updateAgent,
     deleteAgent,
@@ -259,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);
@@ -267,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 : {}
@@ -298,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) => {
@@ -345,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' });
@@ -405,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' });
     }
@@ -431,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' });
     }
@@ -455,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' });
@@ -571,7 +531,12 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
         const client = createOpenCodeClient({
           baseUrl: buildOpenCodeUrl('/', '').replace(/\/$/, ''),
           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({ location: { directory } });
         if (!Array.isArray(response?.data)) {
@@ -669,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' });
@@ -697,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' });
@@ -722,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' });