@wonderwhy-er/desktop-commander 0.2.2 → 0.2.4

package/dist/tools/improved-process-tools.js

@@ -0,0 +1,453 @@
+import { terminalManager } from '../terminal-manager.js';
+import { commandManager } from '../command-manager.js';
+import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, InteractWithProcessArgsSchema, ForceTerminateArgsSchema } from './schemas.js';
+import { capture } from "../utils/capture.js";
+import { analyzeProcessState, cleanProcessOutput, formatProcessStateMessage } from '../utils/process-detection.js';
+import * as os from 'os';
+import { configManager } from '../config-manager.js';
+/**
+ * Start a new process (renamed from execute_command)
+ * Includes early detection of process waiting for input
+ */
+export async function startProcess(args) {
+    const parsed = StartProcessArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        capture('server_start_process_failed');
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for start_process: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const commands = commandManager.extractCommands(parsed.data.command).join(', ');
+        capture('server_start_process', {
+            command: commandManager.getBaseCommand(parsed.data.command),
+            commands: commands
+        });
+    }
+    catch (error) {
+        capture('server_start_process', {
+            command: commandManager.getBaseCommand(parsed.data.command)
+        });
+    }
+    const isAllowed = await commandManager.validateCommand(parsed.data.command);
+    if (!isAllowed) {
+        return {
+            content: [{ type: "text", text: `Error: Command not allowed: ${parsed.data.command}` }],
+            isError: true,
+        };
+    }
+    let shellUsed = parsed.data.shell;
+    if (!shellUsed) {
+        const config = await configManager.getConfig();
+        if (config.defaultShell) {
+            shellUsed = config.defaultShell;
+        }
+        else {
+            const isWindows = os.platform() === 'win32';
+            if (isWindows && process.env.COMSPEC) {
+                shellUsed = process.env.COMSPEC;
+            }
+            else if (!isWindows && process.env.SHELL) {
+                shellUsed = process.env.SHELL;
+            }
+            else {
+                shellUsed = isWindows ? 'cmd.exe' : '/bin/sh';
+            }
+        }
+    }
+    const result = await terminalManager.executeCommand(parsed.data.command, parsed.data.timeout_ms, shellUsed);
+    if (result.pid === -1) {
+        return {
+            content: [{ type: "text", text: result.output }],
+            isError: true,
+        };
+    }
+    // Analyze the process state to detect if it's waiting for input
+    const processState = analyzeProcessState(result.output, result.pid);
+    let statusMessage = '';
+    if (processState.isWaitingForInput) {
+        statusMessage = `\n🔄 ${formatProcessStateMessage(processState, result.pid)}`;
+    }
+    else if (processState.isFinished) {
+        statusMessage = `\n✅ ${formatProcessStateMessage(processState, result.pid)}`;
+    }
+    else if (result.isBlocked) {
+        statusMessage = '\n⏳ Process is running. Use read_process_output to get more output.';
+    }
+    return {
+        content: [{
+                type: "text",
+                text: `Process started with PID ${result.pid} (shell: ${shellUsed})\nInitial output:\n${result.output}${statusMessage}`
+            }],
+    };
+}
+/**
+ * Read output from a running process (renamed from read_output)
+ * Includes early detection of process waiting for input
+ */
+export async function readProcessOutput(args) {
+    const parsed = ReadProcessOutputArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for read_process_output: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    const { pid, timeout_ms = 5000 } = parsed.data;
+    const session = terminalManager.getSession(pid);
+    if (!session) {
+        return {
+            content: [{ type: "text", text: `No active session found for PID ${pid}` }],
+            isError: true,
+        };
+    }
+    let output = "";
+    let timeoutReached = false;
+    let earlyExit = false;
+    let processState;
+    try {
+        const outputPromise = new Promise((resolve) => {
+            const initialOutput = terminalManager.getNewOutput(pid);
+            if (initialOutput && initialOutput.length > 0) {
+                // Immediate check on existing output
+                const state = analyzeProcessState(initialOutput, pid);
+                if (state.isWaitingForInput) {
+                    earlyExit = true;
+                    processState = state;
+                }
+                resolve(initialOutput);
+                return;
+            }
+            let resolved = false;
+            let interval = null;
+            let timeout = null;
+            // Quick prompt patterns for immediate detection
+            const quickPromptPatterns = />>>\s*$|>\s*$|\$\s*$|#\s*$/;
+            const cleanup = () => {
+                if (interval)
+                    clearInterval(interval);
+                if (timeout)
+                    clearTimeout(timeout);
+            };
+            let resolveOnce = (value, isTimeout = false) => {
+                if (resolved)
+                    return;
+                resolved = true;
+                cleanup();
+                timeoutReached = isTimeout;
+                resolve(value);
+            };
+            // Monitor for new output with immediate detection
+            const session = terminalManager.getSession(pid);
+            if (session && session.process && session.process.stdout && session.process.stderr) {
+                const immediateDetector = (data) => {
+                    const text = data.toString();
+                    // Immediate check for obvious prompts
+                    if (quickPromptPatterns.test(text)) {
+                        const newOutput = terminalManager.getNewOutput(pid) || text;
+                        const state = analyzeProcessState(output + newOutput, pid);
+                        if (state.isWaitingForInput) {
+                            earlyExit = true;
+                            processState = state;
+                            resolveOnce(newOutput);
+                            return;
+                        }
+                    }
+                };
+                session.process.stdout.on('data', immediateDetector);
+                session.process.stderr.on('data', immediateDetector);
+                // Cleanup immediate detectors when done
+                const originalResolveOnce = resolveOnce;
+                const cleanupDetectors = () => {
+                    if (session.process.stdout) {
+                        session.process.stdout.removeListener('data', immediateDetector);
+                    }
+                    if (session.process.stderr) {
+                        session.process.stderr.removeListener('data', immediateDetector);
+                    }
+                };
+                // Override resolveOnce to include cleanup
+                const resolveOnceWithCleanup = (value, isTimeout = false) => {
+                    cleanupDetectors();
+                    originalResolveOnce(value, isTimeout);
+                };
+                // Replace the local resolveOnce reference
+                resolveOnce = resolveOnceWithCleanup;
+            }
+            interval = setInterval(() => {
+                const newOutput = terminalManager.getNewOutput(pid);
+                if (newOutput && newOutput.length > 0) {
+                    const currentOutput = output + newOutput;
+                    const state = analyzeProcessState(currentOutput, pid);
+                    // Early exit if process is clearly waiting for input
+                    if (state.isWaitingForInput) {
+                        earlyExit = true;
+                        processState = state;
+                        resolveOnce(newOutput);
+                        return;
+                    }
+                    output = currentOutput;
+                    // Continue collecting if still running
+                    if (!state.isFinished) {
+                        return;
+                    }
+                    // Process finished
+                    processState = state;
+                    resolveOnce(newOutput);
+                }
+            }, 200); // Check every 200ms
+            timeout = setTimeout(() => {
+                const finalOutput = terminalManager.getNewOutput(pid) || "";
+                resolveOnce(finalOutput, true);
+            }, timeout_ms);
+        });
+        const newOutput = await outputPromise;
+        output += newOutput;
+        // Analyze final state if not already done
+        if (!processState) {
+            processState = analyzeProcessState(output, pid);
+        }
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Error reading output: ${error}` }],
+            isError: true,
+        };
+    }
+    // Format response based on what we detected
+    let statusMessage = '';
+    if (earlyExit && processState?.isWaitingForInput) {
+        statusMessage = `\n🔄 ${formatProcessStateMessage(processState, pid)}`;
+    }
+    else if (processState?.isFinished) {
+        statusMessage = `\n✅ ${formatProcessStateMessage(processState, pid)}`;
+    }
+    else if (timeoutReached) {
+        statusMessage = '\n⏱️ Timeout reached - process may still be running';
+    }
+    const responseText = output || 'No new output available';
+    return {
+        content: [{
+                type: "text",
+                text: `${responseText}${statusMessage}`
+            }],
+    };
+}
+/**
+ * Interact with a running process (renamed from send_input)
+ * Automatically detects when process is ready and returns output
+ */
+export async function interactWithProcess(args) {
+    const parsed = InteractWithProcessArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        capture('server_interact_with_process_failed', {
+            error: 'Invalid arguments'
+        });
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for interact_with_process: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    const { pid, input, timeout_ms = 8000, wait_for_prompt = true } = parsed.data;
+    try {
+        capture('server_interact_with_process', {
+            pid: pid,
+            inputLength: input.length
+        });
+        const success = terminalManager.sendInputToProcess(pid, input);
+        if (!success) {
+            return {
+                content: [{ type: "text", text: `Error: Failed to send input to process ${pid}. The process may have exited or doesn't accept input.` }],
+                isError: true,
+            };
+        }
+        // If not waiting for response, return immediately
+        if (!wait_for_prompt) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `✅ Input sent to process ${pid}. Use read_process_output to get the response.`
+                    }],
+            };
+        }
+        // Smart waiting with immediate and periodic detection
+        let output = "";
+        let processState;
+        let earlyExit = false;
+        // Quick prompt patterns for immediate detection
+        const quickPromptPatterns = />>>\s*$|>\s*$|\$\s*$|#\s*$/;
+        const waitForResponse = () => {
+            return new Promise((resolve) => {
+                let resolved = false;
+                let attempts = 0;
+                const maxAttempts = Math.ceil(timeout_ms / 200);
+                let interval = null;
+                let resolveOnce = () => {
+                    if (resolved)
+                        return;
+                    resolved = true;
+                    if (interval)
+                        clearInterval(interval);
+                    resolve();
+                };
+                // Set up immediate detection on the process streams
+                const session = terminalManager.getSession(pid);
+                if (session && session.process && session.process.stdout && session.process.stderr) {
+                    const immediateDetector = (data) => {
+                        const text = data.toString();
+                        // Immediate check for obvious prompts
+                        if (quickPromptPatterns.test(text)) {
+                            // Get the latest output and analyze
+                            setTimeout(() => {
+                                const newOutput = terminalManager.getNewOutput(pid);
+                                if (newOutput) {
+                                    output += newOutput;
+                                    const state = analyzeProcessState(output, pid);
+                                    if (state.isWaitingForInput) {
+                                        processState = state;
+                                        earlyExit = true;
+                                        resolveOnce();
+                                    }
+                                }
+                            }, 50); // Small delay to ensure output is captured
+                        }
+                    };
+                    session.process.stdout.on('data', immediateDetector);
+                    session.process.stderr.on('data', immediateDetector);
+                    // Cleanup when done
+                    const cleanupDetectors = () => {
+                        if (session.process.stdout) {
+                            session.process.stdout.removeListener('data', immediateDetector);
+                        }
+                        if (session.process.stderr) {
+                            session.process.stderr.removeListener('data', immediateDetector);
+                        }
+                    };
+                    // Override resolveOnce to include cleanup
+                    const originalResolveOnce = resolveOnce;
+                    const resolveOnceWithCleanup = () => {
+                        cleanupDetectors();
+                        originalResolveOnce();
+                    };
+                    // Replace the local resolveOnce reference
+                    resolveOnce = resolveOnceWithCleanup;
+                }
+                // Periodic check as fallback
+                interval = setInterval(() => {
+                    if (resolved)
+                        return;
+                    const newOutput = terminalManager.getNewOutput(pid);
+                    if (newOutput && newOutput.length > 0) {
+                        output += newOutput;
+                        // Analyze current state
+                        processState = analyzeProcessState(output, pid);
+                        // Exit early if we detect the process is waiting for input
+                        if (processState.isWaitingForInput) {
+                            earlyExit = true;
+                            resolveOnce();
+                            return;
+                        }
+                        // Also exit if process finished
+                        if (processState.isFinished) {
+                            resolveOnce();
+                            return;
+                        }
+                    }
+                    attempts++;
+                    if (attempts >= maxAttempts) {
+                        resolveOnce();
+                    }
+                }, 200);
+            });
+        };
+        await waitForResponse();
+        // Clean and format output
+        const cleanOutput = cleanProcessOutput(output, input);
+        const timeoutReached = !earlyExit && !processState?.isFinished && !processState?.isWaitingForInput;
+        // Determine final state
+        if (!processState) {
+            processState = analyzeProcessState(output, pid);
+        }
+        let statusMessage = '';
+        if (processState.isWaitingForInput) {
+            statusMessage = `\n🔄 ${formatProcessStateMessage(processState, pid)}`;
+        }
+        else if (processState.isFinished) {
+            statusMessage = `\n✅ ${formatProcessStateMessage(processState, pid)}`;
+        }
+        else if (timeoutReached) {
+            statusMessage = '\n⏱️ Response may be incomplete (timeout reached)';
+        }
+        if (cleanOutput.trim().length === 0 && !timeoutReached) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `✅ Input executed in process ${pid}.\n📭 (No output produced)${statusMessage}`
+                    }],
+            };
+        }
+        // Format response with better structure and consistent emojis
+        let responseText = `✅ Input executed in process ${pid}`;
+        if (cleanOutput && cleanOutput.trim().length > 0) {
+            responseText += `:\n\n📤 Output:\n${cleanOutput}`;
+        }
+        else {
+            responseText += `.\n📭 (No output produced)`;
+        }
+        if (statusMessage) {
+            responseText += `\n\n${statusMessage}`;
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: responseText
+                }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        capture('server_interact_with_process_error', {
+            error: errorMessage
+        });
+        return {
+            content: [{ type: "text", text: `Error interacting with process: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Force terminate a process
+ */
+export async function forceTerminate(args) {
+    const parsed = ForceTerminateArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for force_terminate: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    const success = terminalManager.forceTerminate(parsed.data.pid);
+    return {
+        content: [{
+                type: "text",
+                text: success
+                    ? `Successfully initiated termination of session ${parsed.data.pid}`
+                    : `No active session found for PID ${parsed.data.pid}`
+            }],
+    };
+}
+/**
+ * List active sessions
+ */
+export async function listSessions() {
+    const sessions = terminalManager.listActiveSessions();
+    return {
+        content: [{
+                type: "text",
+                text: sessions.length === 0
+                    ? 'No active sessions'
+                    : sessions.map(s => `PID: ${s.pid}, Blocked: ${s.isBlocked}, Runtime: ${Math.round(s.runtime / 1000)}s`).join('\n')
+            }],
+    };
+}

package/dist/tools/schemas.d.ts

@@ -11,7 +11,7 @@ export declare const SetConfigValueArgsSchema: z.ZodObject<{
     value?: any;
 }>;
 export declare const ListProcessesArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-export declare const ExecuteCommandArgsSchema: z.ZodObject<{
+export declare const StartProcessArgsSchema: z.ZodObject<{
     command: z.ZodString;
     timeout_ms: z.ZodNumber;
     shell: z.ZodOptional<z.ZodString>;
@@ -24,7 +24,7 @@ export declare const ExecuteCommandArgsSchema: z.ZodObject<{
     timeout_ms: number;
     shell?: string | undefined;
 }>;
-export declare const ReadOutputArgsSchema: z.ZodObject<{
+export declare const ReadProcessOutputArgsSchema: z.ZodObject<{
     pid: z.ZodNumber;
     timeout_ms: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
@@ -173,3 +173,21 @@ export declare const EditBlockArgsSchema: z.ZodObject<{
     new_string: string;
     expected_replacements?: number | undefined;
 }>;
+export declare const InteractWithProcessArgsSchema: z.ZodObject<{
+    pid: z.ZodNumber;
+    input: z.ZodString;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+    wait_for_prompt: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    pid: number;
+    input: string;
+    timeout_ms?: number | undefined;
+    wait_for_prompt?: boolean | undefined;
+}, {
+    pid: number;
+    input: string;
+    timeout_ms?: number | undefined;
+    wait_for_prompt?: boolean | undefined;
+}>;
+export declare const GetUsageStatsArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const GiveFeedbackArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;

package/dist/tools/schemas.js

@@ -1,5 +1,4 @@
 import { z } from "zod";
-console.error("Loading schemas.ts");
 // Config tools schemas
 export const GetConfigArgsSchema = z.object({});
 export const SetConfigValueArgsSchema = z.object({
@@ -9,12 +8,12 @@ export const SetConfigValueArgsSchema = z.object({
 // Empty schemas
 export const ListProcessesArgsSchema = z.object({});
 // Terminal tools schemas
-export const ExecuteCommandArgsSchema = z.object({
+export const StartProcessArgsSchema = z.object({
     command: z.string(),
     timeout_ms: z.number(),
     shell: z.string().optional(),
 });
-export const ReadOutputArgsSchema = z.object({
+export const ReadProcessOutputArgsSchema = z.object({
     pid: z.number(),
     timeout_ms: z.number().optional(),
 });
@@ -76,3 +75,21 @@ export const EditBlockArgsSchema = z.object({
     new_string: z.string(),
     expected_replacements: z.number().optional().default(1),
 });
+// Send input to process schema
+export const InteractWithProcessArgsSchema = z.object({
+    pid: z.number(),
+    input: z.string(),
+    timeout_ms: z.number().optional(),
+    wait_for_prompt: z.boolean().optional(),
+});
+// Usage stats schema
+export const GetUsageStatsArgsSchema = z.object({});
+// Feedback tool schema - no pre-filled parameters, all user input
+export const GiveFeedbackArgsSchema = z.object({
+// No parameters needed - form will be filled manually by user
+// Only auto-filled hidden fields remain:
+// - tool_call_count (auto)
+// - days_using (auto) 
+// - platform (auto)
+// - client_id (auto)
+});

package/dist/tools/usage.d.ts

@@ -0,0 +1,5 @@
+import { ServerResult } from '../types.js';
+/**
+ * Get usage statistics for debugging and analysis
+ */
+export declare function getUsageStats(): Promise<ServerResult>;

package/dist/tools/usage.js

@@ -0,0 +1,24 @@
+import { usageTracker } from '../utils/usageTracker.js';
+/**
+ * Get usage statistics for debugging and analysis
+ */
+export async function getUsageStats() {
+    try {
+        const summary = await usageTracker.getUsageSummary();
+        return {
+            content: [{
+                    type: "text",
+                    text: summary
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error retrieving usage stats: ${error instanceof Error ? error.message : String(error)}`
+                }],
+            isError: true
+        };
+    }
+}

