@agilno-tech/rivet 0.1.0-alpha.0

package/src/state/snapshot-store.js

@@ -0,0 +1,310 @@
+import { constants } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { basename, join } from 'node:path';
+import { lstat, open, rename, unlink } from 'node:fs/promises';
+import { setTimeout as delay } from 'node:timers/promises';
+
+import { acquireLock, LockBusyError } from './lock.js';
+import { assertResolvedStatePaths, verifyResolvedStatePaths } from './paths.js';
+import { redactSecrets } from './redact.js';
+
+const MAX_SNAPSHOT_BYTES = 4 * 1024 * 1024;
+const LOCK_WAIT_MS = 2_000;
+const NOFOLLOW = constants.O_NOFOLLOW ?? 0;
+const DIRECTORY = constants.O_DIRECTORY ?? 0;
+
+function sameIdentity(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+
+function privateRegularFile(metadata) {
+  return metadata.isFile()
+    && !metadata.isSymbolicLink()
+    && metadata.nlink === 1
+    && (metadata.mode & 0o777) === 0o600;
+}
+
+export class StateVersionExhaustedError extends Error {
+  constructor() {
+    super('state version is exhausted');
+    this.name = 'StateVersionExhaustedError';
+    this.code = 'ERR_STATE_VERSION_EXHAUSTED';
+  }
+}
+
+export class SnapshotDurabilityError extends Error {
+  constructor() {
+    super('Private snapshot durability is unsupported on this filesystem');
+    this.name = 'SnapshotDurabilityError';
+    this.code = 'ERR_STATE_DURABILITY_UNSUPPORTED';
+  }
+}
+
+async function metadataOrNull(path) {
+  try {
+    const metadata = await lstat(path);
+    if (!privateRegularFile(metadata)) throw new Error('Unsafe state snapshot');
+    return metadata;
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+function validSnapshot(snapshot) {
+  return snapshot
+    && typeof snapshot === 'object'
+    && !Array.isArray(snapshot)
+    && Object.keys(snapshot).length === 2
+    && Number.isSafeInteger(snapshot.version)
+    && snapshot.version >= 1
+    && Object.hasOwn(snapshot, 'data');
+}
+
+async function readBoundedUtf8(handle, maximumBytes) {
+  const buffer = Buffer.alloc(maximumBytes + 1);
+  let offset = 0;
+  while (offset < buffer.length) {
+    const { bytesRead } = await handle.read(buffer, offset, buffer.length - offset, null);
+    if (bytesRead === 0) break;
+    offset += bytesRead;
+  }
+  if (offset > maximumBytes) throw new Error('Invalid state snapshot');
+  try {
+    return new TextDecoder('utf-8', { fatal: true }).decode(buffer.subarray(0, offset));
+  } catch {
+    throw new Error('Invalid state snapshot');
+  }
+}
+
+async function readSnapshot(path) {
+  const before = await metadataOrNull(path);
+  if (!before) return null;
+  if (before.size <= 0 || before.size > MAX_SNAPSHOT_BYTES) throw new Error('Invalid state snapshot');
+  let handle;
+  try {
+    handle = await open(path, constants.O_RDONLY | NOFOLLOW);
+    const opened = await handle.stat();
+    if (!privateRegularFile(opened) || !sameIdentity(before, opened)) throw new Error('Unsafe state snapshot');
+    const source = await readBoundedUtf8(handle, MAX_SNAPSHOT_BYTES);
+    const after = await lstat(path);
+    if (!privateRegularFile(after) || !sameIdentity(opened, after) || after.size !== opened.size) {
+      throw new Error('State snapshot identity changed');
+    }
+    if (!source.endsWith('\n')) throw new Error('Invalid state snapshot');
+    let snapshot;
+    try { snapshot = JSON.parse(source); } catch { throw new Error('Invalid state snapshot'); }
+    if (!validSnapshot(snapshot)) throw new Error('Invalid state snapshot');
+    return snapshot;
+  } finally {
+    await handle?.close();
+  }
+}
+
+async function acquireWithRetry(path, options) {
+  const lockWaitMs = options.lockWaitMs ?? LOCK_WAIT_MS;
+  if (!Number.isSafeInteger(lockWaitMs) || lockWaitMs < 0 || lockWaitMs > 60_000) {
+    throw new TypeError('Invalid state lock wait');
+  }
+  const deadline = Date.now() + lockWaitMs;
+  while (true) {
+    try {
+      return await acquireLock(path, options.lockOptions);
+    } catch (error) {
+      if (!(error instanceof LockBusyError) || Date.now() >= deadline) throw error;
+      await delay(5);
+    }
+  }
+}
+
+async function openPrivateDirectory(path) {
+  const before = await lstat(path);
+  if (!before.isDirectory() || before.isSymbolicLink() || (before.mode & 0o777) !== 0o700) {
+    throw new Error('Private state path identity changed');
+  }
+  const handle = await open(path, constants.O_RDONLY | DIRECTORY | NOFOLLOW);
+  try {
+    const opened = await handle.stat();
+    if (!opened.isDirectory() || !sameIdentity(before, opened)) throw new Error('Private state path identity changed');
+    return handle;
+  } catch (error) {
+    await handle.close();
+    throw error;
+  }
+}
+
+async function verifyPrivateDirectory(paths, handle) {
+  await verifyResolvedStatePaths(paths);
+  const [opened, current] = await Promise.all([handle.stat(), lstat(paths.instanceDir)]);
+  if (!opened.isDirectory() || !current.isDirectory() || !sameIdentity(opened, current)) {
+    throw new Error('Private state path identity changed');
+  }
+}
+
+async function syncDirectory(handle) {
+  try {
+    await handle.sync();
+  } catch {
+    throw new SnapshotDurabilityError();
+  }
+}
+
+async function cleanupTemporary(paths, directoryHandle, temporaryPath, expected) {
+  if (!expected) return;
+  try {
+    await verifyPrivateDirectory(paths, directoryHandle);
+    const current = await lstat(temporaryPath);
+    if (privateRegularFile(current) && sameIdentity(current, expected)) await unlink(temporaryPath);
+  } catch {}
+}
+
+async function atomicWrite(paths, source, temporaryId, directoryHandle) {
+  const path = paths.snapshotPath;
+  const temporaryPath = join(paths.instanceDir, `.${basename(path)}.${temporaryId}.tmp`);
+  const targetBefore = await metadataOrNull(path);
+  let handle;
+  let createdMetadata;
+  let temporaryMetadata;
+  try {
+    handle = await open(
+      temporaryPath,
+      constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | NOFOLLOW,
+      0o600,
+    );
+    createdMetadata = await handle.stat();
+    if (!privateRegularFile(createdMetadata) || createdMetadata.size !== 0) {
+      throw new Error('Unsafe state snapshot temporary file');
+    }
+    await handle.chmod(0o600);
+    await handle.writeFile(source, { encoding: 'utf8' });
+    await handle.sync();
+    temporaryMetadata = await handle.stat();
+    if (
+      !privateRegularFile(temporaryMetadata)
+      || !sameIdentity(createdMetadata, temporaryMetadata)
+      || temporaryMetadata.size !== Buffer.byteLength(source)
+    ) {
+      throw new Error('State snapshot temporary identity changed');
+    }
+    await handle.close();
+    handle = null;
+    await verifyPrivateDirectory(paths, directoryHandle);
+    const targetNow = await metadataOrNull(path);
+    if (
+      (targetBefore === null) !== (targetNow === null)
+      || (targetBefore && !sameIdentity(targetBefore, targetNow))
+    ) {
+      throw new Error('State snapshot identity changed');
+    }
+    const temporaryNow = await lstat(temporaryPath);
+    if (!privateRegularFile(temporaryNow) || !sameIdentity(temporaryNow, temporaryMetadata)) {
+      throw new Error('State snapshot temporary identity changed');
+    }
+    await rename(temporaryPath, path);
+    await syncDirectory(directoryHandle);
+    const persisted = await metadataOrNull(path);
+    if (!persisted || !sameIdentity(persisted, temporaryMetadata)) throw new Error('State snapshot was not persisted');
+  } catch (error) {
+    await cleanupTemporary(paths, directoryHandle, temporaryPath, temporaryMetadata ?? createdMetadata);
+    if (error.code === 'EEXIST') throw new Error('Unsafe state snapshot temporary file');
+    throw error;
+  } finally {
+    await handle?.close();
+  }
+}
+
+function assertPaths(paths) {
+  assertResolvedStatePaths(paths);
+}
+
+function captureLockOptions(lockOptions) {
+  if (lockOptions === undefined) return undefined;
+  if (!lockOptions || typeof lockOptions !== 'object') throw new TypeError('Invalid state lock options');
+  return Object.freeze({
+    staleAfterMs: lockOptions.staleAfterMs,
+    now: lockOptions.now,
+  });
+}
+
+function captureStoreOptions(options) {
+  const beforeCommit = options.beforeCommit;
+  const temporaryIdFactory = options.temporaryIdFactory ?? randomUUID;
+  if (beforeCommit !== undefined && typeof beforeCommit !== 'function') {
+    throw new TypeError('Invalid snapshot hook');
+  }
+  if (typeof temporaryIdFactory !== 'function') throw new TypeError('Invalid snapshot temporary ID factory');
+  return Object.freeze({
+    lockWaitMs: options.lockWaitMs,
+    lockOptions: captureLockOptions(options.lockOptions),
+    secretKeys: options.secretKeys,
+    environment: options.environment,
+    beforeCommit,
+    temporaryIdFactory,
+  });
+}
+
+export function createSnapshotStore(paths, options = {}) {
+  assertPaths(paths);
+  const storeOptions = captureStoreOptions(options);
+
+  async function withLock(operation) {
+    await verifyResolvedStatePaths(paths);
+    const lock = await acquireWithRetry(paths.lockPath, storeOptions);
+    try {
+      await verifyResolvedStatePaths(paths);
+      return await operation();
+    } finally {
+      await lock.release();
+    }
+  }
+
+  return Object.freeze({
+    async read() {
+      return withLock(() => readSnapshot(paths.snapshotPath));
+    },
+    async version() {
+      return withLock(async () => (await readSnapshot(paths.snapshotPath))?.version ?? 0);
+    },
+    async write(data, writeOptions = {}) {
+      const expectedVersion = writeOptions.expectedVersion;
+      const preparedData = redactSecrets(data, {
+        secretKeys: writeOptions.secretKeys ?? storeOptions.secretKeys,
+        environment: writeOptions.environment ?? storeOptions.environment ?? process.env,
+      });
+      if (!Number.isSafeInteger(expectedVersion) || expectedVersion < 0) {
+        throw new TypeError('Snapshot write requires a non-negative expectedVersion');
+      }
+      if (storeOptions.beforeCommit) await storeOptions.beforeCommit();
+      const temporaryId = storeOptions.temporaryIdFactory();
+      if (typeof temporaryId !== 'string' || !/^[A-Za-z0-9-]{1,64}$/.test(temporaryId)) {
+        throw new TypeError('Invalid snapshot temporary identifier');
+      }
+      return withLock(async () => {
+        const directoryHandle = await openPrivateDirectory(paths.instanceDir);
+        try {
+          await verifyPrivateDirectory(paths, directoryHandle);
+          const current = await readSnapshot(paths.snapshotPath);
+          const currentVersion = current?.version ?? 0;
+          if (expectedVersion !== currentVersion) throw new Error('state version conflict');
+          if (currentVersion >= Number.MAX_SAFE_INTEGER) throw new StateVersionExhaustedError();
+          const snapshot = {
+            version: currentVersion + 1,
+            data: preparedData,
+          };
+          const source = `${JSON.stringify(snapshot)}\n`;
+          if (Buffer.byteLength(source) > MAX_SNAPSHOT_BYTES) throw new Error('State snapshot exceeds storage limit');
+          await atomicWrite(paths, source, temporaryId, directoryHandle);
+          return snapshot;
+        } finally {
+          await directoryHandle.close();
+        }
+      });
+    },
+  });
+}
+
+export async function readSnapshotWithoutLock(paths) {
+  assertPaths(paths);
+  await verifyResolvedStatePaths(paths);
+  return readSnapshot(paths.snapshotPath);
+}

package/src/status/public/app.js

@@ -0,0 +1,96 @@
+const byId = id => document.getElementById(id);
+
+function element(tag, text, className) {
+  const value = document.createElement(tag);
+  if (text !== undefined) value.textContent = String(text);
+  if (className) value.className = className;
+  return value;
+}
+
+function duration(milliseconds) {
+  const minutes = Math.floor((milliseconds ?? 0) / 60_000);
+  const hours = Math.floor(minutes / 60);
+  return hours > 0 ? `${hours}h ${minutes % 60}m` : `${minutes}m`;
+}
+
+function rows(target, values, render, empty = 'None') {
+  const children = values.length ? values.map(render) : [element('p', empty, 'muted')];
+  target.replaceChildren(...children);
+}
+
+function card(title, detail, status) {
+  const value = element('div', undefined, 'row');
+  const copy = element('div');
+  copy.append(element('strong', title), element('small', detail));
+  value.append(copy, element('span', status, `badge status-${status}`));
+  return value;
+}
+
+function render(model) {
+  byId('goal-heading').textContent = model.goal.id;
+  byId('stage').textContent = model.currentStage
+    ? `Current stage: ${model.currentStage.nodeId} · ${model.currentStage.status}`
+    : 'No active stage';
+  const metrics = [
+    ['State', model.goal.status], ['Elapsed', duration(model.budget.elapsedMs)],
+    ['Tokens', model.budget.usage.tokens], ['Cost', `$${model.budget.usage.costUsd}`],
+    ['Heartbeat', model.latestHeartbeatAt ? new Date(model.latestHeartbeatAt).toLocaleTimeString() : '—'],
+  ];
+  byId('metrics').replaceChildren(...metrics.map(([label, value]) => {
+    const metric = element('div', undefined, 'metric');
+    metric.append(element('span', label), element('strong', value));
+    return metric;
+  }));
+  rows(byId('graph'), model.graph.nodes, node => card(
+    node.id,
+    `${node.role} · parent ${node.parentId ?? 'root'} · depends on ${node.dependencies.join(', ') || 'none'}`,
+    node.status,
+  ));
+  rows(byId('agents'), model.agents, agent => card(agent.id, `${agent.role} · ${agent.currentNodeId} · ${duration(agent.elapsedMs)}`, agent.status));
+  rows(byId('worktrees'), model.worktrees, worktree => card(
+    worktree.nodeId,
+    `${worktree.ownerId} · ${worktree.displayPath}`,
+    worktree.status,
+  ), 'No owned worktrees');
+  rows(byId('gates'), model.gates, gate => card(gate.id, gate.requiredEvidence.join(' · '), gate.status), 'No human gates');
+  rows(byId('corrective'), model.correctiveWork, item => card(item.nodeId, `Attempt ${item.attempt}${item.reason ? ` · ${item.reason}` : ''}`, item.status), 'No corrective work');
+  rows(byId('evidence'), model.evidence, item => {
+    const value = card(item.id, `${item.type} · ${item.nodeId ?? 'goal'}`, item.approvalState);
+    if (item.url) {
+      const link = element('a', 'Open evidence', 'evidence-link');
+      link.href = item.url;
+      link.rel = 'noreferrer noopener';
+      value.append(link);
+    }
+    return value;
+  }, 'No evidence recorded');
+  rows(byId('decisions'), model.humanDecisions, item => card(item.gateId, `${item.actorId} · ${new Date(item.decidedAt).toLocaleTimeString()}`, item.decision), 'No human decisions');
+  rows(byId('events'), model.events.slice(-20).reverse(), item => card(item.type, `${item.nodeId ?? 'goal'} · #${item.sequence}`, item.actor.role), 'No events');
+}
+
+async function refresh() {
+  const response = await fetch('/api/state', { cache: 'no-store' });
+  if (!response.ok) throw new Error('status unavailable');
+  render(await response.json());
+}
+
+function connect() {
+  const source = new EventSource('/events');
+  source.onopen = () => {
+    byId('connection').textContent = 'Live';
+    byId('connection-dot').className = 'connected';
+  };
+  source.addEventListener('status', () => { void refresh(); });
+  source.addEventListener('reset', () => { void refresh(); });
+  source.addEventListener('unavailable', () => {
+    byId('connection').textContent = 'Reconnecting';
+    byId('connection-dot').className = '';
+  });
+  source.onerror = () => {
+    byId('connection').textContent = 'Reconnecting';
+    byId('connection-dot').className = '';
+  };
+}
+
+refresh().catch(() => { byId('connection').textContent = 'Unavailable'; });
+connect();

package/src/status/public/index.html

@@ -0,0 +1,37 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta name="color-scheme" content="dark">
+    <title>Orchestration status</title>
+    <link rel="stylesheet" href="/styles.css">
+    <script src="/app.js" defer></script>
+  </head>
+  <body>
+    <header class="masthead">
+      <div>
+        <p class="eyebrow">Local control room</p>
+        <h1>Orchestration status</h1>
+      </div>
+      <div class="connection"><span id="connection-dot"></span><span id="connection">Connecting</span></div>
+    </header>
+    <main>
+      <section class="hero panel" aria-labelledby="goal-heading">
+        <div><p class="eyebrow">Active goal</p><h2 id="goal-heading">Loading…</h2><p id="stage"></p></div>
+        <div id="metrics" class="metrics"></div>
+      </section>
+      <section class="layout">
+        <article class="panel span-two"><h2>Goal graph</h2><div id="graph" class="graph"></div></article>
+        <article class="panel"><h2>Agents</h2><div id="agents" class="stack"></div></article>
+        <article class="panel"><h2>Owned worktrees</h2><div id="worktrees" class="stack"></div></article>
+        <article class="panel"><h2>Human gates</h2><div id="gates" class="stack"></div></article>
+        <article class="panel"><h2>Corrective work</h2><div id="corrective" class="stack"></div></article>
+        <article class="panel"><h2>Evidence</h2><div id="evidence" class="stack"></div></article>
+        <article class="panel"><h2>Decisions</h2><div id="decisions" class="stack"></div></article>
+        <article class="panel span-two"><h2>Recent events</h2><div id="events" class="timeline"></div></article>
+      </section>
+    </main>
+    <noscript>This local status view requires JavaScript.</noscript>
+  </body>
+</html>

package/src/status/public/styles.css

@@ -0,0 +1,50 @@
+:root {
+  color-scheme: dark;
+  --ink: #f6f8ff;
+  --muted: #9ba7bd;
+  --panel: rgba(17, 25, 42, 0.9);
+  --line: rgba(173, 192, 229, 0.15);
+  --accent: #79e2c5;
+  --blue: #7eb6ff;
+  font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+
+* { box-sizing: border-box; }
+body {
+  margin: 0;
+  min-height: 100vh;
+  color: var(--ink);
+  background: radial-gradient(circle at 12% 0%, #17365b 0, transparent 38rem), #070c16;
+}
+.masthead, main { width: min(1800px, calc(100% - 48px)); margin-inline: auto; }
+.masthead { display: flex; align-items: center; justify-content: space-between; padding: 30px 0 18px; }
+h1, h2, p { margin: 0; }
+h1 { font-size: clamp(1.8rem, 3vw, 3.2rem); letter-spacing: -0.04em; }
+h2 { margin-bottom: 18px; font-size: 1.05rem; }
+.eyebrow { color: var(--accent); font-size: 0.72rem; font-weight: 800; letter-spacing: 0.16em; text-transform: uppercase; }
+.connection { display: flex; align-items: center; gap: 10px; color: var(--muted); }
+#connection-dot { width: 10px; height: 10px; border-radius: 50%; background: #f0b35c; box-shadow: 0 0 18px currentColor; }
+#connection-dot.connected { background: var(--accent); }
+.panel { padding: 22px; border: 1px solid var(--line); border-radius: 18px; background: var(--panel); backdrop-filter: blur(16px); }
+.hero { display: flex; align-items: end; justify-content: space-between; gap: 28px; margin-bottom: 16px; }
+.hero h2 { margin: 7px 0; font-size: clamp(1.5rem, 2.3vw, 2.6rem); }
+#stage { color: var(--muted); }
+.metrics { display: grid; grid-template-columns: repeat(5, minmax(100px, 1fr)); gap: 10px; }
+.metric { min-width: 105px; padding: 12px; border-left: 2px solid var(--blue); background: rgba(255,255,255,0.03); }
+.metric span, .row small { display: block; margin-bottom: 4px; color: var(--muted); font-size: 0.72rem; }
+.layout { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 16px; padding-bottom: 32px; }
+.span-two { grid-column: span 2; }
+.stack, .graph, .timeline { display: grid; gap: 9px; max-height: 420px; overflow: auto; }
+.graph { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+.row { display: flex; min-width: 0; align-items: center; justify-content: space-between; gap: 12px; padding: 11px 12px; border: 1px solid var(--line); border-radius: 11px; background: rgba(255,255,255,0.025); }
+.row > div { min-width: 0; }
+.row strong, .row small { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.badge { flex: none; padding: 4px 8px; border-radius: 999px; color: var(--blue); background: rgba(126,182,255,0.1); font-size: 0.68rem; text-transform: uppercase; }
+.status-completed, .status-approved, .status-alive { color: var(--accent); background: rgba(121,226,197,0.1); }
+.status-failed, .status-blocked, .status-corrective { color: #ff9ca5; background: rgba(255,91,110,0.1); }
+.evidence-link { color: var(--accent); font-size: 0.75rem; }
+.muted { color: var(--muted); }
+
+/* Presentation resolution keeps every operational lane visible on a single 16:9 screen. */
+@media (max-width: 1200px) { .layout { grid-template-columns: repeat(2, minmax(0, 1fr)); } .hero { align-items: stretch; flex-direction: column; } }
+@media (max-width: 720px) { .masthead, main { width: min(100% - 24px, 1800px); } .layout, .graph, .metrics { grid-template-columns: 1fr; } .span-two { grid-column: span 1; } }