vite-plugin-opencode-assistant 1.0.14 → 1.0.16

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

@@ -0,0 +1,58 @@
+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 LoadingContent_vue_exports = {};
+__export(LoadingContent_vue_exports, {
+  default: () => LoadingContent_vue_default
+});
+module.exports = __toCommonJS(LoadingContent_vue_exports);
+var import_vue = require("vue");
+var import_vue2 = require("vue");
+const __vue_sfc__ = /* @__PURE__ */ (0, import_vue.defineComponent)({
+  __name: "LoadingContent",
+  props: {
+    loadingText: { type: String, required: true }
+  },
+  setup(__props, { expose: __expose }) {
+    __expose();
+    const __returned__ = {};
+    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
+    return __returned__;
+  }
+});
+const _hoisted_1 = { class: "opencode-custom-loading" };
+const _hoisted_2 = { class: "opencode-loading-text" };
+function __vue_render__(_ctx, _cache, $props, $setup, $data, $options) {
+  return (0, import_vue2.openBlock)(), (0, import_vue2.createElementBlock)("div", _hoisted_1, [
+    _cache[0] || (_cache[0] = (0, import_vue2.createElementVNode)(
+      "div",
+      { class: "opencode-loading-spinner" },
+      null,
+      -1
+      /* CACHED */
+    )),
+    (0, import_vue2.createElementVNode)(
+      "div",
+      _hoisted_2,
+      (0, import_vue2.toDisplayString)($props.loadingText),
+      1
+      /* TEXT */
+    )
+  ]);
+}
+__vue_sfc__.render = __vue_render__;
+var LoadingContent_vue_default = __vue_sfc__;

package/lib/client/composables/useContext.d.ts

@@ -0,0 +1,8 @@
+import type { OpenCodeSelectedElement, ServiceStatus } from "@vite-plugin-opencode-assistant/shared";
+export declare function useContext(serviceStatus: {
+    value: ServiceStatus;
+}, selectedElements: {
+    value: OpenCodeSelectedElement[];
+}): {
+    updateContext: (force?: boolean) => void;
+};

package/lib/client/composables/useContext.js

@@ -0,0 +1,86 @@
+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 useContext_exports = {};
+__export(useContext_exports, {
+  useContext: () => useContext
+});
+module.exports = __toCommonJS(useContext_exports);
+var import_vue = require("vue");
+function useContext(serviceStatus, selectedElements) {
+  let currentPageUrl = "";
+  let currentPageTitle = "";
+  const updateContext = (force = false) => {
+    if (serviceStatus.value === "idle") return;
+    const newUrl = window.location.href;
+    const newTitle = document.title;
+    if (force || newUrl !== currentPageUrl || newTitle !== currentPageTitle) {
+      currentPageUrl = newUrl;
+      currentPageTitle = newTitle;
+      fetch("/__opencode_context__", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          url: newUrl,
+          title: newTitle,
+          selectedElements: selectedElements.value
+        })
+      }).catch(() => {
+      });
+    }
+  };
+  const scheduleContextUpdate = () => {
+    requestAnimationFrame(() => updateContext());
+  };
+  let titleObserver = null;
+  const originalPushState = history.pushState;
+  const originalReplaceState = history.replaceState;
+  (0, import_vue.onMounted)(() => {
+    history.pushState = function(...args) {
+      originalPushState.apply(this, args);
+      scheduleContextUpdate();
+    };
+    history.replaceState = function(...args) {
+      originalReplaceState.apply(this, args);
+      scheduleContextUpdate();
+    };
+    window.addEventListener("popstate", scheduleContextUpdate);
+    window.addEventListener("hashchange", scheduleContextUpdate);
+    titleObserver = new MutationObserver(() => {
+      if (document.title !== currentPageTitle) updateContext();
+    });
+    if (document.head) {
+      titleObserver.observe(document.head, { childList: true, subtree: true });
+    }
+  });
+  (0, import_vue.onUnmounted)(() => {
+    history.pushState = originalPushState;
+    history.replaceState = originalReplaceState;
+    window.removeEventListener("popstate", scheduleContextUpdate);
+    window.removeEventListener("hashchange", scheduleContextUpdate);
+    if (titleObserver) {
+      titleObserver.disconnect();
+    }
+  });
+  return {
+    updateContext
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useContext
+});

