@yanglaofish/fishtools 0.5.1 → 0.5.3

package/manual/packages/core/src/application.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile, writeFile, rename } from 'node:fs/promises';
+import { mkdir, readFile, writeFile, rename, rm, rmdir } from 'node:fs/promises';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { EventEmitter } from 'node:events';
@@ -7,6 +7,9 @@ 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 {runShell} from '@mytools/fst-platform/shell';
+import {COMMANDS_PLUGIN_ID,commandsPluginRoot,createCommandsPlugin,validateCommandPresets} from '@mytools/commands';
+import {validateShortcuts,describeShortcuts,bindShortcutCommands} from '@mytools/fst-workspace/shortcuts';
 import {createFileProbe} from '@mytools/fst-platform/fs';
 import {readJson} from '@mytools/fst-platform/json';
 import {loadPlugin} from '@mytools/fst-plugin/loader';
@@ -20,13 +23,31 @@ 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 {validateNetworkPolicy,inspectNetworkPolicy,resolveNetworkPolicy,buildProcessEnv} from '@mytools/fst-platform/network';
 import {resolvePrivilegeRequirement,checkStaticPrivilege} from '@mytools/fst-plugin/privileges';
+import {registerWorkspace,registryWorkflowReferences,registryPluginReferences} from '@mytools/fst-workspace/registry';
+import {mergePluginEntries,preparePluginCatalog} from './plugin-catalog.js';
 
-export async function createApplication({projectDir=process.cwd(),workspace,outputDir,plugins,config={},maintenance=false,omitInstalledPlugin,allowUnknownPrivileges=false}={}) {
+function declaredCommands(entries){
+  return entries.flatMap(entry=>{const plugin=entry.plugin??entry;return Object.keys(plugin.commands??{}).map(name=>({name,plugin:plugin.id}));});
+}
+
+function workflowActions(steps,found=new Set()){
+  for(const step of steps??[]){
+    if(step.action)found.add(step.action);
+    if(step.branch){workflowActions(step.branch.then,found);workflowActions(step.branch.else,found);}
+    if(step.parallel)workflowActions(step.parallel.steps,found);
+  }
+  return found;
+}
+
+export async function createApplication({projectDir=process.cwd(),workspace,pluginRegistryDir,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 requestedOutput=outputDir??process.env.FLOW_OUTPUT_DIR;
+  const output=path.resolve(requestedOutput??(project.readOnly?path.join(process.cwd(),'flow-results'):path.join(projectDir,'.flow','runs')));
+  const results=path.resolve(requestedOutput||project.readOnly?path.join(output,'files'):path.join(projectDir,'results'));
+  const sessionId=randomUUID();
   const store=new WorkflowStore(path.join(projectDir,'workflows'));
   const emitter=new EventEmitter(), runs=new Map(),journals=new WeakMap();
   const resources=createResources(),operations=new Set();let closing,launching=0;
@@ -35,22 +56,34 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
   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,busy=false;
+  const registryDir=path.resolve(pluginRegistryDir&&!project.readOnly&&!project.baseBundle?pluginRegistryDir:projectDir),shared=registryDir!==projectDir;
+  if(shared)await registerWorkspace(registryDir,projectDir);
+  const opened=await openPluginState(registryDir,{readOnly:project.readOnly});
+  const localOpened=shared?await openPluginState(projectDir):null;
+  let host,state=opened.state,localState=localOpened?.state,busy=false,pending=new Map(),catalogEntries=[],localEntries=[];
   const installationLeases=new Map();
   if(state.root)installationLeases.set(path.resolve(state.root),opened.release);
+  if(localState?.root)installationLeases.set(path.resolve(localState.root),localOpened.release);
+  const withRegistryMutation=callback=>withPluginMutation(registryDir,()=>shared?withPluginMutation(projectDir,callback):callback());
+  const assertStates=async()=>{await assertPluginState(registryDir,state);if(shared)await assertPluginState(projectDir,localState);};
   const app={
-    projectDir,project,outputDir:output,store,
+    projectDir,project,pluginRegistryDir:registryDir,pluginScope:shared?'global':'workspace',outputDir:output,resultsDir:results,sessionId,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,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)})),
+    pluginDefinition:id=>host.definitions.get(id)??pending.get(id)?.entry.plugin,
+    listPlugins:()=>catalogEntries.map(entry=>{const p=entry.plugin??entry,scope=entry.scope??'preset',installed=scope==='global'?state:scope==='workspace'?(shared?localState:state):{};return {id:p.id,version:p.version,title:p.title,description:p.description,scope,source:entry.root,platforms:p.platforms,architectures:p.architectures,environments:p.environments,config:p.config,requirements:p.requirements,privileges:pluginPrivileges(p),runtime:{...(pending.has(p.id)?{status:'unconfigured'}:host.runtimeStatus().find(r=>r.id===p.id)),...(p.runtime?{updatePolicy:p.runtime.updatePolicy??'maintenance'}:{})},...(pending.has(p.id)?{configurationError:pending.get(p.id).message}:{}),removable:!!(installed.dependencies?.[p.id]||installed.links?.[p.id]),development:!!installed.links?.[p.id],warnings:host.warnings.filter(item=>item.plugin===p.id).map(item=>item.message)};}),
     listCommands:()=>host.commands(),
