vite-plugin-opencode-assistant 1.0.14 → 1.0.16

package/es/utils/system.d.ts

@@ -1,5 +1,7 @@
-export declare function waitForServer(url: string, timeout?: number): Promise<void>;
+import type { ResultPromise } from "execa";
+export declare function waitForServer(url: string, timeout?: number, process?: ResultPromise): Promise<void>;
 export declare function checkOpenCodeInstalled(): Promise<boolean>;
 export declare function isPortAvailable(port: number, hostname?: string): Promise<boolean>;
 export declare function findAvailablePort(startPort: number, hostname?: string, maxTries?: number): Promise<number>;
 export declare function killOrphanOpenCodeProcesses(): Promise<number>;
+export declare function findGitRoot(startDir: string, maxDepth?: number): string;

package/es/utils/system.js

@@ -19,16 +19,14 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 import { spawn } from "child_process";
+import fs from "fs";
 import http from "http";
 import net from "net";
-import {
-  DEFAULT_HOSTNAME,
-  MAX_PORT_TRIES,
-  SERVER_CHECK_INTERVAL
-} from "@vite-plugin-opencode-assistant/shared";
+import path from "path";
+import { MAX_PORT_TRIES, SERVER_CHECK_INTERVAL } from "@vite-plugin-opencode-assistant/shared";
 import { PerformanceTimer, createLogger } from "@vite-plugin-opencode-assistant/shared";
 const log = createLogger("Utils");
