@yanglaofish/fishtools 0.5.2 → 0.6.0

package/node_modules/@mytools/fst-platform/src/shell.js

@@ -7,6 +7,8 @@ import {runProcess as executeProcess} from './process.js';
 
 const shells=new Set(['auto','powershell','pwsh','sh','bash']);
 const powerShellArgs=['-NoLogo','-NoProfile','-NonInteractive','-OutputFormat','Text'];
+const windowsOemEncodings=new Map([[866,'ibm866'],[874,'windows-874'],[932,'shift_jis'],[936,'gbk'],[949,'euc-kr'],[950,'big5'],[65001,'utf-8']]);
+let windowsOemCodePage;
 
 function selectShell(script,shell,platform){
   if(typeof script!=='string'||!script.trim()||script.includes('\u0000'))throw new FlowError('命令文本必须是非空字符串，且不能包含 NUL 字符',{code:'VALIDATION'});
@@ -14,6 +16,42 @@ function selectShell(script,shell,platform){
   return shell==='auto'?(platform==='win32'?'powershell':'sh'):shell;
 }
 
+function ipconfigArguments(script){
+  // 只解析单行字面量；Shell 运算符、展开、组合引号与特殊引号均留给 PowerShell。
+  if(/[\r\n\u0085\u2028\u2029\u2018\u2019\u201c\u201d]/.test(script))return;
+  const command=/^\s*ipconfig(?:\.exe)?(?=\s|$)/i.exec(script);
+  if(!command)return;
+  let remaining=script.slice(command[0].length);const args=[];
+  while(remaining.trim()){
+    const token=/^\s+(?:'((?:[^']|'')*)'|"([^"`$]*)"|([^\s"'`$;|&<>(){}\[\]#@,]+))(?=\s|$)/.exec(remaining);
+    if(!token)return;
+    const value=token[1]!==undefined?token[1].replaceAll("''","'"):token[2]??token[3];
+    if(value==='--%')return;
+    args.push(value);remaining=remaining.slice(token[0].length);
+  }
+  return args;
+}
+
+async function ipconfigEncoding(windowsRoot,{cwd,env,extendEnv,signal,timeout}){
+  if(windowsOemCodePage===undefined){
+    // GetOEMCP 读取当前系统原生代码页，不修改控制台代码页或依赖用户的区域格式。
+    const source=`Add-Type -Namespace Fst -Name NativeCodePage -MemberDefinition '[System.Runtime.InteropServices.DllImport("kernel32.dll")] public static extern uint GetOEMCP();'; [Console]::WriteLine([Fst.NativeCodePage]::GetOEMCP())`;
+    const encoded=Buffer.from(source,'utf16le').toString('base64');
+    const command=`& ([ScriptBlock]::Create([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('${encoded}'))))`;
+    let result;
+    try{
+      result=await executeProcess(path.join(windowsRoot,'System32','WindowsPowerShell','v1.0','powershell.exe'),[...powerShellArgs,'-Command',command],{cwd,env,extendEnv,signal,timeout,maxBuffer:4096});
+    }catch(error){
+      if(error.code==='CANCELLED'||error.code==='TIMEOUT')throw error;
+      return;
+    }
+    if(result.exitCode!==0||!/^\d+$/.test(result.stdout.trim()))return;
+    windowsOemCodePage=Number(result.stdout.trim());
+  }
+  // TextDecoder 不支持 OEM 437、850 等代码页；无法准确解码时保留原 Shell 路径。
+  return windowsOemEncodings.get(windowsOemCodePage);
+}
+
 function powerShellSource(script){
   // $? 在脚本最后一条命令后立即读取，避免沿用更早的外部命令退出码。
   return `[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding($false)
@@ -42,6 +80,13 @@ export function shellInvocation(script,{shell='auto',platform=process.platform}=
 export async function runShell(script,{shell='auto',runProcess:execute=executeProcess,temporaryDir=tmpdir(),...processOptions}={}){
   const file=selectShell(script,shell,process.platform),powershell=file==='powershell'||file==='pwsh';
   if(processOptions.signal?.aborted)throw new FlowError('操作已取消',{code:'CANCELLED'});
+  if(process.platform==='win32'&&shell==='auto'){
+    const args=ipconfigArguments(script),windowsRoot=process.env.SystemRoot??process.env.windir;
+    if(args&&windowsRoot&&path.isAbsolute(windowsRoot)){
+      const encoding=processOptions.encoding??await ipconfigEncoding(windowsRoot,processOptions);
+      if(encoding)return execute(path.join(windowsRoot,'System32','ipconfig.exe'),args,{...processOptions,encoding,commandText:script});
+    }
+  }
   const directory=path.resolve(temporaryDir);
   await mkdir(directory,{recursive:true});
   const scriptFile=path.join(directory,`fst-shell-${randomUUID()}.${powershell?'ps1':'sh'}`);
@@ -53,6 +98,6 @@ export async function runShell(script,{shell='auto',runProcess:execute=executePr
       await handle.writeFile(powershell?'\uFEFF'+powerShellSource(script):script,'utf8');
     }finally{await handle.close();}
     const args=powershell?[...powerShellArgs,'-ExecutionPolicy','Bypass','-File',scriptFile]:[scriptFile];
-    return await execute(file,args,processOptions);
+    return await execute(file,args,{...processOptions,commandText:script});
   }finally{await rm(scriptFile,{force:true});}
 }

package/node_modules/@mytools/fst-plugin/README.md

@@ -20,6 +20,10 @@
 
 ## 维护与验证
 
+动作及命令的上下文 runProcess 使用 platform/managed-process 的共用包装，统一指令、输出关联与取消信号；代理仍由宿主按动作构造。权限预检发生在动作主体之前，不自动提权。共享包装不串行化调用；宿主同进程信任模型不变，开发约束不能替代安全隔离。
+
+动作、动作别名命令及独立交互命令共用 SDK 输入解析。顶层输入字段的 `x-fst.fromConfig` 声明先取实际插件配置，再回退到输入 schema 默认值；显式输入优先。`host.previewInput(target, input)` 返回有效值及来源，管理界面无需读取整份宿主配置。声明由 `validateDeclarations` 检查，插件加载和开发工具使用同一规则。
+
 本模块负责上述职责的实现、文档与回归；跨模块接口调整需要同时检查生产者与消费者。具体维护人员尚未指定。
 
 在仓库根目录执行：

package/node_modules/@mytools/fst-plugin/package.json

@@ -18,7 +18,7 @@
   ],
   "license": "MIT",
   "engines": {
-    "node": ">=24.15.0"
+    "node": "^22.22.2 || >=24.0.0"
   },
   "dependencies": {
     "@mytools/sdk": "0.1.0",

package/node_modules/@mytools/fst-plugin/src/contracts.js

@@ -3,6 +3,7 @@ import {conditionOperators} from '@mytools/sdk/conditions';
 import {resolveSchemaPath} from '@mytools/sdk/schema-path';
 import {inside} from '@mytools/fst-platform/environments';
 import path from 'node:path';
+import {validateInputRules} from '@mytools/sdk/inputs';
 
 export const builtinCommands=[
   ['workflows','选择已有工作流'],['new','新建工作流'],['add','添加插件能力或子工作流'],
@@ -37,6 +38,8 @@ function validatePrivilegeDeclarations(plugin){
 }
 
 export function validateDeclarations(plugin){
+  for(const [name,owner] of Object.entries(plugin.actions??{}))validateInputRules(owner?.input,plugin.config,`plugin.actions.${name}.input`);
+  for(const [name,owner] of Object.entries(plugin.commands??{}))if(!owner?.action)validateInputRules(owner?.input,plugin.config,`plugin.commands.${name}.input`);
   for(const [name,action] of Object.entries(plugin.actions??{})){
     if(!action||typeof action!=='object'||Array.isArray(action))throw new FlowError(`动作 ${name} 的声明必须为对象`,{code:'VALIDATION'});
     if(action.conditions!==undefined&&(!action.conditions||typeof action.conditions!=='object'||Array.isArray(action.conditions)))throw new FlowError(`动作 ${name} 的 conditions 必须为对象`,{code:'VALIDATION'});

package/node_modules/@mytools/fst-plugin/src/host.js

@@ -2,37 +2,32 @@ import { Context } from 'cordis';
 import semver from 'semver';
 import { SDK_VERSION, FlowError } from '@mytools/sdk';
 import { validate, emptyObject } from '@mytools/sdk/schema';
+import {resolveInput} from '@mytools/sdk/inputs';
 import {validateDeclarations,validateCommands} from './contracts.js';
 import {prepareEnvironments,platformWarnings} from '@mytools/fst-platform/environments';
 import path from 'node:path';
 import {mkdir} from 'node:fs/promises';
 import {createHash} from 'node:crypto';
-import {createRuntime} from './runtime.js';
+import {createRuntime,validateRuntimes,validateRuntimeDeclaration} from './runtime.js';
 import {pluginError} from '@mytools/sdk/diagnostics';
 import {validateNetworkPolicy,resolveNetworkPolicy,createHttpClient,buildProcessEnv} from '@mytools/fst-platform/network';
 import {resolvePrivilegeRequirement,resolvePrivilegePreflight,checkStaticPrivilege,runPrivilegePreflight} from './privileges.js';
+import {createProcessRunner} from '@mytools/fst-platform/managed-process';
 
 export async function createHost({ plugins = [], config = {}, services = {}, project,network,environmentOverrides={},runtimeEnabled=true,allowUnknownPrivileges=false } = {}) {
   const currentNetwork=()=>typeof network==='function'?network():network;
   validateNetworkPolicy(currentNetwork());
   const ctx = new Context();
   const actions = new Map();
-  const definitions = new Map();
+  const definitions = validatePluginDefinitions(plugins);
   const extensions = new Map();
-  const serviceNames = new Set();
-  const commandNames=new Set(),commands=new Map();
+  const commands=new Map();
   function bindContext(context){
     const {application:ignored,...capabilities}=services;
     const bound={...capabilities,...context},execute=bound.runProcess;
     // 面向用户的输出与诊断日志共用持久化通道，只区分默认可见性。
     bound.print=(message,data)=>Promise.resolve(bound.log?.(message,data,{audience:'user'}));
-    if(typeof execute==='function')bound.runProcess=(file,args,options={})=>{
-      const signal=context.signal&&options.signal?AbortSignal.any([context.signal,options.signal]):context.signal??options.signal;
-      return execute(file,args,{...options,signal,onOutput:async({stream,message})=>{
-        await bound.log?.(message,undefined,{stream});
-        await options.onOutput?.({stream,message});
-      }});
-    };
+    if(typeof execute==='function')bound.runProcess=createProcessRunner({execute,signal:context.signal,log:bound.log});
     return bound;
   }
   async function pluginContext(plugin,action,context){
@@ -48,6 +43,7 @@ export async function createHost({ plugins = [], config = {}, services = {}, pro
     const stateDir=projectDir&&!readOnly?path.join(projectDir,'.flow','plugin-state',createHash('sha256').update(plugin.id).digest('hex')):undefined;
     if(stateDir)await mkdir(stateDir,{recursive:true});
     for(const message of platformWarnings(plugin))await bound.log?.(message,{code:'PLATFORM_MISMATCH'},{audience:'user'});
+    if(plugin.root)await bound.log?.('插件文件目录',{plugin:plugin.id,directory:plugin.root},{kind:'source'});
     const environments=await prepareEnvironments(plugin,action,environmentOverrides[plugin.id],{cwd:projectDir??process.cwd()});
     context.signal?.throwIfAborted();
     const policy=context.networkPolicy??currentNetwork();
@@ -75,26 +71,8 @@ export async function createHost({ plugins = [], config = {}, services = {}, pro
     if(result.status==='unknown')await context.log?.('权限状态未确认，按本次选择继续运行',{plugin:plugin.id,action:actionName,reason:result.reason},{audience:'user'});
     return requirement;
   }
-  for (const entry of plugins) {
-    const plugin = entry.plugin ?? entry;
-    validateDeclarations(plugin);validateCommands(plugin,commandNames);
-    if (!plugin.id || definitions.has(plugin.id)) throw new FlowError(`插件标识缺失或重复：${plugin.id}`, {code:'VALIDATION'});
-    if (!semver.satisfies(SDK_VERSION, plugin.sdk ?? '^0.1.0')) throw new FlowError(`插件 ${plugin.id} 与 SDK ${SDK_VERSION} 不兼容`, {code:'VALIDATION'});
-    for(const [name,action] of Object.entries(plugin.actions??{})){
-      if(typeof action?.run!=='function')throw new FlowError(`动作 ${plugin.id}:${name} 缺少执行函数`);
-    }
-    for(const [name,extension] of Object.entries(plugin.services??{})){
-      if(serviceNames.has(name))throw new FlowError(`服务重复：${name}`);
-      if(typeof extension!=='function')throw new FlowError(`服务 ${name} 缺少执行函数`);
-      serviceNames.add(name);
-    }
-    definitions.set(plugin.id, {...plugin, root:entry.root});
-  }
   const settingsById=new Map();
   for (const plugin of definitions.values()) {
-    for (const [id, range] of Object.entries(plugin.dependencies ?? {})) {
-      if (!definitions.has(id) || !semver.satisfies(definitions.get(id).version,range)) throw new FlowError(`插件 ${plugin.id} 缺少兼容依赖 ${id}@${range}`,{code:'VALIDATION'});
-    }
     const settings = validate(plugin.config, config[plugin.id] ?? {}, `${plugin.id} 配置`);
     settingsById.set(plugin.id,settings);
   }
@@ -176,6 +154,12 @@ export async function createHost({ plugins = [], config = {}, services = {}, pro
       }
     },
     commands(){assertReadable();return [...commands.values()].map(({run,preflight,config,...metadata})=>structuredClone(metadata));},
+    previewInput(target,input={}){
+      assertReadable();
+      const owner=target.startsWith('/')?commands.get(target.slice(1)):actions.get(target);
+      if(!owner)throw new FlowError(`参数目标不存在：${target}`,{code:'VALIDATION'});
+      return resolveInput(owner.input??emptyObject,input,owner.config,{check:false,label:`${target} 输入`});
+    },
     async invokeCommand(name,input,context={}){
       assertHealthy();
       const command=commands.get(name);if(!command)throw new FlowError(`命令不存在：/${name}`);
@@ -185,7 +169,7 @@ export async function createHost({ plugins = [], config = {}, services = {}, pro
       try{
       const getService=runtime.bindServices(plugin.id);
       context.signal?.throwIfAborted();
-      const checked=validate(command.input??emptyObject,input,`/${name} 输入`);
+      const checked=resolveInput(command.input??emptyObject,input,command.config,{label:`/${name} 输入`}).value;
       const bound=await pluginContext(plugin,undefined,context);
       let result;
       try{
@@ -204,7 +188,7 @@ export async function createHost({ plugins = [], config = {}, services = {}, pro
       try{
       const getService=runtime.bindServices(action.plugin);
       context.signal?.throwIfAborted();
-      const checked=validate(action.input ?? emptyObject,input,`${id} 输入`);
+      const checked=resolveInput(action.input??emptyObject,input,action.config,{label:`${id} 输入`}).value;
       const plugin=definitions.get(action.plugin),bound=await pluginContext(plugin,action,context);
       let result;
       try{
@@ -233,3 +217,42 @@ export async function createHost({ plugins = [], config = {}, services = {}, pro
     close:()=>runtime.close(),
   };
 }
+
+// 单插件契约检查不依赖其他插件，供启动恢复路径精确归属故障。
+export function validatePluginDefinition(entry){
+  const plugin=entry?.plugin??entry;
+  if(!plugin||typeof plugin!=='object'||Array.isArray(plugin)||typeof plugin.id!=='string'||!plugin.id)throw new FlowError('插件默认导出必须是包含 id 的对象',{code:'VALIDATION'});
+  validateDeclarations(plugin);validateCommands(plugin,new Set());
+  if(!semver.satisfies(SDK_VERSION,plugin.sdk??'^0.1.0'))throw new FlowError(`插件 ${plugin.id} 与 SDK ${SDK_VERSION} 不兼容`,{code:'VALIDATION'});
+  for(const [name,action] of Object.entries(plugin.actions??{}))if(typeof action?.run!=='function')throw new FlowError(`动作 ${plugin.id}:${name} 缺少执行函数`,{code:'VALIDATION'});
+  for(const [name,extension] of Object.entries(plugin.services??{}))if(typeof extension!=='function')throw new FlowError(`服务 ${name} 缺少执行函数`,{code:'VALIDATION'});
+  validateRuntimeDeclaration(plugin,new Context());
+  return plugin;
+}
+
+// 恢复启动只豁免已确认故障的节点；其他可确定的声明和依赖错误仍明确拒绝。
+export function validatePluginDefinitions(entries,{unavailable=new Set(),blocked=new Set()}={}){
+  const definitions=new Map(),commandNames=new Set(),serviceNames=new Set();
+  for(const entry of entries){
+    const plugin=entry.plugin??entry;
+    if(!plugin.id||definitions.has(plugin.id))throw new FlowError(`插件标识缺失或重复：${plugin.id}`,{code:'VALIDATION'});
+    if(unavailable.has(plugin.id)){definitions.set(plugin.id,{...plugin,root:entry.root});continue;}
+    validatePluginDefinition(entry);validateCommands(plugin,commandNames);
+    for(const name of Object.keys(plugin.services??{})){
+      if(serviceNames.has(name))throw new FlowError(`服务重复：${name}`,{code:'VALIDATION'});
+      serviceNames.add(name);
+    }
+    definitions.set(plugin.id,{...plugin,root:entry.root});
+  }
+  for(const plugin of definitions.values()){
+    // 此节点已隔离且不会执行；它的损坏依赖不能阻断其他健康插件恢复。
+    if(unavailable.has(plugin.id))continue;
+    for(const [id,range] of Object.entries(plugin.dependencies??{})){
+      // 无法读取目标版本时保留恢复入口；已知版本仍须满足健康消费者的声明。
+      if(unavailable.has(id)&&!semver.valid(definitions.get(id)?.version))continue;
+      if(!definitions.has(id)||!semver.satisfies(definitions.get(id).version,range))throw new FlowError(`插件 ${plugin.id} 缺少兼容依赖 ${id}@${range}`,{code:'VALIDATION'});
+    }
+  }
+  validateRuntimes(new Map([...definitions].filter(([id])=>!unavailable.has(id))),new Context(),{blocked});
+  return definitions;
+}

package/node_modules/@mytools/fst-plugin/src/runtime.js

@@ -1,16 +1,20 @@
 import {FlowError} from '@mytools/sdk';
 
+export function validateRuntimeDeclaration(p,ctx){
+  const r=p.runtime;if(r===undefined)return;
+  if(!r||typeof r.apply!=='function')throw new FlowError(`${p.id} runtime 必须提供 apply`);
+  for(const key of ['provides','inject']){
+    const names=r[key]??[];
+    if(!Array.isArray(names)||names.some(n=>typeof n!=='string'||!/^\w[\w.-]*$/.test(n)||n in ctx)||new Set(names).size!==names.length)throw new FlowError(`${p.id} runtime.${key} 服务名称无效或重复`);
+  }
+}
+
 // 静态声明用于诊断与打包，运行时激活仍由 Cordis inject 驱动。
-export function validateRuntimes(definitions,ctx){
+export function validateRuntimes(definitions,ctx,{blocked=new Set()}={}){
   const providers=new Map(),ordered=[],visiting=new Set(),visited=new Set();
   for(const p of definitions.values()){
-    const r=p.runtime;if(r===undefined)continue;
-    if(!r||typeof r.apply!=='function')throw new FlowError(`${p.id} runtime 必须提供 apply`);
-    for(const key of ['provides','inject']){
-      const names=r[key]??[];
-      if(!Array.isArray(names)||names.some(n=>typeof n!=='string'||!/^\w[\w.-]*$/.test(n)||n in ctx)||new Set(names).size!==names.length)throw new FlowError(`${p.id} runtime.${key} 服务名称无效或重复`);
-    }
-    for(const name of r.provides??[]){
+    validateRuntimeDeclaration(p,ctx);
+    for(const name of p.runtime?.provides??[]){
       if(providers.has(name))throw new FlowError(`服务重复：${name}（${providers.get(name)}、${p.id}）`);
       providers.set(name,p.id);
     }
@@ -21,6 +25,8 @@ export function validateRuntimes(definitions,ctx){
     visiting.add(id);const p=definitions.get(id);
     for(const name of p.runtime?.inject??[]){
       const owner=providers.get(name);
+      // 故障依赖的声明不可读取时，只跳过无法确认归属的服务；已知冲突与环仍检查。
+      if(!owner&&blocked.has(id))continue;
       if(!owner)throw new FlowError(`${id} 缺少服务提供者：${name}`);
       if(owner!==id&&!Object.hasOwn(p.dependencies??{},owner))throw new FlowError(`${id} 的 dependencies 必须声明服务 ${name} 的提供者 ${owner}`);
       visit(owner);

package/node_modules/@mytools/fst-workflow/package.json

@@ -16,7 +16,7 @@
   ],
   "license": "MIT",
   "engines": {
-    "node": ">=24.15.0"
+    "node": "^22.22.2 || >=24.0.0"
   },
   "dependencies": {
     "@mytools/sdk": "0.1.0"

package/node_modules/@mytools/fst-workflow/src/engine.js

@@ -57,7 +57,7 @@ export async function runWorkflow({store,host,id,input={},signal,onEvent=()=>{},
       let output;
       if(step.action)output=await host.invoke(step.action,args,{
         ...context,signal:currentSignal,runId,stepId:step.id,callPath,workflow:w,
-        log:(message,data,meta={})=>emit({type:'log',stream:meta.stream,...(meta.audience==='user'?{audience:'user'}:{}),...base,message,data}),
+        log:(message,data,meta={})=>emit({type:'log',stream:meta.stream,...(typeof meta.processId==='string'?{processId:meta.processId}:{}),...(meta.audience==='user'?{audience:'user'}:{}),...(['process','source'].includes(meta.kind)?{kind:meta.kind}:{}),...base,message,data}),
       });
       else if(step.workflow)output=await execute(store.childId(step.workflow),args,callPath,currentSignal,reportFailure);
       else if(step.branch){

package/node_modules/@mytools/fst-workspace/README.md

@@ -6,6 +6,8 @@
 
 项目初始化、模板、工作流文件、插件安装批次、租约、开发引用及便携工作区。插件执行由 plugin 负责，系统调用由 platform 负责。
 
+`@mytools/fst-workspace/registry` 提供用户级插件库路径、工作区登记与跨工作区工作流引用查询。共享库复用安装批次、状态恢复备份及租约；普通工作区的配置与文件仍独立保存。
+
 内部依赖：`@mytools/sdk`、`@mytools/fst-platform`、`@mytools/fst-plugin`、`@mytools/fst-workflow`。
 ## 公开入口
 
@@ -26,6 +28,10 @@
 
 `/shortcuts` 提供 `validateShortcuts` 校验、`bindShortcutCommands` 在用户配置时补齐命令提供者身份，以及 `describeShortcuts` 生成可用或失效状态。绑定函数可传入 previous 保留旧项：未绑定命令修改参数或重命名仍保持失效，需重新选择目标。命令项使用 command 与 plugin 同时匹配，动作项使用稳定 action ID；不执行其他插件的同名能力。实际保存、备份与宿主装配由 core 协调。
 
+`WorkflowStore.list()` 保留正常工作流，同时返回 `status: 'invalid'` 的损坏文件诊断条目，`diagnostic` 含文件路径、错误消息以及可获得的 YAML 行列。诊断条目不能保存或复制。`list({strict:true})` 遇错误即拒绝，删除和卸载依赖扫描必须使用此模式；`get/check/run` 保持严格读取。`resolve()` 对根及全部子流程的输入 Schema 提前编译，打包与执行共用闭包预检，不会先执行前置业务步骤才发现子流程声明错误。
+
+`installGeneration` 的可选 `recoverInstalled` 回调仅用于纯卸载时重新读取剩余旧插件，交由 core 提供恢复条目；默认调用、新安装和链接保持严格加载。
+
 本模块负责上述职责的实现、文档与回归；跨模块接口调整需要同时检查生产者与消费者。具体维护人员尚未指定。
 
 在仓库根目录执行：

package/node_modules/@mytools/fst-workspace/package.json

@@ -11,6 +11,7 @@
     "./shortcuts": "./src/shortcuts.js",
     "./plugins": "./src/plugins.js",
     "./installations": "./src/plugin-installations.js",
+    "./registry": "./src/plugin-registry.js",
     "./bundles": "./src/bundle-workspace.js",
     "./package.json": "./package.json"
   },
@@ -22,7 +23,7 @@
   ],
   "license": "MIT",
   "engines": {
-    "node": ">=24.15.0"
+    "node": "^22.22.2 || >=24.0.0"
   },
   "dependencies": {
     "@mytools/sdk": "0.1.0",

package/node_modules/@mytools/fst-workspace/src/plugin-registry.js

@@ -0,0 +1,58 @@
+import path from 'node:path';
+import os from 'node:os';
+import {mkdir,writeFile,rename} from 'node:fs/promises';
+import {randomUUID} from 'node:crypto';
+import {readJson} from '@mytools/fst-platform/json';
+import {withPluginMutation} from './plugin-installations.js';
+import {WorkflowStore} from './workflows.js';
+import {readPluginState} from './plugin-installations.js';
+import {loadPlugin} from '@mytools/fst-plugin/loader';
+
+export const userPluginRegistry=()=>path.resolve(process.env.FISHTOOLS_HOME??path.join(os.homedir(),'.fishtools'),'plugins');
+
+export async function registerWorkspace(registryDir,projectDir){
+  return withPluginMutation(registryDir,async()=>{
+    const file=path.join(registryDir,'.flow','workspaces.json'),projects=await readJson(file,[]),directory=path.resolve(projectDir);
+    if(projects.includes(directory))return;
+    const temporary=`${file}.${randomUUID()}.tmp`;
+    await mkdir(path.dirname(file),{recursive:true});
+    await writeFile(temporary,JSON.stringify([...projects,directory],null,2));await rename(temporary,file);
+  });
+}
+
+function referencedActions(steps,id,result=new Set()){
+  for(const step of steps??[]){
+    if(step.action?.startsWith(`${id}:`))result.add(step.action);
+    if(step.branch){referencedActions(step.branch.then,id,result);referencedActions(step.branch.else,id,result);}
+    if(step.parallel)referencedActions(step.parallel.steps,id,result);
+  }
+  return [...result];
+}
+
+// 调用方持有共享库锁；各工作区的工作流修改也持有该锁，因此扫描期间不会补写引用。
+export async function registryWorkflowReferences(registryDir,id){
+  const projects=await readJson(path.join(registryDir,'.flow','workspaces.json'),[]),references=[];
+  for(const projectDir of projects){
+    for(const workflow of await new WorkflowStore(path.join(projectDir,'workflows')).list({strict:true})){
+      const actions=referencedActions(workflow.steps,id);
+      if(actions.length)references.push({projectDir,id:workflow.id,title:workflow.title??workflow.id,actions});
+    }
+  }
+  return references;
+}
+
+export async function registryPluginReferences(registryDir,id,{globalPlugins=[]}={}){
+  const projects=await readJson(path.join(registryDir,'.flow','workspaces.json'),[]),globalState=await readPluginState(registryDir),references=[];
+  const excluded=new Set([...Object.keys(globalState.dependencies??{}),...Object.keys(globalState.links??{}),...(globalState.disabledLegacy??[])]);
+  for(const projectDir of projects){
+    const project=await readJson(path.join(projectDir,'flow.project.json'),{});
+    if(project.readOnly||project.baseBundle)continue;
+    const local=await readPluginState(projectDir),definitions=new Map(globalPlugins.map(plugin=>[plugin.id,plugin]));
+    const add=async(spec,base)=>{const {plugin}=await loadPlugin(spec,base);if(!excluded.has(plugin.id))definitions.set(plugin.id,plugin);};
+    for(const spec of project.plugins??[])if(!excluded.has(spec))await add(spec,projectDir);
+    for(const name of Object.keys(local.dependencies??{}))if(!excluded.has(name))await add(name,local.root);
+    for(const [name,source] of Object.entries(local.links??{}))if(!excluded.has(name))await add(source,projectDir);
+    for(const plugin of definitions.values())if(plugin.id!==id&&Object.hasOwn(plugin.dependencies??{},id))references.push({projectDir,plugin:plugin.id});
+  }
+  return references;
+}

package/node_modules/@mytools/fst-workspace/src/plugins.js

@@ -5,22 +5,25 @@ import {FlowError} from '@mytools/sdk';
 import {readJson} from '@mytools/fst-platform/json';
 import {npm} from '@mytools/fst-platform/npm';
 import {loadPlugin} from '@mytools/fst-plugin/loader';
-export async function installGeneration(projectDir,{add,remove,link,state}) {
+export async function installGeneration(projectDir,{add,remove,link,state,sourceDir=projectDir,recoverInstalled}) {
   const root=path.join(projectDir,'.flow','installations',randomUUID());
   await mkdir(root,{recursive:true});
   const dependencies={...(state?.dependencies??{})};
   const links={...(state?.links??{})};
+  const disabledLegacy=new Set(state?.disabledLegacy??[]);
   if(remove){delete dependencies[remove];delete links[remove];}
+  if(remove&&state?.global)disabledLegacy.add(remove);
   if(link){
     const source=path.resolve(link),pkg=await readJson(path.join(source,'package.json'));
     const loaded=await loadPlugin(source,projectDir);
     if(!pkg.name||pkg.name!==loaded.plugin?.id||pkg.version!==loaded.plugin?.version)throw new FlowError('开发插件的包名/版本必须与插件 id/version 一致',{code:'VALIDATION'});
     links[pkg.name]=source;delete dependencies[pkg.name];
+    disabledLegacy.delete(pkg.name);
   }
   await writeFile(path.join(root,'package.json'),JSON.stringify({name:'flow-project-plugins',private:true,dependencies},null,2));
   let source=add;
   if(add) {
-    try {await access(path.resolve(projectDir,add));source=path.resolve(projectDir,add);} catch {}
+    try {await access(path.resolve(sourceDir,add));source=path.resolve(sourceDir,add);} catch {}
     if(source.startsWith('-')) throw new FlowError('插件来源不能以选项符号开头',{code:'VALIDATION'});
   }
   if(source||Object.keys(dependencies).length){
@@ -29,7 +32,9 @@ export async function installGeneration(projectDir,{add,remove,link,state}) {
   }
   const pkg=await readJson(path.join(root,'package.json'));
   const loaded=[];
-  for(const name of Object.keys(pkg.dependencies??{})){delete links[name];loaded.push(await loadPlugin(name,root));}
-  for(const source of Object.values(links))loaded.push(await loadPlugin(source,projectDir));
-  return {state:{root,dependencies:pkg.dependencies??{},links,...(state?.root?{previousRoot:state.root}:{})},loaded};
+  // 卸载故障插件时允许保留其他旧故障；安装/链接操作仍严格校验新批次。
+  const load=remove&&!add&&!link&&recoverInstalled?recoverInstalled:(_id,spec,base)=>loadPlugin(spec,base);
+  for(const name of Object.keys(pkg.dependencies??{})){delete links[name];disabledLegacy.delete(name);loaded.push(await load(name,name,root));}
+  for(const [name,source] of Object.entries(links))loaded.push(await load(name,source,projectDir,{linked:true}));
+  return {state:{root,dependencies:pkg.dependencies??{},links,...(state?.global?{global:true,disabledLegacy:[...disabledLegacy]}:{}),...(state?.root?{previousRoot:state.root}:{})},loaded};
 }

package/node_modules/@mytools/fst-workspace/src/workflows.js

@@ -12,14 +12,21 @@ export class WorkflowStore {
   file(id) { assertId(id); return path.join(this.root,`${id}.yaml`); }
   async get(id) {
     const file=this.file(id);
-    const physical=await realpath(file);
-    const root=await realpath(this.root);
-    if (!physical.startsWith(root+path.sep)) throw new FlowError('工作流越界，必须位于工作流目录内',{code:'VALIDATION'});
-    const definition=YAML.parse(await readFile(file,'utf8'));
-    if (definition?.id !== id) throw new FlowError(`工作流 ID 与文件名不一致：${id}`,{code:'VALIDATION'});
-    return this.validateShape(definition);
+    try{
+      const physical=await realpath(file);
+      const root=await realpath(this.root);
+      if (!physical.startsWith(root+path.sep)) throw new FlowError('工作流越界，必须位于工作流目录内',{code:'VALIDATION'});
+      const definition=YAML.parse(await readFile(file,'utf8'));
+      if (definition?.id !== id) throw new FlowError(`工作流 ID 与文件名不一致：${id}`,{code:'VALIDATION'});
+      return this.validateShape(definition);
+    }catch(error){
+      const position=error.linePos?.[0];
+      const details={file,...(position?{line:position.line,column:position.col}:{}),reason:error.code};
+      throw new FlowError(`工作流读取失败：${file}${position?`:${position.line}:${position.col}`:''}\n${error.message}`,{code:'VALIDATION',details,cause:error});
+    }
   }
   validateShape(w) {
+    if(w?.status==='invalid')throw new FlowError(w.diagnostic?.message??'损坏工作流的诊断条目不能保存或复制，请先修复原文件',{code:'VALIDATION'});
     assertId(w?.id);
     if (w.schemaVersion!==1 || !Array.isArray(w.steps)) throw new FlowError('工作流格式错误：需要 schemaVersion: 1 与 steps 列表',{code:'VALIDATION'});
     validateStepList(w.steps,assertId);
@@ -66,21 +73,33 @@ export class WorkflowStore {
       throw error;
     }
   }
-  async list() {
+  async list({strict=false}={}) {
     await mkdir(this.root,{recursive:true});
     const files=await readdir(this.root);
-    return Promise.all(files.filter(f=>f.endsWith('.yaml')).sort().map(f=>this.get(f.slice(0,-5))));
+    return Promise.all(files.filter(f=>f.endsWith('.yaml')).sort().map(async f=>{
+      const id=f.slice(0,-5);
+      try{return await this.get(id);}
+      catch(error){
+        if(strict)throw error;
+        const file=path.join(this.root,f),diagnostic={...error.details,file,message:error.message};
+        // 保留数组协议和已有 Web 展示字段；此条目仅供诊断，不是可保存的定义。
+        return {id,title:`不可用：${f}`,description:`${file}\n${error.message}`,status:'invalid',diagnostic,inputs:false,steps:[],outputs:{}};
+      }
+    }));
   }
-  async remove(id){
+  async remove(id,{backup=true}={}){
+    if(typeof backup!=='boolean')throw new FlowError('backup 必须是布尔值',{code:'VALIDATION'});
     await this.get(id);
     const refers=steps=>steps.some(step=>step.workflow&&this.childId(step.workflow)===id||step.branch&&(refers(step.branch.then)||refers(step.branch.else??[]))||step.parallel&&refers(step.parallel.steps));
-    const dependents=(await this.list()).filter(flow=>flow.id!==id&&refers(flow.steps));
+    // 文件无法读取时不能证明不存在引用，必须阻止删除。
+    const dependents=(await this.list({strict:true})).filter(flow=>flow.id!==id&&refers(flow.steps));
     if(dependents.length)throw new FlowError(`工作流仍被引用：${dependents.map(flow=>flow.title??flow.id).join('、')}`);
+    if(!backup){await unlink(this.file(id));return null;}
     const directory=path.join(path.dirname(this.root),'.flow','deleted-workflows');
     await mkdir(directory,{recursive:true});
-    const backup=path.join(directory,`${id}-${randomUUID()}.yaml`);
+    const backupFile=path.join(directory,`${id}-${randomUUID()}.yaml`);
     // 同项目内原子移动，备份保留完整原文；复制回原文件名即可恢复。
-    await rename(this.file(id),backup);return backup;
+    await rename(this.file(id),backupFile);return backupFile;
   }
   childId(reference) {
     if(typeof reference!=='string' || !/^(\.\/)?[A-Za-z0-9][A-Za-z0-9_-]*\.yaml$/.test(reference)) throw new FlowError(`子流程必须位于工作流目录内：${reference}`,{code:'VALIDATION'});
@@ -93,6 +112,7 @@ export class WorkflowStore {
       if(workflows.has(id)) return;
       visiting.add(id);
       const w=await this.get(id);
+      assertSchema(w.inputs??emptyObject,`${this.file(id)} inputs schema`);
       const checker=previous=>ref=>{
         const p=referenceParts(ref);
         if(p[0]==='steps' && !previous.has(p[1])) throw new FlowError(`${id} 引用必须指向前序步骤：${ref}`,{code:'VALIDATION'});

package/node_modules/@mytools/pack/package.json

@@ -9,10 +9,10 @@
   "license": "MIT",
   "dependencies": {
     "@mytools/sdk": "0.1.0",
-    "@npmcli/arborist": "10.0.3",
+    "@npmcli/arborist": "9.9.2",
     "archiver": "8.0.0",
-    "make-fetch-happen": "16.0.1",
-    "npm-packlist": "11.3.0",
+    "make-fetch-happen": "15.0.6",
+    "npm-packlist": "10.0.4",
     "tar": "7.5.22",
     "yaml": "2.9.1",
     "@mytools/fst-platform": "0.1.0",

package/node_modules/@mytools/pack/runtime-cache.js

@@ -0,0 +1,26 @@
+import {readFile,rename,unlink,writeFile} from 'node:fs/promises';
+import {createHash,randomUUID} from 'node:crypto';
+import {FlowError} from '@mytools/sdk';
+
+export async function writeCachedFile(file,bytes){
+  const temporary=`${file}.${randomUUID()}.tmp`;
+  try{
+    await writeFile(temporary,bytes,{flag:'wx'});
+    try{await rename(temporary,file);}catch(error){
+      // Windows 上并发替换可能返回 EPERM；仅接受另一写入者已留下的完全相同内容。
+      if(process.platform!=='win32'||!['EPERM','EACCES','EBUSY'].includes(error.code))throw error;
+      let existing;try{existing=await readFile(file);}catch{throw error;}
+      if(!existing.equals(bytes))throw error;
+    }
+  }
+  finally{await unlink(temporary).catch(error=>{if(error.code!=='ENOENT')throw error;});}
+}
+
+export async function readVerifiedCache(file,load,{sha256,message}){
+  let bytes,missing=false;
+  try{bytes=await readFile(file);}catch(error){if(error.code!=='ENOENT')throw error;missing=true;bytes=await load();}
+  if(createHash('sha256').update(bytes).digest('hex')!==sha256)throw new FlowError(message);
+  // 命中有效缓存不再截断重写；冷缓存校验后原子替换，读取者只见完整文件。
+  if(missing)await writeCachedFile(file,bytes);
+  return bytes;
+}

package/node_modules/@mytools/pack/runtime.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import * as tar from 'tar';
 import fetch from 'make-fetch-happen';
 import { FlowError } from '@mytools/sdk';
+import {readVerifiedCache,writeCachedFile} from './runtime-cache.js';
 
 export const NODE_VERSION='24.15.0';
 const hashes={
@@ -24,13 +25,11 @@ export async function copyRuntime({target,directory,cacheDir,runtimePath,include
   if(runtimePath){
     if(!win)throw new FlowError('自定义 runtimePath 首版只接受已验证的 Windows Node.js 文件');
     bytes=await readFile(runtimePath);
+    if(digest(bytes)!==hashes[target])throw new FlowError('Node.js 运行时校验失败，请检查缓存或指定文件');
+    await writeCachedFile(cache,bytes);
   }else{
-    try{bytes=await readFile(cache);}catch{
-      bytes=await download(`https://nodejs.org/download/release/v${NODE_VERSION}/${file}`);
-    }
+    bytes=await readVerifiedCache(cache,()=>download(`https://nodejs.org/download/release/v${NODE_VERSION}/${file}`),{sha256:hashes[target],message:'Node.js 运行时校验失败，请检查缓存或指定文件'});
   }
-  if(digest(bytes)!==hashes[target])throw new FlowError('Node.js 运行时校验失败，请检查缓存或指定文件');
-  await writeFile(cache,bytes);
   if(win)await writeFile(path.join(directory,'runtime','node.exe'),bytes);
   else{
     const extraction=path.join(cacheDir,'linux-extracted');await mkdir(extraction,{recursive:true});
@@ -43,16 +42,13 @@ export async function copyRuntime({target,directory,cacheDir,runtimePath,include
   try{license=await readFile(licenseCache);}catch{
     try{if(process.versions.node!==NODE_VERSION)throw new Error('版本不同');license=await readFile(path.join(path.dirname(process.execPath),'LICENSE'));}
     catch{license=await download(`https://raw.githubusercontent.com/nodejs/node/v${NODE_VERSION}/LICENSE`);}
-    await writeFile(licenseCache,license);
+    await writeCachedFile(licenseCache,license);
   }
   await mkdir(path.join(directory,'licenses'),{recursive:true});await writeFile(path.join(directory,'licenses','NODE_LICENSE'),license);
   if(includeNpm){
     // npm 是平台无关的 JS，直接复用已固定校验的官方 Linux 分发中的完整 npm 目录。
     const npmArchive=path.join(cacheDir,`node-v${NODE_VERSION}-linux-x64.tar.gz`);
-    let npmBytes;
-    try{npmBytes=await readFile(npmArchive);}catch{npmBytes=await download(`https://nodejs.org/download/release/v${NODE_VERSION}/node-v${NODE_VERSION}-linux-x64.tar.gz`);}
-    if(digest(npmBytes)!==hashes['linux-x64-glibc'])throw new FlowError('npm 来源的 Node.js 归档校验失败');
-    await writeFile(npmArchive,npmBytes);
+    await readVerifiedCache(npmArchive,()=>download(`https://nodejs.org/download/release/v${NODE_VERSION}/node-v${NODE_VERSION}-linux-x64.tar.gz`),{sha256:hashes['linux-x64-glibc'],message:'npm 来源的 Node.js 归档校验失败'});
     const extraction=path.join(cacheDir,'npm-extracted');await mkdir(extraction,{recursive:true});
     await tar.x({file:npmArchive,cwd:extraction,filter:name=>name.includes('/lib/node_modules/npm/')});
     await cp(path.join(extraction,`node-v${NODE_VERSION}-linux-x64/lib/node_modules/npm`),path.join(directory,'runtime/node_modules/npm'),{recursive:true,dereference:true});