@kenkaiiii/ggcoder 5.34.2 → 5.35.0

package/dist/core/mcp/shared-pool.d.ts

@@ -0,0 +1,158 @@
+import type { McpCatalogCache } from "./catalog-cache.js";
+import type { MCPConnectResult, MCPElicitHandler } from "./client.js";
+import type { MCPServerConfig } from "./types.js";
+/**
+ * Process-wide pool of MCP connections that are safe for every session to
+ * share, so one stdio child serves the whole daemon instead of one per session.
+ *
+ * The daemon hosts many `AgentSession`s at once — one per window, plus Ken chat
+ * and Ken autopilot within each window — and each used to spawn its own child
+ * for every configured stdio server. For a stateless proxy such as
+ * `kencode-search` that is N identical processes doing identical work: measured
+ * at 7 live children, ~43 MB each, purely duplicated.
+ *
+ * Sharing is the DEFAULT for stdio servers. A stdio connection has nothing
+ * session-specific in it: every one is spawned with `cwd: os.homedir()`, so a
+ * server cannot observe which project the caller is in even in principle, and
+ * the pool key hashes command/args/env, so two configs differing in any way
+ * that changes behaviour already get their own process.
+ *
+ * The two concerns that sharing has to answer are handled rather than avoided:
+ *
+ *  - **Per-caller state.** Multiplexing many sessions over one connection would
+ *    let a server that remembers "the current project" leak one session's
+ *    context into another's answers. That is invisible from a config, so it
+ *    stays a declaration: `shared: false` opts such a server out and it keeps a
+ *    private child per session.
+ *  - **User prompting.** "Ask the user" has to name a window, so elicitation is
+ *    routed to the session with a tool call in flight (see `dispatchElicit`),
+ *    and cancelled rather than guessed when that is ambiguous. Because a
+ *    connection declares its elicitation capability once at initialize, callers
+ *    that can prompt and callers that cannot are keyed apart.
+ *
+ * The pool deliberately knows nothing about `MCPClientManager` — the connection
+ * is supplied as a `SharedConnector`. That keeps the dependency pointing one
+ * way (client → pool), and lets tests exercise refcounting against a fake.
+ */
+/**
+ * Is this server shared across sessions in this process?
+ *
+ * Sharing is the DEFAULT for stdio servers, because a stdio MCP connection has
+ * nothing session-specific in it: every one is spawned with `cwd:
+ * os.homedir()` (see client.ts), so a server cannot observe which project the
+ * caller is in even in principle, and the pool key hashes command/args/env, so
+ * two configs that differ in any way that changes behaviour already get their
+ * own process. What remained — elicitation, the one genuinely per-window
+ * concern — is routed back to the calling session rather than dropped.
+ *
+ * `shared: false` opts a server out. That exists for a server that keeps
+ * per-CALLER state across requests (a cursor, a selected workspace, an open
+ * handle), where multiplexing two sessions over one connection would let one
+ * session's state change the other's answers. That property is invisible from
+ * a config, so it stays a declaration rather than a guess.
+ *
+ * HTTP servers are never shared. Sharing exists to collapse duplicate child
+ * PROCESSES and an HTTP server has none, so it would save nothing while adding
+ * real risk: OAuth tokens and `Mcp-Session-Id` are per-connection, and pooling
+ * them would cross one session's authenticated identity with another's.
+ */
+export declare function isShareableServer(config: MCPServerConfig): boolean;
+/** One pooled connection, owned by the pool and torn down at zero references. */
+export interface SharedConnector {
+    connect(config: MCPServerConfig): Promise<MCPConnectResult>;
+    dispose(): Promise<void>;
+}
+export interface SharedAcquireOptions {
+    catalogCache?: McpCatalogCache;
+    modernProtocol?: boolean;
+    /** Invoked by the connection when its server exits on its own. */
+    onClosed?: () => void;
+    /**
+     * The acquiring session's elicitation handler. Invoked only while that
+     * session has a tool call in flight on this connection (see `dispatchElicit`).
+     */
+    onElicit?: MCPElicitHandler;
+}
+/**
+ * Builds the underlying connection the first time a config is pooled. The pool
+ * supplies its own `onElicit`: a dispatcher that routes each request to the
+ * session that asked for it, instead of any one session's handler.
+ */
+export type SharedConnectorFactory = (opts: SharedAcquireOptions) => SharedConnector;
+/** A session's claim on a shared connection. `release` is idempotent. */
+export interface SharedServerHandle {
+    result: MCPConnectResult;
+    release: () => Promise<void>;
+    /**
+     * Mark a tool call from this session as in flight, returning the function
+     * that ends it. Elicitation arriving during the call is routed to this
+     * session's window.
+     */
+    beginCall: () => () => void;
+}
+export declare class SharedMcpPool {
+    private entries;
+    /**
+     * Key on everything that changes what the connection IS, not merely what it
+     * exposes: `hashServerConfig` covers command/args/env/url/transport, the name
+     * keeps two differently-named aliases apart, and the protocol flag is
+     * included because it changes the handshake — a session that opted into the
+     * modern revision must not be handed a legacy-negotiated connection.
+     *
+     * Whether the caller can prompt is part of the key for the same reason. A
+     * connection declares its elicitation capability once, at initialize, and
+     * servers use that declaration to decide whether to ask at all — so a
+     * headless caller (CLI, JSON mode) must not be handed a connection that
+     * promises prompting nobody can deliver, and a windowed caller must not be
+     * handed one that forecloses it. Splitting the key keeps each connection's
+     * declaration honest; in practice a daemon's sessions are uniformly windowed
+     * and the CLI's uniformly headless, so this still means one process.
+     */
+    private keyFor;
+    /**
+     * Get-or-create the shared connection for `config` and claim a reference.
+     *
+     * Concurrent acquirers share one connect attempt: the entry and its pending
+     * promise are registered synchronously before the first `await`, so a second
+     * caller arriving mid-connect joins the in-flight attempt instead of spawning
+     * a rival child.
+     */
+    acquire(config: MCPServerConfig, createConnector: SharedConnectorFactory, opts?: SharedAcquireOptions): Promise<SharedServerHandle>;
+    /**
+     * Drop a connection whose server died, without touching its callers' claims.
+     *
+     * The entry is unregistered but NOT disposed: its transport is already gone,
+     * and the sessions still holding handles will release them normally on their
+     * own dispose. Guarded on identity so a death notice arriving after the entry
+     * was already replaced cannot evict its successor.
+     */
+    private evictDead;
+    /**
+     * Route an elicitation to the session that provoked it.
+     *
+     * A shared connection is held by many windows, so "ask the user" has to name
+     * one. Elicitation only happens while a server is servicing a tool call, so
+     * the session with a call in flight IS the one whose window should show the
+     * form. When that is ambiguous — no call in flight, or two windows calling
+     * the same server at once — the request is cancelled rather than guessed:
+     * showing one project's consent form in another project's window would be a
+     * worse failure than a declined prompt, and `cancel` is exactly what a server
+     * already handles for a user who dismissed the dialog.
+     */
+    private dispatchElicit;
+    /**
+     * Drop one session's claim. At zero the entry is unregistered SYNCHRONOUSLY
+     * before the disposal await, so an `acquire` landing mid-teardown builds a
+     * fresh connection instead of receiving a client that is already closing.
+     */
+    private releaseKey;
+    /** Live shared connections. Test/diagnostic use. */
+    get size(): number;
+    /** Reference count for one config, or 0 when nothing is pooled for it. */
+    refCount(config: MCPServerConfig, opts?: SharedAcquireOptions): number;
+    /** Tear every shared connection down regardless of refs (process shutdown). */
+    disposeAll(): Promise<void>;
+}
+/** The daemon-wide pool. One per process, which is exactly the sharing scope. */
+export declare const sharedMcpPool: SharedMcpPool;
+//# sourceMappingURL=shared-pool.d.ts.map

