@viewportai/daemon 0.2.0 → 0.2.1

package/node_modules/@viewportai/context-engine/src/repo/materializer.js

@@ -0,0 +1,299 @@
+const { decryptJson } = require('../crypto/envelope');
+const { unwrapRepoKeyWithHpke } = require('../crypto/hpke-grants');
+const { unwrapKeyForIdentity } = require('../crypto/keys');
+const { verifyEnvelope } = require('../crypto/signatures');
+const { createProtocolValidator } = require('../protocol/schemas');
+const { allCandidates, allEntries } = require('../store/search');
+const { resetStore } = require('../store/sqlite');
+const { listJsonFiles, readJson, writeJson } = require('./files');
+
+const protocol = createProtocolValidator();
+
+function assertValidEvent(event) {
+  if (!protocol.validateEvent(event)) {
+    throw new Error(`Invalid context event schema: ${event.id ?? 'unknown'}`);
+  }
+
+  if (event.grant?.wrappedRepoKeyEnvelope) {
+    const grant = event.grant.wrappedRepoKeyEnvelope;
+    const validLegacyGrant = protocol.validateKeyGrant(grant);
+    const validHpkeGrant = protocol.validateKeyGrantHpkeDraft(grant);
+    if (!validLegacyGrant && !validHpkeGrant) {
+      throw new Error(
+        `Invalid context key grant schema: ${event.id ?? 'unknown'}`,
+      );
+    }
+  }
+}
+
+function unwrapSupportedGrant(wrappedRepoKeyEnvelope, identity) {
+  if (
+    wrappedRepoKeyEnvelope.version ===
+    'viewport.context_key_grant/hpke-draft-01'
+  ) {
+    throw new Error(
+      'HPKE key grant materialization is not wired into the synchronous POC store yet',
+    );
+  }
+
+  return unwrapKeyForIdentity(wrappedRepoKeyEnvelope, identity);
+}
+
+function grantRecipientNameFor(identity, actorName) {
+  return identity.grantRecipientName ?? actorName;
+}
+
+function grantRecipientIdentity(identity, actorName) {
+  return {
+    ...identity,
+    name: grantRecipientNameFor(identity, actorName),
+    encryptionPrivateKey:
+      identity.grantEncryptionPrivateKey ?? identity.encryptionPrivateKey,
+    hpkePrivateKey: identity.grantHpkePrivateKey ?? identity.hpkePrivateKey,
+  };
+}
+
+async function unwrapSupportedGrantAsync(
+  wrappedRepoKeyEnvelope,
+  identity,
+  { repoId, keyEpoch },
+) {
+  if (
+    wrappedRepoKeyEnvelope.version ===
+    'viewport.context_key_grant/hpke-draft-01'
+  ) {
+    return unwrapRepoKeyWithHpke(wrappedRepoKeyEnvelope, identity, {
+      expectedRepoId: repoId,
+      expectedKeyEpoch: keyEpoch,
+    });
+  }
+
+  return unwrapKeyForIdentity(wrappedRepoKeyEnvelope, identity);
+}
+
+function decryptEventPayload(event, identity, keys) {
+  if (event.visibility === 'private') {
+    if (event.actorName !== identity.name) {
+      throw new Error('Private event does not belong to actor');
+    }
+
+    return decryptJson(
+      event.encrypted,
+      Buffer.from(identity.personalKey, 'base64'),
+    );
+  }
+
+  const key = keys.epochs[String(event.keyEpoch)];
+  if (!key) {
+    throw new Error(`No key for epoch ${event.keyEpoch}`);
+  }
+
+  return decryptJson(event.encrypted, Buffer.from(key, 'base64'));
+}
+
+function materializeRepo({ paths, actorName, identity, publicKeys }) {
+  const db = resetStore(paths.db);
+  const keys = readJson(paths.keys, { epochs: {} });
+
+  const insertEntry = db.prepare(`
+    INSERT OR REPLACE INTO context_entries
+    (id, version_id, scope, title, body, source_kind, trust_state, source, created_at, superseded_by)
+    VALUES (@id, @versionId, @scope, @title, @body, @sourceKind, @trustState, @source, @createdAt, @supersededBy)
+  `);
+  const insertFts = db.prepare(`
+    INSERT INTO context_entries_fts (id, title, body) VALUES (?, ?, ?)
+  `);
+  const deleteFts = db.prepare(`
+    DELETE FROM context_entries_fts WHERE id = ?
+  `);
+  const insertCandidate = db.prepare(`
+    INSERT OR REPLACE INTO context_candidates
+    (id, proposal_event_id, payload_digest, title, body, source_kind, trust_state, source, created_at, status, priority_score)
+    VALUES (@id, @proposalEventId, @payloadDigest, @title, @body, @sourceKind, @trustState, @source, @createdAt, @status, @priorityScore)
+  `);
+  const assignCandidate = db.prepare(`
+    UPDATE context_candidates
+    SET status = 'assigned', assigned_to = @assignedTo, reviewed_at = @reviewedAt
+    WHERE id = @id AND status NOT IN ('approved', 'rejected', 'tombstoned')
+  `);
+  const approveCandidate = db.prepare(`
+    UPDATE context_candidates
+    SET status = 'approved', reviewed_by = @reviewedBy, reviewed_at = @reviewedAt
+    WHERE id = @id AND status NOT IN ('rejected', 'tombstoned')
+  `);
+  const rejectCandidate = db.prepare(`
+    UPDATE context_candidates
+    SET status = 'rejected', reviewed_by = @reviewedBy, review_reason = @reviewReason, reviewed_at = @reviewedAt
+    WHERE id = @id AND status != 'approved'
+  `);
+  const tombstoneCandidate = db.prepare(`
+    UPDATE context_candidates
+    SET status = 'tombstoned', reviewed_by = @reviewedBy, review_reason = @reviewReason, tombstoned_at = @tombstonedAt
+    WHERE id = @id AND status != 'approved'
+  `);
+  const insertEdge = db.prepare(`
+    INSERT INTO context_edges (from_id, relation, to_id) VALUES (?, ?, ?)
+  `);
+  const markSuperseded = db.prepare(`
+    UPDATE context_entries SET superseded_by = ? WHERE id = ?
+  `);
+
+  const tx = db.transaction(() => {
+    const eventFiles = listJsonFiles(paths.eventsDir);
+
+    for (const file of eventFiles) {
+      const event = readJson(file);
+      assertValidEvent(event);
+      const signerPublicKey = publicKeys.get(event.actorName);
+      if (!signerPublicKey || !verifyEnvelope(event, signerPublicKey)) {
+        throw new Error(`Invalid event signature: ${event.id}`);
+      }
+
+      if (
+        event.type === 'repo.created' ||
+        event.type === 'member.granted' ||
+        event.type === 'key.rotated'
+      ) {
+        if (
+          event.grant?.recipientName ===
+          grantRecipientNameFor(identity, actorName)
+        ) {
+          if (
+            event.grant.wrappedRepoKeyEnvelope.version ===
+            'viewport.context_key_grant/hpke-draft-01'
+          ) {
+            if (!keys.epochs[String(event.grant.keyEpoch)]) {
+              throw new Error(
+                'HPKE key grant requires async materialization before synchronous projection',
+              );
+            }
+          } else {
+            try {
+              keys.epochs[String(event.grant.keyEpoch)] = unwrapSupportedGrant(
+                event.grant.wrappedRepoKeyEnvelope,
+                grantRecipientIdentity(identity, actorName),
+              ).toString('base64');
+            } catch {
+              continue;
+            }
+          }
+        }
+      }
+    }
+
+    for (const file of eventFiles) {
+      const event = readJson(file);
+
+      if (
+        event.type === 'repo.created' ||
+        event.type === 'member.granted' ||
+        event.type === 'key.rotated'
+      ) {
+        continue;
+      }
+
+      let payload = null;
+      try {
+        payload = decryptEventPayload(event, identity, keys);
+      } catch {
+        continue;
+      }
+
+      if (event.type === 'entry.approved') {
+        const row = { ...payload, supersededBy: null };
+        insertEntry.run(row);
+        deleteFts.run(row.id);
+        insertFts.run(row.id, row.title, row.body);
+        for (const target of payload.appliesTo ?? []) {
+          insertEdge.run(row.id, 'applies_to', target);
+        }
+      }
+
+      if (event.type === 'entry.proposed') {
+        insertCandidate.run({
+          ...payload,
+          proposalEventId: event.id,
+          payloadDigest: event.payloadDigest,
+        });
+      }
+
+      if (event.type === 'candidate.assigned') {
+        assignCandidate.run(payload);
+      }
+
+      if (event.type === 'candidate.approved') {
+        approveCandidate.run(payload);
+      }
+
+      if (event.type === 'candidate.rejected') {
+        rejectCandidate.run(payload);
+      }
+
+      if (event.type === 'candidate.tombstoned') {
+        tombstoneCandidate.run(payload);
+      }
+
+      if (event.type === 'entry.superseded') {
+        markSuperseded.run(payload.supersededBy, payload.id);
+        insertEdge.run(payload.id, 'superseded_by', payload.supersededBy);
+      }
+    }
+  });
+
+  tx();
+  writeJson(paths.keys, keys);
+
+  const result = {
+    entries: allEntries(db),
+    candidates: allCandidates(db),
+  };
+  db.close();
+  return result;
+}
+
+async function materializeRepoAsync({
+  paths,
+  actorName,
+  identity,
+  publicKeys,
+}) {
+  const eventFiles = listJsonFiles(paths.eventsDir);
+  const keys = readJson(paths.keys, { epochs: {} });
+
+  for (const file of eventFiles) {
+    const event = readJson(file);
+    assertValidEvent(event);
+    const signerPublicKey = publicKeys.get(event.actorName);
+    if (!signerPublicKey || !verifyEnvelope(event, signerPublicKey)) {
+      throw new Error(`Invalid event signature: ${event.id}`);
+    }
+
+    if (
+      event.type === 'repo.created' ||
+      event.type === 'member.granted' ||
+      event.type === 'key.rotated'
+    ) {
+      if (
+        event.grant?.recipientName ===
+        grantRecipientNameFor(identity, actorName)
+      ) {
+        try {
+          keys.epochs[String(event.grant.keyEpoch)] = (
+            await unwrapSupportedGrantAsync(
+              event.grant.wrappedRepoKeyEnvelope,
+              grantRecipientIdentity(identity, actorName),
+              { repoId: event.repoId, keyEpoch: event.grant.keyEpoch },
+            )
+          ).toString('base64');
+        } catch {
+          continue;
+        }
+      }
+    }
+  }
+
+  writeJson(paths.keys, keys);
+  return materializeRepo({ paths, actorName, identity, publicKeys });
+}
+
+module.exports = { materializeRepo, materializeRepoAsync };

