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

package/dist/protocol/client.js

@@ -99,6 +99,50 @@ export class AgentClient {
     async cancel(sessionId, reason) {
         await this.request(Methods.Cancel, { sessionId, reason });
     }
+    /**
+     * Clear a session's persisted active goal (CC `/goal clear`). Returns whether
+     * a goal was actually cleared (false = there was none).
+     */
+    async goalClear(sessionId) {
+        const res = (await this.request(Methods.GoalClear, { sessionId }));
+        return res?.cleared === true;
+    }
+    /**
+     * Read a session's persisted active goal objective, or null when there's
+     * none. The host calls this on session load to re-surface the goal block +
+     * Cancel button after a reload (a persistent goal isn't replayed from the
+     * transcript, so the live stream never re-announces it).
+     */
+    async goalGet(sessionId) {
+        const res = (await this.request(Methods.GoalGet, { sessionId }));
+        return res?.goal ?? null;
+    }
+    /**
+     * Steer an in-flight run: queue a user message spliced in at the next
+     * turn-loop step (不打断 — does not abort the current step). `id` is a stable
+     * host-side handle that rides through to the steer_injected event and lets
+     * unsteer() revoke a still-pending entry. Mirrors the server's handleSteer +
+     * the desktop preload's steer(); without it the SDK can't reach the method
+     * (request() is private) — the protocol was asymmetric after the steer merge.
+     */
+    async steer(sessionId, text, id, clientMessageId) {
+        const res = (await this.request(Methods.Steer, {
+            sessionId,
+            text,
+            id,
+            clientMessageId,
+        }));
+        return { accepted: res?.accepted === true, id: res?.id };
+    }
+    /**
+     * Revoke a still-pending steer entry by id (before the loop consumes it).
+     * Returns false when the loop already consumed it (not an error — it will
+     * arrive as a normal user bubble).
+     */
+    async unsteer(sessionId, id) {
+        const res = (await this.request(Methods.Unsteer, { sessionId, id }));
+        return res?.removed === true;
+    }
     /**
      * Update runtime configuration on the server.
      */

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,31 +92,122 @@ 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).
      */
     private requestApprovalFromClient;
     /**
-     * Ask the client to answer a question from the agent (legacy single-engine path).
+     * 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.
      */
+    private requestAskUserForSession;
     /**
-     * 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.
+     * 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;
+    /**
+     * 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.
      */
-    private requestAskUserForSession;
     private requestAskUserFromClient;
     private notify;
     /**
@@ -115,5 +220,13 @@ export declare class AgentServer {
     private anyEngine;
     close(): void;
     private clearApprovalTimer;
+    /**
+     * Resolve all of a chat session's pending approvals as cancelled and clear
+     * 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. Bounded request types have same-keyed timer entries;
+     * AskUserQuestion does not.
+     */
+    private cancelSessionApprovals;
     private clearAllApprovalTimers;
 }