cowork-os 0.3.21

package/dist/electron/electron/agent/skills/image-generator.js

@@ -0,0 +1,225 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageGenerator = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const mimetypes = __importStar(require("mime-types"));
+const provider_factory_1 = require("../llm/provider-factory");
+/**
+ * Map our model names to Gemini model IDs
+ * - nano-banana: gemini-2.5-flash-image (fast, good quality)
+ * - nano-banana-pro: gemini-3-pro-image-preview (best quality)
+ */
+const MODEL_MAP = {
+    'nano-banana': 'gemini-2.5-flash-image',
+    'nano-banana-pro': 'gemini-3-pro-image-preview',
+};
+/**
+ * ImageGenerator - Generates images using Google's Gemini models
+ *
+ * Supports two models:
+ * - Nano Banana: Fast generation using Gemini 2.5 Flash Image
+ * - Nano Banana Pro: High-quality generation using Gemini 3 Pro Image Preview
+ */
+class ImageGenerator {
+    constructor(workspace) {
+        this.workspace = workspace;
+    }
+    /**
+     * Generate images from a text prompt using Gemini's generateContent API
+     */
+    async generate(request) {
+        const { prompt, model = 'nano-banana-pro', filename, imageSize = '1K', numberOfImages = 1, } = request;
+        // Get Gemini API key from settings
+        const settings = provider_factory_1.LLMProviderFactory.loadSettings();
+        const apiKey = settings.gemini?.apiKey;
+        if (!apiKey) {
+            return {
+                success: false,
+                images: [],
+                model: MODEL_MAP[model],
+                error: 'Gemini API key not configured. Please configure it in Settings to use image generation.',
+            };
+        }
+        const modelId = MODEL_MAP[model];
+        const endpoint = `https://generativelanguage.googleapis.com/v1beta/models/${modelId}:generateContent`;
+        try {
+            console.log(`[ImageGenerator] Generating image with ${model} (${modelId})`);
+            console.log(`[ImageGenerator] Prompt: "${prompt.substring(0, 100)}${prompt.length > 100 ? '...' : ''}"`);
+            const images = [];
+            const baseFilename = filename || `generated_${Date.now()}`;
+            const outputDir = this.workspace.path;
+            let textResponse;
+            // Generate requested number of images (one API call per image for streaming support)
+            for (let imageIndex = 0; imageIndex < Math.min(numberOfImages, 4); imageIndex++) {
+                const response = await fetch(`${endpoint}?key=${apiKey}`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        contents: [
+                            {
+                                role: 'user',
+                                parts: [
+                                    {
+                                        text: prompt,
+                                    },
+                                ],
+                            },
+                        ],
+                        generationConfig: {
+                            responseModalities: ['IMAGE', 'TEXT'],
+                            imageConfig: {
+                                imageSize: imageSize,
+                            },
+                        },
+                    }),
+                });
+                if (!response.ok) {
+                    const errorBody = await response.text();
+                    console.error(`[ImageGenerator] API error: ${response.status} ${response.statusText}`);
+                    console.error(`[ImageGenerator] Error body:`, errorBody);
+                    // Parse error for better message
+                    let errorMessage = `Image generation failed: ${response.status}`;
+                    try {
+                        const errorJson = JSON.parse(errorBody);
+                        if (errorJson.error?.message) {
+                            errorMessage = errorJson.error.message;
+                        }
+                    }
+                    catch {
+                        // Use default message
+                    }
+                    // If first image fails, return error
+                    if (imageIndex === 0) {
+                        return {
+                            success: false,
+                            images: [],
+                            model: modelId,
+                            error: errorMessage,
+                        };
+                    }
+                    // Otherwise continue with what we have
+                    break;
+                }
+                const data = await response.json();
+                const candidate = data.candidates?.[0];
+                const parts = candidate?.content?.parts || [];
+                for (const part of parts) {
+                    // Handle text response
+                    if (part.text) {
+                        textResponse = part.text;
+                        console.log(`[ImageGenerator] Text response: ${part.text.substring(0, 100)}...`);
+                    }
+                    // Handle image data
+                    if (part.inlineData?.data) {
+                        const inlineData = part.inlineData;
+                        const mimeType = inlineData.mimeType || 'image/png';
+                        const extension = mimetypes.extension(mimeType) || 'png';
+                        // Determine filename
+                        const imageName = numberOfImages > 1
+                            ? `${baseFilename}_${imageIndex + 1}.${extension}`
+                            : `${baseFilename}.${extension}`;
+                        const outputPath = path.join(outputDir, imageName);
+                        // Decode and save image
+                        const imageBuffer = Buffer.from(inlineData.data, 'base64');
+                        await fs.promises.writeFile(outputPath, imageBuffer);
+                        const stats = await fs.promises.stat(outputPath);
+                        images.push({
+                            path: outputPath,
+                            filename: imageName,
+                            mimeType: mimeType,
+                            size: stats.size,
+                        });
+                        console.log(`[ImageGenerator] Saved image: ${imageName} (${stats.size} bytes)`);
+                    }
+                }
+            }
+            if (images.length === 0) {
+                return {
+                    success: false,
+                    images: [],
+                    model: modelId,
+                    textResponse,
+                    error: textResponse || 'No images were generated. The prompt may have been blocked by safety filters.',
+                };
+            }
+            return {
+                success: true,
+                images,
+                model: modelId,
+                textResponse,
+            };
+        }
+        catch (error) {
+            console.error(`[ImageGenerator] Error:`, error);
+            return {
+                success: false,
+                images: [],
+                model: modelId,
+                error: error.message || 'Failed to generate image',
+            };
+        }
+    }
+    /**
+     * Check if image generation is available (API key configured)
+     */
+    static isAvailable() {
+        const settings = provider_factory_1.LLMProviderFactory.loadSettings();
+        return !!settings.gemini?.apiKey;
+    }
+    /**
+     * Get available image generation models
+     */
+    static getAvailableModels() {
+        return [
+            {
+                id: 'nano-banana',
+                name: 'Nano Banana',
+                description: 'Fast image generation using Gemini 2.5 Flash',
+                modelId: MODEL_MAP['nano-banana'],
+            },
+            {
+                id: 'nano-banana-pro',
+                name: 'Nano Banana Pro',
+                description: 'High-quality image generation using Gemini 3 Pro',
+                modelId: MODEL_MAP['nano-banana-pro'],
+            },
+        ];
+    }
+}
+exports.ImageGenerator = ImageGenerator;

