amalgm 0.1.75 → 0.1.76

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.75",
+  "version": "0.1.76",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,

package/runtime/scripts/amalgm-mcp/agent-config/importers/claude.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const path = require('path');
+const { collectClaudeHooks } = require('../../agents/hooks');
+const {
+  markdownAgentsFromDir,
+  nativeHome,
+  readText,
+  skillsFromDir,
+} = require('./common');
+
+function importClaudeConfig() {
+  const home = nativeHome();
+  const claudeHome = path.join(home, '.claude');
+  const hooks = collectClaudeHooks(home).hooks.map((hook) => ({
+    ...hook,
+    source: {
+      kind: 'native-import',
+      provider: 'claude_code',
+      path: hook.sourcePath,
+    },
+  }));
+  const instructions =
+    readText(path.join(claudeHome, 'CLAUDE.md'))
+    || readText(path.join(home, 'CLAUDE.md'));
+  const skills = [
+    ...skillsFromDir(path.join(claudeHome, 'skills'), 'claude_code'),
+    ...skillsFromDir(path.join(home, '.config', 'claude', 'skills'), 'claude_code'),
+  ];
+  const agents = [
+    ...markdownAgentsFromDir(path.join(claudeHome, 'agents'), 'claude_code', 'claude_code'),
+    ...markdownAgentsFromDir(path.join(home, '.config', 'claude', 'agents'), 'claude_code', 'claude_code'),
+  ];
+  return {
+    config: {
+      ...(instructions ? { instructions } : {}),
+      ...(skills.length ? { skills } : {}),
+      ...(hooks.length ? { hooks } : {}),
+    },
+    agents,
+    sources: [
+      path.join(claudeHome, 'CLAUDE.md'),
+      path.join(claudeHome, 'skills'),
+      path.join(claudeHome, 'agents'),
+      path.join(claudeHome, 'settings.json'),
+      path.join(claudeHome, 'settings.local.json'),
+      path.join(home, '.claude.json'),
+    ],
+  };
+}
+
+module.exports = { importClaudeConfig };