package/node_modules/@viewportai/context-engine/src/repo/membership.js

@@ -0,0 +1,177 @@
+const { createRepoKey, wrapKeyForIdentity } = require('../crypto/keys');
+const { wrapRepoKeyWithHpke } = require('../crypto/hpke-grants');
+const { listJsonFiles, readJson, writeJson } = require('./files');
+const { repoPaths } = require('./paths');
+
+function grantRepo(vault, { repoId, actorName, recipientName }) {
+  const recipient = vault.getKnownIdentity(recipientName);
+  const metadata = vault.getRepoMetadata(repoId);
+  const repoKey = vault.getRepoKey(repoId, metadata.currentKeyEpoch);
+
+  return appendGrantEvent(vault, {
+    repoId,
+    actorName,
+    recipient,
+    keyEpoch: metadata.currentKeyEpoch,
+    repoKey,
+    eventType: 'member.granted',
+  });
+}
+
+async function grantRepoHpke(vault, { repoId, actorName, recipientName }) {
+  const recipient = vault.getKnownIdentity(recipientName);
+  const metadata = vault.getRepoMetadata(repoId);
+  const repoKey = vault.getRepoKey(repoId, metadata.currentKeyEpoch);
+
+  return appendGrantEventHpke(vault, {
+    repoId,
+    actorName,
+    recipient,
+    keyEpoch: metadata.currentKeyEpoch,
+    repoKey,
+    eventType: 'member.granted',
+  });
+}
+
+function revokeRepo(vault, { repoId, actorName, recipientName }) {
+  const actor = vault.getIdentity(actorName);
+  const actorRecipientName = actor.grantRecipientName ?? actorName;
+  const paths = repoPaths(vault.home, repoId);
+  const metadata = vault.getRepoMetadata(repoId);
+  const active = activeRecipients(vault.home, repoId);
+  active.delete(recipientName);
+  active.add(actorRecipientName);
+
+  const nextEpoch = metadata.currentKeyEpoch + 1;
+  const nextRepoKey = createRepoKey();
+  const keys = readJson(paths.keys, { epochs: {} });
+  keys.epochs[String(nextEpoch)] = nextRepoKey.toString('base64');
+  writeJson(paths.keys, keys);
+  writeJson(paths.metadata, { ...metadata, currentKeyEpoch: nextEpoch });
+
+  const revokeEvent = vault.appendUnsignedEvent({
+    repoId,
+    actor,
+    type: 'member.revoked',
+    keyEpoch: metadata.currentKeyEpoch,
+    visibility: 'shared',
+    grant: {
+      revokedName: recipientName,
+      nextKeyEpoch: nextEpoch,
+    },
+  });
+
+  const rotateEvents = [...active]
+    .sort()
+    .map((activeRecipientName) => appendGrantEvent(vault, {
+      repoId,
+      actorName,
+      recipient: vault.getKnownIdentity(activeRecipientName),
+      keyEpoch: nextEpoch,
+      repoKey: nextRepoKey,
+      eventType: 'key.rotated',
+    }));
+
+  return { revokeEvent, rotateEvent: rotateEvents[0], rotateEvents };
+}
+
+async function revokeRepoHpke(vault, { repoId, actorName, recipientName }) {
+  const actor = vault.getIdentity(actorName);
+  const actorRecipientName = actor.grantRecipientName ?? actorName;
+  const paths = repoPaths(vault.home, repoId);
+  const metadata = vault.getRepoMetadata(repoId);
+  const active = activeRecipients(vault.home, repoId);
+  active.delete(recipientName);
+  active.add(actorRecipientName);
+
+  const nextEpoch = metadata.currentKeyEpoch + 1;
+  const nextRepoKey = createRepoKey();
+  const keys = readJson(paths.keys, { epochs: {} });
+  keys.epochs[String(nextEpoch)] = nextRepoKey.toString('base64');
+  writeJson(paths.keys, keys);
+  writeJson(paths.metadata, { ...metadata, currentKeyEpoch: nextEpoch });
+
+  const revokeEvent = vault.appendUnsignedEvent({
+    repoId,
+    actor,
+    type: 'member.revoked',
+    keyEpoch: metadata.currentKeyEpoch,
+    visibility: 'shared',
+    grant: {
+      revokedName: recipientName,
+      nextKeyEpoch: nextEpoch,
+    },
+  });
+
+  const rotateEvents = [];
+  for (const activeRecipientName of [...active].sort()) {
+    rotateEvents.push(await appendGrantEventHpke(vault, {
+      repoId,
+      actorName,
+      recipient: vault.getKnownIdentity(activeRecipientName),
+      keyEpoch: nextEpoch,
+      repoKey: nextRepoKey,
+      eventType: 'key.rotated',
+    }));
+  }
+
+  return { revokeEvent, rotateEvent: rotateEvents[0], rotateEvents };
+}
+
+function appendGrantEvent(vault, { repoId, actorName, recipient, keyEpoch, repoKey, eventType }) {
+  return vault.appendUnsignedEvent({
+    repoId,
+    actor: vault.getIdentity(actorName),
+    type: eventType,
+    keyEpoch,
+    visibility: 'shared',
+    grant: {
+      recipientName: recipient.name,
+      keyEpoch,
+      wrappedRepoKeyEnvelope: wrapKeyForIdentity(repoKey, recipient),
+    },
+  });
+}
+
+async function appendGrantEventHpke(vault, { repoId, actorName, recipient, keyEpoch, repoKey, eventType }) {
+  return vault.appendUnsignedEvent({
+    repoId,
+    actor: vault.getIdentity(actorName),
+    type: eventType,
+    keyEpoch,
+    visibility: 'shared',
+    grant: {
+      recipientName: recipient.name,
+      keyEpoch,
+      wrappedRepoKeyEnvelope: await wrapRepoKeyWithHpke(repoKey, recipient, { repoId, keyEpoch }),
+    },
+  });
+}
+
+function activeRecipients(home, repoId) {
+  const recipients = new Set();
+
+  for (const eventFile of listJsonFiles(repoPaths(home, repoId).eventsDir)) {
+    const event = readJson(eventFile);
+
+    if (['repo.created', 'member.granted', 'key.rotated'].includes(event.type) && event.grant?.recipientName) {
+      recipients.add(event.grant.recipientName);
+    }
+
+    if (event.type === 'member.revoked' && event.grant?.revokedName) {
+      recipients.delete(event.grant.revokedName);
+    }
+  }
+
+  return recipients;
+}
+
+module.exports = {
+  activeRecipients,
+  appendGrantEvent,
+  appendGrantEventHpke,
+  grantRepo,
+  grantRepoHpke,
+  revokeRepo,
+  revokeRepoHpke,
+};

