@umituz/web-cloudflare 1.0.1 → 1.1.0

package/README.md

@@ -5,6 +5,7 @@ Comprehensive Cloudflare Workers integration with config-based patterns, middlew
 ## 🚀 Features
 
 - ✅ **Config-Based Patterns** - Pre-built configurations for different app types
+- ✅ **Wrangler CLI Integration** - TypeScript wrapper for Wrangler CLI commands
 - ✅ **Express-like Router** - Simple, intuitive routing with middleware support
 - ✅ **Comprehensive Middleware** - CORS, caching, rate limiting, security, compression
 - ✅ **Workers AI Integration** - AI content generation with emotion control
@@ -130,6 +131,50 @@ const analysis = await aiService.analyzeSentiment(content);
 // { sentiment: 'positive', confidence: 0.89, emotions: ['excited'] }
 ```
 
+### Using Wrangler CLI
+
+```typescript
+import { WranglerService } from '@umituz/web-cloudflare/wrangler';
+
+const wrangler = new WranglerService();
+
+// Authentication
+await wrangler.login();
+const authInfo = await wrangler.whoami();
+
+// Project management
+await wrangler.init('my-worker', 'typescript');
+await wrangler.deploy({ env: 'production' });
+
+// Start development server
+await wrangler.dev({ port: 8787, local: true });
+
+// KV operations
+const namespace = await wrangler.kvNamespaceCreate('MY_KV');
+await wrangler.kvKeyPut(namespace.id, 'key', 'value');
+const value = await wrangler.kvKeyGet(namespace.id, 'key');
+
+// R2 operations
+await wrangler.r2BucketCreate('my-bucket');
+const buckets = await wrangler.r2BucketList();
+await wrangler.r2ObjectPut('my-bucket', 'file.txt', './local-file.txt');
+
+// D1 operations
+const db = await wrangler.d1Create('my-database');
+const result = await wrangler.d1Execute('my-database', 'SELECT * FROM users');
+
+// Secrets management
+await wrangler.secretPut('API_KEY', 'secret-value');
+const secrets = await wrangler.secretList();
+
+// Monitoring
+await wrangler.tail({ format: 'json' });
+
+// Version management
+const versions = await wrangler.versionsList();
+await wrangler.versionsRollback(versions[0].id);
+```
+
 ## 📚 Subpath Exports
 
 ### Services
@@ -152,6 +197,9 @@ import { ImagesService } from '@umituz/web-cloudflare/images';
 
 // Analytics
 import { AnalyticsService } from '@umituz/web-cloudflare/analytics';
+
+// Wrangler CLI
+import { WranglerService } from '@umituz/web-cloudflare/wrangler';
 ```
 
 ### Workflows & AI

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/web-cloudflare",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Comprehensive Cloudflare Workers integration with config-based patterns, middleware, router, workflows, and AI",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -16,6 +16,7 @@
     "./workflows": "./src/infrastructure/services/workflows/index.ts",
     "./ai-gateway": "./src/infrastructure/services/ai-gateway/index.ts",
     "./workers-ai": "./src/infrastructure/services/ai-gateway/index.ts",
+    "./wrangler": "./src/infrastructure/services/wrangler/index.ts",
     "./router": "./src/infrastructure/router/index.ts",
     "./middleware": "./src/infrastructure/middleware/index.ts",
     "./utils": "./src/infrastructure/utils/helpers.ts",
