sqlseed-web 0.2.4__py3-none-any.whl

sqlseed_web/static/js/workbench/guidance.js

@@ -0,0 +1,29 @@
+// Guidance describes evidence already available to the workbench. It never
+// changes rules, starts AI, or grants permission to write data.
+export function nextStep(model, previews = new Map()) {
+  const tables=model.document.tables;
+  const scope=`已选 ${tables.length} 张表 · 计划生成 ${tables.reduce((sum,table)=>sum+table.count,0)} 行`;
+  if(!tables.length)return {scope:'尚未选择生成表',title:'先选择要生成的表',body:'在左侧勾选本次需要生成数据的表，再设置每张表的生成数量。浏览表名不会加入生成范围。',action:'select',label:'选择生成表'};
+  if(model.errors.size)return {scope,title:'先修正无效输入',body:[...model.errors.values()].join('；'),action:'edit',label:'检查输入'};
+  if(model.check?.issues?.some(issue=>issue.severity==='error'))return {scope,title:'先处理检查发现的问题',body:'查看具体字段、引用来源和处理建议，修正后重新检查。',action:'check',label:'查看检查问题'};
+  const current=new Set(tables.filter(table=>{
+    const preview=previews.get(table.name);
+    return preview?.epoch===model.epoch && preview.result.ok && preview.result.preview_complete!==false
+      && Array.isArray(preview.result.samples?.[table.name]) && preview.result.samples[table.name].length>0;
+  }).map(table=>table.name));
+  if(current.size===tables.length)return {scope,title:`已预览所选 ${tables.length} 张表`,body:'请确认样例符合业务要求。下一步查看写入计划，系统会重新检查依赖；确认后才写入数据库。',action:'generate',label:'查看生成计划'};
+  const applied=model.aiApplied?.epoch===model.epoch?model.aiApplied.targets.filter(item=>tables.some(table=>table.name===item.table)):[];
+  if(applied.some(item=>!current.has(item.table)))return {scope,title:`已应用 ${applied.length} 条 AI 建议，请预览`,body:'建议已进入当前生成配置。请查看实际样例，核对业务要求是否都已覆盖；AI 建议不代表数据库写入一定成功。',action:'preview',label:'预览 AI 调整结果'};
+  if(current.size)return {scope,title:`已预览 ${current.size}/${tables.length} 张所选表`,body:'可以继续查看其余表的样例，再核对写入计划。预览不会写入数据库。',action:'preview',label:'预览已选范围'};
+  if(tables.some(table=>previews.get(table.name)?.epoch<model.epoch))return {scope,title:'配置已变化，请重新预览',body:'已有样例对应之前的规则或生成范围。重新查看样例，确认本次配置的实际效果。',action:'preview',label:'重新预览'};
+  if(tables.some(table=>previews.get(table.name)?.epoch===model.epoch))return {scope,title:'部分样例暂不可用',body:'查看预览中的具体原因；依赖尚未生成的父键时，可先核对依赖计划。',action:'check',label:'检查依赖'};
+  return {scope,title:'先确认规则是否符合业务',body:'检查数值范围、日期和字段含义。可以手动调整，也可让 AI 根据业务说明建议规则；已有配置合适时可直接预览。',action:'preview',label:'直接预览'};
+}
+
+export function guideAIState(config) {
+  if(config?.availability_status==='import_error')return {label:'检查 AI 插件',status:'插件加载异常 · 规则建议不可用'};
+  if(config?.available===false)return {label:'安装 AI 扩展',status:'AI 扩展未安装 · 规则建议不可用'};
+  if(config?.available && !config.ready)return {label:'配置 AI 助手',status:'可选 · 需配置服务'};
+  if(config?.ready)return {label:'用 AI 建议规则',status:'可选 · 服务配置已填写'};
+  return {label:'查看 AI 助手',status:'可选 · 状态待确认'};
+}

sqlseed_web/static/js/workbench/model.js

