@steerable/agent-shell 0.6.55 → 0.6.57

package/dist/storage/sqlite-driver.js

@@ -1,11 +1,14 @@
+import { existsSync } from 'node:fs';
 import path from 'node:path';
 import Database from 'better-sqlite3';
 import { getProductConfig } from '../product-config.js';
 import { getUserDataDir } from '../runtime.js';
 import { LOCAL_SCOPE } from './driver.js';
 import { SqliteScopedStore } from './index.js';
-import { acquireWriteLease, lockPathForDb, } from './write-lease.js';
+import { HOST_SCHEMA_VERSION, OPEN_LOCK_WAIT_MS, StorageUpgradeBlockedError, openLockPath, } from './process-locks.js';
+import { acquireSharedLease, acquireWriteLease, lockPathForDb, StoreAlreadyOwnedError, } from './write-lease.js';
 import { acquireWriteLeaseOrExit } from './write-lease-error.js';
+const MAIN_DB_BUSY_TIMEOUT_MS = 5_000;
 function invokeStatement(statement, operation, params) {
     if (Array.isArray(params))
         return statement[operation](...params);
@@ -71,32 +74,92 @@ class SqlitePackDbAccess {
         }
     }
 }
+function readUserVersion(dbPath) {
+    if (!existsSync(dbPath))
+        return 0;
+    const db = new Database(dbPath, { readonly: true, fileMustExist: true, timeout: 5_000 });
+    try {
+        return Number(db.pragma('user_version', { simple: true }));
+    }
+    finally {
+        db.close();
+    }
+}
+function blockUpgrade(message) {
+    console.error(`[bs] storage upgrade blocked: ${message}`);
+    queueMicrotask(() => process.exit(75));
+    throw new StorageUpgradeBlockedError(message);
+}
 /** Default local SQLite storage driver. */
 export class SqliteStorageDriver {
     db = null;
-    writeLease = null;
+    openLease = null;
+    changeTimer = null;
     localSqliteStore = null;
     stores = new Map();
     async initialize() {
         if (this.db)
             return;
         const dbPath = path.join(getUserDataDir(), getProductConfig().dbFileName ?? 'agent-shell.db');
-        this.writeLease = acquireWriteLeaseOrExit(() => acquireWriteLease(lockPathForDb(dbPath)));
+        // A previous build held this lock for the whole process. If it is still
+        // held, that process cannot share the database, so refuse to migrate
+        // or to open alongside it.
+        acquireWriteLeaseOrExit(() => {
+            const legacy = acquireWriteLease(lockPathForDb(dbPath));
+            legacy.release();
+        });
+        const gate = openLockPath(dbPath);
+        let version = readUserVersion(dbPath);
+        if (version > HOST_SCHEMA_VERSION) {
+            blockUpgrade(`本地数据库版本 ${version} 高于本程序支持的版本 ${HOST_SCHEMA_VERSION}。请升级后再打开。`);
+        }
+        let exclusive = null;
+        if (version === HOST_SCHEMA_VERSION) {
+            // Make sure the open-lock table exists, then register as a shared holder.
+            // A live shared holder rejects this exclusive probe immediately.
+            try {
+                acquireWriteLease(gate).release();
+            }
+            catch (error) {
+                if (!(error instanceof StoreAlreadyOwnedError))
+                    throw error;
+            }
+        }
+        else {
+            try {
+                exclusive = acquireWriteLease(gate, OPEN_LOCK_WAIT_MS);
+            }
+            catch (error) {
+                if (!(error instanceof StoreAlreadyOwnedError))
+                    throw error;
+                version = readUserVersion(dbPath);
+                if (version !== HOST_SCHEMA_VERSION) {
+                    blockUpgrade('本地数据库需要升级，但仍被另一个进程打开。请先关闭正在运行的应用及其命令行任务后再升级。');
+                }
+            }
+        }
         let db = null;
         try {
-            db = new Database(dbPath);
+            db = new Database(dbPath, { timeout: MAIN_DB_BUSY_TIMEOUT_MS });
+            db.pragma(`busy_timeout = ${MAIN_DB_BUSY_TIMEOUT_MS}`);
             db.pragma('journal_mode = WAL');
             db.pragma('foreign_keys = ON');
             this.db = db;
             const local = new SqliteScopedStore(db, LOCAL_SCOPE);
             await local.initialize();
+            db.pragma(`user_version = ${HOST_SCHEMA_VERSION}`);
             this.localSqliteStore = local;
             this.stores.set(this.scopeKey(LOCAL_SCOPE), local);
+            exclusive?.release();
+            exclusive = null;
+            this.openLease = acquireSharedLease(gate);
         }
         catch (error) {
+            exclusive?.release();
             db?.close();
-            this.writeLease.release();
-            this.writeLease = null;
+            this.db = null;
+            this.openLease?.release();
+            this.openLease = null;
             throw error;
         }
     }
@@ -116,13 +179,31 @@ export class SqliteStorageDriver {
     async applyPackMigrations() {
         this.localSqliteStore?.applyPackMigrations();
     }
+    watchChanges(onChange) {
+        const db = this.requireDb();
+        if (this.changeTimer)
+            return;
+        let version = Number(db.pragma('data_version', { simple: true }));
+        this.changeTimer = setInterval(() => {
+            const next = Number(db.pragma('data_version', { simple: true }));
+            if (next === version)
+                return;
+            version = next;
+            onChange();
+        }, 1_000);
+        this.changeTimer.unref?.();
+    }
     async close() {
+        if (this.changeTimer) {
+            clearInterval(this.changeTimer);
+            this.changeTimer = null;
+        }
         this.stores.clear();
         this.db?.close();
         this.db = null;
         this.localSqliteStore = null;
-        this.writeLease?.release();
-        this.writeLease = null;
+        this.openLease?.release();
+        this.openLease = null;
     }
     requireDb() {
         if (!this.db)

package/dist/storage/write-lease.d.ts

@@ -23,4 +23,10 @@ export interface HeldWriteLease {
     release(): void;
 }
 export declare function lockPathForDb(dbPath: string): string;
-export declare function acquireWriteLease(lockPath: string): HeldWriteLease;
+export declare function acquireWriteLease(lockPath: string, timeoutMs?: number): HeldWriteLease;
+/**
+ * Shared open registration. Many processes may hold this at once.
+ * An exclusive lease on the same file waits until every shared holder closes.
+ * The lock file must already contain the lease table (the exclusive opener creates it).
+ */
+export declare function acquireSharedLease(lockPath: string): HeldWriteLease;

package/dist/storage/write-lease.js

@@ -36,17 +36,18 @@ export function lockPathForDb(dbPath) {
     const parsed = path.parse(path.resolve(dbPath));
     return path.join(parsed.dir, `${parsed.name}.lock`);
 }
-export function acquireWriteLease(lockPath) {
+export function acquireWriteLease(lockPath, timeoutMs = 0) {
+    const waitMs = Number.isFinite(timeoutMs) ? Math.max(0, Math.trunc(timeoutMs)) : 0;
     fs.mkdirSync(path.dirname(lockPath), { recursive: true });
     // Loaded lazily so tests that only exercise lockPathForDb do not need
     // better-sqlite3's Electron ABI.
     const Database = require('better-sqlite3');
-    const db = new Database(lockPath, { timeout: 0 });
+    const db = new Database(lockPath, { timeout: waitMs });
     try {
         // Every statement here can hit the incumbent's lock, including the
         // journal_mode pragma — it rewrites the header and so needs the same
-        // write lock. busy_timeout 0 makes that immediate instead of a stall.
-        db.pragma('busy_timeout = 0');
+        // write lock. timeoutMs 0 makes that immediate instead of a stall.
+        db.pragma(`busy_timeout = ${waitMs}`);
         db.pragma('journal_mode = DELETE');
         db.exec('CREATE TABLE IF NOT EXISTS lease (id INTEGER PRIMARY KEY)');
         db.exec('BEGIN EXCLUSIVE');
@@ -72,3 +73,33 @@ export function acquireWriteLease(lockPath) {
         },
     };
 }
+/**
+ * Shared open registration. Many processes may hold this at once.
+ * An exclusive lease on the same file waits until every shared holder closes.
+ * The lock file must already contain the lease table (the exclusive opener creates it).
+ */
+export function acquireSharedLease(lockPath) {
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    const Database = require('better-sqlite3');
+    const db = new Database(lockPath, { timeout: 5_000 });
+    try {
+        db.pragma('busy_timeout = 5000');
+        db.exec('BEGIN');
+        db.prepare('SELECT id FROM lease LIMIT 1').get();
+    }
+    catch (err) {
+        db.close();
+        if (isSqliteBusy(err))
+            throw new StoreAlreadyOwnedError(lockPath);
+        throw err;
+    }
+    let released = false;
+    return {
+        release() {
+            if (released)
+                return;
+            released = true;
+            db.close();
+        },
+    };
+}

package/dist/terminal-manager.js

@@ -1,7 +1,7 @@
 import { EventEmitter } from 'events';
 import os from 'os';
 import { randomUUID } from 'crypto';
-import log from 'electron-log';
+import { log } from './log.js';
 import * as pty from 'node-pty';
 import { adaptCommandForPowerShell } from './shell-adapt.js';
 const DEFAULT_COLS = 100;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steerable/agent-shell",
-  "version": "0.6.55",
+  "version": "0.6.57",
   "description": "Steerable framework — product-neutral Node HostRuntime and headless HTTP server shared by Tauri desktop and browser deployments; scenario packs extend it through @steerable/pack-sdk.",
   "license": "Apache-2.0",
   "homepage": "https://steerableframework.com/",
@@ -49,12 +49,11 @@
     "better-sqlite3": "^11.9.1",
     "conf": "10.2.0",
     "dotenv": "^17.4.2",
-    "electron-log": "^5.4.3",
     "he": "^1.2.0",
     "node-pty": "^1.1.0",
-    "@steerable/agent-harness": "0.6.55",
-    "@steerable/pack-sdk": "0.6.55",
-    "@steerable/agent-protocol": "0.6.55"
+    "@steerable/agent-harness": "0.6.57",
+    "@steerable/pack-sdk": "0.6.57",
+    "@steerable/agent-protocol": "0.6.57"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",