@cloudflare/sandbox 0.0.0-037c848

package/src/index.ts

@@ -0,0 +1,136 @@
+import { Container, getContainer } from "@cloudflare/containers";
+import { HttpClient } from "./client";
+
+export function getSandbox(ns: DurableObjectNamespace<Sandbox>, id: string) {
+  return getContainer(ns, id);
+}
+
+export class Sandbox<Env = unknown> extends Container<Env> {
+  defaultPort = 3000; // The default port for the container to listen on
+  sleepAfter = "3m"; // Sleep the sandbox if no requests are made in this timeframe
+  client: HttpClient;
+
+  constructor(ctx: DurableObjectState, env: Env) {
+    super(ctx, env);
+    this.client = new HttpClient({
+      onCommandComplete: (success, exitCode, stdout, stderr, command, args) => {
+        console.log(
+          `[Container] Command completed: ${command}, Success: ${success}, Exit code: ${exitCode}`
+        );
+      },
+      onCommandStart: (command, args) => {
+        console.log(
+          `[Container] Command started: ${command} ${args.join(" ")}`
+        );
+      },
+      onError: (error, command, args) => {
+        console.error(`[Container] Command error: ${error}`);
+      },
+      onOutput: (stream, data, command) => {
+        console.log(`[Container] [${stream}] ${data}`);
+      },
+      port: this.defaultPort,
+      stub: this,
+    });
+  }
+
+  envVars = {
+    MESSAGE: "I was passed in via the Sandbox class!",
+  };
+
+  override onStart() {
+    console.log("Sandbox successfully started");
+  }
+
+  override onStop() {
+    console.log("Sandbox successfully shut down");
+    if (this.client) {
+      this.client.clearSession();
+    }
+  }
+
+  override onError(error: unknown) {
+    console.log("Sandbox error:", error);
+  }
+
+  async exec(command: string, args: string[], options?: { stream?: boolean }) {
+    if (options?.stream) {
+      return this.client.executeStream(command, args);
+    }
+    return this.client.execute(command, args);
+  }
+
+  async gitCheckout(
+    repoUrl: string,
+    options: { branch?: string; targetDir?: string; stream?: boolean }
+  ) {
+    if (options?.stream) {
+      return this.client.gitCheckoutStream(
+        repoUrl,
+        options.branch,
+        options.targetDir
+      );
+    }
+    return this.client.gitCheckout(repoUrl, options.branch, options.targetDir);
+  }
+
+  async mkdir(
+    path: string,
+    options: { recursive?: boolean; stream?: boolean } = {}
+  ) {
+    if (options?.stream) {
+      return this.client.mkdirStream(path, options.recursive);
+    }
+    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/client.example.ts

@@ -0,0 +1,308 @@
+import {
+  createClient,
+  quickExecute,
+  quickExecuteStream,
+  quickGitCheckout,
+  quickGitCheckoutStream,
+  quickMkdir,
+  quickMkdirStream,
+} from "../../sandbox/src/client";
+
+// Example 1: Basic client usage
+async function basicExample() {
+  console.log("=== Basic Client Example ===");
+
+  const client = createClient({
+    baseUrl: "http://localhost:3000",
+    onCommandComplete: (success, exitCode, stdout, stderr, command, args) => {
+      console.log(
+        `Command completed: ${command}, success=${success}, exitCode=${exitCode}`
+      );
+      if (stderr) console.log(`Stderr: ${stderr}`);
+    },
+    onCommandStart: (command, args) => {
+      console.log(`Starting command: ${command} ${args.join(" ")}`);
+    },
+    onError: (error, command, args) => {
+      console.error(`Error in ${command}: ${error}`);
+    },
+    onOutput: (stream, data, command) => {
+      console.log(`[${stream}] ${data}`);
+    },
+  });
+
+  try {
+    // Create a session
+    const sessionId = await client.createSession();
+    console.log(`Created session: ${sessionId}`);
+
+    // Execute some commands
+    const lsResult = await client.execute("ls", ["-la"]);
+    console.log("LS result:", lsResult.stdout);
+
+    const pwdResult = await client.ping();
+    console.log("Ping result:", pwdResult);
+
+    const commands = await client.getCommands();
+    console.log("Available commands:", commands.slice(0, 5));
+
+    // List sessions
+    const sessions = await client.listSessions();
+    console.log(`Active sessions: ${sessions.count}`);
+  } catch (error) {
+    console.error("Operation failed:", error);
+  } finally {
+    client.clearSession();
+  }
+}
+
+// Example 2: Streaming command execution
+async function streamingExample() {
+  console.log("\n=== Streaming Command Example ===");
+
+  const client = createClient({
+    baseUrl: "http://localhost:3000",
+    onCommandComplete: (success, exitCode, stdout, stderr, command, args) => {
+      console.log(
+        `\n✅ Completed: ${command}, success=${success}, exitCode=${exitCode}`
+      );
+    },
+    onCommandStart: (command, args) => {
+      console.log(`🚀 Starting: ${command} ${args.join(" ")}`);
+    },
+    onOutput: (stream, data, command) => {
+      process.stdout.write(data);
+    },
+  });
+
+  try {
+    await client.createSession();
+
+    // Execute a long-running command with streaming
+    console.log("Executing 'find . -name '*.ts' -type f' with streaming...");
+    await client.executeStream("find", [".", "-name", "*.ts", "-type", "f"]);
+
+    console.log("\nExecuting 'ls -la' with streaming...");
+    await client.executeStream("ls", ["-la"]);
+  } catch (error) {
+    console.error("Streaming failed:", error);
+  } finally {
+    client.clearSession();
+  }
+}
+
+// Example 3: Git operations
+async function gitExample() {
+  console.log("\n=== Git Operations Example ===");
+
+  const client = createClient({
+    baseUrl: "http://localhost:3000",
+    onCommandComplete: (success, exitCode, stdout, stderr, command, args) => {
+      console.log(`✅ Git operation completed: ${command}, success=${success}`);
+    },
+    onCommandStart: (command, args) => {
+      console.log(`🔧 Starting: ${command} ${args.join(" ")}`);
+    },
+    onOutput: (stream, data, command) => {
+      console.log(`[${stream}] ${data.trim()}`);
+    },
+  });
+
+  try {
+    await client.createSession();
+
+    // Create a directory for the repository
+    console.log("Creating directory for repository...");
+    const mkdirResult = await client.mkdir("test-repo", true);
+    console.log(`Directory created: ${mkdirResult.success}`);
+
+    // Checkout a small test repository
+    console.log("Checking out a test repository...");
+    const gitResult = await client.gitCheckout(
+      "https://github.com/octocat/Hello-World.git",
+      "main",
+      "test-repo/hello-world"
+    );
+    console.log(
+      `Repository cloned: ${gitResult.success}, target: ${gitResult.targetDir}`
+    );
+
+    // List the contents of the cloned repository
+    console.log("Listing repository contents...");
+    const lsResult = await client.execute("ls", [
+      "-la",
+      "test-repo/hello-world",
+    ]);
+    console.log("Repository contents:", lsResult.stdout);
+  } catch (error) {
+    console.error("Git operations failed:", error);
+  } finally {
+    client.clearSession();
+  }
+}
+
+// Example 4: Streaming git operations
+async function streamingGitExample() {
+  console.log("\n=== Streaming Git Operations Example ===");
+
+  const client = createClient({
+    baseUrl: "http://localhost:3000",
+    onCommandComplete: (success, exitCode, stdout, stderr, command, args) => {
+      console.log(
+        `\n🎉 Git operation completed: ${command}, success=${success}`
+      );
+    },
+    onCommandStart: (command, args) => {
+      console.log(`🌐 Starting git operation: ${command} ${args.join(" ")}`);
+    },
+    onOutput: (stream, data, command) => {
+      if (stream === "stderr") {
+        process.stderr.write(data);
+      } else {
+        process.stdout.write(data);
+      }
+    },
+  });
+
+  try {
+    await client.createSession();
+
+    // Create directory with streaming
+    console.log("Creating directory with streaming...");
+    await client.mkdirStream("streaming-test", true);
+
+    // Checkout repository with streaming (real-time progress)
+    console.log("Checking out repository with streaming...");
+    await client.gitCheckoutStream(
+      "https://github.com/octocat/Hello-World.git",
+      "main",
+      "streaming-test/hello-world"
+    );
+  } catch (error) {
+    console.error("Streaming git operations failed:", error);
+  } finally {
+    client.clearSession();
+  }
+}
+
+// Example 5: Quick execute utilities
+async function quickExecuteExample() {
+  console.log("\n=== Quick Execute Utilities Example ===");
+
+  try {
+    // Quick command execution
+    console.log("Quick command execution...");
+    const dateResult = await quickExecute("date");
+    console.log("Date:", dateResult.stdout.trim());
+
+    const whoamiResult = await quickExecute("whoami");
+    console.log("User:", whoamiResult.stdout.trim());
+
+    // Quick directory creation
+    console.log("Quick directory creation...");
+    const mkdirResult = await quickMkdir("quick-test", true);
+    console.log(`Directory created: ${mkdirResult.success}`);
+
+    // Quick git checkout
+    console.log("Quick git checkout...");
+    const gitResult = await quickGitCheckout(
+      "https://github.com/octocat/Hello-World.git",
+      "main",
+      "quick-test/repo"
+    );
+    console.log(`Repository cloned: ${gitResult.success}`);
+
+    // Quick streaming execution
+    console.log("Quick streaming execution...");
+    await quickExecuteStream("ls", ["-la", "quick-test"]);
+  } catch (error) {
+    console.error("Quick execute failed:", error);
+  }
+}
+
+// Example 6: Error handling
+async function errorHandlingExample() {
+  console.log("\n=== Error Handling Example ===");
+
+  const client = createClient({
+    baseUrl: "http://localhost:3000",
+    onError: (error, command, args) => {
+      console.error(`❌ Error in ${command}: ${error}`);
+    },
+  });
+
+  try {
+    await client.createSession();
+
+    // Try to execute a non-existent command
+    console.log("Trying to execute non-existent command...");
+    try {
+      await client.execute("nonexistentcommand");
+    } catch (error) {
+      console.log(
+        "Expected error caught:",
+        error instanceof Error ? error.message : error
+      );
+    }
+
+    // Try to create a directory in a protected location
+    console.log("Trying to create directory in protected location...");
+    try {
+      await client.mkdir("/etc/test", false);
+    } catch (error) {
+      console.log(
+        "Expected error caught:",
+        error instanceof Error ? error.message : error
+      );
+    }
+
+    // Try to checkout an invalid repository
+    console.log("Trying to checkout invalid repository...");
+    try {
+      await client.gitCheckout("invalid-url");
+    } catch (error) {
+      console.log(
+        "Expected error caught:",
+        error instanceof Error ? error.message : error
+      );
+    }
+  } catch (error) {
+    console.error("Error handling example failed:", error);
+  } finally {
+    client.clearSession();
+  }
+}
+
+// Run examples
+async function runExamples() {
+  console.log("🚀 HTTP Client Examples\n");
+
+  try {
+    await basicExample();
+    await streamingExample();
+    await gitExample();
+    await streamingGitExample();
+    await quickExecuteExample();
+    await errorHandlingExample();
+
+    console.log("\n✅ All examples completed!");
+  } catch (error) {
+    console.error("❌ Example failed:", error);
+  }
+}
+
+// Export for use in other modules
+export {
+  createClient,
+  quickExecute,
+  quickExecuteStream,
+  quickGitCheckout,
+  quickMkdir,
+  quickGitCheckoutStream,
+  quickMkdirStream,
+};
+
+// Run examples if this file is executed directly
+if (require.main === module) {
+  runExamples();
+}

package/tests/connection-test.ts

@@ -0,0 +1,81 @@
+import { HttpClient } from "../../sandbox/src/client";
+
+async function connectionTest() {
+  console.log("🔌 Testing HTTP Connection Only");
+
+  const client = new HttpClient({
+    baseUrl: "http://localhost:3000",
+    onCommandComplete: (
+      success: boolean,
+      exitCode: number,
+      stdout: string,
+      stderr: string,
+      command: string,
+      args: string[]
+    ) => {
+      console.log(
+        `✅ Command completed: ${command}, Success: ${success}, Exit code: ${exitCode}`
+      );
+    },
+    onCommandStart: (command: string, args: string[]) => {
+      console.log("📝 Command started:", command, args);
+    },
+    onError: (error: string, command?: string, args?: string[]) => {
+      console.error(`❌ Error: ${error}`);
+    },
+    onOutput: (stream: "stdout" | "stderr", data: string, command: string) => {
+      console.log(`📤 [${stream}] ${data.trim()}`);
+    },
+  });
+
+  try {
+    // Test ping to verify server is reachable
+    console.log("🏓 Testing ping...");
+    const pingResult = await client.ping();
+    console.log("✅ Ping successful:", pingResult);
+
+    // Create a session
+    console.log("🔗 Creating session...");
+    const sessionId = await client.createSession();
+    console.log("✅ Session created:", sessionId);
+
+    // Test getting available commands
+    console.log("📋 Getting available commands...");
+    const commands = await client.getCommands();
+    console.log("✅ Available commands:", commands.length);
+
+    // Test listing sessions
+    console.log("📝 Listing sessions...");
+    const sessions = await client.listSessions();
+    console.log("✅ Active sessions:", sessions.count);
+
+    // Wait a moment
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    console.log("✅ Connection test successful");
+  } catch (error) {
+    console.error("❌ Connection test failed:", error);
+    throw error;
+  } finally {
+    client.clearSession();
+    console.log("🔌 Session cleared");
+  }
+}
+
+// Add a timeout to prevent hanging
+const timeout = setTimeout(() => {
+  console.error("❌ Connection test timed out after 15 seconds");
+  process.exit(1);
+}, 15000);
+
+connectionTest()
+  .then(() => {
+    clearTimeout(timeout);
+    console.log("✅ Connection test finished successfully");
+    process.exit(0);
+  })
+  .catch((error) => {
+    clearTimeout(timeout);
+    console.error("❌ Connection test failed:", error);
+    process.exit(1);
+  });

package/tests/simple-test.ts

@@ -0,0 +1,81 @@
+import {
+  HttpClient,
+  quickExecute,
+  quickExecuteStream,
+} from "../../sandbox/src/client";
+
+async function testHttpClient() {
+  console.log("🚀 Testing HTTP Client...\n");
+
+  // Create a client instance
+  const client = new HttpClient({
+    baseUrl: "http://localhost:3000",
+    onCommandComplete: (success, exitCode, stdout, stderr, command, args) => {
+      console.log(
+        `✅ Command completed: ${command}, Success: ${success}, Exit code: ${exitCode}`
+      );
+    },
+    onCommandStart: (command, args) => {
+      console.log(`📝 Command started: ${command} ${args.join(" ")}`);
+    },
+    onError: (error, command, args) => {
+      console.error(`❌ Command error: ${error}`);
+    },
+    onOutput: (stream, data, command) => {
+      console.log(`📤 [${stream}] ${data.trim()}`);
+    },
+  });
+
+  try {
+    // Test ping
+    console.log("1. Testing ping...");
+    const pingTime = await client.ping();
+    console.log(`   Ping response time: ${pingTime}\n`);
+
+    // Test getting available commands
+    console.log("2. Testing get commands...");
+    const commands = await client.getCommands();
+    console.log(`   Available commands: ${commands.join(", ")}\n`);
+
+    // Test session creation
+    console.log("3. Testing session creation...");
+    const sessionId = await client.createSession();
+    console.log(`   Created session: ${sessionId}\n`);
+
+    // Test listing sessions
+    console.log("4. Testing session listing...");
+    const sessions = await client.listSessions();
+    console.log(`   Active sessions: ${sessions.count}\n`);
+
+    // Test regular command execution
+    console.log("5. Testing regular command execution...");
+    const result = await client.execute("echo", ["Hello from HTTP client!"]);
+    console.log(`   Command result: ${result.stdout.trim()}\n`);
+
+    // Test another command
+    console.log("6. Testing another command...");
+    const pwdResult = await client.execute("pwd");
+    console.log(`   Current directory: ${pwdResult.stdout.trim()}\n`);
+
+    // Test streaming command execution
+    console.log("7. Testing streaming command execution...");
+    await client.executeStream("ls", ["-la"]);
+    console.log("   Streaming command completed\n");
+
+    // Test quick execute utility
+    console.log("8. Testing quick execute utility...");
+    const quickResult = await quickExecute("whoami");
+    console.log(`   Quick execute result: ${quickResult.stdout.trim()}\n`);
+
+    console.log("🎉 All tests completed successfully!");
+  } catch (error) {
+    console.error("❌ Test failed:", error);
+  }
+}
+
+// Run the test if this file is executed directly
+if (import.meta.main) {
+  testHttpClient().catch(console.error);
+}
+
+export { testHttpClient };