[Init] Initial commit - NetMesh terminal manager

electron/bridges/aiBridge/sdk/codebuddySessionManager.cjs

@@ -0,0 +1,430 @@
+"use strict";
+
+/**
+ * CodeBuddy V2 Session Manager — @experimental
+ *
+ * Manages persistent multi-turn sessions using the SDK's unstable_v2 Session
+ * API (createSession / resumeSession). Falls back to the legacy query() path
+ * when the V2 API is unavailable.
+ *
+ * Benefits over query()-per-turn:
+ * - CLI process stays warm across turns (faster subsequent responses)
+ * - True multi-turn context without replaying history
+ * - Supports steer (mid-turn追加消息) via session.send()
+ */
+
+const {
+  buildCodebuddyQueryOptions,
+  buildCodebuddyPromptInput,
+  buildCodebuddyHooks,
+  buildCodebuddyElicitation,
+  translateCodebuddyMessage,
+  inspectCodebuddyMessageContent,
+  codebuddyResultFallbackText,
+  classifyCodebuddySpawnError,
+} = require("./codebuddyDriver.cjs");
+
+/**
+ * Compute a stable fingerprint from option-affecting fields so we can detect
+ * when the user changes model, env, permission mode, tools, etc. between turns.
+ * Only JSON-serializable fields are included; function-valued fields (hooks,
+ * canUseTool, elicitation) are excluded since they are rebuilt every turn.
+ */
+function computeOptionsFingerprint(sessionOptions) {
+  const relevant = {
+    cwd: sessionOptions.cwd,
+    model: sessionOptions.model,
+    env: sessionOptions.env,
+    pathToCodebuddyCode: sessionOptions.pathToCodebuddyCode,
+    mcpServers: sessionOptions.mcpServers,
+    permissionMode: sessionOptions.permissionMode,
+    extraArgs: sessionOptions.extraArgs,
+    systemPrompt: sessionOptions.systemPrompt,
+    tools: sessionOptions.tools,
+    disallowedTools: sessionOptions.disallowedTools,
+    settingSources: sessionOptions.settingSources,
+    maxTurns: sessionOptions.maxTurns,
+    agents: sessionOptions.agents,
+    thinking: sessionOptions.thinking,
+    effort: sessionOptions.effort,
+    hasHooks: Boolean(sessionOptions.hooks),
+    hasCanUseTool: typeof sessionOptions.canUseTool === "function",
+    hasElicitation: Boolean(sessionOptions.elicitation),
+  };
+  try {
+    return JSON.stringify(relevant);
+  } catch {
+    return null;
+  }
+}
+
+function createSessionCallbackState(sessionOptions) {
+  const state = {
+    elicitation: sessionOptions.elicitation,
+    elicitationDelegate: null,
+  };
+  if (state.elicitation) {
+    state.elicitationDelegate = {
+      create(request, options) {
+        const handler = state.elicitation;
+        return handler?.create
+          ? handler.create(request, options)
+          : Promise.resolve({ action: "cancel" });
+      },
+      complete(notification) {
+        return state.elicitation?.complete?.(notification);
+      },
+    };
+  }
+  return state;
+}
+
+function refreshSessionCallbacks(entry, sessionOptions) {
+  if (sessionOptions.hooks) {
+    if (typeof entry.session.setHooks !== "function") return false;
+    entry.session.setHooks(sessionOptions.hooks);
+  }
+  if (typeof sessionOptions.canUseTool === "function") {
+    if (typeof entry.session.setCanUseTool !== "function") return false;
+    entry.session.setCanUseTool(sessionOptions.canUseTool);
+  }
+  if (sessionOptions.elicitation) {
+    if (!entry.callbackState?.elicitationDelegate) return false;
+    entry.callbackState.elicitation = sessionOptions.elicitation;
+  }
+  return true;
+}
+
+class CodebuddySessionManager {
+  constructor({ loadSdk } = {}) {
+    /** @type {Map<string, {
+     *   session: object,
+     *   fingerprint: string|null,
+     *   callbackState?: ReturnType<typeof createSessionCallbackState>,
+     * }>} */
+    this.sessions = new Map();
+    /** @type {Map<string, { resolve: Function, reject: Function }>} */
+    this.elicitationPending = new Map();
+    this.loadSdk = loadSdk || (() => import("@tencent-ai/agent-sdk"));
+  }
+
+  /**
+   * Get an existing session or create/resume one.
+   * If the session exists but its option-affecting fields have changed,
+   * the stale session is closed and a fresh one is created.
+   * @param {object} args
+   * @param {string} args.sessionKey  unique key (chatSessionId + backend + binPath)
+   * @param {object} args.sessionOptions  SDK SessionOptions
+   * @param {string} [args.resumeSessionId]  resume an existing session by ID
+   * @returns {Promise<object|null>} session instance or null if V2 unavailable
+   */
+  async getOrCreateSession({ sessionKey, sessionOptions, resumeSessionId }) {
+    const fingerprint = computeOptionsFingerprint(sessionOptions);
+    const existing = this.sessions.get(sessionKey);
+    if (existing) {
+      // Reuse only when serialized options still match, but always refresh
+      // turn-scoped callbacks so events target the current request emitter.
+      if (fingerprint !== null && existing.fingerprint === fingerprint) {
+        try {
+          if (refreshSessionCallbacks(existing, sessionOptions)) {
+            return existing.session;
+          }
+        } catch {
+          // Recreate below if the installed SDK cannot refresh callbacks.
+        }
+      }
+      // Options changed — close the stale session and create a fresh one.
+      try { existing.session.close(); } catch { /* best effort */ }
+      this.sessions.delete(sessionKey);
+    }
+
+    let sdk;
+    try {
+      sdk = await this.loadSdk();
+    } catch {
+      return null;
+    }
+
+    const createSession = sdk.unstable_v2_createSession;
+    const resumeSession = sdk.unstable_v2_resumeSession;
+    if (!createSession || !resumeSession) return null;
+
+    let session;
+    try {
+      const callbackState = createSessionCallbackState(sessionOptions);
+      const sdkSessionOptions = callbackState.elicitationDelegate
+        ? { ...sessionOptions, elicitation: callbackState.elicitationDelegate }
+        : sessionOptions;
+      if (resumeSessionId) {
+        session = resumeSession(resumeSessionId, sdkSessionOptions);
+      } else {
+        session = createSession(sdkSessionOptions);
+      }
+      // Do not connect before the first send. In resume mode, send() marks the
+      // initialization as having a prompt so the SDK does not replay historical
+      // messages into the new turn's stream.
+      this.sessions.set(sessionKey, { session, fingerprint, callbackState });
+      return session;
+    } catch {
+      // A factory failure can still leave a partially constructed session.
+      try { session?.close(); } catch { /* best effort */ }
+      // V2 session creation failed — caller should fall back to query().
+      return null;
+    }
+  }
+
+  /**
+   * Run a turn using the V2 Session API.
+   * Returns { sessionId, usedV2: true } on success, or null to signal fallback.
+   */
+  async runTurn({
+    sessionKey, prompt, attachments, options, emitter,
+    sessionOptions, resumeSessionId,
+  }) {
+    const signal = options.abortController?.signal;
+    if (signal?.aborted) {
+      emitter.emitDone();
+      return { sessionId: null, usedV2: true };
+    }
+
+    const session = await this.getOrCreateSession({
+      sessionKey, sessionOptions, resumeSessionId,
+    });
+    if (!session) {
+      if (signal?.aborted) {
+        emitter.emitDone();
+        return { sessionId: null, usedV2: true };
+      }
+      return null; // signal caller to use query() fallback
+    }
+
+    const promptInput = buildCodebuddyPromptInput(prompt, attachments);
+    let sessionId = session.sessionId || null;
+    let hasContent = false;
+    let hasAssistantText = false;
+    let hasStreamedText = false;
+    let hasStreamedReasoning = false;
+    let hasTerminalError = false;
+    let resultFallbackText = "";
+    let emittedSessionId = null;
+    let removeAbortListener = null;
+
+    try {
+      // Register before sending so cancellation during connection or send
+      // cannot start a prompt without also interrupting the SDK session.
+      const interruptSession = () => {
+        if (typeof session.interrupt === "function") {
+          void Promise.resolve(session.interrupt()).catch((err) => {
+            console.debug("[CodeBuddy SDK] session interrupt failed:", err?.message || err);
+          });
+        }
+      };
+      if (signal) {
+        signal.addEventListener("abort", interruptSession, { once: true });
+        removeAbortListener = () => signal.removeEventListener("abort", interruptSession);
+        if (signal.aborted) {
+          interruptSession();
+          emitter.emitDone();
+          return { sessionId, usedV2: true };
+        }
+      }
+
+      try {
+        // Send before the initial connection so resumed sessions suppress
+        // historical replay and stream only the response to this prompt.
+        if (typeof promptInput === "string") {
+          await session.send(promptInput);
+        } else {
+          // Async iterable of UserMessage — send first message.
+          for await (const msg of promptInput) {
+            await session.send(msg);
+          }
+        }
+      } catch {
+        // Initial transport setup happens inside send(). Release any acquired
+        // session lock/process before the caller falls back to legacy query().
+        this.closeSession(sessionKey);
+        if (signal?.aborted) {
+          emitter.emitDone();
+          return { sessionId, usedV2: true };
+        }
+        return null;
+      }
+
+      if (signal?.aborted) {
+        emitter.emitDone();
+        return { sessionId, usedV2: true };
+      }
+      if (sessionId) {
+        emitter.sessionId(sessionId);
+        emittedSessionId = sessionId;
+      }
+
+      // Stream responses.
+      for await (const message of session.stream()) {
+        if (options.abortController?.signal?.aborted) {
+          try { await session.interrupt(); } catch (err) {
+            // Best effort — surface for diagnostics without failing the turn.
+            console.debug("[CodeBuddy SDK] session interrupt failed:", err?.message || err);
+          }
+          break;
+        }
+        if (message?.session_id && message.session_id !== sessionId) {
+          sessionId = message.session_id;
+        }
+        if (sessionId && sessionId !== emittedSessionId) {
+          emitter.sessionId(sessionId);
+          emittedSessionId = sessionId;
+        }
+        const contentState = inspectCodebuddyMessageContent(message);
+        if (contentState.hasContent) hasContent = true;
+        if (contentState.hasText) hasAssistantText = true;
+        resultFallbackText ||= codebuddyResultFallbackText(message);
+        const translation = translateCodebuddyMessage(
+          message,
+          emitter,
+          {
+            skipAssistantText: hasStreamedText,
+            skipAssistantReasoning: hasStreamedReasoning,
+            skipSessionId: true,
+          },
+        );
+        if (translation?.terminalError) hasTerminalError = true;
+        if (contentState.streamedText) hasStreamedText = true;
+        if (contentState.streamedReasoning) hasStreamedReasoning = true;
+      }
+
+      if (hasTerminalError) {
+        return { sessionId, usedV2: true };
+      }
+      if (!hasAssistantText && resultFallbackText) {
+        emitter.text(resultFallbackText);
+        hasContent = true;
+      }
+      if (!hasContent && !options.abortController?.signal?.aborted) {
+        emitter.emitError(
+          "CodeBuddy returned an empty response. Run `codebuddy` in a terminal to log in, " +
+          "or set CODEBUDDY_API_KEY / CODEBUDDY_AUTH_TOKEN.",
+        );
+        return { sessionId, usedV2: true };
+      }
+      emitter.emitDone();
+      return { sessionId, usedV2: true };
+    } catch (error) {
+      if (signal?.aborted) {
+        emitter.emitDone();
+        return { sessionId, usedV2: true };
+      }
+      // A stream failure means the transport is no longer safe to reuse. Close
+      // it now so the next turn can create/resume a fresh V2 session.
+      this.closeSession(sessionKey);
+      const classified = classifyCodebuddySpawnError(error);
+      if (classified.isSpawnEnoent) {
+        emitter.emitError(
+          "CodeBuddy CLI not found or not runnable. " +
+          "Install codebuddy and ensure it's on PATH, or set CODEBUDDY_CODE_PATH.",
+        );
+      } else {
+        emitter.emitError(classified.message || "CodeBuddy turn failed");
+      }
+      return { sessionId, usedV2: true };
+    } finally {
+      removeAbortListener?.();
+    }
+  }
+
+  /**
+   * Report mid-turn steer as unsupported for the current V2 Session API.
+   */
+  async steer() {
+    // SDK 0.3.230 Session.send() starts a new turn by resetting the shared
+    // message iterator and discarding pending messages. Calling it while
+    // runTurn() owns session.stream() can strand that active consumer.
+    // Keep this disabled until the SDK exposes a dedicated mid-turn steer API.
+    return { status: "unsupported" };
+  }
+
+  /**
+   * Set model at runtime without rebuilding the session.
+   */
+  async setModel(sessionKey, model) {
+    const entry = this.sessions.get(sessionKey);
+    if (!entry) return false;
+    try {
+      await entry.session.setModel(model);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Close a specific session.
+   */
+  closeSession(sessionKey) {
+    const entry = this.sessions.get(sessionKey);
+    if (entry) {
+      try { entry.session.close(); } catch { /* best effort */ }
+      this.sessions.delete(sessionKey);
+    }
+  }
+
+  /**
+   * Close all sessions for a given chat session prefix.
+   * Also cancels pending elicitations scoped to the chat so main-process
+   * promises cannot leak when the renderer never responds (chat closed).
+   */
+  closeForChat(chatSessionId) {
+    const prefix = `${String(chatSessionId || "")}\u0000`;
+    for (const key of this.sessions.keys()) {
+      if (key.startsWith(prefix)) {
+        this.closeSession(key);
+      }
+    }
+    this.cancelElicitationsForChat(chatSessionId);
+  }
+
+  /**
+   * Close all sessions (app shutdown).
+   */
+  closeAll() {
+    for (const key of [...this.sessions.keys()]) {
+      this.closeSession(key);
+    }
+    for (const [elicitationId, pending] of [...this.elicitationPending]) {
+      this.elicitationPending.delete(elicitationId);
+      try { pending.resolve({ action: "cancel" }); } catch { /* best effort */ }
+    }
+  }
+
+  /**
+   * Cancel pending elicitations belonging to a chat session, resolving each
+   * as { action: "cancel" } so waiting create() promises settle.
+   */
+  cancelElicitationsForChat(chatSessionId) {
+    const target = String(chatSessionId || "");
+    for (const [elicitationId, pending] of [...this.elicitationPending]) {
+      if (String(pending?.chatSessionId || "") !== target) continue;
+      this.elicitationPending.delete(elicitationId);
+      try { pending.resolve({ action: "cancel" }); } catch { /* best effort */ }
+    }
+  }
+
+  /**
+   * Resolve a pending elicitation response from the renderer.
+   */
+  resolveElicitation(elicitationId, response) {
+    const pending = this.elicitationPending.get(elicitationId);
+    if (pending) {
+      this.elicitationPending.delete(elicitationId);
+      pending.resolve(response);
+      return true;
+    }
+    return false;
+  }
+}
+
+// Singleton instance shared across the app lifecycle.
+const codebuddySessionManager = new CodebuddySessionManager();
+
+module.exports = { CodebuddySessionManager, codebuddySessionManager, computeOptionsFingerprint };