toolroll 0.9.51 → 0.9.52

package/dist/workspace-revision.js

@@ -1,19 +1,275 @@
-/** Durable invalidation for authenticated workspace reads. This is cache
- * metadata only: it never grants access or certifies task/process state. */
-import { createHash } from 'node:crypto';
 import { DEFAULT_LIVENESS_MS } from './runner.js';
-/** The service_cursor row the revision triggers move (live-bus.ts listens for it). */
+/** The service_cursor row every meaningful commit moves (live-bus.ts listens for it). */
 export const WORKSPACE_REVISION_KEY = 'workspace-content:v1';
 const KEY = WORKSPACE_REVISION_KEY;
-const PREFIX = 'workspace_revision_v1_';
 const MAX_AGE_MS = 60_000;
-const OMIT = new Set(['schema_version', 'service_cursor', 'wake', 'notification_delivery',
+const OMIT = new Set(['schema_version', 'service_cursor', 'wake', 'notification_delivery', 'sqlite_sequence',
     'team_read', 'team_request', 'push_delivery', 'telegram_update', 'telegram_outbound_message', 'telegram_retry', 'bridge_lease']);
 const QUIET = {
     runner: ['heartbeat_at'], claim: ['heartbeat_at', 'expires_at'], watch_lease: ['heartbeat_at', 'expires_at'],
     watch_episode: ['ticks'], provider_readiness: ['observed_at'],
 };
-const identifier = (name) => `"${name.replaceAll('"', '""')}"`;
+/** A quiet beat that revives what a view already rendered as gone: the rows a beat may move, read before and after.
+ * A runner beat after its liveness window (or backwards) is a revival; a lease renewed at or past its expiry is one. */
+const REVIVAL = {
+    runner: { rows: 'SELECT rowid AS id, heartbeat_at AS h, NULL AS e FROM runner',
+        revived: (before, after) => after.h < before.h || Date.parse(after.h) >= Date.parse(before.h) + DEFAULT_LIVENESS_MS },
+    claim: { rows: 'SELECT rowid AS id, heartbeat_at AS h, expires_at AS e FROM claim WHERE released_at IS NULL', revived: (before, after) => before.e !== null && after.h >= before.e },
+    watch_lease: { rows: 'SELECT rowid AS id, heartbeat_at AS h, expires_at AS e FROM watch_lease', revived: (before, after) => before.e !== null && after.h >= before.e },
+};
+const BUMP = `INSERT INTO service_cursor(key,value,updated_at) VALUES ('${KEY}',1,strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+  ON CONFLICT(key) DO UPDATE SET value=service_cursor.value+1,updated_at=excluded.updated_at`;
+const NAME = String.raw `(?:"((?:[^"]|"")+)"|\[([^\]]+)\]|([A-Za-z_][\w$]*))`;
+const TABLE = new RegExp(String.raw `^(?:${NAME}\s*\.\s*)?${NAME}`);
+function tableAt(text) {
+    const match = TABLE.exec(text);
+    if (match === null)
+        return null;
+    const schema = match[1] ?? match[2] ?? match[3] ?? null;
+    const table = match[4] ?? match[5] ?? match[6];
+    return { schema: schema?.toLowerCase() ?? null, table: table.replaceAll('""', '"').toLowerCase(), rest: text.slice(match[0].length) };
+}
+/** The columns an UPDATE's SET clause assigns, or null when it can't be read (then the write counts). */
+function assigned(rest) {
+    const set = /^\s+SET\s+/i.exec(rest);
+    if (set === null)
+        return null;
+    const columns = [];
+    let depth = 0, quote = null, start = set[0].length;
+    const take = (end) => {
+        const lhs = rest.slice(start, end).split('=')[0].trim();
+        const names = lhs.startsWith('(') ? lhs.slice(1, -1).split(',') : [lhs];
+        for (const one of names) {
+            const name = tableAt(one.trim());
+            if (name === null)
+                return false;
+            columns.push(name.table);
+        }
+        return true;
+    };
+    for (let i = start; i < rest.length; i++) {
+        const c = rest[i];
+        if (quote !== null) {
+            if (c === quote)
+                quote = null;
+            continue;
+        }
+        if (c === "'" || c === '"' || c === '`') {
+            quote = c;
+            continue;
+        }
+        if (c === '(')
+            depth++;
+        else if (c === ')')
+            depth--;
+        else if (depth === 0 && c === ',') {
+            if (!take(i))
+                return null;
+            start = i + 1;
+        }
+        else if (depth === 0 && /^\s(?:WHERE|FROM|RETURNING|ORDER|LIMIT)\b/i.test(rest.slice(i, i + 11))) {
+            return take(i) ? columns : null;
+        }
+    }
+    return take(rest.length) ? columns : null;
+}
+export function statementEffect(sql) {
+    const text = sql.replace(/^(?:\s|--[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\/)+/, '');
+    if (/^BEGIN\b/i.test(text))
+        return { kind: 'begin' };
+    if (/^(?:COMMIT|END)\b/i.test(text))
+        return { kind: 'commit' };
+    let match = /^ROLLBACK(?:\s+TRANSACTION)?\s+TO\s+(?:SAVEPOINT\s+)?(\S+?)\s*;?\s*$/i.exec(text);
+    if (match !== null)
+        return { kind: 'rollback-to', name: match[1].toLowerCase() };
+    if (/^ROLLBACK\b/i.test(text))
+        return { kind: 'rollback' };
+    match = /^SAVEPOINT\s+(\S+?)\s*;?\s*$/i.exec(text);
+    if (match !== null)
+        return { kind: 'savepoint', name: match[1].toLowerCase() };
+    match = /^RELEASE\s+(?:SAVEPOINT\s+)?(\S+?)\s*;?\s*$/i.exec(text);
+    if (match !== null)
+        return { kind: 'release', name: match[1].toLowerCase() };
+    // WITH … is only ever a prefix to one data statement here; its CTEs cannot write.
+    const body = /^WITH\b/i.test(text) ? text.replace(/^WITH\b[\s\S]*?(?=\b(?:INSERT|REPLACE|UPDATE|DELETE)\b)/i, '') : text;
+    match = /^(?:(?:INSERT|REPLACE)(?:\s+OR\s+\w+)?\s+INTO|DELETE\s+FROM)\s+/i.exec(body);
+    const update = match === null ? /^UPDATE(?:\s+OR\s+\w+)?\s+/i.exec(body) : null;
+    const at = match ?? update;
+    if (at === null)
+        return { kind: 'none' };
+    const target = tableAt(body.slice(at[0].length));
+    if (target === null)
+        return { kind: 'write', table: '', quiet: false };
+    if (target.schema === 'temp' || OMIT.has(target.table) || target.table.startsWith('memory_search'))
+        return { kind: 'none' };
+    const quietColumns = QUIET[target.table];
+    if (update === null || quietColumns === undefined)
+        return { kind: 'write', table: target.table, quiet: false };
+    const columns = assigned(target.rest);
+    return { kind: 'write', table: target.table, quiet: columns !== null && columns.every(column => quietColumns.includes(column)) };
+}
+/** How many times this connection has moved the revision; read through any wrapper around it. */
+const BUMPS = Symbol('workspace revision bumps');
+/** Wrap one connection so each committed meaningful write moves the workspace revision exactly once. Native
+ * extensions (scalar functions, isTransaction) pass through; a test spy on prepare/exec replaces only the facade's. */
+export function trackWorkspaceWrites(db) {
+    const state = { bumps: 0 };
+    const effects = new Map();
+    const effectOf = (sql) => {
+        let effect = effects.get(sql);
+        if (effect === undefined) {
+            effect = statementEffect(sql);
+            if (effects.size >= 2048)
+                effects.clear();
+            effects.set(sql, effect);
+        }
+        return effect;
+    };
+    let open = false, dirty = false, bySavepoint = false;
+    let savepoints = [];
+    const native = db;
+    const inTransaction = () => typeof native.isTransaction === 'boolean' ? native.isTransaction : open;
+    let totals = null;
+    const total = () => Number((totals ??= db.prepare('SELECT total_changes() AS n')).get()?.['n'] ?? 0);
+    const bump = () => {
+        try {
+            db.exec(BUMP);
+            state.bumps++;
+        }
+        catch { /* a file without the cursor (an old shape opened bare) has no revision to move */ }
+    };
+    const reset = () => { open = false; dirty = false; bySavepoint = false; savepoints = []; };
+    /** A meaningful write changed a row: its transaction's commit moves the revision, or this autocommit does now. */
+    const wrote = () => { if (inTransaction())
+        dirty = true;
+    else
+        bump(); };
+    const control = (effect, run) => {
+        switch (effect.kind) {
+            case 'begin':
+                run();
+                reset();
+                open = true;
+                return;
+            case 'commit':
+                if (dirty) {
+                    bump();
+                    dirty = false;
+                }
+                run();
+                reset();
+                return;
+            case 'rollback':
+                try {
+                    run();
+                }
+                finally {
+                    reset();
+                }
+                return;
+            case 'savepoint':
+                if (!inTransaction()) {
+                    reset();
+                    bySavepoint = true;
+                }
+                run();
+                open = true;
+                savepoints.push({ name: effect.name, dirty });
+                return;
+            case 'rollback-to': {
+                run();
+                const at = savepoints.map(one => one.name).lastIndexOf(effect.name);
+                if (at >= 0) {
+                    dirty = savepoints[at].dirty;
+                    savepoints.length = at + 1;
+                }
+                return;
+            }
+            case 'release': {
+                const at = savepoints.map(one => one.name).lastIndexOf(effect.name);
+                // Releasing the savepoint that began the transaction commits it.
+                if (at === 0 && bySavepoint && dirty) {
+                    bump();
+                    dirty = false;
+                }
+                run();
+                if (at >= 0)
+                    savepoints.length = at;
+                if (!inTransaction())
+                    reset();
+                return;
+            }
+            default: run();
+        }
+    };
+    /** Run one data statement and report whether it changed the workspace. */
+    const measured = (effect, body) => {
+        if (effect.kind !== 'write')
+            return body();
+        const revival = effect.quiet ? REVIVAL[effect.table] : undefined;
+        const beats = () => new Map(db.prepare(revival.rows).all()
+            .map(row => [Number(row['id']), { h: String(row['h']), e: row['e'] == null ? null : String(row['e']) }]));
+        const before = revival === undefined ? null : beats();
+        const changes = total();
+        const result = body();
+        if (total() === changes)
+            return result;
+        if (!effect.quiet)
+            wrote();
+        else if (before !== null) {
+            for (const [id, after] of beats()) {
+                const was = before.get(id);
+                if (was !== undefined && was.h !== after.h && revival.revived(was, after)) {
+                    wrote();
+                    break;
+                }
+            }
+        }
+        return result;
+    };
+    const methods = {
+        exec(sql) {
+            let effect = effectOf(sql);
+            // A script of several statements is read by its first; past a quiet first one, any row it changes counts.
+            if (effect.kind === 'none' && /;\s*\S/.test(sql))
+                effect = { kind: 'write', table: '', quiet: false };
+            if (effect.kind === 'write' || effect.kind === 'none')
+                measured(effect, () => db.exec(sql));
+            else
+                control(effect, () => db.exec(sql));
+        },
+        prepare(sql) {
+            const statement = db.prepare(sql), effect = effectOf(sql);
+            if (effect.kind === 'none')
+                return statement;
+            const run = (body) => effect.kind === 'write' ? measured(effect, body) : (control(effect, () => { body(); }), undefined);
+            return passThrough(statement, {
+                run: (...params) => effect.kind === 'write' ? measured(effect, () => statement.run(...params)) : runControl(effect, control, () => statement.run(...params)),
+                get: (...params) => run(() => statement.get(...params)),
+                all: (...params) => run(() => statement.all(...params)),
+            });
+        },
+        close() { db.close(); },
+    };
+    return passThrough(db, Object.assign(methods, { [BUMPS]: () => state.bumps }));
+}
+function runControl(effect, control, body) {
+    let result = { changes: 0 };
+    control(effect, () => { result = body(); });
+    return result;
+}
+function passThrough(inner, methods) {
+    return new Proxy(methods, {
+        get(target, property) {
+            if (Object.hasOwn(target, property))
+                return Reflect.get(target, property);
+            const value = Reflect.get(inner, property, inner);
+            return typeof value === 'function' ? value.bind(inner) : value;
+        },
+        has: (target, property) => Reflect.has(target, property) || Reflect.has(inner, property),
+        getPrototypeOf: () => Object.getPrototypeOf(inner),
+    });
+}
 /** Per-server response metadata. Reads preserve insertion order; writes at
  * capacity discard the oldest key before storing the supplied validator. */
 export class WorkspaceValidatorCache {
@@ -27,46 +283,13 @@ export class WorkspaceValidatorCache {
 }
 export function prepareWorkspaceRevision(store) {
     const db = store.raw();
-    const bump = `INSERT INTO service_cursor(key,value,updated_at) VALUES ('${KEY}',1,strftime('%Y-%m-%dT%H:%M:%fZ','now'))
-    ON CONFLICT(key) DO UPDATE SET value=service_cursor.value+1,updated_at=excluded.updated_at;`;
-    const wanted = new Map();
-    // Virtual tables (the FTS5 memory index) cannot carry triggers, and their
-    // shadow tables are derived views rebuilt from the stores of record.
-    const tables = db.prepare("SELECT name FROM sqlite_schema WHERE type='table' AND name NOT LIKE 'sqlite_%' AND sql NOT LIKE 'CREATE VIRTUAL%' AND name NOT LIKE 'memory_search%'").all();
-    for (const row of tables) {
-        const table = String(row['name']);
-        if (OMIT.has(table))
-            continue;
-        const columns = db.prepare(`PRAGMA table_info(${identifier(table)})`).all().map(column => String(column['name']));
-        const meaningful = columns.filter(column => !QUIET[table]?.includes(column));
-        const changes = meaningful.map(column => `OLD.${identifier(column)} IS NOT NEW.${identifier(column)}`);
-        // A routine beat is quiet, but a revival after a liveness/lease gap must
-        // invalidate an already-rendered "offline" view immediately.
-        if (table === 'runner')
-            changes.push(`NEW.heartbeat_at < OLD.heartbeat_at OR NEW.heartbeat_at >= strftime('%Y-%m-%dT%H:%M:%fZ',OLD.heartbeat_at,'+${DEFAULT_LIVENESS_MS / 1000} seconds')`);
-        if (table === 'claim' || table === 'watch_lease')
-            changes.push('NEW.heartbeat_at >= OLD.expires_at');
-        for (const event of ['INSERT', 'UPDATE', 'DELETE']) {
-            const guard = event === 'UPDATE' ? ` WHEN ${changes.join(' OR ')}` : '';
-            const body = `AFTER ${event} ON ${identifier(table)}${guard} BEGIN ${bump} END`;
-            const digest = createHash('sha256').update(body).digest('hex').slice(0, 16);
-            wanted.set(`${PREFIX}${table}_${event.toLowerCase()}_${digest}`, body);
-        }
-    }
-    // Only DDL and one metadata row are written here; no task/history scan or
-    // backfill holds the writer. Existing installations perform no DDL writes.
-    store.transact(() => {
-        const existing = db.prepare("SELECT name FROM sqlite_schema WHERE type='trigger' AND name LIKE ?").all(`${PREFIX}%`);
-        const installed = new Set(existing.map(row => String(row['name'])).filter(name => name.startsWith(PREFIX)));
-        for (const name of installed)
-            if (!wanted.has(name))
-                db.exec(`DROP TRIGGER ${identifier(name)}`);
-        for (const [name, body] of wanted)
-            if (!installed.has(name))
-                db.exec(`CREATE TRIGGER ${identifier(name)} ${body}`);
-        db.prepare('INSERT OR IGNORE INTO service_cursor(key,value,updated_at) VALUES (?,0,?)').run(KEY, new Date().toISOString());
-    });
-    const current = db.prepare('SELECT CAST(value AS TEXT) AS value FROM service_cursor WHERE key = ?');
+    db.prepare('INSERT OR IGNORE INTO service_cursor(key,value,updated_at) VALUES (?,0,?)').run(KEY, new Date().toISOString());
+    const cursor = db.prepare('SELECT CAST(value AS TEXT) AS value FROM service_cursor WHERE key = ?');
+    // Another connection's commit moves data_version; this connection's own moves its bump count. Neither moved: the
+    // revision read last is still the revision.
+    const dataVersion = db.prepare('PRAGMA data_version');
+    const counted = db[BUMPS];
+    let seen = null;
     const boundary = db.prepare(`SELECT MIN(at) AS at FROM (
     SELECT MIN(expires_at) AS at FROM claim WHERE released_at IS NULL AND expires_at > ?
     UNION ALL SELECT MIN(until) FROM hold WHERE until > ?
@@ -79,10 +302,14 @@ export function prepareWorkspaceRevision(store) {
   )`);
     return {
         current() {
-            const value = current.get(KEY)?.['value'];
+            const data = dataVersion.get()?.['data_version'], bumps = counted?.() ?? -1;
+            if (seen !== null && counted !== undefined && seen.data === data && seen.bumps === bumps)
+                return seen.revision;
+            const value = cursor.get(KEY)?.['value'];
             if (typeof value !== 'string' || !/^\d+$/.test(value))
                 throw new Error('Workspace revision is unavailable');
-            return `v1:${value}`;
+            seen = { data, bumps, revision: `v1:${value}` };
+            return seen.revision;
         },
         expiresAt(now) {
             const iso = now.toISOString();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.51",
+  "version": "0.9.52",
   "description": "A control plane for unattended coding agents — queue tasks, walk away, come back to pull requests. Agents build in leased worktrees, never touch your default branch, and interrupt you only for decisions that need a human.",
   "directories": {
     "doc": "docs"
@@ -70,8 +70,6 @@
     "@types/react-dom": "19.3.0",
     "esbuild": "0.28.2",
     "happy-dom": "20.14.5",
-    "paper": "0.12.18",
-    "simple-icons": "16.34.0",
     "tailwindcss": "4.3.3",
     "tsx": "4.23.15",
     "typescript": "7.0.2",