webdav_get_directory_tree

Instructions

Implementation Reference

• src/handlers/tool-handlers.ts:577-611 (registration)

  Registration of the webdav_get_directory_tree tool, including input schema (path and excludePatterns), description, and inline handler that calls the service method and returns JSON response or error.

  server.tool(
    "webdav_get_directory_tree",
    "Get a recursive tree view of files and directories as a JSON structure",
    {
      path: z.string().optional().default("/").describe(
        "Root directory for the tree",
      ),
      excludePatterns: z.array(z.string()).optional().default([]).describe(
        "Array of glob patterns to exclude from the tree",
      ),
    },
    async ({ path, excludePatterns }) => {
      try {
        const tree = await webdavService.getDirectoryTree(
          path,
          excludePatterns,
        );
  
        return {
          content: [{
            type: "text",
            text: JSON.stringify(tree, null, 2),
          }],
        };
      } catch (error) {
        return {
          content: [{
            type: "text",
            text: `Error getting directory tree: ${(error as Error).message}`,
          }],
          isError: true,
        };
      }
    },
  );

• src/services/webdav-service.ts:724-745 (handler)

  Core handler logic in WebDAVService: computes full path, calls recursive tree builder, logs, handles errors and returns the tree structure.

  async getDirectoryTree(
    path: string = "/",
    excludePatterns: string[] = [],
  ): Promise<any> {
    const fullPath = this.getFullPath(path);
    logger.debug(`Getting directory tree: ${fullPath}`, { excludePatterns });
  
    try {
      const tree = await this._buildDirectoryTree(
        fullPath,
        path,
        excludePatterns,
      );
      logger.debug(`Directory tree built: ${fullPath}`);
      return tree;
    } catch (error) {
      logger.error(`Error getting directory tree ${fullPath}:`, error);
      throw new Error(
        `Failed to get directory tree: ${(error as Error).message}`,
      );
    }
  }

• src/services/webdav-service.ts:750-795 (helper)

  Recursive helper that lists directory contents, applies exclusion patterns using minimatch, builds tree nodes, and recurses into subdirectories.

  private async _buildDirectoryTree(
    currentPath: string,
    basePath: string,
    excludePatterns: string[],
  ): Promise<any[]> {
    try {
      const items = await this.list(currentPath);
      const tree: any[] = [];
  
      for (const item of items) {
        const relativePath = item.filename.replace(
          this.rootPath === "/" ? "" : this.rootPath,
          "",
        );
  
        // Check if this item should be excluded
        const shouldExclude = excludePatterns.some((excludePattern) =>
          minimatch(relativePath, excludePattern, { dot: true })
        );
  
        if (shouldExclude) {
          continue;
        }
  
        const node: any = {
          name: item.basename,
          type: item.type,
        };
  
        if (item.type === "directory") {
          node.children = await this._buildDirectoryTree(
            item.filename,
            basePath,
            excludePatterns,
          );
        }
  
        tree.push(node);
      }
  
      return tree;
    } catch (error) {
      logger.warn(`Warning: Could not access directory ${currentPath}:`, error);
      return [];
    }
  }