@wonderwhy-er/desktop-commander 0.2.2 → 0.2.4

package/dist/utils/startup-detector.d.ts

@@ -0,0 +1,65 @@
+/**
+ * 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.
+ */
+export interface StartupInfo {
+    method: 'npm-run' | 'npx' | 'docker' | 'node-direct' | 'ci-cd' | 'smithery' | 'unknown';
+    confidence: number;
+    details: {
+        npmScript?: string;
+        ciPlatform?: string;
+        dockerContainer?: boolean;
+        smitheryClient?: string;
+        smitheryConnection?: string;
+        smitherySession?: string;
+        evidence: string[];
+    };
+    environment: 'development' | 'production' | 'ci' | 'container' | 'smithery' | 'unknown';
+}
+export declare class StartupDetector {
+    private static instance;
+    private _startupInfo;
+    private constructor();
+    static getInstance(): StartupDetector;
+    /**
+     * Get startup information (cached after first call)
+     */
+    getStartupInfo(): StartupInfo;
+    /**
+     * Force re-detection (useful for testing)
+     */
+    forceRedetect(): StartupInfo;
+    private detectStartupMethod;
+    private detectNpmRun;
+    private detectNpx;
+    private detectDocker;
+    private detectCiCd;
+    private detectDirectNode;
+    private detectSmithery;
+    private detectEnvironment;
+    /**
+     * Get a simple string representation of how the app was started
+     */
+    getStartupMethodString(): string;
+    /**
+     * Check if running in a specific environment
+     */
+    isEnvironment(env: StartupInfo['environment']): boolean;
+    /**
+     * Check if running via a specific method
+     */
+    isMethod(method: StartupInfo['method']): boolean;
+}
+export declare const startupDetector: StartupDetector;
+export declare const getStartupInfo: () => StartupInfo;
+export declare const getStartupMethod: () => string;
+export declare const isProduction: () => boolean;
+export declare const isDevelopment: () => boolean;
+export declare const isDocker: () => boolean;
+export declare const isCi: () => boolean;
+export declare const isSmithery: () => boolean;
+export declare const getSmitheryClient: () => string | undefined;
+export declare const getSmitheryConnection: () => string | undefined;

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/system-info.d.ts

@@ -0,0 +1,30 @@
+export interface SystemInfo {
+    platform: string;
+    platformName: string;
+    defaultShell: string;
+    pathSeparator: string;
+    isWindows: boolean;
+    isMacOS: boolean;
+    isLinux: boolean;
+    examplePaths: {
+        home: string;
+        temp: string;
+        absolute: string;
+    };
+}
+/**
+ * Get comprehensive system information for tool prompts
+ */
+export declare function getSystemInfo(): SystemInfo;
+/**
+ * Generate OS-specific guidance for tool prompts
+ */
+export declare function getOSSpecificGuidance(systemInfo: SystemInfo): string;
+/**
+ * Get common development tool guidance based on OS
+ */
+export declare function getDevelopmentToolGuidance(systemInfo: SystemInfo): string;
+/**
+ * Get path guidance (simplified since paths are normalized)
+ */
+export declare function getPathGuidance(systemInfo: SystemInfo): string;

package/dist/utils/system-info.js

