@wonderwhy-er/desktop-commander 0.2.9 → 0.2.11

package/dist/utils/system-info.js

@@ -2,37 +2,111 @@ import os from 'os';
 import fs from 'fs';
 import path from 'path';
 /**
- * Detect if running inside Docker container
+ * Detect container environment and type
  */
-function isRunningInDocker() {
-    // Method 1: MCP_CLIENT_DOCKER environment variable (set in Dockerfile)
+function detectContainerEnvironment() {
+    // Method 1: Check environment variables first (most reliable when set)
+    // Docker-specific
     if (process.env.MCP_CLIENT_DOCKER === 'true') {
-        return true;
+        return { isContainer: true, containerType: 'docker', orchestrator: null };
     }
-    // Method 2: Check for .dockerenv file
+    // Kubernetes detection
+    if (process.env.KUBERNETES_SERVICE_HOST || process.env.KUBERNETES_PORT) {
+        return { isContainer: true, containerType: 'kubernetes', orchestrator: 'kubernetes' };
+    }
+    // Podman detection
+    if (process.env.PODMAN_CONTAINER || process.env.CONTAINER_HOST?.includes('podman')) {
+        return { isContainer: true, containerType: 'podman', orchestrator: null };
+    }
+    // Method 2: Check for container indicator files
     if (fs.existsSync('/.dockerenv')) {
-        return true;
+        return { isContainer: true, containerType: 'docker', orchestrator: null };
     }
     // Method 3: Check /proc/1/cgroup for container indicators (Linux only)
     if (os.platform() === 'linux') {
         try {
             const cgroup = fs.readFileSync('/proc/1/cgroup', 'utf8');
-            if (cgroup.includes('docker') || cgroup.includes('containerd')) {
-                return true;
+            // Docker detection
+            if (cgroup.includes('docker')) {
+                return { isContainer: true, containerType: 'docker', orchestrator: null };
+            }
+            // Kubernetes detection (pods run in containerd/cri-o)
+            if (cgroup.includes('kubepods') || cgroup.includes('pod')) {
+                return { isContainer: true, containerType: 'kubernetes', orchestrator: 'kubernetes' };
+            }
+            // Podman detection
+            if (cgroup.includes('podman') || cgroup.includes('libpod')) {
+                return { isContainer: true, containerType: 'podman', orchestrator: null };
+            }
+            // LXC detection
+            if (cgroup.includes('lxc')) {
+                return { isContainer: true, containerType: 'lxc', orchestrator: null };
+            }
+            // systemd-nspawn detection
+            if (cgroup.includes('machine.slice')) {
+                return { isContainer: true, containerType: 'systemd-nspawn', orchestrator: null };
+            }
+            // Generic containerd detection
+            if (cgroup.includes('containerd')) {
+                return { isContainer: true, containerType: 'other', orchestrator: null };
             }
         }
         catch (error) {
             // /proc/1/cgroup might not exist
         }
     }
-    return false;
+    // Method 4: Check /proc/1/environ for container indicators
+    if (os.platform() === 'linux') {
+        try {
+            const environ = fs.readFileSync('/proc/1/environ', 'utf8');
+            if (environ.includes('container=')) {
+                // systemd-nspawn sets container=systemd-nspawn
+                if (environ.includes('container=systemd-nspawn')) {
+                    return { isContainer: true, containerType: 'systemd-nspawn', orchestrator: null };
+                }
+                // LXC sets container=lxc
+                if (environ.includes('container=lxc')) {
+                    return { isContainer: true, containerType: 'lxc', orchestrator: null };
+                }
+                // Generic container detection
+                return { isContainer: true, containerType: 'other', orchestrator: null };
+            }
+        }
+        catch (error) {
+            // /proc/1/environ might not exist or be accessible
+        }
+    }
+    // Method 5: Check hostname for Kubernetes patterns
+    try {
+        const hostname = os.hostname();
+        // Kubernetes pods often have hostnames like: podname-deploymentid-randomid
+        if (hostname && (hostname.includes('-') && hostname.split('-').length >= 3)) {
+            // Additional check for Kubernetes service account
+            if (fs.existsSync('/var/run/secrets/kubernetes.io')) {
+                return { isContainer: true, containerType: 'kubernetes', orchestrator: 'kubernetes' };
+            }
+        }
+    }
+    catch (error) {
+        // Hostname check failed
+    }
+    // Method 6: Check for orchestrator-specific indicators
+    // Docker Compose detection
+    if (process.env.COMPOSE_PROJECT_NAME || process.env.COMPOSE_SERVICE) {
+        return { isContainer: true, containerType: 'docker', orchestrator: 'docker-compose' };
+    }
+    // Docker Swarm detection
+    if (process.env.DOCKER_SWARM_MODE || process.env.DOCKER_NODE_ID) {
+        return { isContainer: true, containerType: 'docker', orchestrator: 'docker-swarm' };
+    }
+    return { isContainer: false, containerType: null, orchestrator: null };
 }
 /**
- * Discover Docker mount points
+ * Discover container mount points
  */
-function discoverDockerMounts() {
+function discoverContainerMounts(isContainer) {
     const mounts = [];
-    if (!isRunningInDocker()) {
+    if (!isContainer) {
         return mounts;
     }
     // Method 1: Parse /proc/mounts (Linux only)
@@ -140,7 +214,7 @@ function discoverDockerMounts() {
 /**
  * Get container environment information
  */
-function getContainerEnvironment() {
+function getContainerEnvironment(containerType) {
     const env = {};
     // Try to get container name from hostname (often set to container ID/name)
     try {
@@ -152,9 +226,78 @@ function getContainerEnvironment() {
     catch (error) {
         // Hostname not available
     }
-    // Try to get Docker image from environment variables
-    if (process.env.DOCKER_IMAGE) {
-        env.dockerImage = process.env.DOCKER_IMAGE;
+    // Docker-specific environment
+    if (containerType === 'docker') {
+        // Try multiple sources for Docker image name
+        if (process.env.DOCKER_IMAGE) {
+            env.dockerImage = process.env.DOCKER_IMAGE;
+        }
+        else if (process.env.IMAGE_NAME) {
+            env.dockerImage = process.env.IMAGE_NAME;
+        }
+        else if (process.env.CONTAINER_IMAGE) {
+            env.dockerImage = process.env.CONTAINER_IMAGE;
+        }
+        // Try to read from Docker labels if available (less common but possible)
+        try {
+            if (fs.existsSync('/proc/self/cgroup')) {
+                const cgroup = fs.readFileSync('/proc/self/cgroup', 'utf8');
+                // Extract container ID from cgroup path
+                const containerIdMatch = cgroup.match(/docker\/([a-f0-9]{64})/);
+                if (containerIdMatch && !env.containerName) {
+                    // Use short container ID as fallback name
+                    env.containerName = containerIdMatch[1].substring(0, 12);
+                }
+            }
+        }
+        catch (error) {
+            // Ignore errors reading cgroup
+        }
+    }
+    // Kubernetes-specific environment
+    if (containerType === 'kubernetes') {
+        if (process.env.KUBERNETES_NAMESPACE || process.env.POD_NAMESPACE) {
+            env.kubernetesNamespace = process.env.KUBERNETES_NAMESPACE || process.env.POD_NAMESPACE;
+        }
+        if (process.env.POD_NAME || process.env.HOSTNAME) {
+            env.kubernetesPod = process.env.POD_NAME || process.env.HOSTNAME;
+        }
+        if (process.env.NODE_NAME || process.env.KUBERNETES_NODE_NAME) {
+            env.kubernetesNode = process.env.NODE_NAME || process.env.KUBERNETES_NODE_NAME;
+        }
+        // Try to get container image from common Kubernetes environment variables
+        if (process.env.CONTAINER_IMAGE) {
+            env.dockerImage = process.env.CONTAINER_IMAGE;
+        }
+        else if (process.env.IMAGE_NAME) {
+            env.dockerImage = process.env.IMAGE_NAME;
+        }
+        // Try to read Kubernetes service account info
+        try {
+            if (fs.existsSync('/var/run/secrets/kubernetes.io/serviceaccount/namespace')) {
+                const namespace = fs.readFileSync('/var/run/secrets/kubernetes.io/serviceaccount/namespace', 'utf8').trim();
+                if (namespace && !env.kubernetesNamespace) {
+                    env.kubernetesNamespace = namespace;
+                }
+            }
+        }
+        catch (error) {
+            // Service account info not available
+        }
+    }
+    // Podman-specific environment
+    if (containerType === 'podman') {
+        // Podman uses similar environment variables to Docker
+        if (process.env.CONTAINER_IMAGE || process.env.PODMAN_IMAGE) {
+            env.dockerImage = process.env.CONTAINER_IMAGE || process.env.PODMAN_IMAGE;
+        }
+    }
+    // LXC-specific environment
+    if (containerType === 'lxc') {
+        // LXC containers might have different naming conventions
+        if (process.env.LXC_NAME) {
+            env.containerName = process.env.LXC_NAME;
+        }
     }
     // Try to detect host platform
     if (process.env.HOST_PLATFORM) {
@@ -170,9 +313,9 @@ export function getSystemInfo() {
     const isWindows = platform === 'win32';
     const isMacOS = platform === 'darwin';
     const isLinux = platform === 'linux';
-    // Docker detection
-    const dockerDetected = isRunningInDocker();
-    const mountPoints = dockerDetected ? discoverDockerMounts() : [];
+    // Container detection
+    const containerDetection = detectContainerEnvironment();
+    const mountPoints = containerDetection.isContainer ? discoverContainerMounts(containerDetection.isContainer) : [];
     let platformName;
     let defaultShell;
     let pathSeparator;
@@ -218,9 +361,37 @@ export function getSystemInfo() {
             absolute: '/path/to/file.txt'
         };
     }
-    // Adjust platform name for Docker
-    if (dockerDetected) {
-        platformName = `${platformName} (Docker)`;
+    // Adjust platform name for containers
+    if (containerDetection.isContainer) {
+        let containerLabel = '';
+        if (containerDetection.containerType === 'kubernetes') {
+            containerLabel = 'Kubernetes';
+            if (containerDetection.orchestrator === 'kubernetes') {
+                containerLabel += ' Pod';
+            }
+        }
+        else if (containerDetection.containerType === 'docker') {
+            containerLabel = 'Docker';
+            if (containerDetection.orchestrator === 'docker-compose') {
+                containerLabel += ' Compose';
+            }
+            else if (containerDetection.orchestrator === 'docker-swarm') {
+                containerLabel += ' Swarm';
+            }
+        }
+        else if (containerDetection.containerType === 'podman') {
+            containerLabel = 'Podman';
+        }
+        else if (containerDetection.containerType === 'lxc') {
+            containerLabel = 'LXC';
+        }
+        else if (containerDetection.containerType === 'systemd-nspawn') {
+            containerLabel = 'systemd-nspawn';
+        }
+        else {
+            containerLabel = 'Container';
+        }
+        platformName = `${platformName} (${containerLabel})`;
         // Add accessible paths from mounts
         if (mountPoints.length > 0) {
             examplePaths.accessible = mountPoints.map(mount => mount.containerPath);
@@ -235,9 +406,14 @@ export function getSystemInfo() {
         isMacOS,
         isLinux,
         docker: {
-            isDocker: dockerDetected,
+            // New container detection fields
+            isContainer: containerDetection.isContainer,
+            containerType: containerDetection.containerType,
+            orchestrator: containerDetection.orchestrator,
+            // Backward compatibility - keep old field
+            isDocker: containerDetection.isContainer && containerDetection.containerType === 'docker',
             mountPoints,
-            containerEnvironment: getContainerEnvironment()
+            containerEnvironment: getContainerEnvironment(containerDetection.containerType)
         },
         examplePaths
     };
@@ -248,12 +424,48 @@ export function getSystemInfo() {
 export function getOSSpecificGuidance(systemInfo) {
     const { platformName, defaultShell, isWindows, docker } = systemInfo;
     let guidance = `Running on ${platformName}. Default shell: ${defaultShell}.`;
-    // Docker-specific guidance
-    if (docker.isDocker) {
+    // Container-specific guidance
+    if (docker.isContainer) {
+        const containerTypeLabel = docker.containerType === 'kubernetes' ? 'KUBERNETES POD' :
+            docker.containerType === 'docker' ? 'DOCKER CONTAINER' :
+                docker.containerType === 'podman' ? 'PODMAN CONTAINER' :
+                    docker.containerType === 'lxc' ? 'LXC CONTAINER' :
+                        docker.containerType === 'systemd-nspawn' ? 'SYSTEMD-NSPAWN CONTAINER' :
+                            'CONTAINER';
         guidance += `
 
-🐳 DOCKER ENVIRONMENT DETECTED:
+🐳 ${containerTypeLabel} ENVIRONMENT DETECTED:`;
+        if (docker.containerType === 'kubernetes') {
+            guidance += `
+This Desktop Commander instance is running inside a Kubernetes pod.`;
+            // Add Kubernetes-specific info
+            if (docker.containerEnvironment?.kubernetesNamespace) {
+                guidance += `
+Namespace: ${docker.containerEnvironment.kubernetesNamespace}`;
+            }
+            if (docker.containerEnvironment?.kubernetesPod) {
+                guidance += `
+Pod: ${docker.containerEnvironment.kubernetesPod}`;
+            }
+            if (docker.containerEnvironment?.kubernetesNode) {
+                guidance += `
+Node: ${docker.containerEnvironment.kubernetesNode}`;
+            }
+        }
+        else if (docker.containerType === 'docker') {
+            guidance += `
 This Desktop Commander instance is running inside a Docker container.`;
+            if (docker.orchestrator === 'docker-compose') {
+                guidance += ` (Docker Compose)`;
+            }
+            else if (docker.orchestrator === 'docker-swarm') {
+                guidance += ` (Docker Swarm)`;
+            }
+        }
+        else {
+            guidance += `
+This Desktop Commander instance is running inside a ${docker.containerType || 'container'} environment.`;
+        }
         if (docker.mountPoints.length > 0) {
             guidance += `
 
@@ -314,7 +526,8 @@ MACOS-SPECIFIC NOTES:
 - 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`;
+- Use 'open' command to open files/applications from terminal
+- For file search: Use mdfind (Spotlight) for fastest exact filename searches`;
     }
     else {
         guidance += `
@@ -366,10 +579,14 @@ COMMON LINUX DEVELOPMENT TOOLS:
  */
 export function getPathGuidance(systemInfo) {
     let guidance = `Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction.`;
-    if (systemInfo.docker.isDocker && systemInfo.docker.mountPoints.length > 0) {
+    if (systemInfo.docker.isContainer && systemInfo.docker.mountPoints.length > 0) {
+        const containerLabel = systemInfo.docker.containerType === 'kubernetes' ? 'KUBERNETES' :
+            systemInfo.docker.containerType === 'docker' ? 'DOCKER' :
+                systemInfo.docker.containerType === 'podman' ? 'PODMAN' :
+                    'CONTAINER';
         guidance += ` 
 
-🐳 DOCKER: Prefer paths within mounted directories: ${systemInfo.docker.mountPoints.map(m => m.containerPath).join(', ')}.
+🐳 ${containerLabel}: Prefer paths within mounted directories: ${systemInfo.docker.mountPoints.map(m => m.containerPath).join(', ')}.
 When users ask about file locations, check these mounted paths first.`;
     }
     return guidance;

package/dist/utils/usageTracker.js

@@ -5,7 +5,7 @@ const TOOL_CATEGORIES = {
     filesystem: ['read_file', 'read_multiple_files', 'write_file', 'create_directory', 'list_directory', 'move_file', 'get_file_info'],
     terminal: ['execute_command', 'read_output', 'force_terminate', 'list_sessions'],
     edit: ['edit_block'],
-    search: ['search_files', 'search_code'],
+    search: ['start_search', 'get_more_search_results', 'stop_search', 'list_searches'],
     config: ['get_config', 'set_config_value'],
     process: ['list_processes', 'kill_process']
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.2.9";
+export declare const VERSION = "0.2.11";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.2.9';
+export const VERSION = '0.2.11';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "MCP server for terminal operations and file editing",
   "license": "MIT",
   "author": "Eduards Ruzga",
@@ -21,12 +21,13 @@
     "testemonials"
   ],
   "scripts": {
+    "postinstall": "node dist/track-installation.js",
     "open-chat": "open -n /Applications/Claude.app",
     "sync-version": "node scripts/sync-version.js",
     "bump": "node scripts/sync-version.js --bump",
     "bump:minor": "node scripts/sync-version.js --bump --minor",
     "bump:major": "node scripts/sync-version.js --bump --major",
-    "build": "tsc && shx cp setup-claude-server.js uninstall-claude-server.js dist/ && shx chmod +x dist/*.js",
+    "build": "tsc && shx cp setup-claude-server.js uninstall-claude-server.js track-installation.js dist/ && shx chmod +x dist/*.js",
     "watch": "tsc --watch",
     "start": "node dist/index.js",
     "start:debug": "node --inspect-brk=9229 dist/index.js",