wave-code 0.19.9 → 1.0.1

package/dist/hooks/useInputManager.js

@@ -1,10 +1,20 @@
-import { useEffect, useReducer, useCallback } from "react";
-import { inputReducer, initialState, } 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, } = 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) {
@@ -24,22 +34,16 @@ export const useInputManager = (callbacks = {}) => {
             return () => clearTimeout(timer);
         }
     }, [state.showFileSelector, state.fileSearchQuery]);
-    // Handle paste debouncing
+    // Auto-expire the double-Esc clear pending flag after the timeout window
+    // (aligned with Claude Code's useDoublePress timeout-based expiry).
     useEffect(() => {
-        if (state.isPasting) {
-            const pasteDebounceDelay = parseInt(process.env.PASTE_DEBOUNCE_MS || "30", 10);
-            const timer = setTimeout(() => {
-                const processedInput = state.pasteBuffer.replace(/\r/g, "\n");
-                dispatch({
-                    type: "INSERT_TEXT_WITH_PLACEHOLDER",
-                    payload: processedInput,
-                });
-                dispatch({ type: "END_PASTE" });
-                dispatch({ type: "RESET_HISTORY_NAVIGATION" });
-            }, pasteDebounceDelay);
-            return () => clearTimeout(timer);
-        }
-    }, [state.isPasting, state.pasteBuffer]);
+        if (!state.escClearPending)
+            return;
+        const timer = setTimeout(() => {
+            dispatch({ type: "RESET_ESC_CLEAR_PENDING" });
+        }, ESC_DOUBLE_PRESS_TIMEOUT_MS);
+        return () => clearTimeout(timer);
+    }, [state.escClearPending]);
     // Sync state changes with callbacks
     useEffect(() => {
         onInputTextChange?.(state.inputText);
@@ -65,28 +69,57 @@ export const useInputManager = (callbacks = {}) => {
                     case "ABORT_MESSAGE":
                         onAbortMessage?.();
                         break;
+                    case "SAVE_PROMPT_HISTORY":
+                        PromptHistoryManager.addEntry(effect.content, sessionId, effect.longTextMap, workdir).catch((err) => {
+                            logger?.error("Failed to save prompt history", err);
+                        });
+                        break;
                     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;
@@ -156,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 });
                             }
@@ -171,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":
@@ -201,7 +243,6 @@ export const useInputManager = (callbacks = {}) => {
         onRecallQueuedMessage,
         onClearMessages,
         onCompact,
-        onGoalCommand,
     ]);
     useEffect(() => {
         onFileSelectorStateChange?.(state.showFileSelector, state.filteredFiles, state.fileSearchQuery, state.atPosition);
@@ -254,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 });
@@ -375,9 +422,10 @@ export const useInputManager = (callbacks = {}) => {
                 key: {},
                 hasSlashCommand: (cmd) => !!onHasSlashCommand?.(cmd),
                 hasQueuedMessages: hasQueuedMessagesProp ?? false,
+                isIdle: isIdleProp ?? false,
             },
         });
-    }, [onHasSlashCommand, hasQueuedMessagesProp]);
+    }, [onHasSlashCommand, hasQueuedMessagesProp, isIdleProp]);
     const handleSubmit = useCallback(async () => {
         dispatch({
             type: "HANDLE_KEY",
@@ -386,9 +434,10 @@ export const useInputManager = (callbacks = {}) => {
                 key: { return: true },
                 hasSlashCommand: (cmd) => !!onHasSlashCommand?.(cmd),
                 hasQueuedMessages: hasQueuedMessagesProp ?? false,
+                isIdle: isIdleProp ?? false,
             },
         });
-    }, [onHasSlashCommand, hasQueuedMessagesProp]);
+    }, [onHasSlashCommand, hasQueuedMessagesProp, isIdleProp]);
     const expandLongTextPlaceholders = useCallback((text) => {
         return handlers.expandLongTextPlaceholders(text, state.longTextMap);
     }, [state.longTextMap]);
@@ -396,17 +445,47 @@ 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,
+                isIdle: isIdleProp ?? false,
             },
         });
         return true;