package/node_modules/@viewportai/context-engine/src/repo/paths.js

@@ -0,0 +1,25 @@
+const path = require('node:path');
+
+function vaultPaths(home) {
+  return {
+    home,
+    identitiesDir: path.join(home, 'identities'),
+    reposDir: path.join(home, 'repos'),
+  };
+}
+
+function repoPaths(home, repoId) {
+  const root = path.join(home, 'repos', repoId);
+
+  return {
+    root,
+    metadata: path.join(root, 'metadata.json'),
+    eventsDir: path.join(root, 'events'),
+    eraseReceiptsDir: path.join(root, 'erase-receipts'),
+    profilesDir: path.join(root, 'profiles'),
+    keys: path.join(root, 'keys.json'),
+    db: path.join(root, 'materialized.sqlite'),
+  };
+}
+
+module.exports = { repoPaths, vaultPaths };

package/node_modules/@viewportai/context-engine/src/repo/profiles.js

@@ -0,0 +1,54 @@
+const path = require('node:path');
+const { canonicalize } = require('../crypto/canonical');
+const { digest } = require('../crypto/envelope');
+const { writeJson, readJson } = require('./files');
+const { repoPaths } = require('./paths');
+
+class ContextProfilePinMismatchError extends Error {
+  constructor(mismatches) {
+    super(`Context profile pin mismatch: ${mismatches.map(({ field }) => field).join(', ')}`);
+    this.name = 'ContextProfilePinMismatchError';
+    this.code = 'CONTEXT_PROFILE_PIN_MISMATCH';
+    this.mismatches = mismatches;
+  }
+}
+
+function profilePath(name) {
+  return `.viewport/context/profiles/${name}.json`;
+}
+
+function writeProfile(home, { repoId, name, profile }) {
+  const paths = repoPaths(home, repoId);
+  const descriptor = {
+    schemaVersion: 'viewport.context_profile/v1',
+    name,
+    path: profilePath(name),
+    profile,
+    digest: digest(canonicalize(profile)),
+    updatedAt: new Date().toISOString(),
+  };
+  writeJson(path.join(paths.profilesDir, `${name}.json`), descriptor);
+  return descriptor;
+}
+
+function getProfile(home, { repoId, name, expected = null }) {
+  const descriptor = readJson(path.join(repoPaths(home, repoId).profilesDir, `${name}.json`));
+  if (!descriptor) {
+    throw new Error(`Unknown context profile: ${name}`);
+  }
+
+  const mismatches = [];
+  if (expected?.path && expected.path !== descriptor.path) {
+    mismatches.push({ field: 'path', expected: expected.path, actual: descriptor.path });
+  }
+  if (expected?.digest && expected.digest !== descriptor.digest) {
+    mismatches.push({ field: 'digest', expected: expected.digest, actual: descriptor.digest });
+  }
+  if (mismatches.length > 0) {
+    throw new ContextProfilePinMismatchError(mismatches);
+  }
+
+  return descriptor;
+}
+
+module.exports = { ContextProfilePinMismatchError, getProfile, writeProfile };