package/dist/utils/capture.d.ts

@@ -12,4 +12,6 @@ export declare function sanitizeError(error: any): {
  * @param event Event name
  * @param properties Optional event properties
  */
+export declare const captureBase: (captureURL: string, event: string, properties?: any) => Promise<void>;
+export declare const capture_call_tool: (event: string, properties?: any) => Promise<void>;
 export declare const capture: (event: string, properties?: any) => Promise<void>;

package/dist/utils/capture.js

@@ -10,11 +10,6 @@ try {
 catch {
     // Continue without version info if not available
 }
-// Configuration
-const GA_MEASUREMENT_ID = 'G-NGGDNL0K4L'; // Replace with your GA4 Measurement ID
-const GA_API_SECRET = '5M0mC--2S_6t94m8WrI60A'; // Replace with your GA4 API Secret
-const GA_BASE_URL = `https://www.google-analytics.com/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
-const GA_DEBUG_BASE_URL = `https://www.google-analytics.com/debug/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
 // Will be initialized when needed
 let uniqueUserId = 'unknown';
 // Function to get or create a persistent UUID
@@ -70,18 +65,27 @@ export function sanitizeError(error) {
  * @param event Event name
  * @param properties Optional event properties
  */
-export const capture = async (event, properties) => {
+export const captureBase = async (captureURL, event, properties) => {
     try {
         // Check if telemetry is enabled in config (defaults to true if not set)
         const telemetryEnabled = await configManager.getValue('telemetryEnabled');
         // If telemetry is explicitly disabled or GA credentials are missing, don't send
-        if (telemetryEnabled === false || !GA_MEASUREMENT_ID || !GA_API_SECRET) {
+        if (telemetryEnabled === false || !captureURL) {
             return;
         }
         // Get or create the client ID if not already initialized
         if (uniqueUserId === 'unknown') {
             uniqueUserId = await getOrCreateUUID();
         }
+        // Get current client information for all events
+        const currentClient = configManager.getCurrentClientInfo();
+        let clientContext = {};
+        if (currentClient) {
+            clientContext = {
+                client_name: currentClient.name,
+                client_version: currentClient.version,
+            };
+        }
         // Create a deep copy of properties to avoid modifying the original objects
         // This ensures we don't alter error objects that are also returned to the AI
         let sanitizedProperties;
@@ -114,16 +118,29 @@ export const capture = async (event, properties) => {
                 delete sanitizedProperties[key];
             }
         }
+        // Is MCP installed with DXT
+        let isDXT = 'false';
+        if (process.env.MCP_DXT) {
+            isDXT = 'true';
+        }
+        // Is MCP running in a Docker container
+        let isDocker = 'false';
+        if (process.env.MCP_CLIENT_DOCKER) {
+            isDocker = 'true';
+        }
         // Prepare standard properties
         const baseProperties = {
             timestamp: new Date().toISOString(),
             platform: platform(),
+            isDocker,
+            isDXT,
             app_version: VERSION,
             engagement_time_msec: "100"
         };
-        // Combine with sanitized properties
+        // Combine with sanitized properties and client context
         const eventProperties = {
             ...baseProperties,
+            ...clientContext,
             ...sanitizedProperties
         };
         // Prepare GA4 payload
@@ -145,7 +162,7 @@ export const capture = async (event, properties) => {
                 'Content-Length': Buffer.byteLength(postData)
             }
         };
-        const req = https.request(GA_BASE_URL, options, (res) => {
+        const req = https.request(captureURL, options, (res) => {
             // Response handling (optional)
             let data = '';
             res.on('data', (chunk) => {
@@ -173,3 +190,17 @@ export const capture = async (event, properties) => {
         // Silently fail - we don't want analytics issues to break functionality
     }
 };
+export const capture_call_tool = async (event, properties) => {
+    const GA_MEASUREMENT_ID = 'G-35YKFM782B'; // Replace with your GA4 Measurement ID
+    const GA_API_SECRET = 'qM5VNk6aQy6NN5s-tCppZw'; // Replace with your GA4 API Secret
+    const GA_BASE_URL = `https://www.google-analytics.com/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
+    const GA_DEBUG_BASE_URL = `https://www.google-analytics.com/debug/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
+    return await captureBase(GA_BASE_URL, event, properties);
+};
+export const capture = async (event, properties) => {
+    const GA_MEASUREMENT_ID = 'G-NGGDNL0K4L'; // Replace with your GA4 Measurement ID
+    const GA_API_SECRET = '5M0mC--2S_6t94m8WrI60A'; // Replace with your GA4 API Secret
+    const GA_BASE_URL = `https://www.google-analytics.com/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
+    const GA_DEBUG_BASE_URL = `https://www.google-analytics.com/debug/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
+    return await captureBase(GA_BASE_URL, event, properties);
+};

package/dist/utils/early-logger.d.ts

@@ -0,0 +1,4 @@
+export declare function setTransportInstance(transport: any): void;
+export declare function logError(message: string, data?: any): void;
+export declare function logInfo(message: string, data?: any): void;
+export declare function logWarning(message: string, data?: any): void;