wave-code 1.4.0 → 1.5.0

package/src/stdio/hostSlashCommands.ts

@@ -0,0 +1,209 @@
+/**
+ * The **one** table of host-local slash commands (spec ui/slash-commands.md
+ * 「弹窗里的宿主命令只有一份表——由服务端下发并按入口过滤」).
+ *
+ * These are the commands a front end handles itself — it opens a dialog, a
+ * settings page or a panel, or it intercepts the text before it reaches the
+ * agent. They are not registered with the SDK, so they cannot come from
+ * `agent.getSlashCommands()`; before this table existed each host carried its
+ * own copy (desktop 17, VS Code 18, JetBrains 17 — differing on `/clear` and
+ * `/config` only) and the phone page carried none, which is why the same
+ * command was visible on the computer and had to be typed by hand on the phone.
+ *
+ * It lives here, next to `AgentBridge`, because that is the one place every
+ * front end already talks to: the daemon and each GUI's `--stdio` child serve
+ * the popup from it, the phone's requests land on it, and JetBrains — which
+ * cannot import TypeScript at all — reads it as JSON over the same RPC.
+ *
+ * **What each entry claims**: `surfaces` is the set of front ends that really
+ * implement it. It is a capability statement, not a label: an entry listed for
+ * a surface that has no handling behind it produces exactly the defect spec
+ * ui/remote-control.md 场景 24 forbids — a row in the popup that does nothing
+ * when picked. `hostSlashCommands.test.ts` pins each surface's set, and the
+ * remote-page set is also cross-checked there against the remote allowlist,
+ * which is the other half of the same promise (popup lists it ⇒ picking it
+ * works).
+ */
+
+import type { HostSurface, SlashCommandInfo } from "wave-agent-sdk/types";
+
+/** Which front ends a command is offered to. */
+type Surfaces = readonly HostSurface[];
+
+interface HostSlashCommandSpec {
+  id: string;
+  description: string;
+  /** Absent = insert `/name ` and let the user finish (only `/btw` today). */
+  runOnSelect?: boolean;
+  surfaces: Surfaces;
+}
+
+/** Everyone's entries — `/clear` being the one that is not quite everyone's. */
+const ALL: Surfaces = ["desktop", "vscode", "jetbrains", "remote-page"];
+
+/** The GUIs that own a settings page / marketplace / panel — not the phone. */
+const GUIS: Surfaces = ["desktop", "vscode", "jetbrains"];
+
+/**
+ * The table, in popup order. Order matters: the popup appends these after the
+ * SDK's own commands and renders them as given, so the machine also decides
+ * where a command sits. This is the order the two GUI hosts already used.
+ */
+export const HOST_SLASH_COMMANDS: readonly HostSlashCommandSpec[] = [
+  // ── 需要宿主界面的：只有桌面端与 IDE 有承载它们的页面 ──
+  {
+    id: "config",
+    description: "打开配置设置",
+    runOnSelect: true,
+    // JB 的设置页在自己的菜单里，没有这条入口；远控页没有设置页。
+    surfaces: ["desktop", "vscode"],
+  },
+  {
+    id: "plugin",
+    description: "打开插件市场",
+    runOnSelect: true,
+    surfaces: GUIS,
+  },
+  {
+    id: "reload-plugins",
+    description: "就地重载插件（不重启对话）",
+    runOnSelect: true,
+    surfaces: GUIS,
+  },
+  {
+    id: "mcp",
+    description: "打开 MCP 服务器管理",
+    runOnSelect: true,
+    surfaces: GUIS,
+  },
+
+  // ── 页面也能执行的：背后是会话内的方法，不需要编辑器与文件系统 ──
+  {
+    id: "status",
+    description: "查看当前状态",
+    runOnSelect: true,
+    surfaces: ALL,
+  },
+  {
+    id: "remote-control",
+    description: "远程控制（用手机接管本机会话）",
+    runOnSelect: true,
+    // 远控页不列它：那一页就是二维码指向的东西，给自己开一个入口是自我指涉。
+    surfaces: GUIS,
+  },
+  {
+    id: "clear",
+    description: "清除对话历史并重置会话",
+    runOnSelect: true,
+    // 桌面端整端移除了 `/clear`（2026-09-05 拍板，见 clear-command.md 与
+    // ui/remote-control.md 场景 24）。
+    surfaces: ["vscode", "jetbrains", "remote-page"],
+  },
+  {
+    id: "compact",
+    description: "手动压缩对话历史",
+    runOnSelect: true,
+    surfaces: ALL,
+  },
+  {
+    id: "tasks",
+    description: "查看后台任务",
+    runOnSelect: true,
+    surfaces: ALL,
+  },
+  {
+    id: "workflows",
+    description: "查看工作流运行",
+    runOnSelect: true,
+    surfaces: ALL,
+  },
+  {
+    id: "agents",
+    description: "查看可用 agents",
+    runOnSelect: true,
+    surfaces: GUIS,
+  },
+  {
+    id: "skills",
+    description: "查看可用技能",
+    runOnSelect: true,
+    surfaces: GUIS,
+  },
+  {
+    id: "hooks",
+    description: "查看已配置钩子",
+    runOnSelect: true,
+    surfaces: GUIS,
+  },
+  {
+    id: "rewind",
+    description: "回退到之前的用户消息",
+    runOnSelect: true,
+    surfaces: ALL,
+  },
+  // `/model` 不在这里：模型入口自 2026-10-21 起是输入卡片底栏的选择器（见 spec
+  // ui/model-selection.md），桌面 / IDE / 远控页都不再有这条命令；CLI 的 TUI 没有
+  // 底栏，因此 `/model` 只留在它自己的命令表里（packages/code 的 AVAILABLE_COMMANDS）。
+  {
+    id: "resume",
+    description: "恢复历史对话",
+    runOnSelect: true,
+    // 页面的会话列表只报进程内的活会话，磁盘历史会话在那边不渲染（场景 24）。
+    surfaces: GUIS,
+  },
+  {
+    id: "btw",
+    description: "旁路提问（不进入聊天记录）",
+    // 不标 `runOnSelect`：选中后只把 `/btw ` 插进输入框，等用户补问题
+    // （spec ui/btw-command.md）。
+    surfaces: ALL,
+  },
+  {
+    id: "plan",
+    description: "启用规划模式或查看当前方案",
+    runOnSelect: true,
+    // 页面上没有计划预览面板，计划正文渲染在 ExitPlanMode 的审批卡里。
+    surfaces: GUIS,
+  },
+];
+
+/** The table as one surface sees it, already in wire shape. */
+export function hostSlashCommandsFor(surface: HostSurface): SlashCommandInfo[] {
+  return HOST_SLASH_COMMANDS.filter((command) =>
+    command.surfaces.includes(surface),
+  ).map((command) => ({
+    id: command.id,
+    name: command.id,
+    description: command.description,
+    ...(command.runOnSelect ? { runOnSelect: true } : {}),
+  }));
+}
+
+/**
+ * An agent command as the popup's wire shape — `handler` and `immediate` do
+ * not cross the wire, and `skillSource` is kept only when it is actually set
+ * (the webview reads "has a source tag" off its presence).
+ */
+export function toSlashCommandInfo(command: {
+  id: string;
+  name: string;
+  description: string;
+  skillSource?: SlashCommandInfo["skillSource"];
+}): SlashCommandInfo {
+  return {
+    id: command.id,
+    name: command.name,
+    description: command.description,
+    ...(command.skillSource ? { skillSource: command.skillSource } : {}),
+  };
+}
+
+/** Narrow the `surface` field a caller sent, or `undefined` when absent/unknown. */
+export function parseHostSurface(value: unknown): HostSurface | undefined {
+  return value === "desktop" ||
+    value === "vscode" ||
+    value === "jetbrains" ||
+    value === "remote-page"
+    ? value
+    : undefined;
+}

