@cloudgrid-io/mcp 0.20.28 → 0.20.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudgrid-io/mcp",
-  "version": "0.20.28",
+  "version": "0.20.30",
   "description": "MCP access to CloudGrid — the live runtime environment where the user's apps run WITH the infrastructure they need out of the box: managed MongoDB, Redis (cache/queues/pub-sub), a pgvector store, persistent disk, and built-in AI with no API keys, in any language or stack, no Docker or Kubernetes to manage. Brainstorm, build, plug, and improve apps, games, dashboards, and tools; instant single-page publishes and full runtime-app deploys with a live URL — for developers and non-technical users. Three editions: local stdio (full toolset), hosted web (light, CLI-free), and a public docs-search server.",
   "type": "module",
   "bin": {
@@ -53,12 +53,14 @@
     "test:fork": "node test/fork.test.mjs",
     "test:set-sharing": "node test/set-sharing.test.mjs",
     "test:check-deploy": "node test/check-deploy.test.mjs",
-    "test:staleness": "node test/staleness.test.mjs"
+    "test:staleness": "node test/staleness.test.mjs",
+    "test:proxy": "node test/proxy.test.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
     "express": "^4.22.2",
     "fflate": "^0.8.3",
+    "undici": "^8.7.0",
     "zod": "^3.23.0"
   },
   "license": "Apache-2.0",

package/src/auth.js

