Add process readiness documentation

Documents the new process readiness feature from PR #273 including:

- serve() method for starting servers with automatic readiness and exposure
- waitFor() method for waiting on process conditions
- ready and readyTimeout options for startProcess()
- Support for string, RegExp, and port-based readiness conditions
- ProcessReadyTimeoutError and ProcessExitedBeforeReadyError handling

Updates:
- API reference (commands.mdx): Full documentation for serve(), waitFor(), and updated startProcess()
- Background processes guide: Comprehensive examples of readiness patterns
- Expose services guide: Simplified workflow using serve()

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: github-actions[bot]

src/content/docs/sandbox/api/commands.mdx

@@ -87,26 +87,42 @@ for await (const event of parseSSEStream<ExecEvent>(stream)) {
 Start a long-running background process.
 
 ```ts
-const process = await sandbox.startProcess(command: string, options?: ProcessOptions): Promise<ProcessInfo>
+const process = await sandbox.startProcess(command: string, options?: ProcessOptions): Promise<Process>
 ```
 
 **Parameters**:
 - `command` - The command to start as a background process
 - `options` (optional):
   - `cwd` - Working directory
   - `env` - Environment variables
+  - `ready` - Condition to wait for before returning (string, RegExp, or port number)
+  - `readyTimeout` - Maximum time to wait for ready condition in milliseconds (default: `30000`)
 
-**Returns**: `Promise<ProcessInfo>` with `id`, `pid`, `command`, `status`
+**Returns**: `Promise<Process>` with `id`, `pid`, `command`, `status`, and methods:
+- `waitFor(condition, timeout?)` - Wait for additional conditions
 
 <TypeScriptExample>
 ```
+// Basic usage
 const server = await sandbox.startProcess('python -m http.server 8000');
 console.log('Started with PID:', server.pid);
 
-// With custom environment
-const app = await sandbox.startProcess('node app.js', {
+// Wait for log pattern before proceeding
+const app = await sandbox.startProcess('npm start', {
+  ready: 'Server listening on port 3000',
+  readyTimeout: 30000
+});
+
+// Wait for port to be available
+const api = await sandbox.startProcess('node app.js', {
+  ready: 8080,
   cwd: '/workspace/my-app',
-  env: { NODE_ENV: 'production', PORT: '3000' }
+  env: { NODE_ENV: 'production' }
+});
+
+// Wait for regex pattern
+const db = await sandbox.startProcess('postgres', {
+  ready: /database system is ready/i
 });
 ```
 </TypeScriptExample>
@@ -195,21 +211,139 @@ for await (const log of parseSSEStream<LogEvent>(logStream)) {
 Get accumulated logs from a process.
 
 ```ts
-const logs = await sandbox.getProcessLogs(processId: string): Promise<string>
+const logs = await sandbox.getProcessLogs(processId: string): Promise<{ stdout: string, stderr: string }>
 ```
 
 **Parameters**:
 - `processId` - The process ID
 
-**Returns**: `Promise<string>` with all accumulated output
+**Returns**: `Promise<{ stdout: string, stderr: string }>` with all accumulated output
 
 <TypeScriptExample>
 ```
 const server = await sandbox.startProcess('node server.js');
 await new Promise(resolve => setTimeout(resolve, 5000));
 
 const logs = await sandbox.getProcessLogs(server.id);
-console.log('Server logs:', logs);
+console.log('Server logs:', logs.stdout);
+console.log('Server errors:', logs.stderr);
+```
+</TypeScriptExample>
+
+### `serve()`
+
+Start a server process, wait for it to be ready, and optionally expose it with a preview URL.
+
+```ts
+const result = await sandbox.serve(
+  command: string,
+  portOrOptions: number | ServeOptions
+): Promise<string | { url: string, process: Process }>
+```
+
+**Parameters**:
+- `command` - The command to start the server
+- `portOrOptions` - Port number or options object:
+  - `port` - Port number to expose
+  - `hostname` - Hostname for preview URL (required for URL exposure)
+  - `ready` - Custom readiness condition (defaults to port check)
+  - `timeout` - Readiness timeout in milliseconds (default: `60000`)
+  - `env` - Environment variables
+  - `cwd` - Working directory
+
+**Returns**:
+- If `hostname` provided: `Promise<{ url: string, process: Process }>` with preview URL
+- If no `hostname`: `Promise<string>` with local URL indication
+
+<TypeScriptExample>
+```
+// Simple port exposure with preview URL
+const { url, process } = await sandbox.serve('npm start', {
+  port: 3000,
+  hostname: request.url.hostname
+});
+
+console.log('Server accessible at:', url);
+
+// With custom readiness pattern
+const { url, process } = await sandbox.serve('python -m http.server 8080', {
+  port: 8080,
+  hostname: request.url.hostname,
+  ready: 'Serving HTTP',
+  timeout: 60000
+});
+
+// Without hostname (for internal use)
+const localUrl = await sandbox.serve('node api.js', 3000);
+// Returns: "http://localhost:3000"
+```
+</TypeScriptExample>
+
+### `process.waitFor()`
+
+Wait for a condition to be met for a running process. Available on the `Process` object returned by `startProcess()`.
+
+```ts
+const result = await process.waitFor(
+  condition: ReadyCondition,
+  timeout?: number
+): Promise<WaitForResult>
+```
+
+**Parameters**:
+- `condition` - String pattern, RegExp, or port number to wait for
+- `timeout` - Maximum wait time in milliseconds (default: `30000`)
+
+**Returns**: `Promise<WaitForResult>` with:
+- `line` - The matching log line (for string/regex conditions)
+- `match` - RegExp capture groups (for regex conditions)
+
+<TypeScriptExample>
+```
+const app = await sandbox.startProcess('npm run dev');
+
+// Wait for database connection
+await app.waitFor('Database connected');
+
+// Wait for port availability
+await app.waitFor(3000);
+
+// Wait for regex with capture groups
+const result = await app.waitFor(/Server started on port (\d+)/);
+console.log('Port:', result.match?.[1]); // "3000"
+
+// With custom timeout
+await app.waitFor('Ready', 60000);
+```
+</TypeScriptExample>
+
+## Error handling
+
+Process readiness operations may throw specific errors:
+
+<TypeScriptExample>
+```
+import {
+  ProcessReadyTimeoutError,
+  ProcessExitedBeforeReadyError
+} from '@cloudflare/sandbox';
+
+try {
+  const server = await sandbox.startProcess('npm start', {
+    ready: 'Server listening',
+    readyTimeout: 10000
+  });
+} catch (error) {
+  if (error instanceof ProcessReadyTimeoutError) {
+    // Process did not become ready in time
+    console.error('Timeout waiting for:', error.condition);
+    console.error('Last output:', error.stdout, error.stderr);
+  } else if (error instanceof ProcessExitedBeforeReadyError) {
+    // Process crashed before becoming ready
+    console.error('Process exited with code:', error.exitCode);
+    console.error('Output:', error.stdout, error.stderr);
+  }
+}
 ```
 </TypeScriptExample>