wave-code 1.3.0 → 1.5.0

package/src/daemon/commands.ts

@@ -103,7 +103,9 @@ function startDaemon(socketPath: string): void {
  * connection (or daemonStartTimeout.ms elapses). Exits (nonzero) with the
  * spec'd error when the daemon cannot be started/reached.
  */
-async function connectDaemonOrExit(socketPath: string): Promise<SocketClient> {
+export async function connectDaemonOrExit(
+  socketPath: string,
+): Promise<SocketClient> {
   try {
     return await connectDaemon(socketPath);
   } catch (err) {
@@ -133,7 +135,7 @@ function fail(message: string): never {
 
 interface DaemonSessionEntry {
   sessionId: string;
-  workingDirectory: string;
+  sessionCwd: string;
   isLoading: boolean;
   /**
    * The other two halves of the idle predicate `wait` / `status` share with
@@ -230,11 +232,15 @@ async function attachSession(
      */
     onInitialized?: (sessionId: string) => void;
   } = {},
-): Promise<{ sessionId: string; workingDirectory: string }> {
+): Promise<{ sessionId: string; currentWorkdir: string }> {
   const init = (await client.request("initialize", {
     workdir: process.cwd(),
     restoreSessionId: sessionId,
-  })) as { sessionId: string; workingDirectory: string };
+    // A daemon restart leaves the session on disk and re-hosts it here; the
+    // re-hosting client is the CLI, and the session file carries no record of
+    // its original creator (see the entrypoint story in the telemetry spec).
+    entrypoint: "cli",
+  })) as { sessionId: string; currentWorkdir: string };
   const initId = init.sessionId;
   options.onInitialized?.(initId);
   try {
@@ -357,6 +363,9 @@ export async function daemonCreateCommand(
       workdir,
       permissionMode: mode,
       model: options.model,
+      // The daemon hosts sessions built from several front ends; this one is
+      // being created by the CLI (`wave daemon create`).
+      entrypoint: "cli",
     })) as { sessionId: string };
     console.log(result.sessionId);
     if (worktreePath !== undefined) {
@@ -389,7 +398,7 @@ export async function daemonListCommand(socketPath: string): Promise<void> {
         // owns running background work.
         status: isIdleSession(s) ? "idle" : "generating",
         messageCount: String(s.messageCount),
-        workingDirectory: s.workingDirectory,
+        sessionCwd: s.sessionCwd,
       }));
       const width = (key: keyof (typeof rows)[number]) =>
         Math.max(...rows.map((r) => r[key].length), key.length);
