amalgm 0.1.115 → 0.1.116

package/package.json

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

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

@@ -6,6 +6,44 @@ const { openLocalDb } = require('./db');
 const emitter = new EventEmitter();
 emitter.setMaxListeners(200);
 
+const DEFAULT_EVENT_LOG_RETENTION_HOURS = 24;
+const DEFAULT_EVENT_LOG_PRUNE_BATCH_SIZE = 1000;
+const DEFAULT_EVENT_LOG_PRUNE_INTERVAL_MS = 60_000;
+
+let lastPruneAttemptAt = 0;
+
+function positiveNumber(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function retentionHours(options = {}) {
+  return positiveNumber(
+    options.retentionHours ?? process.env.AMALGM_EVENT_LOG_RETENTION_HOURS,
+    DEFAULT_EVENT_LOG_RETENTION_HOURS,
+  );
+}
+
+function pruneBatchSize(options = {}) {
+  return Math.max(1, Math.floor(positiveNumber(
+    options.batchSize ?? process.env.AMALGM_EVENT_LOG_PRUNE_BATCH_SIZE,
+    DEFAULT_EVENT_LOG_PRUNE_BATCH_SIZE,
+  )));
+}
+
+function pruneIntervalMs(options = {}) {
+  return positiveNumber(
+    options.intervalMs ?? process.env.AMALGM_EVENT_LOG_PRUNE_INTERVAL_MS,
+    DEFAULT_EVENT_LOG_PRUNE_INTERVAL_MS,
+  );
+}
+
+function retentionCutoffIso(options = {}) {
+  const cutoff = options.cutoffIso || options.cutoff;
+  if (typeof cutoff === 'string' && cutoff) return cutoff;
+  return new Date(Date.now() - retentionHours(options) * 60 * 60 * 1000).toISOString();
+}
+
 function safeJsonStringify(value) {
   if (value === undefined) return null;
   return JSON.stringify(value);
@@ -73,6 +111,7 @@ function insertStateEvent(database, input) {
 
 function publishStateEvent(event) {
   if (event) emitter.emit('event', event);
+  maybePruneEventLog();
 }
 
 function currentSeq() {
@@ -98,6 +137,75 @@ function listEventsAfter(afterSeq, options = {}) {
   return rows.map(normalizeEventRow).filter(Boolean);
 }
 
+function eventLogBounds(database = openLocalDb()) {
+  const row = database
+    .prepare('SELECT MIN(seq) AS min_seq, MAX(seq) AS max_seq FROM event_log')
+    .get();
+  const minSeq = row?.min_seq == null ? 0 : Number(row.min_seq);
+  const maxSeq = row?.max_seq == null ? 0 : Number(row.max_seq);
+  return { minSeq, maxSeq };
+}
+
+function replayGapAfter(afterSeq, database = openLocalDb()) {
+  const after = Number.isFinite(Number(afterSeq)) ? Number(afterSeq) : 0;
+  if (after <= 0) return null;
+  const { minSeq, maxSeq } = eventLogBounds(database);
+  if (minSeq > 0 && minSeq > after + 1) {
+    return {
+      code: 'state_event_gap',
+      message: 'State event history has been compacted; fetch a fresh snapshot.',
+      after,
+      minSeq,
+      maxSeq,
+    };
+  }
+  return null;
+}
+
+function pruneEventLog(options = {}) {
+  const hours = retentionHours(options);
+  if (!Number.isFinite(hours) || hours <= 0) {
+    return { deleted: 0, skipped: true, reason: 'disabled' };
+  }
+
+  const database = options.database || openLocalDb();
+  const cutoffIso = retentionCutoffIso({ ...options, retentionHours: hours });
+  const batchSize = pruneBatchSize(options);
+  const result = database.prepare(`
+    DELETE FROM event_log
+    WHERE seq IN (
+      SELECT seq
+      FROM event_log
+      WHERE ts < ?
+      ORDER BY seq ASC
+      LIMIT ?
+    )
+  `).run(cutoffIso, batchSize);
+
+  return {
+    deleted: result.changes || 0,
+    cutoffIso,
+    retentionHours: hours,
+    batchSize,
+  };
+}
+
+function maybePruneEventLog(options = {}) {
+  const now = Date.now();
+  const intervalMs = pruneIntervalMs(options);
+  if (now - lastPruneAttemptAt < intervalMs) {
+    return { deleted: 0, skipped: true, reason: 'throttled' };
+  }
+  lastPruneAttemptAt = now;
+  try {
+    return pruneEventLog(options);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn('[LocalLive] Event log retention failed:', message);
+    return { deleted: 0, skipped: true, reason: 'error', error: message };
+  }
+}
+
 function subscribeStateEvents(callback) {
   emitter.on('event', callback);
   return () => emitter.off('event', callback);
@@ -106,8 +214,12 @@ function subscribeStateEvents(callback) {
 module.exports = {
   appendStateEvent,
   currentSeq,
+  eventLogBounds,
   insertStateEvent,
   listEventsAfter,
+  maybePruneEventLog,
   publishStateEvent,
+  pruneEventLog,
+  replayGapAfter,
   subscribeStateEvents,
 };

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

@@ -1,7 +1,11 @@
 'use strict';
 
 const { buildSnapshot } = require('./snapshot');
-const { listEventsAfter, subscribeStateEvents } = require('./events');
+const {
+  listEventsAfter,
+  replayGapAfter,
+  subscribeStateEvents,
+} = require('./events');
 
 function parsePositiveInt(value, fallback) {
   const parsed = Number(value);
@@ -14,6 +18,11 @@ function sendSseEvent(res, event) {
   res.write(`data: ${JSON.stringify(event)}\n\n`);
 }
 
+function sendSseControl(res, type, payload) {
+  res.write(`event: ${type}\n`);
+  res.write(`data: ${JSON.stringify(payload)}\n\n`);
+}
+
 async function handleSnapshot(query, sendJson) {
   sendJson(200, buildSnapshot(query.resources));
 }
@@ -21,6 +30,11 @@ async function handleSnapshot(query, sendJson) {
 async function handleEvents(query, sendJson) {
   const after = parsePositiveInt(query.after, 0);
   const limit = parsePositiveInt(query.limit, 1000);
+  const gap = replayGapAfter(after);
+  if (gap) {
+    sendJson(409, { ...gap, reset: true });
+    return;
+  }
   const events = listEventsAfter(after, { limit });
   sendJson(200, {
     events,
@@ -39,6 +53,13 @@ function handleStream(req, res, query) {
   });
   res.write(': local-live-store connected\n\n');
 
+  const gap = replayGapAfter(after);
+  if (gap) {
+    sendSseControl(res, 'reset', { ...gap, reset: true });
+    res.end();
+    return;
+  }
+
   const unsubscribe = subscribeStateEvents((event) => {
     if (event.seq > after) sendSseEvent(res, event);
   });

package/runtime/scripts/amalgm-mcp/tests/state-events-retention.test.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-state-events-test-'));
+process.env.AMALGM_DIR = path.join(tempRoot, '.amalgm');
+process.env.AMALGM_EVENT_LOG_PRUNE_INTERVAL_MS = '0';
+
+const { closeLocalDb, openLocalDb } = require('../state/db');
+const {
+  eventLogBounds,
+  insertStateEvent,
+  listEventsAfter,
+  pruneEventLog,
+  replayGapAfter,
+} = require('../state/events');
+
+test.after(() => {
+  closeLocalDb();
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+test('event log retention removes old batches and reports replay gaps', () => {
+  const db = openLocalDb();
+  const oldCutoff = '2026-06-15T00:00:00.000Z';
+  const freshCutoff = '2026-06-16T00:00:00.000Z';
+
+  insertStateEvent(db, {
+    resource: 'apps',
+    op: 'replace',
+    value: [{ id: 'old-1' }],
+    source: 'test',
+  });
+  insertStateEvent(db, {
+    resource: 'apps',
+    op: 'replace',
+    value: [{ id: 'old-2' }],
+    source: 'test',
+  });
+  insertStateEvent(db, {
+    resource: 'apps',
+    op: 'replace',
+    value: [{ id: 'fresh' }],
+    source: 'test',
+  });
+
+  db.prepare('UPDATE event_log SET ts = ? WHERE seq IN (1, 2)').run(oldCutoff);
+  db.prepare('UPDATE event_log SET ts = ? WHERE seq = 3').run(freshCutoff);
+
+  const result = pruneEventLog({
+    database: db,
+    cutoffIso: '2026-06-15T12:00:00.000Z',
+    batchSize: 2,
+  });
+
+  assert.equal(result.deleted, 2);
+  assert.deepEqual(eventLogBounds(db), { minSeq: 3, maxSeq: 3 });
+  assert.equal(replayGapAfter(1, db)?.code, 'state_event_gap');
+  assert.equal(replayGapAfter(2, db), null);
+  assert.deepEqual(
+    listEventsAfter(2).map((event) => event.value),
+    [[{ id: 'fresh' }]],
+  );
+});

package/runtime/scripts/local-gateway.js

@@ -159,6 +159,7 @@ const MCP_PREFIXES = [
   '/artifacts',
   '/agents',
   '/agent-config',
+  '/user-preferences',
   '/browser',
 ];