@dexto/tui 1.15.0-beta.0 → 1.15.0-beta.1

package/dist/services/processStream.test.js

@@ -72,9 +72,6 @@ function createSetters({
     promptAddWizard: null,
     autoApproveEdits: false,
     todoExpanded: true,
-    backgroundTasksRunning: 0,
-    backgroundTasksExpanded: false,
-    backgroundTasks: [],
     chatgptRateLimitStatus: null,
     insufficientCredits: null,
     planModeActive: false,
@@ -476,6 +473,40 @@ describe("processStream (reasoning)", () => {
     expect(assistantMessages[1]?.content).toBe("Final");
     expect(assistantMessages[1]?.reasoning).toBeUndefined();
   });
+  it("reports a fatal error once when the stream rethrows it", async () => {
+    const { getMessages, setters } = createSetters();
+    const error = new Error("Provider error 500");
+    async function* failing() {
+      yield { name: "llm:error", sessionId: "test-session", error };
+      throw new Error("Provider error 500");
+    }
+    await processStream(failing(), setters, {
+      useStreaming: true,
+      autoApproveEditsRef: { current: false },
+      bypassPermissionsRef: { current: false },
+      eventBus: { emit: vi.fn() }
+    });
+    const faults = getMessages().filter((each) => each.content.includes("Provider error 500"));
+    expect(faults).toHaveLength(1);
+    expect(faults[0]?.systemKind).toBe("fault");
+  });
+  it("still reports a stream failure nothing has reported", async () => {
+    const { getMessages, setters } = createSetters();
+    async function* failing() {
+      yield* [];
+      throw new Error("socket closed");
+    }
+    await processStream(failing(), setters, {
+      useStreaming: true,
+      autoApproveEditsRef: { current: false },
+      bypassPermissionsRef: { current: false },
+      eventBus: { emit: vi.fn() }
+    });
+    expect(getMessages().at(-1)).toMatchObject({
+      content: "Stream error: socket closed",
+      systemKind: "fault"
+    });
+  });
   it("shows the billing recovery overlay for insufficient credits", async () => {
     const { getMessages, getUi, setters } = createSetters();
     const error = Object.assign(new Error("Insufficient Dexto credits. Balance: $0.00"), {
@@ -558,3 +589,20 @@ describe("processStream (reasoning)", () => {
     );
   });
 });
+describe("processStream (stop)", () => {
+  it("clears the stop state when a cancelled run ends its stream", async () => {
+    const { setters, getUi } = createSetters();
+    setters.setUi((prev) => ({ ...prev, isProcessing: false, isCancelling: true }));
+    await processStream(
+      eventStream([{ name: "llm:thinking", sessionId: "test-session" }]),
+      setters,
+      {
+        useStreaming: true,
+        autoApproveEditsRef: { current: false },
+        bypassPermissionsRef: { current: false },
+        eventBus: { emit: vi.fn() }
+      }
+    );
+    expect(getUi().isCancelling).toBe(false);
+  });
+});

package/dist/signal/background.cjs

@@ -0,0 +1,154 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var background_exports = {};
+__export(background_exports, {
+  BACKGROUND_QUERY: () => BACKGROUND_QUERY,
+  BACKGROUND_TIMEOUT_MS: () => BACKGROUND_TIMEOUT_MS,
+  createTerminalReplyFilter: () => createTerminalReplyFilter,
+  detectBackgroundTheme: () => detectBackgroundTheme,
+  parseBackgroundReply: () => parseBackgroundReply,
+  queryBackgroundTheme: () => queryBackgroundTheme,
+  shouldQueryBackground: () => shouldQueryBackground
+});
+module.exports = __toCommonJS(background_exports);
+var import_caps = require("./caps.js");
+const BACKGROUND_QUERY = "\x1B]11;?\x07\x1B[c";
+const BACKGROUND_TIMEOUT_MS = 250;
+const OSC11_REPLY = /\x1b\]11;rgba?:([0-9a-f]{1,4})\/([0-9a-f]{1,4})\/([0-9a-f]{1,4})/i;
+const DA1_REPLY = /\x1b\[\?[\d;]*c/;
+function channel(hex) {
+  return parseInt(hex, 16) / (16 ** hex.length - 1);
+}
+function parseBackgroundReply(data) {
+  const match = OSC11_REPLY.exec(data);
+  if (match === null) return null;
+  const [r, g, b] = [match[1], match[2], match[3]].map((hex) => channel(hex ?? ""));
+  if (r === void 0 || g === void 0 || b === void 0) return null;
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b >= 0.5 ? "light" : "dark";
+}
+function shouldQueryBackground(caps, stdinIsTTY) {
+  return caps.palette === "signal" && caps.color !== "none" && caps.tty && stdinIsTTY;
+}
+function queryBackgroundTheme(io, timeoutMs) {
+  const { stdin, stdout } = io;
+  const wasRaw = stdin.isRaw === true;
+  return new Promise((resolve) => {
+    let received = "";
+    const finish = () => {
+      clearTimeout(timer);
+      stdin.removeListener("data", onData);
+      stdin.setRawMode?.(wasRaw);
+      stdin.pause();
+      const { keys, held } = stripReplies(received);
+      const rest = keys + held;
+      if (rest !== "") stdin.unshift(Buffer.from(rest, "latin1"));
+      resolve(parseBackgroundReply(received));
+    };
+    const onData = (chunk) => {
+      received += (typeof chunk === "string" ? Buffer.from(chunk) : chunk).toString("latin1");
+      if (DA1_REPLY.test(received)) finish();
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    stdin.setRawMode?.(true);
+    stdin.on("data", onData);
+    stdin.resume();
+    stdout.write(BACKGROUND_QUERY);
+  });
+}
+const MAX_REPLY_LENGTH = 64;
+function scanOscReply(s, at) {
+  if (s.length < at + 3) return "none";
+  for (let k = 2; k < 5; k++) {
+    const ch = s[at + k];
+    if (ch === void 0) return "partial";
+    const ok = k === 2 ? ch === "1" : k === 3 ? ch === "0" || ch === "1" : ch === ";";
+    if (!ok) return "none";
+  }
+  for (let i = at + 5; i < s.length && i - at <= MAX_REPLY_LENGTH; i++) {
+    const ch = s[i] ?? "";
+    if (ch === "\x07") return i + 1;
+    if (ch === "\x1B") {
+      const next = s[i + 1];
+      if (next === void 0) return "partial";
+      return next === "\\" ? i + 2 : "none";
+    }
+    if (!/[0-9a-z:/]/i.test(ch)) return "none";
+  }
+  return s.length - at > MAX_REPLY_LENGTH ? "none" : "partial";
+}
+function scanDa1Reply(s, at) {
+  if (s[at + 2] !== "?") return "none";
+  for (let i = at + 3; i < s.length && i - at <= MAX_REPLY_LENGTH; i++) {
+    const ch = s[i] ?? "";
+    if (ch === "c") return i + 1;
+    if (!/[\d;]/.test(ch)) return "none";
+  }
+  return s.length - at > MAX_REPLY_LENGTH ? "none" : "partial";
+}
+function scanReply(s, at) {
+  const kind = s[at + 1];
+  if (kind === "]") return scanOscReply(s, at);
+  if (kind === "[") return scanDa1Reply(s, at);
+  return "none";
+}
+function stripReplies(input) {
+  let keys = "";
+  let i = 0;
+  while (i < input.length) {
+    const esc = input.indexOf("\x1B", i);
+    if (esc === -1) {
+      keys += input.slice(i);
+      break;
+    }
+    keys += input.slice(i, esc);
+    const end = scanReply(input, esc);
+    if (end === "partial") return { keys, held: input.slice(esc) };
+    if (end === "none") {
+      keys += "\x1B";
+      i = esc + 1;
+    } else {
+      i = end;
+    }
+  }
+  return { keys, held: "" };
+}
+function createTerminalReplyFilter() {
+  let held = "";
+  return (data) => {
+    const result = stripReplies(held + data);
+    held = result.held;
+    return result.keys;
+  };
+}
+async function detectBackgroundTheme(io) {
+  const caps = (0, import_caps.getCaps)();
+  if (!shouldQueryBackground(caps, io.stdin.isTTY === true)) return;
+  const theme = await queryBackgroundTheme(io, BACKGROUND_TIMEOUT_MS);
+  if (theme !== null && theme !== caps.theme) (0, import_caps.setCaps)({ ...(0, import_caps.getCaps)(), theme });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BACKGROUND_QUERY,
+  BACKGROUND_TIMEOUT_MS,
+  createTerminalReplyFilter,
+  detectBackgroundTheme,
+  parseBackgroundReply,
+  queryBackgroundTheme,
+  shouldQueryBackground
+});

package/dist/signal/background.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Asks the terminal for its background colour (OSC 11) so the Signal palette picks its dark or
+ * light set from what is actually on screen, not from COLORFGBG alone.
+ *
+ * The query is followed by DA1 (primary device attributes), which every terminal answers. That
+ * reply marks the end: a terminal that ignores OSC 11 costs one round trip, not the timeout.
+ * Runs once at start-up, before Ink takes stdin.
+ */
+import { type Caps, type ThemeName } from './caps.js';
+export declare const BACKGROUND_QUERY = "\u001B]11;?\u0007\u001B[c";
+/** How long to wait for a terminal that answers neither query (a pipe dressed as a TTY). */
+export declare const BACKGROUND_TIMEOUT_MS = 250;
+/** The theme for an OSC 11 reply found anywhere in `data`, or null when there is none. */
+export declare function parseBackgroundReply(data: string): ThemeName | null;
+/** Only the Signal palette reads the theme, and only a colour TTY can answer. */
+export declare function shouldQueryBackground(caps: Caps, stdinIsTTY: boolean): boolean;
+export interface TerminalIO {
+    stdin: NodeJS.ReadableStream & {
+        isTTY?: boolean;
+        isRaw?: boolean;
+        setRawMode?: (mode: boolean) => unknown;
+    };
+    stdout: {
+        write: (chunk: string) => boolean;
+    };
+}
+/**
+ * Sends the query and resolves with the background's theme, or null when the terminal does not
+ * say. Everything read that is not a complete reply goes back onto stdin byte for byte: keys
+ * typed during start-up, a UTF-8 character cut off by the timeout, and the start of a reply cut
+ * off by it (the keypress filter drops the rest of that reply when it arrives). Leaves stdin
+ * paused and in the raw mode it found it in.
+ */
+export declare function queryBackgroundTheme(io: TerminalIO, timeoutMs: number): Promise<ThemeName | null>;
+/**
+ * Removes OSC 10/11 and DA1 replies from keyboard input, holding back the start of one that is
+ * split across chunks. Sits in front of the keypress parser so a reply that arrives after
+ * `queryBackgroundTheme` gave up never becomes prompt text. One filter per input stream.
+ */
+export declare function createTerminalReplyFilter(): (data: string) => string;
+/** Refines the process-wide caps' theme from the terminal's background, when it can tell. */
+export declare function detectBackgroundTheme(io: TerminalIO): Promise<void>;
+//# sourceMappingURL=background.d.ts.map

package/dist/signal/background.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"background.d.ts","sourceRoot":"","sources":["../../src/signal/background.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAoB,KAAK,IAAI,EAAE,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAExE,eAAO,MAAM,gBAAgB,8BAAwB,CAAC;AAEtD,4FAA4F;AAC5F,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAYzC,0FAA0F;AAC1F,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAMnE;AAED,iFAAiF;AACjF,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,GAAG,OAAO,CAE9E;AAED,MAAM,WAAW,UAAU;IACvB,KAAK,EAAE,MAAM,CAAC,cAAc,GAAG;QAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC;KAC3C,CAAC;IACF,MAAM,EAAE;QAAE,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAA;KAAE,CAAC;CACjD;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CA0BjG;AA0ED;;;;GAIG;AACH,wBAAgB,yBAAyB,IAAI,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAOpE;AAED,6FAA6F;AAC7F,wBAAsB,qBAAqB,CAAC,EAAE,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAKzE"}

package/dist/signal/background.js

@@ -0,0 +1,124 @@
+import { getCaps, setCaps } from "./caps.js";
+const BACKGROUND_QUERY = "\x1B]11;?\x07\x1B[c";
+const BACKGROUND_TIMEOUT_MS = 250;
+const OSC11_REPLY = /\x1b\]11;rgba?:([0-9a-f]{1,4})\/([0-9a-f]{1,4})\/([0-9a-f]{1,4})/i;
+const DA1_REPLY = /\x1b\[\?[\d;]*c/;
+function channel(hex) {
+  return parseInt(hex, 16) / (16 ** hex.length - 1);
+}
+function parseBackgroundReply(data) {
+  const match = OSC11_REPLY.exec(data);
+  if (match === null) return null;
+  const [r, g, b] = [match[1], match[2], match[3]].map((hex) => channel(hex ?? ""));
+  if (r === void 0 || g === void 0 || b === void 0) return null;
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b >= 0.5 ? "light" : "dark";
+}
+function shouldQueryBackground(caps, stdinIsTTY) {
+  return caps.palette === "signal" && caps.color !== "none" && caps.tty && stdinIsTTY;
+}
+function queryBackgroundTheme(io, timeoutMs) {
+  const { stdin, stdout } = io;
+  const wasRaw = stdin.isRaw === true;
+  return new Promise((resolve) => {
+    let received = "";
+    const finish = () => {
+      clearTimeout(timer);
+      stdin.removeListener("data", onData);
+      stdin.setRawMode?.(wasRaw);
+      stdin.pause();
+      const { keys, held } = stripReplies(received);
+      const rest = keys + held;
+      if (rest !== "") stdin.unshift(Buffer.from(rest, "latin1"));
+      resolve(parseBackgroundReply(received));
+    };
+    const onData = (chunk) => {
+      received += (typeof chunk === "string" ? Buffer.from(chunk) : chunk).toString("latin1");
+      if (DA1_REPLY.test(received)) finish();
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    stdin.setRawMode?.(true);
+    stdin.on("data", onData);
+    stdin.resume();
+    stdout.write(BACKGROUND_QUERY);
+  });
+}
+const MAX_REPLY_LENGTH = 64;
+function scanOscReply(s, at) {
+  if (s.length < at + 3) return "none";
+  for (let k = 2; k < 5; k++) {
+    const ch = s[at + k];
+    if (ch === void 0) return "partial";
+    const ok = k === 2 ? ch === "1" : k === 3 ? ch === "0" || ch === "1" : ch === ";";
+    if (!ok) return "none";
+  }
+  for (let i = at + 5; i < s.length && i - at <= MAX_REPLY_LENGTH; i++) {
+    const ch = s[i] ?? "";
+    if (ch === "\x07") return i + 1;
+    if (ch === "\x1B") {
+      const next = s[i + 1];
+      if (next === void 0) return "partial";
+      return next === "\\" ? i + 2 : "none";
+    }
+    if (!/[0-9a-z:/]/i.test(ch)) return "none";
+  }
+  return s.length - at > MAX_REPLY_LENGTH ? "none" : "partial";
+}
+function scanDa1Reply(s, at) {
+  if (s[at + 2] !== "?") return "none";
+  for (let i = at + 3; i < s.length && i - at <= MAX_REPLY_LENGTH; i++) {
+    const ch = s[i] ?? "";
+    if (ch === "c") return i + 1;
+    if (!/[\d;]/.test(ch)) return "none";
+  }
+  return s.length - at > MAX_REPLY_LENGTH ? "none" : "partial";
+}
+function scanReply(s, at) {
+  const kind = s[at + 1];
+  if (kind === "]") return scanOscReply(s, at);
+  if (kind === "[") return scanDa1Reply(s, at);
+  return "none";
+}
+function stripReplies(input) {
+  let keys = "";
+  let i = 0;
+  while (i < input.length) {
+    const esc = input.indexOf("\x1B", i);
+    if (esc === -1) {
+      keys += input.slice(i);
+      break;
+    }
+    keys += input.slice(i, esc);
+    const end = scanReply(input, esc);
+    if (end === "partial") return { keys, held: input.slice(esc) };
+    if (end === "none") {
+      keys += "\x1B";
+      i = esc + 1;
+    } else {
+      i = end;
+    }
+  }
+  return { keys, held: "" };
+}
+function createTerminalReplyFilter() {
+  let held = "";
+  return (data) => {
+    const result = stripReplies(held + data);
+    held = result.held;
+    return result.keys;
+  };
+}
+async function detectBackgroundTheme(io) {
+  const caps = getCaps();
+  if (!shouldQueryBackground(caps, io.stdin.isTTY === true)) return;
+  const theme = await queryBackgroundTheme(io, BACKGROUND_TIMEOUT_MS);
+  if (theme !== null && theme !== caps.theme) setCaps({ ...getCaps(), theme });
+}
+export {
+  BACKGROUND_QUERY,
+  BACKGROUND_TIMEOUT_MS,
+  createTerminalReplyFilter,
+  detectBackgroundTheme,
+  parseBackgroundReply,
+  queryBackgroundTheme,
+  shouldQueryBackground
+};

package/dist/signal/background.test.cjs

@@ -0,0 +1,186 @@
+"use strict";
+var import_node_stream = require("node:stream");
+var import_vitest = require("vitest");
+var import_caps = require("./caps.js");
+var import_background = require("./background.js");
+const caps = {
+  tty: true,
+  color: "truecolor",
+  glyphs: "unicode",
+  logo: "quadrant",
+  theme: "dark",
+  motion: "full",
+  palette: "signal"
+};
+const DA1 = "\x1B[?62;22c";
+(0, import_vitest.describe)("parseBackgroundReply", () => {
+  (0, import_vitest.it)("reads a dark and a light background, with either terminator", () => {
+    (0, import_vitest.expect)((0, import_background.parseBackgroundReply)("\x1B]11;rgb:1e1e/1e1e/1e1e\x07")).toBe("dark");
+    (0, import_vitest.expect)((0, import_background.parseBackgroundReply)("\x1B]11;rgb:ffff/ffff/ffff\x1B\\")).toBe("light");
+  });
+  (0, import_vitest.it)("accepts one to four hex digits per channel, and rgba", () => {
+    (0, import_vitest.expect)((0, import_background.parseBackgroundReply)("\x1B]11;rgb:f/f/f\x07")).toBe("light");
+    (0, import_vitest.expect)((0, import_background.parseBackgroundReply)("\x1B]11;rgb:fd/f6/e3\x07")).toBe("light");
+    (0, import_vitest.expect)((0, import_background.parseBackgroundReply)("\x1B]11;rgba:0000/2b2b/3636/ffff\x07")).toBe("dark");
+  });
+  (0, import_vitest.it)("weighs green over blue, as the eye does", () => {
+    (0, import_vitest.expect)((0, import_background.parseBackgroundReply)("\x1B]11;rgb:0000/c0c0/0000\x07")).toBe("light");
+    (0, import_vitest.expect)((0, import_background.parseBackgroundReply)("\x1B]11;rgb:0000/0000/ffff\x07")).toBe("dark");
+  });
+  (0, import_vitest.it)("finds the reply among other bytes, and returns null when there is none", () => {
+    (0, import_vitest.expect)((0, import_background.parseBackgroundReply)(`junk\x1B]11;rgb:ffff/ffff/ffff\x07${DA1}`)).toBe("light");
+    (0, import_vitest.expect)((0, import_background.parseBackgroundReply)(DA1)).toBeNull();
+    (0, import_vitest.expect)((0, import_background.parseBackgroundReply)("\x1B]11;rgb:zz/00/00\x07")).toBeNull();
+  });
+});
+(0, import_vitest.describe)("shouldQueryBackground", () => {
+  (0, import_vitest.it)("asks only when the Signal palette will use the answer on a colour TTY", () => {
+    (0, import_vitest.expect)((0, import_background.shouldQueryBackground)(caps, true)).toBe(true);
+    (0, import_vitest.expect)((0, import_background.shouldQueryBackground)({ ...caps, palette: "legacy" }, true)).toBe(false);
+    (0, import_vitest.expect)((0, import_background.shouldQueryBackground)({ ...caps, color: "none" }, true)).toBe(false);
+    (0, import_vitest.expect)((0, import_background.shouldQueryBackground)({ ...caps, tty: false }, true)).toBe(false);
+    (0, import_vitest.expect)((0, import_background.shouldQueryBackground)(caps, false)).toBe(false);
+  });
+});
+function fakeTerminal(reply) {
+  const stdin = Object.assign(new import_node_stream.PassThrough(), {
+    isTTY: true,
+    isRaw: false,
+    setRawMode: import_vitest.vi.fn(function(mode) {
+      this.isRaw = mode;
+      return this;
+    })
+  });
+  const written = [];
+  const stdout = {
+    write: (chunk) => {
+      written.push(chunk);
+      const answer = reply?.(chunk) ?? null;
+      if (answer !== null) setTimeout(() => stdin.write(answer), 0);
+      return true;
+    }
+  };
+  const io = { stdin, stdout };
+  return { io, stdin, written };
+}
+(0, import_vitest.describe)("queryBackgroundTheme", () => {
+  (0, import_vitest.it)("sends OSC 11 then DA1, and reads the theme from the reply", async () => {
+    const { io, written } = fakeTerminal(() => `\x1B]11;rgb:ffff/ffff/ffff\x07${DA1}`);
+    await (0, import_vitest.expect)((0, import_background.queryBackgroundTheme)(io, 500)).resolves.toBe("light");
+    (0, import_vitest.expect)(written).toEqual([import_background.BACKGROUND_QUERY]);
+  });
+  (0, import_vitest.it)("stops at the DA1 reply when the terminal does not answer OSC 11", async () => {
+    const { io } = fakeTerminal(() => DA1);
+    const started = Date.now();
+    await (0, import_vitest.expect)((0, import_background.queryBackgroundTheme)(io, 5e3)).resolves.toBeNull();
+    (0, import_vitest.expect)(Date.now() - started).toBeLessThan(1e3);
+  });
+  (0, import_vitest.it)("gives up after the timeout when nothing answers", async () => {
+    const { io } = fakeTerminal(null);
+    await (0, import_vitest.expect)((0, import_background.queryBackgroundTheme)(io, 20)).resolves.toBeNull();
+  });
+  (0, import_vitest.it)("handles a reply split across chunks", async () => {
+    const { io, stdin } = fakeTerminal(() => null);
+    const pending = (0, import_background.queryBackgroundTheme)(io, 500);
+    stdin.write("\x1B]11;rgb:00");
+    stdin.write(`00/0000/0000\x07${DA1}`);
+    await (0, import_vitest.expect)(pending).resolves.toBe("dark");
+  });
+  (0, import_vitest.it)("puts stdin back as it found it", async () => {
+    const { io, stdin } = fakeTerminal(() => DA1);
+    await (0, import_background.queryBackgroundTheme)(io, 500);
+    (0, import_vitest.expect)(stdin.setRawMode).toHaveBeenLastCalledWith(false);
+    (0, import_vitest.expect)(stdin.isRaw).toBe(false);
+    (0, import_vitest.expect)(stdin.listenerCount("data")).toBe(0);
+    (0, import_vitest.expect)(stdin.isPaused()).toBe(true);
+  });
+});
+(0, import_vitest.describe)("detectBackgroundTheme", () => {
+  (0, import_vitest.it)("updates the caps theme from the reply on the Signal palette", async () => {
+    const saved = (0, import_caps.getCaps)();
+    (0, import_caps.setCaps)({ ...caps, theme: "dark" });
+    try {
+      const { io } = fakeTerminal(() => `\x1B]11;rgb:ffff/ffff/ffff\x07${DA1}`);
+      await (0, import_background.detectBackgroundTheme)(io);
+      (0, import_vitest.expect)((0, import_caps.getCaps)().theme).toBe("light");
+    } finally {
+      (0, import_caps.setCaps)(saved);
+    }
+  });
+  (0, import_vitest.it)("sends nothing on the legacy palette", async () => {
+    const saved = (0, import_caps.getCaps)();
+    (0, import_caps.setCaps)({ ...caps, palette: "legacy" });
+    try {
+      const { io, written } = fakeTerminal(() => DA1);
+      await (0, import_background.detectBackgroundTheme)(io);
+      (0, import_vitest.expect)(written).toEqual([]);
+    } finally {
+      (0, import_caps.setCaps)(saved);
+    }
+  });
+});
+(0, import_vitest.describe)("queryBackgroundTheme keeps what the user typed", () => {
+  (0, import_vitest.it)("hands bytes that are not part of the reply back to stdin", async () => {
+    const { io, stdin } = fakeTerminal(
+      () => `\x1B]11;rgb:ffff/ffff/ffff\x07summarize this\r${DA1}`
+    );
+    await (0, import_vitest.expect)((0, import_background.queryBackgroundTheme)(io, 500)).resolves.toBe("light");
+    (0, import_vitest.expect)(String(stdin.read())).toBe("summarize this\r");
+  });
+  (0, import_vitest.it)("hands back nothing when only the replies arrived", async () => {
+    const { io, stdin } = fakeTerminal(() => `\x1B]11;rgb:ffff/ffff/ffff\x07${DA1}`);
+    await (0, import_background.queryBackgroundTheme)(io, 500);
+    (0, import_vitest.expect)(stdin.read()).toBeNull();
+  });
+});
+(0, import_vitest.describe)("createTerminalReplyFilter", () => {
+  const OSC = "\x1B]11;rgb:ffff/ffff/ffff";
+  (0, import_vitest.it)("drops background and DA1 replies, with either terminator", () => {
+    const filter = (0, import_background.createTerminalReplyFilter)();
+    (0, import_vitest.expect)(filter(`${OSC}\x07`)).toBe("");
+    (0, import_vitest.expect)(filter(`${OSC}\x1B\\`)).toBe("");
+    (0, import_vitest.expect)(filter(DA1)).toBe("");
+    (0, import_vitest.expect)(filter("\x1B]10;rgb:0/0/0\x07")).toBe("");
+  });
+  (0, import_vitest.it)("keeps the keys around a reply", () => {
+    const filter = (0, import_background.createTerminalReplyFilter)();
+    (0, import_vitest.expect)(filter(`ab${OSC}\x07cd${DA1}e`)).toBe("abcde");
+  });
+  (0, import_vitest.it)("drops a reply split across chunks", () => {
+    const filter = (0, import_background.createTerminalReplyFilter)();
+    (0, import_vitest.expect)(filter("x\x1B]11;rgb:ff")).toBe("x");
+    (0, import_vitest.expect)(filter("ff/ffff/ffff\x07y\x1B[?6")).toBe("y");
+    (0, import_vitest.expect)(filter("2;22cz")).toBe("z");
+  });
+  (0, import_vitest.it)("passes keyboard escapes through untouched", () => {
+    const filter = (0, import_background.createTerminalReplyFilter)();
+    (0, import_vitest.expect)(filter("\x1B")).toBe("\x1B");
+    (0, import_vitest.expect)(filter("\x1B]")).toBe("\x1B]");
+    (0, import_vitest.expect)(filter("\x1B[")).toBe("\x1B[");
+    (0, import_vitest.expect)(filter("\x1B[A\x1B[1;5C\x1B[<0;10;5M")).toBe("\x1B[A\x1B[1;5C\x1B[<0;10;5M");
+    (0, import_vitest.expect)(filter("\x1B]a")).toBe("\x1B]a");
+  });
+  (0, import_vitest.it)("releases held bytes that turn out not to be a reply", () => {
+    const filter = (0, import_background.createTerminalReplyFilter)();
+    (0, import_vitest.expect)(filter("\x1B]11;rgb")).toBe("");
+    (0, import_vitest.expect)(filter(" hello")).toBe("\x1B]11;rgb hello");
+  });
+});
+(0, import_vitest.describe)("queryBackgroundTheme hands back unfinished input as raw bytes", () => {
+  (0, import_vitest.it)("returns a reply cut off by the timeout, so the keypress filter can finish dropping it", async () => {
+    const { io, stdin } = fakeTerminal(() => "\x1B]11;rgb:ff");
+    await (0, import_vitest.expect)((0, import_background.queryBackgroundTheme)(io, 50)).resolves.toBeNull();
+    const handedBack = String(stdin.read());
+    (0, import_vitest.expect)(handedBack).toBe("\x1B]11;rgb:ff");
+    const filter = (0, import_background.createTerminalReplyFilter)();
+    (0, import_vitest.expect)(filter(handedBack) + filter("ff/ffff/ffff\x07a")).toBe("a");
+  });
+  (0, import_vitest.it)("returns a UTF-8 character cut off by the timeout unchanged", async () => {
+    const { io, stdin } = fakeTerminal(() => null);
+    const pending = (0, import_background.queryBackgroundTheme)(io, 50);
+    stdin.write(Buffer.from([104, 226]));
+    await (0, import_vitest.expect)(pending).resolves.toBeNull();
+    const handedBack = stdin.read();
+    (0, import_vitest.expect)(Buffer.concat([handedBack, Buffer.from([130, 172])]).toString("utf8")).toBe("h\u20AC");
+  });
+});

package/dist/signal/background.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=background.test.d.ts.map

package/dist/signal/background.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"background.test.d.ts","sourceRoot":"","sources":["../../src/signal/background.test.ts"],"names":[],"mappings":""}