starmux 0.12.0 → 0.13.0

package/dist/vendor/desktop-commander/dist/utils/fuzzySearchLogger.js

@@ -0,0 +1,126 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+class FuzzySearchLogger {
+    constructor() {
+        this.initialized = false;
+        // Create log file in a dedicated directory
+        const logDir = path.join(os.homedir(), '.claude-server-commander-logs');
+        this.logPath = path.join(logDir, 'fuzzy-search.log');
+    }
+    async ensureLogFile() {
+        if (this.initialized)
+            return;
+        try {
+            // Create log directory if it doesn't exist
+            const logDir = path.dirname(this.logPath);
+            await fs.mkdir(logDir, { recursive: true });
+            // Check if log file exists, create with headers if not
+            try {
+                await fs.access(this.logPath);
+            }
+            catch {
+                // File doesn't exist, create with headers
+                const headers = [
+                    'timestamp',
+                    'searchText',
+                    'foundText',
+                    'similarity',
+                    'executionTime',
+                    'exactMatchCount',
+                    'expectedReplacements',
+                    'fuzzyThreshold',
+                    'belowThreshold',
+                    'diff',
+                    'searchLength',
+                    'foundLength',
+                    'fileExtension',
+                    'characterCodes',
+                    'uniqueCharacterCount',
+                    'diffLength'
+                ].join('\t');
+                await fs.writeFile(this.logPath, headers + '\n');
+            }
+            this.initialized = true;
+        }
+        catch (error) {
+            console.error('Failed to initialize fuzzy search log file:', error);
+            throw error;
+        }
+    }
+    async log(entry) {
+        try {
+            await this.ensureLogFile();
+            // Convert entry to tab-separated string
+            const logLine = [
+                entry.timestamp.toISOString(),
+                entry.searchText.replace(/\n/g, '\\n').replace(/\t/g, '\\t'),
+                entry.foundText.replace(/\n/g, '\\n').replace(/\t/g, '\\t'),
+                entry.similarity.toString(),
+                entry.executionTime.toString(),
+                entry.exactMatchCount.toString(),
+                entry.expectedReplacements.toString(),
+                entry.fuzzyThreshold.toString(),
+                entry.belowThreshold.toString(),
+                entry.diff.replace(/\n/g, '\\n').replace(/\t/g, '\\t'),
+                entry.searchLength.toString(),
+                entry.foundLength.toString(),
+                entry.fileExtension,
+                entry.characterCodes,
+                entry.uniqueCharacterCount.toString(),
+                entry.diffLength.toString()
+            ].join('\t');
+            await fs.appendFile(this.logPath, logLine + '\n');
+        }
+        catch (error) {
+            console.error('Failed to write to fuzzy search log:', error);
+        }
+    }
+    async getLogPath() {
+        await this.ensureLogFile();
+        return this.logPath;
+    }
+    async getRecentLogs(count = 10) {
+        try {
+            await this.ensureLogFile();
+            const content = await fs.readFile(this.logPath, 'utf-8');
+            const lines = content.split('\n').filter(line => line.trim());
+            // Return last N lines (excluding header)
+            return lines.slice(-count - 1, -1);
+        }
+        catch (error) {
+            console.error('Failed to read fuzzy search logs:', error);
+            return [];
+        }
+    }
+    async clearLog() {
+        try {
+            // Recreate with just headers
+            const headers = [
+                'timestamp',
+                'searchText',
+                'foundText',
+                'similarity',
+                'executionTime',
+                'exactMatchCount',
+                'expectedReplacements',
+                'fuzzyThreshold',
+                'belowThreshold',
+                'diff',
+                'searchLength',
+                'foundLength',
+                'fileExtension',
+                'characterCodes',
+                'uniqueCharacterCount',
+                'diffLength'
+            ].join('\t');
+            await fs.writeFile(this.logPath, headers + '\n');
+            console.log('Fuzzy search log cleared');
+        }
+        catch (error) {
+            console.error('Failed to clear fuzzy search log:', error);
+        }
+    }
+}
+// Singleton instance
+export const fuzzySearchLogger = new FuzzySearchLogger();

