webdav_move_remote_item

Move or rename files and directories on a remote WebDAV server by specifying source and destination paths, with optional overwrite control.

Instructions

Move or rename a file or directory on a remote WebDAV server

Input Schema

TableJSON Schema

Name	Required	Description	Default
`fromPath`	Yes
`toPath`	Yes
`overwrite`	No

Implementation Reference

src/handlers/tool-handlers.ts:191-243 (handler)

Registers the 'webdav_move_remote_item' tool with input schema validation and execution handler that performs existence checks and calls webdavService.move()

server.tool(
  'webdav_move_remote_item',
  'Move or rename a file or directory on a remote WebDAV server',
  {
    fromPath: z.string().min(1, 'Source path must not be empty'),
    toPath: z.string().min(1, 'Destination path must not be empty'),
    overwrite: z.boolean().optional().default(false)
  },
  async ({ fromPath, toPath, overwrite }) => {
    try {
      // Check if source exists
      const sourceExists = await webdavService.exists(fromPath);
      if (!sourceExists) {
        return {
          content: [{
            type: 'text',
            text: `Error: Source path does not exist at ${fromPath}`
          }],
          isError: true
        };
      }

      // Check if destination exists and respect overwrite flag
      const destExists = await webdavService.exists(toPath);
      if (destExists && !overwrite) {
        return {
          content: [{
            type: 'text',
            text: `Error: Destination already exists at ${toPath}. Use overwrite=true to replace it.`
          }],
          isError: true
        };
      }

      await webdavService.move(fromPath, toPath);
      
      return {
        content: [{
          type: 'text',
          text: `Successfully moved ${fromPath} to ${toPath}`
        }]
      };
    } catch (error) {
      return {
        content: [{
          type: 'text',
          text: `Error moving: ${(error as Error).message}`
        }],
        isError: true
      };
    }
  }
);

src/services/webdav-service.ts:232-260 (helper)

Implements the move operation in WebDAVService by calling WebDAVClient.moveFile with path normalization and error handling

async move(fromPath: string, toPath: string): Promise<void> {
  const fullFromPath = this.getFullPath(fromPath);
  const fullToPath = this.getFullPath(toPath);
  logger.debug(`Moving from ${fullFromPath} to ${fullToPath}`);
  
  try {
    // Get type before moving for better logging
    const stat = await this.stat(fromPath).catch(() => null);
    const itemType = stat?.type || 'item';
    
    // moveFile in v5.x returns a boolean indicating success
    const result = await this.client.moveFile(fullFromPath, fullToPath);
    
    // Check result based on type
    if (typeof result === 'boolean' && !result) {
      throw new Error("Failed to move: server returned failure status");
    } else if (this.isResponseData(result) && 
               result.status !== undefined && 
               result.status !== 201 && 
               result.status !== 204) {
      throw new Error(`Failed to move: server returned status ${result.status}`);
    }
    
    logger.debug(`Successfully moved ${itemType} from ${fullFromPath} to ${fullToPath}`);
  } catch (error) {
    logger.error(`Error moving from ${fullFromPath} to ${fullToPath}:`, error);
    throw new Error(`Failed to move: ${(error as Error).message}`);
  }
}

src/lib.ts:77-79 (registration)
Top-level server setup calls setupToolHandlers(server, webdavService) which registers the webdav_move_remote_item tool among others
```
setupResourceHandlers(server, webdavService);
setupToolHandlers(server, webdavService);
setupPromptHandlers(server);
```

src/handlers/tool-handlers.ts:195-198 (schema)

Input schema for the webdav_move_remote_item tool using Zod validation

  fromPath: z.string().min(1, 'Source path must not be empty'),
  toPath: z.string().min(1, 'Destination path must not be empty'),
  overwrite: z.boolean().optional().default(false)
},

WebDAV MCP Server