tanmi-dock 0.10.0-beta → 1.0.3

package/dist/commands/link.js

@@ -7,13 +7,13 @@ import { Command } from 'commander';
 import { ensureInitialized } from '../core/guard.js';
 import * as config from '../core/config.js';
 import { setLogLevel } from '../utils/logger.js';
-import { parseProjectDependencies, getRelativeConfigPath, parseCodepacDep, extractActions, parseActionCommand, extractNestedDependencies, findAllCodepacConfigs, extractDependencies, resolveProjectRootPath, } from '../core/parser.js';
+import { parseProjectDependencies, getRelativeConfigPath, parseCodepacDep, extractActions, buildActionExecutionPlan, extractNestedDependencies, findAllCodepacConfigs, extractDependencies, resolveProjectRootPath, } from '../core/parser.js';
 import { getRegistry } from '../core/registry.js';
 import * as store from '../core/store.js';
 import * as linker from '../core/linker.js';
 import * as codepac from '../core/codepac.js';
 import { setProxyConfig } from '../core/codepac.js';
-import { getPlatformHelpText, GENERAL_PLATFORM, SHARED_PLATFORM, pathsEqual, isSparseOnlyCommon, KNOWN_PLATFORM_VALUES, getRequestedPlatformTargets, } from '../core/platform.js';
+import { getPlatformHelpText, GENERAL_PLATFORM, SHARED_PLATFORM, pathsEqual, isSparseOnlyCommon, KNOWN_PLATFORM_VALUES, getRequestedPlatformTargets, resolveSparseConfig, getBaseKeyForCodepac, } from '../core/platform.js';
 import { Transaction } from '../core/transaction.js';
 import { formatSize, checkDiskSpace } from '../utils/disk.js';
 import { getDirSize } from '../utils/fs-utils.js';
@@ -37,6 +37,7 @@ export function createLinkCommand() {
         .option('--no-download', '不自动下载缺失库')
         .option('--dry-run', '只显示将要执行的操作')
         .option('--config <configs...>', '指定可选配置文件 (如 codepac-dep-inner.json)')
+        .option('--skip-action, --skip_action, -sa <names...>', '按 action.name 跳过指定嵌套 action')
         .option('--no-submodules', '不检测 git submodule 依赖')
         .addHelpText('after', `${getPlatformHelpText()}
 
@@ -48,6 +49,7 @@ export function createLinkCommand() {
   td link --dry-run             预览操作，不实际执行
   td link -y                    跳过确认，自动执行
   td link --config codepac-dep-inner.json   使用指定的可选配置
+  td link --skip-action prepareNested       跳过指定 action.name
   td link --no-submodules       跳过 git submodule 检测`)
         .action(async (projectPath, options) => {
         await ensureInitialized();
@@ -97,8 +99,20 @@ async function resolveRequestedStoreState(dependency, requestedPlatforms, vars)
         if (await store.exists(dependency.libName, dependency.commit, platform)) {
             resolvedExisting.push(platform);
         }
+        else {
+            const registry = getRegistry();
+            const storeKey = registry.getStoreKey(dependency.libName, dependency.commit, platform);
+            if (registry.getStore(storeKey)) {
+                registry.removeStore(storeKey);
+                const storePath = await store.getStorePath();
+                const platformPath = store.getLibraryPath(storePath, dependency.libName, dependency.commit, platform);
+                await fs.rm(platformPath, { recursive: true, force: true }).catch(() => { });
+            }
+        }
     }
-    return resolveRequestedPlatformsByActual(requestedPlatforms, dependency.sparse, resolvedExisting, vars);
+    const result = resolveRequestedPlatformsByActual(requestedPlatforms, dependency.sparse, resolvedExisting, vars);
+    debug(`[link-store-state] ${dependency.libName}@${dependency.commit.slice(0, 7)} 请求平台=${requestedPlatforms.join(', ') || '空'}, Store候选=${candidatePlatforms.join(', ') || '空'}, 实际存在=${result.actualExisting.join(', ') || '无'}, 满足请求=${result.satisfiedRequested.join(', ') || '无'}, 缺失请求=${result.missingRequested.join(', ') || '无'}`);
+    return result;
 }
 function getBlockedRequestedPlatforms(registry, dependency, requestedPlatforms, vars) {
     const { manualPlatforms, autoPlatforms } = resolveUnavailablePlatforms(registry, dependency);
@@ -109,7 +123,9 @@ function getBlockedRequestedPlatforms(registry, dependency, requestedPlatforms,
         const targets = getRequestedPlatformTargets(platform, dependency.sparse, vars);
         return targets.length === 1 && targets[0] === platform;
     });
-    return [...new Set([...manualBlocked, ...autoBlocked])];
+    const blocked = [...new Set([...manualBlocked, ...autoBlocked])];
+    debug(`[link-platforms] ${dependency.libName}@${dependency.commit.slice(0, 7)} 请求平台=${requestedPlatforms.join(', ') || '空'}, 手动跳过=${manualBlocked.join(', ') || '无'}, 自动跳过=${autoBlocked.join(', ') || '无'}, 最终跳过=${blocked.join(', ') || '无'}`);
+    return blocked;
 }
 function clearSatisfiedAutoUnavailablePlatforms(registry, dependency, satisfiedRequested) {
     if (satisfiedRequested.length === 0)
@@ -154,12 +170,93 @@ function upsertLibraryAvailability(dependency, updates) {
         lastAccess: new Date().toISOString(),
     });
 }
