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

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

@@ -0,0 +1,280 @@
+/**
+ * OpenCode v2 agent markdown.
+ *
+ * A file is native only when every frontmatter key is a current agent field.
+ * Any older key makes the loader migrate the whole file, and native keys in
+ * that file are then treated as request body. Saving therefore rewrites the
+ * whole file as native markdown. Fields the runtime does not apply are reported
+ * and kept until the caller confirms they can be dropped.
+ */
+
+const NATIVE_KEYS = new Set([
+  'model',
+  'variant',
+  'request',
+  'system',
+  'description',
+  'mode',
+  'hidden',
+  'color',
+  'steps',
+  'disabled',
+  'permissions',
+]);
+
+const ACTION_RENAMES = {
+  bash: 'shell',
+  task: 'subagent',
+  write: 'edit',
+  patch: 'edit',
+};
+
+const HEX_COLOR = /^#[0-9a-fA-F]{6}$/;
+const PROMPT_FILE = /^\{file:.+\}$/i;
+const EFFECTS = new Set(['allow', 'ask', 'deny']);
+
+export class DropConfirmationRequired extends Error {
+  /**
+   * @param {Array<{ key: string, reason: string }>} dropped
+   */
+  constructor(dropped) {
+    super('Drop confirmation required');
+    this.code = 'drop-confirmation';
+    this.dropped = dropped;
+  }
+}
+
+const isEffect = (value) => typeof value === 'string' && EFFECTS.has(value);
+
+const renameAction = (action) => ACTION_RENAMES[action] || action;
+
+/**
+ * @param {unknown} config
+ * @returns {{ legacy: boolean, dropped: Array<{ key: string, reason: string }> }}
+ */
+export function inspectAgentConfig(config) {
+  const source = config && typeof config === 'object' && !Array.isArray(config) ? config : {};
+  /** @type {Array<{ key: string, reason: string }>} */
+  const dropped = [];
+  const keys = Object.keys(source);
+
+  for (const key of keys) {
+    if (key === 'temperature' || key === 'top_p') {
+      dropped.push({ key, reason: 'generation' });
+      continue;
+    }
+    if (key === 'options' && source.options && typeof source.options === 'object' && Object.keys(source.options).length > 0) {
+      dropped.push({ key, reason: 'unknown' });
+      continue;
+    }
+    if (key === 'prompt' && typeof source.prompt === 'string' && PROMPT_FILE.test(source.prompt.trim())) {
+      dropped.push({ key, reason: 'prompt-file' });
+      continue;
+    }
+    if (key === 'color' && source.color != null && source.color !== '' && !HEX_COLOR.test(String(source.color))) {
+      dropped.push({ key, reason: 'color' });
+      continue;
+    }
+    if (key === 'variant' && (typeof source.model !== 'string' || source.model.length === 0)) {
+      dropped.push({ key, reason: 'variant' });
+      continue;
+    }
+    if (!NATIVE_KEYS.has(key) && !isConvertibleKey(key)) {
+      dropped.push({ key, reason: 'unknown' });
+    }
+  }
+
+  const legacy = keys.some((key) => !NATIVE_KEYS.has(key)) || dropped.length > 0;
+  return { legacy, dropped };
+}
+
+const isConvertibleKey = (key) => (
+  key === 'prompt'
+  || key === 'tools'
+  || key === 'disable'
+  || key === 'maxSteps'
+  || key === 'permission'
+  || key === 'name'
+  || key === 'options'
+);
+
+/**
+ * @param {unknown} config
+ * @returns {{ frontmatter: Record<string, unknown>, body: string, legacy: boolean, dropped: Array<{ key: string, reason: string }> }}
+ */
+export function convertAgentConfig(config) {
+  const source = config && typeof config === 'object' && !Array.isArray(config) ? { ...config } : {};
+  const inspection = inspectAgentConfig(source);
+  /** @type {Record<string, unknown>} */
+  const frontmatter = {};
+
+  if (typeof source.description === 'string' && source.description.trim()) {
+    frontmatter.description = source.description;
+  }
+  if (source.mode === 'primary' || source.mode === 'subagent' || source.mode === 'all') {
+    frontmatter.mode = source.mode;
+  }
+
+  const model = encodeModel(source.model, source.variant);
+  if (model) frontmatter.model = model;
+
+  if (source.hidden === true) frontmatter.hidden = true;
+  if (source.disabled === true || source.disable === true) frontmatter.disabled = true;
+  if (typeof source.color === 'string' && HEX_COLOR.test(source.color)) frontmatter.color = source.color;
+
+  const steps = positiveInt(source.steps) ?? positiveInt(source.maxSteps);
+  if (steps !== undefined) frontmatter.steps = steps;
+
+  if (isRequest(source.request)) frontmatter.request = source.request;
+
+  const permissions = normalizePermissions(source.permissions ?? source.permission, source.tools);
+  if (permissions.length > 0) frontmatter.permissions = permissions;
+
+  const body = readSystem(source);
+  return { frontmatter, body, legacy: inspection.legacy, dropped: inspection.dropped };
+}
+
+/**
+ * @param {{ frontmatter: Record<string, unknown>, body: string }} current
+ * @param {Record<string, unknown>} patch
+ */
+export function applyNativePatch(current, patch) {
+  const frontmatter = { ...current.frontmatter };
+  let body = current.body;
+  const changes = patch && typeof patch === 'object' ? patch : {};
+  for (const [key, value] of Object.entries(changes)) {
+    if (value === undefined || key === 'name' || key === 'scope' || key === 'confirmDrop') continue;
+    if (key === 'system') {
+      body = value === null ? '' : String(value);
+      delete frontmatter.system;
+      continue;
+    }
+    if (value === null || value === false && (key === 'hidden' || key === 'disabled')) {
+      delete frontmatter[key];
+      if (key === 'model') delete frontmatter.variant;
+      continue;
+    }
+    if (key === 'color' && (typeof value !== 'string' || !HEX_COLOR.test(value))) {
+      continue;
+    }
+    if (key === 'steps') {
+      const steps = positiveInt(value);
+      if (steps === undefined) delete frontmatter.steps;
+      else frontmatter.steps = steps;
+      continue;
+    }
+    if (key === 'permissions') {
+      const permissions = normalizePermissions(value, undefined);
+      delete frontmatter.permission;
+      if (permissions.length === 0) delete frontmatter.permissions;
+      else frontmatter.permissions = permissions;
+      continue;
+    }
+    if (key === 'model') delete frontmatter.variant;
+    frontmatter[key] = value;
+  }
+  return { frontmatter, body };
+}
+
+/**
+ * Write only the keys in `patch` onto the existing markdown document.
+ * `confirmDrop` removes fields the current format cannot represent.
+ * Unmentioned fields, including permissions, stay as they are.
+ *
+ * @param {{ frontmatter?: Record<string, unknown>, body?: string }} existing
+ * @param {Record<string, unknown>} patch
+ * @param {boolean} confirmDrop
+ */
+export function writeAgentDocument(existing, patch, confirmDrop) {
+  const frontmatter = { ...(existing?.frontmatter || {}) };
+  let body = typeof existing?.body === 'string' ? existing.body : '';
+  if (confirmDrop) {
+    const inspection = inspectAgentConfig({
+      ...frontmatter,
+      ...(body.trim() ? { prompt: body } : {}),
+    });
+    for (const item of inspection.dropped) {
+      if (item.key === 'prompt') {
+        body = '';
+        delete frontmatter.prompt;
+      } else {
+        delete frontmatter[item.key];
+      }
+    }
+  }
+  return applyNativePatch({ frontmatter, body }, patch);
+}
+
+const encodeModel = (model, variant) => {
+  if (typeof model !== 'string') return undefined;
+  const trimmed = model.trim();
+  if (!trimmed) return undefined;
+  if (trimmed.includes('#')) return trimmed;
+  if (typeof variant === 'string' && variant.trim() && !variant.includes('#')) {
+    return `${trimmed}#${variant.trim()}`;
+  }
+  return trimmed;
+};
+
+const positiveInt = (value) => {
+  const number = typeof value === 'number' ? value : typeof value === 'string' && value.trim() ? Number(value) : NaN;
+  if (!Number.isInteger(number) || number < 1) return undefined;
+  return number;
+};
+
+const isRequest = (value) => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const request = /** @type {Record<string, unknown>} */ (value);
+  return request.headers != null || request.body != null;
+};
+
+const readSystem = (source) => {
+  if (typeof source.system === 'string') return source.system;
+  if (typeof source.prompt === 'string' && !PROMPT_FILE.test(source.prompt.trim())) return source.prompt;
+  return '';
+};
+
+const normalizePermissions = (permission, tools) => {
+  /** @type {Array<{ action: string, resource: string, effect: string }>} */
+  const rules = [];
+  if (tools && typeof tools === 'object' && !Array.isArray(tools)) {
+    for (const [tool, enabled] of Object.entries(tools)) {
+      if (typeof enabled !== 'boolean') continue;
+      pushRule(rules, renameAction(tool), '*', enabled ? 'allow' : 'deny');
+    }
+  }
+  if (isEffect(permission)) {
+    pushRule(rules, '*', '*', permission);
+  } else if (Array.isArray(permission)) {
+    for (const rule of permission) {
+      if (!rule || typeof rule !== 'object') continue;
+      if (typeof rule.permission === 'string' && typeof rule.pattern === 'string') {
+        pushRule(rules, renameAction(rule.permission), rule.pattern, rule.action);
+        continue;
+      }
+      pushRule(rules, renameAction(rule.action), rule.resource, rule.effect);
+    }
+  } else if (permission && typeof permission === 'object') {
+    for (const [key, rule] of Object.entries(permission)) {
+      const action = renameAction(key);
+      if (isEffect(rule)) {
+        pushRule(rules, action, '*', rule);
+        continue;
+      }
+      if (rule && typeof rule === 'object' && !Array.isArray(rule)) {
+        for (const [resource, effect] of Object.entries(rule)) {
+          pushRule(rules, action, resource, effect);
+        }
+      }
+    }
+  }
+  return rules;
+};
+
+const pushRule = (rules, action, resource, effect) => {
+  if (!action || !resource || !isEffect(effect)) return;
+  const index = rules.findIndex((rule) => rule.action === action && rule.resource === resource);
+  const next = { action, resource, effect };
+  if (index >= 0) rules[index] = next;
+  else rules.push(next);
+};

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,
     });