amalgm 0.1.245 → 0.1.246

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

@@ -0,0 +1,287 @@
+'use strict';
+
+/**
+ * The local entity API — the runtime half of `amalgm register`. Authenticated
+ * by the same boundary as every other local route (server/http-service.js
+ * authorizes before dispatch), so this file is only the shape of the
+ * request and the shape of the failure.
+ *
+ * Two failures, two meanings, and the boundary itself says which:
+ *
+ *   400  a REFUSAL — the request named ground amalgm will not take
+ *        (registration/refusal.js). The message IS the reason and is
+ *        meant to be shown to whoever asked.
+ *   ---  anything else is a FAULT: a torn identity store, an unusable
+ *        database, a bug. The request was fine; the installation is
+ *        not. It travels on to the server's fault handler, which is
+ *        what already reports every other route's faults.
+ *
+ * The split is never made by reading an error's wording. A message is
+ * for people; it changes. Deciding on it would mean that the day the
+ * identity store tears, the user is told their path is bad.
+ */
+
+const crypto = require('crypto');
+
+const {
+  USER_HOME_CLOUD_CONTRACT,
+  USER_HOME_CLOUD_SCHEMA_VERSION,
+  registrationService,
+} = require('../../registration/service');
+const { isRefusal } = require('../../registration/refusal');
+
+function privateUserHomeResourceId(userId) {
+  return `pvr_${crypto
+    .createHash('sha256')
+    .update(`private-user:${userId}:${USER_HOME_CLOUD_CONTRACT}`)
+    .digest('base64url')
+    .slice(0, 32)}`;
+}
+
+function userHomeCloudIdentity() {
+  const { userId } = require('../../workspace/identity');
+  const ownerUserId = userId();
+  if (!ownerUserId) return { enabled: false, reason: 'runtime is not enrolled to a user' };
+  return {
+    enabled: true,
+    resourceId: privateUserHomeResourceId(ownerUserId),
+    contract: USER_HOME_CLOUD_CONTRACT,
+    schemaVersion: USER_HOME_CLOUD_SCHEMA_VERSION,
+  };
+}
+
+function snapshotBytes(value) {
+  const bytes = Buffer.from(JSON.stringify(value), 'utf8');
+  return {
+    snapshotBase64: bytes.toString('base64'),
+    snapshotBytes: bytes.length,
+    snapshotChecksum: crypto.createHash('sha256').update(bytes).digest('hex'),
+  };
+}
+
+async function handleEntityRoutes(ctx) {
+  if (ctx.pathname === '/entities/user-home/cloud/identity' && ctx.method === 'GET') {
+    ctx.res.setHeader('Cache-Control', 'no-store');
+    ctx.sendJson(200, userHomeCloudIdentity());
+    return true;
+  }
+
+  if (ctx.pathname === '/entities/user-home/cloud/bootstrap' && ctx.method === 'GET') {
+    ctx.res.setHeader('Cache-Control', 'no-store');
+    const identity = userHomeCloudIdentity();
+    if (!identity.enabled) {
+      ctx.sendJson(200, identity);
+      return true;
+    }
+    const home = await registrationService().bootstrapUserHome();
+    ctx.sendJson(200, { ...identity, ...snapshotBytes(home.cloudSnapshot) });
+    return true;
+  }
+
+  if (ctx.pathname === '/entities/user-home/cloud/install' && ctx.method === 'POST') {
+    ctx.res.setHeader('Cache-Control', 'no-store');
+    const identity = userHomeCloudIdentity();
+    if (!identity.enabled) {
+      ctx.sendJson(409, identity);
+      return true;
+    }
+    const body = await ctx.readJsonBody();
+    if (
+      body?.resourceId !== identity.resourceId
+      || body?.contract !== identity.contract
+      || Number(body?.schemaVersion) !== identity.schemaVersion
+    ) {
+      ctx.sendJson(400, { error: 'cloud user-home identity does not belong to this runtime user' });
+      return true;
+    }
+    const bytes = Buffer.from(String(body.snapshotBase64 || ''), 'base64');
+    const checksum = crypto.createHash('sha256').update(bytes).digest('hex');
+    if (checksum !== body.snapshotChecksum) {
+      ctx.sendJson(400, { error: 'cloud user-home snapshot checksum mismatch' });
+      return true;
+    }
+    let snapshot;
+    try {
+      snapshot = JSON.parse(bytes.toString('utf8'));
+    } catch {
+      ctx.sendJson(400, { error: 'cloud user-home snapshot is not JSON' });
+      return true;
+    }
+    const home = await registrationService().bootstrapUserHome({ identitySnapshot: snapshot });
+    ctx.sendJson(200, {
+      resourceId: identity.resourceId,
+      roots: home.roots.map(({ key, record }) => ({ key, uuid: record.uuid })),
+      exactManaged: home.exactManaged.map(({ key, record }) => ({ key, uuid: record.uuid })),
+    });
+    return true;
+  }
+
+  // The universal entity graph has its own private resource. It is kept
+  // separate from the user-home declaration: the latter establishes the
+  // fixed safe roots and exact governance; this resource carries every
+  // logical entity record and its durable mutation tail.
+  if (ctx.pathname === '/entities/cloud/identity' && ctx.method === 'GET') {
+    ctx.res.setHeader('Cache-Control', 'no-store');
+    ctx.sendJson(200, registrationService().entityCloud.identity());
+    return true;
+  }
+
+  if (ctx.pathname === '/entities/cloud/bootstrap' && ctx.method === 'GET') {
+    ctx.res.setHeader('Cache-Control', 'no-store');
+    const service = registrationService();
+    const identity = service.entityCloud.identity();
+    if (!identity.enabled) {
+      ctx.sendJson(200, identity);
+      return true;
+    }
+    // A missing entity resource is first created from the same declared
+    // user-home graph that login owns. This is not an alternate registrar.
+    await service.bootstrapUserHome();
+    ctx.sendJson(200, service.entityCloud.bootstrap(service.registration.registry));
+    return true;
+  }
+
+  if (ctx.pathname === '/entities/cloud/install' && ctx.method === 'POST') {
+    ctx.res.setHeader('Cache-Control', 'no-store');
+    const body = await ctx.readJsonBody();
+    const service = registrationService();
+    try {
+      ctx.sendJson(200, service.entityCloud.install({
+        registry: service.registration.registry,
+        resourceId: body?.resourceId,
+        authorityEpoch: body?.authorityEpoch,
+        headVersion: body?.headVersion,
+        snapshotBase64: body?.snapshotBase64,
+        snapshotChecksum: body?.snapshotChecksum,
+      }));
+    } catch (error) {
+      ctx.sendJson(409, { error: error.message });
+    }
+    return true;
+  }
+
+  if (ctx.pathname === '/entities/cloud/mutations/claim' && ctx.method === 'POST') {
+    const body = await ctx.readJsonBody();
+    ctx.sendJson(200, {
+      mutations: registrationService().entityCloud.claim({
+        limit: body?.limit,
+        leaseMs: body?.leaseMs,
+      }),
+    });
+    return true;
+  }
+
+  // Content objects are a separate ordered rail: a file record is not
+  // submitted until this endpoint has received the immutable object manifest
+  // acknowledgement for its payload head.
+  if (ctx.pathname === '/entities/cloud/content/claim' && ctx.method === 'POST') {
+    const body = await ctx.readJsonBody();
+    ctx.sendJson(200, {
+      upload: registrationService().entityCloud.claimContent({ leaseMs: body?.leaseMs }),
+    });
+    return true;
+  }
+
+  if (ctx.pathname === '/entities/cloud/content/ack' && ctx.method === 'POST') {
+    const body = await ctx.readJsonBody();
+    try {
+      ctx.sendJson(200, registrationService().entityCloud.acknowledgeContent({
+        resourceId: body?.resourceId,
+        contentHash: body?.contentHash,
+        kind: body?.kind,
+        partIndex: body?.partIndex,
+      }));
+    } catch (error) {
+      ctx.sendJson(400, { error: error.message });
+    }
+    return true;
+  }
+
+  if (ctx.pathname === '/entities/cloud/content/fail' && ctx.method === 'POST') {
+    const body = await ctx.readJsonBody();
+    try {
+      ctx.sendJson(200, registrationService().entityCloud.failContent({
+        resourceId: body?.resourceId,
+        contentHash: body?.contentHash,
+        message: body?.message,
+      }));
+    } catch (error) {
+      ctx.sendJson(400, { error: error.message });
+    }
+    return true;
+  }
+
+  if (ctx.pathname === '/entities/cloud/mutations/ack' && ctx.method === 'POST') {
+    const body = await ctx.readJsonBody();
+    try {
+      ctx.sendJson(200, registrationService().entityCloud.acknowledge({
+        resourceId: body?.resourceId,
+        mutationId: body?.mutationId,
+        version: body?.version,
+        committedAt: body?.committedAt,
+      }));
+    } catch (error) {
+      ctx.sendJson(400, { error: error.message });
+    }
+    return true;
+  }
+
+  if (ctx.pathname === '/entities/cloud/mutations/fail' && ctx.method === 'POST') {
+    const body = await ctx.readJsonBody();
+    try {
+      ctx.sendJson(200, registrationService().entityCloud.fail({
+        resourceId: body?.resourceId,
+        mutationId: body?.mutationId,
+        message: body?.message,
+        retryable: body?.retryable,
+      }));
+    } catch (error) {
+      ctx.sendJson(400, { error: error.message });
+    }
+    return true;
+  }
+
+  if (ctx.pathname === '/entities/cloud/mutations/ingest' && ctx.method === 'POST') {
+    const body = await ctx.readJsonBody();
+    const service = registrationService();
+    try {
+      ctx.sendJson(200, service.entityCloud.ingest({
+        registry: service.registration.registry,
+        envelope: body?.envelope,
+        version: body?.version,
+        committedAt: body?.committedAt,
+      }));
+    } catch (error) {
+      ctx.sendJson(409, { error: error.message });
+    }
+    return true;
+  }
+
+  if (ctx.pathname !== '/entities/register' || ctx.method !== 'POST') return false;
+
+  const body = await ctx.readJsonBody();
+  if (body?.path !== undefined && body?.paths !== undefined) {
+    ctx.sendJson(400, { error: 'send either path or paths, not both' });
+    return true;
+  }
+  const targets = Array.isArray(body?.paths)
+    ? body.paths.map((target) => typeof target === 'string' ? target.trim() : '')
+    : [typeof body?.path === 'string' ? body.path.trim() : ''];
+  if (targets.length === 0 || targets.some((target) => !target)) {
+    ctx.sendJson(400, { error: 'path or paths is required: one or more absolute paths to register' });
+    return true;
+  }
+
+  try {
+    const results = await registrationService().registerMany(targets);
+    // Preserve the one-path response while exposing the full batch result to
+    // the CLI and any future SDK. One registration remains a degenerate batch.
+    ctx.sendJson(200, results.length === 1 ? { ...results[0], results } : { results });
+  } catch (error) {
+    if (!isRefusal(error)) throw error;
+    ctx.sendJson(400, { error: error.message });
+  }
+  return true;
+}
+
+module.exports = { handleEntityRoutes, privateUserHomeResourceId, userHomeCloudIdentity };

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

