@darbotlabs/darbot-browser-mcp 0.2.0 → 1.3.0

package/lib/tools/diagnostics.js

@@ -0,0 +1,132 @@
+/**
+ * Copyright (c) DarbotLabs.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { z } from 'zod';
+import { defineTool } from './tool.js';
+/**
+ * Enhanced console with filtering - builds on existing console tool
+ */
+const consoleFiltered = defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_console_filtered',
+        title: 'Autonomous filtered console',
+        description: 'Autonomously retrieve console messages filtered by type (log, error, warning, info, debug). Useful for focused debugging.',
+        inputSchema: z.object({
+            type: z.enum(['log', 'error', 'warning', 'info', 'debug', 'all']).optional().default('all').describe('Type of console messages to retrieve'),
+            limit: z.number().optional().default(100).describe('Maximum number of messages to return'),
+        }),
+        type: 'readOnly',
+    },
+    handle: async (context, params) => {
+        const tab = context.currentTabOrDie();
+        const messages = tab.consoleMessages();
+        let filtered = messages;
+        if (params.type && params.type !== 'all') {
+            filtered = messages.filter(msg => msg.type === params.type);
+        }
+        // Apply limit
+        filtered = filtered.slice(-params.limit);
+        const log = filtered.length > 0
+            ? filtered.map(msg => `[${(msg.type || 'unknown').toUpperCase()}] ${msg.text}`).join('\n')
+            : `No ${params.type === 'all' ? '' : params.type + ' '}console messages found.`;
+        return {
+            code: [`// <internal code to get filtered console messages: type=${params.type}, limit=${params.limit}>`],
+            action: async () => {
+                return {
+                    content: [{ type: 'text', text: log }]
+                };
+            },
+            captureSnapshot: false,
+            waitForNetwork: false,
+        };
+    },
+});
+/**
+ * Performance metrics tool - get performance timing information
+ */
+const performanceMetrics = defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_performance_metrics',
+        title: 'Autonomous performance analysis',
+        description: 'Autonomously retrieve performance metrics including page load times, DOM content loaded, and other timing data.',
+        inputSchema: z.object({}),
+        type: 'readOnly',
+    },
+    handle: async (context) => {
+        const tab = context.currentTabOrDie();
+        const code = [
+            `// Get performance metrics`,
+            `const metrics = await page.evaluate(() => JSON.stringify(performance.timing));`,
+        ];
+        const action = async () => {
+            const metrics = await tab.page.evaluate(() => {
+                const timing = performance.timing;
+                const navigation = performance.getEntriesByType('navigation')[0];
+                return {
+                    // Core Web Vitals related
+                    domContentLoaded: timing.domContentLoadedEventEnd - timing.navigationStart,
+                    loadComplete: timing.loadEventEnd - timing.navigationStart,
+                    domInteractive: timing.domInteractive - timing.navigationStart,
+                    // Network timing
+                    dnsLookup: timing.domainLookupEnd - timing.domainLookupStart,
+                    tcpConnection: timing.connectEnd - timing.connectStart,
+                    serverResponse: timing.responseEnd - timing.requestStart,
+                    // Additional metrics
+                    firstByte: timing.responseStart - timing.navigationStart,
+                    domParsing: timing.domComplete - timing.domLoading,
+                    // Navigation type
+                    navigationType: navigation?.type || 'unknown',
+                    redirectCount: navigation?.redirectCount || 0,
+                };
+            });
+            const output = [
+                '=== Performance Metrics ===',
+                '',
+                '📊 Core Timings:',
+                `  • DOM Content Loaded: ${metrics.domContentLoaded}ms`,
+                `  • Load Complete: ${metrics.loadComplete}ms`,
+                `  • DOM Interactive: ${metrics.domInteractive}ms`,
+                '',
+                '🌐 Network Timing:',
+                `  • DNS Lookup: ${metrics.dnsLookup}ms`,
+                `  • TCP Connection: ${metrics.tcpConnection}ms`,
+                `  • Server Response: ${metrics.serverResponse}ms`,
+                `  • Time to First Byte: ${metrics.firstByte}ms`,
+                '',
+                '📄 DOM Parsing:',
+                `  • DOM Parsing Time: ${metrics.domParsing}ms`,
+                '',
+                '🔄 Navigation:',
+                `  • Type: ${metrics.navigationType}`,
+                `  • Redirect Count: ${metrics.redirectCount}`,
+            ].join('\n');
+            return {
+                content: [{ type: 'text', text: output }]
+            };
+        };
+        return {
+            code,
+            action,
+            captureSnapshot: false,
+            waitForNetwork: false,
+        };
+    },
+});
+export default [
+    consoleFiltered,
+    performanceMetrics,
+];

