@cjhyy/code-shell-core 0.6.0-rc.1 → 0.6.0-rc.10

package/dist/protocol/server.js

@@ -26,6 +26,19 @@ import { logger } from "../logging/logger.js";
 import { nanoid } from "nanoid";
 import { redactLlmConfig, maskSecretValue } from "./redact.js";
 import { redactSecrets } from "../logging/sanitize-messages.js";
+const COMPACT_STREAM_STRATEGIES = new Set([
+    "micro",
+    "summary",
+    "window",
+    "snip",
+    "emergency",
+    "compacted",
+]);
+function toCompactStreamStrategy(strategy) {
+    return COMPACT_STREAM_STRATEGIES.has(strategy)
+        ? strategy
+        : "compacted";
+}
 export class AgentServer {
     chatManager;
     legacyEngine;
@@ -307,6 +320,19 @@ export class AgentServer {
             this.transport.send(createErrorResponse(req.id, ErrorCodes.SessionNotFound, `session ${params.sessionId} does not exist`));
             return;
         }
+        if (params.model !== undefined) {
+            if (typeof params.model !== "string" || params.model.length === 0) {
+                this.transport.send(createErrorResponse(req.id, ErrorCodes.InvalidParams, "model must be a non-empty string"));
+                return;
+            }
+            try {
+                session.requestModelSwitch(params.model);
+            }
+            catch (err) {
+                this.transport.send(createErrorResponse(req.id, ErrorCodes.InvalidParams, err.message));
+                return;
+            }
+        }
         if (typeof params.planMode === "boolean") {
             session.engine.setPlanMode(params.planMode);
         }
@@ -323,9 +349,9 @@ export class AgentServer {
             session.engine.setAskUser((question, opts) => this.requestAskUserForSession(session, sid, question, opts));
             // Browser automation bridge: each method routes a browser action to the
             // client (Electron main drives the webview via CDP) over the SAME
-            // request/response channel as askUser (pendingApprovals + requestId),
-            // reusing its proven resolve/timeout/cleanup. The main-side handler
-            // replies with the action's JSON result.
+            // request/response channel as askUser (pendingApprovals + requestId).
+            // Browser actions still keep their own bounded timeout; AskUserQuestion
+            // waits for a real answer or Stop/cancel.
             session.engine.setBrowserBridge(this.makeBrowserBridge(session, sid));
             // Cookie→browser injection (InjectCredential tool): same cross-process
             // channel; main restores the cookie jar into the built-in browser.
@@ -339,6 +365,7 @@ export class AgentServer {
                     ? params.goal
                     : undefined,
                 onStream: (event) => this.notify(Methods.StreamEvent, { sessionId: sid, event }),
+                clientMessageId: typeof params.clientMessageId === "string" ? params.clientMessageId : undefined,
             });
             const runResult = {
                 text: result.text,
@@ -387,6 +414,19 @@ export class AgentServer {
             // Engine.setPermissionMode now keeps this.permissionMode + this.planMode
             // in sync and tools read them via ToolContext.permissionMode/planMode.
         }
+        if (params.model !== undefined) {
+            if (typeof params.model !== "string" || params.model.length === 0) {
+                this.transport.send(createErrorResponse(req.id, ErrorCodes.InvalidParams, "model must be a non-empty string"));
+                return;
+            }
+            try {
+                this.legacyEngine.switchModel(params.model);
+            }
+            catch (err) {
+                this.transport.send(createErrorResponse(req.id, ErrorCodes.InvalidParams, err.message));
+                return;
+            }
+        }
         this.running = true;
         this.abortController = new AbortController();
         this.notify(Methods.Status, { status: "running" });
@@ -405,6 +445,7 @@ export class AgentServer {
                 sessionId: params.sessionId,
                 signal: runController.signal,
                 onStream: streamToClient,
+                clientMessageId: typeof params.clientMessageId === "string" ? params.clientMessageId : undefined,
                 goal: typeof params.goal === "string" ||
                     (params.goal != null && typeof params.goal === "object")
                     ? params.goal
@@ -452,7 +493,10 @@ export class AgentServer {
     // ─── Approve ────────────────────────────────────────────────────
     handleApprove(req) {
         const params = (req.params ?? {});
-        // ChatSessionManager path: look up per-session pendingApprovals
+        // ChatSessionManager path: approvals are scoped by (sessionId, requestId).
+        // Never fall back from a session-tagged response to the legacy global map:
+        // a stale/misrouted UI response must fail closed instead of resolving a
+        // pending prompt from another session.
         if (this.chatManager && typeof params.sessionId === "string") {
             const s = this.chatManager.get(params.sessionId);
             if (!s) {
@@ -461,14 +505,13 @@ export class AgentServer {
             }
             const resolve = s.pendingApprovals.get(params.requestId);
             if (!resolve) {
-                this.transport.send(createErrorResponse(req.id, ErrorCodes.InvalidParams, `No pending approval: ${params.requestId}`));
+                this.transport.send(createErrorResponse(req.id, ErrorCodes.InvalidParams, `No pending approval for session ${params.sessionId}: ${params.requestId}`));
                 return;
             }
             s.pendingApprovals.delete(params.requestId);
-            // Cancel the pending timeout for THIS request (the ask path armed one).
-            // The legacy single-engine branch below already does this; without it
-            // here a decided request leaves a live timer that fires at
-            // APPROVAL_TIMEOUT_MS and churns a dead map entry.
+            // Cancel the pending timeout for requests that arm one (browser actions,
+            // credential injection, and tool approvals). AskUserQuestion does not use
+            // a timeout; this is harmless for those request ids.
             this.clearApprovalTimer(params.requestId);
             resolve(params.decision);
             this.transport.send(createResponse(req.id, { ok: true }));
@@ -502,11 +545,10 @@ export class AgentServer {
             s.cancel();
             // s.cancel() only aborts the engine controller + drains queued turns. The
             // session's pendingApprovals (askUser / browser_action / tool approvals)
-            // are NOT driven by the abort signal — they only settle on a client reply
-            // or the 5-minute APPROVAL_TIMEOUT_MS. Left alone, the awaiting tool call
-            // hangs until that timeout (delaying run wind-down) and the server-side
-            // approvalTimers entry leaks. Resolve them as cancelled now and clear the
-            // matching timers, mirroring the legacy path below.
+            // are NOT driven directly by the abort signal. Left alone, an awaiting
+            // AskUserQuestion would now wait forever, while bounded request types
+            // would wait until APPROVAL_TIMEOUT_MS. Resolve them as cancelled now and
+            // clear any matching timers, mirroring the legacy path below.
             this.cancelSessionApprovals(s);
             this.transport.send(createResponse(req.id, { ok: true }));
             return;
@@ -689,6 +731,10 @@ export class AgentServer {
             return;
         }
         if (this.chatManager) {
+            const session = this.chatManager.get(params.sessionId);
+            if (session) {
+                this.cancelSessionApprovals(session, "session closed");
+            }
             this.chatManager.close(params.sessionId);
         }
         // Explicit session teardown — reap that session's background shells
@@ -709,7 +755,11 @@ export class AgentServer {
             const sid = params.sessionId;
             const s = this.chatManager.get(sid);
             if (!s) {
-                this.transport.send(createErrorResponse(req.id, ErrorCodes.SessionClosed, `No such session: ${sid}`));
+                // Session not found (already cleaned by idle sweeper, or never created).
+                // Don't create one just for configure — let the subsequent run() do it
+                // with proper per-session config. Return OK since there's nothing to
+                // configure on a non-existent session.
+                this.transport.send(createResponse(req.id, { ok: true }));
                 return;
             }
             if (typeof params.planMode === "boolean")
@@ -717,13 +767,32 @@ export class AgentServer {
             if (typeof params.permissionMode === "string") {
                 s.engine.setPermissionMode(params.permissionMode);
             }
+            if (params.clearModels) {
+                this.chatManager.runtime.clearModels();
+            }
+            if (params.reloadModels) {
+                try {
+                    this.chatManager.runtime.reloadModelsFromSettings();
+                }
+                catch (err) {
+                    this.transport.send(createErrorResponse(req.id, ErrorCodes.InternalError, err.message));
+                    return;
+                }
+            }
             // Per-session model switch — the missing piece that made model changes
             // worker-global (session-isolation research §3). requestModelSwitch
             // applies immediately when idle, defers to the run boundary when busy
             // so it never swaps the model under a running LLM client.
             if (typeof params.model === "string") {
                 try {
-                    s.requestModelSwitch(params.model);
+                    const entry = s.requestModelSwitch(params.model);
+                    this.transport.send(createResponse(req.id, {
+                        ok: true,
+                        model: entry.model,
+                        key: entry.key,
+                        maxContextTokens: entry.maxContextTokens,
+                    }));
+                    return;
                 }
                 catch (err) {
                     this.transport.send(createErrorResponse(req.id, ErrorCodes.InvalidParams, err.message));
@@ -746,22 +815,33 @@ export class AgentServer {
         // Global configure — delegate to legacyEngine if available,
         // or to any session's engine from chatManager for settings ops
         const engine = this.legacyEngine ?? this.anyEngine();
+        if (params.clearModels) {
+            if (this.chatManager) {
+                this.chatManager.runtime.clearModels();
+            }
+            else {
+                this.legacyEngine?.getModelPool().clear();
+                this.globalQueryEngine?.getModelPool().clear();
+            }
+        }
         if (params.reloadModels) {
             try {
-                const seen = new Set();
-                const reload = (target) => {
-                    if (!target || seen.has(target))
-                        return;
-                    seen.add(target);
-                    target.reloadModelPool();
-                };
-                reload(this.legacyEngine);
-                reload(this.globalQueryEngine);
                 if (this.chatManager) {
-                    this.chatManager.forEachSession((s) => reload(s.engine));
+                    this.chatManager.runtime.reloadModelsFromSettings();
+                }
+                else {
+                    const seen = new Set();
+                    const reload = (target) => {
+                        if (!target || seen.has(target))
+                            return;
+                        seen.add(target);
+                        target.reloadModelPool();
+                    };
+                    reload(this.legacyEngine);
+                    reload(this.globalQueryEngine);
+                    if (seen.size === 0)
+                        reload(engine);
                 }
-                if (seen.size === 0)
-                    reload(engine);
             }
             catch (err) {
                 this.transport.send(createErrorResponse(req.id, ErrorCodes.InternalError, err.message));
@@ -771,7 +851,12 @@ export class AgentServer {
         if (params.model !== undefined && engine) {
             try {
                 const entry = engine.switchModel(params.model);
-                this.transport.send(createResponse(req.id, { ok: true, model: entry.model, key: entry.key }));
+                this.transport.send(createResponse(req.id, {
+                    ok: true,
+                    model: entry.model,
+                    key: entry.key,
+                    maxContextTokens: entry.maxContextTokens,
+                }));
                 return;
             }
             catch (err) {
@@ -921,12 +1006,53 @@ export class AgentServer {
                 break;
             }
             case "compact": {
-                if (!engine) {
+                const compactSessionId = typeof params.sessionId === "string" && params.sessionId.length > 0
+                    ? params.sessionId
+                    : undefined;
+                let compactEngine = engine;
+                if (this.chatManager) {
+                    if (compactSessionId) {
+                        let session = this.chatManager.get(compactSessionId);
+                        if (!session) {
+                            const probeEngine = this.anyEngine();
+                            if (!probeEngine?.sessionExistsOnDisk(compactSessionId)) {
+                                this.transport.send(createErrorResponse(req.id, ErrorCodes.SessionNotFound, `Session not found: ${compactSessionId}`));
+                                return;
+                            }
+                            try {
+                                session = this.chatManager.getOrCreate(compactSessionId, {
+                                    cwd: probeEngine.getSessionManager().readCwd(compactSessionId),
+                                });
+                            }
+                            catch (err) {
+                                this.transport.send(createErrorResponse(req.id, err.code ?? ErrorCodes.InternalError, err.message));
+                                return;
+                            }
+                        }
+                        compactEngine = session.engine;
+                    }
+                    else {
+                        compactEngine = this.anyEngine();
+                    }
+                }
+                if (!compactEngine) {
                     this.transport.send(createErrorResponse(req.id, ErrorCodes.InternalError, "No engine available for compact query"));
                     return;
                 }
                 try {
-                    const result = engine.forceCompact();
+                    const result = await compactEngine.forceCompact(compactSessionId);
+                    if (result.before > result.after) {
+                        const event = {
+                            type: "context_compact",
+                            strategy: toCompactStreamStrategy(result.strategy),
+                            before: result.before,
+                            after: result.after,
+                        };
+                        this.notify(Methods.StreamEvent, {
+                            sessionId: compactSessionId ?? "",
+                            event,
+                        });
+                    }
                     this.transport.send(createResponse(req.id, {
                         type: "compact",
                         data: result,
@@ -1254,8 +1380,8 @@ export class AgentServer {
             return;
         }
         try {
-            engine.enqueueSteer(params.sessionId, params.text, params.id);
-            this.transport.send(createResponse(req.id, { ok: true }));
+            const result = engine.enqueueSteer(params.sessionId, params.text, params.id, params.clientMessageId);
+            this.transport.send(createResponse(req.id, { ok: true, ...result }));
         }
         catch (err) {
             this.transport.send(createErrorResponse(req.id, ErrorCodes.InternalError, err.message));
@@ -1291,27 +1417,42 @@ export class AgentServer {
     requestApprovalFromClient(request) {
         return new Promise((resolve) => {
             const requestId = nanoid(12);
-            this.pendingApprovals.set(requestId, resolve);
+            const sessionId = typeof request.sessionId === "string" ? request.sessionId : undefined;
+            const session = this.chatManager && sessionId ? this.chatManager.get(sessionId) : undefined;
+            if (this.chatManager && sessionId && !session) {
+                resolve({ approved: false, reason: `session closed: ${sessionId}` });
+                return;
+            }
+            if (session) {
+                session.pendingApprovals.set(requestId, (decision) => {
+                    resolve(decision);
+                });
+            }
+            else {
+                this.pendingApprovals.set(requestId, resolve);
+            }
             const timer = setTimeout(() => {
-                if (this.pendingApprovals.has(requestId)) {
-                    this.pendingApprovals.delete(requestId);
+                const pending = session?.pendingApprovals ?? this.pendingApprovals;
+                if (pending.has(requestId)) {
+                    pending.delete(requestId);
                     this.approvalTimers.delete(requestId);
                     resolve({ approved: false, reason: "approval timed out" });
                 }
             }, AgentServer.APPROVAL_TIMEOUT_MS);
             this.approvalTimers.set(requestId, timer);
-            this.notify(Methods.ApprovalRequest, { requestId, request });
+            this.notify(Methods.ApprovalRequest, {
+                ...(sessionId ? { sessionId } : {}),
+                requestId,
+                request,
+            });
         });
     }
     /**
-     * Ask the client to answer a question from the agent (legacy single-engine path).
-     */
-    /**
-     * Per-session AskUserQuestion for the chatManager path. Mirrors
-     * requestAskUserFromClient but resolves via the SESSION's pendingApprovals
-     * (the chatManager approve handler looks there, keyed by sessionId+requestId)
-     * and tags the notify with sessionId so the renderer routes the question to
-     * the right chat tab.
+     * Per-session AskUserQuestion for the chatManager path. Resolves via the
+     * SESSION's pendingApprovals (the chatManager approve handler looks there,
+     * keyed by sessionId+requestId) and tags the notify with sessionId so the
+     * renderer routes the question to the right chat tab. This intentionally has
+     * no wall-clock timeout; Stop/cancel drains the pending ask.
      */
     requestAskUserForSession(session, sessionId, question, opts) {
         return new Promise((resolve) => {
@@ -1327,14 +1468,6 @@ export class AgentServer {
                     resolve(typeof decision === "string" ? decision : "");
                 }
             });
-            const timer = setTimeout(() => {
-                if (session.pendingApprovals.has(requestId)) {
-                    session.pendingApprovals.delete(requestId);
-                    this.approvalTimers.delete(requestId);
-                    resolve("(approval timed out)");
-                }
-            }, AgentServer.APPROVAL_TIMEOUT_MS);
-            this.approvalTimers.set(requestId, timer);
             const args = { question };
             if (opts?.header !== undefined)
                 args.header = opts.header;
@@ -1479,6 +1612,11 @@ export class AgentServer {
             });
         });
     }
+    /**
+     * Ask the client to answer a question from the agent (legacy single-engine
+     * path). This intentionally has no wall-clock timeout; Stop/cancel drains
+     * the pending ask.
+     */
     requestAskUserFromClient(question, opts) {
         return new Promise((resolve) => {
             const requestId = nanoid(12);
@@ -1491,14 +1629,6 @@ export class AgentServer {
                     resolve(result.reason ?? "(user declined to answer)");
                 }
             });
-            const timer = setTimeout(() => {
-                if (this.pendingApprovals.has(requestId)) {
-                    this.pendingApprovals.delete(requestId);
-                    this.approvalTimers.delete(requestId);
-                    resolve("(approval timed out)");
-                }
-            }, AgentServer.APPROVAL_TIMEOUT_MS);
-            this.approvalTimers.set(requestId, timer);
             const args = { question };
             if (opts?.header !== undefined)
                 args.header = opts.header;
@@ -1560,6 +1690,9 @@ export class AgentServer {
             this.bgAgentBusUnsubscribe = null;
         }
         if (this.chatManager) {
+            this.chatManager.forEachSession((session) => {
+                this.cancelSessionApprovals(session, "server closing");
+            });
             this.chatManager.closeAll();
         }
         // Legacy path cleanup
@@ -1588,17 +1721,16 @@ export class AgentServer {
     }
     /**
      * Resolve all of a chat session's pending approvals as cancelled and clear
-     * the matching server-side approval timers. Used by handleCancel's
+     * any matching server-side approval timers. Used by handleCancel's
      * per-session path so a Stop while a tool is awaiting approval doesn't leave
-     * the tool hanging until APPROVAL_TIMEOUT_MS (and leak the timer). Each
-     * requestId in the session map has a same-keyed entry in this.approvalTimers
-     * (see requestAskUserForSession / makeBrowserBridge).
+     * the tool hanging. Bounded request types have same-keyed timer entries;
+     * AskUserQuestion does not.
      */
-    cancelSessionApprovals(session) {
+    cancelSessionApprovals(session, reason = "cancelled") {
         for (const [requestId, resolve] of session.pendingApprovals) {
             this.clearApprovalTimer(requestId);
             try {
-                resolve({ approved: false, reason: "cancelled" });
+                resolve({ approved: false, reason });
             }
             catch {
                 /* a resolver must never break cancel cleanup */

package/dist/protocol/types.d.ts

@@ -51,6 +51,8 @@ export declare const ErrorCodes: {
 export interface RunParams {
     sessionId: string;
     task: string;
+    /** Stable id for the user's submit intent; duplicate ids are idempotent. */
+    clientMessageId?: string;
     /**
      * Working directory for this run. When omitted, the Engine uses its
      * configured cwd.
@@ -61,6 +63,12 @@ export interface RunParams {
      * When omitted, the engine keeps its configured default.
      */
     permissionMode?: PermissionMode;
+    /**
+     * Per-run model pool key. Applied after the session exists and before the
+     * turn starts, so cold desktop runs don't need a separate pre-run configure
+     * request to a worker that has not been spawned yet.
+     */
+    model?: string;
     /**
      * Workspace trust for this run's project (`cwd`), asserted by the host
      * (desktop main from its trust-store) — never by the renderer. When false,
@@ -127,6 +135,8 @@ export interface SteerParams {
     /** Stable host-side id for this queued draft. Rides through to the
      *  steer_injected event and is the handle Unsteer uses to revoke it. */
     id?: string;
+    /** Stable submit-intent id, distinct from the queued steer id. */
+    clientMessageId?: string;
 }
 /** Revoke a still-pending steer entry by id (before the loop consumes it). */
 export interface UnsteerParams {
@@ -149,6 +159,8 @@ export interface ConfigureParams {
      * running engine picks them up without a process restart.
      */
     reloadModels?: boolean;
+    /** Clear the live model pool, used after logout removes saved credentials. */
+    clearModels?: boolean;
     /**
      * Re-read disk settings and hot-push the disk-default config fields (preset /
      * customSystemPrompt / appendSystemPrompt / personalization / mcpServers) +
@@ -243,6 +255,8 @@ export interface AgentStreamEventNotification {
 }
 /** Server requests approval from the client (UI). */
 export interface ApprovalRequestNotification {
+    /** Originating engine session when known. */
+    sessionId?: string;
     requestId: string;
     request: ApprovalRequest;
 }

package/dist/runtime/background-shell.js

@@ -89,6 +89,7 @@ export class BackgroundShellManager {
                 error: `Too many background shells for this session (max ${MAX_SHELLS_PER_SESSION}). KillShell some first.`,
             };
         }
+        const profileStartedAt = backgroundSpawnProfileEnabled() ? performance.now() : 0;
         const shell = opts.shell ?? defaultShellBinary();
         const { file, args } = resolveSpawnTarget(opts.command, {
             cwd: opts.cwd,
@@ -113,8 +114,10 @@ export class BackgroundShellManager {
             });
         }
         catch (err) {
+            logBackgroundSpawnProfile(file, args, elapsedProfileMs(profileStartedAt), "spawn_failed");
             return { ok: false, error: `Failed to spawn background shell: ${err.message}` };
         }
+        logBackgroundSpawnProfile(file, args, elapsedProfileMs(profileStartedAt), "started");
         if (child.pid === undefined) {
             return { ok: false, error: "Failed to spawn background shell: no pid" };
         }
@@ -493,3 +496,14 @@ export class BackgroundShellManager {
 }
 /** Process-local singleton, mirroring asyncAgentRegistry's lifetime contract. */
 export const backgroundShellManager = new BackgroundShellManager();
+function backgroundSpawnProfileEnabled() {
+    return process.env.CODESHELL_SPAWN_PROFILE === "1";
+}
+function elapsedProfileMs(startedAt) {
+    return startedAt > 0 ? Math.round(performance.now() - startedAt) : undefined;
+}
+function logBackgroundSpawnProfile(file, args, elapsedMs, status) {
+    if (!backgroundSpawnProfileEnabled())
+        return;
+    console.error(`[spawn-profile] background shell=${JSON.stringify(file)} flag=${JSON.stringify(args[0] ?? "")} elapsedMs=${elapsedMs ?? "n/a"} status=${status}`);
+}