Claude Desktop Commander MCP

Instructions

                    Retrieve detailed metadata about a file or directory including:
                    - size
                    - creation time
                    - last modified time 
                    - permissions
                    - type
                    - lineCount (for text files)
                    - lastLine (zero-indexed number of last line, for text files)
                    - appendPosition (line number for appending, for text files)
                    
                    Only works within allowed directories.
                    
                    IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.

Implementation Reference

• src/handlers/filesystem-handlers.ts:296-312 (handler)

  Main handler function that executes the get_file_info tool: parses input schema, calls helper getFileInfo, formats output as key-value text.

  export async function handleGetFileInfo(args: unknown): Promise<ServerResult> {
      try {
          const parsed = GetFileInfoArgsSchema.parse(args);
          const info = await getFileInfo(parsed.path);
          return {
              content: [{
                  type: "text",
                  text: Object.entries(info)
                      .map(([key, value]) => `${key}: ${value}`)
                      .join('\n')
              }],
          };
      } catch (error) {
          const errorMessage = error instanceof Error ? error.message : String(error);
          return createErrorResponse(errorMessage);
      }
  }

• src/tools/schemas.ts:115-117 (schema)

  Zod schema for validating get_file_info tool input: requires 'path' string.

  export const GetFileInfoArgsSchema = z.object({
    path: z.string(),
  });

• src/server.ts:1280-1282 (registration)

  Registration/dispatch: Maps 'get_file_info' tool calls to handleGetFileInfo handler in the CallToolRequest switch statement.

  case "get_file_info":
      result = await handlers.handleGetFileInfo(args);
      break;

• src/server.ts:622-643 (registration)

  Tool registration in ListToolsRequest handler: defines name, description, input schema for get_file_info.

      name: "get_file_info",
      description: `
              Retrieve detailed metadata about a file or directory including:
              - size
              - creation time
              - last modified time 
              - permissions
              - type
              - lineCount (for text files)
              - lastLine (zero-indexed number of last line, for text files)
              - appendPosition (line number for appending, for text files)
              
              Only works within allowed directories.
              
              ${PATH_GUIDANCE}
              ${CMD_PREFIX_DESCRIPTION}`,
      inputSchema: zodToJsonSchema(GetFileInfoArgsSchema),
      annotations: {
          title: "Get File Information",
          readOnlyHint: true,
      },
  },

• src/tools/filesystem.ts:1131-1167 (helper)

  Core helper function that retrieves file stats (size, times, type, permissions) and optionally line count for text files.

  export async function getFileInfo(filePath: string): Promise<Record<string, any>> {
      const validPath = await validatePath(filePath);
      const stats = await fs.stat(validPath);
  
      // Basic file info
      const info: Record<string, any> = {
          size: stats.size,
          created: stats.birthtime,
          modified: stats.mtime,
          accessed: stats.atime,
          isDirectory: stats.isDirectory(),
          isFile: stats.isFile(),
          permissions: stats.mode.toString(8).slice(-3),
      };
  
      // For text files that aren't too large, also count lines
      if (stats.isFile() && stats.size < FILE_SIZE_LIMITS.LINE_COUNT_LIMIT) {
          try {
              // Get MIME type information
              const { mimeType, isImage, isPdf } = await getMimeTypeInfo(validPath);
  
              // Only count lines for non-image, likely text files
              if (!isImage && !isPdf) {
                  const content = await fs.readFile(validPath, 'utf8');
                  const lineCount = countLines(content);
                  info.lineCount = lineCount;
                  info.lastLine = lineCount - 1; // Zero-indexed last line
                  info.appendPosition = lineCount; // Position to append at end
              }
          } catch (error) {
              // If reading fails, just skip the line count
              // This could happen for binary files or very large files
          }
      }
  
      return info;
  }