Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
56 changes: 56 additions & 0 deletions apps/desktop/src/renderer/lib/terminal/terminal-clipboard.test.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,56 @@
import { afterEach, describe, expect, it, mock } from "bun:test";
import { writeTerminalClipboard } from "./terminal-clipboard";

const previous = Object.getOwnPropertyDescriptor(globalThis, "navigator");
afterEach(() => {
if (previous) Object.defineProperty(globalThis, "navigator", previous);
else Reflect.deleteProperty(globalThis, "navigator");
});

function clipboard(writeText?: (text: string) => Promise<void>) {
Object.defineProperty(globalThis, "navigator", {
configurable: true,
value: { clipboard: writeText ? { writeText } : undefined },
});
}

describe("writeTerminalClipboard", () => {
it("does not invoke native copying after browser success", async () => {
const write = mock(async () => {});
const native = mock(async () => {});
clipboard(write);
await writeTerminalClipboard("a\r\nb\u3000", native);
expect(write).toHaveBeenCalledWith("a\r\nb\u3000");
expect(native).not.toHaveBeenCalled();
});
it("falls back when the browser rejects", async () => {
clipboard(async () => {
throw new Error("NotAllowedError");
});
const native = mock(async () => {});
await writeTerminalClipboard("selected", native);
expect(native).toHaveBeenCalledWith("selected");
});
it("falls back when the browser API is absent", async () => {
clipboard();
const native = mock(async () => {});
await writeTerminalClipboard("selected", native);
expect(native).toHaveBeenCalledWith("selected");
});
it("falls back on synchronous browser failure", async () => {
clipboard(() => {
throw new Error("denied");
});
const native = mock(async () => {});
await writeTerminalClipboard("selected", native);
expect(native).toHaveBeenCalledWith("selected");
});
it("propagates native failure so callers cannot report success", async () => {
clipboard();
await expect(
writeTerminalClipboard("selected", async () => {
throw new Error("native failed");
}),
).rejects.toThrow("native failed");
});
});
17 changes: 17 additions & 0 deletions apps/desktop/src/renderer/lib/terminal/terminal-clipboard.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,17 @@
async function writeNativeText(text: string): Promise<void> {
const { electronTrpcClient } = await import("renderer/lib/trpc-client");
await electronTrpcClient.external.copyText.mutate(text);
}

export async function writeTerminalClipboard(
text: string,
writeFallback: (text: string) => Promise<void> = writeNativeText,
): Promise<void> {
try {
if (navigator.clipboard?.writeText) {
await navigator.clipboard.writeText(text);
return;
}
} catch {}
await writeFallback(text);
}
202 changes: 202 additions & 0 deletions apps/desktop/src/renderer/lib/terminal/terminal-copy.test.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,202 @@
import { describe, expect, it, mock, spyOn } from "bun:test";
import type { Terminal as XTerm } from "@xterm/xterm";
import {
getTerminalSelectionForCopy,
installTerminalCopyHandler,
trimTerminalSelection,
} from "./terminal-copy";

function terminalStub(
selection: string,
{ mode = 0, remainder = " ", wrapped = false, singleLine = false } = {},
): XTerm {
return {
element: new EventTarget(),
getSelection: () => selection,
getSelectionPosition: () => ({
start: { x: 0, y: 0 },
end: { x: 4, y: singleLine ? 0 : 2 },
}),
buffer: {
active: {
getLine: (row: number) =>
row === (singleLine ? 1 : 3)
? { isWrapped: wrapped }
: { translateToString: () => remainder },
},
},
_core: { _selectionService: { _activeSelectionMode: mode } },
} as unknown as XTerm;
}

function copyEvent(clipboardData: unknown = null): ClipboardEvent {
const event = new Event("copy", { cancelable: true });
Object.defineProperty(event, "clipboardData", { value: clipboardData });
return event as ClipboardEvent;
}

