cowork-os 0.3.21

package/dist/electron/electron/agent/sandbox/security-utils.js

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * Security Utilities for Sandbox Operations
+ *
+ * Provides secure implementations for common operations:
+ * - Secure temp file creation (TOCTOU-safe)
+ * - Path validation with symlink resolution
+ * - String escaping for sandbox profiles
+ */
+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.createSecureTempFile = createSecureTempFile;
+exports.validateAndResolvePath = validateAndResolvePath;
+exports.escapeSandboxProfileString = escapeSandboxProfileString;
+exports.validatePathForSandboxProfile = validatePathForSandboxProfile;
+exports.escapeDockerEnvValue = escapeDockerEnvValue;
+exports.validateEnvVarName = validateEnvVarName;
+exports.buildSafeEnvironment = buildSafeEnvironment;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const crypto = __importStar(require("crypto"));
+/**
+ * Create a secure temporary file with random name
+ * Uses crypto.randomBytes to prevent predictable filenames (TOCTOU mitigation)
+ *
+ * @param extension - File extension (e.g., '.py', '.js')
+ * @param content - Content to write to the file
+ * @returns Object with file path and cleanup function
+ */
+function createSecureTempFile(extension, content) {
+    // Generate cryptographically random filename
+    const randomBytes = crypto.randomBytes(16).toString('hex');
+    const filename = `cowork_${randomBytes}${extension}`;
+    const tempDir = os.tmpdir();
+    // Validate temp directory exists and is writable
+    if (!fs.existsSync(tempDir)) {
+        throw new Error(`Temp directory does not exist: ${tempDir}`);
+    }
+    const filePath = path.join(tempDir, filename);
+    // Use O_CREAT | O_EXCL to atomically create file (fails if exists)
+    // This prevents TOCTOU race conditions
+    const fd = fs.openSync(filePath, fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY, 0o600);
+    try {
+        fs.writeSync(fd, content, 0, 'utf8');
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    const cleanup = () => {
+        try {
+            if (fs.existsSync(filePath)) {
+                fs.unlinkSync(filePath);
+            }
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    };
+    return { filePath, cleanup };
+}
+/**
+ * Validate and resolve a path, following symlinks
+ * Returns null if path is outside allowed boundaries
+ *
+ * @param targetPath - Path to validate
+ * @param allowedBasePaths - List of allowed base paths
+ * @returns Resolved real path or null if invalid/outside boundaries
+ */
+function validateAndResolvePath(targetPath, allowedBasePaths) {
+    // Reject paths with null bytes (path traversal attack vector)
+    if (targetPath.includes('\0')) {
+        return null;
+    }
+    // Normalize the path first
+    const normalizedTarget = path.normalize(targetPath);
+    // Check if path exists before attempting to resolve symlinks
+    if (!fs.existsSync(normalizedTarget)) {
+        // For non-existent paths, just validate against normalized path
+        for (const basePath of allowedBasePaths) {
+            const normalizedBase = path.resolve(basePath);
+            if (path.resolve(normalizedTarget).startsWith(normalizedBase + path.sep) ||
+                path.resolve(normalizedTarget) === normalizedBase) {
+                return path.resolve(normalizedTarget);
+            }
+        }
+        return null;
+    }
+    try {
+        // Resolve symlinks to get real path
+        const realPath = fs.realpathSync(normalizedTarget);
+        // Check if real path is within allowed boundaries
+        for (const basePath of allowedBasePaths) {
+            const realBasePath = fs.existsSync(basePath)
+                ? fs.realpathSync(basePath)
+                : path.resolve(basePath);
+            if (realPath.startsWith(realBasePath + path.sep) || realPath === realBasePath) {
+                return realPath;
+            }
+        }
+        return null;
+    }
+    catch {
+        // If we can't resolve the path, it's not valid
+        return null;
+    }
+}
+/**
+ * Escape a string for use in macOS sandbox-exec profile
+ * Prevents sandbox profile injection attacks
+ *
+ * @param input - String to escape
+ * @returns Escaped string safe for sandbox profile
+ */
+function escapeSandboxProfileString(input) {
+    // Validate input doesn't contain null bytes
+    if (input.includes('\0')) {
+        throw new Error('Path contains null byte, which is not allowed');
+    }
+    // Escape characters that have special meaning in sandbox profiles:
+    // - Backslash: escape character
+    // - Double quote: string delimiter
+    // - Parentheses: LISP-like syntax
+    // - Semicolon: comment start
+    return input
+        .replace(/\\/g, '\\\\') // Escape backslashes first
+        .replace(/"/g, '\\"') // Escape double quotes
+        .replace(/\(/g, '\\(') // Escape open paren
+        .replace(/\)/g, '\\)') // Escape close paren
+        .replace(/;/g, '\\;'); // Escape semicolons
+}
+/**
+ * Validate a path is safe for sandbox profile inclusion
+ * Rejects paths with dangerous characters that could break profile syntax
+ *
+ * @param pathToValidate - Path to validate
+ * @returns true if safe, throws error if not
+ */
+function validatePathForSandboxProfile(pathToValidate) {
+    // Check for null bytes
+    if (pathToValidate.includes('\0')) {
+        throw new Error('Path contains null byte');
+    }
+    // Check for newlines (could inject new profile lines)
+    if (pathToValidate.includes('\n') || pathToValidate.includes('\r')) {
+        throw new Error('Path contains newline characters');
+    }
+    // Validate path is absolute and normalized
+    if (!path.isAbsolute(pathToValidate)) {
+        throw new Error('Path must be absolute');
+    }
+    return true;
+}
+/**
+ * Escape a value for Docker environment variable
+ * Prevents command injection through environment variables
+ *
+ * @param value - Environment variable value to escape
+ * @returns Escaped value safe for Docker -e flag
+ */
+function escapeDockerEnvValue(value) {
+    // Reject values with null bytes
+    if (value.includes('\0')) {
+        throw new Error('Environment value contains null byte');
+    }
+    // For Docker, we need to handle shell metacharacters
+    // The safest approach is to reject problematic characters
+    // or use Docker's --env-file feature for complex values
+    // Check for newlines which could inject additional arguments
+    if (value.includes('\n') || value.includes('\r')) {
+        throw new Error('Environment value contains newline characters');
+    }
+    return value;
+}
+/**
+ * Validate an environment variable name is safe
+ *
+ * @param name - Environment variable name
+ * @returns true if valid, throws if not
+ */
+function validateEnvVarName(name) {
+    // Standard env var naming: alphanumeric and underscore, starting with letter or underscore
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+        throw new Error(`Invalid environment variable name: ${name}`);
+    }
+    // Blacklist dangerous environment variables that could affect sandboxed processes
+    const dangerousVars = [
+        'LD_PRELOAD',
+        'LD_LIBRARY_PATH',
+        'DYLD_INSERT_LIBRARIES',
+        'DYLD_LIBRARY_PATH',
+        'PYTHONPATH',
+        'NODE_OPTIONS',
+        'NODE_PATH',
+        'PERL5OPT',
+        'RUBYOPT',
+    ];
+    if (dangerousVars.includes(name.toUpperCase())) {
+        throw new Error(`Dangerous environment variable not allowed: ${name}`);
+    }
+    return true;
+}
+/**
+ * Safe environment passthrough that validates and filters variables
+ *
+ * @param requestedVars - List of environment variable names to pass through
+ * @returns Record of safe environment variables
+ */
+function buildSafeEnvironment(requestedVars) {
+    const safeEnv = {};
+    for (const name of requestedVars) {
+        try {
+            validateEnvVarName(name);
+            const value = process.env[name];
+            if (value !== undefined) {
+                escapeDockerEnvValue(value); // Validates value is safe
+                safeEnv[name] = value;
+            }
+        }
+        catch {
+            // Skip invalid or dangerous variables silently
+            console.warn(`[SecurityUtils] Skipping unsafe environment variable: ${name}`);
+        }
+    }
+    return safeEnv;
+}

package/dist/electron/electron/agent/search/brave-provider.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BraveProvider = void 0;
+/**
+ * Brave Search API provider
+ * https://brave.com/search/api/
+ */
+class BraveProvider {
+    constructor(config) {
+        this.type = 'brave';
+        this.supportedSearchTypes = ['web', 'news', 'images'];
+        this.baseUrl = 'https://api.search.brave.com/res/v1';
+        const apiKey = config.braveApiKey;
+        if (!apiKey) {
+            throw new Error('Brave API key is required. Configure it in Settings or get one from https://brave.com/search/api/');
+        }
+        this.apiKey = apiKey;
+    }
+    async search(query) {
+        const searchType = query.searchType || 'web';
+        if (!this.supportedSearchTypes.includes(searchType)) {
+            throw new Error(`Brave does not support ${searchType} search`);
+        }
+        const endpoint = this.getEndpoint(searchType);
+        const params = new URLSearchParams({
+            q: query.query,
+            count: String(query.maxResults || 10),
+            ...(query.region && { country: query.region }),
+            ...(query.language && { search_lang: query.language }),
+            ...(query.safeSearch !== undefined && {
+                safesearch: query.safeSearch ? 'strict' : 'off',
+            }),
+            ...(query.dateRange && { freshness: this.mapDateRange(query.dateRange) }),
+        });
+        const response = await fetch(`${this.baseUrl}/${endpoint}?${params}`, {
+            headers: {
+                Accept: 'application/json',
+                'X-Subscription-Token': this.apiKey,
+            },
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Brave API error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        return {
+            results: this.mapResults(data, searchType),
+            query: query.query,
+            searchType,
+            provider: 'brave',
+        };
+    }
+    async testConnection() {
+        try {
+            await this.search({ query: 'test', maxResults: 1 });
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to connect to Brave Search API',
+            };
+        }
+    }
+    getEndpoint(searchType) {
+        switch (searchType) {
+            case 'news':
+                return 'news/search';
+            case 'images':
+                return 'images/search';
+            default:
+                return 'web/search';
+        }
+    }
+    mapDateRange(range) {
+        switch (range) {
+            case 'day':
+                return 'pd'; // past day
+            case 'week':
+                return 'pw'; // past week
+            case 'month':
+                return 'pm'; // past month
+            case 'year':
+                return 'py'; // past year
+            default:
+                return 'pw';
+        }
+    }
+    mapResults(data, searchType) {
+        if (searchType === 'images') {
+            return (data.results || []).map((r) => ({
+                title: r.title || '',
+                url: r.url || r.page_url || '',
+                snippet: r.description || '',
+                thumbnailUrl: r.thumbnail?.src,
+                imageUrl: r.properties?.url || r.url,
+                width: r.properties?.width,
+                height: r.properties?.height,
+            }));
+        }
+        if (searchType === 'news') {
+            return (data.results || []).map((r) => ({
+                title: r.title || '',
+                url: r.url || '',
+                snippet: r.description || '',
+                publishedDate: r.age,
+                source: r.meta_url?.hostname,
+            }));
+        }
+        // Web results
+        return (data.web?.results || []).map((r) => ({
+            title: r.title || '',
+            url: r.url || '',
+            snippet: r.description || '',
+            source: r.meta_url?.hostname,
+        }));
+    }
+}
+exports.BraveProvider = BraveProvider;

package/dist/electron/electron/agent/search/google-provider.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleProvider = void 0;
+/**
+ * Google Custom Search API provider
+ * https://developers.google.com/custom-search/v1/introduction
+ */
+class GoogleProvider {
+    constructor(config) {
+        this.type = 'google';
+        this.supportedSearchTypes = ['web', 'images'];
+        this.baseUrl = 'https://www.googleapis.com/customsearch/v1';
+        const apiKey = config.googleApiKey;
+        const searchEngineId = config.googleSearchEngineId;
+        if (!apiKey) {
+            throw new Error('Google API key is required. Configure it in Settings or get one from https://console.cloud.google.com/');
+        }
+        if (!searchEngineId) {
+            throw new Error('Google Search Engine ID is required. Configure it in Settings or create one at https://programmablesearchengine.google.com/');
+        }
+        this.apiKey = apiKey;
+        this.searchEngineId = searchEngineId;
+    }
+    async search(query) {
+        const searchType = query.searchType || 'web';
+        if (!this.supportedSearchTypes.includes(searchType)) {
+            throw new Error(`Google Custom Search does not support ${searchType} search. Use 'web' or 'images'.`);
+        }
+        const params = new URLSearchParams({
+            key: this.apiKey,
+            cx: this.searchEngineId,
+            q: query.query,
+            num: String(Math.min(query.maxResults || 10, 10)), // Google CSE max is 10
+            ...(query.region && { gl: query.region }),
+            ...(query.language && { lr: `lang_${query.language}` }),
+            ...(query.safeSearch !== undefined && {
+                safe: query.safeSearch ? 'active' : 'off',
+            }),
+            ...(searchType === 'images' && { searchType: 'image' }),
+            ...(query.dateRange && { dateRestrict: this.mapDateRange(query.dateRange) }),
+        });
+        const response = await fetch(`${this.baseUrl}?${params}`);
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(`Google CSE error: ${response.status} - ${error.error?.message || 'Unknown error'}`);
+        }
+        const data = await response.json();
+        return {
+            results: this.mapResults(data.items || [], searchType),
+            query: query.query,
+            searchType,
+            totalResults: data.searchInformation?.totalResults
+                ? parseInt(data.searchInformation.totalResults)
+                : undefined,
+            provider: 'google',
+        };
+    }
+    async testConnection() {
+        try {
+            await this.search({ query: 'test', maxResults: 1 });
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to connect to Google Custom Search',
+            };
+        }
+    }
+    mapDateRange(range) {
+        switch (range) {
+            case 'day':
+                return 'd1';
+            case 'week':
+                return 'w1';
+            case 'month':
+                return 'm1';
+            case 'year':
+                return 'y1';
+            default:
+                return 'w1';
+        }
+    }
+    mapResults(items, searchType) {
+        return items.map((item) => ({
+            title: item.title || '',
+            url: item.link || '',
+            snippet: item.snippet || '',
+            // Image-specific fields
+            ...(searchType === 'images' && {
+                thumbnailUrl: item.image?.thumbnailLink,
+                imageUrl: item.link,
+                width: item.image?.width,
+                height: item.image?.height,
+            }),
+            source: item.displayLink,
+        }));
+    }
+}
+exports.GoogleProvider = GoogleProvider;

package/dist/electron/electron/agent/search/index.js

@@ -0,0 +1,28 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchProviderFactory = exports.GoogleProvider = exports.SerpApiProvider = exports.BraveProvider = exports.TavilyProvider = void 0;
+__exportStar(require("./types"), exports);
+var tavily_provider_1 = require("./tavily-provider");
+Object.defineProperty(exports, "TavilyProvider", { enumerable: true, get: function () { return tavily_provider_1.TavilyProvider; } });
+var brave_provider_1 = require("./brave-provider");
+Object.defineProperty(exports, "BraveProvider", { enumerable: true, get: function () { return brave_provider_1.BraveProvider; } });
+var serpapi_provider_1 = require("./serpapi-provider");
+Object.defineProperty(exports, "SerpApiProvider", { enumerable: true, get: function () { return serpapi_provider_1.SerpApiProvider; } });
+var google_provider_1 = require("./google-provider");
+Object.defineProperty(exports, "GoogleProvider", { enumerable: true, get: function () { return google_provider_1.GoogleProvider; } });
+var provider_factory_1 = require("./provider-factory");
+Object.defineProperty(exports, "SearchProviderFactory", { enumerable: true, get: function () { return provider_factory_1.SearchProviderFactory; } });