package/dist/core/mcp/shared-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-pool.d.ts","sourceRoot":"","sources":["../../../src/core/mcp/shared-pool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAElE;AAED,iFAAiF;AACjF,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC5D,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACnC,YAAY,CAAC,EAAE,eAAe,CAAC;IAC/B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,kEAAkE;IAClE,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,EAAE,gBAAgB,CAAC;CAC7B;AAED;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,IAAI,EAAE,oBAAoB,KAAK,eAAe,CAAC;AAErF,yEAAyE;AACzE,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,gBAAgB,CAAC;IACzB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B;;;;OAIG;IACH,SAAS,EAAE,MAAM,MAAM,IAAI,CAAC;CAC7B;AAgBD,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAAgC;IAE/C;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,MAAM;IAMd;;;;;;;OAOG;IACG,OAAO,CACX,MAAM,EAAE,eAAe,EACvB,eAAe,EAAE,sBAAsB,EACvC,IAAI,GAAE,oBAAyB,GAC9B,OAAO,CAAC,kBAAkB,CAAC;IAwE9B;;;;;;;OAOG;IACH,OAAO,CAAC,SAAS;IAMjB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,cAAc;IActB;;;;OAIG;YACW,UAAU;IAUxB,oDAAoD;IACpD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,eAAe,EAAE,IAAI,GAAE,oBAAyB,GAAG,MAAM;IAI1E,+EAA+E;IACzE,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;CAKlC;AAED,iFAAiF;AACjF,eAAO,MAAM,aAAa,eAAsB,CAAC"}

