@travisennis/acai 0.0.1

package/source/tools/bash.ts

@@ -0,0 +1,367 @@
+import path from "node:path";
+import { input, select } from "@inquirer/prompts";
+import { tool } from "ai";
+import chalk from "chalk";
+import { z } from "zod";
+import { config } from "../config.ts";
+import type { Terminal } from "../terminal/index.ts";
+import type { TokenCounter } from "../token-utils.ts";
+import { executeCommand } from "../utils/process.ts";
+import { CommandValidation } from "./command-validation.ts";
+import type { SendData } from "./types.ts";
+
+export const BashTool = {
+  name: "bash" as const,
+};
+
+type Token = { raw: string; unquoted: string };
+
+function tokenize(inputStr: string): Token[] {
+  const tokens: Token[] = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < inputStr.length; i++) {
+    const ch: string = inputStr[i] as string;
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle;
+      current += ch;
+      continue;
+    }
+    if (ch === '"' && !inSingle) {
+      inDouble = !inDouble;
+      current += ch;
+      continue;
+    }
+    if (!inSingle && !inDouble && /\s/.test(ch)) {
+      if (current.length > 0) {
+        const raw = current;
+        const unquoted = raw.replace(/^['"]|['"]$/g, "");
+        tokens.push({ raw, unquoted });
+        current = "";
+      }
+      continue;
+    }
+    if (ch === "\\" && inDouble && i + 1 < inputStr.length) {
+      const next = inputStr[i + 1];
+      if (next === '"' || next === "\\") {
+        current += next;
+        i++;
+        continue;
+      }
+    }
+    current += ch;
+  }
+  if (current.length > 0) {
+    const raw = current;
+    const unquoted = raw.replace(/^['"]|['"]$/g, "");
+    tokens.push({ raw, unquoted });
+  }
+  return tokens;
+}
+
+function shouldSkipPathValidation(tokens: Token[], index: number): boolean {
+  if (index === 0) return false;
+  const cmd = tokens[0]?.unquoted;
+  if (cmd !== "git") return false;
+  const sub = tokens[1]?.unquoted;
+  if (
+    sub !== "commit" &&
+    sub !== "tag" &&
+    !(sub === "notes" && tokens[2]?.unquoted === "add")
+  ) {
+    return false;
+  }
+  const prev = tokens[index - 1]?.unquoted;
+  if (prev === "-m" || prev === "--message") return true;
+  return false;
+}
+
+function looksLikeUrl(str: string): boolean {
+  return str.startsWith("http://") || str.startsWith("https://");
+}
+
+// Whitelist of allowed commands
+const ALLOWED_COMMANDS = [
+  "chmod",
+  "ls",
+  "pwd",
+  "cat",
+  "grep",
+  "find",
+  "echo",
+  "mkdir",
+  "touch",
+  "cp",
+  "mv",
+  "pwd",
+  "wc",
+  "diff",
+  "sort",
+  "head",
+  "tail",
+  "sleep",
+  "npm",
+  "npx",
+  "node",
+  "git",
+  "gh",
+  "rg",
+  "jq",
+  "sed",
+  "awk",
+];
+
+// Command execution timeout in milliseconds
+const DEFAULT_TIMEOUT = 1.5 * 60 * 1000; // 1.5 minutes
+
+// Initialize command validator with allowed commands
+const commandValidator = new CommandValidation(ALLOWED_COMMANDS);
+
+// Ensure path is within base directory
+function isPathWithinBaseDir(requestedPath: string, baseDir: string): boolean {
+  const normalizedRequestedPath = path.normalize(requestedPath);
+  const normalizedBaseDir = path.normalize(baseDir);
+
+  return normalizedRequestedPath.startsWith(normalizedBaseDir);
+}
+
+export const createBashTool = ({
+  baseDir,
+  sendData,
+  tokenCounter,
+  terminal,
+  autoAcceptAll,
+}: {
+  baseDir: string;
+  sendData?: SendData | undefined;
+  tokenCounter: TokenCounter;
+  terminal?: Terminal;
+  autoAcceptAll: boolean;
+}) => {
+  let autoAcceptCommands = autoAcceptAll;
+  return {
+    [BashTool.name]: tool({
+      description: `Execute bash commands and return their output. Limited to a whitelist of safe commands: ${ALLOWED_COMMANDS.join(", ")}. Commands will only execute within the project directory for security. Always specify absolute paths to avoid errors.`,
+      inputSchema: z.object({
+        command: z
+          .string()
+          .describe(
+            "Full CLI command to execute. Must be from the allowed list without chaining operators.",
+          ),
+        cwd: z
+          .string()
+          .nullable()
+          .describe(
+            "Working directory (default: project root). Must be within the project directory.",
+          ),
+        timeout: z
+          .number()
+          .nullable()
+          .describe(
+            `Command execution timeout in milliseconds. Default: ${DEFAULT_TIMEOUT}ms`,
+          ),
+      }),
+      execute: async ({ command, cwd, timeout }, { toolCallId }) => {
+        // Guard against null cwd and timeout
+        const safeCwd = cwd == null ? baseDir : cwd;
+        const safeTimeout = timeout == null ? DEFAULT_TIMEOUT : timeout;
+
+        sendData?.({
+          event: "tool-init",
+          id: toolCallId,
+          data: `Executing: ${chalk.cyan(command)} in ${chalk.cyan(safeCwd)}`,
+        });
+
+        // Validate command using CommandValidation
+        if (!commandValidator.isValid(command)) {
+          const errorMsg = `Command not allowed. Ensure all sub-commands are in the approved list: ${ALLOWED_COMMANDS.join(", ")} and no unsafe operators (>, <, \`, $()) are used.`;
+          sendData?.({ event: "tool-error", id: toolCallId, data: errorMsg });
+          return errorMsg;
+        }
+
+        // Validate working directory
+        if (!isPathWithinBaseDir(safeCwd, baseDir)) {
+          const errorMsg = `Working directory must be within the project directory: ${baseDir}`;
+          sendData?.({ event: "tool-error", id: toolCallId, data: errorMsg });
+          return errorMsg;
+        }
+
+        // Validate command arguments for paths outside baseDir
+        const tokens = tokenize(command);
+        for (let i = 0; i < tokens.length; i++) {
+          const token = tokens[i];
+          if (token == null) continue;
+          const part = token.unquoted;
+
+          if (shouldSkipPathValidation(tokens, i)) {
+            continue;
+          }
+
+          if (looksLikeUrl(part)) {
+            continue;
+          }
+
+          if (
+            part.startsWith("/") ||
+            part.includes("../") ||
+            part.includes("./") ||
+            (part.includes("/") && !part.startsWith("-"))
+          ) {
+            try {
+              const resolvedPath = path.resolve(safeCwd, part);
+              if (!isPathWithinBaseDir(resolvedPath, baseDir)) {
+                const errorMsg = `Command argument references path outside the project directory: ${part} (resolved to ${resolvedPath})`;
+                sendData?.({
+                  event: "tool-error",
+                  id: toolCallId,
+                  data: errorMsg,
+                });
+                return errorMsg;
+              }
+            } catch (e) {
+              console.info(
+                `Could not resolve potential path argument: ${part}`,
+                e as unknown as string,
+              );
+            }
+          }
+        }
+
+        // Prompt user for command execution approval (only in interactive mode)
+        if (terminal) {
+          if (!autoAcceptCommands) {
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+          }
+          terminal.lineBreak();
+          terminal.writeln(
+            `${chalk.blue.bold("●")} About to execute command: ${chalk.cyan(command)}`,
+          );
+          terminal.writeln(`${chalk.gray("Working directory:")} ${safeCwd}`);
+          terminal.lineBreak();
+
+          let userChoice: string;
+          if (autoAcceptCommands) {
+            terminal.writeln(
+              chalk.green(
+                "✓ Auto-accepting command (all future commands will be accepted)",
+              ),
+            );
+            userChoice = "accept";
+          } else {
+            userChoice = await select({
+              message: "What would you like to do with this command?",
+              choices: [
+                { name: "Execute this command", value: "accept" },
+                {
+                  name: "Execute all future commands (including this)",
+                  value: "accept-all",
+                },
+                { name: "Reject this command", value: "reject" },
+              ],
+              default: "accept",
+            });
+          }
+
+          terminal.lineBreak();
+
+          if (userChoice === "accept-all") {
+            autoAcceptCommands = true;
+            terminal.writeln(
+              chalk.yellow(
+                "✓ Auto-accept mode enabled for all future commands",
+              ),
+            );
+            terminal.lineBreak();
+          }
+
+          if (userChoice === "reject") {
+            const reason = await input({ message: "Feedback: " });
+            terminal.lineBreak();
+
+            const rejectionMsg = `Command rejected by user. Reason: ${reason}`;
+            sendData?.({
+              event: "tool-completion",
+              id: toolCallId,
+              data: rejectionMsg,
+            });
+            return rejectionMsg;
+          }
+        }
+
+        try {
+          const result = await executeCommand(command, {
+            cwd: safeCwd,
+            timeout: safeTimeout,
+            shell: true,
+            throwOnError: false,
+          });
+
+          if (result.signal === "SIGTERM") {
+            const timeoutMessage = `Command timed out after ${safeTimeout}ms. This might be because the command is waiting for input.`;
+            sendData?.({
+              event: "tool-error",
+              id: toolCallId,
+              data: timeoutMessage,
+            });
+            return timeoutMessage;
+          }
+
+          const formattedResult = format(result);
+
+          sendData?.({
+            event: "tool-update",
+            id: toolCallId,
+            data: {
+              primary: "Result",
+              secondary: formattedResult.split("\n").slice(-5),
+            },
+          });
+
+          let tokenCount = 0;
+          try {
+            tokenCount = tokenCounter.count(formattedResult);
+          } catch (tokenError) {
+            console.error("Error calculating token count:", tokenError);
+            // Log or handle error, but don't block file return
+          }
+
+          const maxTokens = (await config.readProjectConfig()).tools.maxTokens;
+          // Adjust max token check message if line selection was used
+          const maxTokenMessage = `Output of commmand (${tokenCount} tokens) exceeds maximum allowed tokens (${maxTokens}). Please adjust how you call the command to get back more specific results`;
+
+          const finalResult =
+            tokenCount <= maxTokens ? formattedResult : maxTokenMessage;
+
+          sendData?.({
+            event: "tool-completion",
+            id: toolCallId,
+            data:
+              tokenCount <= maxTokens
+                ? "Command executed successfully."
+                : `Output of commmand (${tokenCount} tokens) exceeds maximum allowed tokens (${maxTokens}).`,
+          });
+          return finalResult;
+        } catch (error) {
+          sendData?.({
+            event: "tool-error",
+            id: toolCallId,
+            data: `Command failed: ${(error as Error).message}`,
+          });
+          return `Command failed: ${(error as Error).message}`;
+        }
+      },
+    }),
+  };
+};
+
+function format({
+  stdout,
+  stderr,
+}: {
+  stdout: string;
+  stderr: string;
+  code: number;
+}) {
+  return `${stdout}\n${stderr}`;
+}

package/source/tools/code-interpreter.ts

@@ -0,0 +1,172 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import process from "node:process";
+import { tool } from "ai";
+import { z } from "zod";
+import type { SendData } from "./types.ts";
+
+export const CodeInterpreterTool = {
+  name: "codeInterpreter" as const,
+};
+
+export const createCodeInterpreterTool = ({
+  sendData,
+}: Readonly<{
+  sendData?: SendData | undefined;
+}>) => {
+  return {
+    [CodeInterpreterTool.name]: tool({
+      description:
+        "Executes JavaScript code in a separate Node.js process using Node's Permission Model. By default, the child process has no permissions except read/write within the current working directory. The tool returns stdout, stderr, and exitCode. Use console.log/console.error to produce output. Timeout defaults to 5 seconds and can be extended up to 60 seconds.",
+      inputSchema: z.object({
+        code: z.string().describe("JavaScript code to be executed."),
+        timeoutSeconds: z
+          .number()
+          .int()
+          .min(1)
+          .max(60)
+          .nullable()
+          .describe("Execution timeout in seconds (1-60). Default 5."),
+      }),
+      execute: async ({ code, timeoutSeconds }, { toolCallId }) => {
+        const workingDirectory = process.cwd();
+
+        try {
+          sendData?.({
+            event: "tool-init",
+            id: toolCallId,
+            data: "Initializing code interpreter environment",
+          });
+
+          sendData?.({
+            event: "tool-update",
+            id: toolCallId,
+            data: {
+              primary: "Executing...",
+              secondary: [
+                `${"`".repeat(3)} javascript\n${code.slice(0, 500)}${"`".repeat(3)}`,
+              ],
+            },
+          });
+
+          if (code.trim().length === 0) {
+            throw new Error("No code provided");
+          }
+
+          const timeoutMs = Math.min(
+            Math.max((timeoutSeconds ?? 5) * 1000, 1000),
+            60000,
+          );
+
+          const tmpBase = join(workingDirectory, ".acai-ci-tmp");
+          await mkdir(tmpBase, { recursive: true });
+          const scriptPath = join(
+            tmpBase,
+            `temp_script_${Date.now()}_${randomUUID()}.mjs`,
+          );
+
+          await writeFile(scriptPath, code, { encoding: "utf8" });
+
+          const args = [
+            "--permission",
+            `--allow-fs-read=${workingDirectory}`,
+            `--allow-fs-write=${workingDirectory}`,
+            scriptPath,
+          ];
+
+          const child = spawn(process.execPath, args, {
+            cwd: workingDirectory,
+            // do not rely solely on spawn's timeout; we implement manual timeout below
+            stdio: "pipe",
+            env: Object.assign({}, process.env, {
+              // biome-ignore lint/style/useNamingConvention: Environment variable keys are uppercase by convention
+              NO_COLOR: "true",
+              // biome-ignore lint/style/useNamingConvention: Environment variable keys are uppercase by convention
+              NODE_OPTIONS: "",
+            } as Record<string, string>),
+          });
+
+          let stdout = "";
+          let stderr = "";
+          let timedOut = false;
+
+          const timer = setTimeout(() => {
+            timedOut = true;
+            try {
+              child.kill("SIGKILL");
+            } catch {}
+          }, timeoutMs);
+
+          child.stdout.setEncoding("utf8");
+          child.stderr.setEncoding("utf8");
+
+          child.stdout.on("data", (chunk) => {
+            stdout += String(chunk);
+          });
+          child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+          });
+
+          const completed = await new Promise<{
+            code: number | null;
+            signal: NodeJS.Signals | null;
+          }>((resolve, reject) => {
+            child.on("error", (err) => reject(err));
+            child.on("close", (code, signal) => resolve({ code, signal }));
+          });
+
+          clearTimeout(timer);
+
+          // Cleanup temp file/directory
+          await rm(scriptPath, { force: true });
+          await rm(tmpBase, { force: true, recursive: true });
+
+          if (timedOut) {
+            throw new Error("Script timed out");
+          }
+
+          if (completed.code === null) {
+            throw new Error(
+              `Process terminated by signal ${completed.signal ?? "unknown"}`,
+            );
+          }
+
+          if (completed.code !== 0) {
+            const message = `Process exited with code ${completed.code}. Stderr: ${stderr.trim()}`;
+            throw new Error(message);
+          }
+
+          const result = {
+            stdout: stdout.trim(),
+            stderr: stderr.trim(),
+            exitCode: completed.code ?? -1,
+          };
+
+          sendData?.({
+            event: "tool-completion",
+            id: toolCallId,
+            data: "Code execution completed successfully",
+          });
+
+          return JSON.stringify(result, null, 2);
+        } catch (err) {
+          const errorMessage =
+            (err as Error).name === "ETIMEDOUT" ||
+            (err as Error).message.includes("timed out")
+              ? "Script timed out"
+              : `Error: ${(err as Error).message}`;
+
+          sendData?.({
+            event: "tool-error",
+            id: toolCallId,
+            data: errorMessage,
+          });
+
+          return errorMessage;
+        }
+      },
+    }),
+  };
+};

