@cueloop/client 0.1.0-alpha.0 → 0.1.0-alpha.100

package/src/integrations/components/share-dialog-store.ts

@@ -0,0 +1,55 @@
+/**
+ * UI state for the share dialog, held in a zustand store rather than juggled
+ * across component state: which category is open (share externally / export),
+ * whether the link wizard is showing, and the wizard's draft (name, auth,
+ * allowlist). The links themselves live on the thread; this is only the
+ * ephemeral surface state.
+ */
+
+import { createStore } from "zustand/vanilla";
+import { useStore } from "zustand";
+
+export type ShareCategory = "external" | "export";
+
+export interface ShareWizardDraft {
+  editingId: string | null;
+  name: string;
+  requireAuth: boolean;
+  allowlist: string[];
+}
+
+export interface ShareDialogState {
+  category: ShareCategory;
+  wizard: ShareWizardDraft | null;
+  setCategory: (category: ShareCategory) => void;
+  openWizard: (draft: ShareWizardDraft) => void;
+  closeWizard: () => void;
+  setName: (name: string) => void;
+  setRequireAuth: (requireAuth: boolean) => void;
+  setAllowlist: (allowlist: string[]) => void;
+  reset: () => void;
+}
+
+/** A fresh wizard draft, prefilled with the thread name for a new link. */
+export function newWizardDraft(threadName: string): ShareWizardDraft {
+  return { editingId: null, name: threadName, requireAuth: false, allowlist: [] };
+}
+
+export const shareDialogStore = createStore<ShareDialogState>((set) => ({
+  category: "external",
+  wizard: null,
+  setCategory: (category) => set({ category }),
+  openWizard: (wizard) => set({ wizard }),
+  closeWizard: () => set({ wizard: null }),
+  setName: (name) => set((state) => (state.wizard ? { wizard: { ...state.wizard, name } } : {})),
+  setRequireAuth: (requireAuth) =>
+    set((state) => (state.wizard ? { wizard: { ...state.wizard, requireAuth } } : {})),
+  setAllowlist: (allowlist) =>
+    set((state) => (state.wizard ? { wizard: { ...state.wizard, allowlist } } : {})),
+  reset: () => set({ category: "external", wizard: null }),
+}));
+
+/** Subscribe a component to the share dialog store. */
+export function useShareDialog<T>(selector: (state: ShareDialogState) => T): T {
+  return useStore(shareDialogStore, selector);
+}

package/src/integrations/editor.test.ts

