@yushaw/sanqian-chat 0.2.4 → 0.2.6

package/dist/main/index.mjs

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/main/client.ts
 import { SanqianSDK } from "@yushaw/sanqian-sdk";
 var SanqianAppClient = class {
@@ -755,7 +762,1266 @@ var FloatingWindow = class _FloatingWindow {
     return this.window;
   }
 };
+
+// src/main/ChatPanel.ts
+import {
+  BrowserWindow as BrowserWindow2,
+  globalShortcut as globalShortcut2,
+  screen as screen2,
+  ipcMain as ipcMain2,
+  app as app2
+} from "electron";
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+var BaseWindowClass;
+var WebContentsViewClass;
+try {
+  const electron = __require("electron");
+  BaseWindowClass = electron.BaseWindow;
+  WebContentsViewClass = electron.WebContentsView;
+} catch {
+}
+var ipcHandlersRegistered2 = false;
+var activeInstance2 = null;
+var DEFAULT_EMBEDDED_WIDTH = 360;
+var DEFAULT_FLOATING_WIDTH = 360;
+var DEFAULT_FLOATING_HEIGHT = 540;
+var ChatPanel = class {
+  constructor(config) {
+    this.visible = false;
+    // Embedded mode view
+    this.embeddedView = null;
+    // Floating mode window and view
+    this.floatingWindow = null;
+    this.floatingView = null;
+    // Shortcuts tracking
+    this.registeredShortcuts = [];
+    // State save timer
+    this.stateSaveTimer = null;
+    // Active streams for cancel support
+    this.activeStreams = /* @__PURE__ */ new Map();
+    // === Private: Host Window Listeners ===
+    this.hostResizeHandler = null;
+    // === Private: Mode Switching ===
+    // Single shared view that moves between containers
+    this.sharedView = null;
+    if (activeInstance2) {
+      console.warn("[ChatPanel] Only one instance supported. Destroying previous.");
+      activeInstance2.destroy();
+    }
+    activeInstance2 = this;
+    this.config = this.normalizeConfig(config);
+    this.embeddedModeAvailable = this.checkEmbeddedModeAvailable();
+    this.mode = this.determineInitialMode();
+    this.embeddedWidth = this.config.width ?? DEFAULT_EMBEDDED_WIDTH;
+    this.floatingWidth = DEFAULT_FLOATING_WIDTH;
+    this.floatingHeight = DEFAULT_FLOATING_HEIGHT;
+    this.currentWidth = this.embeddedWidth;
+    this.loadState();
+    this.currentWidth = this.mode === "embedded" ? this.embeddedWidth : this.floatingWidth;
+    this.initWebContents();
+    this.setupIpcHandlers();
+    app2.whenReady().then(() => this.setupShortcuts());
+    this.setupHostWindowListeners();
+  }
+  setupHostWindowListeners() {
+    let resizePending = false;
+    this.hostResizeHandler = () => {
+      if (resizePending) return;
+      resizePending = true;
+      setImmediate(() => {
+        resizePending = false;
+        if (this.mode === "embedded") {
+          this.handleResponsiveResize();
+        }
+      });
+    };
+    const hostWindow = this.config.hostWindow;
+    if ("on" in hostWindow) {
+      hostWindow.on("resize", this.hostResizeHandler);
+    }
+  }
+  cleanupHostWindowListeners() {
+    if (this.hostResizeHandler) {
+      const hostWindow = this.config.hostWindow;
+      if ("off" in hostWindow) {
+        hostWindow.off("resize", this.hostResizeHandler);
+      }
+      this.hostResizeHandler = null;
+    }
+  }
+  /**
+   * Handle window resize - update layout
+   */
+  handleResponsiveResize() {
+    if (this.visible) {
+      this.updateEmbeddedLayout();
+    } else {
+      this.updateHostLayoutForHidden();
+    }
+  }
+  // === Public API ===
+  /**
+   * Show panel
+   */
+  show() {
+    if (this.visible) return;
+    this.visible = true;
+    if (this.mode === "embedded") {
+      this.showEmbedded();
+    } else {
+      this.showFloating();
+    }
+    this.notifyVisibilityChange();
+  }
+  /**
+   * Hide panel
+   */
+  hide() {
+    if (!this.visible) return;
+    this.visible = false;
+    if (this.mode === "embedded") {
+      this.hideEmbedded();
+    } else {
+      this.hideFloating();
+    }
+    this.notifyVisibilityChange();
+  }
+  /**
+   * Toggle visibility
+   */
+  toggle() {
+    if (this.visible) {
+      this.hide();
+    } else {
+      this.show();
+    }
+  }
+  /**
+   * Get current mode
+   */
+  getMode() {
+    return this.mode;
+  }
+  /**
+   * Set mode
+   */
+  setMode(mode) {
+    if (mode === this.mode) return;
+    if (mode === "embedded" && !this.embeddedModeAvailable) {
+      console.warn("[ChatPanel] Embedded mode not available, staying in floating mode");
+      return;
+    }
+    const wasVisible = this.visible;
+    if (wasVisible) {
+      if (this.mode === "embedded") {
+        this.hideEmbedded();
+      } else {
+        this.hideFloating();
+      }
+    }
+    this.currentWidth = mode === "embedded" ? this.embeddedWidth : this.floatingWidth;
+    if (mode === "embedded") {
+      this.switchToEmbedded();
+    } else {
+      this.switchToFloating();
+    }
+    if (wasVisible) {
+      if (mode === "embedded") {
+        this.showEmbedded();
+      } else {
+        this.showFloating();
+      }
+    }
+    this.mode = mode;
+    this.notifyModeChange();
+    this.saveState();
+  }
+  /**
+   * Toggle mode
+   */
+  toggleMode() {
+    const newMode = this.mode === "embedded" ? "floating" : "embedded";
+    this.setMode(newMode);
+    return this.mode;
+  }
+  /**
+   * Check if visible
+   */
+  isVisible() {
+    return this.visible;
+  }
+  /**
+   * Set width with optional animation
+   */
+  setWidth(width, animate = false) {
+    const clampedWidth = Math.max(this.config.minWidth, width);
+    if (animate && this.currentWidth !== clampedWidth) {
+      this.animateWidth(this.currentWidth, clampedWidth);
+    } else {
+      this.currentWidth = clampedWidth;
+      if (this.mode === "embedded") {
+        this.embeddedWidth = clampedWidth;
+        this.updateEmbeddedLayout();
+      } else {
+        this.floatingWidth = clampedWidth;
+        if (this.floatingWindow) {
+          const bounds = this.floatingWindow.getBounds();
+          this.floatingWindow.setBounds({ ...bounds, width: clampedWidth });
+        }
+      }
+      this.scheduleSaveState();
+    }
+  }
+  /**
+   * Called when resize drag ends - update window min width constraint
+   */
+  onResizeEnd() {
+    if (this.mode === "embedded" && this.visible) {
+      this.updateHostWindowMinWidth(true);
+    }
+  }
+  /**
+   * Animate width change smoothly
+   */
+  animateWidth(fromWidth, toWidth, duration = 200) {
+    const startTime = Date.now();
+    const deltaWidth = toWidth - fromWidth;
+    const step = () => {
+      const elapsed = Date.now() - startTime;
+      const progress = Math.min(elapsed / duration, 1);
+      const eased = 1 - Math.pow(1 - progress, 3);
+      this.currentWidth = Math.round(fromWidth + deltaWidth * eased);
+      if (this.mode === "embedded") {
+        this.updateEmbeddedLayout();
+      } else if (this.floatingWindow) {
+        const bounds = this.floatingWindow.getBounds();
+        this.floatingWindow.setBounds({ ...bounds, width: this.currentWidth });
+      }
+      if (progress < 1) {
+        setImmediate(step);
+      } else {
+        this.currentWidth = toWidth;
+        if (this.mode === "embedded") {
+          this.embeddedWidth = toWidth;
+          if (this.visible) {
+            this.updateHostWindowMinWidth(true);
+          }
+        } else {
+          this.floatingWidth = toWidth;
+        }
+        this.scheduleSaveState();
+      }
+    };
+    step();
+  }
+  /**
+   * Get width
+   */
+  getWidth() {
+    return this.currentWidth;
+  }
+  /**
+   * Get attach state (for floating mode)
+   * Note: Attachment feature not implemented yet - see FloatingWindow.ts for reference
+   */
+  getAttachState() {
+    return "unavailable";
+  }
+  /**
+   * Toggle attach state
+   * Note: Attachment feature not implemented yet - see FloatingWindow.ts for reference
+   */
+  toggleAttach() {
+    return "unavailable";
+  }
+  /**
+   * Get webContents (for IPC)
+   */
+  getWebContents() {
+    return this.webContents;
+  }
+  /**
+   * Destroy panel
+   */
+  destroy() {
+    this.cleanupHostWindowListeners();
+    this.registeredShortcuts.forEach((key) => globalShortcut2.unregister(key));
+    this.registeredShortcuts = [];
+    if (this.stateSaveTimer) {
+      clearTimeout(this.stateSaveTimer);
+      this.stateSaveTimer = null;
+    }
+    if (this.floatingWindow) {
+      this.floatingWindow.destroy();
+      this.floatingWindow = null;
+      this.floatingView = null;
+    }
+    if (this.embeddedView && this.embeddedModeAvailable) {
+      const hostWindow = this.config.hostWindow;
+      try {
+        hostWindow.contentView.removeChildView(this.embeddedView);
+      } catch {
+      }
+      this.embeddedView = null;
+    }
+    this.sharedView = null;
+    if (activeInstance2 === this) {
+      activeInstance2 = null;
+      this.cleanupIpcHandlers();
+    }
+  }
+  // === Private: Initialization ===
+  normalizeConfig(config) {
+    return {
+      hostWindow: config.hostWindow,
+      hostMainView: config.hostMainView,
+      initialMode: config.initialMode ?? "embedded",
+      position: config.position ?? "right",
+      width: config.width ?? 360,
+      minWidth: config.minWidth ?? 240,
+      minHostContentWidth: config.minHostContentWidth ?? 0,
+      resizable: config.resizable ?? true,
+      preloadPath: config.preloadPath,
+      rendererPath: config.rendererPath,
+      devMode: config.devMode ?? false,
+      getClient: config.getClient,
+      getAgentId: config.getAgentId,
+      onLayoutChange: config.onLayoutChange,
+      shortcuts: {
+        toggle: config.shortcuts?.toggle ?? "CommandOrControl+Shift+Space",
+        toggleMode: config.shortcuts?.toggleMode ?? "CommandOrControl+Shift+E"
+      },
+      stateKey: config.stateKey ?? "default",
+      uiConfig: config.uiConfig
+    };
+  }
+  checkEmbeddedModeAvailable() {
+    const isBaseWindow = this.config.hostWindow.constructor.name === "BaseWindow";
+    const hasMainView = this.config.hostMainView !== void 0;
+    return isBaseWindow && hasMainView;
+  }
+  determineInitialMode() {
+    if (!this.embeddedModeAvailable) {
+      return "floating";
+    }
+    return this.config.initialMode;
+  }
+  initWebContents() {
+    if (!WebContentsViewClass) {
+      throw new Error("[ChatPanel] WebContentsView not available. Requires Electron >= 30.0.0");
+    }
+    const view = this.getOrCreateSharedView();
+    if (this.mode === "embedded" && this.embeddedModeAvailable) {
+      this.embeddedView = view;
+    } else {
+      this.floatingWindow = this.createFloatingWindow();
+      this.floatingView = view;
+      this.floatingWindow.contentView.addChildView(view);
+      this.updateFloatingViewBounds();
+    }
+  }
+  // === Private: Embedded Mode ===
+  showEmbedded() {
+    if (!this.embeddedView || !this.embeddedModeAvailable) return;
+    const hostWindow = this.config.hostWindow;
+    this.updateHostWindowMinWidth(true);
+    this.expandHostWindowIfNeeded();
+    hostWindow.contentView.addChildView(this.embeddedView);
+    this.updateEmbeddedLayout();
+  }
+  /**
+   * Update host window minimum width constraint based on chat panel visibility.
+   * When chat is visible: minWidth = minHostContentWidth + chatWidth
+   * When chat is hidden: minWidth = minHostContentWidth
+   */
+  updateHostWindowMinWidth(chatVisible) {
+    const { minHostContentWidth } = this.config;
+    if (minHostContentWidth <= 0) return;
+    const hostWindow = this.config.hostWindow;
+    const [, minHeight] = hostWindow.getMinimumSize();
+    const newMinWidth = chatVisible ? minHostContentWidth + this.currentWidth : minHostContentWidth;
+    hostWindow.setMinimumSize(newMinWidth, minHeight);
+  }
+  /**
+   * Expand host window to the right if main content area would be too narrow.
+   * If expansion would exceed screen bounds, shift window left as needed.
+   */
+  expandHostWindowIfNeeded() {
+    const { minHostContentWidth } = this.config;
+    if (minHostContentWidth <= 0) return;
+    const hostWindow = this.config.hostWindow;
+    const bounds = hostWindow.getBounds();
+    const requiredWidth = minHostContentWidth + this.currentWidth;
+    if (bounds.width < requiredWidth) {
+      const display = screen2.getDisplayMatching(bounds);
+      const screenBounds = display.workArea;
+      const screenRight = screenBounds.x + screenBounds.width;
+      let newX = bounds.x;
+      const newWidth = requiredWidth;
+      if (newX + newWidth > screenRight) {
+        newX = Math.max(screenBounds.x, screenRight - newWidth);
+      }
+      hostWindow.setBounds({
+        x: newX,
+        y: bounds.y,
+        width: newWidth,
+        height: bounds.height
+      });
+    }
+  }
+  hideEmbedded() {
+    if (!this.embeddedView || !this.embeddedModeAvailable) return;
+    const hostWindow = this.config.hostWindow;
+    hostWindow.contentView.removeChildView(this.embeddedView);
+    this.updateHostWindowMinWidth(false);
+    this.updateHostLayoutForHidden();
+  }
+  updateEmbeddedLayout() {
+    if (!this.embeddedView || !this.visible) return;
+    const hostWindow = this.config.hostWindow;
+    const { width, height } = hostWindow.getBounds();
+    const chatWidth = this.currentWidth;
+    const mainWidth = width - chatWidth;
+    if (this.config.position === "left") {
+      this.embeddedView.setBounds({ x: 0, y: 0, width: chatWidth, height });
+    } else {
+      this.embeddedView.setBounds({ x: mainWidth, y: 0, width: chatWidth, height });
+    }
+    this.config.onLayoutChange?.({
+      mainWidth,
+      chatWidth,
+      chatVisible: true
+    });
+  }
+  updateHostLayoutForHidden() {
+    const hostWindow = this.config.hostWindow;
+    const { width } = hostWindow.getBounds();
+    this.config.onLayoutChange?.({
+      mainWidth: width,
+      chatWidth: 0,
+      chatVisible: false
+    });
+  }
+  // === Private: Floating Mode ===
+  createFloatingWindow() {
+    const isWindows = process.platform === "win32";
+    const windowOptions = {
+      width: this.floatingWidth,
+      height: this.floatingHeight,
+      frame: false,
+      transparent: !isWindows,
+      backgroundColor: isWindows ? "#1F1F1F" : "#00000000",
+      alwaysOnTop: true,
+      skipTaskbar: true,
+      show: false,
+      resizable: this.config.resizable,
+      minWidth: this.config.minWidth,
+      minHeight: 300
+    };
+    if (typeof this.floatingX === "number" && typeof this.floatingY === "number") {
+      windowOptions.x = this.floatingX;
+      windowOptions.y = this.floatingY;
+    }
+    const win = new BrowserWindow2(windowOptions);
+    win.on("resize", () => {
+      this.updateFloatingViewBounds();
+      this.scheduleSaveState();
+    });
+    win.on("move", () => {
+      this.scheduleSaveState();
+    });
+    return win;
+  }
+  showFloating() {
+    const isNewWindow = !this.floatingWindow;
+    if (isNewWindow) {
+      this.floatingWindow = this.createFloatingWindow();
+      const view = this.getOrCreateSharedView();
+      this.floatingView = view;
+      this.floatingWindow.contentView.addChildView(view);
+      this.updateFloatingViewBounds();
+      if (typeof this.floatingX !== "number" || typeof this.floatingY !== "number") {
+        this.positionFloatingWindow();
+      }
+    }
+    this.floatingWindow.show();
+    this.floatingWindow.focus();
+  }
+  hideFloating() {
+    if (this.floatingWindow) {
+      this.floatingWindow.hide();
+    }
+  }
+  updateFloatingViewBounds() {
+    if (!this.floatingWindow || !this.floatingView) return;
+    const { width, height } = this.floatingWindow.getBounds();
+    this.floatingView.setBounds({ x: 0, y: 0, width, height });
+  }
+  positionFloatingWindow() {
+    if (!this.floatingWindow) return;
+    const hostBounds = this.getHostWindowBounds();
+    const x = this.config.position === "left" ? hostBounds.x - this.currentWidth : hostBounds.x + hostBounds.width;
+    this.floatingWindow.setBounds({
+      x,
+      y: hostBounds.y,
+      width: this.currentWidth,
+      height: hostBounds.height
+    });
+  }
+  getHostWindowBounds() {
+    return this.config.hostWindow.getBounds();
+  }
+  getOrCreateSharedView() {
+    if (!this.sharedView) {
+      this.sharedView = new WebContentsViewClass({
+        webPreferences: {
+          preload: this.config.preloadPath,
+          contextIsolation: true,
+          nodeIntegration: false
+        }
+      });
+      this.webContents = this.sharedView.webContents;
+      this.webContents.on("context-menu", (event, params) => {
+        if (this.config.devMode) {
+          event.preventDefault();
+          const { Menu, MenuItem } = __require("electron");
+          const menu = new Menu();
+          menu.append(new MenuItem({
+            label: "Inspect Element",
+            click: () => {
+              this.webContents.inspectElement(params.x, params.y);
+            }
+          }));
+          menu.append(new MenuItem({
+            label: "Toggle Developer Tools",
+            click: () => {
+              if (this.webContents.isDevToolsOpened()) {
+                this.webContents.closeDevTools();
+              } else {
+                this.webContents.openDevTools({ mode: "detach" });
+              }
+            }
+          }));
+          menu.popup();
+        }
+      });
+      if (this.config.devMode) {
+        this.webContents.loadURL(this.config.rendererPath);
+      } else {
+        this.webContents.loadFile(this.config.rendererPath);
+      }
+    }
+    return this.sharedView;
+  }
+  switchToEmbedded() {
+    if (!this.embeddedModeAvailable) {
+      console.warn("[ChatPanel] Cannot switch to embedded mode - not available");
+      return;
+    }
+    const view = this.getOrCreateSharedView();
+    if (this.floatingWindow) {
+      try {
+        this.floatingWindow.contentView.removeChildView(view);
+      } catch {
+      }
+      this.floatingWindow.destroy();
+      this.floatingWindow = null;
+    }
+    this.embeddedView = view;
+    this.floatingView = null;
+  }
+  switchToFloating() {
+    const view = this.getOrCreateSharedView();
+    if (this.embeddedModeAvailable) {
+      const hostWindow = this.config.hostWindow;
+      try {
+        hostWindow.contentView.removeChildView(view);
+      } catch {
+      }
+    }
+    this.floatingWindow = this.createFloatingWindow();
+    this.floatingView = view;
+    this.floatingWindow.contentView.addChildView(view);
+    this.updateFloatingViewBounds();
+    this.embeddedView = null;
+    this.updateHostLayoutForHidden();
+  }
+  // === Private: Notifications ===
+  notifyVisibilityChange() {
+    this.webContents.send("chatPanel:visibilityChanged", { visible: this.visible });
+  }
+  notifyModeChange() {
+    this.webContents.send("chatPanel:modeChanged", { mode: this.mode });
+  }
+  // === Private: Shortcuts ===
+  setupShortcuts() {
+    const { shortcuts } = this.config;
+    if (shortcuts.toggle !== false) {
+      const key = shortcuts.toggle;
+      if (globalShortcut2.register(key, () => this.toggle())) {
+        this.registeredShortcuts.push(key);
+      } else {
+        console.warn(`[ChatPanel] Failed to register shortcut: ${key}`);
+      }
+    }
+    if (shortcuts.toggleMode !== false) {
+      const key = shortcuts.toggleMode;
+      if (globalShortcut2.register(key, () => this.toggleMode())) {
+        this.registeredShortcuts.push(key);
+      } else {
+        console.warn(`[ChatPanel] Failed to register shortcut: ${key}`);
+      }
+    }
+  }
+  // === Private: State Persistence ===
+  getStatePath() {
+    const stateDir = path2.join(os2.homedir(), ".sanqian-chat");
+    const safeKey = this.config.stateKey.replace(/[^a-zA-Z0-9._-]/g, "_");
+    return path2.join(stateDir, `${safeKey}-panel.json`);
+  }
+  loadState() {
+    try {
+      const statePath = this.getStatePath();
+      const raw = fs2.readFileSync(statePath, "utf8");
+      const state = JSON.parse(raw);
+      if (typeof state.embeddedWidth === "number") {
+        this.embeddedWidth = Math.max(this.config.minWidth, state.embeddedWidth);
+      } else if (typeof state.width === "number") {
+        this.embeddedWidth = Math.max(this.config.minWidth, state.width);
+      }
+      if (typeof state.floatingWidth === "number") {
+        this.floatingWidth = Math.max(this.config.minWidth, state.floatingWidth);
+      }
+      if (typeof state.floatingHeight === "number") {
+        this.floatingHeight = Math.max(300, state.floatingHeight);
+      }
+      if (typeof state.floatingX === "number") {
+        this.floatingX = state.floatingX;
+      }
+      if (typeof state.floatingY === "number") {
+        this.floatingY = state.floatingY;
+      }
+      if (state.preferredMode && this.embeddedModeAvailable) {
+        this.mode = state.preferredMode;
+      }
+    } catch {
+    }
+  }
+  scheduleSaveState() {
+    if (this.stateSaveTimer) clearTimeout(this.stateSaveTimer);
+    this.stateSaveTimer = setTimeout(() => {
+      this.stateSaveTimer = null;
+      this.saveState();
+    }, 200);
+  }
+  saveState() {
+    try {
+      const statePath = this.getStatePath();
+      if (this.floatingWindow) {
+        const bounds = this.floatingWindow.getBounds();
+        this.floatingWidth = bounds.width;
+        this.floatingHeight = bounds.height;
+        this.floatingX = bounds.x;
+        this.floatingY = bounds.y;
+      }
+      const state = {
+        embeddedWidth: this.embeddedWidth,
+        floatingWidth: this.floatingWidth,
+        floatingHeight: this.floatingHeight,
+        floatingX: this.floatingX,
+        floatingY: this.floatingY,
+        preferredMode: this.mode
+      };
+      fs2.mkdirSync(path2.dirname(statePath), { recursive: true });
+      fs2.writeFileSync(statePath, JSON.stringify(state, null, 2), "utf8");
+    } catch (e) {
+      console.warn("[ChatPanel] Failed to save state:", e);
+    }
+  }
+  // === Private: SDK Access ===
+  getSdk() {
+    const client = this.config.getClient();
+    return client;
+  }
+  // === Private: IPC Handlers ===
+  setupIpcHandlers() {
+    if (ipcHandlersRegistered2) return;
+    ipcHandlersRegistered2 = true;
+    ipcMain2.handle("sanqian-chat:connect", async () => {
+      try {
+        const sdk = activeInstance2?.getSdk();
+        if (!sdk) throw new Error("SDK not available");
+        await sdk.ensureReady();
+        return { success: true };
+      } catch (e) {
+        return { success: false, error: e instanceof Error ? e.message : "Connection failed" };
+      }
+    });
+    ipcMain2.handle("sanqian-chat:isConnected", () => {
+      const sdk = activeInstance2?.getSdk();
+      return sdk?.isConnected() ?? false;
+    });
+    ipcMain2.handle("sanqian-chat:stream", async (event, params) => {
+      const webContents = event.sender;
+      const { streamId, messages, conversationId, agentId: requestedAgentId } = params;
+      const sdk = activeInstance2?.getSdk();
+      const agentId = requestedAgentId ?? activeInstance2?.config.getAgentId();
+      if (!sdk || !agentId) {
+        webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "error", error: "SDK or agent not ready" } });
+        return;
+      }
+      const streamState = { cancelled: false, runId: null };
+      activeInstance2?.activeStreams.set(streamId, streamState);
+      try {
+        await sdk.ensureReady();
+        const sdkMessages = messages.map((m) => ({ role: m.role, content: m.content }));
+        const stream = sdk.chatStream(agentId, sdkMessages, { conversationId, persistHistory: true });
+        for await (const evt of stream) {
+          if (streamState.cancelled) break;
+          if (activeInstance2?.config.devMode) {
+            console.log("[ChatPanel] SDK event:", evt.type, JSON.stringify(evt).slice(0, 200));
+          }
+          switch (evt.type) {
+            case "start": {
+              const startEvt = evt;
+              if (startEvt.run_id) {
+                streamState.runId = startEvt.run_id;
+              }
+              webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "start", run_id: startEvt.run_id } });
+              break;
+            }
+            case "text":
+              webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "text", content: evt.content } });
+              break;
+            case "thinking":
+              webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "thinking", content: evt.content } });
+              break;
+            case "tool_call":
+              webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "tool_call", tool_call: evt.tool_call } });
+              break;
+            case "tool_result":
+              webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "tool_result", tool_call_id: evt.tool_call_id, result: evt.result } });
+              break;
+            case "done":
+              webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "done", conversationId: evt.conversationId, title: evt.title } });
+              break;
+            case "error":
+              webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "error", error: evt.error } });
+              break;
+            default: {
+              const anyEvt = evt;
+              if (anyEvt.type === "interrupt") {
+                webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "interrupt", interrupt_type: anyEvt.interrupt_type, interrupt_payload: anyEvt.interrupt_payload, run_id: anyEvt.run_id } });
+              }
+              break;
+            }
+          }
+        }
+      } catch (e) {
+        if (!streamState.cancelled) {
+          webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "error", error: e instanceof Error ? e.message : "Stream error" } });
+        }
+      } finally {
+        activeInstance2?.activeStreams.delete(streamId);
+      }
+    });
+    ipcMain2.handle("sanqian-chat:cancelStream", (_, params) => {
+      const stream = activeInstance2?.activeStreams.get(params.streamId);
+      if (stream) {
+        stream.cancelled = true;
+        if (stream.runId) {
+          const sdk = activeInstance2?.getSdk();
+          if (sdk) {
+            try {
+              sdk.cancelRun(stream.runId);
+            } catch (e) {
+              console.warn("[ChatPanel] Failed to cancel run:", e);
+            }
+          }
+        }
+        activeInstance2?.activeStreams.delete(params.streamId);
+      }
+      return { success: true };
+    });
+    ipcMain2.handle("sanqian-chat:hitlResponse", (_, params) => {
+      const sdk = activeInstance2?.getSdk();
+      if (sdk && params.runId) {
+        sdk.sendHitlResponse(params.runId, params.response);
+      }
+      return { success: true };
+    });
+    ipcMain2.handle("sanqian-chat:listConversations", async (_, params) => {
+      const sdk = activeInstance2?.getSdk();
+      if (!sdk) return { success: false, error: "SDK not ready" };
+      try {
+        const result = await sdk.listConversations({
+          limit: params?.limit,
+          offset: params?.offset
+        });
+        return { success: true, data: result };
+      } catch (e) {
+        return { success: false, error: e instanceof Error ? e.message : "Failed to list" };
+      }
+    });
+    ipcMain2.handle("sanqian-chat:getConversation", async (_, params) => {
+      const sdk = activeInstance2?.getSdk();
+      if (!sdk) return { success: false, error: "SDK not ready" };
+      try {
+        const result = await sdk.getConversation(params.conversationId, { messageLimit: params.messageLimit });
+        let messages = result?.messages;
+        const sdkWithHistory = sdk;
+        if (typeof sdkWithHistory.getMessages === "function") {
+          try {
+            const history = await sdkWithHistory.getMessages(params.conversationId, { limit: params.messageLimit });
+            if (history?.messages && history.messages.length > 0) {
+              messages = history.messages;
+            }
+          } catch (e) {
+            console.warn("[ChatPanel] getMessages failed, fallback to getConversation:", e);
+          }
+        }
+        return { success: true, data: { ...result, messages } };
+      } catch (e) {
+        return { success: false, error: e instanceof Error ? e.message : "Failed to get" };
+      }
+    });
+    ipcMain2.handle("sanqian-chat:deleteConversation", async (_, params) => {
+      const sdk = activeInstance2?.getSdk();
+      if (!sdk) return { success: false, error: "SDK not ready" };
+      try {
+        await sdk.deleteConversation(params.conversationId);
+        return { success: true };
+      } catch (e) {
+        return { success: false, error: e instanceof Error ? e.message : "Failed to delete" };
+      }
+    });
+    ipcMain2.handle("sanqian-chat:hide", () => {
+      activeInstance2?.hide();
+      return { success: true };
+    });
+    ipcMain2.handle("sanqian-chat:setAlwaysOnTop", (_event, params) => {
+      if (!activeInstance2?.floatingWindow) return { success: false, error: "Floating window not available" };
+      activeInstance2.floatingWindow.setAlwaysOnTop(params.alwaysOnTop);
+      return { success: true };
+    });
+    ipcMain2.handle("sanqian-chat:getAlwaysOnTop", () => {
+      if (!activeInstance2?.floatingWindow) return { success: false, error: "Floating window not available" };
+      return { success: true, data: activeInstance2.floatingWindow.isAlwaysOnTop() };
+    });
+    ipcMain2.handle("sanqian-chat:getUiConfig", () => {
+      return { success: true, data: activeInstance2?.config.uiConfig ?? null };
+    });
+    ipcMain2.handle("sanqian-chat:setBackgroundColor", (_event, params) => {
+      if (!activeInstance2?.floatingWindow) return { success: false, error: "Floating window not available" };
+      try {
+        activeInstance2.floatingWindow.setBackgroundColor(params.color);
+        return { success: true };
+      } catch (e) {
+        return { success: false, error: e instanceof Error ? e.message : "Failed to set background color" };
+      }
+    });
+    ipcMain2.handle("chatPanel:getMode", () => {
+      return activeInstance2?.getMode() ?? "floating";
+    });
+    ipcMain2.handle("chatPanel:setMode", (_, mode) => {
+      activeInstance2?.setMode(mode);
+      return { success: true };
+    });
+    ipcMain2.handle("chatPanel:toggleMode", () => {
+      return activeInstance2?.toggleMode() ?? "floating";
+    });
+    ipcMain2.handle("chatPanel:isVisible", () => {
+      return activeInstance2?.isVisible() ?? false;
+    });
+    ipcMain2.handle("chatPanel:show", () => {
+      activeInstance2?.show();
+      return { success: true };
+    });
+    ipcMain2.handle("chatPanel:hide", () => {
+      activeInstance2?.hide();
+      return { success: true };
+    });
+    ipcMain2.handle("chatPanel:toggle", () => {
+      activeInstance2?.toggle();
+      return { success: true };
+    });
+    ipcMain2.handle("chatPanel:getWidth", () => {
+      return activeInstance2?.getWidth() ?? 360;
+    });
+    ipcMain2.handle("chatPanel:setWidth", (_, params) => {
+      activeInstance2?.setWidth(params.width, params.animate);
+      return { success: true };
+    });
+    ipcMain2.handle("chatPanel:onResizeEnd", () => {
+      activeInstance2?.onResizeEnd();
+      return { success: true };
+    });
+    ipcMain2.handle("chatPanel:getAttachState", () => {
+      return { success: true, data: activeInstance2?.getAttachState() ?? "unavailable" };
+    });
+    ipcMain2.handle("chatPanel:toggleAttach", () => {
+      const newState = activeInstance2?.toggleAttach() ?? "unavailable";
+      return { success: true, data: newState };
+    });
+    ipcMain2.handle("chatPanel:getUiConfig", () => {
+      return { success: true, data: activeInstance2?.config.uiConfig ?? null };
+    });
+  }
+  cleanupIpcHandlers() {
+    if (!ipcHandlersRegistered2) return;
+    ipcMain2.removeHandler("sanqian-chat:connect");
+    ipcMain2.removeHandler("sanqian-chat:isConnected");
+    ipcMain2.removeHandler("sanqian-chat:stream");
+    ipcMain2.removeHandler("sanqian-chat:cancelStream");
+    ipcMain2.removeHandler("sanqian-chat:hitlResponse");
+    ipcMain2.removeHandler("sanqian-chat:listConversations");
+    ipcMain2.removeHandler("sanqian-chat:getConversation");
+    ipcMain2.removeHandler("sanqian-chat:deleteConversation");
+    ipcMain2.removeHandler("sanqian-chat:hide");
+    ipcMain2.removeHandler("sanqian-chat:setAlwaysOnTop");
+    ipcMain2.removeHandler("sanqian-chat:getAlwaysOnTop");
+    ipcMain2.removeHandler("sanqian-chat:getUiConfig");
+    ipcMain2.removeHandler("sanqian-chat:setBackgroundColor");
+    ipcMain2.removeHandler("chatPanel:getMode");
+    ipcMain2.removeHandler("chatPanel:setMode");
+    ipcMain2.removeHandler("chatPanel:toggleMode");
+    ipcMain2.removeHandler("chatPanel:isVisible");
+    ipcMain2.removeHandler("chatPanel:show");
+    ipcMain2.removeHandler("chatPanel:hide");
+    ipcMain2.removeHandler("chatPanel:toggle");
+    ipcMain2.removeHandler("chatPanel:getWidth");
+    ipcMain2.removeHandler("chatPanel:setWidth");
+    ipcMain2.removeHandler("chatPanel:onResizeEnd");
+    ipcMain2.removeHandler("chatPanel:getAttachState");
+    ipcMain2.removeHandler("chatPanel:toggleAttach");
+    ipcMain2.removeHandler("chatPanel:getUiConfig");
+    ipcHandlersRegistered2 = false;
+  }
+};
+
+// src/main/WindowAttachment.ts
+import { screen as screen3 } from "electron";
+var WindowAttachment = class {
+  constructor(chatWindow, config) {
+    this.pollTimer = null;
+    this.reattachHandler = null;
+    // Throttle state
+    this.updatePending = false;
+    this.throttledUpdatePosition = () => {
+      if (this.updatePending) return;
+      this.updatePending = true;
+      setImmediate(() => {
+        this.updatePosition();
+        this.updatePending = false;
+      });
+    };
+    // === Event Handlers ===
+    this.handleTargetMinimize = () => {
+      switch (this.config.onMinimize) {
+        case "hide":
+          this.chatWindow.hide();
+          break;
+        case "minimize":
+          this.chatWindow.minimize();
+          break;
+        case "detach":
+          break;
+      }
+    };
+    this.handleTargetRestore = () => {
+      if (this.config.onMinimize === "hide") {
+        this.chatWindow.show();
+      } else if (this.config.onMinimize === "minimize") {
+        this.chatWindow.restore();
+      }
+      this.updatePosition();
+    };
+    this.handleTargetMaximize = () => {
+      const targetBounds = this.config.window.getBounds();
+      const display = screen3.getDisplayMatching(targetBounds);
+      const chatWidth = this.chatWindow.getBounds().width;
+      if (targetBounds.width + chatWidth + this.config.gap > display.workArea.width) {
+        this.chatWindow.hide();
+      } else {
+        this.updatePosition();
+      }
+    };
+    this.handleTargetUnmaximize = () => {
+      if (!this.chatWindow.isVisible() && this.state.isAttached) {
+        this.chatWindow.show();
+      }
+      this.updatePosition();
+    };
+    this.handleTargetEnterFullScreen = () => {
+      this.chatWindow.hide();
+    };
+    this.handleTargetLeaveFullScreen = () => {
+      if (this.state.isAttached) {
+        this.chatWindow.show();
+        this.updatePosition();
+      }
+    };
+    this.handleTargetClose = () => {
+    };
+    this.handleTargetClosed = () => {
+      this.detach();
+      if (this.config.onClose === "hide") {
+        this.chatWindow.hide();
+      } else {
+        this.chatWindow.destroy();
+      }
+    };
+    this.handleChatMove = () => {
+      if (!this.state.isAttached || !this.state.lastTargetBounds) return;
+      const chatBounds = this.chatWindow.getBounds();
+      const expectedBounds = this.calculateAttachedBounds(
+        this.state.lastTargetBounds,
+        chatBounds
+      );
+      const dx = Math.abs(chatBounds.x - expectedBounds.x);
+      const dy = Math.abs(chatBounds.y - expectedBounds.y);
+      if (dx > 10 || dy > 10) {
+        this.state.isAttached = false;
+        this.onDetached();
+      }
+    };
+    this.chatWindow = chatWindow;
+    this.config = this.normalizeConfig(config);
+    this.state = {
+      isAttached: true,
+      position: this.config.position,
+      lastTargetBounds: null
+    };
+  }
+  /**
+   * Start attachment listeners
+   */
+  attach() {
+    const target = this.config.window;
+    target.on("move", this.throttledUpdatePosition);
+    target.on("resize", this.throttledUpdatePosition);
+    target.on("minimize", this.handleTargetMinimize);
+    target.on("restore", this.handleTargetRestore);
+    target.on("maximize", this.handleTargetMaximize);
+    target.on("unmaximize", this.handleTargetUnmaximize);
+    target.on("enter-full-screen", this.handleTargetEnterFullScreen);
+    target.on("leave-full-screen", this.handleTargetLeaveFullScreen);
+    target.on("close", this.handleTargetClose);
+    target.on("closed", this.handleTargetClosed);
+    if (this.config.allowDetach) {
+      this.chatWindow.on("move", this.handleChatMove);
+    }
+    this.updatePosition();
+    if (process.platform === "win32") {
+      this.startPolling();
+    }
+  }
+  /**
+   * Stop attachment listeners
+   */
+  detach() {
+    const target = this.config.window;
+    target.off("move", this.throttledUpdatePosition);
+    target.off("resize", this.throttledUpdatePosition);
+    target.off("minimize", this.handleTargetMinimize);
+    target.off("restore", this.handleTargetRestore);
+    target.off("maximize", this.handleTargetMaximize);
+    target.off("unmaximize", this.handleTargetUnmaximize);
+    target.off("enter-full-screen", this.handleTargetEnterFullScreen);
+    target.off("leave-full-screen", this.handleTargetLeaveFullScreen);
+    target.off("close", this.handleTargetClose);
+    target.off("closed", this.handleTargetClosed);
+    if (this.config.allowDetach) {
+      this.chatWindow.off("move", this.handleChatMove);
+    }
+    this.stopPolling();
+    this.stopReattachListener();
+  }
+  /**
+   * Update chat window position to match target
+   */
+  updatePosition() {
+    if (!this.state.isAttached) return;
+    const target = this.config.window;
+    if (target.isDestroyed() || target.isMinimized()) return;
+    const targetBounds = target.getBounds();
+    const chatBounds = this.chatWindow.getBounds();
+    const newBounds = this.calculateAttachedBounds(targetBounds, chatBounds);
+    const safeBounds = this.constrainToScreen(newBounds);
+    this.chatWindow.setBounds(safeBounds);
+    this.state.lastTargetBounds = targetBounds;
+  }
+  /**
+   * Set state change callback
+   */
+  onStateChange(callback) {
+    this.onStateChangeCallback = callback;
+  }
+  /**
+   * Toggle attach state
+   */
+  toggle() {
+    if (this.state.isAttached) {
+      this.manualDetach();
+      return "detached";
+    } else {
+      this.manualAttach();
+      return "attached";
+    }
+  }
+  /**
+   * Manual detach
+   */
+  manualDetach() {
+    this.state.isAttached = false;
+    this.notifyStateChange("detached");
+    if (this.config.allowReattach) {
+      this.startReattachListener();
+    }
+  }
+  /**
+   * Manual attach
+   */
+  manualAttach() {
+    this.state.isAttached = true;
+    this.stopReattachListener();
+    this.updatePosition();
+    this.notifyStateChange("attached");
+  }
+  /**
+   * Get current attach state
+   */
+  get isAttached() {
+    return this.state.isAttached;
+  }
+  /**
+   * Get current position
+   */
+  get position() {
+    return this.state.position;
+  }
+  // === Private Methods ===
+  normalizeConfig(config) {
+    return {
+      window: config.window,
+      position: config.position ?? "right",
+      gap: config.gap ?? 0,
+      syncSize: config.syncSize ?? true,
+      onMinimize: config.onMinimize ?? "hide",
+      onClose: config.onClose ?? "hide",
+      allowDetach: config.allowDetach ?? true,
+      allowReattach: config.allowReattach ?? true,
+      reattachThreshold: config.reattachThreshold ?? 20
+    };
+  }
+  calculateAttachedBounds(targetBounds, chatBounds) {
+    const { position, gap, syncSize } = this.config;
+    const result = { ...chatBounds };
+    switch (position) {
+      case "right":
+        result.x = targetBounds.x + targetBounds.width + gap;
+        result.y = targetBounds.y;
+        if (syncSize) result.height = targetBounds.height;
+        break;
+      case "left":
+        result.x = targetBounds.x - chatBounds.width - gap;
+        result.y = targetBounds.y;
+        if (syncSize) result.height = targetBounds.height;
+        break;
+      case "top":
+        result.x = targetBounds.x;
+        result.y = targetBounds.y - chatBounds.height - gap;
+        if (syncSize) result.width = targetBounds.width;
+        break;
+      case "bottom":
+        result.x = targetBounds.x;
+        result.y = targetBounds.y + targetBounds.height + gap;
+        if (syncSize) result.width = targetBounds.width;
+        break;
+    }
+    return result;
+  }
+  constrainToScreen(bounds) {
+    const display = screen3.getDisplayMatching(bounds);
+    const workArea = display.workArea;
+    return {
+      x: Math.max(workArea.x, Math.min(bounds.x, workArea.x + workArea.width - bounds.width)),
+      y: Math.max(workArea.y, Math.min(bounds.y, workArea.y + workArea.height - bounds.height)),
+      width: Math.min(bounds.width, workArea.width),
+      height: Math.min(bounds.height, workArea.height)
+    };
+  }
+  notifyStateChange(state) {
+    this.onStateChangeCallback?.(state);
+  }
+  onDetached() {
+    console.log("[WindowAttachment] Detached from target window");
+    this.notifyStateChange("detached");
+    if (this.config.allowReattach) {
+      this.startReattachListener();
+    }
+  }
+  // === Reattach Listener ===
+  startReattachListener() {
+    this.stopReattachListener();
+    this.reattachHandler = () => {
+      if (this.state.isAttached) {
+        this.stopReattachListener();
+        return;
+      }
+      const target = this.config.window;
+      if (target.isDestroyed()) {
+        this.stopReattachListener();
+        return;
+      }
+      const targetBounds = target.getBounds();
+      const chatBounds = this.chatWindow.getBounds();
+      const threshold = this.config.reattachThreshold;
+      const nearRight = Math.abs(chatBounds.x - (targetBounds.x + targetBounds.width)) < threshold;
+      const nearLeft = Math.abs(chatBounds.x + chatBounds.width - targetBounds.x) < threshold;
+      const verticalOverlap = chatBounds.y < targetBounds.y + targetBounds.height && chatBounds.y + chatBounds.height > targetBounds.y;
+      if (verticalOverlap && (nearRight || nearLeft)) {
+        this.state.isAttached = true;
+        this.state.position = nearRight ? "right" : "left";
+        this.updatePosition();
+        this.notifyStateChange("attached");
+        this.stopReattachListener();
+        console.log("[WindowAttachment] Reattached to target window");
+      }
+    };
+    this.chatWindow.on("moved", this.reattachHandler);
+  }
+  stopReattachListener() {
+    if (this.reattachHandler) {
+      this.chatWindow.off("moved", this.reattachHandler);
+      this.reattachHandler = null;
+    }
+  }
+  // === Windows Polling (Aero Snap workaround) ===
+  startPolling() {
+    this.pollTimer = setInterval(() => {
+      if (!this.state.isAttached) return;
+      const target = this.config.window;
+      if (target.isDestroyed() || target.isMinimized()) return;
+      const currentBounds = target.getBounds();
+      const lastBounds = this.state.lastTargetBounds;
+      if (lastBounds && (currentBounds.x !== lastBounds.x || currentBounds.y !== lastBounds.y || currentBounds.width !== lastBounds.width || currentBounds.height !== lastBounds.height)) {
+        this.updatePosition();
+      }
+    }, 100);
+  }
+  stopPolling() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+};
 export {
+  ChatPanel,
   FloatingWindow,
-  SanqianAppClient
+  SanqianAppClient,
+  WindowAttachment
 };