wave-code 1.1.3 → 1.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-code",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "CLI-based code assistant powered by AI, built with React and Ink",
   "repository": {
     "type": "git",
@@ -56,7 +56,7 @@
     "wrap-ansi": "^10.0.0",
     "yargs": "^17.7.2",
     "zod": "^3.23.8",
-    "wave-agent-sdk": "1.1.3"
+    "wave-agent-sdk": "1.1.4"
   },
   "engines": {
     "node": ">=22"
@@ -71,7 +71,7 @@
     "test:unit": "vitest run --reporter=dot --exclude 'tests/integration/**' --exclude '**/*.integration.test.ts'",
     "test:unit:coverage": "vitest run --coverage --reporter=dot --exclude 'tests/integration/**' --exclude '**/*.integration.test.ts'",
     "test:integration": "vitest run --reporter=dot tests/integration .integration.test",
-    "lint": "eslint --cache",
+    "lint": "oxlint",
     "format": "prettier --write ."
   }
 }

package/src/commands/update.ts

@@ -1,4 +1,4 @@
-import { spawnSync } from "child_process";
+import { spawn, spawnSync } from "child_process";
 import https from "https";
 import chalk from "chalk";
 import { isUpdateAvailable } from "../utils/version.js";
@@ -83,6 +83,25 @@ export async function updateCommand() {
     console.log(chalk.blue(`Updating WAVE Code using ${packageManager}...`));
     console.log(chalk.dim(`Running: ${updateCmd} ${args.join(" ")}`));
 
+    if (process.platform === "win32") {
+      // On Windows the running `wave` process keeps the global bin shims
+      // (e.g. %APPDATA%\npm\wave.cmd) locked, so npm cannot overwrite them
+      // while we are still alive. Exit first and let a detached child process
+      // perform the install after a short delay.
+      console.log(
+        chalk.yellow(
+          "The update will finish in the background. Close and reopen wave afterwards.",
+        ),
+      );
+      const child = spawn(
+        "cmd.exe",
+        ["/c", `timeout /t 2 /nobreak >nul & ${updateCmd} ${args.join(" ")}`],
+        { detached: true, stdio: "ignore", windowsHide: true },
+      );
+      child.unref();
+      process.exit(0);
+    }
+
     const result = spawnSync(updateCmd, args, { stdio: "inherit" });
 
     if (result.status === 0) {
@@ -95,13 +114,11 @@ export async function updateCommand() {
           `Please try running the update command manually: ${updateCmd} ${args.join(" ")}`,
         ),
       );
-      if (process.platform !== "win32") {
-        console.log(
-          chalk.yellow(
-            "You might need to run it with sudo if you encounter permission issues.",
-          ),
-        );
-      }
+      console.log(
+        chalk.yellow(
+          "You might need to run it with sudo if you encounter permission issues.",
+        ),
+      );
       process.exit(1);
     }
   } catch (error) {

package/src/components/HelpView.tsx

@@ -72,7 +72,12 @@ export const HelpView: React.FC<HelpViewProps> = ({
     { key: "Ctrl+O", description: "Expand/collapse messages" },
     { key: "Ctrl+T", description: "Toggle task list" },
     { key: "Ctrl+B", description: "Background current task" },
-    { key: "Ctrl+V", description: "Paste image" },
+    // Windows terminals reserve Ctrl+V for system paste (it never reaches the
+    // app), so image paste is Alt+V there — same split as Claude Code.
+    {
+      key: process.platform === "win32" ? "Alt+V" : "Ctrl+V",
+      description: "Paste image",
+    },
     { key: "Ctrl+J", description: "Newline" },
     { key: "Ctrl+A", description: "Cursor to line start" },
     { key: "Ctrl+E", description: "Cursor to line end" },

package/src/index.ts

@@ -9,6 +9,7 @@ import {
 } from "wave-agent-sdk";
 import { createWorktree, type WorktreeSession } from "./utils/worktree.js";
 import path from "path";
+import { pathToFileURL } from "url";
 import { readNearestPackageJson } from "./utils/readPackageJson.js";
 
 const version = readNearestPackageJson().version;
@@ -642,8 +643,15 @@ export {
   type ClipboardImageResult,
 } from "./utils/clipboard.js";
 
-// Execute main function if this file is run directly
-if (import.meta.url === `file://${process.argv[1]}`) {
+// Execute main function if this file is run directly. Compare via
+// pathToFileURL: on Windows process.argv[1] keeps backslashes while
+// import.meta.url is a forward-slash file:// URL, so a naive string
+// concatenation never matches and main() silently never runs.
+const entryFile = process.argv[1];
+if (
+  entryFile &&
+  pathToFileURL(path.resolve(entryFile)).href === import.meta.url
+) {
   main().catch((error) => {
     console.error("Failed to start WAVE Code:", error);
     process.exit(1);

package/src/managers/inputHandlers.ts

@@ -5,6 +5,7 @@ import {
   InputState,
   InputAction,
   InputManagerCallbacks,
+  isPasteImageKey,
 } from "./inputReducer.js";
 
 export const expandLongTextPlaceholders = (
@@ -677,7 +678,7 @@ export const handleNormalInput = async (
     return true;
   }
 
-  if (key.ctrl && input === "v") {
+  if (isPasteImageKey(key, input)) {
     handlePasteImage(dispatch).catch((error) => {
       console.warn("Failed to handle paste image:", error);
     });

package/src/managers/inputReducer.ts

@@ -37,6 +37,15 @@ export const btwOverlayActiveRef: { current: boolean } = { current: false };
 
 export const ESC_DOUBLE_PRESS_TIMEOUT_MS = 1000;
 
+/**
+ * Paste-image shortcut: Ctrl+V everywhere, plus Alt+V on Windows — Windows
+ * terminals reserve Ctrl+V for their own system paste, so the key never
+ * reaches the app (same platform split as Claude Code). Ink reports Alt+V
+ * as meta.
+ */
+export const isPasteImageKey = (key: Key, input: string): boolean =>
+  (key.ctrl || (process.platform === "win32" && key.meta)) && input === "v";
+
 export type PendingEffect =
   | {
       type: "SEND_MESSAGE";
@@ -1121,7 +1130,7 @@ export function inputReducer(
         };
       }
 
-      if (key.ctrl && input === "v") {
+      if (isPasteImageKey(key, input)) {
         return { ...state, pendingEffect: { type: "PASTE_IMAGE" } };
       }
 

package/src/stdio/agentBridge.ts

@@ -739,7 +739,26 @@ export class AgentBridge {
         this.canUseTool(context, ctx),
     };
 
-    const agent = await Agent.create(options);
+    let agent: Agent;
+    try {
+      agent = await Agent.create(options);
+    } catch (createError) {
+      // The old entry was already destroyed and removed above. If the session
+      // file is missing or unrecoverable (fresh session, cleared chat, or a
+      // never-persisted empty session), fail soft: recreate WITHOUT
+      // restoreSessionId so this session slot keeps working. Without this the
+      // client's sessionId still points at the destroyed entry and every later
+      // request fails with "Session not found" until the window is reloaded.
+      // Non-session errors (bad baseURL/apiKey/config) must surface unchanged.
+      if (!options.restoreSessionId || !isSessionRecoveryError(createError)) {
+        throw createError;
+      }
+      logger?.warn(
+        `updateConfig: failed to restore session ${currentSessionId}, recreating as a fresh session:`,
+        createError,
+      );
+      agent = await Agent.create({ ...options, restoreSessionId: undefined });
+    }
     ctx.agent = agent;
     ctx.registeredSessionId = agent.sessionId;
     this.sessions.set(agent.sessionId, {
@@ -1623,3 +1642,17 @@ export class RpcError extends Error {
     return { code: this.code, message: this.message };
   }
 }
+
+/**
+ * True when the error means the restoreSessionId session cannot be recovered
+ * from disk (missing file, corrupt transcript, etc.) — the recovery actions in
+ * updateConfig/restoreSession degrade to a fresh session for these. Anything
+ * else (config validation, plugin load, …) must surface to the client.
+ */
+function isSessionRecoveryError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  return (
+    message.includes("not found on disk") ||
+    message.startsWith("Session not found:")
+  );
+}

package/src/utils/clipboard.ts

@@ -140,30 +140,50 @@ async function readClipboardImageMac(): Promise<ClipboardImageResult> {
   }
 }
 
+/**
+ * Run a PowerShell script via execFile (no cmd shell), returning stdout.
+ *
+ * The script must be passed as a single argv element: routing
+ * `powershell -Command "<script>"` through exec() / cmd /c mangles the
+ * nested double quotes (cmd strips them), so PowerShell receives garbage
+ * and exits 0 with empty output — image paste silently failed on Windows.
+ */
+async function runPowerShellScript(script: string): Promise<string> {
+  const { execFile } = await import("child_process");
+  const { promisify } = await import("util");
+  const execFileAsync = promisify(execFile);
+  const { stdout } = await execFileAsync("powershell.exe", [
+    "-NoProfile",
+    "-Command",
+    script,
+  ]);
+  return stdout;
+}
+
+// Check script shared by the two Windows clipboard functions. Get-Clipboard
+// is PowerShell 5.1's built-in cmdlet (same as Claude Code): no WinForms/STA
+// ceremony, returns a System.Drawing.Image directly.
+const CLIPBOARD_IMAGE_CHECK_SCRIPT = `
+  $image = Get-Clipboard -Format Image -ErrorAction SilentlyContinue
+  if ($null -ne $image) {
+    Write-Output "true"
+  } else {
+    Write-Output "false"
+  }
+`;
+
+async function hasPowerShellClipboardImage(): Promise<boolean> {
+  const stdout = await runPowerShellScript(CLIPBOARD_IMAGE_CHECK_SCRIPT);
+  return stdout.trim() === "true";
+}
+
 /**
  * Read clipboard image on Windows
  */
 async function readClipboardImageWindows(): Promise<ClipboardImageResult> {
   try {
-    const { exec } = await import("child_process");
-    const { promisify } = await import("util");
-    const execAsync = promisify(exec);
-
-    // Use PowerShell to check if clipboard contains image
-    const checkScript = `
-      Add-Type -AssemblyName System.Windows.Forms
-      if ([System.Windows.Forms.Clipboard]::ContainsImage()) {
-        Write-Output "true"
-      } else {
-        Write-Output "false"
-      }
-    `;
-
     try {
-      const { stdout } = await execAsync(
-        `powershell -Command "${checkScript}"`,
-      );
-      const hasImage = stdout.trim() === "true";
+      const hasImage = await hasPowerShellClipboardImage();
 
       if (!hasImage) {
         return {
@@ -175,22 +195,20 @@ async function readClipboardImageWindows(): Promise<ClipboardImageResult> {
       // Generate temporary file path
       const tempFilePath = join(tmpdir(), `clipboard-image-${Date.now()}.png`);
 
-      // Use PowerShell to save clipboard image
+      // Save the clipboard image via PowerShell (single-quoted path; a single
+      // quote in the path is escaped by doubling it). Keeps its own preamble
+      // because it needs the $image variable.
       const saveScript = `
-        Add-Type -AssemblyName System.Windows.Forms
-        Add-Type -AssemblyName System.Drawing
-        $image = [System.Windows.Forms.Clipboard]::GetImage()
-        if ($image -ne $null) {
-          $image.Save("${tempFilePath.replace(/\\/g, "\\\\")}", [System.Drawing.Imaging.ImageFormat]::Png)
+        $image = Get-Clipboard -Format Image -ErrorAction SilentlyContinue
+        if ($null -ne $image) {
+          $image.Save('${tempFilePath.replace(/'/g, "''")}', [System.Drawing.Imaging.ImageFormat]::Png)
           Write-Output "true"
         } else {
           Write-Output "false"
         }
       `;
 
-      const { stdout: saveResult } = await execAsync(
-        `powershell -Command "${saveScript}"`,
-      );
+      const saveResult = await runPowerShellScript(saveScript);
 
       if (saveResult.trim() !== "true" || !existsSync(tempFilePath)) {
         return {
@@ -354,21 +372,7 @@ async function hasClipboardImageMac(): Promise<boolean> {
  */
 async function hasClipboardImageWindows(): Promise<boolean> {
   try {
-    const { exec } = await import("child_process");
-    const { promisify } = await import("util");
-    const execAsync = promisify(exec);
-
-    const checkScript = `
-      Add-Type -AssemblyName System.Windows.Forms
-      if ([System.Windows.Forms.Clipboard]::ContainsImage()) {
-        Write-Output "true"
-      } else {
-        Write-Output "false"
-      }
-    `;
-
-    const { stdout } = await execAsync(`powershell -Command "${checkScript}"`);
-    return stdout.trim() === "true";
+    return await hasPowerShellClipboardImage();
   } catch {
     return false;
   }

package/src/utils/constants.ts

@@ -12,9 +12,14 @@ import os from "os";
 export const DATA_DIRECTORY = path.join(os.homedir(), ".wave");
 
 /**
- * Application log file path
+ * Log directory — one file per surface (cli/desktop/vscode/jetbrains).
  */
-export const LOG_FILE = path.join(DATA_DIRECTORY, "app.log");
+export const LOGS_DIRECTORY = path.join(DATA_DIRECTORY, "logs");
+
+/**
+ * CLI log file path
+ */
+export const LOG_FILE = path.join(LOGS_DIRECTORY, "cli.log");
 
 /**
  * Pagination related constants

package/src/utils/highlightUtils.ts

@@ -108,6 +108,12 @@ export function highlightToAnsi(code: string, language?: string): string {
   if (!code) {
     return "";
   }
+  // hljs.highlight logs a console.error (then throws) when the language is not
+  // registered. We bundle a trimmed language set, so check first and fall back
+  // to plain text instead of spamming stderr with LANGUAGE_NOT_FOUND noise.
+  if (language && !hljs.getLanguage(language)) {
+    return code;
+  }
   try {
     const highlighted = language
       ? hljs.highlight(code, { language }).value

package/src/utils/logger.ts

@@ -9,9 +9,10 @@
  */
 
 import * as fs from "fs";
+import * as path from "path";
 import { Chalk } from "chalk";
 import { getLastLines } from "wave-agent-sdk";
-import { LOG_FILE, DATA_DIRECTORY } from "./constants.js";
+import { LOG_FILE } from "./constants.js";
 
 const chalk = new Chalk({ level: 3 });
 
@@ -166,9 +167,10 @@ const logMessage = (level: LogLevel, ...args: unknown[]): void => {
   const formattedMessage = `[${chalk.gray(timestamp)}] [${color(levelName)}] ${messageText}\n`;
 
   try {
-    // Ensure directory exists
-    if (!fs.existsSync(DATA_DIRECTORY)) {
-      fs.mkdirSync(DATA_DIRECTORY, { recursive: true });
+    // Ensure the log file's directory exists (LOG_FILE moved to ~/.wave/logs)
+    const logDir = path.dirname(logFile);
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
     }
 
     // Write log to file