@cloudflare/sandbox 0.0.0-db09b4d → 0.0.0-eb0ea62

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @cloudflare/sandbox
 
+## 0.0.4
+
+### Patch Changes
+
+- [`c0d9d33`](https://github.com/cloudflare/sandbox-sdk/commit/c0d9d3396badee1eab45e6b4a73d48957f31409b) Thanks [@threepointone](https://github.com/threepointone)! - actually work
+
+- [`444d2da`](https://github.com/cloudflare/sandbox-sdk/commit/444d2dafde9a0f190e50c879b0e768da1b289b51) Thanks [@threepointone](https://github.com/threepointone)! - add experimental label
+
+## 0.0.3
+
+### Patch Changes
+
+- [`2b087c4`](https://github.com/cloudflare/sandbox-sdk/commit/2b087c40a29697c20dad19b4e3b8512f5d404bd3) Thanks [@ghostwriternr](https://github.com/ghostwriternr)! - Fix worker unable to find container port
+
+## 0.0.2
+
+### Patch Changes
+
+- [`52f02f0`](https://github.com/cloudflare/sandbox-sdk/commit/52f02f0625ef9f8eac695e51f93fa79651c0206d) Thanks [@threepointone](https://github.com/threepointone)! - readFile
+
 ## 0.0.1
 
 ### Patch Changes

package/README.md

@@ -1,5 +1,7 @@
 ## @cloudflare/sandbox
 
+> **⚠️ Experimental** - This library is currently experimental and we're actively seeking feedback. Please try it out and let us know what you think!
+
 A library to spin up a sandboxed environment.
 
 First, setup your wrangler.json to use the sandbox:
@@ -56,6 +58,7 @@ export default {
 - `gitCheckout(repoUrl: string, options: { branch?: string; targetDir?: string; stream?: boolean })`: Checkout a git repository in the sandbox.
 - `mkdir(path: string, options: { recursive?: boolean; stream?: boolean })`: Create a directory in the sandbox.
 - `writeFile(path: string, content: string, options: { encoding?: string; stream?: boolean })`: Write content to a file in the sandbox.
+- `readFile(path: string, options: { encoding?: string; stream?: boolean })`: Read content from a file in the sandbox.
 - `deleteFile(path: string, options?: { stream?: boolean })`: Delete a file from the sandbox.
 - `renameFile(oldPath: string, newPath: string, options?: { stream?: boolean })`: Rename a file in the sandbox.
 - `moveFile(sourcePath: string, destinationPath: string, options?: { stream?: boolean })`: Move a file from one location to another in the sandbox.

package/container_src/index.ts

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { mkdir, rename, unlink, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { serve } from "bun";
 
@@ -28,6 +28,12 @@ interface WriteFileRequest {
   sessionId?: string;
 }
 
+interface ReadFileRequest {
+  path: string;
+  encoding?: string;
+  sessionId?: string;
+}
+
 interface DeleteFileRequest {
   path: string;
   sessionId?: string;
@@ -297,6 +303,18 @@ const server = serve({
           }
           break;
 
+        case "/api/read":
+          if (req.method === "POST") {
+            return handleReadFileRequest(req, corsHeaders);
+          }
+          break;
+
+        case "/api/read/stream":
+          if (req.method === "POST") {
+            return handleStreamingReadFileRequest(req, corsHeaders);
+          }
+          break;
+
         case "/api/delete":
           if (req.method === "POST") {
             return handleDeleteFileRequest(req, corsHeaders);
@@ -1476,6 +1494,235 @@ async function handleStreamingWriteFileRequest(
   }
 }
 
+async function handleReadFileRequest(
+  req: Request,
+  corsHeaders: Record<string, string>
+): Promise<Response> {
+  try {
+    const body = (await req.json()) as ReadFileRequest;
+    const { path, encoding = "utf-8", sessionId } = body;
+
+    if (!path || typeof path !== "string") {
+      return new Response(
+        JSON.stringify({
+          error: "Path is required and must be a string",
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+          status: 400,
+        }
+      );
+    }
+
+    // Basic safety check - prevent dangerous paths
+    const dangerousPatterns = [
+      /^\/$/, // Root directory
+      /^\/etc/, // System directories
+      /^\/var/, // System directories
+      /^\/usr/, // System directories
+      /^\/bin/, // System directories
+      /^\/sbin/, // System directories
+      /^\/boot/, // System directories
+      /^\/dev/, // System directories
+      /^\/proc/, // System directories
+      /^\/sys/, // System directories
+      /^\/tmp\/\.\./, // Path traversal attempts
+      /\.\./, // Path traversal attempts
+    ];
+
+    if (dangerousPatterns.some((pattern) => pattern.test(path))) {
+      return new Response(
+        JSON.stringify({
+          error: "Dangerous path not allowed",
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+          status: 400,
+        }
+      );
+    }
+
+    console.log(`[Server] Reading file: ${path}`);
+
+    const result = await executeReadFile(path, encoding, sessionId);
+
+    return new Response(
+      JSON.stringify({
+        content: result.content,
+        exitCode: result.exitCode,
+        path,
+        success: result.success,
+        timestamp: new Date().toISOString(),
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders,
+        },
+      }
+    );
+  } catch (error) {
+    console.error("[Server] Error in handleReadFileRequest:", error);
+    return new Response(
+      JSON.stringify({
+        error: "Failed to read file",
+        message: error instanceof Error ? error.message : "Unknown error",
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders,
+        },
+        status: 500,
+      }
+    );
+  }
+}
+
+async function handleStreamingReadFileRequest(
+  req: Request,
+  corsHeaders: Record<string, string>
+): Promise<Response> {
+  try {
+    const body = (await req.json()) as ReadFileRequest;
+    const { path, encoding = "utf-8", sessionId } = body;
+
+    if (!path || typeof path !== "string") {
+      return new Response(
+        JSON.stringify({
+          error: "Path is required and must be a string",
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+          status: 400,
+        }
+      );
+    }
+
+    // Basic safety check - prevent dangerous paths
+    const dangerousPatterns = [
+      /^\/$/, // Root directory
+      /^\/etc/, // System directories
+      /^\/var/, // System directories
+      /^\/usr/, // System directories
+      /^\/bin/, // System directories
+      /^\/sbin/, // System directories
+      /^\/boot/, // System directories
+      /^\/dev/, // System directories
+      /^\/proc/, // System directories
+      /^\/sys/, // System directories
+      /^\/tmp\/\.\./, // Path traversal attempts
+      /\.\./, // Path traversal attempts
+    ];
+
+    if (dangerousPatterns.some((pattern) => pattern.test(path))) {
+      return new Response(
+        JSON.stringify({
+          error: "Dangerous path not allowed",
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+          status: 400,
+        }
+      );
+    }
+
+    console.log(`[Server] Reading file (streaming): ${path}`);
+
+    const stream = new ReadableStream({
+      start(controller) {
+        (async () => {
+          try {
+            // Send command start event
+            controller.enqueue(
+              new TextEncoder().encode(
+                `data: ${JSON.stringify({
+                  path,
+                  timestamp: new Date().toISOString(),
+                  type: "command_start",
+                })}\n\n`
+              )
+            );
+
+            // Read the file
+            const content = await readFile(path, {
+              encoding: encoding as BufferEncoding,
+            });
+
+            console.log(`[Server] File read successfully: ${path}`);
+
+            // Send command completion event
+            controller.enqueue(
+              new TextEncoder().encode(
+                `data: ${JSON.stringify({
+                  content,
+                  path,
+                  success: true,
+                  timestamp: new Date().toISOString(),
+                  type: "command_complete",
+                })}\n\n`
+              )
+            );
+
+            controller.close();
+          } catch (error) {
+            console.error(`[Server] Error reading file: ${path}`, error);
+
+            controller.enqueue(
+              new TextEncoder().encode(
+                `data: ${JSON.stringify({
+                  error:
+                    error instanceof Error ? error.message : "Unknown error",
+                  path,
+                  type: "error",
+                })}\n\n`
+              )
+            );
+
+            controller.close();
+          }
+        })();
+      },
+    });
+
+    return new Response(stream, {
+      headers: {
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "Content-Type": "text/event-stream",
+        ...corsHeaders,
+      },
+    });
+  } catch (error) {
+    console.error("[Server] Error in handleStreamingReadFileRequest:", error);
+    return new Response(
+      JSON.stringify({
+        error: "Failed to read file",
+        message: error instanceof Error ? error.message : "Unknown error",
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders,
+        },
+        status: 500,
+      }
+    );
+  }
+}
+
 async function handleDeleteFileRequest(
   req: Request,
   corsHeaders: Record<string, string>
@@ -2506,6 +2753,37 @@ function executeWriteFile(
   });
 }
 
+function executeReadFile(
+  path: string,
+  encoding: string,
+  sessionId?: string
+): Promise<{
+  success: boolean;
+  exitCode: number;
+  content: string;
+}> {
+  return new Promise((resolve, reject) => {
+    (async () => {
+      try {
+        // Read the file
+        const content = await readFile(path, {
+          encoding: encoding as BufferEncoding,
+        });
+
+        console.log(`[Server] File read successfully: ${path}`);
+        resolve({
+          content,
+          exitCode: 0,
+          success: true,
+        });
+      } catch (error) {
+        console.error(`[Server] Error reading file: ${path}`, error);
+        reject(error);
+      }
+    })();
+  });
+}
+
 function executeDeleteFile(
   path: string,
   sessionId?: string
@@ -2610,6 +2888,8 @@ console.log(`   POST /api/mkdir - Create a directory`);
 console.log(`   POST /api/mkdir/stream - Create a directory (streaming)`);
 console.log(`   POST /api/write - Write a file`);
 console.log(`   POST /api/write/stream - Write a file (streaming)`);
+console.log(`   POST /api/read - Read a file`);
+console.log(`   POST /api/read/stream - Read a file (streaming)`);
 console.log(`   POST /api/delete - Delete a file`);
 console.log(`   POST /api/delete/stream - Delete a file (streaming)`);
 console.log(`   POST /api/rename - Rename a file`);

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@cloudflare/sandbox",
-  "version": "0.0.0-db09b4d",
+  "version": "0.0.0-eb0ea62",
   "repository": {
     "type": "git",
     "url": "https://github.com/cloudflare/sandbox-sdk"
   },
   "description": "A sandboxed environment for running commands",
   "dependencies": {
-    "@cloudflare/containers": "^0.0.8"
+    "@cloudflare/containers": "^0.0.13"
   },
   "tags": [
     "sandbox",
@@ -17,7 +17,7 @@
     "durable objects"
   ],
   "scripts": {
-    "build": "tsup src/*.ts --outDir dist --dts --sourcemap --format esm"
+    "build": "rm -rf dist && tsup src/*.ts --outDir dist --dts --sourcemap --format esm"
   },
   "exports": {
     ".": {

package/src/client.ts

@@ -85,6 +85,20 @@ export interface WriteFileResponse {
   timestamp: string;
 }
 
+interface ReadFileRequest {
+  path: string;
+  encoding?: string;
+  sessionId?: string;
+}
+
+export interface ReadFileResponse {
+  success: boolean;
+  exitCode: number;
+  path: string;
+  content: string;
+  timestamp: string;
+}
+
 interface DeleteFileRequest {
   path: string;
   sessionId?: string;
@@ -142,6 +156,7 @@ interface StreamEvent {
   newPath?: string;
   sourcePath?: string;
   destinationPath?: string;
+  content?: string;
   success?: boolean;
   exitCode?: number;
   stdout?: string;
@@ -978,6 +993,164 @@ export class HttpClient {
     }
   }
 
+  async readFile(
+    path: string,
+    encoding: string = "utf-8",
+    sessionId?: string
+  ): Promise<ReadFileResponse> {
+    try {
+      const targetSessionId = sessionId || this.sessionId;
+
+      const response = await this.doFetch(`/api/read`, {
+        body: JSON.stringify({
+          encoding,
+          path,
+          sessionId: targetSessionId,
+        }),
+        headers: {
+          "Content-Type": "application/json",
+        },
+        method: "POST",
+      });
+
+      if (!response.ok) {
+        const errorData = (await response.json().catch(() => ({}))) as {
+          error?: string;
+        };
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+
+      const data: ReadFileResponse = await response.json();
+      console.log(
+        `[HTTP Client] File read: ${path}, Success: ${data.success}, Content length: ${data.content.length}`
+      );
+
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error reading file:", error);
+      throw error;
+    }
+  }
+
+  async readFileStream(
+    path: string,
+    encoding: string = "utf-8",
+    sessionId?: string
+  ): Promise<void> {
+    try {
+      const targetSessionId = sessionId || this.sessionId;
+
+      const response = await this.doFetch(`/api/read/stream`, {
+        body: JSON.stringify({
+          encoding,
+          path,
+          sessionId: targetSessionId,
+        }),
+        headers: {
+          "Content-Type": "application/json",
+        },
+        method: "POST",
+      });
+
+      if (!response.ok) {
+        const errorData = (await response.json().catch(() => ({}))) as {
+          error?: string;
+        };
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+
+      if (!response.body) {
+        throw new Error("No response body for streaming request");
+      }
+
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+
+          if (done) {
+            break;
+          }
+
+          const chunk = decoder.decode(value, { stream: true });
+          const lines = chunk.split("\n");
+
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              try {
+                const eventData = line.slice(6); // Remove 'data: ' prefix
+                const event: StreamEvent = JSON.parse(eventData);
+
+                console.log(
+                  `[HTTP Client] Read file stream event: ${event.type}`
+                );
+                this.options.onStreamEvent?.(event);
+
+                switch (event.type) {
+                  case "command_start":
+                    console.log(
+                      `[HTTP Client] Read file started: ${event.path}`
+                    );
+                    this.options.onCommandStart?.("read", [path, encoding]);
+                    break;
+
+                  case "command_complete":
+                    console.log(
+                      `[HTTP Client] Read file completed: ${
+                        event.path
+                      }, Success: ${event.success}, Content length: ${
+                        event.content?.length || 0
+                      }`
+                    );
+                    this.options.onCommandComplete?.(
+                      event.success!,
+                      0,
+                      event.content || "",
+                      "",
+                      "read",
+                      [path, encoding]
+                    );
+                    break;
+
+                  case "error":
+                    console.error(
+                      `[HTTP Client] Read file error: ${event.error}`
+                    );
+                    this.options.onError?.(event.error!, "read", [
+                      path,
+                      encoding,
+                    ]);
+                    break;
+                }
+              } catch (parseError) {
+                console.warn(
+                  "[HTTP Client] Failed to parse read file stream event:",
+                  parseError
+                );
+              }
+            }
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    } catch (error) {
+      console.error("[HTTP Client] Error in streaming read file:", error);
+      this.options.onError?.(
+        error instanceof Error ? error.message : "Unknown error",
+        "read",
+        [path, encoding]
+      );
+      throw error;
+    }
+  }
+
   async deleteFile(
     path: string,
     sessionId?: string
@@ -1629,6 +1802,38 @@ export async function quickWriteFileStream(
   }
 }
 
+// Convenience function for quick file reading
+export async function quickReadFile(
+  path: string,
+  encoding: string = "utf-8",
+  options?: HttpClientOptions
+): Promise<ReadFileResponse> {
+  const client = createClient(options);
+  await client.createSession();
+
+  try {
+    return await client.readFile(path, encoding);
+  } finally {
+    client.clearSession();
+  }
+}
+
+// Convenience function for quick streaming file reading
+export async function quickReadFileStream(
+  path: string,
+  encoding: string = "utf-8",
+  options?: HttpClientOptions
+): Promise<void> {
+  const client = createClient(options);
+  await client.createSession();
+
+  try {
+    await client.readFileStream(path, encoding);
+  } finally {
+    client.clearSession();
+  }
+}
+
 // Convenience function for quick file deletion
 export async function quickDeleteFile(
   path: string,

package/src/index.ts

@@ -76,4 +76,54 @@ export class Sandbox<Env = unknown> extends Container<Env> {
     }
     return this.client.mkdir(path, options.recursive);
   }
+
+  async writeFile(
+    path: string,
+    content: string,
+    options: { encoding?: string; stream?: boolean }
+  ) {
+    if (options?.stream) {
+      return this.client.writeFileStream(path, content, options.encoding);
+    }
+    return this.client.writeFile(path, content, options.encoding);
+  }
+
+  async deleteFile(path: string, options: { stream?: boolean }) {
+    if (options?.stream) {
+      return this.client.deleteFileStream(path);
+    }
+    return this.client.deleteFile(path);
+  }
+
+  async renameFile(
+    oldPath: string,
+    newPath: string,
+    options: { stream?: boolean }
+  ) {
+    if (options?.stream) {
+      return this.client.renameFileStream(oldPath, newPath);
+    }
+    return this.client.renameFile(oldPath, newPath);
+  }
+
+  async moveFile(
+    sourcePath: string,
+    destinationPath: string,
+    options: { stream?: boolean }
+  ) {
+    if (options?.stream) {
+      return this.client.moveFileStream(sourcePath, destinationPath);
+    }
+    return this.client.moveFile(sourcePath, destinationPath);
+  }
+
+  async readFile(
+    path: string,
+    options: { encoding?: string; stream?: boolean }
+  ) {
+    if (options?.stream) {
+      return this.client.readFileStream(path, options.encoding);
+    }
+    return this.client.readFile(path, options.encoding);
+  }
 }

package/tests/test2.ts

@@ -7,6 +7,8 @@ import {
   quickExecuteStream,
   quickMoveFile,
   quickMoveFileStream,
+  quickReadFile,
+  quickReadFileStream,
   quickRenameFile,
   quickRenameFileStream,
   quickWriteFile,
@@ -683,6 +685,223 @@ async function testHttpClient() {
     );
   }
 
+  // Test 25: File reading
+  console.log("Test 25: File reading");
+  try {
+    // First create a file to read
+    const readContent = "This is a test file for reading\nLine 2\nLine 3";
+    await quickWriteFile("file-to-read.txt", readContent);
+    console.log("✅ Test file created for reading");
+
+    // Read the file
+    const result = await quickReadFile("file-to-read.txt");
+    console.log("✅ File read successfully:", result.success);
+    console.log("   Path:", result.path);
+    console.log("   Content length:", result.content.length, "characters");
+    console.log("   Exit code:", result.exitCode);
+
+    // Verify the content
+    console.log("✅ File content verified:", result.content === readContent);
+    console.log("   Content:", result.content);
+    console.log("✅ File reading test completed\n");
+  } catch (error) {
+    console.error("❌ Test 25 failed:", error);
+  }
+
+  // Test 26: File reading with custom encoding
+  console.log("Test 26: File reading with custom encoding");
+  try {
+    // Create a file with special characters
+    const specialContent = "Hello 世界! 🌍 Test with emojis and unicode";
+    await quickWriteFile("special-chars.txt", specialContent, "utf-8");
+    console.log("✅ Special characters file created");
+
+    // Read with explicit UTF-8 encoding
+    const result = await quickReadFile("special-chars.txt", "utf-8");
+    console.log(
+      "✅ Special characters file read successfully:",
+      result.success
+    );
+    console.log(
+      "✅ Special characters verified:",
+      result.content === specialContent
+    );
+    console.log("   Content:", result.content);
+    console.log("✅ Custom encoding test completed\n");
+  } catch (error) {
+    console.error("❌ Test 26 failed:", error);
+  }
+
+  // Test 27: File reading in nested directories
+  console.log("Test 27: File reading in nested directories");
+  try {
+    // Create a file in a nested directory
+    const nestedContent = "This file is in a nested directory for reading";
+    await quickWriteFile("nested/read/test-nested-read.txt", nestedContent);
+    console.log("✅ Nested file created for reading");
+
+    // Read the nested file
+    const result = await quickReadFile("nested/read/test-nested-read.txt");
+    console.log("✅ Nested file read successfully:", result.success);
+    console.log(
+      "✅ Nested file content verified:",
+      result.content === nestedContent
+    );
+    console.log("   Content:", result.content);
+    console.log("✅ Nested directory reading test completed\n");
+  } catch (error) {
+    console.error("❌ Test 27 failed:", error);
+  }
+
+  // Test 28: Streaming file reading
+  console.log("Test 28: Streaming file reading");
+  try {
+    const client = createClient();
+    await client.createSession();
+
+    // Create a file to read via streaming
+    const streamReadContent =
+      "This file will be read via streaming\nLine 2\nLine 3";
+    await client.writeFile("stream-read-file.txt", streamReadContent);
+    console.log("✅ Test file created for streaming reading");
+
+    let readContent = "";
+    let readCompleted = false;
+
+    // Set up event handlers for streaming
+    client.setOnStreamEvent((event) => {
+      if (event.type === "command_complete" && event.content) {
+        readContent = event.content;
+        readCompleted = true;
+      }
+    });
+
+    console.log("   Starting streaming file reading...");
+    await client.readFileStream("stream-read-file.txt");
+    console.log("✅ Streaming file reading completed");
+
+    // Verify the content was read correctly
+    console.log(
+      "✅ Streaming read content verified:",
+      readContent === streamReadContent
+    );
+    console.log("   Content length:", readContent.length, "characters");
+
+    client.clearSession();
+    console.log("✅ Streaming file reading test completed\n");
+  } catch (error) {
+    console.error("❌ Test 28 failed:", error);
+  }
+
+  // Test 29: Quick streaming file reading
+  console.log("Test 29: Quick streaming file reading");
+  try {
+    // Create a file for quick streaming read
+    const quickReadContent = "Quick streaming read test content";
+    await quickWriteFile("quick-read-stream.txt", quickReadContent);
+    console.log("✅ Test file created for quick streaming reading");
+
+    let quickReadContentReceived = "";
+    let quickReadCompleted = false;
+
+    console.log("   Starting quick streaming file reading...");
+    await quickReadFileStream("quick-read-stream.txt", "utf-8", {
+      onStreamEvent: (event) => {
+        if (event.type === "command_complete" && event.content) {
+          quickReadContentReceived = event.content;
+          quickReadCompleted = true;
+        }
+      },
+    });
+    console.log("✅ Quick streaming file reading completed");
+
+    // Verify the content
+    console.log(
+      "✅ Quick streaming read verified:",
+      quickReadContentReceived === quickReadContent
+    );
+    console.log("   Content:", quickReadContentReceived);
+    console.log("✅ Quick streaming file reading test completed\n");
+  } catch (error) {
+    console.error("❌ Test 29 failed:", error);
+  }
+
+  // Test 30: File reading with session management
+  console.log("Test 30: File reading with session management");
+  try {
+    const client = createClient();
+    const sessionId = await client.createSession();
+
+    // Create a file in session
+    const sessionReadContent =
+      "This file was created and read with session management";
+    await client.writeFile(
+      "session-read-file.txt",
+      sessionReadContent,
+      "utf-8",
+      sessionId
+    );
+    console.log("✅ Session file created for reading");
+
+    // Read the file in the same session
+    const result = await client.readFile(
+      "session-read-file.txt",
+      "utf-8",
+      sessionId
+    );
+    console.log("✅ Session file read successfully:", result.success);
+    console.log(
+      "✅ Session file content verified:",
+      result.content === sessionReadContent
+    );
+    console.log("   Session ID:", sessionId);
+    console.log("   Content:", result.content);
+
+    client.clearSession();
+    console.log("✅ Session file reading test completed\n");
+  } catch (error) {
+    console.error("❌ Test 30 failed:", error);
+  }
+
+  // Test 31: Error handling for file reading
+  console.log("Test 31: Error handling for file reading");
+  try {
+    // Try to read a non-existent file
+    await quickReadFile("non-existent-read-file.txt");
+    console.log("❌ Should have failed for non-existent file");
+  } catch (error) {
+    console.log("✅ Error handling works for non-existent files");
+    console.log(
+      "   Error:",
+      error instanceof Error ? error.message : "Unknown error"
+    );
+  }
+
+  try {
+    // Try to read from a dangerous path
+    await quickReadFile("/etc/passwd");
+    console.log("❌ Should have failed for dangerous path");
+  } catch (error) {
+    console.log("✅ Error handling works for dangerous paths");
+    console.log(
+      "   Error:",
+      error instanceof Error ? error.message : "Unknown error"
+    );
+  }
+
+  try {
+    // Try to read with empty path
+    await quickReadFile("");
+    console.log("❌ Should have failed for empty path");
+  } catch (error) {
+    console.log("✅ Error handling works for empty paths");
+    console.log(
+      "   Error:",
+      error instanceof Error ? error.message : "Unknown error",
+      "\n"
+    );
+  }
+
   console.log("🎉 All tests completed!");
 }