wave-code 1.3.0 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-code",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "CLI-based code assistant powered by AI, built with React and Ink",
   "repository": {
     "type": "git",
@@ -29,9 +29,11 @@
   ],
   "dependencies": {
     "@vscode/ripgrep": "^1.18.0",
+    "qrcode": "^1.5.4",
     "sharp": "^0.35.4"
   },
   "devDependencies": {
+    "@types/qrcode": "^1.5.6",
     "@types/react": "^19.1.8",
     "@types/semver": "^7.7.1",
     "@types/yargs": "^17.0.0",
@@ -57,7 +59,7 @@
     "wrap-ansi": "^10.0.0",
     "yargs": "^17.7.2",
     "zod": "^3.23.8",
-    "wave-agent-sdk": "1.3.0"
+    "wave-agent-sdk": "1.4.0"
   },
   "engines": {
     "node": ">=22"

package/src/commands/update.ts

@@ -1,32 +1,70 @@
 import { spawn, spawnSync } from "child_process";
-import https from "https";
 import chalk from "chalk";
 import { isUpdateAvailable } from "../utils/version.js";
 import { readNearestPackageJson } from "../utils/readPackageJson.js";
 
 const currentVersion = readNearestPackageJson().version;
 
-async function getLatestVersion(): Promise<string> {
-  return new Promise((resolve, reject) => {
-    https
-      .get("https://registry.npmjs.org/wave-code/latest", (res) => {
-        let data = "";
-        res.on("data", (chunk) => {
-          data += chunk;
-        });
-        res.on("end", () => {
-          try {
-            const json = JSON.parse(data);
-            resolve(json.version);
-          } catch {
-            reject(new Error("Failed to parse npm registry response"));
-          }
-        });
-      })
-      .on("error", (err) => {
-        reject(err);
-      });
+/** npm registry mirror for China users (the CLI downloads its runtime deps from the same one). */
+const REGISTRY_MIRROR = "https://registry.npmmirror.com";
+/** Official registry — the fallback when the mirror is unreachable. */
+const REGISTRY_OFFICIAL = "https://registry.npmjs.org";
+/** Cap each registry request so a hanging one cannot stall the fallback. */
+const REGISTRY_TIMEOUT_MS = 5000;
+
+interface LatestVersion {
+  version: string;
+  /** The registry that answered — the install reuses it (see getLatestVersion). */
+  registry: string;
+}
+
+async function fetchLatestVersion(registry: string): Promise<string> {
+  const response = await fetch(`${registry}/wave-code/latest`, {
+    signal: AbortSignal.timeout(REGISTRY_TIMEOUT_MS),
   });
+  if (!response.ok) {
+    throw new Error(
+      `HTTP ${response.status} fetching ${registry}/wave-code/latest`,
+    );
+  }
+  const json = (await response.json()) as { version?: string };
+  if (!json.version) {
+    throw new Error(`No version in the response from ${registry}`);
+  }
+  return json.version;
+}
+
+/**
+ * The mirror answers first so the check is fast in CN; the official registry is
+ * a silent fallback so an unreachable mirror never blocks the check.
+ *
+ * The install reuses whichever registry answered: a machine that can only reach
+ * the official registry would fail the install for the very reason the check
+ * fell back.
+ */
+async function getLatestVersion(): Promise<LatestVersion> {
+  try {
+    return {
+      version: await fetchLatestVersion(REGISTRY_MIRROR),
+      registry: REGISTRY_MIRROR,
+    };
+  } catch (mirrorError) {
+    try {
+      return {
+        version: await fetchLatestVersion(REGISTRY_OFFICIAL),
+        registry: REGISTRY_OFFICIAL,
+      };
+    } catch (officialError) {
+      throw new Error(
+        `Could not reach ${REGISTRY_MIRROR} (${errorText(mirrorError)}) ` +
+          `or ${REGISTRY_OFFICIAL} (${errorText(officialError)})`,
+      );
+    }
+  }
+}
+
+function errorText(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
 }
 
 function detectPackageManager(): "npm" | "pnpm" | "yarn" {
@@ -53,7 +91,7 @@ export async function updateCommand() {
   console.log(chalk.dim(`Current version: ${currentVersion}`));
 
   try {
-    const latestVersion = await getLatestVersion();
+    const { version: latestVersion, registry } = await getLatestVersion();
     console.log(chalk.dim(`Latest version: ${latestVersion}`));
 
     if (!isUpdateAvailable(currentVersion, latestVersion)) {
@@ -79,6 +117,8 @@ export async function updateCommand() {
       updateCmd = "npm";
       args = ["install", "-g", "wave-code@latest"];
     }
+    // Appended once so every package manager (including a future branch) gets it.
+    args.push(`--registry=${registry}`);
 
     console.log(chalk.blue(`Updating WAVE Code using ${packageManager}...`));
     console.log(chalk.dim(`Running: ${updateCmd} ${args.join(" ")}`));

package/src/components/BackgroundTaskManager.tsx

@@ -6,6 +6,10 @@ import {
   backgroundTaskManagerReducer,
   type BackgroundTaskManagerState,
 } from "../reducers/backgroundTaskManagerReducer.js";
+import WorkflowRunDetail, {
+  formatDuration,
+  formatTime,
+} from "./WorkflowRunDetail.js";
 
 export interface BackgroundTaskManagerProps {
   onCancel: () => void;
@@ -14,8 +18,12 @@ export interface BackgroundTaskManagerProps {
 export const BackgroundTaskManager: React.FC<BackgroundTaskManagerProps> = ({
   onCancel,
 }) => {
-  const { backgroundTasks, getBackgroundTaskOutput, stopBackgroundTask } =
-    useChat();
+  const {
+    backgroundTasks,
+    workflowRuns,
+    getBackgroundTaskOutput,
+    stopBackgroundTask,
+  } = useChat();
   const MAX_VISIBLE_ITEMS = 3;
 
   const [state, dispatch] = useReducer(backgroundTaskManagerReducer, {
@@ -71,18 +79,6 @@ export const BackgroundTaskManager: React.FC<BackgroundTaskManagerProps> = ({
     }
   }, [viewMode, detailTaskId, getBackgroundTaskOutput]);
 
-  const formatDuration = (ms: number): string => {
-    if (ms < 1000) return `${ms}ms`;
-    if (ms < 60000) return `${Math.round(ms / 1000)}s`;
-    const minutes = Math.floor(ms / 60000);
-    const seconds = Math.round((ms % 60000) / 1000);
-    return `${minutes}m ${seconds}s`;
-  };
-
-  const formatTime = (timestamp: number): string => {
-    return new Date(timestamp).toLocaleTimeString();
-  };
-
   // Calculate visible window
   const startIndex = Math.max(
     0,
@@ -104,6 +100,15 @@ export const BackgroundTaskManager: React.FC<BackgroundTaskManagerProps> = ({
       return null;
     }
 
+    // A workflow background task's id IS its run id, so a workflow task can show
+    // real progress instead of the (always empty) text output: the same run
+    // fields `/workflows` shows, via the same component. Absent run (e.g. the
+    // session was cleared) falls back to the plain task detail below.
+    const selectedRun =
+      task.type === "workflow"
+        ? (workflowRuns.find((r) => r.runId === task.id) ?? null)
+        : null;
+
     return (
       <Box
         flexDirection="column"
@@ -134,53 +139,70 @@ export const BackgroundTaskManager: React.FC<BackgroundTaskManagerProps> = ({
               </Text>
             </Box>
           )}
-          <Box>
-            <Text>
-              <Text color="blue">Status:</Text> {task.status}
-              {task.exitCode !== undefined && ` (exit code: ${task.exitCode})`}
-            </Text>
-          </Box>
-          <Box>
-            <Text>
-              <Text color="blue">Started:</Text> {formatTime(task.startTime)}
-              {task.runtime !== undefined && (
+          {/* With the run block below, the task's own status and start time
+              would repeat it — the run is the authority on how far the
+              workflow got. The header keeps only what identifies the task. */}
+          {!selectedRun && (
+            <>
+              <Box>
                 <Text>
-                  {" "}
-                  | <Text color="blue">Runtime:</Text>{" "}
-                  {formatDuration(task.runtime)}
+                  <Text color="blue">Status:</Text> {task.status}
+                  {task.exitCode !== undefined &&
+                    ` (exit code: ${task.exitCode})`}
+                </Text>
+              </Box>
+              <Box>
+                <Text>
+                  <Text color="blue">Started:</Text>{" "}
+                  {formatTime(task.startTime)}
+                  {task.runtime !== undefined && (
+                    <Text>
+                      {" "}
+                      | <Text color="blue">Runtime:</Text>{" "}
+                      {formatDuration(task.runtime)}
+                    </Text>
+                  )}
                 </Text>
+              </Box>
+              {task.outputPath && (
+                <Box>
+                  <Text>
+                    <Text color="blue">Log File:</Text> {task.outputPath}
+                  </Text>
+                </Box>
               )}
-            </Text>
-          </Box>
-          {task.outputPath && (
-            <Box>
-              <Text>
-                <Text color="blue">Log File:</Text> {task.outputPath}
-              </Text>
-            </Box>
+            </>
           )}
         </Box>
 
-        {detailOutput.stdout && (
-          <Box flexDirection="column" marginTop={1}>
-            <Text color="green" bold>
-              OUTPUT (last 10 lines):
-            </Text>
-            <Box borderStyle="single" borderColor="green" padding={1}>
-              <Text>{getLastLines(detailOutput.stdout, 10)}</Text>
-            </Box>
-          </Box>
-        )}
+        {selectedRun ? (
+          <WorkflowRunDetail run={selectedRun} />
+        ) : (
+          <>
+            {detailOutput.stdout && (
+              <Box flexDirection="column" marginTop={1}>
+                <Text color="green" bold>
+                  OUTPUT (last 10 lines):
+                </Text>
+                <Box borderStyle="single" borderColor="green" padding={1}>
+                  <Text>{getLastLines(detailOutput.stdout, 10)}</Text>
+                </Box>
+              </Box>
+            )}
 
-        {detailOutput.stderr && (
-          <Box flexDirection="column" marginTop={1}>
-            <Text color="red" bold>
-              ERRORS:
-            </Text>
-            <Box borderStyle="single" borderColor="red" padding={1}>
-              <Text color="red">{getLastLines(detailOutput.stderr, 10)}</Text>
-            </Box>
-          </Box>
+            {detailOutput.stderr && (
+              <Box flexDirection="column" marginTop={1}>
+                <Text color="red" bold>
+                  ERRORS:
+                </Text>
+                <Box borderStyle="single" borderColor="red" padding={1}>
+                  <Text color="red">
+                    {getLastLines(detailOutput.stderr, 10)}
+                  </Text>
+                </Box>
+              </Box>
+            )}
+          </>
         )}
 
         <Box marginTop={1}>

package/src/components/ConfirmationDetails.tsx

@@ -37,10 +37,24 @@ const getActionDescription = (
     case ASK_USER_QUESTION_TOOL_NAME:
       return "Answer questions to clarify intent";
     case ARTIFACT_TOOL_NAME:
-      if (toolInput.action === "read") {
-        return `Read artifact: ${toolInput.url || "unknown artifact"}`;
+      switch (toolInput.action) {
+        case "list":
+          return `List artifacts (scope: ${toolInput.scope || "mine"})`;
+        case "upload_asset":
+          return `Upload asset: ${toolInput.file_path || "unknown file"}`;
+        case "list_assets":
+          return `List assets of artifact: ${toolInput.url || "unknown artifact"}`;
+        case "read_asset":
+          return `Read asset: ${toolInput.asset_id || "unknown asset"}`;
+        case "delete_asset":
+          return `Delete asset: ${toolInput.asset_id || "unknown asset"}`;
+        case "copy_from":
+          return `Copy assets into artifact: ${toolInput.url || "unknown artifact"}`;
+        case "read":
+          return `Read artifact: ${toolInput.url || "unknown artifact"}`;
+        default:
+          return `Publish file: ${toolInput.file_path || "unknown file"}`;
       }
-      return `Publish file: ${toolInput.file_path || "unknown file"}`;
     default:
       return "Execute operation";
   }

package/src/components/InputBox.tsx

@@ -98,6 +98,7 @@ export const InputBox: React.FC<InputBoxProps> = ({
     compact,
     addDir,
     renameSession,
+    remoteControlCommand,
     currentModel,
     configuredModels,
     setModel,
@@ -201,6 +202,7 @@ export const InputBox: React.FC<InputBoxProps> = ({
     onReloadPlugins: reloadPlugins,
     onAddDir: addDir,
     onRenameSession: renameSession,
+    onRemoteControlCommand: remoteControlCommand,
     onHasSlashCommand: hasSlashCommand,
     onAbortMessage: abortMessage,
     onBackgroundCurrentTask: backgroundCurrentTask,

package/src/components/MessageBlockItem.tsx

@@ -1,7 +1,6 @@
 import React from "react";
 import { Box, Text } from "ink";
 import type { Message, MessageBlock } from "wave-agent-sdk";
-import { MessageSource } from "wave-agent-sdk";
 import { ToolDisplay } from "./ToolDisplay.js";
 import { CompactDisplay } from "./CompactDisplay.js";
 import { ReasoningDisplay } from "./ReasoningDisplay.js";
@@ -25,11 +24,6 @@ export const MessageBlockItem = ({
     <Box flexDirection="column" paddingTop={paddingTop}>
       {block.type === "text" && block.content.trim() && (
         <Box>
-          {block.source === MessageSource.HOOK && (
-            <Text color="magenta" bold>
-              ~{" "}
-            </Text>
-          )}
           {message.role === "user" || isExpanded ? (
             <Text
               backgroundColor={message.role === "user" ? "gray" : undefined}

package/src/components/WorkflowManager.tsx

@@ -1,49 +1,20 @@
 import React, { useEffect, useReducer } from "react";
 import { Box, Text, useInput } from "ink";
 import { useChat } from "../contexts/useChat.js";
-import type { WorkflowRun } from "wave-agent-sdk";
 import {
   workflowManagerReducer,
   type WorkflowManagerState,
 } from "../reducers/workflowManagerReducer.js";
+import WorkflowRunDetail, {
+  formatDuration,
+  formatTokens,
+  workflowStatusColor,
+} from "./WorkflowRunDetail.js";
 
 export interface WorkflowManagerProps {
   onCancel: () => void;
 }
 
-const statusColor = (
-  status: WorkflowRun["status"],
-): "green" | "blue" | "red" | "yellow" => {
-  switch (status) {
-    case "running":
-      return "green";
-    case "completed":
-      return "blue";
-    case "failed":
-    case "aborted":
-      return "red";
-    case "paused":
-      return "yellow";
-  }
-};
-
-const formatDuration = (ms: number): string => {
-  if (ms < 1000) return `${ms}ms`;
-  if (ms < 60000) return `${Math.round(ms / 1000)}s`;
-  const minutes = Math.floor(ms / 60000);
-  const seconds = Math.round((ms % 60000) / 1000);
-  return `${minutes}m ${seconds}s`;
-};
-
-const formatTime = (timestamp: number): string => {
-  return new Date(timestamp).toLocaleTimeString();
-};
-
-const formatTokens = (tokens: number): string => {
-  if (tokens < 1000) return `${tokens}`;
-  return `${(tokens / 1000).toFixed(1)}k`;
-};
-
 export const WorkflowManager: React.FC<WorkflowManagerProps> = ({
   onCancel,
 }) => {
@@ -94,10 +65,6 @@ export const WorkflowManager: React.FC<WorkflowManagerProps> = ({
       return null;
     }
 
-    const elapsed = run.endTime
-      ? run.endTime - run.startTime
-      : Date.now() - run.startTime;
-
     return (
       <Box
         flexDirection="column"
@@ -115,75 +82,7 @@ export const WorkflowManager: React.FC<WorkflowManagerProps> = ({
           </Text>
         </Box>
 
-        <Box flexDirection="column" gap={0}>
-          <Box>
-            <Text>
-              <Text color="blue">Run ID:</Text> {run.runId}
-            </Text>
-          </Box>
-          {run.meta.description && (
-            <Box>
-              <Text>
-                <Text color="blue">Description:</Text> {run.meta.description}
-              </Text>
-            </Box>
-          )}
-          <Box>
-            <Text>
-              <Text color="blue">Status:</Text>{" "}
-              <Text color={statusColor(run.status)}>{run.status}</Text>
-            </Text>
-          </Box>
-          <Box>
-            <Text>
-              <Text color="blue">Started:</Text> {formatTime(run.startTime)}
-              {run.endTime && (
-                <Text>
-                  {" "}
-                  | <Text color="blue">Ended:</Text> {formatTime(run.endTime)}
-                </Text>
-              )}
-              {" | "}
-              <Text color="blue">Duration:</Text> {formatDuration(elapsed)}
-            </Text>
-          </Box>
-          <Box>
-            <Text>
-              <Text color="blue">Agents:</Text> {run.totalAgents} {" | "}
-              <Text color="blue">Tokens:</Text> {formatTokens(run.totalTokens)}
-            </Text>
-          </Box>
-          <Box>
-            <Text>
-              <Text color="blue">Script:</Text> {run.scriptPath}
-            </Text>
-          </Box>
-          {run.error && (
-            <Box>
-              <Text color="red">
-                <Text color="blue">Error:</Text> {run.error}
-              </Text>
-            </Box>
-          )}
-        </Box>
-
-        {run.phases.length > 0 && (
-          <Box flexDirection="column" marginTop={1}>
-            <Text color="cyan" bold>
-              Phases:
-            </Text>
-            {run.phases.map((phase, i) => (
-              <Box key={i} marginLeft={2}>
-                <Text>
-                  <Text color="blue">{phase.title}</Text>
-                  {" — "}
-                  {phase.agentCount} agents | {formatTokens(phase.tokens)}{" "}
-                  tokens | {formatDuration(phase.elapsed)}
-                </Text>
-              </Box>
-            ))}
-          </Box>
-        )}
+        <WorkflowRunDetail run={run} />
 
         <Box marginTop={1}>
           <Text dimColor>
@@ -225,6 +124,17 @@ export const WorkflowManager: React.FC<WorkflowManagerProps> = ({
   );
   const visibleRuns = runs.slice(startIndex, startIndex + MAX_VISIBLE_ITEMS);
 
+  // Header counts of the states a user acts on (a failed run is plain to see in
+  // its own row, so it needs no tally).
+  const runningCount = runs.filter((r) => r.status === "running").length;
+  const completedCount = runs.filter((r) => r.status === "completed").length;
+  const subtitle = [
+    runningCount > 0 ? `${runningCount} running` : "",
+    completedCount > 0 ? `${completedCount} completed` : "",
+  ]
+    .filter(Boolean)
+    .join(" · ");
+
   return (
     <Box
       flexDirection="column"
@@ -240,6 +150,7 @@ export const WorkflowManager: React.FC<WorkflowManagerProps> = ({
         <Text color="cyan" bold>
           Workflows
         </Text>
+        {subtitle && <Text dimColor> {subtitle}</Text>}
       </Box>
       <Text dimColor>Select a run to view details</Text>
 
@@ -250,7 +161,15 @@ export const WorkflowManager: React.FC<WorkflowManagerProps> = ({
           const elapsed = run.endTime
             ? run.endTime - run.startTime
             : Date.now() - run.startTime;
-          const phaseText = run.phases.map((p) => p.title).join(" → ");
+          // Duration always reads; the two counters are dropped at zero so an
+          // unstarted run does not claim "0 agents · 0 tokens".
+          const meta = [
+            formatDuration(elapsed),
+            run.totalAgents > 0 ? `${run.totalAgents} agents` : "",
+            run.totalTokens > 0
+              ? `${formatTokens(run.totalTokens)} tokens`
+              : "",
+          ].filter(Boolean);
 
           return (
             <Box key={run.runId} flexDirection="column">
@@ -259,43 +178,24 @@ export const WorkflowManager: React.FC<WorkflowManagerProps> = ({
                 backgroundColor={isSelected ? "cyan" : undefined}
               >
                 {isSelected ? "▶ " : "  "}
-                {actualIndex + 1}. {run.runId.slice(0, 8)} {run.meta.name}
-                <Text color={statusColor(run.status)}> ({run.status})</Text>
+                {actualIndex + 1}. {run.meta.name || run.meta.description}
+                <Text color={workflowStatusColor(run.status)}>
+                  {" "}
+                  ({run.status})
+                </Text>
+                {/* Oversized marker: the row is where a run is picked, so the
+                    "too big to leave running" signal belongs on it (spec
+                    「预算与规模硬上限」场景 7). The counts are on the meta line
+                    right below, and the stop key is in the footer. */}
+                {run.sizeWarning && <Text color="yellow"> ⚠ Large</Text>}
               </Text>
               <Text
                 color={isSelected ? "black" : "gray"}
                 backgroundColor={isSelected ? "cyan" : undefined}
               >
                 {"     "}
-                {run.totalAgents} agents · {formatTokens(run.totalTokens)}{" "}
-                tokens · {formatDuration(elapsed)}
+                {meta.join(" · ")}
               </Text>
-              {phaseText && (
-                <Text
-                  color={isSelected ? "black" : "gray"}
-                  backgroundColor={isSelected ? "cyan" : undefined}
-                >
-                  {"     "}
-                  {run.phases.map((p, pi) => (
-                    <React.Fragment key={pi}>
-                      {pi > 0 && " → "}
-                      <Text
-                        color={
-                          isSelected
-                            ? "black"
-                            : pi === run.phases.length - 1 &&
-                                run.status === "running"
-                              ? "green"
-                              : undefined
-                        }
-                        backgroundColor={isSelected ? "cyan" : undefined}
-                      >
-                        {p.title}
-                      </Text>
-                    </React.Fragment>
-                  ))}
-                </Text>
-              )}
               {isSelected && (
                 <Box marginLeft={4} flexDirection="column">
                   <Text color="gray" dimColor>