+    listShortcuts:()=>describeShortcuts(project.shortcuts??{},{actions:host.catalog(),commands:host.commands()}),
+    async configureShortcuts(value){return updateUserCommands({shortcuts:value});},
+    async configureCommandPresets(value,options={}){
+      return updateUserCommands({commandPresets:value,...(options.shortcuts!==undefined?{shortcuts:options.shortcuts}:{})},options);
+    },
     listWorkflows:()=>store.list(),
-    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 saveWorkflow(w){return mutateWorkflow(()=>store.save(w),w);},
+    async duplicateWorkflow(definition,options){return mutateWorkflow(()=>store.duplicate(definition,options),definition);},
+    async removeWorkflow(id,options){return mutateWorkflow(()=>store.remove(id,options));},
     async checkWorkflow(id){
       host.assertHealthy();
       const closure=await store.resolve([id],host);
@@ -66,17 +99,42 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
       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}});
-      });
+      },{kind:'workflow',title:closure.workflows.find(flow=>flow.id===id)?.title??id,input});
     },
     async startCommand(name,input={},context={}){
       if(busy)throw new FlowError('插件更新中，请稍后调用');
+      for(const [id,{entry}] of pending)if(Object.hasOwn(entry.plugin.commands??{},name))assertConfigured(id);
       const networkPolicy=structuredClone(project.network??{});
-      return app.executeTracked(`/${name}`,(activeHost,runContext)=>activeHost.invokeCommand(name,input,{...context,...runContext,networkPolicy}));
+      return app.executeTracked(`/${name}`,(activeHost,runContext)=>{
+        if(context.expectedPlugin!==undefined&&!activeHost.commands().some(command=>command.name===name&&command.plugin===context.expectedPlugin)){
+          throw new FlowError('命令目标插件已变更，请重新选择目标后执行',{code:'COMMAND_TARGET_CHANGED',details:{command:name,plugin:context.expectedPlugin}});
+        }
+        return activeHost.invokeCommand(name,input,{...context,...runContext,networkPolicy});
+      },{kind:'command',title:host.commands().find(command=>command.name===name)?.description??`/${name}`,input});
+    },
+    async startAction(id,input={},context={}){
+      if(busy)throw new FlowError('插件更新中，请稍后调用');
+      assertConfigured(id.slice(0,id.lastIndexOf(':')));
+      const networkPolicy=structuredClone(project.network??{});
+      return app.executeTracked(id,(activeHost,runContext)=>activeHost.invoke(id,input,{...context,...runContext,networkPolicy}),{kind:'action',title:host.catalog().find(action=>action.id===id)?.title??id,input});
+    },
+    async startShell(script,{shell='auto',timeout=30000}={}){
+      if(busy)throw new FlowError('项目更新中，请稍后执行命令');
+      if(!Number.isSafeInteger(timeout)||timeout<0||timeout>2147483647)throw new FlowError('命令超时必须为 0 到 2147483647 毫秒，0 表示不限时',{code:'VALIDATION'});
+      const policy=resolveNetworkPolicy(structuredClone(project.network??{}));
+      const env=buildProcessEnv(policy);
+      return app.executeTracked('!命令',async(_host,context)=>{
+        const result=await runShell(script,{shell,temporaryDir:context.outputDir,cwd:projectDir,env,extendEnv:false,signal:context.signal,timeout,outputMode:'stream',summaryBytes:65536,
+          onStart:invocation=>context.log('执行程序',invocation,{kind:'process'}),
+          onOutput:({stream,message})=>context.log(message,undefined,{stream,audience:'user'})});
+        if(result.exitCode!==0)throw new FlowError(`命令执行失败，退出码 ${result.exitCode}`,{code:'EXECUTION_FAILED',details:result});
+        return result;
+      },{kind:'shell',title:'系统命令'});
     },
-    async executeTracked(id,execute){
+    async executeTracked(id,execute,{kind='workflow',title=id,input}={}){
       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)});
+      const run={id:runId,workflowId:id,kind,title,sessionId,resultDir:path.join(results,runId),logOwner:runLogs.owner,status:'running',startedAt:new Date().toISOString(),controller};
+      const journal=await runLogs.start({id:runId,workflowId:id,kind,title,sessionId,status:run.status,startedAt:run.startedAt},{onEvent:event=>emitter.emit('event',event)});
       journals.set(run,journal);
       // 兼容运行句柄的事件读取；外部修改不影响日志模块的缓存。
       Object.defineProperty(run,'events',{get:()=>journal.snapshot().events});