@@ -36,6 +37,8 @@
   "keywords": [
     "cloudflare",
     "workers",
+    "wrangler",
+    "wrangler-cli",
     "edge",
     "kv",
     "r2",

package/src/domain/entities/wrangler.entity.ts

@@ -0,0 +1,142 @@
+/**
+ * Wrangler CLI Domain Entities
+ * Defines entities for Wrangler CLI operations
+ */
+
+/**
+ * Wrangler command types
+ */
+export enum WranglerCommand {
+  // Authentication
+  LOGIN = 'login',
+  LOGOUT = 'logout',
+  WHOAMI = 'whoami',
+
+  // Project management
+  INIT = 'init',
+  DEV = 'dev',
+  DEPLOY = 'deploy',
+  DELETE = 'delete',
+
+  // KV operations
+  KV_NAMESPACE_CREATE = 'kv:namespace create',
+  KV_NAMESPACE_LIST = 'kv:namespace list',
+  KV_KEY_PUT = 'kv:key put',
+  KV_KEY_GET = 'kv:key get',
+  KV_KEY_LIST = 'kv:key list',
+  KV_KEY_DELETE = 'kv:key delete',
+
+  // R2 operations
+  R2_BUCKET_CREATE = 'r2 bucket create',
+  R2_BUCKET_LIST = 'r2 bucket list',
+  R2_BUCKET_DELETE = 'r2 bucket delete',
+  R2_OBJECT_PUT = 'r2 object put',
+  R2_OBJECT_GET = 'r2 object get',
+  R2_OBJECT_LIST = 'r2 object list',
+  R2_OBJECT_DELETE = 'r2 object delete',
+
+  // D1 operations
+  D1_CREATE = 'd1 create',
+  D1_LIST = 'd1 list',
+  D1_EXECUTE = 'd1 execute',
+  D1_BACKUP = 'd1 backups create',
+
+  // Secrets
+  SECRET_PUT = 'secret put',
+  SECRET_LIST = 'secret list',
+  SECRET_DELETE = 'secret delete',
+
+  // Monitoring
+  TAIL = 'tail',
+  ANALYTICS = 'analytics',
+
+  // Versions
+  VERSIONS_LIST = 'versions list',
+  VERSIONS_ROLLBACK = 'versions rollback',
+}
+
+/**
+ * Wrangler execution result
+ */
+export interface WranglerResult<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  stdout?: string;
+  stderr?: string;
+  exitCode?: number;
+}
+
+/**
+ * Wrangler command options
+ */
+export interface WranglerCommandOptions {
+  cwd?: string;
+  env?: Record<string, string>;
+  timeout?: number;
+  silent?: boolean;
+}
+
+/**
+ * Auth information
+ */
+export interface AuthInfo {
+  email?: string;
+  accountId?: string;
+  username?: string;
+}
+
+/**
+ * KV namespace info
+ */
+export interface KVNamespaceInfo {
+  id: string;
+  title: string;
+  supportsUrlEncoding?: boolean;
+}
+
+/**
+ * R2 bucket info
+ */
+export interface R2BucketInfo {
+  name: string;
+  creationDate?: string;
+  location?: string;
+}
+
+/**
+ * D1 database info
+ */
+export interface D1DatabaseInfo {
+  uuid: string;
+  name: string;
+  created_at: string;
+  version?: string;
+}
+
+/**
+ * Secret info
+ */
+export interface SecretInfo {
+  name: string;
+  type?: string;
+}
+
+/**
+ * Worker version info
+ */
+export interface WorkerVersionInfo {
+  id: string;
+  created_at: string;
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Analytics data
+ */
+export interface AnalyticsData {
+  requests?: number;
+  errors?: number;
+  statusCodes?: Record<string, number>;
+  countries?: Record<string, number>;
+}

package/src/domain/interfaces/wrangler.interface.ts

@@ -0,0 +1,130 @@
+/**
+ * Wrangler Service Interface
+ * Defines the contract for Wrangler CLI operations
+ */
+
+import type {
+  WranglerResult,
+  WranglerCommandOptions,
+  AuthInfo,
+  KVNamespaceInfo,
+  R2BucketInfo,
+  D1DatabaseInfo,
+  SecretInfo,
+  WorkerVersionInfo,
+  AnalyticsData,
+} from '../entities/wrangler.entity';
+
+export interface IWranglerService {
+  // Authentication
+  login(options?: WranglerCommandOptions): Promise<WranglerResult<AuthInfo>>;
+  logout(options?: WranglerCommandOptions): Promise<WranglerResult<void>>;
+  whoami(options?: WranglerCommandOptions): Promise<WranglerResult<AuthInfo>>;
+
+  // Project management
+  init(
+    projectName: string,
+    template?: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<void>>;
+  dev(
+    options?: WranglerCommandOptions & { port?: number; local?: boolean }
+  ): Promise<WranglerResult<void>>;
+  deploy(
+    options?: WranglerCommandOptions & { env?: string }
+  ): Promise<WranglerResult<{ url?: string }>>;
+  deleteWorker(
+    workerName: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<void>>;
+
+  // KV operations
+  kvNamespaceCreate(
+    title: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<KVNamespaceInfo>>;
+  kvNamespaceList(
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<KVNamespaceInfo[]>>;
+  kvKeyPut(
+    namespaceId: string,
+    key: string,
+    value: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<void>>;
+  kvKeyGet(
+    namespaceId: string,
+    key: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<string>>;
+  kvKeyDelete(
+    namespaceId: string,
+    key: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<void>>;
+
+  // R2 operations
+  r2BucketCreate(
+    bucketName: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<R2BucketInfo>>;
+  r2BucketList(
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<R2BucketInfo[]>>;
+  r2BucketDelete(
+    bucketName: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<void>>;
+  r2ObjectPut(
+    bucketName: string,
+    key: string,
+    file: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<void>>;
+
+  // D1 operations
+  d1Create(
+    databaseName: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<D1DatabaseInfo>>;
+  d1List(options?: WranglerCommandOptions): Promise<WranglerResult<D1DatabaseInfo[]>>;
+  d1Execute(
+    databaseName: string,
+    command: string,
+    file?: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<unknown[]>>;
+
+  // Secrets
+  secretPut(
+    secretName: string,
+    value: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<void>>;
+  secretList(options?: WranglerCommandOptions): Promise<WranglerResult<SecretInfo[]>>;
+  secretDelete(
+    secretName: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<void>>;
+
+  // Monitoring
+  tail(
+    options?: WranglerCommandOptions & { format?: 'pretty' | 'json' }
+  ): Promise<WranglerResult<void>>;
+
+  // Versions
+  versionsList(
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<WorkerVersionInfo[]>>;
+  versionsRollback(
+    versionId: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<void>>;
+
+  // Generic command execution
+  executeCommand(
+    command: string,
+    args: string[],
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<string>>;
+}

package/src/index.ts

@@ -38,6 +38,7 @@ export * from "./infrastructure/services/images";
 export * from "./infrastructure/services/analytics";
 export * from "./infrastructure/services/workflows";
 export * from "./infrastructure/services/ai-gateway";
+export * from "./infrastructure/services/wrangler";
 
 // Infrastructure - Router, Middleware, Utils
 export * from "./infrastructure/router";

package/src/infrastructure/services/wrangler/index.ts

@@ -0,0 +1,17 @@
+/**
+ * Wrangler Service Exports
+ */
+
+export { WranglerService } from './wrangler.service';
+export type {
+  WranglerResult,
+  WranglerCommandOptions,
+  AuthInfo,
+  KVNamespaceInfo,
+  R2BucketInfo,
+  D1DatabaseInfo,
+  SecretInfo,
+  WorkerVersionInfo,
+  AnalyticsData,
+} from '../../domain/entities/wrangler.entity';
+export type { IWranglerService } from '../../domain/interfaces/wrangler.interface';

package/src/infrastructure/services/wrangler/wrangler.service.ts

@@ -0,0 +1,461 @@
+/**
+ * Wrangler Service Implementation
+ * Wraps Wrangler CLI commands with TypeScript
+ */
+
+import { exec, spawn } from 'child_process';
+import { promisify } from 'util';
+import type {
+  WranglerResult,
+  WranglerCommandOptions,
+  AuthInfo,
+  KVNamespaceInfo,
+  R2BucketInfo,
+  D1DatabaseInfo,
+  SecretInfo,
+  WorkerVersionInfo,
+} from '../../../domain/entities/wrangler.entity';
+import type { IWranglerService } from '../../../domain/interfaces/wrangler.interface';
+
+const execAsync = promisify(exec);
+
+export class WranglerService implements IWranglerService {
+  private readonly wranglerCommand: string;
+
+  constructor(options?: { wranglerPath?: string }) {
+    this.wranglerCommand = options?.wranglerPath || 'npx wrangler';
+  }
+
+  /**
+   * Execute a wrangler command
+   */
+  private async execute(
+    args: string[],
+    options: WranglerCommandOptions = {}
+  ): Promise<WranglerResult<string>> {
+    const { cwd = process.cwd(), env = {}, timeout = 30000, silent = false } = options;
+
+    const command = `${this.wranglerCommand} ${args.join(' ')}`;
+
+    try {
+      if (!silent) {
+        console.log(`🔧 Executing: ${command}`);
+      }
+
+      const { stdout, stderr } = await execAsync(command, {
+        cwd,
+        env: { ...process.env, ...env },
+        timeout,
+      });
+
+      return {
+        success: true,
+        data: stdout.trim(),
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+      };
+    } catch (error: unknown) {
+      const err = error as { stdout?: string; stderr?: string; code?: number };
+      return {
+        success: false,
+        error: err.stderr || err.stdout || String(error),
+        exitCode: err.code,
+      };
+    }
+  }
+
+  /**
+   * Execute a wrangler command with streaming (for dev, tail, etc.)
+   */
+  private executeStreaming(
+    args: string[],
+    options: WranglerCommandOptions = {}
+  ): Promise<WranglerResult<void>> {
+    return new Promise((resolve, reject) => {
+      const { cwd = process.cwd(), env = {} } = options;
+      const argsWithCommand = this.wranglerCommand.split(' ').concat(args);
+
+      const child = spawn(argsWithCommand[0], argsWithCommand.slice(1), {
+        cwd,
+        env: { ...process.env, ...env },
+        stdio: 'inherit',
+      });
+
+      child.on('close', (code) => {
+        if (code === 0) {
+          resolve({ success: true });
+        } else {
+          resolve({
+            success: false,
+            error: `Command exited with code ${code}`,
+            exitCode: code,
+          });
+        }
+      });
+
+      child.on('error', (error) => {
+        resolve({
+          success: false,
+          error: error.message,
+        });
+      });
+    });
+  }
+
+  /**
+   * Parse JSON from stdout
+   */
+  private parseJSON<T>(stdout: string): T | null {
+    try {
+      // Find JSON in output (wrangler sometimes outputs text before JSON)
+      const jsonMatch = stdout.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        return JSON.parse(jsonMatch[0]) as T;
+      }
+      return JSON.parse(stdout) as T;
+    } catch {
+      return null;
+    }
+  }
+
+  // ==================== Authentication ====================
+
+  async login(options?: WranglerCommandOptions): Promise<WranglerResult<AuthInfo>> {
+    const result = await this.execute(['login'], options);
+    if (result.success) {
+      return {
+        ...result,
+        data: { email: 'authenticated' },
+      };
+    }
+    return result;
+  }
+
+  async logout(options?: WranglerCommandOptions): Promise<WranglerResult<void>> {
+    return this.execute(['logout'], options);
+  }
+
+  async whoami(options?: WranglerCommandOptions): Promise<WranglerResult<AuthInfo>> {
+    const result = await this.execute(['whoami', '--json'], options);
+    if (result.success && result.data) {
+      const data = this.parseJSON<AuthInfo>(result.data);
+      return {
+        ...result,
+        data: data || { email: 'authenticated' },
+      };
+    }
+    return result;
+  }
+
+  // ==================== Project Management ====================
+
+  async init(
+    projectName: string,
+    template?: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<void>> {
+    const args = ['init', projectName];
+    if (template) {
+      args.push('--template', template);
+    }
+    return this.execute(args, options);
+  }
+
+  async dev(
+    options?: WranglerCommandOptions & { port?: number; local?: boolean }
+  ): Promise<WranglerResult<void>> {
+    const args = ['dev'];
+    if (options?.port) {
+      args.push('--port', options.port.toString());
+    }
+    if (options?.local) {
+      args.push('--local');
+    }
+    return this.executeStreaming(args, options);
+  }
+
+  async deploy(
+    options?: WranglerCommandOptions & { env?: string }
+  ): Promise<WranglerResult<{ url?: string }>> {
+    const args = ['deploy'];
+    if (options?.env) {
+      args.push('--env', options.env);
+    }
+    const result = await this.execute(args, options);
+
+    if (result.success && result.data) {
+      // Extract URL from output
+      const urlMatch = result.data.match(/https?:\/\/[^\s]+/);
+      return {
+        ...result,
+        data: { url: urlMatch?.[0] },
+      };
+    }
+
+    return result;
+  }
+
+  async deleteWorker(
+    workerName: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<void>> {
+    return this.execute(['delete', workerName], options);
+  }
+
+  // ==================== KV Operations ====================
+
+  async kvNamespaceCreate(
+    title: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<KVNamespaceInfo>> {
+    const result = await this.execute(['kv:namespace', 'create', title], options);
+    if (result.success && result.data) {
+      const data = this.parseJSON<KVNamespaceInfo>(result.data);
+      if (data) {
+        return { ...result, data };
+      }
+    }
+    return result;
+  }
+
+  async kvNamespaceList(
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<KVNamespaceInfo[]>> {
+    const result = await this.execute(['kv:namespace', 'list'], options);
+    if (result.success && result.data) {
+      const data = this.parseJSON<KVNamespaceInfo[]>(result.data);
+      if (data) {
+        return { ...result, data };
+      }
+    }
+    return result;
+  }
+
+  async kvKeyPut(
+    namespaceId: string,
+    key: string,
+    value: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<void>> {
+    return this.execute(['kv:key', 'put', '--namespace-id', namespaceId, key, value], options);
+  }
+
+  async kvKeyGet(
+    namespaceId: string,
+    key: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<string>> {
+    return this.execute(['kv:key', 'get', '--namespace-id', namespaceId, key], options);
+  }
+
+  async kvKeyDelete(
+    namespaceId: string,
+    key: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<void>> {
+    return this.execute(['kv:key', 'delete', '--namespace-id', namespaceId, key], options);
+  }
+
+  // ==================== R2 Operations ====================
+
+  async r2BucketCreate(
+    bucketName: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<R2BucketInfo>> {
+    const result = await this.execute(['r2', 'bucket', 'create', bucketName], options);
+    if (result.success) {
+      return {
+        ...result,
+        data: { name: bucketName },
+      };
+    }
+    return result;
+  }
+
+  async r2BucketList(
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<R2BucketInfo[]>> {
+    const result = await this.execute(['r2', 'bucket', 'list'], options);
+    if (result.success && result.data) {
+      const data = this.parseJSON<R2BucketInfo[]>(result.data);
+      if (data) {
+        return { ...result, data };
+      }
+    }
+    return result;
+  }
+
+  async r2BucketDelete(
+    bucketName: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<void>> {
+    return this.execute(['r2', 'bucket', 'delete', bucketName], options);
+  }
+
+  async r2ObjectPut(
+    bucketName: string,
+    key: string,
+    file: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<void>> {
+    return this.execute(['r2', 'object', 'put', bucketName, key, '--file', file], options);
+  }
+
+  // ==================== D1 Operations ====================
+
+  async d1Create(
+    databaseName: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<D1DatabaseInfo>> {
+    const result = await this.execute(['d1', 'create', databaseName], options);
+    if (result.success && result.data) {
+      const data = this.parseJSON<D1DatabaseInfo>(result.data);
+      if (data) {
+        return { ...result, data };
+      }
+    }
+    return result;
+  }
+
+  async d1List(options?: WranglerCommandOptions): Promise<WranglerResult<D1DatabaseInfo[]>> {
+    const result = await this.execute(['d1', 'list'], options);
+    if (result.success && result.data) {
+      const data = this.parseJSON<D1DatabaseInfo[]>(result.data);
+      if (data) {
+        return { ...result, data };
+      }
+    }
+    return result;
+  }
+
+  async d1Execute(
+    databaseName: string,
+    command: string,
+    file?: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<unknown[]>> {
+    const args = ['d1', 'execute', databaseName];
+    if (file) {
+      args.push('--file', file);
+    } else {
+      args.push('--command', command);
+    }
+    const result = await this.execute(args, options);
+    if (result.success && result.data) {
+      const data = this.parseJSON<unknown[]>(result.data);
+      if (data) {
+        return { ...result, data };
+      }
+    }
+    return result;
+  }
+
+  // ==================== Secrets ====================
+
+  async secretPut(
+    secretName: string,
+    value: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<void>> {
+    // For secrets, we need to use stdin
+    return new Promise((resolve) => {
+      const args = ['secret', 'put', secretName];
+      const argsWithCommand = this.wranglerCommand.split(' ').concat(args);
+
+      const child = spawn(argsWithCommand[0], argsWithCommand.slice(1), {
+        cwd: options?.cwd || process.cwd(),
+        env: { ...process.env, ...options?.env },
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout?.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      child.stderr?.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      child.on('close', (code) => {
+        if (code === 0) {
+          resolve({ success: true, stdout: stdout.trim() });
+        } else {
+          resolve({
+            success: false,
+            error: stderr || 'Failed to put secret',
+            exitCode: code,
+          });
+        }
+      });
+
+      // Write the secret value to stdin
+      child.stdin?.write(value);
+      child.stdin?.end();
+    });
+  }
+
+  async secretList(options?: WranglerCommandOptions): Promise<WranglerResult<SecretInfo[]>> {
+    const result = await this.execute(['secret', 'list'], options);
+    if (result.success && result.data) {
+      const data = this.parseJSON<SecretInfo[]>(result.data);
+      if (data) {
+        return { ...result, data };
+      }
+    }
+    return result;
+  }
+
+  async secretDelete(
+    secretName: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<void>> {
+    return this.execute(['secret', 'delete', secretName], options);
+  }
+
+  // ==================== Monitoring ====================
+
+  async tail(
+    options?: WranglerCommandOptions & { format?: 'pretty' | 'json' }
+  ): Promise<WranglerResult<void>> {
+    const args = ['tail'];
+    if (options?.format) {
+      args.push('--format', options.format);
+    }
+    return this.executeStreaming(args, options);
+  }
+
+  // ==================== Versions ====================
+
+  async versionsList(
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<WorkerVersionInfo[]>> {
+    const result = await this.execute(['versions', 'list'], options);
+    if (result.success && result.data) {
+      const data = this.parseJSON<WorkerVersionInfo[]>(result.data);
+      if (data) {
+        return { ...result, data };
+      }
+    }
+    return result;
+  }
+
+  async versionsRollback(
+    versionId: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<void>> {
+    return this.execute(['versions', 'rollback', '--version-id', versionId], options);
+  }
+
+  // ==================== Generic Command Execution ====================
+
+  async executeCommand(
+    command: string,
+    args: string[],
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<string>> {
+    return this.execute([command, ...args], options);
+  }
+}