@wonderwhy-er/desktop-commander 0.2.3 → 0.2.5

package/dist/utils/startup-detector.js

@@ -0,0 +1,390 @@
+/**
+ * Production-Ready Startup Detection Module
+ *
+ * This module provides a lightweight, production-ready way to detect
+ * how a Node.js application was started. Perfect for logging, analytics,
+ * or conditional behavior based on startup method.
+ */
+import { readFileSync } from 'fs';
+import { platform } from 'os';
+export class StartupDetector {
+    constructor() {
+        this._startupInfo = null;
+    }
+    static getInstance() {
+        if (!StartupDetector.instance) {
+            StartupDetector.instance = new StartupDetector();
+        }
+        return StartupDetector.instance;
+    }
+    /**
+     * Get startup information (cached after first call)
+     */
+    getStartupInfo() {
+        if (!this._startupInfo) {
+            this._startupInfo = this.detectStartupMethod();
+        }
+        return this._startupInfo;
+    }
+    /**
+     * Force re-detection (useful for testing)
+     */
+    forceRedetect() {
+        this._startupInfo = this.detectStartupMethod();
+        return this._startupInfo;
+    }
+    detectStartupMethod() {
+        const detectors = [
+            this.detectSmithery.bind(this),
+            this.detectNpmRun.bind(this),
+            this.detectNpx.bind(this),
+            this.detectDocker.bind(this),
+            this.detectCiCd.bind(this),
+            this.detectDirectNode.bind(this)
+        ];
+        const results = detectors.map(detector => detector()).filter(result => result !== null);
+        // Sort by confidence, highest first
+        results.sort((a, b) => b.confidence - a.confidence);
+        if (results.length === 0) {
+            return {
+                method: 'unknown',
+                confidence: 0,
+                details: { evidence: ['No detection method succeeded'] },
+                environment: 'unknown'
+            };
+        }
+        const topResult = results[0];
+        topResult.environment = this.detectEnvironment(topResult);
+        return topResult;
+    }
+    detectNpmRun() {
+        const evidence = [];
+        let confidence = 0;
+        // Primary indicator - npm_lifecycle_event is only set during npm run
+        if (process.env.npm_lifecycle_event) {
+            confidence += 50;
+            evidence.push(`npm script: ${process.env.npm_lifecycle_event}`);
+            // Additional confidence for npm script context
+            if (process.env.npm_lifecycle_script) {
+                confidence += 20;
+            }
+            return {
+                method: 'npm-run',
+                confidence,
+                details: {
+                    npmScript: process.env.npm_lifecycle_event,
+                    evidence
+                },
+                environment: 'unknown' // Will be set later
+            };
+        }
+        return null;
+    }
+    detectNpx() {
+        const evidence = [];
+        let confidence = 0;
+        // Check user agent for npx
+        const userAgent = process.env.npm_config_user_agent;
+        if (userAgent?.includes('npx')) {
+            confidence += 40;
+            evidence.push(`User agent indicates npx: ${userAgent}`);
+        }
+        // NPX specific environment variables
+        if (process.env.NPM_CLI_JS?.includes('npx')) {
+            confidence += 30;
+            evidence.push('NPM_CLI_JS indicates npx execution');
+        }
+        if (confidence > 0) {
+            return {
+                method: 'npx',
+                confidence,
+                details: { evidence },
+                environment: 'unknown'
+            };
+        }
+        return null;
+    }
+    detectDocker() {
+        const evidence = [];
+        let confidence = 0;
+        // Most reliable: Check for .dockerenv file
+        try {
+            readFileSync('/.dockerenv');
+            confidence += 70;
+            evidence.push('/.dockerenv file exists');
+        }
+        catch {
+            // Not in Docker
+        }
+        // Check container environment variable
+        if (process.env.container === 'docker' || process.env.container === 'podman') {
+            confidence += 50;
+            evidence.push(`Container type: ${process.env.container}`);
+        }
+        // Check for Docker-like hostname pattern
+        const hostname = process.env.HOSTNAME;
+        if (hostname && hostname.length === 12 && /^[a-f0-9]{12}$/.test(hostname)) {
+            confidence += 25;
+            evidence.push('Docker-style hostname detected');
+        }
+        // Linux-specific: Check cgroup
+        if (platform() === 'linux') {
+            try {
+                const cgroup = readFileSync('/proc/1/cgroup', 'utf8');
+                if (cgroup.includes('docker') || cgroup.includes('containerd')) {
+                    confidence += 60;
+                    evidence.push('Docker detected in cgroup');
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        if (confidence > 0) {
+            return {
+                method: 'docker',
+                confidence,
+                details: {
+                    dockerContainer: true,
+                    evidence
+                },
+                environment: 'unknown'
+            };
+        }
+        return null;
+    }
+    detectCiCd() {
+        const evidence = [];
+        let confidence = 0;
+        let ciPlatform;
+        const ciDetectors = {
+            'GitHub Actions': () => process.env.GITHUB_ACTIONS === 'true',
+            'GitLab CI': () => process.env.GITLAB_CI === 'true',
+            'Jenkins': () => !!process.env.JENKINS_URL,
+            'CircleCI': () => process.env.CIRCLECI === 'true',
+            'Travis CI': () => process.env.TRAVIS === 'true',
+            'Azure DevOps': () => process.env.TF_BUILD === 'True',
+            'Bamboo': () => !!process.env.bamboo_buildKey,
+            'TeamCity': () => !!process.env.TEAMCITY_VERSION
+        };
+        for (const [platform, detector] of Object.entries(ciDetectors)) {
+            if (detector()) {
+                ciPlatform = platform;
+                confidence += 60;
+                evidence.push(`${platform} environment detected`);
+                break;
+            }
+        }
+        // Generic CI detection
+        if (!ciPlatform && (process.env.CI === 'true' || process.env.CI === '1')) {
+            confidence += 40;
+            evidence.push('Generic CI environment');
+            ciPlatform = 'Generic CI';
+        }
+        if (confidence > 0) {
+            return {
+                method: 'ci-cd',
+                confidence,
+                details: {
+                    ciPlatform,
+                    evidence
+                },
+                environment: 'unknown'
+            };
+        }
+        return null;
+    }
+    detectDirectNode() {
+        const evidence = [];
+        let confidence = 0;
+        // If no npm/npx indicators are present, likely direct node
+        if (!process.env.npm_lifecycle_event &&
+            !process.env.npm_config_user_agent &&
+            !process.env.npm_execpath) {
+            confidence += 30;
+            evidence.push('No package manager environment variables');
+        }
+        // This is more of a fallback, so lower confidence
+        if (confidence > 0) {
+            return {
+                method: 'node-direct',
+                confidence,
+                details: { evidence },
+                environment: 'unknown'
+            };
+        }
+        return null;
+    }
+    detectSmithery() {
+        const evidence = [];
+        let confidence = 0;
+        let smitheryClient;
+        let smitheryConnection;
+        let smitherySession;
+        // Check for Smithery-specific environment variables
+        const smitheryEnvVars = [
+            'SMITHERY_SESSION_ID',
+            'SMITHERY_CLIENT',
+            'SMITHERY_PROFILE',
+            'SMITHERY_ANALYTICS',
+            'SMITHERY_CONNECTION_TYPE',
+            'SMITHERY_QUALIFIED_NAME'
+        ];
+        for (const envVar of smitheryEnvVars) {
+            if (process.env[envVar]) {
+                confidence += 40;
+                evidence.push(`Smithery environment variable: ${envVar}`);
+                // Extract specific details
+                switch (envVar) {
+                    case 'SMITHERY_SESSION_ID':
+                        smitherySession = process.env[envVar];
+                        break;
+                    case 'SMITHERY_CLIENT':
+                        smitheryClient = process.env[envVar];
+                        break;
+                    case 'SMITHERY_CONNECTION_TYPE':
+                        smitheryConnection = process.env[envVar];
+                        break;
+                }
+            }
+        }
+        // Check for Smithery endpoints
+        if (process.env.REGISTRY_ENDPOINT?.includes('smithery')) {
+            confidence += 30;
+            evidence.push('Smithery registry endpoint detected');
+        }
+        if (process.env.ANALYTICS_ENDPOINT?.includes('smithery')) {
+            confidence += 25;
+            evidence.push('Smithery analytics endpoint detected');
+        }
+        // Check process arguments for Smithery patterns
+        const args = process.argv.join(' ');
+        const smitheryPatterns = [
+            /smithery[\s\/\\]cli/i,
+            /@smithery[\s\/\\]cli/i,
+            /npx.*@smithery/i,
+            /smithery.*run/i
+        ];
+        for (const pattern of smitheryPatterns) {
+            if (pattern.test(args)) {
+                confidence += 35;
+                evidence.push('Smithery CLI pattern in arguments');
+                break;
+            }
+        }
+        // Check for UUID v7 session pattern (Smithery uses uuidv7)
+        const envVars = Object.keys(process.env);
+        for (const key of envVars) {
+            const value = process.env[key] || '';
+            if (/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)) {
+                confidence += 25;
+                evidence.push('UUID v7 session ID pattern detected');
+                if (!smitherySession)
+                    smitherySession = value;
+                break;
+            }
+        }
+        if (confidence > 0) {
+            return {
+                method: 'smithery',
+                confidence,
+                details: {
+                    smitheryClient,
+                    smitheryConnection,
+                    smitherySession,
+                    evidence
+                },
+                environment: 'unknown'
+            };
+        }
+        return null;
+    }
+    detectEnvironment(startupInfo) {
+        // Smithery is always considered smithery environment
+        if (startupInfo.method === 'smithery') {
+            return 'smithery';
+        }
+        // Docker containers are usually production or CI
+        if (startupInfo.method === 'docker') {
+            // Check if it's also CI
+            if (process.env.CI === 'true' || process.env.CI === '1') {
+                return 'ci';
+            }
+            return 'container';
+        }
+        // Check NODE_ENV
+        const nodeEnv = process.env.NODE_ENV?.toLowerCase();
+        if (nodeEnv === 'production')
+            return 'production';
+        if (nodeEnv === 'development')
+            return 'development';
+        // NPM scripts often indicate development
+        if (startupInfo.method === 'npm-run') {
+            const script = startupInfo.details.npmScript;
+            if (script?.includes('dev') || script?.includes('start')) {
+                return 'development';
+            }
+            if (script?.includes('prod') || script?.includes('build')) {
+                return 'production';
+            }
+            return 'development'; // Default for npm scripts
+        }
+        // NPX is often used for one-off tools in development
+        if (startupInfo.method === 'npx') {
+            return 'development';
+        }
+        return 'unknown';
+    }
+    /**
+     * Get a simple string representation of how the app was started
+     */
+    getStartupMethodString() {
+        const info = this.getStartupInfo();
+        switch (info.method) {
+            case 'npm-run':
+                return `npm run ${info.details.npmScript || 'script'}`;
+            case 'npx':
+                return 'npx';
+            case 'docker':
+                return 'Docker container';
+            case 'ci-cd':
+                return info.details.ciPlatform || 'CI/CD';
+            case 'smithery':
+                return `Smithery CLI${info.details.smitheryClient ? ` (${info.details.smitheryClient})` : ''}`;
+            case 'node-direct':
+                return 'node (direct)';
+            default:
+                return 'unknown';
+        }
+    }
+    /**
+     * Check if running in a specific environment
+     */
+    isEnvironment(env) {
+        return this.getStartupInfo().environment === env;
+    }
+    /**
+     * Check if running via a specific method
+     */
+    isMethod(method) {
+        return this.getStartupInfo().method === method;
+    }
+}
+// Singleton instance
+export const startupDetector = StartupDetector.getInstance();
+// Convenience functions
+export const getStartupInfo = () => startupDetector.getStartupInfo();
+export const getStartupMethod = () => startupDetector.getStartupMethodString();
+export const isProduction = () => startupDetector.isEnvironment('production');
+export const isDevelopment = () => startupDetector.isEnvironment('development');
+export const isDocker = () => startupDetector.isMethod('docker');
+export const isCi = () => startupDetector.isEnvironment('ci');
+export const isSmithery = () => startupDetector.isMethod('smithery');
+export const getSmitheryClient = () => {
+    const info = startupDetector.getStartupInfo();
+    return info.method === 'smithery' ? info.details.smitheryClient : undefined;
+};
+export const getSmitheryConnection = () => {
+    const info = startupDetector.getStartupInfo();
+    return info.method === 'smithery' ? info.details.smitheryConnection : undefined;
+};

package/dist/utils/usageTracker.d.ts

@@ -0,0 +1,85 @@
+export interface ToolUsageStats {
+    filesystemOperations: number;
+    terminalOperations: number;
+    editOperations: number;
+    searchOperations: number;
+    configOperations: number;
+    processOperations: number;
+    totalToolCalls: number;
+    successfulCalls: number;
+    failedCalls: number;
+    toolCounts: Record<string, number>;
+    firstUsed: number;
+    lastUsed: number;
+    totalSessions: number;
+    lastFeedbackPrompt: number;
+}
+export interface UsageSession {
+    sessionStart: number;
+    lastActivity: number;
+    commandsInSession: number;
+}
+declare class UsageTracker {
+    private currentSession;
+    /**
+     * Get default usage stats
+     */
+    private getDefaultStats;
+    /**
+     * Get current usage stats from config
+     */
+    getStats(): Promise<ToolUsageStats>;
+    /**
+     * Save usage stats to config
+     */
+    private saveStats;
+    /**
+     * Determine which category a tool belongs to
+     */
+    private getToolCategory;
+    /**
+     * Check if we're in a new session
+     */
+    private isNewSession;
+    /**
+     * Update session tracking
+     */
+    private updateSession;
+    /**
+     * Track a successful tool call
+     */
+    trackSuccess(toolName: string): Promise<ToolUsageStats>;
+    /**
+     * Track a failed tool call
+     */
+    trackFailure(toolName: string): Promise<ToolUsageStats>;
+    /**
+     * Check if user should be prompted for feedback based on usage patterns
+     */
+    shouldPromptForFeedback(): Promise<boolean>;
+    /**
+     * Get a random feedback prompt message with strong CTAs and clear actions
+     */
+    getFeedbackPromptMessage(): Promise<{
+        variant: string;
+        message: string;
+    }>;
+    /**
+     * Check if user should be prompted for error feedback
+     */
+    shouldPromptForErrorFeedback(): Promise<boolean>;
+    /**
+     * Mark that user was prompted for feedback
+     */
+    markFeedbackPrompted(): Promise<void>;
+    /**
+     * Mark that user has given feedback
+     */
+    markFeedbackGiven(): Promise<void>;
+    /**
+     * Get usage summary for debugging/admin purposes
+     */
+    getUsageSummary(): Promise<string>;
+}
+export declare const usageTracker: UsageTracker;
+export {};