@actiondock/core 2.9.1 → 2.11.0

package/dist/storage/sqlite-config.js

@@ -0,0 +1,59 @@
+import { safeParseStoredJson } from "./utils.js";
+export class SqliteConfigStore {
+    statementCache = new Map();
+    driver;
+    packageId;
+    dbPath;
+    clock;
+    constructor(driver, packageId, dbPath, clock) {
+        this.driver = driver;
+        this.packageId = packageId;
+        this.dbPath = dbPath;
+        this.clock = clock;
+    }
+    getStatement(sql) {
+        let stmt = this.statementCache.get(sql);
+        if (!stmt) {
+            stmt = this.driver.prepare(sql);
+            this.statementCache.set(sql, stmt);
+        }
+        return stmt;
+    }
+    getConfig(key) {
+        const stmt = this.getStatement("SELECT value_json FROM config WHERE package_id = ? AND key = ?");
+        const row = stmt.get(this.packageId, key);
+        if (!row || row.value_json === undefined || row.value_json === null) {
+            return undefined;
+        }
+        return safeParseStoredJson(row.value_json, `config db=${this.dbPath} package=${this.packageId} key=${key}`);
+    }
+    listConfig() {
+        const stmt = this.getStatement("SELECT key, value_json FROM config WHERE package_id = ?");
+        const rows = stmt.all(this.packageId);
+        const result = {};
+        for (const row of rows) {
+            result[row.key] = safeParseStoredJson(row.value_json, `config db=${this.dbPath} package=${this.packageId} key=${row.key}`);
+        }
+        return result;
+    }
+    setConfig(key, value) {
+        const stmt = this.getStatement(`
+      INSERT INTO config (package_id, key, value_json, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(package_id, key) DO UPDATE SET
+        value_json = excluded.value_json,
+        updated_at = excluded.updated_at
+    `);
+        const valJson = JSON.stringify(value);
+        const now = this.clock.now().toISOString();
+        stmt.run(this.packageId, key, valJson, now);
+    }
+    deleteConfig(key) {
+        const stmt = this.getStatement("DELETE FROM config WHERE package_id = ? AND key = ?");
+        const res = stmt.run(this.packageId, key);
+        return res.changes > 0;
+    }
+    close() {
+        this.statementCache.clear();
+    }
+}

package/dist/storage/sqlite-driver.d.ts