@@ -0,0 +1,146 @@
+import os from 'os';
+/**
+ * Get comprehensive system information for tool prompts
+ */
+export function getSystemInfo() {
+    const platform = os.platform();
+    const isWindows = platform === 'win32';
+    const isMacOS = platform === 'darwin';
+    const isLinux = platform === 'linux';
+    let platformName;
+    let defaultShell;
+    let pathSeparator;
+    let examplePaths;
+    if (isWindows) {
+        platformName = 'Windows';
+        defaultShell = 'powershell.exe';
+        pathSeparator = '\\';
+        examplePaths = {
+            home: 'C:\\Users\\username',
+            temp: 'C:\\Temp',
+            absolute: 'C:\\path\\to\\file.txt'
+        };
+    }
+    else if (isMacOS) {
+        platformName = 'macOS';
+        defaultShell = 'zsh';
+        pathSeparator = '/';
+        examplePaths = {
+            home: '/Users/username',
+            temp: '/tmp',
+            absolute: '/path/to/file.txt'
+        };
+    }
+    else if (isLinux) {
+        platformName = 'Linux';
+        defaultShell = 'bash';
+        pathSeparator = '/';
+        examplePaths = {
+            home: '/home/username',
+            temp: '/tmp',
+            absolute: '/path/to/file.txt'
+        };
+    }
+    else {
+        // Fallback for other Unix-like systems
+        platformName = 'Unix';
+        defaultShell = 'bash';
+        pathSeparator = '/';
+        examplePaths = {
+            home: '/home/username',
+            temp: '/tmp',
+            absolute: '/path/to/file.txt'
+        };
+    }
+    return {
+        platform,
+        platformName,
+        defaultShell,
+        pathSeparator,
+        isWindows,
+        isMacOS,
+        isLinux,
+        examplePaths
+    };
+}
+/**
+ * Generate OS-specific guidance for tool prompts
+ */
+export function getOSSpecificGuidance(systemInfo) {
+    const { platformName, defaultShell, isWindows } = systemInfo;
+    let guidance = `Running on ${platformName}. Default shell: ${defaultShell}.`;
+    if (isWindows) {
+        guidance += `
+        
+WINDOWS-SPECIFIC TROUBLESHOOTING:
+- If Node.js/Python commands fail with "not recognized" errors:
+  * Try different shells: specify shell parameter as "cmd" or "powershell.exe"
+  * PowerShell may have execution policy restrictions for some tools
+  * CMD typically has better compatibility with development tools
+  * Use set_config_value to change defaultShell if needed
+- Windows services and processes use different commands (Get-Process vs ps)
+- Package managers: choco, winget, scoop instead of apt/brew
+- Environment variables: $env:VAR instead of $VAR
+- File permissions work differently than Unix systems`;
+    }
+    else if (systemInfo.isMacOS) {
+        guidance += `
+        
+MACOS-SPECIFIC NOTES:
+- Package manager: brew (Homebrew) is commonly used
+- Python 3 might be 'python3' command, not 'python'
+- Some GNU tools have different names (e.g., gsed instead of sed)
+- System Integrity Protection (SIP) may block certain operations
+- Use 'open' command to open files/applications from terminal`;
+    }
+    else {
+        guidance += `
+        
+LINUX-SPECIFIC NOTES:
+- Package managers vary by distro: apt, yum, dnf, pacman, zypper
+- Python 3 might be 'python3' command, not 'python'
+- Standard Unix shell tools available (grep, awk, sed, etc.)
+- File permissions and ownership important for many operations
+- Systemd services common on modern distributions`;
+    }
+    return guidance;
+}
+/**
+ * Get common development tool guidance based on OS
+ */
+export function getDevelopmentToolGuidance(systemInfo) {
+    const { isWindows, isMacOS, isLinux, platformName } = systemInfo;
+    if (isWindows) {
+        return `
+COMMON WINDOWS DEVELOPMENT TOOLS:
+- Node.js: Usually installed globally, accessible from any shell
+- Python: May be 'python' or 'py' command, check both
+- Git: Git Bash provides Unix-like environment
+- WSL: Windows Subsystem for Linux available for Unix tools
+- Visual Studio tools: cl, msbuild for C++ compilation`;
+    }
+    else if (isMacOS) {
+        return `
+COMMON MACOS DEVELOPMENT TOOLS:
+- Xcode Command Line Tools: Required for many development tools
+- Homebrew: Primary package manager for development tools
+- Python: Usually python3, check if python points to Python 2
+- Node.js: Available via brew or direct installer
+- Ruby: System Ruby available, rbenv/rvm for version management`;
+    }
+    else {
+        return `
+COMMON LINUX DEVELOPMENT TOOLS:
+- Package managers: Install tools via distribution package manager
+- Python: Usually python3, python may point to Python 2
+- Node.js: Available via package manager or NodeSource repository
+- Build tools: gcc, make typically available or easily installed
+- Container tools: docker, podman common for development`;
+    }
+}
+/**
+ * Get path guidance (simplified since paths are normalized)
+ */
+export function getPathGuidance(systemInfo) {
+    return `Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction.`;
+}