@yanglaofish/fishtools 0.4.0 → 0.5.0

package/node_modules/@mytools/core/src/development-watch-worker.js

@@ -0,0 +1,69 @@
+import {watch} from 'node:fs';
+import {readFile,opendir,lstat} from 'node:fs/promises';
+import path from 'node:path';
+
+// 所有目录 I/O 都留在可回收进程中；扫描限制同时约束监听句柄和遍历工作量。
+const options=JSON.parse(process.env.FISHTOOLS_WATCH_OPTIONS),handles=new Map();
+const ignored=new Set(['node_modules','.git','.flow','dist']);
+let stopped=false,scanning=false,again=false,first=true,links=[];
+const send=message=>{if(process.connected)process.send(message);};
+const remote=value=>/^\\\\|^\/\//.test(value);
+async function json(file,fallback){try{return JSON.parse(await readFile(file,'utf8'));}catch(error){if(error.code==='ENOENT')return fallback;throw error;}}
+function change(file){send({type:'changed',file});}
+function addWatch(key,directory,callback,wanted){
+  wanted.add(key);if(handles.has(key))return;
+  try{const handle=watch(directory,callback);handle.on('error',error=>send({type:'warning',message:`监听 ${directory} 失败：${error.message}`}));handles.set(key,handle);}
+  catch(error){send({type:'warning',message:`无法监听 ${directory}：${error.message}`});}
+}
+async function scan(){
+  if(stopped)return;if(scanning){again=true;return;}scanning=true;
+  send({type:'scanning'});const wanted=new Set();let directories=0,entries=0,incomplete=false;
+  try{
+    addWatch('project',options.projectDir,(_event,name)=>{
+      if(name===null||['flow.project.json','.flow'].includes(String(name))){
+        if(name===null||String(name)==='flow.project.json')change(path.join(options.projectDir,String(name??'')));
+        void scan();
+      }
+    },wanted);
+    const stateDirectory=path.join(options.projectDir,'.flow');
+    addWatch('state',stateDirectory,(_event,name)=>{if(name===null||String(name)==='plugins.json'){change(path.join(stateDirectory,'plugins.json'));void scan();}},wanted);
+    if(options.configFile)addWatch('config',path.dirname(options.configFile),(_event,name)=>{
+      if(name===null||String(name)===path.basename(options.configFile)){change(options.configFile);void scan();}
+    },wanted);
+    let project={};
+    try{
+      project=await json(path.join(options.projectDir,'flow.project.json'),{});
+      const state=await json(path.join(stateDirectory,'plugins.json'),{});
+      links=Object.values(state.links??{}).filter(value=>typeof value==='string').map(value=>path.resolve(options.projectDir,value));
+    }catch(error){send({type:'warning',message:`开发配置暂不可读，保留已有源码监听：${error.message}`});}
+    incomplete=links.length>options.maxDirectories;
+    const queue=links.slice(0,options.maxDirectories).map(directory=>({directory,depth:0})),seen=new Set();
+    while(queue.length&&!stopped){
+      const {directory,depth}=queue.shift();if(seen.has(directory))continue;seen.add(directory);
+      if(remote(directory)){send({type:'warning',message:`跳过远程开发目录：${directory}`});continue;}
+      if(directories>=options.maxDirectories||entries>=options.maxEntries){incomplete=true;break;}
+      let stat;try{stat=await lstat(directory);}catch{continue;}
+      if(!stat.isDirectory()||stat.isSymbolicLink())continue;directories++;
+      addWatch(`source:${directory}`,directory,(event,name)=>{
+        const relative=String(name??'');if(relative.split(/[\\/]/).some(part=>ignored.has(part)))return;
+        change(path.join(directory,relative));if(event==='rename')void scan();
+      },wanted);
+      if(depth>=options.maxDepth){incomplete=true;continue;}
+      let listing;
+      try{
+        listing=await opendir(directory);
+        for await(const entry of listing){
+          entries++;if(entries>=options.maxEntries){incomplete=true;break;}
+          if(entry.isDirectory()&&!ignored.has(entry.name))queue.push({directory:path.join(directory,entry.name),depth:depth+1});
+        }
+      }catch(error){send({type:'warning',message:`扫描 ${directory} 失败：${error.message}`});}
+    }
+    for(const [key,handle] of handles)if(!wanted.has(key)){handle.close();handles.delete(key);}
+    if(incomplete)send({type:'warning',message:'开发源码扫描达到目录、深度或条目预算，超出部分未监听'});
+    send({type:first?'ready':'snapshot',readOnly:!!project.readOnly,directories,watchers:handles.size,incomplete});first=false;
+  }finally{scanning=false;if(again){again=false;void scan();}}
+}
+function close(){stopped=true;for(const handle of handles.values())handle.close();handles.clear();process.disconnect?.();}
+process.on('message',message=>{if(message?.type==='close')close();});
+process.on('disconnect',close);
+void scan().catch(error=>{send({type:'fatal',message:error.message});close();});

