src/backup/server.ts.bak

// src/server.ts
import { FastMCP, UserError } from 'fastmcp';
import { z } from 'zod';
import { google, docs_v1 } from 'googleapis';
import { authorize } from './auth.js';
import { OAuth2Client } from 'google-auth-library';

// --- Helper function for hex color validation (basic) ---
const hexColorRegex = /^#?([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/;
const validateHexColor = (color: string) => hexColorRegex.test(color);

// --- Helper function for Hex to RGB conversion ---
/**
 * Converts a hex color string to a Google Docs API RgbColor object.
 * @param hex - The hex color string (e.g., "#FF0000", "#F00", "FF0000").
 * @returns A Google Docs API RgbColor object or null if invalid.
 */
function hexToRgbColor(hex: string): docs_v1.Schema$RgbColor | null {
  if (!hex) return null;
  let hexClean = hex.startsWith('#') ? hex.slice(1) : hex;

  // Expand shorthand form (e.g. "F00") to full form (e.g. "FF0000")
  if (hexClean.length === 3) {
    hexClean = hexClean[0] + hexClean[0] + hexClean[1] + hexClean[1] + hexClean[2] + hexClean[2];
  }

  if (hexClean.length !== 6) {
    return null; // Invalid length
  }

  const bigint = parseInt(hexClean, 16);
  if (isNaN(bigint)) {
      return null; // Invalid hex characters
  }

  // Extract RGB values and normalize to 0.0 - 1.0 range
  const r = ((bigint >> 16) & 255) / 255;
  const g = ((bigint >> 8) & 255) / 255;
  const b = (bigint & 255) / 255;

  return { red: r, green: g, blue: b };
}

// --- Zod Schema for the formatText tool ---
// const FormatTextParameters = z.object({
//   documentId: z.string().describe('The ID of the Google Document.'),
//   startIndex: z.number().int().min(1).describe('The starting index of the text range (inclusive, starts from 1).'),
//   endIndex: z.number().int().min(1).describe('The ending index of the text range (inclusive).'),
//   // Optional Formatting Parameters (SHARED)
//   bold: z.boolean().optional().describe('Apply bold formatting.'),
//   italic: z.boolean().optional().describe('Apply italic formatting.'),
//   underline: z.boolean().optional().describe('Apply underline formatting.'),
//   strikethrough: z.boolean().optional().describe('Apply strikethrough formatting.'),
//   fontSize: z.number().min(1).optional().describe('Set font size (in points, e.g., 12).'),
//   fontFamily: z.string().optional().describe('Set font family (e.g., "Arial", "Times New Roman").'),
//   foregroundColor: z.string()
//     .refine(validateHexColor, { message: "Invalid hex color format (e.g., #FF0000 or #F00)" })
//     .optional()
//     .describe('Set text color using hex format (e.g., "#FF0000").'),
//   backgroundColor: z.string()
//     .refine(validateHexColor, { message: "Invalid hex color format (e.g., #00FF00 or #0F0)" })
//     .optional()
//     .describe('Set text background color using hex format (e.g., "#FFFF00").'),
//   linkUrl: z.string().url().optional().describe('Make the text a hyperlink pointing to this URL.')
// })
// .refine(data => data.endIndex >= data.startIndex, {
//   message: "endIndex must be greater than or equal to startIndex",
//   path: ["endIndex"],
// })
// .refine(data => Object.keys(data).some(key => !['documentId', 'startIndex', 'endIndex'].includes(key) && data[key as keyof typeof data] !== undefined), {
//     message: "At least one formatting option (bold, italic, fontSize, etc.) must be provided."
// });

// --- Define the TypeScript type based on the schema ---
// type FormatTextArgs = z.infer<typeof FormatTextParameters>;

