Rewrite listFiles to use std lib's "walk" + test

common/spaces/disk_space_primitives.ts

@@ -9,6 +9,7 @@ import {
   base64DecodeDataUrl,
   base64EncodedDataUrl,
 } from "../../plugos/asset_bundle/base64.ts";
+import { walk } from "../../plugos/deps.ts";
 
 function lookupContentType(path: string): string {
   return mime.getType(path) || "application/octet-stream";
@@ -149,32 +150,26 @@ export class DiskSpacePrimitives implements SpacePrimitives {
   }
 
   async fetchFileList(): Promise<FileMeta[]> {
-    const fileList: FileMeta[] = [];
+    const allFiles: FileMeta[] = [];
+    for await (
+      const file of walk(this.rootPath, {
+        includeDirs: false,
+        // Exclude hidden directories
+        skip: [/^.*\/\..+$/],
+      })
+    ) {
+      const fullPath = file.path;
+      const s = await Deno.stat(fullPath);
+      allFiles.push({
+        name: fullPath.substring(this.rootPath.length + 1),
+        lastModified: s.mtime!.getTime(),
+        contentType: mime.getType(fullPath) || "application/octet-stream",
+        size: s.size,
+        perm: "rw",
+      });
+    }
 
-    const walkPath = async (dir: string) => {
+    return allFiles;
-      for await (const file of Deno.readDir(dir)) {
-        if (file.name.startsWith(".")) {
-          continue;
-        }
-        const fullPath = path.join(dir, file.name);
-        const s = await Deno.stat(fullPath);
-        if (file.isDirectory) {
-          await walkPath(fullPath);
-        } else {
-          if (!file.name.startsWith(".")) {
-            fileList.push({
-              name: this.pathToFilename(fullPath),
-              size: s.size,
-              contentType: lookupContentType(fullPath),
-              lastModified: s.mtime!.getTime(),
-              perm: "rw",
-            });
-          }
-        }
-      }
-    };
-    await walkPath(this.rootPath);
-    return fileList;
   }
 
   // Plugs

plugos/syscalls/fs.deno.test.ts

@@ -0,0 +1,17 @@
+import { assert } from "../../test_deps.ts";
+import { FileMeta } from "../../common/types.ts";
+import { path } from "../deps.ts";
+import fileSystemSyscalls from "./fs.deno.ts";
+
+const fakeCtx = {} as any;
+
+Deno.test("Test FS operations", async () => {
+  const thisFolder = path.dirname(new URL(import.meta.url).pathname);
+  const syscalls = fileSystemSyscalls(thisFolder);
+  const allFiles: FileMeta[] = await syscalls["fs.listFiles"](
+    fakeCtx,
+    thisFolder,
+    true,
+  );
+  assert(allFiles.find((f) => f.name === "fs.deno.test.ts"));
+});

plugos/syscalls/fs.deno.ts

@@ -1,5 +1,5 @@
 import type { SysCallMapping } from "../system.ts";
-import { mime, path } from "../deps.ts";
+import { mime, path, walk } from "../deps.ts";
 import { base64DecodeDataUrl, base64Encode } from "../asset_bundle/base64.ts";
 import { FileMeta } from "../../common/types.ts";
 
@@ -72,26 +72,24 @@ export default function fileSystemSyscalls(root = "/"): SysCallMapping {
     ): Promise<FileMeta[]> => {
       dirPath = resolvedPath(dirPath);
       const allFiles: FileMeta[] = [];
-
+      for await (
-      async function walkPath(dir: string) {
+        const file of walk(dirPath, {
-        const files = await Deno.readDir(dir);
+          includeDirs: false,
-        for await (const file of files) {
+          // Exclude hidden files
-          const fullPath = path.join(dir, file.name);
+          skip: [/^.*\/\..+$/],
-          const s = await Deno.stat(fullPath);
+          maxDepth: recursive ? Infinity : 1,
-          if (s.isDirectory && recursive) {
+        })
-            await walkPath(fullPath);
+      ) {
-          } else {
+        const fullPath = file.path;
-            allFiles.push({
+        const s = await Deno.stat(fullPath);
-              name: fullPath.substring(dirPath.length + 1),
+        allFiles.push({
-              lastModified: s.mtime!.getTime(),
+          name: fullPath.substring(dirPath.length + 1),
-              contentType: mime.getType(fullPath) || "application/octet-stream",
+          lastModified: s.mtime!.getTime(),
-              size: s.size,
+          contentType: mime.getType(fullPath) || "application/octet-stream",
-              perm: "rw",
+          size: s.size,
-            });
+          perm: "rw",
-          }
+        });
-        }
       }
-      await walkPath(dirPath);
       return allFiles;
     },
   };