wave-code 1.0.0 → 1.0.2

package/dist/hooks/useInputManager.js

@@ -1,10 +1,20 @@
-import { useEffect, useReducer, useCallback } from "react";
-import { inputReducer, initialState, ESC_DOUBLE_PRESS_TIMEOUT_MS, } from "../managers/inputReducer.js";
+import { useEffect, useReducer, useCallback, useRef } from "react";
+import { inputReducer, initialState, ESC_DOUBLE_PRESS_TIMEOUT_MS, btwOverlayActiveRef, } from "../managers/inputReducer.js";
+import { createBracketedPasteDetector } from "../utils/bracketedPaste.js";
 import { searchFiles as searchFilesUtil, PromptHistoryManager, } from "wave-agent-sdk";
 import * as handlers from "../managers/inputHandlers.js";
 export const useInputManager = (callbacks = {}) => {
     const [state, dispatch] = useReducer(inputReducer, initialState);
-    const { onInputTextChange, onCursorPositionChange, onFileSelectorStateChange, onCommandSelectorStateChange, onHistorySearchStateChange, onBackgroundTaskManagerStateChange, onMcpManagerStateChange, onRewindManagerStateChange, onHelpStateChange, onStatusCommandStateChange, onPluginManagerStateChange, onModelSelectorStateChange, onWorkflowManagerStateChange, onImagesStateChange, onSendMessage, onHasSlashCommand, onAbortMessage, onBackgroundCurrentTask, onPermissionModeChange, onAskBtw, sessionId, workdir, getFullMessageThread, logger, hasQueuedMessages: hasQueuedMessagesProp, onRecallQueuedMessage, onClearMessages, onCompact, onGoalCommand, isIdle: isIdleProp, } = callbacks;
+    // Detects bracketed paste (DECSET 2004) markers so pasted text is inserted
+    // without triggering submit — a pasted trailing \r must not be treated as
+    // Enter (see utils/bracketedPaste.ts).
+    const pasteDetectorRef = useRef(createBracketedPasteDetector());
+    // Abort plumbing for the /btw side question: ABORT_BTW (set when the overlay
+    // is dismissed while loading) aborts the in-flight onAskBtw call; the
+    // dismissed ref suppresses the late SET_BTW_STATE dispatch / error logging.
+    const btwAbortRef = useRef(null);
+    const btwDismissedRef = useRef(false);
+    const { onInputTextChange, onCursorPositionChange, onFileSelectorStateChange, onCommandSelectorStateChange, onHistorySearchStateChange, onBackgroundTaskManagerStateChange, onMcpManagerStateChange, onRewindManagerStateChange, onHelpStateChange, onStatusCommandStateChange, onPluginManagerStateChange, onModelSelectorStateChange, onWorkflowManagerStateChange, onImagesStateChange, onSendMessage, onHasSlashCommand, onAbortMessage, onBackgroundCurrentTask, onPermissionModeChange, onAskBtw, sessionId, workdir, getFullMessageThread, logger, hasQueuedMessages: hasQueuedMessagesProp, onRecallQueuedMessage, onClearMessages, onCompact, isIdle: isIdleProp, } = callbacks;
     // Handle debounced file search
     useEffect(() => {
         if (state.showFileSelector) {
@@ -67,25 +77,49 @@ export const useInputManager = (callbacks = {}) => {
                     case "BACKGROUND_CURRENT_TASK":
                         onBackgroundCurrentTask?.();
                         break;
-                    case "ASK_BTW":
+                    case "ASK_BTW": {
+                        const controller = new AbortController();
+                        btwAbortRef.current = controller;
+                        btwDismissedRef.current = false;
                         try {
-                            const answer = await onAskBtw?.(effect.question);
-                            dispatch({
-                                type: "SET_BTW_STATE",
-                                payload: { answer, isLoading: false },
+                            const answer = await onAskBtw?.(effect.question, controller.signal, (content) => {
+                                // Stream partial answers into the overlay so the user sees
+                                // the response grow in real time (same visual language as
+                                // assistant text / thinking blocks) instead of a static
+                                // "Answering..." indicator.
+                                if (!btwDismissedRef.current) {
+                                    dispatch({
+                                        type: "SET_BTW_STATE",
+                                        payload: { answer: content, isLoading: true },
+                                    });
+                                }
                             });
+                            if (!btwDismissedRef.current) {
+                                dispatch({
+                                    type: "SET_BTW_STATE",
+                                    payload: { answer, isLoading: false },
+                                });
+                            }
                         }
                         catch (error) {
-                            console.error("Failed to ask side question:", error);
-                            dispatch({
-                                type: "SET_BTW_STATE",
-                                payload: {
-                                    answer: "Error: Failed to get an answer for your side question.",
-                                    isLoading: false,
-                                },
-                            });
+                            if (!btwDismissedRef.current) {
+                                console.error("Failed to ask side question:", error);
+                                dispatch({
+                                    type: "SET_BTW_STATE",
+                                    payload: {
+                                        answer: "Error: Failed to get an answer for your side question.",
+                                        isLoading: false,
+                                    },
+                                });
+                            }
                         }
                         break;
+                    }
+                    case "ABORT_BTW":
+                        btwDismissedRef.current = true;
+                        btwAbortRef.current?.abort();
+                        btwAbortRef.current = null;
+                        break;
                     case "PERMISSION_MODE_CHANGE":
                         onPermissionModeChange?.(effect.mode);
                         break;
@@ -155,6 +189,18 @@ export const useInputManager = (callbacks = {}) => {
                             else if (command === "logout") {
                                 dispatch({ type: "SET_SHOW_LOGIN_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 });
                             }
@@ -170,9 +216,6 @@ export const useInputManager = (callbacks = {}) => {
                             else if (command === "compact") {
                                 await onCompact?.(effect.args);
                             }
-                            else if (command === "goal") {
-                                await onGoalCommand?.(effect.args);
-                            }
                         }
                         break;
                     case "RECALL_QUEUED_MESSAGE":
@@ -200,7 +243,6 @@ export const useInputManager = (callbacks = {}) => {
         onRecallQueuedMessage,
         onClearMessages,
         onCompact,
-        onGoalCommand,
     ]);
     useEffect(() => {
         onFileSelectorStateChange?.(state.showFileSelector, state.filteredFiles, state.fileSearchQuery, state.atPosition);
@@ -253,7 +295,13 @@ export const useInputManager = (callbacks = {}) => {
     useEffect(() => {
         onImagesStateChange?.(state.attachedImages);
     }, [state.attachedImages, onImagesStateChange]);
-    // /btw side question is handled via pendingEffect "ASK_BTW" above
+    // Keep the shared overlay-active flag in sync so App's Ctrl+C exit handler
+    // can defer to the /btw overlay (ink runs ALL useInput handlers per keypress
+    // with no propagation control).
+    useEffect(() => {
+        btwOverlayActiveRef.current =
+            state.btwState.question !== "" || state.btwState.answer !== undefined;
+    }, [state.btwState.question, state.btwState.answer]);
     // Methods
     const insertTextAtCursor = useCallback((text) => {
         dispatch({ type: "INSERT_TEXT", payload: text });
@@ -397,10 +445,39 @@ export const useInputManager = (callbacks = {}) => {
         dispatch({ type: "CLEAR_LONG_TEXT_MAP" });
     }, []);
     const handleInput = useCallback(async (input, key) => {
+        const result = pasteDetectorRef.current.process(input);
+        if (result.kind === "consume") {
+            // Content of an in-flight bracketed paste (or an empty paste):
+            // hold it, never submit or insert prematurely.
+            return true;
+        }
+        if (result.kind === "paste") {
+            if (result.leadingInput) {
+                dispatch({
+                    type: "HANDLE_KEY",
+                    payload: {
+                        input: result.leadingInput,
+                        key,
+                        hasSlashCommand: (cmd) => !!onHasSlashCommand?.(cmd),
+                        hasQueuedMessages: hasQueuedMessagesProp ?? false,
+                        isIdle: isIdleProp ?? false,
+                    },
+                });
+            }
+            if (result.text !== "") {
+                // Insert-only: \r → \n normalizes CRLF terminals, matching the
+                // canonical paste path (inputHandlers.handlePasteInput).
+                dispatch({
+                    type: "INSERT_TEXT_WITH_PLACEHOLDER",
+                    payload: result.text.replace(/\r/g, "\n"),
+                });
+            }
+            return true;
+        }
         dispatch({
             type: "HANDLE_KEY",
             payload: {
-                input,
+                input: result.input,
                 key,
                 hasSlashCommand: (cmd) => !!onHasSlashCommand?.(cmd),
                 hasQueuedMessages: hasQueuedMessagesProp ?? false,

package/dist/index.js

@@ -44,6 +44,11 @@ export async function main() {
             type: "boolean",
             default: false,
             global: false,
+        })
+            .option("daemon", {
+            description: "Start as a background daemon (JSON-RPC over a unix socket at PATH)",
+            type: "string",
+            global: false,
         })
             .option("show-stats", {
             description: "Show timing and usage statistics in print mode",
@@ -300,6 +305,11 @@ export async function main() {
             const { startStdioCli } = await import("./stdio-cli.js");
             return startStdioCli();
         }
+        // Handle daemon mode (remote background sessions)
+        if (typeof argv.daemon === "string") {
+            const { startDaemonCli } = await import("./daemon-cli.js");
+            return startDaemonCli(argv.daemon);
+        }
         await startCli({
             restoreSessionId: argv.restore,
             continueLastSession: argv.continue,

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;