@@ -45,7 +45,17 @@ export function buildLoginUrl(code) {
 // A 404 means the session for this code does not exist yet — the user has not
 // opened the sign-in URL — so it is reported as 'not_started', not an error.
 export async function pollStatusOnce(code) {
-  const res = await fetch(`${API_BASE}/auth/status?code=${encodeURIComponent(code)}`);
+  let res;
+  try {
+    res = await fetch(`${API_BASE}/auth/status?code=${encodeURIComponent(code)}`);
+  } catch (err) {
+    const cause = err?.cause?.code || err?.cause?.message || err?.cause || err.message;
+    throw new Error(
+      `Can't reach api.cloudgrid.io (${cause}). ` +
+        `If you are behind a proxy, set HTTPS_PROXY; or use the hosted connector ` +
+        `https://mcp-connected.cloudgrid.io/mcp.`,
+    );
+  }
   if (res.status === 404) {
     return { status: "not_started" };
   }

package/src/index.js

@@ -5,6 +5,9 @@
 // Desktop). Full toolset, including the CLI-wrapping tools. Identity comes from
 // the shared ~/.cloudgrid/credentials file, so it interoperates with the CLI.
 
+import { installProxy } from "./proxy.js";
+installProxy();
+
 import { readFileSync } from "node:fs";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

package/src/proxy.js

@@ -0,0 +1,63 @@
+// Corporate proxy support for Node's global fetch (undici).
+//
+// Node's built-in fetch ignores HTTPS_PROXY / HTTP_PROXY. This module reads
+// the standard proxy env vars and, when set, installs an undici ProxyAgent as
+// the global dispatcher so every subsequent fetch() honors the proxy.
+//
+// Fully guarded: if undici is unavailable or the env is unset, this is a
+// silent no-op. Never throws at startup.
+
+import { createRequire } from "node:module";
+
+export function resolveProxy() {
+  const proxyUrl =
+    process.env.HTTPS_PROXY ||
+    process.env.https_proxy ||
+    process.env.HTTP_PROXY ||
+    process.env.http_proxy ||
+    null;
+
+  if (!proxyUrl) return null;
+
+  const raw =
+    process.env.NO_PROXY ||
+    process.env.no_proxy ||
+    "";
+
+  const noProxy = raw
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+  return { proxyUrl, noProxy };
+}
+
+export function shouldBypassProxy(hostname, noProxyList) {
+  if (!noProxyList || noProxyList.length === 0) return false;
+  for (const entry of noProxyList) {
+    if (entry === "*") return true;
+    if (hostname === entry) return true;
+    if (entry.startsWith(".") && hostname.endsWith(entry)) return true;
+  }
+  return false;
+}
+
+export function installProxy() {
+  try {
+    const cfg = resolveProxy();
+    if (!cfg) return;
+
+    const require = createRequire(import.meta.url);
+    const { ProxyAgent, setGlobalDispatcher } = require("undici");
+
+    setGlobalDispatcher(
+      new ProxyAgent({
+        uri: cfg.proxyUrl,
+        noProxy: cfg.noProxy.join(","),
+      }),
+    );
+  } catch {
+    // Silent: undici unavailable or ProxyAgent unsupported — fall through to
+    // default (unproxied) fetch. Never break startup.
+  }
+}

package/src/tools/deploy.js

@@ -1424,9 +1424,10 @@ export async function runPlug(ctx, input, deps = {}) {
   // budget. Fast builds come back "live" in this same tool call; a build that
   // outlives the budget returns "building" with explicit do-not-claim-live copy;
   // a failed build surfaces the platform's user-language error instead of a URL.
-  if ((data.status === "building" || data.poll_url) && data.poll_url && !useAnonWire) {
+  if ((data.status === "building" || data.poll_url) && !useAnonWire && (data.poll_url || data.entity_id)) {
     const verdict = await pollDeployTrace(ctx, {
       pollUrl: data.poll_url,
+      entityId: data.entity_id,
       grid: data.grid,
       budgetMs: ctx.deployPollBudgetMs ?? DEPLOY_POLL_BUDGET_MS,
       intervalMs: ctx.deployPollIntervalMs ?? DEPLOY_POLL_INTERVAL_MS,
@@ -1773,6 +1774,34 @@ const sleepMs = (ms) => new Promise((r) => setTimeout(r, ms));
 // GET one deploy-trace snapshot. Returns { status, error } — status is the
 // server's word ("queued"/"building"/"success"/"failed"), error is the
 // user-language message when failed. Throws only on a non-OK HTTP response.
+// Resolve a pollable deploy target. The hosted inline-create 202 returns
+// poll_url:null and trace_id:null (the trace is minted async), so when we only
+// have an entity_id we look up its latest deploy — GET /entities/:id/deploys
+// exposes a real trace_id even when the plug response omitted it — and poll the
+// normal /deploys/<trace_id>. Returns a poll path, or null when there is no
+// trace yet (the caller retries within its budget). Never throws.
+async function resolvePollUrl(ctx, { pollUrl, entityId, grid }) {
+  if (pollUrl) return pollUrl;
+  if (!entityId) return null;
+  try {
+    const token = await ctx.getToken();
+    const headers = {};
+    if (token) headers.Authorization = `Bearer ${token}`;
+    const orgSlug = grid || (await ctx.getActiveGrid());
+    if (orgSlug) {
+      headers["X-CloudGrid-Grid"] = orgSlug;
+      headers["X-CloudGrid-Org"] = orgSlug;
+    }
+    const res = await fetch(`${API_BASE}/api/v2/entities/${encodeURIComponent(entityId)}/deploys?limit=1`, { headers });
+    if (!res.ok) return null;
+    const data = await res.json();
+    const traceId = data?.deploys?.[0]?.trace_id;
+    return traceId ? `/deploys/${traceId}` : null;
+  } catch {
+    return null;
+  }
+}
+
 async function fetchDeployTrace(ctx, { pollUrl, grid }) {
   const token = await ctx.getToken();
   const headers = {};
@@ -1799,12 +1828,16 @@ async function fetchDeployTrace(ctx, { pollUrl, grid }) {
 // Poll until terminal or the budget runs out. Never throws — an unreachable
 // poll endpoint degrades to { status: "unknown" } and the caller keeps the
 // do-not-claim-live wording (the safe direction).
-export async function pollDeployTrace(ctx, { pollUrl, grid, budgetMs = DEPLOY_POLL_BUDGET_MS, intervalMs = DEPLOY_POLL_INTERVAL_MS }) {
+export async function pollDeployTrace(ctx, { pollUrl, entityId, grid, budgetMs = DEPLOY_POLL_BUDGET_MS, intervalMs = DEPLOY_POLL_INTERVAL_MS }) {
   const start = Date.now();
   let last = { status: "unknown", error: null };
   for (;;) {
     try {
-      last = await fetchDeployTrace(ctx, { pollUrl, grid });
+      // Resolve each iteration: on the hosted inline-create path poll_url is
+      // null and the trace may not exist for the first second or two, so keep
+      // trying to resolve it from the entity until it appears.
+      const target = await resolvePollUrl(ctx, { pollUrl, entityId, grid });
+      if (target) last = await fetchDeployTrace(ctx, { pollUrl: target, grid });
     } catch {
       // transient/unauthorized/network — keep last, retry within budget
     }
@@ -1819,13 +1852,21 @@ export async function pollDeployTrace(ctx, { pollUrl, grid, budgetMs = DEPLOY_PO
 // were missing — they had no way to confirm a runtime build came live and
 // blind-polled the public URL into 502s.
 export async function runCheckDeploy(ctx, { poll_url, grid } = {}) {
-  const pollUrl = poll_url || ctx.state.lastDrop?.poll_url;
-  if (!pollUrl) {
+  const gridSlug = grid || ctx.state.lastDrop?.grid;
+  const entityId = ctx.state.lastDrop?.entity_id;
+  // poll_url may be null on the hosted inline-create path — fall back to the
+  // session's entity_id and resolve the trace from /entities/:id/deploys.
+  const target = await resolvePollUrl(ctx, {
+    pollUrl: poll_url || ctx.state.lastDrop?.poll_url,
+    entityId,
+    grid: gridSlug,
+  });
+  if (!target) {
     throw new Error(
-      "No build to check. Pass poll_url from a grid_deploy result, or deploy something first in this session. (Instant inspiration deploys are live on return and have no poll_url.)",
+      "No build to check. Pass poll_url from a grid_deploy result, or deploy something first in this session. (Instant inspiration deploys are live on return and have no build to poll.)",
     );
   }
-  const verdict = await fetchDeployTrace(ctx, { pollUrl, grid: grid || ctx.state.lastDrop?.grid });
+  const verdict = await fetchDeployTrace(ctx, { pollUrl: target, grid: gridSlug });
   const url = ctx.state.lastDrop?.url;
   if (verdict.status === "success") {
     return {

package/src/web.js

@@ -14,6 +14,9 @@
 //
 // Run: PORT=8080 node src/web.js     Health: GET /healthz
 
+import { installProxy } from "./proxy.js";
+installProxy();
+
 import { readFileSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import express from "express";