@microsoft/inshellisense 0.0.1-rc.2 → 0.0.1-rc.20

package/build/isterm/commandManager.js

@@ -0,0 +1,290 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import convert from "color-convert";
+import os from "node:os";
+import { getShellPromptRewrites, Shell } from "../utils/shell.js";
+import log from "../utils/log.js";
+const maxPromptPollDistance = 10;
+export class CommandManager {
+    #activeCommand;
+    #terminal;
+    #previousCommandLines;
+    #maxCursorY;
+    #shell;
+    #promptRewrites;
+    #supportsProperOscPlacements = os.platform() !== "win32";
+    promptTerminator = "";
+    constructor(terminal, shell) {
+        this.#terminal = terminal;
+        this.#shell = shell;
+        this.#activeCommand = {};
+        this.#maxCursorY = 0;
+        this.#previousCommandLines = new Set();
+        this.#promptRewrites = getShellPromptRewrites(shell);
+        if (this.#supportsProperOscPlacements) {
+            this.#terminal.parser.registerCsiHandler({ final: "J" }, (params) => {
+                if (params.at(0) == 3 || params.at(0) == 2) {
+                    this.handleClear();
+                }
+                return false;
+            });
+        }
+    }
+    handlePromptStart() {
+        this.#activeCommand = { promptStartMarker: this.#terminal.registerMarker(0), hasOutput: false, cursorTerminated: false };
+    }
+    handlePromptEnd() {
+        if (this.#activeCommand.promptEndMarker != null)
+            return;
+        this.#activeCommand.promptEndMarker = this.#terminal.registerMarker(0);
+        if (this.#activeCommand.promptEndMarker?.line === this.#terminal.buffer.active.cursorY) {
+            this.#activeCommand.promptEndX = this.#terminal.buffer.active.cursorX;
+        }
+        if (this.#supportsProperOscPlacements) {
+            this.#activeCommand.promptText = this.#terminal.buffer.active.getLine(this.#activeCommand.promptEndMarker?.line ?? 0)?.translateToString(true);
+            this.#previousCommandLines.add(this.#activeCommand.promptEndMarker?.line ?? -1);
+        }
+    }
+    handleClear() {
+        this.handlePromptStart();
+        this.#maxCursorY = 0;
+        this.#previousCommandLines = new Set();
+    }
+    _getWindowsPrompt(y) {
+        const line = this.#terminal.buffer.active.getLine(y);
+        if (!line) {
+            return;
+        }
+        const lineText = line.translateToString(true);
+        if (!lineText) {
+            return;
+        }
+        // dynamic prompt terminator
+        if (this.promptTerminator && lineText.trim().endsWith(this.promptTerminator)) {
+            const adjustedPrompt = this._adjustPrompt(lineText, lineText, this.promptTerminator);
+            if (adjustedPrompt) {
+                return adjustedPrompt;
+            }
+        }
+        // User defined prompt
+        if (this.#shell == Shell.Bash) {
+            const bashPrompt = lineText.match(/^(?<prompt>\$\s?)/)?.groups?.prompt;
+            if (bashPrompt) {
+                const adjustedPrompt = this._adjustPrompt(bashPrompt, lineText, "$");
+                if (adjustedPrompt) {
+                    return adjustedPrompt;
+                }
+            }
+        }
+        if (this.#shell == Shell.Fish) {
+            const fishPrompt = lineText.match(/(?<prompt>.*>\s?)/)?.groups?.prompt;
+            if (fishPrompt) {
+                const adjustedPrompt = this._adjustPrompt(fishPrompt, lineText, ">");
+                if (adjustedPrompt) {
+                    return adjustedPrompt;
+                }
+            }
+        }
+        if (this.#shell == Shell.Nushell) {
+            const nushellPrompt = lineText.match(/(?<prompt>.*>\s?)/)?.groups?.prompt;
+            if (nushellPrompt) {
+                const adjustedPrompt = this._adjustPrompt(nushellPrompt, lineText, ">");
+                if (adjustedPrompt) {
+                    return adjustedPrompt;
+                }
+            }
+        }
+        if (this.#shell == Shell.Xonsh) {
+            let xonshPrompt = lineText.match(/(?<prompt>.*@\s?)/)?.groups?.prompt;
+            if (xonshPrompt) {
+                const adjustedPrompt = this._adjustPrompt(xonshPrompt, lineText, "@");
+                if (adjustedPrompt) {
+                    return adjustedPrompt;
+                }
+            }
+            xonshPrompt = lineText.match(/(?<prompt>.*>\s?)/)?.groups?.prompt;
+            if (xonshPrompt) {
+                const adjustedPrompt = this._adjustPrompt(xonshPrompt, lineText, ">");
+                if (adjustedPrompt) {
+                    return adjustedPrompt;
+                }
+            }
+        }
+        if (this.#shell == Shell.Powershell || this.#shell == Shell.Pwsh) {
+            const pwshPrompt = lineText.match(/(?<prompt>(\(.+\)\s)?(?:PS.+>\s?))/)?.groups?.prompt;
+            if (pwshPrompt) {
+                const adjustedPrompt = this._adjustPrompt(pwshPrompt, lineText, ">");
+                if (adjustedPrompt) {
+                    return adjustedPrompt;
+                }
+            }
+        }
+        if (this.#shell == Shell.Cmd) {
+            return lineText.match(/^(?<prompt>(\(.+\)\s)?(?:[A-Z]:\\.*>)|(> ))/)?.groups?.prompt;
+        }
+        // Custom prompts like starship end in the common \u276f character
+        const customPrompt = lineText.match(/.*\u276f(?=[^\u276f]*$)/g)?.[0];
+        if (customPrompt) {
+            const adjustedPrompt = this._adjustPrompt(customPrompt, lineText, "\u276f");
+            if (adjustedPrompt) {
+                return adjustedPrompt;
+            }
+        }
+    }
+    _adjustPrompt(prompt, lineText, char) {
+        if (!prompt) {
+            return;
+        }
+        // Conpty may not 'render' the space at the end of the prompt
+        if (lineText === prompt && prompt.endsWith(char)) {
+            prompt += " ";
+        }
+        return prompt;
+    }
+    _getFgPaletteColor(cell) {
+        if (cell?.isFgDefault())
+            return 0;
+        if (cell?.isFgPalette())
+            return cell.getFgColor();
+        if (cell?.isFgRGB())
+            return convert.hex.ansi256(cell.getFgColor().toString(16));
+    }
+    _isSuggestion(cell) {
+        const color = this._getFgPaletteColor(cell);
+        const dim = (cell?.isDim() ?? 0) > 0;
+        const italic = (cell?.isItalic() ?? 0) > 0;
+        const dullColor = color == 8 || color == 7 || (color ?? 0) > 235 || (color == 15 && dim);
+        const dimItalic = dim || italic;
+        if (this.#shell == Shell.Pwsh || this.#shell == Shell.Powershell) {
+            return dimItalic;
+        }
+        return dullColor;
+    }
+    getState() {
+        return {
+            promptText: this.#activeCommand.promptText,
+            commandText: this.#activeCommand.commandText,
+            suggestionsText: this.#activeCommand.suggestionsText,
+            hasOutput: this.#activeCommand.hasOutput,
+            cursorTerminated: this.#activeCommand.cursorTerminated,
+        };
+    }
+    clearActiveCommand() {
+        this.#activeCommand = {};
+    }
+    _getCommandLines() {
+        const lines = [];
+        let lineY = this.#activeCommand.promptEndMarker.line;
+        let line = this.#terminal.buffer.active.getLine(this.#activeCommand.promptEndMarker.line);
+        const absoluteY = this.#terminal.buffer.active.baseY + this.#terminal.buffer.active.cursorY;
+        for (; lineY < this.#terminal.buffer.active.baseY + this.#terminal.rows;) {
+            if (line)
+                lines.push(line);
+            lineY += 1;
+            line = this.#terminal.buffer.active.getLine(lineY);
+            const lineWrapped = line?.isWrapped;
+            const cursorWrapped = absoluteY > lineY - 1;
+            const wrapped = lineWrapped || cursorWrapped;
+            if (!wrapped)
+                break;
+        }
+        return lines;
+    }
+    _getCommandText(commandLines) {
+        const absoluteY = this.#terminal.buffer.active.baseY + this.#terminal.buffer.active.cursorY;
+        const cursorLine = Math.max(absoluteY - this.#activeCommand.promptEndMarker.line, 0);
+        let preCursorCommand = "";
+        let postCursorCommand = "";
+        let suggestion = "";
+        for (const [y, line] of commandLines.entries()) {
+            const startX = y == 0 ? this.#activeCommand.promptText?.length ?? 0 : 0;
+            for (let x = startX; x < this.#terminal.cols; x++) {
+                if (postCursorCommand.endsWith("    "))
+                    break; // assume that a command that ends with 4 spaces is terminated, avoids capturing right prompts
+                const cell = line.getCell(x);
+                if (cell == null)
+                    continue;
+                const chars = cell.getChars() == "" ? " " : cell.getChars();
+                const beforeCursor = y < cursorLine || (y == cursorLine && x < this.#terminal.buffer.active.cursorX);
+                const isCommand = !this._isSuggestion(cell) && suggestion.length == 0;
+                if (isCommand && beforeCursor) {
+                    preCursorCommand += chars;
+                }
+                else if (isCommand) {
+                    postCursorCommand += chars;
+                }
+                else {
+                    suggestion += chars;
+                }
+            }
+        }
+        log.debug({ msg: "command text", preCursorCommand, postCursorCommand, suggestion });
+        return { suggestion, preCursorCommand, postCursorCommand };
+    }
+    _getCommandOutputStatus(commandLines) {
+        const outputLineY = this.#activeCommand.promptEndMarker.line + commandLines;
+        const maxLineY = this.#terminal.buffer.active.baseY + this.#terminal.rows;
+        if (outputLineY >= maxLineY)
+            return false;
+        const line = this.#terminal.buffer.active.getLine(outputLineY);
+        let cell = undefined;
+        for (let i = 0; i < this.#terminal.cols; i++) {
+            cell = line?.getCell(i, cell);
+            if (cell?.getChars() != "") {
+                return true;
+            }
+        }
+        return false;
+    }
+    termSync() {
+        if (this.#activeCommand.promptEndMarker == null || this.#activeCommand.promptStartMarker == null) {
+            return;
+        }
+        const globalCursorPosition = this.#terminal.buffer.active.baseY + this.#terminal.buffer.active.cursorY;
+        const withinPollDistance = globalCursorPosition < this.#activeCommand.promptEndMarker.line + 5;
+        this.#maxCursorY = Math.max(this.#maxCursorY, globalCursorPosition);
+        if (globalCursorPosition < this.#activeCommand.promptStartMarker.line || globalCursorPosition < this.#maxCursorY) {
+            this.handleClear();
+            this.#activeCommand.promptEndMarker = this.#terminal.registerMarker(0);
+            return;
+        }
+        if (this.#activeCommand.promptEndMarker == null)
+            return;
+        // if we haven't fond the prompt yet, poll over the next 5 lines searching for it
+        if (this.#activeCommand.promptText == null && withinPollDistance) {
+            for (let i = globalCursorPosition; i < this.#activeCommand.promptEndMarker.line + maxPromptPollDistance; i++) {
+                if (this.#previousCommandLines.has(i) && !this.#promptRewrites)
+                    continue;
+                const promptResult = this._getWindowsPrompt(i);
+                if (promptResult != null) {
+                    this.#activeCommand.promptEndMarker = this.#terminal.registerMarker(i - globalCursorPosition);
+                    this.#activeCommand.promptEndX = promptResult.length;
+                    this.#activeCommand.promptText = promptResult;
+                    this.#previousCommandLines.add(i);
+                    break;
+                }
+            }
+        }
+        // if the prompt is set, now parse out the values from the terminal
+        if (this.#activeCommand.promptText != null) {
+            const commandLines = this._getCommandLines();
+            const { suggestion, preCursorCommand, postCursorCommand } = this._getCommandText(commandLines);
+            const command = preCursorCommand + postCursorCommand.trim();
+            const cursorAtEndOfInput = postCursorCommand.trim() == "";
+            const hasOutput = this._getCommandOutputStatus(commandLines.length);
+            this.#activeCommand.persistentOutput = this.#activeCommand.hasOutput && hasOutput;
+            this.#activeCommand.hasOutput = hasOutput;
+            this.#activeCommand.suggestionsText = suggestion;
+            this.#activeCommand.commandText = command;
+            this.#activeCommand.cursorTerminated = cursorAtEndOfInput;
+        }
+        log.debug({
+            msg: "cmd manager state",
+            ...this.#activeCommand,
+            promptEndMarker: this.#activeCommand.promptEndMarker?.line,
+            promptStartMarker: this.#activeCommand.promptStartMarker?.line,
+            cursorX: this.#terminal.buffer.active.cursorX,
+            cursorY: globalCursorPosition,
+        });
+    }
+}

package/build/isterm/index.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { spawn } from "./pty.js";
+export default { spawn };

package/build/isterm/pty.js

@@ -0,0 +1,372 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { EventEmitter } from "node:events";
+import process from "node:process";
+import os from "node:os";
+import path from "node:path";
+import url from "node:url";
+import fs from "node:fs";
+import stripAnsi from "strip-ansi";
+import { Unicode11Addon } from "@xterm/addon-unicode11";
+import pty from "@homebridge/node-pty-prebuilt-multiarch";
+import { Shell, userZdotdir, zdotdir } from "../utils/shell.js";
+import { IsTermOscPs, IstermOscPt, IstermPromptStart, IstermPromptEnd } from "../utils/ansi.js";
+import xterm from "@xterm/headless";
+import { CommandManager } from "./commandManager.js";
+import log from "../utils/log.js";
+import { gitBashPath } from "../utils/shell.js";
+import styles from "ansi-styles";
+import * as ansi from "../utils/ansi.js";
+import which from "which";
+const ISTermOnDataEvent = "data";
+export class ISTerm {
+    pid;
+    cols;
+    rows;
+    process;
+    handleFlowControl = false;
+    onData;
+    onExit;
+    shellBuffer;
+    cwd = "";
+    #pty;
+    #ptyEmitter;
+    #term;
+    #commandManager;
+    #shell;
+    constructor({ shell, cols, rows, env, shellTarget, shellArgs, underTest, login }) {
+        this.#pty = pty.spawn(shellTarget, shellArgs ?? [], {
+            name: "xterm-256color",
+            cols,
+            rows,
+            cwd: process.cwd(),
+            env: { ...convertToPtyEnv(shell, underTest, login), ...env },
+        });
+        this.pid = this.#pty.pid;
+        this.cols = this.#pty.cols;
+        this.rows = this.#pty.rows;
+        this.process = this.#pty.process;
+        const unicode11Addon = new Unicode11Addon();
+        this.#term = new xterm.Terminal({ allowProposedApi: true, rows, cols });
+        this.#term.loadAddon(unicode11Addon);
+        this.#term.unicode.activeVersion = "11";
+        this.#term.parser.registerOscHandler(IsTermOscPs, (data) => this._handleIsSequence(data));
+        this.#commandManager = new CommandManager(this.#term, shell);
+        this.#shell = shell;
+        this.#ptyEmitter = new EventEmitter();
+        this.#pty.onData((data) => {
+            this.#term.write(data, () => {
+                log.debug({ msg: "parsing data", data, bytes: Uint8Array.from([...data].map((c) => c.charCodeAt(0))) });
+                this.#commandManager.termSync();
+                this.#ptyEmitter.emit(ISTermOnDataEvent, data);
+            });
+        });
+        this.onData = (listener) => {
+            this.#ptyEmitter.on(ISTermOnDataEvent, listener);
+            return {
+                dispose: () => this.#ptyEmitter.removeListener(ISTermOnDataEvent, listener),
+            };
+        };
+        this.onExit = this.#pty.onExit;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    on(_event, _listener) {
+        throw new Error("Method not implemented as deprecated in node-pty.");
+    }
+    _deserializeIsMessage(message) {
+        return message.replaceAll(/\\(\\|x([0-9a-f]{2}))/gi, (_match, op, hex) => (hex ? String.fromCharCode(parseInt(hex, 16)) : op));
+    }
+    _sanitizedCwd(cwd) {
+        if (cwd.match(/^['"].*['"]$/)) {
+            cwd = cwd.substring(1, cwd.length - 1);
+        }
+        // Convert a drive prefix to windows style when using Git Bash
+        if (os.platform() === "win32" && this.#shell == Shell.Bash && cwd && cwd.match(/^\/[A-z]{1}\//)) {
+            cwd = `${cwd[1]}:\\` + cwd.substring(3, cwd.length);
+        }
+        // Make the drive letter uppercase on Windows (see vscode #9448)
+        if (os.platform() === "win32" && cwd && cwd[1] === ":") {
+            return cwd[0].toUpperCase() + cwd.substring(1);
+        }
+        return cwd;
+    }
+    _sanitizedPrompt(prompt) {
+        // eslint-disable-next-line no-control-regex -- strip OSC control sequences
+        const oscStrippedPrompt = prompt.replace(/\x1b\][0-9]+;.*\x07/g, "");
+        return stripAnsi(oscStrippedPrompt);
+    }
+    _handleIsSequence(data) {
+        const argsIndex = data.indexOf(";");
+        const sequence = argsIndex === -1 ? data : data.substring(0, argsIndex);
+        switch (sequence) {
+            case IstermOscPt.PromptStarted:
+                this.#commandManager.handlePromptStart();
+                break;
+            case IstermOscPt.PromptEnded:
+                this.#commandManager.handlePromptEnd();
+                break;
+            case IstermOscPt.CurrentWorkingDirectory: {
+                const cwd = data.split(";").at(1);
+                if (cwd != null) {
+                    this.cwd = path.resolve(this._sanitizedCwd(this._deserializeIsMessage(cwd)));
+                }
+                break;
+            }
+            case IstermOscPt.Prompt: {
+                const prompt = data.split(";").slice(1).join(";");
+                if (prompt != null) {
+                    const sanitizedPrompt = this._sanitizedPrompt(this._deserializeIsMessage(prompt));
+                    const lastPromptLine = sanitizedPrompt.substring(sanitizedPrompt.lastIndexOf("\n")).trim();
+                    const promptTerminator = lastPromptLine.substring(lastPromptLine.lastIndexOf(" ")).trim();
+                    if (promptTerminator) {
+                        this.#commandManager.promptTerminator = promptTerminator;
+                        log.debug({ msg: "prompt terminator", promptTerminator });
+                    }
+                }
+                break;
+            }
+            default:
+                return false;
+        }
+        return true;
+    }
+    noop() {
+        this.#ptyEmitter.emit(ISTermOnDataEvent, "");
+    }
+    resize(columns, rows) {
+        this.cols = columns;
+        this.rows = rows;
+        this.#pty.resize(columns, rows);
+        this.#term.resize(columns, rows);
+    }
+    clear() {
+        this.#term.reset();
+        this.#pty.clear();
+    }
+    kill(signal) {
+        this.#pty.kill(signal);
+    }
+    pause() {
+        this.#pty.pause();
+    }
+    resume() {
+        this.#pty.resume();
+    }
+    write(data) {
+        log.debug({ msg: "reading data", data, bytes: Uint8Array.from([...data].map((c) => c.charCodeAt(0))) });
+        this.#pty.write(data);
+    }
+    getCommandState() {
+        return this.#commandManager.getState();
+    }
+    getCursorState() {
+        return {
+            onLastLine: this.#term.buffer.active.cursorY >= this.#term.rows - 2,
+            remainingLines: Math.max(this.#term.rows - 2 - this.#term.buffer.active.cursorY, 0),
+            cursorX: this.#term.buffer.active.cursorX,
+            cursorY: this.#term.buffer.active.cursorY,
+        };
+    }
+    _sameAccent(baseCell, targetCell) {
+        return (baseCell?.isBold() == targetCell?.isBold() &&
+            baseCell?.isItalic() == targetCell?.isItalic() &&
+            baseCell?.isUnderline() == targetCell?.isUnderline() &&
+            baseCell?.extended.underlineStyle == targetCell?.extended.underlineStyle &&
+            baseCell?.hasExtendedAttrs() == targetCell?.hasExtendedAttrs() &&
+            baseCell?.isInverse() == targetCell?.isInverse() &&
+            baseCell?.isBlink() == targetCell?.isBlink() &&
+            baseCell?.isInvisible() == targetCell?.isInvisible() &&
+            baseCell?.isDim() == targetCell?.isDim() &&
+            baseCell?.isStrikethrough() == targetCell?.isStrikethrough());
+    }
+    _getAnsiAccents(cell) {
+        if (cell == null)
+            return "";
+        let underlineAnsi = "";
+        if (cell.isUnderline()) {
+            if (cell.hasExtendedAttrs() && cell.extended.underlineStyle) {
+                underlineAnsi = `\x1b[4:${cell.extended.underlineStyle}m`;
+            }
+            else {
+                underlineAnsi = "\x1b[4m";
+            }
+        }
+        const boldAnsi = cell.isBold() ? "\x1b[1m" : "";
+        const dimAnsi = cell.isDim() ? "\x1b[2m" : "";
+        const italicAnsi = cell.isItalic() ? "\x1b[3m" : "";
+        const blinkAnsi = cell.isBlink() ? "\x1b[5m" : "";
+        const inverseAnsi = cell.isInverse() ? "\x1b[7m" : "";
+        const invisibleAnsi = cell.isInvisible() ? "\x1b[8m" : "";
+        const strikethroughAnsi = cell.isStrikethrough() ? "\x1b[9m" : "";
+        return boldAnsi + italicAnsi + underlineAnsi + inverseAnsi + dimAnsi + blinkAnsi + invisibleAnsi + strikethroughAnsi;
+    }
+    _sameColor(baseCell, targetCell) {
+        return (baseCell?.getBgColorMode() == targetCell?.getBgColorMode() &&
+            baseCell?.getBgColor() == targetCell?.getBgColor() &&
+            baseCell?.getFgColorMode() == targetCell?.getFgColorMode() &&
+            baseCell?.getFgColor() == targetCell?.getFgColor());
+    }
+    _getAnsiColors(cell) {
+        if (cell == null)
+            return "";
+        let bgAnsi = "";
+        cell.getBgColor;
+        cell.getFgColor;
+        if (cell.isBgDefault()) {
+            bgAnsi = "\x1b[49m";
+        }
+        else if (cell.isBgPalette()) {
+            bgAnsi = `\x1b[48;5;${cell.getBgColor()}m`;
+        }
+        else {
+            bgAnsi = `\x1b[48;5;${styles.hexToAnsi256(cell.getBgColor().toString(16))}m`;
+        }
+        let fgAnsi = "";
+        if (cell.isFgDefault()) {
+            fgAnsi = "\x1b[39m";
+        }
+        else if (cell.isFgPalette()) {
+            fgAnsi = `\x1b[38;5;${cell.getFgColor()}m`;
+        }
+        else {
+            fgAnsi = `\x1b[38;5;${styles.hexToAnsi256(cell.getFgColor().toString(16))}m`;
+        }
+        return bgAnsi + fgAnsi;
+    }
+    clearCommand() {
+        this.#commandManager.clearActiveCommand();
+    }
+    getCells(height, direction) {
+        const currentCursorPosition = this.#term.buffer.active.cursorY + this.#term.buffer.active.baseY;
+        const writeLine = (y) => {
+            const line = this.#term.buffer.active.getLine(y);
+            const ansiLine = [ansi.resetColor, ansi.resetLine];
+            if (line == null)
+                return "";
+            let prevCell;
+            for (let x = 0; x < line.length; x++) {
+                const cell = line.getCell(x);
+                const chars = cell?.getChars() ?? "";
+                const sameColor = this._sameColor(prevCell, cell);
+                const sameAccents = this._sameAccent(prevCell, cell);
+                if (!sameColor || !sameAccents) {
+                    ansiLine.push(ansi.resetColor);
+                }
+                if (!sameColor) {
+                    ansiLine.push(this._getAnsiColors(cell));
+                }
+                if (!sameAccents) {
+                    ansiLine.push(this._getAnsiAccents(cell));
+                }
+                const isWide = prevCell?.getWidth() == 2 && cell?.getWidth() == 0;
+                const cursorForward = isWide ? "" : ansi.cursorForward();
+                ansiLine.push(chars == "" ? cursorForward : chars);
+                prevCell = cell;
+            }
+            return ansiLine.join("");
+        };
+        const lines = [];
+        if (direction == "above") {
+            const startCursorPosition = currentCursorPosition - 1;
+            const endCursorPosition = currentCursorPosition - 1 - height;
+            for (let y = startCursorPosition; y > endCursorPosition; y--) {
+                lines.push(writeLine(y));
+            }
+        }
+        else {
+            const startCursorPosition = currentCursorPosition + 1;
+            const endCursorPosition = currentCursorPosition + 1 + height;
+            for (let y = startCursorPosition; y < endCursorPosition; y++) {
+                lines.push(writeLine(y));
+            }
+        }
+        return lines.reverse().join(ansi.cursorNextLine);
+    }
+}
+export const spawn = async (program, options) => {
+    const { shellTarget, shellArgs } = await convertToPtyTarget(options.shell, options.underTest, options.login);
+    if (!(await shellExists(shellTarget))) {
+        program.error(`shell not found on PATH: ${shellTarget}`, { exitCode: 1 });
+    }
+    return new ISTerm({ ...options, shellTarget, shellArgs });
+};
+const shellExists = async (shellTarget) => {
+    const fileExists = fs.existsSync(shellTarget);
+    const fileOnPath = await which(shellTarget, { nothrow: true });
+    return fileExists || fileOnPath != null;
+};
+const convertToPtyTarget = async (shell, underTest, login) => {
+    const platform = os.platform();
+    const shellTarget = shell == Shell.Bash && platform == "win32" ? await gitBashPath() : platform == "win32" ? `${shell}.exe` : shell;
+    const shellFolderPath = path.join(path.dirname(url.fileURLToPath(import.meta.url)), "..", "..", "shell");
+    let shellArgs = [];
+    switch (shell) {
+        case Shell.Bash:
+            shellArgs = ["--init-file", path.join(shellFolderPath, "shellIntegration.bash")];
+            break;
+        case Shell.Powershell:
+        case Shell.Pwsh:
+            shellArgs = ["-noexit", "-command", `try { . "${path.join(shellFolderPath, "shellIntegration.ps1")}" } catch {}`];
+            break;
+        case Shell.Fish:
+            shellArgs =
+                platform == "win32"
+                    ? ["--init-command", `. "$(cygpath -u '${path.join(shellFolderPath, "shellIntegration.fish")}')"`]
+                    : ["--init-command", `. ${path.join(shellFolderPath, "shellIntegration.fish").replace(/(\s+)/g, "\\$1")}`];
+            break;
+        case Shell.Xonsh: {
+            const sharedConfig = os.platform() == "win32" ? path.join("C:\\ProgramData", "xonsh", "xonshrc") : path.join("etc", "xonsh", "xonshrc");
+            const userConfigs = [
+                path.join(os.homedir(), ".xonshrc"),
+                path.join(os.homedir(), ".config", "xonsh", "rc.xsh"),
+                path.join(os.homedir(), ".config", "xonsh", "rc.d"),
+            ];
+            const configs = [sharedConfig, ...userConfigs].filter((config) => fs.existsSync(config));
+            shellArgs = ["--rc", ...configs, path.join(shellFolderPath, "shellIntegration.xsh")];
+            break;
+        }
+        case Shell.Nushell:
+            shellArgs = ["-e", `source \`${path.join(shellFolderPath, "shellIntegration.nu")}\``];
+            if (underTest)
+                shellArgs.push("-n");
+            break;
+    }
+    if (login) {
+        switch (shell) {
+            case Shell.Powershell:
+            case Shell.Pwsh:
+                shellArgs.unshift("-login");
+                break;
+            case Shell.Zsh:
+            case Shell.Fish:
+            case Shell.Xonsh:
+            case Shell.Nushell:
+                shellArgs.unshift("--login");
+                break;
+        }
+    }
+    return { shellTarget, shellArgs };
+};
+const convertToPtyEnv = (shell, underTest, login) => {
+    const env = {
+        ...process.env,
+        ISTERM: "1",
+    };
+    if (underTest)
+        env.ISTERM_TESTING = "1";
+    if (login)
+        env.ISTERM_LOGIN = "1";
+    switch (shell) {
+        case Shell.Cmd: {
+            if (underTest) {
+                return { ...env, PROMPT: `${IstermPromptStart}$G ${IstermPromptEnd}` };
+            }
+            const prompt = process.env.PROMPT ? process.env.PROMPT : "$P$G";
+            return { ...env, PROMPT: `${IstermPromptStart}${prompt}${IstermPromptEnd}` };
+        }
+        case Shell.Zsh: {
+            return { ...env, ZDOTDIR: zdotdir, USER_ZDOTDIR: userZdotdir };
+        }
+    }
+    return env;
+};