package/node_modules/@mytools/core/src/development.js

@@ -0,0 +1,146 @@
+import {fork} from 'node:child_process';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
+
+const worker=fileURLToPath(new URL('./development-watch-worker.js',import.meta.url));
+const positive=(value,fallback,name)=>{const number=value??fallback;if(!Number.isInteger(number)||number<1)throw new TypeError(`${name} 必须是正整数`);return number;};
+const send=(child,message)=>{if(child?.connected)child.send(message,()=>{});};
+
+/** 监督进程只传递配置和 IPC；每一代应用拥有独立的完整 ESM 模块图。 */
+export async function createDevelopmentSupervisor(options={}){
+  const projectDir=path.resolve(options.projectDir??process.cwd());
+  if(!options.entry)throw new TypeError('开发模式需要应用子进程入口');
+  const debounce=positive(options.debounce,180,'debounce'),closeTimeout=positive(options.closeTimeout,5000,'closeTimeout');
+  const killTimeout=positive(options.killTimeout,2000,'killTimeout'),startupTimeout=positive(options.startupTimeout,15000,'startupTimeout');
+  const watchTimeout=positive(options.watchTimeout,5000,'watchTimeout');
+  let phase='starting',child=null,watcher=null,generation=0,pending=false,draining=false,stopping=false,failed=false,closing;
+  let debounceTimer,startTimer,closeTimer,scanTimer;
+  const environment={...process.env,...options.env,FISHTOOLS_DEV_CHILD:'1'};
+  const emit=(type,details={})=>options.onEvent?.({generation,...details,type});
+  const active=()=>child&&child.exitCode===null&&child.signalCode===null;
+  const clearChildTimers=()=>{clearTimeout(startTimer);clearTimeout(closeTimer);};
+  async function terminate(target,kind){
+    if(!target||target.exitCode!==null||target.signalCode!==null)return true;
+    emit('forced',{pid:target.pid,kind,message:`${kind==='application'?'应用关闭':'文件监听'}超时，正在强制回收`});
+    target.kill('SIGKILL');
+    return new Promise(resolve=>{
+      const timer=setTimeout(()=>{target.removeListener('exit',exited);emit('blocked',{pid:target.pid,kind,message:'子进程尚未回收，保留占用预算并停止启动新宿主'});phase='blocked';resolve(false);},killTimeout);
+      const exited=()=>{clearTimeout(timer);resolve(true);};target.once('exit',exited);
+      if(target.exitCode!==null||target.signalCode!==null)exited();
+    });
+  }
+  function launch(){
+    if(stopping||active()||phase==='blocked')return;
+    clearTimeout(debounceTimer);debounceTimer=null;pending=false;draining=false;phase='starting';generation++;
+    const next=fork(path.resolve(options.entry),options.args??[],{cwd:options.cwd??process.cwd(),env:environment,execArgv:[],windowsHide:true,stdio:options.stdio??['inherit','inherit','inherit','ipc']});
+    child=next;let ready=false,reported=false;
+    startTimer=setTimeout(()=>{reported=true;failed=true;emit('failed',{pid:next.pid,message:'开发应用启动超时，继续等待源码修复'});void terminate(next,'application');},startupTimeout);
+    next.on('message',message=>{
+      if(next!==child)return;
+      if(message?.type==='development:ready'){
+        clearTimeout(startTimer);ready=true;phase='running';
+        if(message.details?.port!==undefined)environment.FISHTOOLS_DEV_PORT=String(message.details.port);
+        emit('ready',{pid:next.pid,details:message.details??{},recovered:failed});failed=false;
+        if(stopping||pending)drain();
+      }else if(message?.type==='development:waiting')emit('waiting',{pid:next.pid,status:message.status});
+      else if(message?.type==='development:closing'){
+        clearTimeout(startTimer);phase='closing';
+        closeTimer=setTimeout(()=>{void terminate(next,'application');},closeTimeout);
+      }else if(message?.type==='development:failed'){
+        reported=true;failed=true;emit('failed',{pid:next.pid,message:message.message});
+      }else if(message?.type==='development:closed')emit('applicationClosed',{pid:next.pid});
+    });
+    next.on('error',error=>{reported=true;failed=true;emit('failed',{pid:next.pid,message:error.message});});
+    next.once('exit',(code,signal)=>{
+      clearChildTimers();emit('exited',{pid:next.pid,code,signal});if(child===next)child=null;
+      if(stopping)return;
+      if(draining){draining=false;phase='waiting';if(!debounceTimer)launch();}
+      else if(pending){phase='waiting';if(!debounceTimer)launch();}
+      else if(ready&&!reported){void supervisor.close();}
+      else{phase='failed';failed=true;if(!reported)emit('failed',{pid:next.pid,message:`开发应用启动失败（${code??signal}），修复源码后自动重试`});}
+    });
+  }
+  function drain(){
+    if(draining||!active())return;
+    draining=true;phase='waiting';emit('restarting',{pid:child.pid});send(child,{type:'development:drain'});
+  }
+  function changed(message){
+    if(stopping)return;pending=true;emit('changed',{file:message.file});clearTimeout(debounceTimer);
+    debounceTimer=setTimeout(()=>{debounceTimer=null;if(active()){if(phase!=='starting')drain();}else launch();},debounce);
+  }
+  const supervisor={
+    status:()=>({phase,generation,pending,pid:active()?child.pid:null,watcherPid:watcher?.exitCode===null&&watcher.signalCode===null?watcher.pid:null}),
+    close(){
+      if(closing)return closing;stopping=true;clearTimeout(debounceTimer);debounceTimer=null;clearTimeout(scanTimer);
+      closing=(async()=>{
+        const watched=watcher;
+        const stopWatch=watched&&watched.exitCode===null&&watched.signalCode===null?new Promise(resolve=>{
+          const timer=setTimeout(async()=>resolve(await terminate(watched,'watcher')),closeTimeout);
+          watched.once('exit',()=>{clearTimeout(timer);resolve(true);});send(watched,{type:'close'});
+        }):Promise.resolve(true);
+        const running=child;
+        const stopApp=active()?new Promise(resolve=>{
+          // 活跃业务无强制截止时间；收到 idle/closing 才开始关闭超时预算。
+          running.once('exit',()=>resolve(true));drain();
+          const blocked=()=>{if(phase==='blocked'){clearInterval(check);resolve(false);}};
+          const check=setInterval(blocked,Math.min(killTimeout,100));running.once('exit',()=>clearInterval(check));
+        }):Promise.resolve(true);
+        const results=await Promise.all([stopWatch,stopApp]);clearChildTimers();
+        if(results.some(result=>!result)){phase='blocked';throw new Error('开发子进程未回收，不能启动重叠宿主');}
+        phase='closed';emit('closed');
+      })();return closing;
+    },
+  };
+  const watchOptions={projectDir,configFile:options.configFile?path.resolve(options.configFile):undefined,
+    maxDirectories:positive(options.maxDirectories,512,'maxDirectories'),maxEntries:positive(options.maxEntries,20000,'maxEntries'),maxDepth:positive(options.maxDepth,24,'maxDepth')};
+  try{
+    await new Promise((resolve,reject)=>{
+      let initialized=false;
+      watcher=fork(worker,[],{env:{...process.env,FISHTOOLS_WATCH_OPTIONS:JSON.stringify(watchOptions)},execArgv:[],windowsHide:true,stdio:['ignore','ignore','pipe','ipc']});
+      const deadline=()=>{clearTimeout(scanTimer);scanTimer=setTimeout(async()=>{
+        emit('watchError',{message:'开发目录扫描超时，停止监听并回收隔离进程'});
+        await terminate(watcher,'watcher');if(!initialized)reject(new Error('开发目录扫描超时'));
+      },watchTimeout);};deadline();
+      watcher.on('message',message=>{
+        if(message?.type==='scanning')deadline();
+        else if(message?.type==='ready'||message?.type==='snapshot'){
+          clearTimeout(scanTimer);emit('watching',message);
+          if(message.readOnly){if(!initialized)reject(new Error('只读运行包不能启用开发源码监听'));else{emit('watchError',{message:'项目已变为只读，开发监听正在关闭'});void supervisor.close();}return;}
+          if(!initialized){initialized=true;resolve();}
+        }else if(message?.type==='changed')changed(message);
+        else if(message?.type==='warning')emit('watchError',{message:message.message});
+        else if(message?.type==='fatal'){clearTimeout(scanTimer);if(!initialized)reject(new Error(message.message));else emit('watchError',{message:message.message});}
+      });
+      watcher.on('error',error=>{if(!initialized)reject(error);else emit('watchError',{message:error.message});});
+      watcher.once('exit',()=>{clearTimeout(scanTimer);if(!initialized)reject(new Error('开发文件监听进程提前退出'));else if(!stopping)emit('watchError',{message:'开发文件监听进程已停止'});});
+      watcher.stderr.on('data',data=>emit('watchError',{message:String(data).trim()}));
+    });launch();return supervisor;
+  }catch(error){await supervisor.close();throw error;}
+}
+
+/** 子进程必须把应用空闲状态与关闭动作放在同一事件循环中判断。 */
+export function bindDevelopmentChild(app,{details={},closePresentation,pollInterval=100}={}){
+  let requested=false,checking=false,closed=false,waiting=false;
+  let finish;const done=new Promise(resolve=>{finish=resolve;});
+  const sendMessage=message=>{if(process.connected)process.send(message);};
+  async function check(){
+    if(!requested||checking||closed)return;
+    const status=app.developmentStatus();
+    if(status.running||status.busy||status.closing){if(!waiting){waiting=true;sendMessage({type:'development:waiting',status});}return;}
+    checking=true;sendMessage({type:'development:closing'});
+    try{
+      const errors=[];
+      try{await app.close();}catch(error){errors.push(error);}
+      try{await closePresentation?.();}catch(error){errors.push(error);}
+      if(errors.length)throw new AggregateError(errors,errors.map(error=>error.message).join('；'));
+      sendMessage({type:'development:closed'});
+    }
+    catch(error){sendMessage({type:'development:failed',message:`开发应用关闭失败：${error.message}`});process.exitCode=1;}
+    finally{closed=true;clearInterval(timer);process.removeListener('message',message);process.removeListener('disconnect',disconnected);process.disconnect?.();finish();}
+  }
+  const message=message=>{if(message?.type==='development:drain'){requested=true;void check();}};
+  const disconnected=()=>{requested=true;void check();};
+  const timer=setInterval(()=>{void check();},positive(pollInterval,100,'pollInterval'));
+  process.on('message',message);process.on('disconnect',disconnected);sendMessage({type:'development:ready',details});
+  return {close:()=>{requested=true;void check();return done;}};
+}

