open-agents-ai 0.184.17 → 0.184.19

package/dist/index.js

@@ -47976,12 +47976,41 @@ async function handleSlashCommand(input, ctx) {
       if (arg === "pause" && existingConfig?.status === "active") {
         existingConfig.status = "paused";
         saveSponsorConfig2(projectDir, existingConfig);
-        renderInfo("Sponsorship paused. /sponsor to resume.");
+        const pauseGw = ctx.getExposeGateway?.();
+        if (pauseGw && "setSponsorLimits" in pauseGw) {
+          pauseGw.setSponsorLimits({ maxRequestsPerMinute: 0, maxTokensPerDay: 0, maxConcurrent: 0, allowedModels: [] });
+        }
+        renderInfo("Sponsorship paused. Tunnel still alive for quick resume.");
+        renderInfo("/sponsor to resume, /sponsor remove to fully stop.");
         return "handled";
       }
       if (arg === "remove" && existingConfig) {
         existingConfig.status = "inactive";
         saveSponsorConfig2(projectDir, existingConfig);
+        if (ctx.isExposeActive?.()) {
+          try {
+            await ctx.exposeStop?.();
+            renderInfo("Tunnel/P2P gateway stopped.");
+          } catch (err) {
+            renderWarning(`Gateway stop: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+        try {
+          const { execSync: execSync34 } = __require("child_process");
+          const pids = execSync34("pgrep -f 'cloudflared tunnel --url http://127.0.0.1'", { encoding: "utf8", timeout: 3e3 }).trim().split("\n");
+          for (const pid of pids) {
+            const p = parseInt(pid, 10);
+            if (p > 0) {
+              try {
+                process.kill(p, "SIGTERM");
+              } catch {
+              }
+            }
+          }
+          if (pids.length > 0 && pids[0])
+            renderInfo(`Killed ${pids.length} orphaned cloudflared process(es).`);
+        } catch {
+        }
         renderInfo("Sponsorship removed.");
         return "handled";
       }
@@ -48019,45 +48048,56 @@ async function handleSlashCommand(input, ctx) {
         ollamaUrl: "http://localhost:11434",
         availableRows: ctx.availableContentRows?.(),
         onGoLive: async (config) => {
-          if (config.transport.libp2p) {
-            try {
-              const nexus = new NexusTool(projectDir);
-              renderInfo("Connecting to nexus P2P mesh...");
-              await nexus.execute({ action: "connect" });
-              await new Promise((r) => setTimeout(r, 3e3));
-              renderInfo("Nexus daemon connected.");
-            } catch (err) {
-              renderWarning(`Nexus auto-connect: ${err instanceof Error ? err.message : String(err)}`);
-            }
-          }
+          const existingGateway = ctx.getExposeGateway?.();
+          const tunnelAlreadyActive = existingGateway?.isActive && existingGateway?.tunnelUrl;
+          const p2pAlreadyActive = ctx.isExposeActive?.() && !existingGateway?.tunnelUrl;
           if (config.transport.cloudflared && ctx.exposeStart) {
-            try {
-              const url = await ctx.exposeStart("ollama", void 0, "tunnel");
-              if (url) {
-                renderInfo(`Tunnel: ${url}`);
-                const gateway = ctx.getExposeGateway?.();
-                if (gateway && "setSponsorLimits" in gateway) {
-                  gateway.setSponsorLimits(config.rateLimits);
-                  renderInfo(`Rate limits active: ${config.rateLimits.maxRequestsPerMinute} req/min, ${config.rateLimits.maxTokensPerDay.toLocaleString()} tokens/day`);
+            if (tunnelAlreadyActive) {
+              renderInfo(`Tunnel already active: ${existingGateway.tunnelUrl}`);
+              if ("setSponsorLimits" in existingGateway) {
+                existingGateway.setSponsorLimits(config.rateLimits);
+              }
+              renderInfo(`Rate limits updated: ${config.rateLimits.maxRequestsPerMinute} req/min, ${config.rateLimits.maxTokensPerDay.toLocaleString()} tokens/day`);
+            } else {
+              try {
+                const url = await ctx.exposeStart("ollama", void 0, "tunnel");
+                if (url) {
+                  renderInfo(`Tunnel: ${url}`);
+                  const gw = ctx.getExposeGateway?.();
+                  if (gw && "setSponsorLimits" in gw) {
+                    gw.setSponsorLimits(config.rateLimits);
+                    renderInfo(`Rate limits active: ${config.rateLimits.maxRequestsPerMinute} req/min, ${config.rateLimits.maxTokensPerDay.toLocaleString()} tokens/day`);
+                  }
                 }
+              } catch (err) {
+                renderError(`Tunnel start failed: ${err instanceof Error ? err.message : String(err)}`);
               }
-            } catch (err) {
-              renderError(`Tunnel start failed: ${err instanceof Error ? err.message : String(err)}`);
             }
           }
           if (config.transport.libp2p && ctx.exposeStart) {
             try {
-              const url = await ctx.exposeStart("ollama", void 0, "libp2p");
-              if (url) {
-                renderInfo(`P2P: ${url}`);
-                const gateway = ctx.getExposeGateway?.();
-                if (gateway && "setSponsorLimits" in gateway) {
-                  gateway.setSponsorLimits(config.rateLimits);
-                }
-              }
+              const nexus = new NexusTool(projectDir);
+              renderInfo("Ensuring nexus daemon is connected...");
+              await nexus.execute({ action: "connect" });
+              await new Promise((r) => setTimeout(r, 2e3));
             } catch (err) {
-              renderError(`P2P start failed: ${err instanceof Error ? err.message : String(err)}`);
+              renderWarning(`Nexus: ${err instanceof Error ? err.message : String(err)}`);
             }
+            if (!p2pAlreadyActive) {
+              try {
+                const url = await ctx.exposeStart("ollama", void 0, "libp2p");
+                if (url)
+                  renderInfo(`P2P: ${url}`);
+              } catch (err) {
+                renderError(`P2P start failed: ${err instanceof Error ? err.message : String(err)}`);
+              }
+            } else {
+              renderInfo("P2P gateway already active.");
+            }
+          }
+          const activeGw = ctx.getExposeGateway?.();
+          if (activeGw && "setSponsorLimits" in activeGw) {
+            activeGw.setSponsorLimits(config.rateLimits);
           }
           try {
             const nexus = new NexusTool(projectDir);
@@ -48065,7 +48105,6 @@ async function handleSlashCommand(input, ctx) {
               await nexus.execute({ action: "connect" });
             } catch {
             }
-            await new Promise((r) => setTimeout(r, 2e3));
             const tunnelGw = ctx.getExposeGateway?.();
             const enabledEps = config.endpoints.filter((e) => e.enabled);
             const allModels = enabledEps.flatMap((e) => e.models || []);
@@ -63500,6 +63539,15 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
         writeContent(() => {
           renderInfo(`Reconnected to existing expose tunnel: ${reconnected.tunnelUrl}`);
         });
+        try {
+          const { loadSponsorConfig: loadSponsorConfig2 } = await Promise.resolve().then(() => (init_sponsor_wizard(), sponsor_wizard_exports));
+          const spCfg = loadSponsorConfig2(repoRoot);
+          if (spCfg && spCfg.status === "active" && "setSponsorLimits" in reconnected) {
+            reconnected.setSponsorLimits(spCfg.rateLimits);
+            writeContent(() => renderInfo(`Sponsor rate limits restored: ${spCfg.rateLimits.maxRequestsPerMinute} req/min`));
+          }
+        } catch {
+        }
       }
     } catch {
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.184.17",
+  "version": "0.184.19",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) \u2014 interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",