wave-code 1.2.0 → 1.4.0

package/src/remote/remoteControlSink.ts

@@ -0,0 +1,77 @@
+/**
+ * The seam between a session holder and the outbound relay that serves a
+ * paired phone.
+ *
+ * Every process that holds sessions needs it, for the same reason and with the
+ * same shape:
+ *
+ * - `--daemon <socket>` — the resident process on a remote host;
+ * - `--stdio` — the child each GUI host (desktop / VS Code / JetBrains) spawns
+ *   and drives over JSON-RPC;
+ * - the interactive CLI itself — the session the user is sitting in front of,
+ *   which lives in that process's React state and nowhere else.
+ *
+ * Whichever one holds the sessions has to be the one serving them: a phone
+ * pointed at another process would show a different session set than the user
+ * is looking at. So the sink is built where the sessions are, never shared
+ * across processes — and, for the CLI, that means built on a `RemoteControlHost`
+ * the front end implements rather than on an `AgentBridge` (which the CLI has
+ * none of).
+ */
+
+import { isRemoteControlEnabled } from "wave-agent-sdk";
+import { resolveRemoteControlEndpoint } from "./remoteControlConfig.js";
+import {
+  RemoteControlService,
+  type RemoteControlController,
+  type RemoteControlHost,
+} from "./remoteControlService.js";
+
+/**
+ * A second fan-out target for a server's notifications, beside its local
+ * clients (unix-socket clients for the daemon, the host's pipe for `--stdio`).
+ *
+ * Its lifecycle is deliberately decoupled from the client set: the daemon is
+ * resident and a paired phone keeps watching while no desktop is attached —
+ * that is the point of serving from the daemon rather than from a GUI host.
+ */
+export interface RemoteNotificationSink {
+  /** Same signature as `JsonRpcConnection.sendNotification`. */
+  sendNotification(method: string, params: unknown, sessionId?: string): void;
+  stop(): void;
+}
+
+/**
+ * The two halves of a remote-control sink: the server fans notifications into
+ * it, and the bridge routes the three `remoteControl*` RPCs to it.
+ */
+export interface RemoteControlSink
+  extends RemoteNotificationSink,
+    RemoteControlController {}
+
+/**
+ * Build the sink factory a session holder takes, or `undefined` when remote
+ * control is switched off for this process.
+ *
+ * The switch is read **once**, here, at process start: a machine that was
+ * already running keeps its old answer, which is why the CLI hint says to
+ * restart (the daemon, or the TUI itself) after changing it. `workdir` decides
+ * which settings files are merged — the user-level `~/.wave/settings.json` is
+ * always consulted, the workdir's own `.wave/settings.json` only when the
+ * process was started there (a GUI host's `--stdio` child inherits the app's
+ * cwd, not the project's, so user-level is the reliable place to set it).
+ */
+export function createRemoteControlSinkFactory(
+  workdir: string,
+): ((host: RemoteControlHost) => RemoteControlSink) | undefined {
+  // Opt-in twice over: this switch says the machine *may* serve its sessions to
+  // a paired phone, and `wave remote-control on` / `/remote-control` is what
+  // actually dials out. The sink is therefore built but not connected.
+  if (!isRemoteControlEnabled(workdir)) {
+    return undefined;
+  }
+  return (host: RemoteControlHost): RemoteControlSink =>
+    new RemoteControlService(host, {
+      resolveEndpoint: resolveRemoteControlEndpoint,
+    });
+}

package/src/remote/remoteNotifications.ts