@@ -0,0 +1,124 @@
+// 唯一可执行文档；视图和未勾选表的编辑草稿单独持久化。
+const copy = value => structuredClone(value);
+
+export class WorkbenchDocument {
+  constructor(schema, document) {
+    this.schema = schema;
+    this.document = copy(document || {provider:schema.provider, locale:schema.locale, tables:[]});
+    this.view = {table:schema.tables[0]?.name || '', page:'fields', graphMode:'all', tableDrafts:{}};
+    this.errors = new Map();
+    this.epoch = 0;
+    this.savedEpoch = -1;
+    this.lifecycleVersion = 0;
+    this.saved = null;
+    this.check = null;
+    this.samples = {};
+    this.previewIssues = [];
+  }
+  get dirty() { return this.epoch !== this.savedEpoch; }
+  touch() { this.epoch++; this.check = null; this.samples = {}; this.previewIssues = []; }
+  restoreView(view) {
+    this.view = {...this.view, ...copy(view || {})};
+    if (!this.schema.tables.some(t=>t.name===this.view.table)) this.view.table=this.schema.tables[0]?.name || '';
+  }
+  selectTable(name, page='fields') {
+    this.view.table = name;
+    this.view.page = page;
+    if (page==='graph') this.view.graphMode='paths';
+  }
+  table(name) {
+    return this.document.tables.find(t=>t.name===name)
+      || this.view.tableDrafts[name] || {name,count:100,columns:[]};
+  }
+  selected(name) { return this.document.tables.some(t=>t.name===name); }
+  putTable(table) {
+    const index=this.document.tables.findIndex(t=>t.name===table.name);
+    if(index>=0) this.document.tables[index]=copy(table);
+    else this.view.tableDrafts[table.name]=copy(table);
+    this.touch();
+  }
+  toggleTable(name,selected) {
+    if(this.selected(name)===selected) return;
+    const table=copy(this.table(name));
+    this.document.tables=this.document.tables.filter(t=>t.name!==name);
+    if(selected) { this.document.tables.push(table); delete this.view.tableDrafts[name]; }
+    else this.view.tableDrafts[name]=table;
+    this.touch();
+  }
+  setCount(name,text) {
+    const key=`count:${name}`;
+    if(!/^\d+$/.test(String(text)) || !Number.isSafeInteger(Number(text)) || Number(text)<1) {
+      this.setError(key,'生成数量必须是大于 0 的整数'); return false;
+    }
+    this.errors.delete(key);
+    this.putTable({...this.table(name),count:Number(text)});
+    return true;
+  }
+  setError(key,error) {
+    if(error) this.errors.set(key,error); else this.errors.delete(key);
+    this.touch();
+  }
+  setColumn(tableName,column,config) {
+    const table=copy(this.table(tableName));
+    table.columns=(table.columns || []).filter(c=>c.name!==column);
+    if(config) table.columns.push({...copy(config),name:column});
+    this.errors.delete(`column:${tableName}.${column}`);
+    this.putTable(table);
+  }
+  applyPatches(patches) {
+    const tables=copy(this.document.tables), drafts=copy(this.view.tableDrafts), seen=new Set();
+    for(const patch of patches) {
+      const key=`${patch.table}.${patch.column}`;
+      if(seen.has(key) || !this.schema.tables.find(t=>t.name===patch.table)?.columns?.some(c=>c.name===patch.column))
+        throw new Error('建议字段已失效或重复，请重新分析');
+      seen.add(key);
+      const index=tables.findIndex(t=>t.name===patch.table);
+      const table=copy(index>=0?tables[index]:drafts[patch.table] || this.table(patch.table));
+      table.columns=(table.columns || []).filter(c=>c.name!==patch.column);
+      if(patch.after)table.columns.push({...copy(patch.after),name:patch.column});
+      if(index>=0)tables[index]=table;else drafts[patch.table]=table;
+    }
+    this.document.tables=tables;this.view.tableDrafts=drafts;
+    for(const key of seen)this.errors.delete(`column:${key}`);
+    if(patches.length)this.touch();
+  }
+  rule(tableName,column) {
+    const override=this.table(tableName).columns?.find(c=>c.name===column);
+    if(override) return copy(override);
+    const inferred=copy(this.check?.effective_rules?.[tableName]?.[column]
+      || this.schema.tables.find(t=>t.name===tableName)?.mapping?.[column] || {});
+    // Reflected/resolved specs may contain sampled parent values. They are
+    // runtime evidence, not editable generator parameters or saved rules.
+    if(inferred.params) inferred.params=Object.fromEntries(Object.entries(inferred.params).filter(([key])=>!key.startsWith('_')));
+    return inferred;
+  }
+  replaceDocument(document) {
+    if('url' in document || 'db_path' in document) throw new Error('连接由当前工作台绑定，文档不能包含连接地址');
+    this.document=copy(document);
+    this.view.tableDrafts={};
+    this.errors.clear();
+    this.touch();
+  }
+  payload(name) {
+    if(this.errors.size) throw new Error([...this.errors.values()].join('；'));
+    return {name,document:copy(this.document),schema_hash:this.schema.schema_hash,view_state:copy(this.view)};
+  }
+  markSaved(saved,epoch) { this.saved=copy(saved); this.savedEpoch=epoch; }
+  // Keep legacy direct callers' full-result behavior; session callers explicitly
+  // distinguish validation from preview, including empty or failed previews.
+  acceptCheck(result,epoch,preview=true) {
+    if(epoch!==this.epoch || this.errors.size) return false;
+    this.check={...copy(result),epoch};
+    if(preview) this.acceptPreview(result,epoch);
+    return true;
+  }
+  acceptPreview(result,epoch) {
+    if(epoch!==this.epoch || this.errors.size) return false;
+    this.samples=copy(result.samples || {});
+    this.previewIssues=copy(result.issues || []);
+    return true;
+  }
+  canRun() {
+    return !!(this.saved && !this.dirty && !this.errors.size && this.check?.ok && this.check.epoch===this.epoch);
+  }
+}