// --- Zod Schema for the NEW formatMatchingText tool ---
const FormatMatchingTextParameters = z.object({
  documentId: z.string().describe('The ID of the Google Document.'),
  textToFind: z.string().min(1).describe('The exact text string to find and format.'),
  matchInstance: z.number().int().min(1).optional().default(1).describe('Which instance of the text to format (1st, 2nd, etc.). Defaults to 1.'),
  // Re-use optional Formatting Parameters (SHARED)
  bold: z.boolean().optional().describe('Apply bold formatting.'),
  italic: z.boolean().optional().describe('Apply italic formatting.'),
  underline: z.boolean().optional().describe('Apply underline formatting.'),
  strikethrough: z.boolean().optional().describe('Apply strikethrough formatting.'),
  fontSize: z.number().min(1).optional().describe('Set font size (in points, e.g., 12).'),
  fontFamily: z.string().optional().describe('Set font family (e.g., "Arial", "Times New Roman").'),
  foregroundColor: z.string()
    .refine(validateHexColor, { message: "Invalid hex color format (e.g., #FF0000 or #F00)" })
    .optional()
    .describe('Set text color using hex format (e.g., "#FF0000").'),
  backgroundColor: z.string()
    .refine(validateHexColor, { message: "Invalid hex color format (e.g., #00FF00 or #0F0)" })
    .optional()
    .describe('Set text background color using hex format (e.g., "#FFFF00").'),
  linkUrl: z.string().url().optional().describe('Make the text a hyperlink pointing to this URL.')
})
.refine(data => Object.keys(data).some(key => !['documentId', 'textToFind', 'matchInstance'].includes(key) && data[key as keyof typeof data] !== undefined), {
    message: "At least one formatting option (bold, italic, fontSize, etc.) must be provided."
});

// --- Define the TypeScript type based on the new schema ---
type FormatMatchingTextArgs = z.infer<typeof FormatMatchingTextParameters>;

// --- Helper function to build TextStyle and fields mask (reusable) ---
function buildTextStyleAndFields(args: Omit<FormatMatchingTextArgs, 'documentId' | 'textToFind' | 'matchInstance'>): { textStyle: docs_v1.Schema$TextStyle, fields: string[] } {
    const textStyle: docs_v1.Schema$TextStyle = {};
    const fieldsToUpdate: string[] = [];

    if (args.bold !== undefined) { textStyle.bold = args.bold; fieldsToUpdate.push('bold'); }
    if (args.italic !== undefined) { textStyle.italic = args.italic; fieldsToUpdate.push('italic'); }
    if (args.underline !== undefined) { textStyle.underline = args.underline; fieldsToUpdate.push('underline'); }
    if (args.strikethrough !== undefined) { textStyle.strikethrough = args.strikethrough; fieldsToUpdate.push('strikethrough'); }
    if (args.fontSize !== undefined) {
        textStyle.fontSize = { magnitude: args.fontSize, unit: 'PT' };
        fieldsToUpdate.push('fontSize');
    }
    if (args.fontFamily !== undefined) {
        textStyle.weightedFontFamily = { fontFamily: args.fontFamily };
        fieldsToUpdate.push('weightedFontFamily');
    }
    if (args.foregroundColor !== undefined) {
        const rgbColor = hexToRgbColor(args.foregroundColor);
        if (!rgbColor) throw new UserError(`Invalid foreground hex color format: ${args.foregroundColor}`);
        textStyle.foregroundColor = { color: { rgbColor: rgbColor } };
        fieldsToUpdate.push('foregroundColor');
    }
    if (args.backgroundColor !== undefined) {
        const rgbColor = hexToRgbColor(args.backgroundColor);
        if (!rgbColor) throw new UserError(`Invalid background hex color format: ${args.backgroundColor}`);
        textStyle.backgroundColor = { color: { rgbColor: rgbColor } };
        fieldsToUpdate.push('backgroundColor');
    }
    if (args.linkUrl !== undefined) {
        textStyle.link = { url: args.linkUrl };
        fieldsToUpdate.push('link');
    }

    if (fieldsToUpdate.length === 0) {
        // This should ideally be caught by Zod refine, but defensive check
        throw new UserError("No formatting options were specified.");
    }

    return { textStyle, fields: fieldsToUpdate };
}

let authClient: OAuth2Client | null = null;
let googleDocs: docs_v1.Docs | null = null;

async function initializeGoogleClient() {
  if (googleDocs) return { authClient, googleDocs };
  if (authClient === null && googleDocs === null) {
    try {
      console.error("Attempting to authorize Google API client...");
      const client = await authorize();
      if (client) {
        authClient = client;
        googleDocs = google.docs({ version: 'v1', auth: authClient });
        console.error("Google API client authorized successfully.");
      } else {
        console.error("FATAL: Authorization returned null or undefined client.");
        authClient = null;
        googleDocs = null;
      }
    } catch (error) {
      console.error("FATAL: Failed to initialize Google API client:", error);
      authClient = null;
      googleDocs = null;
    }
  }
  return { authClient, googleDocs };
}