package/node_modules/@mytools/core/src/environments.js

@@ -1,67 +1,2 @@
-import path from 'node:path';
-import {FlowError} from '@mytools/sdk';
-import which from 'which';
-
-export const currentTarget=()=>`${process.platform}-${process.arch}${process.platform==='linux'?'-glibc':''}`;
-export function inside(root,relative){
-  if(typeof relative!=='string'||!relative||path.isAbsolute(relative)||/^[A-Za-z]:|\\/.test(relative))throw new FlowError(`资源路径必须是包内相对路径：${relative}`);
-  const absolute=path.resolve(root,relative),rel=path.relative(root,absolute);
-  if(rel==='..'||rel.startsWith('..'+path.sep)||path.isAbsolute(rel))throw new FlowError(`资源路径越界：${relative}`);
-  return absolute;
-}
-export function environmentDeclarations(plugin,action){return {...plugin.environments,...action?.environments};}
-export function resolveEnvironments(plugin,action,overrides={},target=currentTarget()){
-  return Object.fromEntries(Object.entries(environmentDeclarations(plugin,action)).map(([id,declaration])=>{
-    const selected=overrides[id];
-    if(selected!==undefined&&(!selected||typeof selected!=='object'||Array.isArray(selected)||Object.keys(selected).some(k=>!['source','executable'].includes(k))||selected.source!==undefined&&typeof selected.source!=='string'||selected.executable!==undefined&&(typeof selected.executable!=='string'||!selected.executable.trim())))throw new FlowError(`环境来源覆盖无效：${plugin.id}/${id}`);
-    const source=selected?.source??declaration.source;
-    if(!(declaration.allowedSources??[declaration.source]).includes(source))throw new FlowError(`环境 ${plugin.id}/${id} 不允许来源 ${source}`);
-    const e={...declaration,source};delete e.artifacts;
-    if(selected?.executable!==undefined){
-      if(source!=='host')throw new FlowError(`只有 host 环境允许覆盖解释器：${plugin.id}/${id}`);
-      e.executable=selected.executable;
-    }
-    if(source==='tool'){
-      if(id!=='node')throw new FlowError(`工具尚未提供环境：${id}`);
-      e.executable=process.execPath;
-    }else if(source==='bundled'){
-      const artifact=declaration.artifacts?.[target];
-      if(!artifact)throw new FlowError(`环境 ${plugin.id}/${id} 未提供 ${target} 的随包资源`);
-      e.root=inside(plugin.root,artifact.directory);e.executable=inside(e.root,artifact.executable);
-    }
-    return [id,e];
-  }));
-}
-
-// 打包只解析声明；真正调用时才在当前工作区选择候选，避免将开发机路径写入跨平台分发包。
-export async function prepareEnvironments(plugin,action,overrides={}, {cwd=process.cwd()}={}){
-  const resolved=resolveEnvironments(plugin,action,overrides);
-  for(const [id,environment] of Object.entries(resolved)){
-    if(environment.source!=='host'||!Array.isArray(environment.executable)&&overrides[id]?.executable===undefined)continue;
-    const candidates=Array.isArray(environment.executable)?environment.executable:[environment.executable];
-    const windows=process.platform==='win32',directory=path.resolve(cwd);
-    const searchDirectories=[...(windows?[directory]:[]),...(process.env.PATH??'').split(path.delimiter)]
-      .map(entry=>path.resolve(directory,entry.replace(/^"(.*)"$/,'$1')));
-    let found;
-    for(const candidate of candidates){
-      const direct=path.isAbsolute(candidate)||candidate.includes('/')||windows&&candidate.includes('\\');
-      // 使用绝对候选，防止 which 在 Windows 擅自优先搜索宿主启动目录。
-      const paths=direct?[path.resolve(directory,candidate)]:searchDirectories.map(base=>path.resolve(base,candidate));
-      for(const executable of paths){
-        found=await which(executable,{nothrow:true});
-        if(found)break;
-      }
-      if(found)break;
-    }
-    if(!found)throw new FlowError(`环境 ${plugin.id}/${id} 未找到程序：${candidates.join('、')}`,{code:'ENOENT',details:{plugin:plugin.id,environment:id,candidates}});
-    environment.executable=path.resolve(found);
-  }
-  return resolved;
-}
-
-export function platformWarnings(plugin,platform=process.platform,architecture=process.arch){
-  const warnings=[];
-  if(plugin.platforms&&!plugin.platforms.includes(platform))warnings.push(`插件 ${plugin.id} 的平台声明不包含当前 ${platform}，继续执行；请核实插件支持范围`);
-  if(plugin.architectures&&!plugin.architectures.includes(architecture))warnings.push(`插件 ${plugin.id} 的架构声明不包含当前 ${architecture}，继续执行；请核实插件支持范围`);
-  return warnings;
-}
+// 兼容既有 core 公开入口，实际能力由 platform 模块维护。
+export * from '@mytools/fst-platform/environments';

