@wonderwhy-er/desktop-commander 0.1.34 → 0.1.35

package/dist/tools/filesystem-fixed.js

@@ -0,0 +1,176 @@
+if (returnMetadata === true) {
+    return { content, mimeType, isImage };
+}
+else {
+    return content;
+}
+try { }
+catch (error) {
+    // If UTF-8 reading fails, treat as binary and return base64 but still as text
+    const buffer = await fs.readFile(validPath);
+    const content = `Binary file content (base64 encoded):\n${buffer.toString('base64')}`;
+    if (returnMetadata === true) {
+        return { content, mimeType: 'text/plain', isImage: false };
+    }
+    else {
+        return content;
+    }
+}
+;
+// Execute with timeout
+const result = await withTimeout(readOperation(), FILE_READ_TIMEOUT, `Read file operation for ${filePath}`, returnMetadata ?
+    { content: `Operation timed out after ${FILE_READ_TIMEOUT / 1000} seconds`, mimeType: 'text/plain', isImage: false } :
+    `Operation timed out after ${FILE_READ_TIMEOUT / 1000} seconds`);
+return result;
+/**
+ * Read a file from either the local filesystem or a URL
+ * @param filePath Path to the file or URL
+ * @param returnMetadata Whether to return metadata with the content
+ * @param isUrl Whether the path is a URL
+ * @returns File content or file result with metadata
+ */
+export async function readFile(filePath, returnMetadata, isUrl) {
+    return isUrl
+        ? readFileFromUrl(filePath, returnMetadata)
+        : readFileFromDisk(filePath, returnMetadata);
+}
+export async function writeFile(filePath, content) {
+    // Expand home directory in filePath before validation
+    const expandedFilePath = expandHome(filePath);
+    const validPath = await validatePath(expandedFilePath);
+    // Check if the path validation returned an error
+    if (validPath.startsWith('__ERROR__:')) {
+        throw new Error(validPath.substring('__ERROR__:'.length).trim());
+    }
+    await fs.writeFile(validPath, content, "utf-8");
+}
+export async function readMultipleFiles(paths) {
+    return Promise.all(paths.map(async (filePath) => {
+        try {
+            // Expand home directory in filePath before validation
+            const expandedFilePath = expandHome(filePath);
+            const validPath = await validatePath(expandedFilePath);
+            // Check if the path validation returned an error
+            if (validPath.startsWith('__ERROR__:')) {
+                return {
+                    path: filePath,
+                    error: validPath.substring('__ERROR__:'.length).trim()
+                };
+            }
+            const fileResult = await readFile(validPath, true);
+            return {
+                path: filePath,
+                content: typeof fileResult === 'string' ? fileResult : fileResult.content,
+                mimeType: typeof fileResult === 'string' ? "text/plain" : fileResult.mimeType,
+                isImage: typeof fileResult === 'string' ? false : fileResult.isImage
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                path: filePath,
+                error: errorMessage
+            };
+        }
+    }));
+}
+export async function createDirectory(dirPath) {
+    // Expand home directory in dirPath before validation
+    const expandedDirPath = expandHome(dirPath);
+    const validPath = await validatePath(expandedDirPath);
+    // Check if the path validation returned an error
+    if (validPath.startsWith('__ERROR__:')) {
+        throw new Error(validPath.substring('__ERROR__:'.length).trim());
+    }
+    await fs.mkdir(validPath, { recursive: true });
+}
+export async function listDirectory(dirPath) {
+    console.log(`List directory called with: ${dirPath}`);
+    // Handle tilde expansion directly here as well
+    const expandedDirPath = expandHome(dirPath);
+    console.log(`Expanded dir path: ${expandedDirPath}`);
+    const validPath = await validatePath(expandedDirPath);
+    console.log(`Valid path: ${validPath}`);
+    // Check if the path starts with an error indicator
+    if (validPath.startsWith('__ERROR__:')) {
+        console.error(`Path validation error: ${validPath}`);
+        return [`Error: ${validPath.substring('__ERROR__:'.length).trim()}`];
+    }
+    try {
+        const entries = await fs.readdir(validPath, { withFileTypes: true });
+        return entries.map((entry) => `${entry.isDirectory() ? "[DIR]" : "[FILE]"} ${entry.name}`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`Error reading directory: ${errorMessage}`);
+        return [`Error reading directory: ${errorMessage}`];
+    }
+}
+export async function moveFile(sourcePath, destinationPath) {
+    // Expand home directory in both paths before validation
+    const expandedSourcePath = expandHome(sourcePath);
+    const expandedDestPath = expandHome(destinationPath);
+    const validSourcePath = await validatePath(expandedSourcePath);
+    const validDestPath = await validatePath(expandedDestPath);
+    // Check if either path validation returned an error
+    if (validSourcePath.startsWith('__ERROR__:')) {
+        throw new Error(validSourcePath.substring('__ERROR__:'.length).trim());
+    }
+    if (validDestPath.startsWith('__ERROR__:')) {
+        throw new Error(validDestPath.substring('__ERROR__:'.length).trim());
+    }
+    await fs.rename(validSourcePath, validDestPath);
+}
+export async function searchFiles(rootPath, pattern) {
+    const results = [];
+    async function search(currentPath) {
+        const entries = await fs.readdir(currentPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentPath, entry.name);
+            try {
+                // No need to expand home directory here as we're generating full paths
+                // from the already validated rootPath
+                await validatePath(fullPath);
+                if (entry.name.toLowerCase().includes(pattern.toLowerCase())) {
+                    results.push(fullPath);
+                }
+                if (entry.isDirectory()) {
+                    await search(fullPath);
+                }
+            }
+            catch (error) {
+                continue;
+            }
+        }
+    }
+    // Expand home directory in rootPath before validation
+    const expandedRootPath = expandHome(rootPath);
+    const validPath = await validatePath(expandedRootPath);
+    // Check if the path validation returned an error
+    if (validPath.startsWith('__ERROR__:')) {
+        throw new Error(validPath.substring('__ERROR__:'.length).trim());
+    }
+    await search(validPath);
+    return results;
+}
+export async function getFileInfo(filePath) {
+    // Expand home directory in filePath before validation
+    const expandedFilePath = expandHome(filePath);
+    const validPath = await validatePath(expandedFilePath);
+    // Check if the path validation returned an error
+    if (validPath.startsWith('__ERROR__:')) {
+        throw new Error(validPath.substring('__ERROR__:'.length).trim());
+    }
+    const stats = await fs.stat(validPath);
+    return {
+        size: stats.size,
+        created: stats.birthtime,
+        modified: stats.mtime,
+        accessed: stats.atime,
+        isDirectory: stats.isDirectory(),
+        isFile: stats.isFile(),
+        permissions: stats.mode.toString(8).slice(-3),
+    };
+}
+// This function has been replaced with configManager.getConfig()
+// Use get_config tool to retrieve allowedDirectories

