update skills

.agents/skills/cloudflare-deploy/references/sandbox/patterns.md

@@ -0,0 +1,201 @@
+# Common Patterns
+
+## AI Code Execution with Code Context
+
+```typescript
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    const { code, variables } = await request.json();
+    const sandbox = getSandbox(env.Sandbox, 'ai-agent');
+    
+    // Create context with persistent variables
+    const ctx = await sandbox.createCodeContext({
+      language: 'python',
+      variables: variables || {}
+    });
+    
+    // Execute with rich outputs (text, images, HTML)
+    const result = await ctx.runCode(code);
+    
+    return Response.json({
+      outputs: result.outputs,  // [{ type: 'text'|'image'|'html', content }]
+      error: result.error,
+      success: !result.error
+    });
+  }
+};
+```
+
+## Interactive Dev Environment
+
+```typescript
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    const proxyResponse = await proxyToSandbox(request, env);
+    if (proxyResponse) return proxyResponse;
+    
+    const sandbox = getSandbox(env.Sandbox, 'ide', { normalizeId: true });
+    
+    if (request.url.endsWith('/start')) {
+      await sandbox.exec('curl -fsSL https://code-server.dev/install.sh | sh');
+      await sandbox.startProcess('code-server --bind-addr 0.0.0.0:8080', {
+        processId: 'vscode'
+      });
+      
+      const exposed = await sandbox.exposePort(8080);
+      return Response.json({ url: exposed.url });
+    }
+    
+    return new Response('Try /start');
+  }
+};
+```
+
+## WebSocket Real-Time Service
+
+```typescript
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    const proxyResponse = await proxyToSandbox(request, env);
+    if (proxyResponse) return proxyResponse;
+
+    if (request.headers.get('Upgrade')?.toLowerCase() === 'websocket') {
+      const sandbox = getSandbox(env.Sandbox, 'realtime-service');
+      return await sandbox.wsConnect(request, 8080);
+    }
+
+    // Non-WebSocket: expose preview URL
+    const sandbox = getSandbox(env.Sandbox, 'realtime-service');
+    const { url } = await sandbox.exposePort(8080, {
+      hostname: new URL(request.url).hostname
+    });
+    return Response.json({ wsUrl: url.replace('https', 'wss') });
+  }
+};
+```
+
+**Dockerfile**:
+```dockerfile
+FROM docker.io/cloudflare/sandbox:latest
+RUN npm install -g ws
+EXPOSE 8080
+```
+
+## Process Readiness Pattern
+
+```typescript
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    const sandbox = getSandbox(env.Sandbox, 'app-server');
+    
+    // Start server
+    const process = await sandbox.startProcess(
+      'node server.js',
+      { processId: 'server' }
+    );
+    
+    // Wait for server to be ready
+    await process.waitForPort(8080);  // Wait for port listening
+    
+    // Now safe to expose
+    const { url } = await sandbox.exposePort(8080);
+    return Response.json({ url });
+  }
+};
+```
+
+## Persistent Data with Bucket Mounting
+
+```typescript
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    const sandbox = getSandbox(env.Sandbox, 'data-processor');
+    
+    // Mount R2 bucket (production only)
+    await sandbox.mountBucket(env.DATA_BUCKET, '/data', {
+      readOnly: false
+    });
+    
+    // Process files in bucket
+    const result = await sandbox.exec('python3 /workspace/process.py', {
+      env: { DATA_DIR: '/data/input' }
+    });
+    
+    // Results written to /data/output are persisted in R2
+    return Response.json({ success: result.success });
+  }
+};
+```
+
+## CI/CD Pipeline
+
+```typescript
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    const { repo, branch } = await request.json();
+    const sandbox = getSandbox(env.Sandbox, `ci-${repo}-${Date.now()}`);
+    
+    await sandbox.exec(`git clone -b ${branch} ${repo} /workspace/repo`);
+    
+    const install = await sandbox.exec('npm install', {
+      cwd: '/workspace/repo',
+      stream: true,
+      onOutput: (stream, data) => console.log(data)
+    });
+    
+    if (!install.success) {
+      return Response.json({ success: false, error: 'Install failed' });
+    }
+    
+    const test = await sandbox.exec('npm test', { cwd: '/workspace/repo' });
+    
+    return Response.json({
+      success: test.success,
+      output: test.stdout,
+      exitCode: test.exitCode
+    });
+  }
+};
+```
+
+
+
+
+
+## Multi-Tenant Pattern
+
+```typescript
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    const userId = request.headers.get('X-User-ID');
+    const sandbox = getSandbox(env.Sandbox, 'multi-tenant');
+    
+    // Each user gets isolated session
+    let session;
+    try {
+      session = await sandbox.getSession(userId);
+    } catch {
+      session = await sandbox.createSession({
+        id: userId,
+        cwd: `/workspace/users/${userId}`,
+        env: { USER_ID: userId }
+      });
+    }
+    
+    const code = await request.text();
+    const result = await session.exec(`python3 -c "${code}"`);
+    
+    return Response.json({ output: result.stdout });
+  }
+};
+```
+
+## Git Operations
+
+```typescript
+// Clone repo
+await sandbox.exec('git clone https://github.com/user/repo.git /workspace/repo');
+
+// Authenticated (use env secrets)
+await sandbox.exec(`git clone https://${env.GITHUB_TOKEN}@github.com/user/repo.git`);
+```