vite-plugin-opencode-assistant 1.0.27 → 1.0.28

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

@@ -1,20 +1,87 @@
-import { ServiceStartupTask } from "@vite-plugin-opencode-assistant/shared";
-interface SSEStatusSyncData {
-    type: "STATUS_SYNC";
-    isStarted?: boolean;
-    task: ServiceStartupTask;
-    errorType?: string;
-    errorMessage?: string;
+import { type Ref } from "vue";
+/**
+ * SSE 连接状态
+ */
+export type SSEConnectionStatus = "idle" | "connecting" | "connected" | "disconnected" | "error";
+/**
+ * SSE 配置选项
+ */
+export interface SSEOptions {
+    /** SSE 端点 URL */
+    endpoint: string;
+    /** 是否自动连接 */
+    autoConnect?: boolean;
+    /** 是否启用 (响应式) */
+    enabled?: Ref<boolean>;
+    /** 最大重试次数 */
+    maxRetries?: number;
+    /** 重试延迟基数 (ms) */
+    retryDelay?: number;
+    /** 连接成功回调 */
+    onConnected?: () => void;
+    /** 连接断开回调 */
+    onDisconnected?: () => void;
+    /** 连接错误回调 */
+    onError?: (error: Error) => void;
+    /** 消息处理回调 */
+    onMessage?: (data: unknown) => void;
 }
-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>;
+/**
+ * 通用 SSE 连接管理
+ * 提供基础的连接、重连、状态管理功能
+ */
+export declare function useSSE(options: SSEOptions): {
+    connection: Ref<{
+        onerror: ((this: EventSource, ev: Event) => any) | null;
+        onmessage: ((this: EventSource, ev: MessageEvent) => any) | null;
+        onopen: ((this: EventSource, ev: Event) => any) | null;
+        readonly readyState: number;
+        readonly url: string;
+        readonly withCredentials: boolean;
+        close: () => void;
+        readonly CONNECTING: 0;
+        readonly OPEN: 1;
+        readonly CLOSED: 2;
+        addEventListener: {
+            <K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: (this: EventSource, event: MessageEvent) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        };
+        removeEventListener: {
+            <K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: (this: EventSource, event: MessageEvent) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        };
+        dispatchEvent: (event: Event) => boolean;
+    } | null, EventSource | {
+        onerror: ((this: EventSource, ev: Event) => any) | null;
+        onmessage: ((this: EventSource, ev: MessageEvent) => any) | null;
+        onopen: ((this: EventSource, ev: Event) => any) | null;
+        readonly readyState: number;
+        readonly url: string;
+        readonly withCredentials: boolean;
+        close: () => void;
+        readonly CONNECTING: 0;
+        readonly OPEN: 1;
+        readonly CLOSED: 2;
+        addEventListener: {
+            <K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: (this: EventSource, event: MessageEvent) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        };
+        removeEventListener: {
+            <K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: (this: EventSource, event: MessageEvent) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        };
+        dispatchEvent: (event: Event) => boolean;
+    } | null>;
+    status: Ref<SSEConnectionStatus, SSEConnectionStatus>;
+    retryCount: Ref<number, number>;
+    isConnected: import("vue").ComputedRef<boolean>;
+    isConnecting: import("vue").ComputedRef<boolean>;
+    connect: () => void;
+    disconnect: () => void;
+    reconnect: () => void;
+    resetRetryCount: () => void;
 };
-export {};

package/lib/client/composables/useSSE.js

@@ -21,61 +21,118 @@ __export(useSSE_exports, {
 });
 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;
+const DEFAULT_MAX_RETRIES = 10;
+const DEFAULT_RETRY_DELAY = 1e3;
+function useSSE(options) {
+  const {
+    endpoint,
+    autoConnect = true,
+    enabled,
+    maxRetries = DEFAULT_MAX_RETRIES,
+    retryDelay = DEFAULT_RETRY_DELAY,
+    onConnected,
+    onDisconnected,
+    onError,
+    onMessage
+  } = options;
+  const connection = (0, import_vue.ref)(null);
+  const status = (0, import_vue.ref)("idle");
+  const retryCount = (0, import_vue.ref)(0);
+  function handleMessage(event) {
     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) {
-        }
+      const data = JSON.parse(event.data);
+      onMessage == null ? void 0 : onMessage(data);
+    } catch (e) {
+      onMessage == null ? void 0 : onMessage(event.data);
+    }
+  }
+  function connect() {
+    if (connection.value || status.value === "connecting") {
+      return;
+    }
+    if ((enabled == null ? void 0 : enabled.value) === false) {
+      status.value = "idle";
+      return;
+    }
+    status.value = "connecting";
+    retryCount.value = 0;
+    try {
+      connection.value = new EventSource(endpoint);
+      connection.value.onopen = () => {
+        status.value = "connected";
+        retryCount.value = 0;
+        onConnected == null ? void 0 : onConnected();
       };
-      sseConnection.value.onerror = () => {
+      connection.value.onmessage = handleMessage;
+      connection.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);
+        const wasConnected = status.value === "connected";
+        status.value = "error";
+        (_a = connection.value) == null ? void 0 : _a.close();
+        connection.value = null;
+        const error = new Error(`SSE connection error: ${endpoint}`);
+        onError == null ? void 0 : onError(error);
+        if (retryCount.value < maxRetries) {
+          retryCount.value++;
+          const delay = retryDelay * retryCount.value;
+          setTimeout(() => {
+            if ((enabled == null ? void 0 : enabled.value) !== false && !connection.value) {
+              connect();
+            }
+          }, delay);
+        } else if (wasConnected) {
+          onDisconnected == null ? void 0 : onDisconnected();
         }
       };
     } catch (e) {
-      sseConnection.value = null;
-      if (sseRetryCount.value < MAX_SSE_RETRIES) {
-        sseRetryCount.value++;
-        setTimeout(setupSSE, SSE_RETRY_DELAY * sseRetryCount.value);
+      status.value = "error";
+      const error = e instanceof Error ? e : new Error(String(e));
+      onError == null ? void 0 : onError(error);
+      if (retryCount.value < maxRetries) {
+        retryCount.value++;
+        const delay = retryDelay * retryCount.value;
+        setTimeout(() => {
+          if (!connection.value) {
+            connect();
+          }
+        }, delay);
       }
     }
-  };
-  const closeSSE = () => {
-    if (sseConnection.value) {
-      sseConnection.value.close();
-      sseConnection.value = null;
+  }
+  function disconnect() {
+    if (connection.value) {
+      connection.value.close();
+      connection.value = null;
+      status.value = "disconnected";
+      retryCount.value = 0;
+      onDisconnected == null ? void 0 : onDisconnected();
     }
-  };
+  }
+  function reconnect() {
+    disconnect();
+    connect();
+  }
+  function resetRetryCount() {
+    retryCount.value = 0;
+  }
+  if (autoConnect && (enabled == null ? void 0 : enabled.value) !== false) {
+    connect();
+  }
   (0, import_vue.onUnmounted)(() => {
-    closeSSE();
+    disconnect();
   });
   return {
-    setupSSE,
-    closeSSE,
-    sseRetryCount
+    // 状态
+    connection,
+    status,
+    retryCount,
+    isConnected: (0, import_vue.computed)(() => status.value === "connected"),
+    isConnecting: (0, import_vue.computed)(() => status.value === "connecting"),
+    // 方法
+    connect,
+    disconnect,
+    reconnect,
+    resetRetryCount
   };
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -0,0 +1,53 @@
+import { ServiceStartupTask } from "@vite-plugin-opencode-assistant/shared";
+/**
+ * Server SSE 状态同步数据
+ */
+export interface ServerSSEStatusSyncData {
+    type: "STATUS_SYNC";
+    isStarted?: boolean;
+    task: ServiceStartupTask;
+    errorType?: string;
+    errorMessage?: string;
+}
+/**
+ * Server SSE 任务更新数据
+ */
+export interface ServerSSETaskUpdateData {
+    type: "TASK_UPDATE";
+    task: ServiceStartupTask;
+    errorType?: string;
+    errorMessage?: string;
+}
+/**
+ * Server SSE 消息类型
+ */
+export type ServerSSEMessage = {
+    type: "CONNECTED";
+} | ServerSSEStatusSyncData | ServerSSETaskUpdateData | {
+    type: "CLEAR_ELEMENTS";
+};
+/**
+ * Server SSE 配置选项
+ */
+export interface ServerSSEOptions {
+    /** 状态同步回调 */
+    onStatusSync?: (data: ServerSSEStatusSyncData) => void;
+    /** 任务更新回调 */
+    onTaskUpdate?: (data: ServerSSETaskUpdateData) => void;
+    /** 清除元素回调 */
+    onClearElements?: () => void;
+    /** 连接成功回调 */
+    onConnected?: () => void;
+    /** 是否启用 */
+    enabled?: boolean;
+}
+/**
+ * 监听 Vite Server SSE 事件
+ * 端点: /__opencode_events__
+ */
+export declare function useServerSSE(options?: ServerSSEOptions): {
+    status: import("vue").Ref<import("./useSSE").SSEConnectionStatus, import("./useSSE").SSEConnectionStatus>;
+    isConnected: import("vue").ComputedRef<boolean>;
+    connect: () => void;
+    disconnect: () => void;
+};

