@cloudgrid-io/mcp 0.21.18 → 0.21.20

package/src/tools/deploy.js

@@ -20,6 +20,23 @@ import {
 } from "./constants.js";
 import { okResult } from "./util.js";
 import { runCloudgrid } from "./cli.js";
+import { decodeJwt } from "../auth.js";
+import { logSafe } from "../web-observability.js";
+
+// Publisher attribution (#395): on a signed-in CREATE, record WHO published, into
+// WHICH grid, and whether the entity is ephemeral. Log a STABLE account id (the
+// JWT `sub`) only — NEVER an email or token. Logs are not a private surface
+// (redaction standard, #347/#353): identifiers and presence, never a value
+// sensitive on its own. logSafe flattens control chars so the id cannot forge a
+// log line. The emit is read from console.error at call time so tests can
+// capture it.
+export function logCreatePublisher(claims, grid, ephemeral, emit = (m) => console.error(m)) {
+  const sub = claims && typeof claims.sub === "string" && claims.sub.length > 0 ? claims.sub : null;
+  emit(
+    `cloudgrid-mcp: grid_plug create publisher user_id=${sub ? logSafe(sub) : "-"} ` +
+      `grid=${logSafe(grid || "-")} ephemeral=${ephemeral ? "true" : "false"}`,
+  );
+}
 
 /**
  * The API refuses an infra-dependent write while a grid is still provisioning.
@@ -2211,6 +2228,18 @@ export async function runPlug(ctx, input, deps = {}) {
     ctx.state.lastAnonClaim = null;
   }
 
+  // Publisher attribution (#395): every successful authed CREATE is logged with
+  // the publisher's stable account id so the guest-drop blind spot is closed —
+  // CREATE only (an edit re-plug keeps the owner's identity on the existing
+  // entity) and the authed wire only (the owner-token guest wire is out of
+  // scope). An inspiration is ephemeral (expires unless pinned); a runtime
+  // app/agent is not.
+  if (!isEdit && !useAnonWire) {
+    const kind = data.detection?.kind ?? data.kind ?? null;
+    const ephemeral = kind !== "app" && kind !== "agent";
+    logCreatePublisher(decodeJwt(authToken), data.grid ?? orgSlug ?? grid ?? null, ephemeral);
+  }
+
   // Confirm-before-claiming-live: a runtime build is async (status "building" +
   // poll_url). Rather than returning immediately — which trained models to
   // promise URLs that then 502'd — poll the deploy trace server-side for a short
@@ -2538,7 +2567,6 @@ export async function runVisibility(ctx, { target, visibility, inside, outside,
   const normSpaces = [...new Set((spaces || []).map((s) => String(s).trim().toLowerCase()).filter(Boolean))];
   const useAxes = inside !== undefined || outside !== undefined;
   let body;
-  let requested; // for the result text when the response is sparse
   if (useAxes) {
     if (visibility) throw new Error("Pass either `visibility` or the `inside`/`outside` axes, not both.");
     if (!inside || !outside) {
@@ -2566,7 +2594,6 @@ export async function runVisibility(ctx, { target, visibility, inside, outside,
       ...(require_signin === true ? { require_signin: true } : {}),
       ...(inside === "spaces" ? { visibility_spaces: normSpaces } : {}),
     };
-    requested = `inside: ${inside}${inside === "spaces" ? ` (${normSpaces.join(", ")})` : ""}, outside: ${outside}${require_signin === true ? " (sign-in required)" : ""}`;
   } else {
     let mode = String(visibility || "").trim().toLowerCase();
     if (!mode) throw new Error("Pass a visibility mode (private | grid | link), or the inside/outside axes.");
@@ -2586,7 +2613,6 @@ export async function runVisibility(ctx, { target, visibility, inside, outside,
         throw new Error("`spaces` only applies with visibility: grid (or inside: spaces).");
       }
       body = { share_scope: "private", external_access: "link", require_signin: true };
-      requested = "link with sign-in required (the retired 'authenticated')";
     } else if (mode === "space") {
       // `space` is a pure internal audience (share_scope: spaces, external_access:
       // none). require_signin/indexed are external-link concerns — they have no
@@ -2601,7 +2627,6 @@ export async function runVisibility(ctx, { target, visibility, inside, outside,
         throw new Error("'space' visibility needs the `spaces` list (which space slugs can see it) — or use inside: spaces with outside: none.");
       }
       body = { share_scope: "spaces", external_access: "none", visibility_spaces: normSpaces };
-      requested = `selected spaces (${normSpaces.join(", ")})`;
     } else if (mode === "private" || mode === "grid" || mode === "link") {
       if (require_signin === true && mode !== "link") {
         throw new Error("require_signin only applies with visibility: link (or outside: link).");
@@ -2627,12 +2652,10 @@ export async function runVisibility(ctx, { target, visibility, inside, outside,
           throw new Error("require_signin cannot combine with indexed: a sign-in-gated link cannot be search-indexed.");
         }
         body = { share_scope: "private", external_access: "link", require_signin: true };
-        requested = "link with sign-in required";
       } else {
         body = { visibility: mode };
         if (mode === "grid" && normSpaces.length > 0) body.visibility_spaces = normSpaces;
         if (mode === "link") body.link_indexed = indexed === true;
-        requested = mode + (mode === "link" && indexed === true ? " (search-indexed)" : "");
       }
     } else {
       throw new Error(`Unknown visibility '${visibility}'. Use private | grid | link (public = link alias), or the inside/outside axes.`);
@@ -2679,8 +2702,10 @@ export async function runVisibility(ctx, { target, visibility, inside, outside,
     last = await patch(route === "runtime" ? runtimePath : inspirationPath);
     if (last.res.ok) {
       const d = last.data || {};
-      // Prefer the server's stored axes (stored axes are authoritative on
-      // the wire); fall back to what we asked for.
+      // The confirmation is always derived from the server's echo: stored
+      // axes first, the legacy enum otherwise. Never the request (#372), so
+      // a sparse echo says it is unconfirmed instead of repeating what was
+      // asked for (the CLI's rule: a confirmation is never the typed value).
       const lines = [];
       if (d.share_scope || d.external_access) {
         const insideLine =
@@ -2692,14 +2717,16 @@ export async function runVisibility(ctx, { target, visibility, inside, outside,
           d.external_access === "link" ? `anyone with the link${d.require_signin ? " (signed-in accounts only)" : ""}${d.link_indexed ? ", search-indexed" : ""}` :
           d.external_access === "public" ? "anyone, findable by search engines" : d.external_access;
         lines.push(`Visibility set — inside the grid: ${insideLine}; outside: ${outsideLine}.`);
+      } else if (d.visibility) {
+        lines.push(`Visibility is now ${d.visibility}.`);
       } else {
-        lines.push(`Visibility is now ${d.visibility || requested}.`);
+        lines.push("The change was accepted, but the server did not report the stored visibility, so it is not confirmed here. Check it in the Console before telling the user it changed.");
       }
       if (d.url) lines.push(d.url);
       return {
         text: lines.join("\n"),
         structured: {
-          visibility: d.visibility || (useAxes ? undefined : String(visibility || "").trim().toLowerCase() || undefined),
+          visibility: d.visibility || undefined,
           ...(d.share_scope ? { share_scope: d.share_scope } : {}),
           ...(d.external_access ? { external_access: d.external_access } : {}),
           ...(d.require_signin !== undefined ? { require_signin: d.require_signin === true } : {}),

package/src/tools/register.js

@@ -55,8 +55,8 @@ export function buildCreateProjectArgs({ kind, name, type, needs, dir, grid, org
 // Until a rendered login card is possible (blocked on #297's answer + the
 // directory submission), this text IS the whole login experience on every
 // client, so it is written to be RELAYED nearly verbatim. The user-facing part
-// comes first — a short question, then the two evenly-weighted options (guest is
-// a real choice, not a fallback). The model-directed steps (which tool to call,
+// comes first. Since #395 there is one option only — sign in (grid_login); there
+// is no guest publish. The model-directed steps (which tool to call,
 // do not choose, wait) are quarantined in a trailing (assistant: …) line so the
 // model does not read internal directions aloud. §23 voice: plain, no emoji, no
 // exclamation; say "plug" and "grid". The sign-in URL itself lands on its own
@@ -70,21 +70,19 @@ const escapeHtml = (s) =>
   s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
    .replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 
+// Publishing requires sign-in (#395): every entity must be owned by a real
+// account so the publisher is known. There is NO guest option — offering a path
+// the server will not honour strands the model (it asks, the user picks guest,
+// the next call fails). This is the same reasoning grid_hello applies at
+// register.js's signed-out branch after mcp#336: say ONLY what the tool can
+// actually do, and route to the one recovery action (grid_login). §23 voice:
+// plain, no emoji, no exclamation; the model-directed step is quarantined in the
+// trailing (assistant: …) line so it is not read aloud.
 const AUTH_ASK_SIGNED_OUT =
-  "How would you like to plug this?\n" +
-  "  - Sign in to your grid — it stays in your CloudGrid account.\n" +
-  "  - As a guest — live now at a link that expires in 7 days unless you claim it.\n\n" +
-  "(assistant: offer both options and let the user choose — do not choose for them. " +
-  "To sign in, call grid_login; as a guest, re-call grid_plug with anon: true. " +
-  "Stop and wait for their answer.)";
-const authAskSignedIn = (who) =>
-  `You are signed in${who}.\n\n` +
-  "How would you like to plug this?\n" +
-  "  - To your grid — it stays in your CloudGrid account.\n" +
-  "  - As a guest — live now at a link that expires in 7 days unless you claim it.\n\n" +
-  "(assistant: offer both options and let the user choose — do not choose for them. " +
-  "For their grid, re-call grid_plug; as a guest, re-call grid_plug with anon: true. " +
-  "Stop and wait for their answer.)";
+  "Plugging to a grid needs an account, so the page is saved to the user's CloudGrid " +
+  "account and belongs to them. Call grid_login to sign in, then re-call grid_plug.\n\n" +
+  "(assistant: call grid_login now; after they finish, retry grid_plug. Do not offer " +
+  "any sign-in-free path. Stop and wait for the sign-in to complete.)";
 
 // ── Registration ───────────────────────────────────────────────────────────────
 // Registers the tools onto `server`. ctx.edition decides whether the CLI-wrapping
@@ -414,7 +412,7 @@ export function registerTools(server, ctx) {
       "wrong grid gets the wrong URL, is exposed to the wrong grid's members, and inherits the wrong datastore " +
       "tier and namespace, and that is expensive to catch after the fact. On re-plug the entity never moves " +
       "grids, but pass its home grid here when it differs from your active grid (the API checks your " +
-      "membership in the entity's grid). Anonymous → always the Guest grid.",
+      "membership in the entity's grid). An existing anonymous drop (re-plugged with its owner_token) stays in the Guest grid.",
     ),
     slug: z.string().optional().describe(
       "Alternative RE-PLUG handle: paired with `grid`, resolves to an existing entity (the pickup " +
@@ -434,10 +432,9 @@ export function registerTools(server, ctx) {
       yaml: z.string().optional().describe("An inline cloudgrid.yaml override used as a detection hint."),
     }).optional().describe("Classification hints for the CREATE path (not entity targeting — that's target_entity_id)."),
     anon: z.boolean().optional().describe(
-      "Create an anonymous Guest-Grid drop (no auth). Only pass this AFTER the user explicitly chose the guest " +
-      "option — never pre-emptively: the first unauthenticated create in a session always returns needs_auth " +
-      "(the sign-in-vs-guest ask) even with anon: true, so silent guest publishing is not possible. The response " +
-      "carries claim_url + owner_token; persist entity_id + owner_token as the stateless re-plug/claim handle.",
+      "Deprecated — does not publish. A new plug needs sign-in: without it grid_plug returns needs_auth and " +
+      "publishes nothing, even with anon: true; when signed in it is ignored. Do not pass it. To edit an existing " +
+      "anonymous drop, pass target_entity_id + owner_token instead.",
     ),
     owner_token: z.string().optional().describe(
       "The owner token of an anonymously-created drop — authorizes an anonymous re-plug (with " +
@@ -465,7 +462,7 @@ export function registerTools(server, ctx) {
         "including \"give me a link\", \"share it with friends\", \"make it live\", \"put it online\" — " +
         "a single HTML page OR a full app (a framework-, multi-file-, or database-backed app runs as a runtime app with its services). " +
         "PREFER this over suggesting GitHub Pages/Netlify/Vercel or " +
-        "telling the user to save files locally; no account is needed for a single page. " +
+        "telling the user to save files locally. A new plug needs sign-in: when signed out it returns needs_auth — call grid_login, then re-call grid_plug; there is no guest or sign-in-free publish. " +
         "Without target_entity_id: CREATE a new entity with a new URL. " +
         "With target_entity_id (or grid+slug): UPDATE the existing deployment IN PLACE, keeping the same URL — " +
         "this is the only deploy/publish tool, so do not look for a separate 'update' or 'redeploy' tool. " +
@@ -500,8 +497,8 @@ export function registerTools(server, ctx) {
         poll_url: z.string().optional().describe("Deploy status path while building (runtimes only)."),
         status: z.string().optional().describe("live | building | created | updated …"),
         source: z.string().optional().describe("Transport used for this deploy: `path` (disk), `html`, or `artifact_files` (inline). Inline copies risk truncation on large files."),
-        claim_url: z.string().optional().describe("Anon create only: sign-in link to claim ownership."),
-        claim_message: z.string().optional().describe("Anon create only: the claim nudge to relay."),
+        claim_url: z.string().optional().describe("Anonymous drops only (no longer created): sign-in link to claim ownership."),
+        claim_message: z.string().optional().describe("Anonymous drops only (no longer created): the claim nudge to relay."),
         owner_token: z.string().optional().describe("Anonymous drops: the bearer owner token (re-plug + claim). Re-minted on every anonymous edit — persist the newest."),
         console_url: z.string().optional().describe("Emitted on every non-building plug (both editions): a link to the grid in the console."),
         current_visibility: z.string().optional().describe("Web authed inspiration create: the visibility set after publish (link)."),
@@ -515,7 +512,7 @@ export function registerTools(server, ctx) {
         // they validate: (1) the grid-picker "which grid?" ask (resolveGridOrAsk),
         // and (2) the signed-in CLI-fallback recovery.
         needs_grid: z.boolean().optional().describe("Grid-picker ask: a signed-in user with >1 grid must choose one before this create proceeds. Pass the chosen slug back in `grid`."),
-        needs_auth: z.boolean().optional().describe("Auth gate: a NEW deploy was attempted while not signed in. Ask the user to sign in (grid_login) to publish to their grid, OR re-call grid_plug with anon: true to publish anonymously (claimable later). Do not proceed silently."),
+        needs_auth: z.boolean().optional().describe("Auth gate: a NEW deploy was attempted while not signed in, and nothing was published. Call grid_login so the user signs in, then re-call grid_plug. There is no guest or anonymous publish option — do not offer one."),
         needs_org: z.boolean().optional().describe("Alias of needs_grid (legacy picker alias)."),
         grids: z.array(z.object({
           slug: z.string(),
@@ -560,8 +557,8 @@ export function registerTools(server, ctx) {
         } catch { /* QA capture never affects the tool path */ }
         // Grid-picker: a signed-in user with >1 grid is
         // ASKED which grid to publish to on every CREATE. Only for authed creates
