amalgm 0.0.0 → 0.0.32

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

@@ -0,0 +1,200 @@
+/**
+ * Slack inbound handoff.
+ *
+ * The api-proxy verifies Slack, resolves/creates the Supabase session, then
+ * forwards a clean Slack payload here. This local route runs the agent through
+ * the same chat-server path as email/tasks/events, then asks the proxy to send
+ * the Slack reply with the bot token that lives outside the local computer.
+ */
+
+const crypto = require('crypto');
+
+const {
+  AMALGM_USER_ID,
+  DEFAULT_CWD,
+  PROXY_BASE_URL,
+  PROXY_TOKEN,
+} = require('../config');
+const { runThroughChatServer } = require('../lib/chat-runner');
+const { ensureFreshProxyToken, readProxyToken } = require('../../proxy-token-store');
+const {
+  hydrateModelPreferences,
+  getSelectedModel,
+  resolveModelSelection,
+  DEFAULT_SELECTED_MODELS,
+} = require('../lib/prefs');
+const { buildLocalMcpServerConfigs } = require('../lib/mcp-resolver');
+const {
+  chatInputToLegacyFields,
+  normalizeChatInput,
+} = require('../../../lib/chatInput');
+const credentialAdapter = require('../../credential-adapter');
+
+function harnessToAgent(harness) {
+  const map = { claude_code: 'claude', codex: 'codex', opencode: 'opencode', pi: 'pi', amp: 'amp', cursor: 'cursor' };
+  return map[harness] || 'claude';
+}
+
+function asString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function isDefaultSessionTitle(title) {
+  return ['', 'New Chat', 'New session', 'New code session'].includes(String(title || '').trim());
+}
+
+function resolveBaseHarness(session) {
+  const metadata = session?.metadata || {};
+  return (
+    asString(metadata.baseHarnessId) ||
+    asString(metadata.harness) ||
+    asString(session?.harness) ||
+    'claude_code'
+  );
+}
+
+function resolveDefaultAuthMethod(baseHarnessId) {
+  if (credentialAdapter.VALID_HARNESS_IDS.includes(baseHarnessId)) {
+    return credentialAdapter.getPersistedAuthMode(baseHarnessId);
+  }
+  return 'amalgm';
+}
+
+async function sendSlackReply({ sessionId, channel, threadTs, message }) {
+  const replyUrl = PROXY_BASE_URL
+    ? `${PROXY_BASE_URL.replace(/\/anthropic\/?$/, '')}/slack/reply`
+    : null;
+  const proxyToken = await ensureFreshProxyToken({ logger: console }) || readProxyToken() || PROXY_TOKEN;
+  if (!replyUrl || !proxyToken) {
+    throw new Error('Slack reply proxy is not configured.');
+  }
+
+  const res = await fetch(replyUrl, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${proxyToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      sessionId,
+      channel,
+      threadTs,
+      text: message,
+    }),
+  });
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`Slack reply proxy failed: ${res.status} ${text.slice(0, 200)}`);
+  }
+  return await res.json().catch(() => ({}));
+}
+
+async function handleSlackInbound(body, sendJson) {
+  const session = body?.session;
+  const inbound = body?.inbound || {};
+  const sessionId = asString(session?.id);
+  const prompt = asString(inbound.text);
+  const channel = asString(inbound.channelId);
+
+  if (!sessionId) return sendJson(400, { error: 'session.id is required' });
+  if (!prompt) return sendJson(400, { error: 'inbound.text is required' });
+  if (!channel) return sendJson(400, { error: 'inbound.channelId is required' });
+
+  await hydrateModelPreferences();
+
+  const metadata = session.metadata || {};
+  const baseHarnessId = resolveBaseHarness(session);
+  const fallbackModelId =
+    asString(metadata.baseModelId) ||
+    getSelectedModel(baseHarnessId) ||
+    DEFAULT_SELECTED_MODELS[baseHarnessId] ||
+    null;
+  const defaultAuthMethod = asString(metadata.authMethod) || resolveDefaultAuthMethod(baseHarnessId);
+  const cwd = asString(metadata.cwd) || DEFAULT_CWD;
+  const computerId = asString(metadata.computerId);
+  const slackSystemPrompt = [
+    asString(metadata.systemPrompt),
+    'You are replying in Slack. Keep responses clear, direct, and Slack-friendly. Use concise Markdown/mrkdwn when helpful.',
+  ].filter(Boolean).join('\n\n');
+
+  const normalizedChatInput = normalizeChatInput({
+    parts: [{ type: 'text', text: prompt }],
+    agent: {
+      harness: baseHarnessId,
+      model: fallbackModelId,
+      authMethod: defaultAuthMethod,
+      customAgentId: asString(metadata.agentId) || null,
+      systemPrompt: slackSystemPrompt || null,
+    },
+    tools: {
+      mcpAppIds: Array.isArray(metadata.mcpAppIds) ? metadata.mcpAppIds : [],
+    },
+    execution: {
+      cwd,
+      computerId,
+    },
+  }, {
+    prompt,
+    harness: baseHarnessId,
+    modelId: fallbackModelId,
+    authMethod: defaultAuthMethod,
+    cwd,
+    computerId,
+    systemPrompt: slackSystemPrompt || undefined,
+    mcpAppIds: Array.isArray(metadata.mcpAppIds) ? metadata.mcpAppIds : [],
+  });
+
+  const legacyChatFields = chatInputToLegacyFields(normalizedChatInput, {
+    prompt,
+    harness: baseHarnessId,
+    modelId: fallbackModelId,
+    authMethod: defaultAuthMethod,
+    cwd,
+    computerId,
+    systemPrompt: slackSystemPrompt || undefined,
+  });
+  const { modelId: uiModelId, cliModel, reasoningEffort } = resolveModelSelection(
+    baseHarnessId,
+    legacyChatFields.modelId || fallbackModelId,
+  );
+  const mcpServers = await buildLocalMcpServerConfigs(legacyChatFields.mcpAppIds || []);
+  const userMessageId = crypto.randomUUID();
+  const assistantMessageId = crypto.randomUUID();
+
+  const { outputText } = await runThroughChatServer({
+    chatInput: normalizedChatInput,
+    prompt: legacyChatFields.prompt,
+    userId: AMALGM_USER_ID || session.user_id,
+    codeSessionId: sessionId,
+    assistantMessageId,
+    userMessageId,
+    userParts: legacyChatFields.userParts,
+    agentId: harnessToAgent(baseHarnessId),
+    modelId: uiModelId,
+    cliModel,
+    ...(reasoningEffort ? { reasoningEffort } : {}),
+    cwd: legacyChatFields.cwd || DEFAULT_CWD,
+    authMethod: legacyChatFields.authMethod || defaultAuthMethod,
+    mcpServers,
+    ...(legacyChatFields.systemPrompt ? { systemPrompt: legacyChatFields.systemPrompt } : {}),
+    ...(!isDefaultSessionTitle(session.title) ? { resumeSessionId: sessionId } : {}),
+    origin: 'slack',
+    originId: inbound.originId || inbound.providerEventId || inbound.ts || null,
+    originName: 'Slack',
+    originHarnessId: session.harness || baseHarnessId,
+    originBaseHarnessId: baseHarnessId,
+  });
+
+  const responseText = outputText.trim() || 'Done.';
+  await sendSlackReply({
+    sessionId,
+    channel,
+    threadTs: asString(inbound.replyThreadTs),
+    message: responseText,
+  });
+
+  return sendJson(200, { ok: true, sessionId, responseLength: responseText.length });
+}
+
+module.exports = { handleSlackInbound };

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,
+};