@travisennis/acai 0.0.9 → 0.0.11

package/dist/utils/bash/parse.js

@@ -0,0 +1,223 @@
+// '<(' is process substitution operator and
+// can be parsed the same as control operator
+const CONTROL = `(?:${[
+    "\\|\\|",
+    "\\&\\&",
+    ";;",
+    "\\|\\&",
+    "\\<\\(",
+    "\\<\\<\\<",
+    ">>",
+    ">\\&",
+    "<\\&",
+    "[&;()|<>]",
+].join("|")})`;
+const controlRe = new RegExp(`^${CONTROL}$`);
+const META = "|&;()<> \t";
+const SINGLE_QUOTE = '"((\\\\"|[^"])*?)"';
+const DOUBLE_QUOTE = "'((\\\\'|[^'])*?)'";
+const hash = /^#$/;
+const SQ = "'";
+const DQ = '"';
+const DS = "$";
+let Token = "";
+const mult = 0x100000000; // Math.pow(16, 8);
+for (let i = 0; i < 4; i++) {
+    Token += (mult * Math.random()).toString(16);
+}
+const startsWithToken = new RegExp(`^${Token}`);
+function matchAll(s, r) {
+    const origIndex = r.lastIndex;
+    const matches = [];
+    let matchObj = r.exec(s);
+    while (matchObj !== null) {
+        matches.push(matchObj);
+        if (r.lastIndex === matchObj.index) {
+            r.lastIndex += 1;
+        }
+        matchObj = r.exec(s);
+    }
+    r.lastIndex = origIndex;
+    return matches;
+}
+function getVar(env, pre, key) {
+    let r = typeof env === "function" ? env(key) : env[key];
+    if (typeof r === "undefined" && key !== "") {
+        r = "";
+    }
+    else if (typeof r === "undefined") {
+        r = "$";
+    }
+    if (typeof r === "object") {
+        return pre + Token + JSON.stringify(r) + Token;
+    }
+    return pre + String(r);
+}
+function parseInternal(string, env, opts = {}) {
+    const Bs = opts.escape || "\\";
+    const Bareword = `(\\${Bs}["'${META}]|[^\\s'""${META}])+`;
+    const chunker = new RegExp([
+        `(${CONTROL})`, // control chars
+        `(${Bareword}|${SINGLE_QUOTE}|${DOUBLE_QUOTE})+`,
+    ].join("|"), "g");
+    const matches = matchAll(string, chunker);
+    if (matches.length === 0) {
+        return [];
+    }
+    const envToUse = env ?? {};
+    let commented = false;
+    return matches
+        .map(
+    // biome-ignore lint:noExcessiveCognitiveComplexity
+    (match) => {
+        const s = match[0];
+        if (!s || commented) {
+            return undefined;
+        }
+        if (controlRe.test(s)) {
+            return { op: s };
+        }
+        // Hand-written scanner/parser for Bash quoting rules:
+        //
+        // 1. inside single quotes, all characters are printed literally.
+        // 2. inside double quotes, all characters are printed literally
+        //    except variables prefixed by '$' and backslashes followed by
+        //    either a double quote or another backslash.
+        // 3. outside of any quotes, backslashes are treated as escape
+        //    characters and not printed (unless they are themselves escaped)
+        // 4. quote context can switch mid-token if there is no whitespace
+        //     between the two quote contexts (e.g. all'one'"token" parses as
+        //     "allonetoken")
+        let quote = false;
+        let esc = false;
+        let out = "";
+        let isGlob = false;
+        let i = 0;
+        function parseEnvVar() {
+            i += 1;
+            let varend;
+            let varname;
+            const char = s.charAt(i);
+            if (char === "{") {
+                i += 1;
+                if (s.charAt(i) === "}") {
+                    throw new Error(`Bad substitution: ${s.slice(i - 2, i + 1)}`);
+                }
+                varend = s.indexOf("}", i);
+                if (varend < 0) {
+                    throw new Error(`Bad substitution: ${s.slice(i)}`);
+                }
+                varname = s.slice(i, varend);
+                i = varend;
+            }
+            else if (/[*@#?$!_-]/.test(char)) {
+                varname = char;
+                i += 1;
+            }
+            else {
+                const slicedFromI = s.slice(i);
+                const varendMatch = slicedFromI.match(/[^\w\d_]/);
+                if (!varendMatch) {
+                    varname = slicedFromI;
+                    i = s.length;
+                }
+                else {
+                    varname = slicedFromI.slice(0, varendMatch.index);
+                    i += (varendMatch.index ?? 0) - 1;
+                }
+            }
+            return getVar(envToUse, "", varname);
+        }
+        for (i = 0; i < s.length; i++) {
+            const c = s.charAt(i);
+            isGlob = isGlob || (!quote && (c === "*" || c === "?"));
+            if (esc) {
+                out += c;
+                esc = false;
+            }
+            else if (quote) {
+                if (c === quote) {
+                    quote = false;
+                }
+                else if (quote === SQ) {
+                    out += c;
+                }
+                else {
+                    // Double quote
+                    if (c === Bs) {
+                        i += 1;
+                        const charAtI = s.charAt(i);
+                        if (charAtI === DQ || charAtI === Bs || charAtI === DS) {
+                            out += charAtI;
+                        }
+                        else {
+                            out += Bs + charAtI;
+                        }
+                    }
+                    else if (c === DS) {
+                        out += parseEnvVar();
+                    }
+                    else {
+                        out += c;
+                    }
+                }
+            }
+            else if (c === DQ || c === SQ) {
+                quote = c;
+            }
+            else if (controlRe.test(c)) {
+                return { op: s };
+            }
+            else if (hash.test(c)) {
+                commented = true;
+                const matchIndex = match.index;
+                const commentObj = {
+                    comment: string.slice((matchIndex ?? 0) + i + 1),
+                };
+                if (out.length) {
+                    return [out, commentObj];
+                }
+                return [commentObj];
+            }
+            else if (c === Bs) {
+                esc = true;
+            }
+            else if (c === DS) {
+                out += parseEnvVar();
+            }
+            else {
+                out += c;
+            }
+        }
+        if (isGlob) {
+            return { op: "glob", pattern: out };
+        }
+        return out;
+    })
+        .reduce((prev, arg) => {
+        // TODO: replace this whole reduce with a concat
+        return typeof arg === "undefined" ? prev : prev.concat(arg);
+    }, []);
+}
+export function parse(s, env = {}, opts) {
+    const mapped = parseInternal(s, env, opts);
+    if (typeof env !== "function") {
+        return mapped;
+    }
+    return mapped.reduce((acc, s) => {
+        if (typeof s === "object") {
+            return acc.concat(s);
+        }
+        const xs = s.split(RegExp(`(${Token}.*?${Token})`, "g"));
+        if (xs.length === 1) {
+            return acc.concat(xs[0]);
+        }
+        return acc.concat(xs.filter(Boolean).map((x) => {
+            if (startsWithToken.test(x)) {
+                const parts = x.split(Token);
+                return JSON.parse(parts[1]);
+            }
+            return x;
+        }));
+    }, []);
+}

package/dist/utils/bash/quote.d.ts

@@ -0,0 +1,6 @@
+type QuoteArg = string | number | boolean | {
+    op: string;
+} | null | undefined;
+export declare function quote(xs: readonly QuoteArg[]): string;
+export {};
+//# sourceMappingURL=quote.d.ts.map

package/dist/utils/bash/quote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quote.d.ts","sourceRoot":"","sources":["../../../source/utils/bash/quote.ts"],"names":[],"mappings":"AAAA,KAAK,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,CAAC;AAE9E,wBAAgB,KAAK,CAAC,EAAE,EAAE,SAAS,QAAQ,EAAE,GAAG,MAAM,CAyBrD"}

package/dist/utils/bash/quote.js

@@ -0,0 +1,23 @@
+export function quote(xs) {
+    return xs
+        .map((s) => {
+        if (s === null || s === undefined) {
+            return String(s);
+        }
+        const str = String(s);
+        if (str === "") {
+            return "''";
+        }
+        if (s && typeof s === "object") {
+            return s.op.replace(/(.)/g, "\\$1");
+        }
+        if (/["\s\\]/.test(str) && !/'/.test(str)) {
+            return `'${str.replace(/(['])/g, "\\$1")}'`;
+        }
+        if (/["'\s]/.test(str)) {
+            return `"${str.replace(/(["\\$`!])/g, "\\$1")}"`;
+        }
+        return str.replace(/([A-Za-z]:)?([#!"$&'()*,:;<=>?@[\\\]^`{|}])/g, "$1\\$2");
+    })
+        .join(" ");
+}

package/dist/utils/bash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../source/utils/bash.ts"],"names":[],"mappings":"AAMA,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EAAE,EACrB,GAAG,EAAE,MAAM,GACV;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CA0EtC;AAED,eAAO,MAAM,UAAU,GACrB,UAAU,MAAM,GAAG,IAAI,GAAG,SAAS,EACnC,YAAY,MAAM,EAClB,cAAc,MAAM,EAAE,KACrB,MAkEF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,KAAG,OAmHtD,CAAC"}
+{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../source/utils/bash.ts"],"names":[],"mappings":"AAuJA,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EAAE,EACrB,GAAG,EAAE,MAAM,GACV;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAiDtC;AAED,eAAO,MAAM,UAAU,GACrB,UAAU,MAAM,GAAG,IAAI,GAAG,SAAS,EACnC,YAAY,MAAM,EAClB,cAAc,MAAM,EAAE,KACrB,MAkEF,CAAC;AA6FF,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,KAAG,OAetD,CAAC"}

package/dist/utils/bash.js

@@ -2,63 +2,158 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { isPathWithinAllowedDirs } from "./filesystem/security.js";
-// Validate path arguments to ensure they're within the project
-export function validatePaths(command, allowedDirs, cwd) {
-    // Simple tokenization - split on spaces but respect quotes
-    const tokens = [];
-    let current = "";
-    let inQuotes = false;
-    let quoteChar = "";
-    for (let i = 0; i < command.length; i++) {
-        const char = command[i] ?? "";
-        if ((char === '"' || char === "'") && !inQuotes) {
-            inQuotes = true;
-            quoteChar = char;
-            current += char;
+function handleNormalMode(state, char, command, tokens) {
+    if (/\s/.test(char)) {
+        if (state.current) {
+            tokens.push(state.current);
+            state.current = "";
         }
-        else if (char === quoteChar && inQuotes) {
-            inQuotes = false;
-            quoteChar = "";
-            current += char;
+        return;
+    }
+    if (char === "'") {
+        state.mode = "single";
+        state.current += char;
+        return;
+    }
+    if (char === '"') {
+        state.mode = "double";
+        state.current += char;
+        return;
+    }
+    if (char === "\\") {
+        const next = command[state.i + 1];
+        if (next !== undefined) {
+            state.current += char + next;
+            state.i++;
+            return;
         }
-        else if (char === " " && !inQuotes) {
-            if (current) {
-                tokens.push(current);
-                current = "";
-            }
+    }
+    state.current += char;
+}
+function handleSingleQuoteMode(state, char) {
+    state.current += char;
+    if (char === "'")
+        state.mode = "normal";
+}
+function handleDoubleQuoteMode(state, char, command) {
+    state.current += char;
+    if (char === "\\") {
+        const next = command[state.i + 1];
+        if (next !== undefined) {
+            state.current += next;
+            state.i++;
         }
-        else {
-            current += char;
+        return;
+    }
+    if (char === '"')
+        state.mode = "normal";
+}
+// Tokenize shell command respecting quotes and escapes
+function tokenizeShellWords(command) {
+    const tokens = [];
+    const state = { current: "", mode: "normal", i: 0 };
+    for (state.i = 0; state.i < command.length; state.i++) {
+        const char = command[state.i] ?? "";
+        if (state.mode === "normal")
+            handleNormalMode(state, char, command, tokens);
+        else if (state.mode === "single")
+            handleSingleQuoteMode(state, char);
+        else
+            handleDoubleQuoteMode(state, char, command);
+    }
+    if (state.current)
+        tokens.push(state.current);
+    return tokens;
+}
+// Strip surrounding quotes from a token
+function stripQuotes(token) {
+    if ((token.startsWith('"') && token.endsWith('"')) ||
+        (token.startsWith("'") && token.endsWith("'"))) {
+        return token.slice(1, -1);
+    }
+    return token;
+}
+// Check if a token is fully quoted (content should not be path-validated)
+function isFullyQuoted(token) {
+    if (token.length < 2)
+        return false;
+    const first = token[0];
+    const last = token[token.length - 1];
+    return (first === '"' && last === '"') || (first === "'" && last === "'");
+}
+// Compute which tokens should be skipped from path validation
+function computeSkipTokenMask(tokens) {
+    const skip = new Array(tokens.length).fill(false);
+    const bin = stripQuotes(tokens[0] ?? "");
+    const sub = stripQuotes(tokens[1] ?? "");
+    // Commands where -m/--message is a string argument (not a path)
+    const gitMessageSubs = new Set(["commit", "merge", "tag", "revert", "notes"]);
+    if (bin === "git" && gitMessageSubs.has(sub)) {
+        let seenDoubleDash = false;
+        for (let i = 2; i < tokens.length; i++) {
+            const t = stripQuotes(tokens[i] ?? "");
+            if (t === "--") {
+                seenDoubleDash = true;
+                continue;
+            }
+            if (seenDoubleDash)
+                continue;
+            // --message=<msg> - skip this entire token
+            if (t.startsWith("--message=")) {
+                skip[i] = true;
+                continue;
+            }
+            // -m<msg> (attached message) - skip this entire token
+            if (/^-m.+/.test(t)) {
+                skip[i] = true;
+                continue;
+            }
+            // -m or --message consumes next token
+            if (t === "-m" || t === "--message") {
+                if (i + 1 < tokens.length)
+                    skip[i + 1] = true;
+                continue;
+            }
+            // Combined short opts containing m, e.g. -am, -avm
+            if (/^-[^-]+$/.test(t) && t.includes("m")) {
+                if (i + 1 < tokens.length)
+                    skip[i + 1] = true;
+            }
         }
     }
-    if (current)
-        tokens.push(current);
+    return skip;
+}
+// Validate path arguments to ensure they're within the project
+export function validatePaths(command, allowedDirs, cwd) {
+    const tokens = tokenizeShellWords(command);
+    const skip = computeSkipTokenMask(tokens);
     // Check each token that looks like a path
     for (let i = 1; i < tokens.length; i++) {
-        // Skip the command itself
         const token = tokens[i];
         if (!token)
             continue;
+        // Skip tokens marked by command-aware logic
+        if (skip[i])
+            continue;
+        // Skip fully quoted tokens - they're string arguments, not paths
+        // (paths are typically unquoted or only quoted to handle spaces)
+        if (isFullyQuoted(token) && token.includes("\n")) {
+            continue;
+        }
         // Remove quotes for path checking
-        const cleanToken = token.replace(/^['"]|['"]$/g, "");
+        const cleanToken = stripQuotes(token);
         // Skip if it's clearly not a path
         if (cleanToken.startsWith("-") ||
             cleanToken.includes("://") ||
             (!cleanToken.includes("/") && cleanToken !== "~")) {
             continue;
         }
-        // Skip git commit messages and other special cases
-        const prevToken = tokens[i - 1]?.replace(/^['"]|['"]$/g, "");
-        if (prevToken === "-m" || prevToken === "--message") {
-            continue;
-        }
         try {
             // Expand ~ to home directory for proper validation
             const expandedToken = cleanToken.startsWith("~/") || cleanToken === "~"
                 ? path.join(os.homedir(), cleanToken.slice(1))
                 : cleanToken;
             const resolvedPath = path.resolve(cwd, expandedToken);
-            // Allow access to explicitly allowed paths
             if (!isPathWithinAllowedDirs(resolvedPath, allowedDirs)) {
                 return {
                     isValid: false,
@@ -125,6 +220,87 @@ export const resolveCwd = (cwdInput, workingDir, allowedDirs) => {
     }
     return target;
 };
+const mutatingBinaries = new Set([
+    "rm",
+    "mv",
+    "cp",
+    "mkdir",
+    "rmdir",
+    "touch",
+    "chmod",
+    "chown",
+    "ln",
+    "truncate",
+    "dd",
+    "tee",
+]);
+const npmMutating = new Set([
+    "install",
+    "uninstall",
+    "update",
+    "ci",
+    "publish",
+    "link",
+    "dedupe",
+    "prune",
+    "rebuild",
+    "add",
+]);
+const gitMutating = new Set([
+    "add",
+    "am",
+    "apply",
+    "branch",
+    "checkout",
+    "switch",
+    "cherry-pick",
+    "clean",
+    "commit",
+    "merge",
+    "mv",
+    "pull",
+    "push",
+    "rebase",
+    "reset",
+    "revert",
+    "stash",
+    "tag",
+    "worktree",
+    "submodule",
+    "config",
+]);
+const actionMutating = new Set(["create", "update", "upgrade", "install"]);
+const packageManagers = new Set(["npm", "pnpm", "yarn"]);
+function isSegmentMutating(seg) {
+    const tokens = seg.split(/\s+/);
+    if (tokens.length === 0)
+        return false;
+    const bin = tokens[0];
+    if (!bin)
+        return false;
+    if (tokens.some((t) => actionMutating.has(t))) {
+        return true;
+    }
+    if (bin === "sed" && tokens.some((t) => /^-i/.test(t))) {
+        return true;
+    }
+    if (mutatingBinaries.has(bin)) {
+        return true;
+    }
+    if (bin === "git" && tokens.length > 1) {
+        const sub = tokens[1];
+        if (typeof sub === "string" && gitMutating.has(sub)) {
+            return true;
+        }
+    }
+    if (packageManagers.has(bin) && tokens.length > 1) {
+        const sub = tokens[1];
+        if (typeof sub === "string" && npmMutating.has(sub)) {
+            return true;
+        }
+    }
+    return false;
+}
 export const isMutatingCommand = (rawCommand) => {
     const command = rawCommand.trim();
     // Redirections that write to disk
@@ -136,96 +312,5 @@ export const isMutatingCommand = (rawCommand) => {
         .split(/\s*(?:&&|\|\||;|\|)\s*/)
         .map((s) => s.trim())
         .filter((s) => s.length > 0);
-    const mutatingBinaries = new Set([
-        "rm",
-        "mv",
-        "cp",
-        "mkdir",
-        "rmdir",
-        "touch",
-        "chmod",
-        "chown",
-        "ln",
-        "truncate",
-        "dd",
-        "tee",
-    ]);
-    const npmMutating = new Set([
-        "install",
-        "uninstall",
-        "update",
-        "ci",
-        "publish",
-        "link",
-        "dedupe",
-        "prune",
-        "rebuild",
-        "add",
-    ]);
-    const gitMutating = new Set([
-        "add",
-        "am",
-        "apply",
-        "branch",
-        "checkout",
-        "switch",
-        "cherry-pick",
-        "clean",
-        "commit",
-        "merge",
-        "mv",
-        "pull",
-        "push",
-        "rebase",
-        "reset",
-        "revert",
-        "stash",
-        "tag",
-        "worktree",
-        "submodule",
-        "config",
-    ]);
-    // Generic action words that should be considered mutating when present in the command
-    const actionMutating = new Set(["create", "update", "upgrade", "install"]);
-    for (const seg of segments) {
-        const tokens = seg.split(/\s+/);
-        if (tokens.length === 0)
-            continue;
-        const bin = tokens[0];
-        if (!bin)
-            continue;
-        // If any token is an action-like mutating word, consider mutating
-        if (tokens.some((t) => actionMutating.has(t))) {
-            return true;
-        }
-        // sed -i is mutating
-        if (bin === "sed") {
-            if (tokens.some((t) => /^-i/.test(t))) {
-                return true;
-            }
-            // sed without -i is not mutating
-        }
-        if (mutatingBinaries.has(bin)) {
-            return true;
-        }
-        if (bin === "git" && tokens.length > 1) {
-            const sub = tokens[1];
-            if (typeof sub === "string" && gitMutating.has(sub)) {
-                return true;
-            }
-        }
-        if (bin === "npm" && tokens.length > 1) {
-            const sub = tokens[1];
-            if (typeof sub === "string" && npmMutating.has(sub)) {
-                return true;
-            }
-        }
-        if ((bin === "pnpm" || bin === "yarn") && tokens.length > 1) {
-            const sub = tokens[1];
-            if (typeof sub === "string" && npmMutating.has(sub)) {
-                return true;
-            }
-        }
-    }
-    return false;
+    return segments.some((seg) => isSegmentMutating(seg));
 };

package/dist/utils/command-protection.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Command Protection Module
+ * Detects and blocks destructive commands that could cause data loss
+ */
+export interface BlockedCommandResult {
+    blocked: true;
+    reason: string;
+    command: string;
+    tip: string;
+}
+export interface SafeCommandResult {
+    blocked: false;
+}
+/**
+ * Result type for command safety check
+ */
+export type CommandSafetyResult = BlockedCommandResult | SafeCommandResult;
+/**
+ * Detects if a command is destructive and should be blocked
+ * @param command - The full command string to check
+ * @returns BlockedCommandResult if destructive, SafeCommandResult if safe
+ */
+export declare function detectDestructiveCommand(command: string): CommandSafetyResult;
+/**
+ * Generate a user-friendly blocked command message
+ */
+export declare function formatBlockedCommandMessage(result: BlockedCommandResult): string;
+//# sourceMappingURL=command-protection.d.ts.map

package/dist/utils/command-protection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-protection.d.ts","sourceRoot":"","sources":["../../source/utils/command-protection.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,IAAI,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,KAAK,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,oBAAoB,GAAG,iBAAiB,CAAC;AAE3E;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,mBAAmB,CA4B7E;AA8UD;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,oBAAoB,GAC3B,MAAM,CAQR"}