@actiondock/core 2.19.0 → 2.21.0

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/migrations/index.d.ts

@@ -0,0 +1,40 @@
+import type { ConfigItemDefinition } from "../../project/types.js";
+import type { ConfigKeyProvider } from "../../security/config-cipher.js";
+import type { Clock } from "../clock.js";
+import { type SqliteDriver } from "../types.js";
+/**
+ * 版本迁移执行上下文：迁移所需的最小依赖集合。
+ *
+ * 由存储装配入口（SqliteRuntimeStorage）提供底层驱动、目标命名空间、
+ * 配置声明集合与密钥提供器；主干层只装配数据，不做任何迁移判断。
+ */
+export interface SchemaMigrationContext {
+    driver: SqliteDriver;
+    dbPath: string;
+    packageId: string;
+    declarations: readonly Record<string, ConfigItemDefinition>[];
+    keyProvider: ConfigKeyProvider;
+    clock: Clock;
+}
+/** 单个版本迁移步骤：from → to 的原子转换。 */
+export interface StorageMigration {
+    from: number;
+    to: number;
+    run(context: SchemaMigrationContext): void;
+}
+/**
+ * 存储打开前的版本就绪入口：新库建库、旧库迁移、当前库校验。
+ *
+ * 调用时机：先于任何正常子存储构造（当前版本存储实现始终假定数据库
+ * 已经是当前版本），也先于运行记录恢复（恢复依赖子存储）。
+ *
+ * - 版本等于当前：锁外只读校验核心表齐备，缺失即拒绝（半升级或损坏
+ *   状态不得静默修补）；
+ * - 其余版本（含全新库）：统一进入 BEGIN IMMEDIATE 写事务，锁内重读
+ *   版本后决策——全新库执行当前版本 DDL，旧版本沿注册链迁移并逐步更新
+ *   版本号，无支持路径（如版本 1 或未来版本）明确拒绝；
+ * - 结构完整性校验在事务内、提交前执行：任何失败（含迁移步骤与最终
+ *   校验）都会把数据、结构与版本号整体回滚，数据库保持进入前状态可重试；
+ * - 并发连接已抢先完成同一升级时，锁内版本已是当前版本，校验后直接通过。
+ */
+export declare function ensureStorageSchema(context: SchemaMigrationContext): void;

package/dist/storage/migrations/index.js

@@ -0,0 +1,96 @@
+import { ActionDockError, UNSUPPORTED_STORAGE_SCHEMA } from "../../errors.js";
+import { createCurrentSchema, validateCurrentSchema } from "../sqlite-schema.js";
+import { STORAGE_SCHEMA_VERSION } from "../types.js";
+import { migrateV2ToV3 } from "./v2-to-v3.js";
+/**
+ * 已注册的版本迁移链。
+ *
+ * 每个历史版本的全部转换逻辑封装在各自迁移文件中；下线某旧版本支持时，
+ * 删除对应迁移文件与注册项即可，当前版本读写代码不感知历史版本。
+ */
+const MIGRATIONS = [
+    { from: 2, to: 3, run: migrateV2ToV3 },
+];
+/** 读取数据库当前 schema 版本号。 */
+function readUserVersion(driver) {
+    const row = driver.prepare("PRAGMA user_version;").get();
+    return Number(row?.user_version ?? 0);
+}
+/** 构造不支持版本的统一拒绝错误。 */
+function unsupportedVersionError(version, dbPath) {
+    return new ActionDockError(UNSUPPORTED_STORAGE_SCHEMA, `Database schema version ${version} of '${dbPath}' has no supported migration path to the current version ${STORAGE_SCHEMA_VERSION}; upgrade the database first with a build that still supports version ${version}.`, { dbPath, version, current: STORAGE_SCHEMA_VERSION });
+}
+/**
+ * 沿注册链推导从 from 到当前版本的迁移步骤序列。
+ *
+ * 返回 null 表示无支持路径：from 非法（<= 0）、不低于当前版本（未来版本
+ * 一律拒绝，结构完整也不得当作当前版本打开），或链上存在缺口、注册步骤
+ * 无法精确抵达当前版本。
+ */
+function buildMigrationChain(from) {
+    if (from <= 0 || from >= STORAGE_SCHEMA_VERSION) {
+        return null;
+    }
+    const chain = [];
+    let version = from;
+    while (version < STORAGE_SCHEMA_VERSION) {
+        const step = MIGRATIONS.find((migration) => migration.from === version);
+        if (!step) {
+            return null;
+        }
+        chain.push(step);
+        version = step.to;
+    }
+    if (version !== STORAGE_SCHEMA_VERSION) {
+        return null;
+    }
+    return chain;
+}
+/**
+ * 存储打开前的版本就绪入口：新库建库、旧库迁移、当前库校验。
+ *
+ * 调用时机：先于任何正常子存储构造（当前版本存储实现始终假定数据库
+ * 已经是当前版本），也先于运行记录恢复（恢复依赖子存储）。
+ *
+ * - 版本等于当前：锁外只读校验核心表齐备，缺失即拒绝（半升级或损坏
+ *   状态不得静默修补）；
+ * - 其余版本（含全新库）：统一进入 BEGIN IMMEDIATE 写事务，锁内重读
+ *   版本后决策——全新库执行当前版本 DDL，旧版本沿注册链迁移并逐步更新
+ *   版本号，无支持路径（如版本 1 或未来版本）明确拒绝；
+ * - 结构完整性校验在事务内、提交前执行：任何失败（含迁移步骤与最终
+ *   校验）都会把数据、结构与版本号整体回滚，数据库保持进入前状态可重试；
+ * - 并发连接已抢先完成同一升级时，锁内版本已是当前版本，校验后直接通过。
+ */
+export function ensureStorageSchema(context) {
+    const { driver, dbPath } = context;
+    // 跨进程写并发基线：优先设置 busy_timeout，确保后续 PRAGMA（如
+    // journal_mode = WAL）与迁移事务在锁争用时能够重试等待
+    driver.exec("PRAGMA busy_timeout = 5000;");
+    driver.exec("PRAGMA journal_mode = WAL;");
+    driver.exec("PRAGMA synchronous = NORMAL;");
+    if (readUserVersion(driver) === STORAGE_SCHEMA_VERSION) {
+        validateCurrentSchema(driver, dbPath);
+        return;
+    }
+    driver.transaction(() => {
+        const locked = readUserVersion(driver);
+        if (locked === STORAGE_SCHEMA_VERSION) {
+            validateCurrentSchema(driver, dbPath);
+            return;
+        }
+        if (locked === 0) {
+            createCurrentSchema(driver);
+        }
+        else {
+            const chain = buildMigrationChain(locked);
+            if (chain === null) {
+                throw unsupportedVersionError(locked, dbPath);
+            }
+            for (const step of chain) {
+                step.run(context);
+                driver.exec(`PRAGMA user_version = ${step.to};`);
+            }
+        }
+        validateCurrentSchema(driver, dbPath);
+    }, "immediate");
+}