package/lib/tools/dialogs.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Microsoft Corporation.
+ * Copyright (c) DarbotLabs.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

package/lib/tools/emulation.js

@@ -0,0 +1,155 @@
+/**
+ * Copyright (c) DarbotLabs.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { z } from 'zod';
+import { defineTool } from './tool.js';
+/**
+ * Media emulation tools - uses Playwright emulateMedia API
+ * Extended support for:
+ * - Color scheme emulation (light/dark)
+ * - Reduced motion emulation
+ * - Contrast emulation (v1.51+)
+ * - Print/screen media
+ */
+const emulateMedia = captureSnapshot => defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_emulate_media',
+        title: 'Autonomous media emulation',
+        description: 'Autonomously emulate media features like color scheme, reduced motion, contrast preference, and media type for accessibility and responsive testing.',
+        inputSchema: z.object({
+            colorScheme: z.enum(['light', 'dark', 'no-preference', 'null']).optional().describe('Emulate color scheme preference: light, dark, no-preference, or null to reset'),
+            reducedMotion: z.enum(['reduce', 'no-preference', 'null']).optional().describe('Emulate prefers-reduced-motion: reduce, no-preference, or null to reset'),
+            contrast: z.enum(['more', 'less', 'no-preference', 'null']).optional().describe('Emulate prefers-contrast: more, less, no-preference, or null to reset'),
+            media: z.enum(['screen', 'print', 'null']).optional().describe('Emulate media type: screen, print, or null to reset'),
+            forcedColors: z.enum(['active', 'none', 'null']).optional().describe('Emulate forced-colors: active, none, or null to reset'),
+        }),
+        type: 'readOnly',
+    },
+    handle: async (context, params) => {
+        const tab = context.currentTabOrDie();
+        const options = {};
+        if (params.colorScheme !== undefined)
+            options.colorScheme = params.colorScheme === 'null' ? null : params.colorScheme;
+        if (params.reducedMotion !== undefined)
+            options.reducedMotion = params.reducedMotion === 'null' ? null : params.reducedMotion;
+        if (params.contrast !== undefined)
+            options.contrast = params.contrast === 'null' ? null : params.contrast;
+        if (params.media !== undefined)
+            options.media = params.media === 'null' ? null : params.media;
+        if (params.forcedColors !== undefined)
+            options.forcedColors = params.forcedColors === 'null' ? null : params.forcedColors;
+        const optionsStr = Object.entries(options)
+            .filter(([_, v]) => v !== undefined)
+            .map(([k, v]) => `${k}: ${v === null ? 'null' : `'${v}'`}`)
+            .join(', ');
+        const code = [
+            `// Emulate media features: ${optionsStr}`,
+            `await page.emulateMedia({ ${optionsStr} });`,
+        ];
+        const action = async () => {
+            await tab.page.emulateMedia(options);
+        };
+        return {
+            code,
+            action,
+            captureSnapshot,
+            waitForNetwork: false,
+        };
+    },
+});
+/**
+ * Geolocation emulation
+ */
+const emulateGeolocation = captureSnapshot => defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_emulate_geolocation',
+        title: 'Autonomous geolocation emulation',
+        description: 'Autonomously emulate a geographic location for location-based testing.',
+        inputSchema: z.object({
+            latitude: z.number().min(-90).max(90).describe('Latitude between -90 and 90'),
+            longitude: z.number().min(-180).max(180).describe('Longitude between -180 and 180'),
+            accuracy: z.number().optional().describe('Accuracy in meters. Defaults to 0.'),
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => {
+        const tab = context.currentTabOrDie();
+        const browserContext = tab.page.context();
+        const code = [
+            `// Emulate geolocation: ${params.latitude}, ${params.longitude}`,
+            `await context.setGeolocation({ latitude: ${params.latitude}, longitude: ${params.longitude}${params.accuracy ? `, accuracy: ${params.accuracy}` : ''} });`,
+        ];
+        const action = async () => {
+            await browserContext.setGeolocation({
+                latitude: params.latitude,
+                longitude: params.longitude,
+                accuracy: params.accuracy,
+            });
+        };
+        return {
+            code,
+            action,
+            captureSnapshot,
+            waitForNetwork: false,
+        };
+    },
+});
+/**
+ * Timezone emulation
+ */
+const emulateTimezone = captureSnapshot => defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_emulate_timezone',
+        title: 'Autonomous timezone emulation',
+        description: 'Autonomously change the browser timezone for testing time-sensitive features.',
+        inputSchema: z.object({
+            timezoneId: z.string().describe('Timezone ID (e.g., "America/New_York", "Europe/London", "Asia/Tokyo")'),
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => {
+        const tab = context.currentTabOrDie();
+        const browserContext = tab.page.context();
+        const code = [
+            `// Emulate timezone: ${params.timezoneId}`,
+            `await context.setDefaultTimezone('${params.timezoneId}');`,
+        ];
+        // Note: Playwright doesn't have setDefaultTimezone - we need to use emulateTimezone differently
+        // This would need to be set at context creation time, so we'll add JavaScript injection instead
+        const action = async () => {
+            await browserContext.addInitScript(`
+        const originalDateTimeFormat = Intl.DateTimeFormat;
+        Intl.DateTimeFormat = function(locale, options = {}) {
+          options.timeZone = '${params.timezoneId}';
+          return new originalDateTimeFormat(locale, options);
+        };
+      `);
+        };
+        return {
+            code,
+            action,
+            captureSnapshot,
+            waitForNetwork: false,
+        };
+    },
+});
+export default (captureSnapshot) => [
+    emulateMedia(captureSnapshot),
+    emulateGeolocation(captureSnapshot),
+    emulateTimezone(captureSnapshot),
+];