-export async function resolveLibraryGeneralState(dependency) {
+export async function resolveLibraryGeneralState(dependency, requestedPlatforms = [], vars) {
     const registry = getRegistry();
     const libKey = registry.getLibraryKey(dependency.libName, dependency.commit);
     const library = registry.getLibrary(libKey);
+    const sparseConfig = resolveSparseConfig(dependency.sparse, vars);
+    const hasPlatformSparse = sparseConfig
+        ? Object.keys(sparseConfig).some((key) => key !== 'common')
+        : Boolean(dependency.sparse && !isSparseOnlyCommon(dependency.sparse));
+    const hasPlatformLibraryHistory = requestedPlatforms.length > 0
+        && library?.isGeneral === false
+        && library.platforms.some((platform) => platform !== GENERAL_PLATFORM);
+    if (requestedPlatforms.length > 0) {
+        const requestedState = await resolveRequestedStoreState(dependency, requestedPlatforms, vars);
+        if (requestedState.actualExisting.length > 0) {
+            if (library?.isGeneral === true) {
+                registry.updateLibrary(libKey, {
+                    platforms: requestedState.actualExisting,
+                    isGeneral: false,
+                    lastAccess: new Date().toISOString(),
+                });
+            }
+            return false;
+        }
+    }
+    if (requestedPlatforms.length > 0 && library?.isGeneral === true) {
+        const requestedTargets = [...new Set(requestedPlatforms.flatMap((platform) => getRequestedPlatformTargets(platform, dependency.sparse, vars)))];
+        const storePath = await store.getStorePath();
+        const commitPath = path.join(storePath, dependency.libName, dependency.commit);
+        try {
+            const entries = await fs.readdir(commitPath, { withFileTypes: true });
+            let hasRequestedPlatformDir = false;
+            for (const entry of entries) {
+                if (!entry.isDirectory() || !requestedTargets.includes(entry.name))
+                    continue;
+                if (await store.exists(dependency.libName, dependency.commit, entry.name)) {
+                    hasRequestedPlatformDir = true;
+                    break;
+                }
+            }
+            if (hasRequestedPlatformDir) {
+                return false;
+            }
+        }
+        catch {
+            // Store 目录不存在时继续使用历史记录或后续 General 检测
+        }
+    }
+    if (requestedPlatforms.length > 0 && hasPlatformSparse) {
+        if (library?.isGeneral === true) {
+            registry.updateLibrary(libKey, {
+                isGeneral: false,
+                lastAccess: new Date().toISOString(),
+            });
+        }
+        return false;
+    }
+    if (hasPlatformLibraryHistory) {
+        return false;
+    }
     if (typeof library?.isGeneral === 'boolean') {
-        return library.isGeneral;
+        if (library.isGeneral) {
+            const hasGeneralContent = await store.exists(dependency.libName, dependency.commit, GENERAL_PLATFORM);
+            if (!hasGeneralContent) {
+                registry.updateLibrary(libKey, {
+                    isGeneral: false,
+                    lastAccess: new Date().toISOString(),
+                });
+                return false;
+            }
+            const actualGeneral = await store.isGeneralLib(dependency.libName, dependency.commit);
+            if (!actualGeneral) {
+                registry.updateLibrary(libKey, {
+                    isGeneral: false,
+                    lastAccess: new Date().toISOString(),
+                });
+            }
+            return actualGeneral;
+        }
+        const actualGeneral = await store.isGeneralLib(dependency.libName, dependency.commit);
+        if (actualGeneral) {
+            registry.updateLibrary(libKey, {
+                platforms: [GENERAL_PLATFORM],
+                isGeneral: true,
+                lastAccess: new Date().toISOString(),
+            });
+        }
+        return actualGeneral;
     }
     return store.isGeneralLib(dependency.libName, dependency.commit);
 }
@@ -173,7 +270,7 @@ export function resolveUnavailablePlatforms(registry, dependency) {
         autoPlatforms,
     };
 }
