Merge pull request #29 from appwrite/feat/list-files-in-dir-and-execute-command

Author: ChiragAgg5k

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@appwrite.io/synapse",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "Operating system gateway for remote serverless environments",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package.json

@@ -8,7 +8,14 @@ import mime from "mime-types";
 import * as path from "path";
 import { Synapse } from "../synapse";
 
-const IGNORE_PATTERNS = ["node_modules", "dist", "build", "coverage", "logs"];
+const IGNORE_PATTERNS = [
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  "logs",
+  ".git",
+];
 
 export type FileItem = {
   name: string;
@@ -61,6 +68,17 @@ export type ZipResult = {
   };
 };
 
+export type FileListItem<WithContent extends boolean = false> =
+  WithContent extends true
+    ? { path: string; content: string }
+    : { path: string };
+
+export type FileListResult<WithContent extends boolean = false> = {
+  success: boolean;
+  data?: FileListItem<WithContent>[];
+  error?: string;
+};
+
 export class Filesystem {
   private synapse: Synapse;
   private workDir: string;
@@ -799,4 +817,108 @@ export class Filesystem {
       };
     }
   }
+
+  /**
+   * Lists all files in a directory with optional content and recursive traversal
+   * @param dirPath - The directory path to list files from
+   * @param withContent - Whether to include file content in the results
+   * @param recursive - Whether to recursively traverse subdirectories
+   * @returns Promise<FileListResult> containing array of file objects
+   */
+  async listFilesInDir({
+    dirPath,
+    withContent,
+    recursive,
+    additionalIgnorePatterns,
+  }: {
+    dirPath: string;
+    withContent?: boolean;
+    recursive?: boolean;
+    additionalIgnorePatterns?: string[];
+  }): Promise<FileListResult<boolean>> {
+    if (!dirPath) {
+      return { success: false, error: "path is required" };
+    }
+
+    try {
+      const fullPath = this.resolvePath(dirPath);
+      const workDir = path.resolve(this.workDir);
+      const results: Array<{ path: string; content?: string }> = [];
+
+      // Read and parse .gitignore
+      let ig: ReturnType<typeof ignore> | null = null;
+      try {
+        const gitignorePath = this.resolvePath(".gitignore");
+        const gitignoreContent = fsSync.existsSync(gitignorePath)
+          ? fsSync.readFileSync(gitignorePath, "utf-8")
+          : "";
+        ig = ignore().add(gitignoreContent);
+      } catch {
+        ig = null;
+      }
+
+      const walkDirectory = async (dir: string) => {
+        let entries: fsSync.Dirent[];
+        try {
+          entries = await fs.readdir(dir, { withFileTypes: true });
+        } catch {
+          return;
+        }
+
+        for (const entry of entries) {
+          const absPath = path.join(dir, entry.name);
+          const relPath = path.relative(workDir, absPath).replace(/\\/g, "/");
+
+          // Skip if ignored by .gitignore or IGNORE_PATTERNS
+          if (ig && ig.ignores(relPath)) {
+            continue;
+          }
+          if (
+            [...IGNORE_PATTERNS, ...(additionalIgnorePatterns || [])].some(
+              (pattern) => relPath.includes(pattern),
+            )
+          ) {
+            continue;
+          }
+
+          if (entry.isDirectory()) {
+            if (recursive) {
+              await walkDirectory(absPath);
+            }
+          } else if (entry.isFile()) {
+            const fileObj: { path: string; content?: string } = {
+              path: relPath,
+            };
+
+            if (withContent) {
+              try {
+                const content = await fs.readFile(absPath, "utf-8");
+                fileObj.content = content;
+              } catch {
+                // If we can't read the file, skip it or include it without content
+                continue;
+              }
+            }
+
+            results.push(fileObj);
+          }
+        }
+      };
+
+      await walkDirectory(fullPath);
+
+      return {
+        success: true,
+        data: results as FileListItem<boolean>[],
+      };
+    } catch (error) {
+      this.log(
+        `Error listing files in directory ${dirPath}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
 }

src/services/filesystem.ts

@@ -2,6 +2,8 @@ import fs from "fs";
 import * as pty from "node-pty";
 import * as os from "os";
 import { Synapse } from "../synapse";
+import { exec } from "child_process";
+import { promisify } from "util";
 
 export type TerminalOptions = {
   shell: string;
@@ -137,6 +139,39 @@ export class Terminal {
     }
   }
 
+  async executeCommand(
+    command: string,
+    cwd: string,
+    timeout: number = 5000,
+  ): Promise<{ output: string; exitCode: number }> {
+    if (!command) {
+      throw new Error("Command is required");
+    }
+
+    if (!cwd) {
+      throw new Error("cwd is required");
+    }
+
+    try {
+      const { stdout, stderr } = await promisify(exec)(command, {
+        cwd,
+        encoding: "utf-8",
+        timeout,
+      });
+
+      return {
+        output: stdout || stderr || "",
+        exitCode: 0, // Success case - error case is handled in catch block
+      };
+    } catch (error: any) {
+      console.error("Failed to execute command:", error);
+      return {
+        output: `Error: ${error instanceof Error ? error.message : String(error)}`,
+        exitCode: 1,
+      };
+    }
+  }
+
   /**
    * Sets the callback for when data is received from the terminal
    * @param callback - The callback to set