@@ -85,9 +143,12 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
       const event=e=>journal.append(e);
       const activeHost=host;
       run.done=(async()=>{
+        let createdResults=false;
         try {
+          createdResults=(await mkdir(run.resultDir,{recursive:true}))!==undefined;
           await event({type:'run.started'});
-          run.output=await execute(activeHost,{outputDir:journal.directory,signal:controller.signal,runId,log:(message,data,meta={})=>event({...meta,type:'log',message,data})},event);
+          if(input!==undefined)await event({type:'run.input',input});
+          run.output=await execute(activeHost,{outputDir:run.resultDir,logDir: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'){
@@ -100,9 +161,16 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
           }
         } finally {
           run.finishedAt=new Date().toISOString();
+          if(createdResults){
+            try{await rmdir(run.resultDir);run.resultDir=undefined;}
+            catch(error){
+              if(error.code==='ENOENT')run.resultDir=undefined;
+              else if(!['ENOTEMPTY','EEXIST'].includes(error.code))run.warnings=[{code:'RESULT_CLEANUP_FAILED',message:`空结果目录无法移除：${error.message}`}];
+            }
+          }
           try{await journal.finish(runState(run));}finally{writingRuns.delete(runId);}
           try{await pruneLogs();}catch(error){
-            run.warnings=[{code:'LOG_PRUNE_FAILED',message:`日志自动清理失败：${error.message}`}];
+            run.warnings=[...(run.warnings??[]),{code:'LOG_PRUNE_FAILED',message:`日志自动清理失败：${error.message}`}];
             await journal.save(runState(run));
           }
         }
@@ -182,29 +250,32 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
     async configurePlugin(id,value,options={}){
       if(project.readOnly)throw new FlowError('只读项目不能保存配置');
       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} 配置`);
+      if(!app.pluginDefinition(id))throw new FlowError(`插件不存在：${id}`);
+      value=validate(app.pluginDefinition(id).config,value,`${id} 配置`);
       busy=true;let backup;
       try{
-        await withPluginMutation(projectDir,async()=>{
-        await assertPluginState(projectDir,state);
+        await withRegistryMutation(async()=>{
+        await assertStates();
         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};
         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]));
+        const prepared=preparePluginCatalog(catalogEntries,effectiveNext);
+        const nextDefinitions=new Map(prepared.active.map(entry=>[(entry.plugin??entry).id,entry.plugin??entry]));
+        const entries=prepared.active,oldEntries=[...host.definitions.values()].map(p=>({plugin:p,root:p.root}));
+        const plan=planPluginUpdate(host.definitions,nextDefinitions,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`;
         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});}
+          if(plan.affected.length)try{await host.replace({plugins:oldEntries,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);
+        pending=prepared.pending;
         });
       }finally{busy=false;}
       return {backup};
@@ -242,19 +313,31 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
       });return closing;
     },
   };
-  let initial;
+  let initial,globalEntries=[];
   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});
