@wonderwhy-er/desktop-commander 0.2.17 → 0.2.18-alpha.1

package/README.md

@@ -10,10 +10,7 @@
 [![Discord](https://img.shields.io/badge/Join%20Discord-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/kQ27sNnZr7)
 
 
-Work with code and text, run processes, and automate tasks, going far beyond other AI editors - without API token costs.
-
-
-![Desktop Commander MCP](https://raw.githubusercontent.com/wonderwhy-er/ClaudeComputerCommander/main/docs/vertical_video_mobile.mp4)
+Work with code and text, run processes, and automate tasks, going far beyond other AI editors - while using host client subscriptions instead of API token costs.
 
 <a href="https://glama.ai/mcp/servers/zempur9oh4">
   <img width="380" height="200" src="https://glama.ai/mcp/servers/zempur9oh4/badge" alt="Desktop Commander MCP" />

package/dist/http-server-auto-tunnel.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/http-server-auto-tunnel.js

@@ -0,0 +1,667 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+#;
+Tunnel;
+Options;
+for (Desktop; Commander; #)
+    #;
+The;
+Problem;
+Currently;
+Desktop;
+Commander;
+requires: -;
+Named;
+tunnel(stable, URL) - `https://mcp.desktopcommander.app`
+    - ;
+Requires;
+own;
+domain + Cloudflare;
+account
+    - ;
+Not;
+accessible;
+for (all; users
+    ** Goal; )
+    :  ** Make;
+Desktop;
+Commander;
+work;
+for (users; without; their)
+    own;
+infrastructure.
+;
+-- - ;
+#;
+Solution;
+Options;
+#;
+#;
+#;
+Option;
+1;
+Random;
+Cloudflare;
+Tunnels(Quick, Start)
+    ** Best;
+for (; ; )
+    :  ** Testing, development, personal;
+use
+    ** How;
+it;
+works:  **
+    -Run `cloudflared tunnel --url http://localhost:3000`
+    - Get;
+random;
+URL: `https://random-words-1234.trycloudflare.com`
+    -  ** Changes;
+every;
+restart **
+        ** Pros;
+ **
+    -;
+No;
+domain;
+needed
+    - ;
+No;
+Cloudflare;
+account;
+needed
+    - ;
+Free
+    - ;
+Works;
+immediately
+    ** Cons;
+ **
+    -;
+URL;
+changes;
+on;
+restart
+    - ;
+Must;
+reconfigure;
+clients;
+after;
+restart
+    - ;
+OAuth;
+redirect;
+URIs;
+break ;
+(need);
+new URL;
+each;
+time;
+    ** Implementation;
+ **
+    `` `bash
+# Already supported!
+npm run start:tunnel
+
+# Or manually:
+cloudflared tunnel --url http://localhost:3000 &
+node dist/http-server.js
+` ``
+        ** For;
+OAuth:  **
+    -;
+Not;
+viable(redirect, URIs, must, be, stable)
+    - ;
+Works;
+without;
+auth;
+-- - ;
+#;
+#;
+Option;
+2;
+Desktop;
+Commander;
+Cloud;
+Service(Recommended)
+    ** Best;
+for (; ; )
+    :  ** Production;
+use, end;
+users
+    ** How;
+it;
+works:  **
+    1.;
+Desktop;
+Commander;
+hosts;
+a;
+proxy;
+service;
+2.;
+Users;
+run;
+local;
+server;
+3.;
+Proxy;
+connects;
+local;
+cloud;
+4.;
+Users;
+get;
+stable;
+subdomain: `https://username.dc.run/mcp`
+    ** Pros;
+ **
+    -;
+No;
+domain;
+needed
+    - ;
+Stable;
+URLs(survives, restarts)
+    - ;
+OAuth;
+works(stable, redirect, URIs)
+    - ;
+Easy;
+user;
+experience
+    - ;
+Can;
+manage;
+auth / quotas;
+centrally
+    ** Cons;
+ **
+    -;
+Requires;
+building;
+proxy;
+service
+    - ;
+Hosting;
+costs
+    - ;
+Privacy;
+concerns(traffic, goes, through, proxy)
+    ** Architecture;
+ **
+    `` `
+User's Computer                Desktop Commander Cloud           AI Client
+┌──────────────┐              ┌─────────────────────┐         ┌──────────┐
+│              │              │                     │         │          │
+│ DC Server    │─────────────▶│  Proxy Service      │◀────────│ Claude/  │
+│ (local:3000) │  WebSocket   │  username.dc.run    │  HTTPS  │ ChatGPT  │
+│              │              │                     │         │          │
+└──────────────┘              └─────────────────────┘         └──────────┘
+` ``
+        ** Implementation;
+Plan:  **
+    -Build;
+proxy;
+service(Node.js + WebSocket)
+    - Deploy;
+to;
+cloud(Vercel / Railway / Fly.io)
+    - Users;
+register;
+for (subdomain
+    - Local; client; connects)
+    to;
+proxy;
+-- - ;
+#;
+#;
+Option;
+3;
+ngrok;
+Integration
+    ** Best;
+for (; ; )
+    :  ** Users;
+already;
+/**
+ * Start Desktop Commander with auto-detected tunnel
+ *
+ * Usage:
+ *   node http-server-auto-tunnel.js
+ *
+ * This script:
+ * 1. Checks for TUNNEL_URL env var (named tunnel)
+ * 2. If not set, starts random Cloudflare tunnel
+ * 3. Extracts tunnel URL from cloudflared output
+ * 4. Starts HTTP server with detected URL
+ */
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+function startRandomTunnel() {
+    console.log('🌐 Starting random Cloudflare Tunnel...');
+    console.log('⏳ Waiting for tunnel URL...\n');
+    const tunnel = spawn('cloudflared', ['tunnel', '--url', 'http://localhost:3000']);
+    let tunnelURL = null;
+    let server = null;
+    tunnel.stdout.on('data', (data) => {
+        const output = data.toString();
+        process.stdout.write(data);
+        // Look for the tunnel URL
+        const urlMatch = output.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/i);
+        if (urlMatch && !tunnelURL) {
+            tunnelURL = urlMatch[0];
+            console.log('\n✅ Random Tunnel URL detected:', tunnelURL);
+            if (process.env.REQUIRE_AUTH === 'true') {
+                console.log('\n⚠️  WARNING: OAuth with random tunnels is not recommended!');
+                console.log('   The URL will change on restart, breaking OAuth redirects.');
+                console.log('   Consider using REQUIRE_AUTH=false or setting up a named tunnel.\n');
+            }
+            console.log('📝 To use this URL:');
+            console.log(`   Add to Claude/ChatGPT: ${tunnelURL}/mcp`);
+            console.log(`   This URL expires when the tunnel stops!\n`);
+            server = startServer(tunnelURL);
+        }
+    });
+    tunnel.stderr.on('data', (data) => {
+        const output = data.toString();
+        process.stderr.write(data);
+        // Also check stderr
+        const urlMatch = output.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/i);
+        if (urlMatch && !tunnelURL) {
+            tunnelURL = urlMatch[0];
+            console.log('\n✅ Random Tunnel URL detected:', tunnelURL);
+            server = startServer(tunnelURL);
+        }
+    });
+    tunnel.on('error', (err) => {
+        console.error('❌ Tunnel failed to start:', err);
+        console.error('\nMake sure cloudflared is installed:');
+        console.error('  brew install cloudflare/cloudflare/cloudflared');
+        process.exit(1);
+    });
+    tunnel.on('close', (code) => {
+        console.log('\n🛑 Tunnel closed with code:', code);
+        if (server)
+            server.kill();
+        process.exit(code);
+    });
+    // Cleanup
+    process.on('SIGINT', () => {
+        console.log('\n🛑 Shutting down...');
+        tunnel.kill();
+        if (server)
+            server.kill();
+        process.exit(0);
+    });
+}
+function startServer(baseUrl) {
+    console.log('\n📡 Starting Desktop Commander HTTP server...');
+    const env = {
+        ...process.env,
+        BASE_URL: baseUrl,
+        PORT: '3000'
+    };
+    const server = spawn('node', ['dist/http-server.js'], {
+        cwd: __dirname,
+        env,
+        stdio: 'inherit'
+    });
+    server.on('error', (err) => {
+        console.error('❌ Server failed to start:', err);
+        process.exit(1);
+    });
+    server.on('close', (code) => {
+        console.log('🔴 Server closed with code:', code);
+        process.exit(code);
+    });
+    return server;
+}
+var ngrok, __filename, __dirname;
+const env_1 = { stack: [], error: void 0, hasError: false };
+try {
+    ngrok = __addDisposableResource(env_1, void 0, false);
+        ** How;
+    it;
+    works:  **
+        -Use;
+    ngrok;
+    instead;
+    of;
+    Cloudflare;
+    tunnels
+        - Get;
+    stable;
+    URLs;
+    with (ngrok)
+        paid;
+    plan
+        - Free;
+    tier;
+    has;
+    random;
+    URLs;
+    like;
+    Cloudflare
+        ** Pros;
+     **
+        -;
+    Well - known;
+    tool
+        - ;
+    Good;
+    documentation
+        - ;
+    Paid;
+    plan = stable;
+    URLs
+        ** Cons;
+     **
+        -;
+    Free;
+    tier = random;
+    URLs(same, problem)
+        - ;
+    Paid;
+    plan = $8 - 10 / month;
+    per;
+    user
+        - ;
+    Not
+        ** Implementation;
+     **
+        `` `typescript
+// Add to package.json
+"scripts": {
+  "start:ngrok": "node dist/http-server-ngrok.js"
+}
+` `` `` `typescript
+// src/http-server-ngrok.ts
+import ngrok from 'ngrok';
+
+async function startWithNgrok() {
+  const url = await ngrok.connect({
+    addr: 3000,
+    authtoken: process.env.NGROK_AUTH_TOKEN
+  });
+  
+  console.log(`;
+    ngrok;
+    tunnel: $;
+    {
+        url;
+    }
+    `);
+  process.env.BASE_URL = url;
+  
+  // Start server...
+}
+` ``;
+    -- - ;
+    #;
+    #;
+    Option;
+    4;
+    Hybrid;
+    Approach(Best, Balance)
+        ** Best;
+    for (; ; )
+        :  ** Supporting;
+    all;
+    user;
+    types
+        ** How;
+    it;
+    works:  **
+        -Offer;
+    multiple;
+    tunnel;
+    options
+        - Users;
+    choose;
+    based;
+    on;
+    their;
+    needs `` `bash
+# Option A: Random tunnel (no setup)
+npm run start:tunnel
+
+# Option B: Named tunnel (own domain)
+TUNNEL_URL=https://mcp.yourname.com npm run start:named-tunnel
+
+# Option C: Cloud service (future)
+npm run start:cloud -- --username yourname
+
+# Option D: Local only (no tunnel)
+npm run start:local
+` ``
+        ** Configuration;
+     **
+        `` `typescript
+// Auto-detect best option
+export async function startServer(options) {
+  if (options.cloudUsername) {
+    // Use DC cloud proxy
+    return startWithCloudProxy(options.cloudUsername);
+  } else if (options.namedTunnel) {
+    // Use named Cloudflare tunnel
+    return startWithNamedTunnel(options.namedTunnel);
+  } else if (options.ngrokToken) {
+    // Use ngrok
+    return startWithNgrok(options.ngrokToken);
+  } else {
+    // Random Cloudflare tunnel
+    return startWithRandomTunnel();
+  }
+}
+` ``;
+    -- - ;
+    #;
+    #;
+    Option;
+    5;
+    Local;
+    Network;
+    Only(No, Tunnel)
+        ** Best;
+    for (; ; )
+        :  ** Privacy - conscious;
+    users, local;
+    testing
+        ** How;
+    it;
+    works:  **
+        -Server;
+    runs;
+    on;
+    local;
+    network;
+    only
+        - Access;
+    via `http://192.168.x.x:3000`
+        - No;
+    internet;
+    exposure
+        ** Pros;
+     **
+        -;
+    Maximum;
+    privacy
+        - ;
+    No;
+    external;
+    dependencies
+        - ;
+    Free
+        ** Cons;
+     **
+        -;
+    Only;
+    works;
+    on;
+    same;
+    network
+        - ;
+    Can;
+    't use with cloud AI services
+        - ;
+    Must;
+    use;
+    Claude;
+    Desktop(not, claude.ai)
+        ** Implementation;
+     **
+        `` `bash
+# Already works!
+npm run start
+
+# Claude Desktop config:
+{
+  "mcpServers": {
+    "desktop-commander": {
+      "command": "node",
+      "args": ["/path/to/dist/index.js"]
+    }
+  }
+}
+` ``;
+    -- - ;
+    #;
+    Recommended;
+    Architecture;
+    #;
+    #;
+    #;
+    Phase;
+    1;
+    Current(Multiple, Options);
+    Offer;
+    all;
+    tunnel;
+    methods, let;
+    users;
+    choose: `` `markdown
+# Installation Methods
+
+## Quick Start (No Setup)
+npm run start:tunnel
+→ Random URL, changes on restart
+
+## Production (Own Domain)  
+TUNNEL_URL=https://mcp.yourname.com npm run start:named-tunnel
+→ Stable URL, requires Cloudflare
+
+## Local Only (Claude Desktop)
+npm run start
+→ No tunnel, configure in Claude Desktop
+` ``;
+    #;
+    #;
+    #;
+    Phase;
+    2;
+    Cloud;
+    Service(Future);
+    Build;
+    Desktop;
+    Commander;
+    Cloud: `` `bash
+# User experience
+npm install -g desktop-commander
+dc login
+dc start
+
+# Behind the scenes:
+# - Authenticates with DC Cloud
+# - Gets stable subdomain: https://yourname.dc.run
+# - Starts local server
+# - Connects to cloud proxy
+# - OAuth redirect: https://yourname.dc.run/oauth/callback
+` ``;
+    -- - ;
+    #;
+    Quick;
+    Implementation: Support;
+    Random;
+    Tunnels;
+    Let;
+    's make random tunnels work better:
+        < function_calls >
+        name;
+    "desktop-commander-host:write_file" >
+        name;
+    "content" > ;
+    !/usr/bin / env;
+    node;
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = dirname(__filename);
+    console.log('🚀 Starting Desktop Commander with Auto Tunnel Detection\n');
+    // Check if named tunnel is configured
+    if (process.env.TUNNEL_URL) {
+        console.log('✅ Using named tunnel from TUNNEL_URL');
+        console.log(`   URL: ${process.env.TUNNEL_URL}\n`);
+        startServer(process.env.TUNNEL_URL);
+    }
+    else {
+        console.log('⚠️  No TUNNEL_URL configured, using random Cloudflare tunnel');
+        console.log('   Note: URL will change on restart!\n');
+        startRandomTunnel();
+    }
+}
+catch (e_1) {
+    env_1.error = e_1;
+    env_1.hasError = true;
+}
+finally {
+    __disposeResources(env_1);
+}

package/dist/http-server-named-tunnel.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};