package/node_modules/@mytools/core/src/export-snapshot.js

@@ -0,0 +1,42 @@
+import {fileURLToPath} from 'node:url';
+import {FlowError} from '@mytools/sdk';
+
+function selectedNetwork(network,ids){
+  if(!network)return undefined;
+  const plugins=Object.fromEntries(Object.entries(network.plugins??{}).filter(([id])=>ids.has(id)));
+  const used=new Set();
+  const add=rule=>{if(rule?.mode==='profile')used.add(rule.profile);};
+  add(network.default);
+  for(const policy of Object.values(plugins)){
+    add(policy.default);
+    for(const rule of Object.values(policy.actions??{}))add(rule);
+  }
+  return {
+    ...(network.default?{default:network.default}:{}),
+    profiles:Object.fromEntries(Object.entries(network.profiles??{}).filter(([name])=>used.has(name))),
+    plugins,
+  };
+}
+
+// 只向打包器交付声明快照和发行入口位置，避免其直接访问活跃宿主。
+export async function createExportSnapshot({store,host,project},{entries,portable=false,includeWeb=false}={}){
+  if(portable)entries=(await store.list()).map(w=>w.id);
+  if(!portable&&!entries?.length)throw new FlowError('请至少选择一个工作流');
+  const closure=await store.resolve(entries,host);
+  const web=[...host.definitions.values()].find(p=>typeof p.services?.web==='function');
+  const ids=new Set(portable?[...host.definitions.keys()].filter(id=>id!==web?.id||includeWeb):closure.plugins);
+  for(const id of closure.plugins)ids.add(id);
+  if(includeWeb){if(!web)throw new FlowError('未安装提供 Web 服务的插件');ids.add(web.id);}
+  for(const id of ids)for(const dependency of Object.keys(host.definitions.get(id)?.dependencies??{}))ids.add(dependency);
+  const plugins=[...ids].map(id=>{
+    const p=host.definitions.get(id);
+    if(!p?.root)throw new FlowError('内存中临时定义的插件不能打包，请先安装为标准包');
+    return Object.fromEntries([
+      ...['id','version','root','platforms','architectures','environments','dependencies','defaultConfig'].map(key=>[key,p[key]]),
+      ['requirements',p.requirements],
+      ['actions',Object.fromEntries(Object.entries(p.actions??{}).map(([name,action])=>[name,{environments:action.environments,requirements:action.requirements}]))],
+    ]);
+  });
+  return structuredClone({entries,closure,plugins,project:{environments:project.environments,network:selectedNetwork(project.network,ids),logs:project.logs,baseBundle:project.baseBundle},
+    toolRoot:fileURLToPath(new URL('../../fst-cli',import.meta.url))});
+}