+  const build=extra=>{
+    catalogEntries=entriesWithPresets(mergePluginEntries(initial,shared?localEntries:extra,shared?extra:[],state.disabledLegacy,{shared}),project.commandPresets??{});
+    const entries=catalogEntries;
+    validateShortcuts(project.shortcuts??{},{reservedNames:declaredCommands(entries).map(command=>command.name)});
+    const prepared=preparePluginCatalog(entries,{...project.config,...config});pending=prepared.pending;
+    return createHost({plugins:prepared.active,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 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);
+    globalEntries=await loadInstalled(state,registryDir);
+    if(shared)localEntries=await loadInstalled(localState,projectDir,new Set([...Object.keys(state.dependencies??{}),...Object.keys(state.links??{}),...(state.disabledLegacy??[])]));
+    host=await build(globalEntries);
+  }catch(error){await fileProbe.close();await opened.release();await localOpened?.release();throw error;}
+  async function loadInstalled(current,base,excluded=new Set()){
+    const loaded=[];
+    for(const name of Object.keys(current.dependencies??{}))if(!excluded.has(name)&&(!maintenance||name!==omitInstalledPlugin))loaded.push(await loadPlugin(name,current.root));
+    for(const [name,source] of Object.entries(current.links??{}))if(!excluded.has(name)&&(!maintenance||name!==omitInstalledPlugin))loaded.push(await loadPlugin(source,base));
+    return loaded;
+  }
+  function assertConfigured(id){if(pending.has(id))throw new FlowError(`插件 ${id} 尚未配置：${pending.get(id).message}`,{code:'PLUGIN_NOT_CONFIGURED',details:{plugin:id}});}
+  for(const name of ['startRun','startCommand','startAction','startShell','startWeb','saveWorkflow','duplicateWorkflow','removeWorkflow','installPlugin','linkPlugin','removePlugin','configurePlugin','configureNetworkPolicy','configureLogs','configureCommandPresets','configureShortcuts','setMaintenance','pack']){
+    const original=app[name],isRun=['startRun','startCommand','startAction','startShell'].includes(name);
     app[name]=async(...args)=>{
       if(closing)throw new FlowError('应用已关闭');
       if(isRun)launching++;
@@ -262,11 +345,16 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
       try{return await task;}finally{operations.delete(task);if(isRun)launching--;}
     };
   }
-  async function mutateWorkflow(operation){
+  async function mutateWorkflow(operation,definition){
     if(project.readOnly)throw new FlowError('只读运行包不能修改工作流');
     if(busy)throw new FlowError('插件变更期间暂不能修改工作流',{code:'PLUGIN_BUSY'});
-    return withPluginMutation(projectDir,async()=>{
-      await assertPluginState(projectDir,state);
+    return withRegistryMutation(async()=>{
+      await assertStates();
+      if(definition){
+        const workflow=store.validateShape(definition),latest=await readJson(path.join(projectDir,'flow.project.json'),project);
+        const missing=[...workflowActions(workflow.steps)].filter(id=>id.startsWith(`${COMMANDS_PLUGIN_ID}:`)&&!Object.hasOwn(latest.commandPresets??{},id.slice(COMMANDS_PLUGIN_ID.length+1)));
+        if(missing.length)throw new FlowError('引用的注册命令已删除，请重新选择动作后保存',{code:'COMMAND_NOT_FOUND',details:{actions:missing}});
+      }
       return operation();
     });
   }
@@ -280,6 +368,57 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
     await writeFile(backup,original,{flag:'wx',mode:0o600});
     return backup;
   }
+  function entriesWithPresets(entries,presets){
+    const definition=createCommandsPlugin(presets);
+    const result=entries.filter(entry=>(entry.plugin??entry).id!==COMMANDS_PLUGIN_ID);
+    if(Object.keys(definition.actions).length)result.push({plugin:definition,root:commandsPluginRoot});
+    return result;
+  }
+  async function updateUserCommands(changes,options={}){
+    if(project.readOnly)throw new FlowError('只读运行包不能修改注册命令或快捷名称');
+    if(busy||launching||app.listRuns().some(run=>run.status==='running'))throw new FlowError('请等待运行或安装结束');
+    const requested=structuredClone(changes);
+    if(Object.hasOwn(requested,'commandPresets'))requested.commandPresets=validateCommandPresets(requested.commandPresets);
+    busy=true;
+    try{return await withRegistryMutation(async()=>{
+      await assertStates();
+      const file=path.join(projectDir,'flow.project.json'),latest=await readJson(file,project);
+      if(latest.readOnly)throw new FlowError('只读运行包不能修改注册命令或快捷名称');
+      for(const field of Object.keys(requested))if(!isDeepStrictEqual(latest[field]??{},project[field]??{})){
+        throw new FlowError('注册命令或快捷名称已被另一实例修改，请重新打开工作区再保存',{code:'USER_COMMANDS_CONFLICT',details:{field}});
+      }
+      const nextProject={...latest,...requested};
+      const presets=validateCommandPresets(nextProject.commandPresets??{});
+      const oldEntries=[...host.definitions.values()].map(plugin=>({plugin,root:plugin.root}));
+      const nextCatalog=entriesWithPresets(catalogEntries,presets),prepared=preparePluginCatalog(nextCatalog,{...latest.config,...config});
+      const entries=prepared.active;
+      const reservedNames=declaredCommands(entries).map(command=>command.name);
+      const shortcuts=Object.hasOwn(requested,'shortcuts')?bindShortcutCommands(nextProject.shortcuts??{},{commands:declaredCommands(entries),previous:latest.shortcuts??{}}):nextProject.shortcuts??{};
+      nextProject.shortcuts=validateShortcuts(shortcuts,{reservedNames});
+      const removed=new Set(Object.keys(project.commandPresets??{}).filter(id=>!Object.hasOwn(presets,id)).map(id=>`${COMMANDS_PLUGIN_ID}:${id}`));
+      if(removed.size){
+        const workflows=(await findPluginWorkflowReferences(COMMANDS_PLUGIN_ID)).filter(workflow=>workflow.actions.some(action=>removed.has(action)));
+        if(workflows.length)throw new FlowError(`命令仍被工作流使用：${workflows.map(workflow=>workflow.title).join('、')}`,{code:'COMMAND_IN_USE',details:{workflows}});
+      }
+      const effectiveConfig={...latest.config,...config},oldConfig={...project.config,...config};
+      const nextDefinitions=new Map(entries.map(entry=>{const plugin=entry.plugin??entry;return [plugin.id,plugin];}));
+      const changed=new Set(isDeepStrictEqual(presets,project.commandPresets??{})?[]:[COMMANDS_PLUGIN_ID]);
+      const plan=planPluginUpdate(host.definitions,nextDefinitions,oldConfig,effectiveConfig,changed);
+      assertMaintenance(plan,options);
+      const backup=await backupProjectFile(file,latest,'commands');
+      if(plan.affected.length)await host.replace({plugins:entries,config:effectiveConfig,affected:plan.affected});
+      const temp=`${file}.${randomUUID()}.tmp`;
+      try{await writeFile(temp,JSON.stringify(nextProject,null,2));await rename(temp,file);}
+      catch(error){
+        if(plan.affected.length)try{await host.replace({plugins:oldEntries,config:oldConfig,affected:plan.affected});}
+        catch(recovery){host.invalidate();throw new AggregateError([error,recovery],`命令设置保存失败且恢复失败：${error.message}；${recovery.message}`);}
+        throw error;
+      }finally{await rm(temp,{force:true});}
+      for(const key of Object.keys(project))delete project[key];Object.assign(project,nextProject);
+      catalogEntries=nextCatalog;pending=prepared.pending;
+      return {backup,commandPresets:structuredClone(presets),shortcuts:structuredClone(nextProject.shortcuts)};
+    });}finally{busy=false;}
+  }
   function pluginPrivileges(plugin){
     const report=action=>{
       const requirement=resolvePrivilegeRequirement(plugin,action);
@@ -327,14 +466,9 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
   }
   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]});
+      const actions=[...workflowActions(workflow.steps)].filter(action=>action.startsWith(`${id}:`));
+      if(actions.length)refs.push({id:workflow.id,title:workflow.title??workflow.id,actions});
     }
     return refs;
   }
