polydev-ai 1.9.36 → 1.9.38

package/lib/tunnelClient.js

@@ -0,0 +1,231 @@
+/**
+ * TunnelClient — CLI-as-API client for the local MCP process.
+ *
+ * Polls the Polydev server for queued API requests, routes them to
+ * local CLI tools via cliManager, and posts responses back.
+ *
+ * Lifecycle:
+ *   1. start() → begins heartbeat (30s) + polling (3s)
+ *   2. pollForRequests() → GET /api/tunnel/pending
+ *   3. handleRequest() → cliManager.sendCliPrompt() → POST /api/tunnel/respond
+ *   4. stop() → clears intervals
+ */
+
+class TunnelClient {
+  constructor(serverBaseUrl, authToken, cliManager) {
+    this.serverBaseUrl = serverBaseUrl.replace(/\/api\/mcp$/, ''); // strip /api/mcp if present
+    this.authToken = authToken;
+    this.cliManager = cliManager;
+
+    this.heartbeatInterval = null;
+    this.pollInterval = null;
+    this._processing = new Set(); // track in-flight request IDs
+    this._started = false;
+
+    // Configurable intervals
+    this.HEARTBEAT_INTERVAL_MS = 30_000;  // 30s
+    this.POLL_INTERVAL_MS = 3_000;        // 3s
+    this.CLI_TIMEOUT_MS = 120_000;        // 2 min per request
+  }
+
+  /**
+   * Start the tunnel client (heartbeat + polling)
+   */
+  async start() {
+    if (this._started) return;
+    this._started = true;
+
+    console.error('[Tunnel] Starting CLI-as-API tunnel client');
+
+    // Send initial heartbeat immediately
+    try {
+      await this.sendHeartbeat();
+    } catch (err) {
+      console.error('[Tunnel] Initial heartbeat failed:', err.message);
+    }
+
+    // Start periodic heartbeat
+    this.heartbeatInterval = setInterval(() => {
+      this.sendHeartbeat().catch(err => {
+        console.error('[Tunnel] Heartbeat error:', err.message);
+      });
+    }, this.HEARTBEAT_INTERVAL_MS);
+
+    // Start polling for requests
+    this.pollInterval = setInterval(() => {
+      this.pollForRequests().catch(err => {
+        console.error('[Tunnel] Poll error:', err.message);
+      });
+    }, this.POLL_INTERVAL_MS);
+
+    console.error('[Tunnel] Tunnel client started (heartbeat: 30s, poll: 3s)');
+  }
+
+  /**
+   * Stop the tunnel client
+   */
+  stop() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    if (this.pollInterval) {
+      clearInterval(this.pollInterval);
+      this.pollInterval = null;
+    }
+    this._started = false;
+    console.error('[Tunnel] Tunnel client stopped');
+  }
+
+  /**
+   * Send heartbeat with available CLI providers
+   */
+  async sendHeartbeat() {
+    const status = await this.cliManager.getCliStatus();
+    const providers = Object.entries(status)
+      .filter(([_, s]) => s.available && s.authenticated)
+      .map(([id]) => id);
+
+    const packageVersion = this._getPackageVersion();
+
+    const url = `${this.serverBaseUrl}/api/tunnel/heartbeat`;
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.authToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        available_providers: providers,
+        client_version: packageVersion,
+      }),
+    });
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      throw new Error(`Heartbeat failed (${res.status}): ${text}`);
+    }
+  }
+
+  /**
+   * Poll for pending tunnel requests
+   */
+  async pollForRequests() {
+    const url = `${this.serverBaseUrl}/api/tunnel/pending`;
+    const res = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${this.authToken}`,
+      },
+    });
+
+    if (!res.ok) {
+      // 401 is expected if token expired — don't spam logs
+      if (res.status === 401) return;
+      const text = await res.text().catch(() => '');
+      throw new Error(`Poll failed (${res.status}): ${text}`);
+    }
+
+    const data = await res.json();
+    const requests = data.requests || [];
+
+    for (const req of requests) {
+      // Skip if already processing
+      if (this._processing.has(req.id)) continue;
+      this._processing.add(req.id);
+
+      // Handle concurrently (don't await)
+      this.handleRequest(req).catch(err => {
+        console.error(`[Tunnel] Request ${req.id} error:`, err.message);
+      }).finally(() => {
+        this._processing.delete(req.id);
+      });
+    }
+  }
+
+  /**
+   * Handle a single tunnel request by routing to CLI
+   */
+  async handleRequest(request) {
+    const startTime = Date.now();
+    console.error(`[Tunnel] Processing request ${request.id} → ${request.provider}`);
+
+    try {
+      const result = await this.cliManager.sendCliPrompt(
+        request.provider,
+        request.prompt,
+        'args',
+        this.CLI_TIMEOUT_MS,
+        request.model_requested || null
+      );
+
+      const latencyMs = Date.now() - startTime;
+
+      if (result.success) {
+        console.error(`[Tunnel] Request ${request.id} completed (${latencyMs}ms)`);
+        await this.sendResponse({
+          request_id: request.id,
+          content: result.content || '',
+          model_used: result.model || result.detectedModel || request.provider,
+          tokens_used: result.tokens_used || null,
+          latency_ms: latencyMs,
+        });
+      } else {
+        console.error(`[Tunnel] Request ${request.id} CLI error: ${result.error}`);
+        await this.sendResponse({
+          request_id: request.id,
+          error: result.error || 'CLI execution failed',
+          latency_ms: latencyMs,
+        });
+      }
+    } catch (err) {
+      const latencyMs = Date.now() - startTime;
+      console.error(`[Tunnel] Request ${request.id} exception: ${err.message}`);
+      await this.sendResponse({
+        request_id: request.id,
+        error: err.message || 'Unexpected error',
+        latency_ms: latencyMs,
+      });
+    }
+  }
+
+  /**
+   * Send response back to server
+   */
+  async sendResponse(responseData) {
+    const url = `${this.serverBaseUrl}/api/tunnel/respond`;
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.authToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(responseData),
+    });
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      console.error(`[Tunnel] Failed to submit response for ${responseData.request_id}: ${res.status} ${text}`);
+    }
+  }
+
+  /**
+   * Get package version from package.json
+   */
+  _getPackageVersion() {
+    try {
+      const path = require('path');
+      const fs = require('fs');
+      const pkgPath = path.join(__dirname, '..', 'package.json');
+      if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        return pkg.version || 'unknown';
+      }
+    } catch {
+      // ignore
+    }
+    return 'unknown';
+  }
+}
+
+module.exports = { TunnelClient };

package/mcp/stdio-wrapper.js

@@ -49,6 +49,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { CLIManager } = require('../lib/cliManager');
+const { TunnelClient } = require('../lib/tunnelClient');
 
 // MCP stdio servers must only emit JSON-RPC on stdout.
 // Redirect any accidental console output to stderr to avoid handshake failures.
@@ -188,8 +189,7 @@ function cleanCliResponse(content) {
     // State: metadata - skip until we hit a section marker
     if (state === 'metadata') {
       // Skip known metadata patterns
-      if (!trimmed) continue;
-      if (trimmed.startsWith('provider:')) continue;
+      if (!trimmed || trimmed.startsWith('provider:')) continue;
       if (trimmed.startsWith('approval:')) continue;
       if (trimmed.startsWith('sandbox:')) continue;
       if (trimmed.startsWith('reasoning effort:')) continue;
@@ -355,6 +355,9 @@ class StdioMCPWrapper {
     
     // Login server reference (for cleanup)
     this._loginServer = null;
+    
+    // CLI-as-API tunnel client (started after CLI detection)
+    this.tunnelClient = null;
   }
 
   loadManifest() {
@@ -2950,6 +2953,27 @@ To re-login: /polydev:login`
     }
   }
 
+  /**
+   * Start CLI-as-API tunnel client if authenticated.
+   * Runs in background — polls for external API requests and routes them to local CLIs.
+   */
+  startTunnelClient() {
+    if (!this.userToken) {
+      return; // No auth, skip tunnel
+    }
+
+    try {
+      this.tunnelClient = new TunnelClient(
+        this.serverUrl, // https://www.polydev.ai/api/mcp
+        this.userToken,
+        this.cliManager
+      );
+      this.tunnelClient.start();
+    } catch (err) {
+      console.error('[Tunnel] Failed to start tunnel client:', err.message);
+    }
+  }
+
   /**
    * Record local usage for analytics
    */
@@ -3223,6 +3247,8 @@ To re-login: /polydev:login`
             this._cliDetectionResolver();
           }
           this.startSmartRefreshScheduler();
+          // Start CLI-as-API tunnel client (background, non-blocking)
+          this.startTunnelClient();
         });
     } else {
       // No token - CLI detection will run after login completes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-ai",
-  "version": "1.9.36",
+  "version": "1.9.38",
   "engines": {
     "node": ">=20.x <=22.x"
   },