package/runtime/scripts/amalgm-mcp/agent-config/importers/codex.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const path = require('path');
+const { collectCodexHooks } = require('../../agents/hooks');
+const { nativeHome, readText, skillsFromDir } = require('./common');
+
+function importCodexConfig() {
+  const home = nativeHome();
+  const codexHome = path.join(home, '.codex');
+  const hooks = collectCodexHooks(home).hooks.map((hook) => ({
+    ...hook,
+    source: {
+      kind: 'native-import',
+      provider: 'codex',
+      path: hook.sourcePath,
+    },
+  }));
+  const instructions = readText(path.join(codexHome, 'AGENTS.md'));
+  const skills = skillsFromDir(path.join(codexHome, 'skills'), 'codex')
+    .filter((skill) => !/\/\.system\//.test(skill.source.path));
+  return {
+    config: {
+      ...(instructions ? { instructions } : {}),
+      ...(skills.length ? { skills } : {}),
+      ...(hooks.length ? { hooks } : {}),
+    },
+    agents: [],
+    sources: [
+      path.join(codexHome, 'AGENTS.md'),
+      path.join(codexHome, 'skills'),
+      path.join(codexHome, 'hooks.json'),
+    ],
+  };
+}
+
+module.exports = { importCodexConfig };

package/runtime/scripts/amalgm-mcp/agent-config/importers/common.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { stableId } = require('../schema');
+
+function nativeHome() {
+  return process.env.AMALGM_NATIVE_HOME || os.homedir();
+}
+
+function readText(file, maxBytes = 128 * 1024) {
+  try {
+    const stat = fs.statSync(file);
+    if (!stat.isFile() || stat.size > maxBytes) return '';
+    return fs.readFileSync(file, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function listDirs(root) {
+  try {
+    return fs.readdirSync(root, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && !entry.name.startsWith('.'))
+      .map((entry) => path.join(root, entry.name));
+  } catch {
+    return [];
+  }
+}
+
+function listMarkdownFiles(root) {
+  try {
+    return fs.readdirSync(root, { withFileTypes: true })
+      .flatMap((entry) => {
+        const full = path.join(root, entry.name);
+        if (entry.isDirectory() && !entry.name.startsWith('.')) return listMarkdownFiles(full);
+        if (entry.isFile() && entry.name.toLowerCase().endsWith('.md')) return [full];
+        return [];
+      });
+  } catch {
+    return [];
+  }
+}
+
+function parseFrontmatter(markdown) {
+  const text = String(markdown || '');
+  if (!text.startsWith('---\n')) return { data: {}, body: text };
+  const end = text.indexOf('\n---', 4);
+  if (end === -1) return { data: {}, body: text };
+  const raw = text.slice(4, end);
+  const data = {};
+  for (const line of raw.split(/\r?\n/)) {
+    const match = line.match(/^\s*([A-Za-z0-9_-]+)\s*:\s*(.*)\s*$/);
+    if (!match) continue;
+    let value = match[2].trim();
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    data[match[1]] = value;
+  }
+  return { data, body: text.slice(end + 4).replace(/^\r?\n/, '') };
+}
+
+function skillsFromDir(root, sourceKind) {
+  return listDirs(root)
+    .map((dir) => {
+      const content = readText(path.join(dir, 'SKILL.md'));
+      if (!content) return null;
+      const name = path.basename(dir);
+      return {
+        id: stableId('skill', `${sourceKind}-${name}`),
+        name,
+        description: '',
+        content,
+        enabled: true,
+        source: { kind: 'native-import', provider: sourceKind, path: path.join(dir, 'SKILL.md') },
+      };
+    })
+    .filter(Boolean);
+}
+
+function markdownAgentsFromDir(root, sourceKind, harnessId) {
+  return listMarkdownFiles(root)
+    .map((file) => {
+      const content = readText(file);
+      if (!content) return null;
+      const { data, body } = parseFrontmatter(content);
+      const name = data.name || path.basename(file, path.extname(file));
+      return {
+        name,
+        description: data.description || '',
+        baseHarnessId: harnessId,
+        instructions: body.trim(),
+        source: { kind: 'native-import', provider: sourceKind, path: file },
+      };
+    })
+    .filter(Boolean);
+}
+
+module.exports = {
+  markdownAgentsFromDir,
+  nativeHome,
+  readJson,
+  readText,
+  skillsFromDir,
+};

package/runtime/scripts/amalgm-mcp/agent-config/importers/index.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const { importClaudeConfig } = require('./claude');
+const { importCodexConfig } = require('./codex');
+const { importOpenCodeConfig } = require('./opencode');
+
+function importNativeConfigForHarness(harnessId) {
+  if (harnessId === 'codex') return importCodexConfig();
+  if (harnessId === 'claude_code') return importClaudeConfig();
+  if (harnessId === 'opencode') return importOpenCodeConfig();
+  return { config: {}, agents: [], sources: [] };
+}
+
+module.exports = { importNativeConfigForHarness };

package/runtime/scripts/amalgm-mcp/agent-config/importers/opencode.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const path = require('path');
+const {
+  markdownAgentsFromDir,
+  nativeHome,
+  readJson,
+  readText,
+  skillsFromDir,
+} = require('./common');
+
+function stringFromConfig(data, keys) {
+  if (!data || typeof data !== 'object') return '';
+  for (const key of keys) {
+    const value = data[key];
+    if (typeof value === 'string' && value.trim()) return value;
+  }
+  return '';
+}
+
+function importOpenCodeConfig() {
+  const home = nativeHome();
+  const configDir = path.join(home, '.config', 'opencode');
+  const dotDir = path.join(home, '.opencode');
+  const configJson =
+    readJson(path.join(configDir, 'opencode.json'))
+    || readJson(path.join(configDir, 'config.json'))
+    || readJson(path.join(dotDir, 'opencode.json'))
+    || {};
+  const instructions =
+    stringFromConfig(configJson, ['instructions', 'systemPrompt', 'prompt'])
+    || readText(path.join(dotDir, 'AGENTS.md'));
+  const skills = [
+    ...skillsFromDir(path.join(configDir, 'skills'), 'opencode'),
+    ...skillsFromDir(path.join(dotDir, 'skills'), 'opencode'),
+  ];
+  const agents = [
+    ...markdownAgentsFromDir(path.join(configDir, 'agents'), 'opencode', 'opencode'),
+    ...markdownAgentsFromDir(path.join(dotDir, 'agents'), 'opencode', 'opencode'),
+  ];
+  return {
+    config: {
+      ...(instructions ? { instructions } : {}),
+      ...(skills.length ? { skills } : {}),
+    },
+    agents,
+    sources: [
+      path.join(configDir, 'opencode.json'),
+      path.join(configDir, 'config.json'),
+      path.join(configDir, 'skills'),
+      path.join(configDir, 'agents'),
+      path.join(dotDir, 'AGENTS.md'),
+      path.join(dotDir, 'skills'),
+      path.join(dotDir, 'agents'),
+    ],
+  };
+}
+
+module.exports = { importOpenCodeConfig };

package/runtime/scripts/amalgm-mcp/agent-config/renderers/hooks.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const { normalizeAgentConfig } = require('../schema');
+
+function enabledCommandHooks(config) {
+  return normalizeAgentConfig(config).hooks
+    .filter((hook) => hook.enabled !== false && hook.type === 'command' && hook.command);
+}
+
+function hookEvent(hook, fallback = 'UserPromptSubmit') {
+  return hook.event || hook.phase || fallback;
+}
+
+function toNativeHookEntry(hook) {
+  return {
+    ...(hook.matcher ? { matcher: hook.matcher } : {}),
+    hooks: [{
+      type: 'command',
+      command: hook.command,
+      ...(hook.timeout ? { timeout: hook.timeout } : {}),
+      ...(hook.statusMessage ? { statusMessage: hook.statusMessage } : {}),
+    }],
+  };
+}
+
+function toHookMap(config) {
+  const out = {};
+  for (const hook of enabledCommandHooks(config)) {
+    const event = hookEvent(hook);
+    out[event] ||= [];
+    out[event].push(toNativeHookEntry(hook));
+  }
+  return out;
+}
+
+function toClaudeSettings(config) {
+  const hooks = toHookMap(config);
+  return Object.keys(hooks).length > 0 ? { hooks } : {};
+}
+
+function toCodexHooksJson(config) {
+  return JSON.stringify({ hooks: toHookMap(config) }, null, 2) + '\n';
+}
+
+function hasHooks(config) {
+  return enabledCommandHooks(config).length > 0;
+}
+
+module.exports = {
+  enabledCommandHooks,
+  hasHooks,
+  toClaudeSettings,
+  toCodexHooksJson,
+  toHookMap,
+};

package/runtime/scripts/amalgm-mcp/agent-config/renderers/instructions.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const { normalizeAgentConfig } = require('../schema');
+
+const AGENT_TO_AGENT_PROMPT = [
+  'You are an Amalgm agent. Other first-class Amalgm agents may be available as peers.',
+  'When a task is better handled by a configured peer, use the Amalgm agent-to-agent tool instead of inventing a hidden subagent.',
+].join(' ');
+
+function renderSkills(skills) {
+  const enabled = (Array.isArray(skills) ? skills : []).filter((skill) => skill.enabled !== false);
+  if (enabled.length === 0) return '';
+  const lines = ['Skills available to this agent:'];
+  for (const skill of enabled) {
+    if (skill.content) {
+      lines.push(`- ${skill.name || skill.id}: ${skill.description || 'see skill content below'}`);
+      lines.push('');
+      lines.push(`<skill id="${skill.id}" name="${skill.name || skill.id}">`);
+      lines.push(skill.content.trim());
+      lines.push('</skill>');
+    } else {
+      lines.push(`- ${skill.name || skill.id}${skill.description ? `: ${skill.description}` : ''}`);
+    }
+  }
+  return `<agent-skills>\n${lines.join('\n')}\n</agent-skills>`;
+}
+
+function renderSubagents(subagents) {
+  const enabled = (Array.isArray(subagents) ? subagents : []).filter((subagent) => subagent.enabled !== false);
+  if (enabled.length === 0) return '';
+  const lines = [
+    'Peer agents available through the Amalgm agent-to-agent tool:',
+    ...enabled.map((subagent) => (
+      `- ${subagent.name || subagent.agentId} (${subagent.agentId})${subagent.description ? `: ${subagent.description}` : ''}`
+    )),
+  ];
+  return `<agent-peers>\n${lines.join('\n')}\n</agent-peers>`;
+}
+
+function renderAgentInstructions(config, options = {}) {
+  const normalized = normalizeAgentConfig(config);
+  const chunks = [
+    normalized.instructions,
+    options.includeAgentToAgentPrompt === false ? '' : AGENT_TO_AGENT_PROMPT,
+    renderSkills(normalized.skills),
+    renderSubagents(normalized.subagents),
+  ];
+  return chunks.map((chunk) => String(chunk || '').trim()).filter(Boolean).join('\n\n');
+}
+
+module.exports = {
+  AGENT_TO_AGENT_PROMPT,
+  renderAgentInstructions,
+};

package/runtime/scripts/amalgm-mcp/agent-config/rest.js

@@ -0,0 +1,168 @@
+'use strict';
+
+const {
+  createAgent,
+  resolveAgent,
+  resolveAgentByNameOrId,
+  updateAgent,
+} = require('../agents/store');
+const { importNativeConfigForHarness } = require('./importers');
+const {
+  getAgentConfig,
+  legacyFieldsFromConfig,
+  upsertAgentConfig,
+} = require('./store');
+const {
+  normalizeAgentConfig,
+  stableId,
+} = require('./schema');
+
+function mergeById(existing, incoming) {
+  const byId = new Map();
+  for (const item of Array.isArray(existing) ? existing : []) byId.set(item.id, item);
+  for (const item of Array.isArray(incoming) ? incoming : []) byId.set(item.id, item);
+  return [...byId.values()];
+}
+
+function mergeSubagents(existing, incoming) {
+  const byAgentId = new Map();
+  for (const item of Array.isArray(existing) ? existing : []) byAgentId.set(item.agentId, item);
+  for (const item of Array.isArray(incoming) ? incoming : []) byAgentId.set(item.agentId, item);
+  return [...byAgentId.values()];
+}
+
+function mergeImportedConfig(existing, imported, subagents, replace) {
+  if (replace) {
+    return normalizeAgentConfig({
+      ...existing,
+      ...imported,
+      subagents,
+    }, existing);
+  }
+  return normalizeAgentConfig({
+    ...existing,
+    instructions: existing.instructions || imported.instructions || '',
+    skills: mergeById(existing.skills, imported.skills),
+    hooks: mergeById(existing.hooks, imported.hooks),
+    subagents: mergeSubagents(existing.subagents, subagents),
+  }, existing);
+}
+
+function importedAgentId(parentAgent, nativeAgent) {
+  const seed = `${parentAgent.id}-${nativeAgent.name || 'subagent'}`;
+  return stableId('imported-agent', seed);
+}
+
+function ensureImportedAgent(parentAgent, nativeAgent) {
+  const id = importedAgentId(parentAgent, nativeAgent);
+  const existing = resolveAgent(id) || resolveAgentByNameOrId(nativeAgent.name);
+  if (existing) {
+    const config = upsertAgentConfig(existing.id, {
+      instructions: nativeAgent.instructions || existing.systemPrompt || '',
+      tools: existing.tools || { mode: 'all', selectedToolIds: [] },
+      skills: existing.skills || [],
+    }, { source: 'agent-config:import-native-subagent' });
+    return { agent: { ...existing, config }, created: false };
+  }
+  const agent = createAgent({
+    id,
+    name: nativeAgent.name,
+    description: nativeAgent.description || '',
+    baseHarnessId: nativeAgent.baseHarnessId || parentAgent.baseHarnessId,
+    baseModelId: parentAgent.baseModelId || '',
+    modelSettings: parentAgent.modelSettings,
+    systemPrompt: nativeAgent.instructions || '',
+    skills: [],
+    tools: { mode: 'all', selectedToolIds: [] },
+    authMethod: parentAgent.authMethod,
+  }, { source: 'agent-config:import-native-subagent' });
+  const config = upsertAgentConfig(agent.id, {
+    runtimeHomeLayout: 'per-agent',
+    instructions: nativeAgent.instructions || '',
+    skills: [],
+    tools: { mode: 'all', selectedToolIds: [] },
+  }, { source: 'agent-config:import-native-subagent' });
+  return { agent: { ...agent, config }, created: true };
+}
+
+function syncLegacyAgentFields(agentId, config) {
+  const legacy = legacyFieldsFromConfig(config);
+  try {
+    updateAgent(agentId, legacy, { source: 'agent-config:sync-legacy-fields' });
+  } catch {
+    // Config is the source of truth; legacy sync is best-effort for older UI paths.
+  }
+}
+
+async function handleGet(body, sendJson) {
+  const { agent_id } = body || {};
+  if (!agent_id) return sendJson(400, { error: 'agent_id is required' });
+  const agent = resolveAgent(agent_id);
+  if (!agent) return sendJson(404, { error: `Agent not found: ${agent_id}` });
+  return sendJson(200, { config: getAgentConfig(agent) });
+}
+
+async function handleUpdate(body, sendJson) {
+  const { agent_id, config } = body || {};
+  if (!agent_id) return sendJson(400, { error: 'agent_id is required' });
+  const agent = resolveAgent(agent_id);
+  if (!agent) return sendJson(404, { error: `Agent not found: ${agent_id}` });
+  let saved;
+  try {
+    saved = upsertAgentConfig(agent_id, config || {}, { source: 'agent-config:update-rest' });
+    syncLegacyAgentFields(agent_id, saved);
+  } catch (error) {
+    return sendJson(400, { error: error.message || 'Failed to update agent config' });
+  }
+  return sendJson(200, { ok: true, config: saved });
+}
+
+async function handleImportNative(body, sendJson) {
+  const { agent_id, replace } = body || {};
+  if (!agent_id) return sendJson(400, { error: 'agent_id is required' });
+  const agent = resolveAgent(agent_id);
+  if (!agent) return sendJson(404, { error: `Agent not found: ${agent_id}` });
+
+  let imported;
+  try {
+    imported = importNativeConfigForHarness(agent.baseHarnessId);
+  } catch (error) {
+    return sendJson(400, { error: error.message || 'Failed to import native config' });
+  }
+
+  const importedAgents = [];
+  const subagentRefs = [];
+  for (const nativeAgent of imported.agents || []) {
+    const result = ensureImportedAgent(agent, nativeAgent);
+    importedAgents.push(result);
+    subagentRefs.push({
+      id: stableId('subagent', result.agent.id),
+      agentId: result.agent.id,
+      name: result.agent.name || nativeAgent.name || '',
+      description: result.agent.description || nativeAgent.description || '',
+      enabled: true,
+      source: nativeAgent.source || { kind: 'native-import', provider: agent.baseHarnessId },
+    });
+  }
+
+  const existing = getAgentConfig(agent);
+  const merged = mergeImportedConfig(existing, imported.config || {}, subagentRefs, replace === true);
+  const saved = upsertAgentConfig(agent.id, merged, { source: 'agent-config:import-native' });
+  syncLegacyAgentFields(agent.id, saved);
+
+  return sendJson(200, {
+    ok: true,
+    config: saved,
+    importedAgents: importedAgents.map((entry) => ({
+      created: entry.created,
+      agent: entry.agent,
+    })),
+    sources: imported.sources || [],
+  });
+}
+
+module.exports = {
+  handleGet,
+  handleImportNative,
+  handleUpdate,
+};