cowork-os 0.3.21 → 0.3.23

package/dist/electron/electron/agent/tools/sharepoint-tools.js

@@ -0,0 +1,243 @@
+"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.SharePointTools = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const sharepoint_manager_1 = require("../../settings/sharepoint-manager");
+const sharepoint_api_1 = require("../../utils/sharepoint-api");
+class SharePointTools {
+    constructor(workspace, daemon, taskId) {
+        this.workspace = workspace;
+        this.daemon = daemon;
+        this.taskId = taskId;
+    }
+    setWorkspace(workspace) {
+        this.workspace = workspace;
+    }
+    static isEnabled() {
+        return sharepoint_manager_1.SharePointSettingsManager.loadSettings().enabled;
+    }
+    async requireApproval(summary, details) {
+        const approved = await this.daemon.requestApproval(this.taskId, 'external_service', summary, details);
+        if (!approved) {
+            throw new Error('User denied SharePoint action');
+        }
+    }
+    resolveFilePath(inputPath) {
+        if (!this.workspace.permissions.read) {
+            throw new Error('Read permission not granted for uploads');
+        }
+        const workspaceRoot = path.resolve(this.workspace.path);
+        const allowedPaths = this.workspace.permissions.allowedPaths || [];
+        const canReadOutside = this.workspace.isTemp || this.workspace.permissions.unrestrictedFileAccess;
+        const isPathAllowed = (absolutePath) => {
+            if (allowedPaths.length === 0)
+                return false;
+            const normalizedPath = path.normalize(absolutePath);
+            return allowedPaths.some((allowed) => {
+                const normalizedAllowed = path.normalize(allowed);
+                return normalizedPath === normalizedAllowed || normalizedPath.startsWith(normalizedAllowed + path.sep);
+            });
+        };
+        const candidate = path.isAbsolute(inputPath)
+            ? path.normalize(inputPath)
+            : path.resolve(workspaceRoot, inputPath);
+        const relative = path.relative(workspaceRoot, candidate);
+        const isInsideWorkspace = !(relative.startsWith('..') || path.isAbsolute(relative));
+        if (!isInsideWorkspace && !canReadOutside && !isPathAllowed(candidate)) {
+            throw new Error('File path must be inside the workspace or in Allowed Paths');
+        }
+        if (!fs.existsSync(candidate)) {
+            throw new Error(`File not found: ${inputPath}`);
+        }
+        const stats = fs.statSync(candidate);
+        if (!stats.isFile()) {
+            throw new Error(`Path is not a file: ${inputPath}`);
+        }
+        return candidate;
+    }
+    getSiteId(inputSiteId) {
+        const settings = sharepoint_manager_1.SharePointSettingsManager.loadSettings();
+        const siteId = inputSiteId || settings.siteId;
+        if (!siteId) {
+            throw new Error('Missing site_id. Provide it in settings or the tool input.');
+        }
+        return siteId;
+    }
+    getDriveId(inputDriveId) {
+        const settings = sharepoint_manager_1.SharePointSettingsManager.loadSettings();
+        const driveId = inputDriveId || settings.driveId;
+        if (!driveId) {
+            throw new Error('Missing drive_id. Provide it in settings or the tool input.');
+        }
+        return driveId;
+    }
+    async executeAction(input) {
+        const settings = sharepoint_manager_1.SharePointSettingsManager.loadSettings();
+        if (!settings.enabled) {
+            throw new Error('SharePoint integration is disabled. Enable it in Settings > Integrations > SharePoint.');
+        }
+        const action = input.action;
+        if (!action) {
+            throw new Error('Missing required "action" parameter');
+        }
+        let result;
+        switch (action) {
+            case 'get_current_user': {
+                result = await (0, sharepoint_api_1.sharepointRequest)(settings, { method: 'GET', path: '/me' });
+                break;
+            }
+            case 'search_sites': {
+                if (!input.query)
+                    throw new Error('Missing query for search_sites');
+                result = await (0, sharepoint_api_1.sharepointRequest)(settings, {
+                    method: 'GET',
+                    path: '/sites',
+                    query: { search: input.query },
+                });
+                break;
+            }
+            case 'get_site': {
+                const siteId = this.getSiteId(input.site_id);
+                result = await (0, sharepoint_api_1.sharepointRequest)(settings, { method: 'GET', path: `/sites/${siteId}` });
+                break;
+            }
+            case 'list_site_drives': {
+                const siteId = this.getSiteId(input.site_id);
+                result = await (0, sharepoint_api_1.sharepointRequest)(settings, { method: 'GET', path: `/sites/${siteId}/drives` });
+                break;
+            }
+            case 'list_drive_items': {
+                const driveId = this.getDriveId(input.drive_id);
+                const pathSuffix = input.item_id ? `/items/${input.item_id}/children` : '/root/children';
+                result = await (0, sharepoint_api_1.sharepointRequest)(settings, { method: 'GET', path: `/drives/${driveId}${pathSuffix}` });
+                break;
+            }
+            case 'get_item': {
+                if (!input.item_id)
+                    throw new Error('Missing item_id for get_item');
+                const driveId = this.getDriveId(input.drive_id);
+                result = await (0, sharepoint_api_1.sharepointRequest)(settings, { method: 'GET', path: `/drives/${driveId}/items/${input.item_id}` });
+                break;
+            }
+            case 'create_folder': {
+                if (!input.name)
+                    throw new Error('Missing name for create_folder');
+                const driveId = this.getDriveId(input.drive_id);
+                const parentPath = input.parent_id
+                    ? `/items/${input.parent_id}/children`
+                    : '/root/children';
+                await this.requireApproval('Create a SharePoint folder', {
+                    action: 'create_folder',
+                    parent_id: input.parent_id || 'root',
+                    name: input.name,
+                });
+                result = await (0, sharepoint_api_1.sharepointRequest)(settings, {
+                    method: 'POST',
+                    path: `/drives/${driveId}${parentPath}`,
+                    body: {
+                        name: input.name,
+                        folder: {},
+                        '@microsoft.graph.conflictBehavior': input.conflict_behavior || 'rename',
+                    },
+                });
+                break;
+            }
+            case 'upload_file': {
+                if (!input.file_path)
+                    throw new Error('Missing file_path for upload_file');
+                const driveId = this.getDriveId(input.drive_id);
+                const resolved = this.resolveFilePath(input.file_path);
+                const data = fs.readFileSync(resolved);
+                const fileName = input.name || path.basename(resolved);
+                let uploadPath;
+                if (input.remote_path) {
+                    const cleaned = input.remote_path.replace(/^\/+/, '');
+                    const encoded = cleaned
+                        .split('/')
+                        .map(segment => encodeURIComponent(segment))
+                        .join('/');
+                    uploadPath = `/drives/${driveId}/root:/${encoded}:/content`;
+                }
+                else if (input.parent_id) {
+                    uploadPath = `/drives/${driveId}/items/${input.parent_id}:/${encodeURIComponent(fileName)}:/content`;
+                }
+                else {
+                    uploadPath = `/drives/${driveId}/root:/${encodeURIComponent(fileName)}:/content`;
+                }
+                await this.requireApproval(`Upload file to SharePoint: ${fileName}`, {
+                    action: 'upload_file',
+                    destination: input.remote_path || input.parent_id || 'root',
+                    file: fileName,
+                });
+                result = await (0, sharepoint_api_1.sharepointRequest)(settings, {
+                    method: 'PUT',
+                    path: uploadPath,
+                    body: data,
+                    headers: { 'Content-Type': 'application/octet-stream' },
+                });
+                break;
+            }
+            case 'delete_item': {
+                if (!input.item_id)
+                    throw new Error('Missing item_id for delete_item');
+                const driveId = this.getDriveId(input.drive_id);
+                await this.requireApproval('Delete a SharePoint item', {
+                    action: 'delete_item',
+                    item_id: input.item_id,
+                });
+                result = await (0, sharepoint_api_1.sharepointRequest)(settings, { method: 'DELETE', path: `/drives/${driveId}/items/${input.item_id}` });
+                break;
+            }
+            default:
+                throw new Error(`Unsupported action: ${action}`);
+        }
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'sharepoint_action',
+            action,
+            status: result?.status,
+            hasData: result?.data ? true : false,
+        });
+        return {
+            success: true,
+            action,
+            status: result?.status,
+            data: result?.data,
+            raw: result?.raw,
+        };
+    }
+}
+exports.SharePointTools = SharePointTools;

