mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-20 15:19:16 +00:00
* fix(autocomplete): honor typed keystrokes when the prompt parser over-captures Closes #806. ## Root cause findPromptBoundary stops at the first "PROMPT_CHAR + space" it sees on the current line. Themes that render additional content after the prompt char — most notably oh-my-zsh robbyrussell's "➜ ~ " where "~" is the cwd — trip it: promptText becomes "➜ ", userInput becomes "~ sudo id". Every consumer downstream treats the theme's cwd marker as part of the user's command, so: 1. recordCommand logs entries like "~ sudo id" into history. 2. fuzzyQueryHistory later returns those polluted entries as suggestions. 3. When the user hits Tab, insertSuggestion compares suggestion.text ("~ ls") against userInput ("~ lo"), falls into the Ctrl-U-plus-rewrite path, and the phantom "~ " ends up on the real command line. The reporter hit this right after `sudo` because sudo's password interaction gave history enough polluted entries to start winning fuzzy matches; without sudo the popup stays empty so the Ctrl-U rewrite path never fires and the bug is invisible. ## Fix Track what the user actually typed in an independent keystroke buffer (typedInputBufferRef) inside the autocomplete hook: - Append every printable char / paste chunk. - Pop on backspace, word-kill on Ctrl+W. - Clear on Enter, Ctrl+C, Ctrl+U, and any escape sequence / unhandled control char (cursor moves we can't follow invalidate the buffer). Introduce reconcilePromptWithTypedInput: if detectPrompt's userInput ends with the typed buffer and is longer, the parser over-captured — move the excess back to promptText so userInput matches what was actually typed. Apply at every detectPrompt call site (fetchSuggestions, the stale-result recheck, insertSuggestion). For Enter-record the typed buffer wins outright when present, but only after a live detectPrompt confirms we're at a shell prompt — otherwise a password-entry Enter would log the password as a command. insertSuggestion / ghost-text accept update the typed buffer to the accepted text so a subsequent Enter records the right command. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(autocomplete): track keystroke-buffer reliability, skip it after cursor moves Codex flagged (#814 P1) that clearing typedInputBufferRef on escape / control sequences and then re-appending printable keys leaves the buffer holding only the post-navigation suffix of the real line. A classic Up-arrow-recall workflow — ↑ to pull "git commit -m fix" out of history, append one char, Enter — would record just that one char as the command, polluting history and skewing future fuzzy matches. Add typedBufferReliableRef as a companion flag: - Reset (reliable=true) on Enter / Ctrl-C / Ctrl-U (zle wipes the line, our buffer is a true view of the empty line again). - Also reset by insertSuggestion and ghost-text right-arrow accept once they write the full accepted text and we re-align the buffer to it. - Cleared (reliable=false) when any escape sequence, unhandled control char (Ctrl-P / Ctrl-N / Ctrl-R / Ctrl-A / Ctrl-E / ...) arrives — those can move the cursor or swap the zle line in ways an append-only buffer can't follow. All four call sites now gate on the flag: - reconcilePromptWithTypedInput receives the buffer only when reliable, so an unreliable buffer never trims the detector's userInput (avoids a symmetric flavor of the original bug where the detector is right and the buffer is wrong). - Enter-record prefers the buffer only when reliable; otherwise it falls straight through to detectPrompt. - The Ctrl+Right (next-word ghost accept) append is skipped when unreliable so we don't seed the buffer with just that word. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(autocomplete): resync typed buffer when sub-dir select rewrites the line Codex flagged (#814 P2) that handleSubDirSelect rewrites the command line via writeToTerminal(Ctrl-U + cmdPrefix + fullPath) but never touches typedInputBufferRef. After the rewrite the buffer still holds whatever was typed before, so pressing Enter records that stale partial input as the executed command — polluting history and steering later suggestions off course. Same commit also routes handleSubDirSelect through reconcilePromptWithTypedInput. The raw detectPrompt would include the robbyrussell "~ " cwd marker in the command prefix it reconstructs, which is the original symmetric #806 bug leaking into this path too. After the rewrite, set the buffer to the newly written command string and flip reliability back on — the terminal line content now matches it exactly, so the next Enter-record does the right thing. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(autocomplete): reset typed buffer when a paste chunk carries a newline Codex flagged (#814 P2) that multi-character paste payloads skip the top-of-handleInput Enter guard (which compares data === "\r" exactly), so a paste like "cmd\r" goes through the paste branch and the "\r" gets appended to typedInputBufferRef verbatim. The shell executes "cmd", but our buffer is left holding "cmd\r...", still marked reliable. The next Enter then records whatever combined stale string lives there. Detect line terminators inside multi-char paste chunks: slice from the last \r or \n onward and keep only that tail as the new buffer content (and flip reliability back on, since the tail now matches the shell's zle line). Skip synthesizing recordCommand entries for the flushed intermediate lines — onCommandExecuted in createXTermRuntime already tracks pasted multi-line input independently, so duplicating the logic here would risk double-counting. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(autocomplete): clear lastAcceptedCommandRef on paste-with-newline early return Codex flagged (#814 P2) that the multi-line-paste branch clears the keystroke buffer and bails out before the rest of handleInput runs — including the line that resets lastAcceptedCommandRef. If the user had just accepted a suggestion (Tab / → / popup click), the embedded newline still flushes it in the shell, but our fast-path cache keeps holding it. The next Enter then takes the lastAcceptedCommandRef shortcut and logs that old suggestion as the executed command, polluting history with something the user didn't actually run. Null lastAcceptedCommandRef.current at the same point we reset the typed buffer so the fast path stays aligned with the shell. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(autocomplete): require typed buffer to align with live line before recording Codex flagged (#814 P1) that paste paths which bypass handleInput — the createXTermRuntime hotkey / context-menu / middle-click handlers all call writeToSession(...) directly — leave typedInputBufferRef stale while still marked reliable. A "type prefix → paste remainder → Enter" flow would then record just the keyboard-typed prefix, feeding garbage back into autocomplete ranking. Require alignment: livePrompt.userInput must end with the typed buffer before we trust it. reconcilePromptWithTypedInput already snaps the two together when they *are* aligned — if its endsWith check fails, the buffer is stale (or mid-navigation) and we fall back to livePrompt.userInput instead. That drops the #806 fix for this one paste-bypass case, but the same flow would have hit the same pollution before this PR, so it's a no-regression fallback. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(autocomplete): route out-of-band paste writes through handleInput Codex flagged (#814 P1) that the reconcile path in fetchSuggestions has the same stale-buffer failure mode the Enter-record path now guards against: snippet / keyboard-paste / selection-paste / middle-click-paste handlers in createXTermRuntime call writeToSession directly, so typedInputBufferRef only holds whatever was typed *after* the paste. reconcilePromptWithTypedInput then treats the pasted prefix as prompt text and trims it, completions fetch on the truncated input, and accepting a suggestion rewrites the command incorrectly. Fix at the source: notify the autocomplete hook with the raw (pre-bracket-wrap) bytes at every paste site so its keystroke buffer absorbs them through the same handleInput path keyboard input uses. handleInput's multi-char paste branch already resets / aligns the buffer (and invalidates on embedded escape sequences), so this single extra call per paste site is enough — no new hook API needed. The existing onData-driven notification at line 684 already covers the non-paste keyboard path, and the snippet / paste / pasteSelection / middle-click handlers are the only remaining paths that bypass it. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(autocomplete): preserve inner newlines of bracketed-paste input Codex flagged (#814 P2) that the multi-char-paste branch in handleInput drops everything before the last newline, but when bracketed paste is active those newlines are literal input staying on the zle line — not command terminators. A multi-line paste like "cmd1\ncmd2" then left only "cmd2" in typedInputBufferRef and the next Enter recorded / trusted just the tail. Teach handleInput to recognize the bracketed-paste wrapper "\x1b[200~...\x1b[201~" and append the enclosed content verbatim (reliability flag stays on — we know exactly what was added). Matching change in createXTermRuntime: pass the final (possibly bracket-wrapped) bytes to ctx.onAutocompleteInput instead of the raw pre-wrap text so the handle sees the markers when applicable. Non-bracketed pastes still hit the existing newline-split branch so each "\n" resets the buffer to the post-terminator tail. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * refactor(autocomplete): route every prompt consumer through getAlignedPrompt Each Codex round on #814 surfaced one more code path that needed the "consume the keystroke buffer only when it's aligned with the live line" gate: Enter-record, fetchSuggestions (×2), insertSuggestion, handleSubDirSelect, fetchSubDirForIndex. The fixes were correct but the guard ended up spelled three different ways across the file: reconcilePromptWithTypedInput(detectPrompt(term), reliable ? buf : "") plus a separate `userInput.endsWith(buf)` check in the Enter branch. That scatter is exactly how the next out-of-band writer gets missed and regresses #806. Collapse all six sites onto one helper: getAlignedPrompt(term, buffer, reliable) → { prompt, alignedTyped } The helper owns the policy — reliability + endsWith alignment — in one place. Non-aligned buffers fall through as raw detector output (same pre-PR behavior, so the worst case for any future forgotten path is a degrade, not a pollution). Enter-record additionally consumes alignedTyped, which is only non-null when the buffer truly matches the tail, so it can record the clean typed command directly without redoing the endsWith check. No behavior change from the previous commit; this is purely deduplication of the alignment guard. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(autocomplete): inherit reliability on bracketed paste instead of resetting Codex flagged (#814 P1 follow-up) that the bracketed-paste branch unconditionally flipped typedBufferReliableRef back to true. A history-recall-then-paste flow (↑ marks the buffer unreliable, then bracketed paste arrives) would then set reliable=true even though the buffer only contains the pasted tail, not the recalled head. getAlignedPrompt's endsWith check can pass trivially for a short paste tail that happens to equal the last N chars of the recalled line, and Enter would record just the pasted fragment. Reliability is now inherited across a bracketed paste rather than reset: if the buffer was already aligned, appending the paste keeps it aligned; if the buffer was unreliable (post-recall / post-cursor- move), it stays unreliable and the alignment guard in getAlignedPrompt falls through to the raw detector result the way it should. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
881 lines
31 KiB
TypeScript
881 lines
31 KiB
TypeScript
import { FitAddon } from "@xterm/addon-fit";
|
||
import { SearchAddon } from "@xterm/addon-search";
|
||
import { SerializeAddon } from "@xterm/addon-serialize";
|
||
import { UnicodeGraphemesAddon } from "@xterm/addon-unicode-graphemes";
|
||
import { WebLinksAddon } from "@xterm/addon-web-links";
|
||
import { WebglAddon } from "@xterm/addon-webgl";
|
||
import { Terminal as XTerm } from "@xterm/xterm";
|
||
import type { Dispatch, RefObject, SetStateAction } from "react";
|
||
import {
|
||
checkAppShortcut,
|
||
getAppLevelActions,
|
||
getTerminalPassthroughActions,
|
||
} from "../../../application/state/useGlobalHotkeys";
|
||
import { fontStore } from "../../../application/state/fontStore";
|
||
import { KeywordHighlighter } from "../keywordHighlight";
|
||
import {
|
||
XTERM_PERFORMANCE_CONFIG,
|
||
type XTermPlatform,
|
||
resolveXTermPerformanceConfig,
|
||
} from "../../../infrastructure/config/xtermPerformance";
|
||
import {
|
||
shouldEnableNativeUserInputAutoScroll,
|
||
shouldScrollOnTerminalInput,
|
||
shouldScrollOnTerminalPaste,
|
||
} from "../../../domain/terminalScroll";
|
||
import {
|
||
resolveHostTerminalFontFamilyId,
|
||
resolveHostTerminalFontSize,
|
||
resolveHostTerminalFontWeight,
|
||
} from "../../../domain/terminalAppearance";
|
||
import { logger } from "../../../lib/logger";
|
||
import { isMacPlatform, normalizeLineEndings, wrapBracketedPaste } from "../../../lib/utils";
|
||
import { netcattyBridge } from "../../../infrastructure/services/netcattyBridge";
|
||
import {
|
||
clearTerminalViewport,
|
||
isEraseViewportSequence,
|
||
isEraseScrollbackSequence,
|
||
preserveTerminalViewportInScrollback,
|
||
} from "../clearTerminalViewport";
|
||
import type {
|
||
Host,
|
||
KeyBinding,
|
||
TerminalSession,
|
||
TerminalSettings,
|
||
TerminalTheme,
|
||
} from "../../../types";
|
||
import { matchesKeyBinding } from "../../../domain/models";
|
||
|
||
type TerminalBackendApi = {
|
||
openExternalAvailable: () => boolean;
|
||
openExternal: (url: string) => Promise<void>;
|
||
writeToSession: (sessionId: string, data: string) => void;
|
||
resizeSession: (sessionId: string, cols: number, rows: number) => void;
|
||
};
|
||
|
||
export type XTermRuntime = {
|
||
term: XTerm;
|
||
fitAddon: FitAddon;
|
||
serializeAddon: SerializeAddon;
|
||
searchAddon: SearchAddon;
|
||
dispose: () => void;
|
||
/** Current working directory detected via OSC 7 */
|
||
currentCwd: string | undefined;
|
||
keywordHighlighter: KeywordHighlighter;
|
||
};
|
||
|
||
export type CreateXTermRuntimeContext = {
|
||
container: HTMLDivElement;
|
||
host: Host;
|
||
fontFamilyId: string;
|
||
fontSize: number;
|
||
terminalTheme: TerminalTheme;
|
||
terminalSettingsRef: RefObject<TerminalSettings | undefined>;
|
||
terminalBackend: TerminalBackendApi;
|
||
sessionRef: RefObject<string | null>;
|
||
|
||
hotkeySchemeRef: RefObject<"disabled" | "mac" | "pc">;
|
||
keyBindingsRef: RefObject<KeyBinding[]>;
|
||
onHotkeyActionRef: RefObject<
|
||
((action: string, event: KeyboardEvent) => void) | undefined
|
||
>;
|
||
|
||
isBroadcastEnabledRef: RefObject<boolean | undefined>;
|
||
onBroadcastInputRef: RefObject<
|
||
((data: string, sourceSessionId: string) => void) | undefined
|
||
>;
|
||
|
||
// Snippets for shortkey support
|
||
snippetsRef?: RefObject<{ id: string; command: string; shortkey?: string }[]>;
|
||
|
||
sessionId: string;
|
||
statusRef: RefObject<TerminalSession["status"]>;
|
||
onCommandExecuted?: (
|
||
command: string,
|
||
hostId: string,
|
||
hostLabel: string,
|
||
sessionId: string,
|
||
) => void;
|
||
commandBufferRef: RefObject<string>;
|
||
setIsSearchOpen: Dispatch<SetStateAction<boolean>>;
|
||
|
||
// Serial-specific options
|
||
serialLocalEcho?: boolean;
|
||
serialLineMode?: boolean;
|
||
serialLineBufferRef?: RefObject<string>;
|
||
|
||
// Callback when shell reports CWD change via OSC 7
|
||
onCwdChange?: (cwd: string) => void;
|
||
|
||
// Callback when remote requests clipboard read in 'prompt' mode; resolves to user's decision
|
||
onOsc52ReadRequest?: () => Promise<boolean>;
|
||
|
||
// Autocomplete key event handler — returns false if event was consumed
|
||
onAutocompleteKeyEvent?: (e: KeyboardEvent) => boolean;
|
||
// Autocomplete input handler — called on every character input
|
||
onAutocompleteInput?: (data: string) => void;
|
||
|
||
// Set to true while we're programmatically restoring a selection so that
|
||
// copy-on-select listeners can suppress redundant clipboard writes.
|
||
isRestoringSelectionRef?: RefObject<boolean>;
|
||
};
|
||
|
||
const detectPlatform = (): XTermPlatform => {
|
||
if (
|
||
typeof process !== "undefined" &&
|
||
(process.platform === "darwin" ||
|
||
process.platform === "win32" ||
|
||
process.platform === "linux")
|
||
) {
|
||
return process.platform;
|
||
}
|
||
|
||
if (typeof navigator !== "undefined") {
|
||
const ua = navigator.userAgent.toLowerCase();
|
||
if (ua.includes("win")) return "win32";
|
||
if (ua.includes("linux")) return "linux";
|
||
}
|
||
|
||
return "darwin";
|
||
};
|
||
|
||
/**
|
||
* Extract the primary font family from a CSS font-family string that may
|
||
* include fallback fonts. `document.fonts.check` returns `false` when *any*
|
||
* listed font is still loading, so passing the entire CJK fallback stack
|
||
* causes false negatives during early terminal creation – which in turn makes
|
||
* `fontWeightBold` fall back to the normal weight and renders bold text too
|
||
* thin.
|
||
*/
|
||
export const primaryFontFamily = (fontFamily: string): string => {
|
||
// Split on commas that are NOT inside quotes to handle font names like "Foo, Bar"
|
||
const match = fontFamily.match(/^(?:"[^"]*"|'[^']*'|[^,])+/);
|
||
const first = match?.[0]?.trim();
|
||
return first || fontFamily;
|
||
};
|
||
|
||
export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime => {
|
||
const platform = detectPlatform();
|
||
const deviceMemoryGb =
|
||
typeof navigator !== "undefined" &&
|
||
typeof (navigator as { deviceMemory?: number }).deviceMemory === "number"
|
||
? (navigator as { deviceMemory?: number }).deviceMemory
|
||
: undefined;
|
||
|
||
const settings = ctx.terminalSettingsRef.current;
|
||
const rendererType = settings?.rendererType ?? "auto";
|
||
const bridge = netcattyBridge.get();
|
||
const isLocalTerminalHost = ctx.host.protocol === "local";
|
||
const windowsPty =
|
||
platform === "win32" && isLocalTerminalHost
|
||
? bridge?.getWindowsPtyInfo?.() ?? { backend: "conpty" as const }
|
||
: undefined;
|
||
|
||
const performanceConfig = resolveXTermPerformanceConfig({
|
||
platform,
|
||
deviceMemoryGb,
|
||
rendererType,
|
||
});
|
||
|
||
const hostFontId = resolveHostTerminalFontFamilyId(ctx.host, ctx.fontFamilyId) || "menlo";
|
||
// Use fontStore for font lookup - guarantees non-empty result
|
||
const fontObj = fontStore.getFontById(hostFontId);
|
||
const fontFamily = fontObj.family;
|
||
|
||
const effectiveFontSize = resolveHostTerminalFontSize(ctx.host, ctx.fontSize);
|
||
|
||
const cursorStyle = settings?.cursorShape ?? "block";
|
||
const cursorBlink = settings?.cursorBlink ?? true;
|
||
// xterm.js treats scrollback=0 as "no scrollback buffer", which breaks mouse
|
||
// wheel scrolling (events become arrow-key sequences). The UI uses 0 to mean
|
||
// "no limit", so map it to a large value instead.
|
||
const rawScrollback = settings?.scrollback ?? 10000;
|
||
const scrollback = rawScrollback === 0 ? 999999 : rawScrollback;
|
||
const drawBoldTextInBrightColors = settings?.drawBoldInBrightColors ?? true;
|
||
const fontWeight = resolveHostTerminalFontWeight(ctx.host, settings?.fontWeight ?? 400);
|
||
const fontWeightBold = settings?.fontWeightBold ?? 700;
|
||
const lineHeight = 1 + (settings?.linePadding ?? 0) / 10;
|
||
const minimumContrastRatio = settings?.minimumContrastRatio ?? 1;
|
||
const scrollOnUserInput = shouldEnableNativeUserInputAutoScroll(settings);
|
||
const smoothScrollDuration = settings?.smoothScrolling
|
||
? performanceConfig.options.smoothScrollDuration
|
||
: 0;
|
||
const altIsMeta = settings?.altAsMeta ?? false;
|
||
const wordSeparator = settings?.wordSeparators ?? " ()[]{}'\"";
|
||
const keywordHighlightRules = settings?.keywordHighlightRules ?? [];
|
||
const keywordHighlightEnabled = settings?.keywordHighlightEnabled ?? false;
|
||
|
||
const resolvedFontWeightBold = (() => {
|
||
if (typeof document === "undefined" || !document.fonts?.check) {
|
||
return fontWeightBold;
|
||
}
|
||
const weightSpec = `${fontWeightBold} ${effectiveFontSize}px ${primaryFontFamily(fontFamily)}`;
|
||
return document.fonts.check(weightSpec) ? fontWeightBold : fontWeight;
|
||
})();
|
||
|
||
const term = new XTerm({
|
||
...performanceConfig.options,
|
||
...(windowsPty ? { windowsPty } : {}),
|
||
// Override ignoreBracketedPasteMode if user explicitly disables bracketed paste
|
||
ignoreBracketedPasteMode: settings?.disableBracketedPaste ?? performanceConfig.options.ignoreBracketedPasteMode,
|
||
// Rescale glyphs that would visually overlap into the next cell (CJK compliance)
|
||
rescaleOverlappingGlyphs: true,
|
||
fontSize: effectiveFontSize,
|
||
fontFamily,
|
||
fontWeight: fontWeight as
|
||
| 100
|
||
| 200
|
||
| 300
|
||
| 400
|
||
| 500
|
||
| 600
|
||
| 700
|
||
| 800
|
||
| 900
|
||
| "normal"
|
||
| "bold",
|
||
fontWeightBold: resolvedFontWeightBold as
|
||
| 100
|
||
| 200
|
||
| 300
|
||
| 400
|
||
| 500
|
||
| 600
|
||
| 700
|
||
| 800
|
||
| 900
|
||
| "normal"
|
||
| "bold",
|
||
lineHeight,
|
||
cursorStyle,
|
||
cursorBlink,
|
||
scrollback,
|
||
// Decorations (keyword highlighting) use proposed APIs; enable globally so toggles work at runtime.
|
||
allowProposedApi: true,
|
||
drawBoldTextInBrightColors,
|
||
minimumContrastRatio,
|
||
smoothScrollDuration,
|
||
scrollOnUserInput,
|
||
macOptionClickForcesSelection: true,
|
||
altClickMovesCursor: !altIsMeta,
|
||
wordSeparator,
|
||
theme: {
|
||
...ctx.terminalTheme.colors,
|
||
selectionBackground: ctx.terminalTheme.colors.selection,
|
||
// Scrollbar theming (xterm 6.0) — derive from foreground color
|
||
scrollbarSliderBackground: ctx.terminalTheme.colors.foreground + '33', // 20% opacity
|
||
scrollbarSliderHoverBackground: ctx.terminalTheme.colors.foreground + '66', // 40% opacity
|
||
scrollbarSliderActiveBackground: ctx.terminalTheme.colors.foreground + '80', // 50% opacity
|
||
},
|
||
});
|
||
|
||
type MaybeRenderer = {
|
||
constructor?: { name?: string };
|
||
type?: string;
|
||
};
|
||
|
||
type IntrospectableTerminal = XTerm & {
|
||
_core?: {
|
||
_renderService?: {
|
||
_renderer?: MaybeRenderer;
|
||
};
|
||
};
|
||
options?: {
|
||
rendererType?: string;
|
||
};
|
||
};
|
||
|
||
const logRenderer = (attempt = 0) => {
|
||
const introspected = term as IntrospectableTerminal;
|
||
const renderer = introspected._core?._renderService?._renderer;
|
||
const candidates = [
|
||
renderer?.type,
|
||
renderer?.constructor?.name,
|
||
introspected.options?.rendererType,
|
||
];
|
||
const rendererName =
|
||
candidates.find((value) => typeof value === "string" && value.length > 0) ||
|
||
undefined;
|
||
const normalized = rendererName
|
||
? rendererName.toLowerCase().includes("webgl")
|
||
? "webgl"
|
||
: rendererName.toLowerCase().includes("canvas")
|
||
? "canvas"
|
||
: rendererName
|
||
: "unknown";
|
||
logger.info(`[XTerm] renderer=${normalized}`);
|
||
const scopedWindow = window as Window & { __xtermRenderer?: string };
|
||
scopedWindow.__xtermRenderer = normalized;
|
||
if (normalized === "unknown" && attempt < 3) {
|
||
setTimeout(() => logRenderer(attempt + 1), 150);
|
||
}
|
||
};
|
||
|
||
const fitAddon = new FitAddon();
|
||
term.loadAddon(fitAddon);
|
||
|
||
const serializeAddon = new SerializeAddon();
|
||
term.loadAddon(serializeAddon);
|
||
|
||
const searchAddon = new SearchAddon();
|
||
term.loadAddon(searchAddon);
|
||
|
||
term.open(ctx.container);
|
||
|
||
let webglAddon: WebglAddon | null = null;
|
||
let webglLoaded = false;
|
||
const scopedWindow = window as Window & {
|
||
__xtermWebGLLoaded?: boolean;
|
||
__xtermRendererPreference?: string;
|
||
};
|
||
|
||
if (performanceConfig.useWebGLAddon) {
|
||
try {
|
||
// WebglAddon constructor only accepts `preserveDrawingBuffer?: boolean`.
|
||
// Passing an object here (legacy API assumption) unintentionally enables
|
||
// preserveDrawingBuffer and can cause sporadic glyph artifacts/ghosting.
|
||
webglAddon = new WebglAddon();
|
||
webglAddon.onContextLoss(() => {
|
||
logger.warn("[XTerm] WebGL context loss detected, disposing addon");
|
||
webglAddon?.dispose();
|
||
});
|
||
term.loadAddon(webglAddon);
|
||
webglLoaded = true;
|
||
} catch (webglErr) {
|
||
logger.warn(
|
||
"[XTerm] WebGL addon failed, using DOM renderer. Error:",
|
||
webglErr instanceof Error ? webglErr.message : webglErr,
|
||
);
|
||
}
|
||
} else {
|
||
logger.info(
|
||
"[XTerm] Skipping WebGL addon (DOM preferred for low-memory devices)",
|
||
);
|
||
}
|
||
|
||
scopedWindow.__xtermWebGLLoaded = webglLoaded;
|
||
scopedWindow.__xtermRendererPreference = performanceConfig.preferDOMRenderer
|
||
? "dom"
|
||
: "webgl";
|
||
|
||
const webLinksAddon = new WebLinksAddon((event, uri) => {
|
||
const currentLinkModifier = ctx.terminalSettingsRef.current?.linkModifier ?? "none";
|
||
let shouldOpen = false;
|
||
switch (currentLinkModifier) {
|
||
case "none":
|
||
shouldOpen = true;
|
||
break;
|
||
case "ctrl":
|
||
shouldOpen = event.ctrlKey;
|
||
break;
|
||
case "alt":
|
||
shouldOpen = event.altKey;
|
||
break;
|
||
case "meta":
|
||
shouldOpen = event.metaKey;
|
||
break;
|
||
}
|
||
if (!shouldOpen) return;
|
||
|
||
if (ctx.terminalBackend.openExternalAvailable()) {
|
||
void ctx.terminalBackend.openExternal(uri);
|
||
} else {
|
||
const safeUri = String(uri || "");
|
||
if (/^https?:\/\//i.test(safeUri)) {
|
||
window.open(safeUri, "_blank", "noopener,noreferrer");
|
||
} else {
|
||
logger.warn("[XTerm] Refusing to open non-http(s) link:", safeUri);
|
||
}
|
||
}
|
||
});
|
||
term.loadAddon(webLinksAddon);
|
||
|
||
// Enable Unicode graphemes for accurate CJK / emoji / Nerd Font character width handling
|
||
const unicodeGraphemes = new UnicodeGraphemesAddon();
|
||
term.loadAddon(unicodeGraphemes);
|
||
term.unicode.activeVersion = '15-graphemes';
|
||
|
||
logRenderer();
|
||
|
||
const appLevelActions = getAppLevelActions();
|
||
const terminalActions = getTerminalPassthroughActions();
|
||
const scrollViewportToBottom = () => {
|
||
term.scrollToBottom();
|
||
if (typeof requestAnimationFrame === "function") {
|
||
requestAnimationFrame(() => {
|
||
term.scrollToBottom();
|
||
});
|
||
}
|
||
};
|
||
const scrollToBottomAfterPaste = () => {
|
||
if (shouldScrollOnTerminalPaste(ctx.terminalSettingsRef.current)) {
|
||
scrollViewportToBottom();
|
||
}
|
||
};
|
||
const scrollToBottomAfterInput = (data: string) => {
|
||
if (shouldScrollOnTerminalInput(ctx.terminalSettingsRef.current, data)) {
|
||
term.scrollToBottom();
|
||
}
|
||
};
|
||
|
||
term.attachCustomKeyEventHandler((e: KeyboardEvent) => {
|
||
if (e.type !== "keydown") {
|
||
return true;
|
||
}
|
||
|
||
// Preserve mouse selection across keystrokes when enabled. xterm.js
|
||
// unconditionally clears the selection on user input
|
||
// (SelectionService.ts: coreService.onUserInput → clearSelection).
|
||
// Capture the selection here, then re-apply it after xterm has
|
||
// processed the key + cleared. The microtask runs after both
|
||
// synchronous listeners, so by then either the selection is gone (and
|
||
// we restore) or it's still there (we no-op).
|
||
if (
|
||
ctx.terminalSettingsRef.current?.preserveSelectionOnInput &&
|
||
term.hasSelection()
|
||
) {
|
||
const sel = term.getSelectionPosition();
|
||
if (sel) {
|
||
const length =
|
||
(sel.end.y - sel.start.y) * term.cols + (sel.end.x - sel.start.x);
|
||
const savedStartX = sel.start.x;
|
||
const savedStartY = sel.start.y;
|
||
queueMicrotask(() => {
|
||
if (term.hasSelection()) return;
|
||
// Bail out if scrollback trim invalidated the row index.
|
||
if (savedStartY >= term.buffer.active.length) return;
|
||
const restoreFlag = ctx.isRestoringSelectionRef;
|
||
if (restoreFlag) restoreFlag.current = true;
|
||
try {
|
||
term.select(savedStartX, savedStartY, length);
|
||
} finally {
|
||
if (restoreFlag) restoreFlag.current = false;
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
// Autocomplete key handler (must be checked before other handlers)
|
||
if (ctx.onAutocompleteKeyEvent) {
|
||
const consumed = ctx.onAutocompleteKeyEvent(e);
|
||
if (!consumed) return false; // Event was consumed by autocomplete
|
||
}
|
||
|
||
const currentScheme = ctx.hotkeySchemeRef.current;
|
||
// Use shared utility for platform detection when hotkey scheme is disabled
|
||
const isMac = currentScheme === "mac" || (currentScheme === "disabled" && isMacPlatform());
|
||
|
||
// Check snippet shortcuts first (even if hotkeys are disabled)
|
||
const snippets = ctx.snippetsRef?.current;
|
||
if (snippets && snippets.length > 0) {
|
||
for (const snippet of snippets) {
|
||
if (snippet.shortkey && matchesKeyBinding(e, snippet.shortkey, isMac)) {
|
||
const id = ctx.sessionRef.current;
|
||
if (id && ctx.statusRef.current === "connected") {
|
||
e.preventDefault();
|
||
e.stopPropagation();
|
||
// Send the snippet command to the terminal
|
||
let snippetData = normalizeLineEndings(snippet.command);
|
||
if (!snippet.noAutoRun) snippetData = `${snippetData}\r`;
|
||
// Broadcast the normalized (un-wrapped) data so each target
|
||
// session can apply its own bracket paste state
|
||
if (ctx.isBroadcastEnabledRef.current && ctx.onBroadcastInputRef.current) {
|
||
ctx.onBroadcastInputRef.current(snippetData, ctx.sessionId);
|
||
}
|
||
// Wrap for this terminal only, after broadcasting
|
||
const snippetIsMultiLine = snippetData.includes("\n");
|
||
if (snippetIsMultiLine && term.modes.bracketedPasteMode && !ctx.terminalSettingsRef.current?.disableBracketedPaste) snippetData = wrapBracketedPaste(snippetData);
|
||
// Notify autocomplete with the final (possibly bracket-wrapped)
|
||
// bytes so its keystroke buffer can tell literal multi-line
|
||
// paste ("\x1b[200~...\x1b[201~") from the non-bracketed path
|
||
// where each \n executes an intermediate command (#814 P2).
|
||
ctx.onAutocompleteInput?.(snippetData);
|
||
ctx.terminalBackend.writeToSession(id, snippetData);
|
||
if (!snippet.noAutoRun && ctx.onCommandExecuted) {
|
||
const cmd = snippet.command.trim();
|
||
if (cmd) ctx.onCommandExecuted(cmd, ctx.host.id, ctx.host.label, ctx.sessionId);
|
||
ctx.commandBufferRef.current = "";
|
||
}
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
|
||
const currentBindings = ctx.keyBindingsRef.current;
|
||
if (currentScheme === "disabled" || currentBindings.length === 0) {
|
||
return true;
|
||
}
|
||
|
||
const matched = checkAppShortcut(e, currentBindings, isMac);
|
||
if (!matched) return true;
|
||
|
||
const { action } = matched;
|
||
|
||
if (appLevelActions.has(action)) {
|
||
return true; // Let app-level handler process it
|
||
}
|
||
|
||
if (terminalActions.has(action)) {
|
||
e.preventDefault();
|
||
e.stopPropagation();
|
||
switch (action) {
|
||
case "copy": {
|
||
const selection = term.getSelection();
|
||
if (selection) navigator.clipboard.writeText(selection);
|
||
break;
|
||
}
|
||
case "paste": {
|
||
navigator.clipboard.readText().then((text) => {
|
||
const id = ctx.sessionRef.current;
|
||
if (id) {
|
||
const rawData = normalizeLineEndings(text);
|
||
const data = term.modes.bracketedPasteMode && !ctx.terminalSettingsRef.current?.disableBracketedPaste
|
||
? wrapBracketedPaste(rawData)
|
||
: rawData;
|
||
// Notify autocomplete with the final bytes so bracketed
|
||
// pastes preserve their inner newlines as literal input.
|
||
ctx.onAutocompleteInput?.(data);
|
||
ctx.terminalBackend.writeToSession(id, data);
|
||
scrollToBottomAfterPaste();
|
||
}
|
||
});
|
||
break;
|
||
}
|
||
case "pasteSelection": {
|
||
const selection = term.getSelection();
|
||
const id = ctx.sessionRef.current;
|
||
if (selection && id) {
|
||
const rawData = normalizeLineEndings(selection);
|
||
const data = term.modes.bracketedPasteMode && !ctx.terminalSettingsRef.current?.disableBracketedPaste
|
||
? wrapBracketedPaste(rawData)
|
||
: rawData;
|
||
ctx.onAutocompleteInput?.(data);
|
||
ctx.terminalBackend.writeToSession(id, data);
|
||
scrollToBottomAfterPaste();
|
||
}
|
||
break;
|
||
}
|
||
case "selectAll": {
|
||
term.selectAll();
|
||
break;
|
||
}
|
||
case "clearBuffer": {
|
||
clearTerminalViewport(term);
|
||
break;
|
||
}
|
||
case "searchTerminal": {
|
||
ctx.setIsSearchOpen(true);
|
||
break;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
});
|
||
|
||
let cleanupMiddleClick: (() => void) | null = null;
|
||
const middleClickPaste = settings?.middleClickPaste ?? true;
|
||
if (middleClickPaste) {
|
||
const handleMiddleClick = async (e: MouseEvent) => {
|
||
if (e.button !== 1) return;
|
||
e.preventDefault();
|
||
try {
|
||
const text = await navigator.clipboard.readText();
|
||
if (text && ctx.sessionRef.current) {
|
||
const rawData = normalizeLineEndings(text);
|
||
const data = term.modes.bracketedPasteMode && !ctx.terminalSettingsRef.current?.disableBracketedPaste
|
||
? wrapBracketedPaste(rawData)
|
||
: rawData;
|
||
ctx.onAutocompleteInput?.(data);
|
||
ctx.terminalBackend.writeToSession(ctx.sessionRef.current, data);
|
||
scrollToBottomAfterPaste();
|
||
}
|
||
} catch (err) {
|
||
logger.warn("[Terminal] Failed to paste from clipboard:", err);
|
||
}
|
||
};
|
||
|
||
ctx.container.addEventListener("auxclick", handleMiddleClick);
|
||
cleanupMiddleClick = () =>
|
||
ctx.container.removeEventListener("auxclick", handleMiddleClick);
|
||
}
|
||
|
||
fitAddon.fit();
|
||
term.focus();
|
||
|
||
term.onData((data) => {
|
||
const id = ctx.sessionRef.current;
|
||
if (id) {
|
||
// Serial line mode: buffer input and send on Enter
|
||
if (ctx.host.protocol === "serial" && ctx.serialLineMode && ctx.serialLineBufferRef) {
|
||
if (data === "\r") {
|
||
// Enter key: send buffered line + CR
|
||
const line = ctx.serialLineBufferRef.current + "\r";
|
||
ctx.terminalBackend.writeToSession(id, line);
|
||
ctx.serialLineBufferRef.current = "";
|
||
// Local echo newline if enabled
|
||
if (ctx.serialLocalEcho) {
|
||
term.write("\r\n");
|
||
}
|
||
} else if (data === "\x7f" || data === "\b") {
|
||
// Backspace: remove last character from buffer
|
||
if (ctx.serialLineBufferRef.current.length > 0) {
|
||
ctx.serialLineBufferRef.current = ctx.serialLineBufferRef.current.slice(0, -1);
|
||
if (ctx.serialLocalEcho) {
|
||
term.write("\b \b");
|
||
}
|
||
}
|
||
} else if (data === "\x03") {
|
||
// Ctrl+C: clear buffer and send Ctrl+C
|
||
ctx.serialLineBufferRef.current = "";
|
||
ctx.terminalBackend.writeToSession(id, data);
|
||
if (ctx.serialLocalEcho) {
|
||
term.write("^C\r\n");
|
||
}
|
||
} else if (data === "\x15") {
|
||
// Ctrl+U: clear line buffer
|
||
if (ctx.serialLocalEcho && ctx.serialLineBufferRef.current.length > 0) {
|
||
// Erase the displayed line
|
||
const len = ctx.serialLineBufferRef.current.length;
|
||
term.write("\b \b".repeat(len));
|
||
}
|
||
ctx.serialLineBufferRef.current = "";
|
||
} else if (data.charCodeAt(0) >= 32 || data.length > 1) {
|
||
// Regular characters: add to buffer
|
||
ctx.serialLineBufferRef.current += data;
|
||
if (ctx.serialLocalEcho) {
|
||
term.write(data);
|
||
}
|
||
}
|
||
} else {
|
||
// Character mode (default): send immediately
|
||
// When backspaceBehavior is configured, remap the Backspace key output
|
||
let outData = data;
|
||
if (data === "\x7f" && ctx.host.backspaceBehavior === "ctrl-h") {
|
||
outData = "\x08";
|
||
}
|
||
ctx.terminalBackend.writeToSession(id, outData);
|
||
|
||
// Local echo for serial connections only when explicitly enabled
|
||
if (ctx.host.protocol === "serial" && ctx.serialLocalEcho) {
|
||
if (data === "\r") {
|
||
term.write("\r\n");
|
||
} else if (data === "\x7f" || data === "\b") {
|
||
term.write("\b \b");
|
||
} else if (data === "\x03") {
|
||
term.write("^C");
|
||
} else if (data.charCodeAt(0) >= 32 || data.length > 1) {
|
||
term.write(data);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (ctx.isBroadcastEnabledRef.current && ctx.onBroadcastInputRef.current) {
|
||
// Use remapped data so broadcast peers also receive the correct byte
|
||
const broadcastData = (data === "\x7f" && ctx.host.backspaceBehavior === "ctrl-h") ? "\x08" : data;
|
||
ctx.onBroadcastInputRef.current(broadcastData, ctx.sessionId);
|
||
}
|
||
|
||
scrollToBottomAfterInput(data);
|
||
|
||
// Notify autocomplete of input
|
||
ctx.onAutocompleteInput?.(data);
|
||
|
||
if (ctx.statusRef.current === "connected" && ctx.onCommandExecuted) {
|
||
if (data === "\r" || data === "\n") {
|
||
const cmd = ctx.commandBufferRef.current.trim();
|
||
if (cmd) ctx.onCommandExecuted(cmd, ctx.host.id, ctx.host.label, ctx.sessionId);
|
||
ctx.commandBufferRef.current = "";
|
||
} else if (data === "\x7f" || data === "\b") {
|
||
ctx.commandBufferRef.current = ctx.commandBufferRef.current.slice(0, -1);
|
||
} else if (data === "\x03") {
|
||
ctx.commandBufferRef.current = "";
|
||
} else if (data === "\x15") {
|
||
ctx.commandBufferRef.current = "";
|
||
} else if (data.length === 1 && data.charCodeAt(0) >= 32) {
|
||
ctx.commandBufferRef.current += data;
|
||
} else if (data.length > 1 && !data.startsWith("\x1b")) {
|
||
ctx.commandBufferRef.current += data;
|
||
}
|
||
}
|
||
}
|
||
});
|
||
|
||
// Track current working directory via OSC 7 escape sequences
|
||
// OSC 7 format: \x1b]7;file://hostname/path\x07 or \x1b]7;file://hostname/path\x1b\\
|
||
let currentCwd: string | undefined = undefined;
|
||
|
||
const eraseScrollbackDisposable = term.parser.registerCsiHandler({ final: "J" }, (params) => {
|
||
if (isEraseViewportSequence(params)) {
|
||
preserveTerminalViewportInScrollback(term);
|
||
return false;
|
||
}
|
||
if (!isEraseScrollbackSequence(params)) {
|
||
return false;
|
||
}
|
||
// CSI 3 J — POSIX/ncurses default `clear` emits this to wipe scrollback.
|
||
// Honor it unless the user opts into the legacy "preserve history" behavior.
|
||
const wipeAllowed = ctx.terminalSettingsRef.current?.clearWipesScrollback ?? true;
|
||
return !wipeAllowed;
|
||
});
|
||
|
||
// Register OSC 7 handler using xterm.js parser
|
||
// OSC 7 is the standard way for shells to report the current working directory
|
||
const osc7Disposable = term.parser.registerOscHandler(7, (data) => {
|
||
try {
|
||
// data is the content after "7;" - typically "file://hostname/path"
|
||
if (data.startsWith('file://')) {
|
||
// Extract path from file:// URL
|
||
const url = new URL(data);
|
||
const path = decodeURIComponent(url.pathname);
|
||
if (path && path.length > 0) {
|
||
currentCwd = path;
|
||
ctx.onCwdChange?.(path);
|
||
logger.debug('[XTerm] OSC 7 CWD update:', path);
|
||
}
|
||
} else if (data.startsWith('/')) {
|
||
// Some shells send just the path without file:// prefix
|
||
currentCwd = data;
|
||
ctx.onCwdChange?.(data);
|
||
logger.debug('[XTerm] OSC 7 CWD update (raw path):', data);
|
||
}
|
||
} catch (err) {
|
||
logger.warn('[XTerm] Failed to parse OSC 7:', err);
|
||
}
|
||
return true; // Indicate we handled the sequence
|
||
});
|
||
|
||
// OSC 52 — clipboard integration
|
||
// Format: 52;<target>;<base64-data> (write) or 52;<target>;? (query/read)
|
||
// <target> is typically "c" (clipboard) or "p" (primary selection)
|
||
// Controlled by terminalSettings.osc52Clipboard: 'off' | 'write-only' | 'read-write'
|
||
const osc52Disposable = term.parser.registerOscHandler(52, (data) => {
|
||
const settings = ctx.terminalSettingsRef.current;
|
||
const mode = settings?.osc52Clipboard ?? 'write-only';
|
||
if (mode === 'off') return true;
|
||
|
||
try {
|
||
const semi = data.indexOf(';');
|
||
if (semi < 0) return true;
|
||
const target = data.substring(0, semi);
|
||
// Only handle clipboard target ('c'); reject unsupported targets like 'p' (PRIMARY)
|
||
if (target !== 'c' && target !== '') return true;
|
||
const payload = data.substring(semi + 1);
|
||
|
||
if (payload === '?') {
|
||
// Read request — allowed in read-write mode, or prompt user in prompt mode
|
||
if (mode !== 'read-write' && mode !== 'prompt') {
|
||
logger.debug('[XTerm] OSC 52 read request ignored (mode:', mode, ')');
|
||
return true;
|
||
}
|
||
const sessionId = ctx.sessionRef.current;
|
||
if (!sessionId) return true;
|
||
// Use Electron bridge as primary, fall back to navigator.clipboard
|
||
const readClipboard = async (): Promise<string> => {
|
||
try {
|
||
const bridge = netcattyBridge.get();
|
||
if (bridge?.readClipboardText) return await bridge.readClipboardText();
|
||
} catch { /* fall through to navigator.clipboard */ }
|
||
return navigator.clipboard.readText();
|
||
};
|
||
const doRead = async () => {
|
||
// In prompt mode, ask user first
|
||
if (mode === 'prompt') {
|
||
const allowed = ctx.onOsc52ReadRequest ? await ctx.onOsc52ReadRequest() : false;
|
||
if (!allowed) {
|
||
logger.debug('[XTerm] OSC 52 read denied by user');
|
||
return;
|
||
}
|
||
}
|
||
const text = await readClipboard();
|
||
// Chunked base64 encoding to avoid stack overflow on large payloads
|
||
const bytes = new TextEncoder().encode(text);
|
||
let binary = '';
|
||
for (let i = 0; i < bytes.length; i += 8192) {
|
||
binary += String.fromCharCode(...bytes.subarray(i, i + 8192));
|
||
}
|
||
const b64 = btoa(binary);
|
||
ctx.terminalBackend.writeToSession(sessionId, `\x1b]52;${target};${b64}\x07`);
|
||
};
|
||
doRead().catch((err) => {
|
||
logger.warn('[XTerm] OSC 52 clipboard read failed:', err);
|
||
});
|
||
return true;
|
||
}
|
||
|
||
// Write: payload is base64-encoded UTF-8 text
|
||
const binary = atob(payload);
|
||
const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
|
||
const text = new TextDecoder().decode(bytes);
|
||
navigator.clipboard.writeText(text).catch((err) => {
|
||
logger.warn('[XTerm] OSC 52 clipboard write failed:', err);
|
||
});
|
||
logger.debug('[XTerm] OSC 52 clipboard write', { length: text.length });
|
||
} catch (err) {
|
||
logger.warn('[XTerm] Failed to handle OSC 52:', err);
|
||
}
|
||
return true;
|
||
});
|
||
|
||
let resizeTimeout: NodeJS.Timeout | null = null;
|
||
const resizeDebounceMs = XTERM_PERFORMANCE_CONFIG.resize.debounceMs;
|
||
term.onResize(({ cols, rows }) => {
|
||
const id = ctx.sessionRef.current;
|
||
if (!id) return;
|
||
if (resizeTimeout) clearTimeout(resizeTimeout);
|
||
resizeTimeout = setTimeout(() => {
|
||
ctx.terminalBackend.resizeSession(id, cols, rows);
|
||
resizeTimeout = null;
|
||
}, resizeDebounceMs);
|
||
});
|
||
|
||
const keywordHighlighter = new KeywordHighlighter(term);
|
||
keywordHighlighter.setRules(keywordHighlightRules, keywordHighlightEnabled);
|
||
|
||
return {
|
||
term,
|
||
fitAddon,
|
||
serializeAddon,
|
||
searchAddon,
|
||
keywordHighlighter,
|
||
dispose: () => {
|
||
cleanupMiddleClick?.();
|
||
keywordHighlighter.dispose();
|
||
eraseScrollbackDisposable.dispose();
|
||
osc7Disposable.dispose();
|
||
osc52Disposable.dispose();
|
||
try {
|
||
term.dispose();
|
||
} catch (err) {
|
||
logger.warn("[XTerm] dispose failed", err);
|
||
}
|
||
try {
|
||
fitAddon.dispose();
|
||
} catch (err) {
|
||
logger.warn("[XTerm] fitAddon dispose failed", err);
|
||
}
|
||
try {
|
||
serializeAddon.dispose();
|
||
} catch (err) {
|
||
logger.warn("[XTerm] serializeAddon dispose failed", err);
|
||
}
|
||
try {
|
||
searchAddon.dispose();
|
||
} catch (err) {
|
||
logger.warn("[XTerm] searchAddon dispose failed", err);
|
||
}
|
||
try {
|
||
webglAddon?.dispose();
|
||
} catch (err) {
|
||
logger.warn("[XTerm] webglAddon dispose failed", err);
|
||
}
|
||
},
|
||
get currentCwd() {
|
||
return currentCwd;
|
||
},
|
||
};
|
||
};
|