Simplify getting started page

Author: ghostwriternr

src/content/docs/sandbox/get-started.mdx

@@ -7,220 +7,206 @@ sidebar:
 
 import { Render, PackageManagers, Steps, WranglerConfig } from "~/components";
 
-This guide will walk you through creating your first secure code execution environment using Sandbox SDK. You'll learn how to:
+Build your first application with Sandbox SDK - a secure code execution environment running on Cloudflare's global network. In this guide, you'll create a Worker that can execute Python code and work with files in isolated containers.
 
-- Create a Worker that can execute code in isolated sandboxes
-- Run commands and capture output
-- Work with files in the sandbox
-- Deploy your application globally
-
-By the end of this guide, you'll have a working sandbox that can safely execute Python code.
+:::note[What you're building]
+A simple API that can safely execute Python code and perform file operations, all running in isolated sandbox environments on Cloudflare's edge network.
+:::
 
 ## Prerequisites
 
 <Render file="prereqs" product="workers" />
 
 ### Ensure Docker is running locally
 
-Sandbox SDK uses [Docker](https://www.docker.com/) to build and push container images alongside your Worker. Docker must be running locally when you run `wrangler deploy`. The easiest way to install Docker is to follow the [Docker Desktop installation guide](https://docs.docker.com/desktop/).
+Sandbox SDK uses [Docker](https://www.docker.com/) to build container images alongside your Worker. Docker must be running when you deploy or run locally.
+
+Install Docker by following the [Docker Desktop installation guide](https://docs.docker.com/desktop/).
 
-You can verify Docker is running by executing:
+Verify Docker is running:
 
 ```sh
 docker info
 ```
 
-If Docker is running, the command will succeed. If not, it will hang or return "Cannot connect to the Docker daemon".
+If Docker is not running, this command will hang or return "Cannot connect to the Docker daemon".
 
-## 1. Create your first sandbox project
+## 1. Create a new project
 
-Create a new project using the Sandbox SDK template:
+Create a new Sandbox SDK project:
 
 <PackageManagers
 	type="create"
 	pkg="cloudflare@latest"
-	args={"my-sandbox --template=cloudflare/sandbox-sdk/examples/basic"}
+	args={"my-sandbox --template=cloudflare/sandbox-sdk/examples/minimal"}
 />
 
-This creates a new `my-sandbox` directory with:
+This creates a `my-sandbox` directory with everything you need:
 
-- A Worker at `src/index.ts` configured to handle sandbox requests
-- A `wrangler.jsonc` configuration file with container and Durable Objects setup
-- A `Dockerfile` that defines the sandbox container environment
-
-Change into your new project directory:
+- `src/index.ts` - Worker with sandbox integration
+- `wrangler.jsonc` - Configuration for Workers and Containers
+- `Dockerfile` - Container environment definition
 
 ```sh
 cd my-sandbox
 ```
 
-## 2. Understanding the configuration
-
-Your `wrangler.jsonc` file contains the configuration for both your Worker and the sandbox container:
-
-<WranglerConfig>
-
-```jsonc
-{
-  "containers": [
-    {
-      "class_name": "Sandbox",
-      "image": "./Dockerfile",
-      "name": "sandbox",
-      "max_instances": 1
-    }
-  ],
-  "durable_objects": {
-    "bindings": [
-      {
-        "class_name": "Sandbox",
-        "name": "Sandbox"
-      }
-    ]
-  },
-  "migrations": [
-    {
-      "new_sqlite_classes": ["Sandbox"],
-      "tag": "v1"
-    }
-  ]
-}
-```
-
-</WranglerConfig>
-
-Key points:
-
-- `containers` - Defines the container image and configuration
-- `durable_objects` - Each sandbox runs in its own Durable Object for isolation
-- `migrations` - Required for Durable Objects using SQLite storage
+## 2. Explore the template
 
-## 3. Create your first sandbox Worker
-
-Replace the contents of `src/index.ts` with this simple example:
+The template provides a minimal Worker that demonstrates core sandbox capabilities:
 
 ```typescript
-import { getSandbox, type Sandbox } from '@cloudflare/sandbox';
+import { getSandbox, proxyToSandbox, type Sandbox } from '@cloudflare/sandbox';
 
 export { Sandbox } from '@cloudflare/sandbox';
 
 type Env = {
-	Sandbox: DurableObjectNamespace<Sandbox>;
+  Sandbox: DurableObjectNamespace<Sandbox>;
 };
 
 export default {
-	async fetch(request: Request, env: Env): Promise<Response> {
-		const url = new URL(request.url);
-
-		// Get a sandbox instance with a unique ID
-		const sandbox = getSandbox(env.Sandbox, 'my-first-sandbox');
-
-		// Execute Python code in the sandbox
-		if (url.pathname === '/run') {
-			const result = await sandbox.exec('python', [
-				'-c',
-				'print("Hello from Sandbox SDK!")'
-			]);
-
-			return Response.json({
-				stdout: result.stdout,
-				stderr: result.stderr,
-				exitCode: result.exitCode,
-				success: result.success
-			});
-		}
-
-		// Write and read a file
-		if (url.pathname === '/file') {
-			await sandbox.writeFile('/tmp/message.txt', 'Hello, World!');
-			const content = await sandbox.readFile('/tmp/message.txt');
-
-			return Response.json({
-				content: content,
-				message: 'File written and read successfully'
-			});
-		}
-
-		return new Response('Try /run or /file endpoints', { status: 200 });
-	},
+  async fetch(request: Request, env: Env): Promise<Response> {
+    // Required for preview URLs (if you expose ports later)
+    const proxyResponse = await proxyToSandbox(request, env);
+    if (proxyResponse) return proxyResponse;
+
+    const url = new URL(request.url);
+
+    // Get or create a sandbox instance
+    const sandbox = getSandbox(env.Sandbox, 'my-sandbox');
+
+    // Execute Python code
+    if (url.pathname === '/run') {
+      const result = await sandbox.exec('python -c "print(2 + 2)"');
+      return Response.json({
+        output: result.stdout,
+        success: result.success
+      });
+    }
+
+    // Work with files
+    if (url.pathname === '/file') {
+      await sandbox.writeFile('/workspace/hello.txt', 'Hello, Sandbox!');
+      const file = await sandbox.readFile('/workspace/hello.txt');
+      return Response.json({
+        content: file.content
+      });
+    }
+
+    return new Response('Try /run or /file');
+  },
 };
 ```
 
-This Worker demonstrates two key Sandbox SDK features:
+**Key concepts**:
 
-1. **Command Execution** - Run Python code and capture output
-2. **File Operations** - Write and read files in the sandbox
+- `getSandbox()` - Gets or creates a sandbox instance by ID
+- `proxyToSandbox()` - Required at the top for preview URLs to work
+- `sandbox.exec()` - Execute commands and capture output
+- `sandbox.writeFile()` / `readFile()` - File operations
 
-## 4. Test locally
+## 3. Test locally
 
-Before deploying, test your sandbox locally:
+Start the development server:
 
 ```sh
 npm run dev
 ```
 
 :::note
-The first time you run `wrangler dev`, it will build the Docker container image. This may take a few minutes. Subsequent runs will be much faster due to Docker's layer caching.
+First run builds the Docker container (2-3 minutes). Subsequent runs are much faster due to caching.
 :::
 
-Once the dev server is running, open your browser and visit:
+Test the endpoints:
 
-- `http://localhost:8787/run` - Execute Python code
-- `http://localhost:8787/file` - Test file operations
+```sh
+# Execute Python code
+curl http://localhost:8787/run
 
-You should see JSON responses with the output from each operation.
+# File operations
+curl http://localhost:8787/file
+```
 
-## 5. Deploy your sandbox
+You should see JSON responses with the command output and file contents.
 
-Deploy your Worker and sandbox container to Cloudflare's global network:
+## 4. Deploy to production
+
+Deploy your Worker and container:
 
 ```sh
 npx wrangler deploy
 ```
 
-When you run `wrangler deploy`:
-
-1. Wrangler builds your container image using Docker
-2. The image is pushed to Cloudflare's Container Registry
-3. Your Worker is deployed with the sandbox configuration
+This will:
+1. Build your container image using Docker
+2. Push it to Cloudflare's Container Registry
+3. Deploy your Worker globally
 
-:::note
-After your first deployment, wait 2-3 minutes for the container to be fully provisioned before making requests. During this time, the Worker is deployed but sandbox operations may error.
+:::caution[Wait for provisioning]
+After first deployment, wait 2-3 minutes before making requests. The Worker deploys immediately, but the container needs time to provision.
 :::
 
-### Check deployment status
-
-Verify your sandbox is ready:
+Check deployment status:
 
 ```sh
 npx wrangler containers list
 ```
 
-This shows all containers in your account and their deployment status.
-
-## 6. Test your deployed sandbox
+## 5. Test your deployment
 
-Visit your deployed Worker URL (shown in the deploy output):
+Visit your Worker URL (shown in deploy output):
 
-```
-https://my-sandbox.<YOUR_SUBDOMAIN>.workers.dev/run
+```sh
+# Replace with your actual URL
+curl https://my-sandbox.YOUR_SUBDOMAIN.workers.dev/run
 ```
 
-You should see the same JSON response as when testing locally, but now running on Cloudflare's global network.
+Your sandbox is now running globally on Cloudflare's network.
+
+## Understanding the configuration
+
+Your `wrangler.jsonc` connects three pieces together:
+
+<WranglerConfig>
+
+```jsonc
+{
+  "containers": [
+    {
+      "class_name": "Sandbox",
+      "image": "./Dockerfile"
+    }
+  ],
+  "durable_objects": {
+    "bindings": [
+      {
+        "class_name": "Sandbox",
+        "name": "Sandbox"
+      }
+    ]
+  },
+  "migrations": [
+    {
+      "new_sqlite_classes": ["Sandbox"],
+      "tag": "v1"
+    }
+  ]
+}
+```
 
-## Summary
+</WranglerConfig>
 
-In this guide, you:
+- **containers** - Your Dockerfile defines the execution environment
+- **durable_objects** - Makes the `Sandbox` binding available in your Worker
+- **migrations** - Initializes Durable Object storage (required once)
 
-- Created a Worker with Sandbox SDK integration
-- Executed Python code in an isolated sandbox
-- Worked with files in the sandbox environment
-- Deployed your sandbox globally
+For detailed configuration options including environment variables, secrets, and custom images, see the [Wrangler configuration reference](/sandbox/configuration/wrangler/).
 
 ## Next steps
 
-- Learn about [command execution](/sandbox/guides/execute-commands/) with streaming output
-- Explore [file operations](/sandbox/guides/manage-files/) and working with projects
-- Set up [preview URLs](/sandbox/guides/expose-services/) to expose services running in your sandbox
-- Review the [API reference](/sandbox/api/) for all available methods
-- Check out [examples](/sandbox/examples/) including AI code execution and data analysis
+Now that you have a working sandbox, explore more capabilities:
+
+- [Execute commands](/sandbox/guides/execute-commands/) - Run shell commands and stream output
+- [Manage files](/sandbox/guides/manage-files/) - Work with files and directories
+- [Expose services](/sandbox/guides/expose-services/) - Get public URLs for services running in your sandbox
+- [API reference](/sandbox/api/) - Complete API documentation