wave-code 1.3.0 → 1.5.0

package/src/hooks/useRemoteControl.ts

@@ -0,0 +1,346 @@
+/**
+ * Wires the interactive CLI's own session to the remote-control relay.
+ *
+ * The daemon serves its sessions by fanning notifications into a
+ * `RemoteControlSink`; the CLI has no notification fan-out at all — every
+ * surface it has is React state. So this hook supplies that fan-out, under the
+ * same method names and payloads a `--stdio` / daemon process uses, which is what
+ * lets the page treat the two hosts identically — including the remote channel's
+ * 150 ms merge window, which only bites if the frames it merges are the same
+ * ones.
+ *
+ * Two halves, and both have to be the same shape as the bridge's:
+ *
+ * - the callbacks that carry content, which the front end hands over from its own
+ *   agent callbacks (`remoteNotifications` → `notify`);
+ * - the coarse state this hook watches itself (`messagesChange` as a content-free
+ *   structural signal, loading, permission mode, context usage, approvals). The
+ *   page answers a signal by pulling with `getMessages({ since })`, so no payload
+ *   ever rides the signal.
+ */
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import type {
+  BackgroundTask,
+  Message,
+  MessageWindow,
+  MessageWindowResult,
+  PermissionDecision,
+  PermissionMode,
+  QueuedMessage,
+  RemoteControlSnapshot,
+  RemoteControlStatus,
+  SlashCommand,
+  Task,
+  ToolPermissionContext,
+} from "wave-agent-sdk";
+import {
+  RemoteControlCliHost,
+  type RemoteControlCliSession,
+} from "../remote/remoteControlCliHost.js";
+import {
+  percentOf,
+  remoteWire,
+  toBackgroundTaskSummaries,
+} from "../remote/remoteNotifications.js";
+import type { RemoteNotify } from "../remote/remoteNotifications.js";
+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;
+  permissionMode: PermissionMode;
+  latestTotalTokens: number;
+  maxInputTokens: number;
+  /**
+   * The title `/rename` sets, read live off the agent — the page's session list
+   * labels the row with it (and the page itself may be the one that renamed it).
+   */
+  customTitle: () => string | undefined;
+  hasRunningBackgroundWork: boolean;
+  hasPendingMessages: boolean;
+  /**
+   * The session-state family the page re-reads off `getSessionInfo` (spec
+   * remote-control「Web 页作为第五种宿主」场景 26) — current values, so the
+   * long-lived host answers reads even though the session underneath it is
+   * replaced.
+   */
+  tasks: Task[];
+  /** Background tasks as the TUI holds them — read off `getSessionInfo`. */
+  backgroundTasks: BackgroundTask[];
+  isCompacting: boolean;
+  isCommandRunning: boolean;
+  queuedMessages: QueuedMessage[];
+  /** Approvals waiting on the user right now. */
+  pending: Array<{ requestId: string; context: ToolPermissionContext }>;
+  availableTools: () => string[];
+  sendMessage: (text: string, force?: boolean) => void | Promise<void>;
+  abort: () => void;
+  setPermissionMode: (mode: PermissionMode) => void;
+  respondPermission: (requestId: string, decision: PermissionDecision) => void;
+  /** Rename the conversation (the title `wave -r` lists). */
+  renameSession: (title: string) => void | Promise<void>;
+  /** Compact the conversation; errors must propagate (the page shows them). */
+  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 {
+  /** The `enableRemoteControl` switch was on when this process started. */
+  enabled: boolean;
+  status: RemoteControlStatus;
+  getSnapshot: () => RemoteControlSnapshot;
+  /** Dials out. `name` labels this machine on the phone. */
+  connect: (name?: string) => void;
+  disconnect: () => void;
+  /**
+   * Send one notification to the phone under the method name a server host
+   * (`AgentBridge`) would use for the same thing. The front end calls it from its
+   * content-carrying agent callbacks (see `remoteNotifications`) — that is what
+   * makes the two hosts' fan-out identical, and therefore what makes the remote
+   * channel's merge window apply to this host too.
+   */
+  notify: RemoteNotify;
+}
+
+/** The GUI dialog polls once a second for the same reason: there is no push. */
+const STATUS_POLL_MS = 1000;
+
+export function useRemoteControl(
+  options: UseRemoteControlOptions,
+): RemoteControlApi {
+  // Every getter below must read the *current* value: the host outlives any
+  // single render, and the session underneath it is replaced on /resume.
+  const latest = useRef(options);
+  latest.current = options;
+
+  const [sink] = useState<RemoteControlSink | undefined>(() => {
+    // The switch is read once, here, exactly as a server process reads it once
+    // at startup — hence "restart the CLI" in the failure hint.
+    const factory = createRemoteControlSinkFactory(options.workdir);
+    if (!factory) return undefined;
+    return factory(new RemoteControlCliHost(adapterOf(latest)));
+  });
+
+  const [status, setStatus] = useState<RemoteControlStatus>(
+    () => sink?.getSnapshot() ?? { state: "off" },
+  );
+
+  // ── Outbound: state changes the phone renders ─────────────────
+  //
+  // `sendNotification` drops everything while the link is down, which is what
+  // we want: a phone that reconnects re-reads the tail anyway.
+  const sessionId = options.sessionId;
+  const { messages, isLoading, permissionMode, latestTotalTokens } = options;
+
+  const notify = useCallback<RemoteNotify>(
+    (method, params) => {
+      sink?.sendNotification(method, params, latest.current.sessionId);
+    },
+    [sink],
+  );
+
+  // A structural notice, never a payload: the phone answers it by pulling the
+  // tail with `getMessages({ since })`, the same path a cold start takes and the
+  // only one that can carry a 13 MB list. What counts as "structurally changed"
+  // is `useStructureKey`'s business below.
+  const structureKey = useStructureKey(messages, sink !== undefined);
+  useEffect(() => {
+    sink?.sendNotification(
+      "messagesChange",
+      remoteWire.messagesChangeSignal(),
+      sessionId,
+    );
+  }, [sink, structureKey, sessionId]);
+
+  useEffect(() => {
+    sink?.sendNotification(
+      "loadingChange",
+      remoteWire.loadingChange(isLoading),
+      sessionId,
+    );
+  }, [sink, isLoading, sessionId]);
+
+  useEffect(() => {
+    sink?.sendNotification(
+      "permissionModeChange",
+      remoteWire.permissionModeChange(permissionMode),
+      sessionId,
+    );
+  }, [sink, permissionMode, sessionId]);
+
+  useEffect(() => {
+    if (!sink || !sessionId) return;
+    sink.sendNotification(
+      "contextUsage",
+      remoteWire.contextUsage(latestTotalTokens, options.maxInputTokens),
+      sessionId,
+    );
+  }, [sink, sessionId, latestTotalTokens, options.maxInputTokens]);
+
+  // Approvals are announced once, when they appear. The page answers with
+  // `permissionResponse`, which the host routes back into the same promise the
+  // terminal is waiting on — first answer wins, as the spec requires.
+  const announced = useRef<Set<string>>(new Set());
+  useEffect(() => {
+    const pending = latest.current.pending;
+    if (!sink || pending.length === 0) return;
+    for (const request of pending) {
+      if (announced.current.has(request.requestId)) continue;
+      announced.current.add(request.requestId);
+      sink.sendNotification(
+        "permissionRequest",
+        remoteWire.permissionRequest(request.requestId, request.context),
+        sessionId,
+      );
+    }
+    const alive = new Set(pending.map((request) => request.requestId));
+    for (const id of [...announced.current]) {
+      if (!alive.has(id)) announced.current.delete(id);
+    }
+  }, [sink, options.pending, sessionId]);
+
+  // ── Status the command view renders ───────────────────────────
+
+  useEffect(() => {
+    if (!sink) return;
+    const timer = setInterval(() => {
+      setStatus(sink.getSnapshot());
+    }, STATUS_POLL_MS);
+    timer.unref?.();
+    return () => clearInterval(timer);
+  }, [sink]);
+
+  const connect = useCallback(
+    (name?: string) => {
+      sink?.connect(name);
+      setStatus(sink?.getSnapshot() ?? { state: "off" });
+    },
+    [sink],
+  );
+
+  const disconnect = useCallback(() => {
+    sink?.disconnect();
+    setStatus(sink?.getSnapshot() ?? { state: "off" });
+  }, [sink]);
+
+  const getSnapshot = useCallback(
+    () => sink?.getSnapshot() ?? { state: "off" as const },
+    [sink],
+  );
+
+  // The process is going away: drop the outbound connection rather than let
+  // the relay keep a subscription for a session that no longer exists.
+  useEffect(() => {
+    return () => {
+      sink?.stop();
+    };
+  }, [sink]);
+
+  return {
+    enabled: sink !== undefined,
+    status,
+    getSnapshot,
+    connect,
+    disconnect,
+    notify,
+  };
+}
+
+/**
+ * The id composition of the display list, in order — what "the list changed"
+ * means for the remote path — as a key that is stable while the composition is.
+ *
+ * Ids are stable across a streamed message's growth and across in-place edits of
+ * its blocks, so comparing this key is what separates a structural change (a
+ * message appeared, was discarded, or the list was truncated/replaced) from a
+ * delta landing in a message the phone already has. Anchored on the ids rather
+ * than on "the messages state changed" so no call site has to be trusted to
+ * remember to announce a structural change — watching `messages` instead is what
+ * turned every model chunk into a signal plus a phone round trip.
+ *
+ * This runs once per render, and a streamed reply renders once per chunk, so the
+ * two shortcuts are the point: with no sink there is nobody to signal, and an
+ * unchanged id list returns the previous key rather than building a new string.
+ *
+ * The trigger stops at the ids on purpose: `since` is an **exclusive** anchor, so
+ * a signal can only ever deliver entries appended after the phone's own last
+ * message — a change made *inside* that message needs a payload-carrying
+ * notification of its own (see `remoteNotifications`).
+ */
+function useStructureKey(messages: Message[], enabled: boolean): string {
+  const last = useRef<{ ids: string[]; key: string }>({ ids: [], key: "" });
+  if (!enabled) return "";
+  const previous = last.current;
+  if (
+    previous.ids.length === messages.length &&
+    messages.every((message, index) => message.id === previous.ids[index])
+  ) {
+    return previous.key;
+  }
+  const ids = messages.map((message) => message.id);
+  last.current = { ids, key: ids.join("\n") };
+  return last.current.key;
+}
+
+/** The single-session adapter the host is built on. */
+function adapterOf(latest: {
+  current: UseRemoteControlOptions;
+}): RemoteControlCliSession {
+  return {
+    sessionId: () => latest.current.sessionId,
+    workdir: () => latest.current.workdir,
+    sessionCwd: () => latest.current.sessionCwd(),
+    messagePage: (window) => latest.current.messagePage(window),
+    currentThread: () => latest.current.currentThread(),
+    threadSummary: () => latest.current.threadSummary(),
+    contextUsagePercent: () =>
+      percentOf(
+        latest.current.latestTotalTokens,
+        latest.current.maxInputTokens,
+      ),
+    latestTotalTokens: () => latest.current.latestTotalTokens,
+    permissionMode: () => latest.current.permissionMode,
+    customTitle: () => latest.current.customTitle(),
+    availableTools: () => latest.current.availableTools(),
+    isLoading: () => latest.current.isLoading,
+    hasRunningBackgroundWork: () => latest.current.hasRunningBackgroundWork,
+    hasPendingMessages: () => latest.current.hasPendingMessages,
+    tasks: () => latest.current.tasks,
+    backgroundTasks: () =>
+      toBackgroundTaskSummaries(latest.current.backgroundTasks),
+    isCompacting: () => latest.current.isCompacting,
+    isCommandRunning: () => latest.current.isCommandRunning,
+    queuedMessages: () => latest.current.queuedMessages,
+    pendingPermissions: () => latest.current.pending,
+    sendMessage: (text, force) => latest.current.sendMessage(text, force),
+    abort: () => latest.current.abort(),
+    setPermissionMode: (mode) => latest.current.setPermissionMode(mode),
+    respondPermission: (requestId, decision) =>
+      latest.current.respondPermission(requestId, decision),
+    renameSession: (title) => latest.current.renameSession(title),
+    compact: (customInstructions) => latest.current.compact(customInstructions),
+    slashCommands: () => latest.current.slashCommands(),
+  };
+}