package/lib/client/composables/useHotkey.d.ts

@@ -0,0 +1,12 @@
+interface HotkeyConfig {
+    ctrl: boolean;
+    shift: boolean;
+    alt: boolean;
+    key: string;
+}
+export declare function parseHotkey(hotkeyStr: string): HotkeyConfig;
+export declare function matchHotkey(e: KeyboardEvent, hotkeyConfig: HotkeyConfig): boolean;
+export declare function useHotkey(hotkeyStr: string, callback: (event: KeyboardEvent) => void): {
+    hotkeyConfig: HotkeyConfig;
+};
+export {};

package/lib/client/composables/useHotkey.js

@@ -0,0 +1,66 @@
+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 useHotkey_exports = {};
+__export(useHotkey_exports, {
+  matchHotkey: () => matchHotkey,
+  parseHotkey: () => parseHotkey,
+  useHotkey: () => useHotkey
+});
+module.exports = __toCommonJS(useHotkey_exports);
+var import_vue = require("vue");
+function parseHotkey(hotkeyStr) {
+  if (!hotkeyStr) return { ctrl: true, shift: false, alt: false, key: "k" };
+  const parts = hotkeyStr.toLowerCase().split("+");
+  const key = parts.pop();
+  return {
+    ctrl: parts.includes("ctrl") || parts.includes("cmd") || parts.includes("meta"),
+    shift: parts.includes("shift"),
+    alt: parts.includes("alt"),
+    key: key || "k"
+  };
+}
+function matchHotkey(e, hotkeyConfig) {
+  const ctrlMatch = hotkeyConfig.ctrl ? e.ctrlKey || e.metaKey : !(e.ctrlKey || e.metaKey);
+  const shiftMatch = hotkeyConfig.shift ? e.shiftKey : !e.shiftKey;
+  const altMatch = hotkeyConfig.alt ? e.altKey : !e.altKey;
+  const keyMatch = e.key.toLowerCase() === hotkeyConfig.key.toLowerCase();
+  return ctrlMatch && shiftMatch && altMatch && keyMatch;
+}
+function useHotkey(hotkeyStr, callback) {
+  const hotkeyConfig = parseHotkey(hotkeyStr);
+  const handleKeydown = (e) => {
+    if (matchHotkey(e, hotkeyConfig)) {
+      callback(e);
+    }
+  };
+  (0, import_vue.onMounted)(() => {
+    document.addEventListener("keydown", handleKeydown);
+  });
+  (0, import_vue.onUnmounted)(() => {
+    document.removeEventListener("keydown", handleKeydown);
+  });
+  return {
+    hotkeyConfig
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  matchHotkey,
+  parseHotkey,
+  useHotkey
+});

package/lib/client/composables/useSSE.d.ts

@@ -0,0 +1,20 @@
+import { ServiceStartupTask } from "@vite-plugin-opencode-assistant/shared";
+interface SSEStatusSyncData {
+    type: "STATUS_SYNC";
+    isStarted?: boolean;
+    task: ServiceStartupTask;
+    errorType?: string;
+    errorMessage?: string;
+}
+interface SSETaskUpdateData {
+    type: "TASK_UPDATE";
+    task: ServiceStartupTask;
+    errorType?: string;
+    errorMessage?: string;
+}
+export declare function useSSE(onStatusSync: (data: SSEStatusSyncData) => void, onTaskUpdate: (data: SSETaskUpdateData) => void, onClearElements: () => void, onConnected: () => void): {
+    setupSSE: () => void;
+    closeSSE: () => void;
+    sseRetryCount: import("vue").Ref<number, number>;
+};
+export {};

package/lib/client/composables/useSSE.js

