wave-code 1.0.0 → 1.0.2

package/src/stdio/protocol.ts

@@ -54,6 +54,7 @@ export type RequestMethod =
   | "getSessionInfo"
   | "sendMessage"
   | "bang"
+  | "askBtw"
   | "abortMessage"
   | "clearMessages"
   | "rewindToMessage"
@@ -73,6 +74,8 @@ export type RequestMethod =
   | "getPromptHistory"
   | "searchPromptHistory"
   | "updateConfig"
+  // Permissions (daemon attach: re-surface pending approvals after reconnect)
+  | "listPendingPermissions"
   // Auth
   | "getAuthStatus"
   | "login"
@@ -105,7 +108,6 @@ export type ClientNotificationMethod = "permissionResponse";
 // ── Server → Client notification methods ────────────────────────
 
 export type ServerNotificationMethod =
-  | "messagesChange"
   | "userMessageAdded"
   | "assistantMessageAdded"
   | "assistantContentUpdated"
@@ -128,7 +130,8 @@ export type ServerNotificationMethod =
   | "authUrl"
   | "compactBlockAdded"
   | "compactionStateChange"
-  | "backgroundTasksChange";
+  | "backgroundTasksChange"
+  | "btwContent";
 
 // ── Helper: is this a request (has id)? ─────────────────────────
 

package/src/stdio/stdioServer.ts

@@ -3,21 +3,12 @@
  * and writes responses / notifications to stdout.
  *
  * One JSON object per line. stderr is reserved for logger output.
+ * Line handling lives in JsonRpcConnection (shared with DaemonServer).
  */
 
-import readline from "readline";
 import type { Readable, Writable } from "stream";
 import { AgentBridge, type AgentBridgeOptions } from "./agentBridge.js";
-import {
-  type JsonRpcRequest,
-  type JsonRpcResponse,
-  type JsonRpcNotification,
-  PARSE_ERROR,
-  INVALID_REQUEST,
-  INTERNAL_ERROR,
-  isRequest,
-  isNotification,
-} from "./protocol.js";
+import { JsonRpcConnection } from "./jsonRpcConnection.js";
 
 export interface StdioServerOptions {
   input?: Readable;
@@ -26,20 +17,20 @@ export interface StdioServerOptions {
 }
 
 export class StdioServer {
-  private rl: readline.Interface | undefined;
   private bridge: AgentBridge;
-  private input: Readable;
-  private output: Writable;
-  private started = false;
+  private conn: JsonRpcConnection;
 
   constructor(options: StdioServerOptions = {}) {
-    this.input = options.input ?? process.stdin;
-    this.output = options.output ?? process.stdout;
     this.bridge = new AgentBridge({
       ...options.bridgeOptions,
       emit: (method, params, sessionId) =>
         this.sendNotification(method, params, sessionId),
     });
+    this.conn = new JsonRpcConnection(
+      options.input ?? process.stdin,
+      options.output ?? process.stdout,
+      this.bridge,
+    );
   }
 
   get agentBridge(): AgentBridge {
@@ -47,123 +38,26 @@ export class StdioServer {
   }
 
   start(): void {
-    if (this.started) return;
-    this.started = true;
-
-    this.rl = readline.createInterface({
-      input: this.input,
-      crlfDelay: Infinity,
-    });
-
-    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;
-    });
+    this.conn.start();
   }
 
   stop(): void {
-    this.rl?.close();
-    this.rl = undefined;
-    this.started = false;
+    this.conn.stop();
   }
 
-  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",
-      });
-    }
+  handleLine(line: string): Promise<void> {
+    return this.conn.handleLine(line);
   }
 
-  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);
+    this.conn.sendResponse(id, result, error);
   }
 
   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");
+    this.conn.sendNotification(method, params, sessionId);
   }
 }

package/src/utils/bracketedPaste.ts

@@ -0,0 +1,170 @@
+/**
+ * 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 };
+}