amalgm 0.1.48 → 0.1.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,

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

@@ -49,7 +49,7 @@ function cleanString(value) {
 // Chat server (local Next.js/Electron) — same process tree; no cloud hop.
 const CHAT_SERVER_URL = `http://localhost:${runtimePort('chat-server')}`;
 
-const SCHEDULER_INTERVAL_MS = 30_000;
+const SCHEDULER_INTERVAL_MS = 60_000;
 
 // Default working directory for automated runs (was /workspace in the container).
 const DEFAULT_CWD = process.env.AMALGM_DEFAULT_CWD || os.homedir();

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

@@ -12,6 +12,7 @@ const os = require('os');
 const { AMALGM_COMPUTER_ID, AMALGM_USER_ID, DEFAULT_CWD } = require('../config');
 const { runThroughChatServer } = require('../lib/chat-runner');
 const { hasSupabase, supabaseInsert, supabasePatch } = require('../lib/supabase');
+const { recordEventRun } = require('./store');
 const {
   chatInputToLegacyFields,
   normalizeChatInput,
@@ -124,6 +125,7 @@ async function executeArtifactEvent(artifactOrTrigger, eventDef, payload, opts =
     projectPath,
   });
   const cwd = legacy.cwd || DEFAULT_CWD;
+  const runTriggerId = triggerId || artifactOrTrigger.id;
   const modelSelection = resolveModelSelection(
     harness,
     modelIdForSettings(legacy.modelId || model, harness, modelSettings),
@@ -135,6 +137,17 @@ async function executeArtifactEvent(artifactOrTrigger, eventDef, payload, opts =
     `[AmalgmMCP:Event] Starting agent run for ${artifactOrTrigger.id}:${eventDef.name} (session: ${codeSessionId}, cwd: ${cwd})`,
   );
 
+  recordEventRun(runTriggerId, {
+    runId: codeSessionId,
+    sessionId: codeSessionId,
+    triggerName: eventDef.name,
+    startedAt,
+    status: 'running',
+    harness,
+    projectPath: projectPath || null,
+    prompt: legacy.prompt,
+  }, { source: 'event_runs:start' });
+
   if (hasSupabase()) {
     try {
       const metadata = {
@@ -195,6 +208,16 @@ async function executeArtifactEvent(artifactOrTrigger, eventDef, payload, opts =
       `[AmalgmMCP:Event] ${artifactOrTrigger.id}:${eventDef.name} completed in ${durationMs}ms (output: ${outputText.length} chars)`,
     );
 
+    recordEventRun(runTriggerId, {
+      runId: codeSessionId,
+      sessionId: codeSessionId,
+      triggerName: eventDef.name,
+      finishedAt: new Date().toISOString(),
+      status: 'completed',
+      durationMs,
+      outputLength: outputText.length,
+    }, { source: 'event_runs:complete' });
+
     if (hasSupabase()) {
       supabasePatch('sessions', 'id', codeSessionId, {
         last_message_at: new Date().toISOString(),
@@ -207,6 +230,14 @@ async function executeArtifactEvent(artifactOrTrigger, eventDef, payload, opts =
       `[AmalgmMCP:Event] ${artifactOrTrigger.id}:${eventDef.name} failed:`,
       err.message,
     );
+    recordEventRun(runTriggerId, {
+      runId: codeSessionId,
+      sessionId: codeSessionId,
+      triggerName: eventDef.name,
+      finishedAt: new Date().toISOString(),
+      status: 'failed',
+      error: err.message,
+    }, { source: 'event_runs:failed' });
     if (hasSupabase()) {
       supabasePatch('sessions', 'id', codeSessionId, {
         last_message_at: new Date().toISOString(),

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

@@ -4,6 +4,7 @@
 
 const { EVENT_TRIGGERS_FILE, STORAGE_DIR } = require('../config');
 const { ensureDir, readJson, writeJsonAtomic } = require('../lib/storage');
+const { openLocalDb } = require('../state/db');
 const {
   chatInputToLegacyFields,
   getChatInputText,
@@ -11,7 +12,22 @@ const {
 } = require('../../../lib/chatInput');
 const { DEFAULT_SELECTED_MODELS, getSelectedModel } = require('../lib/prefs');
 const credentialAdapter = require('../../credential-adapter');
-const { appendStateEvent } = require('../state/events');
+const { appendStateEvent, insertStateEvent, publishStateEvent } = require('../state/events');
+
+const DEFAULT_RUN_LIMIT = 100;
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function parseJson(value, fallback = null) {
+  if (typeof value !== 'string' || !value) return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
 
 function normalizeStoredTrigger(trigger) {
   const harness =
@@ -78,6 +94,7 @@ function migrateTriggersData(data) {
 
 function ensureTriggersDirs() {
   ensureDir(STORAGE_DIR);
+  openLocalDb();
   if (!readJson(EVENT_TRIGGERS_FILE, null)) {
     writeJsonAtomic(EVENT_TRIGGERS_FILE, { triggers: [] });
   }
@@ -110,4 +127,187 @@ function saveEventTriggers(data, options = {}) {
   publishEventTriggersChange(data, options.source || 'event-triggers:save');
 }
 
-module.exports = { ensureTriggersDirs, loadEventTriggers, saveEventTriggers };
+function rowToEventRun(row) {
+  if (!row) return null;
+  const parsed = parseJson(row.run_json, {});
+  return {
+    ...parsed,
+    id: row.id,
+    runId: row.id,
+    triggerId: row.trigger_id,
+    status: row.status,
+    startedAt: row.started_at || parsed.startedAt || null,
+    finishedAt: row.finished_at || parsed.finishedAt || null,
+    sessionId: row.session_id || parsed.sessionId || null,
+    harness: row.harness || parsed.harness || null,
+    projectPath: row.project_path || parsed.projectPath || null,
+    error: row.error || parsed.error || null,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+function eventRunRowParams(run) {
+  const timestamp = nowIso();
+  const createdAt = run.createdAt || timestamp;
+  const updatedAt = run.updatedAt || timestamp;
+  const runJson = {
+    ...run,
+    id: run.id,
+    runId: run.id,
+    triggerId: run.triggerId,
+    status: run.status || 'running',
+    startedAt: run.startedAt || null,
+    finishedAt: run.finishedAt || null,
+    sessionId: run.sessionId || null,
+    harness: run.harness || null,
+    projectPath: run.projectPath || null,
+    error: run.error || null,
+    createdAt,
+    updatedAt,
+  };
+  return {
+    id: run.id,
+    trigger_id: run.triggerId,
+    status: run.status || 'running',
+    started_at: run.startedAt || null,
+    finished_at: run.finishedAt || null,
+    session_id: run.sessionId || null,
+    harness: run.harness || null,
+    project_path: run.projectPath || null,
+    error: run.error || null,
+    run_json: JSON.stringify(runJson),
+    created_at: createdAt,
+    updated_at: updatedAt,
+  };
+}
+
+function upsertEventRunRow(db, run) {
+  const params = eventRunRowParams(run);
+  db.prepare(`
+    INSERT INTO event_runs (
+      id,
+      trigger_id,
+      status,
+      started_at,
+      finished_at,
+      session_id,
+      harness,
+      project_path,
+      error,
+      run_json,
+      created_at,
+      updated_at
+    )
+    VALUES (
+      @id,
+      @trigger_id,
+      @status,
+      @started_at,
+      @finished_at,
+      @session_id,
+      @harness,
+      @project_path,
+      @error,
+      @run_json,
+      @created_at,
+      @updated_at
+    )
+    ON CONFLICT(id) DO UPDATE SET
+      trigger_id = excluded.trigger_id,
+      status = excluded.status,
+      started_at = excluded.started_at,
+      finished_at = excluded.finished_at,
+      session_id = excluded.session_id,
+      harness = excluded.harness,
+      project_path = excluded.project_path,
+      error = excluded.error,
+      run_json = excluded.run_json,
+      updated_at = excluded.updated_at
+  `).run(params);
+}
+
+function mergeEventRunEntry(existing, triggerId, entry) {
+  const timestamp = nowIso();
+  const startedAt = entry.startedAt || existing?.startedAt || timestamp;
+  const finishedAt = entry.finishedAt || existing?.finishedAt || null;
+  const events = Array.isArray(existing?.events) ? existing.events.slice(-99) : [];
+  events.push({ ...entry, recordedAt: timestamp });
+
+  return {
+    ...(existing || {}),
+    id: entry.runId || entry.id || existing?.id || entry.sessionId || timestamp,
+    runId: entry.runId || entry.id || existing?.id || entry.sessionId || null,
+    triggerId,
+    triggerName: entry.triggerName || existing?.triggerName || null,
+    status: entry.status || existing?.status || 'running',
+    startedAt,
+    finishedAt,
+    sessionId: entry.sessionId || existing?.sessionId || null,
+    harness: entry.harness || existing?.harness || null,
+    projectPath: entry.projectPath || existing?.projectPath || null,
+    error: entry.error || existing?.error || null,
+    durationMs: entry.durationMs ?? existing?.durationMs ?? null,
+    outputLength: entry.outputLength ?? existing?.outputLength ?? null,
+    prompt: entry.prompt || existing?.prompt || null,
+    events,
+    createdAt: existing?.createdAt || startedAt,
+    updatedAt: timestamp,
+  };
+}
+
+function listEventRuns(options = {}) {
+  ensureTriggersDirs();
+  const limit = Math.max(1, Math.min(Number(options.limit) || DEFAULT_RUN_LIMIT, 1000));
+  const db = openLocalDb();
+  const rows = options.triggerId
+    ? db.prepare(`
+        SELECT * FROM event_runs
+        WHERE trigger_id = ?
+        ORDER BY datetime(updated_at) DESC, datetime(started_at) DESC
+        LIMIT ?
+      `).all(options.triggerId, limit)
+    : db.prepare(`
+        SELECT * FROM event_runs
+        ORDER BY datetime(updated_at) DESC, datetime(started_at) DESC
+        LIMIT ?
+      `).all(limit);
+  return rows.map(rowToEventRun).filter(Boolean);
+}
+
+function recordEventRun(triggerId, entry, options = {}) {
+  if (!triggerId || (!entry?.runId && !entry?.id && !entry?.sessionId)) return null;
+  ensureTriggersDirs();
+
+  const db = openLocalDb();
+  const source = options.source || entry.source || 'event_runs:record';
+  let run = null;
+  let event = null;
+
+  db.transaction(() => {
+    const runId = entry.runId || entry.id || entry.sessionId;
+    const existingRow = db.prepare('SELECT * FROM event_runs WHERE id = ?').get(runId);
+    const existing = rowToEventRun(existingRow);
+    run = mergeEventRunEntry(existing, triggerId, { ...entry, runId });
+    upsertEventRunRow(db, run);
+    run = rowToEventRun(db.prepare('SELECT * FROM event_runs WHERE id = ?').get(run.id));
+    event = insertStateEvent(db, {
+      resource: 'event_runs',
+      op: existing ? 'update' : 'insert',
+      id: run.id,
+      value: run,
+      source,
+    });
+  })();
+
+  if (event) publishStateEvent(event);
+  return run;
+}
+
+module.exports = {
+  ensureTriggersDirs,
+  listEventRuns,
+  loadEventTriggers,
+  recordEventRun,
+  saveEventTriggers,
+};