@hraness/dawg 0.6.1 → 0.8.0

package/src/web/fetch.ts

@@ -7,6 +7,7 @@
  */
 import { lookup as dnsLookup } from "node:dns/promises";
 import { isIP } from "node:net";
+import { checkServerIdentity, type PeerCertificate } from "node:tls";
 import {
   decodeEntities,
   describeFetchError,
@@ -81,26 +82,64 @@ function isPrivateV4(address: string): boolean {
   );
 }
 
-function isPrivateV6(address: string): boolean {
-  const lower = address.toLowerCase().split("%")[0]!;
-  if (lower === "::" || lower === "::1") return true;
-  const mapped = /^(?:0*:)*:?ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(lower);
-  if (mapped) return isPrivateV4(mapped[1]!);
-  const hexMapped = /^(?:0*:)*:?ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(
-    lower,
-  );
-  if (hexMapped) {
-    const high = Number.parseInt(hexMapped[1]!, 16);
-    const low = Number.parseInt(hexMapped[2]!, 16);
-    return isPrivateV4(`${high >> 8}.${high & 0xff}.${low >> 8}.${low & 0xff}`);
+/** Expand an IPv6 address (zone stripped, embedded dotted IPv4 allowed) to 8 groups. */
+function expandV6(address: string): number[] | undefined {
+  let text = address.toLowerCase().split("%")[0]!;
+  const dotted = /(\d+)\.(\d+)\.(\d+)\.(\d+)$/.exec(text);
+  if (dotted) {
+    const [a, b, c, d] = dotted.slice(1).map(Number) as [
+      number,
+      number,
+      number,
+      number,
+    ];
+    text = `${text.slice(0, dotted.index)}${((a << 8) | b).toString(16)}:${((c << 8) | d).toString(16)}`;
   }
-  const first = Number.parseInt(lower.split(":")[0] || "0", 16);
+  const halves = text.split("::");
+  if (halves.length > 2) return undefined;
+  const parse = (part: string) =>
+    part === ""
+      ? []
+      : part.split(":").map((group) => Number.parseInt(group, 16));
+  const head = parse(halves[0]!);
+  const tail = halves.length === 2 ? parse(halves[1]!) : [];
+  const fill = 8 - head.length - tail.length;
+  if (halves.length === 1 ? fill !== 0 : fill < 1) return undefined;
+  const groups = [
+    ...head,
+    ...new Array<number>(halves.length === 2 ? fill : 0).fill(0),
+    ...tail,
+  ];
+  return groups.every((g) => Number.isInteger(g) && g >= 0 && g <= 0xffff)
+    ? groups
+    : undefined;
+}
+
+function v4From(high: number, low: number): string {
+  return `${high >> 8}.${high & 0xff}.${low >> 8}.${low & 0xff}`;
+}
+
+function isPrivateV6(address: string): boolean {
+  const g = expandV6(address);
+  if (!g) return true;
+  const zero = (from: number, to: number) =>
+    g.slice(from, to).every((x) => x === 0);
+  // ::/96 covers :: and ::1 and the deprecated IPv4-compatible form (::a.b.c.d).
+  if (zero(0, 6)) return true;
+  // ::ffff:0:0/96 IPv4-mapped: as private as the address it carries.
+  if (zero(0, 5) && g[5] === 0xffff) return isPrivateV4(v4From(g[6]!, g[7]!));
+  // 2002::/16 6to4 embeds an IPv4 address in bits 16..47.
+  if (g[0] === 0x2002) return isPrivateV4(v4From(g[1]!, g[2]!));
+  const first = g[0]!;
   return (
+    (first === 0x64 && g[1] === 0xff9b) || // 64:ff9b::/96 and 64:ff9b:1::/48 NAT64
+    (first === 0x100 && zero(1, 4)) || // 100::/64 discard
+    (first === 0x2001 && g[1] === 0) || // 2001::/32 Teredo (obfuscated IPv4)
+    (first === 0x2001 && g[1] === 0xdb8) || // 2001:db8::/32 documentation
     (first & 0xfe00) === 0xfc00 || // fc00::/7 unique local
     (first & 0xffc0) === 0xfe80 || // fe80::/10 link-local
-    (first & 0xff00) === 0xff00 || // ff00::/8 multicast
-    lower.startsWith("64:ff9b:") || // NAT64 well-known prefix
-    lower.startsWith("2001:db8:") // documentation
+    (first & 0xffc0) === 0xfec0 || // fec0::/10 deprecated site-local
+    (first & 0xff00) === 0xff00 // ff00::/8 multicast
   );
 }
 
@@ -136,12 +175,19 @@ export function admitUrl(raw: unknown): URL {
   return url;
 }
 
-async function assertPublicHost(url: URL, lookup: Lookup): Promise<void> {
+/**
+ * Check that a URL's host is public and return the address to connect to.
+ * Every resolved address must be public; the first one is returned so the
+ * request connects to exactly the address that was checked, never to a
+ * second, independent DNS answer (which a rebinding domain could point at
+ * loopback or a metadata service).
+ */
+async function assertPublicHost(url: URL, lookup: Lookup): Promise<string> {
   const host = url.hostname.replace(/^\[|\]$/g, "");
   if (isIP(host)) {
     if (isPrivateAddress(host))
       throw new WebError(`${host} is a private or local address`);
-    return;
+    return host;
   }
   let addresses: readonly string[];
   try {
@@ -153,6 +199,42 @@ async function assertPublicHost(url: URL, lookup: Lookup): Promise<void> {
   for (const address of addresses)
     if (isPrivateAddress(address))
       throw new WebError(`${host} resolves to a private or local address`);
+  return addresses[0]!;
+}
+
+/** Bun's fetch accepts TLS options beyond the standard RequestInit. */
+type PinnedInit = RequestInit & {
+  tls?: {
+    serverName?: string;
+    checkServerIdentity?: (
+      hostname: string,
+      cert: PeerCertificate,
+    ) => Error | undefined;
+  };
+};
+
+/**
+ * Address a request to a checked IP while keeping the original name for the
+ * Host header and for TLS (SNI and certificate verification), so the
+ * connection cannot be redirected by a later DNS answer.
+ */
+export function pinRequest(
+  url: URL,
+  address: string,
+): { target: string; host: string; tls?: PinnedInit["tls"] } {
+  const hostname = url.hostname.replace(/^\[|\]$/g, "");
+  const pinned = new URL(url.toString());
+  pinned.hostname = isIP(address) === 6 ? `[${address}]` : address;
+  const result: { target: string; host: string; tls?: PinnedInit["tls"] } = {
+    target: pinned.toString(),
+    host: url.host,
+  };
+  if (url.protocol === "https:" && !isIP(hostname))
+    result.tls = {
+      serverName: hostname,
+      checkServerIdentity: (_name, cert) => checkServerIdentity(hostname, cert),
+    };
+  return result;
 }
 
 export async function fetchUrl(
@@ -168,18 +250,22 @@ export async function fetchUrl(
     let url = admitUrl(raw);
     let response: Response | undefined;
     for (let hop = 0; hop <= FETCH_LIMITS.maxRedirects; hop += 1) {
-      await assertPublicHost(url, lookup);
+      const address = await assertPublicHost(url, lookup);
+      const pin = pinRequest(url, address);
+      const init: PinnedInit = {
+        method: "GET",
+        redirect: "manual",
+        headers: {
+          host: pin.host,
+          accept:
+            "text/html,application/xhtml+xml,text/plain;q=0.9,application/json;q=0.8,*/*;q=0.5",
+          "user-agent": "Mozilla/5.0 (compatible; dawg-agent)",
+        },
+        signal: timer.signal,
+      };
+      if (pin.tls) init.tls = pin.tls;
       try {
-        response = await fetcher(url, {
-          method: "GET",
-          redirect: "manual",
-          headers: {
-            accept:
-              "text/html,application/xhtml+xml,text/plain;q=0.9,application/json;q=0.8,*/*;q=0.5",
-            "user-agent": "Mozilla/5.0 (compatible; dawg-agent)",
-          },
-          signal: timer.signal,
-        });
+        response = await fetcher(pin.target, init);
       } catch (error) {
         throw new WebError(
           `fetch failed: ${timer.timedOut() ? `timed out after ${timeoutMs / 1000}s` : describeFetchError(error)}`,

package/tui/activity.ts

@@ -23,6 +23,33 @@ export interface ActivityCard {
   trackId?: string | undefined;
   /** Key hint shown after the card, e.g. "u undo". */
   hint?: string | undefined;
+  /**
+   * A one-time info card (a launch note, a tip): it leaves the strip after
+   * `ONCE_TTL_MS` or `ONCE_ACTIONS` later actions, whichever comes first.
+   */
+  once?: boolean | undefined;
+  /** Repeats of the same text and tone, shown as `×N` (absent is 1). */
+  count?: number | undefined;
+  /** A quieter note joined to the card, e.g. the auto-name. */
+  suffix?: string | undefined;
+  /** `actions` when the card was pushed, for the `once` expiry. */
+  atAction?: number | undefined;
+}
+
+/** A `once` card's lifetime in milliseconds. */
+export const ONCE_TTL_MS = 8_000;
+/** Actions (receipts, requests) after which a `once` card leaves. */
+export const ONCE_ACTIONS = 3;
+/** Age after which an older error fades to the faint role. */
+export const ERROR_FADE_MS = 6_000;
+
+/** One strip line: newlines read as ` · `, runs of space collapse. */
+export function stripLine(text: string): string {
+  return text
+    .split(/\s*\n\s*/)
+    .map((part) => part.replace(/[ \t]+/g, " ").trim())
+    .filter(Boolean)
+    .join(" · ");
 }
 
 export type TranscriptKind =
@@ -134,7 +161,10 @@ export class ActivityFeed {
   private spinnerLabel: string | undefined;
   private spinnerSince = 0;
   private streamText = "";
+  private turnReceipt = "";
   private queue = 0;
+  /** Receipts and requests so far: the clock `once` cards expire on. */
+  private actions = 0;
   private listeners = new Set<() => void>();
   /** Increments on every change; renderers can skip work when unchanged. */
   version = 0;
@@ -167,6 +197,36 @@ export class ActivityFeed {
     return this.cardList[this.cardList.length - 1];
   }
 
+  /**
+   * The cards the strip shows at `nowMs`, first slot first: the newest
+   * receipt leads, live `once` notes follow it, and expired `once` notes
+   * are gone.
+   */
+  visible(nowMs: number = this.clock()): ActivityCard[] {
+    const live = this.cardList.filter(
+      (card) =>
+        !card.once ||
+        (nowMs - card.atMs < ONCE_TTL_MS &&
+          this.actions - (card.atAction ?? 0) < ONCE_ACTIONS),
+    );
+    const newest = [...live].reverse();
+    return [
+      ...newest.filter((card) => !card.once),
+      ...newest.filter((card) => card.once),
+    ];
+  }
+
+  /** The next time a `once` card expires on the clock, for frame wakeups. */
+  nextExpiry(nowMs: number = this.clock()): number | undefined {
+    let next: number | undefined;
+    for (const card of this.cardList) {
+      if (!card.once) continue;
+      const at = card.atMs + ONCE_TTL_MS;
+      if (at > nowMs && (next === undefined || at < next)) next = at;
+    }
+    return next;
+  }
+
   subscribe(listener: () => void): () => void {
     this.listeners.add(listener);
     return () => this.listeners.delete(listener);
@@ -176,32 +236,85 @@ export class ActivityFeed {
     text: string,
     details: Omit<Partial<ActivityCard>, "id" | "atMs" | "text"> = {},
   ): ActivityCard {
+    const line = stripLine(text);
+    const once = details.once === true;
+    if (!once) this.actions += 1;
+    const last = this.cardList[this.cardList.length - 1];
+    const tone = details.tone ?? "info";
+    // The same message again reads `×N` instead of filling the strip.
+    if (
+      last &&
+      last.text === line &&
+      last.tone === tone &&
+      last.resultRevision === details.resultRevision
+    ) {
+      const repeat: ActivityCard = {
+        ...last,
+        count: (last.count ?? 1) + 1,
+        atMs: this.clock(),
+        atAction: this.actions,
+      };
+      this.cardList = [...this.cardList.slice(0, -1), repeat];
+      this.record(tone === "error" ? "error" : "op", line);
+      this.changed();
+      return repeat;
+    }
     const card: ActivityCard = {
       id: this.nextId++,
-      text,
-      tone: details.tone ?? "info",
+      text: line,
+      tone,
       atMs: this.clock(),
       baseRevision: details.baseRevision,
       resultRevision: details.resultRevision,
       trackId: details.trackId,
       hint: details.hint,
+      ...(once ? { once: true } : {}),
+      ...(details.suffix ? { suffix: stripLine(details.suffix) } : {}),
+      atAction: this.actions,
     };
     this.cardList = [...this.cardList, card].slice(-this.maxCards);
     const revision = revisionLabel(card.baseRevision, card.resultRevision);
     this.record(
       card.tone === "error" ? "error" : "op",
-      revision ? `${text} · ${revision}` : text,
+      revision ? `${line} · ${revision}` : line,
     );
     this.changed();
     return card;
   }
 
+  /**
+   * Join a quiet note to the newest receipt (`… · named "dusk loop"`), so
+   * it rides in the first slot instead of pushing the receipt aside. With
+   * no receipt in the last few seconds it becomes a `once` card.
+   */
+  attachNote(text: string, withinMs = ONCE_TTL_MS): ActivityCard {
+    const line = stripLine(text);
+    const last = this.cardList[this.cardList.length - 1];
+    if (
+      last &&
+      !last.once &&
+      last.tone !== "error" &&
+      this.clock() - last.atMs < withinMs
+    ) {
+      const joined: ActivityCard = {
+        ...last,
+        suffix: last.suffix ? `${last.suffix} · ${line}` : line,
+      };
+      this.cardList = [...this.cardList.slice(0, -1), joined];
+      this.record("note", line);
+      this.changed();
+      return joined;
+    }
+    return this.pushCard(line, { tone: "info", once: true });
+  }
+
   pushError(message: string): ActivityCard {
     return this.pushCard(message, { tone: "error" });
   }
 
   /** Record a user request in the transcript without adding a strip card. */
   pushRequest(text: string): void {
+    this.actions += 1;
     this.record("request", text);
     this.changed();
   }
@@ -227,6 +340,23 @@ export class ActivityFeed {
     this.changed();
   }
 
+  /**
+   * The musical receipt of the running agent turn (`musicalReceipt` of the
+   * score before and after), shown as the turn's closing card.
+   */
+  setTurnReceipt(text: string): void {
+    this.turnReceipt = text;
+  }
+
+  /**
+   * The latest prose sentence of the streaming agent text, for the faint
+   * tail of the spinner: a complete sentence when one has ended, else the
+   * one being written.
+   */
+  get streamSentence(): string {
+    return latestSentence(this.streamText);
+  }
+
   /** Adapter for the agent lane's streaming events. */
   applyAgentEvent(event: AgentActivityEvent): void {
     switch (event.type) {
@@ -271,7 +401,7 @@ export class ActivityFeed {
           baseRevision: event.baseRevision,
           resultRevision: event.resultRevision,
           trackId: event.trackId,
-          hint: unchanged ? undefined : "^z undo",
+          hint: unchanged ? undefined : "ctrl-z undo",
         });
         return;
       }
@@ -287,9 +417,20 @@ export class ActivityFeed {
       case "done": {
         if (this.streamText) this.record("agent", this.streamText);
         this.streamText = "";
+        // A turn that changed the music ends on what it changed, in musical
+        // terms; its prose stays in the ctrl-o log.
+        const receipt = this.turnReceipt;
+        this.turnReceipt = "";
         const summary =
-          event.summary ?? event.text?.split("\n")[0]?.slice(0, 160);
-        if (summary) this.pushCard(summary, { tone: "agent" });
+          receipt ||
+          event.summary ||
+          firstSentence(event.text ?? "").slice(0, 160) ||
+          undefined;
+        if (summary)
+          this.pushCard(summary, {
+            tone: "agent",
+            hint: receipt ? "ctrl-z undo" : undefined,
+          });
         else if (event.applied === 0)
           this.pushCard("agent made no changes", { tone: "info" });
         this.setSpinner(undefined);
@@ -300,7 +441,7 @@ export class ActivityFeed {
         this.setSpinner(undefined);
         if (event.code === "aborted")
           this.pushCard(
-            `cancelled${event.revision === undefined ? "" : ` · kept rev ${event.revision}`}`,
+            `canceled${event.revision === undefined ? "" : ` · kept rev ${event.revision}`}`,
             { tone: "warning" },
           );
         else
@@ -331,11 +472,16 @@ export class ActivityFeed {
  * success, `false` a failure, `"warn"` a no-op or conflict. Handlers return
  * these so the strip never infers failure from prose.
  */
-export type Receipt = Readonly<{ ok: boolean | "warn"; text: string }>;
+export type Receipt = Readonly<{
+  ok: boolean | "warn" | "info";
+  text: string;
+}>;
 
 export const ok = (text: string): Receipt => ({ ok: true, text });
 export const fail = (text: string): Receipt => ({ ok: false, text });
 export const warn = (text: string): Receipt => ({ ok: "warn", text });
+/** A status read (`•`): nothing changed (bare `fx`, `tracks`). */
+export const note = (text: string): Receipt => ({ ok: "info", text });
 
 /** Tone of a structured receipt; strings fall back to `receiptTone`. */
 export function toneOf(receipt: string | Receipt): CardTone {
@@ -344,7 +490,9 @@ export function toneOf(receipt: string | Receipt): CardTone {
     ? "success"
     : receipt.ok === "warn"
       ? "warning"
-      : "error";
+      : receipt.ok === "info"
+        ? "info"
+        : "error";
 }
 
 /**
@@ -362,3 +510,26 @@ export function receiptTone(message: string): CardTone {
     return "warning";
   return "success";
 }
+
+/** The first sentence of a reply (up to its first `.`, `!` or `?`). */
+export function firstSentence(text: string): string {
+  const flat = text.replace(/\s+/g, " ").trim();
+  const match = /^.*?[.!?](?=\s|$)/.exec(flat);
+  return (match ? match[0] : flat).trim();
+}
+
+/** The last complete sentence of streaming text, or the one in progress. */
+export function latestSentence(text: string): string {
+  const flat = text.replace(/\s+/g, " ").trim();
+  if (!flat) return "";
+  const sentences = flat.match(/[^.!?]+[.!?]+(?=\s|$)|[^.!?]+$/g) ?? [flat];
+  const last = sentences[sentences.length - 1]!.trim();
+  // A fragment of a few words reads as noise; keep the sentence before it.
+  if (
+    !/[.!?]$/.test(last) &&
+    last.split(" ").length < 4 &&
+    sentences.length > 1
+  )
+    return sentences[sentences.length - 2]!.trim();
+  return last;
+}