@@ -0,0 +1,149 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { editInEditor, resolveEditor, resolveEditorCommand } from "./editor";
+
+describe("resolveEditor", () => {
+  test("a clean environment falls back to nano so editing always works", () => {
+    // Assert
+    expect(resolveEditor(undefined, {})).toBe("nano");
+  });
+
+  test("the environment chain wins in order: CUELOOP_EDITOR, VISUAL, EDITOR", () => {
+    // Assert
+    expect(resolveEditor(undefined, { EDITOR: "vim", VISUAL: "code", CUELOOP_EDITOR: "hx" })).toBe(
+      "hx",
+    );
+    expect(resolveEditor(undefined, { EDITOR: "vim", VISUAL: "code" })).toBe("code");
+    expect(resolveEditor(undefined, { EDITOR: "vim" })).toBe("vim");
+  });
+
+  test("the [ui] editor config overrides the environment", () => {
+    // Assert
+    expect(resolveEditor("code --wait", { EDITOR: "vim" })).toBe("code --wait");
+  });
+});
+
+describe("resolveEditorCommand", () => {
+  test("a known GUI editor gets its wait flag appended and is trusted to wait", () => {
+    // Assert
+    expect(resolveEditorCommand("code")).toEqual({ argv: ["code", "--wait"], waits: true });
+    expect(resolveEditorCommand("subl")).toEqual({
+      argv: ["subl", "--new-window", "--wait"],
+      waits: true,
+    });
+  });
+
+  test("an existing wait flag is not duplicated", () => {
+    // Assert
+    expect(resolveEditorCommand("code --wait").argv).toEqual(["code", "--wait"]);
+  });
+
+  test("a terminal editor is left alone and trusted to hold the tty", () => {
+    // Assert
+    expect(resolveEditorCommand("vim")).toEqual({ argv: ["vim"], waits: true });
+  });
+
+  test("an unknown editor is neither flagged nor trusted to wait", () => {
+    // Assert
+    expect(resolveEditorCommand("my-editor")).toEqual({ argv: ["my-editor"], waits: false });
+  });
+});
+
+describe("editInEditor", () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), "cueloop-edit-test-"));
+  });
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  /** A runnable editor stub with a chosen base name and body. */
+  function stubEditor(name: string, body: string): string {
+    const script = join(dir, name);
+
+    writeFileSync(script, `#!/bin/sh\n${body}\n`);
+    chmodSync(script, 0o755);
+
+    return script;
+  }
+
+  const instant = (): (() => number) => {
+    let value = 0;
+
+    return () => (value += 5);
+  };
+
+  test("an editor that changes the file reports the new content", () => {
+    // Act
+    const result = editInEditor("old", "plan.md", {
+      editor: stubEditor("writer.sh", `printf 'new' > "$1"`),
+    });
+
+    // Assert
+    expect(result).toEqual({ content: "new", changed: true });
+  });
+
+  test("a fast, unchanged return opens the gate; confirming re-reads the saved file", () => {
+    // Arrange
+    let askedLabel = "";
+
+    // Act
+    const result = editInEditor("keep", "plan.md", {
+      editor: stubEditor("gui-like.sh", "exit 0"),
+      now: instant(),
+      confirmSaved: (label, path) => {
+        askedLabel = label;
+        writeFileSync(path, "saved in the GUI");
+
+        return true;
+      },
+    });
+
+    // Assert
+    expect(askedLabel).toContain("gui-like.sh");
+    expect(result).toEqual({ content: "saved in the GUI", changed: true });
+  });
+
+  test("declining the gate keeps the original content", () => {
+    // Act
+    const result = editInEditor("keep", "plan.md", {
+      editor: stubEditor("gui-like.sh", "exit 0"),
+      now: instant(),
+      confirmSaved: () => false,
+    });
+
+    // Assert
+    expect(result).toEqual({ content: "keep", changed: false });
+  });
+
+  test("a terminal editor that makes no change never opens the gate", () => {
+    // Arrange
+    let asked = false;
+
+    // Act
+    const result = editInEditor("keep", "plan.md", {
+      editor: stubEditor("vi", "exit 0"),
+      now: instant(),
+      confirmSaved: () => {
+        asked = true;
+
+        return true;
+      },
+    });
+
+    // Assert
+    expect(asked).toBeFalse();
+    expect(result).toEqual({ content: "keep", changed: false });
+  });
+
+  test("a nonzero editor exit throws", () => {
+    // Assert
+    expect(() => editInEditor("x", "plan.md", { editor: stubEditor("fail.sh", "exit 3") })).toThrow(
+      "editor exited 3",
+    );
+  });
+});

package/src/integrations/editor.ts

