wave-code 1.0.9 → 1.1.0

package/src/daemon/commands.ts

@@ -1,7 +1,8 @@
 /**
  * `wave daemon` client subcommands — talk to the wave daemon's unix socket
  * (JSON-RPC over newline-delimited JSON) to list hosted sessions, inspect
- * progress, inject messages and respond to pending permission requests.
+ * progress, inject messages, respond to pending permission requests and abort
+ * in-flight message generation.
  *
  * All subcommands are non-interactive: results go to stdout, diagnostics to
  * stderr, and every handler calls process.exit() itself (yargs would fall
@@ -68,7 +69,7 @@ async function connectDaemonOrExit(socketPath: string): Promise<SocketClient> {
   } catch (err) {
     const code = (err as NodeJS.ErrnoException).code;
     console.error(
-      `无法连接 daemon socket ${socketPath}：daemon 未运行？（daemon 空闲 60 秒自动退出）` +
+      `Cannot connect to daemon socket ${socketPath}: is the daemon running? (it auto-exits after 60s idle)` +
         (code ? ` (${code})` : ""),
     );
     process.exit(1);
@@ -115,7 +116,7 @@ async function attachSession(
       // initialize silently started a junk fresh session — remove it from the
       // registry so the failed attach leaves no trace (spec: 会话不存在错误).
       await client.request("destroy", undefined, initId).catch(() => {});
-      fail(`会话不存在或未被该 daemon 托管：${sessionId}`);
+      fail(`Session not found or not hosted by this daemon: ${sessionId}`);
     }
     throw err;
   }
@@ -149,7 +150,7 @@ export async function daemonListCommand(socketPath: string): Promise<void> {
     if (sessions.length > 0) {
       const rows = sessions.map((s) => ({
         sessionId: s.sessionId,
-        status: s.isLoading ? "生成中" : "空闲",
+        status: s.isLoading ? "generating" : "idle",
         messageCount: String(s.messageCount),
         workingDirectory: s.workingDirectory,
       }));
@@ -158,7 +159,7 @@ export async function daemonListCommand(socketPath: string): Promise<void> {
       const pad = (value: string, w: number) => value.padEnd(w);
 
       console.log(
-        `${pad("会话", width("sessionId"))}  ${pad("状态", width("status"))}  ${pad("消息数", width("messageCount"))}  工作目录`,
+        `${pad("Session", width("sessionId"))}  ${pad("Status", width("status"))}  ${pad("Messages", width("messageCount"))}  Working directory`,
       );
       for (const r of rows) {
         console.log(
@@ -167,10 +168,10 @@ export async function daemonListCommand(socketPath: string): Promise<void> {
       }
     } else {
       // Daemon idle-exit is normal — an empty registry is not an error.
-      console.log("无会话");
+      console.log("No sessions");
     }
   } catch (err) {
-    fail(`wave daemon list 失败：${(err as Error).message}`);
+    fail(`wave daemon list failed: ${(err as Error).message}`);
   } finally {
     await client?.dispose();
   }
@@ -226,14 +227,18 @@ export async function daemonStatusCommand(
     };
 
     const status =
-      pending.length > 0 ? "等待审批" : loading ? "生成中" : "空闲";
-    console.log(`会话: ${initId}`);
-    console.log(`工作目录: ${init.workingDirectory}`);
-    console.log(`状态: ${status}`);
+      pending.length > 0
+        ? "waiting for approval"
+        : loading
+          ? "generating"
+          : "idle";
+    console.log(`Session: ${initId}`);
+    console.log(`Working directory: ${init.workingDirectory}`);
+    console.log(`Status: ${status}`);
 
     if (pending.length > 0) {
       console.log("");
-      console.log("待审批请求:");
+      console.log("Pending approval requests:");
       for (const r of pending) {
         const params = summarizeToolInput(r.context);
         console.log(
@@ -245,7 +250,7 @@ export async function daemonStatusCommand(
     const recent = messages.messages.slice(-lines);
     if (recent.length > 0) {
       console.log("");
-      console.log(`最近消息 (${recent.length}):`);
+      console.log(`Recent messages (${recent.length}):`);
       for (const m of recent) {
         const text = getMessageContent(m).replace(/\s+/g, " ").trim();
         if (!text) continue; // tool-only messages carry no readable text
@@ -253,7 +258,7 @@ export async function daemonStatusCommand(
       }
     }
   } catch (err) {
-    fail(`wave daemon status 失败：${(err as Error).message}`);
+    fail(`wave daemon status failed: ${(err as Error).message}`);
   } finally {
     await client?.dispose();
   }
@@ -311,7 +316,7 @@ export async function daemonSendCommand(
     await client.request("sendMessage", { text: message }, initId);
   } catch (err) {
     client.dispose();
-    fail(`wave daemon send 失败：${(err as Error).message}`);
+    fail(`wave daemon send failed: ${(err as Error).message}`);
   }
 
   // Wait for the reply that corresponds to our message.
@@ -327,13 +332,13 @@ export async function daemonSendCommand(
       client.dispose();
       if (pending.length > 0) {
         fail(
-          `会话等待权限审批，请通过 \`wave daemon respond ${sessionId} ${pending[0].requestId}\` 处理后重试`,
+          `Session is waiting for permission approval; handle it with \`wave daemon respond ${sessionId} ${pending[0].requestId}\` and retry`,
         );
       }
       fail(
         options.timeout === 0
-          ? "等待回复超时"
-          : `等待回复超时（${options.timeout} 秒），未收到助手回复`,
+          ? "Timed out waiting for a reply"
+          : `Timed out waiting for a reply (${options.timeout}s), no assistant reply received`,
       );
     }
     await sleep(200);
@@ -351,7 +356,7 @@ export async function daemonSendCommand(
       if (content) console.log(content);
     }
   } catch (err) {
-    fail(`wave daemon send 失败：${(err as Error).message}`);
+    fail(`wave daemon send failed: ${(err as Error).message}`);
   } finally {
     client.dispose();
   }
@@ -376,7 +381,7 @@ export async function daemonRespondCommand(
   options: RespondOptions,
 ): Promise<void> {
   if (!!options.allow === !!options.deny) {
-    fail("请指定 --allow 或 --deny（二选一）");
+    fail("Specify either --allow or --deny");
   }
   let client: SocketClient | undefined;
   try {
@@ -387,11 +392,11 @@ export async function daemonRespondCommand(
     const pending = await listPendingPermissions(client);
     const req = pending.find((r) => r.requestId === requestId);
     if (!req) {
-      fail("该请求不存在或已处理");
+      fail("Request not found or already handled");
     }
     if (req.sessionId && req.sessionId !== sessionId) {
       // Cross-check before notifying; never touch another session's request.
-      fail("会话不存在或未被该 daemon 托管");
+      fail("Session not found or not hosted by this daemon");
     }
 
     let decision: PermissionDecision;
@@ -407,13 +412,15 @@ export async function daemonRespondCommand(
         decision = { behavior: "allow", newPermissionMode: "default" };
       } else if (toolName === ASK_USER_QUESTION_TOOL_NAME) {
         if (!options.answer) {
-          fail("AskUserQuestion 请求需要 --answer 提供答案 JSON");
+          fail(
+            "AskUserQuestion requests require --answer with the answer JSON",
+          );
         }
         let answers: unknown;
         try {
           answers = JSON.parse(options.answer);
         } catch {
-          fail("--answer 不是合法的 JSON");
+          fail("--answer is not valid JSON");
         }
         decision = { behavior: "allow", message: JSON.stringify(answers) };
       } else {
@@ -424,7 +431,7 @@ export async function daemonRespondCommand(
       if (options.mode) {
         if (!PERMISSION_MODES.includes(options.mode as PermissionMode)) {
           fail(
-            `无效的权限模式：${options.mode}（可选：${PERMISSION_MODES.join("、")}）`,
+            `Invalid permission mode: ${options.mode} (options: ${PERMISSION_MODES.join(", ")})`,
           );
         }
         decision.newPermissionMode = options.mode as PermissionMode;
@@ -434,9 +441,32 @@ export async function daemonRespondCommand(
     // Mirror desktop stdioAgent.sendPermissionResponse: envelope sessionId
     // present, decision built from the pending request's tool.
     client.notify("permissionResponse", { requestId, decision }, sessionId);
-    console.log(`已处理审批请求：${requestId}`);
+    console.log(`Handled approval request: ${requestId}`);
+  } catch (err) {
+    fail(`wave daemon respond failed: ${(err as Error).message}`);
+  } finally {
+    await client?.dispose();
+  }
+  process.exit(0);
+}
+
+// ── abort ─────────────────────────────────────────────────────
+
+export async function daemonAbortCommand(
+  socketPath: string,
+  sessionId: string,
+): Promise<void> {
+  let client: SocketClient | undefined;
+  try {
+    client = await connectDaemonOrExit(socketPath);
+    const init = await attachSession(client, sessionId);
+    // abortMessage is idempotent: a no-op on idle sessions, interrupts
+    // in-flight generation (incl. subagents / bash / slash / queued messages)
+    // otherwise (spec: 中断幂等，无需先确认是否正在生成).
+    await client.request("abortMessage", undefined, init.sessionId);
+    console.log(`Aborted session: ${sessionId}`);
   } catch (err) {
-    fail(`wave daemon respond 失败：${(err as Error).message}`);
+    fail(`wave daemon abort failed: ${(err as Error).message}`);
   } finally {
     await client?.dispose();
   }

package/src/daemon/jsonRpcClient.ts

@@ -76,7 +76,7 @@ export abstract class JsonRpcClient {
   ): Promise<unknown> {
     if (this.closed) {
       throw new Error(
-        "连接已断开。wave 进程已退出，请重启编辑器或检查 CLI 安装。",
+        "Connection closed. The wave process has exited; restart the editor or check your CLI installation.",
       );
     }
     const id = this.nextId++;

package/src/daemon/socketClient.ts

@@ -16,7 +16,7 @@ export class SocketClient extends JsonRpcClient {
     this.attachReadable(socket);
 
     socket.on("close", () => {
-      this.handleClosed("远端连接已断开。");
+      this.handleClosed("Remote connection closed.");
     });
     socket.on("error", (err) => {
       console.error("[wave-daemon] Socket error:", err.message);
@@ -28,7 +28,7 @@ export class SocketClient extends JsonRpcClient {
   }
 
   dispose(): void {
-    this.handleClosed("远端连接已断开。");
+    this.handleClosed("Remote connection closed.");
     this.socket.destroy();
   }
 }

package/src/hooks/useInputManager.ts

@@ -157,7 +157,7 @@ export const useInputManager = (
                   // Stream partial answers into the overlay so the user sees
                   // the response grow in real time (same visual language as
                   // assistant text / thinking blocks) instead of a static
-                  // "Answering..." indicator.
+                  // "Answering" indicator.
                   if (!btwDismissedRef.current) {
                     dispatch({
                       type: "SET_BTW_STATE",

package/src/index.ts

@@ -9,13 +9,9 @@ import {
 } from "wave-agent-sdk";
 import { createWorktree, type WorktreeSession } from "./utils/worktree.js";
 import path from "path";
-import { readFileSync } from "fs";
-import { fileURLToPath } from "url";
+import { readNearestPackageJson } from "./utils/readPackageJson.js";
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const packageJsonPath = path.resolve(__dirname, "../package.json");
-const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-const version = packageJson.version;
+const version = readNearestPackageJson().version;
 
 // Export main function for external use
 export async function main() {
@@ -379,6 +375,24 @@ export async function main() {
                 );
               },
             )
+            .command(
+              "abort <sessionId>",
+              "Abort the session's in-flight message generation",
+              (yargs) => {
+                return yargs.positional("sessionId", {
+                  describe: "Session ID hosted by the daemon",
+                  type: "string",
+                });
+              },
+              async (argv) => {
+                const { daemonAbortCommand, DEFAULT_DAEMON_SOCKET } =
+                  await import("./daemon/commands.js");
+                await daemonAbortCommand(
+                  DEFAULT_DAEMON_SOCKET,
+                  argv.sessionId as string,
+                );
+              },
+            )
             .demandCommand(1, "Please specify a daemon subcommand");
         },
       )
@@ -497,13 +511,29 @@ export async function main() {
       const { startSessionSelectorCli } = await import(
         "./session-selector-cli.js"
       );
-      const selectedSessionId = await startSessionSelectorCli({ workdir });
-      if (!selectedSessionId) {
+      const { listWorktrees } = await import("./utils/worktree.js");
+      const worktreePaths = await listWorktrees(process.cwd());
+      const selection = await startSessionSelectorCli({
+        workdir,
+        worktreePaths,
+      });
+      if (!selection) {
         return;
       }
+
+      // Resume a session from a sibling worktree of the same repo — chdir into
+      // that worktree so the agent's workdir matches the session's origin
+      // (mirrors Claude Code's worktree resume; projectRoot is not set, so
+      // skills/history stay anchored to the original project).
+      let resumeWorkdir = workdir;
+      if (selection.resumeWorkdir) {
+        resumeWorkdir = selection.resumeWorkdir;
+        process.chdir(resumeWorkdir);
+      }
+
       // Continue with the selected session
       return startCli({
-        restoreSessionId: selectedSessionId,
+        restoreSessionId: selection.sessionId,
         bypassPermissions: argv.dangerouslySkipPermissions as boolean,
         permissionMode: argv.permissionMode as PermissionMode | undefined,
         pluginDirs,
@@ -512,7 +542,7 @@ export async function main() {
         allowedTools,
         disallowedTools,
         worktreeSession,
-        workdir,
+        workdir: resumeWorkdir,
         originalCwd,
         version,
         model: argv.model as string | undefined,
@@ -520,6 +550,23 @@ export async function main() {
       });
     }
 
+    // Validate an explicitly-specified restore ID before entering the CLI —
+    // loadSessionFromJsonl scans every project dir as a fallback, so a miss
+    // here means the session truly does not exist. Fail fast with a clear
+    // error instead of silently starting a fresh session.
+    if (
+      typeof argv.restore === "string" &&
+      argv.restore !== "" &&
+      !argv.print
+    ) {
+      const { loadSessionFromJsonl } = await import("wave-agent-sdk");
+      const exists = await loadSessionFromJsonl(argv.restore, workdir);
+      if (!exists) {
+        console.error(`Session ${argv.restore} not found on disk.`);
+        process.exit(1);
+      }
+    }
+
     // Handle print mode directly
     if (argv.print !== undefined) {
       const { startPrintCli } = await import("./print-cli.js");