@actiondock/core 2.18.0 → 2.20.0

package/dist/storage/mask.d.ts

@@ -1,10 +1,8 @@
+import type { JsonValue } from "@actiondock/sdk";
 import type { ConfigItemDefinition } from "../project/types.js";
 /**
- * 检查指定配置项是否为敏感数据（密码、私钥、Token、密钥等）。
- *
- * 判定逻辑：
- * 严格依据配置项元数据属性判定：若声明了 `secret: true`，直接判定为敏感数据；否则不视为敏感数据。
- * 不进行基于正则或键名的自动探测，由开发者显式配置驱动。
+ * 检查指定配置项是否为敏感数据（顶层 secret: true 或模式中嵌套 secret: true）。
+ * 不进行基于正则或键名的自动探测，调用方若涉及模板应先解析具体声明项。
  *
  * @param _key 配置键名（保留入参以兼容契约）
  * @param declaredItem 项目中声明的配置元数据（可选）
@@ -17,9 +15,38 @@ export declare function isSecretConfigKey(_key?: string, declaredItem?: ConfigIt
  * @returns 掩码脱敏后的安全展示字符串
  */
 export declare function maskSecretValue(value: unknown): string;
+/**
+ * 配置值脱敏安全视图产物。
+ */
+export interface RedactResult {
+    /** 脱敏后的数据值（顶层敏感时为 undefined） */
+    value: JsonValue | undefined;
+    /** 是否包含敏感信息或发生了保守脱敏 */
+    secret: boolean;
+    /** 发生脱敏替换的字段路径集合（标准 JSON Pointer 格式） */
+    redactedPaths: string[];
+}
+/**
+ * 依据单项配置声明对配置值执行纯函数脱敏处理。
+ *
+ * @param value 待脱敏的配置原始数据值
+ * @param item 对应的单项配置定义元数据
+ */
+export declare function redactConfigValue(value: unknown, item?: ConfigItemDefinition): RedactResult;
+/** 根据可信隐藏路径应用幂等掩码，绝不把远端提供的路径本身当成已脱敏的证据。 */
+export declare function redactConfigValueAtPaths(value: unknown, paths: string[]): RedactResult;
+/**
+ * 依据跨包多重声明对配置值执行合并脱敏处理（取脱敏路径并集，祖先路径覆盖子路径）。
+ *
+ * @param value 待脱敏的配置原始数据值
+ * @param items 各相关包分别解析得到的配置声明集合
+ */
+export declare function redactConfigValueForDeclarations(value: unknown, items: ConfigItemDefinition[]): RedactResult;
 /**
  * 对配置定义字典进行脱敏处理：
- * 针对声明为 secret: true 的项，剥离其 default 默认值，不返回敏感默认值。
+ * - 针对外层 secret: true 或嵌套包含敏感字段的项，剥离其 default 默认值，避免敏感默认值泄露或误用于执行；
+ * - 针对模式中敏感节点的 enum 约束列表进行清洗，杜绝约束文本泄露秘密；
+ * - 仅返回安全副本，严禁修改清单原始数据。
  *
  * @param config 声明的配置定义字典
  */

package/dist/storage/mask.js