package/src/index.ts

@@ -537,6 +537,41 @@ export async function main() {
             .demandCommand(1, "Please specify a daemon subcommand");
         },
       )
+      .command(
+        "remote-control [action] [name]",
+        "Serve this machine's sessions to a paired phone (via the wave daemon)",
+        (yargs) => {
+          return yargs
+            .positional("action", {
+              describe: "on | off | status",
+              type: "string",
+              default: "status",
+            })
+            .positional("name", {
+              describe: "Label for this machine, shown on the phone",
+              type: "string",
+            });
+        },
+        async (argv) => {
+          const {
+            remoteControlOnCommand,
+            remoteControlOffCommand,
+            remoteControlStatusCommand,
+          } = await import("./remote/remoteControlCommands.js");
+          const action = (argv.action as string | undefined) ?? "status";
+          if (action === "on") {
+            await remoteControlOnCommand(argv.name as string | undefined);
+          } else if (action === "off") {
+            await remoteControlOffCommand();
+          } else if (action === "status") {
+            await remoteControlStatusCommand();
+          } else {
+            console.error(`Unknown remote-control action: ${action}`);
+            console.error("Usage: wave remote-control [on|off|status] [name]");
+            process.exit(1);
+          }
+        },
+      )
       .command(
         "update",
         "Update WAVE Code to the latest version",

package/src/managers/inputHandlers.ts

@@ -405,6 +405,8 @@ export const handleCommandSelect = (
           await callbacks.onAddDir?.();
         } else if (command === "rename") {
           await callbacks.onRenameSession?.();
+        } else if (command === "remote-control") {
+          dispatch({ type: "SET_SHOW_REMOTE_CONTROL", payload: true });
         }
       }
     })();