sqlseed_web/static/js/workbench/plugin-management.js

@@ -0,0 +1,512 @@
+import { h, api } from '../api.js';
+import { button, modal } from './ui.js';
+const prefix = '/api/settings/plugins';
+const managed = new Set(['ai', 'cli', 'mcp', 'mimesis']);
+export function componentImpact(id) {
+  return {
+    ai: 'AI 规则建议与分析不可用；手动配置、预览和生成数据仍可使用。',
+    cli: '终端 sqlseed 命令不可用；网页中的手动配置、预览和生成数据仍可使用。',
+    mcp: 'MCP 客户端调用 sqlseed 的功能不可用；网页工作台仍可使用。',
+    mimesis: '使用 Mimesis 的配置暂时无法预览或生成数据；请重新安装，或主动改用其他可用引擎。'
+  }[id] || '';
+}
+export function createPluginManagement({
+  onChange = () => {},
+  onMode = () => {},
+  onRestored = async () => {},
+  initialEnabled = false
+}) {
+  let active = true,
+    version = 0,
+    info = {
+      enabled: initialEnabled
+    },
+    pending = false,
+    error = '',
+    uncertain = false;
+  let task = null,
+    taskError = '',
+    polling = false,
+    timer = null,
+    review = null,
+    reconnects = 0,
+    generation = null,
+    syncing = false;
+  const controllers = new Set();
+  const el = h('section', {
+    class: 'settings-management',
+    'aria-label': '插件管理'
+  }, h('p', {}, '正在读取插件管理状态…'));
+  const current = expected => active && expected === version;
+  const automatic = () => info?.automatic_lifecycle === true;
+  const maintenance = () => Boolean(info?.enabled) && !automatic();
+  const busy = () => pending || Boolean(review) || task?.status === 'running';
+  const locked = () => busy() || uncertain || syncing || !info?.token || Boolean(info?.restart_required);
+  async function request(path, body) {
+    const controller = new AbortController();
+    controllers.add(controller);
+    try {
+      return await api(`${prefix}/${path}`, {
+        signal: controller.signal,
+        ...(body ? {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'X-Sqlseed-Management-Token': info.token
+          },
+          body: JSON.stringify(body)
+        } : {})
+      });
+    } finally {
+      controllers.delete(controller);
+    }
+  }
+  function draw() {
+    const outputOpen = Boolean(el.querySelector('[data-plugin-output]')?.open) || task?.status === 'failed';
+    const environmentOpen = Boolean(el.querySelector('[data-plugin-environment]')?.open);
+    function managementAvailabilityHint() {
+      if (automatic()) {
+        return info.reason || '按需安装或卸载可选组件，完成后自动生效。';
+      } else if (maintenance()) {
+        return info.reason || '可在此环境中安装或卸载可选组件。';
+      } else {
+        return '此部署暂不支持网页内管理组件，请联系应用管理员。';
+      }
+    }
+    el.replaceChildren(h('h3', {}, maintenance() ? '插件维护模式' : '组件管理'), h('p', {}, error || managementAvailabilityHint()));
+    if (info?.python_executable) {
+      const environment = h('details', {
+        class: 'settings-management-environment',
+        'data-plugin-environment': ''
+      }, h('summary', {}, '环境信息'), h('p', {
+        class: 'mono'
+      }, info.python_executable));
+      environment.open = environmentOpen;
+      el.append(environment);
+    }
+    if (info?.restart_required && !automatic()) {
+      el.append(h('p', {
+        class: 'settings-management-restart',
+        role: 'status'
+      }, task?.status === 'running' ? '任务结束后，停止 Web 并退出维护模式；重新启动普通模式后验证组件。' : '环境已发生变更。请停止 Web，退出维护模式后重新启动普通模式，再验证组件可用性。'));
+    }
+    if (pending) {
+      el.append(h('p', {
+        class: 'settings-notice',
+        role: 'status'
+      }, '正在处理，请稍候…'));
+    }
+    if (task) {
+      renderTaskProgress();
+    }
+    if (automatic() && info?.phase === 'recovery_failed') {
+      el.append(button('重试恢复服务', recover, {
+        small: true,
+        disabled: busy()
+      }));
+    }
+    if (info?.session_restore?.session_lost) {
+      el.append(h('p', {
+        class: 'settings-management-restart',
+        role: 'status'
+      }, info.session_restore.message || '服务意外退出，原连接和会话密钥需要重新配置。'));
+    }
+    if (info?.session_restore?.failed_connections?.length) {
+      el.append(h('section', {
+        class: 'settings-management-restart',
+        role: 'status'
+      }, h('strong', {}, '部分数据库连接未恢复'), ...info.session_restore.failed_connections.map(item => h('p', {}, item.message || '请检查数据库连接后重新连接。'))));
+    }
+    onChange();
+    function renderTaskProgress() {
+      let state;
+      if (taskError) {
+        if (automatic() && reconnects < 30) {
+          state = '重新连接中';
+        } else {
+          state = '状态暂时未知';
+        }
+      } else {
+        state = {
+          running: '执行中',
+          succeeded: '已完成',
+          failed: '执行失败'
+        }[task.status] || '状态暂时未知';
+      }
+      const progress = h('section', {
+        class: 'settings-plugin-task',
+        'aria-label': '插件任务',
+        'aria-busy': String(task.status === 'running')
+      }, h('h4', {}, `${task.action === 'uninstall' ? '卸载' : '安装'} ${{
+        ai: 'AI',
+        cli: 'CLI',
+        mcp: 'MCP',
+        mimesis: 'Mimesis'
+      }[task.component_id] || task.component_id} · ${state}`), h('p', {
+        role: 'status',
+        'aria-live': 'polite'
+      }, taskError || task.message || state));
+      if (automatic() && task.status === 'running') {
+        progress.append(h('ol', {
+          class: 'settings-plugin-stages',
+          'aria-label': '处理阶段'
+        }, ...[['preparing', '准备'], ['installing', '处理组件'], ['restoring', '恢复服务']].map(([stage, label]) => h('li', {
+          'aria-current': task.stage === stage ? 'step' : 'false'
+        }, label))));
+      }
+      if (task.output?.length) {
+        const output = h('details', {
+          'data-plugin-output': ''
+        }, h('summary', {}, '查看执行输出'), h('pre', {
+          class: 'settings-plugin-output'
+        }, task.output.join('\n')));
+        output.open = outputOpen;
+        progress.append(output);
+      }
+      if (Number.isInteger(task.returncode) && !automatic()) {
+        progress.append(h('p', {
+          class: 'muted'
+        }, `退出码：${task.returncode}`));
+      }
+      if (taskError && (!automatic() || reconnects >= 30)) {
+        progress.append(button('重新读取任务状态', poll, {
+          small: true,
+          disabled: polling
+        }));
+      }
+      el.append(progress);
+    }
+  }
+  async function refresh() {
+    if (!active || pending || review) {
+      return;
+    }
+    const expected = ++version;
+    pending = true;
+    error = '';
+    clearTimeout(timer);
+    polling = false;
+    for (const controller of controllers) {
+      controller.abort();
+    }
+    draw();
+    try {
+      const response = await request('management');
+      if (!current(expected)) {
+        return;
+      }
+      await receiveManagement(response);
+    } catch (error_) {
+      if (!current(expected)) return;
+      error = `无法读取插件管理状态：${error_.message}。可稍后刷新状态。`;
+      if (automatic() && (uncertain || syncing) && ++reconnects < 30) {
+        error = '正在重新连接服务并核对操作结果，不会重复提交。';
+        timer = setTimeout(refresh, 1000);
+      }
+    } finally {
+      if (current(expected)) {
+        pending = false;
+        draw();
+      }
+    }
+  }
+  async function receiveManagement(response) {
+    const nextGeneration = response.automatic_lifecycle ? `${response.instance_id}:${response.service_generation}` : null;
+    const restored = generation !== null && nextGeneration !== generation && response.phase === 'ready';
+    if (nextGeneration !== null) {
+      generation = nextGeneration;
+    }
+    info = response;
+    uncertain = false;
+    syncing = false;
+    error = '';
+    taskError = '';
+    task = null;
+    reconnects = 0;
+    onMode(maintenance());
+    if (response.active_task) {
+      receiveTask(typeof response.active_task === 'string' ? {
+        task_id: response.active_task,
+        status: 'running'
+      } : response.active_task);
+    } else if (automatic() && ['preparing', 'installing', 'restoring'].includes(response.phase)) {
+      syncing = true;
+      timer = setTimeout(refresh, 1000);
+    }
+    if (restored) {
+      await onRestored(response);
+    }
+  }
+  function allowed(id, action) {
+    return active && managed.has(id) && info?.enabled && info.available && !error && Boolean(info.components?.find(value => value.id === id)?.[action === 'install' ? 'can_install' : 'can_uninstall']);
+  }
+  async function prepare(id, action) {
+    if (locked() || !allowed(id, action)) {
+      return;
+    }
+    const expected = version;
+    pending = true;
+    error = '';
+    draw();
+    try {
+      const plan = await request('plan', {
+        component_id: id,
+        action
+      });
+      if (!current(expected)) {
+        return;
+      }
+      if (!plan.plan_id || plan.component_id !== id || plan.action !== action || !Number.isFinite(plan.expires_in) || plan.expires_in <= 0) {
+        throw new Error('服务返回的计划与所选操作不一致，请刷新状态。');
+      }
+      showReview(plan);
+    } catch (error_) {
+      if (current(expected)) error = `无法生成操作计划：${error_.message}`;
+    } finally {
+      if (current(expected)) {
+        pending = false;
+        draw();
+      }
+    }
+  }
+  function showReview(plan) {
+    const operation = plan.action === 'install' ? '安装' : '卸载';
+    const confirmation = {
+      plan,
+      expired: false,
+      expiresAt: Date.now() + plan.expires_in * 1000,
+      dialog: null,
+      timer: null
+    };
+    const dialog = modal(`确认${operation}插件`, {
+      onClose: () => {
+        clearTimeout(confirmation.timer);
+        if (review === confirmation) {
+          review = null;
+        }
+        if (active) {
+          draw();
+        }
+      }
+    });
+    confirmation.dialog = dialog;
+    review = confirmation;
+    const expiry = h('p', {
+      class: 'muted',
+      role: 'status'
+    }, `此计划 ${Math.ceil(plan.expires_in / 60)} 分钟内有效。`);
+    const details = h('dl', {
+      class: 'settings-plugin-plan'
+    }, h('dt', {}, '组件'), h('dd', {
+      class: 'mono'
+    }, plan.distribution), h('dt', {}, '版本'), h('dd', {
+      class: 'mono'
+    }, plan.version || '兼容版本'), h('dt', {}, '目标环境'), h('dd', {
+      class: 'mono'
+    }, info.python_executable || '当前应用环境'));
+    dialog.body.append(h('p', {}, automatic() ? `${operation} ${{
+      ai: 'AI',
+      cli: 'CLI',
+      mcp: 'MCP',
+      mimesis: 'Mimesis'
+    }[plan.component_id] || plan.distribution}` : plan.summary), ...(plan.action === 'uninstall' && componentImpact(plan.component_id) ? [h('p', {
+      class: 'settings-component-impact'
+    }, `卸载后，${componentImpact(plan.component_id)}`)] : []), automatic() ? h('details', {
+      class: 'settings-management-environment'
+    }, h('summary', {}, '技术信息'), details) : details, h('ul', {
+      class: 'settings-plugin-warnings'
+    }, ...(plan.warnings || []).map(warning => h('li', {}, warning))), expiry);
+    const confirm = button(`确认${operation}`, () => execute(confirmation), {
+      primary: true,
+      'data-plugin-confirm': ''
+    });
+    dialog.actions.append(button('取消', dialog.close), confirm);
+    confirmation.timer = setTimeout(() => {
+      if (!active || review !== confirmation) {
+        return;
+      }
+      confirmation.expired = true;
+      confirm.disabled = true;
+      expiry.textContent = '计划已过期。请取消后重新生成并确认计划。';
+    }, plan.expires_in * 1000);
+  }
+  async function execute(confirmation) {
+    if (!active || pending || review !== confirmation || confirmation.expired || Date.now() >= confirmation.expiresAt) {
+      return;
+    }
+    const expected = version;
+    pending = true;
+    error = '';
+    uncertain = true;
+    confirmation.dialog.close();
+    draw();
+    try {
+      const response = await request('execute', {
+        plan_id: confirmation.plan.plan_id
+      });
+      if (!current(expected)) {
+        return;
+      }
+      receiveTask(response);
+      uncertain = false;
+    } catch (error_) {
+      if (current(expected)) {
+        if ([400, 403, 409, 422].includes(error_.status)) {
+          uncertain = false;
+          error = error_.message;
+        } else {
+          error = `提交结果未知：${error_.message}。正在核对后台状态，不会重复提交。`;
+          if (automatic()) timer = setTimeout(refresh, 1000);
+        }
+      }
+    } finally {
+      if (current(expected)) {
+        pending = false;
+        draw();
+      }
+    }
+  }
+  function receiveTask(response) {
+    if (!response?.task_id || !['running', 'succeeded', 'failed'].includes(response.status)) {
+      throw new Error('服务未返回有效任务状态');
+    }
+    task = response;
+    taskError = '';
+    reconnects = 0;
+    info.restart_required ||= Boolean(task.restart_required);
+    clearTimeout(timer);
+    if (task.status === 'running') {
+      timer = setTimeout(poll, 1000);
+    }
+  }
+  async function poll() {
+    if (!active || !task?.task_id || polling) {
+      return;
+    }
+    const expected = version,
+      id = task.task_id;
+    polling = true;
+    clearTimeout(timer);
+    try {
+      const response = await request(`tasks/${encodeURIComponent(id)}`);
+      if (!current(expected) || task?.task_id !== id) {
+        return;
+      }
+      if (response.task_id !== id) {
+        throw new Error('服务返回的任务标识不一致');
+      }
+      receiveTask(response);
+      if (automatic() && response.status !== 'running') {
+        syncing = true;
+        await refresh();
+      }
+    } catch (error_) {
+      showPollingFailure(error_);
+    } finally {
+      if (current(expected)) {
+        polling = false;
+        draw();
+      }
+    }
+    function showPollingFailure(error_) {
+      if (current(expected) && task?.task_id === id) {
+        reconnects++;
+        taskError = automatic() && reconnects < 30 ? '正在重新连接服务，后台操作不会重复提交。' : `状态暂时未知：${error_.message}。任务可能仍在执行，请重新读取状态。`;
+        if (automatic() && reconnects < 30) timer = setTimeout(poll, 1000);
+      }
+    }
+  }
+  async function recover() {
+    if (!active || busy() || !automatic() || info.phase !== 'recovery_failed') {
+      return;
+    }
+    const expected = version;
+    pending = true;
+    error = '';
+    draw();
+    try {
+      const response = await request('recover', {});
+      if (current(expected)) {
+        await receiveManagement(response);
+      }
+    } catch (error_) {
+      if (current(expected)) {
+        error = `恢复结果暂时未知：${error_.message}。正在核对后台状态，不会重复提交。`;
+        uncertain = true;
+        timer = setTimeout(refresh, 1000);
+      }
+    } finally {
+      if (current(expected)) {
+        pending = false;
+        draw();
+      }
+    }
+  }
+  function controls(item) {
+    if (!managed.has(item.id) || !info?.enabled || !info.available) {
+      return null;
+    }
+    const component = info.components?.find(value => value.id === item.id);
+    if (!component) {
+      return null;
+    }
+    let action;
+    if (component.can_install) {
+      action = 'install';
+    } else if (component.can_uninstall) {
+      action = 'uninstall';
+    } else {
+      action = null;
+    }
+    let actionButton;
+    if (action) {
+      actionButton = button(action === 'install' ? '安装' : '卸载', () => {
+        if (actionButton.isConnected) {
+          return prepare(item.id, action);
+        }
+      }, {
+        small: true,
+        disabled: locked() || Boolean(error),
+        'data-plugin-action': action
+      });
+    } else {
+      actionButton = null;
+    }
+    return h('div', {
+      class: 'settings-package-management'
+    }, actionButton, !action && component.reason ? h('span', {
+      class: 'muted'
+    }, component.reason) : null, component.required_by?.length ? h('span', {
+      class: 'muted'
+    }, `依赖此组件：${component.required_by.join('、')}`) : null);
+  }
+  return {
+    el,
+    refresh,
+    controls,
+    get enabled() {
+      return Boolean(info?.enabled);
+    },
+    get automatic() {
+      return automatic();
+    },
+    get maintenance() {
+      return maintenance();
+    },
+    get busy() {
+      return busy();
+    },
+    get refreshBlocked() {
+      return pending || Boolean(review);
+    },
+    destroy() {
+      active = false;
+      version++;
+      clearTimeout(timer);
+      review?.dialog.close();
+      for (const controller of controllers) {
+        controller.abort();
+      }
+    }
+  };
+}