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

package/build/isterm/pty.js

@@ -0,0 +1,361 @@
+// 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 },
+            useConpty: true,
+            useConptyDll: true,
+        });
+        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;
+            }
+            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;
+};

package/build/runtime/alias.js

@@ -0,0 +1,66 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import log from "../utils/log.js";
+import { gitBashPath, Shell } from "../utils/shell.js";
+import { parseCommand } from "./parser.js";
+import { buildExecuteShellCommand } from "./utils.js";
+import os from "node:os";
+const loadedAliases = {};
+const platform = os.platform();
+const executeShellCommand = await buildExecuteShellCommand(5000);
+const loadBashAliases = async () => {
+    const shellTarget = platform == "win32" ? await gitBashPath() : Shell.Bash;
+    const { stdout, stderr, status } = await executeShellCommand({
+        command: `'${shellTarget}'`,
+        args: ["-i", "-c", "alias"],
+        cwd: process.cwd(),
+        env: { ISTERM: "1" },
+    });
+    if (status !== 0) {
+        log.debug({ msg: "failed to load bash aliases", stderr, status });
+        return;
+    }
+    return stdout
+        .trim()
+        .split("\n")
+        .forEach((line) => {
+        const [alias, ...commandSegments] = line.replace("alias ", "").replaceAll("'\\''", "'").split("=");
+        loadedAliases[alias] = parseCommand(commandSegments.join("=").slice(1, -1) + " ", Shell.Bash);
+    });
+};
+const loadZshAliases = async () => {
+    const { stdout, stderr, status } = await executeShellCommand({ command: Shell.Zsh, args: ["-i", "-c", "alias"], cwd: process.cwd(), env: { ISTERM: "1" } });
+    if (status !== 0) {
+        log.debug({ msg: "failed to load zsh aliases", stderr, status });
+        return;
+    }
+    return stdout
+        .trim()
+        .split("\n")
+        .forEach((line) => {
+        const [alias, ...commandSegments] = line.replaceAll("'\\''", "'").split("=");
+        loadedAliases[alias] = parseCommand(commandSegments.join("=").slice(1, -1) + " ", Shell.Zsh);
+    });
+};
+export const loadAliases = async (shell) => {
+    switch (shell) {
+        case Shell.Bash:
+            await loadBashAliases();
+            break;
+        case Shell.Zsh:
+            await loadZshAliases();
+            break;
+    }
+    return [];
+};
+export const getAliasNames = () => Object.keys(loadedAliases);
+export const aliasExpand = (command) => {
+    if (!command.at(0)?.complete)
+        return command;
+    const alias = loadedAliases[command.at(0)?.token ?? ""];
+    if (alias) {
+        log.debug({ msg: "expanding alias", alias, command: command.slice(1) });
+        return [...alias, ...command.slice(1)];
+    }
+    return command;
+};

package/build/runtime/generator.js

@@ -1,11 +1,12 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
+import log from "../utils/log.js";
 import { runTemplates } from "./template.js";
 import { buildExecuteShellCommand } from "./utils.js";
-const getGeneratorContext = () => {
+const getGeneratorContext = (cwd) => {
     return {
         environmentVariables: Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] != null)),
-        currentWorkingDirectory: process.cwd(),
+        currentWorkingDirectory: cwd,
         currentProcess: "",
         sshPrefix: "",
         isDangerous: false,
@@ -13,30 +14,42 @@ const getGeneratorContext = () => {
     };
 };
 // TODO: add support for caching, trigger, & getQueryTerm
