wave-code 1.0.0 → 1.0.1

package/dist/managers/inputHandlers.js

@@ -33,15 +33,27 @@ export const handleSubmit = async (state, dispatch, callbacks, attachedImagesOve
             const question = contentWithPlaceholders.startsWith("/btw ")
                 ? contentWithPlaceholders.substring(5).trim()
                 : "";
-            const payload = {
-                isActive: true,
-                question,
-                isLoading: question !== "",
-            };
-            dispatch({
-                type: "SET_BTW_STATE",
-                payload,
-            });
+            if (question) {
+                dispatch({
+                    type: "SET_BTW_STATE",
+                    payload: {
+                        question,
+                        isLoading: true,
+                        answer: undefined,
+                    },
+                });
+            }
+            else {
+                // Bare /btw — show usage (aligned with Claude Code)
+                dispatch({
+                    type: "SET_BTW_STATE",
+                    payload: {
+                        question: "",
+                        isLoading: false,
+                        answer: "Usage: /btw <your question>",
+                    },
+                });
+            }
             dispatch({ type: "CLEAR_INPUT" });
             dispatch({ type: "RESET_HISTORY_NAVIGATION" });
             dispatch({ type: "CLEAR_LONG_TEXT_MAP" });
@@ -261,6 +273,18 @@ export const handleCommandSelect = (state, dispatch, callbacks, command) => {
                 else if (command === "status") {
                     dispatch({ type: "SET_SHOW_STATUS_COMMAND", payload: true });
                 }
+                else if (command === "btw") {
+                    // Bare /btw executed via the command selector — show usage
+                    // (aligned with Claude Code's empty-args message).
+                    dispatch({
+                        type: "SET_BTW_STATE",
+                        payload: {
+                            question: "",
+                            isLoading: false,
+                            answer: "Usage: /btw <your question>",
+                        },
+                    });
+                }
                 else if (command === "plugin") {
                     dispatch({ type: "SET_SHOW_PLUGIN_MANAGER", payload: true });
                 }
@@ -276,9 +300,6 @@ export const handleCommandSelect = (state, dispatch, callbacks, command) => {
                 else if (command === "compact") {
                     await callbacks.onCompact?.();
                 }
-                else if (command === "goal") {
-                    await callbacks.onGoalCommand?.();
-                }
             }
         })();
         dispatch({ type: "CANCEL_COMMAND_SELECTOR" });
