wave-code 1.2.0 → 1.4.0

package/src/stdio/daemonServer.ts

@@ -18,10 +18,19 @@ import net from "net";
 import * as fs from "fs";
 import { AgentBridge, type AgentBridgeOptions } from "./agentBridge.js";
 import { JsonRpcConnection } from "./jsonRpcConnection.js";
+import type { RemoteControlSink } from "../remote/remoteControlSink.js";
 
 export interface DaemonServerOptions {
   socketPath: string;
   bridgeOptions?: AgentBridgeOptions;
+  /**
+   * Built with the bridge (which the daemon owns privately) so the sink can
+   * route inbound phone requests back through it. Its notifications are wired
+   * up here; connecting is the user's call, not ours. Unset means remote
+   * control is off for this daemon — the `remoteControl*` RPCs then report
+   * exactly that through the bridge's own error.
+   */
+  createRemoteSink?: (bridge: AgentBridge) => RemoteControlSink;
 }
 
 export class DaemonServer {
@@ -30,11 +39,17 @@ export class DaemonServer {
   private bridge: AgentBridge;
   private connections = new Set<JsonRpcConnection>();
   private sockets = new Set<net.Socket>();
+  private remoteSink: RemoteControlSink | undefined;
 
   constructor(options: DaemonServerOptions) {
     this.socketPath = options.socketPath;
+    let remoteSink: RemoteControlSink | undefined;
     this.bridge = new AgentBridge({
       ...options.bridgeOptions,
+      // The sink is handed the bridge it must route phone requests back
+      // through, so it can only be built after it; reading it lazily keeps the
+      // two from having to be constructed in a circle.
+      remoteControl: () => remoteSink,
       // Notifications go to every attached client; a fully detached daemon
       // has none, and the write is dropped silently (the attach snapshot
       // re-syncs state on reconnect).
@@ -42,11 +57,20 @@ export class DaemonServer {
         for (const conn of this.connections) {
           conn.sendNotification(method, params, sessionId);
         }
+        // The phone must never be able to take the local clients down with
+        // it, so a remote-path failure is contained here rather than thrown.
+        try {
+          this.remoteSink?.sendNotification(method, params, sessionId);
+        } catch {
+          // Dropped frame; the phone re-syncs on reconnect.
+        }
       },
       // The `shutdown` RPC (wave daemon stop/restart) destroys every session in
       // the bridge, then hands off here to tear the process down.
       onShutdownRequest: () => this.shutdown(),
     });
+    remoteSink = options.createRemoteSink?.(this.bridge);
+    this.remoteSink = remoteSink;
     this.server = net.createServer((socket) => {
       const conn = new JsonRpcConnection(socket, socket, this.bridge);
       this.connections.add(conn);
@@ -124,6 +148,8 @@ export class DaemonServer {
 
   stop(): Promise<void> {
     return new Promise((resolve) => {
+      this.remoteSink?.stop();
+      this.remoteSink = undefined;
       const server = this.server;
       if (!server) return resolve();
       this.server = undefined;
@@ -140,6 +166,10 @@ export class DaemonServer {
    * teardown.
    */
   private shutdown(): void {
+    // Drop the relay link explicitly: the process is about to exit, and leaving
+    // the socket to the OS would have the relay hold a dead subscription.
+    this.remoteSink?.stop();
+    this.remoteSink = undefined;
     for (const socket of this.sockets) socket.destroy();
     this.sockets.clear();
     this.server?.close();

package/src/stdio/jsonRpcConnection.ts

@@ -12,9 +12,11 @@ import readline from "readline";
 import type { Readable, Writable } from "stream";
 import { AgentBridge } from "./agentBridge.js";
 import {
+  type ClientNotificationMethod,
   type JsonRpcRequest,
   type JsonRpcResponse,
   type JsonRpcNotification,
+  type RequestMethod,
   PARSE_ERROR,
   INVALID_REQUEST,
   INTERNAL_ERROR,
@@ -123,8 +125,12 @@ export class JsonRpcConnection {
 
   private async handleRequest(msg: JsonRpcRequest): Promise<void> {
     try {
+      // The boundary and the only cast: JSON-RPC `method` is untrusted input.
+      // Anything outside the union still reaches the bridge and is answered by
+      // its `default:` branch with -32601 — the type stops at this line, and no
+      // runtime allow-list is duplicated here.
       const result = await this.bridge.handleRequest(
-        msg.method,
+        msg.method as RequestMethod,
         msg.params,
         msg.sessionId,
       );
@@ -141,7 +147,10 @@ export class JsonRpcConnection {
 
   private handleNotification(msg: JsonRpcNotification): void {
     try {
-      this.bridge.handleNotification(msg.method, msg.params);
+      this.bridge.handleNotification(
+        msg.method as ClientNotificationMethod,
+        msg.params,
+      );
     } catch (err) {
       // Notifications don't get responses, but we log to stderr
       process.stderr.write(

package/src/stdio/protocol.ts

@@ -44,112 +44,20 @@ export const METHOD_NOT_FOUND = -32601;
 export const INVALID_PARAMS = -32602;
 export const INTERNAL_ERROR = -32603;
 
-// ── Client → Server request methods ─────────────────────────────
-
-export type RequestMethod =
-  | "initialize"
-  | "destroy"
-  | "restoreSession"
-  | "listSessions"
-  | "getSessionInfo"
-  | "sendMessage"
-  | "bang"
-  | "askBtw"
-  | "abortMessage"
-  | "clearMessages"
-  | "rewindToMessage"
-  | "listRewindCheckpoints"
-  | "deleteQueuedMessage"
-  | "updateQueuedMessage"
-  | "deleteQueuedMessageById"
-  | "getMessages"
-  | "getFullMessageThread"
-  | "setPermissionMode"
-  | "getPermissionMode"
-  | "getPlanFile"
-  | "getMcpServers"
-  | "connectMcpServer"
-  | "disconnectMcpServer"
-  | "removeMcpServer"
-  | "getMcpConfigPaths"
-  | "getSlashCommands"
-  | "getSubagentConfigurations"
-  | "getSkillMetadata"
-  | "deleteSkill"
-  | "deleteSubagent"
-  | "getHooksByScope"
-  | "deleteHook"
-  | "searchFiles"
-  | "writeArtifactFile"
-  | "getPromptHistory"
-  | "searchPromptHistory"
-  | "updateConfig"
-  | "getConfiguredModels"
-  | "setModel"
-  // Permissions (daemon attach: re-surface pending approvals after reconnect)
-  | "listPendingPermissions"
-  // Daemon (global — list in-memory session registry, no session required)
-  | "listDaemonSessions"
-  // Auth
-  | "getAuthStatus"
-  | "getAccountInfo"
-  | "login"
-  | "logout"
-  // Memory files (user-level ~/.wave/AGENTS.md and project-level <workdir>/AGENTS.md)
-  | "getAgentsContent"
-  | "setAgentsContent"
-  // Plugins
-  | "listPlugins"
-  | "installPlugin"
-  | "uninstallPlugin"
-  | "enablePlugin"
-  | "disablePlugin"
-  | "updatePlugin"
-  | "listMarketplaces"
-  | "addMarketplace"
-  | "removeMarketplace"
-  | "updateMarketplace"
-  | "compact"
-  | "getBackgroundTaskOutput"
-  | "stopBackgroundTask"
-  | "getWorkflowRuns"
-  | "stopWorkflowRun"
-  // Git / worktree (global — no session required)
-  | "listGitBranches"
-  | "createWorktree"
-  | "getWorktreeChanges"
-  | "removeWorktree";
-
-// ── Client → Server notification methods ────────────────────────
-
-export type ClientNotificationMethod = "permissionResponse";
-
-// ── Server → Client notification methods ────────────────────────
-
-export type ServerNotificationMethod =
-  | "userMessageAdded"
-  | "assistantMessageAdded"
-  | "assistantContentUpdated"
-  | "assistantReasoningUpdated"
-  | "toolBlockUpdated"
-  | "errorBlockAdded"
-  | "loadingChange"
-  | "commandRunningChange"
-  | "queuedMessagesChange"
-  | "tasksChange"
-  | "sessionIdChange"
-  | "permissionModeChange"
-  | "mcpServersChange"
-  | "workdirChange"
-  | "notificationMessageAdded"
-  | "permissionRequest"
-  | "authUrl"
-  | "compactBlockAdded"
-  | "compactionStateChange"
-  | "compactionContentUpdate"
-  | "backgroundTasksChange"
-  | "btwContent"
-  | "contextUsage";
+// ── Method / notification lists ────────────────────────────────
+// Declared once, in the SDK (`src/types/stdioProtocol.ts`), because the RPC
+// client lives there too and both sides of the wire must read the same union.
+// Re-exported here so this package has one module to import from.
+//
+// The compiler — not a source-scanning test — is what keeps them honest: the
+// bridge's `default:` branch is `never`-checked, and `emit` / `RpcClient` are
+// typed with these unions, so a method added on one side without the other does
+// not build.
+export type {
+  ClientNotificationMethod,
+  RequestMethod,
+  ServerNotificationMethod,
+} from "wave-agent-sdk";
 
 // ── Helper: is this a request (has id)? ─────────────────────────
 

package/src/stdio/stdioServer.ts

@@ -9,23 +9,47 @@
 import type { Readable, Writable } from "stream";
 import { AgentBridge, type AgentBridgeOptions } from "./agentBridge.js";
 import { JsonRpcConnection } from "./jsonRpcConnection.js";
+import type { RemoteControlSink } from "../remote/remoteControlSink.js";
 
 export interface StdioServerOptions {
   input?: Readable;
   output?: Writable;
   bridgeOptions?: AgentBridgeOptions;
+  /**
+   * Same seam as `DaemonServerOptions.createRemoteSink`, for the other server
+   * that owns sessions: the `--stdio` child a GUI host spawns. Unset means
+   * remote control is off for this child — the `remoteControl*` RPCs then
+   * report exactly that through the bridge's own error.
+   */
+  createRemoteSink?: (bridge: AgentBridge) => RemoteControlSink;
 }
 
 export class StdioServer {
   private bridge: AgentBridge;
   private conn: JsonRpcConnection;
+  private remoteSink: RemoteControlSink | undefined;
 
   constructor(options: StdioServerOptions = {}) {
+    let remoteSink: RemoteControlSink | undefined;
     this.bridge = new AgentBridge({
       ...options.bridgeOptions,
-      emit: (method, params, sessionId) =>
-        this.sendNotification(method, params, sessionId),
+      // The sink is handed the bridge it must route phone requests back
+      // through, so it can only be built after it; reading it lazily keeps the
+      // two from having to be constructed in a circle.
+      remoteControl: () => remoteSink,
+      emit: (method, params, sessionId) => {
+        this.sendNotification(method, params, sessionId);
+        // The phone must never be able to take the host's own client down with
+        // it, so a remote-path failure is contained here rather than thrown.
+        try {
+          this.remoteSink?.sendNotification(method, params, sessionId);
+        } catch {
+          // Dropped frame; the phone re-syncs on reconnect.
+        }
+      },
     });
+    remoteSink = options.createRemoteSink?.(this.bridge);
+    this.remoteSink = remoteSink;
     this.conn = new JsonRpcConnection(
       options.input ?? process.stdin,
       options.output ?? process.stdout,
@@ -43,6 +67,8 @@ export class StdioServer {
   }
 
   stop(): void {
+    this.remoteSink?.stop();
+    this.remoteSink = undefined;
     this.conn.stop();
   }
 
@@ -52,9 +78,14 @@ export class StdioServer {
    * auto-memory first; a timeout bounds it so a stuck agent can't orphan the
    * exit. This is the real-world "parent died" path: without it the process
    * lingers forever whenever an agent keeps event-loop handles alive.
+   *
+   * The relay link is dropped explicitly before the exit: leaving the socket to
+   * the OS would have the relay hold a subscription for a process that is gone.
    */
   private async onConnectionClosed(): Promise<void> {
     const SHUTDOWN_TIMEOUT_MS = 5_000;
+    this.remoteSink?.stop();
+    this.remoteSink = undefined;
     await Promise.race([
       this.bridge.destroyAll(),
       new Promise((resolve) => setTimeout(resolve, SHUTDOWN_TIMEOUT_MS)),

package/src/stdio-cli.ts

@@ -6,7 +6,9 @@
  * the client sends an "initialize" request.
  */
 
+import { ensureRuntimeDeps, setTelemetryStdoutProtected } from "wave-agent-sdk";
 import { StdioServer } from "./stdio/stdioServer.js";
+import { createRemoteControlSinkFactory } from "./remote/remoteControlSink.js";
 import { logger } from "./utils/logger.js";
 
 /**
@@ -54,6 +56,15 @@ export function guardStdoutForJsonRpc(): void {
 
 export async function startStdioCli(): Promise<void> {
   guardStdoutForJsonRpc();
+  // stdout is the JSON-RPC channel here: console telemetry exporters would
+  // print onto it (OTel's console exporters use console.dir, which
+  // guardStdoutForJsonRpc does not cover) — strip them at config resolution.
+  setTelemetryStdoutProtected(true);
+  // Install the on-demand runtime dependencies (image codec + ripgrep) before
+  // answering any RPC (see cli.tsx). Blocking here is what closes the race: the
+  // host's `initialize` — and with it the webview's initial state — only lands
+  // once a pasted image can be handled. Failures are non-fatal.
+  await ensureRuntimeDeps();
   // Registered here (stdio mode only): the interactive CLI keeps Node's
   // default behavior so the terminal shows the crash stack directly.
   process.on("uncaughtException", (error) =>
@@ -63,7 +74,11 @@ export async function startStdioCli(): Promise<void> {
     crashHandler("unhandledRejection", reason),
   );
 
-  const server = new StdioServer();
+  const server = new StdioServer({
+    // This child owns the sessions its host shows, so it — not a daemon on the
+    // same machine — is what serves a paired phone.
+    createRemoteSink: createRemoteControlSinkFactory(process.cwd()),
+  });
   server.start();
 
   // Keep the process alive — readline on stdin handles the event loop.

package/src/utils/gitCredentialHelper.ts

@@ -0,0 +1,106 @@
+/**
+ * Git credential helper installed for repositories cloned from a `wave://clone`
+ * deep link (spec: docs/specs/desktop/desktop-deep-link.md「克隆出的仓库长期
+ * 自动认证」).
+ *
+ * What lands in the repository config is *this command*, never the credential:
+ *
+ *     [credential]
+ *         helper =
+ *         helper = !exec '/Users/me/.wave/git-credential-wave'
+ *
+ * The empty first entry resets the helper list inherited from system/global
+ * config. Without it a machine-wide store/cache helper (osxkeychain, manager,
+ * credential-store) also runs and pins the first credential it sees, so later
+ * logins and token refreshes would never be picked up.
+ *
+ * The helper is a plain `/bin/sh` script rather than a call back into the CLI:
+ * git invokes it before *every* authenticated network operation, and booting
+ * the Electron-bundled Node runtime for that would add seconds to each push. It
+ * only needs the token sitting in `~/.wave/auth.json`, which the CLI keeps
+ * current (including background refreshes).
+ */
+
+import { chmodSync, mkdirSync, writeFileSync } from "fs";
+import * as path from "path";
+import { AuthService } from "wave-agent-sdk";
+
+/** Extensionless on purpose: git execs it through the shebang, and MSYS sh
+ *  resolves a bare path that starts with `#!`. */
+export const GIT_CREDENTIAL_HELPER_FILENAME = "git-credential-wave";
+
+export interface InstalledGitCredentialHelper {
+  /** Absolute path of the generated script. */
+  path: string;
+  /** Ready-to-use `credential.helper` value (written into repo config). */
+  command: string;
+}
+
+/** `<home>/.wave/git-credential-wave` — next to `auth.json`. */
+export function gitCredentialHelperPath(): string {
+  return path.join(
+    path.dirname(AuthService.getInstance().getAuthPath()),
+    GIT_CREDENTIAL_HELPER_FILENAME,
+  );
+}
+
+/**
+ * (Re)write the helper script and return the config value that installs it.
+ * Idempotent — safe to call on every deep-link clone.
+ */
+export function installGitCredentialHelper(): InstalledGitCredentialHelper {
+  const scriptPath = gitCredentialHelperPath();
+  mkdirSync(path.dirname(scriptPath), { recursive: true });
+  writeFileSync(
+    scriptPath,
+    renderGitCredentialHelper(AuthService.getInstance().getAuthPath()),
+    "utf-8",
+  );
+  chmodSync(scriptPath, 0o755);
+  return { path: scriptPath, command: `!exec ${shellQuote(scriptPath)}` };
+}
+
+/** The script body. Exported for tests. */
+export function renderGitCredentialHelper(authFilePath: string): string {
+  return `#!/bin/sh
+# Wave git credential helper — generated by CodeWave IDE.
+# Rewritten on every deep-link clone; do not edit by hand.
+#
+# Prints the current Wave SSO token, read fresh from the login store on each
+# request, so logging in (or the CLI refreshing the token) takes effect without
+# touching any repository.
+
+AUTH_FILE=${shellQuote(authFilePath)}
+
+# Drain git's request: we only look at the capabilities it advertises below, and
+# a helper that exits before reading stdin can get EPIPE'd.
+input=$(cat 2>/dev/null) || input=
+
+token=$(sed -n 's/.*"SSO_TOKEN"[[:space:]]*:[[:space:]]*"\\([^"]*\\)".*/\\1/p' "$AUTH_FILE" 2>/dev/null | head -n 1)
+
+if [ -z "$token" ]; then
+	# Not logged in on this machine. Stop git right here: quit=true skips the
+	# remaining helpers *and* the interactive prompt (there is no terminal when
+	# the agent runs git), so the operation fails fast instead of hanging.
+	echo "quit=true"
+	exit 0
+fi
+
+case "$input" in
+*capability\\[\\]=authtype*)
+	echo "capability[]=authtype"
+	echo "authtype=bearer"
+	printf 'credential=%s\\n' "$token"
+	;;
+*)
+	echo "username=oauth2"
+	printf 'password=%s\\n' "$token"
+	;;
+esac
+`;
+}
+
+/** Single-quote a value for `sh`, escaping embedded single quotes. */
+export function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}

package/src/utils/logger.ts

@@ -11,7 +11,7 @@
 import * as fs from "fs";
 import * as path from "path";
 import { Chalk } from "chalk";
-import { getLastLines } from "wave-agent-sdk";
+import { getLastLines, errorReplacer } from "wave-agent-sdk";
 import { LOG_FILE } from "./constants.js";
 
 const chalk = new Chalk({ level: 3 });
@@ -132,7 +132,10 @@ const formatArg = (arg: unknown): string => {
     result = arg.stack || arg.message || String(arg);
   } else if (typeof arg === "object") {
     try {
-      result = JSON.stringify(arg);
+      // The replacer keeps Errors nested inside a payload ({ error: e }) from
+      // serializing to `{}` — the `instanceof` check above only covers args
+      // passed bare.
+      result = JSON.stringify(arg, errorReplacer);
     } catch {
       // If JSON.stringify fails, fallback to String()
       result = String(arg);

package/src/utils/rewindCheckpoints.ts

@@ -2,15 +2,13 @@ import type { Message } from "wave-agent-sdk";
 
 /**
  * 判断一条 user 消息能否作为 /rewind 检查点。
- * 后台任务通知（task_notification）、hook 注入的消息（source: "hook"）
- * 都是系统生成、用户不可见的，不能作为回滚点。bash 模式命令消息
+ * 后台任务通知（task_notification）与 hook 注入的消息都是系统生成、
+ * 用户不可见的（meta），不能作为回滚点。bash 模式命令消息
  * （`!ls`）是用户真正输入，与 fork skill 命令消息一致，可作为回滚点。
  * CLI 交互式选择器与 stdio listRewindCheckpoints 共用此判定，避免两处漂移。
  */
 export function isUserCheckpointMessage(m: Message): boolean {
   if (m.role !== "user" || m.isMeta) return false;
   if (m.blocks.some((b) => b.type === "task_notification")) return false;
-  if (m.blocks.some((b) => b.type === "text" && b.source === "hook"))
-    return false;
   return true;
 }

package/src/utils/sessionOwnership.ts

@@ -0,0 +1,62 @@
+import { existsSync } from "fs";
+import { PathEncoder } from "wave-agent-sdk";
+
+/** POSIX single-quote wrapping for use inside a `cd <path> && ...` command. */
+export 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}`,
+  };
+}