package/dist/tools/filesystem.d.ts

@@ -5,7 +5,7 @@
  *
  * @param requestedPath The path to validate
  * @returns Promise<string> The validated path
- * @throws Error if the path or its parent directories don't exist
+ * @throws Error if the path or its parent directories don't exist or if the path is not allowed
  */
 export declare function validatePath(requestedPath: string): Promise<string>;
 export interface FileResult {
@@ -16,17 +16,16 @@ export interface FileResult {
 /**
  * Read file content from a URL
  * @param url URL to fetch content from
- * @param returnMetadata Whether to return metadata with the content
  * @returns File content or file result with metadata
  */
-export declare function readFileFromUrl(url: string, returnMetadata?: boolean): Promise<string | FileResult>;
+export declare function readFileFromUrl(url: string): Promise<FileResult>;
 /**
  * Read file content from the local filesystem
  * @param filePath Path to the file
  * @param returnMetadata Whether to return metadata with the content
  * @returns File content or file result with metadata
  */
-export declare function readFileFromDisk(filePath: string, returnMetadata?: boolean): Promise<string | FileResult>;
+export declare function readFileFromDisk(filePath: string): Promise<FileResult>;
 /**
  * Read a file from either the local filesystem or a URL
  * @param filePath Path to the file or URL
@@ -34,7 +33,7 @@ export declare function readFileFromDisk(filePath: string, returnMetadata?: bool
  * @param isUrl Whether the path is a URL
  * @returns File content or file result with metadata
  */
-export declare function readFile(filePath: string, returnMetadata?: boolean, isUrl?: boolean): Promise<string | FileResult>;
+export declare function readFile(filePath: string, isUrl?: boolean): Promise<FileResult>;
 export declare function writeFile(filePath: string, content: string): Promise<void>;
 export interface MultiFileResult {
     path: string;
@@ -49,4 +48,3 @@ export declare function listDirectory(dirPath: string): Promise<string[]>;
 export declare function moveFile(sourcePath: string, destinationPath: string): Promise<void>;
 export declare function searchFiles(rootPath: string, pattern: string): Promise<string[]>;
 export declare function getFileInfo(filePath: string): Promise<Record<string, any>>;
-export declare function listAllowedDirectories(): string[];

package/dist/tools/filesystem.js

@@ -2,22 +2,35 @@ import fs from "fs/promises";
 import path from "path";
 import os from 'os';
 import fetch from 'cross-fetch';
-import { withTimeout } from '../utils.js';
-// Store allowed directories - temporarily allowing all paths
-// TODO: Make this configurable through a configuration file
-const allowedDirectories = [
-    "/" // Root directory - effectively allows all paths
-];
-// Original implementation commented out for future reference
-/*
-const allowedDirectories: string[] = [
-    process.cwd(), // Current working directory
-    os.homedir()   // User's home directory
-];
-*/
+import { capture, withTimeout } from '../utils.js';
+import { configManager } from '../config-manager.js';
+// Initialize allowed directories from configuration
+async function getAllowedDirs() {
+    try {
+        let allowedDirectories;
+        const config = await configManager.getConfig();
+        if (config.allowedDirectories && Array.isArray(config.allowedDirectories)) {
+            allowedDirectories = config.allowedDirectories;
+        }
+        else {
+            // Fall back to default directories if not configured
+            allowedDirectories = [
+                os.homedir() // User's home directory
+            ];
+            // Update config with default
+            await configManager.setValue('allowedDirectories', allowedDirectories);
+        }
+        return allowedDirectories;
+    }
+    catch (error) {
+        console.error('Failed to initialize allowed directories:', error);
+        // Keep the default permissive path
+    }
+    return [];
+}
 // Normalize all paths consistently
 function normalizePath(p) {
-    return path.normalize(p).toLowerCase();
+    return path.normalize(expandHome(p)).toLowerCase();
 }
 function expandHome(filepath) {
     if (filepath.startsWith('~/') || filepath === '~') {
@@ -49,6 +62,47 @@ async function validateParentDirectories(directoryPath) {
         return validateParentDirectories(parentDir);
     }
 }
+/**
+ * Checks if a path is within any of the allowed directories
+ *
+ * @param pathToCheck Path to check
+ * @returns boolean True if path is allowed
+ */
+async function isPathAllowed(pathToCheck) {
+    // If root directory is allowed, all paths are allowed
+    const allowedDirectories = await getAllowedDirs();
+    if (allowedDirectories.includes('/') || allowedDirectories.length === 0) {
+        return true;
+    }
+    let normalizedPathToCheck = normalizePath(pathToCheck);
+    if (normalizedPathToCheck.slice(-1) === path.sep) {
+        normalizedPathToCheck = normalizedPathToCheck.slice(0, -1);
+    }
+    // Check if the path is within any allowed directory
+    const isAllowed = allowedDirectories.some(allowedDir => {
+        let normalizedAllowedDir = normalizePath(allowedDir);
+        if (normalizedAllowedDir.slice(-1) === path.sep) {
+            normalizedAllowedDir = normalizedAllowedDir.slice(0, -1);
+        }
+        // Check if path is exactly the allowed directory
+        if (normalizedPathToCheck === normalizedAllowedDir) {
+            return true;
+        }
+        // Check if path is a subdirectory of the allowed directory
+        // Make sure to add a separator to prevent partial directory name matches
+        // e.g. /home/user vs /home/username
+        const subdirCheck = normalizedPathToCheck.startsWith(normalizedAllowedDir + path.sep);
+        if (subdirCheck) {
+            return true;
+        }
+        // If allowed directory is the root (C:\ on Windows), allow access to the entire drive
+        if (normalizedAllowedDir === 'c:' && process.platform === 'win32') {
+            return normalizedPathToCheck.startsWith('c:');
+        }
+        return false;
+    });
+    return isAllowed;
+}
 /**
  * Validates a path to ensure it can be accessed or created.
  * For existing paths, returns the real path (resolving symlinks).
@@ -56,7 +110,7 @@ async function validateParentDirectories(directoryPath) {
  *
  * @param requestedPath The path to validate
  * @returns Promise<string> The validated path
- * @throws Error if the path or its parent directories don't exist
+ * @throws Error if the path or its parent directories don't exist or if the path is not allowed
  */
 export async function validatePath(requestedPath) {
     const PATH_VALIDATION_TIMEOUT = 10000; // 10 seconds timeout
@@ -67,6 +121,10 @@ export async function validatePath(requestedPath) {
         const absolute = path.isAbsolute(expandedPath)
             ? path.resolve(expandedPath)
             : path.resolve(process.cwd(), expandedPath);
+        // Check if path is allowed
+        if (!(await isPathAllowed(absolute))) {
+            throw (`Path not allowed: ${requestedPath}. Must be within one of these directories: ${(await getAllowedDirs()).join(', ')}`);
+        }
         // Check if path exists
         try {
             const stats = await fs.stat(absolute);
@@ -88,17 +146,16 @@ export async function validatePath(requestedPath) {
     const result = await withTimeout(validationOperation(), PATH_VALIDATION_TIMEOUT, `Path validation for ${requestedPath}`, null);
     if (result === null) {
         // Return a path with an error indicator instead of throwing
-        return `__ERROR__: Path validation timed out after ${PATH_VALIDATION_TIMEOUT / 1000} seconds for: ${requestedPath}`;
+        throw new Error(`Path validation failed for path: ${requestedPath}`);
     }
     return result;
 }
 /**
  * Read file content from a URL
  * @param url URL to fetch content from
- * @param returnMetadata Whether to return metadata with the content
  * @returns File content or file result with metadata
  */
-export async function readFileFromUrl(url, returnMetadata) {
+export async function readFileFromUrl(url) {
     // Import the MIME type utilities
     const { isImageFile } = await import('./mime-types.js');
     // Set up fetch with timeout
@@ -121,22 +178,12 @@ export async function readFileFromUrl(url, returnMetadata) {
             // For images, convert to base64
             const buffer = await response.arrayBuffer();
             const content = Buffer.from(buffer).toString('base64');
-            if (returnMetadata === true) {
-                return { content, mimeType: contentType, isImage };
-            }
-            else {
-                return content;
-            }
+            return { content, mimeType: contentType, isImage };
         }
         else {
             // For text content
             const content = await response.text();
-            if (returnMetadata === true) {
-                return { content, mimeType: contentType, isImage };
-            }
-            else {
-                return content;
-            }
+            return { content, mimeType: contentType, isImage };
         }
     }
     catch (error) {
@@ -146,16 +193,7 @@ export async function readFileFromUrl(url, returnMetadata) {
         const errorMessage = error instanceof DOMException && error.name === 'AbortError'
             ? `URL fetch timed out after ${FETCH_TIMEOUT_MS}ms: ${url}`
             : `Failed to fetch URL: ${error instanceof Error ? error.message : String(error)}`;
-        if (returnMetadata === true) {
-            return {
-                content: `Error: ${errorMessage}`,
-                mimeType: 'text/plain',
-                isImage: false
-            };
-        }
-        else {
-            return `Error: ${errorMessage}`;
-        }
+        throw new Error(errorMessage);
     }
 }
 /**
@@ -164,7 +202,7 @@ export async function readFileFromUrl(url, returnMetadata) {
  * @param returnMetadata Whether to return metadata with the content
  * @returns File content or file result with metadata
  */
-export async function readFileFromDisk(filePath, returnMetadata) {
+export async function readFileFromDisk(filePath) {
     // Import the MIME type utilities
     const { getMimeType, isImageFile } = await import('./mime-types.js');
     const validPath = await validatePath(filePath);
@@ -174,21 +212,18 @@ export async function readFileFromDisk(filePath, returnMetadata) {
         const MAX_SIZE = 100 * 1024; // 100KB limit
         if (stats.size > MAX_SIZE) {
             const message = `File too large (${(stats.size / 1024).toFixed(2)}KB > ${MAX_SIZE / 1024}KB limit)`;
-            if (returnMetadata) {
-                return {
-                    content: message,
-                    mimeType: 'text/plain',
-                    isImage: false
-                };
-            }
-            else {
-                return message;
-            }
+            return {
+                content: message,
+                mimeType: 'text/plain',
+                isImage: false
+            };
         }
     }
     catch (error) {
+        console.error('error catch ' + error);
+        capture('server_read_file_error', { error: error });
         // If we can't stat the file, continue anyway and let the read operation handle errors
-        console.error(`Failed to stat file ${validPath}:`, error);
+        //console.error(`Failed to stat file ${validPath}:`, error);
     }
     // Detect the MIME type based on file extension
     const mimeType = getMimeType(validPath);
@@ -200,41 +235,28 @@ export async function readFileFromDisk(filePath, returnMetadata) {
             // For image files, read as Buffer and convert to base64
             const buffer = await fs.readFile(validPath);
             const content = buffer.toString('base64');
-            if (returnMetadata === true) {
-                return { content, mimeType, isImage };
-            }
-            else {
-                return content;
-            }
+            return { content, mimeType, isImage };
         }
         else {
             // For all other files, try to read as UTF-8 text
             try {
                 const content = await fs.readFile(validPath, "utf-8");
-                if (returnMetadata === true) {
-                    return { content, mimeType, isImage };
-                }
-                else {
-                    return content;
-                }
+                return { content, mimeType, isImage };
             }
             catch (error) {
                 // If UTF-8 reading fails, treat as binary and return base64 but still as text
                 const buffer = await fs.readFile(validPath);
                 const content = `Binary file content (base64 encoded):\n${buffer.toString('base64')}`;
-                if (returnMetadata === true) {
-                    return { content, mimeType: 'text/plain', isImage: false };
-                }
-                else {
-                    return content;
-                }
+                return { content, mimeType: 'text/plain', isImage: false };
             }
         }
     };
     // Execute with timeout
-    const result = await withTimeout(readOperation(), FILE_READ_TIMEOUT, `Read file operation for ${filePath}`, returnMetadata ?
-        { content: `Operation timed out after ${FILE_READ_TIMEOUT / 1000} seconds`, mimeType: 'text/plain', isImage: false } :
-        `Operation timed out after ${FILE_READ_TIMEOUT / 1000} seconds`);
+    const result = await withTimeout(readOperation(), FILE_READ_TIMEOUT, `Read file operation for ${filePath}`, null);
+    if (result == null) {
+        // Handles the impossible case where withTimeout resolves to null instead of throwing
+        throw new Error('Failed to read the file');
+    }
     return result;
 }
 /**
@@ -244,10 +266,10 @@ export async function readFileFromDisk(filePath, returnMetadata) {
  * @param isUrl Whether the path is a URL
  * @returns File content or file result with metadata
  */
-export async function readFile(filePath, returnMetadata, isUrl) {
+export async function readFile(filePath, isUrl) {
     return isUrl
-        ? readFileFromUrl(filePath, returnMetadata)
-        : readFileFromDisk(filePath, returnMetadata);
+        ? readFileFromUrl(filePath)
+        : readFileFromDisk(filePath);
 }
 export async function writeFile(filePath, content) {
     const validPath = await validatePath(filePath);
@@ -257,7 +279,7 @@ export async function readMultipleFiles(paths) {
     return Promise.all(paths.map(async (filePath) => {
         try {
             const validPath = await validatePath(filePath);
-            const fileResult = await readFile(validPath, true);
+            const fileResult = await readFile(validPath);
             return {
                 path: filePath,
                 content: typeof fileResult === 'string' ? fileResult : fileResult.content,
@@ -326,6 +348,5 @@ export async function getFileInfo(filePath) {
         permissions: stats.mode.toString(8).slice(-3),
     };
 }
-export function listAllowedDirectories() {
-    return ["/ (All paths are currently allowed)"];
-}
+// This function has been replaced with configManager.getConfig()
+// Use get_config tool to retrieve allowedDirectories

package/dist/tools/schemas.d.ts

@@ -1,13 +1,28 @@
 import { z } from "zod";
+export declare const GetConfigArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const SetConfigValueArgsSchema: z.ZodObject<{
+    key: z.ZodString;
+    value: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    value?: any;
+}, {
+    key: string;
+    value?: any;
+}>;
+export declare const ListProcessesArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
 export declare const ExecuteCommandArgsSchema: z.ZodObject<{
     command: z.ZodString;
     timeout_ms: z.ZodOptional<z.ZodNumber>;
+    shell: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     command: string;
     timeout_ms?: number | undefined;
+    shell?: string | undefined;
 }, {
     command: string;
     timeout_ms?: number | undefined;
+    shell?: string | undefined;
 }>;
 export declare const ReadOutputArgsSchema: z.ZodObject<{
     pid: z.ZodNumber;
@@ -31,20 +46,6 @@ export declare const KillProcessArgsSchema: z.ZodObject<{
 }, {
     pid: number;
 }>;
-export declare const BlockCommandArgsSchema: z.ZodObject<{
-    command: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    command: string;
-}, {
-    command: string;
-}>;
-export declare const UnblockCommandArgsSchema: z.ZodObject<{
-    command: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    command: string;
-}, {
-    command: string;
-}>;
 export declare const ReadFileArgsSchema: z.ZodObject<{
     path: z.ZodString;
     isUrl: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;

package/dist/tools/schemas.js

@@ -1,8 +1,18 @@
 import { z } from "zod";
+console.error("Loading schemas.ts");
+// Config tools schemas
+export const GetConfigArgsSchema = z.object({});
+export const SetConfigValueArgsSchema = z.object({
+    key: z.string(),
+    value: z.any(),
+});
+// Empty schemas
+export const ListProcessesArgsSchema = z.object({});
 // Terminal tools schemas
 export const ExecuteCommandArgsSchema = z.object({
     command: z.string(),
     timeout_ms: z.number().optional(),
+    shell: z.string().optional(),
 });
 export const ReadOutputArgsSchema = z.object({
     pid: z.number(),
@@ -14,12 +24,6 @@ export const ListSessionsArgsSchema = z.object({});
 export const KillProcessArgsSchema = z.object({
     pid: z.number(),
 });
-export const BlockCommandArgsSchema = z.object({
-    command: z.string(),
-});
-export const UnblockCommandArgsSchema = z.object({
-    command: z.string(),
-});
 // Filesystem tools schemas
 export const ReadFileArgsSchema = z.object({
     path: z.string(),

package/dist/tools/search.js

@@ -3,6 +3,7 @@ import path from 'path';
 import fs from 'fs/promises';
 import { validatePath } from './filesystem.js';
 import { rgPath } from '@vscode/ripgrep';
+import { capture } from "../utils.js";
 // Function to search file contents using ripgrep
 export async function searchCode(options) {
     const { rootPath, pattern, filePattern, ignoreCase = true, maxResults = 1000, includeHidden = false, contextLines = 0 } = options;
@@ -77,8 +78,8 @@ export async function searchCode(options) {
                         }
                     }
                     catch (e) {
-                        // Skip non-JSON output
-                        console.error('Error parsing ripgrep output:', e);
+                        capture('server_request_error', { error: 'Error parsing ripgrep output:' + e });
+                        console.error();
                     }
                 }
                 resolve(results);
@@ -164,7 +165,6 @@ export async function searchTextInFiles(options) {
         return await searchCode(options);
     }
     catch (error) {
-        console.error('Ripgrep search failed, falling back to native implementation:', error);
         return searchCodeFallback({
             ...options,
             excludeDirs: ['node_modules', '.git', 'dist']

package/dist/utils.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Send an event to Google Analytics
+ * @param event Event name
+ * @param properties Optional event properties
+ */
 export declare const capture: (event: string, properties?: any) => void;
 /**
  * Executes a promise with a timeout. If the promise doesn't resolve or reject within