amalgm 0.1.135 → 0.1.136

package/runtime/scripts/amalgm-mcp/agent-bundles/automation-entries.js

@@ -0,0 +1,186 @@
+'use strict';
+
+/**
+ * Portable automation bundle entries.
+ *
+ * An exported entry carries only what another machine needs to recreate the
+ * automation: names, trigger shapes, and workflow source text. Machine-bound
+ * state (ids, webhook secrets/URLs, project paths, schedule clocks, run
+ * history) is stripped on export; the recipient's store mints fresh values on
+ * install via the normal createAutomation path.
+ */
+
+const {
+  createAutomation,
+  getAutomation,
+  listAutomations,
+} = require('../automations/store');
+const { resolveWorkflowToolAction } = require('../automations/tool-actions');
+
+function isObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function cloneJson(value) {
+  if (value == null) return value;
+  return JSON.parse(JSON.stringify(value));
+}
+
+function cleanString(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function portableTrigger(trigger) {
+  const base = {
+    kind: trigger.kind === 'scheduled' ? 'scheduled' : 'event',
+    name: trigger.name || '',
+    description: trigger.description || '',
+    enabled: trigger.enabled !== false,
+  };
+  if (base.kind === 'scheduled') {
+    return { ...base, schedule: cloneJson(trigger.schedule) || null };
+  }
+  // Event triggers travel as shapes only. secret and webhookUrl stay behind:
+  // the recipient's normalizeTriggerRecord mints fresh ones on install.
+  return {
+    ...base,
+    source: trigger.source || '*',
+    event: trigger.event || '*',
+    sourceUrl: trigger.sourceUrl || null,
+  };
+}
+
+function portableWorkflow(workflow) {
+  return {
+    name: workflow.name || 'Workflow',
+    description: workflow.description || '',
+    enabled: workflow.enabled !== false,
+    workflowText: workflow.workflowText || '',
+    allowlist: cloneJson(workflow.allowlist) || {},
+    limits: cloneJson(workflow.limits) || {},
+  };
+}
+
+/**
+ * Toolbox tool ids referenced by the automation's compiled workflows. These
+ * become bundled tool records; builtin/first-party refs are platform-provided
+ * and are reported separately so the bundle can list them as system deps.
+ */
+function workflowToolRefs(workflows) {
+  const toolboxToolIds = [];
+  const systemRefs = [];
+  const missingRefs = [];
+  for (const workflow of workflows) {
+    const cells = Array.isArray(workflow.workflowIr?.cells) ? workflow.workflowIr.cells : [];
+    for (const cell of cells) {
+      if (cell.kind !== 'tool') continue;
+      const resolved = resolveWorkflowToolAction(cell.toolId, cell.actionName);
+      const ref = `${cell.toolId}.${cell.actionName}`;
+      if (!resolved) {
+        if (!missingRefs.includes(ref)) missingRefs.push(ref);
+        continue;
+      }
+      if (resolved.kind === 'toolbox') {
+        if (!toolboxToolIds.includes(resolved.toolId)) toolboxToolIds.push(resolved.toolId);
+      } else if (!systemRefs.includes(resolved.ref)) {
+        systemRefs.push(resolved.ref);
+      }
+    }
+  }
+  return { toolboxToolIds, systemRefs, missingRefs };
+}
+
+function exportAutomationEntry(automationId) {
+  const automation = getAutomation(automationId);
+  if (!automation) throw new Error(`Automation not found: ${automationId}`);
+  if (automation.internal === true) {
+    throw new Error(`Internal automations cannot be shared: ${automationId}`);
+  }
+
+  const workflows = (automation.workflows || []).filter((workflow) => workflow?.internal !== true);
+  if (workflows.length === 0) {
+    throw new Error(`Automation has no shareable workflows: ${automationId}`);
+  }
+  const triggers = (automation.triggers || []).filter((trigger) => trigger?.internal !== true);
+  if (triggers.length === 0) {
+    throw new Error(`Automation has no shareable triggers: ${automationId}`);
+  }
+
+  const refs = workflowToolRefs(workflows);
+  return {
+    entry: {
+      sourceAutomationId: automation.id,
+      automation: {
+        name: automation.name || 'Automation',
+        description: automation.description || '',
+      },
+      triggers: triggers.map(portableTrigger),
+      workflows: workflows.map(portableWorkflow),
+      // Toolbox tools the workflows call — bundled alongside so the graph can
+      // draw automation → tool edges and installs carry the dependency.
+      toolIds: refs.toolboxToolIds,
+    },
+    toolboxToolIds: refs.toolboxToolIds,
+    systemRefs: refs.systemRefs,
+    missingRefs: refs.missingRefs,
+  };
+}
+
+function uniqueAutomationName(name) {
+  const base = cleanString(name) || 'Imported automation';
+  const existing = new Set(
+    listAutomations().map((automation) => cleanString(automation.name).toLowerCase()),
+  );
+  if (!existing.has(base.toLowerCase())) return base;
+  const imported = `${base} (imported)`;
+  if (!existing.has(imported.toLowerCase())) return imported;
+  for (let index = 2; index < 1000; index += 1) {
+    const candidate = `${base} (imported ${index})`;
+    if (!existing.has(candidate.toLowerCase())) return candidate;
+  }
+  return `${base} (${Date.now().toString(36)})`;
+}
+
+function assertInstallableEntry(entry) {
+  if (!isObject(entry)) throw new Error('automation entry must be an object');
+  if (!isObject(entry.automation)) throw new Error('automation entry is missing its automation record');
+  if (!Array.isArray(entry.triggers) || entry.triggers.length === 0) {
+    throw new Error('automation entry must include at least one trigger');
+  }
+  if (!Array.isArray(entry.workflows) || entry.workflows.length === 0) {
+    throw new Error('automation entry must include at least one workflow');
+  }
+  for (const workflow of entry.workflows) {
+    if (!cleanString(workflow?.workflowText)) {
+      throw new Error('automation entry workflows must include workflowText');
+    }
+  }
+}
+
+/**
+ * Install a portable automation entry as a new, active local automation.
+ * Workflow text recompiles through createAutomation, event triggers get a
+ * fresh webhook secret/URL from the local store, and everything installs
+ * enabled — a shared automation starts active on the receiving machine.
+ */
+function installAutomationEntry(entry, options = {}) {
+  assertInstallableEntry(entry);
+  return createAutomation({
+    name: uniqueAutomationName(entry.automation.name),
+    description: entry.automation.description || '',
+    enabled: true,
+    triggers: entry.triggers.map((trigger) => ({
+      ...portableTrigger(isObject(trigger) ? trigger : {}),
+      enabled: true,
+    })),
+    workflows: entry.workflows.map((workflow) => ({
+      ...portableWorkflow(isObject(workflow) ? workflow : {}),
+      enabled: true,
+    })),
+  }, { source: options.source || 'agent-bundles:install' });
+}
+
+module.exports = {
+  exportAutomationEntry,
+  installAutomationEntry,
+};

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

@@ -7,14 +7,22 @@ const { normalizeAgentConfig } = require('../agent-config/schema');
 const { createAgent, getAllAgentsWithBuiltins, resolveAgent } = require('../agents/store');
 const { hydrateConfigSkills } = require('../skills/store');
 const { defaultToolboxService } = require('../toolbox/service');
-
-const BUNDLE_KIND = 'amalgm.agent.bundle';
+const { exportAutomationEntry, installAutomationEntry } = require('./automation-entries');
+const { exportAppEntry, installAppEntry } = require('./app-entries');
+
+// Agent-only bundles keep the legacy kind so older runtimes can still install
+// them; bundles that carry automations or apps use the general kind so older
+// runtimes reject them outright instead of silently dropping primitives.
+const BUNDLE_KIND = 'amalgm.bundle';
+const LEGACY_AGENT_BUNDLE_KIND = 'amalgm.agent.bundle';
 const BUNDLE_SCHEMA_VERSION = 1;
 const GRAPH_ELEMENT_ORDER = {
   agent: 0,
-  tool: 1,
-  tool_action: 2,
-  skill: 3,
+  automation: 1,
+  app: 2,
+  tool: 3,
+  tool_action: 4,
+  skill: 5,
 };
 
 const SECRET_KEY_PATTERN = /(api[_-]?key|authorization|bearer|cookie|password|passwd|secret|token|credential|private[_-]?key)/i;
@@ -196,6 +204,37 @@ function collectSkillRecords(bundleAgents) {
   return [...byKey.values()];
 }
 
+function automationEntryId(entry) {
+  return isObject(entry) ? cleanEntryId(entry.sourceAutomationId) : '';
+}
+
+function appEntryId(entry) {
+  return isObject(entry) ? cleanEntryId(entry.sourceAppId) : '';
+}
+
+function cleanEntryId(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+/**
+ * App elements carry the portable record and a file manifest; file contents
+ * stay in bundle.apps[] so the graph remains cheap to render.
+ */
+function appElementData(entry) {
+  return {
+    sourceAppId: appEntryId(entry),
+    app: cloneJson(entry.app || {}),
+    files: (Array.isArray(entry.files) ? entry.files : []).map((file) => ({
+      path: file.path,
+      size: file.size,
+      encoding: file.encoding,
+      ...(file.executable ? { executable: true } : {}),
+    })),
+    totalBytes: entry.totalBytes || 0,
+    skipped: cloneJson(entry.skipped || []),
+  };
+}
+
 function buildFlatAgentBundleGraph(bundle) {
   const elements = new Map();
   const edges = new Map();
@@ -220,6 +259,28 @@ function buildFlatAgentBundleGraph(bundle) {
     });
   }
 
+  for (const entry of bundle.automations || []) {
+    const currentAutomationId = automationEntryId(entry);
+    if (!currentAutomationId) continue;
+    pushGraphElement(elements, {
+      id: graphElementId('automation', currentAutomationId),
+      type: 'automation',
+      label: entry.automation?.name || currentAutomationId,
+      data: cloneJson(entry),
+    });
+  }
+
+  for (const entry of bundle.apps || []) {
+    const currentAppId = appEntryId(entry);
+    if (!currentAppId) continue;
+    pushGraphElement(elements, {
+      id: graphElementId('app', currentAppId),
+      type: 'app',
+      label: entry.app?.name || currentAppId,
+      data: appElementData(entry),
+    });
+  }
+
   for (const skill of skills) {
     const elementId = skillElementId(skill);
     if (!elementId) continue;
@@ -233,6 +294,19 @@ function buildFlatAgentBundleGraph(bundle) {
 
   const includedToolIds = new Set();
   const includedActionIds = new Set();
+
+  for (const entry of bundle.automations || []) {
+    const currentAutomationId = automationEntryId(entry);
+    if (!currentAutomationId) continue;
+    for (const toolId of uniqueStrings(entry.toolIds)) {
+      includedToolIds.add(toolId);
+      pushGraphEdge(edges, {
+        from: graphElementId('automation', currentAutomationId),
+        to: graphElementId('tool', toolId),
+        kind: 'uses-tool',
+      });
+    }
+  }
   for (const entry of bundle.agents || []) {
     const currentAgentId = agentEntryId(entry);
     if (!currentAgentId) continue;
@@ -311,18 +385,46 @@ function buildFlatAgentBundleGraph(bundle) {
     });
   }
 
-  const firstAgentId = agentEntryId(bundle.agents?.[0]);
-  const rootAgentId = typeof bundle.rootAgentId === 'string' && bundle.rootAgentId.trim()
-    ? bundle.rootAgentId.trim()
-    : firstAgentId;
-
   return {
-    headIds: rootAgentId ? [graphElementId('agent', rootAgentId)] : [],
+    headIds: bundleHeadIds(bundle, elements),
     elements: [...elements.values()].sort(compareGraphElements),
     edges: [...edges.values()].sort(compareGraphEdges),
   };
 }
 
+/**
+ * Heads are the user-facing roots of the bundle. Explicit bundle.heads win;
+ * otherwise fall back to the legacy single agent root plus every automation
+ * and app entry (those are always top-level).
+ */
+function bundleHeadIds(bundle, elements) {
+  const headIds = [];
+  const explicitHeads = Array.isArray(bundle.heads) ? bundle.heads : [];
+  for (const head of explicitHeads) {
+    const type = cleanEntryId(head?.type);
+    const id = cleanEntryId(head?.id);
+    if (!type || !id) continue;
+    const elementId = graphElementId(type, id);
+    if (elements.has(elementId) && !headIds.includes(elementId)) headIds.push(elementId);
+  }
+  if (headIds.length > 0) return headIds;
+
+  const firstAgentId = agentEntryId(bundle.agents?.[0]);
+  const rootAgentId = cleanEntryId(bundle.rootAgentId) || firstAgentId;
+  if (rootAgentId && elements.has(graphElementId('agent', rootAgentId))) {
+    headIds.push(graphElementId('agent', rootAgentId));
+  }
+  for (const entry of bundle.automations || []) {
+    const id = automationEntryId(entry);
+    if (id) headIds.push(graphElementId('automation', id));
+  }
+  for (const entry of bundle.apps || []) {
+    const id = appEntryId(entry);
+    if (id) headIds.push(graphElementId('app', id));
+  }
+  return [...new Set(headIds)];
+}
+
 function assertClosedFlatBundleGraph(bundle) {
   if (!Array.isArray(bundle.headIds) || bundle.headIds.length === 0) {
     throw new Error('bundle graph must include at least one head');
@@ -427,18 +529,67 @@ function collectAgentGraph(rootAgentId) {
   return ordered;
 }
 
-function createAgentBundle(agentId, options = {}) {
-  if (!agentId) throw new Error('agent_id is required');
-  const agents = collectAgentGraph(agentId);
+function bundleTitleAndDescription(agents, automations, apps) {
+  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 || '' };
+  }
+  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);
+  if (agentIds.length === 0 && automationIds.length === 0 && appIds.length === 0) {
+    throw new Error('At least one agent, automation, or app 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);
@@ -446,25 +597,52 @@ function createAgentBundle(agentId, options = {}) {
     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);
+  }
+
+  const apps = [];
+  let skippedAppFiles = 0;
+  for (const appId of appIds) {
+    const exported = exportAppEntry(appId);
+    apps.push(exported.entry);
+    skippedAppFiles += exported.skipped.length;
+  }
+
   const { tools, toolActions } = collectToolRecords(loadoutToolIds, requires);
   const skills = collectSkillRecords(agents);
   const hooks = countHooks(agents);
-  const warnings = [
-    '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.length > 0 ? ['Tools can call external services or local commands. Recipients should reconnect credentials on their own machine.'] : []),
+  const warnings = bundleWarnings({
+    hooks,
+    tools: tools.length,
+    automations: automations.length,
+    apps: apps.length,
+    skippedAppFiles,
+  });
+  const { title, description } = bundleTitleAndDescription(agents, automations, apps);
+  const heads = [
+    ...agentIds.map((id) => ({ type: 'agent', id })),
+    ...automationIds.map((id) => ({ type: 'automation', id })),
+    ...appIds.map((id) => ({ type: 'app', id })),
   ];
 
   const bundle = withBundleGraph({
-    kind: BUNDLE_KIND,
+    kind: automations.length > 0 || apps.length > 0 ? BUNDLE_KIND : LEGACY_AGENT_BUNDLE_KIND,
     schemaVersion: BUNDLE_SCHEMA_VERSION,
     bundleId: options.bundleId || bundleId(),
     createdAt: nowIso(),
-    rootAgentId: agents[0]?.sourceAgentId || agentId,
-    title: agents[0]?.agent?.name || 'Shared agent',
-    description: agents[0]?.agent?.description || '',
+    rootAgentId: agents[0]?.sourceAgentId || null,
+    heads,
+    title,
+    description,
     agents,
+    automations,
+    apps,
     tools,
     toolActions,
     skills,
@@ -473,6 +651,8 @@ function createAgentBundle(agentId, options = {}) {
     warnings,
     summary: {
       agents: agents.length,
+      automations: automations.length,
+      apps: apps.length,
       tools: tools.length,
       toolActions: toolActions.length,
       skills: skills.length,
@@ -502,6 +682,22 @@ function createAgentBundle(agentId, options = {}) {
         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,
@@ -514,6 +710,11 @@ function createAgentBundle(agentId, options = {}) {
   };
 }
 
+function createAgentBundle(agentId, options = {}) {
+  if (!agentId) throw new Error('agent_id is required');
+  return createBundle({ agentIds: [agentId] }, options);
+}
+
 function uniqueAgentName(name) {
   const base = String(name || 'Imported agent').trim() || 'Imported agent';
   const existing = new Set(
@@ -568,14 +769,19 @@ function assertClosedAgentBundleGraph(bundle) {
 
 function validateBundle(bundle) {
   if (!isObject(bundle)) throw new Error('bundle must be an object');
-  if (bundle.kind !== BUNDLE_KIND) throw new Error(`Unsupported bundle kind: ${bundle.kind || 'unknown'}`);
+  if (bundle.kind !== BUNDLE_KIND && bundle.kind !== LEGACY_AGENT_BUNDLE_KIND) {
+    throw new Error(`Unsupported bundle kind: ${bundle.kind || 'unknown'}`);
+  }
   if (bundle.schemaVersion !== BUNDLE_SCHEMA_VERSION) {
     throw new Error(`Unsupported bundle schema version: ${bundle.schemaVersion || 'unknown'}`);
   }
-  if (!Array.isArray(bundle.agents) || bundle.agents.length === 0) {
-    throw new Error('bundle must include at least one agent');
+  const agents = Array.isArray(bundle.agents) ? bundle.agents : [];
+  const automations = Array.isArray(bundle.automations) ? bundle.automations : [];
+  const apps = Array.isArray(bundle.apps) ? bundle.apps : [];
+  if (agents.length === 0 && automations.length === 0 && apps.length === 0) {
+    throw new Error('bundle must include at least one agent, automation, or app');
   }
-  assertClosedAgentBundleGraph(bundle);
+  if (agents.length > 0) assertClosedAgentBundleGraph(bundle);
   return withBundleGraph(bundle);
 }
 
@@ -601,14 +807,12 @@ function installTools(bundle) {
   return installed;
 }
 
-function installAgentBundle(input, options = {}) {
-  const bundle = validateBundle(input);
-  const installedTools = installTools(bundle);
+function installBundleAgents(bundle, options = {}) {
   const idMap = new Map();
   const createdAgents = [];
   const createdAt = nowIso();
 
-  for (const entry of bundle.agents) {
+  for (const entry of Array.isArray(bundle.agents) ? bundle.agents : []) {
     const config = normalizeAgentConfig(entry.config || {});
     const fields = agentFieldsFromConfig(config);
     const agent = createAgent({
@@ -658,6 +862,38 @@ function installAgentBundle(input, options = {}) {
     });
   }
 
+  return { idMap, installedAgents };
+}
+
+function defaultAppsInstallRoot() {
+  const { getWorkspaceRoot } = require('../workspace/rest');
+  return getWorkspaceRoot();
+}
+
+/**
+ * Install every primitive in a validated bundle: tools first (agents and
+ * automations reference them), then agents, automations, and apps. Apps
+ * materialize into the local workspace root, build, and start.
+ */
+async function installBundle(input, options = {}) {
+  const bundle = validateBundle(input);
+  const installedTools = installTools(bundle);
+  const { idMap, installedAgents } = installBundleAgents(bundle, options);
+
+  const installedAutomations = [];
+  for (const entry of Array.isArray(bundle.automations) ? bundle.automations : []) {
+    installedAutomations.push(installAutomationEntry(entry, { source: 'agent-bundles:install' }));
+  }
+
+  const installedApps = [];
+  const appEntries = Array.isArray(bundle.apps) ? bundle.apps : [];
+  if (appEntries.length > 0) {
+    const rootDir = options.appsRootDir || defaultAppsInstallRoot();
+    for (const entry of appEntries) {
+      installedApps.push(await installAppEntry(entry, { rootDir, register: options.registerApp }));
+    }
+  }
+
   return {
     ok: true,
     bundleId: bundle.bundleId,
@@ -665,6 +901,8 @@ function installAgentBundle(input, options = {}) {
     idMap: Object.fromEntries(idMap.entries()),
     installedAgents,
     installedTools,
+    installedAutomations,
+    installedApps,
     warnings: bundle.warnings || [],
   };
 }
@@ -672,7 +910,9 @@ function installAgentBundle(input, options = {}) {
 module.exports = {
   BUNDLE_KIND,
   BUNDLE_SCHEMA_VERSION,
+  LEGACY_AGENT_BUNDLE_KIND,
   createAgentBundle,
-  installAgentBundle,
+  createBundle,
+  installBundle,
   validateBundle,
 };

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

@@ -1,19 +1,36 @@
 'use strict';
 
 const {
-  createAgentBundle,
-  installAgentBundle,
+  createBundle,
+  installBundle,
 } = require('./bundles');
 
+function idList(...values) {
+  const ids = [];
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim()) ids.push(value.trim());
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (typeof item === 'string' && item.trim()) ids.push(item.trim());
+      }
+    }
+  }
+  return [...new Set(ids)];
+}
+
 async function handlePreview(body, sendJson) {
-  const { agent_id: agentId } = body || {};
-  if (!agentId) return sendJson(400, { error: 'agent_id is required' });
+  const agentIds = idList(body?.agent_id, body?.agent_ids);
+  const automationIds = idList(body?.automation_id, body?.automation_ids);
+  const appIds = idList(body?.app_id, body?.app_ids);
+  if (agentIds.length === 0 && automationIds.length === 0 && appIds.length === 0) {
+    return sendJson(400, { error: 'At least one of agent_ids, automation_ids, or app_ids is required' });
+  }
 
   try {
-    const result = createAgentBundle(agentId);
+    const result = createBundle({ agentIds, automationIds, appIds });
     return sendJson(200, { ok: true, ...result });
   } catch (error) {
-    return sendJson(400, { error: error.message || 'Failed to create agent bundle' });
+    return sendJson(400, { error: error.message || 'Failed to create bundle' });
   }
 }
 
@@ -22,10 +39,10 @@ async function handleInstall(body, sendJson) {
   if (!bundle) return sendJson(400, { error: 'bundle is required' });
 
   try {
-    const result = installAgentBundle(bundle, { authMethod });
+    const result = await installBundle(bundle, { authMethod });
     return sendJson(200, result);
   } catch (error) {
-    const message = error.message || 'Failed to install agent bundle';
+    const message = error.message || 'Failed to install bundle';
     return sendJson(message.includes('Unsupported bundle') ? 400 : 500, { error: message });
   }
 }