package/dist/vendor/desktop-commander/dist/utils/internal-facts.js

@@ -0,0 +1,23 @@
+/**
+ * Tools whose structuredContent is for Desktop Commander's own code and tests
+ * only: fixes added it next to the text, and a client must keep receiving what
+ * it received before (no new information in tool results). It is dropped here,
+ * before the result is recorded in the tool-call history or sent. Tools that
+ * already sent structuredContent (the read_file/edit widgets, get_config) are
+ * not listed and keep it.
+ */
+const INTERNAL_STRUCTURED_CONTENT_TOOLS = new Set([
+    'write_pdf',
+    'start_process',
+    'interact_with_process',
+    'list_sessions',
+    'start_search',
+    'get_more_search_results',
+]);
+/** The result as the client receives it: without structuredContent kept internal */
+export function withoutInternalFacts(toolName, result) {
+    if (!INTERNAL_STRUCTURED_CONTENT_TOOLS.has(toolName) || !('structuredContent' in result))
+        return result;
+    const { structuredContent: _internal, ...sent } = result;
+    return sent;
+}

package/dist/vendor/desktop-commander/dist/utils/lazy-package.js

@@ -0,0 +1,44 @@
+import { logger } from './logger.js';
+/**
+ * A package only some files need, declared next to the code that uses it,
+ * whose load() loads it on first use (#715). Loading them before initialize
+ * took 25-90 s on one reporter's machine and timed the client out, and loading
+ * one inside the tool call that first needs it can take longer than a client
+ * waits. So the server preloads them right after initialize, one at a time
+ * (preloadFileSupport() in utils/files/factory.ts), and until one is loaded the
+ * calls that need it answer at once that it is still loading. preload() loads
+ * it on a later turn of the event loop, so a call that starts it answers
+ * first. `error` says why the last preload failed. Callers that load with
+ * import() can mark failures as requiring a restart, because Node caches a
+ * failed dynamic import.
+ */
+export class LazyPackage {
+    constructor(name, support, load, restartAfterFailure = false) {
+        this.name = name;
+        this.support = support;
+        this.load = load;
+        this.restartAfterFailure = restartAfterFailure;
+        this.loaded = false;
+        this.needsRestart = false;
+    }
+    preload() {
+        this.running ?? (this.running = new Promise((resolve) => setImmediate(resolve)).then(async () => {
+            let loading;
+            try {
+                loading = this.load();
+                await loading;
+                this.loaded = true;
+                this.error = undefined;
+            }
+            catch (error) {
+                this.error = error instanceof Error ? error.message : String(error);
+                this.needsRestart = this.restartAfterFailure;
+                logger.error(`Loading ${this.name} failed: ${this.error}`);
+            }
+            finally {
+                this.running = undefined;
+            }
+        }));
+        return this.running;
+    }
+}

package/dist/vendor/desktop-commander/dist/utils/lineEndingHandler.js