-    }, [onHasSlashCommand, hasQueuedMessagesProp]);
+    }, [onHasSlashCommand, hasQueuedMessagesProp, isIdleProp]);
     return {
         // State
         inputText: state.inputText,
@@ -433,6 +512,7 @@ export const useInputManager = (callbacks = {}) => {
         permissionMode: state.permissionMode,
         attachedImages: state.attachedImages,
         btwState: state.btwState,
+        escClearPending: state.escClearPending,
         isManagerReady: true,
         // Methods
         insertTextAtCursor,

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" });
@@ -196,15 +208,12 @@ export const processSelectorInput = (state, dispatch, char) => {
 };
 export const handlePasteInput = (state, dispatch, callbacks, input) => {
     const inputString = input;
-    const isPasteOperation = inputString.length > 1 ||
-        inputString.includes("\n") ||
-        inputString.includes("\r");
-    if (isPasteOperation) {
-        // Dispatch a single action type; the reducer determines start vs append
-        // by checking pasteBuffer, avoiding stale state issues
+    if (inputString.length > 1) {
+        // Multi-char chunk: insert immediately (\r → \n normalizes CRLF
+        // terminals), matching the reducer's HANDLE_KEY path.
         dispatch({
-            type: "APPEND_PASTE_CHUNK",
-            payload: { chunk: inputString, cursorPosition: state.cursorPosition },
+            type: "INSERT_TEXT_WITH_PLACEHOLDER",
+            payload: inputString.replace(/\r/g, "\n"),
         });
     }
     else {
@@ -264,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 });
                 }
@@ -279,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" });
@@ -510,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,16 @@ 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";
     content: string;
@@ -18,6 +28,10 @@ export type PendingEffect = {
         mimeType: string;
     }>;
     longTextMap: Record<string, string>;
+} | {
+    type: "SAVE_PROMPT_HISTORY";
+    content: string;
+    longTextMap: Record<string, string>;
 } | {
     type: "ABORT_MESSAGE";
 } | {
@@ -25,6 +39,8 @@ export type PendingEffect = {
 } | {
     type: "ASK_BTW";
     question: string;
+} | {
+    type: "ABORT_BTW";
 } | {
     type: "PERMISSION_MODE_CHANGE";
     mode: PermissionMode;
@@ -62,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<{
@@ -74,6 +89,7 @@ export interface InputManagerCallbacks {
     }>;
     logger?: Logger;
     hasQueuedMessages?: boolean;
+    isIdle?: boolean;
     onRecallQueuedMessage?: () => void;
 }
 export interface InputState {
@@ -103,9 +119,6 @@ export interface InputState {
     showWorkflowManager: boolean;
     permissionMode: PermissionMode;
     selectorJustUsed: boolean;
-    isPasting: boolean;
-    pasteBuffer: string;
-    initialPasteCursorPosition: number;
     history: PromptEntry[];
     historyIndex: number;
     originalInputText: string;
@@ -113,6 +126,7 @@ export interface InputState {
     isFileSearching: boolean;
     btwState: BtwState;
     pendingEffect: PendingEffect | null;
+    escClearPending: boolean;
 }
 export declare const initialState: InputState;
 export type InputAction = {
@@ -206,23 +220,6 @@ export type InputAction = {
     type: "CLEAR_LONG_TEXT_MAP";
 } | {
     type: "CLEAR_INPUT";
-} | {
-    type: "START_PASTE";
-    payload: {
-        buffer: string;
-        cursorPosition: number;
-    };
-} | {
-    type: "APPEND_PASTE_BUFFER";
-    payload: string;
-} | {
-    type: "APPEND_PASTE_CHUNK";
-    payload: {
-        chunk: string;
-        cursorPosition: number;
-    };
-} | {
-    type: "END_PASTE";
 } | {
     type: "ADD_IMAGE_AND_INSERT_PLACEHOLDER";
     payload: {
@@ -254,6 +251,8 @@ export type InputAction = {
     payload: Partial<BtwState>;
 } | {
     type: "CLEAR_PENDING_EFFECT";
+} | {
+    type: "RESET_ESC_CLEAR_PENDING";
 } | {
     type: "HANDLE_KEY";
     payload: {
@@ -261,6 +260,7 @@ export type InputAction = {
         key: Key;
         hasSlashCommand: (cmd: string) => boolean;
         hasQueuedMessages?: boolean;
+        isIdle?: boolean;
     };
 };
 export declare function inputReducer(state: InputState, action: InputAction): InputState;