package/dist/storage/migrations/v2-to-v3.d.ts

@@ -0,0 +1,16 @@
+import type { SchemaMigrationContext } from "./index.js";
+/**
+ * V2 → V3 专用迁移：V2 数据库全部历史知识的唯一归属地。
+ *
+ * 在调用方维护事务（BEGIN IMMEDIATE）内完成：
+ * - 结构补齐：runs 表新增列（origin_json / host_session_id / host_pid /
+ *   heartbeat_at）、events 审计事件表、config_encryption 密钥元数据表；
+ * - 敏感明文转密文：按声明集合（各字典内具体键优先于模板、跨字典取并集）
+ *   判定当前命名空间的配置键，整键加密并保留业务值与 updated_at；
+ * - 密钥管理：存在待加密行时才解析并持久化密钥（提供器在迁移事务内先落盘
+ *   密钥与身份标记，再由本事务提交密文），同一事务内钉住密钥指纹。
+ *
+ * 直接操作底层 SQL，不构造也不调用当前版本存储对象：将来修改正常写入
+ * 行为不会意外改变历史迁移语义。本文件与注册项在下线 V2 支持时整体删除。
+ */
+export declare function migrateV2ToV3(context: SchemaMigrationContext): void;

package/dist/storage/migrations/v2-to-v3.js