@@ -357,39 +491,51 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
     if(busy || launching || [...runs.values()].some(r=>r.status==='running'))throw new FlowError('请等待当前运行或安装结束');
     busy=true;let candidate,nextRelease;
     try {
-      return await withPluginMutation(projectDir,async()=>{
-      await assertPluginState(projectDir,state);
+      return await withRegistryMutation(async()=>{
+      await assertStates();
+      const targetDir=shared&&operation.remove&&!state.dependencies?.[operation.remove]&&!state.links?.[operation.remove]?projectDir:registryDir;
+      const targetState=targetDir===registryDir?state:localState;
       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(!targetState.dependencies?.[name]&&!targetState.links?.[name])throw new FlowError('此插件来自发行配置，不能在此移除');
+        const dependents=catalogEntries.map(entry=>entry.plugin??entry).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(shared&&targetDir===registryDir){
+          const references=await registryPluginReferences(registryDir,name,{globalPlugins:catalogEntries.filter(entry=>entry.scope==='global').map(entry=>entry.plugin)});
+          if(references.length){const dependencies=references.map(item=>`${item.plugin}（${item.projectDir}）`);throw new FlowError(`插件仍被其他工作区插件依赖：${dependencies.join('、')}`,{code:'PLUGIN_IN_USE',details:{dependencies}});}
+        }
+        const workflows=shared&&targetDir===registryDir?await registryWorkflowReferences(registryDir,name):await findPluginWorkflowReferences(name);
         if(workflows.length&&!options.force)throw new FlowError(`插件 ${name} 仍被工作流引用：${workflows.map(w=>w.id).join('、')}`,{code:'PLUGIN_IN_USE',details:{workflows}});
       }
-      const next=await installGeneration(projectDir,{...operation,state});
-      const nextEntries=[...initial,...next.loaded],activeConfig={...project.config,...config},effectiveConfig={...latest.config,...config};
+      const next=await installGeneration(targetDir,{...operation,sourceDir:projectDir,state:shared&&targetDir===registryDir?{...targetState,global:true}:targetState});
+      const nextLocal=shared?(targetDir===projectDir?next.loaded:localEntries):next.loaded,nextGlobal=shared?(targetDir===registryDir?next.loaded:globalEntries):[];
+      const nextState=targetDir===registryDir?next.state:state;
+      const nextCatalog=entriesWithPresets(mergePluginEntries(initial,nextLocal,nextGlobal,nextState.disabledLegacy,{shared}),latest.commandPresets??{}),activeConfig={...project.config,...config},effectiveConfig={...latest.config,...config};
+      const prepared=preparePluginCatalog(nextCatalog,effectiveConfig),nextEntries=prepared.active;
       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});
+      validateShortcuts(latest.shortcuts??{},{reservedNames:declaredCommands(nextEntries).map(command=>command.name)});
+      const sourceChanges=await changedPluginSources(host.definitions,candidate.definitions,{oldInstallationRoot:targetState.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);
+      nextRelease=await leaseInstallation(targetDir,next.state.root);
       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);}
+      try{await savePluginState(targetDir,next.state,targetState);}
       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;
+      if(targetDir===registryDir){state=next.state;globalEntries=next.loaded;}else{localState=next.state;localEntries=next.loaded;}
+      catalogEntries=nextCatalog;pending=prepared.pending;
       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))){
+      installationLeases.set(path.resolve(next.state.root),nextRelease);nextRelease=null;
+      const usedRoots=[...host.definitions.values(),...catalogEntries];
+      for(const [root,release] of installationLeases)if(root!==path.resolve(next.state.root)&&!usedRoots.some(entry=>entry.root&&path.resolve(entry.root).startsWith(root+path.sep))){
         try{await release();installationLeases.delete(root);}
         catch(error){emitter.emit('event',{type:'plugin.cleanup.warning',message:`旧安装批次租约暂未清理：${error.message}`,root});}
       }

package/manual/packages/core/src/development-watch-worker.js

@@ -34,7 +34,16 @@ async function scan(){
     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));
