plugsuits 1.0.0

package/src/tools/utils/execute/noninteractive-wrapper.test.ts

@@ -0,0 +1,306 @@
+import { describe, expect, it } from "bun:test";
+import {
+  buildEnvPrefix,
+  getFullWrappedCommand,
+  wrapCommandNonInteractive,
+} from "./noninteractive-wrapper";
+
+const DUPLICATE_Y_FLAG = /-y.*-y/;
+
+describe("wrapCommandNonInteractive", () => {
+  describe("apt/apt-get commands", () => {
+    it("wraps apt-get install with DEBIAN_FRONTEND and -y", () => {
+      const result = wrapCommandNonInteractive("apt-get install nginx");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("apt");
+      expect(result.env.DEBIAN_FRONTEND).toBe("noninteractive");
+      expect(result.command).toContain("-y");
+    });
+
+    it("wraps sudo apt-get install", () => {
+      const result = wrapCommandNonInteractive("sudo apt-get install nginx");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("apt");
+      expect(result.env.DEBIAN_FRONTEND).toBe("noninteractive");
+    });
+
+    it("wraps apt install", () => {
+      const result = wrapCommandNonInteractive("apt install curl");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("apt");
+    });
+
+    it("does not duplicate -y flag if already present", () => {
+      const result = wrapCommandNonInteractive("apt-get install -y nginx");
+
+      expect(result.command).not.toMatch(DUPLICATE_Y_FLAG);
+    });
+  });
+
+  describe("git commands", () => {
+    it("wraps git clone with GIT_TERMINAL_PROMPT=0", () => {
+      const result = wrapCommandNonInteractive(
+        "git clone https://github.com/user/repo"
+      );
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("git");
+      expect(result.env.GIT_TERMINAL_PROMPT).toBe("0");
+      expect(result.env.GIT_SSH_COMMAND).toContain("BatchMode=yes");
+    });
+
+    it("wraps git fetch", () => {
+      const result = wrapCommandNonInteractive("git fetch origin");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("git");
+    });
+
+    it("wraps git pull", () => {
+      const result = wrapCommandNonInteractive("git pull");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("git");
+    });
+
+    it("wraps git push", () => {
+      const result = wrapCommandNonInteractive("git push origin main");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("git");
+    });
+
+    it("does not wrap git status", () => {
+      const result = wrapCommandNonInteractive("git status");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBeNull();
+      expect(result.command).toBe("git status");
+      expect(result.env.CI).toBe("true");
+    });
+
+    it("does not wrap git log", () => {
+      const result = wrapCommandNonInteractive("git log --oneline");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBeNull();
+      expect(result.command).toBe("git log --oneline");
+      expect(result.env.CI).toBe("true");
+    });
+  });
+
+  describe("ssh/scp commands", () => {
+    it("wraps ssh with BatchMode", () => {
+      const result = wrapCommandNonInteractive("ssh user@host");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("ssh");
+      expect(result.command).toContain("BatchMode=yes");
+    });
+
+    it("wraps scp with BatchMode", () => {
+      const result = wrapCommandNonInteractive("scp file.txt user@host:/path");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("scp");
+      expect(result.command).toContain("BatchMode=yes");
+    });
+  });
+
+  describe("npm/yarn/pnpm/bun commands", () => {
+    it("wraps npm install with CI=true", () => {
+      const result = wrapCommandNonInteractive("npm install");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("npm");
+      expect(result.env.CI).toBe("true");
+    });
+
+    it("wraps yarn install with --non-interactive", () => {
+      const result = wrapCommandNonInteractive("yarn install");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("yarn");
+      expect(result.command).toContain("--non-interactive");
+    });
+
+    it("wraps pnpm install with CI=true", () => {
+      const result = wrapCommandNonInteractive("pnpm install");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("pnpm");
+      expect(result.env.CI).toBe("true");
+    });
+
+    it("wraps bun install with CI=true", () => {
+      const result = wrapCommandNonInteractive("bun install");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("bun");
+      expect(result.env.CI).toBe("true");
+    });
+  });
+
+  describe("pip commands", () => {
+    it("wraps pip install with PIP_NO_INPUT=1", () => {
+      const result = wrapCommandNonInteractive("pip install requests");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("pip");
+      expect(result.env.PIP_NO_INPUT).toBe("1");
+    });
+
+    it("wraps pip3 install", () => {
+      const result = wrapCommandNonInteractive("pip3 install flask");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("pip");
+    });
+  });
+
+  describe("package managers with -y flag", () => {
+    it("wraps yum with -y", () => {
+      const result = wrapCommandNonInteractive("yum install httpd");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("yum");
+      expect(result.command).toContain("-y");
+    });
+
+    it("wraps dnf with -y", () => {
+      const result = wrapCommandNonInteractive("dnf install nginx");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("dnf");
+      expect(result.command).toContain("-y");
+    });
+
+    it("wraps pacman with --noconfirm", () => {
+      const result = wrapCommandNonInteractive("pacman -S nginx");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("pacman");
+      expect(result.command).toContain("--noconfirm");
+    });
+  });
+
+  describe("brew commands", () => {
+    it("wraps brew install with NONINTERACTIVE=1", () => {
+      const result = wrapCommandNonInteractive("brew install wget");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("brew");
+      expect(result.env.NONINTERACTIVE).toBe("1");
+      expect(result.env.HOMEBREW_NO_AUTO_UPDATE).toBe("1");
+    });
+  });
+
+  describe("terraform commands", () => {
+    it("wraps terraform apply with -auto-approve", () => {
+      const result = wrapCommandNonInteractive("terraform apply");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("terraform");
+      expect(result.command).toContain("-auto-approve");
+    });
+
+    it("wraps terraform destroy with -auto-approve", () => {
+      const result = wrapCommandNonInteractive("terraform destroy");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBe("terraform");
+      expect(result.command).toContain("-auto-approve");
+    });
+
+    it("does not wrap terraform plan", () => {
+      const result = wrapCommandNonInteractive("terraform plan");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBeNull();
+      expect(result.command).toBe("terraform plan");
+      expect(result.env.CI).toBe("true");
+    });
+  });
+
+  describe("unrecognized commands", () => {
+    it("does not wrap unknown commands", () => {
+      const result = wrapCommandNonInteractive("echo hello");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBeNull();
+      expect(result.command).toBe("echo hello");
+      expect(result.env.CI).toBe("true");
+    });
+
+    it("does not wrap ls command", () => {
+      const result = wrapCommandNonInteractive("ls -la");
+
+      expect(result.wrapped).toBe(true);
+      expect(result.tool).toBeNull();
+      expect(result.command).toBe("ls -la");
+      expect(result.env.CI).toBe("true");
+    });
+
+    it("does not inherit arbitrary process environment variables", () => {
+      process.env.CEA_TEST_RANDOM_ENV = "should-not-propagate";
+
+      try {
+        const result = wrapCommandNonInteractive("echo hello");
+        expect(result.env.CEA_TEST_RANDOM_ENV).toBeUndefined();
+      } finally {
+        process.env.CEA_TEST_RANDOM_ENV = undefined;
+      }
+    });
+  });
+});
+
+describe("buildEnvPrefix", () => {
+  it("returns empty string for empty env", () => {
+    const result = buildEnvPrefix({});
+
+    expect(result).toBe("");
+  });
+
+  it("builds single env var prefix", () => {
+    const result = buildEnvPrefix({ CI: "true" });
+
+    expect(result).toBe("CI='true' ");
+  });
+
+  it("builds multiple env var prefix", () => {
+    const result = buildEnvPrefix({
+      DEBIAN_FRONTEND: "noninteractive",
+      CI: "true",
+    });
+
+    expect(result).toContain("DEBIAN_FRONTEND='noninteractive'");
+    expect(result).toContain("CI='true'");
+    expect(result).toEndWith(" ");
+  });
+});
+
+describe("getFullWrappedCommand", () => {
+  it("returns full command with env prefix for apt", () => {
+    const result = getFullWrappedCommand("apt-get install nginx");
+
+    expect(result).toContain("DEBIAN_FRONTEND='noninteractive'");
+    expect(result).toContain("apt-get install nginx");
+    expect(result).toContain("-y");
+  });
+
+  it("returns original command for unrecognized commands", () => {
+    const result = getFullWrappedCommand("echo hello");
+
+    expect(result).toContain("CI='true'");
+    expect(result).toContain("echo hello");
+  });
+
+  it("keeps wrapped command length compact", () => {
+    const result = getFullWrappedCommand("echo hello");
+
+    expect(result.length).toBeLessThan(1000);
+  });
+});