package/node_modules/@mytools/core/src/plugin-update.js

@@ -0,0 +1,108 @@
+import {isDeepStrictEqual} from 'node:util';
+import {createHash} from 'node:crypto';
+import {createReadStream} from 'node:fs';
+import {readFile,readdir,readlink} from 'node:fs/promises';
+import path from 'node:path';
+
+function comparable(value){
+  if(typeof value==='function')return {functionSource:Function.prototype.toString.call(value)};
+  if(Array.isArray(value))return value.map(comparable);
+  if(value&&typeof value==='object')return Object.fromEntries(Object.entries(value).filter(([key])=>key!=='root').map(([key,item])=>[key,comparable(item)]));
+  return value;
+}
+
+function dependencies(definitions){
+  const consumers=new Map(),providers=new Map();
+  for(const [id,p] of definitions)for(const name of p.runtime?.provides??[])providers.set(name,id);
+  for(const [id,p] of definitions){
+    const used=new Set(Object.keys(p.dependencies??{}));
+    for(const name of p.runtime?.inject??[])if(providers.has(name))used.add(providers.get(name));
+    for(const owner of used){
+      if(!consumers.has(owner))consumers.set(owner,new Set());
+      consumers.get(owner).add(id);
+    }
+  }
+  return consumers;
+}
+
+export function planPluginUpdate(current,next,currentConfig={},nextConfig={},sourceChanged=new Set()){
+  const all=[...new Set([...current.keys(),...next.keys()])],changed=[];
+  for(const id of all){
+    const before=current.get(id),after=next.get(id);
+    if(!before||!after||sourceChanged.has(id)||!isDeepStrictEqual(comparable(before),comparable(after))||!isDeepStrictEqual(currentConfig[id]??{},nextConfig[id]??{}))changed.push(id);
+  }
+  const oldConsumers=dependencies(current),newConsumers=dependencies(next),affected=new Set(changed),queue=[...changed];
+  while(queue.length){
+    const owner=queue.shift();
+    for(const id of new Set([...(oldConsumers.get(owner)??[]),...(newConsumers.get(owner)??[])]))if(!affected.has(id)){
+      affected.add(id);queue.push(id);
+    }
+  }
+  const maintenance=[...affected].filter(id=>[current.get(id),next.get(id)].some(p=>p?.runtime&&p.runtime.updatePolicy!=='automatic'));
+  return {changed,affected:[...affected],maintenance};
+}
+
+async function directoryDigest(root){
+  const hash=createHash('sha256');
+  const visit=async(directory,relative='')=>{
+    const entries=(await readdir(directory,{withFileTypes:true})).sort((a,b)=>a.name.localeCompare(b.name));
+    for(const entry of entries){
+      if(entry.name==='node_modules'||entry.name==='.git')continue;
+      const name=path.posix.join(relative,entry.name),file=path.join(directory,entry.name);
+      hash.update(name);hash.update('\0');
+      if(entry.isDirectory())await visit(file,name);
+      else if(entry.isFile())for await(const chunk of createReadStream(file))hash.update(chunk);
+      else if(entry.isSymbolicLink())hash.update(await readlink(file));
+      else hash.update(entry.name);
+      hash.update('\0');
+    }
+  };
+  await visit(root);return hash.digest('hex');
+}
+
+async function resolutionDigest(installationRoot,pluginRoot){
+  if(!installationRoot)return null;
+  let lock;
+  try{lock=JSON.parse(await readFile(path.join(installationRoot,'package-lock.json'),'utf8'));}
+  catch(error){if(error.code==='ENOENT')return null;throw error;}
+  const packages=lock.packages??{},start=path.relative(installationRoot,pluginRoot).split(path.sep).join('/');
+  if(!Object.hasOwn(packages,start))return null;
+  const visited=new Set(),items=[];
+  const resolve=(from,name)=>{
+    let prefix=from;
+    while(true){
+      const key=`${prefix?`${prefix}/`:''}node_modules/${name}`;
+      if(Object.hasOwn(packages,key))return key;
+      if(!prefix)return null;
+      const index=prefix.lastIndexOf('/node_modules/');
+      prefix=index<0?'':prefix.slice(0,index);
+    }
+  };
+  const visit=key=>{
+    if(visited.has(key))return;visited.add(key);
+    const entry=packages[key];items.push([key,entry]);
+    for(const name of Object.keys({...entry.dependencies,...entry.optionalDependencies,...entry.peerDependencies}).sort()){
+      const dependency=resolve(key,name);
+      if(dependency)visit(dependency);
+      else items.push([`${key} -> ${name}`,null]);
+    }
+  };
+  visit(start);
+  items.sort(([a],[b])=>a.localeCompare(b));
+  return createHash('sha256').update(JSON.stringify(items)).digest('hex');
+}
+
+export async function changedPluginSources(current,next,{oldInstallationRoot,newInstallationRoot}={}){
+  const changed=new Set();
+  for(const [id,before] of current){
+    const after=next.get(id);
+    if(!after||before.root===after.root)continue;
+    if(!before.root||!after.root){changed.add(id);continue;}
+    const [beforeFiles,afterFiles,beforeLock,afterLock]=await Promise.all([
+      directoryDigest(before.root),directoryDigest(after.root),
+      resolutionDigest(oldInstallationRoot,before.root),resolutionDigest(newInstallationRoot,after.root),
+    ]);
+    if(beforeFiles!==afterFiles||beforeLock!==afterLock)changed.add(id);
+  }
+  return changed;
+}

