vite-plugin-opencode-assistant 1.0.15 → 1.0.16

package/es/client/composables/useHotkey.js

@@ -0,0 +1,41 @@
+import { onMounted, onUnmounted } from "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);
+    }
+  };
+  onMounted(() => {
+    document.addEventListener("keydown", handleKeydown);
+  });
+  onUnmounted(() => {
+    document.removeEventListener("keydown", handleKeydown);
+  });
+  return {
+    hotkeyConfig
+  };
+}
+export {
+  matchHotkey,
+  parseHotkey,
+  useHotkey
+};

package/es/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/es/client/composables/useSSE.js

@@ -0,0 +1,61 @@
+import { ref, onUnmounted } from "vue";
+const MAX_SSE_RETRIES = 10;
+const SSE_RETRY_DELAY = 1e3;
+function useSSE(onStatusSync, onTaskUpdate, onClearElements, onConnected) {
+  const sseConnection = ref(null);
+  const sseRetryCount = 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;
+    }
+  };
+  onUnmounted(() => {
+    closeSSE();
+  });
+  return {
+    setupSSE,
+    closeSSE,
+    sseRetryCount
+  };
+}
+export {
+  useSSE
+};

package/es/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/es/client/composables/useSelectedElements.js

@@ -0,0 +1,43 @@
+import { ref, watch } from "vue";
+function useSelectedElements() {
+  const selectedElements = ref([]);
+  try {
+    const stored = sessionStorage.getItem("__opencode_selected_elements__");
+    if (stored) {
+      selectedElements.value = JSON.parse(stored);
+    }
+  } catch (e) {
+  }
+  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
+  };
+}
+export {
+  useSelectedElements
+};

package/es/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/es/client/composables/useServiceStatus.js

@@ -0,0 +1,53 @@
+import { ref, computed } from "vue";
+import { SERVICE_STARTUP_TASKS } from "@vite-plugin-opencode-assistant/shared";
+function useServiceStatus() {
+  const currentTask = ref("");
+  const serviceStatus = ref("idle");
+  const chromeMcpFailed = ref(false);
+  const chromeMcpErrorType = ref(void 0);
+  const chromeMcpErrorMessage = ref(void 0);
+  const thinking = ref(false);
+  const loadingText = computed(() => {
+    if (!currentTask.value) return "\u52A0\u8F7D\u4E2D...";
+    return 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
+  };
+}
+export {
+  useServiceStatus
+};

package/es/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;
+};

package/es/client/composables/useSessions.js