@@ -0,0 +1,160 @@
+/**
+ * File-level edit mode = the editor hand-off: write the working copy to a temp
+ * file, run the reviewer's editor on it, read the result back. Editing must
+ * work with zero configuration, so the resolution chain ends in a terminal
+ * fallback that is always present. A GUI editor launched without a wait flag
+ * forks and returns instantly, losing the edit silently; known GUI editors get
+ * their wait flag applied, and any editor that still returns right away with an
+ * untouched file drops to a confirm gate rather than discarding the work.
+ */
+
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+export interface EditResult {
+  content: string;
+  changed: boolean;
+}
+
+/** Present on every POSIX system, so a clean shell can still edit. */
+const DEFAULT_EDITOR = "nano";
+
+/** GUI editors fork and return immediately unless given their wait flag. */
+interface GuiWaitFlags {
+  [editor: string]: string[];
+}
+
+const GUI_WAIT_FLAGS: GuiWaitFlags = {
+  code: ["--wait"],
+  "code-insiders": ["--wait"],
+  codium: ["--wait"],
+  cursor: ["--wait"],
+  windsurf: ["--wait"],
+  subl: ["--new-window", "--wait"],
+  sublime_text: ["--new-window", "--wait"],
+  zed: ["--wait"],
+  bbedit: ["--wait"],
+  mate: ["--wait"],
+  gedit: ["--wait"],
+  kate: ["--block"],
+  idea: ["--wait"],
+  webstorm: ["--wait"],
+};
+
+/** Editors that hold the terminal themselves - never GUI, never a wait gate. */
+const TERMINAL_EDITORS = new Set([
+  "vi",
+  "vim",
+  "nvim",
+  "nano",
+  "pico",
+  "emacs",
+  "emacsclient",
+  "micro",
+  "hx",
+  "helix",
+  "kak",
+  "ed",
+  "joe",
+  "mcedit",
+]);
+
+export interface ResolvedEditor {
+  argv: string[];
+  waits: boolean;
+}
+
+/** The editor to run: [ui] editor, then the environment chain, then nano. */
+export function resolveEditor(
+  configuredEditor: string | undefined,
+  env: Record<string, string | undefined> = process.env,
+): string {
+  const candidates = [configuredEditor, env.CUELOOP_EDITOR, env.VISUAL, env.EDITOR];
+
+  return candidates.find((candidate) => candidate && candidate.trim())?.trim() ?? DEFAULT_EDITOR;
+}
+
+function editorBaseName(command: string): string {
+  return (command.split(/[\\/]/).pop() ?? command).toLowerCase();
+}
+
+/** Split the editor string and apply a GUI wait flag when we know one. */
+export function resolveEditorCommand(rawEditor: string): ResolvedEditor {
+  const parts = rawEditor.trim().split(/\s+/);
+  const base = editorBaseName(parts[0] ?? "");
+
+  if (TERMINAL_EDITORS.has(base)) return { argv: parts, waits: true };
+  const waitFlags = GUI_WAIT_FLAGS[base];
+
+  if (waitFlags) {
+    const alreadyWaits = parts.some(
+      (part) => part === "--wait" || part === "-w" || part === "--block",
+    );
+
+    return { argv: alreadyWaits ? parts : [...parts, ...waitFlags], waits: true };
+  }
+
+  return { argv: parts, waits: false };
+}
+
+/** A fast return with an untouched file means the editor probably did not wait. */
+const NO_WAIT_THRESHOLD_MS = 1000;
+
+function suspectsNoWait(resolved: ResolvedEditor, elapsedMs: number, unchanged: boolean): boolean {
+  if (resolved.waits) return false; // holds the terminal or has a wait flag - trust the exit
+  if (!unchanged) return false; // edits landed, so it waited after all
+
+  return elapsedMs < NO_WAIT_THRESHOLD_MS;
+}
+
+export interface EditHandOff {
+  editor?: string;
+  env?: Record<string, string | undefined>;
+  confirmSaved?: (editorLabel: string, path: string) => boolean;
+  now?: () => number;
+}
+
+/** Prompt on the released terminal during the suspend window. */
+function promptSaved(editorLabel: string, path: string): boolean {
+  const answer = prompt(
+    `${editorLabel} returned immediately and the plan is unchanged - a GUI editor needs its wait flag. Save and close ${path}, then press Enter to load your edits (or type n to skip):`,
+  );
+
+  return answer !== null && answer.trim().toLowerCase() !== "n";
+}
+
+export function editInEditor(
+  content: string,
+  filename = "plan.md",
+  handOff: EditHandOff = {},
+): EditResult {
+  const env = handOff.env ?? process.env;
+  const now = handOff.now ?? Date.now;
+  const resolved = resolveEditorCommand(resolveEditor(handOff.editor, env));
+  const dir = mkdtempSync(join(tmpdir(), "cueloop-edit-"));
+  const path = join(dir, filename);
+
+  writeFileSync(path, content);
+  try {
+    const startedAt = now();
+    const editorProcess = Bun.spawnSync([...resolved.argv, path], {
+      stdin: "inherit",
+      stdout: "inherit",
+      stderr: "inherit",
+    });
+
+    if (editorProcess.exitCode !== 0) throw new Error(`editor exited ${editorProcess.exitCode}`);
+    let next = readFileSync(path, "utf8");
+
+    if (suspectsNoWait(resolved, now() - startedAt, next === content)) {
+      const confirm = handOff.confirmSaved ?? promptSaved;
+
+      if (confirm(resolved.argv[0] ?? "the editor", path)) next = readFileSync(path, "utf8");
+    }
+
+    return { content: next, changed: next !== content };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}

package/src/integrations/github-identity.test.ts

@@ -0,0 +1,58 @@
+import { afterEach, expect, test } from "bun:test";
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { resolveGithubIdentity } from "./github-identity";
+
+const originalBinary = process.env.CUELOOP_GH;
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+  if (originalBinary === undefined) delete process.env.CUELOOP_GH;
+  else process.env.CUELOOP_GH = originalBinary;
+  for (const directory of tempDirectories.splice(0)) {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
+
+function stubGithubCli(script: string): string {
+  const directory = mkdtempSync(join(tmpdir(), "gh-stub-"));
+
+  tempDirectories.push(directory);
+  const path = join(directory, "gh");
+
+  writeFileSync(path, `#!/bin/sh\n${script}\n`);
+  chmodSync(path, 0o755);
+
+  return path;
+}
+
+test("reads the GitHub login and name from gh", async () => {
+  process.env.CUELOOP_GH = stubGithubCli(`printf '{"login":"markus","name":"Markus M"}'`);
+
+  expect(await resolveGithubIdentity()).toEqual({ login: "markus", name: "Markus M" });
+});
+
+test("drops a null name to undefined", async () => {
+  process.env.CUELOOP_GH = stubGithubCli(`printf '{"login":"markus","name":null}'`);
+
+  expect(await resolveGithubIdentity()).toEqual({ login: "markus" });
+});
+
+test("falls back to null when gh exits non-zero (logged out)", async () => {
+  process.env.CUELOOP_GH = stubGithubCli(`exit 1`);
+
+  expect(await resolveGithubIdentity()).toBeNull();
+});
+
+test("falls back to null when gh is not installed", async () => {
+  process.env.CUELOOP_GH = join(tmpdir(), "cueloop-absent-gh-binary");
+
+  expect(await resolveGithubIdentity()).toBeNull();
+});
+
+test("falls back to null when gh prints an unexpected shape", async () => {
+  process.env.CUELOOP_GH = stubGithubCli(`printf 'not json'`);
+
+  expect(await resolveGithubIdentity()).toBeNull();
+});

package/src/integrations/github-identity.ts

@@ -0,0 +1,41 @@
+/** The signed-in GitHub identity from the local gh tool, or null when gh cannot answer. */
+
+import * as v from "valibot";
+
+export interface GithubIdentity {
+  login: string;
+  name?: string;
+}
+
+const GithubUserSchema = v.object({
+  login: v.string(),
+  name: v.nullish(v.string()),
+});
+
+/** The gh binary is injectable so tests stub it without a real GitHub login. */
+function githubCliBinary(): string {
+  return process.env.CUELOOP_GH || "gh";
+}
+
+/** Read the authenticated GitHub login and name, or null when gh cannot answer. */
+export async function resolveGithubIdentity(): Promise<GithubIdentity | null> {
+  try {
+    const githubProcess = Bun.spawn(
+      [githubCliBinary(), "api", "user", "--jq", "{login: .login, name: .name}"],
+      { stdout: "pipe", stderr: "ignore" },
+    );
+    const [output, exitCode] = await Promise.all([
+      new Response(githubProcess.stdout).text(),
+      githubProcess.exited,
+    ]);
+
+    if (exitCode !== 0) return null;
+    const parsed = v.safeParse(GithubUserSchema, JSON.parse(output));
+
+    if (!parsed.success) return null;
+
+    return { login: parsed.output.login, name: parsed.output.name ?? undefined };
+  } catch {
+    return null;
+  }
+}

package/src/integrations/herdr.test.ts

@@ -0,0 +1,43 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { focusHerdrPane } from "./herdr";
+
+let dir: string;
+
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), "cueloop-herdr-"));
+});
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true });
+});
+
+describe("focusHerdrPane", () => {
+  test("resolves the pane's tab and focuses it", () => {
+    // Arrange
+    const log = join(dir, "calls.log");
+    const stub = join(dir, "herdr");
+
+    writeFileSync(
+      stub,
+      `#!/bin/sh
+echo "$@" >> "${log}"
+if [ "$1" = "pane" ]; then echo '{"result":{"pane":{"tab_id":"w1:t3"}}}'; fi
+`,
+    );
+    Bun.spawnSync(["chmod", "+x", stub]);
+
+    // Assert
+    expect(focusHerdrPane(stub, "w1:p1")).toBe(true);
+    const calls = readFileSync(log, "utf8").trim().split("\n");
+
+    expect(calls[0]).toBe("pane get w1:p1");
+    expect(calls[1]).toBe("tab focus w1:t3");
+  });
+
+  test("a missing binary never throws", () => {
+    // Assert
+    expect(focusHerdrPane(join(dir, "nope"), "w1:p1")).toBe(false);
+  });
+});

