autoclaw 1.0.4 → 1.0.6

package/README.md

@@ -1,14 +1,23 @@
 # AutoClaw 🦞
 
-AutoClaw is a lightweight AI agent CLI tool that brings the power of Large Language Models (LLMs) directly to your terminal. It allows you to interact with your file system and execute commands using natural language.
+**The Docker-Native Headless Agent for Massive Scale Automation.**
+
+AutoClaw is a hyper-lightweight AI agent designed to live inside **Docker containers**. Unlike heavy, GUI-dependent agents, AutoClaw is built for **headless, massive-scale concurrency**.
+
+You can run one instance to fix a local script, or orchestrate **10,000+ instances** in a Kubernetes cluster to refactor codebases, audit servers, or process data streams in parallel.
+
+## Why AutoClaw?
+- 🐳 **Docker Native**: Built to run safely inside containers. Minimal footprint (Node.js/Alpine friendly).
+- 🚀 **Massive Scalability**: Text-only, headless design means you can spawn thousands of agents without consuming graphical resources.
+- 🛡️ **Sandbox Safety**: Ideal for running untrusted code when isolated in Docker.
+- 🔌 **Swarm Ready**: Stateless design allows for easy orchestration via K8s, Docker Swarm, or simple shell loops.
 
 ## Features
 
-- 💬 **Natural Language Interface**: Chat with your terminal to perform complex tasks.
-- 🛡️ **Safe Execution**: All shell commands require user confirmation before execution.
-- 📂 **File Management**: Read and write files effortlessly.
-- 🧠 **Context Aware**: Automatically detects your OS, shell, and environment for accurate command generation.
-- 🔌 **Model Agnostic**: Compatible with OpenAI, DeepSeek, LocalLLM, or any OpenAI-compatible API.
+- 📜 **Headless Execution**: No browsers, no GUIs. Pure terminal efficiency.
+- 🤖 **Non-Interactive**: Intelligent flag handling (`-y`) for zero-touch automation.
+- 📂 **Universal Control**: From simple file I/O to complex system administration.
+- 🧠 **Context Aware**: Detects container environments to optimize command strategies.
 
 ## Installation
 

package/dist/agent.js

@@ -2,17 +2,19 @@ import OpenAI from 'openai';
 import chalk from 'chalk';
 import ora from 'ora';
 import * as os from 'os';