describe("trimTerminalSelection", () => {
it("removes ASCII row padding while preserving indentation and blank lines", () => {
expect(trimTerminalSelection(" first \n \n last ")).toBe(
" first\n\n last",
);
});
it("preserves Unicode whitespace and tabs", () => {
expect(trimTerminalSelection("日本語\u3000 \nvalue\u202f\t ")).toBe(
"日本語\u3000\nvalue\u202f\t",
);
});
it("preserves CRLF and mixed line endings", () => {
expect(trimTerminalSelection("a \r\nb \nc \r\n")).toBe("a\r\nb\nc\r\n");
});
it("preserves explicitly selected whitespace", () => {
expect(trimTerminalSelection(" ")).toBe(" ");
expect(trimTerminalSelection(" \r\n\t ")).toBe(" \r\n\t ");
});
it("preserves spaces inside an unwrapped logical line", () => {
expect(trimTerminalSelection("first continued \nlast")).toBe(
"first continued\nlast",
);
});
});

describe("getTerminalSelectionForCopy", () => {
it.each([
0, 1, 2,
])("trims complete logical lines in selection mode %i", (mode) => {
expect(
getTerminalSelectionForCopy(terminalStub("foo \nbar ", { mode })),
).toBe("foo\nbar");
});
it("preserves rectangular and unknown selections in both drag directions", () => {
for (const mode of [3, 99]) {
const terminal = terminalStub("a \nlong", { mode });
expect(getTerminalSelectionForCopy(terminal)).toBe("a \nlong");
terminal.getSelectionPosition = () => ({
start: { x: 9, y: 0 },
end: { x: 1, y: 2 },
});
expect(getTerminalSelectionForCopy(terminal)).toBe("a \nlong");
}
});
it("preserves spaces at a partial selection boundary", () => {
expect(
getTerminalSelectionForCopy(
terminalStub("foo \nbar ", { remainder: "next" }),
),
).toBe("foo\nbar ");
});
it("preserves spaces before a soft-wrap continuation", () => {
expect(
getTerminalSelectionForCopy(
terminalStub("foo \nbar ", { wrapped: true }),
),
).toBe("foo\nbar ");
});
it("preserves a single-line selection exactly", () => {
expect(
getTerminalSelectionForCopy(terminalStub("abc ", { singleLine: true })),
).toBe("abc ");
});
it("preserves a single logical line spanning soft-wrapped rows", () => {
expect(getTerminalSelectionForCopy(terminalStub("wrapped text "))).toBe(
"wrapped text ",
);
});
it("fails conservatively when selection mode or bounds are unavailable", () => {
const terminal = terminalStub("foo \nbar ");
terminal.getSelectionPosition = () => undefined;
expect(getTerminalSelectionForCopy(terminal)).toBe("foo \nbar ");
expect(
getTerminalSelectionForCopy({
getSelection: () => "foo \nbar ",
} as XTerm),
).toBe("foo \nbar ");
});
});

describe("installTerminalCopyHandler", () => {
it("overwrites xterm's earlier raw copy and removes its listener on disposal", () => {
const terminal = terminalStub("foo \nbar ");
const data = new Map<string, string>();
const event = () =>
copyEvent({
setData: (type: string, text: string) => data.set(type, text),
});
terminal.element?.addEventListener("copy", (event) => {
(event as ClipboardEvent).clipboardData?.setData(
"text/plain",
terminal.getSelection(),
);
event.preventDefault();
});
const dispose = installTerminalCopyHandler(terminal);
const first = event();
terminal.element?.dispatchEvent(first);
expect(first.defaultPrevented).toBe(true);
expect(data.get("text/plain")).toBe("foo\nbar");
dispose();
terminal.element?.dispatchEvent(event());
expect(data.get("text/plain")).toBe("foo \nbar ");
});
it("leaves copy events alone with no selection", () => {
const terminal = terminalStub("");
const write = mock(async () => {});
installTerminalCopyHandler(terminal, write);
const event = copyEvent();
terminal.element?.dispatchEvent(event);
expect(event.defaultPrevented).toBe(false);
expect(write).not.toHaveBeenCalled();
});
it("writes whitespace-only selections rather than clearing the clipboard", () => {
const terminal = terminalStub(" ");
const setData = mock(() => {});
installTerminalCopyHandler(terminal);
terminal.element?.dispatchEvent(copyEvent({ setData }));
expect(setData).toHaveBeenCalledWith("text/plain", " ");
});
it("uses the explicit writer when xterm has already canceled an event without clipboardData", () => {
const terminal = terminalStub("foo \nbar ");
terminal.element?.addEventListener("copy", (event) =>
event.preventDefault(),
);
const write = mock(async () => {});
installTerminalCopyHandler(terminal, write);
const event = copyEvent();
terminal.element?.dispatchEvent(event);
expect(event.defaultPrevented).toBe(true);
expect(write).toHaveBeenCalledWith("foo\nbar");
});
it("falls back when event clipboard writes throw", () => {
const terminal = terminalStub("foo\nbar");
const write = mock(async () => {});
installTerminalCopyHandler(terminal, write);
terminal.element?.dispatchEvent(
copyEvent({
setData: () => {
throw new Error("denied");
},
}),
);
expect(write).toHaveBeenCalledWith("foo\nbar");
});
it("reports failed writes and leaves the selection available to retry", async () => {
const terminal = terminalStub("foo\nbar");
const error = new Error("native clipboard failed");
const log = spyOn(console, "error").mockImplementation(() => {});
try {
installTerminalCopyHandler(terminal, async () => {
throw error;
});
terminal.element?.dispatchEvent(copyEvent());
await Promise.resolve();
expect(log).toHaveBeenCalledWith(
"[terminal] Failed to copy selection",
error,
);
expect(terminal.getSelection()).toBe("foo\nbar");
} finally {
log.mockRestore();
}
});
});
87 changes: 87 additions & 0 deletions apps/desktop/src/renderer/lib/terminal/terminal-copy.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,87 @@
import type { Terminal as XTerm } from "@xterm/xterm";
import { writeTerminalClipboard } from "./terminal-clipboard";