package/lib/client/composables/useServerSSE.js

@@ -0,0 +1,59 @@
+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 useServerSSE_exports = {};
+__export(useServerSSE_exports, {
+  useServerSSE: () => useServerSSE
+});
+module.exports = __toCommonJS(useServerSSE_exports);
+var import_useSSE = require("./useSSE");
+function useServerSSE(options = {}) {
+  const { onStatusSync, onTaskUpdate, onClearElements, onConnected } = options;
+  const { status, isConnected, connect, disconnect } = (0, import_useSSE.useSSE)({
+    endpoint: "/__opencode_events__",
+    autoConnect: false,
+    onMessage: (data) => {
+      const message = data;
+      switch (message.type) {
+        case "CONNECTED":
+          onConnected == null ? void 0 : onConnected();
+          break;
+        case "STATUS_SYNC":
+          onStatusSync == null ? void 0 : onStatusSync(message);
+          break;
+        case "TASK_UPDATE":
+          onTaskUpdate == null ? void 0 : onTaskUpdate(message);
+          break;
+        case "CLEAR_ELEMENTS":
+          onClearElements == null ? void 0 : onClearElements();
+          break;
+      }
+    }
+  });
+  return {
+    // 状态
+    status,
+    isConnected,
+    // 方法
+    connect,
+    disconnect
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useServerSSE
+});

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