package/src/integrations/herdr.ts

@@ -0,0 +1,38 @@
+/**
+ * First-class herdr return: a review opened beside an agent hands focus back
+ * to the agent's pane when it closes, not leaving the reviewer on a dead tab.
+ * The env contract and the return-target rule live in @cueloop/schema; this
+ * module owns the one reviewer-side action that spawns the herdr CLI. Focus
+ * is best-effort - a failure never blocks closing the review.
+ */
+
+import * as v from "valibot";
+
+const HerdrPaneSchema = v.object({
+  result: v.optional(v.object({ pane: v.optional(v.object({ tab_id: v.optional(v.string()) })) })),
+});
+
+/** Focus the tab holding the target pane. Synchronous: runs just before exit. */
+export function focusHerdrPane(binPath: string, paneId: string): boolean {
+  try {
+    const got = Bun.spawnSync([binPath, "pane", "get", paneId], {
+      stdout: "pipe",
+      stderr: "ignore",
+    });
+
+    if (got.exitCode !== 0) return false;
+    const parsed = v.safeParse(HerdrPaneSchema, JSON.parse(got.stdout.toString()));
+
+    if (!parsed.success) return false;
+    const tab = parsed.output.result?.pane?.tab_id;
+
+    if (!tab) return false;
+
+    return (
+      Bun.spawnSync([binPath, "tab", "focus", tab], { stdout: "ignore", stderr: "ignore" })
+        .exitCode === 0
+    );
+  } catch {
+    return false;
+  }
+}

