feihong-code 7.0.0 → 7.2.0

package/dist/web/public/js/api.js

@@ -355,7 +355,16 @@
     }
 
     async function api(path, method = 'GET', body) {
-      const res = await fetch(path, { method, headers: authHeaders(), body: body ? JSON.stringify(body) : undefined });
+      let res;
+      try {
+        res = await fetch(path, { method, headers: authHeaders(), body: body ? JSON.stringify(body) : undefined });
+      } catch (e) {
+        // 网络层失败（Failed to fetch / 连接拒绝 / 超时中断）：标记后端可能已断开
+        if (typeof BackendConn !== 'undefined') BackendConn.markFailure();
+        throw e;
+      }
+      // 请求到达后端并返回响应：若之前处于断连状态，立即恢复
+      if (typeof BackendConn !== 'undefined' && !BackendConn.online) BackendConn.setOnline(true);
       if (!res.ok) {
         const d = await res.json().catch(() => ({}));
         // 401：令牌确实被服务端拒绝，清除并回到登录页。
@@ -380,3 +389,108 @@
     function authHeaders() {
       return state.token ? { 'Authorization': 'Bearer ' + state.token, 'Content-Type': 'application/json' } : { 'Content-Type': 'application/json' };
     }
+
+    /* ========== 后端连接状态监测（心跳 + 断连横幅 + 自动重连） ==========
+     * 解决问题：后端进程崩溃后，前端无感知，用户操作均报 "Failed to fetch" 且不知原因。
+     * 机制：
+     *  1. 每 5s 轮询 /api/health，连续失败 2 次判定后端断开，顶部显示红色横幅。
+     *  2. 断连后自动加快到每 2s 重试，恢复后自动切回 5s 并 toast 提示。
+     *  3. 任意 api() 调用网络失败也会累计失败计数（双保险，不必等下一轮心跳）。
+     *  4. 页面从后台切回 / 网络恢复事件时立即检测一次。
+     */
+    const BackendConn = {
+      online: true,
+      heartbeatTimer: null,
+      reconnectTimer: null,
+      intervalMs: 5000,       // 正常心跳间隔
+      reconnectMs: 2000,       // 断连后重连检测间隔
+      consecutiveFailures: 0,
+      threshold: 2,             // 连续失败 N 次才判定断开（避免瞬时抖动误报）
+      healthTimeoutMs: 3000,    // 单次健康检查超时
+
+      init() {
+        this.startHeartbeat();
+        // 重连按钮
+        const btn = document.getElementById('backendReconnectBtn');
+        if (btn) btn.addEventListener('click', () => this.reconnect());
+        // 页面从后台切回前台时立即检测
+        document.addEventListener('visibilitychange', () => {
+          if (!document.hidden) this.check();
+        });
+        // 浏览器网络恢复事件
+        window.addEventListener('online', () => this.check());
+      },
+
+      startHeartbeat() {
+        if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = setInterval(() => this.check(), this.intervalMs);
+      },
+
+      async check() {
+        try {
+          const ctrl = new AbortController();
+          const timeout = setTimeout(() => ctrl.abort(), this.healthTimeoutMs);
+          const res = await fetch('/api/health', {
+            method: 'GET',
+            signal: ctrl.signal,
+            cache: 'no-store',
+            headers: { 'Cache-Control': 'no-cache' },
+          });
+          clearTimeout(timeout);
+          if (res.ok) {
+            this.consecutiveFailures = 0;
+            this.setOnline(true);
+          } else {
+            this.markFailure();
+          }
+        } catch (e) {
+          this.markFailure();
+        }
+      },
+
+      /** 累计失败次数，达到阈值则判定断开 */
+      markFailure() {
+        this.consecutiveFailures++;
+        if (this.consecutiveFailures >= this.threshold) {
+          this.setOnline(false);
+        }
+      },
+
+      setOnline(online) {
+        if (this.online === online) return;
+        this.online = online;
+        const banner = document.getElementById('backendOfflineBanner');
+        const text = document.getElementById('backendOfflineText');
+        if (banner) {
+          banner.style.display = online ? 'none' : 'flex';
+        }
+        if (online) {
+          // 恢复：切回正常心跳间隔
+          if (this.reconnectTimer) { clearInterval(this.reconnectTimer); this.reconnectTimer = null; }
+          this.startHeartbeat();
+          try { toast('后端服务已恢复连接'); } catch (e) {}
+        } else {
+          // 断开：停止正常心跳，加快重连检测
+          if (this.heartbeatTimer) { clearInterval(this.heartbeatTimer); this.heartbeatTimer = null; }
+          if (!this.reconnectTimer) {
+            this.reconnectTimer = setInterval(() => this.check(), this.reconnectMs);
+          }
+          if (text) text.textContent = '后端服务已断开，正在自动重连…';
+        }
+      },
+
+      /** 手动触发重连：重置失败计数并立即检测 */
+      reconnect() {
+        const text = document.getElementById('backendOfflineText');
+        if (text) text.textContent = '正在重连后端服务…';
+        this.consecutiveFailures = 0;
+        this.check();
+      },
+    };
+
+    // 页面加载完成后启动心跳监测
+    if (document.readyState === 'loading') {
+      document.addEventListener('DOMContentLoaded', () => BackendConn.init());
+    } else {
+      BackendConn.init();
+    }

package/dist/web/public/js/mock-api.js

@@ -0,0 +1,234 @@
+/**
+ * 飞虹 Code - 安卓版 Mock API 层 (mock-api.js)
+ *
+ * 在 Android WebView 中无本地 Node.js 后端时提供离线演示数据。
+ * 通过拦截 window.fetch 对 /api/ 请求返回本地模拟数据，保证 UI 完整可用。
+ *
+ * 模式：
+ *  - 默认：本地 Mock 模式（离线演示）
+ *  - 可在设置中填写服务器地址切换为远程模式（真实调用后端）
+ *
+ * 此文件在 api.js 之前加载，必须在最顶部定义，保证 window.fetch 被优先拦截。
+ */
+(function () {
+  if (window.__feihongMockInstalled) return;
+  window.__feihongMockInstalled = true;
+
+  // ========== 远程服务器配置 ==========
+  var REMOTE_KEY = 'fhcode.remote.base';
+  function getRemoteBase() {
+    try { return localStorage.getItem(REMOTE_KEY) || ''; } catch (e) { return ''; }
+  }
+
+  // ========== Mock 数据 ==========
+  var MODELS = [
+    { id: 'deepseek-chat', name: 'DeepSeek Chat', provider: 'deepseek', reasoning: false, enabled: true },
+    { id: 'deepseek-reasoner', name: 'DeepSeek Reasoner', provider: 'deepseek', reasoning: true, enabled: true },
+    { id: 'qwen-max', name: '通义千问 Max', provider: 'qwen', reasoning: false, enabled: true },
+    { id: 'gpt-4o', name: 'GPT-4o', provider: 'openai', reasoning: false, enabled: true }
+  ];
+
+  var SKILLS = [
+    { id: 'code-review', name: '代码审查', desc: '自动审查代码质量与安全', enabled: true },
+    { id: 'test-gen', name: '测试生成', desc: '自动生成单元测试用例', enabled: true },
+    { id: 'doc-gen', name: '文档生成', desc: '自动生成 API 文档', enabled: true },
+    { id: 'refactor', name: '重构专家', desc: '代码重构与优化', enabled: true },
+    { id: 'bug-hunt', name: 'Bug 猎手', desc: '自动定位与修复 Bug', enabled: true }
+  ];
+
+  var OFFICE_CAPS = [
+    { title: '生成周报', icon: '📊', prompt: '帮我生成一份本周工作周报', desc: '自动生成结构化周报' },
+    { title: '写邮件', icon: '✉️', prompt: '帮我写一封商务邮件', desc: '专业邮件撰写' },
+    { title: 'PPT 大纲', icon: '📑', prompt: '帮我生成一份 PPT 大纲', desc: '结构化演示大纲' },
+    { title: '会议纪要', icon: '📝', prompt: '帮我整理会议纪要', desc: '智能会议纪要' },
+    { title: '数据分析', icon: '📈', prompt: '帮我分析这份数据', desc: '数据洞察分析' },
+    { title: '翻译文档', icon: '🌐', prompt: '帮我翻译这段内容', desc: '中英互译' }
+  ];
+
+  var ROLES = [
+    { id: 'architect', name: '架构师', icon: '🏛️', desc: '系统设计、技术选型' },
+    { id: 'developer', name: '开发者', icon: '💻', desc: '代码实现' },
+    { id: 'tester', name: '测试工程师', icon: '🧪', desc: '测试用例设计' },
+    { id: 'reviewer', name: '评审员', icon: '🔍', desc: '代码审查' }
+  ];
+
+  var CUSTOM_AGENTS = [
+    { id: 'builtin-代码审查员', name: '代码审查员', category: 'review', desc: '专业代码审查，安全漏洞/性能/最佳实践', useCount: 12 },
+    { id: 'builtin-测试工程师', name: '测试工程师', category: 'testing', desc: '自动生成测试用例', useCount: 8 },
+    { id: 'builtin-文档生成器', name: '文档生成器', category: 'documentation', desc: '自动生成代码文档', useCount: 6 },
+    { id: 'builtin-重构专家', name: '重构专家', category: 'refactoring', desc: '代码重构优化', useCount: 9 },
+    { id: 'builtin-Bug猎手', name: 'Bug 猎手', category: 'debugging', desc: 'Bug 分析和修复', useCount: 15 }
+  ];
+
+  // ========== Mock 路由处理 ==========
+  function handleMock(path, method, body) {
+    var p = path.split('?')[0];
+    var lower = p.toLowerCase();
+
+    // 健康检查
+    if (lower === '/api/health') {
+      return ok({ product: '飞虹 Code', version: '7.0.0', enterprise: true, signature: '安卓版 · 离线演示模式', mode: 'mock', time: new Date().toISOString() });
+    }
+
+    // 模型
+    if (lower === '/api/models' && method === 'GET') return ok({ models: MODELS });
+    if (lower === '/api/models' && method === 'POST') {
+      var m = body || {};
+      MODELS.push({ id: 'custom-' + Date.now(), name: m.name || '自定义模型', provider: 'custom', reasoning: !!m.reasoning, enabled: true });
+      return ok({ model: MODELS[MODELS.length - 1] });
+    }
+
+    // 技能
+    if (lower === '/api/skills/installed') return ok({ skills: SKILLS });
+    if (lower === '/api/skills' ) return ok({ skills: SKILLS });
+
+    // 办公能力
+    if (lower === '/api/office/capabilities') return ok({ capabilities: OFFICE_CAPS });
+
+    // 多智能体角色
+    if (lower === '/api/multi-agent/roles') return ok({ roles: ROLES });
+    if (lower === '/api/multi-agent/run') {
+      var goal = (body && body.goal) || '完成任务';
+      return ok({
+        goal: goal,
+        rounds: [
+          { role: '架构师', output: '设计方案：采用模块化架构，定义清晰接口边界。\n- 技术选型：TypeScript + 分层设计\n- 接口定义：RESTful API\n- 错误处理：统一异常捕获', score: 85 },
+          { role: '开发者', output: '代码实现：完成核心模块开发。\n- 实现业务逻辑\n- 编写单元测试\n- 补充类型定义', score: 88 }
+        ],
+        finalVerdict: '通过',
+        qualityScore: 86,
+        issues: []
+      });
+    }
+
+    // 自定义 Agent
+    if (lower === '/api/custom-agents') return ok({ agents: CUSTOM_AGENTS });
+    if (lower.indexOf('/api/custom-agents/match') === 0) {
+      var inp = (body && body.input) || '';
+      var matched = CUSTOM_AGENTS.filter(function (a) {
+        return !inp || a.name.indexOf(inp) !== -1 || a.desc.indexOf(inp) !== -1;
+      }).slice(0, 3);
+      return ok({ agents: matched });
+    }
+    if (lower.indexOf('/api/custom-agents/') === 0 && method === 'GET') {
+      var id = p.split('/').pop();
+      var agent = CUSTOM_AGENTS.find(function (a) { return a.id === id; });
+      return ok({ agent: agent || CUSTOM_AGENTS[0] });
+    }
+
+    // 事件驱动
+    if (lower === '/api/event-driven/config') return ok({ config: { enabled: true, tasks: [] } });
+    if (lower === '/api/event-driven/events') return ok({ events: [] });
+    if (lower === '/api/event-driven/cron') return ok({ tasks: [] });
+
+    // 记忆
+    if (lower === '/api/memory/history') return ok({ history: [] });
+    if (lower === '/api/memory/long') return ok({ content: '这是长期记忆区域。在安卓离线演示模式下，长期记忆功能暂未启用。\n\n连接远程服务器后，将自动同步您的记忆数据。' });
+    if (lower === '/api/memory/short') return ok({ content: '当天暂无记录' });
+    if (lower === '/api/memory/stats') return ok({ shortTermFiles: 0, longTermNotes: 0, lastSummarize: '暂无' });
+
+    // 补全
+    if (lower.indexOf('/api/completion') === 0) {
+      return ok({
+        completions: [
+          { text: 'async function handleRequest(req, res) {\n  try {\n    const data = await fetchData(req.params.id);\n    res.json({ ok: true, data });\n  } catch (e) {\n    res.status(500).json({ ok: false, error: e.message });\n  }\n}', score: 0.95 },
+          { text: 'function validate(input) {\n  if (!input) throw new Error("input is required");\n  return input.trim();\n}', score: 0.88 }
+        ]
+      });
+    }
+
+    // 会话 / 统计
+    if (lower === '/api/sessions') return ok({ sessions: [] });
+    if (lower.indexOf('/api/team') === 0) {
+      if (method === 'GET') return ok({ members: [], tasks: [] });
+      return ok({ ok: true });
+    }
+    if (lower.indexOf('/api/git') === 0) {
+      if (method === 'GET') return ok({ branches: [], status: { clean: true }, commits: [] });
+      return ok({ ok: true });
+    }
+    if (lower.indexOf('/api/design-to-code') === 0) {
+      return ok({ ok: true, html: '<!-- 安卓演示模式：设计稿转代码需连接远程服务器 -->' });
+    }
+    if (lower.indexOf('/api/solo') === 0) {
+      return ok({ ok: true, status: 'idle' });
+    }
+    if (lower.indexOf('/api/mcp') === 0) {
+      return ok({ servers: [] });
+    }
+
+    // 登录/认证
+    if (lower === '/api/auth/login' || lower === '/api/login') {
+      return ok({ token: 'mock-token-' + Date.now(), user: { name: '演示用户', role: 'admin' } });
+    }
+
+    // 对话 / Agent 执行
+    if (lower.indexOf('/api/chat') === 0 || lower.indexOf('/api/agent') === 0 || lower.indexOf('/api/task') === 0) {
+      var prompt = (body && (body.prompt || body.message || body.goal || body.input)) || '任务';
+      return ok({
+        id: 'mock-' + Date.now(),
+        answer: '【安卓离线演示】\n\n已收到任务：' + prompt + '\n\n当前处于离线演示模式，AI 生成能力需要连接远程飞虹 Code 服务器。\n\n在「设置」中填写服务器地址后，即可使用完整 AI 能力（多模型路由、Agent 执行、代码补全等）。',
+        done: true
+      });
+    }
+
+    // 配置
+    if (lower === '/api/config' || lower === '/api/settings') {
+      return ok({ config: { mode: 'mock', remoteBase: getRemoteBase(), version: '7.0.0' } });
+    }
+
+    // 兜底：GET 返回空结构，其他返回 ok
+    if (method === 'GET') return ok({ ok: true, data: [] });
+    return ok({ ok: true, data: [] });
+  }
+
+  function ok(data) {
+    return {
+      ok: true,
+      status: 200,
+      json: function () { return Promise.resolve(data); },
+      text: function () { return Promise.resolve(JSON.stringify(data)); }
+    };
+  }
+
+  // ========== 拦截 fetch ==========
+  var originalFetch = window.fetch;
+  window.fetch = function (input, init) {
+    var url = typeof input === 'string' ? input : input.url;
+    var method = ((init && init.method) || (input && input.method) || 'GET').toUpperCase();
+
+    // 远程模式：配置了服务器地址且请求的是 /api/ 相对路径时，转发到远程
+    var remoteBase = getRemoteBase();
+    if (remoteBase && url.indexOf('/api/') === 0) {
+      var remoteUrl = remoteBase.replace(/\/$/, '') + url;
+      return originalFetch.call(window, remoteUrl, init).catch(function (e) {
+        // 远程失败时降级到 Mock
+        return Promise.resolve(handleMock(url, method, parseBody(init)));
+      });
+    }
+
+    // Mock 模式：拦截 /api/ 请求
+    if (url.indexOf('/api/') === 0) {
+      return Promise.resolve(handleMock(url, method, parseBody(init)));
+    }
+
+    // 其他请求（静态资源等）正常处理
+    return originalFetch.apply(window, arguments);
+  };
+
+  function parseBody(init) {
+    if (!init || !init.body) return null;
+    try { return JSON.parse(init.body); } catch (e) { return null; }
+  }
+
+  // ========== 暴露远程模式切换接口 ==========
+  window.FeiHongApp = window.FeiHongApp || {};
+  window.FeiHongApp.setRemote = function (base) {
+    try { localStorage.setItem(REMOTE_KEY, base || ''); } catch (e) {}
+    return base;
+  };
+  window.FeiHongApp.getRemote = function () { return getRemoteBase(); };
+  window.FeiHongApp.isMock = function () { return !getRemoteBase(); };
+
+  console.log('[MockAPI] 飞虹 Code 安卓离线 Mock 层已加载 (mode=' + (getRemoteBase() ? 'remote' : 'mock') + ')');
+})();

package/dist/web/public/js/monaco-editor.js

@@ -0,0 +1,203 @@
+/**
+ * 飞虹 Code - Monaco Editor 封装模块
+ * VSCode 同款编辑器内核，提供语法高亮、智能补全、内联 ghost text 等能力
+ *
+ * 依赖：index.html 中已加载 vendor/monaco/vs/loader.js（AMD loader）
+ */
+(function (global) {
+  'use strict';
+
+  let monacoInstance = null;
+  let initPromise = null;
+  const editors = new Map(); // containerId -> editor instance
+  let inlineCompletionProvider = null;
+  let completionItemProvider = null;
+
+  /** 根据文件扩展名推断 Monaco language id */
+  function detectLanguage(filePath) {
+    const ext = filePath.split('.').pop().toLowerCase();
+    const map = {
+      ts: 'typescript', tsx: 'typescript', js: 'javascript', jsx: 'javascript',
+      json: 'json', md: 'markdown', html: 'html', css: 'css', scss: 'scss',
+      less: 'less', py: 'python', java: 'java', c: 'c', cpp: 'cpp', h: 'cpp',
+      cs: 'csharp', go: 'go', rs: 'rust', php: 'php', rb: 'ruby', swift: 'swift',
+      kt: 'kotlin', scala: 'scala', sh: 'shell', bash: 'shell', zsh: 'shell',
+      sql: 'sql', yaml: 'yaml', yml: 'yaml', xml: 'xml', vue: 'html', svelte: 'html',
+      proto: 'protobuf', dockerfile: 'dockerfile', toml: 'ini', ini: 'ini',
+    };
+    if (filePath.toLowerCase().endsWith('dockerfile')) return 'dockerfile';
+    return map[ext] || 'plaintext';
+  }
+
+  /** 初始化 Monaco（只执行一次，返回 Promise） */
+  function initMonaco() {
+    if (monacoInstance) return Promise.resolve(monacoInstance);
+    if (initPromise) return initPromise;
+
+    initPromise = new Promise((resolve, reject) => {
+      if (typeof global.require === 'undefined') {
+        reject(new Error('Monaco loader.js 未加载，请检查 vendor/monaco/vs/loader.js'));
+        return;
+      }
+      global.require.config({ paths: { vs: 'vendor/monaco/vs' } });
+      global.require(['vs/editor/editor.main'], function () {
+        monacoInstance = global.monaco;
+        // 配置默认主题（跟随系统深色/浅色）
+        const isDark = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;
+        monacoInstance.editor.setTheme(isDark ? 'vs-dark' : 'vs');
+        resolve(monacoInstance);
+      }, reject);
+    });
+    return initPromise;
+  }
+
+  /**
+   * 在指定容器中创建 Monaco 编辑器
+   * @param {HTMLElement|string} container - 容器元素或 ID
+   * @param {string} value - 初始内容
+   * @param {string} filePath - 文件路径（用于推断语言）
+   * @param {object} options - 额外选项
+   * @returns {Promise<monaco.editor.IStandaloneCodeEditor>}
+   */
+  async function createEditor(container, value, filePath, options = {}) {
+    const monaco = await initMonaco();
+    const el = typeof container === 'string' ? document.getElementById(container) : container;
+    if (!el) throw new Error('编辑器容器不存在: ' + container);
+
+    // 如果该容器已有编辑器，先销毁
+    const existing = editors.get(el.id || container);
+    if (existing) {
+      existing.dispose();
+      editors.delete(el.id || container);
+    }
+
+    const language = detectLanguage(filePath);
+    const editor = monaco.editor.create(el, {
+      value: value || '',
+      language: language,
+      theme: undefined, // 使用全局主题
+      automaticLayout: true,
+      fontSize: 13,
+      lineNumbers: 'on',
+      minimap: { enabled: true },
+      scrollBeyondLastLine: false,
+      wordWrap: 'on',
+      bracketPairColorization: { enabled: true },
+      guides: { bracketPairs: true, indentation: true },
+      tabSize: 2,
+      renderWhitespace: 'selection',
+      smoothScrolling: true,
+      cursorBlinking: 'smooth',
+      // P0-1: 启用内联补全（ghost text，Tab 接受）
+      inlineSuggest: { enabled: true, showToolbar: 'always' },
+      // 启用快速建议（输入时自动触发补全弹窗）
+      quickSuggestions: { other: true, comments: false, strings: true },
+      quickSuggestionsDelay: 200,
+      ...options,
+    });
+
+    const key = el.id || container;
+    editors.set(key, editor);
+    return editor;
+  }
+
+  /** 获取编辑器实例 */
+  function getEditor(container) {
+    const key = typeof container === 'string' ? container : container.id;
+    return editors.get(key);
+  }
+
+  /** 销毁编辑器 */
+  function disposeEditor(container) {
+    const key = typeof container === 'string' ? container : container.id;
+    const editor = editors.get(key);
+    if (editor) {
+      editor.dispose();
+      editors.delete(key);
+    }
+  }
+
+  /**
+   * 注册内联补全 Provider（ghost text，Tab 接受）
+   * @param {function} fetchFn - 异步补全函数，参数 {filePath, content, offset}，返回 {text: string}
+   */
+  function registerInlineCompletions(fetchFn) {
+    initMonaco().then((monaco) => {
+      if (inlineCompletionProvider) {
+        inlineCompletionProvider.dispose();
+      }
+      inlineCompletionProvider = monaco.languages.registerInlineCompletionsProvider('*', {
+        provideInlineCompletions: async function (model, position, context, token) {
+          try {
+            const filePath = model.uri.path || 'untitled';
+            const content = model.getValue();
+            const offset = model.getOffsetAt(position);
+            const result = await fetchFn({ filePath, content, offset, token });
+            if (!result || !result.text) return { items: [] };
+            const item = {
+              range: new monaco.Range(position.lineNumber, position.column, position.lineNumber, position.column),
+              insertText: result.text,
+              filterText: result.text.slice(0, 20),
+            };
+            return { items: [item] };
+          } catch (e) {
+            return { items: [] };
+          }
+        },
+        freeInlineCompletions: function () {},
+      });
+    });
+  }
+
+  /**
+   * 注册补全项 Provider（Ctrl+Space 触发弹窗，↑↓选择，Enter接受）
+   * @param {function} fetchFn - 异步补全函数，参数 {filePath, content, offset, prefix}，返回数组 [{label, kind, insertText, detail}]
+   */
+  function registerCompletionItems(fetchFn) {
+    initMonaco().then((monaco) => {
+      if (completionItemProvider) {
+        completionItemProvider.dispose();
+      }
+      completionItemProvider = monaco.languages.registerCompletionItemProvider('*', {
+        triggerCharacters: ['.', '(', ',', ' '],
+        provideCompletionItems: async function (model, position, context, token) {
+          try {
+            const filePath = model.uri.path || 'untitled';
+            const content = model.getValue();
+            const offset = model.getOffsetAt(position);
+            const word = model.getWordUntilPosition(position);
+            const prefix = word.word || '';
+            const suggestions = await fetchFn({ filePath, content, offset, prefix, token });
+            if (!Array.isArray(suggestions) || !suggestions.length) return { suggestions: [] };
+            const range = new monaco.Range(
+              position.lineNumber, word.startColumn,
+              position.lineNumber, position.column
+            );
+            return {
+              suggestions: suggestions.map((s) => ({
+                label: s.label || s.insertText || '',
+                kind: monaco.languages.CompletionItemKind[s.kind] || monaco.languages.CompletionItemKind.Text,
+                insertText: s.insertText || '',
+                detail: s.detail || '',
+                range: range,
+              })),
+            };
+          } catch (e) {
+            return { suggestions: [] };
+          }
+        },
+      });
+    });
+  }
+
+  /** 暴露全局 API */
+  global.FHMonaco = {
+    init: initMonaco,
+    createEditor: createEditor,
+    getEditor: getEditor,
+    disposeEditor: disposeEditor,
+    detectLanguage: detectLanguage,
+    registerInlineCompletions: registerInlineCompletions,
+    registerCompletionItems: registerCompletionItems,
+  };
+})(window);