sensemaking 0.24.4 → 0.24.6

package/dist/cjs/watch-claim.js

@@ -0,0 +1,446 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get WATCH_CLAIM_FILENAME () {
+        return WATCH_CLAIM_FILENAME;
+    },
+    get WATCH_HEARTBEAT_INTERVAL_MS () {
+        return WATCH_HEARTBEAT_INTERVAL_MS;
+    },
+    get WATCH_STALE_HEARTBEAT_MS () {
+        return WATCH_STALE_HEARTBEAT_MS;
+    },
+    get WatchClaimDatabase () {
+        return WatchClaimDatabase;
+    },
+    get readWatchClaim () {
+        return readWatchClaim;
+    },
+    get startWatchClaim () {
+        return startWatchClaim;
+    }
+});
+var _nodecrypto = require("node:crypto");
+var _nodefs = require("node:fs");
+var _nodepath = require("node:path");
+var _nodesqlite = require("node:sqlite");
+var _nodeworker_threads = require("node:worker_threads");
+var _errorsts = require("./errors.js");
+var _workerfilets = require("./lib/worker-file.js");
+var _workererrorts = require("./scan/worker-error.js");
+var _connectionts = require("./store/sqlite/connection.js");
+var _transactionts = require("./store/transaction.js");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else return left instanceof right;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var WATCH_CLAIM_FILENAME = '.sense-watch.db';
+var WATCH_HEARTBEAT_INTERVAL_MS = 5000;
+var WATCH_STALE_HEARTBEAT_MS = 15000;
+var CLAIM_BUSY_TIMEOUT_MS = 30000;
+function claimPath(configDir) {
+    return (0, _nodepath.join)(configDir, WATCH_CLAIM_FILENAME);
+}
+function changedOne(changes) {
+    return changes === 1 || changes === BigInt(1);
+}
+var WatchClaimDatabase = /*#__PURE__*/ function() {
+    "use strict";
+    function WatchClaimDatabase(configDir) {
+        _class_call_check(this, WatchClaimDatabase);
+        var db = new _nodesqlite.DatabaseSync(claimPath(configDir));
+        try {
+            db.exec("PRAGMA busy_timeout = ".concat(CLAIM_BUSY_TIMEOUT_MS));
+            db.exec('CREATE TABLE IF NOT EXISTS watch_claim (singleton INTEGER PRIMARY KEY CHECK (singleton = 1), token TEXT NOT NULL, pid INTEGER NOT NULL, heartbeat_ms INTEGER NOT NULL)');
+        } catch (err) {
+            try {
+                db.close();
+            } catch (closeError) {
+                throw new AggregateError([
+                    err,
+                    closeError
+                ], 'watch claim setup and database cleanup both failed');
+            }
+            throw err;
+        }
+        this.db = db;
+        this.conn = (0, _connectionts.createConnection)(db);
+    }
+    var _proto = WatchClaimDatabase.prototype;
+    _proto.acquire = function acquire(token, pid, force) {
+        return _async_to_generator(function() {
+            var _this;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _this = this;
+                        return [
+                            4,
+                            (0, _transactionts.withTransaction)(this.conn, function() {
+                                return _async_to_generator(function() {
+                                    var current, age;
+                                    return _ts_generator(this, function(_state) {
+                                        current = this.db.prepare('SELECT token, pid, heartbeat_ms FROM watch_claim WHERE singleton = 1').get();
+                                        if (current && !force) {
+                                            age = Date.now() - current.heartbeat_ms;
+                                            if (age >= 0 && age < WATCH_STALE_HEARTBEAT_MS) throw new _errorsts.SenseError('WATCH_ACTIVE', "another watcher appears active (heartbeat ".concat(Math.round(age / 1000), "s ago); use --force to override"));
+                                        }
+                                        this.db.prepare('INSERT INTO watch_claim (singleton, token, pid, heartbeat_ms) VALUES (1, ?, ?, ?) ON CONFLICT(singleton) DO UPDATE SET token = excluded.token, pid = excluded.pid, heartbeat_ms = excluded.heartbeat_ms').run(token, pid, Date.now());
+                                        return [
+                                            2
+                                        ];
+                                    });
+                                }).call(_this);
+                            }, _transactionts.BEGIN_WRITE)
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            2
+                        ];
+                }
+            });
+        }).call(this);
+    };
+    _proto.renew = function renew(token) {
+        return changedOne(this.db.prepare('UPDATE watch_claim SET heartbeat_ms = ? WHERE singleton = 1 AND token = ?').run(Date.now(), token).changes);
+    };
+    _proto.release = function release(token) {
+        return changedOne(this.db.prepare('DELETE FROM watch_claim WHERE singleton = 1 AND token = ?').run(token).changes);
+    };
+    _proto.read = function read() {
+        var row = this.db.prepare('SELECT token, pid, heartbeat_ms FROM watch_claim WHERE singleton = 1').get();
+        return row ? {
+            token: row.token,
+            pid: row.pid,
+            heartbeatMs: row.heartbeat_ms
+        } : null;
+    };
+    _proto.close = function close() {
+        this.db.close();
+    };
+    return WatchClaimDatabase;
+}();
+function readWatchClaim(configDir) {
+    var path = claimPath(configDir);
+    if (!(0, _nodefs.existsSync)(path)) return null;
+    var db;
+    try {
+        db = new _nodesqlite.DatabaseSync(path, {
+            readOnly: true
+        });
+    } catch (err) {
+        if (!(0, _nodefs.existsSync)(path)) return null;
+        throw err;
+    }
+    try {
+        db.exec("PRAGMA busy_timeout = ".concat(CLAIM_BUSY_TIMEOUT_MS));
+        var row = db.prepare('SELECT token, pid, heartbeat_ms FROM watch_claim WHERE singleton = 1').get();
+        return row ? {
+            token: row.token,
+            pid: row.pid,
+            heartbeatMs: row.heartbeat_ms
+        } : null;
+    } catch (err) {
+        if (/no such table: watch_claim/.test(err.message)) return null;
+        throw err;
+    } finally{
+        db.close();
+    }
+}
+function startWatchClaim(configDir, force, heartbeatIntervalMs, onFailure) {
+    return _async_to_generator(function() {
+        var workerData, worker, acquired, closing, exited, failureReported, closeError, closePromise, resolveExit, exit, resolveStart, rejectStart, start, fail, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    workerData = {
+                        configDir: configDir,
+                        force: force,
+                        heartbeatIntervalMs: heartbeatIntervalMs,
+                        pid: process.pid,
+                        token: (0, _nodecrypto.randomUUID)()
+                    };
+                    worker = new _nodeworker_threads.Worker((0, _workerfilets.resolveWorkerFile)('watch-heartbeat'), {
+                        workerData: workerData
+                    });
+                    acquired = false;
+                    closing = false;
+                    exited = false;
+                    failureReported = false;
+                    closeError = null;
+                    exit = new Promise(function(resolve) {
+                        resolveExit = resolve;
+                    });
+                    start = new Promise(function(resolve, reject) {
+                        resolveStart = resolve;
+                        rejectStart = reject;
+                    });
+                    fail = function fail(err) {
+                        if (failureReported) return;
+                        failureReported = true;
+                        if (!acquired) rejectStart(err);
+                        else if (closing) closeError !== null && closeError !== void 0 ? closeError : closeError = err;
+                        else onFailure(err);
+                    };
+                    worker.on('message', function(message) {
+                        if (message.type === 'acquired') {
+                            acquired = true;
+                            resolveStart();
+                        } else if (message.type === 'failure') {
+                            fail((0, _workererrorts.reviveError)(message.error));
+                        }
+                    });
+                    worker.on('error', fail);
+                    worker.on('exit', function(code) {
+                        exited = true;
+                        resolveExit();
+                        if (closing && code !== 0) closeError !== null && closeError !== void 0 ? closeError : closeError = new Error("watch heartbeat worker stopped with exit code ".concat(code));
+                        else if (!closing && !failureReported) fail(new Error("watch heartbeat worker stopped unexpectedly with exit code ".concat(code)));
+                    });
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        3,
+                        ,
+                        7
+                    ]);
+                    return [
+                        4,
+                        start
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        3,
+                        7
+                    ];
+                case 3:
+                    err = _state.sent();
+                    closing = true;
+                    if (!!exited) return [
+                        3,
+                        5
+                    ];
+                    return [
+                        4,
+                        worker.terminate()
+                    ];
+                case 4:
+                    _state.sent();
+                    _state.label = 5;
+                case 5:
+                    return [
+                        4,
+                        exit
+                    ];
+                case 6:
+                    _state.sent();
+                    throw err;
+                case 7:
+                    return [
+                        2,
+                        {
+                            close: function close() {
+                                closePromise !== null && closePromise !== void 0 ? closePromise : closePromise = function() {
+                                    return _async_to_generator(function() {
+                                        var err;
+                                        return _ts_generator(this, function(_state) {
+                                            switch(_state.label){
+                                                case 0:
+                                                    closing = true;
+                                                    if (!!exited) return [
+                                                        3,
+                                                        4
+                                                    ];
+                                                    _state.label = 1;
+                                                case 1:
+                                                    _state.trys.push([
+                                                        1,
+                                                        2,
+                                                        ,
+                                                        4
+                                                    ]);
+                                                    worker.postMessage({
+                                                        type: 'stop'
+                                                    });
+                                                    return [
+                                                        3,
+                                                        4
+                                                    ];
+                                                case 2:
+                                                    err = _state.sent();
+                                                    closeError !== null && closeError !== void 0 ? closeError : closeError = _instanceof(err, Error) ? err : new Error(String(err));
+                                                    return [
+                                                        4,
+                                                        worker.terminate()
+                                                    ];
+                                                case 3:
+                                                    _state.sent();
+                                                    return [
+                                                        3,
+                                                        4
+                                                    ];
+                                                case 4:
+                                                    return [
+                                                        4,
+                                                        exit
+                                                    ];
+                                                case 5:
+                                                    _state.sent();
+                                                    if (closeError) throw closeError;
+                                                    return [
+                                                        2
+                                                    ];
+                                            }
+                                        });
+                                    })();
+                                }();
+                                return closePromise;
+                            }
+                        }
+                    ];
+            }
+        });
+    })();
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/watch-claim.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/watch-claim.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto';\nimport { existsSync } from 'node:fs';\nimport { join } from 'node:path';\nimport { DatabaseSync } from 'node:sqlite';\nimport { Worker } from 'node:worker_threads';\nimport { SenseError } from './errors.ts';\nimport { resolveWorkerFile } from './lib/worker-file.ts';\nimport { reviveError, type WorkerErrorPayload } from './scan/worker-error.ts';\nimport { createConnection } from './store/sqlite/connection.ts';\nimport { BEGIN_WRITE, withTransaction } from './store/transaction.ts';\n\nexport const WATCH_CLAIM_FILENAME = '.sense-watch.db';\nexport const WATCH_HEARTBEAT_INTERVAL_MS = 5_000;\nexport const WATCH_STALE_HEARTBEAT_MS = 15_000;\nconst CLAIM_BUSY_TIMEOUT_MS = 30_000;\n\nexport interface WatchClaimRecord {\n  token: string;\n  pid: number;\n  heartbeatMs: number;\n}\n\ninterface ClaimRow {\n  token: string;\n  pid: number;\n  heartbeat_ms: number;\n}\n\nexport interface WatchClaimWorkerData {\n  configDir: string;\n  force: boolean;\n  heartbeatIntervalMs: number;\n  pid: number;\n  token: string;\n}\n\nexport type WatchClaimWorkerMessage = { type: 'acquired' } | { type: 'stopped' } | { type: 'failure'; error: WorkerErrorPayload };\n\nexport interface WatchClaimController {\n  close(): Promise<void>;\n}\n\nfunction claimPath(configDir: string): string {\n  return join(configDir, WATCH_CLAIM_FILENAME);\n}\n\nfunction changedOne(changes: number | bigint): boolean {\n  return changes === 1 || changes === BigInt(1);\n}\n\n// This database is separate from the selected search store so its heartbeat remains writable while\n// a DuckDB, Turso, or SQLite reconciliation owns the cache connection or blocks the main thread.\nexport class WatchClaimDatabase {\n  private readonly db: DatabaseSync;\n  private readonly conn: ReturnType<typeof createConnection>;\n\n  constructor(configDir: string) {\n    const db = new DatabaseSync(claimPath(configDir));\n    try {\n      db.exec(`PRAGMA busy_timeout = ${CLAIM_BUSY_TIMEOUT_MS}`);\n      db.exec('CREATE TABLE IF NOT EXISTS watch_claim (singleton INTEGER PRIMARY KEY CHECK (singleton = 1), token TEXT NOT NULL, pid INTEGER NOT NULL, heartbeat_ms INTEGER NOT NULL)');\n    } catch (err) {\n      try {\n        db.close();\n      } catch (closeError) {\n        throw new AggregateError([err, closeError], 'watch claim setup and database cleanup both failed');\n      }\n      throw err;\n    }\n    this.db = db;\n    this.conn = createConnection(db);\n  }\n\n  async acquire(token: string, pid: number, force: boolean): Promise<void> {\n    await withTransaction(\n      this.conn,\n      async () => {\n        const current = this.db.prepare('SELECT token, pid, heartbeat_ms FROM watch_claim WHERE singleton = 1').get() as ClaimRow | undefined;\n        if (current && !force) {\n          const age = Date.now() - current.heartbeat_ms;\n          if (age >= 0 && age < WATCH_STALE_HEARTBEAT_MS) throw new SenseError('WATCH_ACTIVE', `another watcher appears active (heartbeat ${Math.round(age / 1000)}s ago); use --force to override`);\n        }\n        this.db.prepare('INSERT INTO watch_claim (singleton, token, pid, heartbeat_ms) VALUES (1, ?, ?, ?) ON CONFLICT(singleton) DO UPDATE SET token = excluded.token, pid = excluded.pid, heartbeat_ms = excluded.heartbeat_ms').run(token, pid, Date.now());\n      },\n      BEGIN_WRITE\n    );\n  }\n\n  renew(token: string): boolean {\n    return changedOne(this.db.prepare('UPDATE watch_claim SET heartbeat_ms = ? WHERE singleton = 1 AND token = ?').run(Date.now(), token).changes);\n  }\n\n  release(token: string): boolean {\n    return changedOne(this.db.prepare('DELETE FROM watch_claim WHERE singleton = 1 AND token = ?').run(token).changes);\n  }\n\n  read(): WatchClaimRecord | null {\n    const row = this.db.prepare('SELECT token, pid, heartbeat_ms FROM watch_claim WHERE singleton = 1').get() as ClaimRow | undefined;\n    return row ? { token: row.token, pid: row.pid, heartbeatMs: row.heartbeat_ms } : null;\n  }\n\n  close(): void {\n    this.db.close();\n  }\n}\n\n// Status opens the coordinator read-only and therefore cannot create either the file or its schema.\nexport function readWatchClaim(configDir: string): WatchClaimRecord | null {\n  const path = claimPath(configDir);\n  if (!existsSync(path)) return null;\n  let db: DatabaseSync;\n  try {\n    db = new DatabaseSync(path, { readOnly: true });\n  } catch (err) {\n    if (!existsSync(path)) return null;\n    throw err;\n  }\n  try {\n    db.exec(`PRAGMA busy_timeout = ${CLAIM_BUSY_TIMEOUT_MS}`);\n    const row = db.prepare('SELECT token, pid, heartbeat_ms FROM watch_claim WHERE singleton = 1').get() as ClaimRow | undefined;\n    return row ? { token: row.token, pid: row.pid, heartbeatMs: row.heartbeat_ms } : null;\n  } catch (err) {\n    if (/no such table: watch_claim/.test((err as Error).message)) return null;\n    throw err;\n  } finally {\n    db.close();\n  }\n}\n\nexport async function startWatchClaim(configDir: string, force: boolean, heartbeatIntervalMs: number, onFailure: (err: Error) => void): Promise<WatchClaimController> {\n  const workerData: WatchClaimWorkerData = { configDir, force, heartbeatIntervalMs, pid: process.pid, token: randomUUID() };\n  const worker = new Worker(resolveWorkerFile('watch-heartbeat'), { workerData });\n  let acquired = false;\n  let closing = false;\n  let exited = false;\n  let failureReported = false;\n  let closeError: Error | null = null;\n  let closePromise: Promise<void> | undefined;\n  let resolveExit!: () => void;\n  const exit = new Promise<void>((resolve) => {\n    resolveExit = resolve;\n  });\n  let resolveStart!: () => void;\n  let rejectStart!: (err: Error) => void;\n  const start = new Promise<void>((resolve, reject) => {\n    resolveStart = resolve;\n    rejectStart = reject;\n  });\n\n  const fail = (err: Error): void => {\n    if (failureReported) return;\n    failureReported = true;\n    if (!acquired) rejectStart(err);\n    else if (closing) closeError ??= err;\n    else onFailure(err);\n  };\n  worker.on('message', (message: WatchClaimWorkerMessage) => {\n    if (message.type === 'acquired') {\n      acquired = true;\n      resolveStart();\n    } else if (message.type === 'failure') {\n      fail(reviveError(message.error));\n    }\n  });\n  worker.on('error', fail);\n  worker.on('exit', (code) => {\n    exited = true;\n    resolveExit();\n    if (closing && code !== 0) closeError ??= new Error(`watch heartbeat worker stopped with exit code ${code}`);\n    else if (!closing && !failureReported) fail(new Error(`watch heartbeat worker stopped unexpectedly with exit code ${code}`));\n  });\n\n  try {\n    await start;\n  } catch (err) {\n    closing = true;\n    if (!exited) await worker.terminate();\n    await exit;\n    throw err;\n  }\n\n  return {\n    close(): Promise<void> {\n      closePromise ??= (async () => {\n        closing = true;\n        if (!exited) {\n          try {\n            worker.postMessage({ type: 'stop' });\n          } catch (err) {\n            closeError ??= err instanceof Error ? err : new Error(String(err));\n            await worker.terminate();\n          }\n        }\n        await exit;\n        if (closeError) throw closeError;\n      })();\n      return closePromise;\n    },\n  };\n}\n"],"names":["WATCH_CLAIM_FILENAME","WATCH_HEARTBEAT_INTERVAL_MS","WATCH_STALE_HEARTBEAT_MS","WatchClaimDatabase","readWatchClaim","startWatchClaim","CLAIM_BUSY_TIMEOUT_MS","claimPath","configDir","join","changedOne","changes","BigInt","db","DatabaseSync","exec","err","close","closeError","AggregateError","conn","createConnection","acquire","token","pid","force","withTransaction","current","age","prepare","get","Date","now","heartbeat_ms","SenseError","Math","round","run","BEGIN_WRITE","renew","release","read","row","heartbeatMs","path","existsSync","readOnly","test","message","heartbeatIntervalMs","onFailure","workerData","worker","acquired","closing","exited","failureReported","closePromise","resolveExit","exit","resolveStart","rejectStart","start","fail","process","randomUUID","Worker","resolveWorkerFile","Promise","resolve","reject","on","type","reviveError","error","code","Error","terminate","postMessage","String"],"mappings":"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"}