pi-ui-extension 1.1.10 → 1.2.0

package/extensions/session/manager.test.ts

@@ -0,0 +1,141 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  getSessionPage, openSessionManager, readSessionPins, sessionsEligibleForClear, sortedSessions, toggleSessionPin,
+  type SessionManagerUI,
+} from "./manager.ts";
+import type { SessionListItem } from "./panel.ts";
+
+function session(id: string, modified: number, title = `Session ${id}`, messages = 1): SessionListItem {
+  return { id, title, modified: new Date(modified), messageCount: messages, current: id === "id-0" };
+}
+
+test("sorting, searching and pagination scale to hundreds of sessions with pinned first", () => {
+  const many = Array.from({ length: 105 }, (_, index) => session(`id-${index}`, index * 1000, `Branch ${index}`, index));
+  many[0] = { ...many[0]!, pinned: true };
+  assert.equal(sortedSessions(many, "recent")[0]!.id, "id-0");
+  assert.deepEqual(getSessionPage(many, "", "recent", 0).items.map((s) => s.id).slice(0, 3),
+    ["id-0", "id-104", "id-103"]);
+  assert.equal(getSessionPage(many, "", "recent", 0).pages, 14);
+  assert.equal(getSessionPage(many, "", "recent", 100).page, 13);
+  assert.equal(getSessionPage(many, "", "recent", -10).page, 0);
+  assert.equal(getSessionPage(many, "BRANCH 1", "recent", 0).total, 16);
+  assert.equal(getSessionPage(many, "id-60", "recent", 0).items[0]!.id, "id-60");
+  assert.equal(getSessionPage(many, "not found", "title", 0).total, 0);
+  assert.equal(sortedSessions(many, "messages")[1]!.id, "id-104");
+  assert.equal(sortedSessions(many, "oldest")[1]!.id, "id-1");
+  assert.equal(sortedSessions(many, "title")[1]!.id, "id-1");
+  assert.deepEqual(sortedSessions([session("b", 0), session("a", 0)], "recent").map((s) => s.id), ["a", "b"]);
+});
+
+test("bulk clear excludes current and pinned sessions", () => {
+  const sessions = [session("current", 0), session("pinned", 1), session("ordinary", 2)];
+  assert.deepEqual(sessionsEligibleForClear(sessions, "current", new Set(["pinned"])).map((s) => s.id), ["ordinary"]);
+});
+
+test("pins persist atomically with private permissions and invalid contents are not overwritten", () => {
+  const root = mkdtempSync(join(tmpdir(), "pi-session-pin-"));
+  const path = join(root, "preferences", "pins.json");
+  try {
+    assert.deepEqual([...readSessionPins(path)], []);
+    assert.equal(toggleSessionPin(path, "some-id"), true);
+    assert.equal(toggleSessionPin(path, "next-id"), true);
+    assert.deepEqual([...readSessionPins(path)], ["some-id", "next-id"]);
+    assert.equal(statSync(path).mode & 0o777, 0o600);
+    assert.equal(toggleSessionPin(path, "some-id"), false);
+    assert.deepEqual([...readSessionPins(path)], ["next-id"]);
+    assert.deepEqual(JSON.parse(readFileSync(path, "utf8")), ["next-id"]);
+    assert.deepEqual(readdirSync(join(root, "preferences")).filter((name) => name.endsWith(".tmp")), []);
+    assert.throws(() => toggleSessionPin(path, "../../oops"), /Invalid session identifier/);
+    writeFileSync(path, "{not-valid}");
+    assert.throws(() => toggleSessionPin(path, "good-id"));
+    assert.equal(readFileSync(path, "utf8"), "{not-valid}");
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+type Choice = (title: string, choices: string[]) => string | undefined;
+function scriptedUI(steps: Choice[]) {
+  const viewed: Array<{ title: string; choices: string[] }> = [];
+  const notices: string[] = [];
+  const ui: SessionManagerUI = {
+    async select(title, choices) {
+      viewed.push({ title, choices });
+      const choose = steps.shift();
+      if (!choose) throw new Error(`Unexpected selector: ${title}`);
+      const choice = choose(title, choices);
+      if (choice !== undefined) assert.ok(choices.includes(choice), `missing option: ${choice}`);
+      return choice;
+    },
+    async input() { return ""; },
+    async confirm() { return true; },
+    notify(message) { notices.push(message); },
+  };
+  return { ui, viewed, notices };
+}
+
+test("manager can navigate pages, pin and unpin, and switch using the selected session", async () => {
+  const root = mkdtempSync(join(tmpdir(), "pi-session-modal-"));
+  const path = join(root, "pins.json");
+  let switched = "";
+  let changes = 0;
+  const all = Array.from({ length: 21 }, (_, index) => session(`id-${index}`, index * 1000));
+  const { ui, viewed, notices } = scriptedUI([
+    (_title, choices) => choices.find((item) => item === "下一页 →"),
+    (_title, choices) => choices.find((item) => item === "下一页 →"),
+    (_title, choices) => choices.find((item) => item.startsWith("1. ")),
+    (_title, choices) => choices.find((item) => item === "置顶会话"),
+    (_title, choices) => choices.find((item) => item.startsWith("1. ★")),
+    (_title, choices) => choices.find((item) => item === "取消置顶"),
+    (_title, choices) => choices.find((item) => item.startsWith("1. ")),
+    (_title, choices) => choices.find((item) => item === "切换到此会话"),
+  ]);
+  try {
+    await openSessionManager({
+      ui,
+      loadSessions: async () => all.map((item) => ({ ...item, pinned: readSessionPins(path).has(item.id) })),
+      togglePin: (id) => toggleSessionPin(path, id),
+      onPinChanged() { changes++; },
+      onSwitch(item) { switched = item.id; },
+      onRename() { throw new Error("unexpected rename"); },
+      onDelete() { throw new Error("unexpected delete"); },
+    });
+    assert.equal(changes, 2);
+    assert.ok(switched.length > 0);
+    assert.deepEqual([...readSessionPins(path)], []);
+    assert.match(viewed[2]!.title, /3\/3/);
+    assert.match(viewed[4]!.choices[0]!, /★/);
+    assert.deepEqual(notices, ["会话已置顶", "已取消置顶"]);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("manager searches, sorts, and requires confirmation to delete noncurrent sessions", async () => {
+  const names = [session("a", 1, "alpha"), session("b", 2, "Beta"), session("c", 3, "gamma")];
+  const { ui, viewed } = scriptedUI([
+    (_title, choices) => choices.find((item) => item.startsWith("⌕ ")), // Search
+    (_title, choices) => choices.find((item) => item.startsWith("↕ ")), // Sort
+    (_title, choices) => choices.find((item) => item.includes("会话标题")),
+    (_title, choices) => choices.find((value) => value.startsWith("1. ")),
+    (_title, choices) => choices.find((value) => value === "移到回收站"),
+  ]);
+  let confirmed = false;
+  let deleted = "";
+  ui.input = async () => "BETA";
+  ui.confirm = async () => { confirmed = true; return true; };
+  await openSessionManager({
+    ui, loadSessions: async () => names,
+    togglePin: () => false, onPinChanged() {},
+    onSwitch() {}, onRename() {},
+    onDelete(item) { deleted = item.id; },
+  });
+  assert.equal(confirmed, true);
+  assert.equal(deleted, "b");
+  assert.match(viewed[3]!.title, /1\/3/);
+  assert.ok(!viewed[3]!.choices.some((value) => value.includes("gamma")));
+});

package/extensions/session/manager.ts

@@ -0,0 +1,183 @@
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { stripTerminalSequences, truncateToWidth } from "@earendil-works/pi-tui";
+import type { SessionListItem } from "./panel.ts";
+
+export type SessionSort = "recent" | "oldest" | "messages" | "title";
+export const SESSION_PAGE_SIZE = 8;
+
+/** Store only opaque session ids; session contents and titles never leave Pi. */
+export function readSessionPins(path: string): ReadonlySet<string> {
+  let text: string;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return new Set();
+    throw error;
+  }
+  if (text.length > 128_000) throw new Error("Session pins file is too large");
+  const parsed: unknown = JSON.parse(text);
+  if (!Array.isArray(parsed) || parsed.length > 2000 ||
+      !parsed.every((id) => typeof id === "string" && /^[a-zA-Z0-9._-]{1,128}$/.test(id))) {
+    throw new Error("Invalid session pins file");
+  }
+  return new Set(parsed as string[]);
+}
+
+/** Atomic, user-private persistence. Never write back a corrupt pins file. */
+export function toggleSessionPin(path: string, id: string): boolean {
+  if (!/^[a-zA-Z0-9._-]{1,128}$/.test(id)) throw new Error("Invalid session identifier");
+  const pins = new Set(readSessionPins(path));
+  const pinned = !pins.has(id);
+  if (pinned) pins.add(id);
+  else pins.delete(id);
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync(temporary, JSON.stringify([...pins]), { encoding: "utf8", mode: 0o600 });
+    renameSync(temporary, path);
+  } finally {
+    rmSync(temporary, { force: true });
+  }
+  return pinned;
+}
+
+export function sortedSessions(sessions: readonly SessionListItem[], sort: SessionSort): SessionListItem[] {
+  return [...sessions].sort((a, b) => {
+    if (Boolean(a.pinned) !== Boolean(b.pinned)) return a.pinned ? -1 : 1;
+    const diff = sort === "recent" ? b.modified.getTime() - a.modified.getTime()
+      : sort === "oldest" ? a.modified.getTime() - b.modified.getTime()
+        : sort === "messages" ? b.messageCount - a.messageCount
+          : a.title.localeCompare(b.title);
+    return (Number.isFinite(diff) ? diff : 0) || a.id.localeCompare(b.id);
+  });
+}
+
+/** Pinned and active sessions are protected from the bulk-clear operation. */
+export function sessionsEligibleForClear<T extends { readonly id: string }>(
+  sessions: readonly T[], activeId: string, pins: ReadonlySet<string>,
+): T[] {
+  return sessions.filter((session) => session.id !== activeId && !pins.has(session.id));
+}
+
+export function getSessionPage(
+  sessions: readonly SessionListItem[], query: string, sort: SessionSort, requestedPage: number,
+  pageSize = SESSION_PAGE_SIZE,
+): { readonly items: readonly SessionListItem[]; readonly total: number; readonly page: number; readonly pages: number } {
+  const q = query.trim().toLocaleLowerCase();
+  const filtered = sortedSessions(sessions.filter((session) =>
+    !q || session.title.toLocaleLowerCase().includes(q) || session.id.toLocaleLowerCase().includes(q),
+  ), sort);
+  const pages = Math.max(1, Math.ceil(filtered.length / Math.max(1, pageSize)));
+  const page = Math.max(0, Math.min(Number.isFinite(requestedPage) ? Math.floor(requestedPage) : 0, pages - 1));
+  return {
+    items: filtered.slice(page * pageSize, (page + 1) * pageSize),
+    total: filtered.length, page, pages,
+  };
+}
+
+export type SessionManagerUI = {
+  select(title: string, choices: string[]): Promise<string | undefined>;
+  input(title: string, placeholder?: string): Promise<string | undefined>;
+  confirm(title: string, message: string): Promise<boolean>;
+  notify(message: string, level: "info" | "warning" | "error"): void;
+};
+
+export type SessionManagerOptions = {
+  readonly ui: SessionManagerUI;
+  readonly loadSessions: () => Promise<readonly SessionListItem[]>;
+  readonly togglePin: (id: string) => boolean;
+  readonly onPinChanged: () => void;
+  readonly onSwitch: (session: SessionListItem) => void;
+  readonly onRename: (session: SessionListItem) => void;
+  readonly onDelete: (session: SessionListItem) => void;
+};
+
+const SORT_CHOICES: ReadonlyArray<{ sort: SessionSort; label: string }> = [
+  { sort: "recent", label: "最近更新" },
+  { sort: "oldest", label: "最早更新" },
+  { sort: "messages", label: "消息数量" },
+  { sort: "title", label: "会话标题" },
+];
+
+function safeLabel(title: string): string {
+  const cleaned = stripTerminalSequences(title).replace(/[\u0000-\u001f\u007f]/g, " ")
+    .replace(/\s+/g, " ").trim() || "(未命名会话)";
+  return truncateToWidth(cleaned, 65, "…");
+}
+
+/** Modal, bounded page of sessions; never executes destructive operations without confirmation. */
+export async function openSessionManager(options: SessionManagerOptions): Promise<void> {
+  const { ui } = options;
+  let query = "";
+  let sort: SessionSort = "recent";
+  let page = 0;
+  let sessions = await options.loadSessions();
+  for (;;) {
+    const current = getSessionPage(sessions, query, sort, page);
+    page = current.page;
+    const labels = current.items.map((session, index) =>
+      `${index + 1}. ${session.pinned ? "★ " : ""}${session.current ? "● " : ""}${safeLabel(session.title)} · ${session.messageCount} 条消息`,
+    );
+    const actions = [
+      "⌕ 搜索 / 清除搜索",
+      `↕ 排序：${SORT_CHOICES.find((choice) => choice.sort === sort)!.label}`,
+      ...(page > 0 ? ["← 上一页"] : []),
+      ...(page + 1 < current.pages ? ["下一页 →"] : []),
+      "↻ 刷新列表",
+      "关闭",
+    ];
+    const choice = await ui.select(
+      `Sessions · ${current.total}/${sessions.length} · ${page + 1}/${current.pages}${query ? ` · 搜索：${safeLabel(query)}` : ""}`,
+      [...labels, ...actions],
+    );
+    if (!choice || choice === "关闭") return;
+    if (choice === actions[0]) {
+      const next = await ui.input("搜索会话标题或 ID（留空清除搜索）", query);
+      if (next !== undefined) { query = next.trim(); page = 0; }
+    } else if (choice === actions[1]) {
+      const names = SORT_CHOICES.map(({ label, sort: key }) => `${key === sort ? "● " : "○ "}${label}`);
+      const selection = await ui.select("会话排序（置顶始终优先）", names);
+      const index = names.indexOf(selection ?? "");
+      if (index >= 0) { sort = SORT_CHOICES[index]!.sort; page = 0; }
+    } else if (choice === "← 上一页") {
+      page--;
+    } else if (choice === "下一页 →") {
+      page++;
+    } else if (choice === "↻ 刷新列表") {
+      sessions = await options.loadSessions();
+    } else {
+      const index = labels.indexOf(choice);
+      const session = current.items[index];
+      if (index < 0 || !session) continue;
+      const menu = [
+        ...(session.current ? [] : ["切换到此会话"]),
+        "重命名",
+        session.pinned ? "取消置顶" : "置顶会话",
+        ...(session.current ? [] : ["移到回收站"]),
+        "返回列表",
+      ];
+      const action = await ui.select(`${safeLabel(session.title)} · 管理`, menu);
+      if (action === "置顶会话" || action === "取消置顶") {
+        try {
+          const pinned = options.togglePin(session.id);
+          ui.notify(pinned ? "会话已置顶" : "已取消置顶", "info");
+          options.onPinChanged();
+          sessions = await options.loadSessions();
+          page = 0;
+        } catch (error) {
+          ui.notify(`保存置顶失败：${error instanceof Error ? error.message : String(error)}`, "error");
+        }
+      } else if (action === "移到回收站") {
+        const confirmed = await ui.confirm("删除会话", `将“${safeLabel(session.title)}”移到回收站？`);
+        if (confirmed) { options.onDelete(session); return; }
+      } else if (action === "切换到此会话") {
+        options.onSwitch(session);
+        return;
+      } else if (action === "重命名") {
+        options.onRename(session);
+        return;
+      }
+    }
+  }
+}

package/extensions/session/panel.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import type { TuiInputListener } from "@earendil-works/pi-tui";
+import { stripTerminalSequences, type TuiInputListener } from "@earendil-works/pi-tui";
 import { SessionPanel, type SessionListItem } from "./panel.ts";
 
 const theme = { fg: (_color: string, text: string) => text } as any;
@@ -236,3 +236,197 @@ test("hides ⊗ on narrow panels", async () => {
   assert.doesNotMatch(panel.render(16)[0]!, /⊗/);
   panel.dispose();
 });
+
+test("opens advanced manager from ≡ without triggering refresh or bulk trash", async () => {
+  let listener: TuiInputListener | undefined;
+  let opened = 0;
+  let cleared = 0;
+  let loads = 0;
+  const tui = {
+    addInputListener(next: TuiInputListener) { listener = next; return () => {}; },
+    requestRender() {},
+    currentLayout: undefined as any,
+  } as any;
+  const panel = new SessionPanel(theme, {
+    tui,
+    getDesiredWidth: () => 40,
+    loadSessions: async () => { loads++; return [session("one", "One session")]; },
+    onSelect() {}, onRename() {}, onDelete() {},
+    onDeleteOthers() { cleared++; },
+    onOpenResources() {},
+    onOpenManager() { opened++; },
+  });
+  tui.currentLayout = {
+    root: { component: panel, rect: { x: 10, y: 5, width: 40, height: 5 },
+      clip: { x: 10, y: 5, width: 40, height: 5 }, children: [] },
+  };
+  panel.refresh();
+  await flushAsync();
+  const header = panel.render(40)[0]!;
+  const managerColumn = header.indexOf("≡");
+  assert.ok(managerColumn > 0, "≡ must be present in the session header");
+  const x = 10 + managerColumn + 1;
+  assert.deepEqual(listener?.(`\u001b[<0;${x};6M`), { consume: true });
+  assert.deepEqual(listener?.(`\u001b[<0;${x};6m`), { consume: true });
+  await flushAsync();
+  assert.equal(opened, 1);
+  assert.equal(cleared, 0);
+  assert.equal(loads, 1);
+  panel.dispose();
+});
+
+test("pinned session remains visible ahead of the five-item sidebar limit", async () => {
+  const tui = { addInputListener: () => () => {}, requestRender() {} } as any;
+  const panel = new SessionPanel(theme, {
+    tui, getDesiredWidth: () => 42,
+    loadSessions: async () => [
+      { ...session("starred", "Important"), pinned: true },
+      ...Array.from({ length: 15 }, (_, index) => session(`other-${index}`, `Recent ${index}`)),
+    ],
+    onSelect() {}, onRename() {}, onDelete() {},
+    onDeleteOthers() {}, onOpenResources() {},
+  });
+  panel.refresh();
+  await flushAsync();
+  const output = panel.render(42).join("\n");
+  assert.match(output, /★○ Important/);
+  assert.match(output, /Recent 3/);
+  assert.doesNotMatch(output, /Recent 4/);
+  panel.dispose();
+});
+
+test("session row ☆/★ toggles pin in place without invoking rename, delete or switch", async () => {
+  let listener: TuiInputListener | undefined;
+  const calls: string[] = [];
+  let pinned = false;
+  const tui = {
+    addInputListener(next: TuiInputListener) { listener = next; return () => {}; },
+    requestRender() {},
+    currentLayout: undefined as any,
+  } as any;
+  const panel = new SessionPanel(theme, {
+    tui, getDesiredWidth: () => 40,
+    loadSessions: async () => [{ ...session("one", "Important session"), pinned }],
+    onSelect() { calls.push("select"); },
+    onRename() { calls.push("rename"); },
+    onDelete() { calls.push("delete"); },
+    onTogglePin(item) {
+      assert.equal(item.id, "one");
+      calls.push("pin");
+      pinned = !pinned;
+      panel.refresh();
+    },
+    onDeleteOthers() {}, onOpenResources() {}, now: () => 0,
+  });
+  tui.currentLayout = {
+    root: {
+      component: panel, rect: { x: 10, y: 5, width: 40, height: 5 },
+      clip: { x: 10, y: 5, width: 40, height: 5 }, children: [],
+    },
+  };
+  const click = (text: string) => {
+    const row = panel.render(40)[1]!;
+    const column = row.lastIndexOf(text);
+    assert.ok(column > 0, `missing button ${text}: ${row}`);
+    const x = 10 + column + 1;
+    assert.deepEqual(listener?.(`\u001b[<0;${x};7M`), { consume: true });
+    assert.deepEqual(listener?.(`\u001b[<0;${x};7m`), { consume: true });
+  };
+  panel.refresh();
+  await flushAsync();
+  assert.match(panel.render(40)[1]!, /☆ ✎ ×/);
+  click("☆");
+  await flushAsync();
+  assert.equal(pinned, true);
+  assert.match(panel.render(40)[1]!, /★ ✎ ×/);
+  assert.match(panel.render(40)[1]!, /★○ Important/);
+  click("★");
+  await flushAsync();
+  assert.equal(pinned, false);
+  assert.match(panel.render(40)[1]!, /☆ ✎ ×/);
+  assert.deepEqual(calls, ["pin", "pin"]);
+
+  click("✎");
+  await flushAsync();
+  click("×");
+  await flushAsync();
+  assert.deepEqual(calls, ["pin", "pin", "rename", "delete"]);
+  panel.dispose();
+});
+
+test("session pin hit area is distinct from rename/delete and cancelled on off-target release", async () => {
+  let listener: TuiInputListener | undefined;
+  const calls: string[] = [];
+  const tui = {
+    addInputListener(next: TuiInputListener) { listener = next; return () => {}; },
+    requestRender() {},
+    currentLayout: undefined as any,
+  } as any;
+  const panel = new SessionPanel(theme, {
+    tui, getDesiredWidth: () => 40,
+    loadSessions: async () => [{ ...session("active", "Current session"), current: true }],
+    onSelect() { calls.push("select"); }, onRename() { calls.push("rename"); },
+    onDelete() { calls.push("delete"); }, onTogglePin() { calls.push("pin"); },
+    onDeleteOthers() {}, onOpenResources() {}, now: () => 0,
+  });
+  tui.currentLayout = {
+    root: {
+      component: panel, rect: { x: 10, y: 5, width: 40, height: 5 },
+      clip: { x: 10, y: 5, width: 40, height: 5 }, children: [],
+    },
+  };
+  panel.refresh();
+  await flushAsync();
+  const line = panel.render(40)[1]!;
+  assert.match(line, /☆ ✎ ·/);
+  const pinX = 10 + line.indexOf("☆") + 1;
+  const renameX = 10 + line.indexOf("✎") + 1;
+  const endX = 10 + line.lastIndexOf("·") + 1;
+  listener?.(`\u001b[<0;${pinX};7M`);
+  listener?.(`\u001b[<0;${renameX};7m`);
+  await flushAsync();
+  assert.deepEqual(calls, []);
+  listener?.(`\u001b[<0;${endX};7M`);
+  listener?.(`\u001b[<0;${endX};7m`);
+  await flushAsync();
+  assert.deepEqual(calls, [], "current session cannot be deleted");
+  listener?.(`\u001b[<0;${pinX};7M`);
+  listener?.(`\u001b[<0;${pinX};7m`);
+  await flushAsync();
+  assert.deepEqual(calls, ["pin"], "current session can still be pinned");
+  panel.dispose();
+});
+
+test("narrow sidebar keeps prior rename/delete actions without showing a truncated pin button", async () => {
+  let listener: TuiInputListener | undefined;
+  const actions: string[] = [];
+  const tui = {
+    addInputListener(next: TuiInputListener) { listener = next; return () => {}; },
+    requestRender() {},
+    currentLayout: undefined as any,
+  } as any;
+  const panel = new SessionPanel(theme, {
+    tui, getDesiredWidth: () => 21,
+    loadSessions: async () => [session("one", "Short")],
+    onSelect() { actions.push("select"); }, onRename() { actions.push("rename"); },
+    onDelete() { actions.push("delete"); }, onTogglePin() { actions.push("pin"); },
+    onDeleteOthers() {}, onOpenResources() {}, now: () => 0,
+  });
+  tui.currentLayout = {
+    root: {
+      component: panel, rect: { x: 3, y: 2, width: 21, height: 5 },
+      clip: { x: 3, y: 2, width: 21, height: 5 }, children: [],
+    },
+  };
+  panel.refresh();
+  await flushAsync();
+  const line = stripTerminalSequences(panel.render(21)[1]!);
+  assert.match(line, / ✎ ×/);
+  assert.doesNotMatch(line, /☆/);
+  const pencilX = 3 + line.indexOf("✎") + 1;
+  assert.deepEqual(listener?.(`\u001b[<0;${pencilX};4M`), { consume: true }, `press at ${pencilX}: ${line}`);
+  assert.deepEqual(listener?.(`\u001b[<0;${pencilX};4m`), { consume: true }, `release at ${pencilX}: ${line}`);
+  await flushAsync();
+  assert.deepEqual(actions, ["rename"]);
+  panel.dispose();
+});