Files
Netcatty/domain/terminalOutputTriggerFilter.ts
T
陈大猫andCursor 6b9b71ac8a feat(scripts): terminal script automation, recording, and side panel (#1763)
* feat(scripts): add terminal script automation, recording, and side panel

Introduce nct script runtime in the main process with terminal-side recording,
execution overlay, Monaco editor, connect-script queues, and scripts side panel
integration. Fix recording to wire scriptRecorderRef into xterm, use waitForPrompt
for root/user shells, and save recorded scripts through the global editor dialog.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): address Bugbot review findings for recording and side panel

Refresh script run state in side panel memo, guard toolbar recording against
multi-session conflicts, reset connect scripts on reconnect, resolve focused
session via getActiveTerminalSessionId, and avoid wiping host edit form when
snippets list updates.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): prevent pending script re-run and improve workspace run feedback

Track one-shot pendingScript execution separately from onConnect queue so
reconnects do not replay Run-now scripts. Fall back to focused session when
running on all tabs outside a workspace, and toast when every tab is still
connecting.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): consume connect-script window once and filter serial hosts

Mark the onConnect script evaluation as consumed even when the queue is
empty so later snippet/host edits do not rerun automation mid-session.
Restore serial-host filtering in SelectHostPanel confirm handler.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): grace period before giving up on connect-script queue

Only mark onConnect automation as consumed after scripts run or a short
post-connect grace window expires, so late-loading snippets still trigger
while mid-session Vault edits do not.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): gate connect-script consumption on vault hydration

Replace the grace timer with vault-init and unresolved host script binding
checks so late-loading snippets still run onConnect automation while
mid-session edits stay suppressed. Clear pending script run state on
disconnect so reconnect retries workspace pending scripts.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): honor run targets and retry failed connect automation

Route QuickScriptEditorDialog Run through onRunSnippet for multi-host
workspaces. Defer connect/pending script completion markers until each
script succeeds and retry the queue after failures.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): stabilize pending runs and global connect queue sync

Keep pending script run state across reconnects, run onConnect scripts
before one-shot workspace pending scripts, and strip per-host queue entries
when an onConnect script targets all hosts.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): defer host queue snippet sync and guard connect runs

Persist snippet target links only when the host panel is saved, block
duplicate connect-script scheduling while a batch is running, and require
runnable hosts before showing Run in the snippets editor footer.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): retry connect failures and surface output-trigger errors

Use a retry tick in connect-script effect deps, toast automation failures
from output triggers, and require runnable hosts before QuickScript Run.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): track id-less pending runs and re-arm output triggers

Remember anonymous pendingScript objects after first run and allow
onOutput triggers to fire again when new terminal output arrives.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): unblock paused connect runs and pass session meta

Resolve waitForScriptRun on pause, run workspace scripts per session
with hostname context, defer output-trigger arming until runs start, and
add noRunnableHosts i18n for QuickScript Run.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): serialize output triggers and defer empty connect finalize

Fire at most one onOutput trigger per scan while a run is active, and
only finalize an empty connect queue after vault snippets are loaded.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): guard output launch race and script run waits

Block overlapping onOutput launches, timeout stuck waitForScriptRun
promises, and disable vault Run when no connectable targets exist.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): match output triggers on new chunks only

Scan onOutput patterns against recent terminal output instead of buffer
length dedupe, and restore overflow-visible on SelectHostPanel new-host flow.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): await sequential workspace runs and output launch

Wait for each tab script to finish in sequential workspace mode, and hold
output-trigger launch guard until the session run becomes active.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): wait through pause and hold output trigger until done

Keep connect and sequential workspace queues blocked until scripts
complete or fail, and retain output-trigger guard until the launched run
finishes.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): harden output trigger wait helpers

Add explicit timeouts to output-trigger wait helpers and stop rescanning
the buffer after script completion to avoid sticky-match rerun loops.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): allow empty connect queue and match output in new chunks