@@ -0,0 +1,194 @@
+/**
+ * The single table of notification **shapes**, shared by the two serving paths.
+ *
+ * `AgentBridge` (a daemon or a GUI-spawned `--stdio` child) puts the agent's
+ * callbacks straight onto the wire; the foreground TUI has no notification
+ * fan-out at all (`useRemoteControl` supplies it from its own React state). They
+ * are two different hosts — one has a session registry, the other a component
+ * tree — so each still decides *which* callbacks it emits. What must not exist in
+ * two copies is the **contract**: a method name and the fields of its payload.
+ * Both hosts build every frame they share from `remoteWire` below, so a payload
+ * change lands once and the phone cannot tell which process served it (spec:
+ * remote-control「前台 CLI 会话也能被手机接管」场景 10/11).
+ *
+ * What is deliberately *not* here: the families only a bridge emits (session
+ * registry reads, `tasksChange`, `queuedMessagesChange`, `commandRunningChange`,
+ * the compaction / plan / mcp changes). Nothing mirrors those, so there is no
+ * shape to keep in sync — and the foreground host is not required to invent one:
+ * the page reads that state off `getSessionInfo` on its alignment paths (spec
+ * 同故事场景 11).
+ */
+
+import type {
+  AgentCallbacks,
+  BackgroundTask,
+  BackgroundTaskSummary,
+  PermissionMode,
+  ToolBlockUpdateCallbackParams,
+  ToolPermissionContext,
+} from "wave-agent-sdk";
+
+/**
+ * A content delta exactly as the SDK callback hands it over — derived rather
+ * than re-declared, so a field added there cannot leave this table describing a
+ * shape the agent does not produce.
+ */
+type StreamDelta = Parameters<
+  NonNullable<AgentCallbacks["onAssistantContentUpdated"]>
+>[0];
+
+/**
+ * Context-window usage as the percentage the ring renders — one rule for every
+ * producer (the bridge's change push and its `getMessages` read, the CLI host's
+ * push and its `getSessionInfo` read). 0 when the cap is unknown, so a caller
+ * that has one reads a number rather than a special case.
+ */
+export function percentOf(tokens: number, maxInputTokens: number): number {
+  if (!maxInputTokens || maxInputTokens <= 0) return 0;
+  return Math.min(100, Math.round((tokens / maxInputTokens) * 100));
+}
+
+/** The shapes both hosts put on the wire, keyed by the method they ride under. */
+export const remoteWire = {
+  /**
+   * A pure-delta frame carries the delta and nothing else — no accumulated value,
+   * so a notification's size is independent of how long the stream has been
+   * running (spec: stdio-transport「流式通知纯增量负载」). Explicit pick rather than
+   * a spread, so a field added to the SDK callback does not silently join the wire.
+   */
+  assistantContentUpdated: (params: StreamDelta) => ({
+    messageId: params.messageId,
+    chunk: params.chunk,
+    stage: params.stage,
+  }),
+
+  assistantReasoningUpdated: (params: StreamDelta) => ({
+    messageId: params.messageId,
+    chunk: params.chunk,
+    stage: params.stage,
+  }),
+
+  /**
+   * `streaming` frames carry only the delta (`parametersChunk`), while `start` /
+   * `running` (one-time snapshots) and `end` (the authoritative full value) keep
+   * `parameters`. The coalescer's merge rule is keyed on exactly this shape, so
+   * this pick is what makes the 150 ms window behave the same in both hosts.
+   */
+  toolBlockUpdated: (params: ToolBlockUpdateCallbackParams) => {
+    if (params.stage !== "streaming") return params;
+    const { parameters, ...rest } = params;
+    void parameters;
+    return rest;
+  },
+
+  errorBlockAdded: (error: string) => ({ error }),
+
+  loadingChange: (loading: boolean, latestTotalTokens?: number) => ({
+    loading,
+    ...(latestTotalTokens === undefined ? {} : { latestTotalTokens }),
+  }),
+
+  contextUsage: (latestTotalTokens: number, maxInputTokens: number) => ({
+    percent: percentOf(latestTotalTokens, maxInputTokens),
+  }),
+
+  permissionModeChange: (mode: PermissionMode) => ({ mode }),
+
+  permissionRequest: (requestId: string, context: ToolPermissionContext) => ({
+    requestId,
+    context,
+  }),
+
+  /**
+   * `messagesChange` has exactly one shape now — content-free, on **every** path
+   * (spec「messagesChange 只有一种形态」): the bridge's re-attach push, the
+   * foreground CLI's structural notice and the relay's fan-out all carry `{}`.
+   * The phone answers it with `getMessages({ since })`; no producer attaches the
+   * list.
+   */
+  messagesChangeSignal: () => ({}),
+} as const;
+
+/** The methods this table defines — the only ones a mirroring host may send. */
+export type RemoteMethod = keyof typeof remoteWire;
+
+/**
+ * A background task (shell / subagent / workflow) as it may travel: the
+ * serializable half of `BackgroundTask`.
+ *
+ * A shape, hence this table's business — the two hosts each own the *list* (the
+ * bridge reads it off the agent on every snapshot, the foreground TUI off its own
+ * state) and both have to describe a task the same way, or the `/tasks` dialog
+ * renders two different things depending on which process served the page. The
+ * fields dropped here are the reasons it exists: `process` (a `ChildProcess`) and
+ * `onStop` (a function) cannot go over a relay, and the full `stdout`/`stderr` are
+ * fetched per task instead (`getBackgroundTaskOutput`).
+ */
+export function toBackgroundTaskSummaries(
+  tasks: BackgroundTask[],
+): BackgroundTaskSummary[] {
+  return tasks.map((task) => ({
+    id: task.id,
+    type: task.type,
+    status: task.status,
+    startTime: task.startTime,
+    endTime: task.endTime,
+    command: task.command,
+    description: task.description,
+    exitCode: task.exitCode,
+    runtime: task.runtime,
+    outputPath: task.outputPath,
+  }));
+}
+
+/**
+ * What `RemoteControlSink.sendNotification` expects of a frame, minus the
+ * session it belongs to (the sink already knows). The method is narrowed to the
+ * table's keys so a caller cannot mirror a family that has no agreed shape.
+ */
+export type RemoteNotify = (method: RemoteMethod, params: unknown) => void;
+
+/**
+ * The callbacks whose **payload** a foreground host has to mirror, mapped onto
+ * the remote path under the bridge's method names.
+ *
+ * One rule decides membership: **can a pull get the change back?** A streaming
+ * delta grows a reply the phone is already holding, and an error block is
+ * appended *inside* the last message — in both cases the `since` anchor is that
+ * very message, so a signal would be a round trip that returns nothing and the
+ * change would never reach the phone (spec remote-control「前台 CLI 会话也能被手机
+ * 接管」场景 10/11). Structural changes (the list's id composition) and the state
+ * the page reads off `getSessionInfo` travel on the hook's own signals instead.
+ */
+export function remoteNotifications(
+  notify: RemoteNotify,
+): Required<
+  Pick<
+    AgentCallbacks,
+    | "onAssistantContentUpdated"
+    | "onAssistantReasoningUpdated"
+    | "onToolBlockUpdated"
+    | "onErrorBlockAdded"
+  >
+> {
+  return {
+    onAssistantContentUpdated: (params) => {
+      notify(
+        "assistantContentUpdated",
+        remoteWire.assistantContentUpdated(params),
+      );
+    },
+    onAssistantReasoningUpdated: (params) => {
+      notify(
+        "assistantReasoningUpdated",
+        remoteWire.assistantReasoningUpdated(params),
+      );
+    },
+    onToolBlockUpdated: (params) => {
+      notify("toolBlockUpdated", remoteWire.toolBlockUpdated(params));
+    },
+    onErrorBlockAdded: (error: string) => {
+      notify("errorBlockAdded", remoteWire.errorBlockAdded(error));
+    },
+  };
+}