@@ -400,7 +409,7 @@ export async function daemonListCommand(socketPath: string): Promise<void> {
       );
       for (const r of rows) {
         console.log(
-          `${pad(r.sessionId, width("sessionId"))}  ${pad(r.status, width("status"))}  ${pad(r.messageCount, width("messageCount"))}  ${r.workingDirectory}`,
+          `${pad(r.sessionId, width("sessionId"))}  ${pad(r.status, width("status"))}  ${pad(r.messageCount, width("messageCount"))}  ${r.sessionCwd}`,
         );
       }
     } else {
@@ -523,7 +532,7 @@ function parseAskUserQuestionAnswer(
 
 interface SessionSnapshot {
   sessionId: string;
-  workingDirectory: string;
+  currentWorkdir: string;
   /** `idle` / `generating` / `waiting for approval`. */
   status: string;
   pending: PendingPermission[];
@@ -543,7 +552,7 @@ interface SessionSnapshot {
  */
 function renderSessionSnapshot(snapshot: SessionSnapshot): void {
   console.log(`Session: ${snapshot.sessionId}`);
-  console.log(`Working directory: ${snapshot.workingDirectory}`);
+  console.log(`Working directory: ${snapshot.currentWorkdir}`);
   console.log(`Status: ${snapshot.status}`);
 
   if (snapshot.pending.length > 0) {
@@ -648,7 +657,7 @@ export async function daemonStatusCommand(
           : "idle";
     renderSessionSnapshot({
       sessionId: initId,
-      workingDirectory: init.workingDirectory,
+      currentWorkdir: init.currentWorkdir,
       status,
       pending,
       messages: messages.messages,
@@ -866,7 +875,7 @@ export async function daemonWaitCommand(
       };
       renderSessionSnapshot({
         sessionId: watch.id,
-        workingDirectory: init.workingDirectory,
+        currentWorkdir: init.currentWorkdir,
         status,
         pending,
         messages: result.messages ?? [],
@@ -1275,7 +1284,7 @@ function runGit(cwd: string, args: string[]): Promise<string> {
 }
 
 /**
- * Resolve the worktree hosting `workingDirectory` for removal, mirroring the
+ * Resolve the worktree hosting `sessionCwd` for removal, mirroring the
  * values protocol createWorktree returns: worktree path via
  * `git rev-parse --show-toplevel`, branch via `git branch --show-current`, and
  * repoRoot = the MAIN repo root (first entry of `git worktree list` — where
@@ -1284,7 +1293,7 @@ function runGit(cwd: string, args: string[]): Promise<string> {
  * check would pass trivially while removeWorktree's fs.rmSync fallback could
  * delete the whole repository.
  */
-async function resolveWorktreeForRemoval(workingDirectory: string): Promise<{
+async function resolveWorktreeForRemoval(sessionCwd: string): Promise<{
   path: string;
   branch: string;
   repoRoot: string;
@@ -1294,17 +1303,17 @@ async function resolveWorktreeForRemoval(workingDirectory: string): Promise<{
   let branch: string;
   try {
     const [toplevel, current] = await Promise.all([
-      runGit(workingDirectory, ["rev-parse", "--show-toplevel"]),
-      runGit(workingDirectory, ["branch", "--show-current"]),
+      runGit(sessionCwd, ["rev-parse", "--show-toplevel"]),
+      runGit(sessionCwd, ["branch", "--show-current"]),
     ]);
     worktreePath = toplevel;
     branch = current;
   } catch {
     throw new Error(
-      `Cannot remove worktree: ${workingDirectory} is not inside a git repository`,
+      `Cannot remove worktree: ${sessionCwd} is not inside a git repository`,
     );
   }
-  const repoRoot = getGitMainRepoRoot(workingDirectory);
+  const repoRoot = getGitMainRepoRoot(sessionCwd);
   if (path.resolve(worktreePath) === path.resolve(repoRoot)) {
     throw new Error(
       `Refusing to remove the main working tree: ${repoRoot} (not a linked worktree)`,
@@ -1324,7 +1333,7 @@ async function resolveWorktreeForRemoval(workingDirectory: string): Promise<{
  * abort there is no attach step: destroy is a pure registry operation keyed by
  * the envelope sessionId, so unknown sessions succeed without touching disk.
  * With --remove-worktree the session's git worktree is resolved from its
- * workingDirectory (getSessionInfo) and removed via protocol removeWorktree
+ * sessionCwd (getSessionInfo) and removed via protocol removeWorktree
  * first, then the session is destroyed.
  */
 export async function daemonDestroyCommand(
@@ -1340,8 +1349,8 @@ export async function daemonDestroyCommand(
         "getSessionInfo",
         undefined,
         sessionId,
-      )) as { workingDirectory: string };
-      const wt = await resolveWorktreeForRemoval(info.workingDirectory);
+      )) as { sessionCwd: string };
+      const wt = await resolveWorktreeForRemoval(info.sessionCwd);
       await client.request("removeWorktree", {
         path: wt.path,
         branch: wt.branch,
@@ -1367,7 +1376,7 @@ export const daemonStopTimeout = { ms: 10_000 };
 const DAEMON_STOP_POLL_INTERVAL_MS = 200;
 
 /** Connect to the daemon socket without starting one; undefined when it is not running. */
-async function tryConnectDaemon(
+export async function connectDaemonIfRunning(
   socketPath: string,
 ): Promise<SocketClient | undefined> {
   try {
@@ -1381,7 +1390,7 @@ async function tryConnectDaemon(
 async function waitForDaemonExit(socketPath: string): Promise<void> {
   const deadline = Date.now() + daemonStopTimeout.ms;
   while (Date.now() < deadline) {
-    const client = await tryConnectDaemon(socketPath);
+    const client = await connectDaemonIfRunning(socketPath);
     if (!client) return;
     client.dispose();
     await sleep(DAEMON_STOP_POLL_INTERVAL_MS);
@@ -1399,7 +1408,7 @@ async function waitForDaemonExit(socketPath: string): Promise<void> {
  * Throws when a running daemon fails to exit in time.
  */
 async function stopDaemon(socketPath: string): Promise<boolean> {
-  const client = await tryConnectDaemon(socketPath);
+  const client = await connectDaemonIfRunning(socketPath);
   if (!client) return false;
   try {
     // The daemon may drop the socket before responding to the RPC — the wait

package/src/daemon-cli.ts

@@ -10,6 +10,7 @@
 
 import { ensureRuntimeDeps } from "wave-agent-sdk";
 import { DaemonServer } from "./stdio/daemonServer.js";
+import { createRemoteControlSinkFactory } from "./remote/remoteControlSink.js";
 
 export async function startDaemonCli(socketPath: string): Promise<void> {
   // Install the on-demand runtime dependencies (image codec + ripgrep) before
@@ -17,7 +18,11 @@ export async function startDaemonCli(socketPath: string): Promise<void> {
   // install belongs here — and it must land before the first client attaches,
   // since the host reports "daemon ready" on this socket.
   await ensureRuntimeDeps();
-  const server = new DaemonServer({ socketPath });
+
+  // The resident daemon owns the remote sessions, so it is the process that
+  // serves a paired phone. Off (undefined) unless the switch says otherwise.
+  const createRemoteSink = createRemoteControlSinkFactory(process.cwd());
+  const server = new DaemonServer({ socketPath, createRemoteSink });
   await server.start();
   // Ready — any error that follows goes to the daemon log via stderr.
 }

package/src/hooks/useInputManager.ts

@@ -7,7 +7,6 @@ import {
   ESC_DOUBLE_PRESS_TIMEOUT_MS,
   btwOverlayActiveRef,
 } from "../managers/inputReducer.js";
-import { createBracketedPasteDetector } from "../utils/bracketedPaste.js";
 import {
   searchFiles as searchFilesUtil,
   PermissionMode,
@@ -21,11 +20,6 @@ export const useInputManager = (
 ) => {
   const [state, dispatch] = useReducer(inputReducer, initialState);
 
-  // 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.
@@ -290,6 +284,8 @@ export const useInputManager = (
                 await onAddDir?.(effect.args);
               } else if (command === "rename") {
                 await onRenameSession?.(effect.args);
+              } else if (command === "remote-control") {
+                dispatch({ type: "SET_SHOW_REMOTE_CONTROL", payload: true });
               } else if (command === "plan") {
                 await onPlanCommand?.(effect.args);
               }
@@ -533,6 +529,10 @@ export const useInputManager = (
     dispatch({ type: "SET_SHOW_STATUS_COMMAND", payload: show });
   }, []);
 
+  const setShowRemoteControl = useCallback((show: boolean) => {
+    dispatch({ type: "SET_SHOW_REMOTE_CONTROL", payload: show });
+  }, []);
+
   const setShowLoginCommand = useCallback((show: boolean) => {
     dispatch({ type: "SET_SHOW_LOGIN_COMMAND", payload: show });
   }, []);
@@ -628,44 +628,27 @@ export const useInputManager = (
     dispatch({ type: "CLEAR_LONG_TEXT_MAP" });
   }, []);
 
+  // Pasted text is insert-only. ink delivers a bracketed paste as one string on
+  // its own channel (`usePaste`), so a trailing newline inside it can never be
+  // mistaken for Enter — going through HANDLE_KEY would submit instead, because
+  // its coalesced-Enter branch fires on any chunk ending with a single \r.
+  const insertPastedText = useCallback((text: string) => {
+    if (text === "") {
+      return;
+    }
+    // \r → \n normalizes CRLF terminals to the newline the input uses.
+    dispatch({
+      type: "INSERT_TEXT_WITH_PLACEHOLDER",
+      payload: text.replace(/\r/g, "\n"),
+    });
+  }, []);
+
   const handleInput = useCallback(
     async (input: string, key: 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: result.input,
+          input,
           key,
           hasSlashCommand: (cmd) => !!onHasSlashCommand?.(cmd),
           hasQueuedMessages: hasQueuedMessagesProp ?? false,
@@ -698,6 +681,7 @@ export const useInputManager = (
     showResumeSelector: state.showResumeSelector,
     showHelp: state.showHelp,
     showStatusCommand: state.showStatusCommand,
+    showRemoteControl: state.showRemoteControl,
     showLoginCommand: state.showLoginCommand,
     showPluginManager: state.showPluginManager,
     showModelSelector: state.showModelSelector,
@@ -746,6 +730,7 @@ export const useInputManager = (
     setShowRewindManager,
     setShowHelp,
     setShowStatusCommand,
+    setShowRemoteControl,
     setShowLoginCommand,
     setShowPluginManager,
     setShowModelSelector,
@@ -764,6 +749,7 @@ export const useInputManager = (
 
     // Paste and text handling
     handlePasteInput,
+    insertPastedText,
     handleSubmit,
     expandLongTextPlaceholders,
     clearLongTextMap,

package/src/hooks/useLineScroll.ts

@@ -1,4 +1,4 @@
-import { useState } from "react";
+import { useEffect, useState } from "react";
 import { useInput } from "ink";
 
 export interface UseLineScrollOptions {
@@ -6,33 +6,68 @@ export interface UseLineScrollOptions {
   totalLines: number;
   /** Number of rows visible at once (computed from the available height). */
   visibleCount: number;
+  /**
+   * Rows moved by one ↑/↓ (or Ctrl+P/Ctrl+N) press. Callers that leave it out
+   * never see the arrow keys handled at all — the overlay keeps only the page
+   * keys, as the /plan and confirmation overlays do.
+   */
+  lineStep?: number;
+  /**
+   * Resets the viewport to the top when this value changes. Only needed by
+   * callers that swap the content of a mounted overlay (the /btw answer of the
+   * next question); a component that is remounted per content set gets the
+   * reset for free.
+   */
+  resetKey?: unknown;
 }
 
 /**
  * Fixed-height line scrolling shared by overlays whose content may exceed the
  * terminal: keeps a scroll offset clamped to the visible window and handles
  * PgUp/PgDn (full page) plus Ctrl+u/Ctrl+d (half page, aligned with Claude
- * Code's modal pager keys). Returns the clamped offset and the ↑/↓ indicator
- * flags so callers can render "N more" lines.
+ * Code's modal pager keys). With `lineStep`, ↑/↓ and Ctrl+P/Ctrl+N move that
+ * many rows — the /btw viewport's keys. Returns the clamped offset, the ↑/↓
+ * indicator flags so callers can render "N more" lines, and `canScroll` (the
+ * content overflows the viewport).
+ *
+ * The handlers act only while the content overflows: a viewport with nothing to
+ * scroll must not react to keys the surrounding UI still owns.
  *
  * Scroll position starts at the top on mount; callers that display a new
- * content set remount this hook (e.g. an overlay component keyed by content),
- * which resets the offset naturally.
+ * content set either remount this hook (e.g. an overlay component keyed by
+ * content) or pass `resetKey`, which resets the offset naturally.
  */
 export function useLineScroll({
   totalLines,
   visibleCount,
+  lineStep,
+  resetKey,
 }: UseLineScrollOptions): {
   scrollOffset: number;
   hasMoreAbove: boolean;
   hasMoreBelow: boolean;
+  canScroll: boolean;
 } {
   const [scrollOffset, setScrollOffset] = useState(0);
 
   const maxScroll = Math.max(0, totalLines - visibleCount);
   const halfPage = Math.max(1, Math.ceil(visibleCount / 2));
+  const canScroll = totalLines > visibleCount;
+
+  useEffect(() => {
+    setScrollOffset(0);
+  }, [resetKey]);
 
   useInput((input, key) => {
+    // Nothing to scroll: leave every key to the surrounding UI instead of
+    // acting on it. The check lives inside the handler rather than in
+    // `useInput`'s `isActive`: the row count is measured one commit after the
+    // mount frame, and a handler subscribed only once the overflow is known
+    // would drop the keypresses that arrive in between (which is exactly when a
+    // user, seeing the content clipped, starts pressing PgDn/↓).
+    if (!canScroll) {
+      return;
+    }
     if (key.pageUp) {
       setScrollOffset((offset) => Math.max(0, offset - visibleCount));
     }
@@ -47,6 +82,16 @@ export function useLineScroll({
     if (key.ctrl && input === "d") {
       setScrollOffset((offset) => Math.min(maxScroll, offset + halfPage));
     }
+    if (lineStep) {
+      // ↑/↓ scroll the viewport line by line; Ctrl+P/Ctrl+N are the same
+      // keys for terminals that swallow the arrows.
+      if (key.upArrow || (key.ctrl && input === "p")) {
+        setScrollOffset((offset) => Math.max(0, offset - lineStep));
+      }
+      if (key.downArrow || (key.ctrl && input === "n")) {
+        setScrollOffset((offset) => Math.min(maxScroll, offset + lineStep));
+      }
+    }
   });
 
   const clampedOffset = Math.min(scrollOffset, maxScroll);
@@ -54,5 +99,6 @@ export function useLineScroll({
     scrollOffset: clampedOffset,
     hasMoreAbove: clampedOffset > 0,
     hasMoreBelow: clampedOffset + visibleCount < totalLines,
+    canScroll,
   };
 }