wave-code 1.3.0 → 1.4.0

package/src/remote/hostIdentity.ts

@@ -0,0 +1,128 @@
+/**
+ * This machine's stable identity on the relay — the id it registers itself with.
+ *
+ * The channel is keyed by the machine. The old scheme let the relay mint that key
+ * on first registration and kept it only in `~/.wave/remote-control.json`, so
+ * losing that file (reinstall, fresh home, read-only home, another OS user)
+ * registered a **second row for the same machine**: the phone then lists one
+ * computer twice, and the page URL — the id is in it — changes with it. Deriving
+ * the id here instead makes the same machine + same account always name the same
+ * row, so registration is idempotent and a lost state file just re-claims it.
+ *
+ * Why the OS machine id and not the hostname: hostnames are renameable, shared,
+ * and only ever a display label here (the `name` field). Why not a MAC address
+ * (the intuition is "it should be stable like a MAC address"): modern systems
+ * randomize it per network, a machine has several, and containers get a fresh
+ * one — none of that is stable enough to key a database row on.
+ *
+ * When the machine id cannot be read (unsupported platform, permissions, a
+ * container hiding it) this yields nothing and registration falls back to the
+ * old path — the relay mints the id. Nothing fails; the machine merely stops
+ * keeping its identity across a lost state file.
+ */
+
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import { authService } from "wave-agent-sdk";
+
+/**
+ * Namespace for every derived host id. **Changing it changes the identity of
+ * every machine** — each one would register as a fresh row — so it only ever
+ * moves together with a deliberate migration. Never add an input to the derived
+ * name for the same reason.
+ */
+const HOST_ID_NAMESPACE = "9f0e1c72-1a9a-4e1c-8f4d-2b6d3c5a7e10";
+
+/** Reading the platform's machine id must never hang a registration. */
+const READ_TIMEOUT_MS = 2_000;
+
+/** RFC 4122 version 5 (SHA-1) UUID over the UTF-8 name. */
+export function uuidv5(namespace: string, name: string): string {
+  const namespaceBytes = Buffer.from(namespace.replace(/-/g, ""), "hex");
+  const digest = createHash("sha1")
+    .update(namespaceBytes)
+    .update(name, "utf8")
+    .digest();
+  const bytes = Buffer.from(digest.subarray(0, 16));
+  bytes[6] = (bytes[6] & 0x0f) | 0x50;
+  bytes[8] = (bytes[8] & 0x3f) | 0x80;
+  const hex = bytes.toString("hex");
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20, 32),
+  ].join("-");
+}
+
+/**
+ * The id this machine should register with, or undefined when it cannot be
+ * derived. Both inputs are required: without a machine id there is nothing
+ * stable to derive from, and without the account id two OS users sharing one
+ * machine would derive the *same* id and fight over one row (the row belongs to
+ * an account, which is also how the relay scopes them).
+ */
+export function deriveHostId(): string | undefined {
+  const machineId = readMachineId();
+  const userId = authService.getAuthUser()?.id;
+  if (!machineId || !userId) return undefined;
+  return uuidv5(HOST_ID_NAMESPACE, `${machineId}\n${userId}`);
+}
+
+/** Best-effort read of the platform's machine id; never throws. */
+export function readMachineId(
+  platform: string = process.platform,
+): string | undefined {
+  try {
+    if (platform === "darwin") return readDarwinMachineId();
+    if (platform === "win32") return readWindowsMachineId();
+    return readLinuxMachineId();
+  } catch {
+    // An unreadable / missing source is not an error worth surfacing: the
+    // caller falls back to letting the relay mint the id.
+    return undefined;
+  }
+}
+
+/** Linux: the conventional systemd / dbus files, first one that reads. */
+function readLinuxMachineId(): string | undefined {
+  for (const file of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
+    try {
+      const value = fs.readFileSync(file, "utf8").trim();
+      if (value) return value;
+    } catch {
+      // Try the next location — neither file is guaranteed to exist.
+    }
+  }
+  return undefined;
+}
+
+/** macOS: the platform UUID, which survives reboots and OS updates. */
+function readDarwinMachineId(): string | undefined {
+  const output = execFileSync(
+    "ioreg",
+    ["-rd1", "-c", "IOPlatformExpertDevice"],
+    {
+      encoding: "utf8",
+      timeout: READ_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "ignore"],
+    },
+  );
+  return /"IOPlatformUUID"\s*=\s*"([^"]+)"/.exec(output)?.[1];
+}
+
+/** Windows: the registry's machine GUID. */
+function readWindowsMachineId(): string | undefined {
+  const output = execFileSync(
+    "reg",
+    ["query", "HKLM\\SOFTWARE\\Microsoft\\Cryptography", "/v", "MachineGuid"],
+    {
+      encoding: "utf8",
+      timeout: READ_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "ignore"],
+    },
+  );
+  return /MachineGuid\s+REG_SZ\s+(\S+)/.exec(output)?.[1];
+}

