@vantran-se/openchamber-web 1.24.4 → 2.0.1

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

@@ -1,4 +1,4 @@
-import { buildDeferredRestartResponse } from './config-mutation-response.js';
+import { buildAppliedResponse } from './config-mutation-response.js';
 
 export const registerConfigEntityRoutes = (app, dependencies) => {
   const {
@@ -6,10 +6,12 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
     resolveOptionalProjectDirectory,
     getAgentSources,
     getAgentConfig,
+    getAgentPermissions,
     createAgent,
     updateAgent,
     deleteAgent,
     getCommandSources,
+    getCommandConfig,
     createCommand,
     updateCommand,
     deleteCommand,
@@ -29,10 +31,11 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
   // Persist to disk immediately; OpenCode restart is deferred to an explicit
   // Apply & Restart so settings edits do not interrupt live sessions.
   const completeMcpMutation = async (res, action, name, applyChange) => {
-    applyChange();
+    const result = applyChange();
     const past = action === 'delete' ? 'deleted' : `${action}d`;
-    return res.json(buildDeferredRestartResponse(
-      `MCP server "${name}" ${past}. Restart OpenCode to apply.`,
+    return res.json(buildAppliedResponse(
+      `MCP server "${name}" ${past}.`,
+      result,
     ));
   };
 
@@ -77,6 +80,20 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
     }
   });
 
+  app.get('/api/config/agents/:name/permissions', async (req, res) => {
+    try {
+      const agentName = req.params.name;
+      const { directory, error } = await resolveProjectDirectory(req);
+      if (!directory) {
+        return res.status(400).json({ error });
+      }
+      res.json(getAgentPermissions(agentName, directory));
+    } catch (error) {
+      console.error('Failed to get agent permissions:', error);
+      res.status(500).json({ error: 'Failed to get agent permissions' });
+    }
+  });
+
   app.post('/api/config/agents/:name', async (req, res) => {
     try {
       const agentName = req.params.name;
@@ -90,9 +107,10 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
       console.log('[Server] Config received:', JSON.stringify(config, null, 2));
       console.log('[Server] Scope:', scope, 'Working directory:', directory);
 
-      createAgent(agentName, config, directory, scope);
-      res.json(buildDeferredRestartResponse(
-        `Agent ${agentName} created successfully. Restart OpenCode to apply.`,
+      const created = createAgent(agentName, config, directory, scope);
+      res.json(buildAppliedResponse(
+        `Agent ${agentName} created successfully.`,
+        created,
       ));
     } catch (error) {
       console.error('Failed to create agent:', error);
@@ -113,12 +131,13 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
       console.log('[Server] Updates:', JSON.stringify(updates, null, 2));
       console.log('[Server] Working directory:', directory);
 
-      updateAgent(agentName, updates, directory);
+      const updated = updateAgent(agentName, updates, directory);
 
       console.log(`[Server] Agent ${agentName} updated successfully`);
 
-      res.json(buildDeferredRestartResponse(
-        `Agent ${agentName} updated successfully. Restart OpenCode to apply.`,
+      res.json(buildAppliedResponse(
+        `Agent ${agentName} updated successfully.`,
+        updated,
       ));
     } catch (error) {
       console.error('[Server] Failed to update agent:', error);
@@ -137,8 +156,8 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
 
       const scope = req.body?.scope;
       deleteAgent(agentName, directory, scope);
-      res.json(buildDeferredRestartResponse(
-        `Agent ${agentName} deleted successfully. Restart OpenCode to apply.`,
+      res.json(buildAppliedResponse(
+        `Agent ${agentName} deleted successfully.`,
       ));
     } catch (error) {
       console.error('Failed to delete agent:', error);
@@ -188,9 +207,7 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
       }
       console.log(`[API:POST /api/config/mcp] Creating MCP server: ${name}`);
 
-      await completeMcpMutation(res, 'create', name, () => {
-        createMcpConfig(name, config, directory, scope);
-      });
+      await completeMcpMutation(res, 'create', name, () => createMcpConfig(name, config, directory, scope));
     } catch (error) {
       console.error('[API:POST /api/config/mcp/:name] Failed:', error);
       res.status(500).json({ error: error.message || 'Failed to create MCP server' });
@@ -207,9 +224,7 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
       }
       console.log(`[API:PATCH /api/config/mcp] Updating MCP server: ${name}`);
 
-      await completeMcpMutation(res, 'update', name, () => {
-        updateMcpConfig(name, updates, directory);
-      });
+      await completeMcpMutation(res, 'update', name, () => updateMcpConfig(name, updates, directory));
     } catch (error) {
       console.error('[API:PATCH /api/config/mcp/:name] Failed:', error);
       if (error?.message === `MCP server "${req.params.name}" not found`) {
@@ -228,9 +243,7 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
       }
       console.log(`[API:DELETE /api/config/mcp] Deleting MCP server: ${name}`);
 
-      await completeMcpMutation(res, 'delete', name, () => {
-        deleteMcpConfig(name, directory);
-      });
+      await completeMcpMutation(res, 'delete', name, () => deleteMcpConfig(name, directory));
     } catch (error) {
       console.error('[API:DELETE /api/config/mcp/:name] Failed:', error);
       res.status(500).json({ error: error.message || 'Failed to delete MCP server' });
@@ -262,6 +275,20 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
     }
   });
 
+  app.get('/api/config/commands/:name/config', async (req, res) => {
+    try {
+      const commandName = req.params.name;
+      const { directory, error } = await resolveProjectDirectory(req);
+      if (!directory) {
+        return res.status(400).json({ error });
+      }
+      res.json(getCommandConfig(commandName, directory));
+    } catch (error) {
+      console.error('Failed to get command config:', error);
+      res.status(500).json({ error: 'Failed to get command configuration' });
+    }
+  });
+
   app.post('/api/config/commands/:name', async (req, res) => {
     try {
       const commandName = req.params.name;
@@ -275,9 +302,10 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
       console.log('[Server] Config received:', JSON.stringify(config, null, 2));
       console.log('[Server] Scope:', scope, 'Working directory:', directory);
 
-      createCommand(commandName, config, directory, scope);
-      res.json(buildDeferredRestartResponse(
-        `Command ${commandName} created successfully. Restart OpenCode to apply.`,
+      const created = createCommand(commandName, config, directory, scope);
+      res.json(buildAppliedResponse(
+        `Command ${commandName} created successfully.`,
+        created,
       ));
     } catch (error) {
       console.error('Failed to create command:', error);
@@ -298,12 +326,13 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
       console.log('[Server] Updates:', JSON.stringify(updates, null, 2));
       console.log('[Server] Working directory:', directory);
 
-      updateCommand(commandName, updates, directory);
+      const updated = updateCommand(commandName, updates, directory);
 
       console.log(`[Server] Command ${commandName} updated successfully`);
 
-      res.json(buildDeferredRestartResponse(
-        `Command ${commandName} updated successfully. Restart OpenCode to apply.`,
+      res.json(buildAppliedResponse(
+        `Command ${commandName} updated successfully.`,
+        updated,
       ));
     } catch (error) {
       console.error('[Server] Failed to update command:', error);
@@ -321,8 +350,8 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
       }
 
       deleteCommand(commandName, directory);
-      res.json(buildDeferredRestartResponse(
-        `Command ${commandName} deleted successfully. Restart OpenCode to apply.`,
+      res.json(buildAppliedResponse(
+        `Command ${commandName} deleted successfully.`,
       ));
     } catch (error) {
       console.error('Failed to delete command:', error);

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

@@ -0,0 +1,290 @@
+import { afterAll, beforeEach, describe, expect, it } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+// The path constants are frozen when the modules load, so point
+// XDG_CONFIG_HOME at a scratch directory BEFORE importing them. Nothing in this
+// file may touch the real ~/.config/opencode.
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'openchamber-entity-v2-'));
+process.env.XDG_CONFIG_HOME = path.join(root, 'xdg');
+delete process.env.OPENCODE_CONFIG;
+
+const { parseMdFile } = await import('./shared.js');
+const { getAgentConfig, getAgentPermissions, updateAgent, createAgent } = await import('./agents.js');
+const { getCommandConfig, updateCommand } = await import('./commands.js');
+const { getMcpConfig, listMcpConfigs, updateMcpConfig } = await import('./mcp.js');
+
+let projectDir;
+
+function write(relativePath, content) {
+  const filePath = path.join(projectDir, relativePath);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content, 'utf8');
+  return filePath;
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+describe('entity modules speak OpenCode 2 shapes', () => {
+  beforeEach(() => {
+    projectDir = fs.mkdtempSync(path.join(root, 'project-'));
+  });
+
+  afterAll(() => {
+    fs.rmSync(root, { recursive: true, force: true });
+    delete process.env.XDG_CONFIG_HOME;
+  });
+
+  it('reads a v1 agent markdown file and answers the v2 shape', () => {
+    write('.opencode/agent/reviewer.md', [
+      '---',
+      'description: Reviewer',
+      'model: anthropic/claude-sonnet-4-5',
+      'variant: high',
+      'temperature: 0.4',
+      'maxSteps: 9',
+      'permission:',
+      '  bash:',
+      '    "git push *": ask',
+      '  edit: deny',
+      '---',
+      '',
+      'Review for correctness.',
+    ].join('\n'));
+
+    const result = getAgentConfig('reviewer', projectDir);
+    expect(result.source).toBe('md');
+    expect(result.legacy).toBe(true);
+    expect(result.config).toEqual({
+      description: 'Reviewer',
+      model: 'anthropic/claude-sonnet-4-5#high',
+      steps: 9,
+      system: 'Review for correctness.',
+      request: { body: { temperature: 0.4 } },
+      permissions: [
+        { action: 'shell', resource: 'git push *', effect: 'ask' },
+        { action: 'edit', resource: '*', effect: 'deny' },
+      ],
+    });
+  });
+
+  it('rewrites a v1 agent file in place, at its own path, in v2 shape', () => {
+    const agentPath = write('.opencode/agent/reviewer.md', [
+      '---',
+      'description: Reviewer',
+      'temperature: 0.4',
+      'permission:',
+      '  bash: ask',
+      '---',
+      '',
+      'Old prompt.',
+    ].join('\n'));
+
+    const result = updateAgent('reviewer', { description: 'Careful reviewer' }, projectDir);
+
+    // Same file: OpenChamber never moves an entity between directories.
+    expect(result.path).toBe(agentPath);
+    expect(fs.existsSync(path.join(projectDir, '.opencode', 'agents', 'reviewer.md'))).toBe(false);
+
+    const parsed = parseMdFile(agentPath);
+    expect(parsed.frontmatter).toEqual({
+      description: 'Careful reviewer',
+      request: { body: { temperature: 0.4 } },
+      permissions: [{ action: 'shell', resource: '*', effect: 'ask' }],
+    });
+    expect(parsed.body).toBe('Old prompt.');
+  });
+
+  it('writes the permission rule array when the client sends a v1 map', () => {
+    write('.opencode/agents/reviewer.md', '---\ndescription: Reviewer\n---\n\nPrompt.\n');
+
+    updateAgent('reviewer', { permission: { task: 'deny', write: 'allow' } }, projectDir);
+
+    const parsed = parseMdFile(path.join(projectDir, '.opencode', 'agents', 'reviewer.md'));
+    expect(parsed.frontmatter.permissions).toEqual([
+      { action: 'subagent', resource: '*', effect: 'deny' },
+      { action: 'edit', resource: '*', effect: 'allow' },
+    ]);
+    expect(parsed.frontmatter.permission).toBeUndefined();
+  });
+
+  it('creates a new agent in the v2 agents directory', () => {
+    createAgent('fresh', { description: 'Fresh', system: 'Do the thing.' }, projectDir, 'project');
+
+    const created = path.join(projectDir, '.opencode', 'agents', 'fresh.md');
+    expect(fs.existsSync(created)).toBe(true);
+    expect(parseMdFile(created)).toEqual({
+      frontmatter: { description: 'Fresh' },
+      body: 'Do the thing.',
+    });
+  });
+
+  it('moves a v1 JSON agent entry into the agents section of the same file', () => {
+    const configPath = write('opencode.json', JSON.stringify({
+      agent: {
+        reviewer: { prompt: 'Old', permission: { bash: 'ask' } },
+        other: { prompt: 'Untouched' },
+      },
+    }, null, 2));
+
+    updateAgent('reviewer', { system: 'New' }, projectDir);
+
+    const written = readJson(configPath);
+    expect(written.agent).toEqual({ other: { prompt: 'Untouched' } });
+    expect(written.agents.reviewer).toEqual({
+      system: 'New',
+      permissions: [{ action: 'shell', resource: '*', effect: 'ask' }],
+    });
+  });
+
+  it('clears v1 fields at the v2 location they moved to', () => {
+    const configPath = write('opencode.json', JSON.stringify({
+      agent: { build: { variant: 'fast', temperature: 0.3, top_p: 0.8, mode: 'subagent' } },
+    }, null, 2));
+
+    // The client still names the v1 fields, but on a v2 entity `variant` is the
+    // `#` suffix on `model` and `temperature`/`top_p` live in `request.body`.
+    updateAgent('build', { variant: null, temperature: null, top_p: null }, projectDir);
+
+    const written = readJson(configPath);
+    expect(written.agent).toBeUndefined();
+    expect(written.agents.build).toEqual({ mode: 'subagent' });
+  });
+
+  it('drops only the variant when a model is set', () => {
+    write('.opencode/agents/reviewer.md', '---\nmodel: anthropic/claude-sonnet-4-5#high\n---\n\nPrompt.\n');
+
+    updateAgent('reviewer', { variant: null }, projectDir);
+
+    const parsed = parseMdFile(path.join(projectDir, '.opencode', 'agents', 'reviewer.md'));
+    expect(parsed.frontmatter.model).toBe('anthropic/claude-sonnet-4-5');
+  });
+
+  it('reports global and agent rules in evaluation order', () => {
+    write('opencode.json', JSON.stringify({
+      permission: { edit: 'allow' },
+      tools: { websearch: false },
+    }, null, 2));
+    write('.opencode/agents/reviewer.md', [
+      '---',
+      'permissions:',
+      '  - action: edit',
+      '    resource: "*"',
+      '    effect: deny',
+      '---',
+      '',
+      'Prompt.',
+    ].join('\n'));
+
+    const result = getAgentPermissions('reviewer', projectDir);
+    expect(result.agent).toEqual([{ action: 'edit', resource: '*', effect: 'deny' }]);
+    expect(result.effective).toEqual([
+      { action: 'websearch', resource: '*', effect: 'deny', source: 'global' },
+      { action: 'edit', resource: '*', effect: 'allow', source: 'global' },
+      { action: 'edit', resource: '*', effect: 'deny', source: 'agent' },
+    ]);
+  });
+
+  it('reads a v1 command file and rewrites it in place as subagent', () => {
+    const commandPath = write('.opencode/command/review.md', [
+      '---',
+      'description: Review',
+      'model: anthropic/claude-sonnet-4-5',
+      'variant: high',
+      'subtask: true',
+      '---',
+      '',
+      'Review the current changes.',
+    ].join('\n'));
+
+    expect(getCommandConfig('review', projectDir).config).toEqual({
+      description: 'Review',
+      model: 'anthropic/claude-sonnet-4-5#high',
+      subagent: true,
+      template: 'Review the current changes.',
+    });
+
+    const result = updateCommand('review', { description: 'Review changes' }, projectDir);
+    expect(result.path).toBe(commandPath);
+    expect(parseMdFile(commandPath).frontmatter).toEqual({
+      description: 'Review changes',
+      model: 'anthropic/claude-sonnet-4-5#high',
+      subagent: true,
+    });
+  });
+
+  it('rewrites a v1 theme color as the hex OpenCode migrates it to', () => {
+    const agentPath = write('.opencode/agent/tinted.md', [
+      '---',
+      'description: Tinted',
+      'color: primary',
+      '---',
+      '',
+      'Prompt.',
+    ].join('\n'));
+
+    updateAgent('tinted', { description: 'Still tinted' }, projectDir);
+
+    // `primary` is not a v2 color; the native decoder would skip the whole file.
+    expect(parseMdFile(agentPath).frontmatter).toEqual({ description: 'Still tinted', color: '#aaaaaa' });
+  });
+
+  it('answers the project v1 override when the user file already holds the v2 spelling', () => {
+    const userConfigPath = path.join(process.env.XDG_CONFIG_HOME, 'opencode', 'opencode.json');
+    fs.mkdirSync(path.dirname(userConfigPath), { recursive: true });
+    fs.writeFileSync(userConfigPath, JSON.stringify({
+      mcp: { servers: { docs: { type: 'remote', url: 'https://global.example.com/mcp' } } },
+    }, null, 2), 'utf8');
+    const projectConfigPath = write('.opencode/opencode.json', JSON.stringify({
+      mcp: { docs: { type: 'remote', url: 'https://project.example.com/mcp', timeout: 5000 } },
+    }, null, 2));
+
+    try {
+      expect(getMcpConfig('docs', projectDir)).toEqual(expect.objectContaining({
+        url: 'https://project.example.com/mcp',
+        scope: 'project',
+        legacy: true,
+      }));
+      expect(listMcpConfigs(projectDir).find((entry) => entry.name === 'docs').url).toBe('https://project.example.com/mcp');
+
+      updateMcpConfig('docs', { timeout: { catalog: 9000, execution: 9000 } }, projectDir);
+
+      expect(readJson(projectConfigPath).mcp).toEqual({
+        servers: { docs: { type: 'remote', url: 'https://project.example.com/mcp', timeout: { catalog: 9000, execution: 9000 } } },
+      });
+      expect(readJson(userConfigPath).mcp.servers.docs.url).toBe('https://global.example.com/mcp');
+    } finally {
+      fs.rmSync(userConfigPath, { force: true });
+    }
+  });
+
+  it('reads a v1 mcp entry and rewrites it under mcp.servers in the same file', () => {
+    const configPath = write('opencode.json', JSON.stringify({
+      mcp: {
+        playwright: { type: 'local', command: ['npx', '@playwright/mcp'], enabled: true, timeout: 30000 },
+      },
+    }, null, 2));
+
+    expect(getMcpConfig('playwright', projectDir)).toEqual(expect.objectContaining({
+      name: 'playwright',
+      type: 'local',
+      disabled: false,
+      timeout: { catalog: 30000, execution: 30000 },
+      legacy: true,
+    }));
+
+    updateMcpConfig('playwright', { disabled: true }, projectDir);
+
+    const written = readJson(configPath);
+    expect(written.mcp.playwright).toBeUndefined();
+    expect(written.mcp.servers.playwright).toEqual({
+      type: 'local',
+      command: ['npx', '@playwright/mcp'],
+      disabled: true,
+      timeout: { catalog: 30000, execution: 30000 },
+    });
+  });
+});

package/server/lib/opencode/config-mutation-response.js

@@ -1,18 +1,28 @@
 /**
  * Shared response shapes for OpenCode config mutations.
  *
- * Settings writes persist to disk immediately but defer the OpenCode restart
- * so the UI can accumulate pending changes and apply them once via
- * POST /api/config/reload ("Apply & Restart OpenCode").
+ * OpenCode 2 watches every config source it reads — agents, commands, skills,
+ * MCP servers, providers, instructions and the plugin list — and rebuilds them
+ * when a file changes. A mutation that lands on disk is therefore already live
+ * by the time the route answers, so config mutations report plain success.
+ *
+ * Only changes OpenChamber cannot hand to a running process still ask for a
+ * restart: the OpenCode binary, its port, and switching between managed and
+ * external OpenCode. Those keep `buildExternalManualRestartResponse` and the
+ * manual `POST /api/config/reload`.
  */
 
-export function buildDeferredRestartResponse(message) {
+/**
+ * `details` carries the file the mutation landed in (`{ path, scope, source }`).
+ * OpenChamber never moves an entity between files, so the caller can show the
+ * user exactly which config file changed — including a v1 file that was
+ * rewritten in place in v2 shape.
+ */
+export function buildAppliedResponse(message, details) {
   return {
     success: true,
-    requiresReload: false,
-    requiresRestart: true,
-    restartDeferred: true,
     message,
+    ...(details && typeof details === 'object' ? details : {}),
   };
 }
 

package/server/lib/opencode/config-mutation-response.test.js

@@ -1,18 +1,15 @@
 import { describe, expect, test } from 'bun:test';
 
 import {
-  buildDeferredRestartResponse,
+  buildAppliedResponse,
   buildExternalManualRestartResponse,
 } from './config-mutation-response.js';
 
 describe('config mutation response helpers', () => {
-  test('buildDeferredRestartResponse marks restart as deferred', () => {
-    expect(buildDeferredRestartResponse('Saved. Restart OpenCode to apply.')).toEqual({
+  test('buildAppliedResponse reports plain success with no restart flags', () => {
+    expect(buildAppliedResponse('Agent saved.')).toEqual({
       success: true,
-      requiresReload: false,
-      requiresRestart: true,
-      restartDeferred: true,
-      message: 'Saved. Restart OpenCode to apply.',
+      message: 'Agent saved.',
     });
   });
 

package/server/lib/opencode/config-paths.test.js

@@ -38,7 +38,7 @@ describe('OpenCode global config paths', () => {
     expect(AGENT_DIR).toBe(path.join(configDir, 'agents'));
     expect(COMMAND_DIR).toBe(path.join(configDir, 'commands'));
     expect(SKILL_DIR).toBe(path.join(configDir, 'skills'));
-    expect(CONFIG_FILE).toBe(path.join(configDir, 'config.json'));
+    expect(CONFIG_FILE).toBe(path.join(configDir, 'opencode.json'));
 
     fs.rmSync(xdgConfigHome, { recursive: true, force: true });
   });
@@ -70,7 +70,7 @@ describe('OpenCode global config paths', () => {
     expect(fs.existsSync(path.join(configDir, 'commands', 'global-command.md'))).toBe(true);
     expect(fs.existsSync(path.join(configDir, 'skills', 'global-skill', 'SKILL.md'))).toBe(true);
     expect(fs.existsSync(path.join(configDir, 'snippet', 'global-snippet.md'))).toBe(true);
-    expect(JSON.parse(fs.readFileSync(path.join(configDir, 'config.json'), 'utf8')).plugin).toEqual(['global-plugin']);
+    expect(JSON.parse(fs.readFileSync(path.join(configDir, 'opencode.json'), 'utf8')).plugins).toEqual(['global-plugin']);
 
     agents.createAgent('project-agent', { description: 'Project', prompt: 'Project prompt' }, projectDir, 'project');
     commands.createCommand('project-command', { description: 'Project', template: 'Project template' }, projectDir, 'project');