amalgm 0.1.146 → 0.1.147

package/runtime/scripts/amalgm-mcp/agent-bundles/export.js

@@ -0,0 +1,383 @@
+'use strict';
+
+const crypto = require('crypto');
+
+const { getAgentConfig } = require('../agent-config/store');
+const { normalizeAgentConfig } = require('../agent-config/schema');
+const { resolveAgent } = require('../agents/store');
+const { hydrateConfigSkills } = require('../skills/store');
+const { defaultToolboxService } = require('../toolbox/service');
+const { getApp } = require('../apps/store');
+const { exportAutomationEntry } = require('./automation-entries');
+const { exportAppEntry } = require('./app-entries');
+const { annotateAppBoundPaths } = require('./tool-bindings');
+const {
+  BUNDLE_KIND,
+  BUNDLE_SCHEMA_VERSION,
+  LEGACY_AGENT_BUNDLE_KIND,
+  addUnique,
+  cloneJson,
+  collectSkillRecords,
+  isObject,
+  nowIso,
+  uniqueStrings,
+  withBundleGraph,
+} = require('./graph');
+
+const SECRET_KEY_PATTERN = /(api[_-]?key|authorization|bearer|cookie|password|passwd|secret|token|credential|private[_-]?key)/i;
+
+function bundleId() {
+  return `agent-bundle-${crypto.randomUUID()}`;
+}
+
+function portableAgent(agent) {
+  return {
+    sourceAgentId: agent.id,
+    name: agent.name || agent.id,
+    description: agent.description || '',
+    baseHarnessId: agent.baseHarnessId || agent.adapter || 'codex',
+    baseModelId: agent.baseModelId || '',
+    modelSettings: isObject(agent.modelSettings) ? cloneJson(agent.modelSettings) : null,
+    authMethod: agent.authMethod || 'amalgm',
+  };
+}
+
+function scrubSecrets(value, path, requires) {
+  if (Array.isArray(value)) {
+    return value.map((entry, index) => scrubSecrets(entry, `${path}[${index}]`, requires));
+  }
+  if (!isObject(value)) return value;
+
+  const out = {};
+  for (const [key, child] of Object.entries(value)) {
+    const childPath = path ? `${path}.${key}` : key;
+    if (SECRET_KEY_PATTERN.test(key)) {
+      addUnique(requires.secrets, childPath);
+      continue;
+    }
+    out[key] = scrubSecrets(child, childPath, requires);
+  }
+  return out;
+}
+
+function portableTool(tool, requires) {
+  return scrubSecrets(cloneJson(tool), `tools.${tool.id}`, requires);
+}
+
+function portableAction(action, requires) {
+  return scrubSecrets(cloneJson(action), `toolActions.${action.id}`, requires);
+}
+
+function countHooks(bundleAgents) {
+  return bundleAgents.reduce((count, entry) => (
+    count + (Array.isArray(entry.config?.hooks) ? entry.config.hooks.length : 0)
+  ), 0);
+}
+
+function collectToolRecords(toolIds, requires) {
+  const catalog = defaultToolboxService.readCatalog();
+  const tools = new Map();
+  const actions = new Map();
+  const selected = uniqueStrings(toolIds);
+
+  for (const selectedId of selected) {
+    const selectedTool = catalog.tools?.[selectedId];
+    const selectedAction = catalog.toolActions?.[selectedId];
+    const tool = selectedTool || (selectedAction ? catalog.tools?.[selectedAction.toolId] : null);
+
+    if (!tool) {
+      addUnique(requires.missingTools, selectedId);
+      continue;
+    }
+
+    if (tool.origin === 'system') {
+      addUnique(requires.systemTools, tool.id);
+    }
+
+    if (!tools.has(tool.id)) tools.set(tool.id, portableTool(tool, requires));
+
+    if (selectedAction) {
+      actions.set(selectedAction.id, portableAction(selectedAction, requires));
+    }
+
+    for (const action of Object.values(catalog.toolActions || {})) {
+      if (action?.toolId === tool.id) actions.set(action.id, portableAction(action, requires));
+    }
+  }
+
+  return {
+    tools: [...tools.values()],
+    toolActions: [...actions.values()],
+  };
+}
+
+function collectAgentGraph(rootAgentId) {
+  const seen = new Set();
+  const ordered = [];
+
+  function visit(agentId) {
+    if (!agentId || seen.has(agentId)) return;
+    seen.add(agentId);
+    const agent = resolveAgent(agentId);
+    if (!agent) throw new Error(`Agent not found: ${agentId}`);
+    const config = hydrateConfigSkills(getAgentConfig(agent));
+    ordered.push({
+      sourceAgentId: agent.id,
+      agent: portableAgent(agent),
+      config: normalizeAgentConfig(config),
+    });
+    for (const subagent of config.subagents || []) {
+      if (subagent?.agentId) visit(subagent.agentId);
+    }
+  }
+
+  visit(rootAgentId);
+  return ordered;
+}
+
+function bundleTitleAndDescription(agents, automations, apps, sharedTools) {
+  const firstAgent = agents[0]?.agent;
+  if (firstAgent) {
+    return { title: firstAgent.name || 'Shared agent', description: firstAgent.description || '' };
+  }
+  const firstAutomation = automations[0]?.automation;
+  if (firstAutomation) {
+    return { title: firstAutomation.name || 'Shared automation', description: firstAutomation.description || '' };
+  }
+  const firstApp = apps[0]?.app;
+  if (firstApp) {
+    return { title: firstApp.name || 'Shared app', description: firstApp.description || '' };
+  }
+  const firstTool = sharedTools?.[0];
+  if (firstTool) {
+    return { title: firstTool.name || 'Shared tool', description: firstTool.description || '' };
+  }
+  return { title: 'Shared bundle', description: '' };
+}
+
+function bundleWarnings({ hooks, tools, automations, apps, skippedAppFiles }) {
+  return [
+    'Instructions, skill text, tool descriptions, and hook commands are shared as plain text.',
+    'Secrets pasted into free-text instructions or files are not automatically detected.',
+    ...(hooks > 0 ? ['This bundle includes executable hook definitions. Review commands before importing.'] : []),
+    ...(tools > 0 ? ['Tools can call external services or local commands. Recipients should reconnect credentials on their own machine.'] : []),
+    ...(automations > 0 ? ['This bundle includes automations. Their workflows run code and call tools on the importing machine — review workflow scripts before importing.'] : []),
+    ...(apps > 0 ? ['This bundle includes apps. Their build and start commands execute on install — review commands before importing.'] : []),
+    ...(skippedAppFiles > 0 ? [`${skippedAppFiles} app file${skippedAppFiles === 1 ? ' was' : 's were'} excluded from the bundle (dependencies, build outputs, env files, or size limits). Builds re-run on install.`] : []),
+  ];
+}
+
+/**
+ * Build a portable bundle from any mix of top-level primitives. Each requested
+ * id becomes a head; agents pull in their full subagent graph, and agents and
+ * automations pull in the toolbox tools they reference.
+ */
+function createBundle(input = {}, options = {}) {
+  const agentIds = uniqueStrings(input.agentIds);
+  const automationIds = uniqueStrings(input.automationIds);
+  const appIds = uniqueStrings(input.appIds);
+  const toolIds = uniqueStrings(input.toolIds);
+  if (agentIds.length === 0 && automationIds.length === 0 && appIds.length === 0 && toolIds.length === 0) {
+    throw new Error('At least one agent, automation, app, or tool is required');
+  }
+
+  const requires = {
+    runtimes: [],
+    auth: [],
+    secrets: [],
+    bindings: [],
+    systemTools: [],
+    systemActions: [],
+    missingTools: [],
+  };
+
+  const agents = [];
+  const seenAgentIds = new Set();
+  for (const agentId of agentIds) {
+    for (const entry of collectAgentGraph(agentId)) {
+      if (seenAgentIds.has(entry.sourceAgentId)) continue;
+      seenAgentIds.add(entry.sourceAgentId);
+      agents.push(entry);
+    }
+  }
+
+  const loadoutToolIds = [];
+  for (const entry of agents) {
+    addUnique(requires.runtimes, entry.agent.baseHarnessId);
+    addUnique(requires.auth, `${entry.agent.baseHarnessId}:${entry.agent.authMethod || 'amalgm'}`);
+    loadoutToolIds.push(...(entry.config.loadout?.toolIds || []));
+  }
+
+  const automations = [];
+  for (const automationId of automationIds) {
+    const exported = exportAutomationEntry(automationId);
+    automations.push(exported.entry);
+    loadoutToolIds.push(...exported.toolboxToolIds);
+    for (const ref of exported.systemRefs) addUnique(requires.systemActions, ref);
+    for (const ref of exported.missingRefs) addUnique(requires.missingTools, ref);
+  }
+
+  // Tool → app closure: an app-owned tool only works next to its app, so any
+  // requested tool whose record points at an app pulls that app in as a
+  // dependency (not a head). Stale pointers degrade to a warning.
+  const appLinkWarnings = [];
+  const dependencyAppIds = [];
+  const catalog = defaultToolboxService.readCatalog();
+  for (const selectedId of uniqueStrings([...loadoutToolIds, ...toolIds])) {
+    const selectedAction = catalog.toolActions?.[selectedId];
+    const tool = catalog.tools?.[selectedId]
+      || (selectedAction ? catalog.tools?.[selectedAction.toolId] : null);
+    const owningAppId = typeof tool?.appId === 'string' ? tool.appId.trim() : '';
+    if (!owningAppId || appIds.includes(owningAppId) || dependencyAppIds.includes(owningAppId)) continue;
+    if (!getApp(owningAppId)) {
+      appLinkWarnings.push(`Tool ${tool.id} belongs to app ${owningAppId}, which no longer exists; the app was not bundled.`);
+      continue;
+    }
+    dependencyAppIds.push(owningAppId);
+  }
+
+  const apps = [];
+  const appCwdBySourceId = new Map();
+  let skippedAppFiles = 0;
+  const appToolIds = [];
+  for (const appId of [...appIds, ...dependencyAppIds]) {
+    const exported = exportAppEntry(appId);
+    apps.push(exported.entry);
+    appCwdBySourceId.set(exported.entry.sourceAppId, exported.sourceCwd);
+    skippedAppFiles += exported.skipped.length;
+    // App → tool closure: tools that belong to a bundled app travel with it.
+    appToolIds.push(...(exported.entry.toolIds || []));
+  }
+
+  const { tools, toolActions } = collectToolRecords([...loadoutToolIds, ...appToolIds, ...toolIds], requires);
+
+  // Tool files that live inside a shared app travel with that app: record
+  // app-relative bindings so install rewrites them to the recipient's copy.
+  // Absolute paths no shared app covers stay machine-bound requirements.
+  for (const record of [...tools, ...toolActions]) {
+    if (record.origin === 'system') continue;
+    const kind = record.toolId ? 'toolAction' : 'tool';
+    const { unbound } = annotateAppBoundPaths(record, appCwdBySourceId);
+    for (const label of unbound) addUnique(requires.bindings, `${kind}:${record.id}:${label}`);
+  }
+  // Standalone tool heads must resolve to a real catalog tool — a dependency
+  // tool that is missing degrades to a placeholder, but a head cannot.
+  const sharedToolIds = toolIds.filter((toolId) => tools.some((tool) => tool.id === toolId));
+  const missingSharedToolIds = toolIds.filter((toolId) => !sharedToolIds.includes(toolId));
+  if (missingSharedToolIds.length > 0) {
+    throw new Error(`Tool not found: ${missingSharedToolIds.join(', ')}`);
+  }
+  const sharedTools = sharedToolIds.map((toolId) => tools.find((tool) => tool.id === toolId));
+  const skills = collectSkillRecords(agents);
+  const hooks = countHooks(agents);
+  const warnings = [
+    ...bundleWarnings({
+      hooks,
+      tools: tools.length,
+      automations: automations.length,
+      apps: apps.length,
+      skippedAppFiles,
+    }),
+    ...appLinkWarnings,
+  ];
+  // Title comes from what the user deliberately shared: dependency apps
+  // pulled in by an app-owned tool must not name the bundle.
+  const headApps = apps.filter((entry) => appIds.includes(entry.sourceAppId));
+  const { title, description } = bundleTitleAndDescription(agents, automations, headApps, sharedTools);
+  const heads = [
+    ...agentIds.map((id) => ({ type: 'agent', id })),
+    ...automationIds.map((id) => ({ type: 'automation', id })),
+    ...appIds.map((id) => ({ type: 'app', id })),
+    ...sharedToolIds.map((id) => ({ type: 'tool', id })),
+  ];
+
+  const bundle = withBundleGraph({
+    kind: automations.length > 0 || apps.length > 0 || sharedToolIds.length > 0
+      ? BUNDLE_KIND
+      : LEGACY_AGENT_BUNDLE_KIND,
+    schemaVersion: BUNDLE_SCHEMA_VERSION,
+    bundleId: options.bundleId || bundleId(),
+    createdAt: nowIso(),
+    rootAgentId: agents[0]?.sourceAgentId || null,
+    heads,
+    title,
+    description,
+    agents,
+    automations,
+    apps,
+    tools,
+    toolActions,
+    skills,
+    assets: [],
+    requires,
+    warnings,
+    summary: {
+      agents: agents.length,
+      automations: automations.length,
+      apps: apps.length,
+      tools: tools.length,
+      toolActions: toolActions.length,
+      skills: skills.length,
+      hooks,
+      assets: 0,
+    },
+  });
+
+  const bytes = Buffer.byteLength(JSON.stringify(bundle));
+  return {
+    bundle,
+    preview: {
+      bundleId: bundle.bundleId,
+      title: bundle.title,
+      description: bundle.description,
+      summary: bundle.summary,
+      requires,
+      warnings,
+      agents: agents.map((entry) => ({
+        sourceAgentId: entry.sourceAgentId,
+        name: entry.agent.name,
+        description: entry.agent.description,
+        baseHarnessId: entry.agent.baseHarnessId,
+        baseModelId: entry.agent.baseModelId,
+        tools: entry.config.loadout?.toolIds?.length || 0,
+        skills: entry.config.skills?.length || 0,
+        subagents: entry.config.subagents?.length || 0,
+        hooks: entry.config.hooks?.length || 0,
+      })),
+      automations: automations.map((entry) => ({
+        sourceAutomationId: entry.sourceAutomationId,
+        name: entry.automation.name,
+        description: entry.automation.description,
+        triggers: entry.triggers.length,
+        workflows: entry.workflows.length,
+        tools: entry.toolIds.length,
+      })),
+      apps: apps.map((entry) => ({
+        sourceAppId: entry.sourceAppId,
+        name: entry.app.name,
+        description: entry.app.description,
+        files: entry.files.length,
+        totalBytes: entry.totalBytes,
+        skippedFiles: entry.skipped.length,
+      })),
+      tools: tools.map((tool) => ({
+        id: tool.id,
+        name: tool.name,
+        type: tool.type,
+        origin: tool.origin,
+        actionCount: toolActions.filter((action) => action.toolId === tool.id).length,
+      })),
+      sizeBytes: bytes,
+    },
+  };
+}
+
+function createAgentBundle(agentId, options = {}) {
+  if (!agentId) throw new Error('agent_id is required');
+  return createBundle({ agentIds: [agentId] }, options);
+}
+
+module.exports = {
+  createAgentBundle,
+  createBundle,
+};