-import { tools, executeTool } from './tools.js';
+import { getToolDefinitions, executeToolHandler } from './tools/index.js';
 export class Agent {
     client;
     messages;
     model;
-    constructor(apiKey, baseURL, model = 'gpt-4-turbo-preview') {
+    config;
+    constructor(apiKey, baseURL, model = 'gpt-4-turbo-preview', config = {}) {
         this.client = new OpenAI({
             apiKey: apiKey,
             baseURL: baseURL
         });
         this.model = model;
+        this.config = config;
         const systemInfo = `
 System Information:
 - OS: ${os.type()} ${os.release()} (${os.platform()})
@@ -25,22 +27,22 @@ System Information:
         this.messages = [
             {
                 role: "system",
-                content: `You are AutoClaw, an advanced AI agent running in a CLI environment.
-Your goal is to help the user perform tasks on their computer.
-You have access to tools to execute shell commands and read/write files.
+                content: `You are AutoClaw, a Docker-Native Autonomous Agent designed for massive scale automation.
+You are likely running inside a container or headless server, possibly as one of thousands of parallel units in a swarm.
 
 CONTEXT:
 ${systemInfo}
 
+ENVIRONMENT CONSTRAINTS:
+1. HEADLESS: No GUI available. Do not try to open browsers or apps.
+2. CONTAINER-OPTIMIZED: Assume you are in a sandbox. You can be aggressive with file creation but robust with errors.
+3. NON-INTERACTIVE: Always use flags to suppress prompts (e.g., 'apt-get -y', 'rm -rf').
+
 GUIDELINES:
-1. Use the System Information above to generate platform-specific commands (e.g., use 'dir' for Windows, 'ls' for Linux).
-2. When asked to perform a task, analyze if you need to use tools.
-3. If you need to run a command, always use 'execute_shell_command' and provide a clear rationale.
-4. If you need to read a file, use 'read_file'.
-5. If you need to write a file, use 'write_file'.
-6. Be concise in your responses.
-7. If the user's request is ambiguous, ask for clarification.
-8. You are running on the user's local machine. Be careful with destructive commands (rm, etc.).
+1. EFFICIENCY: Your goal is speed and success. Write scripts that just work.
+2. ROBUSTNESS: Use standard Linux/Unix tools found in minimal images (Alpine/Debian).
+3. TOOLS: Use 'execute_shell_command' for actions, 'write_file' for code generation.
+4. CLARITY: Output concise logs. You are a worker unit, not a chat bot.
 `
             }
         ];
@@ -54,7 +56,7 @@ GUIDELINES:
                 const response = await this.client.chat.completions.create({
                     model: this.model,
                     messages: this.messages,
-                    tools: tools,
+                    tools: getToolDefinitions(),
                     tool_choice: "auto"
                 });
                 spinner.stop();
@@ -70,13 +72,13 @@ GUIDELINES:
                         const functionName = toolCall.function.name;
                         const functionArgs = JSON.parse(toolCall.function.arguments);
                         console.log(chalk.gray(`Executing tool: ${functionName}...`));
-                        const toolResult = await executeTool(functionName, functionArgs);
+                        // Pass the full config to the tool handler
+                        const toolResult = await executeToolHandler(functionName, functionArgs, this.config);
                         this.messages.push({
                             role: "tool",
                             tool_call_id: toolCall.id,
                             content: toolResult
                         });
-                        // console.log(chalk.dim(`Tool Output: ${toolResult.slice(0, 100)}...`));
                     }
                 }
                 else {

package/dist/index.js

@@ -22,7 +22,7 @@ function loadJsonConfig(filePath) {
     }
     return {};
 }
-// Load local env vars
+// Load local env vars (lowest priority of env vars, but env vars override JSON)
 dotenv.config();
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // In dist/index.js, package.json is usually up one level in the root
@@ -78,12 +78,55 @@ async function runSetup() {
             name: 'model',
             message: 'Enter default Model:',
             default: currentConfig.model || 'gpt-4o'
+        },
+        {
+            type: 'confirm',
+            name: 'configureEmail',
+            message: 'Do you want to configure the Email Tool (SMTP)?',
+            default: !!currentConfig.smtpHost
         }
     ]);