-export async function collectProjectDependencyGraph(projectRoot) {
+export async function collectProjectDependencyGraph(projectRoot, codepacPlatforms = []) {
     const { normalizedPath, configPath } = await resolveProjectRootPath(projectRoot);
     if (!configPath) {
         throw new Error('只能在项目目录下使用');
@@ -182,11 +279,17 @@ export async function collectProjectDependencyGraph(projectRoot) {
     const seenDeps = new Set();
     const visitedConfigs = new Set();
     const queue = [
-        { configPath, source: 'direct' },
+        { configPath, targetDir: path.dirname(configPath), codepacPlatforms, source: 'direct' },
     ];
-    const submodules = await findSubmoduleConfigs(normalizedPath);
+    const submodules = await findSubmoduleConfigs(normalizedPath, '', 0, codepacPlatforms);
     for (const submodule of submodules) {
-        queue.push({ configPath: submodule.configPath, scope: submodule.relativePath, source: 'submodule' });
+        queue.push({
+            configPath: submodule.configPath,
+            targetDir: path.dirname(submodule.configPath),
+            codepacPlatforms,
+            scope: submodule.relativePath,
+            source: 'submodule',
+        });
     }
     while (queue.length > 0) {
         const current = queue.shift();
@@ -200,25 +303,32 @@ export async function collectProjectDependencyGraph(projectRoot) {
         catch {
             continue;
         }
-        for (const dependency of extractDependencies(parsedConfig)) {
+        const extractOptions = { platforms: current.codepacPlatforms, configPath: current.configPath };
+        for (const dependency of extractDependencies(parsedConfig, extractOptions)) {
             const key = `${dependency.libName}:${dependency.commit}:${current.scope ?? ''}`;
             if (!seenDeps.has(key)) {
                 seenDeps.add(key);
                 results.push({ ...dependency, scope: current.scope, source: current.source });
             }
         }
-        for (const action of extractActions(parsedConfig)) {
-            let parsedAction;
+        for (const action of extractActions(parsedConfig, extractOptions)) {
+            let plan;
             try {
-                parsedAction = parseActionCommand(action.command);
+                plan = buildActionExecutionPlan(action, {
+                    parentConfigPath: current.configPath,
+                    parentTargetDir: current.targetDir,
+                    inheritedCodepacPlatforms: current.codepacPlatforms,
+                });
             }
             catch {
                 continue;
             }
-            const nestedConfigPath = path.resolve(path.dirname(current.configPath), parsedAction.configDir, 'codepac-dep.json');
             let nested;
             try {
-                nested = await extractNestedDependencies(nestedConfigPath, parsedAction.libraries);
+                nested = await extractNestedDependencies(plan.nestedConfigPath, plan.libraries, {
+                    platforms: plan.effectiveCodepacPlatforms,
+                    configPath: plan.nestedConfigPath,
+                });
             }
             catch {
                 continue;
@@ -230,7 +340,15 @@ export async function collectProjectDependencyGraph(projectRoot) {
                     results.push({ ...dependency, scope: current.scope, source: 'nested' });
                 }
             }
-            queue.push({ configPath: nestedConfigPath, scope: current.scope, source: 'nested' });
+            if (!plan.parsed.disableAction) {
+                queue.push({
+                    configPath: plan.nestedConfigPath,
+                    targetDir: plan.nestedTargetDir,
+                    codepacPlatforms: plan.effectiveCodepacPlatforms,
+                    scope: current.scope,
+                    source: 'nested',
+                });
+            }
         }
     }
     return results;
@@ -276,6 +394,16 @@ async function selectSubmodules(configs, options, remembered) {
     }
     return selected.map(s => ({ ...s }));
 }
+function buildSubmoduleOptionalConfigState(submodules) {
+    const state = {};
+    for (const submodule of submodules) {
+        const names = submodule.selectedOptionalConfigs?.map((config) => config.name) ?? [];
+        if (names.length > 0) {
+            state[submodule.relativePath] = names;
+        }
+    }
+    return Object.keys(state).length > 0 ? state : undefined;
+}
 /**
  * 单个 scope（主项目或 submodule）的链接处理
  *
@@ -284,6 +412,7 @@ async function selectSubmodules(configs, options, remembered) {
 async function linkScope(params) {
     const { scopeName, configPath, platforms, scanExtraPlatforms, registry, tx, projectHash, projectRoot, storePath, download, dryRun, yes, concurrency, gitLightweightDownload, optionalConfigs, scope, } = params;
     let finalLinkPlatforms = [...params.finalLinkPlatforms];
+    const codepacPlatforms = [...new Set(platforms.map((platform) => getBaseKeyForCodepac(platform)))];
     // 记录 General 类型库
     const generalLibs = new Set();
     const downloadedLibs = [];
@@ -292,17 +421,32 @@ async function linkScope(params) {
     info(`分析 ${scopeName}: ${configPath}`);
     let dependencies;
     let configVars;
+    const selectedActions = [];
+    const cacheConfigPaths = [configPath];
     try {
-        const result = await parseProjectDependencies(path.dirname(path.dirname(configPath)));
+        const result = await parseProjectDependencies(path.dirname(path.dirname(configPath)), {
+            platforms: codepacPlatforms,
+        });
         dependencies = result.dependencies;
         configVars = result.vars;
+        const topLevelConfig = await parseCodepacDep(configPath);
+        selectedActions.push(...extractActions(topLevelConfig, { platforms: codepacPlatforms, configPath }));
         // 合并可选配置依赖
         if (optionalConfigs && optionalConfigs.length > 0) {
             for (const optionalConfig of optionalConfigs) {
                 try {
                     const optionalResult = await parseCodepacDep(optionalConfig.path);
-                    const optionalDeps = extractDependencies(optionalResult);
+                    const optionalDeps = extractDependencies(optionalResult, {
+                        platforms: codepacPlatforms,
+                        configPath: optionalConfig.path,
+                    });
                     dependencies = mergeDepLists(dependencies, optionalDeps);
+                    configVars = { ...configVars, ...optionalResult.vars };
+                    selectedActions.push(...extractActions(optionalResult, {
+                        platforms: codepacPlatforms,
+                        configPath: optionalConfig.path,
+                    }));
+                    cacheConfigPaths.push(optionalConfig.path);
                     info(`  + ${optionalConfig.name}: ${optionalDeps.length} 个依赖`);
                 }
                 catch (optErr) {
@@ -463,7 +607,7 @@ async function linkScope(params) {
             case DependencyStatus.LINKED: {
                 const blockedPlatforms = getBlockedRequestedPlatforms(registry, dependency, platforms, configVars);
                 const requestedPlatforms = platforms.filter((platform) => !blockedPlatforms.includes(platform));
-                const isLinkedGeneral = await resolveLibraryGeneralState(dependency);
+                const isLinkedGeneral = await resolveLibraryGeneralState(dependency, requestedPlatforms, configVars);
                 if (!isLinkedGeneral) {
                     const supplementResult = await supplementMissingPlatforms(dependency, platforms, registry, tx, {
                         vars: configVars,
@@ -489,7 +633,7 @@ async function linkScope(params) {
                 const blockedPlatforms = getBlockedRequestedPlatforms(registry, dependency, platforms, configVars);
                 const requestedPlatforms = platforms.filter((platform) => !blockedPlatforms.includes(platform));
                 const relinkCommitPath = path.join(storePath, dependency.libName, dependency.commit);
-                const isRelinkGeneral = await resolveLibraryGeneralState(dependency);
+                const isRelinkGeneral = await resolveLibraryGeneralState(dependency, requestedPlatforms, configVars);
                 if (isRelinkGeneral) {
                     tx.recordOp('unlink', localPath);
                     await linker.unlink(localPath);
@@ -547,7 +691,7 @@ async function linkScope(params) {
                 const requestedPlatforms = platforms.filter((platform) => !blockedPlatforms.includes(platform));
                 const replaceSize = await getDirSize(localPath);
                 const replaceCommitPath = path.join(storePath, dependency.libName, dependency.commit);
-                const isReplaceGeneral = await resolveLibraryGeneralState(dependency);
+                const isReplaceGeneral = await resolveLibraryGeneralState(dependency, requestedPlatforms, configVars);
                 if (isReplaceGeneral) {
                     const sharedPath = path.join(replaceCommitPath, '_shared');
                     tx.recordOp('replace', localPath, sharedPath);
@@ -776,7 +920,7 @@ async function linkScope(params) {
                 }
                 const { actualExisting: linkNewExisting, satisfiedRequested, } = await resolveRequestedStoreState(dependency, requestedPlatforms, configVars);
                 clearSatisfiedAutoUnavailablePlatforms(registry, dependency, satisfiedRequested);
-                const isLinkNewGeneral = await resolveLibraryGeneralState(dependency);
+                const isLinkNewGeneral = await resolveLibraryGeneralState(dependency, requestedPlatforms, configVars);
                 if (isLinkNewGeneral) {
                     const sharedPath = path.join(linkNewCommitPath, '_shared');
                     tx.recordOp('link', localPath, sharedPath);
@@ -845,9 +989,34 @@ async function linkScope(params) {
                     const storeCommitPath = path.join(storePath, dependency.libName, dependency.commit);
                     const blockedPlatforms = getBlockedRequestedPlatforms(registry, dependency, platforms, configVars);
                     const requestedPlatforms = platforms.filter((platform) => !blockedPlatforms.includes(platform));
+                    if (requestedPlatforms.length === 0) {
+                        pLog.warn(`${dependency.libName} 请求平台 [${platforms.join(', ')}] 均已按规则跳过，没有可链接产物`);
+                        if (await linker.cleanupEmptyLocalDirectory(localPath)) {
+                            pLog.warn(`${dependency.libName} 已清理历史遗留的空本地目录`);
+                        }
+                        return {
+                            success: false,
+                            name: dependency.libName,
+                            skipped: true,
+                            skippedPlatforms: blockedPlatforms,
+                            unsupported: true,
+                        };
+                    }
                     const { actualExisting: existing, missingRequested: missing, satisfiedRequested, } = await resolveRequestedStoreState(dependency, requestedPlatforms, configVars);
                     clearSatisfiedAutoUnavailablePlatforms(registry, dependency, satisfiedRequested);
                     if (missing.length === 0) {
+                        if (existing.length === 0) {
+                            pLog.warn(`${dependency.libName} 请求平台 [${requestedPlatforms.join(', ')}] 在 Store 中没有可链接产物，已拒绝创建空目录`);
+                            if (await linker.cleanupEmptyLocalDirectory(localPath)) {
+                                pLog.warn(`${dependency.libName} 已清理历史遗留的空本地目录`);
+                            }
+                            return {
+                                success: false,
+                                name: dependency.libName,
+                                skipped: true,
+                                skippedPlatforms: requestedPlatforms,
+                            };
+                        }
                         pLog.info(`${dependency.libName} 所有平台已存在，直接链接...`);
                         tx.recordOp('link', localPath, storeCommitPath);
                         await linker.linkLib(localPath, storeCommitPath, existing);
@@ -864,6 +1033,9 @@ async function linkScope(params) {
                         if (knownUnavailable.length > 0) {
                             pLog.warn(`${dependency.libName} 平台 [${knownUnavailable.join(', ')}] 已按规则跳过`);
                         }
+                        if (await linker.cleanupEmptyLocalDirectory(localPath)) {
+                            pLog.warn(`${dependency.libName} 已清理历史遗留的空本地目录`);
+                        }
                         return { success: false, name: dependency.libName, skipped: true, skippedPlatforms: missing, unsupported: true };
                     }
                     pLog.info(`下载 ${dependency.libName} [${dlToDownload.join(', ')}]...`);
@@ -924,6 +1096,10 @@ async function linkScope(params) {
                         }
                         const linkPlatforms = [...existing, ...filteredDownloaded];
                         if (linkPlatforms.length === 0) {
+                            pLog.warn(`${dependency.libName} 下载后没有生成请求平台 [${requestedPlatforms.join(', ')}] 的可链接产物，已拒绝创建空目录`);
+                            if (await linker.cleanupEmptyLocalDirectory(localPath)) {
+                                pLog.warn(`${dependency.libName} 已清理历史遗留的空本地目录`);
+                            }
                             return {
                                 success: false,
                                 name: dependency.libName,
@@ -978,26 +1154,32 @@ async function linkScope(params) {
         }
     }
     // 9. 处理嵌套依赖 (actions)
-    const topLevelConfig = await parseCodepacDep(configPath);
-    const actions = extractActions(topLevelConfig);
+    const actions = selectedActions;
     const nestedLinkedDeps = [];
     if (actions.length > 0) {
         blank();
         separator();
         info(`发现 ${actions.length} 个嵌套依赖配置`);
         const nestedContext = {
-            depth: 0, processedConfigs: new Set([configPath]), platforms, vars: configVars,
+            depth: 0,
+            processedConfigs: new Set([buildActionVisitKey(configPath, path.dirname(configPath))]),
+            platforms,
+            codepacPlatforms,
+            vars: configVars,
         };
         const thirdPartyDir = path.dirname(configPath);
         for (const action of actions) {
-            await processAction(action, nestedContext, thirdPartyDir, {
+            await processAction(action, nestedContext, configPath, thirdPartyDir, {
                 tx, registry, projectHash, projectRoot, dryRun, download, yes,
-                gitLightweightDownload, generalLibs, downloadedLibs, nestedLinkedDeps,
+                gitLightweightDownload, skipActions: new Set(params.skipActions ?? []),
+                generalLibs, downloadedLibs, nestedLinkedDeps,
             });
         }
     }
     // 10. 同步 cache 文件
-    await syncCacheFile(configPath);
+    for (const cacheConfigPath of cacheConfigPaths) {
+        await syncCacheFile(cacheConfigPath);
+    }
     // 11. 构建返回结果
     const linkedDeps = [];
     for (const item of classified) {
@@ -1070,9 +1252,10 @@ export async function linkProject(projectPath, options) {
         error(`路径不存在: ${absolutePath}`);
         process.exit(EXIT_CODES.NOINPUT);
     }
-    // 发现可选配置文件
-    const thirdpartyDir = path.join(normalizedPath, '3rdparty');
-    const configDiscovery = await findAllCodepacConfigs(thirdpartyDir);
+    // 发现可选配置文件，扫描位置跟随实际主配置所在目录。
+    const configDiscovery = discoveredConfigPath
+        ? await findAllCodepacConfigs(path.dirname(discoveredConfigPath))
+        : null;
     let selectedOptionalConfigs = [];
     if (configDiscovery && configDiscovery.optionalConfigs.length > 0) {
         if (options.config && options.config.length > 0) {
@@ -1119,14 +1302,21 @@ export async function linkProject(projectPath, options) {
     // === 阶段 2: Submodule 检测 ===
     let selectedSubmodules = [];
     if (options.submodules !== false) {
-        const submoduleConfigs = await findSubmoduleConfigs(normalizedPath);
+        const codepacPlatforms = [...new Set(platforms.map((platform) => getBaseKeyForCodepac(platform)))];
+        const submoduleConfigs = await findSubmoduleConfigs(normalizedPath, '', 0, codepacPlatforms);
         if (submoduleConfigs.length > 0) {
             selectedSubmodules = await selectSubmodules(submoduleConfigs, options, existingProject?.submodules);
             // 为选中的 submodule 处理可选配置
             for (const sub of selectedSubmodules) {
-                if (sub.optionalConfigs.length > 0 && !options.yes && process.stdout.isTTY) {
+                if (sub.optionalConfigs.length === 0)
+                    continue;
+                const rememberedConfigs = existingProject?.submoduleOptionalConfigs?.[sub.relativePath] ?? [];
+                if (options.yes) {
+                    sub.selectedOptionalConfigs = sub.optionalConfigs.filter((configInfo) => rememberedConfigs.includes(configInfo.name));
+                }
+                else if (process.stdout.isTTY) {
                     info(`${sub.name} 发现可选配置:`);
-                    const selected = await selectOptionalConfigs(sub.optionalConfigs, { isTTY: true, specifiedConfigs: [] });
+                    const selected = await selectOptionalConfigs(sub.optionalConfigs, { isTTY: true, specifiedConfigs: rememberedConfigs });
                     if (selected !== PROMPT_CANCELLED) {
                         sub.selectedOptionalConfigs = selected;
                     }
@@ -1194,6 +1384,7 @@ export async function linkProject(projectPath, options) {
             concurrency,
             gitLightweightDownload,
             optionalConfigs: selectedOptionalConfigs,
+            skipActions: options.skipAction ?? [],
         });
         const finalLinkPlatforms = mainResult.finalLinkPlatforms;
         // 如果 dry-run 模式，linkScope 内已显示信息
@@ -1219,6 +1410,7 @@ export async function linkProject(projectPath, options) {
                     gitLightweightDownload,
                     optionalConfigs: sub.selectedOptionalConfigs,
                     scope: sub.relativePath,
+                    skipActions: options.skipAction ?? [],
                 });
             }
             return;
@@ -1245,6 +1437,7 @@ export async function linkProject(projectPath, options) {
                 gitLightweightDownload,
                 optionalConfigs: sub.selectedOptionalConfigs,
                 scope: sub.relativePath,
+                skipActions: options.skipAction ?? [],
             });
             subResults.push(subResult);
         }
@@ -1269,6 +1462,7 @@ export async function linkProject(projectPath, options) {
                 ? selectedOptionalConfigs.map(c => c.name) : undefined,
             submodules: selectedSubmodules.length > 0
                 ? selectedSubmodules.map(s => s.relativePath) : undefined,
+            submoduleOptionalConfigs: buildSubmoduleOptionalConfigState(selectedSubmodules),
         });
         // 更新 Store 引用关系
         const newStoreKeys = allLinkedDeps.map((d) => registry.getStoreKey(d.libName, d.commit, d.platform));
@@ -1419,10 +1613,7 @@ function hintStoreRepairCommand(err) {
 async function registerSharedStore(libName, commit, branch = '', url = '') {
     const registry = getRegistry();
     const storeKey = registry.getStoreKey(libName, commit, SHARED_PLATFORM);
-    // 如果已存在，不重复注册
-    if (registry.getStore(storeKey)) {
-        return true;
-    }
+    const existingEntry = registry.getStore(storeKey);
     // 检查 _shared 目录是否存在
     const storePath = await config.getStorePath();
     if (!storePath)
@@ -1440,17 +1631,27 @@ async function registerSharedStore(libName, commit, branch = '', url = '') {
     }
     // 计算 _shared 完整性信息并注册
     const integrity = await store.captureIntegrity(libName, commit, SHARED_PLATFORM);
-    registry.addStore({
-        libName,
-        commit,
-        platform: SHARED_PLATFORM,
-        branch,
-        url,
-        ...integrity,
-        usedBy: [], // _shared 不追踪引用，生命周期跟随平台
-        createdAt: new Date().toISOString(),
-        lastAccess: new Date().toISOString(),
-    });
+    if (existingEntry) {
+        registry.updateStore(storeKey, {
+            branch: existingEntry.branch || branch,
+            url: existingEntry.url || url,
+            ...integrity,
+            lastAccess: new Date().toISOString(),
+        });
+    }
+    else {
+        registry.addStore({
+            libName,
+            commit,
+            platform: SHARED_PLATFORM,
+            branch,
+            url,
+            ...integrity,
+            usedBy: [], // _shared 不追踪引用，生命周期跟随平台
+            createdAt: new Date().toISOString(),
+            lastAccess: new Date().toISOString(),
+        });
+    }
     debug(`注册 _shared: ${libName}:${commit.slice(0, 8)} (${formatSize(integrity.size)})`);
     return true;
 }
@@ -1476,6 +1677,13 @@ async function ensureStoreInfo(libName, commit, platform, branch, url, projectHa
         const integrity = await store.captureIntegrity(libName, commit, platform);
         registry.updateStore(storeKey, integrity);
     }
+    if (existingEntry && ((!existingEntry.branch && branch) || (!existingEntry.url && url))) {
+        registry.updateStore(storeKey, {
+            branch: existingEntry.branch || branch,
+            url: existingEntry.url || url,
+            lastAccess: new Date().toISOString(),
+        });
+    }
     if (projectHash) {
         registry.addStoreReference(storeKey, projectHash);
     }
@@ -1716,7 +1924,7 @@ async function classifyDependencies(dependencies, projectPath, configPath, platf
         }
         const existing = verifiedExisting;
         // 也检查是否为 General 库（有 _shared 且有内容）
-        const isGeneral = await resolveLibraryGeneralState(dep);
+        const isGeneral = await resolveLibraryGeneralState(dep, requestedPlatforms, vars);
         const inStore = existing.length > 0 || isGeneral;
         if (satisfiedRequested.length > 0) {
             clearSatisfiedAutoUnavailablePlatforms(getRegistry(), dep, satisfiedRequested);
@@ -1953,19 +2161,20 @@ function getStatusKey(status) {
 async function syncCacheFile(configPath) {
     const configDir = path.dirname(configPath);
     const cacheDir = path.join(configDir, '.cache');
-    const cachePath = path.join(cacheDir, 'codepac-dep.json');
+    const configFileName = path.basename(configPath);
+    const cachePath = path.join(cacheDir, configFileName);
     try {
         // 确保 .cache 目录存在
         await fs.mkdir(cacheDir, { recursive: true });
         // 复制配置文件到 cache
         await fs.copyFile(configPath, cachePath);
         if (process.env.VERBOSE) {
-            info(`已同步 cache: ${path.basename(configPath)}`);
+            info(`已同步 cache: ${configFileName} -> ${path.relative(configDir, cachePath)}`);
         }
     }
     catch (err) {
         // cache 同步失败不应阻塞主流程，仅警告
-        warn(`cache 同步失败: ${err.message}`);
+        warn(`cache 同步失败: ${configFileName} -> ${path.relative(configDir, cachePath)}: ${err.message}`);
     }
 }
 /**
@@ -1975,78 +2184,98 @@ async function syncCacheFile(configPath) {
  * @param thirdPartyDir 3rdparty 目录路径
  * @param options 处理选项
  */
-async function processAction(action, context, thirdPartyDir, options) {
+async function processAction(action, context, parentConfigPath, parentTargetDir, options) {
     const indent = '  '.repeat(context.depth);
-    // 1. 解析 action 命令
-    let parsed;
+    if (action.name && options.skipActions.has(action.name)) {
+        info(`${indent}跳过嵌套 action: name=${action.name}, 原因=skip-action`);
+        debug(`${indent}CodePac action 跳过: name=${action.name}, command=${action.command}, skipActions=${Array.from(options.skipActions).join(',')}`);
+        return;
+    }
+    // 1. 解析 action 命令和执行计划
+    let plan;
     try {
-        parsed = parseActionCommand(action.command);
+        plan = buildActionExecutionPlan(action, {
+            parentConfigPath,
+            parentTargetDir,
+            inheritedCodepacPlatforms: context.codepacPlatforms ?? context.platforms,
+        });
     }
     catch (err) {
-        warn(`${indent}无法解析 action: ${err.message}`);
+        warn(`${indent}跳过嵌套 action: name=${action.name ?? '(未命名)'}, 原因=无法解析命令, message=${err.message}`);
+        debug(`${indent}CodePac action 解析失败: command=${action.command}`);
         return;
     }
-    const libsDisplay = parsed.libraries.length > 0 ? parsed.libraries.join(', ') : '全部依赖';
-    info(`${indent}处理嵌套依赖: ${parsed.configDir} → [${libsDisplay}]`);
-    // 2. 构建嵌套配置路径
-    const nestedConfigPath = path.join(thirdPartyDir, parsed.configDir, 'codepac-dep.json');
-    // 3. 循环检测
-    if (context.processedConfigs.has(nestedConfigPath)) {
-        warn(`${indent}  检测到循环依赖，跳过: ${parsed.configDir}`);
+    const libsDisplay = plan.libraries.length > 0 ? plan.libraries.join(', ') : '全部依赖';
+    info(`${indent}处理嵌套 action: name=${plan.actionName ?? '(未命名)'}, config=${plan.nestedConfigPath}, target=${plan.nestedTargetDir}, libs=[${libsDisplay}]`);
+    debug(`${indent}CodePac action 执行计划: command=${plan.command}, parentConfig=${parentConfigPath}, parentTarget=${parentTargetDir}, parsedConfigDir=${plan.configDir}, parsedTargetDir=${plan.targetDir}, resolvedConfig=${plan.nestedConfigPath}, resolvedTarget=${plan.nestedTargetDir}, inheritedPlatforms=${formatActionPlatforms(plan.inheritedPlatforms)}, effectivePlatforms=${formatActionPlatforms(plan.effectiveCodepacPlatforms)}, explicitPlatform=${plan.parsed.hasExplicitPlatform}, fullgit=${plan.parsed.hasExplicitFullGit}, unshallow=${plan.parsed.hasExplicitUnshallow}, disable_sparse=${plan.parsed.hasExplicitDisableSparse}`);
+    // 2. 循环检测
+    const visitKey = buildActionVisitKey(plan.nestedConfigPath, plan.nestedTargetDir);
+    if (context.processedConfigs.has(visitKey)) {
+        warn(`${indent}  跳过嵌套 action: name=${plan.actionName ?? '(未命名)'}, 原因=循环配置, config=${plan.nestedConfigPath}, target=${plan.nestedTargetDir}`);
         return;
     }
-    context.processedConfigs.add(nestedConfigPath);
-    // 4. 检查配置文件是否存在
+    context.processedConfigs.add(visitKey);
+    // 3. 检查配置文件是否存在
     try {
-        await fs.access(nestedConfigPath);
+        await fs.access(plan.nestedConfigPath);
     }
     catch {
-        warn(`${indent}  嵌套配置文件不存在: ${nestedConfigPath}`);
-        hint(`${indent}  请确保 ${parsed.configDir} 库已被下载`);
+        warn(`${indent}  跳过嵌套 action: name=${plan.actionName ?? '(未命名)'}, 原因=配置不存在, config=${plan.nestedConfigPath}`);
+        hint(`${indent}  请确保 ${plan.configDir} 库已被下载`);
         return;
     }
-    // 5. 提取指定库的依赖
+    // 4. 提取指定库的依赖
     let nestedResult;
     try {
-        nestedResult = await extractNestedDependencies(nestedConfigPath, parsed.libraries);
+        nestedResult = await extractNestedDependencies(plan.nestedConfigPath, plan.libraries, {
+            platforms: plan.effectiveCodepacPlatforms,
+            configPath: plan.nestedConfigPath,
+        });
     }
     catch (err) {
-        warn(`${indent}  解析嵌套配置失败: ${err.message}`);
+        warn(`${indent}  跳过嵌套 action: name=${plan.actionName ?? '(未命名)'}, 原因=解析配置失败, message=${err.message}`);
         return;
     }
     const { dependencies, vars, nestedActions } = nestedResult;
     if (dependencies.length === 0) {
-        warn(`${indent}  在 ${parsed.configDir} 中未找到指定的库`);
+        warn(`${indent}  跳过嵌套 action: name=${plan.actionName ?? '(未命名)'}, 原因=未找到依赖, libs=[${libsDisplay}], config=${plan.nestedConfigPath}`);
         return;
     }
-    info(`${indent}  找到 ${dependencies.length} 个嵌套依赖`);
-    // 6. 合并变量
+    info(`${indent}  嵌套 action 命中 ${dependencies.length} 个依赖，继承平台: ${formatActionPlatforms(plan.inheritedPlatforms)}, 生效平台: ${formatActionPlatforms(plan.effectiveCodepacPlatforms)}`);
+    // 5. 合并变量
     const mergedVars = { ...context.vars, ...vars };
-    // 7. 处理这些依赖（targetDir 指定嵌套依赖的目标目录）
+    // 6. 处理这些依赖（targetDir 指定嵌套依赖的目标目录）
     await linkNestedDependencies(dependencies, {
-        thirdPartyDir,
-        targetDir: parsed.targetDir,
-        nestedConfigPath,
-        context: { ...context, vars: mergedVars },
+        targetDir: plan.nestedTargetDir,
+        nestedConfigPath: plan.nestedConfigPath,
+        context: { ...context, codepacPlatforms: plan.effectiveCodepacPlatforms, vars: mergedVars },
         options,
         indent,
     });
     // 同步嵌套配置文件的 cache（兼容 checkValid.js 检测）
-    await syncCacheFile(nestedConfigPath);
-    // 8. 递归处理嵌套 actions（如果没有 disable_action）
-    // 注意：递归时 thirdPartyDir 应该更新为当前嵌套依赖的目标目录
-    if (!parsed.disableAction && nestedActions.length > 0) {
+    await syncCacheFile(plan.nestedConfigPath);
+    // 7. 递归处理嵌套 actions（如果没有 disable_action）
+    if (!plan.parsed.disableAction && nestedActions.length > 0) {
         const nestedContext = {
             depth: context.depth + 1,
             processedConfigs: context.processedConfigs,
             platforms: context.platforms,
+            codepacPlatforms: plan.effectiveCodepacPlatforms,
             vars: mergedVars,
         };
-        const nestedThirdPartyDir = path.join(thirdPartyDir, parsed.targetDir);
         for (const nestedAction of nestedActions) {
-            await processAction(nestedAction, nestedContext, nestedThirdPartyDir, options);
+            await processAction(nestedAction, nestedContext, plan.nestedConfigPath, plan.nestedTargetDir, options);
         }
     }
+    else if (plan.parsed.disableAction && nestedActions.length > 0) {
+        info(`${indent}  跳过后续嵌套 action: name=${plan.actionName ?? '(未命名)'}, 原因=disable_action`);
+    }
+}
+function formatActionPlatforms(platforms) {
+    return platforms && platforms.length > 0 ? platforms.join(',') : 'all';
+}
+function buildActionVisitKey(configPath, targetDir) {
+    return `${configPath}::${targetDir}`;
 }
 /**
  * 统一的本地目录验证+吸收流程
@@ -2104,9 +2333,7 @@ async function resolveLocalAndAbsorb(localPath, libName, commit, options) {
  * 链接嵌套依赖
  */
 async function linkNestedDependencies(dependencies, params) {
-    const { thirdPartyDir, targetDir, context, options, indent } = params;
-    // 计算嵌套依赖的实际目标目录
-    const nestedTargetDir = path.join(thirdPartyDir, targetDir);
+    const { targetDir: nestedTargetDir, context, options, indent } = params;
     const { tx, registry, projectHash, projectRoot, dryRun, download, generalLibs, downloadedLibs, nestedLinkedDeps } = options;
     const { platforms, vars } = context;
     for (const dep of dependencies) {
@@ -2130,7 +2357,7 @@ async function linkNestedDependencies(dependencies, params) {
         const availablePlatforms = platforms.filter(p => !unavailablePlatforms.includes(p));
         const knownUnavailable = platforms.filter(p => unavailablePlatforms.includes(p));
         let storeHas = false;
-        const existingPlatforms = [];
+        let existingPlatforms = [];
         const initialStoreState = await resolveRequestedStoreState(dep, availablePlatforms, vars);
         existingPlatforms.push(...initialStoreState.actualExisting);
         if (initialStoreState.satisfiedRequested.length > 0) {
@@ -2140,6 +2367,7 @@ async function linkNestedDependencies(dependencies, params) {
         // 完整性校验：验证 existing 平台的文件完整性（与 classifyDependencies 同逻辑）
         if (existingPlatforms.length > 0) {
             const { valid: verifiedPlatforms, corrupted } = await verifyExistingPlatforms(dep.libName, dep.commit, existingPlatforms);
+            existingPlatforms = verifiedPlatforms;
             if (corrupted.length > 0) {
                 for (const p of corrupted) {
                     const storeKey = registry.getStoreKey(dep.libName, dep.commit, p);
@@ -2147,10 +2375,10 @@ async function linkNestedDependencies(dependencies, params) {
                     const platformPath = store.getLibraryPath(await store.getStorePath(), dep.libName, dep.commit, p);
                     await fs.rm(platformPath, { recursive: true, force: true }).catch(() => { });
                 }
-                storeHas = verifiedPlatforms.length > 0;
             }
+            storeHas = existingPlatforms.length > 0;
         }
-        let isGeneral = await resolveLibraryGeneralState(dep);
+        let isGeneral = await resolveLibraryGeneralState(dep, availablePlatforms, vars);
         // 如果所有平台都已知不可用，跳过
         if (availablePlatforms.length === 0 && knownUnavailable.length > 0 && !isGeneral) {
             warn(`${indent}  ${dep.libName} - 平台 [${knownUnavailable.join(', ')}] 已按规则跳过`);
@@ -2171,10 +2399,21 @@ async function linkNestedDependencies(dependencies, params) {
                 if (resolveResult.isGeneral) {
                     isGeneral = true;
                 }
+                else if (resolveResult.absorbResult) {
+                    const absorbedPlatforms = resolveResult.absorbResult.platforms;
+                    const absorbedPlatformSet = new Set(absorbedPlatforms);
+                    const linkableAbsorbedPlatforms = [...new Set(availablePlatforms.flatMap((platform) => getRequestedPlatformTargets(platform, dep.sparse, vars)
+                            .filter((target) => absorbedPlatformSet.has(target))))];
+                    existingPlatforms = [...new Set([
+                            ...existingPlatforms,
+                            ...linkableAbsorbedPlatforms,
+                        ])];
+                    debug(`${indent}  ${dep.libName} - 本地吸收后平台回填: requested=${availablePlatforms.join(', ') || '无'}, absorbed=${absorbedPlatforms.join(', ') || '无'}, linkable=${existingPlatforms.join(', ') || '无'}`);
+                }
                 if (resolveResult.absorbResult?.nestedLibraries.length) {
                     await registerNestedLibraries(resolveResult.absorbResult.nestedLibraries, projectHash);
                 }
-                storeHas = true;
+                storeHas = isGeneral || existingPlatforms.length > 0;
                 // 吸收为 General 后，检查是否实际需要平台内容
                 // 本地可能只有部分文件（如只有 _shared 内容），被误分类为 General
                 if (resolveResult.isGeneral && download) {
@@ -2481,26 +2720,62 @@ export async function verifyExistingPlatforms(libName, commit, existingPlatforms
     for (const platform of existingPlatforms) {
         const storeKey = registry.getStoreKey(libName, commit, platform);
         const entry = registry.getStore(storeKey);
-        // 没有 StoreEntry，跳过校验视为合法
         if (!entry) {
+            try {
+                const integrity = await store.captureIntegrity(libName, commit, platform);
+                if (integrity.fileCount === 0) {
+                    corrupted.push(platform);
+                    warn(`${libName} (${commit.slice(0, 7)}) ${platform}: Store 目录为空`);
+                    continue;
+                }
+                registry.addStore({
+                    libName,
+                    commit,
+                    platform,
+                    branch: '',
+                    url: '',
+                    ...integrity,
+                    usedBy: [],
+                    createdAt: new Date().toISOString(),
+                    lastAccess: new Date().toISOString(),
+                });
+            }
+            catch {
+                corrupted.push(platform);
+                warn(`${libName} (${commit.slice(0, 7)}) ${platform}: Store 完整性回填失败`);
+                continue;
+            }
             valid.push(platform);
             continue;
         }
+        if (entry.fileCount === 0) {
+            corrupted.push(platform);
+            warn(`${libName} (${commit.slice(0, 7)}) ${platform}: Store 记录为空`);
+            continue;
+        }
         // 旧数据回填：升级后首次遇到无 fileCount 的条目，顺便记录完整性数据
         if (entry.fileCount == null) {
             try {
                 const integrity = await store.captureIntegrity(libName, commit, platform);
                 registry.updateStore(storeKey, integrity);
+                if (integrity.fileCount === 0) {
+                    corrupted.push(platform);
+                    warn(`${libName} (${commit.slice(0, 7)}) ${platform}: Store 目录为空`);
+                    continue;
+                }
             }
             catch {
-                // 回填失败不影响正常流程
+                corrupted.push(platform);
+                warn(`${libName} (${commit.slice(0, 7)}) ${platform}: Store 完整性回填失败`);
+                continue;
             }
             valid.push(platform);
             continue;
         }
-        const result = await store.quickVerify(libName, commit, platform, {
+        const result = await store.fullVerify(libName, commit, platform, {
             size: entry.size,
             fileCount: entry.fileCount,
+            contentHash: entry.contentHash,
         });
         if (result.valid) {
             valid.push(platform);