@@ -0,0 +1,77 @@
+/**
+ * Detect the line ending style used in a file - Optimized version
+ * This algorithm uses early termination for maximum performance
+ */
+export function detectLineEnding(content) {
+    for (let i = 0; i < content.length; i++) {
+        if (content[i] === '\r') {
+            if (i + 1 < content.length && content[i + 1] === '\n') {
+                return '\r\n';
+            }
+            return '\r';
+        }
+        if (content[i] === '\n') {
+            return '\n';
+        }
+    }
+    // Default to system line ending if no line endings found
+    return process.platform === 'win32' ? '\r\n' : '\n';
+}
+/**
+ * Normalize line endings to match the target style
+ */
+export function normalizeLineEndings(text, targetLineEnding) {
+    // First normalize to LF
+    let normalized = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    // Then convert to target
+    if (targetLineEnding === '\r\n') {
+        return normalized.replace(/\n/g, '\r\n');
+    }
+    else if (targetLineEnding === '\r') {
+        return normalized.replace(/\n/g, '\r');
+    }
+    return normalized;
+}
+/**
+ * Analyze line ending usage in content
+ */
+export function analyzeLineEndings(content) {
+    let crlfCount = 0;
+    let lfCount = 0;
+    let crCount = 0;
+    // Count line endings
+    for (let i = 0; i < content.length; i++) {
+        if (content[i] === '\r') {
+            if (i + 1 < content.length && content[i + 1] === '\n') {
+                crlfCount++;
+                i++; // Skip the LF
+            }
+            else {
+                crCount++;
+            }
+        }
+        else if (content[i] === '\n') {
+            lfCount++;
+        }
+    }
+    // Determine predominant style
+    const total = crlfCount + lfCount + crCount;
+    let style;
+    if (crlfCount > lfCount && crlfCount > crCount) {
+        style = '\r\n';
+    }
+    else if (lfCount > crCount) {
+        style = '\n';
+    }
+    else {
+        style = '\r';
+    }
+    // Check for mixed line endings
+    const usedStyles = [crlfCount > 0, lfCount > 0, crCount > 0].filter(Boolean).length;
+    const hasMixed = usedStyles > 1;
+    return {
+        style,
+        count: total,
+        hasMixed
+    };
+}

package/dist/vendor/desktop-commander/dist/utils/logger.js

@@ -0,0 +1,72 @@
+/**
+ * Centralized logging utility for Desktop Commander
+ * Ensures all logging goes through proper channels based on initialization state
+ */
+/**
+ * Log a message using the appropriate method based on MCP initialization state
+ */
+export function log(level, message, data) {
+    try {
+        // Check if MCP transport is available
+        if (global.mcpTransport) {
+            // Always use MCP logging (will buffer if not initialized yet)
+            global.mcpTransport.sendLog(level, message, data);
+        }
+        else {
+            // This should rarely happen, but fallback to create a JSON-RPC notification manually
+            const notification = {
+                jsonrpc: "2.0",
+                method: "notifications/message",
+                params: {
+                    level: level,
+                    logger: "desktop-commander",
+                    data: data ? { message, ...data } : message
+                }
+            };
+            process.stdout.write(JSON.stringify(notification) + '\n');
+        }
+    }
+    catch (error) {
+        // Ultimate fallback - but this should be JSON-RPC too
+        const notification = {
+            jsonrpc: "2.0",
+            method: "notifications/message",
+            params: {
+                level: "error",
+                logger: "desktop-commander",
+                data: `[LOG-ERROR] Failed to log message: ${message}`
+            }
+        };
+        process.stdout.write(JSON.stringify(notification) + '\n');
+    }
+}
+/**
+ * Convenience functions for different log levels
+ */
+export const logger = {
+    emergency: (message, data) => log('emergency', message, data),
+    alert: (message, data) => log('alert', message, data),
+    critical: (message, data) => log('critical', message, data),
+    error: (message, data) => log('error', message, data),
+    warning: (message, data) => log('warning', message, data),
+    notice: (message, data) => log('notice', message, data),
+    info: (message, data) => log('info', message, data),
+    debug: (message, data) => log('debug', message, data),
+};
+/**
+ * Log to stderr during early initialization (before MCP is ready)
+ * Use this for critical startup messages that must be visible
+ * NOTE: This should also be JSON-RPC format
+ */
+export function logToStderr(level, message) {
+    const notification = {
+        jsonrpc: "2.0",
+        method: "notifications/message",
+        params: {
+            level: level,
+            logger: "desktop-commander",
+            data: message
+        }
+    };
+    process.stdout.write(JSON.stringify(notification) + '\n');
+}

package/dist/vendor/desktop-commander/dist/utils/mcp-ui-ab-test.js