package/node_modules/@mytools/core/src/process.js

@@ -1,80 +1,2 @@
-import { execa } from 'execa';
-import treeKill from 'tree-kill';
-import which from 'which';
-import { FlowError } from '@mytools/sdk';
-import path from 'node:path';
-
-const outputText=bytes=>bytes??new Uint8Array();
-const stripFinalNewline=text=>text.endsWith('\r\n')?text.slice(0,-2):text.endsWith('\n')?text.slice(0,-1):text;
-
-export async function runProcess(file,args=[],{cwd,env,signal,timeout=30000,maxBuffer=4*1024*1024,encoding='utf8',onOutput}={}) {
-  if(typeof encoding!=='string')throw new TypeError(`不支持的程序输出编码：${String(encoding)}`);
-  const label=/^(utf16le|ucs2|ucs-2)$/i.test(encoding)?'utf-16le':encoding;
-  let decoderEncoding;
-  try {decoderEncoding=new TextDecoder(label).encoding;}
-  catch {throw new TypeError(`不支持的程序输出编码：${encoding}`);}
-  if(signal?.aborted) throw new FlowError('操作已取消',{code:'CANCELLED'});
-  let executable;
-  try {
-    // 不改变宿主 cwd；程序路径和 PATH 中相对目录都以子进程 cwd 为基准。
-    const directory=path.resolve(cwd??process.cwd()),windows=process.platform==='win32';
-    const hasPath=path.isAbsolute(file)||file.includes('/')||(windows&&file.includes('\\'));
-    const search=hasPath?[path.resolve(directory,file)]:[
-      ...(windows?[directory]:[]),...(env?.PATH??(windows?env?.Path:undefined)??process.env.PATH??'').split(path.delimiter),
-    ].map(entry=>path.resolve(directory,entry.replace(/^"(.*)"$/,'$1'),file));
-    for(const candidate of search){
-      executable=await which(candidate,{nothrow:true,pathExt:env?.PATHEXT??process.env.PATHEXT});
-      if(executable)break;
-    }
-    if(!executable)throw Object.assign(new Error(`not found: ${file}`),{code:'ENOENT'});
-  }
-  catch(cause){throw new FlowError(`未找到程序：${file}`,{code:'ENOENT',details:{executable:file},cause});}
-  // Execa 收集原始字节；文本只在这里按同一编码解码，避免返回值被默认 UTF-8 解码。
-  const child=execa(executable,args,{cwd,env,reject:false,windowsHide:true,maxBuffer,timeout:0,shell:false,encoding:'buffer',stripFinalNewline:false});
-  let reason,killing,outputError,outputFailed=false,outputWrites=Promise.resolve();
-  const stop=kind=>{
-    if(reason) return; reason=kind;
-    killing=new Promise(resolve=>child.pid ? treeKill(child.pid,'SIGKILL',()=>resolve()) : resolve());
-  };
-  const cancel=()=>stop('cancelled');
-  signal?.addEventListener('abort',cancel,{once:true});
-  if(signal?.aborted)cancel();
-  const emit=(stream,message)=>{
-    if(!onOutput||!message)return;
-    // 立即挂接拒绝处理，不能让事件回调中的异步落盘变成未处理拒绝。
-    outputWrites=outputWrites.then(async()=>{if(!outputFailed)await onOutput({stream,message});}).catch(error=>{
-      if(!outputFailed){outputFailed=true;outputError=error;stop('output-callback');}
-    });
-  };
-  const flush=[];
-  for(const [name,stream] of [['stdout',child.stdout],['stderr',child.stderr]]){
-    let bytes=0,ended=false;
-    const decoder=new TextDecoder(decoderEncoding);
-    const finish=()=>{if(!ended){ended=true;emit(name,decoder.decode());}};
-    flush.push(finish);stream?.once('end',finish);
-    stream?.on('data',chunk=>{
-      bytes+=Buffer.byteLength(chunk);
-      // 流量超限时立即回收整棵进程树，不继续扩张待落盘的日志队列。
-      if(bytes>maxBuffer){stop('output-limit');return;}
-      if(onOutput)emit(name,decoder.decode(chunk,{stream:true}));
-    });
-  }
-  const timer=timeout>0 ? setTimeout(()=>stop('timeout'),timeout) : null;
-  let result;
-  try {
-    result=await child;
-  } finally {
-    clearTimeout(timer);
-    for(const finish of flush)finish();
-    await outputWrites;
-    if(killing)await killing;
-    signal?.removeEventListener('abort',cancel);
-  }
-  if(reason==='output-callback')throw outputError;
-  if(reason==='output-limit')throw new FlowError('程序输出超过上限',{code:'OUTPUT_LIMIT'});
-  if(reason)throw new FlowError(reason==='cancelled'?'操作已取消':'程序运行超时',{code:reason==='cancelled'?'CANCELLED':'TIMEOUT'});
-  if(result.isMaxBuffer)throw new FlowError('程序输出超过上限',{code:'OUTPUT_LIMIT'});
-  if(result.exitCode===undefined&&result.failed)throw new FlowError(`无法启动程序 ${file}：${result.shortMessage??result.message}`,{code:result.code??'SPAWN_FAILED'});
-  const decode=bytes=>stripFinalNewline(new TextDecoder(decoderEncoding).decode(outputText(bytes)));
-  return {exitCode:result.exitCode,stdout:decode(result.stdout),stderr:decode(result.stderr)};
-}
+// 兼容既有 core 公开入口，实际能力由 platform 模块维护。
+export * from '@mytools/fst-platform';

