@yanglaofish/fishtools 0.5.0 → 0.5.2

package/manual/packages/fst-cli/src/terminal/run-feed.js

@@ -1,12 +1,21 @@
 import {readableValue,readableError,readableTimeline} from './run-presentation.js';
 import {runStatuses} from './run-viewer.js';
+import {createStepSummaries} from '@mytools/fst-logs/steps';
+import {previewRun} from '@mytools/fst-logs/preview';
+
+const feedRecord=(record,maxBytes)=>{
+  const {stepSummaries,stepSummaryBytes,stepsTruncated,...state}=record;
+  return previewRun({...state,events:[...(state.events??[])]},{maxValueBytes:Math.min(maxBytes,65536)});
+};
 
 // 主面板按事件到达顺序追加；运行快照另存，配置菜单不会清掉执行记录。
 export class RunFeed{
   constructor(refresh,{maxEvents=1000,maxBytes=1048576,maxRuns=50}={}){Object.assign(this,{refresh,maxEvents,maxBytes,maxRuns});this.runs=new Map();this.entries=[];this.subscriptions=new Map();this.expanded=false;this.dropped=0;}
   track({app,runId,title,input}){
     if(this.runs.has(runId))return;
-    const record=app.getRun(runId),item={app,record,title,input,count:0,ended:false,steps:new Map(),catalog:new Map((app.catalog?.()??[]).map(action=>[action.id,action]))};
+    const raw=app.getRun(runId),record=feedRecord(raw,this.maxBytes),bounded=previewRun({input},{maxValueBytes:Math.min(this.maxBytes,65536)});
+    const item={app,record,title,input:bounded.input,inputTruncated:bounded.inputTruncated,count:0,ended:false,steps:createStepSummaries({maxEvents:this.maxEvents,maxMemoryBytes:this.maxBytes}),catalog:new Map((app.catalog?.()??[]).map(action=>[action.id,action]))};
+    for(const summary of raw.stepSummaries??[])item.steps.append(summary);
     this.runs.set(runId,item);
     this.entries.push({type:'start',item});
     if(!this.subscriptions.has(app))this.subscriptions.set(app,app.subscribe(event=>{
@@ -30,12 +39,13 @@ export class RunFeed{
     if(event?.type&&!['run.succeeded','run.failed','run.cancelled','run.stopped'].includes(event.type)){item.record.events.push(event);events=[event];item.count++;}
     else{
       const record=item.app.getRun(item.record.id);if(!record)return;
-      item.record={...record,events:[...(record.events??[])]};
+      item.record=feedRecord(record,this.maxBytes);
+      for(const summary of record.stepSummaries??[])item.steps.append(summary);
       events=record.events.filter((e,index)=>e.seq!==undefined?e.seq>item.count:index>=item.count);
       item.count=record.eventCount??record.events.length;
     }
     const {record}=item;
-    for(const event of events)if(event.type.startsWith('step.'))item.steps.set(event.callPath,{...item.steps.get(event.callPath),...event});
+    for(const event of events)item.steps.append(event);
     if(events.length){
       const last=this.entries.at(-1);
       if(last?.type==='events'&&last.item===item)last.events.push(...events);
@@ -59,7 +69,6 @@ export class RunFeed{
     this.entries=this.entries.filter(entry=>!entry.events||entry.events.length);
     for(const item of this.runs.values()){
       item.record.events=this.entries.filter(e=>e.item===item&&e.events).flatMap(e=>e.events);
-      while(item.steps.size>this.maxEvents)item.steps.delete(item.steps.keys().next().value);
     }
     const ended=[...this.runs.values()].filter(item=>item.ended);
     for(const item of ended.slice(0,Math.max(0,ended.length-this.maxRuns))){this.runs.delete(item.record.id);this.entries=this.entries.filter(e=>e.item!==item);this.dropped++;}
@@ -75,10 +84,14 @@ export class RunFeed{
     for(const event of entry.events){
       const key=`${item.record.id}\0${event.callPath}`;
       if(event.type.startsWith('step.')&&!seen.has(key)){
-        seen.add(key);const latest=item.steps.get(event.callPath),action=item.catalog.get(latest.action);
-        const status=latest.type.slice(5),symbols={started:'●',succeeded:'✓',failed:'✗',cancelled:'×',skipped:'–',stopped:'■'};
-        const name=action?.title??latest.action??latest.stepId??latest.callPath;
-        rows.push(`${symbols[status]??'·'} ${name} · ${status==='started'?'执行中':runStatuses[status]??status}${latest.durationMs!==undefined?' · '+latest.durationMs+' ms':''}${action?.plugin?' · '+action.plugin:''} · ${latest.callPath}`);
+        seen.add(key);const latest=item.steps.get(event.callPath);
+        if(!latest)rows.push(`· ${event.action??event.stepId??event.callPath} · 摘要已省略 · ${event.callPath}`);
+        else{
+          const action=item.catalog.get(latest.action);
+          const status=latest.type.slice(5),symbols={started:'●',succeeded:'✓',failed:'✗',cancelled:'×',skipped:'–',stopped:'■'};
+          const name=action?.title??latest.action??latest.stepId??latest.callPath;
+          rows.push(`${symbols[status]??'·'} ${name} · ${status==='started'?'执行中':runStatuses[status]??status}${latest.durationMs!==undefined?' · '+latest.durationMs+' ms':''}${action?.plugin?' · '+action.plugin:''} · ${latest.callPath}`);
+        }
       }
       if(event.type==='log'&&event.audience==='user')rows.push(`[${event.callPath??item.record.workflowId}] ${event.message??''}${event.data!==undefined?'\n'+readableValue(event.data):''}`);
       if(event.type==='step.failed'&&![...item.steps.values()].some(step=>step.type==='step.failed'&&step.callPath?.startsWith(event.callPath+'/')))rows.push(`✗ ${event.callPath}\n${readableError(event.error??{message:event.message})}`);
@@ -86,18 +99,20 @@ export class RunFeed{
     }
     return rows.length?`${item.title??item.record.workflowId} · ${item.record.id.slice(0,8)}\n${rows.join('\n')}`:'';
   }
-  text(){const seen=new Set();return (this.dropped?'主面板仅保留近期摘要；完整日志可在 /logs 中按 p 分页阅读。\n\n':'')+this.entries.map(entry=>{
+  text(){const seen=new Set();return (this.dropped?'主面板仅保留近期摘要；超出预算的事件和步骤摘要已省略。完整日志可在 /logs 中按 p 分页阅读。\n\n':'')+this.entries.map(entry=>{
     if(entry.type==='message')return entry.text;
     const {record,title,input}=entry.item,label=`${title??record.workflowId} · ${record.id.slice(0,8)}`;
     if(entry.type==='start')return [
       `› ${record.workflowId.startsWith('/')?record.workflowId:'/run '+record.workflowId} · ${label}`,
       `状态：${runStatuses[record.status]??record.status}`,
       this.expanded&&input&&Object.keys(input).length?'输入\n'+readableValue(input):'',
+      this.expanded&&entry.item.inputTruncated?'输入较大，主面板仅显示摘要。':'',
     ].filter(Boolean).join('\n');
     if(entry.type==='events')return this.expanded?`${label}\n${readableTimeline(entry.events,{values:true})}`:this.compactEvents(entry,seen);
     return [`结果 · ${label} · ${runStatuses[record.status]??record.status}`,
       ...(record.warnings??[]).map(warning=>`警告：${warning.message}`),
       this.expanded&&record.output!==undefined?readableValue(record.output):'',record.error&&(this.expanded||![...entry.item.steps.values()].some(step=>step.type==='step.failed'))?readableError(record.error,{details:this.expanded}):'',record.reason??'',
+      this.expanded&&record.outputTruncated?'结果较大，主面板仅显示摘要；完整结果请在 /logs 中按 p 分页阅读。':'',
     ].filter(Boolean).join('\n');
   }).filter(Boolean).join('\n\n');}
   close(){if(this.refreshTimer)clearTimeout(this.refreshTimer);this.refreshTimer=null;for(const unsubscribe of this.subscriptions.values())unsubscribe();this.subscriptions.clear();}

package/manual/packages/fst-cli/src/terminal/session.js

@@ -9,6 +9,8 @@ import {gettingStarted,pluginStatus,pluginDetails} from './presentation.js';
 import {readableValue,readableError} from './run-presentation.js';
 import {commandMenu} from './navigation.js';
 import {workflowMenu} from './workflow-menu.js';
+import {commandPresetsMenu,shortcutsMenu,runShortcut} from './command-menu.js';
+import {validate} from '@mytools/sdk/schema';
 import {resolvePrivilegeRequirement,checkStaticPrivilege} from '@mytools/fst-plugin/privileges';
 
 export class TerminalSession{
@@ -24,7 +26,7 @@ export class TerminalSession{
     }
   }
   current(){if(!this.flow)throw new Error('先用 /workflows 打开或新建工作流');return this.flow;}
-  commands(){return commandMenu(this.app.listPlugins?.()??[],this.app.listCommands());}
+  commands(){return commandMenu(this.app.listPlugins?.()??[],this.app.listCommands(),this.app.listShortcuts?.()??[]);}
   async discard(){return !this.dirty||await this.ui.confirm('当前修改未保存，是否放弃修改？');}
   async mayExit(){
     if(!await this.discard())return false;
@@ -41,7 +43,7 @@ export class TerminalSession{
       while(!this.exiting){
         this.ui.summary(`欢迎使用 Fishtools · 插件编排工作台\n当前工作区：${this.app.projectDir}\n${this.app.listPlugins().length} 个插件 · ${(await this.app.listWorkflows()).length} 个工作流${this.flow?` · ${this.flow.title??this.flow.id} · ${this.dirty?'未保存':'已保存'}`:''}`);
         let text;
-        try{text=await this.ui.input('fst > 输入 / 选择操作，@ 引用文件',{commands:this.commands(),workflows:await this.app.listWorkflows()});}
+        try{text=await this.ui.input('fst > / 操作 · ! 系统命令 · Shift+Enter 换行 · Enter 提交',{commands:this.commands(),workflows:await this.app.listWorkflows(),multiline:true});}
         catch(e){if(e.code!=='PROMPT_CANCELLED')throw e;try{if(await this.mayExit())break;}catch{}continue;}
         if(!text.trim())continue;
         try{await this.execute(text);}catch(e){if(e.code!=='PROMPT_CANCELLED'||!this.ui.endCommand)this.ui.show(e.code==='PROMPT_CANCELLED'?'已返回主面板。':`${e.code==='COMMAND_INPUT'?'输入提示':'操作失败'}：${e.message}`);}
@@ -57,19 +59,25 @@ export class TerminalSession{
     finally{this.commandDepth--;if(outer&&!this.exiting)this.ui.endCommand?.();}
   }
   async executeCommand(text){
+    if(text.trimStart().startsWith('!'))return this.shellCommand(text.trimStart().slice(1));
     const [command,...args]=parseCommand(text);
+    const shortcut=this.app.listShortcuts?.().find(entry=>entry.name===command);
+    if(shortcut)return runShortcut(this,shortcut,args);
     const entry=this.commands().find(c=>c.name===command&&c.plugin);
     if(entry){if(args.length)throw new Error(`/${command} 请从二级菜单选择能力`);return this.pluginSkills(entry.plugin);}
     const pluginCommand=this.app.listCommands().find(c=>c.name===command);
     if(pluginCommand)return this.pluginCommand(pluginCommand,args);
     if(command!=='run'&&args.length)throw new Error(`/${command} 使用交互选择，请不要附加参数`);
     switch(command){
+      case 'commands':return commandPresetsMenu(this);
+      case 'shortcuts':return shortcutsMenu(this);
       case 'help':await this.ui.viewMarkdown('Fishtools 使用指南',[
         '# Fishtools',
         '将插件能力组合为工作流，在终端内编辑、运行并查看结果。',
         `当前工作区：${this.app.projectDir}`,
         `文件路径起点：${this.baseDir}`,
         '## 常用操作',gettingStarted(await this.app.listWorkflows(),this.app.project),
+        '## 系统命令与快捷名称','输入 ! 后接系统命令可直接执行，输出和状态保留在主面板；/commands 注册常用命令供快捷执行与工作流编排，/shortcuts 给任意插件动作或命令设置中文快捷名称。主输入框和命令编辑框使用 Shift+Enter 换行、Enter 提交，Alt+Enter 为备用换行；支持多行粘贴。系统命令按当前 Shell 语法执行，目标机器需要已安装相应外部程序。',
         '## 编排工作流','/workflows 浏览、新建、打开工作流，进入后添加步骤、编辑参数、设置输出、保存或删除。删除会保留备份，仍被其他流程引用时不能删除。/run 选择已保存的工作流，或补全工作流 ID/中文标题后执行已保存版本，不会要求保存编辑草稿。要执行未保存修改，在工作流编辑菜单选择运行，再选择保存并运行；返回编辑会保留草稿。',
         '## 主面板','运行期间可以继续输入命令，打开配置、管理插件或执行其他工作流。↑/↓ 回看本次启动已提交的命令，回到底部恢复草稿；补全菜单打开时仍用于选择候选。Ctrl+O 展开或收起执行详情，PgUp/PgDn 或滚轮浏览执行过程；/logs 回看各次执行的步骤、输入输出和日志。关闭菜单不会清空运行内容。',
         '## 命令分层','/config 配置 Fishtools，/plugin 管理插件及各插件配置。输入 /插件入口名 后进入该插件的能力菜单；补全列表标明 [内置] 或 [插件]。/tools 包含 Web 与离线文档。旧 /new、/add、/steps、/outputs、/save、/plugins 以及插件的原始命令仍可直接输入。',
@@ -118,14 +126,26 @@ export class TerminalSession{
   }
   async pluginCommand(command,args){
     if(args.length>1)throw new Error(`用法：/${command.name} [@参数.json]`);
-    const input=args.length?await readRunInput(args[0],this.baseDir):command.input?await editValue(this.ui,command.input,{}, {baseDir:this.baseDir,required:true,label:command.description}):{};
+    let input;
+    if(args.length)input=await readRunInput(args[0],this.baseDir);
+    else{
+      const initial=structuredClone(command.shortcutInput??{});
+      const empty=command.input?.type==='object'&&command.input.properties&&Object.keys(command.input.properties).length===0;
+      if(command.shortcutInput!==undefined||empty){
+        try{input=validate(command.input,initial,command.description??command.name);}
+        catch{input=await editValue(this.ui,command.input,initial,{baseDir:this.baseDir,required:true,label:command.description});}
+      }else input=command.input?await editValue(this.ui,command.input,initial,{baseDir:this.baseDir,required:true,label:command.description}):initial;
+    }
     const ui=Object.fromEntries(['input','select','show','confirm'].map(name=>[name,this.ui[name].bind(this.ui)]));
     const definition=this.app.host.definitions.get(command.plugin);
+    if(!definition)throw new Error('目标插件已移除，请重新选择目标后执行');
     const requirement=resolvePrivilegeRequirement(definition,command.action);
     const unknown=requirement.declared&&checkStaticPrivilege(requirement).status==='unknown';
     const allowUnknownPrivileges=unknown?await this.ui.confirm(`/${command.name} 的权限需要运行时核查。若检查结果仍无法确认，是否允许本次继续？\n${requirement.reason??''}\n${requirement.remediation??''}`):false;
     if(unknown&&!allowUnknownPrivileges)return;
-    const run=await this.app.startCommand(command.name,input,{ui,allowUnknownPrivileges});
+    const targetName=command.targetName??command.name;
+    if(!command.actionId&&!this.app.listCommands().some(current=>current.name===targetName&&current.plugin===command.plugin))throw new Error('命令目标插件已变更，请重新选择目标后执行');
+    const run=command.actionId?await this.app.startAction(command.actionId,input,{ui,allowUnknownPrivileges}):await this.app.startCommand(targetName,input,{ui,allowUnknownPrivileges,expectedPlugin:command.plugin});
     if(this.ui.trackRun){
       this.ui.clearMessages?.();this.ui.trackRun({app:this.app,runId:run.id,title:command.description??command.name,input});
       if(command.action){void run.done.catch(error=>{if(!this.ui.closed)this.ui.show(`运行记录保存失败：${error.message}`);});return;}
@@ -135,6 +155,17 @@ export class TerminalSession{
     try{const result=await run.done;if(!this.ui.trackRun)this.ui.show(`插件执行${runStatuses[result.status]??result.status}\n${result.error?readableError(result.error):readableValue(result.output)}\n/logs 查看执行详情与历史日志`);}
     finally{unsubscribe();done();}
   }
+  async shellCommand(script){
+    const run=await this.app.startShell(script);
+    if(this.ui.trackRun){
+      this.ui.clearMessages?.();this.ui.trackRun({app:this.app,runId:run.id,title:'系统命令'});
+      void run.done.catch(error=>{if(!this.ui.closed)this.ui.show(`运行记录保存失败：${error.message}`);});return;
+    }
+    const unsubscribe=this.app.subscribe(event=>{if(event.runId===run.id&&event.type==='log')this.ui.show(event.message);});
+    const done=this.ui.busy('正在执行系统命令 · Ctrl+C 取消',()=>this.app.cancelRun(run.id));
+    try{const result=await run.done;this.ui.show(`命令${runStatuses[result.status]??result.status}\n${result.error?readableError(result.error):readableValue(result.output)}\n/logs 查看完整日志`);}
+    finally{unsubscribe();done();}
+  }
   async configure(selectedId){
     this.writable();
     const plugins=this.app.listPlugins().filter(p=>p.config);

package/manual/packages/fst-cli/src/terminal/view.js

@@ -76,7 +76,20 @@ export class TerminalView{
       input(data);
     },resize);
     this.header=new Text('',1,0);this.transcript=new Text('',1,0);this.prompt=new Container();this.hint=new Text('',1,0);
-    this.hint.render=width=>['',fitLine(' '+palette.muted(this.homeInput?(width<45?`/ 操作 · Ctrl+O ${this.feed.expanded?'收起':'展开'}`:`/ 操作 · Ctrl+O ${this.feed.expanded?'收起':'展开'}详情 · /logs 回看 · Ctrl+C 退出`):(width<45?'↑↓ 选择  Enter 确认  Esc 返回':'↑↓ 选择   Enter 确认   Tab 补全   Esc 返回   Ctrl+C 退出')),width)];
+    this.hint.render=width=>{
+      const lines=[''];
+      if(this.editor&&(this.homeInput||this.multilineInput)){
+        // 按完整按键分组换行，窄屏也能看清主键和备用键。
+        let line='';
+        for(const hint of ['Shift+Enter 换行','Enter 提交','Alt+Enter 备用换行']){
+          const next=line?line+' · '+hint:hint;
+          if(line&&visibleWidth(next)>width-1){lines.push(line);line=hint;}else line=next;
+        }
+        lines.push(line);
+      }
+      lines.push(this.homeInput?(width<45?`/ 操作 · ! 命令 · Ctrl+O ${this.feed.expanded?'收起':'展开'}`:`/ 操作 · ! 命令 · Ctrl+O ${this.feed.expanded?'收起':'展开'}详情 · /logs 回看 · Ctrl+C 退出`):this.editor&&this.multilineInput?'↑↓ 移动 · Tab 补全 · Esc 返回 · Ctrl+C 退出':(width<45?'↑↓ 选择  Enter 确认  Esc 返回':'↑↓ 选择   Enter 确认   Tab 补全   Esc 返回   Ctrl+C 退出'));
+      return lines.map(line=>line?fitLine(' '+palette.muted(line),width):'');
+    };
     const renderTranscript=this.transcript.render.bind(this.transcript);
     this.headingLines=(width,mark='FISHtools')=>{
       const room=Math.max(1,width-2),lines=[''];
@@ -127,7 +140,7 @@ export class TerminalView{
   browseCommands(data){
     const direction=matchesKey(data,'up')?-1:matchesKey(data,'down')?1:0;
     // 补全菜单保留方向键；多行编辑保留光标移动，不把配置值放进命令历史。
-    if(!direction||!this.editor||this.editor.isShowingAutocomplete()||this.editor.getText().includes('\n')||!this.commandHistory.length)return false;
+    if(!direction||!this.editor||this.editor.isShowingAutocomplete()||this.editor.getExpandedText().includes('\n')||!this.commandHistory.length)return false;
     const current=this.commandHistoryIndex??this.commandHistory.length;
     const next=Math.max(0,Math.min(this.commandHistory.length,current+direction));
     if(next===current)return true;
@@ -235,19 +248,40 @@ export class TerminalView{
     if(message.startsWith('fst >'))title.render=()=>[];
     this.prompt.clear();this.prompt.addChild(title);this.prompt.addChild(component);this.tui.setFocus(component);this.tui.requestRender();
     try{return await new Promise((resolve,reject)=>{this.pending={resolve,reject};component.onSubmit=text=>{
-      if(this.homeInput&&text.trim()&&this.commandHistory.at(-1)!==text.trim()){
-        this.commandHistory.push(text.trim());if(this.commandHistory.length>100)this.commandHistory.shift();
+      // Shell 历史保留末尾换行，避免再次执行时改变反斜杠续行等语义。
+      const historyText=text.trimStart().startsWith('!')?text:text.trim();
+      if(this.homeInput&&historyText&&this.commandHistory.at(-1)!==historyText){
+        this.commandHistory.push(historyText);if(this.commandHistory.length>100)this.commandHistory.shift();
       }
       resolve(text);
     };component.onSelect=item=>resolve(item.value);component.onCancel=()=>reject(cancelled());});}
-    finally{if(this.homeInput)this.terminal.write(mouseOff);this.pending=null;this.editor=null;this.homeInput=false;this.prompt.clear();this.tui.requestRender();}
+    finally{if(this.homeInput)this.terminal.write(mouseOff);this.pending=null;this.editor=null;this.homeInput=false;this.multilineInput=false;this.prompt.clear();this.tui.requestRender();}
   }
-  input(message,{value='',commands=[],files=true,workflows=[]}={}){
+  input(message,{value='',commands=[],files=true,workflows=[],multiline=false}={}){
     const editor=new Editor(this.tui,{borderColor:palette.border,selectList:theme},{paddingX:1});
+    const handleInput=editor.handleInput.bind(editor);
+    editor.handleInput=data=>{
+      // ProcessTerminal 已把分段粘贴合并为完整事件；公开插入接口保留脚本制表符和换行。
+      if(data.startsWith('\x1b[200~')&&data.endsWith('\x1b[201~')){
+        const text=safe(data.slice(6,-6).replace(/\r\n?/g,'\n'));
+        if(this.homeInput||multiline||text.includes('\n')){editor.insertTextAtCursor(text);return;}
+      }
+      if(matchesKey(data,'shift+enter')||matchesKey(data,'alt+enter')||data==='\x1b[13;2~'){
+        editor.insertTextAtCursor('\n');return;
+      }
+      // 反斜杠属于命令原文，不能触发上游的“反斜杠后 Enter 换行”兼容键位。
+      if(data==='\\'){editor.insertTextAtCursor(data);return;}
+      if(matchesKey(data,'enter')&&!editor.isShowingAutocomplete()){
+        if(!editor.disableSubmit){const text=editor.getExpandedText();editor.setText('');editor.onSubmit?.(text);}
+        return;
+      }
+      handleInput(data);
+    };
     const renderEditor=editor.render.bind(editor);
     editor.render=width=>{
-      if(width<8)return renderEditor(width);
-      const inner=width-4,lines=renderEditor(inner);let closed=false;
+      // 上游 visibleWidth 按三个空格计算 Tab；只扩展显示，提交仍保留原始 Tab。
+      if(width<8)return renderEditor(width).map(line=>line.replaceAll('\t','   '));
+      const inner=width-4,lines=renderEditor(inner).map(line=>line.replaceAll('\t','   '));let closed=false;
       return lines.map((line,i)=>{
         if(i===0)return ' '+palette.border('╭'+'─'.repeat(inner)+'╮');
         if(!closed&&/^─+$/.test(safe(line))){closed=true;return ' '+palette.border('╰'+'─'.repeat(inner)+'╯');}
@@ -256,6 +290,7 @@ export class TerminalView{
       });
     };
     this.homeInput=message.startsWith('fst >');
+    this.multilineInput=multiline;
     this.commandHistoryIndex=null;
     if(this.homeInput)editor.onChange=text=>{
       if(this.commandHistoryIndex!==null&&text!==this.commandHistory[this.commandHistoryIndex])this.commandHistoryIndex=null;

package/manual/packages/fst-cli/src/terminal/workflow-menu.js

@@ -4,7 +4,6 @@ export async function workflowMenu(session){
     const workflows=await app.listWorkflows();
     const choice=await ui.select('工作流 · 选择后编辑或执行',[
       ...workflows.map(flow=>({value:`workflow:${flow.id}`,label:flow.title??flow.id,description:`${flow.id} · ${flow.steps.length} 步`})),
-      ...(!app.project.readOnly?workflows.map(flow=>({value:`duplicate:${flow.id}`,label:`复制 ${flow.title??flow.id} 为新工作流`,description:`从已保存版本 ${flow.id} 创建副本` })):[]),
       ...(!app.project.readOnly?[{value:'new',label:'＋ 新建工作流'}]:[]),
       ...(session.dirty?[{value:'draft',label:`继续编辑草稿：${session.flow.title}`}]:[]),
       {value:'back',label:'返回主面板'},
@@ -12,11 +11,7 @@ export async function workflowMenu(session){
     if(choice==='back')return;
     try{
       const id=choice.startsWith('workflow:')?choice.slice(9):null;
-      if(choice.startsWith('duplicate:')){
-        if(!await session.discard())continue;
-        await duplicateIntoSession(session,workflows.find(flow=>flow.id===choice.slice(10)));
-      }
-      else if(choice==='new'){if(await session.execute('/new')===false)continue;}
+      if(choice==='new'){if(await session.execute('/new')===false)continue;}
       else if(choice!=='draft'&&session.flow?.id!==id){
         if(!await session.discard())continue;
         session.flow=structuredClone(workflows.find(flow=>flow.id===id));session.dirty=false;

package/manual/packages/fst-devtools/src/documentation.js

@@ -3,6 +3,7 @@ import {fileURLToPath} from 'node:url';
 import {access,readFile,readdir,lstat,mkdir,copyFile,realpath} from 'node:fs/promises';
 
 const topics=[
+  ['commands','系统命令与快捷名称','docs/terminal-commands.md'],
   ['plugins','插件开发规范','docs/plugin-development.md'],
   ['deployment','安装与部署','docs/deployment.md'],
   ['control','控制流与运行观察规范','docs/superpowers/specs/2026-10-11-control-observation.md'],
@@ -14,7 +15,7 @@ const topics=[
   ['readme','Fishtools 使用说明','README.md'],
 ];
 // 保留文档链接所需的目录布局；参考代码仅供阅读，不是第二份运行时。
-const assets=['README.md','LICENSE','THIRD_PARTY_NOTICES.md','docs','examples/service-plugins','plugins/examples','plugins/environment','plugins/web/README.md','packages/sdk','packages/core','packages/pack','packages/fst-logs','packages/fst-platform','packages/fst-workflow','packages/fst-plugin','packages/fst-workspace','packages/fst-devtools','packages/fst-cli','tests/application.test.js'];
+const assets=['README.md','LICENSE','THIRD_PARTY_NOTICES.md','docs','examples/service-plugins','plugins/examples','plugins/environment','plugins/commands','plugins/web/README.md','packages/sdk','packages/core','packages/pack','packages/fst-logs','packages/fst-platform','packages/fst-workflow','packages/fst-plugin','packages/fst-workspace','packages/fst-devtools','packages/fst-cli','tests/application.test.js'];
 const excluded=new Set(['node_modules','dist','.git','.cache','__pycache__','.pytest_cache','coverage','public']);
 const inside=(parent,child)=>{const relative=path.relative(parent,child);return relative===''||(!relative.startsWith(`..${path.sep}`)&&relative!=='..'&&!path.isAbsolute(relative));};
 

package/manual/packages/fst-logs/README.md

@@ -13,6 +13,8 @@
 | --- | --- |
 | `@mytools/fst-logs` | `./src/run-logs.js` |
 | `@mytools/fst-logs/markdown` | `./src/markdown-log.js` |
+| `@mytools/fst-logs/steps` | `./src/step-summaries.js` |
+| `@mytools/fst-logs/preview` | `./src/run-preview.js` |
 | `@mytools/fst-logs/package.json` | `./package.json` |
 
 仅依赖 exports 声明的入口，禁止消费者跨包读取 src/bin 私有文件。入口路径由本模块维护，修改协议时同步消费方回归。
@@ -35,6 +37,15 @@
 
 快照与历史元数据另有 `stepSummaries`、`stepSummaryBytes`、`stepsTruncated`。步骤摘要按 callPath（缺少时按 stepId）保留最新状态，仅包含类型、定位、动作、时间、序号、耗时及有界原因/错误，不缓存 input/output。步骤摘要使用独立的 maxEvents/maxMemoryBytes 预算，因此两份缓存合计最多为两倍 maxMemoryBytes；单条步骤摘要仍受 maxEventBytes 限制。普通日志淘汰不影响步骤状态；步骤本身超预算淘汰时 stepsTruncated 为 true，展示端应把无法确认的步骤显示为未知状态。
 
+`createStepSummaries(policy)` 从 `/steps` 入口提供同一套摘要缓存，日志写入器与 TUI 共用。
+`append(event)` 更新状态并刷新淘汰顺序；`get(callPath)`、`values()` 和 `snapshot()` 返回副本。
+`snapshot()` 包含上述三个步骤摘要字段，`size` 为保留条数。
+
+`previewRun(record,{maxValueBytes=65536})` 从 `/preview` 入口提供展示与历史元数据共用的结果投影。
+input/output、error、reason 等字段转为有界 JSON 预览，过大时标记 `<字段>Truncated:true`；业务数据对象不变。
+定位字段与 events/stepSummaries 保留，后两者由各自缓存预算负责；展示端应裁去不使用的缓存副本。
+maxValueBytes 至少为 2，连预览本身也容不下时省略字段值并保留截断标记。
+
 队列预算在追加时检查。未等待 append 的插件同样受到预算约束；超限返回 `LOG_QUEUE_LIMIT` 拒绝，并使 finish 失败。拒绝已安装内部处理，调用方仍可 await 观察失败，不会产生未处理拒绝。`LOG_DISK_LIMIT` 表示可选磁盘预算不足，拒绝完整追加而不静默截断。磁盘预算与队列预算都计算 JSONL 和 Markdown。建议插件等待 append，以便磁盘写入形成背压。
 
 `read`/`list` 仅读取受限的 result.json 元数据，运行中的 read 回退到归属元数据；不加载 JSONL 或 Markdown 正文。巨大旧 result.json 超过读取预算时，read 明确返回 `LOG_METADATA_LIMIT`，list 跳过该记录。旧版本缺少归属信息时仅在 `allowLegacy:true` 下可读。

package/manual/packages/fst-logs/package.json

@@ -6,6 +6,8 @@
   "main": "src/run-logs.js",
   "exports": {
     ".": "./src/run-logs.js",
+    "./steps": "./src/step-summaries.js",
+    "./preview": "./src/run-preview.js",
     "./markdown": "./src/markdown-log.js",
     "./package.json": "./package.json"
   },

package/manual/packages/fst-logs/src/run-logs.js

@@ -2,7 +2,9 @@ import path from 'node:path';
 import {readdir,readFile,lstat,unlink,rmdir,mkdir,writeFile,appendFile,open} from 'node:fs/promises';
 import {FlowError} from '@mytools/sdk';
 import {markdownHeader,markdownEvent,markdownResult} from './markdown-log.js';
-import {logPolicy,jsonSize,preview,eventPreview} from './log-bounds.js';
+import {logPolicy,jsonSize,eventPreview} from './log-bounds.js';
+import {createStepSummaries} from './step-summaries.js';
+import {previewRun} from './run-preview.js';
 
 const validId=id=>typeof id==='string'&&/^[a-f0-9-]{36}$/.test(id);
 const logFiles=['run.md','events.jsonl','result.json','run.meta.json'];
@@ -68,15 +70,15 @@ export function createRunLogs(directory,{projectDir,allowLegacy=false,...options
   return {
     list,read,owner,policy:Object.freeze({...policy}),
     async start(initial,{onEvent=()=>{}}={}){
-      const directory=location(initial.id),events=[],sizes=[],steps=new Map();
+      const directory=location(initial.id),events=[],sizes=[],steps=createStepSummaries(policy);
       await mkdir(root,{recursive:true});
       const rootStat=await lstat(root);if(!rootStat.isDirectory()||rootStat.isSymbolicLink())throw new FlowError('日志根目录无效');
       await mkdir(directory,{recursive:true});
       await safeDirectory(initial.id);
       for(const name of logFiles){try{await lstat(path.join(directory,name));throw new FlowError('运行日志已存在，拒绝覆盖');}catch(error){if(error.code!=='ENOENT')throw error;}}
       const markdownFile=path.join(directory,'run.md');
-      let writes=Promise.resolve(),failure=null,pendingBytes=0,diskBytes=0,resultBytes=0,eventCount=0,eventBytes=2,eventsTruncated=false,stepSummaryBytes=2,stepsTruncated=false,finished=false;
-      const snapshot=state=>structuredClone({...initial,...state,logOwner:owner,events,eventCount,eventBytes,eventsTruncated,stepSummaries:[...steps.values()].map(entry=>entry.event),stepSummaryBytes,stepsTruncated});
+      let writes=Promise.resolve(),failure=null,pendingBytes=0,diskBytes=0,resultBytes=0,eventCount=0,eventBytes=2,eventsTruncated=false,finished=false;
+      const snapshot=state=>structuredClone({...initial,...state,logOwner:owner,events,eventCount,eventBytes,eventsTruncated,...steps.snapshot()});
       const reject=error=>{failure??=error;const promise=Promise.reject(failure);promise.catch(()=>{});return promise;};
       function diskCheck(extra){if(policy.maxDiskBytes!==null&&diskBytes+extra>policy.maxDiskBytes)throw new FlowError('日志磁盘预算已满',{code:'LOG_DISK_LIMIT',details:{maxDiskBytes:policy.maxDiskBytes}});}
       const queue=(bytes,operation)=>{
@@ -95,28 +97,11 @@ export function createRunLogs(directory,{projectDir,allowLegacy=false,...options
         while(events.length>policy.maxEvents||eventBytes>policy.maxMemoryBytes){
           const removed=sizes.shift();events.shift();eventBytes-=removed+(events.length?1:0);eventsTruncated=true;
         }
-        if(typeof full.type==='string'&&full.type.startsWith('step.')&&(full.callPath!==undefined||full.stepId!==undefined)){
-          const lightweight={};
-          for(const key of ['type','callPath','stepId','action','time','seq','durationMs','reason','error'])if(full[key]!==undefined)lightweight[key]=full[key];
-          const summary=eventPreview(lightweight,policy.maxEventBytes),key=summary.callPath??summary.stepId;
-          if(key!==undefined&&summary.callPath===full.callPath&&summary.stepId===full.stepId){
-            const previous=steps.get(key);
-            if(previous){steps.delete(key);stepSummaryBytes-=previous.bytes+(steps.size?1:0);}
-            const bytes=Buffer.byteLength(JSON.stringify(summary));steps.set(key,{event:summary,bytes});stepSummaryBytes+=bytes+(steps.size>1?1:0);
-            while(steps.size>policy.maxEvents||stepSummaryBytes>policy.maxMemoryBytes){
-              const oldest=steps.keys().next().value,removed=steps.get(oldest);steps.delete(oldest);stepSummaryBytes-=removed.bytes+(steps.size?1:0);stepsTruncated=true;
-            }
-          }else stepsTruncated=true;
-        }
+        steps.append(full);
         onEvent(structuredClone(event));
       }
       function metadata(state){
-        const run={...initial,...state,logOwner:owner,events,eventCount,eventBytes,eventsTruncated,stepSummaries:[...steps.values()].map(entry=>entry.event),stepSummaryBytes,stepsTruncated};
-        for(const key of Object.keys(run)){
-          if(['events','stepSummaries','id','workflowId','logOwner','status','startedAt','finishedAt'].includes(key))continue;
-          if(run[key]===undefined)continue;
-          const bounded=preview(run[key],policy.maxEventBytes);run[key]=bounded.value;if(bounded.truncated)run[`${key}Truncated`]=true;
-        }
+        const run=previewRun({...initial,...state,logOwner:owner,events,eventCount,eventBytes,eventsTruncated,...steps.snapshot()},{maxValueBytes:policy.maxEventBytes});
         const text=JSON.stringify(run);
         if(Buffer.byteLength(text)>metadataLimit)throw new FlowError('运行记录元数据超过写入预算',{code:'LOG_METADATA_LIMIT'});
         return text;

package/manual/packages/fst-logs/src/run-preview.js

@@ -0,0 +1,18 @@
+import {FlowError} from '@mytools/sdk';
+import {defaults,preview,jsonSize} from './log-bounds.js';
+
+const retainedFields=new Set(['events','stepSummaries','id','workflowId','logOwner','status','startedAt','finishedAt']);
+
+// 路由信息与已有独立预算的缓存保留；业务正文和诊断字段只投影有界预览。
+export function previewRun(record,{maxValueBytes=defaults.maxEventBytes}={}){
+  if(!Number.isSafeInteger(maxValueBytes)||maxValueBytes<2)throw new FlowError('结果预览 maxValueBytes 必须为至少 2 的整数字节数');
+  const run={...record};
+  for(const key of Object.keys(run)){
+    if(retainedFields.has(key)||run[key]===undefined)continue;
+    const bounded=preview(run[key],maxValueBytes);
+    if(jsonSize(bounded.value,maxValueBytes)>maxValueBytes)delete run[key];
+    else run[key]=bounded.value;
+    if(bounded.truncated)run[`${key}Truncated`]=true;
+  }
+  return run;
+}

package/manual/packages/fst-logs/src/step-summaries.js

@@ -0,0 +1,28 @@
+import {logPolicy,eventPreview} from './log-bounds.js';
+
+// 日志写入器与展示端共用轻量摘要，避免各端重新缓存业务 input/output。
+export function createStepSummaries(options={}){
+  const policy=logPolicy(options),steps=new Map();
+  let bytes=2,truncated=false;
+  return {
+    append(full){
+      if(typeof full.type!=='string'||!full.type.startsWith('step.')||(full.callPath===undefined&&full.stepId===undefined))return;
+      const lightweight={};
+      for(const key of ['type','callPath','stepId','action','time','seq','durationMs','reason','error'])if(full[key]!==undefined)lightweight[key]=full[key];
+      const summary=eventPreview(lightweight,policy.maxEventBytes),key=summary.callPath??summary.stepId;
+      if(key===undefined||summary.callPath!==full.callPath||summary.stepId!==full.stepId){truncated=true;return;}
+      const previous=steps.get(key);
+      if(previous){steps.delete(key);bytes-=previous.bytes+(steps.size?1:0);}
+      const size=Buffer.byteLength(JSON.stringify(summary));
+      steps.set(key,{event:summary,bytes:size});bytes+=size+(steps.size>1?1:0);
+      while(steps.size>policy.maxEvents||bytes>policy.maxMemoryBytes){
+        const oldest=steps.keys().next().value,removed=steps.get(oldest);
+        steps.delete(oldest);bytes-=removed.bytes+(steps.size?1:0);truncated=true;
+      }
+    },
+    get size(){return steps.size;},
+    get(key){return structuredClone(steps.get(key)?.event);},
+    values(){return [...steps.values()].map(entry=>structuredClone(entry.event));},
+    snapshot(){return {stepSummaries:this.values(),stepSummaryBytes:bytes,stepsTruncated:truncated};},
+  };
+}

package/manual/packages/fst-platform/README.md

@@ -16,7 +16,9 @@
 | `@mytools/fst-platform/bundle` | `./src/bundle.js` |
 | `@mytools/fst-platform/json` | `./src/json.js` |
 | `@mytools/fst-platform/npm` | `./src/npm.js` |
+| `@mytools/fst-platform/network` | `./src/network.js` |
 | `@mytools/fst-platform/fs` | `./src/file-probe.js` |
+| `@mytools/fst-platform/shell` | `./src/shell.js` |
 | `@mytools/fst-platform/package.json` | `./package.json` |
 
 仅依赖 exports 声明的入口，禁止消费者跨包读取 src/bin 私有文件。入口路径由本模块维护，修改协议时同步消费方回归。
@@ -31,6 +33,21 @@
 node --test tests/modules.test.js tests/process.test.js tests/environments.test.js
 ```
 
+进程停止专项：`node --test tests/process.test.js tests/process-stream.test.js tests/process-tree-stop.test.js`。
+
+## 子进程环境
+
+`/shell` 的 `runShell(script,{shell='auto',runProcess,temporaryDir,...processOptions})` 使用唯一临时脚本文件，避免长脚本超过系统命令行长度上限，运行结束后删除本次文件。默认 Windows PowerShell / Linux sh，可选 powershell、pwsh、sh、bash；PowerShell 使用 UTF-8 BOM，其他 Shell 使用无 BOM UTF-8。插件传入 `ctx.runProcess` 与 `temporaryDir:ctx.outputDir`，保留当前代理、取消与日志规则，并兼容只读包目录。`shellInvocation` 保留构造简短命令参数的兼容接口。
+
+`runProcess(file,args,{env,extendEnv=true})` 默认把 `env` 覆盖到宿主环境上。
+当调用方已按动作代理规则构造完整环境时，传 `extendEnv:false`，防止已移除的代理变量被重新继承。
+
+缓冲模式由平台按每条输出流的原始字节计算 `maxBuffer`，默认每条流 4 MiB；超限返回 `OUTPUT_LIMIT`。
+`maxBuffer` 必须为非负数，`0` 仅允许空输出，`Infinity` 表示调用方显式取消缓冲上限；对象、`NaN` 和负数会在启动前被拒绝。
+流式模式通过 `onOutput` 消费输出，仅保留 `summaryBytes` 指定的尾部摘要。
+超限、取消、超时或输出回调失败时，平台终止整棵进程树，等待回收结束后返回错误。
+停止过程中继续排空并丢弃管道输出，避免提前关闭管道使父进程因 `EPIPE` 退出，导致 Windows `taskkill /T` 无法找到后代进程。
+
 ## 隔离文件探测
 
 `createFileProbe({timeout=2000,maxConcurrent=2,maxPending=16,allowRemote=false})` 创建只读探测器。

package/manual/packages/fst-platform/package.json

@@ -6,6 +6,7 @@
   "main": "src/process.js",
   "exports": {
     ".": "./src/process.js",
+    "./shell": "./src/shell.js",
     "./environments": "./src/environments.js",
     "./bundle": "./src/bundle.js",
     "./json": "./src/json.js",

package/manual/packages/fst-platform/src/process.js

@@ -4,11 +4,11 @@ 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,outputMode='buffer',summaryBytes=65536}={}) {
+export async function runProcess(file,args=[],{cwd,env,extendEnv=true,signal,timeout=30000,maxBuffer=4*1024*1024,encoding='utf8',onOutput,outputMode='buffer',summaryBytes=65536}={}) {
   if(!['buffer','stream'].includes(outputMode))throw new TypeError('outputMode 必须为 buffer 或 stream');
+  if(typeof maxBuffer!=='number'||Number.isNaN(maxBuffer)||maxBuffer<0)throw new TypeError('maxBuffer 必须为非负数，可用 Infinity 表示不限制缓冲');
   const streaming=outputMode==='stream';
   if(streaming&&typeof onOutput!=='function')throw new TypeError('stream 模式必须提供 onOutput 消费输出');
   if(!Number.isSafeInteger(summaryBytes)||summaryBytes<0||summaryBytes>1024*1024)throw new TypeError('summaryBytes 必须为 0 到 1048576 的整数');
@@ -33,11 +33,12 @@ export async function runProcess(file,args=[],{cwd,env,signal,timeout=30000,maxB
     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,buffer:!streaming,timeout:0,shell:false,encoding:'buffer',stripFinalNewline:false});
+  // 平台统一收集原始字节和执行上限；Execa 的超限收集器会提前关闭管道，
+  // 导致持续输出的父进程因 EPIPE 退出，taskkill 尚未遍历就失去父 PID。
+  const child=execa(executable,args,{cwd,env,extendEnv,reject:false,windowsHide:true,maxBuffer,buffer:false,timeout:0,shell:false,encoding:'buffer',stripFinalNewline:false});
   let reason,killing,outputError,outputFailed=false,outputWrites=Promise.resolve();
   let markStopped;const stopped=new Promise(resolve=>{markStopped=resolve;});
-  const outputBytes={stdout:0,stderr:0},tails={stdout:'',stderr:''};let outputTruncated=false;
+  const outputBytes={stdout:0,stderr:0},tails={stdout:'',stderr:''},buffers={stdout:[],stderr:[]};let outputTruncated=false;
   const remember=(name,message)=>{
     const bytes=Buffer.from(tails[name]+message);let start=Math.max(0,bytes.length-summaryBytes);
     if(start){outputTruncated=true;while(start<bytes.length&&(bytes[start]&0xc0)===0x80)start++;}
@@ -67,7 +68,8 @@ export async function runProcess(file,args=[],{cwd,env,signal,timeout=30000,maxB
         const decoder=new TextDecoder(decoderEncoding);
         try{
           for await(const chunk of stream){
-            if(reason)break;outputBytes[name]+=chunk.byteLength;
+            // 停止后继续排空并丢弃输出，避免迭代器 break 提前关闭管道触发 EPIPE。
+            if(reason)continue;outputBytes[name]+=chunk.byteLength;
             const message=decoder.decode(chunk,{stream:true});remember(name,message);
             await Promise.race([emit(name,message),stopped]);
           }
@@ -81,9 +83,11 @@ export async function runProcess(file,args=[],{cwd,env,signal,timeout=30000,maxB
     const finish=()=>{if(!ended){ended=true;emit(name,decoder.decode());}};
     flush.push(finish);stream?.once('end',finish);
     stream?.on('data',chunk=>{
+      if(reason)return;
       bytes+=Buffer.byteLength(chunk);
       // 流量超限时立即回收整棵进程树，不继续扩张待落盘的日志队列。
       if(bytes>maxBuffer){stop('output-limit');return;}
+      buffers[name].push(chunk);
       if(onOutput)emit(name,decoder.decode(chunk,{stream:true}));
     });
   }
@@ -104,7 +108,7 @@ export async function runProcess(file,args=[],{cwd,env,signal,timeout=30000,maxB
   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)));
+  const decode=chunks=>stripFinalNewline(new TextDecoder(decoderEncoding).decode(Buffer.concat(chunks)));
   if(streaming)return {exitCode:result.exitCode,stdout:stripFinalNewline(tails.stdout),stderr:stripFinalNewline(tails.stderr),outputMode,outputTruncated,outputBytes};
-  return {exitCode:result.exitCode,stdout:decode(result.stdout),stderr:decode(result.stderr)};
+  return {exitCode:result.exitCode,stdout:decode(buffers.stdout),stderr:decode(buffers.stderr)};
 }