package/src/stdio/uiPayload.ts

@@ -0,0 +1,65 @@
+/**
+ * Payload trimming for everything this process sends **to a UI**
+ * (docs/specs/ui/stdio-transport.md「工具图片的字节不下发 UI」).
+ *
+ * Tool images arrive as base64 on `ToolBlock.images` (Read on a picture, MCP
+ * tools returning image content). No UI renders them — the webview's only read
+ * of the field sits in a branch that never runs for a tool block, the CLI shows
+ * a count — while one screenshot can be well over a megabyte of base64, and a
+ * remote-hosted page cannot even receive a frame that large. So every message
+ * leaving this process for a host goes through here: notifications,
+ * `getMessages`, `getFullMessageThread`, and the remote relay that is fed by
+ * the same frames.
+ *
+ * **The agent's own copy is untouched.** The SDK still holds the bytes, the
+ * next request still sends them to the model, and the transcript on disk keeps
+ * them. This is a wire cut, not a memory model: stripping `images` where the
+ * SDK writes the block would break the next turn, so do not move it there.
+ *
+ * Copies are shallow and made only where the field is actually present — the
+ * common message (no images) keeps its identity and costs nothing.
+ */
+
+import type {
+  Message,
+  ToolBlock,
+  ToolBlockUpdateCallbackParams,
+} from "wave-agent-sdk";
+
+/** A message whose tool blocks carry no image bytes. */
+export function messageForUi(message: Message): Message {
+  const { blocks } = message;
+  if (!Array.isArray(blocks)) return message;
+  const trimmed = blocks.map((block) =>
+    block.type === "tool" && hasImages(block) ? withoutImages(block) : block,
+  );
+  const changed = trimmed.some((block, index) => block !== blocks[index]);
+  return changed ? { ...message, blocks: trimmed } : message;
+}
+
+/** `messageForUi` over a page / list, preserving the array when nothing changed. */
+export function messagesForUi(messages: Message[]): Message[] {
+  const trimmed = messages.map(messageForUi);
+  const changed = trimmed.some((message, index) => message !== messages[index]);
+  return changed ? trimmed : messages;
+}
+
+/** A `toolBlockUpdated` frame whose block carries no image bytes. */
+export function toolBlockUpdateForUi(
+  params: ToolBlockUpdateCallbackParams,
+): ToolBlockUpdateCallbackParams {
+  if (!params.images || params.images.length === 0) return params;
+  const { images, ...rest } = params;
+  void images;
+  return rest;
+}
+
+function hasImages(block: ToolBlock): boolean {
+  return Array.isArray(block.images) && block.images.length > 0;
+}
+
+function withoutImages(block: ToolBlock): ToolBlock {
+  const { images, ...rest } = block;
+  void images;
+  return rest;
+}