+      let sources={...state.links};
+      if(options.pluginRegistryDir&&!project.baseBundle&&!project.readOnly&&options.pluginRegistryDir!==options.projectDir){
+        const globalDirectory=path.join(options.pluginRegistryDir,'.flow');
+        addWatch('global-state',globalDirectory,(_event,name)=>{if(name===null||String(name)==='plugins.json'){change(path.join(globalDirectory,'plugins.json'));void scan();}},wanted);
+        const global=await json(path.join(globalDirectory,'plugins.json'),{});
+        for(const id of global.disabledLegacy??[])delete sources[id];
+        sources={...sources,...global.links};
+        for(const id of Object.keys(global.dependencies??{}))delete sources[id];
+      }
+      links=Object.values(sources).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();

package/manual/packages/core/src/development.js

@@ -91,7 +91,7 @@ export async function createDevelopmentSupervisor(options={}){
       })();return closing;
     },
   };
-  const watchOptions={projectDir,configFile:options.configFile?path.resolve(options.configFile):undefined,
+  const watchOptions={projectDir,pluginRegistryDir:options.pluginRegistryDir?path.resolve(options.pluginRegistryDir):undefined,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)=>{

package/manual/packages/core/src/export-snapshot.js

@@ -1,5 +1,6 @@
 import {fileURLToPath} from 'node:url';
 import {FlowError} from '@mytools/sdk';
+import {COMMANDS_PLUGIN_ID} from '@mytools/commands';
 
 function selectedNetwork(network,ids){
   if(!network)return undefined;
@@ -28,6 +29,24 @@ export async function createExportSnapshot({store,host,project},{entries,portabl
   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 usedActions=new Set();
+  const scan=steps=>{for(const step of steps??[]){
+    if(step.action)usedActions.add(step.action);
+    if(step.branch){scan(step.branch.then);scan(step.branch.else);}
+    if(step.parallel)scan(step.parallel.steps);
+  }};
+  for(const workflow of closure.workflows)scan(workflow.steps);
+  const commandPresets=Object.fromEntries(Object.entries(project.commandPresets??{}).filter(([id])=>ids.has(COMMANDS_PLUGIN_ID)&&(portable||usedActions.has(`${COMMANDS_PLUGIN_ID}:${id}`))));
+  const commandAllowed=id=>!id.startsWith(`${COMMANDS_PLUGIN_ID}:`)||Object.hasOwn(commandPresets,id.slice(COMMANDS_PLUGIN_ID.length+1));
+  const commands=new Map(host.commands().map(command=>[command.name,command]));
+  const shortcuts=Object.fromEntries(Object.entries(project.shortcuts??{}).filter(([,target])=>{
+    if(target.action){
+      const action=host.actions.get(target.action);
+      return action&&ids.has(action.plugin)&&commandAllowed(target.action);
+    }
+    const command=commands.get(target.command);
+    return command&&target.plugin===command.plugin&&ids.has(command.plugin)&&(!command.action||commandAllowed(`${command.plugin}:${command.action}`));
+  }));
   const plugins=[...ids].map(id=>{
     const p=host.definitions.get(id);
     if(!p?.root)throw new FlowError('内存中临时定义的插件不能打包，请先安装为标准包');
@@ -37,6 +56,6 @@ export async function createExportSnapshot({store,host,project},{entries,portabl
       ['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},
+  return structuredClone({entries,closure,plugins,project:{environments:project.environments,network:selectedNetwork(project.network,ids),logs:project.logs,baseBundle:project.baseBundle,commandPresets,shortcuts},
     toolRoot:fileURLToPath(new URL('../../fst-cli',import.meta.url))});
 }

package/manual/packages/core/src/plugin-catalog.js

@@ -0,0 +1,42 @@
+import {validate,assertSchema} from '@mytools/sdk/schema';
+import {FlowError} from '@mytools/sdk';
+import {validatePluginDefinitions} from '@mytools/fst-plugin';
+
+export function mergePluginEntries(initial,local,global,disabledLegacy=[],{shared=true}={}){
+  const result=new Map();
+  for(const entry of initial){
+    const plugin=entry.plugin??entry;
+    if(result.has(plugin.id))throw new FlowError(`插件标识重复：${plugin.id}`,{code:'VALIDATION'});
+    result.set(plugin.id,{...('plugin' in entry?entry:{plugin:entry}),scope:'preset'});
+  }
+  for(const entry of local)if(!disabledLegacy.includes(entry.plugin.id)){
+    if(!shared&&result.has(entry.plugin.id))throw new FlowError(`插件标识重复：${entry.plugin.id}`,{code:'VALIDATION'});
+    result.set(entry.plugin.id,{...entry,scope:'workspace'});
+  }
+  for(const entry of global)result.set(entry.plugin.id,{...entry,scope:'global'});
+  return [...result.values()];
+}
+
+export function preparePluginCatalog(entries,config){
+  const pending=new Map();validatePluginDefinitions(entries);
+  for(const entry of entries){
+    const plugin=entry.plugin??entry;
+    if(plugin.config!==undefined)assertSchema(plugin.config,`${plugin.id} 配置`);
+    try{validate(plugin.config,config[plugin.id]??{},`${plugin.id} 配置`);}
+    catch(error){
+      if(entry.scope!=='global'||error.code!=='VALIDATION')throw error;
+      pending.set(plugin.id,{entry,message:error.message});
+    }
+  }
+  // 缺配置的服务提供者暂不启用，相关消费者也等待；无关插件正常装配。
+  let changed;
+  do{
+    changed=false;
+    for(const entry of entries){
+      const plugin=entry.plugin??entry;
+      const missing=Object.keys(plugin.dependencies??{}).filter(id=>pending.has(id));
+      if(!pending.has(plugin.id)&&missing.length){pending.set(plugin.id,{entry,message:`依赖插件尚未配置：${missing.join('、')}`});changed=true;}
+    }
+  }while(changed);
+  return {active:entries.filter(entry=>!pending.has((entry.plugin??entry).id)),pending};
+}

package/manual/packages/core/src/version.js

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

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

@@ -33,6 +33,12 @@ fst 命令入口、交互终端、输入呈现和运行观察。通过公开应
 
 ## 维护与验证
 
+TUI 支持 `!` 系统命令、`/commands` 常用命令注册和 `/shortcuts` 任意插件能力快捷名。主输入框与命令编辑框使用 Shift+Enter / Alt+Enter 换行、Enter 提交；真实多行粘贴保持换行及缩进。使用说明可通过 `fst docs commands` 离线阅读。
+
+运行和步骤附近提示 Ctrl+O，展开后按 schema 字段标题阅读结果；受管进程显示实际程序、参数、目录和原始命令。`/logs` 中按 m 单独格式化阅读输出，j 仍保留原始 JSON。总耗时在执行期间每秒更新，结束或关闭界面后回收刷新计时器。平台声明提示直接显示在 TUI。
+
+`/history` 或 `/tools` → 历史会话恢复输入、反馈与结果，不重跑指令；与已有插件或快捷名 `history` 冲突时保留原入口。通过 `fst-logs/sessions` 在所属工作区保存有界快照与完整追加交互记录，只读包改用可写输出目录。较早的内容分页读取，运行日志仍独立保存并遵循其保留策略。恢复创建当前会话的继续记录，不覆盖来源会话；未提交草稿和配置表单不保存。
+
 本模块负责上述职责的实现、文档与回归；跨模块接口调整需要同时检查生产者与消费者。具体维护人员尚未指定。
 
 在仓库根目录执行：

package/manual/packages/fst-cli/bin/fst.js

@@ -12,13 +12,14 @@ import {listDocumentation,readDocumentation,findDocumentationRoot,exportDocument
 import {collectInstallations} from '@mytools/fst-workspace/installations';
 import {prepareBundleWorkspace} from '@mytools/fst-workspace/bundles';
 import {readJson} from '@mytools/fst-platform/json';
+import {userPluginRegistry} from '@mytools/fst-workspace/registry';
 
 const program=new Command().name('fst').description('Fishtools · 插件式工作流工作台').version(VERSION);
 program.option('--maintenance','维护模式：不启动有状态服务插件');
 program.option('--allow-unverified-privileges','本次允许权限预检结果无法确认的服务启动');
 program.option('--watch','开发模式：监听本地 link 源码，等待业务空闲后重启');
 program.option('--project <directory>','项目目录（默认当前项目或用户工作区）').option('--workspace <directory>','便携包的可写工作区').option('--output <directory>','日志与结果目录').option('--config <file>','插件配置覆盖文件').option('--host <host>','Web 监听地址','127.0.0.1').option('--port <port>','Web 监听端口','8765');
-async function app({management=false,removeInstalled,allowUnknownPrivileges=false}={}){const o=program.opts();return createApplication({projectDir:process.env.FISHTOOLS_DEV_PROJECT??await resolveProject(o.project,o.workspace),outputDir:o.output,maintenance:management||!!o.maintenance,omitInstalledPlugin:removeInstalled,allowUnknownPrivileges:allowUnknownPrivileges||!!o.allowUnverifiedPrivileges,config:o.config?JSON.parse(await readFile(o.config,'utf8')):{}});}
+async function app({management=false,removeInstalled,allowUnknownPrivileges=false}={}){const o=program.opts();return createApplication({projectDir:process.env.FISHTOOLS_DEV_PROJECT??await resolveProject(o.project,o.workspace),pluginRegistryDir:userPluginRegistry(),outputDir:o.output,maintenance:management||!!o.maintenance,omitInstalledPlugin:removeInstalled,allowUnknownPrivileges:allowUnknownPrivileges||!!o.allowUnverifiedPrivileges,config:o.config?JSON.parse(await readFile(o.config,'utf8')):{}});}
 const developmentChild=process.env.FISHTOOLS_DEV_CHILD==='1';
 program.hook('preAction',(_program,command)=>{
   if(!program.opts().watch||developmentChild)return;
@@ -30,7 +31,7 @@ async function watchDevelopment(mode,settings=program.opts()){
   return startDevelopment({projectDir:await resolveProject(settings.project,settings.workspace),entry:fileURLToPath(import.meta.url),
     args:process.argv.slice(2).filter(argument=>argument!=='--watch'),configFile:settings.config,mode,port:Number(settings.port)});
 }
-async function use(fn,options){const a=await app(options);try{for(const warning of a.host.warnings)console.error(`警告：${warning.message}`);return await fn(a);}finally{await a.close();}}
+async function use(fn,options){const a=await app(options);try{if(!options?.terminal)for(const warning of a.host.warnings)console.error(`警告：${warning.message}`);return await fn(a);}finally{await a.close();}}
 program.command('init [directory]').description('创建项目，保留已有配置与工作流').action(async directory=>console.log(`Fishtools 项目：${await initializeProject(path.resolve(directory??process.cwd()))}`));
 program.command('docs [topic]').description('阅读或导出随安装提供的离线文档').option('--path','只打印文档路径').option('--export <directory>','导出完整资料到新目录').action(async(topic,options)=>{
   if(options.export){if(topic||options.path)throw new Error('--export 不可与文档主题或 --path 同用');console.log(await exportDocumentation(options.export));return;}
@@ -57,10 +58,10 @@ program.command('run <id>').option('--input <file>','JSON 输入文件').option(
   const result=cliRunResult(await waitForCliRun(a,run));console.log(JSON.stringify(result.value,null,2));
   process.exitCode=result.exitCode;
 },{allowUnknownPrivileges:!!o.allowUnverifiedPrivileges}));
-const plugin=program.command('plugin').description('管理插件');
+const plugin=program.command('plugin').description('管理用户级全局插件，工作区配置独立');
 plugin.command('list').action(()=>use(a=>console.log(JSON.stringify(a.listPlugins(),null,2))));
 plugin.command('add <source>').action(source=>use(async a=>console.log(JSON.stringify(await a.installPlugin(source),null,2)),{management:true}));
-plugin.command('link <directory>').description('引用本地开发源码，修改后重启 fst 生效').action(directory=>use(async a=>console.log(JSON.stringify(await a.linkPlugin(path.resolve(directory)),null,2)),{management:true}));
+plugin.command('link <directory>').description('全局链接开发源码，修改后重启 fst 生效').action(directory=>use(async a=>console.log(JSON.stringify(await a.linkPlugin(path.resolve(directory)),null,2)),{management:true}));
 plugin.command('remove <name>').option('--force','即使工作流仍引用此插件也继续卸载；不会越过插件依赖与活动 Web 检查').action((name,o)=>use(async a=>console.log(JSON.stringify(await a.removePlugin(name,{force:!!o.force}),null,2)),{management:true,removeInstalled:name}));
 const network=program.command('network').description('查看或保存工作区、插件和动作级代理规则');
 network.command('show').action(()=>use(a=>console.log(JSON.stringify(a.networkPolicy(),null,2))));
@@ -82,7 +83,7 @@ plugin.command('gc').description('预览未引用安装批次；--apply 先备
   const settings=program.opts(),projectDir=await prepareBundleWorkspace(await resolveProject(settings.project,settings.workspace),settings.workspace);
   const project=await readJson(path.join(projectDir,'flow.project.json'),{});
   if(project.readOnly)throw new Error('只读项目不能清理插件批次');
-  console.log(JSON.stringify(await collectInstallations(projectDir,{apply:!!options.apply}),null,2));
+  console.log(JSON.stringify(await collectInstallations(project.baseBundle?projectDir:userPluginRegistry(),{apply:!!options.apply}),null,2));
 });
 const packOptions=command=>command.requiredOption('--target <target>','win32-x64 或 linux-x64-glibc').option('--out <directory>','导出目录','dist').option('--read-only','导出只读精简运行包').option('--environments <file>','环境来源覆盖 JSON').option('--plan','只查看打包资源计划');
 async function pack(a,entries,o,portable=false){
@@ -110,7 +111,7 @@ program.action(async()=>{
   if(!process.stdin.isTTY||!process.stdout.isTTY){program.outputHelp();return;}
   if(developmentChild){const {runDevelopmentChild}=await import('../src/development.js');const a=await app();try{return await runDevelopmentChild(a,{mode:'terminal',webOptions:{host:program.opts().host,port:Number(program.opts().port)}});}catch(error){await a.close();throw error;}}
   const {startTerminal}=await import('../src/terminal/session.js');
-  await use(a=>startTerminal(a,{webOptions:{host:program.opts().host,port:Number(program.opts().port)}}));
+  await use(a=>startTerminal(a,{webOptions:{host:program.opts().host,port:Number(program.opts().port)}}),{terminal:true});
 });
 program.command('web').description('启动可选的 Fishtools Web 工作台').option('--host <host>','监听地址').option('--port <port>','监听端口').action(o=>web({...program.opts(),...o}));
 program.command('doctor').action(()=>use(async a=>{