autoclaw 1.0.31 → 1.0.33

package/dist/index.js

@@ -8,8 +8,6 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { fileURLToPath } from 'url';
-import { createInterface } from 'node:readline/promises';
-import { stdin as input, stdout as output } from 'node:process';
 // Handle Ctrl+C gracefully
 function handleExit() {
     console.log(chalk.cyan("\n\nGoodbye! (Interrupted)"));
@@ -114,6 +112,12 @@ async function runSetup(options = {}) {
             message: 'Enter default Model:',
             default: currentConfig.model || 'gpt-4o'
         },
+        {
+            type: 'confirm',
+            name: 'configureImage',
+            message: 'Do you want to configure a separate Image Generation Service (DALL-E)?',
+            default: !!currentConfig.imageApiKey
+        },
         {
             type: 'confirm',
             name: 'configureEmail',
@@ -135,6 +139,36 @@ async function runSetup(options = {}) {
     ]);
     // Resolve sensitive values (Keep old if empty)
     const finalApiKey = answers.apiKey || currentConfig.apiKey;
+    let imageConfig = {};
+    if (answers.configureImage) {
+        const imageAnswers = await inquirer.prompt([
+            {
+                type: 'password',
+                name: 'imageApiKey',
+                message: currentConfig.imageApiKey
+                    ? `Enter Image Service API Key (Leave empty to keep ${maskSecret(currentConfig.imageApiKey)}, or leave empty to use main API key):`
+                    : 'Enter Image Service API Key (Leave empty to use main API key):',
+                mask: '*'
+            },
+            {
+                type: 'input',
+                name: 'imageBaseUrl',
+                message: 'Enter Image Service Base URL:',
+                default: currentConfig.imageBaseUrl || currentConfig.baseUrl || 'https://api.openai.com/v1'
+            },
+            {
+                type: 'input',
+                name: 'imageModel',
+                message: 'Default Image Model:',
+                default: currentConfig.imageModel || 'dall-e-3'
+            }
+        ]);
+        imageConfig = {
+            imageApiKey: imageAnswers.imageApiKey || currentConfig.imageApiKey,
+            imageBaseUrl: imageAnswers.imageBaseUrl,
+            imageModel: imageAnswers.imageModel
+        };
+    }
     let emailConfig = {};
     if (answers.configureEmail) {
         const emailAnswers = await inquirer.prompt([
@@ -250,6 +284,7 @@ async function runSetup(options = {}) {
         apiKey: finalApiKey,
         baseUrl: answers.baseUrl,
         model: answers.model,
+        ...imageConfig,
         ...emailConfig,
         ...searchConfig,
         ...notifyConfig
@@ -354,20 +389,16 @@ async function runChat(queryParts, options) {
         }
     }
     // Main chat loop
-    const rl = createInterface({ input, output });
     try {
         while (true) {
-            let userInput;
-            try {
-                userInput = await rl.question(chalk.green('? ') + 'You > ');
-            }
-            catch (err) {
-                if (err.code === 'ABORT_ERR') {
-                    console.log(chalk.cyan("\nGoodbye!"));
-                    break;
+            const { userInput } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'userInput',
+                    message: 'You >',
+                    prefix: chalk.green('?')
                 }
-                throw err;
-            }
+            ]);
             if (userInput.toLowerCase() === 'exit' || userInput.toLowerCase() === 'quit') {
                 console.log(chalk.cyan("Goodbye!"));
                 break;
@@ -378,17 +409,13 @@ async function runChat(queryParts, options) {
         }
     }
     catch (err) {
-        if (err.name === 'AbortError' || err.code === 'ABORT_ERR') {
-            // Handled inside loop mostly, but just in case
+        if (err.message && (err.message.includes('User force closed') || err.message.includes('Prompt was canceled'))) {
             console.log(chalk.cyan("\nGoodbye!"));
         }
         else {
             console.error(chalk.red("Error in chat loop:"), err);
         }
     }
-    finally {
-        rl.close();
-    }
 }
 // Global error handler
 main().catch(err => {

package/dist/tools/image.js

@@ -0,0 +1,239 @@
+import OpenAI from 'openai';
+import * as fs from 'fs';
+import * as path from 'path';
+const toolDefinition = {
+    type: "function",
+    function: {
+        name: "generate_image",
+        description: "Generates or edits images using AI models (DALL-E 3/2). Supports text-to-image, image variation, and image editing. Allows control over size, resolution (quality), and model selection.",
+        parameters: {
+            type: "object",
+            properties: {
+                prompt: {
+                    type: "string",
+                    description: "Text description of the desired image. Required for text-to-image and edit modes."
+                },
+                image_path: {
+                    type: "string",
+                    description: "Path to an existing image file (local path). Required for variation and editing modes."
+                },
+                mask_path: {
+                    type: "string",
+                    description: "Path to a mask image file (local path). Optional, used only for editing."
+                },
+                mode: {
+                    type: "string",
+                    enum: ["text-to-image", "variation", "edit"],
+                    description: "Operation mode. Inferred if not provided."
+                },
+                model: {
+                    type: "string",
+                    enum: ["dall-e-3", "dall-e-2"],
+                    description: "The AI model to use. 'dall-e-3' for high quality (default), 'dall-e-2' for faster/smaller generation or editing.",
+                    default: "dall-e-3"
+                },
+                n: {
+                    type: "integer",
+                    description: "Number of images to generate. Default is 1.",
+                    default: 1
+                },
+                size: {
+                    type: "string",
+                    description: "Image resolution/size. DALL-E 3: '1024x1024', '1024x1792' (Portrait), '1792x1024' (Landscape). DALL-E 2: '256x256', '512x512', '1024x1024'.",
+                    default: "1024x1024"
+                },
+                quality: {
+                    type: "string",
+                    enum: ["standard", "hd"],
+                    description: "Image quality (DALL-E 3 only). 'hd' creates more detailed images. Default is 'standard'.",
+                    default: "standard"
+                },
+                style: {
+                    type: "string",
+                    enum: ["vivid", "natural"],
+                    description: "Image style (DALL-E 3 only). Default is 'vivid'.",
+                    default: "vivid"
+                },
+                output_dir: {
+                    type: "string",
+                    description: "Directory to save the generated images. Defaults to current directory."
+                }
+            },
+            required: []
+        }
+    }
+};
+async function downloadImage(url, destPath) {
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`Failed to download image: ${response.statusText}`);
+    const buffer = await response.arrayBuffer();
+    fs.writeFileSync(destPath, Buffer.from(buffer));
+}
+const handler = async (args, config) => {
+    const apiKey = config.imageApiKey || config.apiKey || process.env.OPENAI_API_KEY;
+    const baseURL = config.imageBaseUrl || config.baseUrl || process.env.OPENAI_BASE_URL;
+    if (!apiKey) {
+        return "Error: Image Service API Key is missing. Please configure it in .autoclaw/setting.json (imageApiKey or apiKey).";
+    }
+    const client = new OpenAI({
+        apiKey: apiKey,
+        baseURL: baseURL
+    });
+    const { prompt, image_path, mask_path, n = 1, size = "1024x1024", quality = "standard", style = "vivid", output_dir = "." } = args;
+    let mode = args.mode;
+    let model = args.model || config.imageModel || "dall-e-3";
+    // Infer mode if not provided
+    if (!mode) {
+        if (image_path && mask_path)
+            mode = "edit";
+        else if (image_path)
+            mode = "variation";
+        else
+            mode = "text-to-image";
+    }
+    // Model-specific validations
+    if (mode === "text-to-image") {
+        // DALL-E 3 Validation
+        if (model === "dall-e-3") {
+            const validSizes = ["1024x1024", "1024x1792", "1792x1024"];
+            if (!validSizes.includes(size)) {
+                return `Error: Invalid size '${size}' for DALL-E 3. Supported sizes are: ${validSizes.join(", ")}.`;
+            }
+        }
+        // DALL-E 2 Validation
+        else if (model === "dall-e-2") {
+            const validSizes = ["256x256", "512x512", "1024x1024"];
+            if (!validSizes.includes(size)) {
+                return `Error: Invalid size '${size}' for DALL-E 2. Supported sizes are: ${validSizes.join(", ")}.`;
+            }
+        }
+    }
+    else {
+        // Variation and Edit only support DALL-E 2 currently
+        if (model === "dall-e-3") {
+            console.log("Note: DALL-E 3 does not support variation/edit. Falling back to DALL-E 2.");
+            model = "dall-e-2";
+        }
+    }
+    // Resolve output directory
+    const resolvedOutputDir = path.resolve(process.cwd(), output_dir);
+    if (!fs.existsSync(resolvedOutputDir)) {
+        fs.mkdirSync(resolvedOutputDir, { recursive: true });
+    }
+    const generatedFiles = [];
+    try {
+        if (mode === "text-to-image") {
+            if (!prompt)
+                return "Error: 'prompt' is required for text-to-image mode.";
+            console.log(`Generating ${n} image(s) with ${model} (${size}, ${quality})...`);
+            if (model === "dall-e-3") {
+                for (let i = 0; i < n; i++) {
+                    const response = await client.images.generate({
+                        model: "dall-e-3",
+                        prompt: prompt,
+                        n: 1, // DALL-E 3 constraint
+                        size: size,
+                        quality: quality,
+                        style: style,
+                        response_format: "url"
+                    });
+                    const imageUrl = response.data?.[0]?.url;
+                    if (imageUrl) {
+                        const fileName = `generated-${Date.now()}-${i + 1}.png`;
+                        const filePath = path.join(resolvedOutputDir, fileName);
+                        await downloadImage(imageUrl, filePath);
+                        generatedFiles.push(filePath);
+                    }
+                }
+            }
+            else {
+                // DALL-E 2
+                const response = await client.images.generate({
+                    model: "dall-e-2",
+                    prompt: prompt,
+                    n: n,
+                    size: size,
+                    response_format: "url"
+                });
+                const data = response.data || [];
+                for (let i = 0; i < data.length; i++) {
+                    const imageUrl = data[i].url;
+                    if (imageUrl) {
+                        const fileName = `generated-${Date.now()}-${i + 1}.png`;
+                        const filePath = path.join(resolvedOutputDir, fileName);
+                        await downloadImage(imageUrl, filePath);
+                        generatedFiles.push(filePath);
+                    }
+                }
+            }
+        }
+        else if (mode === "variation") {
+            if (!image_path)
+                return "Error: 'image_path' is required for variation mode.";
+            if (!fs.existsSync(image_path))
+                return `Error: Image file not found at ${image_path}`;
+            console.log(`Generating ${n} variation(s) with ${model}...`);
+            const response = await client.images.createVariation({
+                image: fs.createReadStream(image_path),
+                n: n,
+                model: "dall-e-2", // Explicitly set model just in case, though it's the default/only option
+                size: size,
+                response_format: "url"
+            });
+            const data = response.data || [];
+            for (let i = 0; i < data.length; i++) {
+                const imageUrl = data[i].url;
+                if (imageUrl) {
+                    const fileName = `variation-${Date.now()}-${i + 1}.png`;
+                    const filePath = path.join(resolvedOutputDir, fileName);
+                    await downloadImage(imageUrl, filePath);
+                    generatedFiles.push(filePath);
+                }
+            }
+        }
+        else if (mode === "edit") {
+            if (!image_path)
+                return "Error: 'image_path' is required for edit mode.";
+            if (!prompt)
+                return "Error: 'prompt' is required for edit mode.";
+            if (!fs.existsSync(image_path))
+                return `Error: Image file not found at ${image_path}`;
+            console.log(`Editing image with ${model}...`);
+            const params = {
+                image: fs.createReadStream(image_path),
+                prompt: prompt,
+                n: n,
+                model: "dall-e-2",
+                size: size,
+                response_format: "url"
+            };
+            if (mask_path && fs.existsSync(mask_path)) {
+                params.mask = fs.createReadStream(mask_path);
+            }
+            const response = await client.images.edit(params);
+            const data = response.data || [];
+            for (let i = 0; i < data.length; i++) {
+                const imageUrl = data[i].url;
+                if (imageUrl) {
+                    const fileName = `edited-${Date.now()}-${i + 1}.png`;
+                    const filePath = path.join(resolvedOutputDir, fileName);
+                    await downloadImage(imageUrl, filePath);
+                    generatedFiles.push(filePath);
+                }
+            }
+        }
+        else {
+            return `Error: Unknown mode '${mode}'.`;
+        }
+        return `Successfully generated ${generatedFiles.length} image(s):\n${generatedFiles.join('\n')}`;
+    }
+    catch (error) {
+        return `Error generating image: ${error.message}`;
+    }
+};
+export const ImageTool = {
+    name: "Image Generation",
+    definition: toolDefinition,
+    handler: handler
+};

package/dist/tools/index.js

@@ -4,6 +4,7 @@ import { SearchTool } from './search.js';
 import { NotifyTool } from './notify.js';
 import { BrowserTool } from './browser.js';
 import { ScreenshotTool } from './screenshot.js';
+import { ImageTool } from './image.js';
 // Central Registry of all available tools
 export const toolRegistry = [
     ShellTool,
@@ -14,7 +15,8 @@ export const toolRegistry = [
     SearchTool,
     NotifyTool,
     BrowserTool,
-    ScreenshotTool
+    ScreenshotTool,
+    ImageTool
 ];
 export function getToolDefinitions() {
     return toolRegistry.map(t => t.definition);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autoclaw",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "type": "module",
   "main": "dist/index.js",
   "bin": {