package/lib/tools/files.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Microsoft Corporation.
+ * Copyright (c) DarbotLabs.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

package/lib/tools/install.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Microsoft Corporation.
+ * Copyright (c) DarbotLabs.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

package/lib/tools/keyboard.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Microsoft Corporation.
+ * Copyright (c) DarbotLabs.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

package/lib/tools/navigate.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Microsoft Corporation.
+ * Copyright (c) DarbotLabs.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

package/lib/tools/network.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Microsoft Corporation.
+ * Copyright (c) DarbotLabs.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

package/lib/tools/pageSnapshot.js

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) DarbotLabs.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { callOnPageNoTrace } from './utils.js';
+export class PageSnapshot {
+    _page;
+    _text;
+    constructor(page) {
+        this._page = page;
+    }
+    static async create(page) {
+        const snapshot = new PageSnapshot(page);
+        await snapshot._build();
+        return snapshot;
+    }
+    text() {
+        return this._text;
+    }
+    async _build() {
+        const snapshotResult = await callOnPageNoTrace(this._page, page => page._snapshotForAI());
+        // Handle both old (string) and new (object with full property) Playwright snapshot formats
+        let snapshot;
+        if (typeof snapshotResult === 'string') {
+            snapshot = snapshotResult;
+        }
+        else if (snapshotResult && typeof snapshotResult === 'object') {
+            // Try different known property names for the snapshot text
+            snapshot = snapshotResult.full
+                ?? snapshotResult.text
+                ?? snapshotResult.snapshot
+                ?? JSON.stringify(snapshotResult, null, 2);
+        }
+        else {
+            snapshot = String(snapshotResult);
+        }
+        this._text = [
+            `- Page Snapshot`,
+            '```yaml',
+            snapshot,
+            '```',
+        ].join('\n');
+    }
+    refLocator(params) {
+        return this._page.locator(`aria-ref=${params.ref}`).describe(params.element);
+    }
+}

package/lib/tools/pdf.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Microsoft Corporation.
+ * Copyright (c) DarbotLabs.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

