attesso 0.7.0 → 0.8.0

package/README.md

@@ -42,11 +42,13 @@ export ATTESSO_SYNC_URL=https://api.attesso.com
 export ATTESSO_API_KEY=att_live_...
 npx attesso sync --dry-run
 npx attesso sync
+npx attesso sync --watch
 ```
 
 The API key must belong to an entitled live workspace. A retry after a failed
 request is safe: the server deduplicates by device and sequence, and the local
-cursor does not move until the batch is accepted.
+cursor does not move until the batch is accepted. `--watch` repeats every five
+seconds, so the hosted view follows a running agent without another command.
 
 ## The overview
 

package/bin/attesso.mjs

@@ -29,7 +29,7 @@ import { resolve } from 'node:path';
 import { CAPABILITIES, TRUST_LEVELS, validateRules } from './../src/rules.mjs';
 import { validatePathsConfig } from './../src/fs-paths.mjs';
 import { startUi } from './../src/ui/server.mjs';
-import { sync } from './../src/sync.mjs';
+import { sync, watchSync } from './../src/sync.mjs';
 
 const argv = process.argv.slice(2);
 const dirAt = argv.indexOf('--dir');
@@ -77,8 +77,9 @@ const USAGE = `attesso: a local, signed ledger of what your agents attempted
   attesso mode [observe|enforce|off]  read or set the active hook mode
   attesso paths [--json|--set FILE]   read or replace the filesystem scope
   attesso ui [--port N] [--no-open]    local control surface for the signed ledger
-  attesso sync [--url URL] [--limit N] [--json] [--dry-run]
+  attesso sync [--url URL] [--limit N] [--json] [--dry-run] [--watch]
                                      send the next decisions to the hosted mirror
+                                     --watch keeps it current every 5 seconds
                                      (key from ATTESSO_API_KEY; never printed)
   attesso explain <seq>              one entry in full: rule, tainting step, what to do
   attesso suggest [--json]           rules the ledger's own counts justify
@@ -628,13 +629,30 @@ switch (command) {
     try {
       const options = flags(rest);
       const requested = options.limit === undefined ? 50 : Number(options.limit);
-      const result = await sync({
-        dir: DIR,
-        url: typeof options.url === 'string' ? options.url : process.env.ATTESSO_SYNC_URL,
-        key: typeof options.key === 'string' ? options.key : process.env.ATTESSO_API_KEY,
-        limit: requested,
-        dryRun: rest.includes('--dry-run'),
-      });
+      const url = typeof options.url === 'string' ? options.url : process.env.ATTESSO_SYNC_URL;
+      const key = typeof options.key === 'string' ? options.key : process.env.ATTESSO_API_KEY;
+      if (rest.includes('--watch')) {
+        if (rest.includes('--dry-run')) throw new Error('--watch cannot be combined with --dry-run');
+        const controller = new AbortController();
+        process.on('SIGINT', () => controller.abort());
+        process.on('SIGTERM', () => controller.abort());
+        console.log('sync: watching the ledger; Ctrl-C stops');
+        await watchSync({
+          dir: DIR,
+          url,
+          key,
+          limit: requested,
+          intervalMs: options.interval === undefined ? 5000 : Number(options.interval),
+          signal: controller.signal,
+          onResult: (result) => {
+            if (result instanceof Error) console.error(`sync: ${result.message}`);
+            else if (options.json) console.log(JSON.stringify(result, null, 2));
+            else console.log(`sync: ${result.accepted} accepted, ${result.skipped} already present, ${result.metered} metered; last #${result.last_seq}`);
+          },
+        });
+        break;
+      }
+      const result = await sync({ dir: DIR, url, key, limit: requested, dryRun: rest.includes('--dry-run') });
       if (options.json) console.log(JSON.stringify(result, null, 2));
       else if (result.dry_run) console.log(`sync dry run: ${result.entries} decision(s) ready`);
       else console.log(`sync: ${result.accepted} accepted, ${result.skipped} already present, ${result.metered} metered; last #${result.last_seq}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "attesso",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Bounds: decide an AI agent's next tool call before it runs, with a signed record. Free and unlimited locally, $0.00085 per synced decision.",
   "license": "Apache-2.0",
   "type": "module",

package/src/sync.mjs

@@ -60,7 +60,10 @@ export async function sync({
   if (typeof deviceId !== 'string' || !/^[A-Za-z0-9._:-]{1,64}$/.test(deviceId)) {
     throw new Error('ledger key id is not a valid device id');
   }
-  const state = readSyncState(dir);
+  let state = readSyncState(dir);
+  if (state.device_id && state.device_id !== deviceId) {
+    state = { version: SYNC_VERSION, last_seq: 0 };
+  }
   const entries = [];
   forEachEntrySync(ledgerPath, (entry) => {
     if (entry.seq <= state.last_seq) return;
@@ -112,3 +115,37 @@ export async function sync({
   writeSyncState(dir, lastSeq, deviceId);
   return { accepted, skipped, metered, last_seq: lastSeq, device_id: deviceId };
 }
+
+
+// watchSync keeps the hosted mirror current for a long-running agent session.
+// It never advances the cursor on an error; the next tick retries the same
+// window. Callers stop it with an AbortSignal.
+export async function watchSync({
+  dir,
+  url,
+  key,
+  limit = DEFAULT_LIMIT,
+  intervalMs = 5000,
+  signal,
+  onResult = () => {},
+} = {}) {
+  if (!Number.isInteger(intervalMs) || intervalMs < 1000 || intervalMs > 300_000) {
+    throw new Error('interval must be an integer from 1000 to 300000 milliseconds');
+  }
+  while (!signal?.aborted) {
+    try {
+      const result = await sync({ dir, url, key, limit });
+      if (result.accepted || result.skipped || result.metered) onResult(result);
+    } catch (error) {
+      onResult(error);
+    }
+    if (signal?.aborted) break;
+    await new Promise((resolve) => {
+      const timer = setTimeout(resolve, intervalMs);
+      signal?.addEventListener('abort', () => {
+        clearTimeout(timer);
+        resolve();
+      }, { once: true });
+    });
+  }
+}