@@ -0,0 +1,84 @@
+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 useSSE_exports = {};
+__export(useSSE_exports, {
+  useSSE: () => useSSE
+});
+module.exports = __toCommonJS(useSSE_exports);
+var import_vue = require("vue");
+const MAX_SSE_RETRIES = 10;
+const SSE_RETRY_DELAY = 1e3;
+function useSSE(onStatusSync, onTaskUpdate, onClearElements, onConnected) {
+  const sseConnection = (0, import_vue.ref)(null);
+  const sseRetryCount = (0, import_vue.ref)(0);
+  const setupSSE = () => {
+    if (sseConnection.value) return;
+    try {
+      sseConnection.value = new EventSource("/__opencode_events__");
+      sseConnection.value.onmessage = (event) => {
+        try {
+          const data = JSON.parse(event.data);
+          if (data.type === "CONNECTED") {
+            onConnected();
+            sseRetryCount.value = 0;
+          } else if (data.type === "STATUS_SYNC") {
+            onStatusSync(data);
+          } else if (data.type === "TASK_UPDATE") {
+            onTaskUpdate(data);
+          } else if (data.type === "CLEAR_ELEMENTS") {
+            onClearElements();
+          }
+        } catch (e) {
+        }
+      };
+      sseConnection.value.onerror = () => {
+        var _a;
+        (_a = sseConnection.value) == null ? void 0 : _a.close();
+        sseConnection.value = null;
+        if (sseRetryCount.value < MAX_SSE_RETRIES) {
+          sseRetryCount.value++;
+          setTimeout(setupSSE, SSE_RETRY_DELAY * sseRetryCount.value);
+        }
+      };
+    } catch (e) {
+      sseConnection.value = null;
+      if (sseRetryCount.value < MAX_SSE_RETRIES) {
+        sseRetryCount.value++;
+        setTimeout(setupSSE, SSE_RETRY_DELAY * sseRetryCount.value);
+      }
+    }
+  };
+  const closeSSE = () => {
+    if (sseConnection.value) {
+      sseConnection.value.close();
+      sseConnection.value = null;
+    }
+  };
+  (0, import_vue.onUnmounted)(() => {
+    closeSSE();
+  });
+  return {
+    setupSSE,
+    closeSSE,
+    sseRetryCount
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useSSE
+});

package/lib/client/composables/useSelectedElements.d.ts

@@ -0,0 +1,19 @@
+import type { OpenCodeSelectedElement } from "@vite-plugin-opencode-assistant/shared";
+export declare function useSelectedElements(): {
+    selectedElements: import("vue").Ref<{
+        filePath: string | null;
+        line: number | null;
+        column: number | null;
+        innerText: string;
+        description?: string | undefined;
+    }[], OpenCodeSelectedElement[] | {
+        filePath: string | null;
+        line: number | null;
+        column: number | null;
+        innerText: string;
+        description?: string | undefined;
+    }[]>;
+    addElement: (element: OpenCodeSelectedElement) => boolean;
+    removeElement: (index: number) => void;
+    clearElements: () => void;
+};

package/lib/client/composables/useSelectedElements.js

@@ -0,0 +1,66 @@
+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 useSelectedElements_exports = {};
+__export(useSelectedElements_exports, {
+  useSelectedElements: () => useSelectedElements
+});
+module.exports = __toCommonJS(useSelectedElements_exports);
+var import_vue = require("vue");
+function useSelectedElements() {
+  const selectedElements = (0, import_vue.ref)([]);
+  try {
+    const stored = sessionStorage.getItem("__opencode_selected_elements__");
+    if (stored) {
+      selectedElements.value = JSON.parse(stored);
+    }
+  } catch (e) {
+  }
+  (0, import_vue.watch)(
+    selectedElements,
+    (val) => {
+      sessionStorage.setItem("__opencode_selected_elements__", JSON.stringify(val));
+    },
+    { deep: true }
+  );
+  const addElement = (element) => {
+    const exists = selectedElements.value.some(
+      (el) => el.filePath === element.filePath && el.line === element.line
+    );
+    if (!exists) {
+      selectedElements.value.push(element);
+      return true;
+    }
+    return false;
+  };
+  const removeElement = (index) => {
+    selectedElements.value.splice(index, 1);
+  };
+  const clearElements = () => {
+    selectedElements.value = [];
+  };
+  return {
+    selectedElements,
+    addElement,
+    removeElement,
+    clearElements
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useSelectedElements
+});

package/lib/client/composables/useServiceStatus.d.ts

