scalix 1.0.0 → 1.1.0

package/dist/tools-browser.js

@@ -12,7 +12,6 @@ async function getPlaywright() {
     if (playwrightAvailable === false)
         return null;
     try {
-        // @ts-expect-error playwright is an optional peer dependency
         const pw = await import('playwright');
         playwrightAvailable = true;
         return pw;
@@ -95,20 +94,62 @@ export const browserNavigateTool = tool({
         }
     },
 });
+const ANNOTATION_SCRIPT = `(() => {
+  const selectors = 'a, button, input, select, textarea, [role="button"], [onclick], [tabindex]:not([tabindex="-1"])';
+  const elements = [...document.querySelectorAll(selectors)].filter(el => {
+    const rect = el.getBoundingClientRect();
+    const style = window.getComputedStyle(el);
+    return rect.width > 0 && rect.height > 0 && style.display !== 'none' && style.visibility !== 'hidden';
+  });
+  const overlay = document.createElement('div');
+  overlay.id = '__scalix_annotations__';
+  overlay.style.cssText = 'position:fixed;top:0;left:0;width:100%;height:100%;pointer-events:none;z-index:2147483647';
+  const annotations = [];
+  elements.forEach((el, i) => {
+    const rect = el.getBoundingClientRect();
+    const idx = i + 1;
+    const box = document.createElement('div');
+    box.style.cssText = 'position:fixed;border:2px solid red;pointer-events:none;box-sizing:border-box;'
+      + 'left:' + rect.left + 'px;top:' + rect.top + 'px;width:' + rect.width + 'px;height:' + rect.height + 'px';
+    const label = document.createElement('span');
+    label.textContent = String(idx);
+    label.style.cssText = 'position:absolute;top:-14px;left:-2px;background:red;color:white;font:bold 10px sans-serif;padding:1px 3px;border-radius:2px;line-height:12px';
+    box.appendChild(label);
+    overlay.appendChild(box);
+    annotations.push({
+      index: idx,
+      tag: el.tagName.toLowerCase(),
+      text: (el.textContent || el.getAttribute('placeholder') || el.getAttribute('aria-label') || '').trim().slice(0, 60),
+      x: Math.round(rect.left),
+      y: Math.round(rect.top),
+      width: Math.round(rect.width),
+      height: Math.round(rect.height),
+      centerX: Math.round(rect.left + rect.width / 2),
+      centerY: Math.round(rect.top + rect.height / 2),
+    });
+  });
+  document.body.appendChild(overlay);
+  return annotations;
+})()`;
 export const browserScreenshotTool = tool({
     name: 'browser_screenshot',
-    description: 'Take a screenshot of the current browser page. Returns the image as a base64 data URL for vision analysis.',
+    description: 'Take a screenshot of the current browser page. Returns the image as a base64 data URL for vision analysis. Use annotate=true to overlay numbered markers on all interactive elements with their coordinates.',
     inputSchema: z.object({
         fullPage: z.boolean().optional().describe('Capture full scrollable page (default: false, viewport only)'),
         selector: z.string().max(500).optional().describe('CSS selector to screenshot a specific element'),
         outputPath: z.string().max(500).optional().describe('Save screenshot to file (default: temporary)'),
+        annotate: z.boolean().optional().describe('Overlay numbered markers on interactive elements with coordinates (default: false)'),
     }),
-    execute: async ({ fullPage, selector, outputPath }) => {
+    execute: async ({ fullPage, selector, outputPath, annotate }) => {
         const session = await ensureBrowser();
         if (!session) {
             return { error: 'Browser not running. Use browser_navigate first.' };
         }
         try {
+            let annotations;
+            if (annotate) {
+                annotations = await session.page.evaluate(ANNOTATION_SCRIPT);
+            }
             const outPath = outputPath
                 ? sandboxPath(outputPath)
                 : path.join(process.cwd(), '.scalix', `browser-${Date.now()}.png`);
@@ -122,17 +163,31 @@ export const browserScreenshotTool = tool({
             else {
                 await session.page.screenshot({ path: outPath, fullPage: fullPage ?? false });
             }
-            const dataUrl = await encodeImageToDataUrl(outPath);
-            const stat = await fs.stat(outPath);
-            if (!outputPath) {
-                await fs.unlink(outPath).catch(() => { });
+            let dataUrl;
+            let size;
+            try {
+                dataUrl = await encodeImageToDataUrl(outPath);
+                size = (await fs.stat(outPath)).size;
+            }
+            finally {
+                if (!outputPath) {
+                    await fs.unlink(outPath).catch(() => { });
+                }
+            }
+            if (annotate) {
+                await session.page.evaluate(() => {
+                    const overlay = document.getElementById('__scalix_annotations__');
+                    if (overlay)
+                        overlay.remove();
+                });
             }
             return {
                 url: session.page.url(),
                 title: await session.page.title(),
                 path: outputPath || undefined,
-                size: stat.size,
+                size,
                 dataUrl,
+                annotations,
             };
         }
         catch (error) {
@@ -142,35 +197,92 @@ export const browserScreenshotTool = tool({
 });
 export const browserClickTool = tool({
     name: 'browser_click',
-    description: 'Click an element on the current browser page by CSS selector or text content.',
+    description: 'Click an element on the current browser page by CSS selector, text content, or pixel coordinates. Use coordinates after taking an annotated screenshot to click at precise positions.',
     inputSchema: z.object({
         selector: z.string().max(500).optional().describe('CSS selector to click'),
         text: z.string().max(200).optional().describe('Click element containing this text'),
+        x: z.number().optional().describe('X pixel coordinate to click at'),
+        y: z.number().optional().describe('Y pixel coordinate to click at'),
         button: z.enum(['left', 'right', 'middle']).optional().describe('Mouse button (default: left)'),
     }),
-    execute: async ({ selector, text, button }) => {
+    execute: async ({ selector, text, x, y, button }) => {
         const session = await ensureBrowser();
         if (!session) {
             return { error: 'Browser not running. Use browser_navigate first.' };
         }
         try {
-            if (text) {
-                await session.page.getByText(text, { exact: false }).first().click({ button: button || 'left', timeout: 10_000 });
+            const btn = button || 'left';
+            if (typeof x === 'number' && typeof y === 'number') {
+                await session.page.mouse.click(x, y, { button: btn });
+            }
+            else if (text) {
+                await session.page.getByText(text, { exact: false }).first().click({ button: btn, timeout: 10_000 });
             }
             else if (selector) {
-                await session.page.click(selector, { button: button || 'left', timeout: 10_000 });
+                await session.page.click(selector, { button: btn, timeout: 10_000 });
             }
             else {
-                return { error: 'Provide either selector or text to click' };
+                return { error: 'Provide selector, text, or x/y coordinates to click' };
             }
             await session.page.waitForTimeout(500);
-            return { clicked: selector || `text:"${text}"`, url: session.page.url() };
+            const target = typeof x === 'number' ? `coords:(${x},${y})` : selector || `text:"${text}"`;
+            return { clicked: target, url: session.page.url() };
         }
         catch (error) {
             return { error: `Click failed: ${error.message}` };
         }
     },
 });
+export const browserMouseTool = tool({
+    name: 'browser_mouse',
+    description: 'Perform mouse operations at specific pixel coordinates. Use after taking a screenshot to identify target positions. Supports hover, double-click, drag, and scroll.',
+    inputSchema: z.object({
+        action: z.enum(['hover', 'doubleclick', 'drag', 'scroll']).describe('Mouse action to perform'),
+        x: z.number().describe('X pixel coordinate'),
+        y: z.number().describe('Y pixel coordinate'),
+        toX: z.number().optional().describe('Drag destination X coordinate'),
+        toY: z.number().optional().describe('Drag destination Y coordinate'),
+        scrollX: z.number().optional().describe('Horizontal scroll amount in pixels'),
+        scrollY: z.number().optional().describe('Vertical scroll amount in pixels'),
+    }),
+    execute: async ({ action, x, y, toX, toY, scrollX, scrollY }) => {
+        const session = await ensureBrowser();
+        if (!session) {
+            return { error: 'Browser not running. Use browser_navigate first.' };
+        }
+        try {
+            switch (action) {
+                case 'hover':
+                    await session.page.mouse.move(x, y);
+                    break;
+                case 'doubleclick':
+                    await session.page.mouse.dblclick(x, y);
+                    await session.page.waitForTimeout(500);
+                    break;
+                case 'drag': {
+                    if (typeof toX !== 'number' || typeof toY !== 'number') {
+                        return { error: 'Drag requires toX and toY coordinates' };
+                    }
+                    await session.page.mouse.move(x, y);
+                    await session.page.mouse.down();
+                    await session.page.mouse.move(toX, toY, { steps: 10 });
+                    await session.page.mouse.up();
+                    await session.page.waitForTimeout(500);
+                    break;
+                }
+                case 'scroll':
+                    await session.page.mouse.move(x, y);
+                    await session.page.mouse.wheel(scrollX ?? 0, scrollY ?? 0);
+                    await session.page.waitForTimeout(300);
+                    break;
+            }
+            return { action, x, y, url: session.page.url() };
+        }
+        catch (error) {
+            return { error: `Mouse ${action} failed: ${error.message}` };
+        }
+    },
+});
 export const browserTypeTool = tool({
     name: 'browser_type',
     description: 'Type text into an input field on the current browser page.',
@@ -253,21 +365,170 @@ export const browserGetTextTool = tool({
         }
     },
 });
-export const browserCloseTool = tool({
-    name: 'browser_close',
-    description: 'Close the browser instance and free resources.',
+const SESSION_DIR = '.scalix/browser-sessions';
+async function saveSessionState(name) {
+    if (!browserContext || !browserPage) {
+        throw new Error('No active browser session to save');
+    }
+    const storageState = await browserContext.storageState();
+    const url = browserPage.url();
+    const sessionDir = path.join(process.cwd(), SESSION_DIR);
+    await fs.mkdir(sessionDir, { recursive: true });
+    const sessionPath = path.join(sessionDir, `${name}.json`);
+    let existing = null;
+    try {
+        existing = JSON.parse(await fs.readFile(sessionPath, 'utf-8'));
+    }
+    catch { }
+    const session = {
+        name,
+        url,
+        storageState,
+        createdAt: existing?.createdAt ?? Date.now(),
+        updatedAt: Date.now(),
+        viewport: { width: 1280, height: 720 },
+    };
+    await fs.writeFile(sessionPath, JSON.stringify(session, null, 2));
+    return session;
+}
+export const browserSessionSaveTool = tool({
+    name: 'browser_session_save',
+    description: 'Save the current browser session (cookies, localStorage, URL) to disk for later restoration.',
+    inputSchema: z.object({
+        name: z.string().max(100).describe('Session name (used to restore later)'),
+    }),
+    execute: async ({ name }) => {
+        try {
+            const session = await saveSessionState(name);
+            return { saved: name, url: session.url, updatedAt: session.updatedAt };
+        }
+        catch (error) {
+            return { error: `Session save failed: ${error.message}` };
+        }
+    },
+});
+export const browserSessionRestoreTool = tool({
+    name: 'browser_session_restore',
+    description: 'Restore a previously saved browser session. Recreates the browser context with saved cookies/localStorage and navigates to the saved URL.',
+    inputSchema: z.object({
+        name: z.string().max(100).describe('Session name to restore'),
+    }),
+    execute: async ({ name }) => {
+        const pw = await getPlaywright();
+        if (!pw) {
+            return { error: 'Playwright not available. Install it: npm install playwright && npx playwright install chromium' };
+        }
+        try {
+            const sessionPath = path.join(process.cwd(), SESSION_DIR, `${name}.json`);
+            const raw = await fs.readFile(sessionPath, 'utf-8');
+            let session;
+            try {
+                session = JSON.parse(raw);
+            }
+            catch {
+                return { error: `Session restore failed: corrupt session file for "${name}"` };
+            }
+            if (!session.storageState || typeof session.storageState !== 'object' ||
+                !session.viewport || typeof session.viewport !== 'object' ||
+                typeof session.viewport.width !== 'number' || typeof session.viewport.height !== 'number') {
+                return { error: `Session restore failed: invalid session data for "${name}" (missing or malformed storageState/viewport)` };
+            }
+            if (browserContext) {
+                try {
+                    await browserContext.close();
+                }
+                catch { }
+                browserContext = null;
+                browserPage = null;
+            }
+            if (!browserInstance) {
+                browserInstance = await pw.chromium.launch({ headless: true });
+            }
+            browserContext = await browserInstance.newContext({
+                viewport: session.viewport,
+                storageState: session.storageState,
+            });
+            browserPage = await browserContext.newPage();
+            if (session.url && session.url !== 'about:blank') {
+                await browserPage.goto(session.url, { waitUntil: 'load', timeout: 30_000 });
+            }
+            const title = await browserPage.title();
+            return {
+                restored: name,
+                url: browserPage.url(),
+                title,
+                savedAt: session.updatedAt,
+            };
+        }
+        catch (error) {
+            return { error: `Session restore failed: ${error.message}` };
+        }
+    },
+});
+export const browserSessionListTool = tool({
+    name: 'browser_session_list',
+    description: 'List all saved browser sessions.',
     inputSchema: z.object({}),
     execute: async () => {
+        try {
+            const sessionDir = path.join(process.cwd(), SESSION_DIR);
+            let files;
+            try {
+                files = await fs.readdir(sessionDir);
+            }
+            catch {
+                return { sessions: [] };
+            }
+            const sessions = [];
+            for (const file of files) {
+                if (!file.endsWith('.json'))
+                    continue;
+                try {
+                    const raw = await fs.readFile(path.join(sessionDir, file), 'utf-8');
+                    const session = JSON.parse(raw);
+                    sessions.push({
+                        name: session.name,
+                        url: session.url,
+                        createdAt: session.createdAt,
+                        updatedAt: session.updatedAt,
+                    });
+                }
+                catch { }
+            }
+            return { sessions };
+        }
+        catch (error) {
+            return { error: `Session list failed: ${error.message}` };
+        }
+    },
+});
+export const browserCloseTool = tool({
+    name: 'browser_close',
+    description: 'Close the browser instance and free resources. Optionally save the session before closing.',
+    inputSchema: z.object({
+        saveSession: z.string().max(100).optional().describe('Save session state under this name before closing'),
+    }),
+    execute: async ({ saveSession } = {}) => {
+        try {
+            if (saveSession && browserContext && browserPage) {
+                await saveSessionState(saveSession);
+            }
+        }
+        catch { }
         await closeBrowser();
-        return { status: 'closed' };
+        return { status: 'closed', sessionSaved: saveSession || undefined };
     },
 });
 export const browserTools = [
     browserNavigateTool,
     browserScreenshotTool,
     browserClickTool,
+    browserMouseTool,
     browserTypeTool,
     browserEvalTool,
     browserGetTextTool,
+    browserSessionSaveTool,
+    browserSessionRestoreTool,
+    browserSessionListTool,
     browserCloseTool,
 ];

package/dist/tools-extra.js

@@ -172,6 +172,13 @@ export const searchFilesTool = tool({
             try {
                 const flags = `${caseInsensitive ? 'i' : ''}${multiline ? 'ms' : ''}`;
                 regex = new RegExp(pattern, flags);
+                // Probe with a short string to catch catastrophic patterns early
+                const probe = 'a'.repeat(50);
+                const start = performance.now();
+                regex.test(probe);
+                if (performance.now() - start > 100) {
+                    return { error: 'Regex pattern is too complex (possible catastrophic backtracking). Simplify the pattern.' };
+                }
             }
             catch (e) {
                 return { error: `Invalid regex pattern: ${e.message}` };

package/dist/tools-vision.js

@@ -2,7 +2,7 @@ import { tool } from './tool-helper.js';
 import { z } from 'zod';
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { sandboxPath } from './sandbox.js';
+import { sandboxPath, getMaxImageSize } from './sandbox.js';
 const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.svg']);
 const MIME_TYPES = {
     '.png': 'image/png',
@@ -38,8 +38,9 @@ export const readImageTool = tool({
                 return { error: `Not a supported image format. Supported: ${[...IMAGE_EXTENSIONS].join(', ')}` };
             }
             const stat = await fs.stat(safePath);
-            if (stat.size > 20 * 1024 * 1024) {
-                return { error: `Image too large (${Math.round(stat.size / 1024 / 1024)}MB). Max 20MB.` };
+            const maxSize = getMaxImageSize();
+            if (stat.size > maxSize) {
+                return { error: `Image too large (${Math.round(stat.size / 1024 / 1024)}MB). Max ${Math.round(maxSize / 1024 / 1024)}MB.` };
             }
             const dataUrl = await encodeImageToDataUrl(safePath);
             return {

package/dist/tools.js

@@ -134,7 +134,13 @@ export const runCommandTool = tool({
             child.stderr?.on('error', () => { });
             child.on('error', (err) => {
                 entry.exitCode = -1;
-                entry.stderr += `\nProcess error: ${err.message}`;
+                const errMsg = `\nProcess error: ${err.message}`;
+                if (entry.stderr.length + errMsg.length <= _limits.bgBufferMax) {
+                    entry.stderr += errMsg;
+                }
+                else if (entry.stderr.length < _limits.bgBufferMax) {
+                    entry.stderr += errMsg.slice(0, _limits.bgBufferMax - entry.stderr.length);
+                }
             });
             child.on('close', (code) => {
                 entry.exitCode = code ?? 1;
@@ -211,8 +217,12 @@ export const readFileTool = tool({
                 return { error: `File too large (${Math.round(stat.size / 1024)}KB, max ${Math.round(_limits.readFileMaxSize / 1024)}KB). Use read_file_lines to read specific sections.` };
             const fd = await fs.open(safePath, 'r');
             const header = Buffer.alloc(BINARY_DETECT_BUFFER_SIZE);
-            await fd.read(header, 0, Math.min(BINARY_DETECT_BUFFER_SIZE, stat.size), 0);
-            await fd.close();
+            try {
+                await fd.read(header, 0, Math.min(BINARY_DETECT_BUFFER_SIZE, stat.size), 0);
+            }
+            finally {
+                await fd.close();
+            }
             if (header.slice(0, Math.min(BINARY_DETECT_BUFFER_SIZE, stat.size)).includes(0x00)) {
                 return { error: 'File appears to be binary. Use a specialized tool to inspect binary files.' };
             }

package/dist/update-checker.js

@@ -0,0 +1,111 @@
+import fs from 'node:fs/promises';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { VERSION, UPDATE_DEFAULTS, USER_CONFIG_DIR } from './constants.js';
+function semverGt(a, b) {
+    const pa = a.replace(/^v/, '').split('.').map(Number);
+    const pb = b.replace(/^v/, '').split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if ((pa[i] ?? 0) > (pb[i] ?? 0))
+            return true;
+        if ((pa[i] ?? 0) < (pb[i] ?? 0))
+            return false;
+    }
+    return false;
+}
+function isValidSemver(v) {
+    return /^\d+\.\d+\.\d+/.test(v.replace(/^v/, ''));
+}
+function getCacheFile() {
+    return path.join(process.env.HOME || process.env.USERPROFILE || '.', USER_CONFIG_DIR, 'update-check.json');
+}
+function readCacheSync() {
+    try {
+        const raw = readFileSync(getCacheFile(), 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.lastCheck === 'number' && typeof parsed.latestVersion === 'string') {
+            return parsed;
+        }
+    }
+    catch { }
+    return null;
+}
+async function writeCache(cache) {
+    const dir = path.dirname(getCacheFile());
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(getCacheFile(), JSON.stringify(cache), { encoding: 'utf-8', mode: 0o600 });
+}
+export async function checkForUpdate() {
+    if (process.env.NO_UPDATE_NOTIFIER)
+        return null;
+    const cached = readCacheSync();
+    const now = Date.now();
+    if (cached && (now - cached.lastCheck) < UPDATE_DEFAULTS.checkIntervalMs) {
+        return {
+            current: VERSION,
+            latest: cached.latestVersion,
+            updateAvailable: semverGt(cached.latestVersion, VERSION),
+        };
+    }
+    try {
+        const res = await fetch(UPDATE_DEFAULTS.registryUrl, {
+            signal: AbortSignal.timeout(UPDATE_DEFAULTS.fetchTimeoutMs),
+            headers: { 'Accept': 'application/json' },
+        });
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        const latest = data.version;
+        if (!latest || !isValidSemver(latest))
+            return null;
+        await writeCache({ lastCheck: now, latestVersion: latest }).catch(() => { });
+        return {
+            current: VERSION,
+            latest,
+            updateAvailable: semverGt(latest, VERSION),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function getUpdateBanner() {
+    if (process.env.NO_UPDATE_NOTIFIER)
+        return null;
+    const cached = readCacheSync();
+    if (!cached)
+        return null;
+    if (!semverGt(cached.latestVersion, VERSION))
+        return null;
+    const current = VERSION;
+    const latest = cached.latestVersion;
+    const line1 = `  Update available: ${current} → ${latest}`;
+    const line2 = `  Run /update or:`;
+    const line3 = `  npm install -g ${UPDATE_DEFAULTS.npmPackageName}@latest`;
+    const maxLen = Math.max(line1.length, line2.length, line3.length) + 2;
+    const pad = (s) => s + ' '.repeat(Math.max(0, maxLen - s.length));
+    return [
+        `╭${'─'.repeat(maxLen)}╮`,
+        `│${pad(line1)}│`,
+        `│${pad(line2)}│`,
+        `│${pad(line3)}│`,
+        `╰${'─'.repeat(maxLen)}╯`,
+    ].join('\n');
+}
+export function performUpdate() {
+    return new Promise((resolve) => {
+        const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+        execFile(npmCmd, ['install', '-g', `${UPDATE_DEFAULTS.npmPackageName}@latest`], {
+            timeout: 120_000,
+            env: { ...process.env },
+        }, (error, stdout, stderr) => {
+            if (error) {
+                resolve({ success: false, output: stderr || error.message });
+            }
+            else {
+                resolve({ success: true, output: stdout.trim() });
+            }
+        });
+    });
+}