package/node_modules/@viewportai/context-engine/src/repo/receipts.js

@@ -0,0 +1,68 @@
+const crypto = require('node:crypto');
+const path = require('node:path');
+const { signEnvelope, verifyEnvelope } = require('../crypto/signatures');
+const { listJsonFiles, readJson, writeJson } = require('./files');
+const { repoPaths } = require('./paths');
+const { resetStore } = require('../store/sqlite');
+
+function cooperativeErase(vault, { repoId, actorName, revocationEventId }) {
+  const paths = repoPaths(vault.home, repoId);
+  const identity = vault.getIdentity(actorName);
+  const metadata = readJson(paths.metadata, { repoId, erasedActors: {} });
+  const revocationEvent = listJsonFiles(paths.eventsDir)
+    .map((file) => readJson(file))
+    .find((event) => event.id === revocationEventId);
+
+  if (!revocationEvent || revocationEvent.type !== 'member.revoked') {
+    throw new Error(`Unknown revocation event: ${revocationEventId}`);
+  }
+
+  if (revocationEvent.grant?.revokedName !== actorName) {
+    throw new Error(`Revocation event does not revoke ${actorName}`);
+  }
+
+  const erasedAt = new Date().toISOString();
+  writeJson(paths.metadata, {
+    ...metadata,
+    erasedActors: {
+      ...(metadata.erasedActors ?? {}),
+      [actorName]: erasedAt,
+    },
+  });
+  writeJson(paths.keys, { epochs: {} });
+  resetStore(paths.db).close();
+
+  const receipt = {
+    schemaVersion: 'viewport.context_erase_receipt/v1',
+    id: `erase_${crypto.randomUUID()}`,
+    repoId,
+    actorName,
+    revocationEventId,
+    erasedAt,
+    cacheTombstoned: true,
+  };
+  const signed = {
+    ...receipt,
+    signature: signEnvelope(receipt, identity),
+  };
+  writeJson(path.join(paths.eraseReceiptsDir, `${signed.id}.json`), signed);
+  return signed;
+}
+
+function verifyEraseReceipt(vault, { repoId, receipt }) {
+  const publicKeys = vault.loadPublicKeys();
+  const publicKey = publicKeys.get(receipt.actorName);
+  if (!publicKey || !verifyEnvelope(receipt, publicKey)) {
+    return false;
+  }
+
+  return listJsonFiles(repoPaths(vault.home, repoId).eventsDir)
+    .map((file) => readJson(file))
+    .some((event) => (
+      event.id === receipt.revocationEventId
+      && event.type === 'member.revoked'
+      && event.grant?.revokedName === receipt.actorName
+    ));
+}
+
+module.exports = { cooperativeErase, verifyEraseReceipt };