type SelectionTerminal = Pick<
XTerm,
"getSelection" | "getSelectionPosition" | "buffer"
>;

const XTERM_LINEAR_SELECTION_MODES = {
normal: 0,
word: 1,
line: 2,
} as const;

function hasLinearSelection(terminal: SelectionTerminal): boolean {
// xterm exposes bounds publicly, but the selection mode is private in our
// pinned version. Preserve raw text if that internal contract changes.
const internal = terminal as SelectionTerminal & {
_core?: { _selectionService?: { _activeSelectionMode?: number } };
};
const mode = internal._core?._selectionService?._activeSelectionMode;
return (
mode === XTERM_LINEAR_SELECTION_MODES.normal ||
mode === XTERM_LINEAR_SELECTION_MODES.word ||
mode === XTERM_LINEAR_SELECTION_MODES.line
);
}

export function trimTerminalSelection(
selection: string,
{ preserveLastLine = false }: { preserveLastLine?: boolean } = {},
): string {
if (!/[^ \t\r\n]/.test(selection)) return selection;
const parts = selection.split(/(\r\n|\n)/);
return parts
.map((part, index) =>
index % 2 === 0 && (!preserveLastLine || index < parts.length - 1)
? part.replace(/ +$/, "")
: part,
)
.join("");
}

export function getTerminalSelectionForCopy(
terminal: SelectionTerminal,
): string {
const selection = terminal.getSelection();
if (!selection.includes("\n")) return selection;
if (!hasLinearSelection(terminal)) return selection;

const position = terminal.getSelectionPosition();
if (!position || position.start.y === position.end.y) return selection;
const buffer = terminal.buffer.active;
const endLine = buffer.getLine(position.end.y);
if (!endLine) return selection;
const remainder = endLine.translateToString(false, position.end.x);
const continues = buffer.getLine(position.end.y + 1)?.isWrapped ?? false;
return trimTerminalSelection(selection, {
preserveLastLine: continues || /[^ ]/.test(remainder),
});
}

export function installTerminalCopyHandler(
terminal: XTerm,
writeText: (text: string) => Promise<void> = writeTerminalClipboard,
): () => void {
const element = terminal.element;
if (!element) return () => {};

const handleCopy = (event: ClipboardEvent) => {
const text = getTerminalSelectionForCopy(terminal);
if (!text) return;
event.preventDefault();
if (event.clipboardData) {
try {
event.clipboardData.setData("text/plain", text);
return;
} catch {}
}
void writeText(text).catch((error: unknown) => {
console.error("[terminal] Failed to copy selection", error);
});
};

element.addEventListener("copy", handleCopy);
return () => element.removeEventListener("copy", handleCopy);
}
Loading