package/src/remote/messageWindow.ts

@@ -0,0 +1,97 @@
+/**
+ * Message-window slicing, shared by every host that answers `getMessages`.
+ *
+ * Two callers need this and must agree byte for byte: the daemon / stdio
+ * bridge (multi-session registry) and the interactive CLI front end (one
+ * session in React state). The phone's reconciliation rules — `since` is an
+ * anchor, a vanished anchor means "re-pull the tail", ids can repeat so the
+ * anchor resolves to its **last** occurrence — are a property of the wire
+ * contract, not of either host, so the arithmetic lives here once.
+ *
+ * Described in docs/specs/ui/remote-control.md (§5 白名单与增量拉取).
+ */
+
+import type { Message } from "wave-agent-sdk";
+
+export interface MessageWindow {
+  /** Exclusive upper anchor: return the page ending just before this id. */
+  before?: string;
+  /** Exclusive lower anchor: return what arrived after this id. */
+  since?: string;
+  limit?: number;
+}
+
+export interface MessageWindowResult {
+  messages: Message[];
+  /** Older messages exist before the returned page. */
+  hasMore?: boolean;
+  /** The `since` anchor is gone — rebuild from the tail. */
+  reset?: boolean;
+  /** Total display messages held for the session. */
+  total?: number;
+}
+
+/** A malformed window. Hosts translate this into their own RPC error type. */
+export class InvalidMessageWindowError extends Error {}
+
+/**
+ * Slice `all` by `window`. Returns `undefined` when no window was asked for —
+ * the caller then answers with the whole list, untouched.
+ *
+ * The validations are here rather than in either caller because silently
+ * widening the read is the one failure mode a caller cannot notice: it asked
+ * for a bounded page and got the thread back.
+ */
+export function sliceMessageWindow(
+  all: Message[],
+  window?: MessageWindow,
+): MessageWindowResult | undefined {
+  const before = window?.before;
+  const since = window?.since;
+  const rawLimit = window?.limit;
+  if (rawLimit !== undefined && (!Number.isInteger(rawLimit) || rawLimit < 1)) {
+    throw new InvalidMessageWindowError(
+      `getMessages limit must be a positive integer, got ${String(rawLimit)}`,
+    );
+  }
+  const limit = rawLimit;
+
+  if (before === undefined && since === undefined && limit === undefined) {
+    return undefined;
+  }
+
+  const lastIndexOfId = (id: string): number => {
+    for (let i = all.length - 1; i >= 0; i--) {
+      if (all[i].id === id) return i;
+    }
+    return -1;
+  };
+
+  if (since !== undefined) {
+    const at = lastIndexOfId(since);
+    if (at === -1) {
+      return { messages: [], reset: true, total: all.length };
+    }
+    const later = all.slice(at + 1);
+    return {
+      messages: limit === undefined ? later : later.slice(-limit),
+      hasMore: false,
+      total: all.length,
+    };
+  }
+
+  // Backward paging; without `before` this is a tail read (`limit` only).
+  const end = before === undefined ? all.length : lastIndexOfId(before);
+  if (end === -1) {
+    // The anchor is gone. Older history may have been truncated along with it,
+    // so answer with an empty page: the caller stops paging rather than looping
+    // on an anchor that will never resolve.
+    return { messages: [], hasMore: false, total: all.length };
+  }
+  const start = limit === undefined ? 0 : Math.max(0, end - limit);
+  return {
+    messages: all.slice(start, end),
+    hasMore: start > 0,
+    total: all.length,
+  };
+}

package/src/remote/notificationCoalescer.ts

