wave-code 1.4.0 → 1.5.0

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,
   };
 }

package/src/hooks/useRemoteControl.ts

@@ -23,6 +23,8 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import type {
   BackgroundTask,
   Message,
+  MessageWindow,
+  MessageWindowResult,
   PermissionDecision,
   PermissionMode,
   QueuedMessage,
@@ -46,7 +48,14 @@ import { createRemoteControlSinkFactory } from "../remote/remoteControlSink.js";
 import type { RemoteControlSink } from "../remote/remoteControlSink.js";
 
 export interface UseRemoteControlOptions {
+  /** Where the shell is *now* — follows a Bash `cd`; the page's `@file` joins use it. */
   workdir: string;
+  /**
+   * Where the session was opened (the agent's `sessionWorkdir`): the directory
+   * the page's session row keys on. Read through a function because the agent
+   * outlives individual renders and does not exist yet on the first one.
+   */
+  sessionCwd: () => string;
   sessionId: string;
   messages: Message[];
   isLoading: boolean;
@@ -85,6 +94,16 @@ export interface UseRemoteControlOptions {
   compact: (customInstructions?: string) => void | Promise<void>;
   /** Slash commands the page may offer (SDK commands: skills / custom). */
   slashCommands: () => SlashCommand[];
+  /** One page of the display thread — read from the transcript when it reaches back. */
+  messagePage: (window: MessageWindow) => Promise<MessageWindowResult>;
+  /** The whole thread in one shot (no window asked for); nothing is cached. */
+  currentThread: () => Promise<Message[]>;
+  /** Thread totals for the session list (the resident window cannot answer). */
+  threadSummary: () => {
+    messageCount: number;
+    firstUserText?: string;
+    lastActiveAt?: string;
+  };
 }
 
 export interface RemoteControlApi {
@@ -292,7 +311,10 @@ function adapterOf(latest: {
   return {
     sessionId: () => latest.current.sessionId,
     workdir: () => latest.current.workdir,
-    displayMessages: () => latest.current.messages,
+    sessionCwd: () => latest.current.sessionCwd(),
+    messagePage: (window) => latest.current.messagePage(window),
+    currentThread: () => latest.current.currentThread(),
+    threadSummary: () => latest.current.threadSummary(),
     contextUsagePercent: () =>
       percentOf(
         latest.current.latestTotalTokens,

package/src/managers/inputHandlers.ts

@@ -406,7 +406,7 @@ export const handleCommandSelect = (
         } else if (command === "rename") {
           await callbacks.onRenameSession?.();
         } else if (command === "remote-control") {
-          await callbacks.onRemoteControlCommand?.();
+          dispatch({ type: "SET_SHOW_REMOTE_CONTROL", payload: true });
         }
       }
     })();
@@ -763,6 +763,7 @@ export const handleInput = async (
         state.showResumeSelector ||
         state.showHelp ||
         state.showStatusCommand ||
+        state.showRemoteControl ||
         state.showPluginManager ||
         state.showModelSelector ||
         state.showWorkflowManager
@@ -788,6 +789,7 @@ export const handleInput = async (
     state.showResumeSelector ||
     state.showHelp ||
     state.showStatusCommand ||
+    state.showRemoteControl ||
     state.showPluginManager ||
     state.showModelSelector ||
     state.showWorkflowManager
@@ -799,6 +801,7 @@ export const handleInput = async (
       state.showResumeSelector ||
       state.showHelp ||
       state.showStatusCommand ||
+      state.showRemoteControl ||
       state.showPluginManager ||
       state.showModelSelector ||
       state.showWorkflowManager

package/src/managers/inputReducer.ts

@@ -123,7 +123,6 @@ export interface InputManagerCallbacks {
   onReloadPlugins?: () => Promise<void>;
   onAddDir?: (args?: string) => Promise<void>;
   onRenameSession?: (args?: string) => Promise<void>;
-  onRemoteControlCommand?: (args?: string) => Promise<void>;
   onPlanCommand?: (args?: string) => Promise<void> | void;
   sessionId?: string;
   workdir?: string;
@@ -160,6 +159,7 @@ export interface InputState {
   showResumeSelector: boolean;
   showHelp: boolean;
   showStatusCommand: boolean;
+  showRemoteControl: boolean;
   showLoginCommand: boolean;
   showPluginManager: boolean;
   showModelSelector: boolean;
@@ -201,6 +201,7 @@ export const initialState: InputState = {
   showResumeSelector: false,
   showHelp: false,
   showStatusCommand: false,
+  showRemoteControl: false,
   showLoginCommand: false,
   showPluginManager: false,
   showModelSelector: false,
@@ -339,6 +340,24 @@ function deleteTokenBefore(
  * when there is nothing to submit (empty text).
  */
 function submitInput(state: InputState): InputState | null {
+  const submitted = buildSubmitState(state);
+  if (!submitted) return null;
+  // A submit consumes the text, so the popups anchored to it have to go too.
+  // Enter reaches here instead of `SELECT_COMMAND` — which is what used to
+  // close the selector — so submitting `/workflows` left the popup painted
+  // above the panel the command had just opened.
+  return {
+    ...submitted,
+    showCommandSelector: false,
+    slashPosition: -1,
+    commandSearchQuery: "",
+    showFileSelector: false,
+    atPosition: -1,
+    fileSearchQuery: "",
+  };
+}
+
+function buildSubmitState(state: InputState): InputState | null {
   if (!state.inputText.trim()) {
     return null;
   }
@@ -485,6 +504,7 @@ export type InputAction =
   | { type: "SET_SHOW_RESUME_SELECTOR"; payload: boolean }
   | { type: "SET_SHOW_HELP"; payload: boolean }
   | { type: "SET_SHOW_STATUS_COMMAND"; payload: boolean }
+  | { type: "SET_SHOW_REMOTE_CONTROL"; payload: boolean }
   | { type: "SET_SHOW_LOGIN_COMMAND"; payload: boolean }
   | { type: "SET_SHOW_PLUGIN_MANAGER"; payload: boolean }
   | { type: "SET_SHOW_MODEL_SELECTOR"; payload: boolean }
@@ -703,6 +723,12 @@ export function inputReducer(
         showStatusCommand: action.payload,
         selectorJustUsed: !action.payload ? true : state.selectorJustUsed,
       };
+    case "SET_SHOW_REMOTE_CONTROL":
+      return {
+        ...state,
+        showRemoteControl: action.payload,
+        selectorJustUsed: !action.payload ? true : state.selectorJustUsed,
+      };
     case "SET_SHOW_LOGIN_COMMAND":
       return {
         ...state,
@@ -753,6 +779,17 @@ export function inputReducer(
         inputText: "",
         cursorPosition: 0,
         historyIndex: -1,
+        // A cleared input leaves no `/` or `@` for a popup to anchor to, but
+        // this action used to reset only the text. Submitting `/workflows` goes
+        // through `handleSubmit` rather than `SELECT_COMMAND`, so the selector
+        // stayed up and painted a stale "Command Selector (filtering: …)" above
+        // the panel the command had just opened.
+        showCommandSelector: false,
+        slashPosition: -1,
+        commandSearchQuery: "",
+        showFileSelector: false,
+        atPosition: -1,
+        fileSearchQuery: "",
       };
     case "ADD_IMAGE_AND_INSERT_PLACEHOLDER": {
       const newImage: AttachedImage = {
@@ -1103,6 +1140,7 @@ export function inputReducer(
             state.showResumeSelector ||
             state.showHelp ||
             state.showStatusCommand ||
+            state.showRemoteControl ||
             state.showLoginCommand ||
             state.showPluginManager ||
             state.showModelSelector ||

package/src/remote/messageWindow.ts

@@ -1,52 +1,36 @@
 /**
- * Message-window slicing, shared by every host that answers `getMessages`.
+ * `getMessages` parameter validation, shared by every host that answers it.
  *
  * Two callers need this and must agree byte for byte: the daemon / stdio
  * bridge (multi-session registry) and the interactive CLI front end (one
  * session in React state). The phone's reconciliation rules — `since` is an
- * anchor, a vanished anchor means "re-pull the tail", ids can repeat so the
- * anchor resolves to its **last** occurrence — are a property of the wire
+ * anchor, a vanished anchor means "re-pull the whole list", ids can repeat so
+ * the anchor resolves to its **last** occurrence — are a property of the wire
  * contract, not of either host, so the arithmetic lives here once.
  *
+ * The list itself lives in the SDK: it starts at the last compaction, and the
+ * remote page takes a `limit`-sized tail of it because of the relay's frame
+ * budget. What is left here is the one rule a misreading caller cannot notice
+ * on its own — a malformed parameter must fail instead of silently widening
+ * into a full read.
+ *
  * Described in docs/specs/ui/remote-control.md (§5 白名单与增量拉取).
  */
 
-import type { Message } from "wave-agent-sdk";
-
-export interface MessageWindow {
-  /** Exclusive upper anchor: return the page ending just before this id. */
-  before?: string;
-  /** Exclusive lower anchor: return what arrived after this id. */
-  since?: string;
-  limit?: number;
-}
+import type { MessageWindow } from "wave-agent-sdk";
 
-export interface MessageWindowResult {
-  messages: Message[];
-  /** Older messages exist before the returned page. */
-  hasMore?: boolean;
-  /** The `since` anchor is gone — rebuild from the tail. */
-  reset?: boolean;
-  /** Total display messages held for the session. */
-  total?: number;
-}
+export type { MessageWindow, MessageWindowResult } from "wave-agent-sdk";
 
 /** A malformed window. Hosts translate this into their own RPC error type. */
 export class InvalidMessageWindowError extends Error {}
 
 /**
- * Slice `all` by `window`. Returns `undefined` when no window was asked for —
- * the caller then answers with the whole list, untouched.
- *
- * The validations are here rather than in either caller because silently
- * widening the read is the one failure mode a caller cannot notice: it asked
- * for a bounded page and got the thread back.
+ * Validate `window` and hand it on. Returns `undefined` when nothing was asked
+ * for — the caller then answers with the whole list, read once.
  */
-export function sliceMessageWindow(
-  all: Message[],
+export function normalizeMessageWindow(
   window?: MessageWindow,
-): MessageWindowResult | undefined {
-  const before = window?.before;
+): MessageWindow | undefined {
   const since = window?.since;
   const rawLimit = window?.limit;
   if (rawLimit !== undefined && (!Number.isInteger(rawLimit) || rawLimit < 1)) {
@@ -54,44 +38,9 @@ export function sliceMessageWindow(
       `getMessages limit must be a positive integer, got ${String(rawLimit)}`,
     );
   }
-  const limit = rawLimit;
-
-  if (before === undefined && since === undefined && limit === undefined) {
-    return undefined;
-  }
-
-  const lastIndexOfId = (id: string): number => {
-    for (let i = all.length - 1; i >= 0; i--) {
-      if (all[i].id === id) return i;
-    }
-    return -1;
-  };
-
-  if (since !== undefined) {
-    const at = lastIndexOfId(since);
-    if (at === -1) {
-      return { messages: [], reset: true, total: all.length };
-    }
-    const later = all.slice(at + 1);
-    return {
-      messages: limit === undefined ? later : later.slice(-limit),
-      hasMore: false,
-      total: all.length,
-    };
-  }
-
-  // Backward paging; without `before` this is a tail read (`limit` only).
-  const end = before === undefined ? all.length : lastIndexOfId(before);
-  if (end === -1) {
-    // The anchor is gone. Older history may have been truncated along with it,
-    // so answer with an empty page: the caller stops paging rather than looping
-    // on an anchor that will never resolve.
-    return { messages: [], hasMore: false, total: all.length };
-  }
-  const start = limit === undefined ? 0 : Math.max(0, end - limit);
+  if (since === undefined && rawLimit === undefined) return undefined;
   return {
-    messages: all.slice(start, end),
-    hasMore: start > 0,
-    total: all.length,
+    ...(since !== undefined ? { since } : {}),
+    ...(rawLimit !== undefined ? { limit: rawLimit } : {}),
   };
 }

package/src/remote/notificationCoalescer.ts

@@ -44,12 +44,13 @@ interface MergeSpec {
 /**
  * Decide whether a notification is a pure delta that may be merged.
  *
- * Only the three streaming callbacks qualify, and only in their streaming
- * stage: their payloads are documented as deltas ("consumers accumulate"), and
+ * Only the streaming callbacks qualify, and only in their streaming stage:
+ * their payloads are documented as deltas ("consumers accumulate"), and
  * `messageOperations.ts` accumulates `parametersChunk` by plain concatenation —
  * the same operation this class performs. A `start` / `running` / `end` frame
  * is a one-time snapshot (or the authoritative full value) and must not be
- * merged with anything.
+ * merged with anything. `btwContent` (the `/btw` answer stream) is the fourth:
+ * one field, no stages, a delta every time.
  */
 function mergeSpec(method: string, params: unknown): MergeSpec | undefined {
   if (typeof params !== "object" || params === null) return undefined;
@@ -78,6 +79,23 @@ function mergeSpec(method: string, params: unknown): MergeSpec | undefined {
     };
   }
 
+  // `/btw` side question (`btwContent`, spec ui/remote-control.md「Web 页也能用
+  // /btw 旁路提问」场景 4). Same family as the three above: `content` is a pure
+  // delta the panel accumulates, so the merged frame carries exactly the bytes
+  // the individual ones would. The key carries the question **and** the channel
+  // (`content` / `thinking`) — the panel drops thinking once content starts, so
+  // merging the two together would resurrect text it had already discarded, and
+  // two questions in flight must never interleave.
+  if (method === "btwContent") {
+    if (typeof p.content !== "string" || typeof p.question !== "string") {
+      return undefined;
+    }
+    return {
+      field: "content",
+      key: `b\u0000${p.question}\u0000${typeof p.type === "string" ? p.type : ""}`,
+    };
+  }
+
   return undefined;
 }
 

package/src/remote/relayClient.ts

@@ -61,7 +61,7 @@ export interface RelayCredential {
 /** The control frames the relay sends us. Not forwarded, not JSON-RPC. */
 export type RelayControlFrame =
   | { type: "auth_ok"; role?: string; hostId?: string }
-  | { type: "auth_error"; error: string; minVersion?: string }
+  | { type: "auth_error"; error: string }
   | { type: "peer_disconnected"; hostId?: string }
   | { type: "resync_required"; hostId?: string }
   | { type: "ping" }
@@ -103,6 +103,8 @@ export const defaultRelaySocketFactory: RelaySocketFactory = (url) => {
 /** Close codes the relay uses to tell us how to react. */
 export const RELAY_CLOSE_UNAVAILABLE = 4001; // transient — the host is not ready yet
 export const RELAY_CLOSE_UNAUTHORIZED = 4003; // permanent — do not come back
+// (the one exception is a *stale stored identity*, which the credential's owner
+// can replace by registering again: see `RELAY_STALE_IDENTITY_ERRORS`)
 export const RELAY_CLOSE_BACKPRESSURE = 4008; // we gave up on a stuck socket
 /**
  * The `4001` reason the relay sends when another process on this machine dialled
@@ -112,6 +114,29 @@ export const RELAY_CLOSE_BACKPRESSURE = 4008; // we gave up on a stuck socket
  */
 export const RELAY_CLOSE_REPLACED = "replaced";
 
+/**
+ * The `auth_error` reasons that mean the **identity this machine stored** no
+ * longer exists on the relay: the row was revoked, the token aged out, or the
+ * local file holds an id/token pair that never belonged together. All of them
+ * are fixed the same way — register again, and the relay hands back the same row
+ * (the id is derived from the machine, so registration is idempotent) — which is
+ * exactly why they are separated from the rest of `4003`. The others
+ * (`organization_mismatch`, `unauthorized`, and anything a relay adds later) are
+ * about *this account, this organization*: registering again cannot change any
+ * of them, and treating them as stale would only hide the real reason behind a
+ * pointless round trip.
+ */
+export const RELAY_STALE_IDENTITY_ERRORS: readonly string[] = [
+  "invalid_host_token",
+  "unknown_host",
+];
+
+export function isStaleIdentityError(
+  error: string | undefined,
+): error is string {
+  return error !== undefined && RELAY_STALE_IDENTITY_ERRORS.includes(error);
+}
+
 /** Retry cadence. Flat 2s: the relay is a well-known host, not a flaky peer —
  * exponential backoff would only delay a laptop waking from sleep. */
 export const RELAY_RETRY_DELAY_MS = 2_000;
@@ -157,9 +182,9 @@ export interface RelayClientOptions {
   onAuthenticated?: (info: { role?: string; hostId?: string }) => void;
   /**
    * `auth_error`. The relay closes with `4003` right after, so this only adds
-   * the *reason* — and, for `host_version_unsupported`, the floor to report.
+   * the *reason* — the close code cannot say why.
    */
-  onAuthError?: (info: { error: string; minVersion?: string }) => void;
+  onAuthError?: (info: { error: string }) => void;
   /** The other end of this channel is gone (the phone, or the machine). */
   onPeerDisconnected?: () => void;
   /**
@@ -169,6 +194,14 @@ export interface RelayClientOptions {
   onResyncRequired?: () => void;
   /** A frame from the relay (phone request or notification). */
   onFrame?: (frame: RelayEnvelope) => void;
+  /**
+   * `4003` whose reason says the stored identity is stale (see
+   * `RELAY_STALE_IDENTITY_ERRORS`). Reported **instead of** `onFatal` because it
+   * is not the end of the road: replacing the credential means an HTTP
+   * registration, which only the credential's owner can do — this class knows
+   * nothing about that. Nothing is retried from here either way.
+   */
+  onStaleIdentity?: (info: { error: string }) => void;
   /** The connection is gone for good — `4003`, or the retry budget ran out. */
   onFatal?: (reason: string) => void;
 }
@@ -182,7 +215,7 @@ export class RelayClient {
   private unavailableAttempts = 0;
   private stopped = false;
   /** Why the relay refused us, kept so the `4003` that follows can say more. */
-  private authError: { error: string; minVersion?: string } | undefined;
+  private authError: { error: string } | undefined;
   /**
    * `auth_ok` has arrived. Until it does the relay parses *every* frame as the
    * auth frame, and one it cannot parse closes the connection for good
@@ -414,6 +447,13 @@ export class RelayClient {
     if (code === RELAY_CLOSE_UNAUTHORIZED) {
       this.stopped = true;
       this.state = "closed";
+      const error = this.authError?.error;
+      if (isStaleIdentityError(error)) {
+        // No reconnect from here: the fix is a registration round trip, not a
+        // retry (dialling again with the same dead token can only repeat this).
+        this.options.onStaleIdentity?.({ error });
+        return;
+      }
       this.options.onFatal?.(
         this.authError
           ? `relay rejected the credential (4003): ${this.authError.error}`
@@ -501,23 +541,8 @@ export class RelayClient {
         });
         return;
       case "auth_error":
-        this.authError = {
-          error: frame.error,
-          ...(frame.minVersion !== undefined
-            ? { minVersion: frame.minVersion }
-            : {}),
-        };
+        this.authError = { error: frame.error };
         this.options.onAuthError?.(this.authError);
-        if (frame.error === "host_version_unsupported") {
-          // Retrying cannot change this build, and the `4003` that follows
-          // would report it as "bad credential" — the wrong advice. So the
-          // decision is taken here, where the floor is still on the wire.
-          this.fail(
-            `this wave build is older than the relay requires` +
-              `${frame.minVersion ? ` (minimum ${frame.minVersion})` : ""}` +
-              ` — upgrade wave on this machine`,
-          );
-        }
         return;
       case "peer_disconnected":
         this.options.onPeerDisconnected?.();
@@ -608,12 +633,9 @@ export function parseRelayControlFrame(
     case "auth_error": {
       const error = asString(frame.error);
       if (error === undefined) return undefined;
-      const minVersion = asString(frame.minVersion);
-      return {
-        type: "auth_error",
-        error,
-        ...(minVersion !== undefined ? { minVersion } : {}),
-      };
+      // Any `minVersion` an older relay still sends is dropped here: the
+      // version floor is no longer part of the contract.
+      return { type: "auth_error", error };
     }
     case "peer_disconnected":
       return {