vite-plugin-opencode-assistant 1.0.27 → 1.0.29

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

@@ -0,0 +1,64 @@
+import { type Ref } from "vue";
+/**
+ * OpenCode SSE 事件 payload
+ */
+export interface OpencodeSSEPayload {
+    type: string;
+    properties: {
+        sessionID?: string;
+        status?: {
+            type: string;
+        };
+        info?: {
+            sessionID?: string;
+            role?: string;
+            time?: {
+                completed?: number;
+                created?: number;
+                updated?: number;
+                archived?: number;
+                compacting?: number;
+            };
+            title?: string;
+            id?: string;
+            summary?: {
+                additions?: number;
+                deletions?: number;
+                files?: number;
+            };
+        };
+        [key: string]: unknown;
+    };
+}
+/**
+ * OpenCode SSE 消息结构
+ */
+export interface OpencodeSSEMessage {
+    payload: OpencodeSSEPayload;
+}
+/**
+ * OpenCode SSE 配置选项
+ */
+export interface OpencodeSSEOptions {
+    /** OpenCode proxy 基础 URL (例如: http://localhost:4098/xxx) */
+    proxyBaseUrl: string;
+    /** 是否启用 */
+    enabled?: Ref<boolean>;
+    /** 事件处理器 */
+    onEvent?: (payload: OpencodeSSEPayload) => void;
+    /** 连接成功回调 */
+    onConnected?: () => void;
+    /** 连接错误回调 */
+    onError?: (error: Error) => void;
+}
+/**
+ * 监听 OpenCode SSE 事件
+ * 端点: /global/event (通过 proxy server)
+ * 只负责连接管理和消息分发，不包含业务逻辑
+ */
+export declare function useOpencodeSSE(options: OpencodeSSEOptions): {
+    status: Ref<import("./useSSE").SSEConnectionStatus, import("./useSSE").SSEConnectionStatus>;
+    isConnected: import("vue").ComputedRef<boolean>;
+    connect: () => void;
+    disconnect: () => void;
+};

package/lib/client/composables/useOpencodeSSE.js

@@ -0,0 +1,52 @@
+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 useOpencodeSSE_exports = {};
+__export(useOpencodeSSE_exports, {
+  useOpencodeSSE: () => useOpencodeSSE
+});
+module.exports = __toCommonJS(useOpencodeSSE_exports);
+var import_useSSE = require("./useSSE");
+function useOpencodeSSE(options) {
+  const { proxyBaseUrl, enabled, onEvent, onConnected, onError } = options;
+  const endpoint = `${proxyBaseUrl}/global/event`;
+  const { status, isConnected, connect, disconnect } = (0, import_useSSE.useSSE)({
+    endpoint,
+    autoConnect: false,
+    enabled,
+    onMessage: (data) => {
+      const message = data;
+      const payload = message.payload;
+      if (!payload) return;
+      onEvent == null ? void 0 : onEvent(payload);
+    },
+    onConnected,
+    onError
+  });
+  return {
+    // 状态
+    status,
+    isConnected,
+    // 方法
+    connect,
+    disconnect
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useOpencodeSSE
+});

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

@@ -0,0 +1,66 @@
+import { type Ref, type ComputedRef } from "vue";
+/**
+ * Session 状态类型
+ */
+export type OpencodeSessionStatusType = "idle" | "running" | "streaming" | "completed";
+/**
+ * Session 思考状态
+ */
+export interface OpencodeSessionThinkingState {
+    thinking: boolean;
+    statusType: OpencodeSessionStatusType;
+    hasPending: boolean;
+}
+/**
+ * Session 更新事件数据
+ */
+export interface OpencodeSessionUpdateData {
+    id: string;
+    title?: string;
+    time?: {
+        created?: number;
+        updated?: number;
+        archived?: number;
+        compacting?: number;
+    };
+    summary?: {
+        additions?: number;
+        deletions?: number;
+        files?: number;
+    };
+}
+/**
+ * OpenCode Session SSE 配置选项
+ */
+export interface OpencodeSessionSSEOptions {
+    /** OpenCode proxy 基础 URL */
+    proxyBaseUrl: string;
+    /** 当前 session ID (响应式) */
+    currentSessionId: Ref<string | null>;
+    /** 是否启用 */
+    enabled?: Ref<boolean>;
+    /** 连接成功回调 */
+    onConnected?: () => void;
+    /** Session 更新回调 (包括标题变化) */
+    onSessionUpdate?: (session: OpencodeSessionUpdateData) => void;
+}
+/**
+ * 监听 OpenCode Session SSE 事件
+ * 专注于 session thinking 状态管理和标题更新
+ */
+export declare function useOpencodeSessionSSE(options: OpencodeSessionSSEOptions): {
+    status: Ref<import("./useSSE").SSEConnectionStatus, import("./useSSE").SSEConnectionStatus>;
+    isConnected: ComputedRef<boolean>;
+    sessionStates: Ref<Record<string, OpencodeSessionThinkingState>, Record<string, OpencodeSessionThinkingState>>;
+    currentThinking: ComputedRef<boolean>;
+    currentSessionState: ComputedRef<OpencodeSessionThinkingState | null>;
+    hasAnyThinking: ComputedRef<boolean>;
+    thinkingSessionCount: ComputedRef<number>;
+    connect: () => void;
+    disconnect: () => void;
+    clearSessionState: (sessionID: string) => void;
+    clearAllSessionStates: () => void;
+    getSessionState: (sessionID: string) => OpencodeSessionThinkingState | undefined;
+    isSessionThinking: (sessionID: string) => boolean;
+    getSessionsThinking: (sessionIds: string[]) => Record<string, boolean>;
+};

