@actiondock/core 2.6.0 → 2.8.0

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

@@ -0,0 +1,40 @@
+import { 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 {
+    private readonly db;
+    private closed;
+    constructor(dbPath?: string | DatabaseSync, options?: any);
+    /**
+     * 检查底层连接是否处于开启状态。
+     */
+    get isOpen(): boolean;
+    /**
+     * 获取底层原始 DatabaseSync 实例。
+     */
+    get rawDatabase(): DatabaseSync;
+    /**
+     * 执行单条或多条无需返回结果的 SQL 脚本语句。
+     */
+    exec(sql: string): void;
+    /**
+     * 预编译 SQL 语句并封装为统一的 SqliteStatement 接口。
+     */
+    prepare(sql: string): SqliteStatement;
+    /**
+     * 执行同步事务，严格拒绝并拦截异步 Promise。
+     */
+    transaction<T>(fn: () => T extends PromiseLike<unknown> ? never : T): T;
+    /**
+     * 关闭底层数据库连接并释放资源。
+     */
+    close(): void;
+    /**
+     * 断言数据库连接未关闭。
+     */
+    private assertOpen;
+}

package/dist/storage/sqlite-driver.js

@@ -0,0 +1,116 @@
+import { DatabaseSync } from "node:sqlite";
+import { normalizeSqliteParams } from "./params.js";
+export { normalizeSqliteParams };
+/**
+ * 基于 Node.js 内置 node:sqlite 实现的 SQLite 驱动适配器。
+ */
+export class NodeSqliteDriver {
+    db;
+    closed = false;
+    constructor(dbPath = ":memory:", options) {
+        if (typeof dbPath === "string") {
+            this.db = options !== undefined ? new DatabaseSync(dbPath, options) : new DatabaseSync(dbPath);
+        }
+        else {
+            this.db = dbPath;
+        }
+    }
+    /**
+     * 检查底层连接是否处于开启状态。
+     */
+    get isOpen() {
+        return !this.closed;
+    }
+    /**
+     * 获取底层原始 DatabaseSync 实例。
+     */
+    get rawDatabase() {
+        return this.db;
+    }
+    /**
+     * 执行单条或多条无需返回结果的 SQL 脚本语句。
+     */
+    exec(sql) {
+        this.assertOpen();
+        this.db.exec(sql);
+    }
+    /**
+     * 预编译 SQL 语句并封装为统一的 SqliteStatement 接口。
+     */
+    prepare(sql) {
+        this.assertOpen();
+        const stmt = this.db.prepare(sql);
+        return {
+            run: (...args) => {
+                this.assertOpen();
+                const params = normalizeSqliteParams(args);
+                const res = stmt.run(...params);
+                return {
+                    changes: Number(res.changes),
+                    lastInsertRowid: res.lastInsertRowid,
+                };
+            },
+            get: (...args) => {
+                this.assertOpen();
+                const params = normalizeSqliteParams(args);
+                return stmt.get(...params);
+            },
+            all: (...args) => {
+                this.assertOpen();
+                const params = normalizeSqliteParams(args);
+                return stmt.all(...params);
+            },
+        };
+    }
+    /**
+     * 执行同步事务，严格拒绝并拦截异步 Promise。
+     */
+    transaction(fn) {
+        this.assertOpen();
+        this.db.exec("BEGIN");
+        let result;
+        try {
+            result = fn();
+        }
+        catch (err) {
+            try {
+                this.db.exec("ROLLBACK");
+            }
+            catch {
+                // 忽略回滚阶段发生的级联异常
+            }
+            throw err;
+        }
+        // 严格检查是否返回了异步 Promise 对象
+        if (result !== null &&
+            (typeof result === "object" || typeof result === "function") &&
+            typeof result.then === "function") {
+            try {
+                this.db.exec("ROLLBACK");
+            }
+            catch {
+                // 忽略回滚阶段发生的级联异常
+            }
+            throw new Error("Async transactions are not allowed in SQLite");
+        }
+        this.db.exec("COMMIT");
+        return result;
+    }
+    /**
+     * 关闭底层数据库连接并释放资源。
+     */
+    close() {
+        if (!this.closed) {
+            this.closed = true;
+            this.db.close();
+        }
+    }
+    /**
+     * 断言数据库连接未关闭。
+     */
+    assertOpen() {
+        if (this.closed) {
+            throw new Error("Database connection is closed");
+        }
+    }
+}

package/dist/storage/sqlite.js

@@ -4,6 +4,7 @@ import { decodeStateKey, encodeStateKey, escapeStateSegment, unescapeStateSegmen
 import { SystemClock } from "./clock.js";
 import { createDefaultSqliteDriver } from "./driver.js";
 import { safeParseStoredJson } from "./utils.js";
+import { ActionDockError, AMBIGUOUS_STATE_KEY, STORED_ERROR_DECODE_FAILED, UNSUPPORTED_STORAGE_SCHEMA } from "../errors.js";
 import { IDEMPOTENCY_RETENTION_MS, STORAGE_SCHEMA_VERSION, isTerminalRunStatus, } from "./types.js";
 export { decodeStateKey, encodeStateKey, escapeStateSegment, unescapeStateSegment, };
 /**
@@ -76,6 +77,10 @@ export class SqliteRuntimeStorage {
     init() {
         this.driver.exec("PRAGMA journal_mode = WAL;");
         this.driver.exec("PRAGMA synchronous = NORMAL;");
+        // 跨进程写并发基线：SQLite 默认忙等为零，持有者与旁观写进程的写窗口重叠时
+        // 会立即抛 SQLITE_BUSY。统一设置 5 秒忙等，使默认同步驱动、工作线程驱动
+        // （worker 脚本已内置同值）与任何注入驱动的行为基线一致。
+        this.driver.exec("PRAGMA busy_timeout = 5000;");
         // 读取 Schema 版本号
         const versionRes = this.driver.prepare("PRAGMA user_version;").get();
         const version = Number(versionRes?.user_version ?? 0);
@@ -142,7 +147,7 @@ export class SqliteRuntimeStorage {
         }
         else if (version !== STORAGE_SCHEMA_VERSION) {
             const err = new Error(`UNSUPPORTED_STORAGE_SCHEMA: Database schema version ${version} is incompatible (expected ${STORAGE_SCHEMA_VERSION}). Silent upgrade and database overwriting are strictly prohibited.`);
-            err.code = "UNSUPPORTED_STORAGE_SCHEMA";
+            err.code = UNSUPPORTED_STORAGE_SCHEMA;
             throw err;
         }
         // 确保已有历史数据库补充迁移 host_session_id 列
@@ -248,7 +253,11 @@ export class SqliteRuntimeStorage {
         if (row.expires_at) {
             const expires = new Date(row.expires_at).getTime();
             if (this.clock.now().getTime() >= expires) {
-                this.deleteState(namespace, key).catch(() => { });
+                // 惰性删除失败仅降级不影响读取语义，但必须可观测，与其他存储降级点对齐
+                this.deleteState(namespace, key).catch((err) => {
+                    const reason = err instanceof Error ? err.message : String(err);
+                    console.warn(`[actiondock] expired state lazy delete failed (namespace='${namespace}' key='${key}'): ${reason}`);
+                });
                 return undefined;
             }
         }
@@ -276,7 +285,13 @@ export class SqliteRuntimeStorage {
         const uniqueMap = new Map();
         for (const r of rawRows) {
             if (r.expires_at && now >= new Date(r.expires_at).getTime()) {
-                this.deleteState(r.namespace, r.key).catch(() => { });
+                // 惰性删除失败仅降级不影响匹配语义，但必须可观测，与其他存储降级点对齐
+                const ns = r.namespace;
+                const k = r.key;
+                this.deleteState(ns, k).catch((err) => {
+                    const reason = err instanceof Error ? err.message : String(err);
+                    console.warn(`[actiondock] expired state lazy delete failed (namespace='${ns}' key='${k}'): ${reason}`);
+                });
                 continue;
             }
             uniqueMap.set(`${r.namespace}\0${r.key}`, r);
@@ -302,7 +317,7 @@ export class SqliteRuntimeStorage {
         }
         const matchingRows = await this.findMatchingStateRows(targetKey);
         if (matchingRows.length > 1) {
-            throw new Error(`Ambiguous state key '${targetKey}': matches ${matchingRows.length} entries (${matchingRows.map((r) => `${r.namespace}:${r.key}`).join(", ")})`);
+            throw new ActionDockError(AMBIGUOUS_STATE_KEY, `Ambiguous state key '${targetKey}': matches ${matchingRows.length} entries (${matchingRows.map((r) => `${r.namespace}:${r.key}`).join(", ")})`);
         }
         if (matchingRows.length === 0) {
             return undefined;
@@ -348,7 +363,7 @@ export class SqliteRuntimeStorage {
         }
         const matchingRows = await this.findMatchingStateRows(targetKey);
         if (matchingRows.length > 1) {
-            throw new Error(`Ambiguous state key '${targetKey}': matches ${matchingRows.length} entries for deletion (${matchingRows.map((r) => `${r.namespace}:${r.key}`).join(", ")})`);
+            throw new ActionDockError(AMBIGUOUS_STATE_KEY, `Ambiguous state key '${targetKey}': matches ${matchingRows.length} entries for deletion (${matchingRows.map((r) => `${r.namespace}:${r.key}`).join(", ")})`);
         }
         if (matchingRows.length === 1) {
             return this.deleteState(matchingRows[0].namespace, matchingRows[0].key);
@@ -644,7 +659,7 @@ export class SqliteRuntimeStorage {
         const normalizedError = error !== undefined
             ? typeof error === "object" && error !== null && typeof error.message === "string"
                 ? error
-                : { code: "STORED_ERROR_DECODE_FAILED", message: String(error) }
+                : { code: STORED_ERROR_DECODE_FAILED, message: String(error) }
             : undefined;
         return {
             id: row.id,

package/dist/storage/types.d.ts

@@ -5,8 +5,8 @@ import type { Clock } from "./clock.js";
  */
 export declare const STORAGE_SCHEMA_VERSION = 2;
 /**
- * 幂等去重记录保留窗口（24 小时），与 LocalActionDockTarget.info()
- * 声明的 idempotencyPolicy.retentionMs 承诺保持单一事实源。
+ * 幂等去重记录保留窗口（24 小时），与 ActionDockService.info()
+ * 中的 idempotencyPolicy.retentionMs 保持单一事实源。
  */
 export declare const IDEMPOTENCY_RETENTION_MS = 86400000;
 /**
@@ -34,8 +34,8 @@ export interface SqliteStatement {
  * 本契约为同步驱动：exec、prepare 与 transaction 全部以同步语义返回结果，
  * 不接受任何 Promise 或异步实现。SqliteRuntimeStorage 的公共同步方法
  * （getConfig、listConfig、getRun、listRuns、checkAndRecordIdempotency 等）
- * 直接依赖这一同步保证。异步驱动（如 runtime-node 的 WorkerSqliteDriver）
- * 不应注入本契约，需通过 RuntimeStorage 的异步外观层另行适配。
+ * 直接依赖这一同步保证。异步驱动不应注入本契约，
+ * 需通过 RuntimeStorage 的异步外观层另行适配。
  */
 export interface SqliteDriver {
     exec(sql: string): void;

package/dist/storage/types.js

@@ -4,8 +4,8 @@ import { ACTION_CANCELLED, ACTION_TIMEOUT } from "../errors.js";
  */
 export const STORAGE_SCHEMA_VERSION = 2;
 /**
- * 幂等去重记录保留窗口（24 小时），与 LocalActionDockTarget.info()
- * 声明的 idempotencyPolicy.retentionMs 承诺保持单一事实源。
+ * 幂等去重记录保留窗口（24 小时），与 ActionDockService.info()
+ * 中的 idempotencyPolicy.retentionMs 保持单一事实源。
  */
 export const IDEMPOTENCY_RETENTION_MS = 86_400_000;
 /**

package/dist/utils/index.d.ts

@@ -1,4 +1,57 @@
 export { isLoopbackHost } from "./net.js";
+export { isProcessAlive } from "./process.js";
+/**
+ * 语义化版本元数据结构。
+ */
+export interface SemVer {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease?: string;
+}
+/**
+ * 解析基础 SemVer 版本字符串（单一事实源）。
+ * 仅接受可选 v/= 前缀的严格三段式语义化版本，可携带预发布后缀；
+ * 其余形态（两段式、非数值等）返回 null，由调用方自行兜底。
+ */
+export declare function parseSemVer(v: string): SemVer | null;
+/**
+ * 目录遍历条目描述。
+ */
+export interface TraverseDirectoryEntry {
+    /** 相对遍历根目录的 POSIX 风格路径 */
+    relPath: string;
+    /** 条目绝对路径 */
+    fullPath: string;
+    /** 是否为目录 */
+    isDir: boolean;
+}
+/**
+ * 目录遍历配置选项。
+ */
+export interface TraverseDirectoryOptions {
+    /**
+     * 条目忽略谓词：返回 true 的相对路径（含目录自身）不进入结果，目录不再下钻。
+     * 各调用方的业务忽略规则（如 node_modules、测试文件）以谓词传入保持现有行为。
+     */
+    ignore?: (relPath: string, isDir: boolean) => boolean;
+    /** 是否在结果中包含目录条目（默认仅返回文件） */
+    includeDirs?: boolean;
+    /** 目录不可读时的错误回调（默认静默跳过该目录） */
+    onReadError?: (dir: string, err: unknown) => void;
+}
+/**
+ * 递归遍历目录的单一事实源实现（同步）。
+ *
+ * 防护策略（以归档与摘要收集链路的历史行为为准）：
+ * - 软链接越界防护：条目真实路径越出遍历根目录边界时直接跳过；
+ * - 循环防护：以真实路径去重，重复访问即跳过（含根目录自身入集合）；
+ * - 无法 stat 或损坏的条目直接跳过，不中断整体遍历；
+ * - 同级条目按名称排序，保证遍历顺序稳定。
+ *
+ * 根目录自身不作为条目返回；目录条目（includeDirs 开启时）先于其子条目输出。
+ */
+export declare function traverseDirectory(root: string, options?: TraverseDirectoryOptions): TraverseDirectoryEntry[];
 /**
  * 跨运行时安全查找可执行文件绝对物理路径。
  *

package/dist/utils/index.js

@@ -1,7 +1,102 @@
-import { existsSync, realpathSync } from "node:fs";
+import { existsSync, readdirSync, realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { ActionDockError, INVALID_PACKAGE_ID, PATH_TRAVERSAL } from "../errors.js";
 export { isLoopbackHost } from "./net.js";
+export { isProcessAlive } from "./process.js";
+/**
+ * 解析基础 SemVer 版本字符串（单一事实源）。
+ * 仅接受可选 v/= 前缀的严格三段式语义化版本，可携带预发布后缀；
+ * 其余形态（两段式、非数值等）返回 null，由调用方自行兜底。
+ */
+export function parseSemVer(v) {
+    const match = v.trim().replace(/^[v=]/, "").match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/);
+    if (!match)
+        return null;
+    return {
+        major: parseInt(match[1], 10),
+        minor: parseInt(match[2], 10),
+        patch: parseInt(match[3], 10),
+        prerelease: match[4],
+    };
+}
+/**
+ * 递归遍历目录的单一事实源实现（同步）。
+ *
+ * 防护策略（以归档与摘要收集链路的历史行为为准）：
+ * - 软链接越界防护：条目真实路径越出遍历根目录边界时直接跳过；
+ * - 循环防护：以真实路径去重，重复访问即跳过（含根目录自身入集合）；
+ * - 无法 stat 或损坏的条目直接跳过，不中断整体遍历；
+ * - 同级条目按名称排序，保证遍历顺序稳定。
+ *
+ * 根目录自身不作为条目返回；目录条目（includeDirs 开启时）先于其子条目输出。
+ */
+export function traverseDirectory(root, options = {}) {
+    const results = [];
+    const visited = new Set();
+    const resolvedRoot = resolve(root);
+    try {
+        visited.add(existsSync(resolvedRoot) ? realpathSync(resolvedRoot) : resolvedRoot);
+    }
+    catch {
+        // 根目录真实路径解析异常时退化为不携带根真实路径的循环拦截
+    }
+    const walk = (dir) => {
+        let names;
+        try {
+            names = readdirSync(dir).sort();
+        }
+        catch (err) {
+            options.onReadError?.(dir, err);
+            return;
+        }
+        for (const name of names) {
+            const fullPath = join(dir, name);
+            const relPath = relative(resolvedRoot, fullPath).split(sep).join("/");
+            let isDir;
+            try {
+                isDir = statSync(fullPath).isDirectory();
+            }
+            catch {
+                // 无法访问或损坏的文件/符号链接直接跳过
+                continue;
+            }
+            if (options.ignore?.(relPath, isDir)) {
+                continue;
+            }
+            // 软链接越界防护：条目真实路径越出根目录边界时直接跳过
+            let real;
+            try {
+                real = existsSync(fullPath) ? realpathSync(fullPath) : fullPath;
+            }
+            catch {
+                continue;
+            }
+            try {
+                assertPathWithinRoot(resolvedRoot, real, "traverse path");
+            }
+            catch {
+                continue;
+            }
+            // 循环防护：真实路径重复出现即跳过
+            if (visited.has(real)) {
+                continue;
+            }
+            visited.add(real);
+            if (isDir) {
+                if (options.includeDirs) {
+                    results.push({ relPath, fullPath, isDir: true });
+                }
+                walk(fullPath);
+            }
+            else {
+                results.push({ relPath, fullPath, isDir: false });
+            }
+        }
+    };
+    walk(resolvedRoot);
+    return results;
+}
 /**
  * 跨运行时安全查找可执行文件绝对物理路径。
  *
@@ -105,7 +200,7 @@ export function assertValidPackageId(packageId) {
         typeof packageId !== "string" ||
         packageId.includes("..") ||
         (!PACKAGE_ID_REGEX.test(packageId) && !isScopedLegacy)) {
-        throw new Error(`Invalid packageId '${packageId}': must match ${PACKAGE_ID_REGEX} and not contain path traversal characters`);
+        throw new ActionDockError(INVALID_PACKAGE_ID, `Invalid packageId '${packageId}': must match ${PACKAGE_ID_REGEX} and not contain path traversal characters`);
     }
 }
 /**
@@ -161,13 +256,13 @@ export function assertPathWithinRoot(rootDir, targetPath, fieldName = "path") {
     const resolvedTarget = resolve(rootDir, targetPath);
     const rel = relative(resolvedRoot, resolvedTarget);
     if (isPathOutsideBoundary(rel)) {
-        throw new Error(`'${fieldName}' escapes boundary '${rootDir}': ${targetPath}`);
+        throw new ActionDockError(PATH_TRAVERSAL, `'${fieldName}' escapes boundary '${rootDir}': ${targetPath}`);
     }
     const canonicalRoot = canonicalizePath(resolvedRoot);
     const canonicalTarget = canonicalizePath(resolvedTarget);
     const relReal = relative(canonicalRoot, canonicalTarget);
     if (isPathOutsideBoundary(relReal)) {
-        throw new Error(`'${fieldName}' symlink resolves outside boundary '${rootDir}': ${targetPath}`);
+        throw new ActionDockError(PATH_TRAVERSAL, `'${fieldName}' symlink resolves outside boundary '${rootDir}': ${targetPath}`);
     }
 }
 /**

package/dist/utils/process.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 检查目标进程是否处于存活状态（跨域通用谓词单一事实源）。
+ *
+ * 基于 process.kill(pid, 0) 探测：无异常视为存活；ESRCH（进程不存在）
+ * 视为已死；其他异常（如 EPERM，权限不足但进程存在）保守视为存活，
+ * 避免权限受限环境下误判他人持有进程死亡而抢占其锁。
+ *
+ * @param pid 待检测的进程标识符
+ */
+export declare function isProcessAlive(pid: number): boolean;

package/dist/utils/process.js

@@ -0,0 +1,21 @@
+/**
+ * 检查目标进程是否处于存活状态（跨域通用谓词单一事实源）。
+ *
+ * 基于 process.kill(pid, 0) 探测：无异常视为存活；ESRCH（进程不存在）
+ * 视为已死；其他异常（如 EPERM，权限不足但进程存在）保守视为存活，
+ * 避免权限受限环境下误判他人持有进程死亡而抢占其锁。
+ *
+ * @param pid 待检测的进程标识符
+ */
+export function isProcessAlive(pid) {
+    if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err?.code !== "ESRCH";
+    }
+}

package/dist/version.d.ts

@@ -1,4 +1,4 @@
 /**
  * ActionDock 核心版本号单一事实源。
  */
-export declare const ACTIONDOCK_VERSION = "2.6.0";
+export declare const ACTIONDOCK_VERSION = "2.8.0";

package/dist/version.js

@@ -1,4 +1,4 @@
 /**
  * ActionDock 核心版本号单一事实源。
  */
-export const ACTIONDOCK_VERSION = "2.6.0";
+export const ACTIONDOCK_VERSION = "2.8.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actiondock/core",
-  "version": "2.6.0",
+  "version": "2.8.0",
   "description": "ActionDock Core Engine - Project loader, runtime execution, SQLite storage, standalone builder, and skill exporter",
   "type": "module",
   "main": "./dist/index.js",
@@ -9,8 +9,45 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "bun": "./src/server/index.ts",
+      "import": "./dist/server/index.js",
+      "default": "./dist/server/index.js"
+    },
+    "./project": {
+      "types": "./dist/project/index.d.ts",
+      "bun": "./src/project/index.ts",
+      "import": "./dist/project/index.js",
+      "default": "./dist/project/index.js"
+    },
+    "./registry": {
+      "types": "./dist/registry/index.d.ts",
+      "bun": "./src/registry/index.ts",
+      "import": "./dist/registry/index.js",
+      "default": "./dist/registry/index.js"
+    },
+    "./profile": {
+      "types": "./dist/profile/index.d.ts",
+      "bun": "./src/profile/index.ts",
+      "import": "./dist/profile/index.js",
+      "default": "./dist/profile/index.js"
+    },
+    "./graph": {
+      "types": "./dist/graph/index.d.ts",
+      "bun": "./src/graph/index.ts",
+      "import": "./dist/graph/index.js",
+      "default": "./dist/graph/index.js"
+    },
+    "./package": {
+      "types": "./dist/package/index.d.ts",
+      "bun": "./src/package/index.ts",
+      "import": "./dist/package/index.js",
+      "default": "./dist/package/index.js"
     }
   },
   "files": [
@@ -29,9 +66,10 @@
     "test": "node ../../scripts/run-tests.ts"
   },
   "dependencies": {
-    "@actiondock/sdk": "^2.6.0",
+    "@actiondock/sdk": "^2.8.0",
     "ajv": "^8.17.1",
-    "ajv-formats": "^3.0.1"
+    "ajv-formats": "^3.0.1",
+    "undici": "^7.29.1"
   },
   "devDependencies": {
     "typescript": "^5.7.0"

package/dist/app/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./types.js";
-export * from "./app.js";

package/dist/app/index.js

@@ -1,2 +0,0 @@
-export * from "./types.js";
-export * from "./app.js";

package/dist/app/types.js

@@ -1 +0,0 @@
-export {};

package/dist/catalog/action-index.d.ts

@@ -1,9 +0,0 @@
-import type { CatalogSnapshot, IndexedAction } from "./types.js";
-export declare class ActionIndex {
-    private actions;
-    constructor(snapshot: CatalogSnapshot);
-    private indexSnapshot;
-    private add;
-    list(packageId?: string): IndexedAction[];
-    find(actionId: string, packageId?: string): IndexedAction[];
-}