package/source/tools/command-validation.ts

@@ -0,0 +1,81 @@
+export class CommandValidation {
+  private readonly allowedCommands: string[];
+  private readonly unsafeOperatorPatterns: RegExp[];
+
+  constructor(allowedCommands: string[]) {
+    this.allowedCommands = allowedCommands;
+    this.unsafeOperatorPatterns = [
+      /`/, // backticks
+      /\$\(/, // $(
+      />/, // redirect out
+      /</, // redirect in
+    ];
+  }
+
+  private isCommandAllowed(command: string): boolean {
+    const baseCommand = command.split(" ")[0] || "";
+    return this.allowedCommands.includes(baseCommand);
+  }
+
+  private hasUnsafeOperators(command: string): boolean {
+    // Remove all quoted segments first
+    const stripped = command
+      .replace(/'([^'\\]|\\.)*'/g, "")
+      .replace(/"([^"\\]|\\.)*"/g, "");
+
+    // Check for unsafe operators only in unquoted portions
+    return this.unsafeOperatorPatterns.some((re) => re.test(stripped));
+  }
+
+  isValid(command: string): boolean {
+    if (!command.trim()) return false;
+
+    // First check for unsafe operators in unquoted portions
+    if (this.hasUnsafeOperators(command)) {
+      return false;
+    }
+
+    // Process command while preserving quoted strings
+    const subCommands: string[] = [];
+    let currentSegment = "";
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+
+    for (let i = 0; i < command.length; i++) {
+      const char = command[i];
+
+      // Handle quote states
+      if (char === "'" && !inDoubleQuote) inSingleQuote = !inSingleQuote;
+      if (char === '"' && !inSingleQuote) inDoubleQuote = !inDoubleQuote;
+
+      // Split on operators only when not in quotes
+      if (
+        !inSingleQuote &&
+        !inDoubleQuote &&
+        (char === "&" || char === "|" || char === ";")
+      ) {
+        if (currentSegment.trim()) {
+          subCommands.push(currentSegment.trim());
+          currentSegment = "";
+        }
+        // Skip the operator and any subsequent same operators (like && or ||)
+        while (
+          i + 1 < command.length &&
+          ["&", "|", ";"].includes(command[i + 1] ?? "")
+        ) {
+          i++;
+        }
+      } else {
+        currentSegment += char;
+      }
+    }
+
+    // Add the last segment
+    if (currentSegment.trim()) {
+      subCommands.push(currentSegment.trim());
+    }
+
+    // Validate all sub-commands
+    return subCommands.every((cmd) => this.isCommandAllowed(cmd));
+  }
+}

package/source/tools/delete-file.ts

@@ -0,0 +1,71 @@
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import { tool } from "ai";
+import chalk from "chalk";
+import { z } from "zod";
+import { joinWorkingDir, validatePath } from "./filesystem-utils.ts";
+import type { SendData } from "./types.ts";
+
+export const DeleteFileTool = {
+  name: "deleteFile" as const,
+};
+
+export const createDeleteFileTool = async ({
+  workingDir,
+  sendData,
+}: {
+  workingDir: string;
+  sendData?: SendData;
+}) => {
+  const allowedDirectory = workingDir;
+  return {
+    [DeleteFileTool.name]: tool({
+      description: "Delete a file permanently.",
+      inputSchema: z.object({
+        path: z.string().describe("Absolute path to the file to delete"),
+      }),
+      execute: async ({ path: userPath }, { toolCallId }) => {
+        sendData?.({
+          id: toolCallId,
+          event: "tool-init",
+          data: `Deleting file: ${chalk.cyan(userPath)}`,
+        });
+        try {
+          const filePath = await validatePath(
+            joinWorkingDir(userPath, workingDir),
+            allowedDirectory,
+          );
+
+          // Check if file exists before attempting delete
+          if (!existsSync(filePath)) {
+            throw new Error(`File not found: ${filePath}`);
+          }
+
+          // Ensure it's a file, not a directory
+          const stats = await fs.stat(filePath);
+          if (stats.isDirectory()) {
+            throw new Error(`Path is a directory, not a file: ${filePath}`);
+          }
+
+          // Delete the original file
+          await fs.unlink(filePath);
+
+          sendData?.({
+            id: toolCallId,
+            event: "tool-completion",
+            data: `File deleted successfully: ${userPath}`,
+          });
+          return `Successfully deleted ${filePath}`;
+        } catch (error) {
+          const errorMessage = `Failed to delete file: ${(error as Error).message}`;
+          sendData?.({
+            id: toolCallId,
+            event: "tool-error",
+            data: errorMessage,
+          });
+          return errorMessage;
+        }
+      },
+    }),
+  };
+};