package/lib/tools/profiles.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Microsoft Corporation.
+ * Copyright (c) DarbotLabs.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,15 +20,15 @@ import { z } from 'zod';
 import { defineTool } from './tool.js';
 import { sanitizeForFilePath } from './utils.js';
 const saveProfileSchema = z.object({
-    name: z.string().describe('Name for the work profile'),
-    description: z.string().optional().describe('Optional description for the work profile'),
+    name: z.string().describe('Name for the session state'),
+    description: z.string().optional().describe('Optional description for the session state'),
 });
 const switchProfileSchema = z.object({
-    name: z.string().describe('Name of the work profile to switch to'),
+    name: z.string().describe('Name of the session state to restore'),
 });
 const listProfilesSchema = z.object({});
 const deleteProfileSchema = z.object({
-    name: z.string().describe('Name of the work profile to delete'),
+    name: z.string().describe('Name of the session state to delete'),
 });
 async function getProfilesDir() {
     let profilesDir;
@@ -40,7 +40,7 @@ async function getProfilesDir() {
         profilesDir = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
     else
         throw new Error('Unsupported platform: ' + process.platform);
-    const result = path.join(profilesDir, 'darbot-browser-mcp', 'work-profiles');
+    const result = path.join(profilesDir, 'darbot-browser-mcp', 'session-states');
     await fs.promises.mkdir(result, { recursive: true });
     return result;
 }
@@ -53,8 +53,27 @@ async function saveCurrentProfile(context, profileName, description) {
     const tab = context.currentTabOrDie();
     const url = tab.page.url();
     const title = await tab.title();
-    // Save profile metadata
+    // Detect Edge profile info from environment/config
+    const edgeProfile = process.env.DARBOT_EDGE_PROFILE || 'default';
+    const edgeProfileEmail = process.env.DARBOT_EDGE_PROFILE_EMAIL || undefined;
+    const workspacePath = process.env.VSCODE_WORKSPACE_FOLDER || process.env.PWD || undefined;
+    const workspaceName = workspacePath ? path.basename(workspacePath) : undefined;
+    // Save session state metadata with unified header
     const profileData = {
+        // Unified header
+        version: '2.0',
+        type: 'darbot-session-state',
+        // Edge profile context
+        edgeProfile: {
+            name: edgeProfile,
+            email: edgeProfileEmail,
+        },
+        // VS Code workspace context (if launched from VS Code)
+        workspace: workspacePath ? {
+            path: workspacePath,
+            name: workspaceName,
+        } : undefined,
+        // Session state details
         name: profileName,
         description: description || '',
         created: new Date().toISOString(),
@@ -82,7 +101,7 @@ async function loadProfile(context, profileName) {
         await fs.promises.access(profileDir);
     }
     catch {
-        throw new Error(`Work profile "${profileName}" not found`);
+        throw new Error(`Session state "${profileName}" not found`);
     }
     // Load profile metadata
     const profileDataPath = path.join(profileDir, 'profile.json');
@@ -95,9 +114,8 @@ async function loadProfile(context, profileName) {
         // Create new context with the stored state
         const tab = await context.ensureTab();
         const currentContext = tab.page.context();
-        if (currentContext) {
+        if (currentContext)
             await currentContext.close();
-        }
         const newContext = await tab.page.context().browser()?.newContext({
             storageState,
             viewport: null,
@@ -151,7 +169,7 @@ async function deleteProfile(profileName) {
         await fs.promises.access(profileDir);
     }
     catch {
-        throw new Error(`Work profile "${profileName}" not found`);
+        throw new Error(`Session state "${profileName}" not found`);
     }
     await fs.promises.rm(profileDir, { recursive: true, force: true });
 }
@@ -159,13 +177,25 @@ export const browserSaveProfile = defineTool({
     capability: 'core',
     schema: {
         name: 'browser_save_profile',
-        title: 'Autonomous profile saving',
-        description: 'Autonomously save the current browser state as a reusable work profile for later restoration',
+        title: 'Save session state',
+        description: 'Save the current browser session state (cookies, localStorage, URL) for later restoration. Includes Edge profile and VS Code workspace context.',
         inputSchema: saveProfileSchema,
         type: 'destructive',
     },
     handle: async (context, { name, description }) => {
         const profileData = await saveCurrentProfile(context, name, description);
+        let text = `Session state "${name}" saved successfully.\n\n`;
+        text += `### Session State Details\n`;
+        text += `- **Name:** ${profileData.name}\n`;
+        if (profileData.description)
+            text += `- **Description:** ${profileData.description}\n`;
+        text += `- **URL:** ${profileData.url}\n`;
+        text += `- **Title:** ${profileData.title}\n`;
+        text += `- **Created:** ${profileData.created}\n\n`;
+        text += `### Context\n`;
+        text += `- **Edge Profile:** ${profileData.edgeProfile.name}${profileData.edgeProfile.email ? ` (${profileData.edgeProfile.email})` : ''}\n`;
+        if (profileData.workspace)
+            text += `- **VS Code Workspace:** ${profileData.workspace.name} (${profileData.workspace.path})\n`;
         return {
             code: [`await browser_save_profile({ name: '${name}', description: '${description || ''}' })`],
             action: async () => ({ content: [] }),
@@ -174,7 +204,7 @@ export const browserSaveProfile = defineTool({
             resultOverride: {
                 content: [{
                         type: 'text',
-                        text: `Work profile "${name}" saved successfully.\n\nProfile details:\n- Name: ${profileData.name}\n- Description: ${profileData.description}\n- URL: ${profileData.url}\n- Title: ${profileData.title}\n- Created: ${profileData.created}`,
+                        text,
                     }],
             },
         };
@@ -184,13 +214,28 @@ export const browserSwitchProfile = defineTool({
     capability: 'core',
     schema: {
         name: 'browser_switch_profile',
-        title: 'Autonomous profile switching',
-        description: 'Autonomously switch to a previously saved work profile, restoring browser state and session',
+        title: 'Restore session state',
+        description: 'Restore a previously saved session state, including cookies, localStorage, and navigate to the saved URL',
         inputSchema: switchProfileSchema,
         type: 'destructive',
     },
     handle: async (context, { name }) => {
         const result = await loadProfile(context, name);
+        const pd = result.profileData;
+        let text = `Session state "${name}" restored.\n\n`;
+        text += `### Session State Details\n`;
+        text += `- **Name:** ${pd.name}\n`;
+        if (pd.description)
+            text += `- **Description:** ${pd.description}\n`;
+        text += `- **URL:** ${pd.url}\n`;
+        text += `- **Title:** ${pd.title}\n`;
+        text += `- **Storage:** ${result.restored ? 'Fully restored' : 'URL only (storage not available)'}\n\n`;
+        if (pd.edgeProfile) {
+            text += `### Original Context\n`;
+            text += `- **Edge Profile:** ${pd.edgeProfile.name}${pd.edgeProfile.email ? ` (${pd.edgeProfile.email})` : ''}\n`;
+        }
+        if (pd.workspace)
+            text += `- **VS Code Workspace:** ${pd.workspace.name}\n`;
         return {
             code: [`await browser_switch_profile({ name: '${name}' })`],
             action: async () => ({ content: [] }),
@@ -199,7 +244,7 @@ export const browserSwitchProfile = defineTool({
             resultOverride: {
                 content: [{
                         type: 'text',
-                        text: `Switched to work profile "${name}".\n\nProfile details:\n- Name: ${result.profileData.name}\n- Description: ${result.profileData.description}\n- URL: ${result.profileData.url}\n- Title: ${result.profileData.title}\n- Storage state ${result.restored ? 'restored' : 'not available'}`,
+                        text,
                     }],
             },
         };
@@ -209,16 +254,16 @@ export const browserListProfiles = defineTool({
     capability: 'core',
     schema: {
         name: 'browser_list_profiles',
-        title: 'Autonomous profile listing',
-        description: 'Autonomously list all saved work profiles with their details and creation information',
+        title: 'List session states',
+        description: 'List all saved Darbot session states with their Edge profile context and workspace information',
         inputSchema: listProfilesSchema,
         type: 'readOnly',
     },
     handle: async (context, {}) => {
         const profiles = await listProfiles();
-        let text = '### Saved Work Profiles\n\n';
+        let text = '### Saved Darbot Session States\n\n';
         if (profiles.length === 0) {
-            text += 'No work profiles saved yet. Use the "browser_save_profile" tool to save your current browser state as a work profile.';
+            text += 'No session states saved yet. Use the "browser_save_profile" tool to save your current browser session state.';
         }
         else {
             for (const profile of profiles) {
@@ -227,7 +272,13 @@ export const browserListProfiles = defineTool({
                     text += `- Description: ${profile.description}\n`;
                 text += `- URL: ${profile.url}\n`;
                 text += `- Title: ${profile.title}\n`;
-                text += `- Created: ${new Date(profile.created).toLocaleString()}\n\n`;
+                text += `- Created: ${new Date(profile.created).toLocaleString()}\n`;
+                // Show Edge profile context if available (v2.0+ session states)
+                if (profile.edgeProfile)
+                    text += `- Edge Profile: ${profile.edgeProfile.name}${profile.edgeProfile.email ? ` (${profile.edgeProfile.email})` : ''}\n`;
+                if (profile.workspace)
+                    text += `- Workspace: ${profile.workspace.name}\n`;
+                text += '\n';
             }
         }
         return {
@@ -248,8 +299,8 @@ export const browserDeleteProfile = defineTool({
     capability: 'core',
     schema: {
         name: 'browser_delete_profile',
-        title: 'Autonomous profile deletion',
-        description: 'Autonomously delete a saved work profile permanently from storage',
+        title: 'Delete session state',
+        description: 'Permanently delete a saved session state from storage',
         inputSchema: deleteProfileSchema,
         type: 'destructive',
     },
@@ -263,7 +314,7 @@ export const browserDeleteProfile = defineTool({
             resultOverride: {
                 content: [{
                         type: 'text',
-                        text: `Work profile "${name}" deleted successfully.`,
+                        text: `Session state "${name}" deleted successfully.`,
                     }],
             },
         };

package/lib/tools/screenshot.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Microsoft Corporation.
+ * Copyright (c) DarbotLabs.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.