package/src/tools/utils/execute/noninteractive-wrapper.ts

@@ -0,0 +1,314 @@
+import { platform } from "node:os";
+
+interface WrapperResult {
+  command: string;
+  description: string | null;
+  env: Record<string, string>;
+  tool: string | null;
+  wrapped: boolean;
+}
+
+interface ToolPattern {
+  description: string;
+  env: Record<string, string>;
+  name: string;
+  pattern: RegExp;
+  prefixArgs?: string[];
+  suffixArgs?: string[];
+}
+
+const TOOL_PATTERNS: ToolPattern[] = [
+  {
+    pattern: /^(sudo\s+)?(apt-get|apt)\s+/,
+    name: "apt",
+    env: { DEBIAN_FRONTEND: "noninteractive" },
+    suffixArgs: ["-y"],
+    description: "Debian/Ubuntu package manager (non-interactive mode)",
+  },
+  {
+    pattern: /^(sudo\s+)?dpkg\s+/,
+    name: "dpkg",
+    env: { DEBIAN_FRONTEND: "noninteractive" },
+    description: "Debian package manager (non-interactive mode)",
+  },
+  {
+    pattern: /^git\s+(clone|fetch|pull|push|submodule)/,
+    name: "git",
+    env: {
+      GIT_TERMINAL_PROMPT: "0",
+      GIT_SSH_COMMAND:
+        "ssh -o BatchMode=yes -o StrictHostKeyChecking=accept-new",
+    },
+    description: "Git operations (no TTY prompts)",
+  },
+  {
+    pattern: /^ssh\s+/,
+    name: "ssh",
+    env: {},
+    prefixArgs: [
+      "-o",
+      "BatchMode=yes",
+      "-o",
+      "StrictHostKeyChecking=accept-new",
+    ],
+    description: "SSH connection (batch mode, no prompts)",
+  },
+  {
+    pattern: /^scp\s+/,
+    name: "scp",
+    env: {},
+    prefixArgs: [
+      "-o",
+      "BatchMode=yes",
+      "-o",
+      "StrictHostKeyChecking=accept-new",
+    ],
+    description: "SCP transfer (batch mode, no prompts)",
+  },
+  {
+    pattern: /^(pip|pip3)\s+install/,
+    name: "pip",
+    env: { PIP_NO_INPUT: "1" },
+    description: "Python pip (no input mode)",
+  },
+  {
+    pattern: /^npm\s+(install|ci|update)/,
+    name: "npm",
+    env: { CI: "true", npm_config_yes: "true" },
+    description: "npm package manager (CI mode)",
+  },
+  {
+    pattern: /^yarn\s+(install|add)/,
+    name: "yarn",
+    env: { CI: "true" },
+    suffixArgs: ["--non-interactive"],
+    description: "Yarn package manager (non-interactive)",
+  },
+  {
+    pattern: /^pnpm\s+(install|add)/,
+    name: "pnpm",
+    env: { CI: "true" },
+    description: "pnpm package manager (CI mode)",
+  },
+  {
+    pattern: /^bun\s+(install|add)/,
+    name: "bun",
+    env: { CI: "true" },
+    description: "Bun package manager (CI mode)",
+  },
+  {
+    pattern: /^(sudo\s+)?yum\s+/,
+    name: "yum",
+    env: {},
+    suffixArgs: ["-y"],
+    description: "YUM package manager (assume yes)",
+  },
+  {
+    pattern: /^(sudo\s+)?dnf\s+/,
+    name: "dnf",
+    env: {},
+    suffixArgs: ["-y"],
+    description: "DNF package manager (assume yes)",
+  },
+  {
+    pattern: /^(sudo\s+)?pacman\s+/,
+    name: "pacman",
+    env: {},
+    suffixArgs: ["--noconfirm"],
+    description: "Pacman package manager (no confirm)",
+  },
+  {
+    pattern: /^(sudo\s+)?apk\s+/,
+    name: "apk",
+    env: {},
+    description: "Alpine package manager (non-interactive by default)",
+  },
+  {
+    pattern: /^brew\s+(install|upgrade|update)/,
+    name: "brew",
+    env: {
+      HOMEBREW_NO_AUTO_UPDATE: "1",
+      NONINTERACTIVE: "1",
+    },
+    description: "Homebrew (non-interactive mode)",
+  },
+  {
+    pattern: /^composer\s+(install|update|require)/,
+    name: "composer",
+    env: { COMPOSER_NO_INTERACTION: "1" },
+    description: "PHP Composer (no interaction)",
+  },
+  {
+    pattern: /^cargo\s+(install|build)/,
+    name: "cargo",
+    env: {},
+    description: "Rust Cargo (non-interactive by default)",
+  },
+  {
+    pattern: /^go\s+(get|install|mod)/,
+    name: "go",
+    env: {},
+    description: "Go modules (non-interactive by default)",
+  },
+  {
+    pattern: /^gem\s+install/,
+    name: "gem",
+    env: {},
+    suffixArgs: ["--no-document"],
+    description: "Ruby Gem (skip documentation prompts)",
+  },
+  {
+    pattern: /^docker\s+(build|pull|push)/,
+    name: "docker",
+    env: { DOCKER_CLI_HINTS: "false" },
+    description: "Docker operations (no hints)",
+  },
+  {
+    pattern: /^ansible(-playbook)?\s+/,
+    name: "ansible",
+    env: { ANSIBLE_HOST_KEY_CHECKING: "False" },
+    description: "Ansible (skip host key checking)",
+  },
+  {
+    pattern: /^terraform\s+(apply|destroy)/,
+    name: "terraform",
+    env: {},
+    suffixArgs: ["-auto-approve"],
+    description: "Terraform (auto-approve)",
+  },
+  {
+    pattern: /^kubectl\s+(delete|apply)/,
+    name: "kubectl",
+    env: {},
+    description: "Kubernetes kubectl (non-interactive by default)",
+  },
+  {
+    pattern: /^mysql\s+/,
+    name: "mysql",
+    env: {},
+    prefixArgs: ["--batch"],
+    description: "MySQL client (batch mode)",
+  },
+  {
+    pattern: /^psql\s+/,
+    name: "psql",
+    env: {},
+    description: "PostgreSQL client (non-interactive by default with -c)",
+  },
+];
+
+const WHITESPACE_SPLIT_PATTERN = /\s+/;
+
+function hasFlag(command: string, flag: string): boolean {
+  return command.split(WHITESPACE_SPLIT_PATTERN).includes(flag);
+}
+
+function insertArgsAfterCommand(
+  command: string,
+  toolPattern: RegExp,
+  args: string[]
+): string {
+  const match = command.match(toolPattern);
+  if (!match) {
+    return command;
+  }
+
+  const matchEnd = (match.index ?? 0) + match[0].length;
+  const before = command.slice(0, matchEnd);
+  const after = command.slice(matchEnd);
+
+  return `${before}${args.join(" ")} ${after}`.replace(/\s+/g, " ").trim();
+}
+
+function appendArgs(command: string, args: string[]): string {
+  const argsToAdd = args.filter((arg) => !hasFlag(command, arg));
+  if (argsToAdd.length === 0) {
+    return command;
+  }
+  return `${command} ${argsToAdd.join(" ")}`;
+}
+
+function getBaseEnv(): Record<string, string> {
+  const locale = process.env.LC_ALL ?? process.env.LANG ?? "en_US.UTF-8";
+
+  const baseEnv: Record<string, string> = {
+    CI: "true",
+    NONINTERACTIVE: "1",
+    NO_TTY: "1",
+    NO_COLOR: "1",
+  };
+
+  if (isWindows()) {
+    baseEnv.GIT_PAGER = "more";
+    baseEnv.PAGER = "more";
+  } else {
+    baseEnv.TERM = "dumb";
+    baseEnv.DEBIAN_FRONTEND = "noninteractive";
+    baseEnv.GIT_PAGER = "cat";
+    baseEnv.PAGER = "cat";
+    baseEnv.LESS = "-FX";
+    baseEnv.LC_ALL = locale;
+  }
+
+  return baseEnv;
+}
+
+export function wrapCommandNonInteractive(command: string): WrapperResult {
+  const trimmedCommand = command.trim();
+
+  for (const tool of TOOL_PATTERNS) {
+    if (tool.pattern.test(trimmedCommand)) {
+      let wrappedCommand = trimmedCommand;
+      const baseEnv = getBaseEnv();
+      const env: Record<string, string> = { ...baseEnv, ...tool.env };
+
+      if (tool.prefixArgs && tool.prefixArgs.length > 0) {
+        wrappedCommand = insertArgsAfterCommand(
+          wrappedCommand,
+          tool.pattern,
+          tool.prefixArgs
+        );
+      }
+
+      if (tool.suffixArgs && tool.suffixArgs.length > 0) {
+        wrappedCommand = appendArgs(wrappedCommand, tool.suffixArgs);
+      }
+
+      return {
+        command: wrappedCommand,
+        env,
+        wrapped: true,
+        tool: tool.name,
+        description: tool.description,
+      };
+    }
+  }
+
+  return {
+    command: trimmedCommand,
+    env: getBaseEnv(),
+    wrapped: true,
+    tool: null,
+    description: "Base environment variables applied",
+  };
+}
+
+export function buildEnvPrefix(env: Record<string, string>): string {
+  if (Object.keys(env).length === 0) {
+    return "";
+  }
+
+  return `${Object.entries(env)
+    .map(([key, value]) => `${key}='${value.replace(/'/g, "'\\''")}'`)
+    .join(" ")} `;
+}
+
+export function getFullWrappedCommand(command: string): string {
+  const result = wrapCommandNonInteractive(command);
+  const envPrefix = buildEnvPrefix(result.env);
+  return `${envPrefix}${result.command}`;
+}
+
+function isWindows(): boolean {
+  return platform() === "win32";
+}

package/src/tools/utils/execute/output-handler.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync, unlinkSync } from "node:fs";
+import { sanitizeOutput, stripAnsi, truncateOutput } from "./output-handler";
+
+describe("stripAnsi", () => {
+  test("removes ANSI color codes", () => {
+    expect(stripAnsi("\x1b[31mred\x1b[0m")).toBe("red");
+  });
+});
+
+describe("sanitizeOutput", () => {
+  test("removes carriage returns and collapses blank lines", () => {
+    const output = "line1\r\nline2\r\n\r\n\r\n\r\nline3\r\n";
+
+    expect(sanitizeOutput(output)).toBe("line1\nline2\n\nline3\n");
+  });
+});
+
+describe("truncateOutput", () => {
+  test("returns original when within limits", async () => {
+    const output = "line1\nline2\nline3";
+
+    const result = await truncateOutput(output, {
+      maxLines: 10,
+      maxBytes: 100,
+    });
+
+    expect(result.truncated).toBe(false);
+    expect(result.text).toBe(output);
+    expect(result.originalLines).toBe(3);
+    expect(result.originalBytes).toBe(Buffer.byteLength(output));
+    expect(result.fullOutputPath).toBeUndefined();
+  });
+
+  test("truncates oversized line-based output and preserves tail", async () => {
+    const output = Array.from({ length: 3000 }, (_, i) => `line-${i + 1}`).join(
+      "\n"
+    );
+
+    const result = await truncateOutput(output);
+
+    expect(result.truncated).toBe(true);
+    expect(result.text.split("\n").length).toBeLessThanOrEqual(2000);
+    expect(result.text).toContain("line-3000");
+    expect(result.fullOutputPath).toBeDefined();
+  });
+
+  test("creates a temp file for truncated output", async () => {
+    const output = Array.from({ length: 3000 }, (_, i) => `line-${i + 1}`).join(
+      "\n"
+    );
+    const tempPaths: string[] = [];
+
+    try {
+      const result = await truncateOutput(output);
+      const fullOutputPath = result.fullOutputPath;
+
+      expect(fullOutputPath).toBeDefined();
+      if (!fullOutputPath) {
+        throw new Error("Expected fullOutputPath to be defined.");
+      }
+      expect(existsSync(fullOutputPath)).toBe(true);
+      tempPaths.push(fullOutputPath);
+    } finally {
+      for (const path of tempPaths) {
+        if (existsSync(path)) {
+          unlinkSync(path);
+        }
+      }
+    }
+  });
+});