@@ -761,6 +763,7 @@ export const handleInput = async (
         state.showResumeSelector ||
         state.showHelp ||
         state.showStatusCommand ||
+        state.showRemoteControl ||
         state.showPluginManager ||
         state.showModelSelector ||
         state.showWorkflowManager
@@ -786,6 +789,7 @@ export const handleInput = async (
     state.showResumeSelector ||
     state.showHelp ||
     state.showStatusCommand ||
+    state.showRemoteControl ||
     state.showPluginManager ||
     state.showModelSelector ||
     state.showWorkflowManager
@@ -797,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

@@ -159,6 +159,7 @@ export interface InputState {
   showResumeSelector: boolean;
   showHelp: boolean;
   showStatusCommand: boolean;
+  showRemoteControl: boolean;
   showLoginCommand: boolean;
   showPluginManager: boolean;
   showModelSelector: boolean;
@@ -200,6 +201,7 @@ export const initialState: InputState = {
   showResumeSelector: false,
   showHelp: false,
   showStatusCommand: false,
+  showRemoteControl: false,
   showLoginCommand: false,
   showPluginManager: false,
   showModelSelector: false,
@@ -338,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;
   }
@@ -484,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 }
@@ -702,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,
@@ -752,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 = {
@@ -1102,6 +1140,7 @@ export function inputReducer(
             state.showResumeSelector ||
             state.showHelp ||
             state.showStatusCommand ||
+            state.showRemoteControl ||
             state.showLoginCommand ||
             state.showPluginManager ||
             state.showModelSelector ||

package/src/print-cli.ts

@@ -5,6 +5,7 @@ import {
   hasNewCommits,
   getDefaultRemoteBranch,
   validateWorktreeRemovalPath,
+  setTelemetryStdoutProtected,
   type WorktreeSession,
 } from "wave-agent-sdk";
 import { displayUsageSummary } from "./utils/usageSummary.js";
@@ -35,6 +36,9 @@ function displayTimingInfo(startTime: Date, showStats: boolean): void {
 }
 
 export async function startPrintCli(options: PrintCliOptions): Promise<void> {
+  // stdout carries the printed result here; console telemetry exporters would
+  // mix structured telemetry into it — strip them at config resolution.
+  setTelemetryStdoutProtected(true);
   const startTime = new Date();
   const {
     restoreSessionId,
@@ -135,6 +139,7 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
       isNewWorktree: worktreeSession?.isNew,
       model,
       mcpServers,
+      entrypoint: "cli",
       // 保持流式模式以获得更好的命令行用户体验
     });
 

package/src/reducers/workflowManagerReducer.ts

@@ -29,8 +29,27 @@ export function workflowManagerReducer(
   action: WorkflowManagerAction,
 ): WorkflowManagerState {
   switch (action.type) {
-    case "SET_RUNS":
-      return { ...state, runs: action.runs };
+    case "SET_RUNS": {
+      // Newest first (spec multi-agent/workflow「工作流管理对话框（IDE 与 CLI）」场景
+      // 1): the run just started is the one to look at. The host hands them over
+      // in its own map order (creation order, plus whatever a session restore
+      // appended), which puts it at the bottom.
+      const runs = [...action.runs].sort((a, b) => b.startTime - a.startTime);
+      // The sort moves rows when a run appears at the top, so an index-stable
+      // selection would silently follow the position instead of the run.
+      const previous = state.runs[state.selectedIndex];
+      const keptIndex = previous
+        ? runs.findIndex((r) => r.runId === previous.runId)
+        : -1;
+      return {
+        ...state,
+        runs,
+        selectedIndex:
+          keptIndex >= 0
+            ? keptIndex
+            : Math.min(state.selectedIndex, Math.max(0, runs.length - 1)),
+      };
+    }
     case "SELECT_INDEX":
       return { ...state, selectedIndex: action.index };
     case "MOVE_UP":

package/src/remote/frameBudget.ts

@@ -0,0 +1,45 @@
+/**
+ * One-frame budget for the frames this machine hands to the relay.
+ *
+ * Two relay-side limits stand behind every frame, and neither is ours to raise:
+ * `maxPayload` (4 MiB by default) makes the relay close the connection with
+ * `1009`, and — lower, and far easier to hit — the per-subscriber buffer
+ * (1 MiB by default) makes it **drop that one frame** and ask for a resync.
+ * The second failure is silent: no error, just a page the phone never sees, and
+ * a phone that answers the resync by asking for the same page again.
+ *
+ * Hence the budget lives here, at half of that buffer, leaving room for the
+ * frames already in flight. It is deliberately **not** derived from the relay's
+ * number at runtime: the promise "nothing we send exceeds what the relay will
+ * forward" has to hold without knowing which relay build is on the other side.
+ */
+export const REMOTE_MAX_FRAME_BYTES = 512 * 1024;
+
+/** Serialized size of a frame, exactly as it goes on the wire. */
+export function frameBytes(frame: unknown): number {
+  const json = JSON.stringify(frame);
+  return json === undefined ? 0 : Buffer.byteLength(json, "utf8");
+}
+
+/**
+ * How many trailing items of a list still fit under the budget.
+ *
+ * The candidate list is always a page of messages, so the newest ones are the
+ * ones worth keeping: a phone that asked for the tail is better served by the
+ * last 80 messages than by the first 80. `fits` must be monotonic in the count
+ * — it is, for a suffix of a JSON array — so this is a binary search rather
+ * than one `stringify` per candidate length.
+ */
+export function trailingCountThatFits(
+  total: number,
+  fits: (count: number) => boolean,
+): number {
+  let low = 0;
+  let high = total;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (fits(mid)) low = mid;
+    else high = mid - 1;
+  }
+  return low;
+}