Treat an empty connectScriptIds array as an explicit cleared queue instead
of re-migrating from snippet targets, and only fire onOutput triggers when
the latest terminal output contains the pattern.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): require fresh output overlap for onOutput triggers

Only fire output-matched scripts when the regex match extends into the
latest terminal chunk, preventing reruns from stale buffer text.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): promote manual scripts added to host connect queue

Diff connect queue changes from raw connectScriptIds so saving a host
updates manual scripts to onConnect when they are newly queued.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): dedupe output triggers by match position

Track the buffer end offset of each output trigger match and ignore
stale re-scans, with a longer wait for run registration before retry.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): record output trigger matches only after run starts

Propagate automation launch failures to output triggers and commit match
dedupe only once the session run is registered as active.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): address Codex review on wait cursor and sensitive codegen

Track scan offset so waitFor/waitForAny only match output after the previous wait, and emit sendLine after sensitive prompt in recorded scripts.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): harden onOutput triggers against PTY echo and local input

Filter server output before pattern matching so onOutput fires only after
Enter on real stdout, not on keystroke/paste echo, OSC/SGR sequences, or
alternate-screen apps. Add dev diagnostics and scope triggers to the active
session when no explicit host targets are configured.

Co-authored-by: Cursor <cursoragent@cursor.com>

* chore(scripts): remove onOutput trigger debug logging

Drop temporary diagnostics module and console traces now that PTY echo
filtering is verified; keep the production trigger pipeline unchanged.

Co-authored-by: Cursor <cursoragent@cursor.com>

---------

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-06-28 23:48:12 +08:00

376 lines
10 KiB
TypeScript

