gogcli-mcp-drive 2.2.0 → 2.4.0

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
   },
   "metadata": {
     "description": "Extended Google Drive for Claude via gogcli — auth + full Drive support (upload, download, permissions, comments, shared drives)",
-    "version": "2.2.0"
+    "version": "2.4.0"
   },
   "plugins": [
     {
@@ -15,7 +15,7 @@
       "displayName": "gogcli (Drive)",
       "source": "./",
       "description": "Extended Google Drive for Claude via gogcli — auth + full Drive support (upload, download, permissions, comments, shared drives)",
-      "version": "2.2.0",
+      "version": "2.4.0",
       "author": {
         "name": "Chris Hall"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "gogcli-mcp-drive",
   "displayName": "gogcli (Drive)",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "description": "Extended Google Drive for Claude via gogcli — auth + full Drive support (upload, download, permissions, comments, shared drives)",
   "author": {
     "name": "Chris Hall",

package/dist/index.js

@@ -31351,7 +31351,7 @@ var failIfNotEmptyParam = external_exports.boolean().optional().describe(
 );
 
 // ../gogcli-mcp/src/server.ts
-var VERSION = true ? "2.2.0" : "0.0.0";
+var VERSION = true ? "2.4.0" : "0.0.0";
 function createServer(options) {
   return new McpServer({
     name: options?.name ?? "gogcli",
@@ -31558,6 +31558,244 @@ function registerExtraDriveTools(server2) {
   }, async ({ fileId, commentId, account }) => {
     return runOrDiagnose(["drive", "comments", "reopen", fileId, commentId], { account });
   });
+  server2.registerTool("gog_drive_du", {
+    description: "Summarize Drive folder sizes (disk-usage style) starting from a folder.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      parent: external_exports.string().optional().describe("Folder ID to start from (default: root)"),
+      depth: external_exports.number().optional().describe("Depth for folder totals (default: 1)"),
+      max: external_exports.number().optional().describe("Max folders to return (0 = unlimited; default: 50)"),
+      sort: external_exports.enum(["size", "path", "files"]).optional().describe("Sort key (default: size)"),
+      order: external_exports.enum(["asc", "desc"]).optional().describe("Sort order (default: desc)"),
+      noAllDrives: external_exports.boolean().optional().describe("My Drive only \u2014 exclude shared drives (shared drives are included by default)"),
+      account: accountParam
+    }
+  }, async ({ parent, depth, max, sort, order, noAllDrives, account }) => {
+    const args = ["drive", "du"];
+    if (parent) args.push(`--parent=${parent}`);
+    if (depth !== void 0) args.push(`--depth=${depth}`);
+    if (max !== void 0) args.push(`--max=${max}`);
+    if (sort) args.push(`--sort=${sort}`);
+    if (order) args.push(`--order=${order}`);
+    if (noAllDrives) args.push("--no-all-drives");
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_drive_tree", {
+    description: "Print a read-only folder tree starting from a folder.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      parent: external_exports.string().optional().describe("Folder ID to start from (default: root)"),
+      depth: external_exports.number().optional().describe("Max depth (0 = unlimited; default: 2)"),
+      max: external_exports.number().optional().describe("Max items to return (0 = unlimited; default: 0)"),
+      noAllDrives: external_exports.boolean().optional().describe("My Drive only \u2014 exclude shared drives (shared drives are included by default)"),
+      account: accountParam
+    }
+  }, async ({ parent, depth, max, noAllDrives, account }) => {
+    const args = ["drive", "tree"];
+    if (parent) args.push(`--parent=${parent}`);
+    if (depth !== void 0) args.push(`--depth=${depth}`);
+    if (max !== void 0) args.push(`--max=${max}`);
+    if (noAllDrives) args.push("--no-all-drives");
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_drive_changes_start_token", {
+    description: "Get a Drive changes start page token \u2014 the cursor you pass to gog_drive_changes_list to enumerate changes since this point.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      drive: external_exports.string().optional().describe("Shared drive ID for a shared-drive change log"),
+      account: accountParam
+    }
+  }, async ({ drive, account }) => {
+    const args = ["drive", "changes", "start-token"];
+    if (drive) args.push(`--drive=${drive}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_drive_changes_list", {
+    description: "List Drive changes since a page token (for sync/automation). Get the initial token from gog_drive_changes_start_token; the response includes a newStartPageToken to persist for the next poll.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      token: external_exports.string().describe("Start page token or next page token"),
+      max: external_exports.number().optional().describe("Max results (default: 100)"),
+      page: external_exports.string().optional().describe("Alias for token when continuing a page"),
+      all: external_exports.boolean().optional().describe("Fetch all pages"),
+      includeRemoved: external_exports.boolean().optional().describe("Include removed changes"),
+      drive: external_exports.string().optional().describe("Shared drive ID for a shared-drive change log"),
+      account: accountParam
+    }
+  }, async ({ token, max, page, all, includeRemoved, drive, account }) => {
+    const args = ["drive", "changes", "list", `--token=${token}`];
+    if (max !== void 0) args.push(`--max=${max}`);
+    if (page) args.push(`--page=${page}`);
+    if (all) args.push("--all");
+    if (includeRemoved) args.push("--include-removed");
+    if (drive) args.push(`--drive=${drive}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_drive_labels_list", {
+    description: "List Drive label schemas available to the account.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      language: external_exports.string().optional().describe("BCP-47 language code"),
+      view: external_exports.enum(["LABEL_VIEW_BASIC", "LABEL_VIEW_FULL"]).optional().describe("Label view (default: LABEL_VIEW_BASIC)"),
+      minimumRole: external_exports.string().optional().describe("Minimum role filter (e.g. READER, APPLIER, ORGANIZER)"),
+      publishedOnly: external_exports.boolean().optional().describe("Only list published labels"),
+      adminAccess: external_exports.boolean().optional().describe("Use admin access for Workspace admin accounts"),
+      account: accountParam
+    }
+  }, async ({ language, view, minimumRole, publishedOnly, adminAccess, account }) => {
+    const args = ["drive", "labels", "list"];
+    if (language) args.push(`--language=${language}`);
+    if (view) args.push(`--view=${view}`);
+    if (minimumRole) args.push(`--minimum-role=${minimumRole}`);
+    if (publishedOnly) args.push("--published-only");
+    if (adminAccess) args.push("--admin-access");
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_drive_labels_get", {
+    description: 'Get a single Drive label schema by name (e.g. "labels/abc123").',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      name: external_exports.string().describe("Label schema name (e.g. labels/abc123)"),
+      language: external_exports.string().optional().describe("BCP-47 language code"),
+      view: external_exports.enum(["LABEL_VIEW_BASIC", "LABEL_VIEW_FULL"]).optional().describe("Label view (default: LABEL_VIEW_FULL)"),
+      adminAccess: external_exports.boolean().optional().describe("Use admin access for Workspace admin accounts"),
+      account: accountParam
+    }
+  }, async ({ name, language, view, adminAccess, account }) => {
+    const args = ["drive", "labels", "get", name];
+    if (language) args.push(`--language=${language}`);
+    if (view) args.push(`--view=${view}`);
+    if (adminAccess) args.push("--admin-access");
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_drive_labels_file_list", {
+    description: "List labels applied to a Drive file.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      fileId: external_exports.string().describe("File ID"),
+      max: external_exports.number().optional().describe("Max results (default: 100)"),
+      page: external_exports.string().optional().describe("Page token"),
+      account: accountParam
+    }
+  }, async ({ fileId, max, page, account }) => {
+    const args = ["drive", "labels", "file", "list", fileId];
+    if (max !== void 0) args.push(`--max=${max}`);
+    if (page) args.push(`--page=${page}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_drive_labels_file_apply", {
+    description: 'Apply or update a label on a Drive file, optionally setting field values. Each field flag takes "fieldId=value" entries (repeatable). selection/integer/date/user values may be comma-separated within one entry for multi-valued fields.',
+    inputSchema: {
+      fileId: external_exports.string().describe("File ID"),
+      labelId: external_exports.string().describe("Label ID to apply"),
+      text: external_exports.array(external_exports.string()).optional().describe("Text fields as fieldId=value (repeatable)"),
+      selection: external_exports.array(external_exports.string()).optional().describe("Selection fields as fieldId=choiceId[,choiceId] (repeatable)"),
+      integer: external_exports.array(external_exports.string()).optional().describe("Integer fields as fieldId=123[,456] (repeatable)"),
+      date: external_exports.array(external_exports.string()).optional().describe("Date fields as fieldId=YYYY-MM-DD[,YYYY-MM-DD] (repeatable)"),
+      user: external_exports.array(external_exports.string()).optional().describe("User fields as fieldId=email[,email] (repeatable)"),
+      unset: external_exports.array(external_exports.string()).optional().describe("Field IDs to unset (repeatable)"),
+      fieldsJson: external_exports.string().optional().describe("Simple JSON object of fieldId to string/number/bool/string-array values"),
+      account: accountParam
+    }
+  }, async ({ fileId, labelId, text, selection, integer: integer2, date: date5, user, unset, fieldsJson, account }) => {
+    const args = ["drive", "labels", "file", "apply", fileId, labelId];
+    if (text) for (const t of text) args.push(`--text=${t}`);
+    if (selection) for (const s of selection) args.push(`--selection=${s}`);
+    if (integer2) for (const i of integer2) args.push(`--integer=${i}`);
+    if (date5) for (const d of date5) args.push(`--date=${d}`);
+    if (user) for (const u of user) args.push(`--user=${u}`);
+    if (unset) for (const u of unset) args.push(`--unset=${u}`);
+    if (fieldsJson) args.push(`--fields-json=${fieldsJson}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_drive_labels_file_remove", {
+    description: "Remove a label from a Drive file.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      fileId: external_exports.string().describe("File ID"),
+      labelId: external_exports.string().describe("Label ID to remove"),
+      account: accountParam
+    }
+  }, async ({ fileId, labelId, account }) => {
+    return runOrDiagnose(["drive", "labels", "file", "remove", fileId, labelId], { account });
+  });
+  server2.registerTool("gog_drive_activity", {
+    description: "Query the Drive Activity API for audit events (edits, creates, deletes, moves, shares, etc.) scoped to a file or folder and/or time range.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      file: external_exports.string().optional().describe("Drive file ID to query"),
+      folder: external_exports.string().optional().describe("Drive folder ID; includes descendants"),
+      actions: external_exports.string().optional().describe("Comma-separated action filters: edit,create,delete,move,rename,restore,comment,share,label,dlp,reference,settings"),
+      from: external_exports.string().optional().describe("Lower activity time bound (RFC3339)"),
+      to: external_exports.string().optional().describe("Upper activity time bound (RFC3339)"),
+      filter: external_exports.string().optional().describe("Raw Drive Activity filter expression appended with AND"),
+      max: external_exports.number().optional().describe("Page size (default: 10)"),
+      page: external_exports.string().optional().describe("Page token"),
+      all: external_exports.boolean().optional().describe("Fetch all pages"),
+      consolidate: external_exports.boolean().optional().describe("Use Drive Activity legacy consolidation strategy"),
+      account: accountParam
+    }
+  }, async ({ file: file2, folder, actions, from, to, filter, max, page, all, consolidate, account }) => {
+    const args = ["drive", "activity", "query"];
+    if (file2) args.push(`--file=${file2}`);
+    if (folder) args.push(`--folder=${folder}`);
+    if (actions) args.push(`--actions=${actions}`);
+    if (from) args.push(`--from=${from}`);
+    if (to) args.push(`--to=${to}`);
+    if (filter) args.push(`--filter=${filter}`);
+    if (max !== void 0) args.push(`--max=${max}`);
+    if (page) args.push(`--page=${page}`);
+    if (all) args.push("--all");
+    if (consolidate) args.push("--consolidate");
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_drive_audit_sharing", {
+    description: "Audit Drive sharing without mutation \u2014 find public (anyone-with-link) or external permissions across a folder tree or a single file.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      file: external_exports.string().optional().describe("Audit one file ID instead of a folder tree"),
+      parent: external_exports.string().optional().describe("Folder ID to scan (default: root)"),
+      depth: external_exports.number().optional().describe("Max folder depth (0 = unlimited; default: 2)"),
+      max: external_exports.number().optional().describe("Max files/folders to scan (0 = unlimited; default: 500)"),
+      internalDomain: external_exports.array(external_exports.string()).optional().describe("Domains treated as internal (defaults to account email domain)"),
+      publicOnly: external_exports.boolean().optional().describe("Only report anyone-with-link/public permissions"),
+      externalOnly: external_exports.boolean().optional().describe("Only report external user/group/domain permissions"),
+      noAllDrives: external_exports.boolean().optional().describe("My Drive only \u2014 exclude shared drives (shared drives are included by default)"),
+      account: accountParam
+    }
+  }, async ({ file: file2, parent, depth, max, internalDomain, publicOnly, externalOnly, noAllDrives, account }) => {
+    const args = ["drive", "audit", "sharing"];
+    if (file2) args.push(`--file=${file2}`);
+    if (parent) args.push(`--parent=${parent}`);
+    if (depth !== void 0) args.push(`--depth=${depth}`);
+    if (max !== void 0) args.push(`--max=${max}`);
+    if (internalDomain) for (const d of internalDomain) args.push(`--internal-domain=${d}`);
+    if (publicOnly) args.push("--public-only");
+    if (externalOnly) args.push("--external-only");
+    if (noAllDrives) args.push("--no-all-drives");
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_drive_audit_user", {
+    description: "Audit Drive sharing without mutation \u2014 find permissions granted to a specific user across a folder tree or a single file.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      user: external_exports.string().describe("User email to audit permissions for"),
+      file: external_exports.string().optional().describe("Audit one file ID instead of a folder tree"),
+      parent: external_exports.string().optional().describe("Folder ID to scan (default: root)"),
+      depth: external_exports.number().optional().describe("Max folder depth (0 = unlimited; default: 2)"),
+      max: external_exports.number().optional().describe("Max files/folders to scan (0 = unlimited; default: 500)"),
+      noAllDrives: external_exports.boolean().optional().describe("My Drive only \u2014 exclude shared drives (shared drives are included by default)"),
+      account: accountParam
+    }
+  }, async ({ user, file: file2, parent, depth, max, noAllDrives, account }) => {
+    const args = ["drive", "audit", "user", user];
+    if (file2) args.push(`--file=${file2}`);
+    if (parent) args.push(`--parent=${parent}`);
+    if (depth !== void 0) args.push(`--depth=${depth}`);
+    if (max !== void 0) args.push(`--max=${max}`);
+    if (noAllDrives) args.push("--no-all-drives");
+    return runOrDiagnose(args, { account });
+  });
 }
 
 // src/index.ts