package/dist/electron/electron/agent/tools/shell-tools.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports._testUtils = exports.ShellTools = void 0;
 const child_process_1 = require("child_process");
 const guardrail_manager_1 = require("../../guardrails/guardrail-manager");
+const builtin_settings_1 = require("./builtin-settings");
 // Limits to prevent runaway commands
 const MAX_TIMEOUT = 5 * 60 * 1000; // 5 minutes max
 const DEFAULT_TIMEOUT = 60 * 1000; // 1 minute default
@@ -321,9 +322,9 @@ class ShellTools {
         }
     }
     /**
-     * Execute a shell command (requires user approval)
+     * Execute a shell command (requires user approval unless auto-approve is enabled)
      * Note: We don't check workspace.permissions.shell here because
-     * shell commands always require explicit user approval via requestApproval()
+     * shell commands are gated by approval flow (or auto-approve/trust settings)
      */
     async runCommand(command, options) {
         // Check if command is blocked by guardrails BEFORE anything else
@@ -335,8 +336,16 @@ class ShellTools {
         }
         // Check if command is trusted (auto-approve without user confirmation)
         const trustCheck = guardrail_manager_1.GuardrailManager.isCommandTrusted(command);
+        const autoApproveEnabled = builtin_settings_1.BuiltinToolsSettingsManager.getToolAutoApprove('run_command');
         let approved = false;
-        if (trustCheck.trusted) {
+        if (autoApproveEnabled && this.isAutoApprovalSafe(command)) {
+            approved = true;
+            this.daemon.logEvent(this.taskId, 'log', {
+                message: 'Auto-approved command (user setting enabled)',
+                command,
+            });
+        }
+        else if (trustCheck.trusted) {
             // Auto-approve trusted commands
             approved = true;
             this.daemon.logEvent(this.taskId, 'log', {

package/dist/electron/electron/agent/tools/x-tools.js

@@ -111,7 +111,7 @@ class XTools {
     async executeAction(input) {
         const settings = x_manager_1.XSettingsManager.loadSettings();
         if (!settings.enabled) {
-            throw new Error('X integration is disabled. Enable it in Settings > More Channels > X.');
+            throw new Error('X integration is disabled. Enable it in Settings > X (Twitter).');
         }
         const action = input.action;
         if (!action) {

package/dist/electron/electron/gateway/index.js

@@ -77,6 +77,7 @@ class ChannelGateway {
                     agentName: settings.agentName || 'CoWork',
                     userName: settings.relationship?.userName,
                     personality: settings.activePersonality || 'professional',
+                    persona: settings.activePersona,
                     emojiUsage: settings.responseStyle?.emojiUsage || 'minimal',
                     quirks: settings.quirks || types_1.DEFAULT_QUIRKS,
                 };