@travisennis/acai 0.0.9 → 0.0.10

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"}