wave-code 1.0.0 → 1.0.2

package/src/stdio/agentBridge.ts

@@ -118,9 +118,16 @@ interface SessionContext {
 
 export class AgentBridge {
   private sessions = new Map<string, SessionEntry>();
+  /** Pending approval requests, keyed by requestId. Stored with the resolve +
+   * context so a re-attached client can list and respond to them (daemon mode:
+   * approvals outlive any single connection). */
   private pendingPermissions = new Map<
     string,
-    (decision: PermissionDecision) => void
+    {
+      resolve: (decision: PermissionDecision) => void;
+      sessionId?: string;
+      context: ToolPermissionContext;
+    }
   >();
   private permissionCounter = 0;
   private emit: NotificationEmitter;
@@ -151,6 +158,8 @@ export class AgentBridge {
         return this.listSessions(p.workdir as string | undefined, sessionId);
       case "getSessionInfo":
         return this.getSessionInfo(sessionId);
+      case "listPendingPermissions":
+        return this.listPendingPermissions();
       case "updateConfig":
         return this.updateConfig(p as unknown as UpdateConfigParams, sessionId);
 
@@ -166,6 +175,8 @@ export class AgentBridge {
         );
       case "bang":
         return this.bang(p.command as string, sessionId);
+      case "askBtw":
+        return this.askBtw(p.question as string, sessionId);
       case "abortMessage":
         return this.abortMessage(sessionId);
       case "clearMessages":
@@ -353,10 +364,10 @@ export class AgentBridge {
         decision: PermissionDecision;
       };
       // requestId is process-level unique; lookup doesn't need sessionId
-      const resolve = this.pendingPermissions.get(p.requestId);
-      if (resolve) {
+      const entry = this.pendingPermissions.get(p.requestId);
+      if (entry) {
         this.pendingPermissions.delete(p.requestId);
-        resolve(p.decision);
+        entry.resolve(p.decision);
       }
     }
   }
@@ -369,6 +380,21 @@ export class AgentBridge {
     permissionMode: PermissionMode;
     latestTotalTokens: number;
   }> {
+    // Re-attach (daemon mode): if the target session is already live in this
+    // process, reuse it instead of creating a second agent writing to the same
+    // transcript. The live agent keeps running across client detach/attach.
+    if (params.restoreSessionId) {
+      const live = this.sessions.get(params.restoreSessionId);
+      if (live) {
+        return {
+          sessionId: live.agent.sessionId,
+          workingDirectory: live.agent.workingDirectory,
+          permissionMode: live.agent.getPermissionMode(),
+          latestTotalTokens: live.agent.latestTotalTokens,
+        };
+      }
+    }
+
     const ctx: SessionContext = {};
     const callbacks = this.createCallbacks(ctx);
 
@@ -423,11 +449,70 @@ export class AgentBridge {
     return null;
   }
 
+  /**
+   * True when every hosted session has settled: not generating, nothing queued,
+   * and no background work (background bash / subagents / workflows) — the same
+   * condition `wave -p` waits on before exiting (print-cli.ts). Pending
+   * permission approvals keep the owning agent's isLoading true, so they are
+   * covered without an explicit check.
+   */
+  public isIdle(): boolean {
+    for (const entry of this.sessions.values()) {
+      const agent = entry.agent;
+      if (
+        agent.isLoading ||
+        agent.hasPendingMessages ||
+        agent.hasRunningBackgroundWork
+      ) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Destroy every hosted session agent. Each Agent.destroy() saves its
+   * transcript, drains in-flight auto-memory extraction, and cleans up
+   * background tasks/subagents. Best-effort: one failing destroy must not
+   * block the rest of the shutdown.
+   */
+  public async destroyAll(): Promise<void> {
+    const entries = [...this.sessions.values()];
+    this.sessions.clear();
+    await Promise.all(
+      entries.map((entry) => entry.agent.destroy().catch(() => {})),
+    );
+  }
+
   private async restoreSession(
     restoreId: string,
     sessionId?: string,
   ): Promise<null> {
     const entry = this.requireSession(sessionId);
+    // Re-attach to a live session: the SDK restore would no-op (target is
+    // already current). Emit the current messages so the freshly attached
+    // client — whose router registered only after initialize returned and so
+    // missed any earlier notifications — gets a snapshot without replay.
+    if (entry.agent.sessionId === restoreId) {
+      this.emit(
+        "messagesChange",
+        { messages: entry.agent.messages },
+        entry.agent.sessionId,
+      );
+      // The re-attached client also missed the loading state that settled
+      // before its router registered — replay it or the client's
+      // isStreaming/running indicator stays false while the live session
+      // keeps generating.
+      this.emit(
+        "loadingChange",
+        {
+          loading: entry.agent.isLoading,
+          latestTotalTokens: entry.agent.latestTotalTokens,
+        },
+        entry.agent.sessionId,
+      );
+      return null;
+    }
     await entry.agent.restoreSession(restoreId);
     return null;
   }
@@ -667,6 +752,35 @@ export class AgentBridge {
     return null;
   }
 
+  private async askBtw(question: string, sessionId?: string): Promise<string> {
+    const entry = this.requireSession(sessionId);
+    return entry.agent.askBtw(
+      question,
+      undefined,
+      // Stream partial content to the client so webview hosts can render the
+      // answer incrementally (thinking and content travel on separate
+      // channels so the panel can drop thinking text once content starts).
+      (content) => {
+        if (sessionId) {
+          this.emit(
+            "btwContent",
+            { question, content, type: "content" },
+            sessionId,
+          );
+        }
+      },
+      (content) => {
+        if (sessionId) {
+          this.emit(
+            "btwContent",
+            { question, content, type: "thinking" },
+            sessionId,
+          );
+        }
+      },
+    );
+  }
+
   private async abortMessage(sessionId?: string): Promise<null> {
     const entry = this.requireSession(sessionId);
     entry.agent.abortMessage();
@@ -901,7 +1015,11 @@ export class AgentBridge {
   ): Promise<PermissionDecision> {
     const requestId = `perm_${++this.permissionCounter}`;
     return new Promise<PermissionDecision>((resolve) => {
-      this.pendingPermissions.set(requestId, resolve);
+      this.pendingPermissions.set(requestId, {
+        resolve,
+        sessionId: ctx.registeredSessionId,
+        context,
+      });
       this.emit(
         "permissionRequest",
         { requestId, context },
@@ -910,6 +1028,27 @@ export class AgentBridge {
     });
   }
 
+  /** Attach snapshot: re-surface approvals that are still pending after a
+   * client disconnected (daemon mode). Responding to any listed requestId
+   * resolves the in-process promise. */
+  private listPendingPermissions(): {
+    requests: Array<{
+      requestId: string;
+      sessionId?: string;
+      context: ToolPermissionContext;
+    }>;
+  } {
+    return {
+      requests: [...this.pendingPermissions.entries()].map(
+        ([requestId, entry]) => ({
+          requestId,
+          sessionId: entry.sessionId,
+          context: entry.context,
+        }),
+      ),
+    };
+  }
+
   // ── Auth (global) ────────────────────────────────────────────
 
   private async getAuthStatus(): Promise<{
@@ -918,6 +1057,14 @@ export class AgentBridge {
     serverUrl: string;
   }> {
     const authService = AuthService.getInstance();
+    // A stale-but-refreshable token still means "logged in" — the daemon may
+    // have started with an expired access token (hourly expiry) and only
+    // refreshes lazily on the first API call. Without this proactive refresh a
+    // fresh client querying right after daemon start gets a false
+    // isAuthenticated and e.g. the desktop welcome page keeps showing the
+    // login button for an authenticated host. Mirrors the refresh that
+    // createAuthAwareFetch does before every real request.
+    await authService.checkAndRefreshTokenIfNeeded();
     return {
       isAuthenticated: authService.isSSOAuthenticated(),
       user: authService.getAuthUser(),
@@ -1091,9 +1238,6 @@ export class AgentBridge {
 
   private createCallbacks(ctx: SessionContext): AgentCallbacks {
     return {
-      onMessagesChange: (messages: Message[]) => {
-        this.emit("messagesChange", { messages }, ctx.registeredSessionId);
-      },
       onUserMessageAdded: () => {
         const msg = this.findLastUserMessage(ctx.agent);
         if (msg)
@@ -1113,13 +1257,36 @@ export class AgentBridge {
           );
       },
       onAssistantContentUpdated: (params) => {
-        this.emit("assistantContentUpdated", params, ctx.registeredSessionId);
+        // Wire carries only the delta; consumers accumulate (spec: 流式通知纯增量负载).
+        this.emit(
+          "assistantContentUpdated",
+          {
+            messageId: params.messageId,
+            chunk: params.chunk,
+            stage: params.stage,
+          },
+          ctx.registeredSessionId,
+        );
       },
       onAssistantReasoningUpdated: (params) => {
-        this.emit("assistantReasoningUpdated", params, ctx.registeredSessionId);
+        this.emit(
+          "assistantReasoningUpdated",
+          {
+            messageId: params.messageId,
+            chunk: params.chunk,
+            stage: params.stage,
+          },
+          ctx.registeredSessionId,
+        );
       },
       onToolBlockUpdated: (params) => {
-        this.emit("toolBlockUpdated", params, ctx.registeredSessionId);
+        // Streaming stages carry only the parametersChunk delta; start/running
+        // (one-time snapshots) and end (authoritative full value) keep
+        // `parameters` (spec: 流式通知纯增量负载).
+        const { parameters, ...rest } = params;
+        void parameters;
+        const wireParams = params.stage === "streaming" ? rest : params;
+        this.emit("toolBlockUpdated", wireParams, ctx.registeredSessionId);
       },
       onErrorBlockAdded: (error: string) => {
         this.emit("errorBlockAdded", { error }, ctx.registeredSessionId);
@@ -1193,14 +1360,26 @@ export class AgentBridge {
       onMcpServersChange: (servers: McpServerStatus[]) => {
         this.emit("mcpServersChange", { servers }, ctx.registeredSessionId);
       },
-      onAddBangMessage: () => {
-        this.emit("bangMessageAdded", {}, ctx.registeredSessionId);
+      onAddBangMessage: (command, messageId) => {
+        this.emit(
+          "bangMessageAdded",
+          { command, messageId },
+          ctx.registeredSessionId,
+        );
       },
-      onUpdateBangMessage: () => {
-        this.emit("bangMessageUpdated", {}, ctx.registeredSessionId);
+      onUpdateBangMessage: (command, output, messageId) => {
+        this.emit(
+          "bangMessageUpdated",
+          { command, output, messageId },
+          ctx.registeredSessionId,
+        );
       },
-      onCompleteBangMessage: () => {
-        this.emit("bangMessageCompleted", {}, ctx.registeredSessionId);
+      onCompleteBangMessage: (command, exitCode, messageId) => {
+        this.emit(
+          "bangMessageCompleted",
+          { command, exitCode, messageId },
+          ctx.registeredSessionId,
+        );
       },
       onNotificationMessageAdded: (params) => {
         const msg = ctx.agent?.messages.find(

package/src/stdio/daemonServer.ts

@@ -0,0 +1,212 @@
+/**
+ * DaemonServer — JSON-RPC server over a unix socket for remote background
+ * sessions (spec: docs/specs/ui/desktop-app.md 「SSH 远程后台会话」).
+ *
+ * The desktop app launches `wave --daemon <socket>` on the remote host via
+ * nohup/setsid, then tunnels the socket back with `ssh -L`. All connections
+ * share one AgentBridge, so sessions and pending tool permissions survive
+ * client detach/attach — the daemon keeps running (and generating) while no
+ * desktop is connected. The daemon never exits on a client disconnect; it
+ * only exits when killed (app quit / 删除会话 / remote reboot).
+ *
+ * Idle auto-exit (spec: 「远程 daemon 空闲自动退出」): once every session has
+ * settled and no client is connected, the daemon mirrors `wave -p`'s exit
+ * semantics — after a grace period it destroys the sessions (saving their
+ * transcripts), closes the socket, and exits, so the remote process doesn't
+ * linger forever after background work completes.
+ */
+
+import net from "net";
+import * as fs from "fs";
+import { AgentBridge, type AgentBridgeOptions } from "./agentBridge.js";
+import { JsonRpcConnection } from "./jsonRpcConnection.js";
+
+export interface DaemonServerOptions {
+  socketPath: string;
+  bridgeOptions?: AgentBridgeOptions;
+  /** Idle grace period before the daemon auto-exits (default 60s). */
+  graceMs?: number;
+}
+
+export class DaemonServer {
+  static readonly DEFAULT_IDLE_GRACE_MS = 60_000;
+
+  private socketPath: string;
+  private server: net.Server | undefined;
+  private bridge: AgentBridge;
+  private connections = new Set<JsonRpcConnection>();
+  private sockets = new Set<net.Socket>();
+  private graceMs: number;
+  private idleTimer: NodeJS.Timeout | undefined;
+  private shuttingDown = false;
+  private stopped = false;
+
+  constructor(options: DaemonServerOptions) {
+    this.socketPath = options.socketPath;
+    this.graceMs = options.graceMs ?? DaemonServer.DEFAULT_IDLE_GRACE_MS;
+    this.bridge = new AgentBridge({
+      ...options.bridgeOptions,
+      // 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).
+      emit: (method, params, sessionId) => {
+        for (const conn of this.connections) {
+          conn.sendNotification(method, params, sessionId);
+        }
+        // Any session activity can change the idle state — re-evaluate.
+        this.evaluateIdle();
+      },
+    });
+    this.server = net.createServer((socket) => {
+      if (this.shuttingDown) {
+        socket.destroy();
+        return;
+      }
+      const conn = new JsonRpcConnection(socket, socket, this.bridge);
+      this.connections.add(conn);
+      this.sockets.add(socket);
+      // A (re)attached client cancels a pending idle exit.
+      this.evaluateIdle();
+      socket.on("error", () => {
+        // The client (ssh tunnel) can reset the socket mid-detach; the daemon
+        // must keep running — 'close' below cleans up the connection.
+      });
+      socket.on("close", () => {
+        this.connections.delete(conn);
+        this.sockets.delete(socket);
+        // A client detach may leave the daemon idle — re-evaluate.
+        this.evaluateIdle();
+      });
+      conn.start();
+    });
+  }
+
+  get agentBridge(): AgentBridge {
+    return this.bridge;
+  }
+
+  /**
+   * Listen on the socket path. Rejects when a live daemon already holds it. A
+   * stale socket file left by a crashed daemon would otherwise block the
+   * restart with EADDRINUSE, so it is cleaned up first: non-socket files are
+   * unlinked outright; socket files are probe-connected — ECONNREFUSED means
+   * no listener (stale → unlink and listen), anything else means a live
+   * daemon owns the path (reject).
+   */
+  start(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const server = this.server;
+      if (!server) return resolve();
+      try {
+        const st = fs.statSync(this.socketPath);
+        if (st.isSocket()) {
+          const probe = net.connect(this.socketPath);
+          probe.once("connect", () => {
+            probe.destroy();
+            reject(
+              new Error(`另一个 wave daemon 已在 ${this.socketPath} 监听`),
+            );
+          });
+          probe.once("error", (err: NodeJS.ErrnoException) => {
+            probe.destroy();
+            if (err.code === "ECONNREFUSED") {
+              fs.unlinkSync(this.socketPath);
+              this.listen(server, resolve, reject);
+            } else {
+              reject(err);
+            }
+          });
+          return;
+        }
+        fs.unlinkSync(this.socketPath);
+      } catch {
+        // ENOENT — no stale socket, listen directly.
+      }
+      this.listen(server, resolve, reject);
+    });
+  }
+
+  private listen(
+    server: net.Server,
+    resolve: () => void,
+    reject: (err: Error) => void,
+  ): void {
+    server.once("error", reject);
+    server.listen(this.socketPath, () => {
+      server.removeListener("error", reject);
+      resolve();
+      // A freshly started daemon may already be idle (no sessions) — start the
+      // idle watch so a zero-session daemon also auto-exits.
+      this.evaluateIdle();
+    });
+  }
+
+  stop(): Promise<void> {
+    this.stopped = true;
+    this.clearIdleTimer();
+    return new Promise((resolve) => {
+      const server = this.server;
+      if (!server) return resolve();
+      this.server = undefined;
+      server.close(() => resolve());
+    });
+  }
+
+  // ── Idle auto-exit ────────────────────────────────────────────
+
+  private clearIdleTimer(): void {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = undefined;
+    }
+  }
+
+  /**
+   * Re-evaluate the idle condition after any state transition: sessions busy
+   * (loading / pending messages / background work) or any client attached →
+   * cancel the timer. Fully idle + detached → arm the grace timer once; when
+   * it fires, shut the daemon down. Evaluation is event-driven (every
+   * busy→idle transition emits a notification, every attach/detach fires a
+   * connection event), so nothing is polled. The failure mode is
+   * conservative: a missed transition just leaves the daemon running.
+   */
+  private evaluateIdle(): void {
+    // A stopped/shutting-down daemon never (re)arms the idle timer — late
+    // socket 'close' events (which fire after server.close resolves) must not
+    // resurrect a timer after stop().
+    if (this.shuttingDown || this.stopped) return;
+    if (this.connections.size > 0 || !this.bridge.isIdle()) {
+      this.clearIdleTimer();
+      return;
+    }
+    if (this.idleTimer) return;
+    this.idleTimer = setTimeout(() => {
+      this.idleTimer = undefined;
+      void this.shutdown();
+    }, this.graceMs);
+  }
+
+  /**
+   * Destroy the sessions (each agent saves its transcript and drains
+   * auto-memory), close the listener, unlink the socket file, then exit.
+   * `shuttingDown` guards against re-entry: new connections are refused and
+   * further idle evaluations become no-ops.
+   */
+  private async shutdown(): Promise<void> {
+    if (this.shuttingDown) return;
+    this.shuttingDown = true;
+    this.clearIdleTimer();
+    // Destroy client sockets first so server.close() can complete (an open
+    // socket keeps the close callback pending).
+    for (const socket of this.sockets) socket.destroy();
+    this.sockets.clear();
+    await this.bridge.destroyAll();
+    await this.stop();
+    try {
+      fs.unlinkSync(this.socketPath);
+    } catch {
+      // Already gone — a stale file would be probed/unlinked on next start.
+    }
+    process.exit(0);
+  }
+}

package/src/stdio/index.ts

@@ -1,4 +1,6 @@
 export { StdioServer, type StdioServerOptions } from "./stdioServer.js";
+export { JsonRpcConnection } from "./jsonRpcConnection.js";
+export { DaemonServer, type DaemonServerOptions } from "./daemonServer.js";
 export {
   AgentBridge,
   type AgentBridgeOptions,

package/src/stdio/jsonRpcConnection.ts

@@ -0,0 +1,160 @@
+/**
+ * JsonRpcConnection — one JSON-RPC connection over a Readable/Writable pair,
+ * dispatching to a shared AgentBridge.
+ *
+ * Shared by StdioServer (process stdin/stdout) and DaemonServer (each unix
+ * socket connection). The AgentBridge owns all session/agent state, so any
+ * number of connections can share it — a detached client loses nothing and
+ * every session keeps running on the daemon side.
+ */
+
+import readline from "readline";
+import type { Readable, Writable } from "stream";
+import { AgentBridge } from "./agentBridge.js";
+import {
+  type JsonRpcRequest,
+  type JsonRpcResponse,
+  type JsonRpcNotification,
+  PARSE_ERROR,
+  INVALID_REQUEST,
+  INTERNAL_ERROR,
+  isRequest,
+  isNotification,
+} from "./protocol.js";
+
+export class JsonRpcConnection {
+  private rl: readline.Interface | undefined;
+  private started = false;
+
+  constructor(
+    private input: Readable,
+    private output: Writable,
+    private bridge: AgentBridge,
+  ) {}
+
+  start(): void {
+    if (this.started) return;
+    this.started = true;
+
+    this.rl = readline.createInterface({
+      input: this.input,
+      crlfDelay: Infinity,
+    });
+
+    // readline re-emits input errors on the Interface; error handling on the
+    // underlying stream is the owner's job (the daemon keeps running on a
+    // client reset), so swallow them here.
+    this.rl.on("error", () => {});
+
+    this.rl.on("line", (line: string) => {
+      this.handleLine(line).catch((err) => {
+        // Should never reach here — handleLine catches internally
+        this.sendResponse(null, undefined, {
+          code: INTERNAL_ERROR,
+          message: `Unhandled error: ${(err as Error).message}`,
+        });
+      });
+    });
+
+    this.rl.on("close", () => {
+      this.started = false;
+    });
+  }
+
+  stop(): void {
+    this.rl?.close();
+    this.rl = undefined;
+    this.started = false;
+  }
+
+  async handleLine(line: string): Promise<void> {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+
+    let msg: unknown;
+    try {
+      msg = JSON.parse(trimmed);
+    } catch {
+      this.sendResponse(null, undefined, {
+        code: PARSE_ERROR,
+        message: "Parse error: invalid JSON",
+      });
+      return;
+    }
+
+    if (isRequest(msg)) {
+      await this.handleRequest(msg);
+    } else if (isNotification(msg)) {
+      this.handleNotification(msg);
+    } else {
+      // Echo back the id if the message has one, otherwise null
+      const id =
+        typeof msg === "object" &&
+        msg !== null &&
+        "id" in msg &&
+        (typeof (msg as { id: unknown }).id === "number" ||
+          typeof (msg as { id: unknown }).id === "string")
+          ? (msg as { id: number | string }).id
+          : null;
+      this.sendResponse(id, undefined, {
+        code: INVALID_REQUEST,
+        message: "Invalid request: must have 'method' field",
+      });
+    }
+  }
+
+  private async handleRequest(msg: JsonRpcRequest): Promise<void> {
+    try {
+      const result = await this.bridge.handleRequest(
+        msg.method,
+        msg.params,
+        msg.sessionId,
+      );
+      this.sendResponse(msg.id, result);
+    } catch (err) {
+      const code =
+        err && typeof err === "object" && "code" in err
+          ? (err as { code: number }).code
+          : INTERNAL_ERROR;
+      const message = err instanceof Error ? err.message : String(err);
+      this.sendResponse(msg.id, undefined, { code, message });
+    }
+  }
+
+  private handleNotification(msg: JsonRpcNotification): void {
+    try {
+      this.bridge.handleNotification(msg.method, msg.params);
+    } catch (err) {
+      // Notifications don't get responses, but we log to stderr
+      process.stderr.write(
+        `Error handling notification ${msg.method}: ${(err as Error).message}\n`,
+      );
+    }
+  }
+
+  // ── Output helpers ────────────────────────────────────────────
+
+  sendResponse(
+    id: number | string | null,
+    result?: unknown,
+    error?: { code: number; message: string },
+  ): void {
+    const response: JsonRpcResponse = { id };
+    if (error) {
+      response.error = error;
+    } else {
+      response.result = result ?? null;
+    }
+    this.write(response);
+  }
+
+  sendNotification(method: string, params?: unknown, sessionId?: string): void {
+    const notification: JsonRpcNotification = { method, params };
+    if (sessionId) notification.sessionId = sessionId;
+    this.write(notification);
+  }
+
+  private write(obj: JsonRpcResponse | JsonRpcNotification): void {
+    this.output.write(JSON.stringify(obj) + "\n");
+  }
+}