-function waitForServer(url, timeout = 1e4) {
+function waitForServer(url, timeout = 1e4, process2) {
   const timer = new PerformanceTimer("waitForServer", { url, timeout });
   return new Promise((resolve, reject) => {
     const startTime = Date.now();
@@ -36,6 +34,11 @@ function waitForServer(url, timeout = 1e4) {
     const check = () => {
       attempts++;
       log.debug(`Checking server availability (attempt ${attempts})`, { url });
+      if ((process2 == null ? void 0 : process2.exitCode) !== null && (process2 == null ? void 0 : process2.exitCode) !== void 0) {
+        timer.end(`\u274C Process exited with code ${process2.exitCode}`);
+        reject(new Error(`Process exited with code ${process2.exitCode}`));
+        return;
+      }
       const req = http.get(url, (res) => {
         if (res.statusCode && res.statusCode < 500) {
           timer.end(`\u2713 Server ready after ${attempts} attempts`);
@@ -81,8 +84,8 @@ function checkOpenCodeInstalled() {
     });
   });
 }
-function isPortAvailable(_0) {
-  return __async(this, arguments, function* (port, hostname = DEFAULT_HOSTNAME) {
+function isPortAvailable(port, hostname) {
+  return __async(this, null, function* () {
     return new Promise((resolve) => {
       const server = net.createServer();
       server.once("error", (err) => {
@@ -98,8 +101,8 @@ function isPortAvailable(_0) {
     });
   });
 }
-function findAvailablePort(_0) {
-  return __async(this, arguments, function* (startPort, hostname = DEFAULT_HOSTNAME, maxTries = MAX_PORT_TRIES) {
+function findAvailablePort(_0, _1) {
+  return __async(this, arguments, function* (startPort, hostname, maxTries = MAX_PORT_TRIES) {
     const timer = log.timer("findAvailablePort", { startPort, hostname, maxTries });
     log.debug(`Looking for available port starting from ${startPort}`);
     for (let port = startPort; port < startPort + maxTries; port++) {
@@ -181,6 +184,31 @@ function killOrphanProcessesOnWindows(resolve, timer) {
     resolve(0);
   });
 }
+function findGitRoot(startDir, maxDepth = 10) {
+  const timer = log.timer("findGitRoot", { startDir, maxDepth });
+  let currentDir = startDir;
+  let depth = 0;
+  while (depth < maxDepth) {
+    const gitDir = path.join(currentDir, ".git");
+    try {
+      if (fs.existsSync(gitDir)) {
+        timer.end(`\u2713 Found git root at depth ${depth}: ${currentDir}`);
+        return currentDir;
+      }
+    } catch (err) {
+      log.debug(`Error checking .git directory at ${currentDir}`, { error: err.message });
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      log.debug("Reached filesystem root");
+      break;
+    }
+    currentDir = parentDir;
+    depth++;
+  }
+  timer.end(`\u274C No git root found after ${depth} levels, using start directory`);
+  return startDir;
+}
 function killOrphanProcessesOnUnix(resolve, timer) {
   var _a;
   log.debug("Using Unix method to find orphan processes");
@@ -235,6 +263,7 @@ function killOrphanProcessesOnUnix(resolve, timer) {
 export {
   checkOpenCodeInstalled,
   findAvailablePort,
+  findGitRoot,
   isPortAvailable,
   killOrphanOpenCodeProcesses,
   waitForServer

package/lib/client/App.vue.d.ts

@@ -0,0 +1,6 @@
+import type { WidgetOptions } from "@vite-plugin-opencode-assistant/shared";
+type __VLS_Props = {
+    config: Partial<WidgetOptions>;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/client/App.vue.js

@@ -0,0 +1,329 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var App_vue_exports = {};
+__export(App_vue_exports, {
+  default: () => App_vue_default
+});
+module.exports = __toCommonJS(App_vue_exports);
+var import_vue = require("vue");
+var import_vue2 = require("vue");
+var import_components = require("@vite-plugin-opencode-assistant/components");
+var import_useHotkey = require("./composables/useHotkey");
+var import_useSSE = require("./composables/useSSE");
+var import_useSessions = require("./composables/useSessions");
+var import_useTheme = require("./composables/useTheme");
+var import_useSelectedElements = require("./composables/useSelectedElements");
+var import_useServiceStatus = require("./composables/useServiceStatus");
+var import_useContext = require("./composables/useContext");
+var import_LoadingContent_vue = __toESM(require("./components/LoadingContent.vue.js"));
+var import_ChromeWarmupError_vue = __toESM(require("./components/ChromeWarmupError.vue.js"));
+var import_vue3 = require("vue");
+const __vue_sfc__ = /* @__PURE__ */ (0, import_vue.defineComponent)({
+  __name: "App",
+  props: {
+    config: { type: Object, required: true }
+  },
+  setup(__props, { expose: __expose }) {
+    __expose();
+    const props = __props;
+    const open = (0, import_vue2.ref)(false);
+    const selectMode = (0, import_vue2.ref)(false);
+    const sessionListCollapsed = (0, import_vue2.ref)(true);
+    const loading = (0, import_vue2.ref)(false);
+    const widgetRef = (0, import_vue2.ref)(null);
+    const retryingWarmup = (0, import_vue2.ref)(false);
+    const {
+      position = "bottom-right",
+      theme: initialTheme = "auto",
+      open: autoOpen = false,
+      hotkey = "ctrl+k"
+    } = props.config;
+    const widgetPosition = position;
+    const widgetTheme = initialTheme;
+    const showNotification = (msg) => {
+      var _a, _b;
+      (_b = (_a = widgetRef.value) == null ? void 0 : _a.showNotification) == null ? void 0 : _b.call(_a, msg);
+    };
+    const {
+      serviceStatus,
+      chromeMcpFailed,
+      chromeMcpErrorType,
+      chromeMcpErrorMessage,
+      thinking,
+      loadingText,
+      updateStatusFromTask,
+      setStarting,
+      setThinking
+    } = (0, import_useServiceStatus.useServiceStatus)();
+    const {
+      selectedElements,
+      addElement,
+      removeElement,
+      clearElements
+    } = (0, import_useSelectedElements.useSelectedElements)();
+    const {
+      theme,
+      sendThemeToIframe
+    } = (0, import_useTheme.useTheme)(widgetTheme, widgetRef);
+    const {
+      sessions,
+      loadingSessionList,
+      currentSessionId,
+      iframeSrc,
+      iframeLoading,
+      loadSessions,
+      createSession,
+      deleteSession,
+      selectSession
+    } = (0, import_useSessions.useSessions)(showNotification);
+    const { updateContext } = (0, import_useContext.useContext)(serviceStatus, selectedElements);
+    const showSessionListSkeleton = (0, import_vue2.computed)(() => serviceStatus.value === "starting");
+    const computedLoading = (0, import_vue2.computed)(() => {
+      return serviceStatus.value === "starting" || iframeLoading.value;
+    });
+    const retryWarmup = () => __async(null, null, function* () {
+      retryingWarmup.value = true;
+      try {
+        const res = yield fetch("/__opencode_warmup__", { method: "POST" });
+        const data = yield res.json();
+        if (data.success) {
+          chromeMcpFailed.value = false;
+          serviceStatus.value = "ready";
+          showNotification("Chrome DevTools MCP \u8FDE\u63A5\u6210\u529F");
+        } else {
+          if (data.errorType === "AI_TIMEOUT") {
+            showNotification("AI \u54CD\u5E94\u8D85\u65F6\uFF0C\u8BF7\u68C0\u67E5 OpenCode AI \u6A21\u578B\u914D\u7F6E");
+          } else if (data.errorType === "AI_RESPONSE_ERROR") {
+            showNotification("AI \u54CD\u5E94\u9519\u8BEF\uFF0C\u8BF7\u68C0\u67E5 OpenCode AI \u6A21\u578B\u914D\u7F6E");
+          } else if (data.errorType === "CHROME_NOT_CONNECTED") {
+            showNotification("Chrome \u8FDC\u7A0B\u8C03\u8BD5\u672A\u5F00\u542F\uFF0C\u8BF7\u6309\u7167\u63D0\u793A\u64CD\u4F5C");
+          } else {
+            showNotification(data.error || "\u91CD\u8BD5\u5931\u8D25\uFF0C\u8BF7\u786E\u8BA4 Chrome \u8FDC\u7A0B\u8C03\u8BD5\u5DF2\u5F00\u542F");
+          }
+        }
+      } catch (e) {
+        console.error("[OpenCode] Retry warmup failed:", e);
+        showNotification("\u91CD\u8BD5\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5");
+      } finally {
+        retryingWarmup.value = false;
+      }
+    });
+    const { setupSSE } = (0, import_useSSE.useSSE)(
+      (data) => {
+        if (data.isStarted !== void 0 && data.isStarted && serviceStatus.value === "idle") {
+          setStarting();
+        }
+        if (data.task) {
+          updateStatusFromTask(data.task, data.errorType, data.errorMessage);
+        }
+        if (serviceStatus.value !== "idle") {
+          loadSessions();
+        }
+      },
+      (data) => {
+        updateStatusFromTask(data.task, data.errorType, data.errorMessage);
+      },
+      () => clearElements(),
+      () => updateContext(true)
+    );
+    const ensureServicesStarted = () => __async(null, null, function* () {
+      if (serviceStatus.value !== "idle") return true;
+      try {
+        const res = yield fetch("/__opencode_start__");
+        const data = yield res.json();
+        if (data.success) {
+          setStarting();
+          setupSSE();
+          return true;
+        }
+      } catch (e) {
+      }
+      return false;
+    });
+    (0, import_useHotkey.useHotkey)(hotkey, (e) => {
+      e.preventDefault();
+      handleToggle(!open.value);
+    });
+    (0, import_useHotkey.useHotkey)("ctrl+p", (e) => {
+      e.preventDefault();
+      const win = window;
+      if (win.__VUE_INSPECTOR__) {
+        selectMode.value = !selectMode.value;
+      } else {
+        showNotification("Vue Inspector \u672A\u52A0\u8F7D\uFF0C\u65E0\u6CD5\u4F7F\u7528\u5143\u7D20\u9009\u62E9\u529F\u80FD");
+      }
+    });
+    (0, import_vue2.onMounted)(() => {
+      if (serviceStatus.value !== "idle") {
+        loadSessions();
+        setupSSE();
+        updateContext(true);
+      }
+      if (autoOpen && serviceStatus.value !== "idle") {
+        setTimeout(() => {
+          open.value = true;
+        }, 1e3);
+      }
+      const handleIframeMessage = (event) => {
+        var _a, _b;
+        if (((_a = event.data) == null ? void 0 : _a.type) === "OPENCODE_THINKING_STATE") {
+          setThinking(event.data.thinking);
+        }
+        if (((_b = event.data) == null ? void 0 : _b.type) === "OPENCODE_READY") {
+          sendThemeToIframe();
+        }
+      };
+      window.addEventListener("message", handleIframeMessage);
+    });
+    const handleToggle = (val) => __async(null, null, function* () {
+      if (serviceStatus.value === "idle" && val) {
+        loading.value = true;
+        const started = yield ensureServicesStarted();
+        loading.value = false;
+        if (!started) {
+          showNotification("\u670D\u52A1\u542F\u52A8\u5931\u8D25");
+          return;
+        }
+      }
+      open.value = val;
+      if (val) updateContext();
+      if (val) {
+        iframeLoading.value = false;
+      }
+    });
+    const handleSelectNode = (element) => {
+      const added = addElement(element);
+      if (added) {
+        showNotification(`\u5DF2\u9009\u4E2D\u5143\u7D20 (${selectedElements.value.length}\u4E2A)`);
+        updateContext(true);
+      } else {
+        showNotification("\u8BE5\u5143\u7D20\u5DF2\u9009\u4E2D");
+      }
+    };
+    const handleClearSelected = () => {
+      clearElements();
+      updateContext(true);
+      showNotification("\u5DF2\u6E05\u9664\u6240\u6709\u9009\u4E2D\u5143\u7D20");
+    };
+    const handleSelectModeChange = (val) => {
+      selectMode.value = val;
+      if (!val && !open.value) {
+        open.value = true;
+      }
+    };
+    const handleSessionListCollapsedChange = (val) => {
+      sessionListCollapsed.value = val;
+    };
+    const handleThemeChange = (val) => {
+      theme.value = val;
+    };
+    const handleRemoveSelectedNode = ({ index }) => {
+      removeElement(index);
+      updateContext(true);
+    };
+    const handleFrameLoaded = () => {
+      iframeLoading.value = false;
+    };
+    const __returned__ = { props, open, selectMode, sessionListCollapsed, loading, widgetRef, retryingWarmup, position, initialTheme, autoOpen, hotkey, widgetPosition, widgetTheme, showNotification, serviceStatus, chromeMcpFailed, chromeMcpErrorType, chromeMcpErrorMessage, thinking, loadingText, updateStatusFromTask, setStarting, setThinking, selectedElements, addElement, removeElement, clearElements, theme, sendThemeToIframe, sessions, loadingSessionList, currentSessionId, iframeSrc, iframeLoading, loadSessions, createSession, deleteSession, selectSession, updateContext, showSessionListSkeleton, computedLoading, retryWarmup, setupSSE, ensureServicesStarted, handleToggle, handleSelectNode, handleClearSelected, handleSelectModeChange, handleSessionListCollapsedChange, handleThemeChange, handleRemoveSelectedNode, handleFrameLoaded, get OpenCodeWidget() {
+      return import_components.OpenCodeWidget;
+    }, LoadingContent: import_LoadingContent_vue.default, ChromeWarmupError: import_ChromeWarmupError_vue.default };
+    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
+    return __returned__;
+  }
+});
+function __vue_render__(_ctx, _cache, $props, $setup, $data, $options) {
+  return (0, import_vue3.openBlock)(), (0, import_vue3.createBlock)($setup["OpenCodeWidget"], {
+    ref: "widgetRef",
+    position: $setup.widgetPosition,
+    theme: $setup.theme,
+    open: $setup.open,
+    "select-mode": $setup.selectMode,
+    "session-list-collapsed": $setup.sessionListCollapsed,
+    "frame-loading": $setup.computedLoading,
+    "loading-session-list": $setup.loadingSessionList,
+    "show-session-list-skeleton": $setup.showSessionListSkeleton,
+    "show-error": $setup.chromeMcpFailed,
+    "iframe-src": $setup.iframeSrc,
+    "current-session-id": $setup.currentSessionId,
+    sessions: $setup.sessions,
+    "session-key": "id",
+    "selected-elements": $setup.selectedElements,
+    "hotkey-label": $setup.hotkey,
+    thinking: $setup.thinking,
+    "onUpdate:open": $setup.handleToggle,
+    "onUpdate:selectMode": $setup.handleSelectModeChange,
+    "onUpdate:sessionListCollapsed": $setup.handleSessionListCollapsedChange,
+    "onUpdate:theme": $setup.handleThemeChange,
+    onToggleTheme: $setup.handleThemeChange,
+    onCreateSession: $setup.createSession,
+    onDeleteSession: $setup.deleteSession,
+    onSelectSession: $setup.selectSession,
+    onClickSelectedNode: $setup.handleSelectNode,
+    onClearSelectedNodes: $setup.handleClearSelected,
+    onRemoveSelectedNode: $setup.handleRemoveSelectedNode,
+    onEmptyAction: $setup.createSession,
+    onFrameLoaded: $setup.handleFrameLoaded
+  }, {
+    loading: (0, import_vue3.withCtx)(() => [
+      (0, import_vue3.createVNode)($setup["LoadingContent"], { "loading-text": $setup.loadingText }, null, 8, ["loading-text"])
+    ]),
+    error: (0, import_vue3.withCtx)(() => [
+      $setup.chromeMcpFailed ? ((0, import_vue3.openBlock)(), (0, import_vue3.createBlock)($setup["ChromeWarmupError"], {
+        key: 0,
+        retrying: $setup.retryingWarmup,
+        "error-type": $setup.chromeMcpErrorType,
+        "error-message": $setup.chromeMcpErrorMessage,
+        onRetry: $setup.retryWarmup
+      }, null, 8, ["retrying", "error-type", "error-message"])) : (0, import_vue3.createCommentVNode)("v-if", true)
+    ]),
+    _: 1
+    /* STABLE */
+  }, 8, ["position", "theme", "open", "select-mode", "session-list-collapsed", "frame-loading", "loading-session-list", "show-session-list-skeleton", "show-error", "iframe-src", "current-session-id", "sessions", "selected-elements", "hotkey-label", "thinking", "onCreateSession", "onDeleteSession", "onSelectSession", "onEmptyAction"]);
+}
+__vue_sfc__.render = __vue_render__;
+var App_vue_default = __vue_sfc__;

package/lib/client/components/ChromeWarmupError-sfc.css

@@ -0,0 +1 @@
+.opencode-chrome-warmup-error-details[data-v-798041da]{margin-top:8px;padding:12px;background:var(--oc-bg-tertiary);border-radius:6px;font-family:Monaco,Menlo,Ubuntu Mono,monospace;font-size:12px;color:var(--oc-text-secondary);max-height:120px;overflow-y:auto;word-break:break-word}

package/lib/client/components/ChromeWarmupError.vue.d.ts

@@ -0,0 +1,11 @@
+type __VLS_Props = {
+    retrying: boolean;
+    errorType?: string;
+    errorMessage?: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    retry: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRetry?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/client/components/ChromeWarmupError.vue.js

@@ -0,0 +1,215 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ChromeWarmupError_vue_exports = {};
+__export(ChromeWarmupError_vue_exports, {
+  default: () => ChromeWarmupError_vue_default
+});
+module.exports = __toCommonJS(ChromeWarmupError_vue_exports);
+var import_ChromeWarmupError_sfc = require("./ChromeWarmupError-sfc.css");
+var import_vue = require("vue");
+var import_shared = require("@vite-plugin-opencode-assistant/shared");
+var import_vue2 = require("vue");
+const __vue_sfc__ = /* @__PURE__ */ (0, import_vue.defineComponent)({
+  __name: "ChromeWarmupError",
+  props: {
+    retrying: { type: Boolean, required: true },
+    errorType: { type: String, required: false },
+    errorMessage: { type: String, required: false }
+  },
+  emits: ["retry"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    __expose();
+    const emit = __emit;
+    const __returned__ = { emit, get ChromeMcpWarmupErrorType() {
+      return import_shared.ChromeMcpWarmupErrorType;
+    } };
+    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
+    return __returned__;
+  }
+});
+const _hoisted_1 = { class: "opencode-chrome-warmup-failed" };
+const _hoisted_2 = { class: "opencode-chrome-warmup-failed-text" };
+const _hoisted_3 = { class: "opencode-chrome-warmup-error-details" };
+const _hoisted_4 = { class: "opencode-chrome-warmup-failed-text" };
+const _hoisted_5 = { key: 0 };
+const _hoisted_6 = { key: 1 };
+const _hoisted_7 = { class: "opencode-chrome-warmup-failed-actions" };
+const _hoisted_8 = ["disabled"];
+function __vue_render__(_ctx, _cache, $props, $setup, $data, $options) {
+  return (0, import_vue2.openBlock)(), (0, import_vue2.createElementBlock)("div", _hoisted_1, [
+    _cache[9] || (_cache[9] = (0, import_vue2.createElementVNode)(
+      "div",
+      { class: "opencode-chrome-warmup-failed-icon" },
+      [
+        (0, import_vue2.createElementVNode)("svg", {
+          xmlns: "http://www.w3.org/2000/svg",
+          fill: "none",
+          viewBox: "0 0 24 24",
+          width: "48",
+          height: "48",
+          stroke: "currentColor",
+          "stroke-width": "1.5"
+        }, [
+          (0, import_vue2.createElementVNode)("path", {
+            "stroke-linecap": "round",
+            "stroke-linejoin": "round",
+            d: "M12 9v3.75m-9.303 3.376c-.866 1.5.217 3.374 1.948 3.374h14.71c1.73 0 2.813-1.874 1.948-3.374L13.949 3.378c-.866-1.5-3.032-1.5-3.898 0L2.697 16.126zM12 15.75h.007v.008H12v-.008z"
+          })
+        ])
+      ],
+      -1
+      /* CACHED */
+    )),
+    (0, import_vue2.createCommentVNode)(" Chrome \u8FDC\u7A0B\u8C03\u8BD5\u672A\u5F00\u542F "),
+    $props.errorType === $setup.ChromeMcpWarmupErrorType.CHROME_NOT_CONNECTED ? ((0, import_vue2.openBlock)(), (0, import_vue2.createElementBlock)(
+      import_vue2.Fragment,
+      { key: 0 },
+      [
+        _cache[1] || (_cache[1] = (0, import_vue2.createElementVNode)(
+          "div",
+          { class: "opencode-chrome-warmup-failed-title" },
+          "Chrome DevTools MCP \u8FDE\u63A5\u5931\u8D25",
+          -1
+          /* CACHED */
+        )),
+        _cache[2] || (_cache[2] = (0, import_vue2.createElementVNode)(
+          "div",
+          { class: "opencode-chrome-warmup-failed-text" },
+          [
+            (0, import_vue2.createElementVNode)("p", null, "\u8BF7\u6309\u4EE5\u4E0B\u6B65\u9AA4\u5F00\u542F Chrome \u8FDC\u7A0B\u8C03\u8BD5\uFF1A"),
+            (0, import_vue2.createElementVNode)("ol", { class: "opencode-chrome-warmup-steps" }, [
+              (0, import_vue2.createElementVNode)("li", null, [
+                (0, import_vue2.createTextVNode)(" \u5728 Chrome \u5730\u5740\u680F\u8F93\u5165 "),
+                (0, import_vue2.createElementVNode)("code", { class: "opencode-chrome-warmup-code" }, "chrome://inspect/#remote-debugging")
+              ]),
+              (0, import_vue2.createElementVNode)("li", null, "\u52FE\u9009 'Allow remote debugging for this browser instance' \u9009\u9879"),
+              (0, import_vue2.createElementVNode)("li", null, "\u91CD\u65B0\u542F\u52A8\u6D4F\u89C8\u5668"),
+              (0, import_vue2.createElementVNode)("li", null, "\u5B8C\u6210\u540E\u70B9\u51FB\u4E0B\u65B9\u6309\u94AE\u91CD\u8BD5")
+            ])
+          ],
+          -1
+          /* CACHED */
+        ))
+      ],
+      64
+      /* STABLE_FRAGMENT */
+    )) : $props.errorType === $setup.ChromeMcpWarmupErrorType.AI_TIMEOUT ? ((0, import_vue2.openBlock)(), (0, import_vue2.createElementBlock)(
+      import_vue2.Fragment,
+      { key: 1 },
+      [
+        (0, import_vue2.createCommentVNode)(" AI \u54CD\u5E94\u8D85\u65F6 "),
+        _cache[3] || (_cache[3] = (0, import_vue2.createElementVNode)(
+          "div",
+          { class: "opencode-chrome-warmup-failed-title" },
+          "AI \u54CD\u5E94\u8D85\u65F6",
+          -1
+          /* CACHED */
+        )),
+        _cache[4] || (_cache[4] = (0, import_vue2.createElementVNode)(
+          "div",
+          { class: "opencode-chrome-warmup-failed-text" },
+          [
+            (0, import_vue2.createElementVNode)("p", null, "AI \u6A21\u578B\u54CD\u5E94\u8D85\u65F6\uFF0C\u53EF\u80FD\u7684\u539F\u56E0\uFF1A"),
+            (0, import_vue2.createElementVNode)("ol", { class: "opencode-chrome-warmup-steps" }, [
+              (0, import_vue2.createElementVNode)("li", null, "OpenCode AI \u6A21\u578B\u672A\u6B63\u786E\u914D\u7F6E"),
+              (0, import_vue2.createElementVNode)("li", null, "AI \u6A21\u578B\u670D\u52A1\u4E0D\u53EF\u7528\u6216\u54CD\u5E94\u7F13\u6162"),
+              (0, import_vue2.createElementVNode)("li", null, "\u7F51\u7EDC\u8FDE\u63A5\u95EE\u9898")
+            ]),
+            (0, import_vue2.createElementVNode)("p", { style: { "margin-top": "12px", "font-weight": "500" } }, "\u8BF7\u68C0\u67E5 OpenCode \u914D\u7F6E\u6587\u4EF6\u4E2D\u7684 AI \u6A21\u578B\u8BBE\u7F6E")
+          ],
+          -1
+          /* CACHED */
+        ))
+      ],
+      64
+      /* STABLE_FRAGMENT */
+    )) : $props.errorType === $setup.ChromeMcpWarmupErrorType.AI_RESPONSE_ERROR ? ((0, import_vue2.openBlock)(), (0, import_vue2.createElementBlock)(
+      import_vue2.Fragment,
+      { key: 2 },
+      [
+        (0, import_vue2.createCommentVNode)(" AI \u54CD\u5E94\u9519\u8BEF "),
+        _cache[7] || (_cache[7] = (0, import_vue2.createElementVNode)(
+          "div",
+          { class: "opencode-chrome-warmup-failed-title" },
+          "AI \u54CD\u5E94\u9519\u8BEF",
+          -1
+          /* CACHED */
+        )),
+        (0, import_vue2.createElementVNode)("div", _hoisted_2, [
+          _cache[5] || (_cache[5] = (0, import_vue2.createElementVNode)(
+            "p",
+            null,
+            "AI \u6A21\u578B\u8FD4\u56DE\u4E86\u610F\u5916\u7684\u54CD\u5E94\uFF1A",
+            -1
+            /* CACHED */
+          )),
+          (0, import_vue2.createElementVNode)(
+            "div",
+            _hoisted_3,
+            (0, import_vue2.toDisplayString)($props.errorMessage || "\u672A\u77E5\u9519\u8BEF"),
+            1
+            /* TEXT */
+          ),
+          _cache[6] || (_cache[6] = (0, import_vue2.createElementVNode)(
+            "p",
+            { style: { "margin-top": "12px" } },
+            "\u8BF7\u68C0\u67E5 OpenCode AI \u6A21\u578B\u914D\u7F6E\u662F\u5426\u6B63\u786E",
+            -1
+            /* CACHED */
+          ))
+        ])
+      ],
+      64
+      /* STABLE_FRAGMENT */
+    )) : ((0, import_vue2.openBlock)(), (0, import_vue2.createElementBlock)(
+      import_vue2.Fragment,
+      { key: 3 },
+      [
+        (0, import_vue2.createCommentVNode)(" \u5176\u4ED6\u9519\u8BEF "),
+        _cache[8] || (_cache[8] = (0, import_vue2.createElementVNode)(
+          "div",
+          { class: "opencode-chrome-warmup-failed-title" },
+          "Chrome DevTools MCP \u8FDE\u63A5\u5931\u8D25",
+          -1
+          /* CACHED */
+        )),
+        (0, import_vue2.createElementVNode)("div", _hoisted_4, [
+          $props.errorMessage ? ((0, import_vue2.openBlock)(), (0, import_vue2.createElementBlock)(
+            "p",
+            _hoisted_5,
+            (0, import_vue2.toDisplayString)($props.errorMessage),
+            1
+            /* TEXT */
+          )) : ((0, import_vue2.openBlock)(), (0, import_vue2.createElementBlock)("p", _hoisted_6, "\u8FDE\u63A5\u5931\u8D25\uFF0C\u8BF7\u91CD\u8BD5"))
+        ])
+      ],
+      64
+      /* STABLE_FRAGMENT */
+    )),
+    (0, import_vue2.createElementVNode)("div", _hoisted_7, [
+      (0, import_vue2.createElementVNode)("button", {
+        class: "opencode-chrome-warmup-failed-btn primary",
+        disabled: $props.retrying,
+        onClick: _cache[0] || (_cache[0] = ($event) => $setup.emit("retry"))
+      }, (0, import_vue2.toDisplayString)($props.retrying ? "\u8FDE\u63A5\u4E2D..." : "\u91CD\u8BD5\u8FDE\u63A5"), 9, _hoisted_8)
+    ])
+  ]);
+}
+__vue_sfc__.render = __vue_render__;
+__vue_sfc__.__scopeId = "data-v-798041da";
+var ChromeWarmupError_vue_default = __vue_sfc__;

package/lib/client/components/LoadingContent.vue.d.ts

@@ -0,0 +1,5 @@
+type __VLS_Props = {
+    loadingText: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;