package/src/integrations/integrations.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from "bun:test";
+import { OBSIDIAN_DEFAULTS } from "@cueloop/integration-obsidian";
+import { loadBundledExporters } from "./integrations";
+import type { IntegrationsConfig } from "../settings/config";
+
+function integrations(overrides: Partial<typeof OBSIDIAN_DEFAULTS> = {}): IntegrationsConfig {
+  return { obsidian: { ...OBSIDIAN_DEFAULTS, ...overrides } };
+}
+
+describe("loadBundledExporters", () => {
+  test("composes the obsidian integration into one named exporter", async () => {
+    // Act
+    const exporters = await loadBundledExporters(integrations());
+
+    // Assert
+    expect(exporters.map((exporter) => exporter.name)).toEqual(["obsidian"]);
+  });
+
+  test("runsOn mirrors the configured export policy", async () => {
+    // Arrange
+    const onApprove = (await loadBundledExporters(integrations({ exportOn: "approved" })))[0]!;
+
+    // Assert
+    expect(onApprove.runsOn("approved")).toBeTrue();
+    expect(onApprove.runsOn("changes_requested")).toBeFalse();
+
+    // Arrange
+    const onMessage = (await loadBundledExporters(integrations({ exportOn: "message" })))[0]!;
+
+    // Assert
+    expect(onMessage.runsOn("approved")).toBeTrue();
+    expect(onMessage.runsOn("changes_requested")).toBeTrue();
+
+    // Arrange
+    const manual = (await loadBundledExporters(integrations({ exportOn: "manual" })))[0]!;
+
+    // Assert
+    expect(manual.runsOn("approved")).toBeFalse();
+    expect(manual.runsOn("changes_requested")).toBeFalse();
+  });
+});