@@ -0,0 +1,116 @@
+import { ActionDockError, CONFIG_ENCRYPTION_ERROR } from "../../errors.js";
+import { resolveConfigDeclaration } from "../../project/config-declarations.js";
+import { isEncryptedConfigValue } from "../../security/config-cipher.js";
+import { isSecretConfigKey } from "../mask.js";
+import { CONFIG_ENCRYPTION_TABLE_DDL } from "../sqlite-schema.js";
+import { encryptConfigEnvelope, mergeProtectionDeclarations } from "../config-value.js";
+import { safeParseStoredJson } from "../utils.js";
+/**
+ * V2 → V3 专用迁移：V2 数据库全部历史知识的唯一归属地。
+ *
+ * 在调用方维护事务（BEGIN IMMEDIATE）内完成：
+ * - 结构补齐：runs 表新增列（origin_json / host_session_id / host_pid /
+ *   heartbeat_at）、events 审计事件表、config_encryption 密钥元数据表；
+ * - 敏感明文转密文：按声明集合（各字典内具体键优先于模板、跨字典取并集）
+ *   判定当前命名空间的配置键，整键加密并保留业务值与 updated_at；
+ * - 密钥管理：存在待加密行时才解析并持久化密钥（提供器在迁移事务内先落盘
+ *   密钥与身份标记，再由本事务提交密文），同一事务内钉住密钥指纹。
+ *
+ * 直接操作底层 SQL，不构造也不调用当前版本存储对象：将来修改正常写入
+ * 行为不会意外改变历史迁移语义。本文件与注册项在下线 V2 支持时整体删除。
+ */
+export function migrateV2ToV3(context) {
+    upgradeRunsColumns(context.driver);
+    ensureEventsTable(context.driver);
+    context.driver.exec(CONFIG_ENCRYPTION_TABLE_DDL);
+    encryptSensitivePlaintextConfigs(context);
+}
+/** 补齐 runs 表历史新增列（旧库形态可能全部缺失）。 */
+function upgradeRunsColumns(driver) {
+    const columns = driver.prepare("PRAGMA table_info(runs);").all();
+    const present = new Set(columns.map((column) => column.name));
+    const additions = [
+        ["origin_json", "TEXT"],
+        ["host_session_id", "TEXT"],
+        ["host_pid", "INTEGER"],
+        ["heartbeat_at", "TEXT"],
+    ];
+    for (const [column, type] of additions) {
+        if (!present.has(column)) {
+            driver.exec(`ALTER TABLE runs ADD COLUMN ${column} ${type};`);
+        }
+    }
+}
+/** 补齐 events 审计事件表（V3 必备结构）。 */
+function ensureEventsTable(driver) {
+    driver.exec(`
+    CREATE TABLE IF NOT EXISTS events (
+      id TEXT PRIMARY KEY,
+      package_id TEXT NOT NULL,
+      event_type TEXT NOT NULL,
+      payload_json TEXT,
+      created_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_events_type ON events(package_id, event_type);
+  `);
+}
+/** 解析目标键在各声明字典下的有效声明并集（各字典内具体键优先于模板）。 */
+function resolveDeclarations(declarations, key) {
+    const items = [];
+    for (const dict of declarations) {
+        const resolved = resolveConfigDeclaration(dict, key)?.item;
+        if (resolved !== undefined) {
+            items.push(resolved);
+        }
+    }
+    return items;
+}
+/**
+ * 按声明集合加密当前命名空间的敏感明文配置行。
+ *
+ * - 只处理非空明文行：普通明文与非敏感键保持原状（普通明文与密文在
+ *   当前版本内合法共存）；空串与空值行留待正常写入路径处理；
+ * - 先对全部目标行完成严格 JSON 解析，再解析密钥并钉住指纹，避免为
+ *   注定失败的迁移提前创建密钥文件；任何一步失败由调用方事务整体回滚；
+ * - 迁移只替换 value_json，业务原值与 updated_at 完整保留。
+ */
+function encryptSensitivePlaintextConfigs(context) {
+    const { driver, packageId, declarations, keyProvider, clock, dbPath } = context;
+    const rows = driver
+        .prepare("SELECT key, value_json FROM config WHERE package_id = ?")
+        .all(packageId);
+    const targets = [];
+    for (const row of rows) {
+        const raw = row.value_json;
+        if (typeof raw !== "string" || raw === "" || isEncryptedConfigValue(raw)) {
+            continue;
+        }
+        const items = resolveDeclarations(declarations, row.key);
+        if (!items.some((item) => isSecretConfigKey(row.key, item))) {
+            continue;
+        }
+        const value = safeParseStoredJson(raw, `v2-migration config db=${dbPath} package=${packageId} key=${row.key}`, { strict: true });
+        targets.push({ key: row.key, value, items });
+    }
+    if (targets.length === 0) {
+        return;
+    }
+    const material = keyProvider(true);
+    const pinned = driver
+        .prepare("SELECT key_id FROM config_encryption WHERE id = 1")
+        .get();
+    if (pinned === undefined) {
+        driver
+            .prepare("INSERT INTO config_encryption (id, key_id, created_at) VALUES (1, ?, ?)")
+            .run(material.id, clock.now().toISOString());
+    }
+    else if (pinned.key_id !== material.id) {
+        throw new ActionDockError(CONFIG_ENCRYPTION_ERROR, `Config encryption metadata exists with a different key identity in database '${dbPath}'`, { dbPath, pinnedKeyId: pinned.key_id });
+    }
+    const update = driver.prepare("UPDATE config SET value_json = ? WHERE package_id = ? AND key = ?");
+    for (const target of targets) {
+        const protection = mergeProtectionDeclarations([], target.items, target.key);
+        const ciphertext = encryptConfigEnvelope(target.value, protection, packageId, target.key, material);
+        update.run(ciphertext, packageId, target.key);
+    }
+}