@@ -0,0 +1,62 @@
+import { configManager } from '../config-manager.js';
+import { getABTestVariant } from './ab-test.js';
+import { capture } from './capture.js';
+import { featureFlagManager } from './feature-flags.js';
+export const MCP_UI_EXPERIMENT_NAME = 'McpUiPreviews';
+export const MCP_UI_SHOW_VARIANT = 'showMCPUi';
+export const MCP_UI_HIDE_VARIANT = 'notShowMCPUi';
+function variantEnablesMcpUi(variant) {
+    if (variant === MCP_UI_HIDE_VARIANT)
+        return false;
+    if (variant === MCP_UI_SHOW_VARIANT)
+        return true;
+    return null;
+}
+export async function resolveMcpUiPreviewDecision(deps) {
+    try {
+        const existingAssignment = await deps.getExistingAssignment();
+        const existingDecision = variantEnablesMcpUi(existingAssignment);
+        if (existingDecision !== null) {
+            if (!deps.wasLoadedFromCache()) {
+                await deps.waitForFreshFlags();
+            }
+            const currentVariant = await deps.getABTestVariant(MCP_UI_EXPERIMENT_NAME);
+            return variantEnablesMcpUi(currentVariant) ?? existingDecision;
+        }
+        if (!deps.isFirstRun()) {
+            return true;
+        }
+        if (!deps.wasLoadedFromCache()) {
+            await deps.waitForFreshFlags();
+        }
+        const variant = await deps.getABTestVariant(MCP_UI_EXPERIMENT_NAME);
+        const decision = variantEnablesMcpUi(variant);
+        if (decision === null) {
+            return true;
+        }
+        try {
+            await deps.capture('server_mcp_ui_ab_decision', {
+                experiment: MCP_UI_EXPERIMENT_NAME,
+                variant,
+                mcp_ui_enabled: decision,
+            });
+        }
+        catch {
+            // Telemetry must not change the assigned product experience.
+        }
+        return decision;
+    }
+    catch {
+        return true;
+    }
+}
+export async function shouldShowMcpUiPreviews() {
+    return resolveMcpUiPreviewDecision({
+        getExistingAssignment: () => configManager.getValue(`abTest_${MCP_UI_EXPERIMENT_NAME}`),
+        isFirstRun: () => configManager.isFirstRun(),
+        wasLoadedFromCache: () => featureFlagManager.wasLoadedFromCache(),
+        waitForFreshFlags: () => featureFlagManager.waitForFreshFlags(),
+        getABTestVariant,
+        capture,
+    });
+}

package/dist/vendor/desktop-commander/dist/utils/open-browser.js

@@ -0,0 +1,2 @@
+export async function openBrowser() {}
+export async function openWelcomePage() {}

package/dist/vendor/desktop-commander/dist/utils/process-detection.js