const server = new FastMCP({
  name: 'Google Docs MCP Server',
  version: '1.0.0',
});

// Tool: Read Google Doc
server.addTool({
  name: 'readGoogleDoc',
  description: 'Reads the content of a specific Google Document.',
  parameters: z.object({
    documentId: z.string().describe('The ID of the Google Document (from the URL).'),
  }),
  execute: async (args, { log }) => {
    const { googleDocs: docs } = await initializeGoogleClient();
    if (!docs) throw new UserError("Google Docs client not initialized.");

    log.info(`Reading Google Doc: ${args.documentId}`);
    try {
      const res = await docs.documents.get({
        documentId: args.documentId,
        fields: 'body(content)',
      });
      log.info(`Fetched doc: ${args.documentId}`);

      let textContent = '';
      res.data.body?.content?.forEach(element => {
        element.paragraph?.elements?.forEach(pe => {
          textContent += pe.textRun?.content || '';
        });
      });

      if (!textContent.trim()) return "Document found, but appears empty.";

      const maxLength = 2000;
      const truncatedContent = textContent.length > maxLength ? textContent.substring(0, maxLength) + '... [truncated]' : textContent;
      return `Content:\n---\n${truncatedContent}`;
    } catch (error: any) {
      log.error(`Error reading doc ${args.documentId}: ${error.message}`);
       if (error.code === 404) throw new UserError(`Doc not found (ID: ${args.documentId}).`);
       if (error.code === 403) throw new UserError(`Permission denied for doc (ID: ${args.documentId}).`);
       throw new UserError(`Failed to read doc: ${error.message}`);
    }
  },
});

// Tool: Append to Google Doc
server.addTool({
  name: 'appendToGoogleDoc',
  description: 'Appends text to the end of a specific Google Document.',
  parameters: z.object({
    documentId: z.string().describe('The ID of the Google Document.'),
    textToAppend: z.string().describe('The text to add.'),
  }),
  execute: async (args, { log }) => {
    const { googleDocs: docs } = await initializeGoogleClient();
     if (!docs) throw new UserError("Google Docs client not initialized.");

    log.info(`Appending to Google Doc: ${args.documentId}`);
    try {
      const docInfo = await docs.documents.get({ documentId: args.documentId, fields: 'body(content)' });
      let endIndex = 1;
      if (docInfo.data.body?.content) {
        const lastElement = docInfo.data.body.content[docInfo.data.body.content.length - 1];
        if (lastElement?.endIndex) endIndex = lastElement.endIndex - 1;
      }
      const textToInsert = (endIndex > 1 && !args.textToAppend.startsWith('\n') ? '\n' : '') + args.textToAppend;

      await docs.documents.batchUpdate({
        documentId: args.documentId,
        requestBody: { requests: [{ insertText: { location: { index: endIndex }, text: textToInsert } }] },
      });

      log.info(`Successfully appended to doc: ${args.documentId}`);
      return `Successfully appended text to document ${args.documentId}.`;
    } catch (error: any) {
      log.error(`Error editing doc ${args.documentId}: ${error.message}`);
      if (error.code === 404) throw new UserError(`Doc not found (ID: ${args.documentId}).`);
      if (error.code === 403) throw new UserError(`Permission denied for doc (ID: ${args.documentId}).`);
      throw new UserError(`Failed to edit doc: ${error.message}`);
    }
  },
});