-export const runGenerator = async (generator, tokens) => {
-    const { script, postProcess, scriptTimeout, splitOn, custom, template } = generator;
-    const executeShellCommand = buildExecuteShellCommand(scriptTimeout ?? 5000);
+export const runGenerator = async (generator, tokens, cwd) => {
+    // TODO: support trigger
+    const { script, postProcess, scriptTimeout, splitOn, custom, template, filterTemplateSuggestions } = generator;
+    const executeShellCommand = await buildExecuteShellCommand(scriptTimeout ?? 5000);
     const suggestions = [];
     try {
         if (script) {
-            const scriptOutput = typeof script === "function" ? script(tokens) : script != null ? await executeShellCommand(script) : "";
+            const shellInput = typeof script === "function" ? script(tokens) : script;
+            const scriptOutput = Array.isArray(shellInput)
+                ? await executeShellCommand({ command: shellInput.at(0) ?? "", args: shellInput.slice(1), cwd })
+                : await executeShellCommand({ ...shellInput, cwd });
+            const scriptStdout = scriptOutput.stdout.trim();
             if (postProcess) {
-                suggestions.push(...postProcess(scriptOutput, tokens));
+                suggestions.push(...postProcess(scriptStdout, tokens));
             }
             else if (splitOn) {
-                suggestions.push(...scriptOutput.split(splitOn).map((s) => ({ name: s })));
+                suggestions.push(...scriptStdout.split(splitOn).map((s) => ({ name: s })));
             }
         }
         if (custom) {
-            suggestions.push(...(await custom(tokens, executeShellCommand, getGeneratorContext())));
+            suggestions.push(...(await custom(tokens, executeShellCommand, getGeneratorContext(cwd))));
         }
         if (template != null) {
-            suggestions.push(...(await runTemplates(template)));
+            const templateSuggestions = await runTemplates(template, cwd);
+            if (filterTemplateSuggestions) {
+                suggestions.push(...filterTemplateSuggestions(templateSuggestions));
+            }
+            else {
+                suggestions.push(...templateSuggestions);
+            }
         }
         return suggestions;
     }
     catch (e) {
-        /* empty */
+        const err = typeof e === "string" ? e : e instanceof Error ? e.message : e;
+        log.debug({ msg: "generator failed", err, script, splitOn, template });
     }
     return suggestions;
 };

package/build/runtime/parser.js

@@ -1,19 +1,48 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-const cmdDelim = /(\|\|)|(&&)|(;)/;
+import wcwidth from "wcwidth";
+import { getShellWhitespaceEscapeChar } from "./utils.js";
+const cmdDelim = /(\|\|)|(&&)|(;)|(\|)/;
 const spaceRegex = /\s/;
-export const parseCommand = (command) => {
+export const parseCommand = (command, shell) => {
     const lastCommand = command.split(cmdDelim).at(-1)?.trimStart();
-    return lastCommand ? lex(lastCommand) : [];
+    const tokens = lastCommand ? lex(lastCommand, shell) : [];
+    return sanitizeTokens(tokens, shell);
 };
-const lex = (command) => {
+const sanitizeTokens = (cmdTokens, shell) => unwrapQuotedTokens(unescapeSpaceTokens(cmdTokens, shell), shell);
+// remove escapes around spaces
+const unescapeSpaceTokens = (cmdTokens, shell) => {
+    const escapeChar = getShellWhitespaceEscapeChar(shell);
+    return cmdTokens.map((cmdToken) => {
+        const { token, isQuoted } = cmdToken;
+        if (!isQuoted && token.includes(`${escapeChar} `)) {
+            return { ...cmdToken, token: token.replaceAll(`${escapeChar} `, " ") };
+        }
+        return cmdToken;
+    });
+};
+// need to unwrap tokens that are quoted with content after the quotes like `"hello"world`
+const unwrapQuotedTokens = (cmdTokens, shell) => {
+    const escapeChar = getShellWhitespaceEscapeChar(shell);
+    return cmdTokens.map((cmdToken) => {
+        const { token, isQuoteContinued } = cmdToken;
+        if (isQuoteContinued) {
+            const quoteChar = token[0];
+            const unquotedToken = token.replaceAll(`${escapeChar}${quoteChar}`, "\u001B").replaceAll(quoteChar, "").replaceAll("\u001B", quoteChar);
+            return { ...cmdToken, token: unquotedToken };
+        }
+        return cmdToken;
+    });
+};
+const lex = (command, shell) => {
     const tokens = [];
-    let [readingQuotedString, readingFlag, readingCmd] = [false, false, false];
+    const escapeChar = getShellWhitespaceEscapeChar(shell);
+    let [readingQuotedString, readingQuoteContinuedString, readingFlag, readingCmd] = [false, false, false, false];
     let readingIdx = 0;
     let readingQuoteChar = "";
     [...command].forEach((char, idx) => {
-        const reading = readingQuotedString || readingFlag || readingCmd;
-        if (!reading && (char === `'` || char === `"`)) {
+        const reading = readingQuotedString || readingQuoteContinuedString || readingFlag || readingCmd;
+        if (!reading && (char === `'` || char === `"` || char == "`")) {
             [readingQuotedString, readingIdx, readingQuoteChar] = [true, idx, char];
             return;
         }
@@ -25,39 +54,80 @@ const lex = (command) => {
             [readingCmd, readingIdx] = [true, idx];
             return;
         }
-        if (readingQuotedString && char === readingQuoteChar && command.at(idx - 1) !== "\\") {
+        if (readingQuotedString && char === readingQuoteChar && command.at(idx - 1) !== escapeChar && !spaceRegex.test(command.at(idx + 1) ?? " ")) {
+            readingQuotedString = false;
+            readingQuoteContinuedString = true;
+        }
+        else if (readingQuotedString && char === readingQuoteChar && command.at(idx - 1) !== escapeChar) {
             readingQuotedString = false;
             const complete = idx + 1 < command.length && spaceRegex.test(command[idx + 1]);
             tokens.push({
-                token: command.slice(readingIdx, idx + 1),
+                token: command.slice(readingIdx + 1, idx),
+                tokenLength: wcwidth(command.slice(readingIdx + 1, idx)) + 2,
                 complete,
                 isOption: false,
+                isQuoted: true,
+            });
+        }
+        else if (readingQuoteContinuedString && spaceRegex.test(char) && command.at(idx - 1) !== escapeChar) {
+            readingQuoteContinuedString = false;
+            tokens.push({
+                token: command.slice(readingIdx, idx),
+                tokenLength: wcwidth(command.slice(readingIdx, idx)),
+                complete: true,
+                isOption: false,
+                isQuoted: true,
+                isQuoteContinued: true,
             });
         }
         else if ((readingFlag && spaceRegex.test(char)) || char === "=") {
             readingFlag = false;
             tokens.push({
                 token: command.slice(readingIdx, idx),
+                tokenLength: wcwidth(command.slice(readingIdx, idx)),
                 complete: true,
                 isOption: true,
             });
         }
-        else if (readingCmd && spaceRegex.test(char)) {
+        else if (readingCmd && spaceRegex.test(char) && command.at(idx - 1) !== escapeChar) {
             readingCmd = false;
             tokens.push({
                 token: command.slice(readingIdx, idx),
+                tokenLength: wcwidth(command.slice(readingIdx, idx)),
                 complete: true,
                 isOption: false,
             });
         }
     });
-    const reading = readingQuotedString || readingFlag || readingCmd;
+    const reading = readingQuotedString || readingQuoteContinuedString || readingFlag || readingCmd;
     if (reading) {
-        tokens.push({
-            token: command.slice(readingIdx),
-            complete: false,
-            isOption: false,
-        });
+        if (readingQuotedString) {
+            tokens.push({
+                token: command.slice(readingIdx + 1),
+                tokenLength: wcwidth(command.slice(readingIdx + 1)) + 1,
+                complete: false,
+                isOption: false,
+                isQuoted: true,
+            });
+        }
+        else if (readingQuoteContinuedString) {
+            tokens.push({
+                token: command.slice(readingIdx),
+                tokenLength: wcwidth(command.slice(readingIdx)),
+                complete: false,
+                isOption: false,
+                isQuoted: true,
+                isQuoteContinued: true,
+            });
+        }
+        else {
+            tokens.push({
+                token: command.slice(readingIdx),
+                tokenLength: wcwidth(command.slice(readingIdx)),
+                complete: false,
+                isOption: readingFlag,
+            });
+        }
     }
     return tokens;
 };