package/node_modules/@mytools/core/src/version.js

@@ -1,2 +1,2 @@
 // 由 npm version 的生命周期脚本同步，内部插件 API 版本独立维护。
-export const VERSION="0.4.0";
+export const VERSION="0.5.0";

package/node_modules/@mytools/fst-cli/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mytools contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,54 @@
+# 命令行与终端模块
+
+包名：`@mytools/fst-cli`。内部 workspace 包，随 `@yanglaofish/fishtools` 统一交付。
+
+## 职责与边界
+
+fst 命令入口、交互终端、输入呈现和运行观察。通过公开应用和模块接口工作，业务执行不在界面中重复实现。
+
+内部依赖：`@mytools/sdk`、`@mytools/core`、`@mytools/fst-workspace`、`@mytools/fst-platform`、`@mytools/fst-plugin`、`@mytools/fst-devtools`。
+## 公开入口
+
+| 导入路径 | 实现位置 |
+| --- | --- |
+| `@mytools/fst-cli` | `./src/terminal/session.js` |
+| `@mytools/fst-cli/entry` | `./bin/fst.js` |
+| `@mytools/fst-cli/run` | `./src/cli-run.js` |
+| `@mytools/fst-cli/terminal/conditions` | `./src/terminal/conditions.js` |
+| `@mytools/fst-cli/terminal/log-viewer` | `./src/terminal/log-viewer.js` |
+| `@mytools/fst-cli/terminal/model` | `./src/terminal/model.js` |
+| `@mytools/fst-cli/terminal/navigation` | `./src/terminal/navigation.js` |
+| `@mytools/fst-cli/terminal/presentation` | `./src/terminal/presentation.js` |
+| `@mytools/fst-cli/terminal/run-feed` | `./src/terminal/run-feed.js` |
+| `@mytools/fst-cli/terminal/run-presentation` | `./src/terminal/run-presentation.js` |
+| `@mytools/fst-cli/terminal/run-viewer` | `./src/terminal/run-viewer.js` |
+| `@mytools/fst-cli/terminal/schema` | `./src/terminal/schema.js` |
+| `@mytools/fst-cli/terminal/session` | `./src/terminal/session.js` |
+| `@mytools/fst-cli/terminal/theme` | `./src/terminal/theme.js` |
+| `@mytools/fst-cli/terminal/view` | `./src/terminal/view.js` |
+| `@mytools/fst-cli/terminal/workflow-menu` | `./src/terminal/workflow-menu.js` |
+| `@mytools/fst-cli/package.json` | `./package.json` |
+
+仅依赖 exports 声明的入口，禁止消费者跨包读取 src/bin 私有文件。入口路径由本模块维护，修改协议时同步消费方回归。
+
+## 维护与验证
+
+本模块负责上述职责的实现、文档与回归；跨模块接口调整需要同时检查生产者与消费者。具体维护人员尚未指定。
+
+在仓库根目录执行：
+
+```sh
+node --test tests/modules.test.js tests/cli.test.js tests/terminal.test.js
+```
+
+## 开发源码自动重载
+
+`fst --watch` 只在交互终端启动开发 TUI；`fst --watch web` 启动开发 Web。先使用 `fst plugin link <目录>` 引用开发源码，修改源码后监督进程等待当前业务运行和管理操作结束，再关闭旧应用并启动新进程。`run`、`plugin`、`pack` 等一次性命令不能使用 `--watch`；只读运行包也不启用源码监听。
+
+连续保存会合并为一次重启，静态导入的子模块随整个进程更新。启动错误在终端明确显示，源码修复后自动恢复。开发 Web 保持同一端口和令牌，`--port 0` 首次分配后的实际端口也会保留。终端重启会恢复旧终端并启动新会话，未保存的编辑草稿不保证保留。关闭卡住时会报告强制回收，确认旧进程退出前不启动下一代。
+
+启动监督器的进程只解析参数及监听源码，不创建插件宿主。实际应用子进程由 `src/development.js` 绑定核心开发生命周期。验证：`node --test tests/development-watch.test.js tests/cli.test.js tests/terminal.test.js`。
+
+## 完整日志分页
+
+`fst logs` 列出历史，`fst logs <id> --cursor 0 --limit 65536 --json` 返回正文和下一页字节游标。TUI 运行详情按 `p` 打开完整日志，每页读取后可前后翻页或刷新。主面板保留有界近期摘要；日志清理失败显示维护警告。细节见 `fst docs generation`。