package/src/types.ts

@@ -18,4 +18,11 @@ export interface BaseAppProps {
   model?: string;
   /** Optional MCP server configs to pass to Agent.create() */
   mcpServers?: Record<string, McpServerConfig>;
+  /**
+   * Erases what ink has drawn without touching the terminal scrollback (ink's
+   * `instance.clear()`, injected by the CLI entry where the ink instance lives).
+   * Actions that must leave the previous conversation scrollable above — `/clear`
+   * — use it instead of a hard erase.
+   */
+  onClearOutput?: () => void;
 }

package/src/utils/bracketedPaste.ts

@@ -1,170 +0,0 @@
-/**
- * Bracketed paste (DECSET 2004) detector.
- *
- * When bracketed paste is enabled, terminals wrap pasted text in
- * `\x1b[200~` (start) and `\x1b[201~` (end) markers, which lets the input
- * pipeline distinguish "text was pasted" from "user typed keys" — most
- * importantly, a pasted trailing `\r` must NOT be treated as an Enter key.
- *
- * ink delivers each stdin chunk through useInput after stripping ONE leading
- * ESC from the parsed sequence (see use-input.js), so markers may arrive in
- * either the raw form (`\x1b[200~`) or the stripped form (`[200~`), and may
- * be split across chunks. The detector normalizes both forms and buffers
- * partial markers until they complete (deferral is safe: a deferred partial
- * is flushed unchanged if the next chunk does not complete a marker).
- */
-export type PasteProcessResult =
-  | { kind: "input"; input: string }
-  | { kind: "paste"; text: string; leadingInput?: string }
-  | { kind: "consume" };
-
-export interface BracketedPasteDetector {
-  /**
-   * Feed one input chunk (as delivered by ink's useInput callback).
-   * - `input`: regular keystrokes, pass through to normal handling.
-   * - `paste`: completed bracketed paste; insert `text` without submitting.
-   *   `leadingInput` (rare) is content that preceded the start marker in the
-   *   same chunk and should be handled as regular input first.
-   * - `consume`: content of an in-flight paste (or an empty paste); do
-   *   nothing with this chunk.
-   */
-  process(chunk: string): PasteProcessResult;
-  reset(): void;
-}
-
-const ESC = "\u001b";
-const START_STRIPPED = "[200~";
-const START_RAW = `${ESC}[200~`;
-const END_STRIPPED = "[201~";
-const END_RAW = `${ESC}[201~`;
-
-const START_FORMS = [START_RAW, START_STRIPPED];
-const END_FORMS = [END_RAW, END_STRIPPED];
-
-/**
- * Suffixes that may be the beginning of a marker split across chunks.
- * Longest-first so the longest matching suffix is deferred (e.g. `[200`
- * rather than `[20` for `...x[200`). Deferral is flush-equivalent: if the
- * next chunk does not complete a marker, the deferred suffix is delivered
- * as regular input unchanged.
- */
-const PARTIAL_SUFFIXES = [
-  `${ESC}[201`,
-  `${ESC}[200`,
-  `${ESC}[20`,
-  `${ESC}[2`,
-  "[201",
-  "[200",
-  "[20",
-  "[2",
-].sort((a, b) => b.length - a.length);
-
-export function createBracketedPasteDetector(): BracketedPasteDetector {
-  let inPaste = false;
-  let buffer = ""; // paste content collected since the start marker
-  let pending = ""; // deferred partial marker suffix from a previous chunk
-
-  const findFirst = (
-    text: string,
-    forms: string[],
-  ): { index: number; length: number } | null => {
-    let best: { index: number; length: number } | null = null;
-    for (const form of forms) {
-      const index = text.indexOf(form);
-      if (index !== -1 && (best === null || index < best.index)) {
-        best = { index, length: form.length };
-      }
-    }
-    return best;
-  };
-
-  const endsWithPartial = (text: string): string | null => {
-    for (const prefix of PARTIAL_SUFFIXES) {
-      if (text.endsWith(prefix)) {
-        return prefix;
-      }
-    }
-    return null;
-  };
-
-  const process = (chunk: string): PasteProcessResult => {
-    let remaining = pending + chunk;
-    pending = "";
-    let leadingInput = "";
-    let pasteText: string | null = null;
-
-    while (remaining.length > 0) {
-      if (!inPaste) {
-        const start = findFirst(remaining, START_FORMS);
-        if (start) {
-          leadingInput += remaining.slice(0, start.index);
-          remaining = remaining.slice(start.index + start.length);
-          inPaste = true;
-          continue;
-        }
-        // Orphan end marker (start was missed, e.g. consumed by another
-        // input handler): treat the preceding text as paste so a trailing
-        // `\r` cannot trigger the coalesced-Enter submit heuristic.
-        const end = findFirst(remaining, END_FORMS);
-        if (end) {
-          pasteText =
-            (pasteText ?? "") + leadingInput + remaining.slice(0, end.index);
-          leadingInput = "";
-          remaining = remaining.slice(end.index + end.length);
-          continue;
-        }
-        const partial = endsWithPartial(remaining);
-        if (partial) {
-          pending = remaining.slice(remaining.length - partial.length);
-          remaining = remaining.slice(0, remaining.length - partial.length);
-        }
-        if (remaining.length > 0) {
-          leadingInput += remaining;
-          remaining = "";
-        }
-        break;
-      }
-
-      const end = findFirst(remaining, END_FORMS);
-      if (end) {
-        pasteText = (pasteText ?? "") + buffer + remaining.slice(0, end.index);
-        buffer = "";
-        inPaste = false;
-        remaining = remaining.slice(end.index + end.length);
-        continue;
-      }
-      const partial = endsWithPartial(remaining);
-      if (partial) {
-        pending = remaining.slice(remaining.length - partial.length);
-        remaining = remaining.slice(0, remaining.length - partial.length);
-      }
-      buffer += remaining;
-      remaining = "";
-      break;
-    }
-
-    if (inPaste) {
-      // Paste still in flight: hold the content, deliver nothing yet.
-      return { kind: "consume" };
-    }
-    if (pasteText !== null) {
-      const result: { kind: "paste"; text: string; leadingInput?: string } = {
-        kind: "paste",
-        text: pasteText,
-      };
-      if (leadingInput !== "") {
-        result.leadingInput = leadingInput;
-      }
-      return result;
-    }
-    return { kind: "input", input: leadingInput };
-  };
-
-  const reset = (): void => {
-    inPaste = false;
-    buffer = "";
-    pending = "";
-  };
-
-  return { process, reset };
-}