package/dist/electron/electron/agent/skills/organizer.js

@@ -0,0 +1,141 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FolderOrganizer = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+/**
+ * FolderOrganizer organizes files in folders
+ */
+class FolderOrganizer {
+    constructor(workspace, daemon, taskId) {
+        this.workspace = workspace;
+        this.daemon = daemon;
+        this.taskId = taskId;
+    }
+    /**
+     * Ensure path is within workspace (security check)
+     * Uses path.relative() to safely detect path traversal attacks including symlinks
+     */
+    validatePath(relativePath) {
+        const normalizedWorkspace = path.resolve(this.workspace.path);
+        const resolved = path.resolve(normalizedWorkspace, relativePath);
+        const relative = path.relative(normalizedWorkspace, resolved);
+        if (relative.startsWith('..') || path.isAbsolute(relative)) {
+            throw new Error('Path is outside workspace boundary');
+        }
+        return resolved;
+    }
+    async organize(relativePath, strategy, rules) {
+        const fullPath = this.validatePath(relativePath);
+        switch (strategy) {
+            case 'by_type':
+                return await this.organizeByType(fullPath);
+            case 'by_date':
+                return await this.organizeByDate(fullPath);
+            case 'custom':
+                return await this.organizeCustom(fullPath, rules);
+            default:
+                throw new Error(`Unknown strategy: ${strategy}`);
+        }
+    }
+    async organizeByType(folderPath) {
+        const entries = await fs.readdir(folderPath, { withFileTypes: true });
+        let changes = 0;
+        const typeMap = {
+            '.jpg': 'Images',
+            '.jpeg': 'Images',
+            '.png': 'Images',
+            '.gif': 'Images',
+            '.pdf': 'Documents',
+            '.doc': 'Documents',
+            '.docx': 'Documents',
+            '.txt': 'Documents',
+            '.xlsx': 'Spreadsheets',
+            '.csv': 'Spreadsheets',
+            '.mp4': 'Videos',
+            '.mov': 'Videos',
+            '.mp3': 'Audio',
+            '.wav': 'Audio',
+        };
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            const ext = path.extname(entry.name).toLowerCase();
+            const category = typeMap[ext] || 'Other';
+            const sourcePath = path.join(folderPath, entry.name);
+            const targetDir = path.join(folderPath, category);
+            const targetPath = path.join(targetDir, entry.name);
+            // Create category folder if needed
+            await fs.mkdir(targetDir, { recursive: true });
+            // Move file
+            await fs.rename(sourcePath, targetPath);
+            changes++;
+            this.daemon.logEvent(this.taskId, 'file_modified', {
+                action: 'organize',
+                from: entry.name,
+                to: path.join(category, entry.name),
+            });
+        }
+        return changes;
+    }
+    async organizeByDate(folderPath) {
+        const entries = await fs.readdir(folderPath, { withFileTypes: true });
+        let changes = 0;
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            const sourcePath = path.join(folderPath, entry.name);
+            const stats = await fs.stat(sourcePath);
+            const date = new Date(stats.mtime);
+            const year = date.getFullYear();
+            const month = String(date.getMonth() + 1).padStart(2, '0');
+            const targetDir = path.join(folderPath, `${year}-${month}`);
+            const targetPath = path.join(targetDir, entry.name);
+            // Create date folder if needed
+            await fs.mkdir(targetDir, { recursive: true });
+            // Move file
+            await fs.rename(sourcePath, targetPath);
+            changes++;
+        }
+        return changes;
+    }
+    async organizeCustom(folderPath, rules) {
+        // TODO: Implement custom organization rules
+        // For MVP, just return 0
+        return 0;
+    }
+}
+exports.FolderOrganizer = FolderOrganizer;