@@ -59,19 +59,6 @@ async function handleStateRoutes(ctx) {
       ));
       return true;
     }
-    if (ctx.pathname === '/state/repo-objects/uploads/fail') {
-      const body = await ctx.readJsonBody();
-      ctx.sendJson(200, require('../../workspace/objects').failUpload(
-        body?.resourceId,
-        body?.sha256,
-        {
-          retryable: body?.retryable,
-          code: body?.code,
-          message: body?.message,
-        },
-      ));
-      return true;
-    }
     if (ctx.pathname === '/state/repo-objects/downloads/claim') {
       ctx.sendJson(200, { download: require('../../workspace/objects').claimDownload() });
       return true;

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

@@ -4,7 +4,7 @@ const crypto = require('crypto');
 
 const { cachedStatement, openLocalDb } = require('./db');
 const { isSharedResourceId } = require('./cloud-resource-id');
-const { appendStateEvent, insertStateEvent } = require('./events');
+const { appendStateEvent } = require('./events');
 
 const ATTACHMENT_ID = /^[A-Za-z0-9_-]{16,160}$/;
 
@@ -30,10 +30,6 @@ function normalizeRow(row) {
     attemptCount: Number(row.attempt_count),
     nextAttemptAt: row.next_attempt_at || null,
     lastError: row.last_error || null,
-    // Legacy requests predate the fence. Their target was required to be
-    // empty, so zero is the only conservative boundary: every surviving or
-    // newly captured local mutation remains overlay.
-    journalCursor: row.journal_cursor == null ? 0 : Number(row.journal_cursor),
     createdAt: row.created_at,
     updatedAt: row.updated_at,
   };
@@ -58,16 +54,12 @@ function enqueueAttachment(input, options = {}) {
     return { attachment, duplicate: true };
   }
   const now = new Date().toISOString();
-  const journalCursor = Number(
-    cachedStatement(database, 'SELECT COALESCE(MAX(journal_id), 0) AS cursor FROM mutation_journal')
-      .get().cursor,
-  );
   try {
     cachedStatement(database, `
       INSERT INTO shared_resource_attachments (
-        attachment_id, resource_id, local_path, journal_cursor, created_at, updated_at
-      ) VALUES (?, ?, ?, ?, ?, ?)
-    `).run(attachmentId, resourceId, localPath, journalCursor, now, now);
+        attachment_id, resource_id, local_path, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?)
+    `).run(attachmentId, resourceId, localPath, now, now);
   } catch (error) {
     if (String(error?.code || '').includes('CONSTRAINT')) {
       throw invalid('that resource or local path already has an attachment request', 409);
@@ -78,22 +70,14 @@ function enqueueAttachment(input, options = {}) {
     cachedStatement(database, 'SELECT * FROM shared_resource_attachments WHERE attachment_id = ?')
       .get(attachmentId),
   );
-  const eventInput = {
+  appendStateEvent({
     resource: 'shared:attachments',
     op: 'update',
     id: attachmentId,
     sharedResourceId: resourceId,
     value: { state: 'pending' },
     source: 'shared:attachment',
-  };
-  if (options.deferEvent === true) {
-    return {
-      attachment,
-      duplicate: false,
-      deferredEvent: insertStateEvent(database, eventInput),
-    };
-  }
-  appendStateEvent(eventInput);
+  });
   return { attachment, duplicate: false };
 }
 
@@ -145,16 +129,7 @@ function acknowledgeAttachment(attachmentIdInput, payload, options = {}) {
 
   const installed = payload?.contract === 'workspace-tree@1'
     ? require('../workspace/tree-store').installCloudTreeSnapshot(attachment.localPath, payload, { database })
-    : payload?.contract === 'code-project-stream@2'
-      ? require('../workspace/project-stream').installSnapshot(
-        attachment.localPath,
-        payload,
-        { database },
-      )
-      : require('./docs').installCloudDocSnapshot(attachment.localPath, {
-        ...payload,
-        attachmentJournalCursor: attachment.journalCursor,
-      });
+    : require('./docs').installCloudDocSnapshot(attachment.localPath, payload);
   const now = new Date().toISOString();
   cachedStatement(database, `
     UPDATE shared_resource_attachments
@@ -219,30 +194,21 @@ function requestRehydration(input, options = {}) {
   let attachmentId;
   if (existing) {
     attachmentId = existing.attachment_id;
-    const journalCursor = Number(
-      cachedStatement(database, 'SELECT COALESCE(MAX(journal_id), 0) AS cursor FROM mutation_journal')
-        .get().cursor,
-    );
     cachedStatement(database, `
       UPDATE shared_resource_attachments
       SET attachment_state = 'pending',
           next_attempt_at = NULL,
           last_error = NULL,
-          journal_cursor = ?,
           updated_at = ?
       WHERE attachment_id = ?
-    `).run(journalCursor, now, attachmentId);
+    `).run(now, attachmentId);
   } else {
     attachmentId = `att_${crypto.randomBytes(16).toString('base64url')}`;
-    const journalCursor = Number(
-      cachedStatement(database, 'SELECT COALESCE(MAX(journal_id), 0) AS cursor FROM mutation_journal')
-        .get().cursor,
-    );
     cachedStatement(database, `
       INSERT INTO shared_resource_attachments (
-        attachment_id, resource_id, local_path, journal_cursor, created_at, updated_at
-      ) VALUES (?, ?, ?, ?, ?, ?)
-    `).run(attachmentId, resourceId, replica.localPath, journalCursor, now, now);
+        attachment_id, resource_id, local_path, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?)
+    `).run(attachmentId, resourceId, replica.localPath, now, now);
   }
   const attachment = normalizeRow(
     cachedStatement(database, 'SELECT * FROM shared_resource_attachments WHERE attachment_id = ?')