package/manifest.json

@@ -3,7 +3,7 @@
   "manifest_version": "0.3",
   "name": "gogcli-mcp-drive",
   "display_name": "gogcli (Drive)",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "description": "Extended Google Drive for Claude via gogcli — auth + full Drive support (upload, download, permissions, comments, shared drives)",
   "author": {
     "name": "Chris Hall",
@@ -172,6 +172,54 @@
     {
       "name": "gog_drive_comments_reopen",
       "description": "Reopen a previously resolved comment"
+    },
+    {
+      "name": "gog_drive_du",
+      "description": "Summarize Drive folder sizes (disk-usage style)"
+    },
+    {
+      "name": "gog_drive_tree",
+      "description": "Print a read-only folder tree"
+    },
+    {
+      "name": "gog_drive_changes_start_token",
+      "description": "Get a Drive changes start page token for sync/automation"
+    },
+    {
+      "name": "gog_drive_changes_list",
+      "description": "List Drive changes since a page token"
+    },
+    {
+      "name": "gog_drive_labels_list",
+      "description": "List Drive label schemas"
+    },
+    {
+      "name": "gog_drive_labels_get",
+      "description": "Get a single Drive label schema by name"
+    },
+    {
+      "name": "gog_drive_labels_file_list",
+      "description": "List labels applied to a Drive file"
+    },
+    {
+      "name": "gog_drive_labels_file_apply",
+      "description": "Apply or update a label (with field values) on a Drive file"
+    },
+    {
+      "name": "gog_drive_labels_file_remove",
+      "description": "Remove a label from a Drive file"
+    },
+    {
+      "name": "gog_drive_activity",
+      "description": "Query the Drive Activity API for audit events"
+    },
+    {
+      "name": "gog_drive_audit_sharing",
+      "description": "Audit Drive sharing for public/external permissions (no mutation)"
+    },
+    {
+      "name": "gog_drive_audit_user",
+      "description": "Audit Drive permissions granted to a specific user (no mutation)"
     }
   ],
   "compatibility": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gogcli-mcp-drive",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "mcpName": "io.github.chrischall/gogcli-mcp-drive",
   "description": "Extended Google Drive MCP server via gogcli — auth + full Drive support (upload/download/permissions/comments/shared drives)",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",