package/src/integrations/integrations.ts

@@ -0,0 +1,32 @@
+/**
+ * Bundled integration wiring: composes the configured integrations into
+ * generic exporters plus their run policy, so the session controller depends
+ * only on the extension seam, never on an integration's own config type. This
+ * and config.ts are the only client modules that name a concrete integration.
+ */
+
+import { Registry, type Exporter } from "@cueloop/extension-api";
+import { createObsidianExtension, shouldExport } from "@cueloop/integration-obsidian";
+import type { MessageOutcome } from "@cueloop/schema";
+import type { IntegrationsConfig } from "../settings/config";
+
+/** An exporter plus the policy deciding which messages trigger it. */
+export interface BundledExporter {
+  name: string;
+  run: Exporter;
+  runsOn(message: MessageOutcome): boolean;
+}
+
+/** Load the bundled integrations from config as generic exporters. */
+export async function loadBundledExporters(
+  integrations: IntegrationsConfig,
+): Promise<BundledExporter[]> {
+  const registry = new Registry();
+  const obsidian = integrations.obsidian;
+  const record = await registry.load("obsidian", createObsidianExtension(obsidian));
+  const run = record.exporters.get("obsidian");
+
+  if (!run) return [];
+
+  return [{ name: "obsidian", run, runsOn: (message) => shouldExport(obsidian.exportOn, message) }];
+}

package/src/integrations/pasted-image.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, test } from "bun:test";
+import { imagePlaceholder, looksLikeBinaryPaste } from "./pasted-image";
+
+function bytesOf(...values: number[]): Uint8Array {
+  return Uint8Array.from(values);
+}
+
+describe("looksLikeBinaryPaste", () => {
+  test("plain text pastes stay text", () => {
+    expect(looksLikeBinaryPaste(new TextEncoder().encode("just a normal comment"))).toBe(false);
+  });
+
+  test("multi-line text with tabs and newlines stays text", () => {
+    expect(
+      looksLikeBinaryPaste(new TextEncoder().encode("line one\n\tline two\r\nline three")),
+    ).toBe(false);
+  });
+
+  test("unicode text stays text", () => {
+    expect(looksLikeBinaryPaste(new TextEncoder().encode("café — naïve — 日本語 — 🎉"))).toBe(
+      false,
+    );
+  });
+
+  test("a PNG signature is binary", () => {
+    expect(looksLikeBinaryPaste(bytesOf(0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a))).toBe(
+      true,
+    );
+  });
+
+  test("a JPEG signature is binary", () => {
+    expect(looksLikeBinaryPaste(bytesOf(0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10))).toBe(true);
+  });
+
+  test("a GIF signature is binary", () => {
+    expect(looksLikeBinaryPaste(new TextEncoder().encode("GIF89a\x01\x02"))).toBe(true);
+  });
+
+  test("a WEBP signature is binary", () => {
+    expect(
+      looksLikeBinaryPaste(bytesOf(0x52, 0x49, 0x46, 0x46, 1, 2, 3, 4, 0x57, 0x45, 0x42, 0x50)),
+    ).toBe(true);
+  });
+
+  test("a NUL byte marks binary", () => {
+    expect(looksLikeBinaryPaste(bytesOf(0x68, 0x69, 0x00, 0x74, 0x68, 0x65, 0x72, 0x65))).toBe(
+      true,
+    );
+  });
+
+  test("a burst of control bytes marks binary", () => {
+    expect(looksLikeBinaryPaste(bytesOf(0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08))).toBe(
+      true,
+    );
+  });
+
+  test("an empty paste is not binary", () => {
+    expect(looksLikeBinaryPaste(new Uint8Array())).toBe(false);
+  });
+});
+
+describe("imagePlaceholder", () => {
+  test("numbers each pasted image", () => {
+    expect(imagePlaceholder(1)).toBe("[Image #1]");
+    expect(imagePlaceholder(2)).toBe("[Image #2]");
+  });
+});