amalgm 0.1.221 → 0.1.235

package/runtime/scripts/amalgm-mcp/workspace/project-stream.js

@@ -0,0 +1,323 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const { appendStateEvent } = require('../state/events');
+const { openLocalDb } = require('../state/db');
+
+const STREAM_CONTRACT = 'code-project-stream@1';
+const WALL_CONTRACT = 'code-project@6';
+const LOCAL_RESOURCE_PREFIX = 'code-project:';
+
+function invalid(message, statusCode = 400) {
+  return Object.assign(new Error(message), { statusCode });
+}
+
+function emptySnapshot(project) {
+  return { schemaVersion: 1, project, version: 0, records: [] };
+}
+
+function localResource(resourceId) {
+  return `${LOCAL_RESOURCE_PREFIX}${resourceId}`;
+}
+
+function normalizeRecord(input, project, official = false) {
+  if (
+    !input
+    || input.wall !== WALL_CONTRACT
+    || input.project !== project
+    || typeof input.machine !== 'string'
+    || !input.machine
+    || typeof input.mutationId !== 'string'
+    || !input.mutationId
+    || typeof input.publishedAt !== 'string'
+    || !Number.isFinite(Date.parse(input.publishedAt))
+    || !Array.isArray(input.cards)
+  ) throw invalid('code project record is invalid', 409);
+  const version = Number(input.version);
+  if (official && (!Number.isSafeInteger(version) || version < 1)) {
+    throw invalid('code project record has no official version', 409);
+  }
+  return {
+    ...input,
+    ...(Number.isSafeInteger(version) && version > 0 ? { version } : {}),
+  };
+}
+
+function normalizeSnapshot(input, project = null, official = false) {
+  if (
+    !input
+    || input.schemaVersion !== 1
+    || typeof input.project !== 'string'
+    || !input.project
+    || !Number.isSafeInteger(Number(input.version))
+    || Number(input.version) < 0
+    || !Array.isArray(input.records)
+    || (project && input.project !== project)
+  ) throw invalid('code project snapshot is invalid', 409);
+  const machines = new Set();
+  const records = input.records.map((record) => {
+    const normalized = normalizeRecord(record, input.project, official);
+    if (official && normalized.version > Number(input.version)) {
+      throw invalid('code project record is newer than its snapshot', 409);
+    }
+    if (machines.has(normalized.machine)) {
+      throw invalid('code project snapshot repeats a machine', 409);
+    }
+    machines.add(normalized.machine);
+    return normalized;
+  });
+  return {
+    schemaVersion: 1,
+    project: input.project,
+    version: Number(input.version),
+    records,
+  };
+}
+
+function readSnapshot(file, project) {
+  if (!fs.existsSync(file) || fs.statSync(file).size === 0) return emptySnapshot(project);
+  try {
+    return normalizeSnapshot(JSON.parse(fs.readFileSync(file, 'utf8')), project);
+  } catch (error) {
+    if (error?.statusCode) throw error;
+    throw invalid('code project snapshot is not JSON', 409);
+  }
+}
+
+function writeSnapshot(file, snapshot) {
+  fs.mkdirSync(require('path').dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(snapshot)}\n`);
+}
+
+function applyRecord(snapshot, record, version = null) {
+  const next = normalizeRecord(
+    version ? { ...record, version } : record,
+    snapshot.project,
+    false,
+  );
+  const records = new Map(snapshot.records.map((entry) => [entry.machine, entry]));
+  records.set(next.machine, next);
+  return {
+    ...snapshot,
+    version: Number.isSafeInteger(version)
+      ? Math.max(snapshot.version, version)
+      : snapshot.version,
+    records: [...records.values()].sort((left, right) => (
+      left.machine.localeCompare(right.machine)
+    )),
+  };
+}
+
+function records(project) {
+  const snapshot = readSnapshot(project.file, project.repoKey);
+  let changed = false;
+  const sealed = snapshot.records.map((record) => {
+    if (record.version) return record;
+    const mutation = require('../state/mutations').getMutation(
+      `resource:${project.resourceId}`,
+      record.mutationId,
+    );
+    const version = mutation?.officialCloudVersion;
+    if (!Number.isSafeInteger(version) || version < 1) return record;
+    changed = true;
+    return { ...record, version };
+  });
+  if (changed) writeSnapshot(project.file, {
+    ...snapshot,
+    version: Math.max(snapshot.version, ...sealed.map((record) => record.version || 0)),
+    records: sealed,
+  });
+  return sealed;
+}
+
+function publish(project, record) {
+  const replica = require('../state/replicas').getReplicaByResourceId(project.resourceId);
+  if (!replica || replica.contract !== STREAM_CONTRACT) {
+    throw invalid('code project stream is not attached', 409);
+  }
+  return require('../state/mutations').commitLocalMutation({
+    channelId: `resource:${project.resourceId}`,
+    localResource: localResource(project.resourceId),
+    sharedResourceId: project.resourceId,
+    mutationId: record.mutationId,
+    deviceId: require('./identity').machineId(),
+    authorityEpoch: replica.authorityEpoch,
+    baseCloudVersion: replica.appliedVersion,
+    contract: STREAM_CONTRACT,
+    schemaVersion: 1,
+    operationKind: 'code.publish',
+    operation: { kind: 'code.publish', record },
+  }, {
+    materialize() {
+      writeSnapshot(
+        project.file,
+        applyRecord(readSnapshot(project.file, project.repoKey), record),
+      );
+    },
+    event: {
+      resource: localResource(project.resourceId),
+      op: 'update',
+      id: project.file,
+      sharedResourceId: project.resourceId,
+      value: record,
+      source: 'code-project:local',
+    },
+  });
+}
+
+function seal(project, mutationId, version) {
+  if (!Number.isSafeInteger(Number(version)) || Number(version) < 1) return false;
+  const snapshot = readSnapshot(project.file, project.repoKey);
+  let changed = false;
+  const records = snapshot.records.map((record) => {
+    if (record.mutationId !== mutationId || record.version === Number(version)) return record;
+    changed = true;
+    return { ...record, version: Number(version) };
+  });
+  if (!changed) return false;
+  writeSnapshot(project.file, {
+    ...snapshot,
+    version: Math.max(snapshot.version, Number(version)),
+    records,
+  });
+  appendStateEvent({
+    resource: localResource(project.resourceId),
+    op: 'update',
+    id: project.file,
+    sharedResourceId: project.resourceId,
+    resourceVersion: Number(version),
+    source: 'code-project:ack',
+  });
+  return true;
+}
+
+function decodeSnapshot(input) {
+  if (input?.contract !== STREAM_CONTRACT || Number(input?.schemaVersion) !== 1) {
+    throw invalid('unsupported code project stream', 409);
+  }
+  const bytes = Buffer.from(String(input.snapshotBase64 || ''), 'base64');
+  if (
+    !bytes.length
+    || crypto.createHash('sha256').update(bytes).digest('hex') !== input.snapshotChecksum
+  ) throw invalid('code project snapshot checksum mismatch', 409);
+  let parsed;
+  try {
+    parsed = JSON.parse(bytes.toString('utf8'));
+  } catch {
+    throw invalid('code project snapshot must be JSON', 409);
+  }
+  const snapshot = normalizeSnapshot(parsed, null, true);
+  if (snapshot.version !== Number(input.snapshotVersion)) {
+    throw invalid('code project snapshot version mismatch', 409);
+  }
+  return { bytes, snapshot };
+}
+
+function installSnapshot(file, input, options = {}) {
+  const database = options.database || openLocalDb();
+  const { snapshot } = decodeSnapshot(input);
+  const replicas = require('../state/replicas');
+  const existing = replicas.getReplicaByResourceId(input.resourceId, { database });
+  if (existing && existing.localPath !== file) {
+    throw invalid('code project stream is bound to another local file', 409);
+  }
+  let installed = snapshot;
+  if (existing) {
+    for (const mutation of require('../state/mutations').listPendingCloudMutations(
+      input.resourceId,
+      { database },
+    )) {
+      if (mutation.contract !== STREAM_CONTRACT || mutation.operationKind !== 'code.publish') continue;
+      installed = applyRecord(installed, mutation.operation?.record);
+    }
+  }
+  writeSnapshot(file, installed);
+  const registered = existing
+    ? {
+      replica: replicas.advanceReplicaSnapshot({
+        resourceId: input.resourceId,
+        snapshotVersion: input.snapshotVersion,
+        snapshotChecksum: input.snapshotChecksum,
+        authorityEpoch: input.authorityEpoch,
+      }, { database }),
+    }
+    : replicas.registerReplica({
+      resourceId: input.resourceId,
+      localResource: localResource(input.resourceId),
+      localPath: file,
+      contract: STREAM_CONTRACT,
+      schemaVersion: 1,
+      authorityEpoch: input.authorityEpoch,
+      appliedVersion: input.snapshotVersion,
+      snapshotVersion: input.snapshotVersion,
+      snapshotChecksum: input.snapshotChecksum,
+    }, { database });
+  appendStateEvent({
+    resource: localResource(input.resourceId),
+    op: 'update',
+    id: file,
+    sharedResourceId: input.resourceId,
+    resourceVersion: Number(input.snapshotVersion),
+    source: 'code-project:snapshot',
+  });
+  return registered;
+}
+
+function applyCloudMutation(input, options = {}) {
+  const envelope = input?.envelope || {};
+  const record = envelope.operation?.record;
+  if (
+    envelope.contract !== STREAM_CONTRACT
+    || envelope.operationKind !== 'code.publish'
+    || envelope.operation?.kind !== 'code.publish'
+    || record?.mutationId !== envelope.mutationId
+  ) throw invalid('invalid code project cloud mutation', 409);
+  const database = options.database || openLocalDb();
+  const replica = require('../state/replicas').getReplicaByResourceId(
+    envelope.resourceId,
+    { database },
+  );
+  if (!replica || replica.contract !== STREAM_CONTRACT) {
+    throw invalid('unknown code project stream', 404);
+  }
+  return require('../state/mutations').ingestCloudMutation({
+    ...input,
+    localResource: localResource(envelope.resourceId),
+  }, {
+    database,
+    materialize() {
+      writeSnapshot(
+        replica.localPath,
+        applyRecord(
+          readSnapshot(replica.localPath, record.project),
+          record,
+          Number(input.version),
+        ),
+      );
+    },
+    event: {
+      resource: localResource(envelope.resourceId),
+      op: 'update',
+      id: replica.localPath,
+      sharedResourceId: envelope.resourceId,
+      resourceVersion: Number(input.version),
+      value: record,
+      source: 'code-project:cloud',
+    },
+  });
+}
+
+module.exports = {
+  LOCAL_RESOURCE_PREFIX,
+  STREAM_CONTRACT,
+  WALL_CONTRACT,
+  _test: { applyRecord, emptySnapshot, normalizeSnapshot },
+  applyCloudMutation,
+  installSnapshot,
+  publish,
+  readSnapshot,
+  records,
+  seal,
+  writeSnapshot,
+};