mcp-google-multi 4.5.0-alpha.2 → 4.5.0-alpha.3

package/dist/index.js

@@ -19,25 +19,11 @@ import { registerChatTools } from './tools/chat.js';
 import { registerAdminTools, registerAlertCenterTools } from './tools/admin.js';
 import { getOptionalBundles, getAdminAccounts } from './auth.js';
 import { ToolRegistry } from './registry.js';
+import { resolvePolicy, isAllowed, describePolicy } from './write-control.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(path.resolve(__dirname, '..', 'package.json'), 'utf-8'));
-async function main() {
-    if (process.argv.includes('auth')) {
-        const { runAuthFlow } = await import('./auth.js');
-        await runAuthFlow(process.argv);
-        return;
-    }
-    if (process.argv.includes('migrate-tokens')) {
-        const { runMigrateTokens } = await import('./migrate-tokens.js');
-        runMigrateTokens();
-        return;
-    }
-    // MCP server mode — no console.log (stdio is the MCP channel)
-    const server = new McpServer({
-        name: 'mcp-google-multi',
-        version: pkg.version,
-    });
-    const registry = new ToolRegistry(server);
+function buildRegistry(server, policy) {
+    const registry = new ToolRegistry(server, policy);
     registerGmailTools(registry);
     registerDriveTools(registry);
     registerCalendarTools(registry);
@@ -56,6 +42,35 @@ async function main() {
         registerAlertCenterTools(registry);
     if (getAdminAccounts().length > 0)
         registerAdminTools(registry);
+    return registry;
+}
+async function main() {
+    if (process.argv.includes('auth')) {
+        const { runAuthFlow } = await import('./auth.js');
+        await runAuthFlow(process.argv);
+        return;
+    }
+    if (process.argv.includes('migrate-tokens')) {
+        const { runMigrateTokens } = await import('./migrate-tokens.js');
+        runMigrateTokens();
+        return;
+    }
+    if (process.argv.includes('config') && process.argv.includes('check')) {
+        const policy = resolvePolicy();
+        const registry = buildRegistry(new McpServer({ name: 'mcp-google-multi', version: pkg.version }), policy);
+        const cud = registry.tools.filter((t) => t.cud !== 'read');
+        const disabled = cud.filter((t) => !isAllowed(t, policy));
+        console.log(`Write-control: ${describePolicy(policy)}`);
+        console.log(`CUD tools enabled: ${cud.length - disabled.length}/${cud.length}`);
+        console.log(`Disabled: ${disabled.map((t) => t.name).join(', ') || '(none)'}`);
+        return;
+    }
+    const policy = resolvePolicy();
+    const server = new McpServer({
+        name: 'mcp-google-multi',
+        version: pkg.version,
+    });
+    buildRegistry(server, policy);
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }

package/dist/registry.d.ts

@@ -1,4 +1,5 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type Policy } from './write-control.js';
 export type Cud = 'read' | 'create' | 'update' | 'delete';
 export interface ToolEntry {
     name: string;
@@ -9,5 +10,5 @@ export declare function inferCud(name: string): Cud;
 export declare class ToolRegistry {
     readonly tools: ToolEntry[];
     readonly registerTool: McpServer['registerTool'];
-    constructor(server: McpServer);
+    constructor(server: McpServer, policy: Policy);
 }

package/dist/registry.js

@@ -1,3 +1,4 @@
+import { isAllowed, writeDisabledResult } from './write-control.js';
 const CUD_OVERRIDES = {
     drive_untrash: 'update',
 };
@@ -19,11 +20,17 @@ export function inferCud(name) {
 export class ToolRegistry {
     tools = [];
     registerTool;
-    constructor(server) {
-        this.registerTool = ((name, ...rest) => {
+    constructor(server, policy) {
+        this.registerTool = ((name, config, handler) => {
             const service = name.includes('_') ? name.slice(0, name.indexOf('_')) : name;
-            this.tools.push({ name, service, cud: inferCud(name) });
-            return server.registerTool(name, ...rest);
+            const cud = inferCud(name);
+            this.tools.push({ name, service, cud });
+            const guarded = cud === 'read'
+                ? handler
+                : (...args) => isAllowed({ name, service, cud }, policy)
+                    ? handler(...args)
+                    : writeDisabledResult({ name, service, cud }, policy);
+            return server.registerTool(name, config, guarded);
         });
     }
 }

package/dist/write-control.d.ts

@@ -0,0 +1,24 @@
+import type { Cud } from './registry.js';
+export type Profile = 'read-only' | 'safe-writes' | 'full-writes';
+export interface Policy {
+    profile: Profile;
+    readOnly: boolean;
+    allow: string[];
+    deny: string[];
+}
+interface ToolRef {
+    name: string;
+    service: string;
+    cud: Cud;
+}
+export declare function resolvePolicy(env?: NodeJS.ProcessEnv): Policy;
+export declare function isAllowed(tool: ToolRef, policy: Policy): boolean;
+export declare function writeDisabledResult(tool: ToolRef, policy: Policy): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: true;
+};
+export declare function describePolicy(policy: Policy): string;
+export {};

package/dist/write-control.js

@@ -0,0 +1,63 @@
+const PROFILES = ['read-only', 'safe-writes', 'full-writes'];
+function parseGlobs(value) {
+    return (value ?? '').split(',').map((s) => s.trim()).filter(Boolean);
+}
+export function resolvePolicy(env = process.env) {
+    const raw = (env.GOOGLE_PROFILE ?? 'read-only').trim();
+    return {
+        profile: PROFILES.includes(raw) ? raw : 'read-only',
+        readOnly: /^(1|true|yes)$/i.test(env.GOOGLE_READ_ONLY ?? ''),
+        allow: parseGlobs(env.GOOGLE_WRITE_ALLOW),
+        deny: parseGlobs(env.GOOGLE_WRITE_DENY),
+    };
+}
+function globToRegExp(glob) {
+    const escaped = glob.trim().replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*');
+    return new RegExp(`^${escaped}$`);
+}
+function candidates(tool) {
+    const op = tool.name.includes('_') ? tool.name.slice(tool.name.indexOf('_') + 1) : tool.name;
+    return [`${tool.service}:${tool.cud}`, `${tool.service}:${op}`];
+}
+function matchesAny(tool, globs) {
+    if (globs.length === 0)
+        return false;
+    const cands = candidates(tool);
+    return globs.some((g) => {
+        const re = globToRegExp(g);
+        return cands.some((c) => re.test(c));
+    });
+}
+function profileAllows(profile, cud) {
+    if (profile === 'full-writes')
+        return true;
+    if (profile === 'safe-writes')
+        return cud === 'create' || cud === 'update';
+    return false;
+}
+export function isAllowed(tool, policy) {
+    if (tool.cud === 'read')
+        return true;
+    if (policy.readOnly)
+        return false;
+    if (matchesAny(tool, policy.deny))
+        return false;
+    if (matchesAny(tool, policy.allow))
+        return true;
+    return profileAllows(policy.profile, tool.cud);
+}
+export function writeDisabledResult(tool, policy) {
+    const envelope = {
+        error: 'write_disabled',
+        message: `"${tool.name}" (${tool.cud}) is disabled by the current write-control policy (profile: ${policy.profile}${policy.readOnly ? ', GOOGLE_READ_ONLY=true' : ''}).`,
+        hint: `Enable via GOOGLE_PROFILE=safe-writes|full-writes, or GOOGLE_WRITE_ALLOW="${tool.service}:*".`,
+        retriable: false,
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(envelope) }],
+        isError: true,
+    };
+}
+export function describePolicy(policy) {
+    return `profile=${policy.profile} readOnly=${policy.readOnly} allow=[${policy.allow.join(', ')}] deny=[${policy.deny.join(', ')}]`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-google-multi",
-  "version": "4.5.0-alpha.2",
+  "version": "4.5.0-alpha.3",
   "description": "MCP server for Gmail, Google Drive, Calendar, Sheets, Docs, and Contacts with multi-account support",
   "type": "module",
   "license": "MIT",