package/src/session-selector-cli.tsx

@@ -1,263 +1,17 @@
-import React, { useState, useCallback, useEffect, useRef } from "react";
-import { render, Box, Text } from "ink";
-import { existsSync } from "fs";
+import React from "react";
+import { render } from "ink";
 import {
-  PathEncoder,
-  listSessions,
-  listAllSessions,
-  truncateContent,
-  type SessionMetadata,
-} from "wave-agent-sdk";
-import { SessionSelector } from "./components/SessionSelector.js";
-import { setClipboardText } from "./utils/clipboard.js";
+  SessionSelectorFlow,
+  type SessionSelectorResult,
+} from "./components/SessionSelectorFlow.js";
 
-export interface SessionSelectorResult {
-  sessionId: string;
-  /**
-   * When the selected session belongs to a sibling git worktree of the same
-   * repo, the caller should chdir into this path before restoring.
-   */
-  resumeWorkdir?: string;
-}
-
-type SessionItem = SessionMetadata & { firstMessage?: string };
-
-/** POSIX single-quote wrapping for use inside a `cd <path> && ...` command. */
-function quotePath(p: string): string {
-  return `'${p.replace(/'/g, `'\\''`)}'`;
-}
-
-export type SessionOwnership =
-  | { kind: "current" }
-  | { kind: "worktree"; resumeWorkdir: string }
-  | { kind: "cross-project"; command: string };
-
-/**
- * Decide how a selected session relates to the current working directory.
- *
- * Ownership is decided by comparing encoded directory names — the decoded
- * workdir is lossy for paths containing "-", but re-encoding it reproduces the
- * original encoded directory name exactly.
- *
- * - current:      session belongs to the current directory → resume in place
- * - worktree:     session belongs to a sibling same-repo worktree → resume
- *                 after chdir into it (skipped when the worktree dir is gone)
- * - cross-project: session belongs to another project → print a cd command
- */
-export async function resolveSessionOwnership(
-  session: { id: string; workdir: string },
-  opts: { worktreePaths: string[]; currentWorkdir: string },
-): Promise<SessionOwnership> {
-  const encoder = new PathEncoder();
-  // encode() resolves the path via realpath and throws ENOENT when the
-  // directory no longer exists (e.g. a deleted worktree); fall back to the
-  // pure string encodeSync so the picker still works for ghost sessions.
-  let sessionEncoded: string;
-  try {
-    sessionEncoded = await encoder.encode(session.workdir);
-  } catch {
-    sessionEncoded = encoder.encodeSync(session.workdir);
-  }
-  const cwdEncoded = await encoder.encode(opts.currentWorkdir);
-
-  if (sessionEncoded === cwdEncoded) {
-    return { kind: "current" };
-  }
-
-  for (const wt of opts.worktreePaths) {
-    let wtEncoded: string;
-    try {
-      wtEncoded = await encoder.encode(wt);
-    } catch {
-      wtEncoded = encoder.encodeSync(wt);
-    }
-    if (wtEncoded === sessionEncoded && existsSync(wt)) {
-      return { kind: "worktree", resumeWorkdir: wt };
-    }
-  }
-
-  return {
-    kind: "cross-project",
-    command: `cd ${quotePath(session.workdir)} && wave --restore ${session.id}`,
-  };
-}
-
-/**
- * Interactive session picker for `wave -r` (restore without an ID).
- *
- * Three scopes, toggled with Ctrl+A / Ctrl+W (mirroring Claude Code's resume
- * picker):
- * - current:   sessions in the current working directory (default)
- * - worktrees: sessions in any worktree of the same git repository
- * - all:       sessions across every project directory
- *
- * Resume decision on selection:
- * - current dir session      → resume in place
- * - same-repo worktree       → resume after chdir into that worktree
- * - other project            → print `cd <path> && wave --restore <id>`,
- *                              copy it to the clipboard, and exit
- */
-function SessionSelectorFlow({
-  currentWorkdir,
-  worktreePaths,
-  onDone,
-}: {
-  currentWorkdir: string;
-  worktreePaths: string[];
-  onDone: (result: SessionSelectorResult | null) => void;
-}): React.ReactNode {
-  const [showAllProjects, setShowAllProjects] = useState(false);
-  const [showAllWorktrees, setShowAllWorktrees] = useState(false);
-  const [sessions, setSessions] = useState<SessionItem[]>([]);
-  const [loading, setLoading] = useState(true);
-  const [crossProjectCommand, setCrossProjectCommand] = useState<string | null>(
-    null,
-  );
-
-  // Mirror of the scope flags for use inside async reload/decision callbacks.
-  const scopeRef = useRef({ showAllProjects: false, showAllWorktrees: false });
-
-  const loadSessions = useCallback(
-    async (allProjects: boolean, allWorktrees: boolean) => {
-      if (allProjects) {
-        return listAllSessions();
-      }
-      if (allWorktrees) {
-        return listAllSessions({ worktreePaths, workdir: currentWorkdir });
-      }
-      return listSessions(currentWorkdir);
-    },
-    [worktreePaths, currentWorkdir],
-  );
-
-  const reload = useCallback(
-    async (allProjects: boolean, allWorktrees: boolean) => {
-      setLoading(true);
-      try {
-        const result = await loadSessions(allProjects, allWorktrees);
-        setSessions(
-          result.map((s) => ({
-            ...s,
-            firstMessage: truncateContent(s.firstMessage || "No content", 80),
-          })),
-        );
-      } finally {
-        setLoading(false);
-      }
-    },
-    [loadSessions],
-  );
-
-  // Initial load: current directory scope
-  useEffect(() => {
-    void reload(false, false);
-  }, [reload]);
-
-  const handleToggleAllProjects = useCallback(
-    (value: boolean) => {
-      scopeRef.current.showAllProjects = value;
-      setShowAllProjects(value);
-      void reload(value, scopeRef.current.showAllWorktrees);
-    },
-    [reload],
-  );
-
-  const handleToggleAllWorktrees = useCallback(
-    (value: boolean) => {
-      scopeRef.current.showAllWorktrees = value;
-      setShowAllWorktrees(value);
-      void reload(scopeRef.current.showAllProjects, value);
-    },
-    [reload],
-  );
-
-  const handleSelect = useCallback(
-    async (sessionId: string) => {
-      const session = sessions.find((s) => s.id === sessionId);
-      if (!session) return;
-
-      const ownership = await resolveSessionOwnership(session, {
-        worktreePaths,
-        currentWorkdir,
-      });
-
-      switch (ownership.kind) {
-        case "current":
-          onDone({ sessionId });
-          return;
-        case "worktree":
-          onDone({ sessionId, resumeWorkdir: ownership.resumeWorkdir });
-          return;
-        case "cross-project":
-          // Different project — show the cd command instead of resuming in place
-          await setClipboardText(ownership.command);
-          setCrossProjectCommand(ownership.command);
-          return;
-      }
-    },
-    [sessions, worktreePaths, currentWorkdir, onDone],
-  );
-
-  if (crossProjectCommand) {
-    return (
-      <CrossProjectMessage
-        command={crossProjectCommand}
-        onExit={() => onDone(null)}
-      />
-    );
-  }
-
-  if (loading) {
-    return (
-      <Box>
-        <Text dimColor>Loading conversations…</Text>
-      </Box>
-    );
-  }
-
-  return (
-    <Box padding={1}>
-      <SessionSelector
-        sessions={sessions}
-        worktreePaths={worktreePaths}
-        showProjectPath={showAllProjects || showAllWorktrees}
-        onSelect={(id) => void handleSelect(id)}
-        onCancel={() => onDone(null)}
-        onToggleAllProjects={handleToggleAllProjects}
-        onToggleAllWorktrees={handleToggleAllWorktrees}
-      />
-    </Box>
-  );
-}
+export type { SessionSelectorResult };
 
 /**
- * Cross-project message auto-exits after a short delay (mirrors Claude Code's
- * resume picker, which prints the cd command and exits).
+ * Interactive session picker for `wave -r` (restore without an ID), rendered in
+ * its own Ink instance before the main TUI starts. The picker itself is shared
+ * with the in-TUI `/resume` command (see `SessionSelectorFlow`).
  */
-function CrossProjectMessage({
-  command,
-  onExit,
-}: {
-  command: string;
-  onExit: () => void;
-}): React.ReactNode {
-  useEffect(() => {
-    const timer = setTimeout(onExit, 100);
-    return () => clearTimeout(timer);
-  }, [onExit]);
-
-  return (
-    <Box flexDirection="column" gap={1}>
-      <Text>This conversation is from a different directory.</Text>
-      <Box flexDirection="column">
-        <Text>To resume, run:</Text>
-        <Text> {command}</Text>
-      </Box>
-      <Text dimColor>(Command copied to clipboard)</Text>
-    </Box>
-  );
-}
-
 export async function startSessionSelectorCli({
   workdir,
   worktreePaths = [],