package/lib/client/composables/useOpencodeSessionSSE.js

@@ -0,0 +1,187 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __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 useOpencodeSessionSSE_exports = {};
+__export(useOpencodeSessionSSE_exports, {
+  useOpencodeSessionSSE: () => useOpencodeSessionSSE
+});
+module.exports = __toCommonJS(useOpencodeSessionSSE_exports);
+var import_vue = require("vue");
+var import_useOpencodeSSE = require("./useOpencodeSSE");
+function useOpencodeSessionSSE(options) {
+  const { proxyBaseUrl, currentSessionId, enabled, onConnected, onSessionUpdate } = options;
+  const sessionStates = (0, import_vue.ref)({});
+  function isPendingMessage(info) {
+    var _a;
+    return (info == null ? void 0 : info.role) === "assistant" && typeof ((_a = info == null ? void 0 : info.time) == null ? void 0 : _a.completed) !== "number";
+  }
+  function updateThinkingState(sessionID) {
+    const state = sessionStates.value[sessionID];
+    const isThinking = (state == null ? void 0 : state.hasPending) || (state == null ? void 0 : state.statusType) !== "idle";
+    sessionStates.value[sessionID] = {
+      thinking: isThinking,
+      statusType: (state == null ? void 0 : state.statusType) || "idle",
+      hasPending: (state == null ? void 0 : state.hasPending) || false
+    };
+  }
+  function handleEvent(payload) {
+    var _a;
+    const type = payload.type;
+    const props = payload.properties;
+    switch (type) {
+      case "session.updated": {
+        const info = props.info;
+        if (!(info == null ? void 0 : info.id)) return;
+        onSessionUpdate == null ? void 0 : onSessionUpdate({
+          id: info.id,
+          title: info.title,
+          time: info.time,
+          summary: info.summary
+        });
+        break;
+      }
+      case "session.status": {
+        const sessionID = props.sessionID;
+        if (!sessionID) return;
+        const statusType = ((_a = props.status) == null ? void 0 : _a.type) || "idle";
+        sessionStates.value[sessionID] = {
+          thinking: statusType !== "idle",
+          statusType,
+          hasPending: false
+        };
+        updateThinkingState(sessionID);
+        break;
+      }
+      case "message.updated": {
+        const info = props.info;
+        if (!(info == null ? void 0 : info.sessionID)) return;
+        const sessionID = info.sessionID;
+        if (info.role === "assistant") {
+          const hasPending = isPendingMessage(info);
+          const current = sessionStates.value[sessionID] || {
+            thinking: false,
+            statusType: "idle",
+            hasPending: false
+          };
+          sessionStates.value[sessionID] = __spreadProps(__spreadValues({}, current), {
+            hasPending
+          });
+          updateThinkingState(sessionID);
+        }
+        break;
+      }
+      case "message.part.delta": {
+        const sessionID = props.sessionID;
+        if (!sessionID) return;
+        const current = sessionStates.value[sessionID];
+        if (!(current == null ? void 0 : current.hasPending)) {
+          sessionStates.value[sessionID] = {
+            thinking: true,
+            statusType: (current == null ? void 0 : current.statusType) || "idle",
+            hasPending: true
+          };
+        }
+        break;
+      }
+    }
+  }
+  const sse = (0, import_useOpencodeSSE.useOpencodeSSE)({
+    proxyBaseUrl,
+    enabled,
+    onEvent: handleEvent,
+    onConnected
+  });
+  const currentThinking = (0, import_vue.computed)(() => {
+    var _a, _b;
+    const id = currentSessionId.value;
+    if (!id) return false;
+    return (_b = (_a = sessionStates.value[id]) == null ? void 0 : _a.thinking) != null ? _b : false;
+  });
+  const currentSessionState = (0, import_vue.computed)(() => {
+    const id = currentSessionId.value;
+    if (!id) return null;
+    return sessionStates.value[id] || null;
+  });
+  const hasAnyThinking = (0, import_vue.computed)(() => {
+    return Object.values(sessionStates.value).some((state) => state.thinking);
+  });
+  const thinkingSessionCount = (0, import_vue.computed)(() => {
+    return Object.values(sessionStates.value).filter((state) => state.thinking).length;
+  });
+  function clearSessionState(sessionID) {
+    delete sessionStates.value[sessionID];
+  }
+  function clearAllSessionStates() {
+    sessionStates.value = {};
+  }
+  function getSessionState(sessionID) {
+    return sessionStates.value[sessionID];
+  }
+  function isSessionThinking(sessionID) {
+    var _a, _b;
+    return (_b = (_a = sessionStates.value[sessionID]) == null ? void 0 : _a.thinking) != null ? _b : false;
+  }
+  function getSessionsThinking(sessionIds) {
+    return sessionIds.reduce(
+      (acc, id) => {
+        acc[id] = isSessionThinking(id);
+        return acc;
+      },
+      {}
+    );
+  }
+  return {
+    // SSE 基础状态
+    status: sse.status,
+    isConnected: sse.isConnected,
+    // session 状态
+    sessionStates,
+    currentThinking,
+    currentSessionState,
+    hasAnyThinking,
+    thinkingSessionCount,
+    // 方法
+    connect: sse.connect,
+    disconnect: sse.disconnect,
+    clearSessionState,
+    clearAllSessionStates,
+    getSessionState,
+    isSessionThinking,
+    getSessionsThinking
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useOpencodeSessionSSE
+});

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: