promethios-bridge 1.3.0 → 1.5.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "promethios-bridge",
-  "version": "1.3.0",
-  "description": "Run Promethios agent frameworks locally on your computer with full file, terminal, and browser access.",
+  "version": "1.5.0",
+  "description": "Run Promethios agent frameworks locally on your computer with full file, terminal, browser access, and Native Framework Mode (run OpenClaw and other frameworks in their native interface via the bridge).",
   "main": "src/index.js",
   "bin": {
     "promethios-bridge": "src/cli.js"
@@ -16,7 +16,10 @@
     "agent",
     "local",
     "bridge",
-    "framework"
+    "framework",
+    "openclaw",
+    "native",
+    "clawhub"
   ],
   "author": "Promethios <hello@promethios.ai>",
   "license": "MIT",
@@ -43,7 +46,11 @@
     "express": "^4.18.2",
     "open": "^8.4.2",
     "ora": "^5.4.1",
-    "node-fetch": "^2.7.0"
+    "node-fetch": "^2.7.0",
+    "playwright": "^1.42.0"
+  },
+  "optionalDependencies": {
+    "playwright": "^1.42.0"
   },
   "engines": {
     "node": ">=18.0.0"

package/src/bridge.js

@@ -75,6 +75,72 @@ async function startBridge({ setupToken, apiBase, port, dev }) {
     res.json({ capabilities: getSupportedCapabilities() });
   });
 
+  // ── Native mode: probe a local port ──────────────────────────────────────
+  // Called by the Promethios backend's /native/detect route.
+  // Returns { detected, running, port, httpOk, serviceInfo }
+  app.get('/native/probe', async (req, res) => {
+    const probePort = parseInt(req.query.port, 10) || 18789;
+    const framework = req.query.framework || 'unknown';
+    log('Native probe request for port', probePort, 'framework', framework);
+    try {
+      const result = await executeLocalTool({
+        toolName: 'probe_local_port',
+        args: { port: probePort, framework, timeout_ms: 3000 },
+        dev,
+      });
+      res.json(result);
+    } catch (err) {
+      res.status(500).json({ detected: false, error: err.message });
+    }
+  });
+
+  // ── Native mode: proxy HTTP requests to a local port ─────────────────────
+  // Called by the Promethios backend's /native/proxy/:port/* route.
+  // Forwards any HTTP method to localhost:<port><path> and returns the response.
+  app.all('/proxy/:port/*', async (req, res) => {
+    const proxyPort = parseInt(req.params.port, 10);
+    const ALLOWED_PORTS = [18789, 18790, 7788, 8080, 3000, 3001, 4000, 5000];
+    if (!ALLOWED_PORTS.includes(proxyPort)) {
+      return res.status(403).json({ error: `Port ${proxyPort} not allowed` });
+    }
+    // Reconstruct the path including query string
+    const proxyPath = '/' + (req.params[0] || '') + (Object.keys(req.query).length ? '?' + new URLSearchParams(req.query).toString() : '');
+    log('Proxy request:', req.method, proxyPort, proxyPath);
+    try {
+      const result = await executeLocalTool({
+        toolName: 'proxy_local_request',
+        args: {
+          port: proxyPort,
+          path: proxyPath,
+          method: req.method,
+          headers: req.headers,
+          body: req.body,
+        },
+        dev,
+      });
+      // Forward status and body back to caller
+      res.status(result.status || 200);
+      res.set('Access-Control-Allow-Origin', '*');
+      res.set('Access-Control-Allow-Methods', 'GET,POST,PUT,DELETE,PATCH,OPTIONS');
+      res.set('Access-Control-Allow-Headers', 'Content-Type,Authorization');
+      if (typeof result.data === 'string') {
+        res.send(result.data);
+      } else {
+        res.json(result.data);
+      }
+    } catch (err) {
+      res.status(502).json({ error: err.message });
+    }
+  });
+
+  // CORS preflight for proxy
+  app.options('/proxy/:port/*', (req, res) => {
+    res.set('Access-Control-Allow-Origin', '*');
+    res.set('Access-Control-Allow-Methods', 'GET,POST,PUT,DELETE,PATCH,OPTIONS');
+    res.set('Access-Control-Allow-Headers', 'Content-Type,Authorization');
+    res.sendStatus(204);
+  });
+
   await new Promise((resolve, reject) => {
     const server = app.listen(port, '127.0.0.1', () => resolve(server));
     server.on('error', reject);
@@ -290,6 +356,8 @@ function getSupportedCapabilities() {
     'terminal.readonly',
     'browser.open',
     'network.http',
+    'native.probe_port',
+    'native.proxy',
   ];
 }
 

package/src/executor.js

@@ -36,6 +36,15 @@ async function executeLocalTool({ toolName, args, frameworkId, dev }) {
   if (toolName === 'local_file_write') {
     return executeLocalTool({ toolName: 'write_file', args: { path: args.path, content: args.content, encoding: args.encoding }, frameworkId, dev });
   }
+  if (toolName === 'local_file_read_binary') {
+    return executeLocalTool({ toolName: 'read_file_binary', args: { path: args.path, maxSizeBytes: args.maxSizeBytes }, frameworkId, dev });
+  }
+  if (toolName === 'local_file_upload_to_thread') {
+    return executeLocalTool({ toolName: 'upload_file_to_thread', args: { path: args.path, displayName: args.displayName }, frameworkId, dev });
+  }
+  if (toolName === 'local_browser_control') {
+    return executeLocalTool({ toolName: 'browser_control', args, frameworkId, dev });
+  }
 
   // ── local_execute is the built-in tool injected by the backend when the bridge
   //    is connected. It uses an `action` field to dispatch to the right handler.
@@ -71,8 +80,17 @@ async function executeLocalTool({ toolName, args, frameworkId, dev }) {
       const filePath = resolveSafePath(args.path);
       log('write_file', filePath);
       const mode = args.append ? 'a' : 'w';
-      await fs.writeFile(filePath, args.content || '', { flag: mode, encoding: 'utf8' });
-      return { success: true, path: filePath, bytesWritten: (args.content || '').length };
+      // Detect base64-encoded binary content (e.g. images transferred from phone)
+      const content = args.content || '';
+      const isBase64 = args.encoding === 'base64' || /^[A-Za-z0-9+/]+=*$/.test(content.replace(/\s/g, '')) && content.length > 100 && !content.includes(' ');
+      if (isBase64 && args.encoding === 'base64') {
+        const buffer = Buffer.from(content, 'base64');
+        await fs.writeFile(filePath, buffer, { flag: mode });
+        return { success: true, path: filePath, bytesWritten: buffer.length };
+      } else {
+        await fs.writeFile(filePath, content, { flag: mode, encoding: 'utf8' });
+        return { success: true, path: filePath, bytesWritten: Buffer.byteLength(content, 'utf8') };
+      }
     }
 
     case 'list_directory': {
@@ -100,6 +118,193 @@ async function executeLocalTool({ toolName, args, frameworkId, dev }) {
       };
     }
 
+    // ── Browser Control (Playwright) ──────────────────────────────────────
+    case 'browser_control': {
+      // Lazy-load playwright — auto-install if missing so users never need
+      // to run terminal commands manually. This runs once on first use.
+      let playwright;
+      try {
+        playwright = require('playwright');
+      } catch (e) {
+        // Playwright not installed — install it automatically
+        const chalk = require('chalk');
+        console.log(chalk.yellow('\n  Playwright not found — installing automatically (one-time setup, ~2 min)...\n'));
+        try {
+          execSync('npm install -g playwright', { stdio: 'inherit' });
+          execSync('npx playwright install chromium', { stdio: 'inherit' });
+          playwright = require('playwright');
+          console.log(chalk.green('\n  Playwright installed. Browser automation is ready.\n'));
+        } catch (installErr) {
+          throw new Error(
+            'Auto-install of Playwright failed: ' + installErr.message +
+            '\nPlease run manually: npm install -g playwright && npx playwright install chromium'
+          );
+        }
+      }
+
+      const action = args.action;
+      if (!action) throw new Error('action is required for browser_control');
+      log('browser_control', action, args.url || args.selector || '');
+
+      // We maintain a single persistent browser context per process so sessions
+      // (cookies / localStorage) survive across multiple tool calls.
+      if (!global.__playwrightBrowser) {
+        // Try to connect to an existing Chrome instance first (user's real profile)
+        // Falls back to a fresh Chromium instance if not available.
+        try {
+          // Launch Chromium with the user's real Chrome profile directory
+          const os = require('os');
+          const platform = process.platform;
+          let userDataDir;
+          if (platform === 'win32') {
+            userDataDir = path.join(process.env.LOCALAPPDATA || os.homedir(), 'Google', 'Chrome', 'User Data');
+          } else if (platform === 'darwin') {
+            userDataDir = path.join(os.homedir(), 'Library', 'Application Support', 'Google', 'Chrome');
+          } else {
+            userDataDir = path.join(os.homedir(), '.config', 'google-chrome');
+          }
+
+          // Use persistent context with real Chrome profile if it exists
+          const fsSync = require('fs');
+          if (fsSync.existsSync(userDataDir)) {
+            global.__playwrightContext = await playwright.chromium.launchPersistentContext(userDataDir, {
+              headless: false,
+              channel: 'chrome',
+              args: ['--no-first-run', '--disable-blink-features=AutomationControlled'],
+            });
+          } else {
+            // Fallback: fresh Chromium (no saved logins)
+            global.__playwrightBrowser = await playwright.chromium.launch({ headless: false });
+            global.__playwrightContext = await global.__playwrightBrowser.newContext();
+          }
+        } catch (e) {
+          // Final fallback: headless Chromium
+          global.__playwrightBrowser = await playwright.chromium.launch({ headless: true });
+          global.__playwrightContext = await global.__playwrightBrowser.newContext();
+        }
+      }
+
+      const context = global.__playwrightContext;
+
+      // Get or create a page
+      const getPage = async () => {
+        const pages = context.pages();
+        return pages.length > 0 ? pages[pages.length - 1] : await context.newPage();
+      };
+
+      switch (action) {
+        case 'navigate': {
+          const page = await getPage();
+          await page.goto(args.url, { waitUntil: 'domcontentloaded', timeout: 30000 });
+          const title = await page.title();
+          const url = page.url();
+          return { success: true, title, url };
+        }
+
+        case 'click': {
+          const page = await getPage();
+          if (args.selector) {
+            await page.click(args.selector, { timeout: 10000 });
+          } else if (args.text) {
+            await page.getByText(args.text).first().click({ timeout: 10000 });
+          } else {
+            throw new Error('click requires selector or text');
+          }
+          return { success: true };
+        }
+
+        case 'type': {
+          const page = await getPage();
+          await page.fill(args.selector, args.text || '', { timeout: 10000 });
+          return { success: true };
+        }
+
+        case 'press_key': {
+          const page = await getPage();
+          await page.keyboard.press(args.key || 'Enter');
+          return { success: true };
+        }
+
+        case 'read_page': {
+          const page = await getPage();
+          // Return page text content and current URL
+          const textContent = await page.evaluate(() => document.body.innerText);
+          const url = page.url();
+          const title = await page.title();
+          // Truncate to avoid overwhelming the agent
+          const maxChars = args.maxChars || 8000;
+          return {
+            url,
+            title,
+            text: textContent.slice(0, maxChars),
+            truncated: textContent.length > maxChars,
+            totalChars: textContent.length,
+          };
+        }
+
+        case 'screenshot': {
+          const page = await getPage();
+          const screenshotBuffer = await page.screenshot({ fullPage: !!args.fullPage });
+          const base64 = screenshotBuffer.toString('base64');
+          return {
+            base64,
+            mimeType: 'image/png',
+            url: page.url(),
+            title: await page.title(),
+          };
+        }
+
+        case 'get_html': {
+          const page = await getPage();
+          const html = await page.content();
+          const maxChars = args.maxChars || 20000;
+          return {
+            html: html.slice(0, maxChars),
+            truncated: html.length > maxChars,
+            url: page.url(),
+          };
+        }
+
+        case 'wait_for': {
+          const page = await getPage();
+          if (args.selector) {
+            await page.waitForSelector(args.selector, { timeout: args.timeout || 15000 });
+          } else if (args.text) {
+            await page.waitForFunction(
+              (t) => document.body.innerText.includes(t),
+              args.text,
+              { timeout: args.timeout || 15000 }
+            );
+          } else {
+            await page.waitForLoadState('networkidle', { timeout: args.timeout || 15000 });
+          }
+          return { success: true };
+        }
+
+        case 'new_tab': {
+          const page = await context.newPage();
+          if (args.url) await page.goto(args.url, { waitUntil: 'domcontentloaded', timeout: 30000 });
+          return { success: true, url: page.url() };
+        }
+
+        case 'close': {
+          // Close the browser context and clean up
+          if (global.__playwrightContext) {
+            await global.__playwrightContext.close();
+            delete global.__playwrightContext;
+          }
+          if (global.__playwrightBrowser) {
+            await global.__playwrightBrowser.close();
+            delete global.__playwrightBrowser;
+          }
+          return { success: true };
+        }
+
+        default:
+          throw new Error(`Unknown browser_control action: ${action}. Valid actions: navigate, click, type, press_key, read_page, screenshot, get_html, wait_for, new_tab, close`);
+      }
+    }
+
     // ── Terminal ──────────────────────────────────────────────────────────
     case 'run_command': {
       const cmd = args.command;
@@ -118,7 +323,94 @@ async function executeLocalTool({ toolName, args, frameworkId, dev }) {
       return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode: 0 };
     }
 
-    // ── Browser ───────────────────────────────────────────────────────────
+    // ── Binary file read ────────────────────────────────────────────────────────────────────
+    case 'read_file_binary': {
+      const filePath = resolveSafePath(args.path);
+      log('read_file_binary', filePath);
+      const maxSize = args.maxSizeBytes || 10 * 1024 * 1024; // 10MB default
+      const stat = await fs.stat(filePath);
+      if (stat.size > maxSize) {
+        throw new Error(`File too large: ${stat.size} bytes exceeds limit of ${maxSize} bytes`);
+      }
+      const buffer = await fs.readFile(filePath);
+      const base64 = buffer.toString('base64');
+      // Detect MIME type from extension
+      const ext = path.extname(filePath).toLowerCase();
+      const mimeTypes = {
+        '.pdf': 'application/pdf',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp',
+        '.bmp': 'image/bmp',
+        '.tiff': 'image/tiff',
+        '.tif': 'image/tiff',
+        '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+        '.doc': 'application/msword',
+        '.xls': 'application/vnd.ms-excel',
+        '.ppt': 'application/vnd.ms-powerpoint',
+        '.zip': 'application/zip',
+        '.mp4': 'video/mp4',
+        '.mp3': 'audio/mpeg',
+      };
+      const mimeType = mimeTypes[ext] || 'application/octet-stream';
+      return {
+        base64,
+        mimeType,
+        sizeBytes: stat.size,
+        fileName: path.basename(filePath),
+        path: filePath
+      };
+    }
+
+    // ── Upload file to thread (read locally, return base64 for cloud upload) ────────────────────
+    case 'upload_file_to_thread': {
+      const filePath = resolveSafePath(args.path);
+      log('upload_file_to_thread', filePath);
+      const maxSize = 50 * 1024 * 1024; // 50MB limit for uploads
+      const stat = await fs.stat(filePath);
+      if (stat.size > maxSize) {
+        throw new Error(`File too large: ${stat.size} bytes exceeds upload limit of 50MB`);
+      }
+      const buffer = await fs.readFile(filePath);
+      const base64 = buffer.toString('base64');
+      const ext = path.extname(filePath).toLowerCase();
+      const mimeTypes = {
+        '.pdf': 'application/pdf',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp',
+        '.md': 'text/markdown',
+        '.txt': 'text/plain',
+        '.csv': 'text/csv',
+        '.json': 'application/json',
+        '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+        '.zip': 'application/zip',
+        '.mp4': 'video/mp4',
+        '.mp3': 'audio/mpeg',
+      };
+      const mimeType = mimeTypes[ext] || 'application/octet-stream';
+      const fileName = args.displayName || path.basename(filePath);
+      // Return the base64 payload — the cloud API will handle the actual upload to Firebase Storage
+      // and return the download URL back to the agent
+      return {
+        __upload_payload: true,
+        base64,
+        mimeType,
+        sizeBytes: stat.size,
+        fileName,
+        originalPath: filePath
+      };
+    }
+
+    // ── Browser ────────────────────────────────────────────────────────────────────
     case 'open_browser': {
       const url = args.url;
       if (!url || !/^https?:\/\//.test(url)) throw new Error('Valid http/https URL required');
@@ -157,6 +449,110 @@ async function executeLocalTool({ toolName, args, frameworkId, dev }) {
       };
     }
 
+    // ── Native Framework Detection ──────────────────────────────────────────
+    // probe_local_port: check if a framework's gateway is running on a local port.
+    // Called by the backend's /native/detect route to power the Native mode button.
+    case 'probe_local_port': {
+      const probePort = args.port || 18789;
+      const probeTimeout = Math.min(args.timeout_ms || 3000, 10000);
+      log('probe_local_port', probePort, 'timeout:', probeTimeout);
+
+      // TCP connect probe — fastest way to check if anything is listening
+      const net = require('net');
+      const isOpen = await new Promise((resolve) => {
+        const socket = new net.Socket();
+        let resolved = false;
+        const done = (result) => {
+          if (!resolved) {
+            resolved = true;
+            socket.destroy();
+            resolve(result);
+          }
+        };
+        socket.setTimeout(probeTimeout);
+        socket.on('connect', () => done(true));
+        socket.on('timeout', () => done(false));
+        socket.on('error', () => done(false));
+        socket.connect(probePort, '127.0.0.1');
+      });
+
+      if (!isOpen) {
+        return { running: false, detected: false, port: probePort, reason: 'port_closed' };
+      }
+
+      // Port is open — try HTTP health check to confirm it's the right service
+      let httpOk = false;
+      let serviceInfo = null;
+      const probePaths = ['/health', '/api/status', '/'];
+      for (const probePath of probePaths) {
+        try {
+          const controller = new AbortController();
+          const timer = setTimeout(() => controller.abort(), 2000);
+          const probeRes = await fetch(`http://127.0.0.1:${probePort}${probePath}`, {
+            signal: controller.signal,
+          }).catch(() => null);
+          clearTimeout(timer);
+          if (probeRes && probeRes.ok) {
+            httpOk = true;
+            try {
+              const text = await probeRes.text();
+              try { serviceInfo = JSON.parse(text); } catch { serviceInfo = { raw: text.slice(0, 200) }; }
+            } catch { /* ignore */ }
+            break;
+          }
+        } catch { /* try next path */ }
+      }
+
+      return {
+        running: true,
+        detected: true,
+        port: probePort,
+        httpOk,
+        serviceInfo,
+        framework: args.framework || 'unknown',
+      };
+    }
+
+    // ── Proxy request to local port ───────────────────────────────────────────
+    // proxy_local_request: forward an HTTP request to a local port and return
+    // the response. Used by the backend /native/proxy route to tunnel requests
+    // through the bridge to a locally-running framework gateway.
+    case 'proxy_local_request': {
+      const { port: proxyPort, path: proxyPath = '/', method = 'GET', headers = {}, body: proxyBody } = args;
+      const ALLOWED_PORTS = [18789, 18790, 7788, 8080, 3000, 3001, 4000, 5000];
+      if (!ALLOWED_PORTS.includes(Number(proxyPort))) {
+        throw new Error(`Port ${proxyPort} is not in the allowed list for proxy: ${ALLOWED_PORTS.join(', ')}`);
+      }
+      log('proxy_local_request', method, proxyPort, proxyPath);
+
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 15000);
+      try {
+        const fetchOptions = {
+          method,
+          headers: { 'Content-Type': 'application/json', ...headers },
+          signal: controller.signal,
+        };
+        if (proxyBody && method !== 'GET' && method !== 'HEAD') {
+          fetchOptions.body = typeof proxyBody === 'string' ? proxyBody : JSON.stringify(proxyBody);
+        }
+        const proxyRes = await fetch(`http://127.0.0.1:${proxyPort}${proxyPath}`, fetchOptions);
+        clearTimeout(timer);
+        const responseText = await proxyRes.text();
+        let responseData;
+        try { responseData = JSON.parse(responseText); } catch { responseData = responseText; }
+        return {
+          status: proxyRes.status,
+          ok: proxyRes.ok,
+          data: responseData,
+          headers: Object.fromEntries(proxyRes.headers.entries()),
+        };
+      } catch (err) {
+        clearTimeout(timer);
+        throw new Error(`Proxy request to port ${proxyPort} failed: ${err.message}`);
+      }
+    }
+
     // ── Custom tool (developer-written code from framework definition) ────
     case 'custom':
     default: {
@@ -203,9 +599,72 @@ async function executeLocalTool({ toolName, args, frameworkId, dev }) {
 // Resolve a path safely — expand ~ and normalize
 // Does NOT restrict to a specific directory (user approved full access)
 // ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * On Windows, the user's Desktop may live under OneDrive sync rather than the
+ * local profile directory. This function detects the real Desktop path by
+ * querying the Windows Shell folder registry key, falling back to the
+ * OneDrive\Desktop path, then the local profile Desktop.
+ *
+ * On macOS/Linux the standard ~/Desktop is used.
+ */
+function resolveDesktopPath() {
+  if (process.platform !== 'win32') {
+    return path.join(require('os').homedir(), 'Desktop');
+  }
+  // Try registry first (most reliable — works even with custom Desktop locations)
+  try {
+    const { execSync } = require('child_process');
+    const regOut = execSync(
+      'reg query "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders" /v Desktop',
+      { encoding: 'utf8', timeout: 3000 }
+    );
+    const match = regOut.match(/Desktop\s+REG_(?:SZ|EXPAND_SZ)\s+(.+)/i);
+    if (match) {
+      // Expand environment variables like %USERPROFILE%
+      let desktopPath = match[1].trim();
+      desktopPath = desktopPath.replace(/%([^%]+)%/g, (_, varName) => process.env[varName] || `%${varName}%`);
+      if (require('fs').existsSync(desktopPath)) return desktopPath;
+    }
+  } catch { /* registry query failed, fall through */ }
+
+  // Fallback: check OneDrive Desktop first (most common on Windows 11)
+  const userProfile = process.env.USERPROFILE || require('os').homedir();
+  const oneDriveDesktop = path.join(userProfile, 'OneDrive', 'Desktop');
+  if (require('fs').existsSync(oneDriveDesktop)) return oneDriveDesktop;
+
+  // Final fallback: local Desktop
+  return path.join(userProfile, 'Desktop');
+}
+
 function resolveSafePath(inputPath) {
   if (!inputPath) throw new Error('Path is required');
-  const expanded = inputPath.replace(/^~/, process.env.HOME || '/home');
+
+  // Expand ~ to home directory
+  let expanded = inputPath.replace(/^~/, require('os').homedir());
+
+  // On Windows, expand %DESKTOP% and ~/Desktop shortcuts to the real Desktop path
+  // This handles the common case where the agent writes to "C:\Users\user\Desktop"
+  // but the actual visible Desktop is under OneDrive.
+  if (process.platform === 'win32') {
+    // Replace %DESKTOP% placeholder
+    expanded = expanded.replace(/%DESKTOP%/gi, resolveDesktopPath());
+
+    // If path contains \Desktop\ or ends with \Desktop, check if OneDrive Desktop exists
+    // and remap the local Desktop path to the OneDrive one.
+    const userProfile = process.env.USERPROFILE || require('os').homedir();
+    const localDesktop = path.join(userProfile, 'Desktop');
+    const realDesktop = resolveDesktopPath();
+    if (realDesktop !== localDesktop) {
+      // Normalize separators for comparison
+      const normalizedExpanded = expanded.replace(/\//g, '\\');
+      const normalizedLocal = localDesktop.replace(/\//g, '\\');
+      if (normalizedExpanded.toLowerCase().startsWith(normalizedLocal.toLowerCase())) {
+        expanded = realDesktop + expanded.slice(localDesktop.length);
+      }
+    }
+  }
+
   return path.resolve(expanded);
 }