@microsoft/inshellisense 0.0.1-rc.13 → 0.0.1-rc.15

package/README.md

@@ -81,7 +81,7 @@ inshellisense supports the following shells:
 
 ## Configuration
 
-All configuration is done through a [toml](https://toml.io/) file located at `~/.inshellisenserc`. The [JSON schema](https://json-schema.org/) for the configuration file can be found [here](https://github.com/microsoft/inshellisense/blob/main/src/utils/config.ts).
+All configuration is done through a [toml](https://toml.io/) file. You can create this file at `~/.inshellisenserc` or, for XDG compliance, at `~/.config/inshellisense/rc.toml`. The [JSON schema](https://json-schema.org/) for the configuration file can be found [here](https://github.com/microsoft/inshellisense/blob/main/src/utils/config.ts).
 
 ### Keybindings
 
@@ -106,18 +106,6 @@ key = "escape"
 
 Key names are matched against the Node.js [keypress](https://nodejs.org/api/readline.html#readlineemitkeypresseventsstream-interface) events.
 
-### Custom Prompts (Windows)
-
-If you are using a custom prompt in your shell (anything that is not the default PS1), you will need to set up a custom prompt in the inshellisense config file. This is because Windows strips details from your prompt which are required for inshellisense to work. To do this, update your config file in your home directory and add the following configuration:
-
-```toml
-[[prompt.bash]]
-regex = "(?<prompt>^>\\s*)" # the prompt match group will be used to detect the prompt
-postfix = ">" # the postfix is the last expected character in your prompt
-```
-
-This example adds custom prompt detection for bash where the prompt is expected to be only `> `. You can add similar configurations for other shells as well as well as multiple configurations for each shell.
-
 ## Contributing
 
 This project welcomes contributions and suggestions. Most contributions require you to agree to a

package/build/commands/root.js

@@ -12,7 +12,7 @@ export const action = (program) => async (options) => {
     const inISTerm = process.env.ISTERM === "1";
     if (options.check || inISTerm) {
         process.stdout.write(renderConfirmation(inISTerm));
-        return;
+        process.exit(0);
     }
     if (options.verbose)
         await log.enable();
@@ -32,5 +32,5 @@ export const action = (program) => async (options) => {
         await setupBashPreExec();
     }
     await loadAliases(shell);
-    await render(shell, options.test ?? false);
+    await render(shell, options.test ?? false, options.login ?? false);
 };

package/build/commands/specs/list.js

@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { Command } from "commander";
+import { loadConfig } from "../../utils/config.js";
+import { getSpecNames, loadLocalSpecsSet } from "../../runtime/runtime.js";
+import { getAliasNames, loadAliases } from "../../runtime/alias.js";
+import { aliasSupportedShells } from "../../utils/shell.js";
+const supportedShells = aliasSupportedShells.join(", ");
+const action = (program) => async (options) => {
+    await loadConfig(program);
+    await loadLocalSpecsSet();
+    const { shell } = options;
+    if (shell && !aliasSupportedShells.map((s) => s.valueOf()).includes(shell)) {
+        program.error(`Unsupported shell: '${shell}', supported shells: ${supportedShells}`, { exitCode: 1 });
+    }
+    if (shell) {
+        await loadAliases(shell);
+    }
+    process.stdout.write(JSON.stringify([...getAliasNames(), ...getSpecNames()]));
+    process.exit(0);
+};
+const cmd = new Command("list");
+cmd.description(`list the names of all available specs`);
+cmd.option("-s, --shell <shell>", `shell to use alias specs, supported shells: ${supportedShells}`);
+cmd.action(action(cmd));
+export default cmd;

package/build/commands/specs/root.js

@@ -0,0 +1,8 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { Command } from "commander";
+import list from "./list.js";
+const cmd = new Command("specs");
+cmd.description(`manage specs`);
+cmd.addCommand(list);
+export default cmd;

package/build/index.js

@@ -6,6 +6,7 @@ import { Command, Option } from "commander";
 import complete from "./commands/complete.js";
 import uninstall from "./commands/uninstall.js";
 import init from "./commands/init.js";
+import specs from "./commands/specs/root.js";
 import { action, supportedShells } from "./commands/root.js";
 import { getVersion } from "./utils/version.js";
 const program = new Command();
@@ -19,12 +20,15 @@ program
     .description("IDE style command line auto complete")
     .version(await getVersion(), "-v, --version", "output the current version")
     .action(action(program))
+    .option("-l, --login", `start shell as a login shell`)
     .option("-s, --shell <shell>", `shell to use for command execution, supported shells: ${supportedShells}`)
     .option("-c, --check", `check if shell is in an inshellisense session`)
     .addOption(hiddenOption("-T, --test", "used to make e2e tests reproducible across machines"))
     .option("-V, --verbose", `enable verbose logging`)
-    .showHelpAfterError("(add --help for additional information)");
+    .showHelpAfterError("(add --help for additional information)")
+    .passThroughOptions();
 program.addCommand(complete);
 program.addCommand(uninstall);
 program.addCommand(init);
+program.addCommand(specs);
 program.parse();

package/build/isterm/commandManager.js

@@ -4,19 +4,21 @@ import convert from "color-convert";
 import os from "node:os";
 import { getShellPromptRewrites, Shell } from "../utils/shell.js";
 import log from "../utils/log.js";
-import { getConfig } from "../utils/config.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) {
@@ -45,17 +47,9 @@ export class CommandManager {
     }
     handleClear() {
         this.handlePromptStart();
+        this.#maxCursorY = 0;
         this.#previousCommandLines = new Set();
     }
-    _extractPrompt(lineText, patterns) {
-        for (const { regex, postfix } of patterns) {
-            const customPrompt = lineText.match(new RegExp(regex))?.groups?.prompt;
-            const adjustedPrompt = this._adjustPrompt(customPrompt, lineText, postfix);
-            if (adjustedPrompt) {
-                return adjustedPrompt;
-            }
-        }
-    }
     _getWindowsPrompt(y) {
         const line = this.#terminal.buffer.active.getLine(y);
         if (!line) {
@@ -65,15 +59,16 @@ export class CommandManager {
         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
-        const inshellisenseConfig = getConfig();
         if (this.#shell == Shell.Bash) {
-            if (inshellisenseConfig?.prompt?.bash != null) {
-                const extractedPrompt = this._extractPrompt(lineText, inshellisenseConfig.prompt.bash);
-                if (extractedPrompt)
-                    return extractedPrompt;
-            }
-            const bashPrompt = lineText.match(/^(?<prompt>.*\$\s?)/)?.groups?.prompt;
+            const bashPrompt = lineText.match(/^(?<prompt>\$\s?)/)?.groups?.prompt;
             if (bashPrompt) {
                 const adjustedPrompt = this._adjustPrompt(bashPrompt, lineText, "$");
                 if (adjustedPrompt) {
@@ -81,12 +76,16 @@ export class CommandManager {
                 }
             }
         }
-        if (this.#shell == Shell.Nushell) {
-            if (inshellisenseConfig?.prompt?.nu != null) {
-                const extractedPrompt = this._extractPrompt(lineText, inshellisenseConfig.prompt.nu);
-                if (extractedPrompt)
-                    return extractedPrompt;
+        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, ">");
@@ -96,11 +95,6 @@ export class CommandManager {
             }
         }
         if (this.#shell == Shell.Xonsh) {
-            if (inshellisenseConfig?.prompt?.xonsh != null) {
-                const extractedPrompt = this._extractPrompt(lineText, inshellisenseConfig.prompt.xonsh);
-                if (extractedPrompt)
-                    return extractedPrompt;
-            }
             let xonshPrompt = lineText.match(/(?<prompt>.*@\s?)/)?.groups?.prompt;
             if (xonshPrompt) {
                 const adjustedPrompt = this._adjustPrompt(xonshPrompt, lineText, "@");
@@ -117,16 +111,6 @@ export class CommandManager {
             }
         }
         if (this.#shell == Shell.Powershell || this.#shell == Shell.Pwsh) {
-            if (inshellisenseConfig?.prompt?.powershell != null) {
-                const extractedPrompt = this._extractPrompt(lineText, inshellisenseConfig.prompt.powershell);
-                if (extractedPrompt)
-                    return extractedPrompt;
-            }
-            if (inshellisenseConfig?.prompt?.pwsh != null) {
-                const extractedPrompt = this._extractPrompt(lineText, inshellisenseConfig.prompt.pwsh);
-                if (extractedPrompt)
-                    return extractedPrompt;
-            }
             const pwshPrompt = lineText.match(/(?<prompt>(\(.+\)\s)?(?:PS.+>\s?))/)?.groups?.prompt;
             if (pwshPrompt) {
                 const adjustedPrompt = this._adjustPrompt(pwshPrompt, lineText, ">");
@@ -188,15 +172,84 @@ export class CommandManager {
             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;
-        if (globalCursorPosition < this.#activeCommand.promptStartMarker.line) {
+        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;
@@ -217,60 +270,15 @@ export class CommandManager {
         }
         // if the prompt is set, now parse out the values from the terminal
         if (this.#activeCommand.promptText != null) {
-            let lineY = this.#activeCommand.promptEndMarker.line;
-            let line = this.#terminal.buffer.active.getLine(this.#activeCommand.promptEndMarker.line);
-            let command = "";
-            let wrappedCommand = "";
-            let suggestions = "";
-            let isWrapped = false;
-            for (; lineY < this.#terminal.buffer.active.baseY + this.#terminal.rows;) {
-                for (let i = lineY == this.#activeCommand.promptEndMarker.line ? this.#activeCommand.promptText.length : 0; i < this.#terminal.cols; i++) {
-                    if (command.endsWith("    "))
-                        break; // assume that a command that ends with 4 spaces is terminated, avoids capturing right prompts
-                    const cell = line?.getCell(i);
-                    if (cell == null)
-                        continue;
-                    const chars = cell.getChars();
-                    const cleanedChars = chars == "" ? " " : chars;
-                    if (!this._isSuggestion(cell) && suggestions.length == 0) {
-                        command += cleanedChars;
-                        wrappedCommand += cleanedChars;
-                    }
-                    else {
-                        suggestions += cleanedChars;
-                    }
-                }
-                lineY += 1;
-                line = this.#terminal.buffer.active.getLine(lineY);
-                const wrapped = line?.isWrapped || this.#terminal.buffer.active.cursorY + this.#terminal.buffer.active.baseY != lineY - 1;
-                isWrapped = isWrapped || wrapped;
-                if (!wrapped) {
-                    break;
-                }
-                wrappedCommand = "";
-            }
-            const cursorAtEndOfInput = isWrapped
-                ? wrappedCommand.trim().length % this.#terminal.cols <= this.#terminal.buffer.active.cursorX
-                : (this.#activeCommand.promptText.length + command.trimEnd().length) % this.#terminal.cols <= this.#terminal.buffer.active.cursorX;
-            let hasOutput = false;
-            let cell = undefined;
-            for (let i = 0; i < this.#terminal.cols; i++) {
-                cell = line?.getCell(i, cell);
-                if (cell == null)
-                    continue;
-                hasOutput = cell.getChars() != "";
-                if (hasOutput) {
-                    break;
-                }
-            }
-            const postfixActive = isWrapped
-                ? wrappedCommand.trim().length < this.#terminal.buffer.active.cursorX
-                : this.#activeCommand.promptText.length + command.trimEnd().length < this.#terminal.buffer.active.cursorX;
-            const commandPostfix = postfixActive ? " " : "";
+            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 = suggestions.trim();
-            this.#activeCommand.commandText = command.trim() + commandPostfix;
+            this.#activeCommand.suggestionsText = suggestion;
+            this.#activeCommand.commandText = command;
             this.#activeCommand.cursorTerminated = cursorAtEndOfInput;
         }
         log.debug({
@@ -278,6 +286,8 @@ export class CommandManager {
             ...this.#activeCommand,
             promptEndMarker: this.#activeCommand.promptEndMarker?.line,
             promptStartMarker: this.#activeCommand.promptStartMarker?.line,
+            cursorX: this.#terminal.buffer.active.cursorX,
+            cursorY: globalCursorPosition,
         });
     }
 }

package/build/isterm/pty.js

@@ -6,6 +6,7 @@ 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 pty from "@homebridge/node-pty-prebuilt-multiarch";
 import { Shell, userZdotdir, zdotdir } from "../utils/shell.js";
 import { IsTermOscPs, IstermOscPt, IstermPromptStart, IstermPromptEnd } from "../utils/ansi.js";
@@ -13,8 +14,8 @@ import xterm from "@xterm/headless";
 import { CommandManager } from "./commandManager.js";
 import log from "../utils/log.js";
 import { gitBashPath } from "../utils/shell.js";
-import ansi from "ansi-escapes";
 import styles from "ansi-styles";
+import * as ansi from "../utils/ansi.js";
 const ISTermOnDataEvent = "data";
 export class ISTerm {
     pid;
@@ -31,13 +32,13 @@ export class ISTerm {
     #term;
     #commandManager;
     #shell;
-    constructor({ shell, cols, rows, env, shellTarget, shellArgs, underTest }) {
+    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), ...env },
+            env: { ...convertToPtyEnv(shell, underTest, login), ...env },
         });
         this.pid = this.#pty.pid;
         this.cols = this.#pty.cols;
@@ -84,6 +85,9 @@ export class ISTerm {
         }
         return cwd;
     }
+    _sanitizedPrompt(prompt) {
+        return stripAnsi(prompt);
+    }
     _handleIsSequence(data) {
         const argsIndex = data.indexOf(";");
         const sequence = argsIndex === -1 ? data : data.substring(0, argsIndex);
@@ -101,6 +105,19 @@ export class ISTerm {
                 }
                 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;
         }
@@ -144,24 +161,37 @@ export class ISTerm {
         };
     }
     _sameAccent(baseCell, targetCell) {
-        return baseCell?.isBold() == targetCell?.isBold() && baseCell?.isItalic() == targetCell?.isItalic() && baseCell?.isUnderline() == targetCell?.isUnderline();
+        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 boldAnsi = "";
-        if (cell.isBold()) {
-            boldAnsi = "\x1b[1m";
-        }
-        let italicAnsi = "";
-        if (cell.isItalic()) {
-            italicAnsi = "\x1b[3m";
-        }
         let underlineAnsi = "";
         if (cell.isUnderline()) {
-            underlineAnsi = "\x1b[4m";
+            if (cell.hasExtendedAttrs() && cell.extended.underlineStyle) {
+                underlineAnsi = `\x1b[4:${cell.extended.underlineStyle}m`;
+            }
+            else {
+                underlineAnsi = "\x1b[4m";
+            }
         }
-        return boldAnsi + italicAnsi + underlineAnsi;
+        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() &&
@@ -196,24 +226,32 @@ export class ISTerm {
         }
         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 = ["\x1b[0m"];
+            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() ?? "";
-                if (!this._sameColor(prevCell, cell)) {
+                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 (!this._sameAccent(prevCell, cell)) {
+                if (!sameAccents) {
                     ansiLine.push(this._getAnsiAccents(cell));
                 }
-                ansiLine.push(chars == "" ? " " : chars);
+                ansiLine.push(chars == "" ? ansi.cursorForward() : chars);
                 prevCell = cell;
             }
             return ansiLine.join("");
@@ -237,10 +275,10 @@ export class ISTerm {
     }
 }
 export const spawn = async (options) => {
-    const { shellTarget, shellArgs } = await convertToPtyTarget(options.shell, options.underTest);
+    const { shellTarget, shellArgs } = await convertToPtyTarget(options.shell, options.underTest, options.login);
     return new ISTerm({ ...options, shellTarget, shellArgs });
 };
-const convertToPtyTarget = async (shell, underTest) => {
+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");
@@ -254,7 +292,10 @@ const convertToPtyTarget = async (shell, underTest) => {
             shellArgs = ["-noexit", "-command", `try { . "${path.join(shellFolderPath, "shellIntegration.ps1")}" } catch {}`];
             break;
         case Shell.Fish:
-            shellArgs = ["--init-command", `. ${path.join(shellFolderPath, "shellIntegration.fish").replace(/(\s+)/g, "\\$1")}`];
+            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");
@@ -273,15 +314,31 @@ const convertToPtyTarget = async (shell, 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) => {
+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) {

package/build/runtime/alias.js

@@ -48,6 +48,7 @@ export const loadAliases = async (shell) => {
     }
     return [];
 };
+export const getAliasNames = () => Object.keys(loadedAliases);
 export const aliasExpand = (command) => {
     if (!command.at(0)?.complete)
         return command;

package/build/runtime/runtime.js

@@ -103,6 +103,9 @@ export const getSuggestions = async (cmd, cwd, shell) => {
     }
     return { ...result, charactersToDrop };
 };
+export const getSpecNames = () => {
+    return Object.keys(specSet).filter((spec) => !spec.startsWith("@") && spec != "-");
+};
 const getPersistentOptions = (persistentOptions, options) => {
     const persistentOptionNames = new Set(persistentOptions.map((o) => (typeof o.name === "string" ? [o.name] : o.name)).flat());
     return persistentOptions.concat((options ?? []).filter((o) => (typeof o.name == "string" ? !persistentOptionNames.has(o.name) : o.name.some((n) => !persistentOptionNames.has(n))) && o.isPersistent === true));

package/build/ui/suggestionManager.js

@@ -19,6 +19,7 @@ export class SuggestionManager {
     #activeSuggestionIdx;
     #suggestBlob;
     #shell;
+    #hideSuggestions = false;
     constructor(terminal, shell) {
         this.#term = terminal;
         this.#suggestBlob = { suggestions: [] };
@@ -28,7 +29,7 @@ export class SuggestionManager {
     }
     async _loadSuggestions() {
         const commandText = this.#term.getCommandState().commandText;
-        if (!commandText) {
+        if (!commandText || this.#hideSuggestions) {
             this.#suggestBlob = undefined;
             this.#activeSuggestionIdx = 0;
             return;
@@ -122,12 +123,20 @@ export class SuggestionManager {
     }
     update(keyPress) {
         const { name, shift, ctrl } = keyPress;
+        if (name == "return") {
+            this.#term.clearCommand(); // clear the current command on enter
+        }
+        // if suggestions are hidden, keep them hidden until during command navigation
+        if (this.#hideSuggestions) {
+            this.#hideSuggestions = name == "up" || name == "down";
+        }
         if (!this.#suggestBlob) {
             return false;
         }
         const { dismissSuggestions: { key: dismissKey, shift: dismissShift, control: dismissCtrl }, acceptSuggestion: { key: acceptKey, shift: acceptShift, control: acceptCtrl }, nextSuggestion: { key: nextKey, shift: nextShift, control: nextCtrl }, previousSuggestion: { key: prevKey, shift: prevShift, control: prevCtrl }, } = getConfig().bindings;
         if (name == dismissKey && shift == !!dismissShift && ctrl == !!dismissCtrl) {
             this.#suggestBlob = undefined;
+            this.#hideSuggestions = true;
         }
         else if (name == prevKey && shift == !!prevShift && ctrl == !!prevCtrl) {
             this.#activeSuggestionIdx = Math.max(0, this.#activeSuggestionIdx - 1);

package/build/ui/ui-root.js

@@ -12,8 +12,8 @@ export const renderConfirmation = (live) => {
     const statusMessage = live ? chalk.green("live") : chalk.red("not found");
     return `inshellisense session [${statusMessage}]\n`;
 };
-export const render = async (shell, underTest) => {
-    const term = await isterm.spawn({ shell, rows: process.stdout.rows, cols: process.stdout.columns, underTest });
+export const render = async (shell, underTest, login) => {
+    const term = await isterm.spawn({ shell, rows: process.stdout.rows, cols: process.stdout.columns, underTest, login });
     const suggestionManager = new SuggestionManager(term, shell);
     let hasActiveSuggestions = false;
     let previousSuggestionsRows = 0;

package/build/ui/utils.js

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 import ansi from "ansi-escapes";
+import { resetColor } from "../utils/ansi.js";
 import wrapAnsi from "wrap-ansi";
 import chalk from "chalk";
 import wcwidth from "wcwidth";
@@ -12,7 +13,7 @@ import wcwidth from "wcwidth";
  */
 export const renderBox = (rows, width, x, borderColor) => {
     const result = [];
-    const setColor = (text) => (borderColor ? chalk.hex(borderColor).apply(text) : text);
+    const setColor = (text) => resetColor + (borderColor ? chalk.hex(borderColor).apply(text) : text);
     result.push(ansi.cursorTo(x) + setColor("┌" + "─".repeat(width - 2) + "┐") + ansi.cursorTo(x));
     rows.forEach((row) => {
         result.push(ansi.cursorDown() + setColor("│") + row + setColor("│") + ansi.cursorTo(x));

package/build/utils/ansi.js

@@ -11,6 +11,7 @@ export var IstermOscPt;
     IstermOscPt["PromptStarted"] = "PS";
     IstermOscPt["PromptEnded"] = "PE";
     IstermOscPt["CurrentWorkingDirectory"] = "CWD";
+    IstermOscPt["Prompt"] = "PROMPT";
 })(IstermOscPt || (IstermOscPt = {}));
 export const IstermPromptStart = IS_OSC + IstermOscPt.PromptStarted + BEL;
 export const IstermPromptEnd = IS_OSC + IstermOscPt.PromptEnded + BEL;
@@ -18,7 +19,10 @@ export const cursorHide = CSI + "?25l";
 export const cursorShow = CSI + "?25h";
 export const cursorNextLine = CSI + "E";
 export const eraseLine = CSI + "2K";
+export const resetColor = CSI + "0m";
+export const resetLine = CSI + "2K";
 export const cursorBackward = (count = 1) => CSI + count + "D";
+export const cursorForward = (count = 1) => CSI + count + "C";
 export const cursorTo = ({ x, y }) => {
     return CSI + (y ?? "") + ";" + (x ?? "") + "H";
 };

package/build/utils/config.js

@@ -49,6 +49,7 @@ const configSchema = {
                 acceptSuggestion: bindingSchema,
             },
         },
+        // DEPRECATED: prompt patterns are no longer used
         prompt: {
             type: "object",
             nullable: true,
@@ -58,6 +59,7 @@ const configSchema = {
                 powershell: promptPatternsSchema,
                 xonsh: promptPatternsSchema,
                 nu: promptPatternsSchema,
+                fish: promptPatternsSchema,
             },
         },
         specs: {
@@ -70,9 +72,12 @@ const configSchema = {
     },
     additionalProperties: false,
 };
-const configFile = ".inshellisenserc";
+const rcFile = ".inshellisenserc";
+const xdgFile = "rc.toml";
 const cachePath = path.join(os.homedir(), ".inshellisense");
-const configPath = path.join(os.homedir(), configFile);
+const rcPath = path.join(os.homedir(), rcFile);
+const xdgPath = path.join(os.homedir(), ".config", "inshellisense", xdgFile);
+const configPaths = [rcPath, xdgPath];
 let globalConfig = {
     bindings: {
         nextSuggestion: { key: "down" },
@@ -83,38 +88,42 @@ let globalConfig = {
 };
 export const getConfig = () => globalConfig;
 export const loadConfig = async (program) => {
-    if (fs.existsSync(configPath)) {
-        let config;
-        try {
-            config = toml.parse((await fsAsync.readFile(configPath)).toString());
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    configPaths.forEach(async (configPath) => {
+        if (fs.existsSync(configPath)) {
+            let config;
+            try {
+                config = toml.parse((await fsAsync.readFile(configPath)).toString());
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (e) {
+                program.error(`${configPath} is invalid toml. Parsing error on line ${e.line}, column ${e.column}: ${e.message}`);
+            }
+            const isValid = ajv.validate(configSchema, config);
+            if (!isValid) {
+                program.error(`${configPath} is invalid: ${ajv.errorsText()}`);
+            }
+            globalConfig = {
+                bindings: {
+                    nextSuggestion: config?.bindings?.nextSuggestion ?? globalConfig.bindings.nextSuggestion,
+                    previousSuggestion: config?.bindings?.previousSuggestion ?? globalConfig.bindings.previousSuggestion,
+                    acceptSuggestion: config?.bindings?.acceptSuggestion ?? globalConfig.bindings.acceptSuggestion,
+                    dismissSuggestions: config?.bindings?.dismissSuggestions ?? globalConfig.bindings.dismissSuggestions,
+                },
+                prompt: {
+                    bash: config.prompt?.bash ?? globalConfig?.prompt?.bash,
+                    powershell: config.prompt?.powershell ?? globalConfig?.prompt?.powershell,
+                    xonsh: config.prompt?.xonsh ?? globalConfig?.prompt?.xonsh,
+                    pwsh: config.prompt?.pwsh ?? globalConfig?.prompt?.pwsh,
+                    nu: config.prompt?.nu ?? globalConfig?.prompt?.nu,
+                    fish: config.prompt?.fish ?? globalConfig?.prompt?.fish,
+                },
+                specs: {
+                    path: [...(config?.specs?.path ?? []), ...(config?.specs?.path ?? [])],
+                },
+            };
         }
-        catch (e) {
-            program.error(`${configFile} is invalid toml. Parsing error on line ${e.line}, column ${e.column}: ${e.message}`);
-        }
-        const isValid = ajv.validate(configSchema, config);
-        if (!isValid) {
-            program.error(`${configFile} is invalid: ${ajv.errorsText()}`);
-        }
-        globalConfig = {
-            bindings: {
-                nextSuggestion: config?.bindings?.nextSuggestion ?? globalConfig.bindings.nextSuggestion,
-                previousSuggestion: config?.bindings?.previousSuggestion ?? globalConfig.bindings.previousSuggestion,
-                acceptSuggestion: config?.bindings?.acceptSuggestion ?? globalConfig.bindings.acceptSuggestion,
-                dismissSuggestions: config?.bindings?.dismissSuggestions ?? globalConfig.bindings.dismissSuggestions,
-            },
-            prompt: {
-                bash: config.prompt?.bash,
-                powershell: config.prompt?.powershell,
-                xonsh: config.prompt?.xonsh,
-                pwsh: config.prompt?.pwsh,
-                nu: config.prompt?.nu,
-            },
-            specs: {
-                path: [`${os.homedir()}/.fig/autocomplete/build`, ...(config?.specs?.path ?? [])],
-            },
-        };
-    }
+    });
+    globalConfig.specs = { path: [`${os.homedir()}/.fig/autocomplete/build`, ...(globalConfig.specs?.path ?? [])] };
 };
 export const deleteCacheFolder = async () => {
     const cliConfigPath = path.join(os.homedir(), cachePath);

package/build/utils/shell.js

@@ -30,6 +30,7 @@ export const supportedShells = [
     Shell.Nushell,
 ].filter((shell) => shell != null);
 export const initSupportedShells = supportedShells.filter((shell) => shell != Shell.Cmd);
+export const aliasSupportedShells = [Shell.Bash, Shell.Zsh];
 export const userZdotdir = process.env?.ZDOTDIR ?? os.homedir() ?? `~`;
 export const zdotdir = path.join(os.tmpdir(), `is-zsh`);
 const configFolder = ".inshellisense";
@@ -49,6 +50,23 @@ export const setupZshDotfiles = async () => {
     await fsAsync.cp(path.join(shellFolderPath, "shellIntegration-login.zsh"), path.join(zdotdir, ".zlogin"));
 };
 export const inferShell = async () => {
+    // try getting shell from shell specific env variables
+    if (process.env.NU_VERSION != null) {
+        return Shell.Nushell;
+    }
+    else if (process.env.XONSHRC != null) {
+        return Shell.Xonsh;
+    }
+    else if (process.env.FISH_VERSION != null) {
+        return Shell.Fish;
+    }
+    else if (process.env.ZSH_VERSION != null) {
+        return Shell.Zsh;
+    }
+    else if (process.env.BASH_VERSION != null) {
+        return Shell.Bash;
+    }
+    // try getting shell from env
     try {
         const name = path.parse(process.env.SHELL ?? "").name;
         const shellName = supportedShells.find((shell) => name.includes(shell));
@@ -58,6 +76,7 @@ export const inferShell = async () => {
     catch {
         /* empty */
     }
+    // try getting shell from parent process
     const processResult = (await find("pid", process.ppid)).at(0);
     const name = processResult?.name;
     return name != null ? supportedShells.find((shell) => name.includes(shell)) : undefined;
@@ -103,9 +122,22 @@ export const getShellPromptRewrites = (shell) => shell == Shell.Nushell;
 export const getShellConfig = (shell) => {
     switch (shell) {
         case Shell.Zsh:
+            return `if [[ -z "\${ISTERM}" && $- = *i* && $- != *c* ]]; then
+  if [[ -o login ]]; then
+    is -s zsh --login ; exit
+  else
+    is -s zsh ; exit
+  fi
+fi`;
         case Shell.Bash:
             return `if [[ -z "\${ISTERM}" && $- = *i* && $- != *c* ]]; then
-  is -s ${shell} ; exit
+  shopt -q login_shell
+  login_shell=$?
+  if [ $login_shell -eq 0 ]; then
+    is -s bash --login ; exit
+  else
+    is -s bash ; exit
+  fi 
 fi`;
         case Shell.Powershell:
         case Shell.Pwsh:
@@ -118,14 +150,21 @@ if ([string]::IsNullOrEmpty($env:ISTERM) -and [Environment]::UserInteractive -an
 }`;
         case Shell.Fish:
             return `if test -z "$ISTERM" && status --is-interactive
-  is -s fish ; kill %self
+  if status --is-login
+    is -s fish --login ; kill %self
+  else
+    is -s fish ; kill %self
+  end 
 end`;
         case Shell.Xonsh:
             return `if 'ISTERM' not in \${...} and $XONSH_INTERACTIVE:
-    is -s xonsh ; exit`;
+    if $XONSH_LOGIN:
+        is -s xonsh --login ; exit
+    else:
+        is -s xonsh ; exit`;
         case Shell.Nushell:
             return `if "ISTERM" not-in $env and $nu.is-interactive {
-    is -s nu ; exit
+    if $nu.is-login { is -s nu --login ; exit } else { is -s nu ; exit }
 }`;
     }
     return "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/inshellisense",
-  "version": "0.0.1-rc.13",
+  "version": "0.0.1-rc.15",
   "description": "IDE style command line auto complete",
   "type": "module",
   "engines": {
@@ -41,6 +41,7 @@
   "dependencies": {
     "@homebridge/node-pty-prebuilt-multiarch": "^0.11.12",
     "@withfig/autocomplete": "2.651.0",
+    "@xterm/headless": "^5.5.0",
     "ajv": "^8.12.0",
     "ansi-escapes": "^6.2.0",
     "ansi-styles": "^6.2.1",
@@ -48,11 +49,11 @@
     "color-convert": "^2.0.1",
     "commander": "^11.0.0",
     "find-process": "^1.4.7",
+    "strip-ansi": "^7.1.0",
     "toml": "^3.0.0",
     "wcwidth": "^1.0.1",
     "which": "^4.0.0",
-    "wrap-ansi": "^8.1.0",
-    "@xterm/headless": "^5.3.0"
+    "wrap-ansi": "^8.1.0"
   },
   "devDependencies": {
     "@microsoft/tui-test": "^0.0.1-rc.3",
@@ -65,6 +66,7 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "@withfig/autocomplete-types": "^1.28.0",
+    "@xterm/xterm": "^5.5.0",
     "eslint": "^8.51.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-header": "^3.1.1",

package/shell/shellIntegration.bash

@@ -1,5 +1,19 @@
-if [ -r ~/.bashrc ]; then
-    . ~/.bashrc
+if [ -z "$ISTERM_LOGIN" ]; then
+	if [ -r ~/.bashrc ]; then
+		. ~/.bashrc
+	fi
+else
+	if [ -r /etc/profile ]; then
+		. /etc/profile
+	fi
+	# execute the first that exists
+	if [ -r ~/.bash_profile ]; then
+		. ~/.bash_profile
+	elif [ -r ~/.bash_login ]; then
+		. ~/.bash_login
+	elif [ -r ~/.profile ]; then
+		. ~/.profile
+	fi
 fi
 
 if [ -r ~/.inshellisense/bash-preexec.sh ]; then
@@ -26,6 +40,10 @@ __is_escape_value() {
 			token="\\\\"
 		elif [ "$byte" = ";" ]; then
 			token="\\x3b"
+		elif [ "$byte" = $'\n' ]; then
+			token="\x0a"
+		elif [ "$byte" = $'\e' ]; then
+			token="\\x1b"
 		else
 			token="$byte"
 		fi
@@ -40,6 +58,16 @@ __is_update_cwd() {
 	builtin printf '\e]6973;CWD;%s\a' "$(__is_escape_value "$PWD")"
 }
 
+__is_report_prompt() {
+	if ((BASH_VERSINFO[0] >= 4)); then
+		__is_prompt=${__is_original_PS1@P}
+	else
+		__is_prompt=${__is_original_PS1}
+	fi
+	__is_prompt="$(builtin printf "%s" "${__is_prompt//[$'\001'$'\002']}")"
+	builtin printf "\e]6973;PROMPT;%s\a" "$(__is_escape_value "${__is_prompt}")"
+}
+
 if [[ -n "${bash_preexec_imported:-}" ]]; then
     precmd_functions+=(__is_precmd)
 fi
@@ -47,6 +75,7 @@ fi
 __is_precmd() {
 	__is_update_cwd
 	__is_update_prompt
+	__is_report_prompt
 }
 
 __is_update_prompt() {

package/shell/shellIntegration.fish

@@ -2,15 +2,18 @@ function __is_copy_function; functions $argv[1] | sed "s/^function $argv[1]/func
 function __is_prompt_start; printf '\e]6973;PS\a'; end
 function __is_prompt_end; printf '\e]6973;PE\a'; end
 
+__is_copy_function fish_prompt is_user_prompt
+
 function __is_escape_value
 	echo $argv \
-	| string replace --all '\\' '\\\\' \
-	| string replace --all ';' '\\x3b' \
+	| string replace -a '\\' '\\\\' \
+	| string replace -a ';' '\\x3b' \
+	| string replace -a \e '\\x1b' \
+	| string split \n | string join '\x0a' \
 	;
 end
-function __is_update_cwd --on-event fish_prompt; set __is_cwd (__is_escape_value "$PWD"); printf "\e]6973;CWD;$__is_cwd\a"; end
-
-__is_copy_function fish_prompt is_user_prompt
+function __is_update_cwd --on-event fish_prompt; set __is_cwd (__is_escape_value "$PWD"); printf "\e]6973;CWD;%s\a" $__is_cwd; end
+function __is_report_prompt --on-event fish_prompt; set __is_prompt (__is_escape_value (is_user_prompt)); printf "\e]6973;PROMPT;%s\a" $__is_prompt; end
 
 if [ "$ISTERM_TESTING" = "1" ]
 	function is_user_prompt; printf '> '; end

package/shell/shellIntegration.nu

@@ -1,18 +1,26 @@
-let __is_escape_value = {|x| $x | str replace --all "\\" "\\\\" | str replace --all ";" "\\x3b" }
+let __is_escape_value = {|x| $x | str replace --all "\\" "\\\\" | str replace --all ";" "\\x3b" | str replace --all "\n" '\x0a' | str replace --all "\e" "\\x1b" }
+let __is_original_PROMPT_COMMAND = if 'PROMPT_COMMAND' in $env { $env.PROMPT_COMMAND } else { "" }
+let __is_original_PROMPT_INDICATOR = if 'PROMPT_INDICATOR' in $env { $env.PROMPT_INDICATOR } else { "" }
 
 let __is_update_cwd = { 
     let pwd = do $__is_escape_value $env.PWD
     $"\e]6973;CWD;($pwd)\a" 
 }
-let __is_original_PROMPT_COMMAND = if 'PROMPT_COMMAND' in $env { $env.PROMPT_COMMAND } else { "" }
+let __is_report_prompt = { 
+    let __is_indicatorCommandType = $__is_original_PROMPT_INDICATOR | describe
+    mut __is_prompt_ind = if $__is_indicatorCommandType == "closure" { do $__is_original_PROMPT_INDICATOR } else { $__is_original_PROMPT_INDICATOR }
+    let __is_esc_prompt_ind = do $__is_escape_value $__is_prompt_ind
+    $"\e]6973;PROMPT;($__is_esc_prompt_ind)\a"
+}
 let __is_custom_PROMPT_COMMAND = {
     let promptCommandType = $__is_original_PROMPT_COMMAND | describe
     mut cmd = if $promptCommandType == "closure" { do $__is_original_PROMPT_COMMAND } else { $__is_original_PROMPT_COMMAND }
     let pwd = do $__is_update_cwd
+    let prompt = do $__is_report_prompt
     if 'ISTERM_TESTING' in $env {
         $cmd = ""
     }
-    $"\e]6973;PS\a($cmd)($pwd)"
+    $"\e]6973;PS\a($cmd)($pwd)($prompt)"
 }
 $env.PROMPT_COMMAND = $__is_custom_PROMPT_COMMAND
 

package/shell/shellIntegration.ps1

@@ -8,7 +8,7 @@ if ($env:ISTERM_TESTING -eq "1") {
 }
 
 function Global:__IS-Escape-Value([string]$value) {
-    [regex]::Replace($value, '[\\\n;]', { param($match)
+    [regex]::Replace($value, "[$([char]0x1b)\\\n;]", { param($match)
             -Join (
                 [System.Text.Encoding]::UTF8.GetBytes($match.Value) | ForEach-Object { '\x{0:x2}' -f $_ }
             )
@@ -17,8 +17,11 @@ function Global:__IS-Escape-Value([string]$value) {
 
 function Global:Prompt() {
     $Result = "$([char]0x1b)]6973;PS`a"
-    $Result += $Global:__IsOriginalPrompt.Invoke()
+    $OriginalPrompt += $Global:__IsOriginalPrompt.Invoke()
+    $Result += $OriginalPrompt
     $Result += "$([char]0x1b)]6973;PE`a"
+
+    $Result += "$([char]0x1b)]6973;PROMPT;$(__IS-Escape-Value $OriginalPrompt)`a"
     $Result += if ($pwd.Provider.Name -eq 'FileSystem') { "$([char]0x1b)]6973;CWD;$(__IS-Escape-Value $pwd.ProviderPath)`a" }
     return $Result
 }

package/shell/shellIntegration.xsh

@@ -1,4 +1,5 @@
 import os
+from xonsh.main import XSH
 
 def __is_prompt_start() -> str:
     return "\001" + "\x1b]6973;PS\x07"
@@ -7,23 +8,30 @@ def __is_prompt_start() -> str:
 def __is_prompt_end() -> str:
     return "\001" + "\x1b]6973;PE\x07" + "\002"
 
-
 def __is_escape_value(value: str) -> str:
     byte_list = [bytes([byte]).decode("utf-8") for byte in list(value.encode("utf-8"))]
     return "".join(
         [
-            "\\x3b" if byte == ";" else "\\\\" if byte == "\\" else byte
+            "\\x3b" if byte == ";" else "\\\\" if byte == "\\" else "\\x1b" if byte == "\x1b" else "\x0a" if byte == "\n" else byte
             for byte in byte_list
         ]
     )
 
 def __is_update_cwd() -> str:
-    return f"\x1b]6973;CWD;{__is_escape_value(os.getcwd())}\x07" + "\002"
+    return f"\x1b]6973;CWD;{__is_escape_value(os.getcwd())}\x07"
+
+__is_original_prompt = $PROMPT
+def __is_report_prompt() -> str:
+    prompt = ""
+    formatted_prompt = XSH.shell.prompt_formatter(__is_original_prompt)
+    prompt = "".join([text for  _, text in XSH.shell.format_color(formatted_prompt)])
+    return f"\x1b]6973;PROMPT;{__is_escape_value(prompt)}\x07" + "\002"
 
 $PROMPT_FIELDS['__is_prompt_start'] = __is_prompt_start
 $PROMPT_FIELDS['__is_prompt_end'] = __is_prompt_end
 $PROMPT_FIELDS['__is_update_cwd'] = __is_update_cwd
+$PROMPT_FIELDS['__is_report_prompt'] = __is_report_prompt
 if 'ISTERM_TESTING' in ${...}:
     $PROMPT = "> "
 
-$PROMPT = "{__is_prompt_start}{__is_update_cwd}" + $PROMPT + "{__is_prompt_end}"
+$PROMPT = "{__is_prompt_start}{__is_update_cwd}{__is_report_prompt}" + $PROMPT + "{__is_prompt_end}"