// --- Add the formatMatchingText tool ---
server.addTool({
    name: 'formatMatchingText',
    description: 'Finds specific text within a Google Document and applies character formatting (bold, italics, color, etc.) to the specified instance.',
    parameters: FormatMatchingTextParameters, // Use the new Zod schema
    execute: async (args: FormatMatchingTextArgs, { log }) => {
        const { googleDocs: docs } = await initializeGoogleClient();
        if (!docs) {
          throw new UserError("Google Docs client is not initialized. Authentication might have failed.");
        }

        log.info(`Attempting to find text "${args.textToFind}" (instance ${args.matchInstance}) in doc: ${args.documentId} and format it.`);

        // 1. Get the document content to find the text range
        let docContent: docs_v1.Schema$Document;
        try {
            const res = await docs.documents.get({
                documentId: args.documentId,
                // Request fields needed to reconstruct text and find indices
                fields: 'body(content(paragraph(elements(startIndex,endIndex,textRun(content)))))',
            });
            docContent = res.data;
            if (!docContent.body?.content) {
                throw new UserError(`Document body or content is empty or inaccessible (ID: ${args.documentId}).`);
            }
            log.info(`Fetched doc content for searching: ${args.documentId}`);
        } catch (error: any) {
            log.error(`Error retrieving doc ${args.documentId} for search: ${error.message}`);
            if (error.code === 404) throw new UserError(`Doc not found (ID: ${args.documentId}).`);
            if (error.code === 403) throw new UserError(`Permission denied for doc (ID: ${args.documentId}).`);
            throw new UserError(`Failed to retrieve doc for searching: ${error.message}`);
        }

        // 2. Find the Nth instance of the text and its range
        let fullText = '';
        const textSegments: { text: string, start: number, end: number }[] = [];
        docContent.body.content.forEach(element => {
            element.paragraph?.elements?.forEach(pe => {
                if (pe.textRun?.content && pe.startIndex && pe.endIndex) {
                    // Handle potential line breaks within content
                    const content = pe.textRun.content;
                    fullText += content;
                    textSegments.push({
                        text: content,
                        start: pe.startIndex,
                        end: pe.endIndex
                    });
                }
            });
        });

        let startIndex = -1;
        let endIndex = -1;
        let foundCount = 0;
        let searchStartIndex = 0;

        while (foundCount < args.matchInstance) {
            const currentIndex = fullText.indexOf(args.textToFind, searchStartIndex);
            if (currentIndex === -1) {
                // Text not found anymore
                break;
            }
            foundCount++;
            if (foundCount === args.matchInstance) {
                // Found the start of the Nth match in the *reconstructed* string.
                // Map this back to the API's startIndex/endIndex.
                const targetStartInFullText = currentIndex;
                const targetEndInFullText = currentIndex + args.textToFind.length;
                let currentPosInFullText = 0;

                for (const seg of textSegments) {
                    const segStartInFullText = currentPosInFullText;
                    // Length of segment text might differ from index range if it contains newlines etc.
                    const segTextLength = seg.text.length;
                    const segEndInFullText = segStartInFullText + segTextLength;

                     // Check if the target *starts* within this segment's text span
                    if (startIndex === -1 && targetStartInFullText >= segStartInFullText && targetStartInFullText < segEndInFullText) {
                        // Calculate the API start index relative to the segment's start index
                        startIndex = seg.start + (targetStartInFullText - segStartInFullText);
                    }

                    // Check if the target *ends* within this segment's text span
                     if (targetEndInFullText > segStartInFullText && targetEndInFullText <= segEndInFullText) {
                        // Calculate the API end index relative to the segment's start index
                        endIndex = seg.start + (targetEndInFullText - segStartInFullText);
                        break; // Found the end, we have the full range
                    }

                    currentPosInFullText = segEndInFullText;
                }

                if (startIndex === -1 || endIndex === -1) {
                     log.warn(`Could not accurately map indices for match ${foundCount} of "${args.textToFind}". Start found at ${targetStartInFullText}, End at ${targetEndInFullText}. Resetting.`);
                     // Reset if we couldn't map indices correctly for this match
                     startIndex = -1;
                     endIndex = -1;
                     // Don't break the outer loop, let it try searching again
                }
            }
            // Continue searching after the start of the current match to find subsequent occurrences
            searchStartIndex = currentIndex + 1;
        }


        if (startIndex === -1 || endIndex === -1) {
          throw new UserError(`Could not find instance ${args.matchInstance} of the text "${args.textToFind}" in document ${args.documentId}. Found ${foundCount} total instance(s).`);
        }

        log.info(`Found text "${args.textToFind}" (instance ${args.matchInstance}) at mapped range: ${startIndex}-${endIndex}`);

        // 3. Build the TextStyle object and fields mask
        const { textStyle, fields } = buildTextStyleAndFields(args);


        // 4. Build the UpdateTextStyleRequest
        const updateTextStyleRequest: docs_v1.Schema$UpdateTextStyleRequest = {
            range: {
                // API uses segmentId, but omitting it defaults to the document BODY
                startIndex: startIndex, // Use the calculated start index
                endIndex: endIndex,     // Use the calculated end index
            },
            textStyle: textStyle,
            fields: fields.join(','), // Crucial: Tells API which fields to update
        };

        // 5. Send the batchUpdate request
        try {
            await docs.documents.batchUpdate({
                documentId: args.documentId,
                requestBody: {
                    requests: [{ updateTextStyle: updateTextStyleRequest }],
                },
            });
            log.info(`Successfully formatted text in doc: ${args.documentId}, range: ${startIndex}-${endIndex}`);
            return `Successfully applied formatting to instance ${args.matchInstance} of "${args.textToFind}".`;
        } catch (error: any) {
            log.error(`Error formatting text in doc ${args.documentId}: ${error.message}`);
            // Consider more specific error handling based on API response if needed
            throw new UserError(`Failed to apply formatting: ${error.message}`);
        }
    },
});

