Google Apps Script MCP Server

Instructions

Implementation Reference

• tools/google-app-script-api/apps-script-api/script-projects-deployments-delete.js:11-64 (handler)

  The main handler function 'executeFunction' that performs the DELETE API call to delete the specified deployment of the Apps Script project, including error handling and logging.

  const executeFunction = async ({ scriptId, deploymentId }) => {
    const baseUrl = 'https://script.googleapis.com';
    const accessToken = ''; // will be provided by the user
    try {
      // Construct the URL for the DELETE request
      const url = `${baseUrl}/v1/projects/${scriptId}/deployments/${deploymentId}?fields=occaecat dolor eu&alt=json&$.xgafv=1&upload_protocol=occaecat dolor eu&uploadType=occaecat dolor eu"aUser=occaecat dolor eu&callback=occaecat dolor eu&prettyPrint=true`;
  
      // Set up headers for the request
      const headers = {
        'Authorization': `Bearer ${accessToken}`,
        'Accept': 'application/json'
      };
  
      // Perform the fetch request
      const response = await fetch(url, {
        method: 'DELETE',
        headers
      });
  
      // Check if the response was successful
      if (!response.ok) {
        const errorData = await response.json();
        throw new Error(errorData);
      }
  
      // Parse and return the response data
      const data = await response.json();
      return data;
    } catch (error) {
      const errorDetails = {
        message: error.message,
        stack: error.stack,
        scriptId,
        deploymentId,
        timestamp: new Date().toISOString(),
        errorType: error.name || 'Unknown'
      };
  
      logger.error('DEPLOYMENT_DELETE', 'Error deleting deployment', errorDetails);
      
      console.error('❌ Error deleting deployment:', errorDetails);
      
      // Return detailed error information for debugging
      return { 
        error: true,
        message: error.message,
        details: errorDetails,
        rawError: {
          name: error.name,
          stack: error.stack
        }
      };
    }
  };

• tools/google-app-script-api/apps-script-api/script-projects-deployments-delete.js:72-92 (schema)

  The tool schema definition including name, description, input parameters (scriptId and deploymentId), and required fields.

  definition: {
    type: 'function',
    function: {
      name: 'script_projects_deployments_delete',
      description: 'Delete a deployment of an Apps Script project.',
      parameters: {
        type: 'object',
        properties: {
          scriptId: {
            type: 'string',
            description: 'The ID of the script project.'
          },
          deploymentId: {
            type: 'string',
            description: 'The ID of the deployment to delete.'
          }
        },
        required: ['scriptId', 'deploymentId']
      }
    }
  }

• tools/paths.js:2-2 (registration)

  The path to this tool's file is registered in the toolPaths array, which is used by the dynamic tool loader to import and register the tool.

  'google-app-script-api/apps-script-api/script-projects-deployments-delete.js',

• lib/tools.js:8-64 (registration)

  The generic tool registration loader that dynamically imports files from toolPaths, extracts apiTool, wraps the function with logging, and returns the list of tools for MCP.

  export async function discoverTools() {
    logger.info('DISCOVERY', `Starting tool discovery for ${toolPaths.length} tool paths`);
    
    const toolPromises = toolPaths.map(async (file) => {
      try {
        logger.debug('DISCOVERY', `Loading tool from: ${file}`);
        const module = await import(`../tools/${file}`);
        
        if (!module.apiTool) {
          logger.warn('DISCOVERY', `Tool file missing apiTool export: ${file}`);
          return null;
        }
  
        const toolName = module.apiTool.definition?.function?.name;
        if (!toolName) {
          logger.warn('DISCOVERY', `Tool missing function name: ${file}`);
          return null;
        }
  
        // Wrap the original function with logging
        const originalFunction = module.apiTool.function;
        const wrappedFunction = withLogging(toolName, originalFunction);
  
        logger.debug('DISCOVERY', `Successfully loaded tool: ${toolName}`, {
          file,
          toolName,
          description: module.apiTool.definition?.function?.description
        });
  
        return {
          ...module.apiTool,
          function: wrappedFunction,
          path: file,
        };
      } catch (error) {
        logger.error('DISCOVERY', `Failed to load tool: ${file}`, {
          file,
          error: {
            message: error.message,
            stack: error.stack
          }
        });
        return null;
      }
    });
    
    const tools = (await Promise.all(toolPromises)).filter(Boolean);
    
    logger.info('DISCOVERY', `Tool discovery completed`, {
      totalPaths: toolPaths.length,
      successfullyLoaded: tools.length,
      failed: toolPaths.length - tools.length,
      toolNames: tools.map(t => t.definition?.function?.name).filter(Boolean)
    });
    
    return tools;
  }