gogcli-mcp-classroom 4.3.0 → 4.4.0

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
   },
   "metadata": {
     "description": "Extended Google Classroom for Claude via gogcli — auth + full Classroom support (courses, rosters, coursework, submissions, announcements, topics, invitations)",
-    "version": "4.3.0"
+    "version": "4.4.0"
   },
   "plugins": [
     {
@@ -15,7 +15,7 @@
       "displayName": "gogcli (Classroom)",
       "source": "./",
       "description": "Extended Google Classroom for Claude via gogcli — auth + full Classroom support (courses, rosters, coursework, submissions, announcements, topics, invitations)",
-      "version": "4.3.0",
+      "version": "4.4.0",
       "author": {
         "name": "Chris Hall"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "gogcli-mcp-classroom",
   "displayName": "gogcli (Classroom)",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "description": "Extended Google Classroom for Claude via gogcli — auth + full Classroom support (courses, rosters, coursework, submissions, announcements, topics, invitations)",
   "author": {
     "name": "Chris Hall",

package/dist/index.js

@@ -37,6 +37,33 @@ var storage2 = new AsyncLocalStorage2();
 function withCallerCapabilities(capabilities, fn) {
   return capabilities ? storage2.run(capabilities, fn) : fn();
 }
+function currentCallerCapabilities() {
+  return storage2.getStore();
+}
+var ENVELOPE_CAPABILITIES_KEY = "io.modelcontextprotocol/clientCapabilities";
+var ELICITATION_MODES = ["form", "url"];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function callerCapabilities(ctx) {
+  const envelope = isRecord(ctx) && isRecord(ctx.mcpReq) ? ctx.mcpReq.envelope : void 0;
+  if (isRecord(envelope)) {
+    const declared = envelope[ENVELOPE_CAPABILITIES_KEY];
+    if (isRecord(declared))
+      return declared;
+  }
+  return currentCallerCapabilities();
+}
+function callerAcceptsFormElicitation(ctx) {
+  const capabilities = callerCapabilities(ctx);
+  if (!capabilities)
+    return void 0;
+  const elicitation = capabilities.elicitation;
+  if (!isRecord(elicitation))
+    return false;
+  const namedModes = ELICITATION_MODES.filter((mode) => mode in elicitation);
+  return namedModes.length === 0 || namedModes.includes("form");
+}
 
 // ../../node_modules/@modelcontextprotocol/server/dist/chunk-Br0eD_fh.mjs
 var __create = Object.create;
@@ -24101,6 +24128,37 @@ var inputRequired = Object.assign(buildInputRequired, {
     return { method: "roots/list" };
   }
 });
+function acceptedContent(responses, key, schema) {
+  const view = inputResponse(responses, key);
+  if (view.kind !== "elicit" || view.action !== "accept" || view.content === void 0) return void 0;
+  if (schema === void 0) return view.content;
+  const outcome = schema["~standard"].validate(view.content);
+  if (outcome instanceof Promise) throw new TypeError("acceptedContent(responses, key, schema) requires a synchronously-validating schema");
+  return outcome.issues === void 0 ? outcome.value : void 0;
+}
+function inputResponse(responses, key) {
+  if (responses === void 0 || typeof responses !== "object" || responses === null) return { kind: "missing" };
+  const entry = responses[key];
+  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) return { kind: "missing" };
+  const candidate = entry;
+  if (candidate["action"] === "accept" || candidate["action"] === "decline" || candidate["action"] === "cancel") {
+    const content = candidate["content"];
+    return {
+      kind: "elicit",
+      action: candidate["action"],
+      ...content !== null && typeof content === "object" && !Array.isArray(content) && { content }
+    };
+  }
+  if (Array.isArray(candidate["roots"])) return {
+    kind: "roots",
+    roots: candidate["roots"]
+  };
+  if (typeof candidate["role"] === "string" && candidate["content"] !== void 0) return {
+    kind: "sampling",
+    result: candidate
+  };
+  return { kind: "missing" };
+}
 var REQUEST_STATE_ONLY_LEG_PACING_MS = 250;
 function inputRequiredRoundsExceededMessage(method, maxRounds) {
   return `Multi-round-trip request '${method}' still required input after ${maxRounds} rounds (inputRequired.maxRounds)`;
@@ -34148,14 +34206,14 @@ function serveStdio(factory, options = {}) {
     return false;
   };
   const answerLegacyRejection = (request, reason, requestedVersion) => {
-    const rejection2 = modernOnlyStrictRejection({
+    const rejection3 = modernOnlyStrictRejection({
       kind: "legacy",
       reason,
       ...requestedVersion !== void 0 && { requestedVersion }
     }, SUPPORTED_MODERN_PROTOCOL_VERSIONS);
-    if (rejection2 === void 0) return Promise.resolve();
-    reportError(/* @__PURE__ */ new Error(`Rejected 2025-era request on a modern-only stdio connection (${rejection2.cell}): ${rejection2.message}`));
-    return writeErrorResponse(request.id, rejection2.code, rejection2.message, rejection2.data);
+    if (rejection3 === void 0) return Promise.resolve();
+    reportError(/* @__PURE__ */ new Error(`Rejected 2025-era request on a modern-only stdio connection (${rejection3.cell}): ${rejection3.message}`));
+    return writeErrorResponse(request.id, rejection3.code, rejection3.message, rejection3.data);
   };
   const onInstanceClosed = (channel) => {
     if (closing || channel === discarding) return;
@@ -34458,6 +34516,11 @@ function walk(value, keep, drop) {
 }
 
 // ../../node_modules/@chrischall/mcp-utils/dist/response/index.js
+function textResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
 function rawTextResult(text) {
   return { content: [{ type: "text", text }] };
 }
@@ -34468,6 +34531,154 @@ function errorResult(message) {
   };
 }
 
+// ../../node_modules/@chrischall/mcp-utils/dist/server/confirmation.js
+import { createHash, createHmac, timingSafeEqual } from "node:crypto";
+var DEFAULT_REQUEST_KEY = "confirmation";
+var DEFAULT_CONFIRMATION_LABEL = "Confirm this action should proceed.";
+var UNSUPPORTED_NOTE = "Nothing was done because this client cannot show a confirmation prompt (it declares no MCP elicitation capability), and this action is never taken without one";
+var STATE_PREFIX = "mcpu.confirm.v1.";
+function canonicalJson(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return JSON.stringify(value);
+  if (value === void 0)
+    return "null";
+  if (typeof value === "number")
+    return Number.isFinite(value) ? JSON.stringify(value) : `{"$num":"${String(value)}"}`;
+  if (typeof value === "bigint")
+    return `{"$bigint":"${value.toString()}"}`;
+  if (typeof value === "function" || typeof value === "symbol") {
+    throw new TypeError(`requireConfirmation: cannot bind a ${typeof value} argument value.`);
+  }
+  if (Array.isArray(value))
+    return `[${value.map(canonicalJson).join(",")}]`;
+  if (value instanceof Date) {
+    return `{"$date":${JSON.stringify(Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString())}}`;
+  }
+  if (ArrayBuffer.isView(value)) {
+    const bytes = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+    return `{"$bytes":${JSON.stringify(bytes.toString("base64"))}}`;
+  }
+  if (value instanceof ArrayBuffer)
+    return `{"$bytes":${JSON.stringify(Buffer.from(value).toString("base64"))}}`;
+  if (value instanceof Map) {
+    const entries2 = [...value.entries()].map(([k, v]) => `[${canonicalJson(k)},${canonicalJson(v)}]`).sort();
+    return `{"$map":[${entries2.join(",")}]}`;
+  }
+  if (value instanceof Set) {
+    return `{"$set":[${[...value].map(canonicalJson).sort().join(",")}]}`;
+  }
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null) {
+    throw new TypeError("requireConfirmation: cannot bind a non-plain object argument value (class instance).");
+  }
+  const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  return `{${entries.map(([k, v]) => `${JSON.stringify(escapeKey(k))}:${canonicalJson(v)}`).join(",")}}`;
+}
+function escapeKey(key) {
+  return key.startsWith("$") ? `$${key}` : key;
+}
+function bindingKey(binding) {
+  if (binding.ttlSeconds !== void 0 && !(Number.isFinite(binding.ttlSeconds) && binding.ttlSeconds > 0)) {
+    throw new RangeError("requireConfirmation: binding.ttlSeconds must be a finite number greater than 0.");
+  }
+  const key = typeof binding.key === "string" ? Buffer.from(binding.key, "utf8") : Buffer.from(binding.key);
+  if (key.length < 32) {
+    throw new RangeError("requireConfirmation: binding.key must be at least 32 bytes.");
+  }
+  return key;
+}
+function commitment(action, args) {
+  return createHash("sha256").update(`${action}\0${canonicalJson(args)}`).digest("base64url");
+}
+function mintState(key, action, binding) {
+  const exp = Math.floor(Date.now() / 1e3) + (binding.ttlSeconds ?? 600);
+  const body = Buffer.from(JSON.stringify({ c: commitment(action, binding.args), exp })).toString("base64url");
+  const mac3 = createHmac("sha256", key).update(`${STATE_PREFIX}${body}`).digest("base64url");
+  return `${STATE_PREFIX}${body}.${mac3}`;
+}
+function verifyState(key, action, binding, state) {
+  if (typeof state !== "string" || !state.startsWith(STATE_PREFIX))
+    return false;
+  const rest = state.slice(STATE_PREFIX.length);
+  const dot = rest.indexOf(".");
+  if (dot < 0)
+    return false;
+  const body = rest.slice(0, dot);
+  const mac3 = Buffer.from(rest.slice(dot + 1), "base64url");
+  const expected = createHmac("sha256", key).update(`${STATE_PREFIX}${body}`).digest();
+  if (mac3.length !== expected.length || !timingSafeEqual(mac3, expected))
+    return false;
+  let payload;
+  try {
+    payload = JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
+  } catch {
+    return false;
+  }
+  if (typeof payload.exp !== "number" || payload.exp * 1e3 <= Date.now())
+    return false;
+  const want = Buffer.from(commitment(action, binding.args));
+  const got = Buffer.from(typeof payload.c === "string" ? payload.c : "");
+  return got.length === want.length && timingSafeEqual(got, want);
+}
+function echoedState(ctx) {
+  const accessor = ctx.mcpReq.requestState;
+  return typeof accessor === "function" ? accessor() : void 0;
+}
+function requireConfirmation(ctx, options) {
+  const requestKey = options.requestKey ?? DEFAULT_REQUEST_KEY;
+  const key = options.binding ? bindingKey(options.binding) : void 0;
+  const confirmationSchema = external_exports.object({
+    confirmed: external_exports.boolean().describe(options.confirmationLabel ?? DEFAULT_CONFIRMATION_LABEL)
+  });
+  const ask = () => {
+    const preview = {
+      action: options.action,
+      ...options.details === void 0 ? {} : { details: options.details }
+    };
+    return inputRequired({
+      inputRequests: {
+        [requestKey]: inputRequired.elicit({
+          message: `${options.message}
+${JSON.stringify(preview, null, 2)}`,
+          requestedSchema: confirmationSchema
+        })
+      },
+      ...key && options.binding ? { requestState: mintState(key, options.action, options.binding) } : {}
+    });
+  };
+  const response = inputResponse(ctx.mcpReq.inputResponses, requestKey);
+  const accepted = acceptedContent(ctx.mcpReq.inputResponses, requestKey, confirmationSchema);
+  if (response.kind === "missing") {
+    if (callerAcceptsFormElicitation(ctx) === false) {
+      return textResult({
+        confirmed: false,
+        dispatched: false,
+        action: options.action,
+        reason: "confirmation-unsupported",
+        note: options.unsupportedNote ? `${UNSUPPORTED_NOTE}. ${options.unsupportedNote}` : `${UNSUPPORTED_NOTE}.`
+      });
+    }
+    return ask();
+  }
+  if (response.kind === "elicit" && response.action === "accept" && accepted?.confirmed === true) {
+    if (key && options.binding) {
+      const state = echoedState(ctx);
+      if (state === void 0 || state === null) {
+        return errorResult(`Confirmation for ${options.action} was accepted, but the retry carried no requestState, so it cannot be checked against the prompt that was shown. Nothing was done. The likely cause is that the MCP client or host does not round-trip requestState (it must echo the requestState from the input_required result back on the retry); asking again would loop.`);
+      }
+      if (!verifyState(key, options.action, options.binding, state))
+        return ask();
+    }
+    return void 0;
+  }
+  return textResult({
+    confirmed: false,
+    cancelled: true,
+    action: options.action,
+    note: "Nothing was changed because the confirmation was declined, cancelled, or left unchecked."
+  });
+}
+
 // ../../node_modules/@chrischall/mcp-utils/dist/server/index.js
 var SERVER_PROTOCOL_VERSIONS = Object.freeze([
   "2026-07-28",
@@ -34763,9 +34974,9 @@ function offsetAt(instant, tz) {
   const w = wallPartsIn(instant, tz);
   const asUTC = Date.UTC(w.year, w.month - 1, w.day, w.hour, w.minute, w.second, instant.getUTCMilliseconds());
   const minutes = Math.round((asUTC - instant.getTime()) / 6e4);
-  const sign = minutes < 0 ? "-" : "+";
+  const sign2 = minutes < 0 ? "-" : "+";
   const abs = Math.abs(minutes);
-  return `${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
+  return `${sign2}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
 }
 function wallPartsIn(instant, tz) {
   const parts = new Intl.DateTimeFormat("en-US", {
@@ -35550,6 +35761,183 @@ function formatAuthHealth(raw, now) {
   return accounts.map((a) => formatOneAccountHealth(a, now)).join("\n\n");
 }
 
+// ../gogcli-mcp/src/send-confirm-token.ts
+import { createHash as createHash2, createHmac as createHmac2, randomBytes, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+var CONFIRM_TOKEN_TTL_DEFAULT_SECONDS = 600;
+var PREFIX = "gct1";
+var secret;
+var spent = /* @__PURE__ */ new Map();
+function sendConfirmFallbackEnabled() {
+  return readEnvVar("GOG_SEND_CONFIRM_FALLBACK")?.trim().toLowerCase() === "token";
+}
+function confirmTokenTtlSeconds() {
+  const raw = readEnvVar("GOG_CONFIRM_TTL_SECONDS")?.trim();
+  if (raw && /^\d+$/.test(raw)) {
+    const n = Number(raw);
+    if (n > 0) return n;
+  }
+  return CONFIRM_TOKEN_TTL_DEFAULT_SECONDS;
+}
+function hmacKey() {
+  if (!secret) {
+    const configured = readEnvVar("GOG_CONFIRM_SECRET");
+    secret = configured ? Buffer.from(configured, "utf8") : randomBytes(32);
+  }
+  return secret;
+}
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const key of Object.keys(value).sort()) {
+      const v = value[key];
+      if (v !== void 0) out[key] = canonicalize(v);
+    }
+    return out;
+  }
+  return value;
+}
+function hashSendPayload(payload) {
+  return createHash2("sha256").update(JSON.stringify(canonicalize(payload))).digest("hex");
+}
+function sign(body) {
+  return createHmac2("sha256", hmacKey()).update(`${PREFIX}.${body}`).digest("base64url");
+}
+function issueConfirmToken(binding, now = Date.now()) {
+  const exp = now + confirmTokenTtlSeconds() * 1e3;
+  const claims = {
+    t: binding.tool,
+    a: binding.account,
+    g: binding.target,
+    ...binding.revision === void 0 ? {} : { r: binding.revision },
+    h: binding.payloadHash,
+    iat: now,
+    exp,
+    n: randomBytes(16).toString("base64url")
+  };
+  const body = Buffer.from(JSON.stringify(claims), "utf8").toString("base64url");
+  return { token: `${PREFIX}.${body}.${sign(body)}`, expiresAt: new Date(exp).toISOString() };
+}
+function signatureMatches(body, sig) {
+  const expected = Buffer.from(sign(body), "utf8");
+  const actual = Buffer.from(sig, "utf8");
+  return expected.length === actual.length && timingSafeEqual2(expected, actual);
+}
+function parseClaims(body) {
+  try {
+    return JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function verifyConfirmToken(token, binding, now = Date.now()) {
+  for (const [nonce, exp] of spent) if (exp < now) spent.delete(nonce);
+  const parts = token.split(".");
+  if (parts.length !== 3 || parts[0] !== PREFIX || !parts[1] || !parts[2]) return { ok: false, error: "TOKEN_INVALID" };
+  const [, body, sig] = parts;
+  if (!signatureMatches(body, sig)) return { ok: false, error: "TOKEN_INVALID" };
+  const claims = parseClaims(body);
+  if (!claims) return { ok: false, error: "TOKEN_INVALID" };
+  if (claims.t !== binding.tool || claims.a !== binding.account || claims.g !== binding.target) {
+    return { ok: false, error: "TOKEN_INVALID" };
+  }
+  if (spent.has(claims.n)) return { ok: false, error: "TOKEN_REUSED" };
+  if (now > claims.exp) return { ok: false, error: "TOKEN_EXPIRED" };
+  if (claims.r !== binding.revision) return { ok: false, error: "DRAFT_CHANGED", reason: "message-id-rotated" };
+  if (claims.h !== binding.payloadHash) return { ok: false, error: "DRAFT_CHANGED", reason: "payload-changed" };
+  spent.set(claims.n, claims.exp);
+  return { ok: true };
+}
+
+// ../gogcli-mcp/src/dispatch-confirmation.ts
+var BODY_PREVIEW_MAX = 2048;
+function bodyPreview(text) {
+  if (!text) return void 0;
+  if (text.length <= BODY_PREVIEW_MAX) return text;
+  return `${text.slice(0, BODY_PREVIEW_MAX)}\u2026 [${text.length - BODY_PREVIEW_MAX} more characters not shown]`;
+}
+var CONFIRM_ACTION_INSTRUCTION = "Show this preview to the user verbatim and proceed only after they explicitly approve in chat. Then call again with confirmToken.";
+var FALLBACK_HINT = "Or set GOG_SEND_CONFIRM_FALLBACK=token to enable two-step confirmation.";
+var CONFIRM_FALLBACK_DESCRIPTION = ' If the client cannot show that prompt (no MCP elicitation, e.g. claude.ai) and the server sets GOG_SEND_CONFIRM_FALLBACK=token, a two-step flow applies instead: call WITHOUT confirmToken and nothing is sent or changed \u2014 the result has status "confirmation-required", the full preview and a confirmToken. Show that preview to the user verbatim; only after they explicitly approve it in chat, call again with the SAME arguments plus confirmToken. The tool re-reads what it would act on and refuses (DRAFT_CHANGED, with a fresh preview and token) if it changed; TOKEN_EXPIRED / TOKEN_REUSED / TOKEN_INVALID also do nothing.';
+var confirmTokenParam = external_exports.string().optional().describe(
+  `ONLY for the two-step fallback (client without MCP elicitation, server with GOG_SEND_CONFIRM_FALLBACK=token). The confirmToken from this same tool's phase-1 "confirmation-required" response, passed back ONLY after the user has seen that preview and explicitly approved it in chat \u2014 never on the first call, never invented, never reused. Call again with the same arguments. Ignored when the client supports elicitation.`
+);
+var TOKEN_ERROR_NOTE = {
+  TOKEN_EXPIRED: "Nothing was sent or changed: the confirmToken expired. Call again WITHOUT confirmToken for a fresh preview, and ask the user to approve it again.",
+  TOKEN_REUSED: "Nothing was sent or changed by this call: this confirmToken was already used, and one approval acts once. If doing it again is really intended, call again WITHOUT confirmToken and get a new approval.",
+  TOKEN_INVALID: "Nothing was sent or changed: this confirmToken was not issued by this server for this tool, account and target (or the server has restarted since). Call again WITHOUT confirmToken for a fresh preview and approval."
+};
+var DRAFT_CHANGED_NOTE = {
+  "message-id-rotated": "Nothing was sent or changed: the target was edited since the user approved it (a draft's messageId or an event's version rotated), so what would happen is not what they saw.",
+  "payload-changed": "Nothing was sent or changed: what would happen no longer matches what the user approved."
+};
+function isToolResult(value) {
+  return Array.isArray(value.content);
+}
+function rejection2(data) {
+  return { ...textResult({ status: "confirmation-rejected", confirmed: false, dispatched: false, ...data }), isError: true };
+}
+async function tokenConfirmation(op, fallback) {
+  const subject = await fallback.subject();
+  if (isToolResult(subject)) return subject;
+  const binding = {
+    tool: fallback.tool,
+    account: fallback.account ?? readEnvVar("GOG_ACCOUNT") ?? "",
+    target: subject.target,
+    ...subject.revision === void 0 ? {} : { revision: subject.revision },
+    payloadHash: hashSendPayload(subject.payload)
+  };
+  const phaseOne = () => {
+    const { token, expiresAt } = issueConfirmToken(binding);
+    return {
+      action: op,
+      preview: subject.preview,
+      confirmToken: token,
+      expiresAt,
+      ttlSeconds: confirmTokenTtlSeconds(),
+      instruction: fallback.instruction ?? CONFIRM_ACTION_INSTRUCTION
+    };
+  };
+  if (!fallback.confirmToken) {
+    return textResult({ status: "confirmation-required", confirmed: false, dispatched: false, ...phaseOne() });
+  }
+  const verdict = verifyConfirmToken(fallback.confirmToken, binding);
+  if (verdict.ok) return void 0;
+  if (verdict.error === "DRAFT_CHANGED") {
+    return rejection2({
+      error: "DRAFT_CHANGED",
+      reason: verdict.reason,
+      note: `${DRAFT_CHANGED_NOTE[verdict.reason]} The current preview and a fresh confirmToken are below.`,
+      ...phaseOne()
+    });
+  }
+  return rejection2({ error: verdict.error, action: op, note: TOKEN_ERROR_NOTE[verdict.error] });
+}
+function gatedElsewhere(what, via, does, tool) {
+  return `${what} ${does} and is not available through ${via}. Use ${tool}, which asks the user to confirm.`;
+}
+function hasCommandWord(args, words) {
+  return args.find((a) => words.has(a.toLowerCase()));
+}
+async function requireDispatchConfirmation(ctx, options) {
+  const { action, fallback } = options;
+  if (fallback && callerAcceptsFormElicitation(ctx) === false && sendConfirmFallbackEnabled()) {
+    return tokenConfirmation(action, fallback);
+  }
+  const note = fallback ? [options.unsupportedNote, FALLBACK_HINT].filter(Boolean).join(" ") : options.unsupportedNote;
+  return requireConfirmation(ctx, {
+    action,
+    message: options.message,
+    details: options.details,
+    confirmationLabel: options.confirmationLabel,
+    ...note ? { unsupportedNote: note } : {}
+  });
+}
+function resultText(result) {
+  const first = result.content[0];
+  return first && first.type === "text" && typeof first.text === "string" ? first.text : "{}";
+}
+
 // ../gogcli-mcp/src/tools/auth.ts
 var AUTH_RUN_SUBCOMMANDS = ["list", "status", "services", "remove", "alias"];
 function registerAuthToolsWith(server, defaultServices) {
@@ -35715,6 +36103,39 @@ var attachInlineParam = external_exports.array(inlineAttachmentSchema).optional(
 );
 
 // ../gogcli-mcp/src/tools/classroom.ts
+var CLASSROOM_CREATE_WORDS = /* @__PURE__ */ new Set(["create", "add", "new"]);
+var CLASSROOM_GATED = {
+  announcements: { does: "posts to a class", tool: "gog_classroom_announcements_create" },
+  announcement: { does: "posts to a class", tool: "gog_classroom_announcements_create" },
+  ann: { does: "posts to a class", tool: "gog_classroom_announcements_create" },
+  invitations: { does: "invites someone to a class", tool: "gog_classroom_invitations_create" },
+  invitation: { does: "invites someone to a class", tool: "gog_classroom_invitations_create" },
+  invites: { does: "invites someone to a class", tool: "gog_classroom_invitations_create" }
+};
+function vetClassroomRun(subcommand, args) {
+  const sub = subcommand.toLowerCase();
+  const gated = Object.hasOwn(CLASSROOM_GATED, sub) ? CLASSROOM_GATED[sub] : void 0;
+  if (!gated) return void 0;
+  const word = hasCommandWord(args, CLASSROOM_CREATE_WORDS);
+  return word ? gatedElsewhere(`gog classroom ${sub} ${word.toLowerCase()}`, "gog_classroom_run", gated.does, gated.tool) : void 0;
+}
+async function readCourse(courseId, account, runner = runOrDiagnose) {
+  const got = await runner(["classroom", "courses", "get", pos(courseId)], { account });
+  if (got.isError) return { error: got };
+  let course;
+  try {
+    course = JSON.parse(resultText(got))?.course;
+  } catch {
+    course = void 0;
+  }
+  return {
+    course: {
+      id: courseId,
+      ...typeof course?.name === "string" ? { name: course.name } : {},
+      ...typeof course?.section === "string" ? { section: course.section } : {}
+    }
+  };
+}
 function registerClassroomTools(server) {
   server.registerTool("gog_classroom_courses_list", {
     description: "List Google Classroom courses.",
@@ -35997,19 +36418,42 @@ function registerClassroomTools(server) {
     return runOrDiagnose(["classroom", "announcements", "get", pos(courseId), pos(announcementId)], { account });
   });
   server.registerTool("gog_classroom_announcements_create", {
-    description: "Create an announcement in a Google Classroom course.",
+    description: "Create an announcement in a Google Classroom course. Unless state is DRAFT (which students cannot see), this reads the course and asks the MCP host to show the user a confirmation prompt with the class, the full text and when it publishes; nothing is posted unless they accept. To stage one without asking, pass state DRAFT." + CONFIRM_FALLBACK_DESCRIPTION,
     annotations: { destructiveHint: true },
     inputSchema: external_exports.object({
       courseId: external_exports.string().describe("Course ID"),
       text: external_exports.string().describe("Announcement text"),
-      state: external_exports.enum(["PUBLISHED", "DRAFT"]).optional().describe("State"),
+      state: external_exports.enum(["PUBLISHED", "DRAFT"]).optional().describe("State (DRAFT is visible only to teachers and needs no confirmation)"),
       scheduled: external_exports.string().optional().describe("Scheduled publish time"),
-      account: accountParam
+      account: accountParam,
+      confirmToken: confirmTokenParam
     })
-  }, async ({ courseId, text, state, scheduled, account }) => {
+  }, async ({ courseId, text, state, scheduled, account, confirmToken }, ctx) => {
     const args = ["classroom", "announcements", "create", pos(courseId), `--text=${text}`];
     if (state) args.push(`--state=${state}`);
     if (scheduled) args.push(`--scheduled=${scheduled}`);
+    if (state !== "DRAFT") {
+      const read = await readCourse(courseId, account);
+      if (read.error) return read.error;
+      const publishes = scheduled ? `at ${scheduled}` : "immediately";
+      const confirmation = await requireDispatchConfirmation(ctx, {
+        action: "classroom.announcement-create",
+        message: "Review and confirm this Classroom announcement:",
+        confirmationLabel: "Confirm that this announcement should be posted to the class.",
+        details: { course: read.course, publishes, textPreview: bodyPreview(text) },
+        unsupportedNote: "Create it with state DRAFT instead; the user can review and post it from Classroom.",
+        fallback: {
+          tool: "gog_classroom_announcements_create",
+          account,
+          confirmToken,
+          subject: () => {
+            const view = { course: read.course, publishes, text };
+            return { target: courseId, payload: view, preview: view };
+          }
+        }
+      });
+      if (confirmation) return confirmation;
+    }
     return runOrDiagnose(args, { account });
   });
   server.registerTool("gog_classroom_topics_list", {
@@ -36099,6 +36543,7 @@ function registerClassroomTools(server) {
   registerRunTool(server, {
     service: "classroom",
     examples: '"guardians", "materials", "guardian-invitations"',
+    vet: vetClassroomRun,
     note: "Covers anything not wrapped by the dedicated tools (guardians, guardian-invitations, materials, coursework assignees, announcement assignees, etc.)."
   });
 }
@@ -36124,7 +36569,7 @@ var replySchema = {
   signatureFile: external_exports.string().optional().describe("Append a local signature file (plain text or HTML), read on the gog server"),
   account: accountParam
 };
-var sendReplySchema = external_exports.object(replySchema);
+var sendReplySchema = external_exports.object({ ...replySchema, confirmToken: confirmTokenParam });
 
 // ../gogcli-mcp/src/tools/sheets.ts
 var cellValueParam = external_exports.union([external_exports.string(), external_exports.number(), external_exports.boolean(), external_exports.null()]);
@@ -36136,7 +36581,7 @@ var failIfNotEmptyParam = external_exports.boolean().optional().describe(
 );
 
 // ../gogcli-mcp/src/server.ts
-var VERSION = true ? "4.3.0" : "0.0.0";
+var VERSION = true ? "4.4.0" : "0.0.0";
 
 // ../gogcli-mcp/src/bootstrap-auth.ts
 import { join as join5 } from "node:path";
@@ -36173,12 +36618,12 @@ async function bootstrapGogAuth(env = process.env, options = {}) {
   const [clientId, clientSecret, refreshToken, account] = values;
   const { spawner } = options;
   try {
-    const { createHash } = await import("node:crypto");
+    const { createHash: createHash3 } = await import("node:crypto");
     const { mkdir, readFile, writeFile, chmod } = await import("node:fs/promises");
     const home = options.home ?? (await import("node:os")).homedir();
     const dir = join5(home, ".gogcli-mcp");
     const marker = join5(dir, AUTH_BOOTSTRAP_MARKER);
-    const fingerprint = createHash("sha256").update(values.join("\0")).digest("hex");
+    const fingerprint = createHash3("sha256").update(values.join("\0")).digest("hex");
     const previous = await readFile(marker, "utf8").catch(() => void 0);
     if (previous === fingerprint && await accountListed(account, spawner)) return "present";
     await run(
@@ -36470,15 +36915,33 @@ function registerExtraClassroomTools(server) {
     return runOrDiagnose(["classroom", "topics", "delete", pos(courseId), pos(topicId), "--force"], { account });
   });
   server.registerTool("gog_classroom_invitations_create", {
-    description: "Create an invitation to a Google Classroom course.",
+    description: "Create an invitation to a Google Classroom course \u2014 Classroom emails the invitee. Reads the course and asks the MCP host to show the user a confirmation prompt with the class, the invitee and the role; nothing is sent unless they accept." + CONFIRM_FALLBACK_DESCRIPTION,
     annotations: { destructiveHint: true },
     inputSchema: external_exports.object({
       courseId: external_exports.string().describe("Course ID"),
       userId: external_exports.string().describe("User ID to invite"),
       role: external_exports.enum(["STUDENT", "TEACHER", "OWNER"]).describe("Role for the invited user"),
-      account: accountParam
+      account: accountParam,
+      confirmToken: confirmTokenParam
     })
-  }, async ({ courseId, userId, role, account }) => {
+  }, async ({ courseId, userId, role, account, confirmToken }, ctx) => {
+    const read = await readCourse(courseId, account, runOrDiagnose);
+    if (read.error) return read.error;
+    const invitation = { course: read.course, invitee: userId, role };
+    const confirmation = await requireDispatchConfirmation(ctx, {
+      action: "classroom.invitation-create",
+      message: role === "OWNER" ? "Review and confirm this Classroom invitation \u2014 it offers OWNERSHIP of the course:" : "Review and confirm this Classroom invitation:",
+      confirmationLabel: "Confirm that this invitation should be sent now.",
+      details: invitation,
+      unsupportedNote: "Ask the user to invite them from Classroom.",
+      fallback: {
+        tool: "gog_classroom_invitations_create",
+        account,
+        confirmToken,
+        subject: () => ({ target: `${courseId}/${userId}`, payload: invitation, preview: invitation })
+      }
+    });
+    if (confirmation) return confirmation;
     return runOrDiagnose(["classroom", "invitations", "create", pos(courseId), pos(userId), `--role=${role}`], { account });
   });
   server.registerTool("gog_classroom_invitations_delete", {

package/manifest.json

@@ -3,7 +3,7 @@
   "manifest_version": "0.3",
   "name": "gogcli-mcp-classroom",
   "display_name": "gogcli (Classroom)",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "description": "Extended Google Classroom for Claude via gogcli — auth + full Classroom support (courses, rosters, coursework, submissions, announcements, topics, invitations)",
   "author": {
     "name": "Chris Hall",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gogcli-mcp-classroom",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "mcpName": "io.github.chrischall/gogcli-mcp-classroom",
   "description": "Extended Google Classroom MCP server via gogcli — auth + full Classroom support",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",

package/server.json

@@ -7,12 +7,12 @@
     "source": "github",
     "subfolder": "packages/gogcli-mcp-classroom"
   },
-  "version": "4.3.0",
+  "version": "4.4.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "gogcli-mcp-classroom",
-      "version": "4.3.0",
+      "version": "4.4.0",
       "transport": {
         "type": "stdio"
       },

package/src/tools/classroom-extra.ts

@@ -1,6 +1,6 @@
 import { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
-import { accountParam, runOrDiagnose, pos } from '../../../gogcli-mcp/src/lib.js';
+import { accountParam, runOrDiagnose, pos, readCourse, requireDispatchConfirmation, CONFIRM_FALLBACK_DESCRIPTION, confirmTokenParam } from '../../../gogcli-mcp/src/lib.js';
 import type { GogArg } from '../../../gogcli-mcp/src/lib.js';
 
 const courseState = z.enum(['ACTIVE', 'ARCHIVED', 'PROVISIONED', 'DECLINED', 'SUSPENDED']);
@@ -286,15 +286,37 @@ export function registerExtraClassroomTools(server: McpServer): void {
   });
 
   server.registerTool('gog_classroom_invitations_create', {
-    description: 'Create an invitation to a Google Classroom course.',
+    description: 'Create an invitation to a Google Classroom course — Classroom emails the invitee. Reads the course '
+      + 'and asks the MCP host to show the user a confirmation prompt with the class, the invitee and the role; '
+      + 'nothing is sent unless they accept.' + CONFIRM_FALLBACK_DESCRIPTION,
     annotations: { destructiveHint: true },
     inputSchema: z.object({
       courseId: z.string().describe('Course ID'),
       userId: z.string().describe('User ID to invite'),
       role: z.enum(['STUDENT', 'TEACHER', 'OWNER']).describe('Role for the invited user'),
       account: accountParam,
+      confirmToken: confirmTokenParam,
     }),
-  }, async ({ courseId, userId, role, account }) => {
+  }, async ({ courseId, userId, role, account, confirmToken }, ctx) => {
+    const read = await readCourse(courseId, account, runOrDiagnose);
+    if (read.error) return read.error;
+    const invitation = { course: read.course, invitee: userId, role };
+    const confirmation = await requireDispatchConfirmation(ctx, {
+      action: 'classroom.invitation-create',
+      message: role === 'OWNER'
+        ? 'Review and confirm this Classroom invitation — it offers OWNERSHIP of the course:'
+        : 'Review and confirm this Classroom invitation:',
+      confirmationLabel: 'Confirm that this invitation should be sent now.',
+      details: invitation,
+      unsupportedNote: 'Ask the user to invite them from Classroom.',
+      fallback: {
+        tool: 'gog_classroom_invitations_create',
+        account,
+        confirmToken,
+        subject: () => ({ target: `${courseId}/${userId}`, payload: invitation, preview: invitation }),
+      },
+    });
+    if (confirmation) return confirmation;
     return runOrDiagnose(['classroom', 'invitations', 'create', pos(courseId), pos(userId), `--role=${role}`], { account });
   });
 

package/tests/tools/classroom-extra.test.ts

@@ -18,7 +18,9 @@ let harness: TestHarness;
 beforeEach(async () => {
   vi.clearAllMocks();
   vi.mocked(lib.runOrDiagnose).mockResolvedValue(rawTextResult('{}'));
-  harness = await createTestHarness(registerExtraClassroomTools);
+  harness = await createTestHarness(registerExtraClassroomTools, {
+    elicitation: async () => ({ action: 'accept', content: { confirmed: true } }),
+  });
 });
 
 describe('gog_classroom_courses_create', () => {
@@ -249,6 +251,55 @@ describe('gog_classroom_topics_delete', () => {
 });
 
 describe('gog_classroom_invitations_create', () => {
+  const COURSE = rawTextResult(JSON.stringify({ course: { id: 'c1', name: 'Algebra II' } }));
+
+  it('reads the course and prompts with the class, invitee and role', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(COURSE);
+    let message = '';
+    const h = await createTestHarness(registerExtraClassroomTools, {
+      elicitation: async (r) => { message = r.params.message; return { action: 'decline' }; },
+    });
+    await h.callTool('gog_classroom_invitations_create', { courseId: 'c1', userId: 'kid@example.com', role: 'OWNER' });
+    expect(message).toMatch(/OWNERSHIP/);
+    expect(JSON.parse(message.split('\n').slice(1).join('\n')).details)
+      .toEqual({ course: { id: 'c1', name: 'Algebra II' }, invitee: 'kid@example.com', role: 'OWNER' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['classroom', 'courses', 'get', pos('c1')], { account: undefined });
+    expect(lib.runOrDiagnose).not.toHaveBeenCalledWith(
+      ['classroom', 'invitations', 'create', pos('c1'), pos('kid@example.com'), '--role=OWNER'], { account: undefined });
+  });
+
+  it('refuses a client that cannot be prompted', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(COURSE);
+    const h = await createTestHarness(registerExtraClassroomTools);
+    const r = JSON.parse((await h.callTool('gog_classroom_invitations_create', { courseId: 'c1', userId: 'u1', role: 'STUDENT' })).content[0]!.text as string);
+    expect(r).toMatchObject({ reason: 'confirmation-unsupported', action: 'classroom.invitation-create' });
+    expect(r.note).toMatch(/invite them from Classroom/);
+  });
+
+  it('token fallback: phase 1 previews, phase 2 invites', async () => {
+    const ORIGINAL = { ...process.env };
+    process.env.GOG_SEND_CONFIRM_FALLBACK = 'token';
+    try {
+      vi.mocked(lib.runOrDiagnose).mockResolvedValue(COURSE);
+      const h = await createTestHarness(registerExtraClassroomTools);
+      const args = { courseId: 'c1', userId: 'u1', role: 'STUDENT' as const };
+      const p1 = JSON.parse((await h.callTool('gog_classroom_invitations_create', args)).content[0]!.text as string);
+      expect(p1.preview).toEqual({ course: { id: 'c1', name: 'Algebra II' }, invitee: 'u1', role: 'STUDENT' });
+      await h.callTool('gog_classroom_invitations_create', { ...args, confirmToken: p1.confirmToken });
+      expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+        ['classroom', 'invitations', 'create', pos('c1'), pos('u1'), '--role=STUDENT'], { account: undefined });
+    } finally {
+      process.env = ORIGINAL;
+    }
+  });
+
+  it('returns a failed course read without inviting', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue({ content: [{ type: 'text', text: 'Error: not found' }], isError: true });
+    const r = await harness.callTool('gog_classroom_invitations_create', { courseId: 'c1', userId: 'u1', role: 'STUDENT' });
+    expect(r.isError).toBe(true);
+    expect(lib.runOrDiagnose).toHaveBeenCalledTimes(1);
+  });
+
   it('calls runOrDiagnose with courseId, userId, role', async () => {
     await harness.callTool('gog_classroom_invitations_create', { courseId: 'c1', userId: 'u1', role: 'STUDENT' });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(