@@ -1,15 +1,45 @@
 /**
- * 检查指定配置项是否为敏感数据（密码、私钥、Token、密钥等）。
- *
- * 判定逻辑：
- * 严格依据配置项元数据属性判定：若声明了 `secret: true`，直接判定为敏感数据；否则不视为敏感数据。
- * 不进行基于正则或键名的自动探测，由开发者显式配置驱动。
+ * 递归检查 Schema 是否包含任何标记为 secret: true 的节点。
+ */
+function schemaHasSecret(schema) {
+    if (!schema || typeof schema !== "object") {
+        return false;
+    }
+    if (schema.secret === true) {
+        return true;
+    }
+    if (schema.properties) {
+        for (const propSchema of Object.values(schema.properties)) {
+            if (schemaHasSecret(propSchema)) {
+                return true;
+            }
+        }
+    }
+    if (schema.items && schemaHasSecret(schema.items)) {
+        return true;
+    }
+    if (schema.additionalProperties &&
+        typeof schema.additionalProperties === "object" &&
+        schemaHasSecret(schema.additionalProperties)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * 检查指定配置项是否为敏感数据（顶层 secret: true 或模式中嵌套 secret: true）。
+ * 不进行基于正则或键名的自动探测，调用方若涉及模板应先解析具体声明项。
  *
  * @param _key 配置键名（保留入参以兼容契约）
  * @param declaredItem 项目中声明的配置元数据（可选）
  */
 export function isSecretConfigKey(_key, declaredItem) {
-    return declaredItem?.secret === true;
+    if (declaredItem?.secret === true) {
+        return true;
+    }
+    if (declaredItem?.schema && schemaHasSecret(declaredItem.schema)) {
+        return true;
+    }
+    return false;
 }
 /**
  * 对敏感数据的值进行掩码脱敏处理（返回 "********"）。
@@ -24,25 +54,277 @@ export function maskSecretValue(value) {
         return "null";
     return "********";
 }
+function escapePointerToken(token) {
+    return token.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function unescapePointerToken(token) {
+    return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function isTypeMatch(val, expectedType) {
+    if (!expectedType)
+        return true;
+    switch (expectedType) {
+        case "string":
+            return typeof val === "string";
+        case "number":
+            return typeof val === "number" && Number.isFinite(val);
+        case "integer":
+            return typeof val === "number" && Number.isInteger(val);
+        case "boolean":
+            return typeof val === "boolean";
+        case "array":
+            return Array.isArray(val);
+        case "object":
+            return val !== null && typeof val === "object" && !Array.isArray(val);
+        default:
+            return true;
+    }
+}
+function redactNode(val, schema, path) {
+    // 模式显式标记敏感节点：直接掩码并终止下钻
+    if (schema?.secret === true) {
+        return {
+            value: "********",
+            redacted: true,
+            paths: [path],
+        };
+    }
+    // 即使省略 type，结构关键字也不能让标量绕过子字段的秘密保护。
+    const objectShape = schema?.properties !== undefined || schema?.additionalProperties !== undefined || schema?.required !== undefined;
+    const arrayShape = schema?.items !== undefined;
+    const incompatibleShape = !schema?.type && (objectShape || arrayShape) &&
+        !(objectShape && val !== null && typeof val === "object" && !Array.isArray(val)) &&
+        !(arrayShape && Array.isArray(val));
+    // 结构与声明类型不符：保守隐藏该节点
+    if (incompatibleShape || (schema?.type && !isTypeMatch(val, schema.type))) {
+        return {
+            value: "********",
+            redacted: true,
+            paths: [path],
+        };
+    }
+    // 数组节点处理
+    if (Array.isArray(val)) {
+        const newArr = [];
+        const childPaths = [];
+        let childRedacted = false;
+        if (schema?.items && typeof schema.items === "object") {
+            for (let i = 0; i < val.length; i++) {
+                const elemPath = path === "" ? `/${i}` : `${path}/${i}`;
+                const res = redactNode(val[i], schema.items, elemPath);
+                newArr.push(res.value);
+                if (res.redacted)
+                    childRedacted = true;
+                childPaths.push(...res.paths);
+            }
+        }
+        else {
+            // 数组按 items 遍历，无对应声明则元素隐藏
+            for (let i = 0; i < val.length; i++) {
+                const elemPath = path === "" ? `/${i}` : `${path}/${i}`;
+                newArr.push("********");
+                childPaths.push(elemPath);
+            }
+            if (val.length > 0) {
+                childRedacted = true;
+            }
+        }
+        return {
+            value: newArr,
+            redacted: childRedacted,
+            paths: childPaths,
+        };
+    }
+    // 普通对象节点处理
+    if (val !== null && typeof val === "object") {
+        const entries = [];
+        const childPaths = [];
+        let childRedacted = false;
+        for (const k of Object.keys(val)) {
+            const childVal = val[k];
+            const token = escapePointerToken(k);
+            const propPath = path === "" ? `/${token}` : `${path}/${token}`;
+            if (schema?.properties && Object.prototype.hasOwnProperty.call(schema.properties, k)) {
+                const res = redactNode(childVal, schema.properties[k], propPath);
+                entries.push([k, res.value]);
+                if (res.redacted)
+                    childRedacted = true;
+                childPaths.push(...res.paths);
+            }
+            else if (schema?.additionalProperties && typeof schema.additionalProperties === "object") {
+                // additionalProperties 声明为模式时继续递归
+                const res = redactNode(childVal, schema.additionalProperties, propPath);
+                entries.push([k, res.value]);
+                if (res.redacted)
+                    childRedacted = true;
+                childPaths.push(...res.paths);
+            }
+            else {
+                // 对象未知属性值隐藏
+                entries.push([k, "********"]);
+                childRedacted = true;
+                childPaths.push(propPath);
+            }
+        }
+        return {
+            value: Object.fromEntries(entries),
+            redacted: childRedacted,
+            paths: childPaths,
+        };
+    }
+    // 标量基元节点
+    return {
+        value: val,
+        redacted: false,
+        paths: [],
+    };
+}
+/**
+ * 依据单项配置声明对配置值执行纯函数脱敏处理。
+ *
+ * @param value 待脱敏的配置原始数据值
+ * @param item 对应的单项配置定义元数据
+ */
+export function redactConfigValue(value, item) {
+    // 外层 secret: true 判定
+    if (item?.secret === true) {
+        if (value === undefined) {
+            return { value: undefined, secret: true, redactedPaths: [] };
+        }
+        return { value: undefined, secret: true, redactedPaths: [""] };
+    }
+    // 未声明 schema 且非顶层 secret 维持旧行为
+    if (!item?.schema) {
+        return { value: value, secret: false, redactedPaths: [] };
+    }
+    // 数据值未配置时，不生成虚假脱敏路径，但反映声明敏感性
+    if (value === undefined) {
+        return {
+            value: undefined,
+            secret: schemaHasSecret(item.schema),
+            redactedPaths: [],
+        };
+    }
+    const res = redactNode(value, item.schema, "");
+    const declarationHasSecret = schemaHasSecret(item.schema);
+    const secret = declarationHasSecret || res.redacted;
+    return {
+        value: res.value,
+        secret,
+        redactedPaths: res.paths,
+    };
+}
+function isAncestorPath(parent, child) {
+    return parent === "" ? child !== "" : child.startsWith(parent + "/");
+}
+/** 根据可信隐藏路径应用幂等掩码，绝不把远端提供的路径本身当成已脱敏的证据。 */
+export function redactConfigValueAtPaths(value, paths) {
+    const hideRoot = () => ({ value: undefined, secret: true, redactedPaths: [""] });
+    if (paths.some((path) => typeof path !== "string" || (path !== "" && (!path.startsWith("/") || /~(?![01])/.test(path))))) {
+        return hideRoot();
+    }
+    if (paths.includes(""))
+        return hideRoot();
+    const unique = [...new Set(paths)];
+    const minimal = unique.filter((path) => !unique.some((parent) => parent !== path && isAncestorPath(parent, path))).sort();
+    const copy = structuredClone(value);
+    for (const path of minimal) {
+        const tokens = path.slice(1).split("/").map(unescapePointerToken);
+        let node = copy;
+        for (const token of tokens.slice(0, -1)) {
+            if (node === null || typeof node !== "object")
+                return hideRoot();
+            if (!Object.hasOwn(node, token)) {
+                node = undefined;
+                break;
+            }
+            node = node[token];
+        }
+        if (node === undefined)
+            continue;
+        if (node === null || typeof node !== "object")
+            return hideRoot();
+        const leaf = tokens[tokens.length - 1];
+        if (Object.hasOwn(node, leaf)) {
+            Object.defineProperty(node, leaf, { value: "********", enumerable: true, writable: true, configurable: true });
+        }
+    }
+    return { value: copy, secret: minimal.length > 0, redactedPaths: minimal };
+}
+/**
+ * 依据跨包多重声明对配置值执行合并脱敏处理（取脱敏路径并集，祖先路径覆盖子路径）。
+ *
+ * @param value 待脱敏的配置原始数据值
+ * @param items 各相关包分别解析得到的配置声明集合
+ */
+export function redactConfigValueForDeclarations(value, items) {
+    if (!items || items.length === 0) {
+        return { value: value, secret: false, redactedPaths: [] };
+    }
+    // 任何声明要求整项敏感，直接隐藏整个根节点
+    if (items.some((item) => item.secret === true)) {
+        if (value === undefined) {
+            return { value: undefined, secret: true, redactedPaths: [] };
+        }
+        return { value: undefined, secret: true, redactedPaths: [""] };
+    }
+    if (value === undefined) {
+        const hasSecret = items.some((item) => isSecretConfigKey("", item));
+        return { value: undefined, secret: hasSecret, redactedPaths: [] };
+    }
+    let anySecret = false;
+    const allPaths = new Set();
+    for (const item of items) {
+        const res = redactConfigValue(value, item);
+        if (res.secret) {
+            anySecret = true;
+        }
+        for (const p of res.redactedPaths) {
+            allPaths.add(p);
+        }
+    }
+    const merged = redactConfigValueAtPaths(value, [...allPaths]);
+    return { ...merged, secret: anySecret || merged.secret };
+}
+function sanitizeSchemaNode(schema, inheritedSecret = false) {
+    const copy = { ...schema };
+    const hidden = inheritedSecret || schema.secret === true;
+    // 祖先枚举也可能携带子字段秘密，未知结构同样不可借约束回显。
+    if (hidden || schemaHasSecret(schema) || schema.enum?.some((value) => redactNode(value, schema, "").redacted)) {
+        delete copy.enum;
+    }
+    if (copy.properties) {
+        copy.properties = Object.fromEntries(Object.entries(copy.properties).map(([key, child]) => [key, sanitizeSchemaNode(child, hidden)]));
+    }
+    if (copy.additionalProperties && typeof copy.additionalProperties === "object") {
+        copy.additionalProperties = sanitizeSchemaNode(copy.additionalProperties, hidden);
+    }
+    if (copy.items && typeof copy.items === "object") {
+        copy.items = sanitizeSchemaNode(copy.items, hidden);
+    }
+    return copy;
+}
 /**
  * 对配置定义字典进行脱敏处理：
- * 针对声明为 secret: true 的项，剥离其 default 默认值，不返回敏感默认值。
+ * - 针对外层 secret: true 或嵌套包含敏感字段的项，剥离其 default 默认值，避免敏感默认值泄露或误用于执行；
+ * - 针对模式中敏感节点的 enum 约束列表进行清洗，杜绝约束文本泄露秘密；
+ * - 仅返回安全副本，严禁修改清单原始数据。
  *
  * @param config 声明的配置定义字典
  */
 export function sanitizeConfigDefinitions(config) {
     if (!config)
         return config;
-    const result = {};
-    for (const [key, item] of Object.entries(config)) {
-        if (item?.secret === true) {
-            const copy = { ...item };
+    return Object.fromEntries(Object.entries(config).map(([key, item]) => {
+        if (!item)
+            return [key, item];
+        const copy = { ...item };
+        if (isSecretConfigKey(key, item) || redactConfigValue(item.default, item).redactedPaths.length > 0) {
             delete copy.default;
-            result[key] = copy;
         }
-        else {
-            result[key] = item;
+        if (copy.schema) {
+            copy.schema = sanitizeSchemaNode(copy.schema, copy.secret === true);
         }
-    }
-    return result;
+        return [key, copy];
+    }));
 }

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

@@ -1,5 +1,5 @@
 import type { Logger, RuntimeError, RunRecord } from "@actiondock/sdk";
-import type { SqliteDriver, TerminalRunStatus, RunsRetentionPolicy, IdempotencyRecord, IdempotencyCheckResult } from "./types.js";
+import type { SqliteDriver, TerminalRunStatus, RunsRetentionPolicy, IdempotencyRecord, IdempotencyCheckResult, RunsQueryFilterOptions } from "./types.js";
 import type { Clock } from "./clock.js";
 import { type ProcessLivenessProbe } from "./run-liveness.js";
 export declare class SqliteRunsStore {
@@ -52,28 +52,16 @@ export declare class SqliteRunsStore {
      * 查询单条运行记录并补齐幂等请求标识关联（详情路径专用）。
      */
     getRunWithRequestId(id: string, isClosed: boolean): RunRecord | null;
-    listRuns(options?: {
-        actionId?: string;
-        status?: string;
-        limit?: number;
-        offset?: number;
-    }): RunRecord[];
+    listRuns(options?: RunsQueryFilterOptions): RunRecord[];
     /**
      * 统计符合过滤条件的真实运行记录总数。
      * 支持按 actionId、status 以及包含 requestIds 的反查场景统计总数。
      */
-    countRuns(options?: {
-        actionId?: string;
-        status?: string;
-        requestIds?: string[];
-    }, isClosed?: boolean): number;
+    countRuns(options?: RunsQueryFilterOptions, isClosed?: boolean): number;
     /**
      * 按客户端幂等请求标识反查关联运行记录总数。
      */
-    countRunsByRequestIds(isClosed: boolean, requestIds: string[], options?: {
-        actionId?: string;
-        status?: string;
-    }): number;
+    countRunsByRequestIds(isClosed: boolean, requestIds: string[], options?: RunsQueryFilterOptions): number;
     /**
      * 构造 IN (…) 占位符列表。
      */
@@ -85,7 +73,7 @@ export declare class SqliteRunsStore {
      * 当前包，保证多包共库（全局库）时不越界读取其他包的运行记录。
      * 不按 owner_id 过滤：写入方与查询方分属不同宿主进程，ownerId 必然不同。
      */
-    listRunsByRequestIds(isClosed: boolean, requestIds: string[]): RunRecord[];
+    listRunsByRequestIds(isClosed: boolean, requestIds: string[], options?: RunsQueryFilterOptions): RunRecord[];
     /**
      * 反查当前包范围内运行记录关联的幂等请求标识。
      *

package/dist/storage/sqlite-runs.js

@@ -244,6 +244,30 @@ export class SqliteRunsStore {
             sql += " AND status = ?";
             params.push(options.status);
         }
+        if (options.channel) {
+            sql += " AND json_extract(origin_json, '$.channel') = ?";
+            params.push(options.channel);
+        }
+        if (options.view) {
+            sql += " AND json_extract(origin_json, '$.viewName') = ?";
+            params.push(options.view);
+        }
+        if (options.since) {
+            sql += " AND started_at >= ?";
+            params.push(options.since);
+        }
+        if (options.until) {
+            sql += " AND started_at <= ?";
+            params.push(options.until);
+        }
+        if (options.rootRunId) {
+            sql += " AND root_run_id = ?";
+            params.push(options.rootRunId);
+        }
+        if (options.parentRunId) {
+            sql += " AND parent_run_id = ?";
+            params.push(options.parentRunId);
+        }
         sql += " ORDER BY started_at DESC LIMIT ?";
         params.push(limit);
         if (typeof options.offset === "number" && options.offset > 0) {
@@ -281,6 +305,30 @@ export class SqliteRunsStore {
                 sql += " AND runs.status = ?";
                 params.push(options.status);
             }
+            if (options.channel) {
+                sql += " AND json_extract(runs.origin_json, '$.channel') = ?";
+                params.push(options.channel);
+            }
+            if (options.view) {
+                sql += " AND json_extract(runs.origin_json, '$.viewName') = ?";
+                params.push(options.view);
+            }
+            if (options.since) {
+                sql += " AND runs.started_at >= ?";
+                params.push(options.since);
+            }
+            if (options.until) {
+                sql += " AND runs.started_at <= ?";
+                params.push(options.until);
+            }
+            if (options.rootRunId) {
+                sql += " AND runs.root_run_id = ?";
+                params.push(options.rootRunId);
+            }
+            if (options.parentRunId) {
+                sql += " AND runs.parent_run_id = ?";
+                params.push(options.parentRunId);
+            }
             const stmt = this.getStatement(sql);
             const row = stmt.get(...params);
             return row?.count ?? 0;
@@ -295,6 +343,30 @@ export class SqliteRunsStore {
             sql += " AND status = ?";
             params.push(options.status);
         }
+        if (options.channel) {
+            sql += " AND json_extract(origin_json, '$.channel') = ?";
+            params.push(options.channel);
+        }
+        if (options.view) {
+            sql += " AND json_extract(origin_json, '$.viewName') = ?";
+            params.push(options.view);
+        }
+        if (options.since) {
+            sql += " AND started_at >= ?";
+            params.push(options.since);
+        }
+        if (options.until) {
+            sql += " AND started_at <= ?";
+            params.push(options.until);
+        }
+        if (options.rootRunId) {
+            sql += " AND root_run_id = ?";
+            params.push(options.rootRunId);
+        }
+        if (options.parentRunId) {
+            sql += " AND parent_run_id = ?";
+            params.push(options.parentRunId);
+        }
         const stmt = this.getStatement(sql);
         const row = stmt.get(...params);
         return row?.count ?? 0;
@@ -318,23 +390,56 @@ export class SqliteRunsStore {
      * 当前包，保证多包共库（全局库）时不越界读取其他包的运行记录。
      * 不按 owner_id 过滤：写入方与查询方分属不同宿主进程，ownerId 必然不同。
      */
-    listRunsByRequestIds(isClosed, requestIds) {
+    listRunsByRequestIds(isClosed, requestIds, options = {}) {
         if (isClosed || requestIds.length === 0)
             return [];
         const uniqueIds = Array.from(new Set(requestIds.filter((id) => typeof id === "string" && id.length > 0)));
         if (uniqueIds.length === 0)
             return [];
-        const sql = `
+        let sql = `
       SELECT runs.*, ik.request_id AS request_id
       FROM runs
       INNER JOIN idempotency_keys AS ik ON ik.run_id = runs.id
       WHERE runs.package_id = ?
         AND ik.request_id IN (${SqliteRunsStore.placeholders(uniqueIds.length)})
-      ORDER BY runs.started_at DESC
     `;
+        const params = [this.packageId, ...uniqueIds];
+        if (options.actionId) {
+            sql += " AND runs.action_id = ?";
+            params.push(options.actionId);
+        }
+        if (options.status) {
+            sql += " AND runs.status = ?";
+            params.push(options.status);
+        }
+        if (options.channel) {
+            sql += " AND json_extract(runs.origin_json, '$.channel') = ?";
+            params.push(options.channel);
+        }
+        if (options.view) {
+            sql += " AND json_extract(runs.origin_json, '$.viewName') = ?";
+            params.push(options.view);
+        }
+        if (options.since) {
+            sql += " AND runs.started_at >= ?";
+            params.push(options.since);
+        }
+        if (options.until) {
+            sql += " AND runs.started_at <= ?";
+            params.push(options.until);
+        }
+        if (options.rootRunId) {
+            sql += " AND runs.root_run_id = ?";
+            params.push(options.rootRunId);
+        }
+        if (options.parentRunId) {
+            sql += " AND runs.parent_run_id = ?";
+            params.push(options.parentRunId);
+        }
+        sql += " ORDER BY runs.started_at DESC";
         const stmt = this.getStatement(sql);
-        const rows = stmt.all(this.packageId, ...uniqueIds);
-        const records = rows.map((r) => this.mapRunRecord(r));
+        const rows = stmt.all(...params);
+        let records = rows.map((r) => this.mapRunRecord(r));
         // requestId 来自联查列，直接补齐（mapRunRecord 无法从 runs 行还原）
         const requestIdByRunId = new Map();
         for (const row of rows) {
@@ -347,6 +452,23 @@ export class SqliteRunsStore {
             if (requestId)
                 record.requestId = requestId;
         }
+        // 内存过滤适配
+        if (options.actionId)
+            records = records.filter((r) => r.actionId === options.actionId);
+        if (options.status)
+            records = records.filter((r) => r.status === options.status);
+        if (options.channel)
+            records = records.filter((r) => r.origin?.channel === options.channel);
+        if (options.view)
+            records = records.filter((r) => r.origin?.viewName === options.view);
+        if (options.since)
+            records = records.filter((r) => r.startedAt >= options.since);
+        if (options.until)
+            records = records.filter((r) => r.startedAt <= options.until);
+        if (options.rootRunId)
+            records = records.filter((r) => r.rootRunId === options.rootRunId);
+        if (options.parentRunId)
+            records = records.filter((r) => r.parentRunId === options.parentRunId);
         return records;
     }
     /**

package/dist/storage/sqlite.d.ts

@@ -1,5 +1,5 @@
 import { decodeStateKey, encodeStateKey, escapeStateSegment, unescapeStateSegment, type Logger, type RuntimeError, type RunRecord } from "@actiondock/sdk";
-import { type IdempotencyCheckResult, type IdempotencyRecord, type RunsRetentionPolicy, type RuntimeStorage, type StateEntry, type StorageOptions, type TerminalRunStatus } from "./types.js";
+import { type IdempotencyCheckResult, type IdempotencyRecord, type RunsQueryFilterOptions, type RunsRetentionPolicy, type RuntimeStorage, type StateEntry, type StorageOptions, type TerminalRunStatus } from "./types.js";
 export { decodeStateKey, encodeStateKey, escapeStateSegment, unescapeStateSegment, };
 export interface SqliteStorageOptions extends StorageOptions {
     logger?: Logger;
@@ -48,17 +48,8 @@ export declare class SqliteRuntimeStorage implements RuntimeStorage {
     createRun(record: RunRecord | any): void;
     updateRun(id: string, status: TerminalRunStatus, output?: unknown, error?: RuntimeError, finishedAt?: string): void;
     getRun(id: string): RunRecord | null;
-    listRuns(options?: {
-        actionId?: string;
-        status?: string;
-        limit?: number;
-        offset?: number;
-    }): RunRecord[];
-    countRuns(options?: {
-        actionId?: string;
-        status?: string;
-        requestIds?: string[];
-    }): number;
+    listRuns(options?: RunsQueryFilterOptions): RunRecord[];
+    countRuns(options?: RunsQueryFilterOptions): number;
     clearRuns(options?: {
         actionId?: string;
         status?: string;
@@ -69,11 +60,8 @@ export declare class SqliteRuntimeStorage implements RuntimeStorage {
     touchRunHeartbeat(runIds: string[]): number;
     checkAndRecordIdempotency(record: IdempotencyRecord): IdempotencyCheckResult;
     getIdempotencyRecord(ownerId: string, actionRef: string, requestId: string): IdempotencyRecord | undefined;
-    listRunsByRequestIds(requestIds: string[]): RunRecord[];
-    countRunsByRequestIds(requestIds: string[], options?: {
-        actionId?: string;
-        status?: string;
-    }): number;
+    listRunsByRequestIds(requestIds: string[], options?: RunsQueryFilterOptions): RunRecord[];
+    countRunsByRequestIds(requestIds: string[], options?: RunsQueryFilterOptions): number;
     getRunRequestIds(runIds: string[]): Record<string, string>;
     getRunWithRequestId(id: string): RunRecord | null;
     appendEvent(eventType: string, payload: unknown): void;

package/dist/storage/sqlite.js

@@ -159,8 +159,8 @@ export class SqliteRuntimeStorage {
     getIdempotencyRecord(ownerId, actionRef, requestId) {
         return this.runsStore.getIdempotencyRecord(this.isClosed, ownerId, actionRef, requestId);
     }
-    listRunsByRequestIds(requestIds) {
-        return this.runsStore.listRunsByRequestIds(this.isClosed, requestIds);
+    listRunsByRequestIds(requestIds, options = {}) {
+        return this.runsStore.listRunsByRequestIds(this.isClosed, requestIds, options);
     }
     countRunsByRequestIds(requestIds, options = {}) {
         return this.runsStore.countRunsByRequestIds(this.isClosed, requestIds, options);