+    let emailConfig = {};
+    if (answers.configureEmail) {
+        emailConfig = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'smtpHost',
+                message: 'SMTP Host:',
+                default: currentConfig.smtpHost
+            },
+            {
+                type: 'input',
+                name: 'smtpPort',
+                message: 'SMTP Port:',
+                default: currentConfig.smtpPort || '587'
+            },
+            {
+                type: 'input',
+                name: 'smtpUser',
+                message: 'SMTP Username:',
+                default: currentConfig.smtpUser
+            },
+            {
+                type: 'password',
+                name: 'smtpPass',
+                message: 'SMTP Password:',
+                mask: '*',
+                default: currentConfig.smtpPass
+            },
+            {
+                type: 'input',
+                name: 'smtpFrom',
+                message: 'Sender Email Address (From):',
+                default: currentConfig.smtpFrom || emailConfig.smtpUser
+            }
+        ]);
+    }
     const newConfig = {
         apiKey: answers.apiKey,
         baseUrl: answers.baseUrl,
-        model: answers.model
+        model: answers.model,
+        ...emailConfig
     };
     try {
         if (!fs.existsSync(GLOBAL_CONFIG_DIR)) {
@@ -106,10 +149,22 @@ async function runChat(options) {
     if (Object.keys(localConfig).length > 0) {
         console.log(chalk.dim(`Loaded project config from ${LOCAL_CONFIG_FILE}`));
     }
-    // 3. Merge: CLI > Env > Local JSON > Global JSON
-    let apiKey = process.env.OPENAI_API_KEY || localConfig.apiKey || globalConfig.apiKey;
-    let baseURL = process.env.OPENAI_BASE_URL || localConfig.baseUrl || globalConfig.baseUrl;
-    let model = options.model || process.env.OPENAI_MODEL || localConfig.model || globalConfig.model || 'gpt-4o';
+    // 3. Merge Configs for Tool Usage
+    // Priority: Local > Global
+    const fullConfig = { ...globalConfig, ...localConfig };
+    // 4. Resolve Env Vars (CLI > Env > Config)
+    let apiKey = process.env.OPENAI_API_KEY || fullConfig.apiKey;
+    let baseURL = process.env.OPENAI_BASE_URL || fullConfig.baseUrl;
+    let model = options.model || process.env.OPENAI_MODEL || fullConfig.model || 'gpt-4o';
+    // Inject Env vars for SMTP if present (optional but good for CI/CD)
+    if (process.env.SMTP_HOST)
+        fullConfig.smtpHost = process.env.SMTP_HOST;
+    if (process.env.SMTP_PORT)
+        fullConfig.smtpPort = process.env.SMTP_PORT;
+    if (process.env.SMTP_USER)
+        fullConfig.smtpUser = process.env.SMTP_USER;
+    if (process.env.SMTP_PASS)
+        fullConfig.smtpPass = process.env.SMTP_PASS;
     if (!apiKey) {
         console.log(chalk.yellow("API Key not found."));
         const { doSetup } = await inquirer.prompt([
@@ -126,6 +181,7 @@ async function runChat(options) {
             apiKey = newConfig.apiKey;
             baseURL = newConfig.baseUrl;
             model = options.model || newConfig.model || 'gpt-4o';
+            Object.assign(fullConfig, newConfig);
         }
         else {
             console.error(chalk.red("API Key is required to proceed."));
@@ -136,7 +192,7 @@ async function runChat(options) {
         console.error(chalk.red("API Key is still missing. Exiting."));
         process.exit(1);
     }
-    const agent = new Agent(apiKey, baseURL, model);
+    const agent = new Agent(apiKey, baseURL, model, fullConfig);
     console.log(chalk.green(`Agent initialized with model: ${model}`));
     console.log(chalk.gray("Type 'exit' or 'quit' to leave."));
     while (true) {

package/dist/tools/core.js

@@ -0,0 +1,104 @@
+import { exec } from 'child_process';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import util from 'util';
+const execAsync = util.promisify(exec);
+export const ShellTool = {
+    name: "Shell Execution",
+    definition: {
+        type: "function",
+        function: {
+            name: "execute_shell_command",
+            description: "Execute a shell command on the host machine. Use this to run scripts, list files, or interact with the system.",
+            parameters: {
+                type: "object",
+                properties: {
+                    command: { type: "string", description: "The shell command to execute." },
+                    rationale: { type: "string", description: "Explain why you are running this command." }
+                },
+                required: ["command", "rationale"]
+            }
+        }
+    },
+    handler: async (args) => {
+        console.log(chalk.yellow(`
+AI wants to execute: `) + chalk.bold(args.command));
+        console.log(chalk.dim(`Reason: ${args.rationale}`));
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Do you want to run this command?',
+                default: false
+            }
+        ]);
+        if (!confirm)
+            return "User denied command execution.";
+        try {
+            const { stdout, stderr } = await execAsync(args.command);
+            return stdout + (stderr ? `
+Stderr: ${stderr}` : '');
+        }
+        catch (error) {
+            return `Command failed: ${error.message}
+Stdout: ${error.stdout}
+Stderr: ${error.stderr}`;
+        }
+    }
+};
+export const ReadFileTool = {
+    name: "File Reader",
+    definition: {
+        type: "function",
+        function: {
+            name: "read_file",
+            description: "Read the content of a file.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "The path to the file to read." }
+                },
+                required: ["path"]
+            }
+        }
+    },
+    handler: async (args) => {
+        try {
+            const content = await fs.readFile(args.path, 'utf-8');
+            return content;
+        }
+        catch (error) {
+            return `Error reading file: ${error.message}`;
+        }
+    }
+};
+export const WriteFileTool = {
+    name: "File Writer",
+    definition: {
+        type: "function",
+        function: {
+            name: "write_file",
+            description: "Write content to a file. Overwrites existing files.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "The path to the file to write." },
+                    content: { type: "string", description: "The content to write." }
+                },
+                required: ["path", "content"]
+            }
+        }
+    },
+    handler: async (args) => {
+        try {
+            await fs.mkdir(path.dirname(args.path), { recursive: true });
+            await fs.writeFile(args.path, args.content, 'utf-8');
+            return `Successfully wrote to ${args.path}`;
+        }
+        catch (error) {
+            return `Error writing file: ${error.message}`;
+        }
+    }
+};

package/dist/tools/email.js

@@ -0,0 +1,48 @@
+import nodemailer from 'nodemailer';
+export const EmailTool = {
+    name: "Email Service",
+    configKeys: ["smtpHost", "smtpPort", "smtpUser", "smtpPass", "smtpFrom"],
+    definition: {
+        type: "function",
+        function: {
+            name: "send_email",
+            description: "Send an email using configured SMTP settings.",
+            parameters: {
+                type: "object",
+                properties: {
+                    to: { type: "string", description: "Recipient email address." },
+                    subject: { type: "string", description: "Email subject." },
+                    body: { type: "string", description: "Email body content (text)." }
+                },
+                required: ["to", "subject", "body"]
+            }
+        }
+    },
+    handler: async (args, config) => {
+        // Validate config
+        if (!config?.smtpHost || !config?.smtpUser || !config?.smtpPass) {
+            return "Error: Email tool is not configured. Please run 'autoclaw setup' to configure SMTP settings.";
+        }
+        try {
+            const transporter = nodemailer.createTransport({
+                host: config.smtpHost,
+                port: parseInt(config.smtpPort || '587'),
+                secure: parseInt(config.smtpPort) === 465, // true for 465, false for other ports
+                auth: {
+                    user: config.smtpUser,
+                    pass: config.smtpPass,
+                },
+            });
+            const info = await transporter.sendMail({
+                from: config.smtpFrom || config.smtpUser, // sender address
+                to: args.to, // list of receivers
+                subject: args.subject, // Subject line
+                text: args.body, // plain text body
+            });
+            return `Email sent successfully. Message ID: ${info.messageId}`;
+        }
+        catch (error) {
+            return `Failed to send email: ${error.message}`;
+        }
+    }
+};

package/dist/tools/index.js

@@ -0,0 +1,29 @@
+import { ShellTool, ReadFileTool, WriteFileTool } from './core.js';
+import { EmailTool } from './email.js';
+// Central Registry of all available tools
+export const toolRegistry = [
+    ShellTool,
+    ReadFileTool,
+    WriteFileTool,
+    EmailTool
+];
+export function getToolDefinitions() {
+    return toolRegistry.map(t => t.definition);
+}
+export async function executeToolHandler(name, args, fullConfig) {
+    const tool = toolRegistry.find(t => t.definition.function.name === name);
+    if (!tool) {
+        return `Error: Tool ${name} not found.`;
+    }
+    // Pass specific config if needed (e.g., email config)
+    // We pass the full config, and let the handler pick what it needs or strictly pass the 'tools' section if structured.
+    // For simplicity, passing full config, or we can structure config.tools.email
+    // Let's assume config has a 'tools' dictionary.
+    const toolConfig = fullConfig.tools ? fullConfig.tools[name] : fullConfig;
+    // Actually, let's just pass the root config for now to keep migration simple, 
+    // or better, pass the 'email' specific config if we structure it.
+    // Strategy: In setup, we will save keys like 'smtpHost' at root or under 'tools.email'.
+    // Let's keep it flat or structured? Structured is better for plugins.
+    // Let's pass the whole config object to the handler, it can pick what it needs.
+    return await tool.handler(args, fullConfig);
+}

package/dist/tools/interface.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autoclaw",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -35,12 +35,14 @@
     "commander": "^14.0.3",
     "dotenv": "^16.4.7",
     "inquirer": "^13.2.2",
+    "nodemailer": "^8.0.0",
     "openai": "^6.18.0",
     "ora": "^9.3.0"
   },
   "devDependencies": {
     "@types/inquirer": "^9.0.9",
     "@types/node": "^25.2.1",
+    "@types/nodemailer": "^7.0.9",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"
   }