@@ -0,0 +1,13 @@
+import type { ServiceStartupTask, ServiceStatus } from "@vite-plugin-opencode-assistant/shared";
+export declare function useServiceStatus(): {
+    currentTask: import("vue").Ref<"" | ServiceStartupTask, "" | ServiceStartupTask>;
+    serviceStatus: import("vue").Ref<ServiceStatus, ServiceStatus>;
+    chromeMcpFailed: import("vue").Ref<boolean, boolean>;
+    chromeMcpErrorType: import("vue").Ref<string | undefined, string | undefined>;
+    chromeMcpErrorMessage: import("vue").Ref<string | undefined, string | undefined>;
+    thinking: import("vue").Ref<boolean, boolean>;
+    loadingText: import("vue").ComputedRef<string>;
+    updateStatusFromTask: (task: ServiceStartupTask | "", errorType?: string, errorMessage?: string) => void;
+    setStarting: () => void;
+    setThinking: (value: boolean) => void;
+};

package/lib/client/composables/useServiceStatus.js

@@ -0,0 +1,76 @@
+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 useServiceStatus_exports = {};
+__export(useServiceStatus_exports, {
+  useServiceStatus: () => useServiceStatus
+});
+module.exports = __toCommonJS(useServiceStatus_exports);
+var import_vue = require("vue");
+var import_shared = require("@vite-plugin-opencode-assistant/shared");
+function useServiceStatus() {
+  const currentTask = (0, import_vue.ref)("");
+  const serviceStatus = (0, import_vue.ref)("idle");
+  const chromeMcpFailed = (0, import_vue.ref)(false);
+  const chromeMcpErrorType = (0, import_vue.ref)(void 0);
+  const chromeMcpErrorMessage = (0, import_vue.ref)(void 0);
+  const thinking = (0, import_vue.ref)(false);
+  const loadingText = (0, import_vue.computed)(() => {
+    if (!currentTask.value) return "\u52A0\u8F7D\u4E2D...";
+    return import_shared.SERVICE_STARTUP_TASKS[currentTask.value] || "\u52A0\u8F7D\u4E2D...";
+  });
+  const updateStatusFromTask = (task, errorType, errorMessage) => {
+    currentTask.value = task;
+    if (task === "ready") {
+      serviceStatus.value = "ready";
+      chromeMcpFailed.value = false;
+      chromeMcpErrorType.value = void 0;
+      chromeMcpErrorMessage.value = void 0;
+    } else if (task === "chrome_mcp_failed") {
+      serviceStatus.value = "partial";
+      chromeMcpFailed.value = true;
+      chromeMcpErrorType.value = errorType;
+      chromeMcpErrorMessage.value = errorMessage;
+    } else if (task === "session_creation_failed" || task === "opencode_not_installed" || task === "web_start_timeout") {
+      serviceStatus.value = "failed";
+    } else if (serviceStatus.value === "idle" && task) {
+      serviceStatus.value = "starting";
+    }
+  };
+  const setStarting = () => {
+    serviceStatus.value = "starting";
+  };
+  const setThinking = (value) => {
+    thinking.value = value;
+  };
+  return {
+    currentTask,
+    serviceStatus,
+    chromeMcpFailed,
+    chromeMcpErrorType,
+    chromeMcpErrorMessage,
+    thinking,
+    loadingText,
+    updateStatusFromTask,
+    setStarting,
+    setThinking
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useServiceStatus
+});

package/lib/client/composables/useSessions.d.ts

@@ -0,0 +1,26 @@
+import type { OpenCodeWidgetSession } from "@vite-plugin-opencode-assistant/shared";
+export declare function useSessions(showNotification: (msg: string) => void): {
+    sessions: import("vue").Ref<{
+        id: string;
+        title?: string | undefined;
+        updatedAt?: (string | number | Date) | undefined;
+        meta?: string | undefined;
+        directory?: string | undefined;
+        url?: string | undefined;
+    }[], OpenCodeWidgetSession[] | {
+        id: string;
+        title?: string | undefined;
+        updatedAt?: (string | number | Date) | undefined;
+        meta?: string | undefined;
+        directory?: string | undefined;
+        url?: string | undefined;
+    }[]>;
+    loadingSessionList: import("vue").Ref<boolean | undefined, boolean | undefined>;
+    currentSessionId: import("vue").Ref<string | null, string | null>;
+    iframeSrc: import("vue").ComputedRef<string>;
+    iframeLoading: import("vue").Ref<boolean, boolean>;
+    loadSessions: () => Promise<void>;
+    createSession: () => Promise<void>;
+    deleteSession: (session: OpenCodeWidgetSession) => Promise<void>;
+    selectSession: (session: OpenCodeWidgetSession) => void;
+};