@@ -5,9 +5,7 @@ export declare function useServiceStatus(): {
     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

@@ -28,7 +28,6 @@ function useServiceStatus() {
   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...";
@@ -54,20 +53,15 @@ function useServiceStatus() {
   const setStarting = () => {
     serviceStatus.value = "starting";
   };
-  const setThinking = (value) => {
-    thinking.value = value;
-  };
   return {
     currentTask,
     serviceStatus,
     chromeMcpFailed,
     chromeMcpErrorType,
     chromeMcpErrorMessage,
-    thinking,
     loadingText,
     updateStatusFromTask,
-    setStarting,
-    setThinking
+    setStarting
   };
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -1,6 +1,18 @@
+import { type Ref } from "vue";
 import type { OpenCodeWidgetSession } from "@vite-plugin-opencode-assistant/shared";
-export declare function useSessions(showNotification: (msg: string) => void): {
-    sessions: import("vue").Ref<{
+export interface UseSessionsOptions {
+    showNotification: (msg: string) => void;
+    /** Session 更新回调 (从 SSE 事件接收) */
+    onSessionUpdate?: Ref<((session: {
+        id: string;
+        title?: string;
+        time?: {
+            updated?: number;
+        };
+    }) => void) | undefined>;
+}
+export declare function useSessions(options: UseSessionsOptions): {
+    sessions: Ref<{
         id: string;
         title?: string | undefined;
         updatedAt?: (string | number | Date) | undefined;
@@ -15,12 +27,19 @@ export declare function useSessions(showNotification: (msg: string) => void): {
         directory?: string | undefined;
         url?: string | undefined;
     }[]>;
-    loadingSessionList: import("vue").Ref<boolean | undefined, boolean | undefined>;
-    currentSessionId: import("vue").Ref<string | null, string | null>;
+    loadingSessionList: Ref<boolean | undefined, boolean | undefined>;
+    currentSessionId: Ref<string | null, string | null>;
     iframeSrc: import("vue").ComputedRef<string>;
-    iframeLoading: import("vue").Ref<boolean, boolean>;
+    iframeLoading: Ref<boolean, boolean>;
     loadSessions: () => Promise<void>;
     createSession: () => Promise<void>;
     deleteSession: (session: OpenCodeWidgetSession) => Promise<void>;
     selectSession: (session: OpenCodeWidgetSession) => void;
+    updateSessionInfo: (sessionUpdate: {
+        id: string;
+        title?: string;
+        time?: {
+            updated?: number;
+        };
+    }) => void;
 };

package/lib/client/composables/useSessions.js

@@ -59,7 +59,8 @@ __export(useSessions_exports, {
 module.exports = __toCommonJS(useSessions_exports);
 var import_vue = require("vue");
 var import_shared = require("@vite-plugin-opencode-assistant/shared");
-function useSessions(showNotification) {
+function useSessions(options) {
+  const { showNotification } = options;
   const sessions = (0, import_vue.ref)([]);
   const loadingSessionList = (0, import_vue.ref)(void 0);
   const currentSessionId = (0, import_vue.ref)(null);
@@ -90,6 +91,18 @@ function useSessions(showNotification) {
       loadingSessionList.value = false;
     }
   });
+  const updateSessionInfo = (sessionUpdate) => {
+    var _a;
+    const index = sessions.value.findIndex((s) => s.id === sessionUpdate.id);
+    if (index === -1) return;
+    const session = sessions.value[index];
+    if (sessionUpdate.title && sessionUpdate.title !== session.title) {
+      sessions.value[index] = __spreadProps(__spreadValues({}, session), {
+        title: sessionUpdate.title,
+        updatedAt: ((_a = sessionUpdate.time) == null ? void 0 : _a.updated) || Date.now()
+      });
+    }
+  };
   const createSession = () => __async(null, null, function* () {
     try {
       const response = yield fetch(import_shared.SESSIONS_API_PATH, { method: "POST" });
@@ -139,7 +152,8 @@ function useSessions(showNotification) {
     loadSessions,
     createSession,
     deleteSession,
-    selectSession
+    selectSession,
+    updateSessionInfo
   };
 }
 // Annotate the CommonJS export names for ESM import in node: