amalgm 0.0.1 → 0.0.33

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

@@ -4,10 +4,10 @@
  * The SDK handles JSON-RPC framing, protocol-version negotiation, batching,
  * and streamable-HTTP transport. We just register the two tool handlers.
  *
- * Each domain module (tasks, events, notify, agents, browser) exports a flat
- * array of { name, description, inputSchema, handler }. We concatenate them
- * into a single TOOLS list, look the tool up by name on each call, and pass
- * the result through unchanged.
+ * Each domain module exports a flat array of
+ * { name, description, inputSchema, handler }. We concatenate the built-in
+ * Amalgm tools with toolbox management tools. Custom CLI/API actions registered
+ * in the ToolboxDB are exposed dynamically through this same MCP transport.
  */
 
 const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
@@ -22,14 +22,15 @@ const {
 const { AMALGM_USER_ID } = require('../config');
 const { hasSupabase, supabaseSelect } = require('../lib/supabase');
 const { attachActionDescriptor } = require('../lib/tool-result');
+const { CORE_TOOLS } = require('./core-tools');
+const {
+  callToolboxMcpTool,
+  listToolboxMcpTools,
+} = require('../toolbox/runner');
 
 const TOOLS = [
-  ...require('../tasks/tools'),
-  ...require('../events/tools'),
-  ...require('../notify'),
-  ...require('../agents/tools'),
-  ...require('../artifacts/tools'),
-  ...require('../browser/tools'),
+  ...CORE_TOOLS,
+  ...require('../toolbox/tools'),
 ];
 
 /**
@@ -49,6 +50,7 @@ async function buildRequestContext(extra) {
     );
     const parent = Array.isArray(rows) ? rows[0] : null;
     if (parent) {
+      ctx.sessionMetadata = parent.metadata || {};
       ctx.originName = parent.title || undefined;
       ctx.originHarnessId = parent.harness || undefined;
       ctx.originBaseHarnessId = parent.metadata?.baseHarnessId || undefined;
@@ -63,19 +65,28 @@ function createMcpServer() {
     { capabilities: { tools: {} } },
   );
 
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: TOOLS.map(({ name, description, inputSchema }) => ({
-      name,
-      description,
-      inputSchema,
-    })),
-  }));
+  server.setRequestHandler(ListToolsRequestSchema, async (_request, extra) => {
+    const ctx = await buildRequestContext(extra);
+    return {
+      tools: [
+        ...TOOLS.map(({ name, description, inputSchema }) => ({
+          name,
+          description,
+          inputSchema,
+        })),
+        ...listToolboxMcpTools(ctx),
+      ],
+    };
+  });
 
   server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
     const toolName = request.params?.name;
     const toolArgs = request.params?.arguments || {};
     const tool = TOOLS.find((t) => t.name === toolName);
     if (!tool) {
+      const ctx = await buildRequestContext(extra);
+      const toolboxResult = await callToolboxMcpTool(toolName, toolArgs, ctx);
+      if (toolboxResult) return attachActionDescriptor(toolboxResult, toolName, toolArgs);
       return attachActionDescriptor({
         content: [{ type: 'text', text: `Unknown tool: ${toolName}` }],
         isError: true,

package/runtime/scripts/amalgm-mcp/state/db.js

@@ -0,0 +1,194 @@
+'use strict';
+
+/**
+ * Local Live Store database.
+ *
+ * SQLite owns the monotonic event sequence. Existing resource stores can keep
+ * their current files while they migrate table-by-table; the realtime contract
+ * is already backed by this WAL database.
+ */
+
+const path = require('path');
+const { ensureDir } = require('../lib/storage');
+const { LOCAL_DB_FILE, STORAGE_DIR } = require('../config');
+
+let db = null;
+
+function getBetterSqlite3() {
+  try {
+    return require('better-sqlite3');
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`better-sqlite3 is required for the Local Live Store: ${message}`);
+  }
+}
+
+function openLocalDb() {
+  if (db) return db;
+
+  ensureDir(path.dirname(LOCAL_DB_FILE || STORAGE_DIR));
+  const Database = getBetterSqlite3();
+  db = new Database(LOCAL_DB_FILE);
+  db.pragma('journal_mode = WAL');
+  db.pragma('synchronous = NORMAL');
+  db.pragma('foreign_keys = ON');
+  db.pragma('busy_timeout = 5000');
+  migrate(db);
+  return db;
+}
+
+function migrate(database = openLocalDb()) {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS event_log (
+      seq INTEGER PRIMARY KEY AUTOINCREMENT,
+      ts TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+      resource TEXT NOT NULL,
+      op TEXT NOT NULL,
+      id TEXT,
+      value_json TEXT,
+      patch_json TEXT,
+      client_mutation_id TEXT,
+      source TEXT,
+      resource_version INTEGER
+    );
+
+    CREATE INDEX IF NOT EXISTS event_log_resource_seq_idx
+      ON event_log(resource, seq);
+
+    CREATE TABLE IF NOT EXISTS tools (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      type TEXT NOT NULL,
+      owner TEXT NOT NULL,
+      origin TEXT NOT NULL,
+      status TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      tool_json TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS tools_status_idx
+      ON tools(status);
+
+    CREATE TABLE IF NOT EXISTS tool_actions (
+      id TEXT PRIMARY KEY,
+      tool_id TEXT NOT NULL,
+      name TEXT NOT NULL,
+      status TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      action_json TEXT NOT NULL,
+      FOREIGN KEY(tool_id) REFERENCES tools(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS tool_actions_tool_id_idx
+      ON tool_actions(tool_id);
+
+    CREATE TABLE IF NOT EXISTS agents (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      adapter TEXT NOT NULL,
+      base_harness_id TEXT NOT NULL,
+      location TEXT NOT NULL,
+      owner_computer_id TEXT,
+      builtin INTEGER NOT NULL DEFAULT 0,
+      deletable INTEGER NOT NULL DEFAULT 1,
+      status TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      agent_json TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS agents_base_harness_id_idx
+      ON agents(base_harness_id);
+
+    CREATE INDEX IF NOT EXISTS agents_owner_computer_id_idx
+      ON agents(owner_computer_id);
+
+    CREATE INDEX IF NOT EXISTS agents_builtin_idx
+      ON agents(builtin);
+  `);
+  migrateLegacyToolboxTables(database);
+  removeInheritedHarnessTools(database);
+}
+
+function tableExists(database, tableName) {
+  const row = database.prepare(
+    "SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?"
+  ).get(tableName);
+  return Boolean(row);
+}
+
+function migrateLegacyToolboxTables(database) {
+  if (tableExists(database, 'toolbox_tools')) {
+    database.prepare(`
+      INSERT OR IGNORE INTO tools (
+        id,
+        name,
+        type,
+        owner,
+        origin,
+        status,
+        updated_at,
+        tool_json
+      )
+      SELECT
+        id,
+        name,
+        type,
+        owner,
+        origin,
+        status,
+        updated_at,
+        tool_json
+      FROM toolbox_tools
+    `).run();
+  }
+
+  if (tableExists(database, 'toolbox_actions')) {
+    database.prepare(`
+      INSERT OR IGNORE INTO tool_actions (
+        id,
+        tool_id,
+        name,
+        status,
+        updated_at,
+        action_json
+      )
+      SELECT
+        legacy.id,
+        legacy.tool_id,
+        legacy.name,
+        legacy.status,
+        legacy.updated_at,
+        legacy.action_json
+      FROM toolbox_actions legacy
+      INNER JOIN tools ON tools.id = legacy.tool_id
+    `).run();
+  }
+}
+
+function removeInheritedHarnessTools(database) {
+  database.prepare(`
+    DELETE FROM tool_actions
+    WHERE tool_id IN (
+      SELECT id FROM tools
+      WHERE owner IN ('codex')
+        AND origin = 'catalog'
+    )
+  `).run();
+
+  database.prepare(`
+    DELETE FROM tools
+    WHERE owner IN ('codex')
+      AND origin = 'catalog'
+  `).run();
+}
+
+function closeLocalDb() {
+  if (!db) return;
+  db.close();
+  db = null;
+}
+
+module.exports = {
+  closeLocalDb,
+  openLocalDb,
+};

package/runtime/scripts/amalgm-mcp/state/events.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const { EventEmitter } = require('events');
+const { openLocalDb } = require('./db');
+
+const emitter = new EventEmitter();
+emitter.setMaxListeners(200);
+
+function safeJsonStringify(value) {
+  if (value === undefined) return null;
+  return JSON.stringify(value);
+}
+
+function safeJsonParse(value) {
+  if (typeof value !== 'string' || !value) return undefined;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return undefined;
+  }
+}
+
+function normalizeEventRow(row) {
+  if (!row) return null;
+  const event = {
+    seq: Number(row.seq),
+    ts: row.ts,
+    resource: row.resource,
+    op: row.op,
+  };
+  if (row.id != null) event.id = row.id;
+  if (row.client_mutation_id != null) event.clientMutationId = row.client_mutation_id;
+  if (row.source != null) event.source = row.source;
+  if (row.resource_version != null) event.version = Number(row.resource_version);
+  const value = safeJsonParse(row.value_json);
+  const patch = safeJsonParse(row.patch_json);
+  if (value !== undefined) event.value = value;
+  if (patch !== undefined) event.patch = patch;
+  return event;
+}
+
+function insertStateEvent(database, input) {
+  if (!input || typeof input.resource !== 'string' || typeof input.op !== 'string') {
+    throw new Error('state event requires resource and op');
+  }
+
+  const info = database.prepare(`
+    INSERT INTO event_log (
+      resource,
+      op,
+      id,
+      value_json,
+      patch_json,
+      client_mutation_id,
+      source,
+      resource_version
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    input.resource,
+    input.op,
+    input.id ?? null,
+    safeJsonStringify(input.value),
+    safeJsonStringify(input.patch),
+    input.clientMutationId ?? input.client_mutation_id ?? null,
+    input.source ?? null,
+    input.version ?? input.resourceVersion ?? null,
+  );
+  return normalizeEventRow(
+    database.prepare('SELECT * FROM event_log WHERE seq = ?').get(info.lastInsertRowid),
+  );
+}
+
+function publishStateEvent(event) {
+  if (event) emitter.emit('event', event);
+}
+
+function currentSeq() {
+  const row = openLocalDb()
+    .prepare('SELECT COALESCE(MAX(seq), 0) AS seq FROM event_log')
+    .get();
+  return Number(row?.seq || 0);
+}
+
+function appendStateEvent(input) {
+  const db = openLocalDb();
+  const event = db.transaction(() => insertStateEvent(db, input))();
+  publishStateEvent(event);
+  return event;
+}
+
+function listEventsAfter(afterSeq, options = {}) {
+  const after = Number.isFinite(Number(afterSeq)) ? Number(afterSeq) : 0;
+  const limit = Math.max(1, Math.min(Number(options.limit) || 1000, 5000));
+  const rows = openLocalDb()
+    .prepare('SELECT * FROM event_log WHERE seq > ? ORDER BY seq ASC LIMIT ?')
+    .all(after, limit);
+  return rows.map(normalizeEventRow).filter(Boolean);
+}
+
+function subscribeStateEvents(callback) {
+  emitter.on('event', callback);
+  return () => emitter.off('event', callback);
+}
+
+module.exports = {
+  appendStateEvent,
+  currentSeq,
+  insertStateEvent,
+  listEventsAfter,
+  publishStateEvent,
+  subscribeStateEvents,
+};

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

@@ -0,0 +1,64 @@
+'use strict';
+
+const { buildSnapshot } = require('./snapshot');
+const { listEventsAfter, subscribeStateEvents } = require('./events');
+
+function parsePositiveInt(value, fallback) {
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : fallback;
+}
+
+function sendSseEvent(res, event) {
+  res.write(`id: ${event.seq}\n`);
+  res.write('event: state\n');
+  res.write(`data: ${JSON.stringify(event)}\n\n`);
+}
+
+async function handleSnapshot(query, sendJson) {
+  sendJson(200, buildSnapshot(query.resources));
+}
+
+async function handleEvents(query, sendJson) {
+  const after = parsePositiveInt(query.after, 0);
+  const limit = parsePositiveInt(query.limit, 1000);
+  const events = listEventsAfter(after, { limit });
+  sendJson(200, {
+    events,
+    seq: events.length > 0 ? events[events.length - 1].seq : after,
+  });
+}
+
+function handleStream(req, res, query) {
+  const after = parsePositiveInt(query.after, 0);
+
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream; charset=utf-8',
+    'Cache-Control': 'no-cache, no-transform',
+    Connection: 'keep-alive',
+    'X-Accel-Buffering': 'no',
+  });
+  res.write(': local-live-store connected\n\n');
+
+  const unsubscribe = subscribeStateEvents((event) => {
+    if (event.seq > after) sendSseEvent(res, event);
+  });
+
+  for (const event of listEventsAfter(after, { limit: 5000 })) {
+    sendSseEvent(res, event);
+  }
+
+  const heartbeat = setInterval(() => {
+    res.write(': heartbeat\n\n');
+  }, 25_000);
+
+  req.on('close', () => {
+    clearInterval(heartbeat);
+    unsubscribe();
+  });
+}
+
+module.exports = {
+  handleEvents,
+  handleSnapshot,
+  handleStream,
+};

package/runtime/scripts/amalgm-mcp/state/snapshot.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const { currentSeq } = require('./events');
+
+const DEFAULT_RESOURCES = [
+  'tasks',
+  'event_triggers',
+  'agents',
+  'artifacts',
+  'toolbox',
+  'tools',
+  'tool_actions',
+];
+
+function normalizeResources(resources) {
+  if (!resources) return DEFAULT_RESOURCES;
+  const values = Array.isArray(resources)
+    ? resources
+    : String(resources).split(',');
+  const clean = values
+    .map((value) => String(value || '').trim())
+    .filter(Boolean);
+  return clean.length > 0 ? Array.from(new Set(clean)) : DEFAULT_RESOURCES;
+}
+
+function readResource(resource, cache) {
+  switch (resource) {
+    case 'tasks':
+      return require('../tasks/store').loadTasks().tasks;
+    case 'event_triggers':
+      return require('../events/store').loadEventTriggers().triggers;
+    case 'agents':
+      return require('../agents/store').getAllAgentsWithBuiltins();
+    case 'artifacts':
+      return require('../artifacts/store').loadArtifacts().artifacts;
+    case 'toolbox': {
+      cache.toolbox ||= require('../toolbox/store').readToolbox();
+      return cache.toolbox;
+    }
+    case 'tools': {
+      cache.toolbox ||= require('../toolbox/store').readToolbox();
+      return cache.toolbox.tools;
+    }
+    case 'tool_actions': {
+      cache.toolbox ||= require('../toolbox/store').readToolbox();
+      return cache.toolbox.toolActions;
+    }
+    default:
+      return undefined;
+  }
+}
+
+function buildSnapshot(resourcesInput) {
+  const resources = normalizeResources(resourcesInput);
+  const beforeSeq = currentSeq();
+  const cache = {};
+  const data = {};
+
+  for (const resource of resources) {
+    const value = readResource(resource, cache);
+    if (value !== undefined) data[resource] = value;
+  }
+
+  const afterSeq = currentSeq();
+  return {
+    seq: afterSeq,
+    stable: beforeSeq === afterSeq,
+    resources: data,
+  };
+}
+
+module.exports = {
+  DEFAULT_RESOURCES,
+  buildSnapshot,
+  normalizeResources,
+};

package/runtime/scripts/amalgm-mcp/tasks/store.js

@@ -22,6 +22,7 @@ const {
 const { normalizeTaskSchedule } = require('./schedule-normalization');
 const { DEFAULT_SELECTED_MODELS, getSelectedModel } = require('../lib/prefs');
 const credentialAdapter = require('../../credential-adapter');
+const { appendStateEvent } = require('../state/events');
 
 function normalizeStoredTask(task) {
   const harness =
@@ -108,8 +109,22 @@ function loadTasks() {
   return migrated.data;
 }
 
-function saveTasks(data) {
+function publishTasksChange(data, source = 'tasks') {
+  try {
+    appendStateEvent({
+      resource: 'tasks',
+      op: 'replace',
+      value: Array.isArray(data?.tasks) ? data.tasks : [],
+      source,
+    });
+  } catch (error) {
+    console.warn('[Tasks] Local Live Store publish failed:', error.message);
+  }
+}
+
+function saveTasks(data, options = {}) {
   writeJsonAtomic(TASKS_FILE, data);
+  publishTasksChange(data, options.source || 'tasks:save');
 }
 
 function updateTaskMeta(taskId, updates) {

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

@@ -0,0 +1,75 @@
+'use strict';
+
+/**
+ * /toolbox REST routes for the internal UI.
+ *
+ * Not part of the MCP tool surface. This is the local ToolboxDB API.
+ */
+
+const {
+  deleteTool,
+  deleteToolAction,
+  readToolbox,
+  upsertTool,
+  upsertToolAction,
+} = require('./store');
+
+async function handleList(sendJson) {
+  sendJson(200, readToolbox());
+}
+
+async function handleUpsertTool(body, sendJson) {
+  try {
+    const rawTool = body?.tool && typeof body.tool === 'object' ? body.tool : body;
+    const tool = {
+      ...rawTool,
+      actions: body?.actions ?? rawTool?.actions,
+      clientMutationId: body?.clientMutationId ?? rawTool?.clientMutationId,
+    };
+    const saved = upsertTool(tool);
+    sendJson(200, { ok: true, ...saved });
+  } catch (error) {
+    sendJson(400, { error: error instanceof Error ? error.message : 'Failed to save tool' });
+  }
+}
+
+async function handleDeleteTool(body, sendJson) {
+  try {
+    const id = body?.id || body?.toolId;
+    if (!id) return sendJson(400, { error: 'id is required' });
+    sendJson(200, deleteTool(id, { clientMutationId: body?.clientMutationId }));
+  } catch (error) {
+    sendJson(400, { error: error instanceof Error ? error.message : 'Failed to delete tool' });
+  }
+}
+
+async function handleUpsertAction(body, sendJson) {
+  try {
+    const rawAction = body?.action && typeof body.action === 'object' ? body.action : body;
+    const action = upsertToolAction({
+      ...rawAction,
+      clientMutationId: body?.clientMutationId ?? rawAction?.clientMutationId,
+    });
+    sendJson(200, { ok: true, action });
+  } catch (error) {
+    sendJson(400, { error: error instanceof Error ? error.message : 'Failed to save tool action' });
+  }
+}
+
+async function handleDeleteAction(body, sendJson) {
+  try {
+    const id = body?.id || body?.actionId;
+    if (!id) return sendJson(400, { error: 'id is required' });
+    sendJson(200, deleteToolAction(id, { clientMutationId: body?.clientMutationId }));
+  } catch (error) {
+    sendJson(400, { error: error instanceof Error ? error.message : 'Failed to delete tool action' });
+  }
+}
+
+module.exports = {
+  handleDeleteAction,
+  handleDeleteTool,
+  handleList,
+  handleUpsertAction,
+  handleUpsertTool,
+};