@cloudgrid-io/mcp 0.21.6 → 0.21.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudgrid-io/mcp",
-  "version": "0.21.6",
+  "version": "0.21.7",
   "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": {
@@ -68,15 +68,22 @@
     "test:web-identity": "node --test test/web-identity.test.mjs",
     "test:web-auth-integration": "node --test test/web-auth-integration.test.mjs",
     "test:web-restart-recovery": "node --test test/web-restart-recovery.test.mjs",
-    "test:web-capabilities-log": "node --test test/web-capabilities-log.test.mjs"
+    "test:web-capabilities-log": "node --test test/web-capabilities-log.test.mjs",
+    "test:internal-refs": "node --test test/no-internal-refs.test.mjs",
+    "test:login-app": "node test/login-app.test.mjs",
+    "build:login-widget": "node scripts/build-login-widget.mjs"
   },
   "dependencies": {
+    "@modelcontextprotocol/ext-apps": "^1.7.5",
     "@modelcontextprotocol/sdk": "^1.30.0",
     "express": "^4.22.2",
     "fflate": "^0.8.3",
     "undici": "^8.10.0",
     "zod": "^3.23.0"
   },
+  "devDependencies": {
+    "esbuild": "^0.25.0"
+  },
   "license": "Apache-2.0",
   "homepage": "https://github.com/cloudgrid-io/mcp",
   "repository": {

package/src/tools/constants.js

@@ -60,6 +60,18 @@ export const LIVE_RESULT_URI = "ui://cloudgrid/live-result.html";
 export const GRID_PICKER_URI = "ui://cloudgrid/org-picker.html";
 export const LIVE_RESULT_HTML = readFileSync(new URL("../widgets/live-result.html", import.meta.url), "utf-8");
 export const GRID_PICKER_HTML = readFileSync(new URL("../widgets/org-picker.html", import.meta.url), "utf-8");
+
+// ── grid_login MCP App (SEP-1865, Claude web) ────────────────────────────────
+// A SECOND, independent UI mechanism from the ChatGPT Apps-SDK widgets above.
+// It is NOT gated behind MCP_APPS_WIDGETS: that flag controls only the
+// openai/outputTemplate key ChatGPT reads, and it must stay exactly as it is.
+// The login card binds via _meta.ui.resourceUri (the SEP-1865 key Claude reads),
+// which ChatGPT ignores — so shipping it does not touch the ChatGPT path. A
+// client without the UI extension ignores _meta.ui and still gets the text-first
+// sign-in URL. The HTML is the self-contained bundle from
+// scripts/build-login-widget.mjs (App class + card inlined; deny-by-default CSP).
+export const GRID_LOGIN_APP_URI = "ui://grid-login/mcp-app.html";
+export const GRID_LOGIN_APP_HTML = readFileSync(new URL("../widgets/grid-login.html", import.meta.url), "utf-8");
 export const WIDGET_CSP = {
   connectDomains: ["https://*.cloudgrid.io"],
   resourceDomains: ["https://*.cloudgrid.io"],

package/src/tools/deploy.js

@@ -1557,6 +1557,7 @@ export async function runPlug(ctx, input, deps = {}) {
     target_entity_id,
     grid,
     slug,
+    url: targetUrl,
     hints,
     anon,
     owner_token,
@@ -1676,16 +1677,30 @@ export async function runPlug(ctx, input, deps = {}) {
     );
   }
 
-  // grid+slug re-plug handle (the pickup contract's `replug_handle`): when no
-  // explicit target_entity_id was given but a grid+slug pair is, resolve it to
-  // an existing entity_id and re-plug that in place. A slug that does NOT resolve
-  // to an existing entity → targetEntityId stays empty → this is a CREATE (no
-  // false-positive re-plug). target_entity_id remains the primary/documented
-  // handle. Best-effort resolve (pickup contract); never fetches the public URL.
+  // Re-plug handle resolution (the pickup contract's `replug_handle`): when no
+  // explicit target_entity_id was given, resolve one from an alternative target
+  // the caller DID name — a grid+slug pair, or a CloudGrid `url` — so an edge
+  // identified only by its public URL re-plugs the SAME entity in place instead
+  // of minting a new one. A target that does NOT resolve to an existing entity →
+  // targetEntityId stays empty → this is a CREATE (no false-positive re-plug).
+  // target_entity_id remains the primary/documented handle. Best-effort resolve
+  // (pickup contract); never fetches the public URL.
+  //
+  // #296: a `url` is only trusted as a re-plug target when its host is a real
+  // CloudGrid grid apex (gridFromCloudgridUrl != null) — a foreign or malformed
+  // host is NOT sent to the resolver, so an untrusted URL can never redirect a
+  // write to another entity. `pickupData` is reused below to header the write
+  // without a second round-trip.
   let targetEntityId = target_entity_id;
-  if ((typeof targetEntityId !== "string" || targetEntityId.length === 0) && grid && slug) {
-    const resolved = await resolveEntityViaPickup(ctx, { target: slug, grid });
-    if (resolved?.entity_id) targetEntityId = resolved.entity_id;
+  const urlGrid = gridFromCloudgridUrl(targetUrl);
+  let pickupData = null;
+  if (typeof targetEntityId !== "string" || targetEntityId.length === 0) {
+    if (grid && slug) {
+      pickupData = await resolveEntityViaPickup(ctx, { target: slug, grid });
+    } else if (urlGrid) {
+      pickupData = await resolveEntityViaPickup(ctx, { url: targetUrl, grid: urlGrid });
+    }
+    if (pickupData?.entity_id) targetEntityId = pickupData.entity_id;
   }
 
   const isEdit = typeof targetEntityId === "string" && targetEntityId.length > 0;
@@ -1771,17 +1786,26 @@ export async function runPlug(ctx, input, deps = {}) {
     // the caller's membership from this header and requires it to MATCH the
     // entity's grid, so pass `grid` here too when the target lives outside the
     // active grid.
-    orgSlug = grid || (await ctx.getActiveGrid());
     // #296: an EDIT's destination is NOT ambiguous — the entity already lives in
-    // exactly one grid. When neither an explicit `grid` nor active-grid session
-    // state resolves one (the common hosted case, where active-grid is often
-    // unset), derive the home grid from the target entity itself so the write
-    // never depends on session state the API would otherwise reject for
-    // (GRID_HEADER_REQUIRED). Best-effort metadata resolve via the pickup
-    // contract (no claim); a null result simply falls back to today's behaviour.
-    if (!orgSlug && isEdit && targetEntityId) {
-      const resolved = await resolveEntityViaPickup(ctx, { target: targetEntityId });
-      if (resolved?.grid) orgSlug = resolved.grid;
+    // exactly one grid, and every way of naming that entity carries the grid.
+    // Resolve it in a deliberate order, cheapest reliable source first, so the
+    // write never depends on session state the API would otherwise reject for
+    // (GRID_HEADER_REQUIRED):
+    //   1. explicit `grid` param        — the caller said so.
+    //   2. active grid                   — session state, no network.
+    //   3. the URL host                  — FREE: the grid is the subdomain of a
+    //      CloudGrid `url` the user pasted; read it before any round-trip. A
+    //      foreign/malformed host yields null (gridFromCloudgridUrl) and we fall
+    //      through — never a silent redirect.
+    //   4. the target entity itself      — a pickup round-trip, only if 1–3 all
+    //      came up empty. Reuse a pickup already done above to resolve the id.
+    orgSlug = grid || (await ctx.getActiveGrid());
+    if (!orgSlug) orgSlug = gridFromCloudgridUrl(targetUrl);
+    if (!orgSlug && isEdit) {
+      if (!pickupData && targetEntityId) {
+        pickupData = await resolveEntityViaPickup(ctx, { target: targetEntityId });
+      }
+      if (pickupData?.grid) orgSlug = pickupData.grid;
     }
     // Grid-native header + X-CloudGrid-Org alias (same slug) during the soak.
     if (orgSlug) {
@@ -2688,6 +2712,42 @@ function isCloudgridHost(hostname) {
   return h === "cloudgrid.io" || h.endsWith(".cloudgrid.io");
 }
 
+// Derive the home grid slug from a CloudGrid URL (or a bare host). The grid is
+// the subdomain: `<grid>.cloudgrid.io/<slug>` (inspiration/path form) and
+// `<slug>--<grid>.cloudgrid.io` (runtime/flat form — grid is the label after
+// `--`), matching composePlugUrl's two serving shapes.
+//
+// SECURITY (#296): this derives a WRITE DESTINATION from user-supplied input, so
+// it is deliberately strict — it reuses `isCloudgridHost` (the single host check,
+// SSRF-shaped) rather than string-matching, and returns null for anything that is
+// not a trusted grid apex: a foreign or lookalike host, a malformed URL, the bare
+// apex `cloudgrid.io`, a deeper host (`a.b.cloudgrid.io`), or the anonymous
+// `guest` apex (never an authed write destination). A null result means "I could
+// not name the grid" → the caller falls through to today's behaviour and NEVER
+// silently redirects the write to a grid the user did not mean.
+export function gridFromCloudgridUrl(input) {
+  const raw = String(input ?? "").trim();
+  if (!raw) return null;
+  let parsed;
+  try {
+    // Accept a bare host (`shoobi.cloudgrid.io/x`) by supplying a scheme; a
+    // string that is already a URL keeps its own scheme.
+    parsed = new URL(/^[a-z][a-z0-9+.-]*:\/\//i.test(raw) ? raw : `https://${raw}`);
+  } catch {
+    return null;
+  }
+  if (!isCloudgridHost(parsed.hostname)) return null;
+  const host = parsed.hostname.toLowerCase();
+  const labels = host.split(".");
+  // Exactly `<sub>.cloudgrid.io`. The apex (`cloudgrid.io`, 2 labels) and any
+  // deeper host (`a.b.cloudgrid.io`, 4+) name no single grid apex we trust.
+  if (labels.length !== 3) return null;
+  const sub = labels[0];
+  const grid = sub.includes("--") ? sub.split("--").pop() : sub;
+  if (!grid || grid === GUEST_ORG_SLUG) return null;
+  return grid;
+}
+
 // Shape an HTML string into the grid_get_app_source result (shared by the API-read
 // and the public-fetch paths). Caps the body at SOURCE_MAX_BYTES. `extra` carries
 // optional edition metadata resolved from the pickup contract (kind, single_html,
@@ -2837,10 +2897,10 @@ export async function runSource(ctx, { entity_id, url, grid, slug } = {}) {
   const resolvedUrl = parsed.toString();
   let eid = entity_id ?? (last && (!entity_id || last.entity_id === entity_id) ? last.entity_id : null);
 
-  // Derive the grid/slug hint from the inspiration path URL (`grid.cloudgrid.io/slug`).
-  const host = parsed.hostname;
-  const gridHint = grid ?? (host.endsWith(".cloudgrid.io") && !host.includes("--") && host.split(".").length === 3
-    ? host.split(".")[0] : null);
+  // Derive the grid/slug hint from the URL. gridFromCloudgridUrl is the single
+  // host→grid parser (it also handles the flat `<slug>--<grid>` form the old
+  // inline check missed); the slug is the first path segment.
+  const gridHint = grid ?? gridFromCloudgridUrl(resolvedUrl);
   const slugHint = slug ?? (parsed.pathname.replace(/^\/+/, "").split("/")[0] || null);
 
   // ── URL → entity_id (fresh chat, no session) via the pickup contract ──────

package/src/tools/register.js

@@ -3,6 +3,7 @@
 // Extracted verbatim from src/tools.js (refactor: split tools.js into modules).
 
 import { z } from "zod";
+import { registerAppResource, RESOURCE_MIME_TYPE } from "@modelcontextprotocol/ext-apps/server";
 import { newLoginCode, buildLoginUrl, pollStatusOnce, checkApiConnectivity, decodeJwt as decodeJwtAuth } from "../auth.js";
 import { PLAYBOOK, fetchCorpus, listWorkflows } from "../playbook.js";
 import {
@@ -12,6 +13,8 @@ import {
   LIVE_RESULT_HTML,
   GRID_PICKER_HTML,
   WIDGET_CSP,
+  GRID_LOGIN_APP_URI,
+  GRID_LOGIN_APP_HTML,
 } from "./constants.js";
 import { fail, okResult } from "./util.js";
 import { cliTool, tryOpenBrowser } from "./cli.js";
@@ -144,6 +147,23 @@ export function registerTools(server, ctx) {
         _meta: { ui: { csp: WIDGET_CSP } },
       }],
     }));
+
+    // grid_login MCP App (SEP-1865). Registered via the official ext-apps
+    // helper, which defaults the MIME type to RESOURCE_MIME_TYPE
+    // (text/html;profile=mcp-app) — the type Claude web looks for. NO csp
+    // domains: the card makes no network requests of its own (it only asks the
+    // host to open the sign-in URL and calls grid_login_status back over the
+    // bridge), so deny-by-default is exactly right. Independent of
+    // APPS_WIDGETS_ENABLED by design (see constants.js).
+    registerAppResource(server, "cloudgrid-grid-login", GRID_LOGIN_APP_URI, {
+      description: "CloudGrid sign-in card — opens the sign-in URL and confirms when you return.",
+    }, async () => ({
+      contents: [{
+        uri: GRID_LOGIN_APP_URI,
+        mimeType: RESOURCE_MIME_TYPE,
+        text: GRID_LOGIN_APP_HTML,
+      }],
+    }));
   }
 
   // ── Direct-API tools (both editions) ──────────────────────────────────────
@@ -380,6 +400,13 @@ export function registerTools(server, ctx) {
       "raw entity_id. target_entity_id takes precedence. A grid+slug that does NOT resolve to an existing " +
       "entity is treated as a CREATE (never a false-positive re-plug).",
     ),
+    url: z.string().optional().describe(
+      "Alternative RE-PLUG handle: the entity's public CloudGrid URL (e.g. https://<grid>.cloudgrid.io/<slug>) " +
+      "— use it to edit in place when you have the URL but no target_entity_id (the common \"change the color of " +
+      "this page\" flow after grid_get_app_source). The grid is read from the host and the entity is resolved via " +
+      "the pickup contract, so no `grid` param is needed. target_entity_id and grid+slug take precedence. A " +
+      "non-CloudGrid host is ignored (never redirects the write); a URL that does not resolve is treated as a CREATE.",
+    ),
     hints: z.object({
       kind: z.enum(["inspiration", "app", "agent"]).optional().describe("Force the detected kind; omit to let the server auto-detect."),
       yaml: z.string().optional().describe("An inline cloudgrid.yaml override used as a detection hint."),
@@ -662,6 +689,14 @@ export function registerTools(server, ctx) {
         login_url: z.string().describe("URL to open in a browser to complete sign-in."),
       },
       annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      // Bind the SEP-1865 sign-in card on the web edition (Claude web). This is
+      // the SEP-1865 key (_meta.ui.resourceUri); ChatGPT reads openai/outputTemplate
+      // and ignores it, and a client without the UI extension ignores it too and
+      // gets the text-first result below. NOT gated behind MCP_APPS_WIDGETS — a
+      // second, independent mechanism (see constants.js). The result shape is
+      // unchanged: content[0] stays the sign-in URL text so the link is never
+      // unreachable if the card does not render.
+      ...(ctx.edition === "web" ? { _meta: { ui: { resourceUri: GRID_LOGIN_APP_URI } } } : {}),
     },
     async () => {
       try {

package/src/widgets/grid-login/mcp-app.css

@@ -0,0 +1,57 @@
+:root { color-scheme: light dark; }
+* { box-sizing: border-box; }
+body {
+  margin: 0;
+  font-family: var(--font-sans, Inter, system-ui, -apple-system, sans-serif);
+  background: transparent;
+  color: light-dark(#0d0d0f, #fafafa);
+}
+#card {
+  max-width: 420px;
+  margin: 0 auto;
+  padding: 1.5rem;
+}
+h1 {
+  font-size: 1.15rem;
+  margin: 0 0 0.5rem;
+}
+.lede {
+  margin: 0 0 1rem;
+  font-size: 0.9rem;
+  line-height: 1.45;
+  opacity: 0.85;
+}
+.status {
+  margin: 0 0 1rem;
+  font-size: 0.85rem;
+  opacity: 0.7;
+  min-height: 1.2em;
+}
+.actions {
+  display: flex;
+  gap: 0.5rem;
+  flex-wrap: wrap;
+}
+button {
+  font: inherit;
+  font-weight: 600;
+  padding: 0.6rem 1.1rem;
+  border-radius: 8px;
+  border: 1px solid transparent;
+  cursor: pointer;
+  background: light-dark(#0d0d0f, #fafafa);
+  color: light-dark(#fafafa, #0d0d0f);
+}
+button:disabled { opacity: 0.5; cursor: default; }
+button.secondary {
+  background: transparent;
+  color: inherit;
+  border-color: light-dark(rgba(13,13,15,0.25), rgba(250,250,250,0.3));
+}
+.fallback {
+  margin: 1rem 0 0;
+  font-size: 0.8rem;
+  opacity: 0.7;
+  word-break: break-all;
+}
+.fallback a { color: inherit; }

package/src/widgets/grid-login/mcp-app.html

@@ -0,0 +1,26 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="color-scheme" content="light dark">
+<title>Sign in to CloudGrid</title>
+<style>/* __CSS__ */</style>
+</head>
+<body>
+<main id="card">
+  <h1>Sign in to CloudGrid</h1>
+  <p class="lede">CloudGrid runs your apps with the infrastructure they need. Sign in to plug to your grid.</p>
+  <p class="status" id="status">Preparing the sign-in link.</p>
+  <div class="actions">
+    <button id="signin" type="button" disabled>Open sign-in</button>
+    <button id="check" type="button" class="secondary" hidden>Check sign-in</button>
+  </div>
+  <p class="fallback" id="fallback" hidden>
+    Or open this link yourself:
+    <a id="fallback-url" href="#" target="_blank" rel="noopener noreferrer"></a>
+  </p>
+</main>
+<script type="module">/* __JS__ */</script>
+</body>
+</html>

package/src/widgets/grid-login/mcp-app.js

@@ -0,0 +1,131 @@
+/**
+ * @file grid_login MCP App — the sign-in card Claude web renders for grid_login.
+ *
+ * This module is the UI half of the MCP Apps (SEP-1865) mechanism. It talks to
+ * the host over postMessage JSON-RPC via the official `App` class — NOT
+ * `window.openai`, which does not exist in Claude's host (that global is the
+ * ChatGPT Apps-SDK bridge the old org-picker widget targets).
+ *
+ * It is bundled into a single self-contained src/widgets/grid-login.html by
+ * scripts/build-login-widget.mjs (esbuild inlines this file and the whole
+ * @modelcontextprotocol/ext-apps App class). The iframe CSP is deny-by-default,
+ * so nothing here may reference a remote script, stylesheet, or font.
+ *
+ * Security invariant (issue #302): the card NEVER receives, displays, or stores
+ * a token. Its only job is to open the sign-in URL in the browser; the browser
+ * performs the auth. The most we surface after sign-in is the account email,
+ * which grid_login_status returns and which is not a credential.
+ */
+import {
+  App,
+  applyDocumentTheme,
+  applyHostFonts,
+  applyHostStyleVariables,
+} from "@modelcontextprotocol/ext-apps";
+
+const els = {
+  root: document.getElementById("card"),
+  status: document.getElementById("status"),
+  signin: document.getElementById("signin"),
+  check: document.getElementById("check"),
+  fallback: document.getElementById("fallback"),
+  fallbackUrl: document.getElementById("fallback-url"),
+};
+
+// The sign-in URL, lifted from the tool result. Never a token — just the URL
+// the browser opens. Held only to wire the button.
+let loginUrl = null;
+
+// Pull the sign-in URL out of a grid_login tool result. structuredContent is
+// the contract (grid_login sets { login_url }); the text content is the
+// text-first fallback that ALSO carries the URL, so we read it if structured is
+// missing. This mirrors the server: the URL is never hidden behind the card.
+function readLoginUrl(result) {
+  const fromStructured = result?.structuredContent?.login_url;
+  if (typeof fromStructured === "string" && fromStructured) return fromStructured;
+  const text = Array.isArray(result?.content)
+    ? result.content.filter((c) => c?.type === "text").map((c) => c.text).join("\n")
+    : "";
+  const match = text.match(/https?:\/\/\S+/);
+  return match ? match[0] : null;
+}
+
+function showSignInReady() {
+  if (loginUrl) {
+    els.fallbackUrl.textContent = loginUrl;
+    els.fallbackUrl.setAttribute("href", loginUrl);
+    els.fallback.hidden = false;
+  }
+  els.signin.disabled = !loginUrl;
+  els.status.textContent = loginUrl
+    ? "Sign in to publish to your grid."
+    : "Preparing the sign-in link.";
+}
+
+function showAwaitingReturn() {
+  els.status.textContent =
+    "Finish signing in on the page that opened, then come back and select Check sign-in.";
+  els.check.hidden = false;
+}
+
+const app = new App({ name: "CloudGrid sign-in", version: "1.0.0" });
+
+app.onerror = (err) => console.error("[grid-login card]", err);
+
+app.onhostcontextchanged = (ctx) => {
+  if (ctx?.theme) applyDocumentTheme(ctx.theme);
+  if (ctx?.styles?.variables) applyHostStyleVariables(ctx.styles.variables);
+  if (ctx?.styles?.css?.fonts) applyHostFonts(ctx.styles.css.fonts);
+};
+
+// The grid_login result arrives here after connect. It carries the URL, never
+// a token.
+app.ontoolresult = (result) => {
+  loginUrl = readLoginUrl(result);
+  showSignInReady();
+};
+
+els.signin.addEventListener("click", async () => {
+  if (!loginUrl) return;
+  try {
+    await app.openLink({ url: loginUrl });
+    showAwaitingReturn();
+  } catch (err) {
+    console.error("[grid-login card] openLink failed", err);
+    // The link is still on-screen (fallback block); the user can open it
+    // manually. Never dead-end.
+    showAwaitingReturn();
+  }
+});
+
+// Check sign-in: ask the server to finish the flow (grid_login_status). It
+// returns { status, email } and NEVER a token, so the card stays token-free.
+els.check.addEventListener("click", async () => {
+  els.check.disabled = true;
+  els.status.textContent = "Checking sign-in.";
+  try {
+    const result = await app.callServerTool({ name: "grid_login_status", arguments: {} });
+    const status = result?.structuredContent?.status;
+    const email = result?.structuredContent?.email;
+    if (status === "authenticated") {
+      els.status.textContent = email ? `Signed in as ${email}.` : "Signed in.";
+      els.signin.hidden = true;
+      els.check.hidden = true;
+    } else {
+      els.status.textContent =
+        "Still waiting for sign-in. Finish on the page that opened, then check again.";
+      els.check.disabled = false;
+    }
+  } catch (err) {
+    console.error("[grid-login card] status check failed", err);
+    els.status.textContent =
+      "Could not check sign-in from here. Complete it in the browser and I will continue.";
+    els.check.disabled = false;
+  }
+});
+
+showSignInReady();
+app.connect().then(() => {
+  const ctx = app.getHostContext();
+  if (ctx) app.onhostcontextchanged(ctx);
+});