package/server.json

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

package/src/tools/drive-extra.ts

@@ -214,4 +214,256 @@ export function registerExtraDriveTools(server: McpServer): void {
   }, async ({ fileId, commentId, account }) => {
     return runOrDiagnose(['drive', 'comments', 'reopen', fileId, commentId], { account });
   });
+
+  // --- gog 0.19.0 ---
+
+  server.registerTool('gog_drive_du', {
+    description: 'Summarize Drive folder sizes (disk-usage style) starting from a folder.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      parent: z.string().optional().describe('Folder ID to start from (default: root)'),
+      depth: z.number().optional().describe('Depth for folder totals (default: 1)'),
+      max: z.number().optional().describe('Max folders to return (0 = unlimited; default: 50)'),
+      sort: z.enum(['size', 'path', 'files']).optional().describe('Sort key (default: size)'),
+      order: z.enum(['asc', 'desc']).optional().describe('Sort order (default: desc)'),
+      noAllDrives: z.boolean().optional().describe('My Drive only — exclude shared drives (shared drives are included by default)'),
+      account: accountParam,
+    },
+  }, async ({ parent, depth, max, sort, order, noAllDrives, account }) => {
+    const args = ['drive', 'du'];
+    if (parent) args.push(`--parent=${parent}`);
+    if (depth !== undefined) args.push(`--depth=${depth}`);
+    if (max !== undefined) args.push(`--max=${max}`);
+    if (sort) args.push(`--sort=${sort}`);
+    if (order) args.push(`--order=${order}`);
+    if (noAllDrives) args.push('--no-all-drives');
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_drive_tree', {
+    description: 'Print a read-only folder tree starting from a folder.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      parent: z.string().optional().describe('Folder ID to start from (default: root)'),
+      depth: z.number().optional().describe('Max depth (0 = unlimited; default: 2)'),
+      max: z.number().optional().describe('Max items to return (0 = unlimited; default: 0)'),
+      noAllDrives: z.boolean().optional().describe('My Drive only — exclude shared drives (shared drives are included by default)'),
+      account: accountParam,
+    },
+  }, async ({ parent, depth, max, noAllDrives, account }) => {
+    const args = ['drive', 'tree'];
+    if (parent) args.push(`--parent=${parent}`);
+    if (depth !== undefined) args.push(`--depth=${depth}`);
+    if (max !== undefined) args.push(`--max=${max}`);
+    if (noAllDrives) args.push('--no-all-drives');
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_drive_changes_start_token', {
+    description: 'Get a Drive changes start page token — the cursor you pass to gog_drive_changes_list to enumerate changes since this point.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      drive: z.string().optional().describe('Shared drive ID for a shared-drive change log'),
+      account: accountParam,
+    },
+  }, async ({ drive, account }) => {
+    const args = ['drive', 'changes', 'start-token'];
+    if (drive) args.push(`--drive=${drive}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_drive_changes_list', {
+    description: 'List Drive changes since a page token (for sync/automation). Get the initial token from gog_drive_changes_start_token; the response includes a newStartPageToken to persist for the next poll.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      token: z.string().describe('Start page token or next page token'),
+      max: z.number().optional().describe('Max results (default: 100)'),
+      page: z.string().optional().describe('Alias for token when continuing a page'),
+      all: z.boolean().optional().describe('Fetch all pages'),
+      includeRemoved: z.boolean().optional().describe('Include removed changes'),
+      drive: z.string().optional().describe('Shared drive ID for a shared-drive change log'),
+      account: accountParam,
+    },
+  }, async ({ token, max, page, all, includeRemoved, drive, account }) => {
+    const args = ['drive', 'changes', 'list', `--token=${token}`];
+    if (max !== undefined) args.push(`--max=${max}`);
+    if (page) args.push(`--page=${page}`);
+    if (all) args.push('--all');
+    if (includeRemoved) args.push('--include-removed');
+    if (drive) args.push(`--drive=${drive}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_drive_labels_list', {
+    description: 'List Drive label schemas available to the account.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      language: z.string().optional().describe('BCP-47 language code'),
+      view: z.enum(['LABEL_VIEW_BASIC', 'LABEL_VIEW_FULL']).optional().describe('Label view (default: LABEL_VIEW_BASIC)'),
+      minimumRole: z.string().optional().describe('Minimum role filter (e.g. READER, APPLIER, ORGANIZER)'),
+      publishedOnly: z.boolean().optional().describe('Only list published labels'),
+      adminAccess: z.boolean().optional().describe('Use admin access for Workspace admin accounts'),
+      account: accountParam,
+    },
+  }, async ({ language, view, minimumRole, publishedOnly, adminAccess, account }) => {
+    const args = ['drive', 'labels', 'list'];
+    if (language) args.push(`--language=${language}`);
+    if (view) args.push(`--view=${view}`);
+    if (minimumRole) args.push(`--minimum-role=${minimumRole}`);
+    if (publishedOnly) args.push('--published-only');
+    if (adminAccess) args.push('--admin-access');
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_drive_labels_get', {
+    description: 'Get a single Drive label schema by name (e.g. "labels/abc123").',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      name: z.string().describe('Label schema name (e.g. labels/abc123)'),
+      language: z.string().optional().describe('BCP-47 language code'),
+      view: z.enum(['LABEL_VIEW_BASIC', 'LABEL_VIEW_FULL']).optional().describe('Label view (default: LABEL_VIEW_FULL)'),
+      adminAccess: z.boolean().optional().describe('Use admin access for Workspace admin accounts'),
+      account: accountParam,
+    },
+  }, async ({ name, language, view, adminAccess, account }) => {
+    const args = ['drive', 'labels', 'get', name];
+    if (language) args.push(`--language=${language}`);
+    if (view) args.push(`--view=${view}`);
+    if (adminAccess) args.push('--admin-access');
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_drive_labels_file_list', {
+    description: 'List labels applied to a Drive file.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      fileId: z.string().describe('File ID'),
+      max: z.number().optional().describe('Max results (default: 100)'),
+      page: z.string().optional().describe('Page token'),
+      account: accountParam,
+    },
+  }, async ({ fileId, max, page, account }) => {
+    const args = ['drive', 'labels', 'file', 'list', fileId];
+    if (max !== undefined) args.push(`--max=${max}`);
+    if (page) args.push(`--page=${page}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_drive_labels_file_apply', {
+    description: 'Apply or update a label on a Drive file, optionally setting field values. Each field flag takes "fieldId=value" entries (repeatable). selection/integer/date/user values may be comma-separated within one entry for multi-valued fields.',
+    inputSchema: {
+      fileId: z.string().describe('File ID'),
+      labelId: z.string().describe('Label ID to apply'),
+      text: z.array(z.string()).optional().describe('Text fields as fieldId=value (repeatable)'),
+      selection: z.array(z.string()).optional().describe('Selection fields as fieldId=choiceId[,choiceId] (repeatable)'),
+      integer: z.array(z.string()).optional().describe('Integer fields as fieldId=123[,456] (repeatable)'),
+      date: z.array(z.string()).optional().describe('Date fields as fieldId=YYYY-MM-DD[,YYYY-MM-DD] (repeatable)'),
+      user: z.array(z.string()).optional().describe('User fields as fieldId=email[,email] (repeatable)'),
+      unset: z.array(z.string()).optional().describe('Field IDs to unset (repeatable)'),
+      fieldsJson: z.string().optional().describe('Simple JSON object of fieldId to string/number/bool/string-array values'),
+      account: accountParam,
+    },
+  }, async ({ fileId, labelId, text, selection, integer, date, user, unset, fieldsJson, account }) => {
+    const args = ['drive', 'labels', 'file', 'apply', fileId, labelId];
+    if (text) for (const t of text) args.push(`--text=${t}`);
+    if (selection) for (const s of selection) args.push(`--selection=${s}`);
+    if (integer) for (const i of integer) args.push(`--integer=${i}`);
+    if (date) for (const d of date) args.push(`--date=${d}`);
+    if (user) for (const u of user) args.push(`--user=${u}`);
+    if (unset) for (const u of unset) args.push(`--unset=${u}`);
+    if (fieldsJson) args.push(`--fields-json=${fieldsJson}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_drive_labels_file_remove', {
+    description: 'Remove a label from a Drive file.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      fileId: z.string().describe('File ID'),
+      labelId: z.string().describe('Label ID to remove'),
+      account: accountParam,
+    },
+  }, async ({ fileId, labelId, account }) => {
+    return runOrDiagnose(['drive', 'labels', 'file', 'remove', fileId, labelId], { account });
+  });
+
+  server.registerTool('gog_drive_activity', {
+    description: 'Query the Drive Activity API for audit events (edits, creates, deletes, moves, shares, etc.) scoped to a file or folder and/or time range.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      file: z.string().optional().describe('Drive file ID to query'),
+      folder: z.string().optional().describe('Drive folder ID; includes descendants'),
+      actions: z.string().optional().describe('Comma-separated action filters: edit,create,delete,move,rename,restore,comment,share,label,dlp,reference,settings'),
+      from: z.string().optional().describe('Lower activity time bound (RFC3339)'),
+      to: z.string().optional().describe('Upper activity time bound (RFC3339)'),
+      filter: z.string().optional().describe('Raw Drive Activity filter expression appended with AND'),
+      max: z.number().optional().describe('Page size (default: 10)'),
+      page: z.string().optional().describe('Page token'),
+      all: z.boolean().optional().describe('Fetch all pages'),
+      consolidate: z.boolean().optional().describe('Use Drive Activity legacy consolidation strategy'),
+      account: accountParam,
+    },
+  }, async ({ file, folder, actions, from, to, filter, max, page, all, consolidate, account }) => {
+    const args = ['drive', 'activity', 'query'];
+    if (file) args.push(`--file=${file}`);
+    if (folder) args.push(`--folder=${folder}`);
+    if (actions) args.push(`--actions=${actions}`);
+    if (from) args.push(`--from=${from}`);
+    if (to) args.push(`--to=${to}`);
+    if (filter) args.push(`--filter=${filter}`);
+    if (max !== undefined) args.push(`--max=${max}`);
+    if (page) args.push(`--page=${page}`);
+    if (all) args.push('--all');
+    if (consolidate) args.push('--consolidate');
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_drive_audit_sharing', {
+    description: 'Audit Drive sharing without mutation — find public (anyone-with-link) or external permissions across a folder tree or a single file.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      file: z.string().optional().describe('Audit one file ID instead of a folder tree'),
+      parent: z.string().optional().describe('Folder ID to scan (default: root)'),
+      depth: z.number().optional().describe('Max folder depth (0 = unlimited; default: 2)'),
+      max: z.number().optional().describe('Max files/folders to scan (0 = unlimited; default: 500)'),
+      internalDomain: z.array(z.string()).optional().describe('Domains treated as internal (defaults to account email domain)'),
+      publicOnly: z.boolean().optional().describe('Only report anyone-with-link/public permissions'),
+      externalOnly: z.boolean().optional().describe('Only report external user/group/domain permissions'),
+      noAllDrives: z.boolean().optional().describe('My Drive only — exclude shared drives (shared drives are included by default)'),
+      account: accountParam,
+    },
+  }, async ({ file, parent, depth, max, internalDomain, publicOnly, externalOnly, noAllDrives, account }) => {
+    const args = ['drive', 'audit', 'sharing'];
+    if (file) args.push(`--file=${file}`);
+    if (parent) args.push(`--parent=${parent}`);
+    if (depth !== undefined) args.push(`--depth=${depth}`);
+    if (max !== undefined) args.push(`--max=${max}`);
+    if (internalDomain) for (const d of internalDomain) args.push(`--internal-domain=${d}`);
+    if (publicOnly) args.push('--public-only');
+    if (externalOnly) args.push('--external-only');
+    if (noAllDrives) args.push('--no-all-drives');
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_drive_audit_user', {
+    description: 'Audit Drive sharing without mutation — find permissions granted to a specific user across a folder tree or a single file.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      user: z.string().describe('User email to audit permissions for'),
+      file: z.string().optional().describe('Audit one file ID instead of a folder tree'),
+      parent: z.string().optional().describe('Folder ID to scan (default: root)'),
+      depth: z.number().optional().describe('Max folder depth (0 = unlimited; default: 2)'),
+      max: z.number().optional().describe('Max files/folders to scan (0 = unlimited; default: 500)'),
+      noAllDrives: z.boolean().optional().describe('My Drive only — exclude shared drives (shared drives are included by default)'),
+      account: accountParam,
+    },
+  }, async ({ user, file, parent, depth, max, noAllDrives, account }) => {
+    const args = ['drive', 'audit', 'user', user];
+    if (file) args.push(`--file=${file}`);
+    if (parent) args.push(`--parent=${parent}`);
+    if (depth !== undefined) args.push(`--depth=${depth}`);
+    if (max !== undefined) args.push(`--max=${max}`);
+    if (noAllDrives) args.push('--no-all-drives');
+    return runOrDiagnose(args, { account });
+  });
 }

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

