mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-17 04:50:52 +00:00
* 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>
376 lines
10 KiB
TypeScript
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,
|
|
};
|
|
}
|