amalgm 0.1.72 → 0.1.73

package/runtime/scripts/amalgm-mcp/automations/tool-actions.js

@@ -1,13 +1,27 @@
 'use strict';
 
-const { readToolbox } = require('../toolbox/store');
-const { toolboxMcpToolName } = require('../toolbox/runner');
+const { toolboxMcpToolName } = require('../toolbox/names');
+const {
+  defaultToolboxService: toolboxService,
+} = require('../toolbox/service');
 
-function coreTools() {
+function firstPartyToolGroups() {
   return [
-    ...require('../notify'),
-    ...require('../agents/tools'),
-    ...require('../apps/tools'),
+    {
+      id: 'amalgm.notifications',
+      kind: 'first_party',
+      tools: require('../notify'),
+    },
+    {
+      id: 'amalgm.agents',
+      kind: 'first_party',
+      tools: require('../agents/tools'),
+    },
+    {
+      id: 'amalgm.apps',
+      kind: 'first_party',
+      tools: require('../apps/tools'),
+    },
   ];
 }
 
@@ -19,35 +33,27 @@ function normalizeRef(value) {
   return String(value || '').trim().toLowerCase().replace(/[^a-z0-9]+/g, '');
 }
 
-function isRunnableToolboxTool(tool) {
-  return !!tool
-    && tool.status === 'enabled'
-    && tool.origin !== 'system'
-    && (tool.type === 'cli' || tool.type === 'api');
-}
-
-function resolveAmalgmCoreTool(actionName) {
-  const normalized = String(actionName || '').trim();
-  return coreTools().find((tool) => (
-    tool.name === normalized
-    || tool.name === normalized.replace(/\./g, '_')
-  )) || null;
+function resolveFirstPartyToolAction(toolId, actionName) {
+  const normalizedToolId = String(toolId || '').trim();
+  const normalizedActionName = String(actionName || '').trim();
+  const group = firstPartyToolGroups().find((candidate) => candidate.id === normalizedToolId);
+  if (!group) return null;
+  const tool = group.tools.find((candidate) => (
+    candidate.name === normalizedActionName
+    || candidate.name === normalizedActionName.replace(/\./g, '_')
+  ));
+  if (!tool) return null;
+  return {
+    kind: 'first_party',
+    ref: actionKey(group.id, tool.name),
+    toolId: group.id,
+    actionName: tool.name,
+    tool,
+  };
 }
 
 function resolveToolboxAction(toolId, actionName) {
-  const normalizedToolId = String(toolId || '').trim();
-  const normalizedActionName = String(actionName || '').trim();
-  const toolbox = readToolbox();
-  const action = Object.values(toolbox.toolActions || {}).find((candidate) => {
-    if (candidate.toolId !== normalizedToolId) return false;
-    return candidate.name === normalizedActionName
-      || candidate.id === normalizedActionName
-      || candidate.id === `${normalizedToolId}.${normalizedActionName}`
-      || candidate.id === `${normalizedToolId}:${normalizedActionName}`;
-  });
-  if (!action || action.status !== 'enabled') return null;
-  const tool = toolbox.tools?.[action.toolId];
-  return isRunnableToolboxTool(tool) ? { tool, action } : null;
+  return toolboxService.resolveRunnableAction(toolId, actionName);
 }
 
 function resolveWorkflowToolAction(toolId, actionName) {
@@ -62,17 +68,9 @@ function resolveWorkflowToolAction(toolId, actionName) {
       description: 'Fetch a URL from a workflow; requires allowlist.network=true at runtime.',
     };
   }
-  if (normalizedToolId === 'amalgm') {
-    const tool = resolveAmalgmCoreTool(normalizedActionName);
-    if (!tool) return null;
-    return {
-      kind: 'amalgm',
-      ref: actionKey('amalgm', tool.name),
-      toolId: 'amalgm',
-      actionName: tool.name,
-      tool,
-    };
-  }
+  const firstParty = resolveFirstPartyToolAction(normalizedToolId, normalizedActionName);
+  if (firstParty) return firstParty;
+
   const resolved = resolveToolboxAction(normalizedToolId, normalizedActionName);
   if (!resolved) return null;
   return {
@@ -86,7 +84,6 @@ function resolveWorkflowToolAction(toolId, actionName) {
 }
 
 function workflowActionSummaries() {
-  const toolbox = readToolbox();
   const actions = [{
     ref: 'http.fetch',
     id: 'http.fetch',
@@ -96,20 +93,20 @@ function workflowActionSummaries() {
     description: 'Fetch a URL; requires allowlist.network=true.',
   }];
 
-  for (const tool of coreTools()) {
-    actions.push({
-      ref: actionKey('amalgm', tool.name),
-      id: actionKey('amalgm', tool.name),
-      toolId: 'amalgm',
-      actionName: tool.name,
-      kind: 'amalgm',
-      description: tool.description || '',
-    });
+  for (const group of firstPartyToolGroups()) {
+    for (const tool of group.tools) {
+      actions.push({
+        ref: actionKey(group.id, tool.name),
+        id: actionKey(group.id, tool.name),
+        toolId: group.id,
+        actionName: tool.name,
+        kind: 'first_party',
+        description: tool.description || '',
+      });
+    }
   }
 
-  for (const action of Object.values(toolbox.toolActions || {})) {
-    const tool = toolbox.tools?.[action.toolId];
-    if (!isRunnableToolboxTool(tool) || action.status !== 'enabled') continue;
+  for (const { tool, action } of toolboxService.listRunnableActions()) {
     actions.push({
       ref: actionKey(tool.id, action.name),
       id: action.id,
@@ -168,7 +165,7 @@ function validateWorkflowToolActions(ir) {
 }
 
 module.exports = {
-  resolveAmalgmCoreTool,
+  resolveFirstPartyToolAction,
   resolveToolboxAction,
   resolveWorkflowToolAction,
   suggestWorkflowToolActions,

package/runtime/scripts/amalgm-mcp/automations/tools.js

@@ -24,10 +24,10 @@ const WORKFLOW_DESCRIPTION = [
   'The script is the workflow. A trigger decides when it runs; cells decide what happens.',
   'Workflow `trigger` refs are `source.event` strings such as `github.push`; `github.*` means any GitHub event; `*.push` means a push from any source; `*.*` means any source and event.',
   'Cells can call `code(name, fn)`, gated local `cli(name, config)`, gated `http(name, config)`, and `tool(name, "tool.action", args)`.',
-  'Agents are tools too: use `agent(name, agentIdOrName, { prompt, run_in_background: true })` or `tool(name, "amalgm.talk_to_agent", args)`.',
+  'Agents are tools too: use `agent(name, agentIdOrName, { prompt, run_in_background: true })` or `tool(name, "amalgm.agents.talk_to_agent", args)`.',
   'Every function receives one ctx object: `{ automation, trigger, workflow, event, payload, headers, previous, outputs, cells, secrets, stop }`.',
   'Cell outputs are available as `ctx.cells.cellName.output`, `ctx.cells.cellName.field` for object outputs, `ctx.outputs.cellName`, and top-level `ctx.cellName`.',
-  'Example: `tool("notify", "amalgm.notify_user", ({ cells }) => ({ message: cells.greet.output.message }))`.',
+  'Example: `tool("notify", "amalgm.notifications.notify_user", ({ cells }) => ({ message: cells.greet.output.message }))`.',
 ].join('\n\n');
 
 function compactAutomation(automation, includeWorkflowText = true) {
@@ -180,12 +180,12 @@ module.exports = [
   {
     name: 'automations_list_actions',
     description:
-      'List workflow-callable tool actions for automation scripts. Use these refs in workflow cells like `tool("name", "tool.ref", args)`. This includes built-in `http.fetch`, Amalgm actions such as `amalgm.notify_user`, and runnable Toolbox CLI/API actions.',
+      'List workflow-callable tool actions for automation scripts. Use these refs in workflow cells like `tool("name", "tool.ref", args)`. This includes built-in `http.fetch`, first-party Toolbox actions such as `amalgm.notifications.notify_user`, and runnable Toolbox CLI/API actions.',
     inputSchema: {
       type: 'object',
       properties: {
         query: { type: 'string', description: 'Optional case-insensitive filter across ref, id, name, and description.' },
-        kind: { type: 'string', enum: ['builtin', 'amalgm', 'toolbox'], description: 'Optional action kind filter.' },
+        kind: { type: 'string', enum: ['builtin', 'first_party', 'toolbox'], description: 'Optional action kind filter.' },
       },
     },
     async handler({ query, kind } = {}) {

package/runtime/scripts/amalgm-mcp/email/inbound.js

@@ -41,6 +41,24 @@ function asString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
 }
 
+function normalizeStringList(values) {
+  if (!Array.isArray(values)) return [];
+  return [...new Set(values
+    .filter((value) => typeof value === 'string')
+    .map((value) => value.trim())
+    .filter(Boolean))];
+}
+
+function sessionToolConfig(metadata) {
+  const tools = metadata?.tools && typeof metadata.tools === 'object' && !Array.isArray(metadata.tools)
+    ? metadata.tools
+    : {};
+  return {
+    mode: tools.mode === 'selected' ? 'selected' : 'all',
+    toolIds: normalizeStringList(tools.selectedToolIds),
+  };
+}
+
 function normalizeSubject(subject) {
   const trimmed = asString(subject) || 'Amalgm reply';
   return /^re:/i.test(trimmed) ? trimmed : `Re: ${trimmed}`;
@@ -124,6 +142,7 @@ async function handleEmailInbound(body, sendJson) {
   const defaultAuthMethod = asString(metadata.authMethod) || resolveDefaultAuthMethod(baseHarnessId);
   const cwd = asString(metadata.cwd) || DEFAULT_CWD;
   const computerId = asString(metadata.computerId);
+  const toolConfig = sessionToolConfig(metadata);
 
   const normalizedChatInput = normalizeChatInput({
     parts: [{ type: 'text', text: prompt }],
@@ -136,6 +155,8 @@ async function handleEmailInbound(body, sendJson) {
     },
     tools: {
       mcpAppIds: Array.isArray(metadata.mcpAppIds) ? metadata.mcpAppIds : [],
+      mode: toolConfig.mode,
+      toolIds: toolConfig.toolIds,
     },
     execution: {
       cwd,

package/runtime/scripts/amalgm-mcp/events/internal-workflows.js

@@ -28,7 +28,7 @@ function engineNpmPublishWorkflow(repoPath) {
   allowlist: {
     localCompute: true,
     secrets: ["NODE_AUTH_TOKEN"],
-    actions: ["amalgm.notify_user"]
+    actions: ["amalgm.notifications.notify_user"]
   },
 
   limits: {
@@ -116,7 +116,7 @@ function engineNpmPublishWorkflow(repoPath) {
       timeoutMs: 600000
     }),
 
-    tool("notify_user", "amalgm", "notify_user", {
+    tool("notify_user", "amalgm.notifications.notify_user", {
       subject: "amalgm npm publish complete",
       level: "success",
       message: ({ outputs }) => {
@@ -153,7 +153,7 @@ function internalWorkflowSeeds() {
       allowlist: {
         localCompute: true,
         secrets: ['NODE_AUTH_TOKEN'],
-        actions: ['amalgm.notify_user'],
+        actions: ['amalgm.notifications.notify_user'],
       },
       limits: {
         maxConcurrentRuns: 1,

package/runtime/scripts/amalgm-mcp/index.js

@@ -19,7 +19,9 @@
  *   agents/                     agents CRUD + talk_to_agent
  *   browser/                    visible Electron browser tools + agent-browser fallback
  *   notify/                     notify_user (email via proxy)
- *   server/                     MCP JSON-RPC dispatch + HTTP route table
+ *   server/                     HTTP service boundaries + MCP adapter plumbing
+ *   services/                   optional standalone process entrypoints for
+ *                               control-plane, MCP adapter, and worker
  */
 
 async function ensureProxyToken() {

package/runtime/scripts/amalgm-mcp/lib/prefs.js

@@ -365,6 +365,20 @@ function reasoningEffortForSelection(harnessId, modelId, normalizedEffort) {
   return normalizeReasoningEffort(settings.effort || settings.reasoningEffort || settings.reasoning) || 'xhigh';
 }
 
+function getModelSettingsForSelection(harnessId, modelId) {
+  const normalizedModelId = normalizeModelSelection(harnessId, modelId).modelId || modelId;
+  const settingsKey = harnessId === 'codex'
+    ? codexModelSettingsKey(normalizedModelId)
+    : normalizedModelId;
+  const settings =
+    (settingsKey && _modelSettings[settingsKey]) ||
+    (modelId && _modelSettings[modelId]) ||
+    null;
+  return isPlainObject(settings) && Object.keys(settings).length > 0
+    ? { ...settings }
+    : null;
+}
+
 function preferredWorkspaceCwd() {
   try {
     const { listWorkspaces } = require('../workspace/store');
@@ -635,6 +649,7 @@ module.exports = {
   writeUserPreferences,
   updateUserPreferences,
   getSelectedModel,
+  getModelSettingsForSelection,
   getPreferredAuthMethod,
   resolveModelSelection,
 };

package/runtime/scripts/amalgm-mcp/mcp-connections/rest.js

@@ -8,7 +8,9 @@ const os = require('os');
 const path = require('path');
 const { AMALGM_DIR } = require('../config');
 const { appendStateEvent } = require('../state/events');
-const { deleteTool, upsertTool } = require('../toolbox/store');
+const {
+  defaultToolboxService: toolboxService,
+} = require('../toolbox/service');
 
 const CONNECTIONS_FILE = path.join(AMALGM_DIR, 'mcp-connections.json');
 const CLAUDE_FILE = path.join(os.homedir(), '.claude.json');
@@ -139,7 +141,7 @@ function mirrorConnectionToToolbox(appId, conn) {
       url: conn?.instanceUrl || conn?.config?.url,
     };
 
-  upsertTool({
+  toolboxService.registerTool({
     id: app?.id || appId,
     name: app?.name || appId,
     type: 'mcp',
@@ -165,7 +167,7 @@ function mirrorConnectionToToolbox(appId, conn) {
 
 function removeConnectionFromToolbox(appId) {
   try {
-    deleteTool(appId);
+    toolboxService.deleteTool(appId);
   } catch {
     // The toolbox mirror is best-effort; MCP connection removal should still
     // succeed even if a future system connector cannot be deleted.

package/runtime/scripts/amalgm-mcp/runtime-worker.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const {
+  startAutomationScheduler,
+  stopAutomationScheduler,
+} = require('./automations/scheduler');
+
+function createRuntimeWorker(scheduler = {
+  startAutomationScheduler,
+  stopAutomationScheduler,
+}) {
+  let running = false;
+
+  return {
+    get running() {
+      return running;
+    },
+    start() {
+      if (running) return false;
+      scheduler.startAutomationScheduler();
+      running = true;
+      return true;
+    },
+    stop() {
+      if (!running) return false;
+      scheduler.stopAutomationScheduler();
+      running = false;
+      return true;
+    },
+  };
+}
+
+const defaultRuntimeWorker = createRuntimeWorker();
+
+function startRuntimeWorker() {
+  return defaultRuntimeWorker.start();
+}
+
+function stopRuntimeWorker() {
+  return defaultRuntimeWorker.stop();
+}
+
+module.exports = {
+  createRuntimeWorker,
+  startRuntimeWorker,
+  stopRuntimeWorker,
+};

package/runtime/scripts/amalgm-mcp/server/combined-service.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const { createRuntimeHttpServer } = require('./http-service');
+const { createControlPlaneHandler } = require('./control-plane-service');
+const { createMcpHttpHandler } = require('./mcp-http-service');
+
+function createCombinedHandler(options = {}) {
+  const mcpHandler = options.mcpHandler || createMcpHttpHandler(options);
+  const controlPlaneHandler = options.controlPlaneHandler || createControlPlaneHandler(options);
+
+  return async function handleCombinedRequest(ctx) {
+    if (await mcpHandler(ctx)) return true;
+    return controlPlaneHandler(ctx);
+  };
+}
+
+function createCombinedServer(options = {}) {
+  return createRuntimeHttpServer(createCombinedHandler(options), {
+    serviceName: options.serviceName || 'AmalgmMCP',
+    exposeHeaders: options.exposeHeaders,
+  });
+}
+
+module.exports = {
+  createCombinedHandler,
+  createCombinedServer,
+};

package/runtime/scripts/amalgm-mcp/server/control-plane-service.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const { createRuntimeHttpServer } = require('./http-service');
+const { createLocalServiceRouter } = require('./local-service-router');
+
+function createControlPlaneHandler(options = {}) {
+  const serviceRouter = options.serviceRouter || createLocalServiceRouter(options.routeGroups);
+
+  return async function handleControlPlaneRequest(ctx) {
+    return serviceRouter.handle(ctx);
+  };
+}
+
+function createControlPlaneServer(options = {}) {
+  return createRuntimeHttpServer(createControlPlaneHandler(options), {
+    serviceName: options.serviceName || 'AmalgmControlPlane',
+    exposeHeaders: options.exposeHeaders,
+  });
+}
+
+module.exports = {
+  createControlPlaneHandler,
+  createControlPlaneServer,
+};

package/runtime/scripts/amalgm-mcp/server/core-tools.js

@@ -8,12 +8,57 @@
  * circular dependency on the MCP server.
  */
 
-const CORE_TOOLS = [
-  ...require('../automations/tools'),
-  ...require('../notify'),
-  ...require('../agents/tools'),
-  ...require('../apps/tools'),
-  ...require('../browser/tools'),
+function group(id, name, description, tools) {
+  return {
+    id,
+    name,
+    type: 'mcp',
+    owner: 'amalgm',
+    origin: 'system',
+    status: 'enabled',
+    description,
+    tools: tools.map((tool) => ({
+      ...tool,
+      toolboxToolId: id,
+      toolboxActionId: `${id}.${tool.name}`,
+      toolboxActionName: tool.name,
+    })),
+  };
+}
+
+const CORE_TOOL_GROUPS = [
+  group(
+    'amalgm.automations',
+    'Amalgm Automations',
+    'Create, inspect, and run scheduled or event-driven automations.',
+    require('../automations/tools'),
+  ),
+  group(
+    'amalgm.notifications',
+    'Amalgm Notifications',
+    'Notify the user about important results, completions, and failures.',
+    require('../notify'),
+  ),
+  group(
+    'amalgm.agents',
+    'Amalgm Agents',
+    'Discover and talk to other agents on the platform.',
+    require('../agents/tools'),
+  ),
+  group(
+    'amalgm.apps',
+    'Amalgm Apps',
+    'Register, run, and route local-first Amalgm apps.',
+    require('../apps/tools'),
+  ),
+  group(
+    'amalgm.browser',
+    'Amalgm Browser',
+    "Use Amalgm's visible browser session for navigation, interaction, and screenshots.",
+    require('../browser/tools'),
+  ),
 ];
 
-module.exports = { CORE_TOOLS };
+const CORE_TOOLS = CORE_TOOL_GROUPS.flatMap((toolGroup) => toolGroup.tools);
+
+module.exports = { CORE_TOOL_GROUPS, CORE_TOOLS };

package/runtime/scripts/amalgm-mcp/server/http-context.js

@@ -0,0 +1,44 @@
+'use strict';
+
+function requestPathname(req) {
+  return new URL(req.url || '/', 'http://127.0.0.1').pathname;
+}
+
+function requestQuery(req) {
+  return Object.fromEntries(
+    new URL(req.url || '/', 'http://127.0.0.1').searchParams.entries(),
+  );
+}
+
+async function readJsonBody(req) {
+  const chunks = [];
+  for await (const chunk of req) chunks.push(chunk);
+  if (chunks.length === 0) return {};
+  return JSON.parse(Buffer.concat(chunks).toString());
+}
+
+function createHttpContext(req, res) {
+  return {
+    req,
+    res,
+    method: req.method || 'GET',
+    pathname: requestPathname(req),
+    getQuery: () => requestQuery(req),
+    readJsonBody: () => readJsonBody(req),
+    sendJson(statusCode, data) {
+      res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(data));
+    },
+    notFound() {
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      res.end('Not found');
+    },
+  };
+}
+
+module.exports = {
+  createHttpContext,
+  readJsonBody,
+  requestPathname,
+  requestQuery,
+};

package/runtime/scripts/amalgm-mcp/server/http-service.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const http = require('http');
+const { authorizeRuntimeHttp } = require('../../runtime-auth');
+const { createHttpContext } = require('./http-context');
+
+function createRuntimeHttpHandler(routeHandler, options = {}) {
+  const serviceName = options.serviceName || 'AmalgmMCP';
+  const exposeHeaders = options.exposeHeaders === undefined
+    ? 'Mcp-Session-Id'
+    : options.exposeHeaders;
+
+  return async (req, res) => {
+    if (!authorizeRuntimeHttp(req, res, { exposeHeaders })) return;
+    const ctx = createHttpContext(req, res);
+
+    try {
+      if (await routeHandler(ctx)) return;
+      ctx.notFound();
+    } catch (err) {
+      console.error(`[${serviceName}] Unhandled error:`, err);
+      if (!res.headersSent) ctx.sendJson(500, { error: 'Internal server error' });
+    }
+  };
+}
+
+function createRuntimeHttpServer(routeHandler, options = {}) {
+  return http.createServer(createRuntimeHttpHandler(routeHandler, options));
+}
+
+module.exports = {
+  createRuntimeHttpHandler,
+  createRuntimeHttpServer,
+};