@@ -254,3 +254,315 @@ describe('gog_drive_comments_reopen', () => {
     );
   });
 });
+
+// --- gog 0.19.0 ---
+
+describe('gog_drive_du', () => {
+  it('calls runOrDiagnose with no flags', async () => {
+    await handlers.get('gog_drive_du')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['drive', 'du'], { account: undefined });
+  });
+
+  it('passes all flags', async () => {
+    await handlers.get('gog_drive_du')!({
+      parent: 'folder1', depth: 3, max: 20, sort: 'files', order: 'asc', noAllDrives: true, account: 'a@b.com',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'du', '--parent=folder1', '--depth=3', '--max=20', '--sort=files', '--order=asc', '--no-all-drives'],
+      { account: 'a@b.com' },
+    );
+  });
+
+  it('handles depth/max=0 and omits noAllDrives when false', async () => {
+    await handlers.get('gog_drive_du')!({ depth: 0, max: 0, noAllDrives: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'du', '--depth=0', '--max=0'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_drive_tree', () => {
+  it('calls runOrDiagnose with no flags', async () => {
+    await handlers.get('gog_drive_tree')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['drive', 'tree'], { account: undefined });
+  });
+
+  it('passes all flags', async () => {
+    await handlers.get('gog_drive_tree')!({ parent: 'folder1', depth: 4, max: 100, noAllDrives: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'tree', '--parent=folder1', '--depth=4', '--max=100', '--no-all-drives'],
+      { account: undefined },
+    );
+  });
+
+  it('handles depth=0 and omits noAllDrives when false', async () => {
+    await handlers.get('gog_drive_tree')!({ depth: 0, noAllDrives: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['drive', 'tree', '--depth=0'], { account: undefined });
+  });
+});
+
+describe('gog_drive_changes_start_token', () => {
+  it('calls runOrDiagnose with no flags', async () => {
+    await handlers.get('gog_drive_changes_start_token')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['drive', 'changes', 'start-token'], { account: undefined });
+  });
+
+  it('passes --drive when provided', async () => {
+    await handlers.get('gog_drive_changes_start_token')!({ drive: 'd1', account: 'a@b.com' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'changes', 'start-token', '--drive=d1'],
+      { account: 'a@b.com' },
+    );
+  });
+});
+
+describe('gog_drive_changes_list', () => {
+  it('calls runOrDiagnose with token only', async () => {
+    await handlers.get('gog_drive_changes_list')!({ token: 'tok1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'changes', 'list', '--token=tok1'],
+      { account: undefined },
+    );
+  });
+
+  it('passes all flags', async () => {
+    await handlers.get('gog_drive_changes_list')!({
+      token: 'tok1', max: 50, page: 'p2', all: true, includeRemoved: true, drive: 'd1',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'changes', 'list', '--token=tok1', '--max=50', '--page=p2', '--all', '--include-removed', '--drive=d1'],
+      { account: undefined },
+    );
+  });
+
+  it('omits boolean flags when false', async () => {
+    await handlers.get('gog_drive_changes_list')!({ token: 'tok1', all: false, includeRemoved: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'changes', 'list', '--token=tok1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_drive_labels_list', () => {
+  it('calls runOrDiagnose with no flags', async () => {
+    await handlers.get('gog_drive_labels_list')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['drive', 'labels', 'list'], { account: undefined });
+  });
+
+  it('passes all flags', async () => {
+    await handlers.get('gog_drive_labels_list')!({
+      language: 'en', view: 'LABEL_VIEW_FULL', minimumRole: 'APPLIER', publishedOnly: true, adminAccess: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'labels', 'list', '--language=en', '--view=LABEL_VIEW_FULL', '--minimum-role=APPLIER', '--published-only', '--admin-access'],
+      { account: undefined },
+    );
+  });
+
+  it('omits boolean flags when false', async () => {
+    await handlers.get('gog_drive_labels_list')!({ publishedOnly: false, adminAccess: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['drive', 'labels', 'list'], { account: undefined });
+  });
+});
+
+describe('gog_drive_labels_get', () => {
+  it('calls runOrDiagnose with name only', async () => {
+    await handlers.get('gog_drive_labels_get')!({ name: 'labels/abc' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['drive', 'labels', 'get', 'labels/abc'], { account: undefined });
+  });
+
+  it('passes all flags', async () => {
+    await handlers.get('gog_drive_labels_get')!({
+      name: 'labels/abc', language: 'en', view: 'LABEL_VIEW_BASIC', adminAccess: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'labels', 'get', 'labels/abc', '--language=en', '--view=LABEL_VIEW_BASIC', '--admin-access'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --admin-access when false', async () => {
+    await handlers.get('gog_drive_labels_get')!({ name: 'labels/abc', adminAccess: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['drive', 'labels', 'get', 'labels/abc'], { account: undefined });
+  });
+});
+
+describe('gog_drive_labels_file_list', () => {
+  it('calls runOrDiagnose with fileId only', async () => {
+    await handlers.get('gog_drive_labels_file_list')!({ fileId: 'f1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'labels', 'file', 'list', 'f1'],
+      { account: undefined },
+    );
+  });
+
+  it('passes --max and --page when provided', async () => {
+    await handlers.get('gog_drive_labels_file_list')!({ fileId: 'f1', max: 25, page: 'tok' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'labels', 'file', 'list', 'f1', '--max=25', '--page=tok'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_drive_labels_file_apply', () => {
+  it('calls runOrDiagnose with fileId and labelId only', async () => {
+    await handlers.get('gog_drive_labels_file_apply')!({ fileId: 'f1', labelId: 'l1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'labels', 'file', 'apply', 'f1', 'l1'],
+      { account: undefined },
+    );
+  });
+
+  it('passes all repeatable field flags and fields-json', async () => {
+    await handlers.get('gog_drive_labels_file_apply')!({
+      fileId: 'f1',
+      labelId: 'l1',
+      text: ['t1=hello', 't2=world'],
+      selection: ['s1=c1,c2'],
+      integer: ['i1=42'],
+      date: ['d1=2026-01-01'],
+      user: ['u1=a@b.com'],
+      unset: ['x1', 'x2'],
+      fieldsJson: '{"f":"v"}',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      [
+        'drive', 'labels', 'file', 'apply', 'f1', 'l1',
+        '--text=t1=hello', '--text=t2=world',
+        '--selection=s1=c1,c2',
+        '--integer=i1=42',
+        '--date=d1=2026-01-01',
+        '--user=u1=a@b.com',
+        '--unset=x1', '--unset=x2',
+        '--fields-json={"f":"v"}',
+      ],
+      { account: undefined },
+    );
+  });
+
+  it('omits empty arrays', async () => {
+    await handlers.get('gog_drive_labels_file_apply')!({
+      fileId: 'f1', labelId: 'l1', text: [], selection: [], integer: [], date: [], user: [], unset: [],
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'labels', 'file', 'apply', 'f1', 'l1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_drive_labels_file_remove', () => {
+  it('calls runOrDiagnose with fileId and labelId', async () => {
+    await handlers.get('gog_drive_labels_file_remove')!({ fileId: 'f1', labelId: 'l1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'labels', 'file', 'remove', 'f1', 'l1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_drive_activity', () => {
+  it('calls runOrDiagnose with no flags', async () => {
+    await handlers.get('gog_drive_activity')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['drive', 'activity', 'query'], { account: undefined });
+  });
+
+  it('passes all flags', async () => {
+    await handlers.get('gog_drive_activity')!({
+      file: 'f1',
+      folder: 'fo1',
+      actions: 'edit,share',
+      from: '2026-01-01T00:00:00Z',
+      to: '2026-02-01T00:00:00Z',
+      filter: 'detail.action_detail_case:RENAME',
+      max: 25,
+      page: 'p2',
+      all: true,
+      consolidate: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      [
+        'drive', 'activity', 'query',
+        '--file=f1', '--folder=fo1', '--actions=edit,share',
+        '--from=2026-01-01T00:00:00Z', '--to=2026-02-01T00:00:00Z',
+        '--filter=detail.action_detail_case:RENAME', '--max=25', '--page=p2', '--all', '--consolidate',
+      ],
+      { account: undefined },
+    );
+  });
+
+  it('omits boolean flags when false', async () => {
+    await handlers.get('gog_drive_activity')!({ all: false, consolidate: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['drive', 'activity', 'query'], { account: undefined });
+  });
+});
+
+describe('gog_drive_audit_sharing', () => {
+  it('calls runOrDiagnose with no flags', async () => {
+    await handlers.get('gog_drive_audit_sharing')!({});
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['drive', 'audit', 'sharing'], { account: undefined });
+  });
+
+  it('passes all flags', async () => {
+    await handlers.get('gog_drive_audit_sharing')!({
+      file: 'f1',
+      parent: 'fo1',
+      depth: 3,
+      max: 100,
+      internalDomain: ['example.com', 'corp.example.com'],
+      publicOnly: true,
+      externalOnly: true,
+      noAllDrives: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      [
+        'drive', 'audit', 'sharing',
+        '--file=f1', '--parent=fo1', '--depth=3', '--max=100',
+        '--internal-domain=example.com', '--internal-domain=corp.example.com',
+        '--public-only', '--external-only', '--no-all-drives',
+      ],
+      { account: undefined },
+    );
+  });
+
+  it('handles depth/max=0, empty domains, and omits booleans when false', async () => {
+    await handlers.get('gog_drive_audit_sharing')!({
+      depth: 0, max: 0, internalDomain: [], publicOnly: false, externalOnly: false, noAllDrives: false,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'audit', 'sharing', '--depth=0', '--max=0'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_drive_audit_user', () => {
+  it('calls runOrDiagnose with user only', async () => {
+    await handlers.get('gog_drive_audit_user')!({ user: 'a@b.com' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'audit', 'user', 'a@b.com'],
+      { account: undefined },
+    );
+  });
+
+  it('passes all flags', async () => {
+    await handlers.get('gog_drive_audit_user')!({
+      user: 'a@b.com', file: 'f1', parent: 'fo1', depth: 3, max: 100, noAllDrives: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'audit', 'user', 'a@b.com', '--file=f1', '--parent=fo1', '--depth=3', '--max=100', '--no-all-drives'],
+      { account: undefined },
+    );
+  });
+
+  it('handles depth/max=0 and omits noAllDrives when false', async () => {
+    await handlers.get('gog_drive_audit_user')!({ user: 'a@b.com', depth: 0, max: 0, noAllDrives: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['drive', 'audit', 'user', 'a@b.com', '--depth=0', '--max=0'],
+      { account: undefined },
+    );
+  });
+});