@@ -1,8 +1,10 @@
-import { DatabaseSync } from "node:sqlite";
+import "../utils/warning.js";
+import type { DatabaseSync } from "node:sqlite";
 import { normalizeSqliteParams } from "./params.js";
 import type { SqliteDriver, SqliteStatement } from "./types.js";
 export { normalizeSqliteParams };
 /**
+
  * 基于 Node.js 内置 node:sqlite 实现的 SQLite 驱动适配器。
  */
 export declare class NodeSqliteDriver implements SqliteDriver {

package/dist/storage/sqlite-driver.js

@@ -1,7 +1,11 @@
-import { DatabaseSync } from "node:sqlite";
+import "../utils/warning.js";
 import { normalizeSqliteParams } from "./params.js";
+import { ActionDockError, ASYNC_TRANSACTION_UNSUPPORTED, STORAGE_CLOSED } from "../errors.js";
+// 基于原生 ESM Top-Level Await 在模块评估期动态加载，确保警告静默拦截器优先就绪且保持纯正 ESM 架构
+const { DatabaseSync: DatabaseSyncConstructor } = (await import("node:sqlite"));
 export { normalizeSqliteParams };
 /**
+
  * 基于 Node.js 内置 node:sqlite 实现的 SQLite 驱动适配器。
  */
 export class NodeSqliteDriver {
@@ -9,11 +13,17 @@ export class NodeSqliteDriver {
     closed = false;
     constructor(dbPath = ":memory:", options) {
         if (typeof dbPath === "string") {
-            this.db = options !== undefined ? new DatabaseSync(dbPath, options) : new DatabaseSync(dbPath);
+            this.db = options !== undefined ? new DatabaseSyncConstructor(dbPath, options) : new DatabaseSyncConstructor(dbPath);
         }
         else {
             this.db = dbPath;
         }
+        try {
+            this.db.exec("PRAGMA busy_timeout = 5000;");
+        }
+        catch {
+            // 忽略已关闭或不支持的只读连接异常
+        }
     }
     /**
      * 检查底层连接是否处于开启状态。
@@ -91,7 +101,7 @@ export class NodeSqliteDriver {
             catch {
                 // 忽略回滚阶段发生的级联异常
             }
-            throw new Error("Async transactions are not allowed in SQLite");
+            throw new ActionDockError(ASYNC_TRANSACTION_UNSUPPORTED, "Async transactions are not allowed in SQLite");
         }
         this.db.exec("COMMIT");
         return result;
@@ -110,7 +120,7 @@ export class NodeSqliteDriver {
      */
     assertOpen() {
         if (this.closed) {
-            throw new Error("Database connection is closed");
+            throw new ActionDockError(STORAGE_CLOSED, "Database connection is closed");
         }
     }
 }

package/dist/storage/sqlite-events.d.ts

@@ -0,0 +1,13 @@
+import type { SqliteDriver } from "./types.js";
+import type { Clock } from "./clock.js";
+export declare class SqliteEventsStore {
+    private statementCache;
+    private driver;
+    private packageId;
+    private clock;
+    constructor(driver: SqliteDriver, packageId: string, clock: Clock);
+    private getStatement;
+    appendEvent(eventType: string, payload: unknown): void;
+    queryEvents(eventType?: string): any[];
+    close(): void;
+}

package/dist/storage/sqlite-events.js

@@ -0,0 +1,48 @@
+import { randomUUID } from "node:crypto";
+import { safeParseStoredJson } from "./utils.js";
+export class SqliteEventsStore {
+    statementCache = new Map();
+    driver;
+    packageId;
+    clock;
+    constructor(driver, packageId, clock) {
+        this.driver = driver;
+        this.packageId = packageId;
+        this.clock = clock;
+    }
+    getStatement(sql) {
+        let stmt = this.statementCache.get(sql);
+        if (!stmt) {
+            stmt = this.driver.prepare(sql);
+            this.statementCache.set(sql, stmt);
+        }
+        return stmt;
+    }
+    appendEvent(eventType, payload) {
+        const stmt = this.getStatement(`
+      INSERT INTO events (id, package_id, event_type, payload_json, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+        const id = randomUUID();
+        const payloadJson = payload !== undefined ? JSON.stringify(payload) : null;
+        stmt.run(id, this.packageId, eventType, payloadJson, this.clock.now().toISOString());
+    }
+    queryEvents(eventType) {
+        const sql = eventType
+            ? "SELECT * FROM events WHERE package_id = ? AND event_type = ? ORDER BY created_at ASC"
+            : "SELECT * FROM events WHERE package_id = ? ORDER BY created_at ASC";
+        const params = eventType ? [this.packageId, eventType] : [this.packageId];
+        const stmt = this.getStatement(sql);
+        const rows = stmt.all(...params);
+        return rows.map((r) => ({
+            id: r.id,
+            packageId: r.package_id,
+            eventType: r.event_type,
+            payload: safeParseStoredJson(r.payload_json, `events.payload id=${r.id}`),
+            createdAt: r.created_at,
+        }));
+    }
+    close() {
+        this.statementCache.clear();
+    }
+}

package/dist/storage/sqlite-runs.d.ts

@@ -0,0 +1,107 @@
+import type { Logger, RuntimeError, RunRecord } from "@actiondock/sdk";
+import type { SqliteDriver, TerminalRunStatus, RunsRetentionPolicy, IdempotencyRecord, IdempotencyCheckResult } from "./types.js";
+import type { Clock } from "./clock.js";
+import { type ProcessLivenessProbe } from "./run-liveness.js";
+export declare class SqliteRunsStore {
+    private statementCache;
+    private runInsertCount;
+    private lastRunsCleanupAt;
+    private static readonly RUNS_CLEANUP_INTERVAL_MS;
+    private static readonly RUNS_CLEANUP_BATCH_THRESHOLD;
+    private driver;
+    private packageId;
+    private dbPath;
+    private clock;
+    private retentionPolicy?;
+    private getConfigFn?;
+    private logger?;
+    private logWarnFn?;
+    constructor(driver: SqliteDriver, packageId: string, dbPath: string, clock: Clock, retentionPolicy?: RunsRetentionPolicy, getConfigFn?: <T>(key: string) => T | undefined, logger?: Logger, logWarnFn?: (msg: string) => void);
+    private logWarn;
+    private getStatement;
+    /**
+     * 收敛死亡宿主遗留的非终态运行记录（保守收割）。
+     *
+     * 判定依据是宿主存活而不是会话归属：会话归属只区分「不是当前会话」，
+     * 无法区分「持有进程已死」与「另一活跃进程仍在执行」。
+     * 先选取非当前会话的非终态候选，再逐条做存活校验，仅收割确认死亡的记录：
+     * - 携带宿主进程标识的记录：进程探测失败（明确不存在）才收割；
+     * - 遗留记录（无进程标识）：心跳（缺省回退开始时间）超过宽限期才收割。
+     *
+     * 无法确认死亡时一律保留，宁司不动也不误杀活跃任务。
+     */
+    recoverDeadSessionRuns(isClosed: boolean, currentHostSessionId?: string, options?: {
+        probe?: ProcessLivenessProbe;
+    }): number;
+    /** 选取非当前会话的非终态候选记录（仅判定所需列） */
+    private selectOrphanCandidates;
+    /** 将确认死亡的记录收敛为 interrupted（单条 SQL 批量执行，不误伤其他在途记录） */
+    private interruptRunsByIds;
+    /**
+     * 刷新在途运行记录的心跳时间戳。
+     *
+     * 执行宿主周期性调用，使无进程标识判定路径（遗留记录兜底）以及其他
+     * 协作方能够区分「在途执行中」与「宿主崩溃后的遗留」。
+     * 仅更新非终态记录，终态记录心跳无意义不更新。
+     */
+    touchRunHeartbeat(isClosed: boolean, runIds: string[]): number;
+    createRun(record: RunRecord | any): void;
+    updateRun(id: string, status: TerminalRunStatus, isClosed: boolean, output?: unknown, error?: RuntimeError, finishedAt?: string): void;
+    getRun(id: string): RunRecord | null;
+    /**
+     * 查询单条运行记录并补齐幂等请求标识关联（详情路径专用）。
+     */
+    getRunWithRequestId(id: string, isClosed: boolean): RunRecord | null;
+    listRuns(options?: {
+        actionId?: string;
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): RunRecord[];
+    /**
+     * 统计符合过滤条件的真实运行记录总数。
+     * 支持按 actionId、status 以及包含 requestIds 的反查场景统计总数。
+     */
+    countRuns(options?: {
+        actionId?: string;
+        status?: string;
+        requestIds?: string[];
+    }, isClosed?: boolean): number;
+    /**
+     * 按客户端幂等请求标识反查关联运行记录总数。
+     */
+    countRunsByRequestIds(isClosed: boolean, requestIds: string[], options?: {
+        actionId?: string;
+        status?: string;
+    }): number;
+    /**
+     * 构造 IN (…) 占位符列表。
+     */
+    private static placeholders;
+    /**
+     * 批量反查当前包范围内、由指定幂等请求标识登记的运行记录。
+     *
+     * 关联链为 idempotency_keys.run_id -> runs.id，且强制 runs.package_id 等于
+     * 当前包，保证多包共库（全局库）时不越界读取其他包的运行记录。
+     * 不按 owner_id 过滤：写入方与查询方分属不同宿主进程，ownerId 必然不同。
+     */
+    listRunsByRequestIds(isClosed: boolean, requestIds: string[]): RunRecord[];
+    /**
+     * 反查当前包范围内运行记录关联的幂等请求标识。
+     *
+     * 仅返回存在关联的键值对；未登记幂等键的运行记录不产生对应键。
+     */
+    getRunRequestIds(isClosed: boolean, runIds: string[]): Record<string, string>;
+    clearRuns(options?: {
+        actionId?: string;
+        status?: string;
+        olderThanMs?: number;
+        keep?: number;
+    }): number;
+    cleanExpiredRuns(isClosed: boolean, policy?: RunsRetentionPolicy): number;
+    private resolveRetentionPolicy;
+    checkAndRecordIdempotency(isClosed: boolean, record: IdempotencyRecord): IdempotencyCheckResult;
+    getIdempotencyRecord(isClosed: boolean, ownerId: string, actionRef: string, requestId: string): IdempotencyRecord | undefined;
+    private mapRunRecord;
+    close(): void;
+}