@@ -0,0 +1,174 @@
+/**
+ * Frame coalescer for the remote-control (phone) path.
+ *
+ * The bridge emits one notification per streamed chunk (see
+ * `agentBridge.ts` `onAssistantContentUpdated`), which mirrors the model's
+ * frame rate — tens to ~150 frames per second per session. Locally that is
+ * free: those frames go out over a unix socket inside the same process. Over a
+ * relay it becomes the dominant cost, because the JSON-RPC envelope (~150–250
+ * B) is an order of magnitude larger than the delta it carries — and the relay
+ * pays that cost per subscriber, per frame.
+ *
+ * So the remote path alone gets a merge window: notifications whose payload is
+ * an accumulating delta are held for at most `windowMs` and concatenated.
+ * Everything else is a discrete event — a permission request, a tool block
+ * reaching `end`, a status signal — and is written through immediately, after
+ * flushing whatever was held, so a phone never observes a reordered stream.
+ *
+ * This is a delay, never a sample: no delta is dropped, and the merged frame
+ * carries exactly the bytes the individual frames would have. The local
+ * desktop / IDE path does not go through here at all.
+ */
+
+/** One notification on its way to the relay. */
+export interface RelayFrame {
+  method: string;
+  params: unknown;
+  sessionId?: string;
+}
+
+/**
+ * Merge window for the remote path. Long enough to collapse a streaming burst
+ * (the model emits far faster than this), short enough that a human reading the
+ * phone cannot tell the difference.
+ */
+export const REMOTE_FRAME_WINDOW_MS = 150;
+
+interface MergeSpec {
+  /** The params field that accumulates. */
+  field: string;
+  /** Identity of the accumulating thing, so two streams never interleave. */
+  key: string;
+}
+
+/**
+ * Decide whether a notification is a pure delta that may be merged.
+ *
+ * Only the three streaming callbacks qualify, and only in their streaming
+ * stage: their payloads are documented as deltas ("consumers accumulate"), and
+ * `messageOperations.ts` accumulates `parametersChunk` by plain concatenation —
+ * the same operation this class performs. A `start` / `running` / `end` frame
+ * is a one-time snapshot (or the authoritative full value) and must not be
+ * merged with anything.
+ */
+function mergeSpec(method: string, params: unknown): MergeSpec | undefined {
+  if (typeof params !== "object" || params === null) return undefined;
+  const p = params as Record<string, unknown>;
+
+  if (
+    method === "assistantContentUpdated" ||
+    method === "assistantReasoningUpdated"
+  ) {
+    if (p.stage !== "streaming" || typeof p.chunk !== "string")
+      return undefined;
+    if (typeof p.messageId !== "string") return undefined;
+    return { field: "chunk", key: `c\u0000${p.messageId}` };
+  }
+
+  if (method === "toolBlockUpdated") {
+    if (p.stage !== "streaming" || typeof p.parametersChunk !== "string") {
+      return undefined;
+    }
+    if (typeof p.messageId !== "string" || typeof p.id !== "string") {
+      return undefined;
+    }
+    return {
+      field: "parametersChunk",
+      key: `t\u0000${p.messageId}\u0000${p.id}`,
+    };
+  }
+
+  return undefined;
+}
+
+interface Pending {
+  method: string;
+  sessionId?: string;
+  /** Params of the first frame of the run, with the delta field zeroed. */
+  base: Record<string, unknown>;
+  field: string;
+  text: string;
+}
+
+export class NotificationCoalescer {
+  private pending = new Map<string, Pending>();
+  /** Insertion order of live keys, so a flush preserves the original order. */
+  private order: string[] = [];
+  private timer: ReturnType<typeof setTimeout> | undefined;
+
+  constructor(
+    private readonly write: (frames: RelayFrame[]) => void,
+    private readonly windowMs: number = REMOTE_FRAME_WINDOW_MS,
+  ) {}
+
+  push(method: string, params: unknown, sessionId?: string): void {
+    const spec = mergeSpec(method, params);
+    if (!spec) {
+      // Discrete event: order matters relative to the buffered deltas, so the
+      // buffer goes out first.
+      this.flush();
+      this.write([{ method, params, sessionId }]);
+      return;
+    }
+
+    const mapKey = `${sessionId ?? ""}\u0000${method}\u0000${spec.key}`;
+    const existing = this.pending.get(mapKey);
+    if (existing) {
+      existing.text += String(
+        (params as Record<string, unknown>)[spec.field] ?? "",
+      );
+      return;
+    }
+
+    const base = { ...(params as Record<string, unknown>) };
+    const text = String(base[spec.field] ?? "");
+    delete base[spec.field];
+    this.pending.set(mapKey, {
+      method,
+      sessionId,
+      base,
+      field: spec.field,
+      text,
+    });
+    this.order.push(mapKey);
+    if (this.timer === undefined) {
+      this.timer = setTimeout(() => this.flush(), this.windowMs);
+      // A pending phone frame must never hold the process open.
+      this.timer.unref?.();
+    }
+  }
+
+  /** Write every buffered run, in the order the runs first appeared. */
+  flush(): void {
+    if (this.timer !== undefined) {
+      clearTimeout(this.timer);
+      this.timer = undefined;
+    }
+    if (this.order.length === 0) return;
+
+    const keys = this.order;
+    const buffered = this.pending;
+    this.order = [];
+    this.pending = new Map();
+
+    const frames: RelayFrame[] = keys.map((key) => {
+      const item = buffered.get(key)!;
+      return {
+        method: item.method,
+        params: { ...item.base, [item.field]: item.text },
+        sessionId: item.sessionId,
+      };
+    });
+    this.write(frames);
+  }
+
+  /** Drop everything buffered without writing — used when the socket dies. */
+  discard(): void {
+    if (this.timer !== undefined) {
+      clearTimeout(this.timer);
+      this.timer = undefined;
+    }
+    this.order = [];
+    this.pending = new Map();
+  }
+}