@yanglaofish/fishtools 0.4.0 → 0.5.0

package/manual/tests/application.test.js

@@ -2,9 +2,9 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { mkdir, writeFile, readFile } from 'node:fs/promises';
 import path from 'node:path';
-import { createApplication } from '../packages/core/src/application.js';
+import { createApplication } from '@mytools/core';
 import { temporary, testPlugin, object } from './helpers.js';
-import {validate} from '../packages/core/src/validation.js';
+import {validate} from '@mytools/sdk/schema';
 
 test('同 ID schema 隔离编译，保留内嵌引用且不串用旧约束',()=>{
   const schema=type=>({$id:'https://fishtools.test/review/config',type:'object',definitions:{value:{type}},properties:{value:{$ref:'#/definitions/value'}},required:['value']});
@@ -47,7 +47,8 @@ test('运行快照独立于之后保存，状态与日志持久化',async t=>{
   assert.deepEqual(app.getRun(run.id).output,{text:'HELLO'});
   const events=(await readFile(path.join(app.outputDir,run.id,'events.jsonl'),'utf8')).trim().split('\n').map(JSON.parse);
   assert.ok(events.some(e=>e.type==='run.succeeded'));
-  assert.ok(!events.some(e=>Object.hasOwn(e,'output')));
+  assert.deepEqual(events.find(e=>e.type==='run.result').output,{text:'HELLO'});
+  assert.deepEqual(events.find(e=>e.type==='step.succeeded').output,{text:'HELLO'});
 });
 
 test('仓库外本地插件可以安装、加载并执行，移除后目录同步',async t=>{
@@ -61,7 +62,8 @@ test('仓库外本地插件可以安装、加载并执行，移除后目录同
   await app.saveWorkflow({id:'external',schemaVersion:1,inputs:object(),steps:[{id:'hello',action:'external-flow-test:hello',with:{}}],outputs:{answer:{$ref:'steps.hello.output.value'}}});
   const run=await app.startRun('external',{});await run.done;
   assert.deepEqual(app.getRun(run.id).output,{answer:42});
-  await app.removePlugin('external-flow-test');
+  await assert.rejects(app.removePlugin('external-flow-test'),error=>error.code==='PLUGIN_IN_USE'&&error.details.workflows[0].id==='external');
+  await app.removePlugin('external-flow-test',{force:true});
   assert.ok(!app.catalog().some(a=>a.id==='external-flow-test:hello'));
 });
 

package/node_modules/@mytools/core/README.md

@@ -0,0 +1,44 @@
+# 应用内核模块
+
+包名：`@mytools/core`。内部 workspace 包，随 `@yanglaofish/fishtools` 统一交付。
+
+## 职责与边界
+
+组合各能力模块、协调运行与关闭、提供 CLI/Web 共用应用接口及导出声明快照。日志写入和缓存由 logs 负责；导出实现通过可选 pack 依赖加载。
+
+内部依赖：`@mytools/sdk`、`@mytools/fst-platform`、`@mytools/fst-logs`、`@mytools/fst-workflow`、`@mytools/fst-plugin`、`@mytools/fst-workspace`、`@mytools/pack`。
+`@mytools/pack` 是可选 peer 依赖；普通发行包含它，只读发行省略它。既有 `/process`、`/bundle`、`/environments` 子入口保留兼容转发。
+
+## 公开入口
+
+| 导入路径 | 实现位置 |
+| --- | --- |
+| `@mytools/core` | `./src/application.js` |
+| `@mytools/core/version` | `./src/version.js` |
+| `@mytools/core/process` | `./src/process.js` |
+| `@mytools/core/environments` | `./src/environments.js` |
+| `@mytools/core/bundle` | `./src/bundle.js` |
+| `@mytools/core/development` | `./src/development.js` |
+| `@mytools/core/package.json` | `./package.json` |
+
+仅依赖 exports 声明的入口，禁止消费者跨包读取 src/bin 私有文件。入口路径由本模块维护，修改协议时同步消费方回归。
+
+## 维护与验证
+
+本模块负责上述职责的实现、文档与回归；跨模块接口调整需要同时检查生产者与消费者。具体维护人员尚未指定。
+
+在仓库根目录执行：
+
+```sh
+node --test tests/modules.test.js tests/application.test.js tests/lifecycle.test.js tests/module-interfaces.test.js
+```
+
+## 开发监督进程
+
+`createDevelopmentSupervisor({projectDir,entry,args,env,configFile,onEvent})` 启动文件监听 worker 和应用子进程，返回 `status()`、幂等 `close()`。父进程不加载插件运行模块；每次重启使用全新的 Node 进程，完整更新 ESM 导入依赖。`bindDevelopmentChild(app,{details,closePresentation})` 通过 IPC 报告就绪，收到重启请求后等待 `app.developmentStatus()` 的运行和管理操作均为空闲，再调用 `app.close()` 及界面清理。
+
+监听来源为项目 `.flow/plugins.json` 的 `links`，同时监听项目配置、插件状态和显式配置覆盖文件。独立 worker 跳过 `node_modules`、`.git`、`.flow`、`dist` 及符号链接；默认限制 512 个源码目录、20000 个扫描条目和 24 层深度。超出预算或扫描超时会明确报告未完整监听，独立进程扫描避免挂载目录的 I/O 阻塞监督器。只读项目拒绝启用开发模式。
+
+源码变化默认合并 180 ms。关闭超时从应用报告空闲并开始关闭后计时，默认 5 秒；启动超时默认 15 秒。强制终止后最多等待 2 秒确认回收，未确认退出的子进程继续占用预算，不能启动重叠宿主。`onEvent` 提供 `ready/changed/waiting/restarting/failed/forced/blocked/watchError/closed` 等状态，启动失败保留源码监听，修复后可再次启动。
+
+验证：`node --test tests/development-watch.test.js` 使用真实非交互子进程验证完整模块图、忙碌等待、连续保存、源码修复、关闭与配置刷新，并验证真实 Web 重启。

package/node_modules/@mytools/core/package.json

@@ -5,34 +5,34 @@
   "main": "src/application.js",
   "exports": {
     ".": "./src/application.js",
+    "./version": "./src/version.js",
     "./process": "./src/process.js",
+    "./environments": "./src/environments.js",
     "./bundle": "./src/bundle.js",
-    "./environments": "./src/environments.js"
-  },
-  "bin": {
-    "fst": "bin/fst.js"
+    "./development": "./src/development.js",
+    "./package.json": "./package.json"
   },
   "files": [
     "src",
-    "bin",
-    "templates"
+    "README.md",
+    "LICENSE"
   ],
   "license": "MIT",
   "engines": {
     "node": ">=24.15.0"
   },
   "dependencies": {
-    "@mariozechner/pi-tui": "0.50.0",
     "@mytools/sdk": "0.1.0",
-    "ajv": "8.20.0",
-    "commander": "14.0.3",
-    "cordis": "3.18.1",
-    "execa": "10.1.0",
-    "semver": "7.7.4",
-    "tar": "7.5.22",
-    "tree-kill": "1.2.2",
-    "validate-npm-package-name": "8.0.0",
-    "which": "7.0.0",
-    "yaml": "2.9.1"
+    "@mytools/fst-platform": "0.1.0",
+    "@mytools/fst-logs": "0.1.0",
+    "@mytools/fst-workflow": "0.1.0",
+    "@mytools/fst-plugin": "0.1.0",
+    "@mytools/fst-workspace": "0.1.0"
+  },
+  "peerDependencies": {
+    "@mytools/pack": "0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@mytools/pack": {"optional": true}
   }
 }

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

@@ -1,77 +1,93 @@
-import { mkdir, appendFile, writeFile, rename, readFile } from 'node:fs/promises';
+import { mkdir, readFile, writeFile, rename } from 'node:fs/promises';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { EventEmitter } from 'node:events';
-import { createHost } from './host.js';
-import { WorkflowStore } from './workflows.js';
-import { runWorkflow } from './engine.js';
-import { runProcess } from './process.js';
-import { readJson, loadPlugin, installGeneration } from './plugins.js';
+import {isDeepStrictEqual} from 'node:util';
+import { createHost } from '@mytools/fst-plugin';
+import { WorkflowStore } from '@mytools/fst-workspace/workflows';
+import { runWorkflow } from '@mytools/fst-workflow';
+import { runProcess } from '@mytools/fst-platform';
+import {createFileProbe} from '@mytools/fst-platform/fs';
+import {readJson} from '@mytools/fst-platform/json';
+import {loadPlugin} from '@mytools/fst-plugin/loader';
+import {installGeneration} from '@mytools/fst-workspace/plugins';
 import { FlowError } from '@mytools/sdk';
-import {prepareBundleWorkspace} from './bundle-workspace.js';
-import {validate} from './validation.js';
+import {prepareBundleWorkspace} from '@mytools/fst-workspace/bundles';
+import {validate} from '@mytools/sdk/schema';
 import {createResources} from './resources.js';
-import {errorRecord} from './diagnostics.js';
-import {markdownHeader,markdownEvent,markdownResult} from './markdown-log.js';
-import {createRunLogs,validateKeepRuns} from './run-logs.js';
-import {openPluginState,withPluginMutation,assertPluginState,savePluginState,leaseInstallation} from './plugin-installations.js';
+import {errorRecord} from '@mytools/sdk/diagnostics';
+import {createExportSnapshot} from './export-snapshot.js';
+import {createRunLogs,validateKeepRuns} from '@mytools/fst-logs';
+import {openPluginState,withPluginMutation,assertPluginState,savePluginState,leaseInstallation} from '@mytools/fst-workspace/installations';
+import {planPluginUpdate,changedPluginSources} from './plugin-update.js';
+import {validateNetworkPolicy,inspectNetworkPolicy} from '@mytools/fst-platform/network';
+import {resolvePrivilegeRequirement,checkStaticPrivilege} from '@mytools/fst-plugin/privileges';
 
-export async function createApplication({projectDir=process.cwd(),workspace,outputDir,plugins,config={},maintenance=false,omitInstalledPlugin}={}) {
+export async function createApplication({projectDir=process.cwd(),workspace,outputDir,plugins,config={},maintenance=false,omitInstalledPlugin,allowUnknownPrivileges=false}={}) {
   projectDir=await prepareBundleWorkspace(path.resolve(projectDir),workspace);
   const project=await readJson(path.join(projectDir,'flow.project.json'),{plugins:[]});
   const output=path.resolve(outputDir??process.env.FLOW_OUTPUT_DIR??(project.readOnly?path.join(process.cwd(),'flow-results'):path.join(projectDir,'.flow','runs')));
   const store=new WorkflowStore(path.join(projectDir,'workflows'));
-  const emitter=new EventEmitter(), runs=new Map();
+  const emitter=new EventEmitter(), runs=new Map(),journals=new WeakMap();
   const resources=createResources(),operations=new Set();let closing,launching=0;
-  const runLogs=createRunLogs(output,{projectDir,allowLegacy:output===path.join(projectDir,'.flow','runs')}),writingRuns=new Set();
+  const runLogs=createRunLogs(output,{...project.logs,projectDir,allowLegacy:output===path.join(projectDir,'.flow','runs')}),writingRuns=new Set();
+  const maxCachedRuns=project.logs?.maxCachedRuns??50;
+  if(!Number.isSafeInteger(maxCachedRuns)||maxCachedRuns<1||maxCachedRuns>1000)throw new FlowError('maxCachedRuns 必须为 1 到 1000 的整数');
+  const fileProbe=createFileProbe(project.fileAccess);
   validateKeepRuns(project.logs?.keepRuns??null);
   const opened=await openPluginState(projectDir,{readOnly:project.readOnly});
-  let host,state=opened.state,releaseInstallation=opened.release,busy=false;
+  let host,state=opened.state,busy=false;
+  const installationLeases=new Map();
+  if(state.root)installationLeases.set(path.resolve(state.root),opened.release);
   const app={
     projectDir,project,outputDir:output,store,
     get host(){return host;},
     get maintenance(){return maintenance;},
+    developmentStatus:()=>({running:launching+writingRuns.size+operations.size,busy,closing:!!closing}),
     catalog:()=>host.catalog(),
-    listPlugins:()=>[...host.definitions.values()].map(p=>({id:p.id,version:p.version,title:p.title,description:p.description,platforms:p.platforms,architectures:p.architectures,environments:p.environments,config:p.config,runtime:host.runtimeStatus().find(r=>r.id===p.id),removable:!!(state.dependencies?.[p.id]||state.links?.[p.id]),development:!!state.links?.[p.id],warnings:host.warnings.filter(item=>item.plugin===p.id).map(item=>item.message)})),
+    listPlugins:()=>[...host.definitions.values()].map(p=>({id:p.id,version:p.version,title:p.title,description:p.description,platforms:p.platforms,architectures:p.architectures,environments:p.environments,config:p.config,requirements:p.requirements,privileges:pluginPrivileges(p),runtime:{...host.runtimeStatus().find(r=>r.id===p.id),...(p.runtime?{updatePolicy:p.runtime.updatePolicy??'maintenance'}:{})},removable:!!(state.dependencies?.[p.id]||state.links?.[p.id]),development:!!state.links?.[p.id],warnings:host.warnings.filter(item=>item.plugin===p.id).map(item=>item.message)})),
     listCommands:()=>host.commands(),
     listWorkflows:()=>store.list(),
-    async saveWorkflow(w){if(project.readOnly)throw new FlowError('此分发包仅用于运行；请在开发项目中编辑');return store.save(w);},
-    async removeWorkflow(id){if(project.readOnly)throw new FlowError('只读项目不能删除工作流');return store.remove(id);},
-    checkWorkflow:id=>store.resolve([id],host),
+    async saveWorkflow(w){return mutateWorkflow(()=>store.save(w));},
+    async duplicateWorkflow(definition,options){return mutateWorkflow(()=>store.duplicate(definition,options));},
+    async removeWorkflow(id){return mutateWorkflow(()=>store.remove(id));},
+    async checkWorkflow(id){
+      host.assertHealthy();
+      const closure=await store.resolve([id],host);
+      return {...closure,privileges:workflowPrivileges(closure,id)};
+    },
     subscribe(fn){emitter.on('event',fn);return ()=>emitter.off('event',fn);},
-    async startRun(id,input={}) {
+    async startRun(id,input={},options={}) {
       if(busy) throw new FlowError('插件更新中，请稍后运行');
-      const closure=await store.resolve([id],host);
+      const closure=await app.checkWorkflow(id);
+      const blocked=closure.privileges.filter(item=>item.mandatory&&item.static.status==='blocked');
       const snapshotStore={resolve:async()=>structuredClone(closure),childId:ref=>store.childId(ref)};
-      return app.executeTracked(id,(activeHost,context,event)=>runWorkflow({store:snapshotStore,host:activeHost,id,input,signal:context.signal,onEvent:event,runId:context.runId,context}));
+      const networkPolicy=structuredClone(project.network??{});
+      return app.executeTracked(id,(activeHost,context,event)=>{
+        if(blocked.length)throw new FlowError(`工作流缺少运行权限：${blocked.map(item=>item.action).join('、')}`,{code:'INSUFFICIENT_PRIVILEGE',details:{actions:blocked}});
+        return runWorkflow({store:snapshotStore,host:activeHost,id,input,signal:context.signal,onEvent:event,runId:context.runId,context:{...context,allowUnknownPrivileges:!!options.allowUnknownPrivileges,networkPolicy}});
+      });
     },
     async startCommand(name,input={},context={}){
       if(busy)throw new FlowError('插件更新中，请稍后调用');
-      return app.executeTracked(`/${name}`,(activeHost,runContext)=>activeHost.invokeCommand(name,input,{...context,...runContext}));
+      const networkPolicy=structuredClone(project.network??{});
+      return app.executeTracked(`/${name}`,(activeHost,runContext)=>activeHost.invokeCommand(name,input,{...context,...runContext,networkPolicy}));
     },
     async executeTracked(id,execute){
-      const runId=randomUUID(),dir=path.join(output,runId),controller=new AbortController();
-      await mkdir(dir,{recursive:true});
-      const run={id:runId,workflowId:id,logOwner:runLogs.owner,status:'running',startedAt:new Date().toISOString(),events:[],controller};
+      const runId=randomUUID(),controller=new AbortController();
+      const run={id:runId,workflowId:id,logOwner:runLogs.owner,status:'running',startedAt:new Date().toISOString(),controller};
+      const journal=await runLogs.start({id:runId,workflowId:id,status:run.status,startedAt:run.startedAt},{onEvent:event=>emitter.emit('event',event)});
+      journals.set(run,journal);
+      // 兼容运行句柄的事件读取；外部修改不影响日志模块的缓存。
+      Object.defineProperty(run,'events',{get:()=>journal.snapshot().events});
       runs.set(runId,run);
       writingRuns.add(runId);
-      const markdownFile=path.join(dir,'run.md');
-      let writes=writeFile(markdownFile,markdownHeader(run));
-      const event=e=>{
-        const full={time:new Date().toISOString(),runId,...e};run.events.push(full);
-        emitter.emit('event',full);
-        const {output:ignored,...record}=full;
-        writes=writes.then(async()=>{
-          await appendFile(path.join(dir,'events.jsonl'),JSON.stringify(record)+'\n');
-          await appendFile(markdownFile,markdownEvent(full));
-        });
-        return writes;
-      };
+      const event=e=>journal.append(e);
       const activeHost=host;
       run.done=(async()=>{
         try {
           await event({type:'run.started'});
-          run.output=await execute(activeHost,{outputDir:dir,signal:controller.signal,runId,log:(message,data,meta={})=>event({...meta,type:'log',message,data})},event);
+          run.output=await execute(activeHost,{outputDir:journal.directory,signal:controller.signal,runId,log:(message,data,meta={})=>event({...meta,type:'log',message,data})},event);
           run.status='succeeded';await event({type:'run.succeeded'});
         } catch(error) {
           if(error?.code==='WORKFLOW_STOPPED'){
@@ -84,23 +100,48 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
           }
         } finally {
           run.finishedAt=new Date().toISOString();
-          await writes;
-          await appendFile(markdownFile,markdownResult(app.getRun(runId)));
-          await writeFile(path.join(dir,'result.json'),JSON.stringify(snapshotRun(run),null,2));
-          writingRuns.delete(runId);
+          try{await journal.finish(runState(run));}finally{writingRuns.delete(runId);}
           try{await pruneLogs();}catch(error){
-            await event({type:'log',message:`日志自动清理失败：${error.message}`});
-            await writeFile(path.join(dir,'result.json'),JSON.stringify(snapshotRun(run),null,2));
+            run.warnings=[{code:'LOG_PRUNE_FAILED',message:`日志自动清理失败：${error.message}`}];
+            await journal.save(runState(run));
           }
         }
-        return snapshotRun(run);
+        const result=snapshotRun(run);trimRuns();return result;
       })();
+      // Web 等调用方只保留运行 ID；立即观察拒绝，但不替换供 CLI/TUI 等待的原 Promise。
+      run.done.catch(error=>{
+        run.status='failed';
+        run.error=errorRecord(new FlowError(`运行日志保存失败：${error.message}`,{code:'LOG_WRITE_FAILED',details:errorRecord(error),cause:run.error}));
+        trimRuns();
+      });
       return run;
     },
     getRun(id){const r=runs.get(id);return r?snapshotRun(r):null;},
-    async readRun(id){if(runs.has(id))return app.getRun(id);if(!/^[a-f0-9-]{36}$/.test(id))throw new FlowError('运行 ID 无效');return JSON.parse(await readFile(path.join(output,id,'result.json'),'utf8'));},
+    async readRun(id){if(runs.has(id))return app.getRun(id);return runLogs.read(id);},
+    readLogPage:(id,options)=>runLogs.page(id,options),
     listRuns:()=>[...runs.keys()].map(id=>{const {events,...r}=app.getRun(id);return r;}),
     logSettings:()=>({keepRuns:project.logs?.keepRuns??null}),
+    networkPolicy:()=>structuredClone(project.network??{}),
+    networkReport:()=>inspectNetworkPolicy(project.network??{},{plugins:[...host.definitions.keys()],actions:[...host.actions.keys()]}),
+    async configureNetworkPolicy(next){
+      validateNetworkPolicy(next);
+      if(project.readOnly)throw new FlowError('只读运行包不能修改代理设置');
+      if(busy)throw new FlowError('项目正在更新，请稍后修改代理设置');
+      busy=true;let backup;
+      try{
+        await withPluginMutation(projectDir,async()=>{
+          const file=path.join(projectDir,'flow.project.json'),latest=await readJson(file,project);
+          if(latest.readOnly)throw new FlowError('只读运行包不能修改代理设置');
+          if(!isDeepStrictEqual(latest.network??{},project.network??{}))throw new FlowError('代理设置已被另一实例修改，请重新读取后再保存',{code:'NETWORK_CONFLICT'});
+          backup=await backupProjectFile(file,latest,'network');
+          const nextProject={...latest,network:structuredClone(next)},temp=`${file}.${randomUUID()}.tmp`;
+          await writeFile(temp,JSON.stringify(nextProject,null,2));await rename(temp,file);
+          for(const key of Object.keys(project))delete project[key];Object.assign(project,nextProject);
+        });
+      }finally{busy=false;}
+      return {policy:app.networkPolicy(),backup};
+    },
+    logUsage:()=>runLogs.usage(),
     async listRunHistory(){
       const records=new Map((await runLogs.list()).map(r=>[r.id,r]));
       for(const id of runs.keys())records.set(id,app.getRun(id));
@@ -108,52 +149,65 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
     },
     async readLog(id){
       const run=runs.get(id);
-      if(run&&writingRuns.has(id))return markdownHeader(run)+run.events.map(markdownEvent).join('');
+      if(run&&writingRuns.has(id))return journals.get(run).markdown(runState(run));
       return runLogs.markdown(id);
     },
     async configureLogs(keepRuns){
       validateKeepRuns(keepRuns);if(project.readOnly)throw new FlowError('只读运行包不能保存日志设置');
       if(busy)throw new FlowError('项目正在更新，请稍后修改日志设置');
-      busy=true;
+      busy=true;let backup,warning;
       try{
         await withPluginMutation(projectDir,async()=>{
           const file=path.join(projectDir,'flow.project.json'),latest=await readJson(file,project);
           if(latest.readOnly)throw new FlowError('只读运行包不能保存日志设置');
+          backup=await backupProjectFile(file,latest,'logs');
           const nextProject={...latest,logs:{...latest.logs,keepRuns}},temp=`${file}.${randomUUID()}.tmp`;
           await writeFile(temp,JSON.stringify(nextProject,null,2));await rename(temp,file);
           for(const key of Object.keys(project))delete project[key];Object.assign(project,nextProject);
-          await pruneLogs();
+          try{await pruneLogs();}
+          catch(error){warning={code:'LOG_PRUNE_FAILED',message:`日志保留设置已保存，但旧日志清理失败：${error.message}`};emitter.emit('event',{type:'logs.prune.warning',...warning});}
         });
       }finally{busy=false;}
+      return {keepRuns,backup,...(warning?{warning}:{})};
     },
     cancelRun(id){const r=runs.get(id);if(r?.status==='running')r.controller.abort();return !!r;},
-    async installPlugin(source){return change({add:source});},
-    async linkPlugin(source){return change({link:path.resolve(projectDir,source)});},
-    async removePlugin(name){if(resources.active(name))throw new FlowError('请先停止此插件提供的 Web');if(!state.dependencies?.[name]&&!state.links?.[name])throw new FlowError('此插件来自发行配置，不能在此移除');return change({remove:name});},
-    async pack(options){const {packApplication}=await import('@mytools/pack');return packApplication(app,options);},
-    async packPlan(options){const {planApplication}=await import('@mytools/pack');return planApplication(app,options);},
-    async configurePlugin(id,value){
+    async installPlugin(source,options){return change({add:source},options);},
+    async linkPlugin(source,options){return change({link:path.resolve(projectDir,source)},options);},
+    async removePlugin(name,options={}){
+      return change({remove:name},options);
+    },
+    exportSnapshot:options=>createExportSnapshot({store,host,project},options),
+    async pack(options){if(project.readOnly)throw new FlowError('只读运行包不能重新打包');const {packApplication}=await import('@mytools/pack');return packApplication(await app.exportSnapshot(options),options);},
+    async packPlan(options){const {planApplication}=await import('@mytools/pack');return planApplication(await app.exportSnapshot(options),options);},
+    async configurePlugin(id,value,options={}){
       if(project.readOnly)throw new FlowError('只读项目不能保存配置');
-      assertMutable();
-      if(resources.active(id))throw new FlowError('请先停止此插件提供的 Web，再修改配置');
       if(busy||launching||app.listRuns().some(r=>r.status==='running'))throw new FlowError('请等待运行或安装结束');
       if(!host.definitions.has(id))throw new FlowError(`插件不存在：${id}`);
       value=validate(host.definitions.get(id).config,value,`${id} 配置`);
-      busy=true;let nextHost;
+      busy=true;let backup;
       try{
         await withPluginMutation(projectDir,async()=>{
         await assertPluginState(projectDir,state);
         const file=path.join(projectDir,'flow.project.json'),latest=await readJson(file,project);
         if(latest.readOnly)throw new FlowError('只读项目不能保存配置');
         const nextConfig={...latest.config,[id]:value};
-        nextHost=await createHost({plugins:[...host.definitions.values()].map(p=>({plugin:p,root:p.root})),config:{...nextConfig,...config},services,environmentOverrides:latest.environments,runtimeEnabled:!maintenance});
+        const oldConfig={...project.config,...config},effectiveNext={...nextConfig,...config};
+        const entries=[...host.definitions.values()].map(p=>({plugin:p,root:p.root}));
+        const plan=planPluginUpdate(host.definitions,host.definitions,oldConfig,effectiveNext,new Set([id]));
+        assertMaintenance(plan,options);
+        backup=await backupProjectFile(file,latest,'config');
+        if(plan.affected.length)await host.replace({plugins:entries,config:effectiveNext,affected:plan.affected});
         const nextProject={...latest,config:nextConfig},temp=`${file}.${randomUUID()}.tmp`;
-        await writeFile(temp,JSON.stringify(nextProject,null,2));await rename(temp,file);
-        const old=host;host=nextHost;nextHost=null;
+        try{await writeFile(temp,JSON.stringify(nextProject,null,2));await rename(temp,file);}
+        catch(error){
+          if(plan.affected.length)try{await host.replace({plugins:entries,config:oldConfig,affected:plan.affected});}
+          catch(recovery){host.invalidate();throw new AggregateError([error,recovery],`配置保存失败且插件恢复失败：${error.message}；${recovery.message}`);}
+          throw error;
+        }
         for(const key of Object.keys(project))delete project[key];Object.assign(project,nextProject);
-        await old.close();
         });
-      }finally{try{if(nextHost)await nextHost.close();}finally{busy=false;}}
+      }finally{busy=false;}
+      return {backup};
     },
     async setMaintenance(enabled){
       if(typeof enabled!=='boolean')throw new FlowError('维护模式必须为布尔值');
@@ -164,7 +218,7 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
       try{
         const entries=[...host.definitions.values()].map(p=>({plugin:p,root:p.root}));
         if(enabled){maintenance=true;await host.close();}
-        const next=await createHost({plugins:entries,config:{...project.config,...config},services,environmentOverrides:project.environments,runtimeEnabled:!enabled});
+        const next=await createHost({plugins:entries,config:{...project.config,...config},services,project:hostProject(),network:()=>project.network,environmentOverrides:project.environments,runtimeEnabled:!enabled,allowUnknownPrivileges});
         const old=host;host=next;maintenance=enabled;if(!enabled)await old.close();
       }finally{busy=false;}
     },
@@ -182,22 +236,24 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
         const errors=[];
         try{await resources.close();}catch(error){errors.push(error);}
         try{await host.close();}catch(error){errors.push(error);}
-        try{await releaseInstallation();}catch(error){errors.push(error);}
+        try{const report=await fileProbe.close();if(report.incomplete)errors.push(new FlowError('文件探测进程尚未全部回收',{code:'FS_CLEANUP_INCOMPLETE',details:report}));}catch(error){errors.push(error);}
+        for(const release of installationLeases.values())try{await release();}catch(error){errors.push(error);}
         if(errors.length)throw new AggregateError(errors,`应用关闭失败：${errors.map(e=>e.message).join('；')}`);
       });return closing;
     },
   };
   let initial;
-  const services={application:app,runProcess};
-  const build=extra=>createHost({plugins:[...initial,...extra],config:{...project.config,...config},services,environmentOverrides:project.environments,runtimeEnabled:!maintenance});
+  const services={application:app,runProcess,fs:fileProbe};
+  const hostProject=()=>({directory:projectDir,readOnly:!!project.readOnly});
+  const build=extra=>createHost({plugins:[...initial,...extra],config:{...project.config,...config},services,project:hostProject(),network:()=>project.network,environmentOverrides:project.environments,runtimeEnabled:!maintenance,allowUnknownPrivileges});
   try{
     initial=plugins??await Promise.all((project.plugins??[]).map(spec=>loadPlugin(spec,project.baseBundle?.root??projectDir)));
     const external=[];
     for(const name of Object.keys(state.dependencies??{}))if(!maintenance||name!==omitInstalledPlugin)external.push(await loadPlugin(name,state.root));
     for(const [name,source] of Object.entries(state.links??{}))if(!maintenance||name!==omitInstalledPlugin)external.push(await loadPlugin(source,projectDir));
     host=await build(external);
-  }catch(error){await releaseInstallation();throw error;}
-  for(const name of ['startRun','startCommand','startWeb','saveWorkflow','removeWorkflow','installPlugin','linkPlugin','removePlugin','configurePlugin','configureLogs','setMaintenance','pack']){
+  }catch(error){await fileProbe.close();await opened.release();throw error;}
+  for(const name of ['startRun','startCommand','startWeb','saveWorkflow','duplicateWorkflow','removeWorkflow','installPlugin','linkPlugin','removePlugin','configurePlugin','configureNetworkPolicy','configureLogs','setMaintenance','pack']){
     const original=app[name],isRun=['startRun','startCommand'].includes(name);
     app[name]=async(...args)=>{
       if(closing)throw new FlowError('应用已关闭');
@@ -206,30 +262,131 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
       try{return await task;}finally{operations.delete(task);if(isRun)launching--;}
     };
   }
-  function assertMutable(){if(!maintenance&&host.hasRuntime)throw new FlowError('运行时插件已启动，请先进入维护模式再修改插件或配置');}
-  function snapshotRun(run){const {done,controller,...result}=run;return structuredClone(result);}
+  async function mutateWorkflow(operation){
+    if(project.readOnly)throw new FlowError('只读运行包不能修改工作流');
+    if(busy)throw new FlowError('插件变更期间暂不能修改工作流',{code:'PLUGIN_BUSY'});
+    return withPluginMutation(projectDir,async()=>{
+      await assertPluginState(projectDir,state);
+      return operation();
+    });
+  }
+  async function backupProjectFile(file,latest,label){
+    const directory=path.join(projectDir,'.flow','backups');
+    await mkdir(directory,{recursive:true,mode:0o700});
+    const backup=path.join(directory,`flow.project.${label}-${randomUUID()}.json`);
+    let original;
+    try{original=await readFile(file,'utf8');}
+    catch(error){if(error.code!=='ENOENT')throw error;original=JSON.stringify(latest,null,2);}
+    await writeFile(backup,original,{flag:'wx',mode:0o600});
+    return backup;
+  }
+  function pluginPrivileges(plugin){
+    const report=action=>{
+      const requirement=resolvePrivilegeRequirement(plugin,action);
+      return {action:action===undefined?null:`${plugin.id}:${action}`,requirement,static:checkStaticPrivilege(requirement)};
+    };
+    return [report(),...Object.keys(plugin.actions??{}).map(report)];
+  }
+  function assertMaintenance(plan,options={}){
+    if(!maintenance&&plan.maintenance.length&&!options.allowMaintenance)throw new FlowError(`更新将重启插件 ${plan.maintenance.join('、')}，请确认本次定向维护`,{code:'MAINTENANCE_REQUIRED',details:{plugins:plan.maintenance,affected:plan.affected}});
+    const active=plan.affected.filter(id=>resources.active(id));
+    if(active.length)throw new FlowError(`请先停止受影响插件提供的 Web：${active.join('、')}`,{code:'WEB_ACTIVE',details:{plugins:active}});
+  }
+  function workflowPrivileges(closure,entryId){
+    const flows=new Map(closure.workflows.map(w=>[w.id,w])),report=[];
+    const visit=(id,mandatory)=>{
+      const workflow=flows.get(id);
+      if(!workflow)return;
+      const steps=(list,required)=>{
+        let available=required;
+        for(const step of list){
+          const needed=available&&!step.when;
+          if(step.action){
+            const pluginId=step.action.slice(0,step.action.lastIndexOf(':')),plugin=host.definitions.get(pluginId);
+            const requirement=resolvePrivilegeRequirement(plugin,step.action.slice(pluginId.length+1));
+            report.push({workflowId:id,stepId:step.id,action:step.action,mandatory:needed,requirement,static:checkStaticPrivilege(requirement)});
+          }
+          if(step.workflow)visit(store.childId(step.workflow),needed);
+          if(step.branch){steps(step.branch.then,false);steps(step.branch.else??[],false);}
+          if(step.parallel)steps(step.parallel.steps,needed);
+          if(step.stop)available=false;
+        }
+      };
+      steps(workflow.steps,mandatory);
+    };
+    visit(entryId,true);return report;
+  }
+  async function findPluginWorkflowReferences(id){
+    const refs=[];
+    const collect=(steps,found)=>{for(const step of steps??[]){
+      if(typeof step.action==='string'&&step.action.startsWith(`${id}:`))found.add(step.action);
+      if(step.branch){collect(step.branch.then,found);collect(step.branch.else,found);}
+      if(step.parallel)collect(step.parallel.steps,found);
+    }};
+    for(const workflow of await store.list()){
+      const found=new Set();collect(workflow.steps,found);
+      if(found.size)refs.push({id:workflow.id,title:workflow.title??workflow.id,actions:[...found]});
+    }
+    return refs;
+  }
+  function runState(run){const {done,controller,...result}=run;return result;}
+  function snapshotRun(run){return journals.get(run).snapshot(runState(run));}
+  function trimRuns(){
+    const completed=[...runs.values()].filter(run=>!writingRuns.has(run.id)&&run.status!=='running');
+    for(const run of completed.slice(0,Math.max(0,completed.length-maxCachedRuns)))runs.delete(run.id);
+    // 超大业务结果交给 done 的调用方；宿主历史改读磁盘摘要，避免长期持有大对象。
+    for(const run of completed){
+      try{if(run.output!==undefined&&Buffer.byteLength(JSON.stringify(run.output))>(project.logs?.maxMemoryBytes??1048576)){
+        if(run.error?.code==='LOG_WRITE_FAILED'){delete run.output;run.outputTruncated=true;}else runs.delete(run.id);
+      }}
+      catch{delete run.output;run.outputTruncated=true;}
+    }
+  }
   async function pruneLogs(){for(const id of await runLogs.prune(project.logs?.keepRuns??null,writingRuns))runs.delete(id);}
-  async function change(operation){
+  async function change(operation,options={}){
     if(project.readOnly)throw new FlowError('运行包不支持安装或移除插件');
-    assertMutable();
     if(busy || launching || [...runs.values()].some(r=>r.status==='running'))throw new FlowError('请等待当前运行或安装结束');
-    busy=true;let nextHost,nextRelease;
+    busy=true;let candidate,nextRelease;
     try {
       return await withPluginMutation(projectDir,async()=>{
       await assertPluginState(projectDir,state);
-      const next=await installGeneration(projectDir,{...operation,state});
-      for(const p of host.definitions.values())if(resources.active(p.id)){
-        const candidate=[...initial,...next.loaded].find(e=>(e.plugin??e).id===p.id);
-        if(!candidate||candidate.root!==p.root||(candidate.plugin??candidate).version!==p.version)throw new FlowError('请先停止活动 Web，再替换其提供者');
+      const latest=await readJson(path.join(projectDir,'flow.project.json'),project);
+      if(latest.readOnly)throw new FlowError('运行包不支持安装或移除插件');
+      if(operation.remove){
+        const name=operation.remove;
+        if(resources.active(name))throw new FlowError('请先停止此插件提供的 Web');
+        if(!state.dependencies?.[name]&&!state.links?.[name])throw new FlowError('此插件来自发行配置，不能在此移除');
+        const dependents=[...host.definitions.values()].filter(p=>p.id!==name&&Object.hasOwn(p.dependencies??{},name)).map(p=>p.id);
+        if(dependents.length)throw new FlowError(`插件仍被其他插件依赖：${dependents.join('、')}`,{code:'PLUGIN_IN_USE',details:{dependencies:dependents}});
+        const workflows=await findPluginWorkflowReferences(name);
+        if(workflows.length&&!options.force)throw new FlowError(`插件 ${name} 仍被工作流引用：${workflows.map(w=>w.id).join('、')}`,{code:'PLUGIN_IN_USE',details:{workflows}});
       }
-      nextHost=await build(next.loaded);
+      const next=await installGeneration(projectDir,{...operation,state});
+      const nextEntries=[...initial,...next.loaded],activeConfig={...project.config,...config},effectiveConfig={...latest.config,...config};
+      candidate=await createHost({plugins:nextEntries,config:effectiveConfig,services,project:hostProject(),network:()=>project.network,environmentOverrides:project.environments,runtimeEnabled:false,allowUnknownPrivileges});
+      const sourceChanges=await changedPluginSources(host.definitions,candidate.definitions,{oldInstallationRoot:state.root,newInstallationRoot:next.state.root});
+      const plan=planPluginUpdate(host.definitions,candidate.definitions,activeConfig,effectiveConfig,sourceChanges);
+      assertMaintenance(plan,options);
+      await candidate.close();candidate=null;
       nextRelease=await leaseInstallation(projectDir,next.state.root);
-      await savePluginState(projectDir,next.state,state);
-      const old=host,oldRelease=releaseInstallation;host=nextHost;nextHost=null;state=next.state;releaseInstallation=nextRelease;nextRelease=null;
-      try{await old.close();}finally{await oldRelease();}
+      const oldEntries=[...host.definitions.values()].map(p=>({plugin:p,root:p.root}));
+      if(plan.affected.length)await host.replace({plugins:nextEntries,config:effectiveConfig,affected:plan.affected});
+      try{await savePluginState(projectDir,next.state,state);}
+      catch(error){
+        if(plan.affected.length)try{await host.replace({plugins:oldEntries,config:activeConfig,affected:plan.affected});}
+        catch(recovery){host.invalidate();throw new AggregateError([error,recovery],`插件状态保存失败且恢复失败：${error.message}；${recovery.message}`);}
+        throw error;
+      }
+      state=next.state;
+      for(const key of Object.keys(project))delete project[key];Object.assign(project,latest);
+      installationLeases.set(path.resolve(state.root),nextRelease);nextRelease=null;
+      for(const [root,release] of installationLeases)if(root!==path.resolve(state.root)&&![...host.definitions.values()].some(p=>p.root&&path.resolve(p.root).startsWith(root+path.sep))){
+        try{await release();installationLeases.delete(root);}
+        catch(error){emitter.emit('event',{type:'plugin.cleanup.warning',message:`旧安装批次租约暂未清理：${error.message}`,root});}
+      }
       return app.listPlugins();
       });
-    } finally {try{if(nextHost)await nextHost.close();}finally{try{if(nextRelease)await nextRelease();}finally{busy=false;}}}
+    } finally {try{if(candidate)await candidate.close();}finally{try{if(nextRelease)await nextRelease();}finally{busy=false;}}}
   }
   return app;
 }

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

@@ -1,17 +1,2 @@
-import { createHash } from 'node:crypto';
-import { readFile, realpath } from 'node:fs/promises';
-import path from 'node:path';
-
-export async function verifyBundle(root){
-  root=await realpath(root);
-  const manifest=JSON.parse(await readFile(path.join(root,'manifest.json'),'utf8'));
-  const errors=[];
-  for(const [relative,expected] of Object.entries(manifest.files??{})){
-    const file=path.resolve(root,relative);
-    try{
-      if(!file.startsWith(root+path.sep)||!(await realpath(file)).startsWith(root+path.sep))throw new Error('路径越界');
-      if(createHash('sha256').update(await readFile(file)).digest('hex')!==expected)errors.push(relative);
-    }catch{errors.push(relative);}
-  }
-  return {ok:errors.length===0,errors};
-}
+// 兼容既有 core 公开入口，实际能力由 platform 模块维护。
+export * from '@mytools/fst-platform/bundle';