package/dist/core/mcp/shared-pool.js

@@ -0,0 +1,235 @@
+import { hashServerConfig } from "./catalog-cache.js";
+import { log } from "../logger.js";
+/**
+ * Process-wide pool of MCP connections that are safe for every session to
+ * share, so one stdio child serves the whole daemon instead of one per session.
+ *
+ * The daemon hosts many `AgentSession`s at once — one per window, plus Ken chat
+ * and Ken autopilot within each window — and each used to spawn its own child
+ * for every configured stdio server. For a stateless proxy such as
+ * `kencode-search` that is N identical processes doing identical work: measured
+ * at 7 live children, ~43 MB each, purely duplicated.
+ *
+ * Sharing is the DEFAULT for stdio servers. A stdio connection has nothing
+ * session-specific in it: every one is spawned with `cwd: os.homedir()`, so a
+ * server cannot observe which project the caller is in even in principle, and
+ * the pool key hashes command/args/env, so two configs differing in any way
+ * that changes behaviour already get their own process.
+ *
+ * The two concerns that sharing has to answer are handled rather than avoided:
+ *
+ *  - **Per-caller state.** Multiplexing many sessions over one connection would
+ *    let a server that remembers "the current project" leak one session's
+ *    context into another's answers. That is invisible from a config, so it
+ *    stays a declaration: `shared: false` opts such a server out and it keeps a
+ *    private child per session.
+ *  - **User prompting.** "Ask the user" has to name a window, so elicitation is
+ *    routed to the session with a tool call in flight (see `dispatchElicit`),
+ *    and cancelled rather than guessed when that is ambiguous. Because a
+ *    connection declares its elicitation capability once at initialize, callers
+ *    that can prompt and callers that cannot are keyed apart.
+ *
+ * The pool deliberately knows nothing about `MCPClientManager` — the connection
+ * is supplied as a `SharedConnector`. That keeps the dependency pointing one
+ * way (client → pool), and lets tests exercise refcounting against a fake.
+ */
+/**
+ * Is this server shared across sessions in this process?
+ *
+ * Sharing is the DEFAULT for stdio servers, because a stdio MCP connection has
+ * nothing session-specific in it: every one is spawned with `cwd:
+ * os.homedir()` (see client.ts), so a server cannot observe which project the
+ * caller is in even in principle, and the pool key hashes command/args/env, so
+ * two configs that differ in any way that changes behaviour already get their
+ * own process. What remained — elicitation, the one genuinely per-window
+ * concern — is routed back to the calling session rather than dropped.
+ *
+ * `shared: false` opts a server out. That exists for a server that keeps
+ * per-CALLER state across requests (a cursor, a selected workspace, an open
+ * handle), where multiplexing two sessions over one connection would let one
+ * session's state change the other's answers. That property is invisible from
+ * a config, so it stays a declaration rather than a guess.
+ *
+ * HTTP servers are never shared. Sharing exists to collapse duplicate child
+ * PROCESSES and an HTTP server has none, so it would save nothing while adding
+ * real risk: OAuth tokens and `Mcp-Session-Id` are per-connection, and pooling
+ * them would cross one session's authenticated identity with another's.
+ */
+export function isShareableServer(config) {
+    return config.shared !== false && Boolean(config.command);
+}
+export class SharedMcpPool {
+    entries = new Map();
+    /**
+     * Key on everything that changes what the connection IS, not merely what it
+     * exposes: `hashServerConfig` covers command/args/env/url/transport, the name
+     * keeps two differently-named aliases apart, and the protocol flag is
+     * included because it changes the handshake — a session that opted into the
+     * modern revision must not be handed a legacy-negotiated connection.
+     *
+     * Whether the caller can prompt is part of the key for the same reason. A
+     * connection declares its elicitation capability once, at initialize, and
+     * servers use that declaration to decide whether to ask at all — so a
+     * headless caller (CLI, JSON mode) must not be handed a connection that
+     * promises prompting nobody can deliver, and a windowed caller must not be
+     * handed one that forecloses it. Splitting the key keeps each connection's
+     * declaration honest; in practice a daemon's sessions are uniformly windowed
+     * and the CLI's uniformly headless, so this still means one process.
+     */
+    keyFor(config, opts) {
+        const era = opts.modernProtocol ? "modern" : "legacy";
+        const prompting = opts.onElicit ? "interactive" : "headless";
+        return `${config.name}\u0000${hashServerConfig(config)}\u0000${era}\u0000${prompting}`;
+    }
+    /**
+     * Get-or-create the shared connection for `config` and claim a reference.
+     *
+     * Concurrent acquirers share one connect attempt: the entry and its pending
+     * promise are registered synchronously before the first `await`, so a second
+     * caller arriving mid-connect joins the in-flight attempt instead of spawning
+     * a rival child.
+     */
+    async acquire(config, createConnector, opts = {}) {
+        const key = this.keyFor(config, opts);
+        const caller = { onElicit: opts.onElicit, activeCalls: 0 };
+        let entry = this.entries.get(key);
+        if (!entry) {
+            // Built before the connector so the dispatcher can close over it: the
+            // connection needs an elicit handler at construction time, but which
+            // session that handler defers to is only knowable per request.
+            const created = {
+                connector: undefined,
+                callers: new Set(),
+                connected: undefined,
+            };
+            // A headless entry gets no dispatcher at all, so its connection declares
+            // no elicitation capability — matching what its callers can actually do.
+            created.connector = createConnector({
+                ...opts,
+                onElicit: opts.onElicit ? this.dispatchElicit(created) : undefined,
+                // A pooled child that dies would otherwise be handed to every session
+                // in the daemon, and to every session that connects later — one crash
+                // becoming a permanent outage. Unregister it so the next acquire builds
+                // a fresh connection. Sessions already holding it still see their calls
+                // fail, which is what a dead server means; they recover on reconnect.
+                onClosed: () => this.evictDead(key, created),
+            });
+            created.connected = created.connector.connect(config);
+            entry = created;
+            this.entries.set(key, entry);
+            log("INFO", "mcp", `Opening shared MCP connection for "${config.name}"`);
+        }
+        entry.callers.add(caller);
+        const claimed = entry;
+        let result;
+        try {
+            result = await claimed.connected;
+        }
+        catch (err) {
+            // The connector reports failure in-band, so a throw is unexpected. Drop
+            // the claim so a broken entry cannot outlive it.
+            await this.releaseKey(key, claimed, caller);
+            throw err;
+        }
+        if (!result.ok) {
+            // A failed connection is not worth pooling: keeping it would make every
+            // later session inherit this failure with no chance to retry. Release the
+            // claim (tearing the entry down at zero) and report the failure as-is.
+            await this.releaseKey(key, claimed, caller);
+            return { result, release: async () => { }, beginCall: () => () => { } };
+        }
+        let released = false;
+        return {
+            result,
+            release: async () => {
+                if (released)
+                    return;
+                released = true;
+                await this.releaseKey(key, claimed, caller);
+            },
+            beginCall: () => {
+                caller.activeCalls += 1;
+                let ended = false;
+                return () => {
+                    if (ended)
+                        return;
+                    ended = true;
+                    caller.activeCalls = Math.max(0, caller.activeCalls - 1);
+                };
+            },
+        };
+    }
+    /**
+     * Drop a connection whose server died, without touching its callers' claims.
+     *
+     * The entry is unregistered but NOT disposed: its transport is already gone,
+     * and the sessions still holding handles will release them normally on their
+     * own dispose. Guarded on identity so a death notice arriving after the entry
+     * was already replaced cannot evict its successor.
+     */
+    evictDead(key, entry) {
+        if (this.entries.get(key) !== entry)
+            return;
+        this.entries.delete(key);
+        log("WARN", "mcp", "shared MCP connection died; next session will reconnect");
+    }
+    /**
+     * Route an elicitation to the session that provoked it.
+     *
+     * A shared connection is held by many windows, so "ask the user" has to name
+     * one. Elicitation only happens while a server is servicing a tool call, so
+     * the session with a call in flight IS the one whose window should show the
+     * form. When that is ambiguous — no call in flight, or two windows calling
+     * the same server at once — the request is cancelled rather than guessed:
+     * showing one project's consent form in another project's window would be a
+     * worse failure than a declined prompt, and `cancel` is exactly what a server
+     * already handles for a user who dismissed the dialog.
+     */
+    dispatchElicit(entry) {
+        return async (request) => {
+            const candidates = [...entry.callers].filter((c) => c.activeCalls > 0 && c.onElicit);
+            if (candidates.length !== 1) {
+                log("WARN", "mcp", "cancelled a shared-server elicitation with no unique caller", {
+                    server: request.server,
+                    candidates: String(candidates.length),
+                });
+                return { action: "cancel" };
+            }
+            return candidates[0].onElicit(request);
+        };
+    }
+    /**
+     * Drop one session's claim. At zero the entry is unregistered SYNCHRONOUSLY
+     * before the disposal await, so an `acquire` landing mid-teardown builds a
+     * fresh connection instead of receiving a client that is already closing.
+     */
+    async releaseKey(key, entry, caller) {
+        if (!entry.callers.delete(caller))
+            return;
+        if (entry.callers.size > 0)
+            return;
+        // Only unregister when this entry is still the live one for the key: a
+        // teardown racing a fresh acquire must not evict its replacement.
+        if (this.entries.get(key) === entry)
+            this.entries.delete(key);
+        await entry.connector.dispose();
+        log("INFO", "mcp", "Closed shared MCP connection (last session released it)");
+    }
+    /** Live shared connections. Test/diagnostic use. */
+    get size() {
+        return this.entries.size;
+    }
+    /** Reference count for one config, or 0 when nothing is pooled for it. */
+    refCount(config, opts = {}) {
+        return this.entries.get(this.keyFor(config, opts))?.callers.size ?? 0;
+    }
+    /** Tear every shared connection down regardless of refs (process shutdown). */
+    async disposeAll() {
+        const entries = [...this.entries.values()];
+        this.entries.clear();
+        await Promise.all(entries.map((entry) => entry.connector.dispose()));
+    }
+}
+/** The daemon-wide pool. One per process, which is exactly the sharing scope. */
+export const sharedMcpPool = new SharedMcpPool();
+//# sourceMappingURL=shared-pool.js.map

package/dist/core/mcp/shared-pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-pool.js","sourceRoot":"","sources":["../../../src/core/mcp/shared-pool.ts"],"names":[],"mappings":"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"}

package/dist/core/mcp/shared-pool.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=shared-pool.test.d.ts.map

package/dist/core/mcp/shared-pool.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-pool.test.d.ts","sourceRoot":"","sources":["../../../src/core/mcp/shared-pool.test.ts"],"names":[],"mappings":""}