@@ -0,0 +1,127 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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());
+  });
+};
+import { ref, computed } from "vue";
+import { SESSIONS_API_PATH } from "@vite-plugin-opencode-assistant/shared";
+function useSessions(showNotification) {
+  const sessions = ref([]);
+  const loadingSessionList = ref(void 0);
+  const currentSessionId = ref(null);
+  const iframeLoading = ref(false);
+  const iframeSrc = computed(() => {
+    var _a;
+    return currentSessionId.value ? ((_a = sessions.value.find((s) => s.id === currentSessionId.value)) == null ? void 0 : _a.url) || "" : "";
+  });
+  const loadSessions = () => __async(null, null, function* () {
+    var _a;
+    loadingSessionList.value = true;
+    try {
+      const response = yield fetch(SESSIONS_API_PATH);
+      const data = yield response.json();
+      sessions.value = data.filter((s) => s.title !== "__chrome_mcp_warmup__").map((s) => {
+        var _a2;
+        return __spreadProps(__spreadValues({}, s), {
+          updatedAt: ((_a2 = s.time) == null ? void 0 : _a2.updated) || Date.now()
+        });
+      });
+      if (!sessions.value.length) {
+        createSession();
+      }
+      currentSessionId.value = ((_a = sessions.value[0]) == null ? void 0 : _a.id) || null;
+    } catch (e) {
+      console.error("[OpenCode] Failed to load sessions:", e);
+    } finally {
+      loadingSessionList.value = false;
+    }
+  });
+  const createSession = () => __async(null, null, function* () {
+    try {
+      const response = yield fetch(SESSIONS_API_PATH, { method: "POST" });
+      const newSession = yield response.json();
+      sessions.value.unshift({
+        id: newSession.id,
+        title: "\u65B0\u4F1A\u8BDD",
+        updatedAt: Date.now(),
+        url: newSession.url
+      });
+      currentSessionId.value = newSession.id;
+      iframeLoading.value = true;
+      loadSessions();
+    } catch (e) {
+      showNotification("\u521B\u5EFA\u4F1A\u8BDD\u5931\u8D25");
+    }
+  });
+  const deleteSession = (session) => __async(null, null, function* () {
+    try {
+      yield fetch(`${SESSIONS_API_PATH}?id=${session.id}`, { method: "DELETE" });
+      yield loadSessions();
+      showNotification("\u4F1A\u8BDD\u5DF2\u5220\u9664");
+      if (currentSessionId.value === session.id) {
+        if (sessions.value.length > 0) {
+          const nextSession = sessions.value[0];
+          currentSessionId.value = nextSession.id;
+          iframeLoading.value = true;
+        } else {
+          currentSessionId.value = null;
+        }
+      }
+    } catch (e) {
+      showNotification("\u5220\u9664\u4F1A\u8BDD\u5931\u8D25");
+    }
+  });
+  const selectSession = (session) => {
+    if (currentSessionId.value === session.id) return;
+    currentSessionId.value = session.id;
+    iframeLoading.value = true;
+  };
+  return {
+    sessions,
+    loadingSessionList,
+    currentSessionId,
+    iframeSrc,
+    iframeLoading,
+    loadSessions,
+    createSession,
+    deleteSession,
+    selectSession
+  };
+}
+export {
+  useSessions
+};

package/es/client/composables/useTheme.d.ts

@@ -0,0 +1,12 @@
+import type { OpenCodeWidgetTheme } from "@vite-plugin-opencode-assistant/shared";
+interface WidgetRef {
+    sendMessageToIframe: (type: string, data?: Record<string, unknown>) => void;
+}
+export declare function useTheme(initialTheme: OpenCodeWidgetTheme, widgetRef: {
+    value: WidgetRef | null;
+}): {
+    theme: import("vue").Ref<OpenCodeWidgetTheme, OpenCodeWidgetTheme>;
+    resolvedTheme: import("vue").ComputedRef<"light" | "dark">;
+    sendThemeToIframe: () => void;
+};
+export {};

package/es/client/composables/useTheme.js

@@ -0,0 +1,42 @@
+import { ref, computed, watch, onMounted, onUnmounted } from "vue";
+function useTheme(initialTheme, widgetRef) {
+  const theme = ref(initialTheme);
+  const resolvedTheme = computed(() => {
+    if (theme.value === "auto") {
+      return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+    }
+    return theme.value;
+  });
+  const sendThemeToIframe = () => {
+    var _a;
+    (_a = widgetRef.value) == null ? void 0 : _a.sendMessageToIframe("OPENCODE_SET_THEME", {
+      theme: resolvedTheme.value
+    });
+  };
+  let mediaQuery = null;
+  const handleSystemThemeChange = () => {
+    if (theme.value === "auto") {
+      sendThemeToIframe();
+    }
+  };
+  onMounted(() => {
+    mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+    mediaQuery.addEventListener("change", handleSystemThemeChange);
+    watch(resolvedTheme, () => {
+      sendThemeToIframe();
+    });
+  });
+  onUnmounted(() => {
+    if (mediaQuery) {
+      mediaQuery.removeEventListener("change", handleSystemThemeChange);
+    }
+  });
+  return {
+    theme,
+    resolvedTheme,
+    sendThemeToIframe
+  };
+}
+export {
+  useTheme
+};

package/es/client/index.d.ts

@@ -1 +1 @@
-import "@vite-plugin-opencode-assistant/components/style.css";
+import "./styles.css";