wave-code 1.3.0 → 1.4.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) {
@@ -234,6 +236,10 @@ async function attachSession(
   const init = (await client.request("initialize", {
     workdir: process.cwd(),
     restoreSessionId: sessionId,
+    // 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; workingDirectory: string };
   const initId = init.sessionId;
   options.onInitialized?.(initId);
@@ -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) {
@@ -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

@@ -64,6 +64,7 @@ export const useInputManager = (
     onReloadPlugins,
     onAddDir,
     onRenameSession,
+    onRemoteControlCommand,
     onPlanCommand,
     isIdle: isIdleProp,
   } = callbacks;
@@ -290,6 +291,8 @@ export const useInputManager = (
                 await onAddDir?.(effect.args);
               } else if (command === "rename") {
                 await onRenameSession?.(effect.args);
+              } else if (command === "remote-control") {
+                await onRemoteControlCommand?.(effect.args);
               } else if (command === "plan") {
                 await onPlanCommand?.(effect.args);
               }
@@ -323,6 +326,7 @@ export const useInputManager = (
     onReloadPlugins,
     onAddDir,
     onRenameSession,
+    onRemoteControlCommand,
     onPlanCommand,
   ]);
 

package/src/hooks/useRemoteControl.ts

@@ -0,0 +1,324 @@
+/**
+ * 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,
+  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 {
+  workdir: 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[];
+}
+
+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,
+    displayMessages: () => latest.current.messages,
+    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") {
+          await callbacks.onRemoteControlCommand?.();
         }
       }
     })();

package/src/managers/inputReducer.ts

@@ -123,6 +123,7 @@ 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;

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