const MAX_PENDING_ECHO = 4096;
const ALTERNATE_SCREEN_MODES = new Set([47, 1047, 1049]);
export type TerminalOutputChunkMeta = {
rawLen: number;
dropReason?:
| 'empty-chunk'
| 'awaiting-submitted-echo'
| 'alternate-screen-active'
| 'pending-escape'
| 'user-echo-only'
| 'control-only'
| 'editing-input-line';
submittedEchoLine?: string;
submittedEchoCandidateLen: number;
afterSubmittedLen: number;
afterUserEchoLen: number;
scannableLen: number;
};
export type TerminalOutputTriggerFilter = {
noteUserInput: (data: string) => void;
processServerChunk: (chunk: string) => {
scannableText: string;
alternateScreenActive: boolean;
meta: TerminalOutputChunkMeta;
};
reset: () => void;
};
function getAlternateScreenAction(sequence: string): 'enter' | 'leave' | null {
if (!sequence.startsWith('\x1b[') || sequence.length < 3) return null;
const final = sequence.at(-1);
if (final !== 'h' && final !== 'l') return null;
const params = sequence.slice(2, -1);
if (!params.startsWith('?')) return null;
const modes = params
.slice(1)
.split(';')
.map((part) => Number.parseInt(part, 10))
.filter(Number.isFinite);
if (!modes.some((mode) => ALTERNATE_SCREEN_MODES.has(mode))) {
return null;
}
return final === 'h' ? 'enter' : 'leave';
}
function readCsiSequence(input: string, startIndex: number): { sequence: string; end: number } | null {
if (input[startIndex] !== '\x1b' || input[startIndex + 1] !== '[') return null;
for (let index = startIndex + 2; index < input.length; index += 1) {
const code = input.charCodeAt(index);
if (code >= 0x40 && code <= 0x7e) {
return {
sequence: input.slice(startIndex, index + 1),
end: index + 1,
};
}
}
return null;
}
/** OSC: ESC ] payload BEL (0x07) or ST (ESC \\). */
function readOscSequence(input: string, startIndex: number): { sequence: string; end: number } | null {
if (input[startIndex] !== '\x1b' || input[startIndex + 1] !== ']') return null;
for (let index = startIndex + 2; index < input.length; index += 1) {
if (input[index] === '\x07') {
return {
sequence: input.slice(startIndex, index + 1),
end: index + 1,
};
}
if (input[index] === '\x1b' && input[index + 1] === '\\') {
return {
sequence: input.slice(startIndex, index + 2),
end: index + 2,
};
}
}
return null;
}
function readEscapeSequence(input: string, startIndex: number): { sequence: string; end: number } | null {
if (input[startIndex] !== '\x1b') return null;
if (startIndex + 1 >= input.length) return null;
const next = input[startIndex + 1];
if (next === '[') return readCsiSequence(input, startIndex);
if (next === ']') return readOscSequence(input, startIndex);
const nextCode = next.charCodeAt(0);
if (nextCode >= 0x40 && nextCode <= 0x7e) {
return {
sequence: input.slice(startIndex, startIndex + 2),
end: startIndex + 2,
};
}
return null;
}
function stripUserEcho(pendingEcho: string, chunk: string): { pendingEcho: string; filtered: string } {
if (!pendingEcho || !chunk) {
return { pendingEcho, filtered: chunk };
}
let echoIndex = 0;
let chunkIndex = 0;
let matchedPrintable = 0;
while (echoIndex < pendingEcho.length && chunkIndex < chunk.length) {
if (chunk[chunkIndex] === '\x1b') {
const sequence = readEscapeSequence(chunk, chunkIndex);
if (!sequence) break;
chunkIndex = sequence.end;
continue;
}
if (pendingEcho[echoIndex] === chunk[chunkIndex]) {
echoIndex += 1;
chunkIndex += 1;
matchedPrintable += 1;
continue;
}
break;
}
if (matchedPrintable > 0) {
return {
pendingEcho: pendingEcho.slice(echoIndex),
filtered: chunk.slice(chunkIndex),
};
}
return {
pendingEcho: '',
filtered: chunk,
};
}
function isPrintableInput(char: string): boolean {
const code = char.codePointAt(0);
return code !== undefined && code >= 0x20 && code !== 0x7f;
}
function applyInputToLine(line: string, data: string): { line: string; submittedLine: string | null } {
let nextLine = line;
let submittedLine: string | null = null;
for (const char of stripInputControlWrappers(data)) {
if (char === '\r' || char === '\n') {
submittedLine = nextLine;
nextLine = '';
continue;
}
if (char === '\x7f' || char === '\b') {
nextLine = nextLine.slice(0, -1);
continue;
}
if (isPrintableInput(char)) {
nextLine += char;
}
}
return { line: nextLine, submittedLine };
}
const BRACKETED_PASTE_START = '\x1b[200~';
const BRACKETED_PASTE_END = '\x1b[201~';
function stripInputControlWrappers(data: string): string {
return data.split(BRACKETED_PASTE_START).join('').split(BRACKETED_PASTE_END).join('');
}
function appendPendingEcho(pendingEcho: string, data: string): string {
let next = pendingEcho;
let index = 0;
const sanitized = stripInputControlWrappers(data);
while (index < sanitized.length) {
const char = sanitized[index];
if (char === '\r' || char === '\n') {
index += 1;
continue;
}
if (char === '\x1b') {
const sequence = readEscapeSequence(sanitized, index);
if (sequence) {
index = sequence.end;
continue;
}
index += 1;
continue;
}
if (char === '\x7f') {
next = next.slice(0, -1);
index += 1;
continue;
}
if (char === '\x08') {
next += char;
index += 1;
continue;
}
if (isPrintableInput(char)) {
next += char;
index += 1;
continue;
}
index += 1;
}
return next.slice(-MAX_PENDING_ECHO);
}
function stripSubmittedLineEcho(
submittedLine: string | null,
candidate: string,
chunk: string,
): { submittedLine: string | null; candidate: string; filtered: string } {
if (submittedLine === null || submittedLine.length === 0) {
return { submittedLine: null, candidate: '', filtered: chunk };
}
const nextCandidate = candidate + chunk;
const echoVariants = [
`${submittedLine}\r\n`,
`${submittedLine}\n`,
`${submittedLine}\r`,
];
const fullEcho = echoVariants.find((variant) => nextCandidate.startsWith(variant));
if (fullEcho) {
return {
submittedLine: null,
candidate: '',
filtered: nextCandidate.slice(fullEcho.length),
};
}
if (echoVariants.some((variant) => variant.startsWith(nextCandidate))) {
return { submittedLine, candidate: nextCandidate, filtered: '' };
}
return {
submittedLine: null,
candidate: '',
filtered: nextCandidate,
};
}
export function createTerminalOutputTriggerFilter(): TerminalOutputTriggerFilter {
let pendingEcho = '';
let currentInputLine = '';
let submittedEchoLine: string | null = null;
let submittedEchoCandidate = '';
let alternateScreenActive = false;
let pendingEscape = '';
const reset = () => {
pendingEcho = '';
currentInputLine = '';
submittedEchoLine = null;
submittedEchoCandidate = '';
alternateScreenActive = false;
pendingEscape = '';
};
const noteUserInput = (data: string) => {
if (!data) return;
const inputState = applyInputToLine(currentInputLine, data);
currentInputLine = inputState.line;
if (inputState.submittedLine !== null) {
submittedEchoLine = inputState.submittedLine;
submittedEchoCandidate = '';
pendingEcho = '';
return;
}
pendingEcho = appendPendingEcho(pendingEcho, data);
};
const processServerChunk = (chunk: string) => {
const input = pendingEscape ? `${pendingEscape}${chunk}` : chunk;
pendingEscape = '';
const submitted = stripSubmittedLineEcho(submittedEchoLine, submittedEchoCandidate, input);
submittedEchoLine = submitted.submittedLine;
submittedEchoCandidate = submitted.candidate;
if (!submitted.filtered) {
return {
scannableText: '',
alternateScreenActive,
meta: {
rawLen: chunk.length,
dropReason: chunk.length === 0
? 'empty-chunk'
: 'awaiting-submitted-echo',
submittedEchoLine: submittedEchoLine ?? undefined,
submittedEchoCandidateLen: submittedEchoCandidate.length,
afterSubmittedLen: 0,
afterUserEchoLen: 0,
scannableLen: 0,
},
};
}
const { pendingEcho: nextPendingEcho, filtered } = stripUserEcho(pendingEcho, submitted.filtered);
pendingEcho = nextPendingEcho;
let scannableText = '';
let hitPendingEscape = false;
for (let index = 0; index < filtered.length; index += 1) {
if (filtered[index] !== '\x1b') {
if (!alternateScreenActive) {
scannableText += filtered[index];
}
continue;
}
const sequence = readEscapeSequence(filtered, index);
if (!sequence) {
pendingEscape = filtered.slice(index);
hitPendingEscape = true;
break;
}
if (sequence.sequence.startsWith('\x1b[')) {
const alternateScreenAction = getAlternateScreenAction(sequence.sequence);
if (alternateScreenAction === 'enter') {
alternateScreenActive = true;
pendingEcho = '';
} else if (alternateScreenAction === 'leave') {
alternateScreenActive = false;
pendingEcho = '';
}
}
index = sequence.end - 1;
}
let dropReason: TerminalOutputChunkMeta['dropReason'];
if (currentInputLine.length > 0) {
scannableText = '';
dropReason = 'editing-input-line';
} else if (!scannableText) {
if (hitPendingEscape) {
dropReason = 'pending-escape';
} else if (alternateScreenActive) {
dropReason = 'alternate-screen-active';
} else if (filtered.length === 0) {
dropReason = 'user-echo-only';
} else {
dropReason = 'control-only';
}
}
return {
scannableText,
alternateScreenActive,
meta: {
rawLen: chunk.length,
dropReason,
submittedEchoLine: submittedEchoLine ?? undefined,
submittedEchoCandidateLen: submittedEchoCandidate.length,
afterSubmittedLen: submitted.filtered.length,
afterUserEchoLen: filtered.length,
scannableLen: scannableText.length,
},
};
};
return {
noteUserInput,
processServerChunk,
reset,
};
}