@cjhyy/code-shell-core 0.5.0-rc.2 → 0.6.0-rc.2

package/dist/protocol/server.d.ts

@@ -38,6 +38,18 @@ export interface AgentServerOptions {
      * When absent, `configure({ reloadSettings })` returns an explicit error.
      */
     settingsReader?: () => ValidatedSettings;
+    /**
+     * Disk-only active-goal reader, used by agent/goalGet when the session is NOT
+     * live in chatManager. In worker (chatManager) mode there is no legacyEngine
+     * to fall back to, and a reopened-after-restart session isn't a live
+     * ChatSession yet (one is only created on agent/run), so chatManager.get()
+     * misses — without this the handler returned goal:null even though state.json
+     * still held the goal, and the UI's goal block never re-surfaced ("goal 还在
+     * 但页面不显示"). Wire it to SessionManager.readActiveGoal. Optional: legacy
+     * mode already reads disk via the engine, and tests that don't exercise the
+     * reopened-session path can omit it.
+     */
+    readActiveGoalFromDisk?: (sessionId: string) => import("../engine/goal.js").GoalConfig | undefined;
 }
 export declare class AgentServer {
     private readonly chatManager;
@@ -46,6 +58,8 @@ export declare class AgentServer {
     private transport;
     /** Fresh-disk settings reader for config hot-reload; null when not wired. */
     private readonly settingsReader;
+    /** Disk-only active-goal reader for agent/goalGet on a non-live session. */
+    private readonly readActiveGoalFromDisk;
     /**
      * Monotonic config-reload version, bumped per reloadSettings request so each
      * Engine.refreshRuntimeConfig can drop out-of-order (stale) deliveries (Q5).
@@ -78,16 +92,89 @@ export declare class AgentServer {
      */
     private bgAgentBusUnsubscribe;
     constructor(options: AgentServerOptions);
+    /**
+     * Wake an IDLE chatManager session that has pending background-completion
+     * notifications, by enqueueing one turn whose task is the drained
+     * notification(s). The model then sees the completion and continues; the
+     * session's persisted goal (if any) is judged on that turn.
+     *
+     * Guards:
+     * - chatManager path only (the legacy single-engine / headless path drives
+     *   its own loop and has no idle-session-resume concept).
+     * - Session must exist AND be idle. If it's busy, we do nothing: the in-flight
+     *   run's end-of-turn `drainAll` already collects every pending notification,
+     *   so a second run would be redundant — and `enqueueTurn` while busy would
+     *   queue a spurious extra turn.
+     * - We `drainAll` exactly here and feed the items into the woken turn. This
+     *   also merges a burst of near-simultaneous completions into one wakeup:
+     *   the first drains all currently-pending items; subsequent bus events for
+     *   the same session find it busy (or find an empty queue) and no-op.
+     *
+     * INVARIANT (the burst-merge correctness depends on it): the merge only
+     * holds because (a) the bus fans out to subscribers SYNCHRONOUSLY, and (b)
+     * `enqueueTurn` sets the session's `active` (→ isBusy()===true) SYNCHRONOUSLY
+     * before its first await. So when bus events #2..N arrive — still on the same
+     * synchronous fan-out as #1 — they already see the session as busy and no-op.
+     * If either path is ever made async (e.g. an await is added inside
+     * enqueueTurn before `active` is set, or the bus starts deferring delivery),
+     * this degrades into N concurrent wakeups for N completions. Keep both
+     * synchronous, or replace this comment's assumption with an explicit
+     * "wakeup in flight" guard flag.
+     */
+    private maybeWakeIdleSession;
     private handleRequest;
     private handleRun;
     private handleRunMulti;
     private handleRunLegacy;
     private handleApprove;
     private handleCancel;
+    /**
+     * Extend a running goal's turn/budget ceilings mid-run (TODO 3.1). Routed to
+     * a specific session (multi-session path). Returns the resulting effective
+     * limits, or an error if no session / no active run.
+     */
+    private handleGoalExtend;
+    /**
+     * Clear a session's persisted active goal (CC /goal clear). Routes to the
+     * named session, falling back to the legacy single engine (mirrors
+     * handleGoalExtend / handleCancel's dual path). Returns { ok, cleared }.
+     */
+    private handleGoalClear;
+    /**
+     * Read a session's persisted active goal so the host can re-surface the goal
+     * block + Cancel button on session load. A persistent goal lives only in
+     * state.activeGoal and is never replayed from the transcript, so a reloaded
+     * (or disk-rebuilt) session has no other way to learn it. Prefers a live
+     * chatManager session, else falls through to a disk read (readActiveGoalFromDisk
+     * in worker mode, or the legacy engine's disk read in single-engine mode) — the
+     * bug case is an aborted/reloaded session that is NOT live. Returns { ok, goal } where goal
+     * is the objective string, or null when there's no goal / unknown session.
+     * Never errors on "no goal" — null is the normal "nothing to show" answer.
+     */
+    private handleGoalGet;
+    /**
+     * Query/control a session's background shells for the desktop UI panel (TODO
+     * 3.2). Reads the singleton BackgroundShellManager directly (shells outlive
+     * the run that spawned them, so we don't need a live ChatSession). Actions:
+     *   - (default) list  → the session's shells
+     *   - output          → full retained output of one shell
+     *   - kill            → terminate one shell's process group
+     * All scoped by sessionId (manager enforces ownership on output/kill).
+     */
+    private handleBackgroundShells;
+    /**
+     * BackgroundWork — unified, list-only view of a session's background work
+     * across all three registries (shells + sub-agents + jobs) for the desktop
+     * background panel. Per-shell output/kill still flow through BackgroundShells
+     * (by shellId); this just answers "what's running in the background right now".
+     */
+    private handleBackgroundWork;
     private handleCloseSession;
     private handleConfigure;
     private handleQuery;
     private handleInject;
+    private handleSteer;
+    private handleUnsteer;
     /**
      * Ask the client to approve a tool operation (legacy single-engine path).
      */
@@ -103,6 +190,22 @@ export declare class AgentServer {
      * the right chat tab.
      */
     private requestAskUserForSession;
+    /**
+     * Build a BrowserBridge whose every method routes a browser action to the
+     * client over the session's pendingApprovals channel (same as askUser). The
+     * client (Electron main) drives the webview via CDP and replies with a JSON
+     * result string we parse back into the typed result. On timeout / malformed
+     * reply we degrade to a safe error result rather than throwing.
+     */
+    private makeBrowserBridge;
+    private requestBrowserActionForSession;
+    /**
+     * Ask the client (Electron main) to inject a cookie credential into the
+     * built-in browser. Same pendingApprovals channel as browser actions; main
+     * calls restoreCookiesToBrowser and replies with a JSON result string we
+     * parse into { ok, count?, error? }. Degrades to ok:false on timeout/malformed.
+     */
+    private requestCredentialInjectForSession;
     private requestAskUserFromClient;
     private notify;
     /**
@@ -115,5 +218,14 @@ export declare class AgentServer {
     private anyEngine;
     close(): void;
     private clearApprovalTimer;
+    /**
+     * Resolve all of a chat session's pending approvals as cancelled and clear
+     * the 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).
+     */
+    private cancelSessionApprovals;
     private clearAllApprovalTimers;
 }