gogcli-mcp-classroom 2.0.3 → 2.0.6

package/manifest.json

@@ -3,7 +3,7 @@
   "manifest_version": "0.3",
   "name": "gogcli-mcp-classroom",
   "display_name": "gogcli (Classroom)",
-  "version": "2.0.3",
+  "version": "2.0.6",
   "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": "2.0.3",
+  "version": "2.0.6",
   "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>",
@@ -25,7 +25,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "zod": "^4.4.2"
+    "zod": "^4.4.3"
   },
   "license": "MIT",
   "keywords": [

package/server.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.chrischall/gogcli-mcp-classroom",
-  "description": "Google Classroom via gogcli for Claude — courses, assignments, submissions, grading",
+  "description": "Google Classroom via gogcli for Claude \u2014 courses, assignments, submissions, grading",
   "repository": {
     "url": "https://github.com/chrischall/gogcli-mcp",
     "source": "github",

package/src/tools/classroom-extra.ts

@@ -1,5 +1,303 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { accountParam, runOrDiagnose } from '../../../gogcli-mcp/src/lib.js';
 
-export function registerExtraClassroomTools(_server: McpServer): void {
-  /* no extras yet */
+const courseState = z.enum(['ACTIVE', 'ARCHIVED', 'PROVISIONED', 'DECLINED', 'SUSPENDED']);
+const workState = z.enum(['PUBLISHED', 'DRAFT']);
+const workType = z.enum(['ASSIGNMENT', 'SHORT_ANSWER_QUESTION', 'MULTIPLE_CHOICE_QUESTION']);
+
+// Fields shared by courses_create and courses_update. `name` is required on
+// create, optional on update — keep it out of this fragment so each tool can
+// declare its own rule.
+const courseSharedFields = {
+  owner: z.string().optional().describe('Owner user ID (default "me" on create)'),
+  section: z.string().optional().describe('Section'),
+  descriptionHeading: z.string().optional().describe('Description heading'),
+  description: z.string().optional().describe('Description'),
+  room: z.string().optional().describe('Room'),
+  state: courseState.optional().describe('Course state'),
+};
+
+// Fields shared by coursework_create and coursework_update.
+const courseworkSharedFields = {
+  description: z.string().optional().describe('Description'),
+  type: workType.optional().describe('Work type (default: ASSIGNMENT)'),
+  state: workState.optional().describe('State'),
+  maxPoints: z.number().optional().describe('Max points'),
+  due: z.string().optional().describe('Due datetime (combined date+time)'),
+  dueDate: z.string().optional().describe('Due date (YYYY-MM-DD)'),
+  dueTime: z.string().optional().describe('Due time (HH:MM)'),
+  scheduled: z.string().optional().describe('Scheduled publish time'),
+  topic: z.string().optional().describe('Topic ID'),
+};
+
+export function registerExtraClassroomTools(server: McpServer): void {
+  server.registerTool('gog_classroom_courses_create', {
+    description: 'Create a new Google Classroom course.',
+    inputSchema: {
+      name: z.string().describe('Course name'),
+      ...courseSharedFields,
+      account: accountParam,
+    },
+  }, async ({ name, owner, section, descriptionHeading, description, room, state, account }) => {
+    const args = ['classroom', 'courses', 'create', `--name=${name}`];
+    if (owner) args.push(`--owner=${owner}`);
+    if (section) args.push(`--section=${section}`);
+    if (descriptionHeading) args.push(`--description-heading=${descriptionHeading}`);
+    if (description) args.push(`--description=${description}`);
+    if (room) args.push(`--room=${room}`);
+    if (state) args.push(`--state=${state}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_classroom_courses_update', {
+    description: 'Update an existing Google Classroom course.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      courseId: z.string().describe('Course ID'),
+      name: z.string().optional().describe('Course name'),
+      ...courseSharedFields,
+      account: accountParam,
+    },
+  }, async ({ courseId, name, owner, section, descriptionHeading, description, room, state, account }) => {
+    const args = ['classroom', 'courses', 'update', courseId];
+    if (name) args.push(`--name=${name}`);
+    if (owner) args.push(`--owner=${owner}`);
+    if (section) args.push(`--section=${section}`);
+    if (descriptionHeading) args.push(`--description-heading=${descriptionHeading}`);
+    if (description) args.push(`--description=${description}`);
+    if (room) args.push(`--room=${room}`);
+    if (state) args.push(`--state=${state}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_classroom_courses_delete', {
+    description: 'Delete a Google Classroom course.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      courseId: z.string().describe('Course ID'),
+      account: accountParam,
+    },
+  }, async ({ courseId, account }) => {
+    return runOrDiagnose(['classroom', 'courses', 'delete', courseId], { account });
+  });
+
+  server.registerTool('gog_classroom_courses_archive', {
+    description: 'Archive a Google Classroom course.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      courseId: z.string().describe('Course ID'),
+      account: accountParam,
+    },
+  }, async ({ courseId, account }) => {
+    return runOrDiagnose(['classroom', 'courses', 'archive', courseId], { account });
+  });
+
+  server.registerTool('gog_classroom_courses_unarchive', {
+    description: 'Unarchive a Google Classroom course (restore to ACTIVE).',
+    inputSchema: {
+      courseId: z.string().describe('Course ID'),
+      account: accountParam,
+    },
+  }, async ({ courseId, account }) => {
+    return runOrDiagnose(['classroom', 'courses', 'unarchive', courseId], { account });
+  });
+
+  server.registerTool('gog_classroom_students_add', {
+    description: 'Add a student to a Google Classroom course.',
+    inputSchema: {
+      courseId: z.string().describe('Course ID'),
+      userId: z.string().describe('Student user ID (or "me")'),
+      enrollmentCode: z.string().optional().describe('Enrollment code (required if adding self via code)'),
+      account: accountParam,
+    },
+  }, async ({ courseId, userId, enrollmentCode, account }) => {
+    const args = ['classroom', 'students', 'add', courseId, userId];
+    if (enrollmentCode) args.push(`--enrollment-code=${enrollmentCode}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_classroom_students_remove', {
+    description: 'Remove a student from a Google Classroom course.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      courseId: z.string().describe('Course ID'),
+      userId: z.string().describe('Student user ID'),
+      account: accountParam,
+    },
+  }, async ({ courseId, userId, account }) => {
+    return runOrDiagnose(['classroom', 'students', 'remove', courseId, userId], { account });
+  });
+
+  server.registerTool('gog_classroom_teachers_add', {
+    description: 'Add a teacher to a Google Classroom course.',
+    inputSchema: {
+      courseId: z.string().describe('Course ID'),
+      userId: z.string().describe('Teacher user ID'),
+      account: accountParam,
+    },
+  }, async ({ courseId, userId, account }) => {
+    return runOrDiagnose(['classroom', 'teachers', 'add', courseId, userId], { account });
+  });
+
+  server.registerTool('gog_classroom_teachers_remove', {
+    description: 'Remove a teacher from a Google Classroom course.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      courseId: z.string().describe('Course ID'),
+      userId: z.string().describe('Teacher user ID'),
+      account: accountParam,
+    },
+  }, async ({ courseId, userId, account }) => {
+    return runOrDiagnose(['classroom', 'teachers', 'remove', courseId, userId], { account });
+  });
+
+  server.registerTool('gog_classroom_coursework_create', {
+    description: 'Create a new coursework item (assignment, question, etc.) in a course.',
+    inputSchema: {
+      courseId: z.string().describe('Course ID'),
+      title: z.string().describe('Coursework title'),
+      ...courseworkSharedFields,
+      account: accountParam,
+    },
+  }, async ({ courseId, title, description, type, state, maxPoints, due, dueDate, dueTime, scheduled, topic, account }) => {
+    const args = ['classroom', 'coursework', 'create', courseId, `--title=${title}`];
+    if (description) args.push(`--description=${description}`);
+    if (type) args.push(`--type=${type}`);
+    if (state) args.push(`--state=${state}`);
+    if (maxPoints !== undefined) args.push(`--max-points=${maxPoints}`);
+    if (due) args.push(`--due=${due}`);
+    if (dueDate) args.push(`--due-date=${dueDate}`);
+    if (dueTime) args.push(`--due-time=${dueTime}`);
+    if (scheduled) args.push(`--scheduled=${scheduled}`);
+    if (topic) args.push(`--topic=${topic}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_classroom_coursework_update', {
+    description: 'Update an existing coursework item.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      courseId: z.string().describe('Course ID'),
+      courseworkId: z.string().describe('Coursework ID'),
+      title: z.string().optional().describe('New title'),
+      ...courseworkSharedFields,
+      account: accountParam,
+    },
+  }, async ({ courseId, courseworkId, title, description, type, state, maxPoints, due, dueDate, dueTime, scheduled, topic, account }) => {
+    const args = ['classroom', 'coursework', 'update', courseId, courseworkId];
+    if (title) args.push(`--title=${title}`);
+    if (description) args.push(`--description=${description}`);
+    if (type) args.push(`--type=${type}`);
+    if (state) args.push(`--state=${state}`);
+    if (maxPoints !== undefined) args.push(`--max-points=${maxPoints}`);
+    if (due) args.push(`--due=${due}`);
+    if (dueDate) args.push(`--due-date=${dueDate}`);
+    if (dueTime) args.push(`--due-time=${dueTime}`);
+    if (scheduled) args.push(`--scheduled=${scheduled}`);
+    if (topic) args.push(`--topic=${topic}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_classroom_coursework_delete', {
+    description: 'Delete a coursework item.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      courseId: z.string().describe('Course ID'),
+      courseworkId: z.string().describe('Coursework ID'),
+      account: accountParam,
+    },
+  }, async ({ courseId, courseworkId, account }) => {
+    return runOrDiagnose(['classroom', 'coursework', 'delete', courseId, courseworkId], { account });
+  });
+
+  server.registerTool('gog_classroom_announcements_update', {
+    description: 'Update an existing announcement.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      courseId: z.string().describe('Course ID'),
+      announcementId: z.string().describe('Announcement ID'),
+      text: z.string().optional().describe('New text'),
+      state: workState.optional().describe('State'),
+      scheduled: z.string().optional().describe('Scheduled publish time'),
+      account: accountParam,
+    },
+  }, async ({ courseId, announcementId, text, state, scheduled, account }) => {
+    const args = ['classroom', 'announcements', 'update', courseId, announcementId];
+    if (text) args.push(`--text=${text}`);
+    if (state) args.push(`--state=${state}`);
+    if (scheduled) args.push(`--scheduled=${scheduled}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_classroom_announcements_delete', {
+    description: 'Delete an announcement.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      courseId: z.string().describe('Course ID'),
+      announcementId: z.string().describe('Announcement ID'),
+      account: accountParam,
+    },
+  }, async ({ courseId, announcementId, account }) => {
+    return runOrDiagnose(['classroom', 'announcements', 'delete', courseId, announcementId], { account });
+  });
+
+  server.registerTool('gog_classroom_topics_create', {
+    description: 'Create a topic in a Google Classroom course.',
+    inputSchema: {
+      courseId: z.string().describe('Course ID'),
+      name: z.string().describe('Topic name'),
+      account: accountParam,
+    },
+  }, async ({ courseId, name, account }) => {
+    return runOrDiagnose(['classroom', 'topics', 'create', courseId, `--name=${name}`], { account });
+  });
+
+  server.registerTool('gog_classroom_topics_update', {
+    description: 'Rename an existing topic.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      courseId: z.string().describe('Course ID'),
+      topicId: z.string().describe('Topic ID'),
+      name: z.string().describe('New topic name'),
+      account: accountParam,
+    },
+  }, async ({ courseId, topicId, name, account }) => {
+    return runOrDiagnose(['classroom', 'topics', 'update', courseId, topicId, `--name=${name}`], { account });
+  });
+
+  server.registerTool('gog_classroom_topics_delete', {
+    description: 'Delete a topic.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      courseId: z.string().describe('Course ID'),
+      topicId: z.string().describe('Topic ID'),
+      account: accountParam,
+    },
+  }, async ({ courseId, topicId, account }) => {
+    return runOrDiagnose(['classroom', 'topics', 'delete', courseId, topicId], { account });
+  });
+
+  server.registerTool('gog_classroom_invitations_create', {
+    description: 'Create an invitation to a Google Classroom course.',
+    inputSchema: {
+      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,
+    },
+  }, async ({ courseId, userId, role, account }) => {
+    return runOrDiagnose(['classroom', 'invitations', 'create', courseId, userId, `--role=${role}`], { account });
+  });
+
+  server.registerTool('gog_classroom_invitations_delete', {
+    description: 'Delete (revoke) a Google Classroom invitation.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      invitationId: z.string().describe('Invitation ID'),
+      account: accountParam,
+    },
+  }, async ({ invitationId, account }) => {
+    return runOrDiagnose(['classroom', 'invitations', 'delete', invitationId], { account });
+  });
 }

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

