MCP File Forge

Instructions

Implementation Reference

• src/tools/write.ts:30-119 (handler)

  Implementation of the logic for writing to a file, handling existence checks, backups, directory creation, and error handling.

  async function writeFileImpl(input: WriteFileInput): Promise<ToolResult> {
    try {
      const absolutePath = path.resolve(input.path);
  
      // Check if file exists
      let exists = false;
      try {
        await fs.access(absolutePath);
        exists = true;
      } catch {
        // File doesn't exist
      }
  
      // Handle overwrite logic
      if (exists && !input.overwrite) {
        return {
          isError: true,
          content: [
            {
              type: 'text',
              text: JSON.stringify({
                code: 'ALREADY_EXISTS',
                message: `File already exists and overwrite is false: ${input.path}`,
              }),
            },
          ],
        };
      }
  
      // Create backup if requested
      if (exists && input.backup) {
        const backupPath = `${absolutePath}.bak`;
        await fs.copyFile(absolutePath, backupPath);
      }
  
      // Create parent directories if requested
      if (input.create_dirs) {
        const dir = path.dirname(absolutePath);
        await fs.mkdir(dir, { recursive: true });
      }
  
      // Write the file
      await fs.writeFile(absolutePath, input.content, {
        encoding: input.encoding as BufferEncoding,
      });
  
      return {
        content: [
          {
            type: 'text',
            text: JSON.stringify({
              success: true,
              path: absolutePath,
              bytes_written: Buffer.byteLength(input.content, input.encoding as BufferEncoding),
            }),
          },
        ],
      };
    } catch (error) {
      const err = error as NodeJS.ErrnoException;
  
      if (err.code === 'EACCES') {
        return {
          isError: true,
          content: [
            {
              type: 'text',
              text: JSON.stringify({
                code: 'PERMISSION_DENIED',
                message: `Permission denied: ${input.path}`,
              }),
            },
          ],
        };
      }
  
      return {
        isError: true,
        content: [
          {
            type: 'text',
            text: JSON.stringify({
              code: 'UNKNOWN_ERROR',
              message: `Error writing file: ${err.message}`,
            }),
          },
        ],
      };
    }
  }

• src/tools/write.ts:544-560 (registration)

  Registration of the 'write_file' tool with the MCP server, including the tool schema definition and the handler call.

  // write_file tool
  server.tool(
    'write_file',
    'Write content to a file',
    {
      path: z.string().describe('Path to write to'),
      content: z.string().describe('Content to write'),
      encoding: z.string().optional().describe('File encoding (default: utf-8)'),
      create_dirs: z.boolean().optional().describe('Create parent directories'),
      overwrite: z.boolean().optional().describe('Overwrite if exists'),
      backup: z.boolean().optional().describe('Create backup before overwrite'),
    },
    async (args) => {
      const input = WriteFileInputSchema.parse(args);
      return await writeFileImpl(input);
    }
  );