@@ -0,0 +1,260 @@
+/**
+ * REPL and Process State Detection Utilities
+ * Detects from its output whether a running process is waiting for input.
+ * Whether it has finished is known from its exit, never from its output
+ * (see TerminalManager.getProcessState).
+ */
+// Common REPL prompts. Most are generic ("... ", "> ", "+ ", "| "): inside or
+// at the end of a longer line they are ordinary text (pytest -v's "collecting
+// ... ", #196; a markdown table's "| a | b |"), so they count only in a last
+// line made of prompts alone: the prompt itself, the prompts a REPL that
+// doesn't echo input printed one after another ("> | " from node -i), or,
+// from a REPL that writes its prompts to stderr (python -i, bash -i), the
+// prompts it wrote there (">>> ... ").
+const REPL_PROMPTS = {
+    python: ['>>> ', '... '],
+    node: ['> ', '... ', '| '], // "| ": Node 24's continuation, "... " before it
+    r: ['> ', '+ '],
+    julia: ['julia> ', '       '], // julia continuation is spaces
+    shell: ['$ ', '# ', '% '],
+    mysql: ['mysql> ', '    -> '],
+    postgres: ['=# ', '-# '],
+    redis: ['redis> '],
+    mongo: ['> ', '... '],
+    powershell: ['>> '] // continuation; after "> ", so it is reported as "> ", as before
+};
+const PROMPTS = [...new Set(Object.values(REPL_PROMPTS).flat())];
+const PROMPTS_ONLY = new RegExp(`^(?:${PROMPTS.map(escapeRegExp).join('|')})+$`);
+// Prompts that also count at the end of a longer line: named ones, after
+// output that didn't end in a newline ("done>>> "), and a shell or psql
+// prompt's end ("bash-5.2$ ", "user@host dir % ", "postgres=# ")
+const LINE_END_PROMPTS = ['>>> ', 'julia> ', 'mysql> ', 'redis> ', '$ ', '# ', '% '];
+// PowerShell's prompt (powershell.exe, pwsh), at the end of a line: "PS ", a
+// location (a drive, provider or path: "C:\Users\me", "/Users/me", "HKLM:\"),
+// then "> " (">> " in a nested or debugger prompt, "[DBG]: PS C:\>> ")
+const POWERSHELL_PROMPT_TEXT = String.raw `PS [^<>|\n]*[\\/:][^<>|\n]*>>? `;
+const POWERSHELL_PROMPT = new RegExp(`${POWERSHELL_PROMPT_TEXT}$`);
+// cmd.exe's prompt: the whole last line is a path and ">", with nothing after
+// it ("C:\Users\me>"); output lines end in a newline, a prompt doesn't
+const CMD_PROMPT_TEXT = String.raw `[A-Za-z]:\\[^<>|"*?\n]*>`;
+const CMD_PROMPT = new RegExp(`^${CMD_PROMPT_TEXT}$`);
+// The same shell prompts at the start of a line, where the shell echoes the
+// next input line after them ("PS C:\Users\me> echo b", "C:\Users\me>echo b")
+const SHELL_PROMPTS_AT_START = [new RegExp(`^${POWERSHELL_PROMPT_TEXT}`), new RegExp(`^${CMD_PROMPT_TEXT}`)];
+// The REPL prompts output cleaning removes, one or more in a row at the start
+// of a line (">>> ... " from a REPL that reads several lines at once)
+const REPL_PROMPT = String.raw `(?:>>> |\.\.\. |>> |> |\| |\+ )`;
+const REPL_PROMPT_RUN = new RegExp(`^${REPL_PROMPT}+`);
+const REPL_PROMPTS_ALONE = new RegExp(`^${REPL_PROMPT}+$`);
+const REPL_PROMPT_TOKEN = new RegExp(REPL_PROMPT, 'g');
+// The prompts of a REPL waiting for more of a statement (Python, Node, PowerShell, R)
+const CONTINUATION_PROMPTS = ['... ', '| ', '>> ', '+ '];
+/** The prompt the last line of output is, or ends in, if any */
+function findPrompt(lastLine) {
+    if (PROMPTS_ONLY.test(lastLine)) {
+        return PROMPTS.find(prompt => lastLine.endsWith(prompt));
+    }
+    const lineEnd = LINE_END_PROMPTS.find(prompt => lastLine.endsWith(prompt));
+    if (lineEnd)
+        return lineEnd;
+    // Reported as "> ", which a PowerShell prompt was reported as before #196
+    if (POWERSHELL_PROMPT.test(lastLine) || CMD_PROMPT.test(lastLine))
+        return '> ';
+    return undefined;
+}
+/**
+ * How much of the end of the output state detection examines. A prompt is
+ * the last thing a process writes before it waits for input, so the end of
+ * the output decides the state; examining only this much keeps detection's
+ * cost the same however much output there is.
+ */
+export const STATE_DETECTION_TAIL_CHARS = 4096;
+/**
+ * Analyze a running process's output to determine whether it is waiting for
+ * input. Output text never makes a process finished: a line such as
+ * "Error: retrying" doesn't end it.
+ *
+ * `output` is what the process wrote most recently. For a process writing to
+ * both stdout and stderr it can be the recent output of each stream that may
+ * have written last (see TerminalManager.getProcessState): their relative
+ * order is unknown, so the process is waiting for input if any of them ends
+ * in a prompt. Only the last STATE_DETECTION_TAIL_CHARS of each are examined.
+ */
+export function analyzeProcessState(output, pid) {
+    const tails = (typeof output === 'string' ? [output] : output)
+        .map(text => text.slice(-STATE_DETECTION_TAIL_CHARS))
+        .filter(text => text.trim().length > 0);
+    const states = tails.map(analyzeOutputTail);
+    return states.find(state => state.isWaitingForInput)
+        ?? {
+            isWaitingForInput: false,
+            isFinished: false,
+            isRunning: true,
+            lastOutput: tails.join('\n')
+        };
+}
+/**
+ * The state the end of one stream's output shows (see analyzeProcessState).
+ */
+function analyzeOutputTail(output) {
+    const lines = output.split('\n');
+    const lastLine = lines[lines.length - 1] || '';
+    // Check for REPL prompts (waiting for input)
+    const detectedPrompt = findPrompt(lastLine);
+    if (detectedPrompt) {
+        return {
+            isWaitingForInput: true,
+            isFinished: false,
+            isRunning: true,
+            detectedPrompt,
+            lastOutput: output
+        };
+    }
+    // Default: process is running, not waiting for input
+    return {
+        isWaitingForInput: false,
+        isFinished: false,
+        isRunning: true,
+        lastOutput: output
+    };
+}
+/**
+ * Clean output by removing prompts and input echoes. `readAtPrompt`: whether
+ * the process was waiting at a prompt when the input was sent; one that
+ * wasn't (a shell reading commands without a prompt) prints none for it.
+ */
+export function cleanProcessOutput(output, inputSent, readAtPrompt = true) {
+    // A process at a prompt prints one prompt for each input line it reads
+    const printed = readAtPrompt && inputSent !== undefined ? inputLinesSent(inputSent).length : 0;
+    const withoutEcho = removeInputEcho(output, inputSent);
+    const cleaned = removePrompts(withoutEcho.output, printed - withoutEcho.prompts);
+    // A line repeating the input is the answer, not an echo, when nothing else
+    // came back: node -i answers `10` with "10", which was removed as the echo.
+    // Not at a continuation prompt: the process waits for more of the input,
+    // so it hasn't answered it
+    if (!cleaned && withoutEcho.output !== output && !waitsAtContinuationPrompt(output)) {
+        return removePrompts(output, printed);
+    }
+    return cleaned;
+}
+/** Whether the output ends at a continuation prompt (">> " after "if ($true) {") */
+function waitsAtContinuationPrompt(output) {
+    const lastLine = output.slice(output.lastIndexOf('\n') + 1);
+    if (!REPL_PROMPTS_ALONE.test(lastLine))
+        return false;
+    const prompts = lastLine.match(REPL_PROMPT_TOKEN) ?? [];
+    return CONTINUATION_PROMPTS.includes(prompts[prompts.length - 1]);
+}
+/**
+ * The output without the process's echo of the input, if it echoed it. A
+ * process that echoes (powershell.exe, cmd.exe, a terminal over ssh -t)
+ * repeats each input line where the output for it starts: the first line at
+ * the start of the output, each later one after the prompt it was read at
+ * ("PS C:\project> echo b", "C:\project>echo b", ">> }"). A line the process
+ * has read (it printed a prompt for it) that isn't repeated there means the
+ * process doesn't echo, and a line equal to an input line is output (node -i
+ * answers `1` with "1"): the output is kept as it is. Lines not read yet (the
+ * call answered at an earlier prompt) have no echo yet. Also returns how many
+ * prompts went with the echoes.
+ */
+function removeInputEcho(output, inputSent) {
+    if (!inputSent)
+        return { output, prompts: 0 };
+    const lines = output.split('\n');
+    const echoes = new Set();
+    let next = 0;
+    for (const [i, inputLine] of inputLinesSent(inputSent).entries()) {
+        const echo = inputLine.trim();
+        if (!echo)
+            continue; // An empty line's echo can't be told from an empty output line
+        const at = i === 0
+            ? (isEchoLine(lines, 0, echo, true) ? 0 : -1)
+            : lines.findIndex((_, index) => index >= next && isEchoLine(lines, index, echo, false));
+        if (at < 0) {
+            // A process prints one prompt for each line it reads
+            const linesRead = lines.reduce((count, line) => count + promptsAtStart(line), 0);
+            if (linesRead > i)
+                return { output, prompts: 0 };
+            break;
+        }
+        echoes.add(at);
+        next = at + 1;
+    }
+    return {
+        output: lines.filter((_, index) => !echoes.has(index)).join('\n'),
+        prompts: [...echoes].reduce((count, index) => count + promptsAtStart(lines[index]), 0),
+    };
+}
+/** How many prompts `line` starts with: REPL prompts, one or more in a row, or a shell's prompt */
+function promptsAtStart(line) {
+    const run = REPL_PROMPT_RUN.exec(line)?.[0];
+    if (run)
+        return run.match(REPL_PROMPT_TOKEN)?.length ?? 0;
+    return SHELL_PROMPTS_AT_START.some(prompt => prompt.test(line)) ? 1 : 0;
+}
+/** The lines of an input as the process reads them (sendInputToProcess ends it with a newline) */
+function inputLinesSent(input) {
+    return (input.endsWith('\n') ? input.slice(0, -1) : input).split('\n');
+}
+/**
+ * Whether lines[index] is the echo of an input line: alone on the line (the
+ * first input line's, at the start of the output) or after a prompt (a later
+ * line's), and ended by the newline that was sent with it
+ */
+function isEchoLine(lines, index, echo, alone) {
+    if (index >= lines.length - 1)
+        return false;
+    const line = lines[index].trimEnd();
+    if (!line.endsWith(echo))
+        return false;
+    const before = line.slice(0, line.length - echo.length).trimEnd();
+    if (alone)
+        return before === '';
+    return before !== '' && (findPrompt(before) !== undefined || findPrompt(`${before} `) !== undefined);
+}
+/**
+ * The output without the REPL prompts the process printed for the input (at
+ * most `printed`), and nothing that only looks like one. The last line, when
+ * it is a prompt, is where the process waits now (a REPL's is removed; a
+ * shell's, "PS C:\project> ", stays in the output as before). The others
+ * start a line: the one where the output for the next input line begins
+ * ("1\n> 2\n> " for `1` and `2` sent to node -i). More prompt-like line starts
+ * than that means some are output ("+ added" in a diff, "> quoted"), and
+ * those lines are all kept as they are.
+ */
+function removePrompts(output, printed) {
+    const lines = output.split('\n');
+    const last = lines.length - 1;
+    let left = printed;
+    if (findPrompt(lines[last]) !== undefined) {
+        left -= Math.max(1, promptsAtStart(lines[last]));
+        if (REPL_PROMPTS_ALONE.test(lines[last]))
+            lines[last] = '';
+    }
+    const runs = lines.map((line, index) => (index < last ? REPL_PROMPT_RUN.exec(line)?.[0] ?? '' : ''));
+    const found = runs.reduce((count, run) => count + (run.match(REPL_PROMPT_TOKEN)?.length ?? 0), 0);
+    if (found <= left) {
+        runs.forEach((run, index) => { lines[index] = lines[index].slice(run.length); });
+    }
+    return lines.join('\n').trim();
+}
+/**
+ * Escape special regex characters
+ */
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Format process state for user display
+ */
+export function formatProcessStateMessage(state, pid) {
+    if (state.isWaitingForInput) {
+        return `Process ${pid} is waiting for input${state.detectedPrompt ? ` (detected: "${state.detectedPrompt.trim()}")` : ''}`;
+    }
+    else if (state.isFinished) {
+        return `Process ${pid} has finished execution`;
+    }
+    else {
+        return `Process ${pid} is running`;
+    }
+}