// Tool: Format Text (existing, keep for index-based formatting if needed)
// server.addTool({
//   name: 'formatText',
//   description: 'Applies character formatting (bold, italics, font size, color, link, etc.) to a specific text range in a Google Document using start/end indices.',
//   parameters: FormatTextParameters, // Use the original Zod schema
//   execute: async (args: FormatTextArgs, { log }) => {
//     const { googleDocs: docs } = await initializeGoogleClient();
//     if (!docs) {
//       throw new UserError("Google Docs client is not initialized. Authentication might have failed.");
//     }
//
//     log.info(`Attempting to format text in doc: ${args.documentId}, range: ${args.startIndex}-${args.endIndex}`);
//
//     // 1. Build the TextStyle object and fields mask
//     const { textStyle, fields } = buildTextStyleAndFields(args);
//
//     // 2. Build the UpdateTextStyleRequest
//     const updateTextStyleRequest: docs_v1.Schema$UpdateTextStyleRequest = {
//       range: {
//         startIndex: args.startIndex,
//         endIndex: args.endIndex,
//       },
//       textStyle: textStyle,
//       fields: fields.join(','),
//     };
//
//     // 3. Send the batchUpdate request
//     try {
//       await docs.documents.batchUpdate({
//         documentId: args.documentId,
//         requestBody: {
//           requests: [{ updateTextStyle: updateTextStyleRequest }],
//         },
//       });
//       log.info(`Successfully formatted text in doc: ${args.documentId}, range: ${args.startIndex}-${args.endIndex}`);
//       return `Successfully applied formatting to range ${args.startIndex}-${args.endIndex}.`;
//     } catch (error: any) {
//       log.error(`Error formatting text in doc ${args.documentId}: ${error.message}`);
//        if (error.code === 404) throw new UserError(`Doc not found (ID: ${args.documentId}).`);
//        if (error.code === 403) throw new UserError(`Permission denied for doc (ID: ${args.documentId}).`);
//       throw new UserError(`Failed to format text: ${error.message}`);
//     }
//   },
// });

// Start the Server (Modified to avoid server.config issue)
async function startServer() {
  await initializeGoogleClient(); // Authorize before starting listeners
  console.error("Starting MCP server...");
  try {
      const configToUse = {
        // Choose one transport:
         transportType: "stdio" as const,
        //  transportType: "sse" as const,
        //  sse: {                       // <-- COMMENT OUT or DELETE SSE config
        //    endpoint: "/sse" as const,
        //    port: 8080,
        //  },
      };

      server.start(configToUse); // Start the server with stdio config

      // Adjust logging (optional, but good practice)
      console.error(`MCP Server running using ${configToUse.transportType}.`);
      if (configToUse.transportType === 'stdio') {
          console.error("Awaiting MCP client connection via stdio...");
      }
      // Removed SSE-specific logging

  } catch(startError) {
      console.error("Error occurred during server.start():", startError);
      throw startError; // Re-throw to be caught by the outer catch
  }
}

// Call the modified startServer function
startServer().catch(err => {
    console.error("Server failed to start:", err);
    process.exit(1);
});