@yanglaofish/fishtools 0.5.2 → 0.5.3

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

@@ -7,7 +7,7 @@ import {prepareEnvironments,platformWarnings} from '@mytools/fst-platform/enviro
 import path from 'node:path';
 import {mkdir} from 'node:fs/promises';
 import {createHash} from 'node:crypto';
-import {createRuntime} from './runtime.js';
+import {createRuntime,validateRuntimes} 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';
@@ -17,10 +17,9 @@ export async function createHost({ plugins = [], config = {}, services = {}, pro
   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;
@@ -28,7 +27,10 @@ export async function createHost({ plugins = [], config = {}, services = {}, pro
     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})=>{
+      return execute(file,args,{...options,signal,onStart:async invocation=>{
+        await bound.log?.('执行程序',invocation,{kind:'process'});
+        await options.onStart?.(invocation);
+      },onOutput:async({stream,message})=>{
         await bound.log?.(message,undefined,{stream});
         await options.onOutput?.({stream,message});
       }});
@@ -48,6 +50,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 +78,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);
   }
@@ -233,3 +218,26 @@ export async function createHost({ plugins = [], config = {}, services = {}, pro
     close:()=>runtime.close(),
   };
 }
+
+// 可用和待配置的插件共用声明检查；配置不足不会掩盖 SDK、依赖或代码错误。
+export function validatePluginDefinitions(entries){
+  const definitions=new Map(),commandNames=new Set(),serviceNames=new Set();
+  for(const entry of entries){
+    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} 缺少执行函数`,{code:'VALIDATION'});
+    for(const [name,extension] of Object.entries(plugin.services??{})){
+      if(serviceNames.has(name))throw new FlowError(`服务重复：${name}`,{code:'VALIDATION'});
+      if(typeof extension!=='function')throw new FlowError(`服务 ${name} 缺少执行函数`,{code:'VALIDATION'});
+      serviceNames.add(name);
+    }
+    definitions.set(plugin.id,{...plugin,root:entry.root});
+  }
+  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'});
+  }
+  validateRuntimes(definitions,new Context());
+  return definitions;
+}

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,...(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`。
 ## 公开入口
 

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()){
+      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}) {
   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,7 @@ 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 name of Object.keys(pkg.dependencies??{})){delete links[name];disabledLegacy.delete(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};
+  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

@@ -71,16 +71,18 @@ export class WorkflowStore {
     const files=await readdir(this.root);
     return Promise.all(files.filter(f=>f.endsWith('.yaml')).sort().map(f=>this.get(f.slice(0,-5))));
   }
-  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));
     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'});

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});