@@ -507,16 +528,23 @@ export const handleNormalInput = async (state, dispatch, callbacks, input, key,
     return false;
 };
 export const handleInput = async (state, dispatch, callbacks, input, key, clearImages) => {
-    // Handle ESC to dismiss btw answer
-    if (key.escape && state.btwState.question && !state.btwState.isLoading) {
-        dispatch({
-            type: "SET_BTW_STATE",
-            payload: {
-                question: "",
-                answer: undefined,
-                isLoading: false,
-            },
-        });
+    // /btw overlay handling (mirrors inputReducer's HANDLE_KEY block; this
+    // handler is not wired, kept in sync for consistency). Active while a
+    // question is displayed, or the bare-/btw usage message shows. Only
+    // Escape dismisses; every other key is ignored.
+    if (state.btwState.question || state.btwState.answer) {
+        if (key.escape) {
+            dispatch({
+                type: "SET_BTW_STATE",
+                payload: {
+                    question: "",
+                    answer: undefined,
+                    isLoading: false,
+                },
+            });
+            return true;
+        }
+        // Any other key while the overlay is up is ignored
         return true;
     }
     if (key.escape) {

package/dist/managers/inputReducer.d.ts

@@ -10,6 +10,15 @@ export interface BtwState {
     answer?: string;
     isLoading: boolean;
 }
+/**
+ * True while the /btw overlay is up (a question is on display, loading or
+ * answered). App's Ctrl+C exit handler checks this so Ctrl+C does not quit
+ * the app while the overlay owns the keys. Synced from useInputManager via
+ * an effect.
+ */
+export declare const btwOverlayActiveRef: {
+    current: boolean;
+};
 export declare const ESC_DOUBLE_PRESS_TIMEOUT_MS = 1000;
 export type PendingEffect = {
     type: "SEND_MESSAGE";
@@ -30,6 +39,8 @@ export type PendingEffect = {
 } | {
     type: "ASK_BTW";
     question: string;
+} | {
+    type: "ABORT_BTW";
 } | {
     type: "PERMISSION_MODE_CHANGE";
     mode: PermissionMode;
@@ -67,10 +78,9 @@ export interface InputManagerCallbacks {
     onAbortMessage?: () => void;
     onBackgroundCurrentTask?: () => void;
     onPermissionModeChange?: (mode: PermissionMode) => void;
-    onAskBtw?: (question: string) => Promise<string>;
+    onAskBtw?: (question: string, abortSignal?: AbortSignal, onContent?: (content: string) => void) => Promise<string>;
     onClearMessages?: () => Promise<void>;
     onCompact?: (instructions?: string) => Promise<void>;
-    onGoalCommand?: (args?: string) => Promise<void>;
     sessionId?: string;
     workdir?: string;
     getFullMessageThread?: () => Promise<{

package/dist/managers/inputReducer.js

@@ -1,5 +1,12 @@
 import { getAtSelectorPosition, getSlashSelectorPosition, getWordEnd, SELECTOR_TRIGGERS, getProjectedState, } from "../utils/inputUtils.js";
 import { AVAILABLE_COMMANDS } from "../constants/commands.js";
+/**
+ * True while the /btw overlay is up (a question is on display, loading or
+ * answered). App's Ctrl+C exit handler checks this so Ctrl+C does not quit
+ * the app while the overlay owns the keys. Synced from useInputManager via
+ * an effect.
+ */
+export const btwOverlayActiveRef = { current: false };
 export const ESC_DOUBLE_PRESS_TIMEOUT_MS = 1000;
 export const initialState = {
     inputText: "",
@@ -91,7 +98,7 @@ function insertTextWithPlaceholder(textToInsert, state) {
 /**
  * Submit the current input text: extract [Image #N] references, route /btw
  * and CLI-internal slash commands, otherwise send as a message. Returns null
- * when there is nothing to submit (empty text, bare /btw).
+ * when there is nothing to submit (empty text).
  */
 function submitInput(state) {
     if (!state.inputText.trim()) {
@@ -112,8 +119,20 @@ function submitInput(state) {
     if (contentWithPlaceholders.startsWith("/btw ")) {
         const question = contentWithPlaceholders.substring(5).trim();
         if (!question) {
-            // Bare /btw with no question text — ignore
-            return null;
+            // "/btw " with no question text — show usage (aligned with Claude Code)
+            return {
+                ...state,
+                inputText: "",
+                cursorPosition: 0,
+                historyIndex: -1,
+                longTextMap: {},
+                attachedImages: [],
+                btwState: {
+                    question: "",
+                    isLoading: false,
+                    answer: "Usage: /btw <your question>",
+                },
+            };
         }
         return {
             ...state,
@@ -131,8 +150,20 @@ function submitInput(state) {
         };
     }
     if (contentWithPlaceholders === "/btw") {
-        // Bare /btw — ignore
-        return null;
+        // Bare /btw — show usage (aligned with Claude Code)
+        return {
+            ...state,
+            inputText: "",
+            cursorPosition: 0,
+            historyIndex: -1,
+            longTextMap: {},
+            attachedImages: [],
+            btwState: {
+                question: "",
+                isLoading: false,
+                answer: "Usage: /btw <your question>",
+            },
+        };
     }
     // Check if the content is a CLI-internal slash command (help, tasks,
     // etc.) that should be executed locally rather than sent as a message.
@@ -593,10 +624,22 @@ export function inputReducer(state, action) {
                 }
                 return state;
             }
-            // 1. Escape Handling
-            if (key.escape) {
-                // Dismiss btw answer
-                if (state.btwState.question && !state.btwState.isLoading) {
+            // 1. /btw overlay handling (active while a question is displayed, or
+            // the bare-/btw usage message). Only Escape dismisses (or aborts the
+            // in-flight side question while loading); every other key is ignored.
+            if (state.btwState.question || state.btwState.answer) {
+                if (key.escape) {
+                    if (state.btwState.isLoading) {
+                        return {
+                            ...state,
+                            btwState: {
+                                question: "",
+                                answer: undefined,
+                                isLoading: false,
+                            },
+                            pendingEffect: { type: "ABORT_BTW" },
+                        };
+                    }
                     return {
                         ...state,
                         btwState: {
@@ -606,6 +649,11 @@ export function inputReducer(state, action) {
                         },
                     };
                 }
+                // Any other key while the overlay is up is ignored
+                return state;
+            }
+            // 1. Escape Handling
+            if (key.escape) {
                 if (state.showFileSelector) {
                     return {
                         ...state,

package/dist/stdio/agentBridge.d.ts

@@ -21,6 +21,9 @@ export interface AgentBridgeOptions {
 }
 export declare class AgentBridge {
     private sessions;
+    /** Pending approval requests, keyed by requestId. Stored with the resolve +
+     * context so a re-attached client can list and respond to them (daemon mode:
+     * approvals outlive any single connection). */
     private pendingPermissions;
     private permissionCounter;
     private emit;
@@ -31,6 +34,21 @@ export declare class AgentBridge {
     handleNotification(method: string, params: unknown): void;
     private initialize;
     private destroy;
+    /**
+     * True when every hosted session has settled: not generating, nothing queued,
+     * and no background work (background bash / subagents / workflows) — the same
+     * condition `wave -p` waits on before exiting (print-cli.ts). Pending
+     * permission approvals keep the owning agent's isLoading true, so they are
+     * covered without an explicit check.
+     */
+    isIdle(): boolean;
+    /**
+     * Destroy every hosted session agent. Each Agent.destroy() saves its
+     * transcript, drains in-flight auto-memory extraction, and cleans up
+     * background tasks/subagents. Best-effort: one failing destroy must not
+     * block the rest of the shutdown.
+     */
+    destroyAll(): Promise<void>;
     private restoreSession;
     private listSessions;
     private listGitBranches;
@@ -40,6 +58,7 @@ export declare class AgentBridge {
     private updateConfig;
     private sendMessage;
     private bang;
+    private askBtw;
     private abortMessage;
     private clearMessages;
     private rewindToMessage;
@@ -64,6 +83,10 @@ export declare class AgentBridge {
     private getPromptHistory;
     private searchPromptHistory;
     private canUseTool;
+    /** Attach snapshot: re-surface approvals that are still pending after a
+     * client disconnected (daemon mode). Responding to any listed requestId
+     * resolves the in-process promise. */
+    private listPendingPermissions;
     private getAuthStatus;
     private login;
     private logout;

package/dist/stdio/agentBridge.js

@@ -23,6 +23,9 @@ import { isUserCheckpointMessage } from "../utils/rewindCheckpoints.js";
 export class AgentBridge {
     constructor(options) {
         this.sessions = new Map();
+        /** Pending approval requests, keyed by requestId. Stored with the resolve +
+         * context so a re-attached client can list and respond to them (daemon mode:
+         * approvals outlive any single connection). */
         this.pendingPermissions = new Map();
         this.permissionCounter = 0;
         this.emit = options.emit;
@@ -42,6 +45,8 @@ export class AgentBridge {
                 return this.listSessions(p.workdir, sessionId);
             case "getSessionInfo":
                 return this.getSessionInfo(sessionId);
+            case "listPendingPermissions":
+                return this.listPendingPermissions();
             case "updateConfig":
                 return this.updateConfig(p, sessionId);
             // ── Messages ──
@@ -49,6 +54,8 @@ export class AgentBridge {
                 return this.sendMessage(p, sessionId);
             case "bang":
                 return this.bang(p.command, sessionId);
+            case "askBtw":
+                return this.askBtw(p.question, sessionId);
             case "abortMessage":
                 return this.abortMessage(sessionId);
             case "clearMessages":
@@ -147,15 +154,29 @@ export class AgentBridge {
         if (method === "permissionResponse") {
             const p = params;
             // requestId is process-level unique; lookup doesn't need sessionId
-            const resolve = this.pendingPermissions.get(p.requestId);
-            if (resolve) {
+            const entry = this.pendingPermissions.get(p.requestId);
+            if (entry) {
                 this.pendingPermissions.delete(p.requestId);
-                resolve(p.decision);
+                entry.resolve(p.decision);
             }
         }
     }
     // ── Lifecycle ─────────────────────────────────────────────────
     async initialize(params) {
+        // Re-attach (daemon mode): if the target session is already live in this
+        // process, reuse it instead of creating a second agent writing to the same
+        // transcript. The live agent keeps running across client detach/attach.
+        if (params.restoreSessionId) {
+            const live = this.sessions.get(params.restoreSessionId);
+            if (live) {
+                return {
+                    sessionId: live.agent.sessionId,
+                    workingDirectory: live.agent.workingDirectory,
+                    permissionMode: live.agent.getPermissionMode(),
+                    latestTotalTokens: live.agent.latestTotalTokens,
+                };
+            }
+        }
         const ctx = {};
         const callbacks = this.createCallbacks(ctx);
         const options = {
@@ -203,8 +224,53 @@ export class AgentBridge {
         }
         return null;
     }
+    /**
+     * True when every hosted session has settled: not generating, nothing queued,
+     * and no background work (background bash / subagents / workflows) — the same
+     * condition `wave -p` waits on before exiting (print-cli.ts). Pending
+     * permission approvals keep the owning agent's isLoading true, so they are
+     * covered without an explicit check.
+     */
+    isIdle() {
+        for (const entry of this.sessions.values()) {
+            const agent = entry.agent;
+            if (agent.isLoading ||
+                agent.hasPendingMessages ||
+                agent.hasRunningBackgroundWork) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Destroy every hosted session agent. Each Agent.destroy() saves its
+     * transcript, drains in-flight auto-memory extraction, and cleans up
+     * background tasks/subagents. Best-effort: one failing destroy must not
+     * block the rest of the shutdown.
+     */
+    async destroyAll() {
+        const entries = [...this.sessions.values()];
+        this.sessions.clear();
+        await Promise.all(entries.map((entry) => entry.agent.destroy().catch(() => { })));
+    }
     async restoreSession(restoreId, sessionId) {
         const entry = this.requireSession(sessionId);
+        // Re-attach to a live session: the SDK restore would no-op (target is
+        // already current). Emit the current messages so the freshly attached
+        // client — whose router registered only after initialize returned and so
+        // missed any earlier notifications — gets a snapshot without replay.
+        if (entry.agent.sessionId === restoreId) {
+            this.emit("messagesChange", { messages: entry.agent.messages }, entry.agent.sessionId);
+            // The re-attached client also missed the loading state that settled
+            // before its router registered — replay it or the client's
+            // isStreaming/running indicator stays false while the live session
+            // keeps generating.
+            this.emit("loadingChange", {
+                loading: entry.agent.isLoading,
+                latestTotalTokens: entry.agent.latestTotalTokens,
+            }, entry.agent.sessionId);
+            return null;
+        }
         await entry.agent.restoreSession(restoreId);
         return null;
     }
@@ -378,6 +444,22 @@ export class AgentBridge {
         await entry.agent.bang(command);
         return null;
     }
+    async askBtw(question, sessionId) {
+        const entry = this.requireSession(sessionId);
+        return entry.agent.askBtw(question, undefined, 
+        // Stream partial content to the client so webview hosts can render the
+        // answer incrementally (thinking and content travel on separate
+        // channels so the panel can drop thinking text once content starts).
+        (content) => {
+            if (sessionId) {
+                this.emit("btwContent", { question, content, type: "content" }, sessionId);
+            }
+        }, (content) => {
+            if (sessionId) {
+                this.emit("btwContent", { question, content, type: "thinking" }, sessionId);
+            }
+        });
+    }
     async abortMessage(sessionId) {
         const entry = this.requireSession(sessionId);
         entry.agent.abortMessage();
@@ -522,10 +604,26 @@ export class AgentBridge {
     canUseTool(context, ctx) {
         const requestId = `perm_${++this.permissionCounter}`;
         return new Promise((resolve) => {
-            this.pendingPermissions.set(requestId, resolve);
+            this.pendingPermissions.set(requestId, {
+                resolve,
+                sessionId: ctx.registeredSessionId,
+                context,
+            });
             this.emit("permissionRequest", { requestId, context }, ctx.registeredSessionId);
         });
     }
+    /** Attach snapshot: re-surface approvals that are still pending after a
+     * client disconnected (daemon mode). Responding to any listed requestId
+     * resolves the in-process promise. */
+    listPendingPermissions() {
+        return {
+            requests: [...this.pendingPermissions.entries()].map(([requestId, entry]) => ({
+                requestId,
+                sessionId: entry.sessionId,
+                context: entry.context,
+            })),
+        };
+    }
     // ── Auth (global) ────────────────────────────────────────────
     async getAuthStatus() {
         const authService = AuthService.getInstance();
@@ -627,9 +725,6 @@ export class AgentBridge {
     // ── Callbacks → Notifications ─────────────────────────────────
     createCallbacks(ctx) {
         return {
-            onMessagesChange: (messages) => {
-                this.emit("messagesChange", { messages }, ctx.registeredSessionId);
-            },
             onUserMessageAdded: () => {
                 const msg = this.findLastUserMessage(ctx.agent);
                 if (msg)
@@ -641,13 +736,28 @@ export class AgentBridge {
                     this.emit("assistantMessageAdded", { message: msg }, ctx.registeredSessionId);
             },
             onAssistantContentUpdated: (params) => {
-                this.emit("assistantContentUpdated", params, ctx.registeredSessionId);
+                // Wire carries only the delta; consumers accumulate (spec: 流式通知纯增量负载).
+                this.emit("assistantContentUpdated", {
+                    messageId: params.messageId,
+                    chunk: params.chunk,
+                    stage: params.stage,
+                }, ctx.registeredSessionId);
             },
             onAssistantReasoningUpdated: (params) => {
-                this.emit("assistantReasoningUpdated", params, ctx.registeredSessionId);
+                this.emit("assistantReasoningUpdated", {
+                    messageId: params.messageId,
+                    chunk: params.chunk,
+                    stage: params.stage,
+                }, ctx.registeredSessionId);
             },
             onToolBlockUpdated: (params) => {
-                this.emit("toolBlockUpdated", params, ctx.registeredSessionId);
+                // Streaming stages carry only the parametersChunk delta; start/running
+                // (one-time snapshots) and end (authoritative full value) keep
+                // `parameters` (spec: 流式通知纯增量负载).
+                const { parameters, ...rest } = params;
+                void parameters;
+                const wireParams = params.stage === "streaming" ? rest : params;
+                this.emit("toolBlockUpdated", wireParams, ctx.registeredSessionId);
             },
             onErrorBlockAdded: (error) => {
                 this.emit("errorBlockAdded", { error }, ctx.registeredSessionId);
@@ -705,14 +815,14 @@ export class AgentBridge {
             onMcpServersChange: (servers) => {
                 this.emit("mcpServersChange", { servers }, ctx.registeredSessionId);
             },
-            onAddBangMessage: () => {
-                this.emit("bangMessageAdded", {}, ctx.registeredSessionId);
+            onAddBangMessage: (command, messageId) => {
+                this.emit("bangMessageAdded", { command, messageId }, ctx.registeredSessionId);
             },
-            onUpdateBangMessage: () => {
-                this.emit("bangMessageUpdated", {}, ctx.registeredSessionId);
+            onUpdateBangMessage: (command, output, messageId) => {
+                this.emit("bangMessageUpdated", { command, output, messageId }, ctx.registeredSessionId);
             },
-            onCompleteBangMessage: () => {
-                this.emit("bangMessageCompleted", {}, ctx.registeredSessionId);
+            onCompleteBangMessage: (command, exitCode, messageId) => {
+                this.emit("bangMessageCompleted", { command, exitCode, messageId }, ctx.registeredSessionId);
             },
             onNotificationMessageAdded: (params) => {
                 const msg = ctx.agent?.messages.find((m) => m.role === "user" &&

package/dist/stdio/daemonServer.d.ts

@@ -0,0 +1,67 @@
+/**
+ * DaemonServer — JSON-RPC server over a unix socket for remote background
+ * sessions (spec: docs/specs/ui/desktop-app.md 「SSH 远程后台会话」).
+ *
+ * The desktop app launches `wave --daemon <socket>` on the remote host via
+ * nohup/setsid, then tunnels the socket back with `ssh -L`. All connections
+ * share one AgentBridge, so sessions and pending tool permissions survive
+ * client detach/attach — the daemon keeps running (and generating) while no
+ * desktop is connected. The daemon never exits on a client disconnect; it
+ * only exits when killed (app quit / 删除会话 / remote reboot).
+ *
+ * Idle auto-exit (spec: 「远程 daemon 空闲自动退出」): once every session has
+ * settled and no client is connected, the daemon mirrors `wave -p`'s exit
+ * semantics — after a grace period it destroys the sessions (saving their
+ * transcripts), closes the socket, and exits, so the remote process doesn't
+ * linger forever after background work completes.
+ */
+import { AgentBridge, type AgentBridgeOptions } from "./agentBridge.js";
+export interface DaemonServerOptions {
+    socketPath: string;
+    bridgeOptions?: AgentBridgeOptions;
+    /** Idle grace period before the daemon auto-exits (default 60s). */
+    graceMs?: number;
+}
+export declare class DaemonServer {
+    static readonly DEFAULT_IDLE_GRACE_MS = 60000;
+    private socketPath;
+    private server;
+    private bridge;
+    private connections;
+    private sockets;
+    private graceMs;
+    private idleTimer;
+    private shuttingDown;
+    private stopped;
+    constructor(options: DaemonServerOptions);
+    get agentBridge(): AgentBridge;
+    /**
+     * Listen on the socket path. Rejects when a live daemon already holds it. A
+     * stale socket file left by a crashed daemon would otherwise block the
+     * restart with EADDRINUSE, so it is cleaned up first: non-socket files are
+     * unlinked outright; socket files are probe-connected — ECONNREFUSED means
+     * no listener (stale → unlink and listen), anything else means a live
+     * daemon owns the path (reject).
+     */
+    start(): Promise<void>;
+    private listen;
+    stop(): Promise<void>;
+    private clearIdleTimer;
+    /**
+     * Re-evaluate the idle condition after any state transition: sessions busy
+     * (loading / pending messages / background work) or any client attached →
+     * cancel the timer. Fully idle + detached → arm the grace timer once; when
+     * it fires, shut the daemon down. Evaluation is event-driven (every
+     * busy→idle transition emits a notification, every attach/detach fires a
+     * connection event), so nothing is polled. The failure mode is
+     * conservative: a missed transition just leaves the daemon running.
+     */
+    private evaluateIdle;
+    /**
+     * Destroy the sessions (each agent saves its transcript and drains
+     * auto-memory), close the listener, unlink the socket file, then exit.
+     * `shuttingDown` guards against re-entry: new connections are refused and
+     * further idle evaluations become no-ops.
+     */
+    private shutdown;
+}