@@ -1,12 +1,264 @@
-import { describe, it, expect, vi } from 'vitest';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { registerExtraClassroomTools } from '../../src/tools/classroom-extra.js';
+import * as lib from '../../../gogcli-mcp/src/lib.js';
+import { setupExtrasHandlers, toText, type ToolHandler } from '../../../gogcli-mcp/tests/helpers/extras-harness.js';
 
-describe('registerExtraClassroomTools', () => {
-  it('registers no tools (no extras yet)', () => {
-    const server = new McpServer({ name: 'test', version: '0.0.0' });
-    const spy = vi.spyOn(server, 'registerTool');
-    registerExtraClassroomTools(server);
-    expect(spy).not.toHaveBeenCalled();
+vi.mock('../../../gogcli-mcp/src/lib.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof lib>();
+  return {
+    ...actual,
+    runOrDiagnose: vi.fn(),
+  };
+});
+
+let handlers: Map<string, ToolHandler>;
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+  handlers = setupExtrasHandlers(registerExtraClassroomTools);
+});
+
+describe('gog_classroom_courses_create', () => {
+  it('calls runOrDiagnose with required name only', async () => {
+    await handlers.get('gog_classroom_courses_create')!({ name: 'Math 101' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['classroom', 'courses', 'create', '--name=Math 101'],
+      { account: undefined },
+    );
+  });
+
+  it('passes all optional flags', async () => {
+    await handlers.get('gog_classroom_courses_create')!({
+      name: 'Math 101',
+      owner: 'me',
+      section: 'Section A',
+      descriptionHeading: 'Welcome',
+      description: 'Algebra',
+      room: 'R101',
+      state: 'ACTIVE',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['classroom', 'courses', 'create', '--name=Math 101', '--owner=me', '--section=Section A', '--description-heading=Welcome', '--description=Algebra', '--room=R101', '--state=ACTIVE'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_classroom_courses_update', () => {
+  it('calls runOrDiagnose with courseId only', async () => {
+    await handlers.get('gog_classroom_courses_update')!({ courseId: 'c1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['classroom', 'courses', 'update', 'c1'], { account: undefined });
+  });
+
+  it('passes all optional flags', async () => {
+    await handlers.get('gog_classroom_courses_update')!({
+      courseId: 'c1',
+      name: 'New Name',
+      owner: 'me',
+      section: 'B',
+      descriptionHeading: 'Heading',
+      description: 'Desc',
+      room: 'R2',
+      state: 'ARCHIVED',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['classroom', 'courses', 'update', 'c1', '--name=New Name', '--owner=me', '--section=B', '--description-heading=Heading', '--description=Desc', '--room=R2', '--state=ARCHIVED'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_classroom_courses_delete', () => {
+  it('calls runOrDiagnose with courseId', async () => {
+    await handlers.get('gog_classroom_courses_delete')!({ courseId: 'c1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['classroom', 'courses', 'delete', 'c1'], { account: undefined });
+  });
+});
+
+describe('gog_classroom_courses_archive', () => {
+  it('calls runOrDiagnose with courseId', async () => {
+    await handlers.get('gog_classroom_courses_archive')!({ courseId: 'c1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['classroom', 'courses', 'archive', 'c1'], { account: undefined });
+  });
+});
+
+describe('gog_classroom_courses_unarchive', () => {
+  it('calls runOrDiagnose with courseId', async () => {
+    await handlers.get('gog_classroom_courses_unarchive')!({ courseId: 'c1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['classroom', 'courses', 'unarchive', 'c1'], { account: undefined });
+  });
+});
+
+describe('gog_classroom_students_add', () => {
+  it('calls runOrDiagnose with courseId and userId', async () => {
+    await handlers.get('gog_classroom_students_add')!({ courseId: 'c1', userId: 'u1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['classroom', 'students', 'add', 'c1', 'u1'], { account: undefined });
+  });
+
+  it('passes --enrollment-code when provided', async () => {
+    await handlers.get('gog_classroom_students_add')!({ courseId: 'c1', userId: 'u1', enrollmentCode: 'abc123' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['classroom', 'students', 'add', 'c1', 'u1', '--enrollment-code=abc123'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_classroom_students_remove', () => {
+  it('calls runOrDiagnose with courseId and userId', async () => {
+    await handlers.get('gog_classroom_students_remove')!({ courseId: 'c1', userId: 'u1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['classroom', 'students', 'remove', 'c1', 'u1'], { account: undefined });
+  });
+});
+
+describe('gog_classroom_teachers_add', () => {
+  it('calls runOrDiagnose with courseId and userId', async () => {
+    await handlers.get('gog_classroom_teachers_add')!({ courseId: 'c1', userId: 'u1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['classroom', 'teachers', 'add', 'c1', 'u1'], { account: undefined });
+  });
+});
+
+describe('gog_classroom_teachers_remove', () => {
+  it('calls runOrDiagnose with courseId and userId', async () => {
+    await handlers.get('gog_classroom_teachers_remove')!({ courseId: 'c1', userId: 'u1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['classroom', 'teachers', 'remove', 'c1', 'u1'], { account: undefined });
+  });
+});
+
+describe('gog_classroom_coursework_create', () => {
+  it('calls runOrDiagnose with required title only', async () => {
+    await handlers.get('gog_classroom_coursework_create')!({ courseId: 'c1', title: 'HW1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['classroom', 'coursework', 'create', 'c1', '--title=HW1'],
+      { account: undefined },
+    );
+  });
+
+  it('passes all optional flags', async () => {
+    await handlers.get('gog_classroom_coursework_create')!({
+      courseId: 'c1',
+      title: 'HW1',
+      description: 'Chapter 1',
+      type: 'ASSIGNMENT',
+      state: 'PUBLISHED',
+      maxPoints: 100,
+      due: '2026-05-01T23:59',
+      dueDate: '2026-05-01',
+      dueTime: '23:59',
+      scheduled: '2026-04-30T12:00',
+      topic: 't1',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['classroom', 'coursework', 'create', 'c1', '--title=HW1', '--description=Chapter 1', '--type=ASSIGNMENT', '--state=PUBLISHED', '--max-points=100', '--due=2026-05-01T23:59', '--due-date=2026-05-01', '--due-time=23:59', '--scheduled=2026-04-30T12:00', '--topic=t1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_classroom_coursework_update', () => {
+  it('calls runOrDiagnose with ids only', async () => {
+    await handlers.get('gog_classroom_coursework_update')!({ courseId: 'c1', courseworkId: 'w1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['classroom', 'coursework', 'update', 'c1', 'w1'], { account: undefined });
+  });
+
+  it('passes all optional flags', async () => {
+    await handlers.get('gog_classroom_coursework_update')!({
+      courseId: 'c1',
+      courseworkId: 'w1',
+      title: 'New Title',
+      description: 'Desc',
+      type: 'SHORT_ANSWER_QUESTION',
+      state: 'DRAFT',
+      maxPoints: 50,
+      due: '2026-05-01T23:59',
+      dueDate: '2026-05-01',
+      dueTime: '23:59',
+      scheduled: '2026-04-30T12:00',
+      topic: 't1',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['classroom', 'coursework', 'update', 'c1', 'w1', '--title=New Title', '--description=Desc', '--type=SHORT_ANSWER_QUESTION', '--state=DRAFT', '--max-points=50', '--due=2026-05-01T23:59', '--due-date=2026-05-01', '--due-time=23:59', '--scheduled=2026-04-30T12:00', '--topic=t1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_classroom_coursework_delete', () => {
+  it('calls runOrDiagnose with ids', async () => {
+    await handlers.get('gog_classroom_coursework_delete')!({ courseId: 'c1', courseworkId: 'w1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['classroom', 'coursework', 'delete', 'c1', 'w1'], { account: undefined });
+  });
+});
+
+describe('gog_classroom_announcements_update', () => {
+  it('calls runOrDiagnose with ids only', async () => {
+    await handlers.get('gog_classroom_announcements_update')!({ courseId: 'c1', announcementId: 'a1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['classroom', 'announcements', 'update', 'c1', 'a1'], { account: undefined });
+  });
+
+  it('passes all optional flags', async () => {
+    await handlers.get('gog_classroom_announcements_update')!({
+      courseId: 'c1',
+      announcementId: 'a1',
+      text: 'edited',
+      state: 'PUBLISHED',
+      scheduled: '2026-05-01T12:00',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['classroom', 'announcements', 'update', 'c1', 'a1', '--text=edited', '--state=PUBLISHED', '--scheduled=2026-05-01T12:00'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_classroom_announcements_delete', () => {
+  it('calls runOrDiagnose with ids', async () => {
+    await handlers.get('gog_classroom_announcements_delete')!({ courseId: 'c1', announcementId: 'a1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['classroom', 'announcements', 'delete', 'c1', 'a1'], { account: undefined });
+  });
+});
+
+describe('gog_classroom_topics_create', () => {
+  it('calls runOrDiagnose with courseId and name', async () => {
+    await handlers.get('gog_classroom_topics_create')!({ courseId: 'c1', name: 'Week 1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['classroom', 'topics', 'create', 'c1', '--name=Week 1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_classroom_topics_update', () => {
+  it('calls runOrDiagnose with ids and name', async () => {
+    await handlers.get('gog_classroom_topics_update')!({ courseId: 'c1', topicId: 't1', name: 'Week 2' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['classroom', 'topics', 'update', 'c1', 't1', '--name=Week 2'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_classroom_topics_delete', () => {
+  it('calls runOrDiagnose with ids', async () => {
+    await handlers.get('gog_classroom_topics_delete')!({ courseId: 'c1', topicId: 't1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['classroom', 'topics', 'delete', 'c1', 't1'], { account: undefined });
+  });
+});
+
+describe('gog_classroom_invitations_create', () => {
+  it('calls runOrDiagnose with courseId, userId, role', async () => {
+    await handlers.get('gog_classroom_invitations_create')!({ courseId: 'c1', userId: 'u1', role: 'STUDENT' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['classroom', 'invitations', 'create', 'c1', 'u1', '--role=STUDENT'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_classroom_invitations_delete', () => {
+  it('calls runOrDiagnose with invitationId', async () => {
+    await handlers.get('gog_classroom_invitations_delete')!({ invitationId: 'i1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['classroom', 'invitations', 'delete', 'i1'], { account: undefined });
   });
 });