@cloudflare/sandbox 0.0.0-02ee8fe

package/src/clients/file-client.ts

@@ -0,0 +1,295 @@
+import type {
+  DeleteFileResult,
+  FileExistsResult,
+  ListFilesOptions,
+  ListFilesResult,
+  MkdirResult,
+  MoveFileResult,
+  ReadFileResult,
+  RenameFileResult,
+  WriteFileResult
+} from '@repo/shared';
+import { BaseHttpClient } from './base-client';
+import type { HttpClientOptions, SessionRequest } from './types';
+
+/**
+ * Request interface for creating directories
+ */
+export interface MkdirRequest extends SessionRequest {
+  path: string;
+  recursive?: boolean;
+}
+
+/**
+ * Request interface for writing files
+ */
+export interface WriteFileRequest extends SessionRequest {
+  path: string;
+  content: string;
+  encoding?: string;
+}
+
+/**
+ * Request interface for reading files
+ */
+export interface ReadFileRequest extends SessionRequest {
+  path: string;
+  encoding?: string;
+}
+
+/**
+ * Request interface for file operations (delete, rename, move)
+ */
+export interface FileOperationRequest extends SessionRequest {
+  path: string;
+  newPath?: string; // For rename/move operations
+}
+
+/**
+ * Client for file system operations
+ */
+export class FileClient extends BaseHttpClient {
+
+  /**
+   * Create a directory
+   * @param path - Directory path to create
+   * @param sessionId - The session ID for this operation
+   * @param options - Optional settings (recursive)
+   */
+  async mkdir(
+    path: string,
+    sessionId: string,
+    options?: { recursive?: boolean }
+  ): Promise<MkdirResult> {
+    try {
+      const data = {
+        path,
+        sessionId,
+        recursive: options?.recursive ?? false,
+      };
+
+      const response = await this.post<MkdirResult>('/api/mkdir', data);
+      
+      this.logSuccess('Directory created', `${path} (recursive: ${data.recursive})`);
+      return response;
+    } catch (error) {
+      this.logError('mkdir', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Write content to a file
+   * @param path - File path to write to
+   * @param content - Content to write
+   * @param sessionId - The session ID for this operation
+   * @param options - Optional settings (encoding)
+   */
+  async writeFile(
+    path: string,
+    content: string,
+    sessionId: string,
+    options?: { encoding?: string }
+  ): Promise<WriteFileResult> {
+    try {
+      const data = {
+        path,
+        content,
+        sessionId,
+        encoding: options?.encoding ?? 'utf8',
+      };
+
+      const response = await this.post<WriteFileResult>('/api/write', data);
+      
+      this.logSuccess('File written', `${path} (${content.length} chars)`);
+      return response;
+    } catch (error) {
+      this.logError('writeFile', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Read content from a file
+   * @param path - File path to read from
+   * @param sessionId - The session ID for this operation
+   * @param options - Optional settings (encoding)
+   */
+  async readFile(
+    path: string,
+    sessionId: string,
+    options?: { encoding?: string }
+  ): Promise<ReadFileResult> {
+    try {
+      const data = {
+        path,
+        sessionId,
+        encoding: options?.encoding ?? 'utf8',
+      };
+
+      const response = await this.post<ReadFileResult>('/api/read', data);
+
+      this.logSuccess('File read', `${path} (${response.content.length} chars)`);
+      return response;
+    } catch (error) {
+      this.logError('readFile', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Stream a file using Server-Sent Events
+   * Returns a ReadableStream of SSE events containing metadata, chunks, and completion
+   * @param path - File path to stream
+   * @param sessionId - The session ID for this operation
+   */
+  async readFileStream(
+    path: string,
+    sessionId: string
+  ): Promise<ReadableStream<Uint8Array>> {
+    try {
+      const data = {
+        path,
+        sessionId,
+      };
+
+      const response = await this.doFetch('/api/read/stream', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(data),
+      });
+
+      const stream = await this.handleStreamResponse(response);
+      this.logSuccess('File stream started', path);
+      return stream;
+    } catch (error) {
+      this.logError('readFileStream', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Delete a file
+   * @param path - File path to delete
+   * @param sessionId - The session ID for this operation
+   */
+  async deleteFile(
+    path: string,
+    sessionId: string
+  ): Promise<DeleteFileResult> {
+    try {
+      const data = { path, sessionId };
+
+      const response = await this.post<DeleteFileResult>('/api/delete', data);
+      
+      this.logSuccess('File deleted', path);
+      return response;
+    } catch (error) {
+      this.logError('deleteFile', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Rename a file
+   * @param path - Current file path
+   * @param newPath - New file path
+   * @param sessionId - The session ID for this operation
+   */
+  async renameFile(
+    path: string,
+    newPath: string,
+    sessionId: string
+  ): Promise<RenameFileResult> {
+    try {
+      const data = { oldPath: path, newPath, sessionId };
+
+      const response = await this.post<RenameFileResult>('/api/rename', data);
+      
+      this.logSuccess('File renamed', `${path} -> ${newPath}`);
+      return response;
+    } catch (error) {
+      this.logError('renameFile', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Move a file
+   * @param path - Current file path
+   * @param newPath - Destination file path
+   * @param sessionId - The session ID for this operation
+   */
+  async moveFile(
+    path: string,
+    newPath: string,
+    sessionId: string
+  ): Promise<MoveFileResult> {
+    try {
+      const data = { sourcePath: path, destinationPath: newPath, sessionId };
+
+      const response = await this.post<MoveFileResult>('/api/move', data);
+
+      this.logSuccess('File moved', `${path} -> ${newPath}`);
+      return response;
+    } catch (error) {
+      this.logError('moveFile', error);
+      throw error;
+    }
+  }
+
+  /**
+   * List files in a directory
+   * @param path - Directory path to list
+   * @param sessionId - The session ID for this operation
+   * @param options - Optional settings (recursive, includeHidden)
+   */
+  async listFiles(
+    path: string,
+    sessionId: string,
+    options?: ListFilesOptions
+  ): Promise<ListFilesResult> {
+    try {
+      const data = {
+        path,
+        sessionId,
+        options: options || {},
+      };
+
+      const response = await this.post<ListFilesResult>('/api/list-files', data);
+
+      this.logSuccess('Files listed', `${path} (${response.count} files)`);
+      return response;
+    } catch (error) {
+      this.logError('listFiles', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Check if a file or directory exists
+   * @param path - Path to check
+   * @param sessionId - The session ID for this operation
+   */
+  async exists(
+    path: string,
+    sessionId: string
+  ): Promise<FileExistsResult> {
+    try {
+      const data = {
+        path,
+        sessionId,
+      };
+
+      const response = await this.post<FileExistsResult>('/api/exists', data);
+
+      this.logSuccess('Path existence checked', `${path} (exists: ${response.exists})`);
+      return response;
+    } catch (error) {
+      this.logError('exists', error);
+      throw error;
+    }
+  }
+}

package/src/clients/git-client.ts

@@ -0,0 +1,92 @@
+import type { GitCheckoutResult } from '@repo/shared';
+import { BaseHttpClient } from './base-client';
+import type { HttpClientOptions, SessionRequest } from './types';
+
+// Re-export for convenience
+export type { GitCheckoutResult };
+
+/**
+ * Request interface for Git checkout operations
+ */
+export interface GitCheckoutRequest extends SessionRequest {
+  repoUrl: string;
+  branch?: string;
+  targetDir?: string;
+}
+
+/**
+ * Client for Git repository operations
+ */
+export class GitClient extends BaseHttpClient {
+
+  /**
+   * Clone a Git repository
+   * @param repoUrl - URL of the Git repository to clone
+   * @param sessionId - The session ID for this operation
+   * @param options - Optional settings (branch, targetDir)
+   */
+  async checkout(
+    repoUrl: string,
+    sessionId: string,
+    options?: {
+      branch?: string;
+      targetDir?: string;
+    }
+  ): Promise<GitCheckoutResult> {
+    try {
+      // Determine target directory - use provided path or generate from repo name
+      let targetDir = options?.targetDir;
+      if (!targetDir) {
+        const repoName = this.extractRepoName(repoUrl);
+        // Ensure absolute path in /workspace
+        targetDir = `/workspace/${repoName}`;
+      }
+
+      const data: GitCheckoutRequest = {
+        repoUrl,
+        sessionId,
+        targetDir,
+      };
+
+      // Only include branch if explicitly specified
+      // This allows Git to use the repository's default branch
+      if (options?.branch) {
+        data.branch = options.branch;
+      }
+
+      const response = await this.post<GitCheckoutResult>(
+        '/api/git/checkout',
+        data
+      );
+
+      this.logSuccess(
+        'Repository cloned',
+        `${repoUrl} (branch: ${response.branch}) -> ${response.targetDir}`
+      );
+
+      return response;
+    } catch (error) {
+      this.logError('checkout', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Extract repository name from URL for default directory name
+   */
+  private extractRepoName(repoUrl: string): string {
+    try {
+      const url = new URL(repoUrl);
+      const pathParts = url.pathname.split('/');
+      const repoName = pathParts[pathParts.length - 1];
+      
+      // Remove .git extension if present
+      return repoName.replace(/\.git$/, '');
+    } catch {
+      // Fallback for invalid URLs
+      const parts = repoUrl.split('/');
+      const repoName = parts[parts.length - 1];
+      return repoName.replace(/\.git$/, '') || 'repo';
+    }
+  }
+}

package/src/clients/index.ts

@@ -0,0 +1,64 @@
+// Main client exports
+
+
+// Command client types
+export type {
+  ExecuteRequest,
+  ExecuteResponse,
+} from './command-client';
+
+// Domain-specific clients
+export { CommandClient } from './command-client';
+// File client types
+export type {
+  FileOperationRequest,
+  MkdirRequest,
+  ReadFileRequest,
+  WriteFileRequest,
+} from './file-client';
+export { FileClient } from './file-client';
+// Git client types
+export type {
+  GitCheckoutRequest,
+  GitCheckoutResult,
+} from './git-client';
+export { GitClient } from './git-client';
+export { type ExecutionCallbacks, InterpreterClient } from './interpreter-client';
+// Port client types
+export type {
+  ExposePortRequest,
+  PortCloseResult,
+  PortExposeResult,
+  PortListResult,
+  UnexposePortRequest,
+} from './port-client';
+export { PortClient } from './port-client';
+// Process client types
+export type {
+  ProcessCleanupResult,
+  ProcessInfoResult,
+  ProcessKillResult,
+  ProcessListResult,
+  ProcessLogsResult,
+  ProcessStartResult,
+  StartProcessRequest,
+} from './process-client';
+export { ProcessClient } from './process-client';
+export { SandboxClient } from './sandbox-client';
+// Types and interfaces
+export type {
+  BaseApiResponse,
+  ContainerStub,
+  ErrorResponse,
+  HttpClientOptions,
+  RequestConfig,
+  ResponseHandler,
+  SessionRequest,
+} from './types';
+// Utility client types
+export type {
+  CommandsResponse,
+  PingResponse,
+  VersionResponse,
+} from './utility-client';
+export { UtilityClient } from './utility-client';