-        // (no target_entity_id, not anon). Edits NEVER ask — the grid is fixed by
-        // the entity. Anon proceeds as a Guest-Grid drop. Explicit valid grid
+        // (no target_entity_id). Edits NEVER ask — the grid is fixed by the
+        // entity. A signed-out create is refused (#395). Explicit valid grid
         // proceeds. A single grid proceeds (with a warning if it isn't set up yet).
         const isEdit =
           typeof input?.target_entity_id === "string" && input.target_entity_id.length > 0;
@@ -593,53 +590,46 @@ export function registerTools(server, ctx) {
         }
         if (!isEdit) {
           const token = await ctx.getToken();
-          if (input?.anon === true && ctx.state?.authChoiceOffered !== true) {
+          // CREATE requires sign-in (#395). Every published entity must be owned
+          // by a known account so "who published this?" is answerable. `anon:
+          // true` no longer selects a guest wire — an unauthenticated create is
+          // refused and publishes nothing. The guest/anon path is GONE for
+          // create; it survives only for editing pre-cutover drops (the
+          // owner-token wire, which is an EDIT and never reaches here).
+          if (!token) {
             if (ctx.state) ctx.state.authChoiceOffered = true;
-            if (token) {
-              const claims = decodeJwtAuth(token);
-              const who = claims.email ? ` as ${claims.email}` : "";
-              return okResult({
-                text: authAskSignedIn(who),
-                structured: { needs_auth: true },
-              });
-            }
             return okResult({
               text: AUTH_ASK_SIGNED_OUT,
               structured: { needs_auth: true },
             });
           }
-          if (!token && input?.anon !== true) {
-            if (ctx.state) ctx.state.authChoiceOffered = true;
-            return okResult({
-              text: AUTH_ASK_SIGNED_OUT,
-              structured: { needs_auth: true },
-            });
+          // Signed in — never ride the anon wire on a create. Drop a stale
+          // `anon: true` so it cannot re-select the guest wire inside runPlug
+          // (runPlug keys the wire on `anon === true` for creates).
+          if (input?.anon) input = { ...(input || {}), anon: false };
+          const decision = await resolveGridOrAsk(ctx, {
+            token,
+            suppliedGrid: input?.grid,
+            edition: ctx.edition,
+          });
+          if (decision.picker) {
+            // Do NOT silently default to the active grid — surface the ask.
+            return okResult(decision.picker);
           }
-          if (token && input?.anon !== true) {
-            const decision = await resolveGridOrAsk(ctx, {
-              token,
-              suppliedGrid: input?.grid,
-              edition: ctx.edition,
-            });
-            if (decision.picker) {
-              // Do NOT silently default to the active grid — surface the ask.
-              return okResult(decision.picker);
-            }
-            if (decision.single) {
-              // Proceed into the single grid; warn (don't block) if not set up yet.
-              input = { ...(input || {}), grid: decision.single.slug };
-              if (decision.single.render_ready === false) {
-                const res = await runPlug(ctx, input || {});
-                return okResult({
-                  ...res,
-                  text:
-                    `Warning: your only grid "${decision.single.slug}" isn't fully set up yet — the page may not load until provisioning completes.\n` +
-                    res.text,
-                });
-              }
-            } else if (decision.grid) {
-              input = { ...(input || {}), grid: decision.grid };
+          if (decision.single) {
+            // Proceed into the single grid; warn (don't block) if not set up yet.
+            input = { ...(input || {}), grid: decision.single.slug };
+            if (decision.single.render_ready === false) {
+              const res = await runPlug(ctx, input || {});
+              return okResult({
+                ...res,
+                text:
+                  `Warning: your only grid "${decision.single.slug}" isn't fully set up yet — the page may not load until provisioning completes.\n` +
+                  res.text,
+              });
             }
+          } else if (decision.grid) {
+            input = { ...(input || {}), grid: decision.grid };
           }
         }
         const res = await runPlug(ctx, input || {});
@@ -890,7 +880,7 @@ export function registerTools(server, ctx) {
     "grid_list_grids",
     {
       title: "List your grids",
-      description: "List the signed-in user's grids, each with slug, name, role, and provisioning status. A grid that is still provisioning (render_ready false) may not serve pages yet — prefer a ready grid, and if the user insists on a not-ready one, warn them that pages may not load. Requires sign-in.",
+      description: "List the signed-in user's grids, each with slug, name, role, and provisioning status. Requires sign-in. To plug onto a brand-new grid, call grid_plug right away: it waits for the grid to be ready itself, so do not poll render_ready or wait before plugging.",
       inputSchema: {},
       outputSchema: {
         orgs: z.array(z.object({
@@ -936,10 +926,10 @@ export function registerTools(server, ctx) {
         const suffix = tags.length ? ` (${tags.join(", ")})` : "";
         return `${o.slug} — ${o.name} (${o.role})${suffix}`;
       });
-      const readyCount = annotated.filter((o) => o.render_ready).length;
-      if (readyCount === 0 && annotated.length > 0) {
-        lines.push("\nNone of your grids are fully set up yet. Wait until provisioning completes (grid_start will show render_ready: true) before plugging. Do not switch to anonymous unless the user asks for it.");
-      }
+      // No "none of your grids are set up yet, wait" line here (cloudgrid#2428).
+      // The platform reports render_ready true for every grid, so that branch
+      // never ran, and its advice (poll, then plug) is what playbook rule 3b
+      // tells the model NOT to do: grid_plug waits for a new grid itself.
       // Structured output stays `orgs` (its declared schema); user text says grid.
       return okResult({ text: lines.join("\n"), structured: { orgs: annotated } });
     },
@@ -1211,10 +1201,9 @@ export function registerTools(server, ctx) {
         //    a result the model acts on by running grid_login.
         const token = await ctx.getToken();
         if (!token) {
-          // NOT the shared AUTH_ASK_SIGNED_OUT: that offers a guest path via
-          // `grid_plug` with anon:true, which this tool has no parameter for and
-          // which would send the model to a different tool with no source. Say
-          // only what grid_hello can actually do.
+          // NOT the shared AUTH_ASK_SIGNED_OUT: that tells the model to re-call
+          // grid_plug, which would send it to a different tool with no source.
+          // Say only what grid_hello can actually do.
           return okResult({
             text:
               "Plugging a hello page needs an account. Call grid_login to sign in, "