@zerodeploy/cli 0.1.0 → 0.1.2

package/README.md

@@ -1,18 +1,18 @@
 # ZeroDeploy CLI
 
-Command-line interface for deploying static sites to ZeroDeploy.
+Command-line interface for deploying static sites and SPAs to [ZeroDeploy](https://zerodeploy.dev).
 
 ## Installation
 
 ```bash
-# From the monorepo root
-bun install
-
-# Link CLI globally
-cd apps/cli && bun link
+npm install -g @zerodeploy/cli
 ```
 
-After linking, the `zerodeploy` command is available globally.
+Or use directly with npx:
+
+```bash
+npx @zerodeploy/cli deploy
+```
 
 ## Quick Start
 
@@ -24,26 +24,26 @@ zerodeploy login
 zerodeploy org create "My Company"
 
 # 3. Create a site
-zerodeploy site create my-company "My Website"
+zerodeploy site create my-company "My Website" --subdomain my-website
 
 # 4. Deploy your site
 zerodeploy deploy my-website --org my-company --dir ./dist
 ```
 
+Your site will be live at `https://my-website.zerodeploy.app`
+
 ## Commands
 
 ### Authentication
 
 #### `zerodeploy login`
 
-Authenticate with GitHub OAuth. Opens browser for authentication and stores JWT token locally.
+Authenticate with GitHub OAuth. Opens your browser for authentication.
 
 ```bash
 zerodeploy login
 ```
 
-Token is stored at `~/.zerodeploy/token`.
-
 #### `zerodeploy logout`
 
 Clear stored authentication token.
@@ -60,449 +60,397 @@ Display current logged-in user information.
 zerodeploy whoami
 ```
 
-Output:
-```
-Logged in as:
-  Username: johndoe
-  User ID:  019b1234-5678-...
-  Admin:    No
-```
-
 ### Organizations
 
 #### `zerodeploy org list`
 
-List all organizations you own.
+List all organizations you have access to.
 
 ```bash
 zerodeploy org list
 ```
 
-Output:
-```
-Organizations:
-- My Company [paid] (id: 019b1234-...)
-- Personal [paid] (id: 019b5678-...)
-```
-
 #### `zerodeploy org create <name>`
 
-Create a new organization. Slug is auto-generated from the name.
+Create a new organization.
 
 ```bash
 zerodeploy org create "My Company"
 ```
 
-Output:
-```
-Organization created: My Company
-  id: 019b1234-5678-...
+#### `zerodeploy org delete <orgSlug>`
+
+Delete an organization (must have no sites).
+
+```bash
+zerodeploy org delete my-company
 ```
 
 ### Sites
 
 #### `zerodeploy site list <orgSlug>`
 
-List all sites in an organization. Shows linked GitHub repositories if configured.
+List all sites in an organization.
 
 ```bash
 zerodeploy site list my-company
 ```
 
-Output:
-```
-Sites:
-  my-website           My Website -> company/frontend
-  landing-page         Landing Page
-  docs                 Documentation -> company/monorepo
-```
-
-#### `zerodeploy site create <orgSlug> <name> [options]`
+#### `zerodeploy site create <orgSlug> <name> --subdomain <subdomain>`
 
-Create a new site in an organization. Slug is auto-generated from the name.
+Create a new site in an organization.
 
 **Options:**
+- `--subdomain <subdomain>` - Subdomain for the site (required, globally unique)
 - `--repo <owner/repo>` - Link to a GitHub repository
 
 ```bash
 # Create a site
-zerodeploy site create my-company "My Website"
+zerodeploy site create my-company "My Website" --subdomain my-website
 
 # Create a site linked to a GitHub repo
-zerodeploy site create my-company "Dashboard" --repo company/monorepo
+zerodeploy site create my-company "Dashboard" --subdomain dashboard --repo company/monorepo
 ```
 
-Output:
-```
-Site created: Dashboard
-  ID: 019b1234-5678-...
-  Repo: company/monorepo
-```
-
-#### `zerodeploy site link <orgSlug> <siteSlug> <repo>`
-
-Link an existing site to a GitHub repository. One repository can be linked to multiple sites (monorepo support).
-
-```bash
-zerodeploy site link my-company dashboard company/monorepo
-```
-
-Output:
-```
-Site "Dashboard" linked to company/monorepo
-```
+Your site will be available at `https://<subdomain>.zerodeploy.app`
 
-#### `zerodeploy site unlink <orgSlug> <siteSlug>`
+#### `zerodeploy site delete <siteSlug> --org <orgSlug>`
 
-Remove the GitHub repository link from a site.
+Delete a site and all its deployments.
 
 ```bash
-zerodeploy site unlink my-company dashboard
-```
-
-Output:
-```
-Site "Dashboard" unlinked from GitHub repository
-```
-
-#### GitHub Repository Linking
-
-Sites can be linked to GitHub repositories to enable:
-- Tracking which repo deploys to which site
-- Future: Automatic PR preview comments
-- Future: GitHub webhook integration
-
-**Monorepo support:** One repository can be linked to multiple sites:
-
-```
-company/monorepo
-├── apps/marketing  → site: marketing
-├── apps/dashboard  → site: dashboard
-└── apps/docs       → site: docs
+zerodeploy site delete my-website --org my-company
 ```
 
 ### Deployment
 
 #### `zerodeploy deploy <siteSlug> [options]`
 
-Deploy a directory to a site. Uploads all files and makes the deployment live.
-
-**Arguments:**
-- `siteSlug` - The site slug to deploy to
+Deploy a directory to a site.
 
 **Options:**
 - `--org <orgSlug>` - Organization slug (required)
 - `--dir <directory>` - Directory to deploy (default: auto-detect)
 - `--build` - Run build command before deploying
-- `--no-build` - Skip build step (even if output dir doesn't exist)
-- `--build-command <cmd>` - Override the build command
+- `--build-command <cmd>` - Custom build command
 - `--install` - Run install command before building
 
-**CI/CD Options:**
-- `--pr <number>` - PR number (for GitHub Actions)
-- `--pr-title <title>` - PR title
-- `--commit <sha>` - Commit SHA
-- `--commit-message <message>` - Commit message
-- `--branch <branch>` - Branch name
-- `--github-output` - Output deployment info in GitHub Actions format
-
 ```bash
 # Deploy specific directory
 zerodeploy deploy my-website --org my-company --dir ./dist
 
-# Auto-detect build directory (looks for dist/, build/, out/, public/)
+# Auto-detect build directory
 zerodeploy deploy my-website --org my-company
 
-# Build and deploy (auto-detects framework)
+# Build and deploy
 zerodeploy deploy my-website --org my-company --build
 
-# Install, build, and deploy
+# Install dependencies, build, and deploy
 zerodeploy deploy my-website --org my-company --install --build
-
-# Custom build command
-zerodeploy deploy my-website --org my-company --build-command "npm run build:prod"
 ```
 
 Output:
 ```
-Detected: Vite
-
-Building...
-> npm run build
-
 Deploying: ./dist
 Found 42 files (1.2 MB)
-Created deployment: 019b1234-5678-...
 Uploading files...
   [100%] 42/42 files
 
 Deployment successful!
-URL:     https://my-website_my-company.zerodeploy.app
-Preview: https://019b1234_my-website_my-company.zerodeploy.app
+URL:     https://my-website.zerodeploy.app
+Preview: https://019b1234-my-website.zerodeploy.app
 ```
 
-#### Preview Deployments
-
-Each deployment gets a unique preview URL that remains accessible even after new deployments:
+#### `zerodeploy deployments list <siteSlug> --org <orgSlug>`
 
-- **Production URL**: `https://site_org.zerodeploy.app` - Always serves the current deployment
-- **Preview URL**: `https://{shortId}_site_org.zerodeploy.app` - Serves a specific deployment
+List deployment history for a site.
 
-Preview URLs use the first 8 characters of the deployment ID. This is useful for:
-- Reviewing changes before promoting to production
-- Sharing specific versions with stakeholders
-- Rolling back by comparing different deployments
-- PR preview deployments
+```bash
+zerodeploy deployments list my-website --org my-company
+```
 
-#### GitHub Actions Integration
+**Options:**
+- `--limit <number>` - Number of deployments to show (default: 10)
 
-ZeroDeploy integrates with GitHub Actions for automated deployments and PR previews.
+#### `zerodeploy rollback <siteSlug> --org <orgSlug>`
 
-**Setup:**
-1. Generate a token: Run `zerodeploy login` and copy the token from `~/.zerodeploy/token`
-2. Add the token to your repository secrets as `ZERODEPLOY_TOKEN`
-3. Copy the workflow template to `.github/workflows/deploy.yml`
+Rollback to a previous deployment.
 
-**Minimal workflow:**
-```yaml
-name: Deploy
-on:
-  push:
-    branches: [main]
+```bash
+# Rollback to the previous deployment
+zerodeploy rollback my-website --org my-company
 
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: oven-sh/setup-bun@v2
-      - run: bun install
-      - run: bun run build
-      - name: Deploy
-        env:
-          ZERODEPLOY_TOKEN: ${{ secrets.ZERODEPLOY_TOKEN }}
-        run: bunx zerodeploy deploy my-site --org my-org
+# Rollback to a specific deployment
+zerodeploy rollback my-website --org my-company --to 019b1230
 ```
 
-**PR Preview workflow:**
-```yaml
-- name: Deploy PR Preview
-  if: github.event_name == 'pull_request'
-  env:
-    ZERODEPLOY_TOKEN: ${{ secrets.ZERODEPLOY_TOKEN }}
-  run: |
-    zerodeploy deploy my-site \
-      --org my-org \
-      --pr ${{ github.event.pull_request.number }} \
-      --pr-title "${{ github.event.pull_request.title }}" \
-      --commit ${{ github.sha }} \
-      --branch ${{ github.head_ref }} \
-      --github-output
-```
+### Deploy Tokens
 
-The `--github-output` flag exports deployment info as GitHub Actions outputs:
-- `deployment_id` - The deployment ID
-- `deployment_url` - The production URL
-- `preview_url` - The unique preview URL
+Deploy tokens allow CI/CD systems to authenticate without using your personal credentials.
 
-See `apps/cli/examples/github-actions/` for full workflow templates including PR comment automation
+#### `zerodeploy token create <name> --org <org> --site <site>`
 
-#### Framework Auto-Detection
+Create a deploy token for CI/CD.
 
-The CLI automatically detects your framework from `package.json` and uses the appropriate build command and output directory:
+```bash
+zerodeploy token create "GitHub Actions" --org my-company --site my-website
+```
 
-| Framework | Detection | Build Command | Output Dir |
-|-----------|-----------|---------------|------------|
-| Vite | `vite` in deps | `npm run build` | `dist/` |
-| Next.js | `next` in deps | `npm run build` | `out/` |
-| Create React App | `react-scripts` in deps | `npm run build` | `build/` |
-| Vue CLI | `@vue/cli-service` in deps | `npm run build` | `dist/` |
-| Nuxt | `nuxt` in deps | `npm run build` | `dist/` |
-| Astro | `astro` in deps | `npm run build` | `dist/` |
-| SvelteKit | `@sveltejs/kit` in deps | `npm run build` | `build/` |
-| Gatsby | `gatsby` in deps | `npm run build` | `public/` |
-| Remix | `@remix-run/dev` in deps | `npm run build` | `public/build/` |
-| Parcel | `parcel` in deps | `npm run build` | `dist/` |
+Save the token securely - it will only be shown once.
 
-**Auto-build behavior:**
-- If a framework is detected but the output directory doesn't exist, the CLI automatically runs the build
-- Use `--no-build` to skip the build step
-- Use `--build-command` to override the detected build command
+#### `zerodeploy token list --org <org> --site <site>`
 
-**Auto-detected directories (fallback):**
-If no framework is detected, the CLI looks for common build output directories:
-1. `dist/` (Vite, Rollup)
-2. `build/` (Create React App)
-3. `out/` (Next.js static export)
-4. `public/` (static sites)
+List deploy tokens for a site.
 
-**Ignored files:**
-The following are automatically excluded from deployments:
-- `node_modules/`
-- `.git/`
-- `.env`, `.env.*` files
-- Hidden files starting with `.`
+```bash
+zerodeploy token list --org my-company --site my-website
+```
 
-#### `zerodeploy deploy list <siteSlug> --org <orgSlug>`
+#### `zerodeploy token delete <tokenId> --org <org> --site <site>`
 
-List all deployments for a site.
+Delete a deploy token.
 
 ```bash
-zerodeploy deploy list my-website --org my-company
-```
-
-Output:
+zerodeploy token delete 019b1234 --org my-company --site my-website
 ```
-Deployments for my-company/my-website:
 
-  019b1234  ready       12/14/2025, 9:00:00 PM <- current
-  019b1230  ready       12/14/2025, 8:30:00 PM
-  019b1220  ready       12/14/2025, 8:00:00 PM
-```
+### Custom Domains
 
-**Options:**
-- `--org <orgSlug>` - Organization slug (required)
-- `--limit <number>` - Number of deployments to show (default: 10)
+Connect your own domain to any ZeroDeploy site with automatic SSL.
 
-#### `zerodeploy deploy rollback <deploymentId>`
+#### `zerodeploy domain add <domain> --org <org> --site <site>`
 
-Rollback to a previous deployment. Sets the specified deployment as the current live deployment.
+Add a custom domain to a site. Returns DNS verification instructions.
 
 ```bash
-zerodeploy deploy rollback 019b1230-5678-...
+zerodeploy domain add www.example.com --org my-company --site my-website
 ```
 
-Output:
-```
-Rolled back successfully
-   Deployment: 019b1230-5678-...
-   URL: https://my-website_my-company.zerodeploy.app
-```
+#### `zerodeploy domain verify <domain> --org <org> --site <site>`
 
-### Deploy Tokens
+Verify domain ownership after adding the TXT record to your DNS.
 
-Deploy tokens allow CI/CD systems to authenticate with ZeroDeploy without using your personal JWT.
+```bash
+zerodeploy domain verify www.example.com --org my-company --site my-website
+```
 
-#### `zerodeploy token create <name> --org <org> --site <site>`
+#### `zerodeploy domain list --org <org> --site <site>`
 
-Create a new deploy token for a site.
+List all custom domains for a site.
 
 ```bash
-zerodeploy token create "GitHub Actions" --org my-company --site my-website
+zerodeploy domain list --org my-company --site my-website
 ```
 
-Output:
+#### `zerodeploy domain remove <domain> --org <org> --site <site>`
+
+Remove a custom domain from a site.
+
+```bash
+zerodeploy domain remove www.example.com --org my-company --site my-website
 ```
-Deploy token created successfully!
 
-Name:  GitHub Actions
-ID:    019b1234-5678-...
+#### `zerodeploy domain redirect <domain> --org <org> --site <site> --mode <mode>`
+
+Set redirect mode for a custom domain. This allows automatic redirects between www and apex (non-www) domains.
+
+**Options:**
+- `--mode <mode>` - Redirect mode: `none`, `www_to_apex`, or `apex_to_www`
 
-Token (save this - it will not be shown again):
+```bash
+# Redirect www.example.com to example.com
+zerodeploy domain redirect example.com --org my-company --site my-website --mode www_to_apex
 
-  abc123def456...
+# Redirect example.com to www.example.com
+zerodeploy domain redirect www.example.com --org my-company --site my-website --mode apex_to_www
 
-Usage in GitHub Actions:
-  Add this token as a repository secret named ZERODEPLOY_TOKEN
+# Disable redirects
+zerodeploy domain redirect example.com --org my-company --site my-website --mode none
 ```
 
-**Options:**
-- `--org <orgSlug>` - Organization slug (required)
-- `--site <siteSlug>` - Site slug (required)
+**Custom Domain Setup:**
 
-#### `zerodeploy token list --org <org> --site <site>`
+1. Add the domain: `zerodeploy domain add www.example.com --org my-org --site my-site`
+2. Add the TXT record to your DNS (shown in output)
+3. Verify ownership: `zerodeploy domain verify www.example.com --org my-org --site my-site`
+4. Add the CNAME record to your DNS (shown in output)
+5. Your site is now live at `https://www.example.com`
+
+## Configuration File
 
-List all deploy tokens for a site.
+Create a `zerodeploy.json` in your project root:
 
 ```bash
-zerodeploy token list --org my-company --site my-website
+zerodeploy init --org my-company --site my-website
 ```
 
-Output:
-```
-Deploy tokens for my-company/my-website:
+This creates:
 
-  019b1234  GitHub Actions        Created: 12/14/2025  Last used: 12/14/2025
-  019b5678  CircleCI              Created: 12/10/2025  Last used: Never
+```json
+{
+  "org": "my-company",
+  "site": "my-website"
+}
 ```
 
-#### `zerodeploy token delete <tokenId> --org <org> --site <site>`
-
-Delete a deploy token. You can use the full ID or the first 8 characters.
+Then deploy with just:
 
 ```bash
-zerodeploy token delete 019b1234 --org my-company --site my-website
+zerodeploy deploy
 ```
 
-## Deployment Flow
+## Deployed Sites
 
-1. **Create deployment** - API creates a new deployment record with `uploading` status
-2. **Upload files** - CLI scans directory and uploads each file as base64 to R2
-3. **Finalize** - API marks deployment as `ready` and sets it as the current deployment
-4. **Live** - Site is immediately accessible at the deployment URL
+### URLs
 
-## Accessing Deployed Sites
+Each site gets a production URL based on its subdomain:
 
-After deployment, sites are accessible at:
-
-**Local development:**
 ```
-http://localhost:8787/serve/<orgSlug>/<siteSlug>/
+https://<subdomain>.zerodeploy.app
 ```
 
-**Production:**
+### Preview URLs
+
+Every deployment also gets a unique preview URL that remains accessible even after new deployments:
+
 ```
-https://<siteSlug>_<orgSlug>.zerodeploy.app
+https://<deploymentId>-<subdomain>.zerodeploy.app
 ```
 
+Preview URLs use the first 8 characters of the deployment ID. Useful for:
+- Reviewing changes before promoting to production
+- Sharing specific versions with stakeholders
+- Comparing different deployments
+
 ### SPA Support
 
 ZeroDeploy automatically handles SPA (Single Page Application) routing:
 - Requests without file extensions fall back to `index.html`
-- Enables client-side routing for React, Vue, Angular, etc.
+- Works with React Router, Vue Router, and other client-side routers
 
 ### Caching
 
-Appropriate cache headers are set automatically:
-- **HTML files**: `max-age=0, must-revalidate` (always check for updates)
-- **Hashed assets** (e.g., `main.abc123.js`): `max-age=31536000, immutable` (1 year)
-- **Other assets**: `max-age=3600, stale-while-revalidate=86400` (1 hour)
+Cache headers are set automatically:
+- **HTML files**: Always revalidate for fresh content
+- **Hashed assets** (e.g., `main.abc123.js`): Cached for 1 year
+- **Other assets**: Cached for 1 hour with background revalidation
 
-## Configuration
+## CI/CD Integration
 
-### Token Storage
+### GitHub Actions
 
-Authentication token is stored at `~/.zerodeploy/token`.
+**1. Create a deploy token:**
 
-For CI/CD, set the `ZERODEPLOY_TOKEN` environment variable instead. The environment variable takes precedence over the file-based token.
+```bash
+zerodeploy token create "GitHub Actions" --org my-company --site my-website
+```
 
-### API URL
+**2. Add the token to your repository secrets** as `ZERODEPLOY_TOKEN`
 
-By default, CLI connects to production (`https://api.zerodeploy.dev`). To use a local development server, set the `ZERODEPLOY_API_URL` environment variable:
+**3. Create `.github/workflows/deploy.yml`:**
 
-```bash
-# Point to local dev server
-export ZERODEPLOY_API_URL=http://localhost:8787
+```yaml
+name: Deploy
+on:
+  push:
+    branches: [main]
 
-# Or prefix individual commands
-ZERODEPLOY_API_URL=http://localhost:8787 zerodeploy whoami
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+      - run: npm ci
+      - run: npm run build
+      - name: Deploy
+        env:
+          ZERODEPLOY_TOKEN: ${{ secrets.ZERODEPLOY_TOKEN }}
+        run: npx @zerodeploy/cli deploy my-site --org my-org
 ```
 
-Make sure your local API is running with `cd apps/api && bun run dev`.
+**PR Preview workflow:**
 
-## Development
+```yaml
+name: PR Preview
+on:
+  pull_request:
+
+jobs:
+  preview:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+      - run: npm ci
+      - run: npm run build
+      - name: Deploy Preview
+        env:
+          ZERODEPLOY_TOKEN: ${{ secrets.ZERODEPLOY_TOKEN }}
+        run: |
+          npx @zerodeploy/cli deploy my-site \
+            --org my-org \
+            --pr ${{ github.event.pull_request.number }} \
+            --pr-title "${{ github.event.pull_request.title }}" \
+            --commit ${{ github.sha }} \
+            --branch ${{ github.head_ref }} \
+            --github-output
+```
+
+The `--github-output` flag exports deployment info as GitHub Actions outputs:
+- `deployment_id` - The deployment ID
+- `deployment_url` - The production URL
+- `preview_url` - The unique preview URL
+
+### Other CI/CD Systems
+
+ZeroDeploy works with any CI/CD system. Set the `ZERODEPLOY_TOKEN` environment variable and run the deploy command:
 
 ```bash
-# Run CLI in development
-cd apps/cli
-bun run src/index.ts <command>
+# Works with npm, yarn, pnpm, or bun
+npx @zerodeploy/cli deploy my-site --org my-org
+yarn dlx @zerodeploy/cli deploy my-site --org my-org
+pnpm dlx @zerodeploy/cli deploy my-site --org my-org
+bunx @zerodeploy/cli deploy my-site --org my-org
+```
+
+## Framework Auto-Detection
+
+The CLI automatically detects your framework and uses the appropriate build command and output directory:
+
+| Framework | Build Command | Output Dir |
+|-----------|---------------|------------|
+| Vite | `npm run build` | `dist/` |
+| Next.js | `npm run build` | `out/` |
+| Create React App | `npm run build` | `build/` |
+| Vue CLI | `npm run build` | `dist/` |
+| Nuxt | `npm run build` | `dist/` |
+| Astro | `npm run build` | `dist/` |
+| SvelteKit | `npm run build` | `build/` |
+| Gatsby | `npm run build` | `public/` |
+| Remix | `npm run build` | `public/build/` |
+| Parcel | `npm run build` | `dist/` |
+
+**Auto-detected directories (fallback):**
+If no framework is detected, the CLI looks for: `dist/`, `build/`, `out/`, `public/`
 
-# Run tests
-bun test
+**Ignored files:**
+The following are automatically excluded from deployments:
+- `node_modules/`
+- `.git/`
+- `.env`, `.env.*` files
+- Hidden files starting with `.`
 
-# Run e2e tests (requires API running)
-bun test test/e2e.test.ts
-```
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `ZERODEPLOY_TOKEN` | Authentication token (for CI/CD) |
+| `ZERODEPLOY_API_URL` | Custom API URL (defaults to production) |
 
 ## Troubleshooting
 
@@ -512,12 +460,20 @@ Run `zerodeploy login` to authenticate.
 
 ### "Org not found"
 
-Ensure you're using the correct org slug (lowercase, hyphenated). Use `zerodeploy org list` to see your organizations.
+Use the correct org slug (lowercase, hyphenated). Check with `zerodeploy org list`.
 
 ### "Site not found"
 
-Ensure you're using the correct site slug and org slug. Use `zerodeploy site list <orgSlug>` to see sites.
+Use the correct site and org slugs. Check with `zerodeploy site list <orgSlug>`.
 
 ### "No build directory found"
 
-Specify the directory explicitly with `--dir ./path/to/build` or ensure your project has a `dist/`, `build/`, `out/`, or `public/` directory.
+Either:
+- Specify the directory with `--dir ./path/to/build`
+- Run with `--build` to build first
+- Ensure your project has a `dist/`, `build/`, `out/`, or `public/` directory
+
+## Links
+
+- [Documentation](https://zerodeploy.dev/docs)
+- [Support](https://zerodeploy.dev/support)

package/dist/cli.js

@@ -3453,7 +3453,7 @@ var domainAddCommand = new Command2("add").description("Add a custom domain to a
     console.log(`   Value: ${data.verification.recordValue}`);
     console.log();
     console.log("After adding the record, run:");
-    console.log(`   zerodeploy domain verify ${data.id} --org ${options.org} --site ${options.site}`);
+    console.log(`   zerodeploy domain verify ${data.domain} --org ${options.org} --site ${options.site}`);
     console.log();
   } catch (err) {
     const message = err instanceof Error ? err.message : "Unknown error";
@@ -3474,6 +3474,16 @@ function formatStatus(status) {
       return status;
   }
 }
+function formatRedirect(mode) {
+  switch (mode) {
+    case "www_to_apex":
+      return "www→apex";
+    case "apex_to_www":
+      return "apex→www";
+    default:
+      return "";
+  }
+}
 var domainListCommand = new Command2("list").description("List custom domains for a site").requiredOption("--org <orgSlug>", "Organization slug").requiredOption("--site <siteSlug>", "Site slug").action(async (options) => {
   const token = loadToken();
   if (!token) {
@@ -3501,7 +3511,9 @@ var domainListCommand = new Command2("list").description("List custom domains fo
     console.log("Custom Domains:");
     console.log();
     for (const d of domains) {
-      console.log(`  ${d.domain.padEnd(30)} ${formatStatus(d.verification_status).padEnd(15)} ${d.id}`);
+      const redirect = formatRedirect(d.redirect_mode);
+      const redirectStr = redirect ? ` [${redirect}]` : "";
+      console.log(`  ${d.domain.padEnd(30)} ${formatStatus(d.verification_status).padEnd(15)}${redirectStr}`);
     }
     console.log();
   } catch (err) {
@@ -3511,14 +3523,33 @@ var domainListCommand = new Command2("list").description("List custom domains fo
 });
 
 // src/commands/domain/verify.ts
-var domainVerifyCommand = new Command2("verify").description("Verify ownership of a custom domain").argument("<domainId>", "Domain ID to verify").requiredOption("--org <orgSlug>", "Organization slug").requiredOption("--site <siteSlug>", "Site slug").action(async (domainId, options) => {
+var domainVerifyCommand = new Command2("verify").description("Verify ownership of a custom domain").argument("<domain>", "Domain to verify (e.g., www.example.com)").requiredOption("--org <orgSlug>", "Organization slug").requiredOption("--site <siteSlug>", "Site slug").action(async (domainName, options) => {
   const token = loadToken();
   if (!token) {
     console.log("Not logged in. Run: zerodeploy login");
     return;
   }
   try {
-    const res = await fetch(`${API_URL}/orgs/${options.org}/sites/${options.site}/domains/${domainId}/verify`, {
+    const listRes = await fetch(`${API_URL}/orgs/${options.org}/sites/${options.site}/domains`, {
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+    if (!listRes.ok) {
+      const error = await listRes.json();
+      throw new Error(error.error || `API Error ${listRes.status}`);
+    }
+    const domains = await listRes.json();
+    const domain = domains.find((d) => d.domain === domainName);
+    if (!domain) {
+      console.error(`
+❌ Domain not found: ${domainName}`);
+      console.log();
+      console.log("Add it first with:");
+      console.log(`  zerodeploy domain add ${domainName} --org ${options.org} --site ${options.site}`);
+      return;
+    }
+    const res = await fetch(`${API_URL}/orgs/${options.org}/sites/${options.site}/domains/${domain.id}/verify`, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${token}`,
@@ -3528,7 +3559,7 @@ var domainVerifyCommand = new Command2("verify").description("Verify ownership o
     const data = await res.json();
     if (!res.ok) {
       console.error(`
-❌ Verification failed for domain`);
+❌ Verification failed for ${domainName}`);
       if (data.message) {
         console.log();
         console.log(data.message);
@@ -3536,7 +3567,7 @@ var domainVerifyCommand = new Command2("verify").description("Verify ownership o
       console.log();
       console.log("Tips:");
       console.log("  • DNS changes can take up to 48 hours to propagate");
-      console.log("  • Verify the TXT record is set correctly using: dig TXT _zerodeploy.<domain>");
+      console.log(`  • Verify the TXT record is set correctly using: dig TXT _zerodeploy.${domainName}`);
       console.log("  • Try again in a few minutes");
       return;
     }
@@ -3587,14 +3618,33 @@ var domainVerifyCommand = new Command2("verify").description("Verify ownership o
 });
 
 // src/commands/domain/remove.ts
-var domainRemoveCommand = new Command2("remove").description("Remove a custom domain from a site").argument("<domainId>", "Domain ID to remove").requiredOption("--org <orgSlug>", "Organization slug").requiredOption("--site <siteSlug>", "Site slug").action(async (domainId, options) => {
+var domainRemoveCommand = new Command2("remove").description("Remove a custom domain from a site").argument("<domain>", "Domain to remove (e.g., www.example.com)").requiredOption("--org <orgSlug>", "Organization slug").requiredOption("--site <siteSlug>", "Site slug").action(async (domainName, options) => {
   const token = loadToken();
   if (!token) {
     console.log("Not logged in. Run: zerodeploy login");
     return;
   }
   try {
-    const res = await fetch(`${API_URL}/orgs/${options.org}/sites/${options.site}/domains/${domainId}`, {
+    const listRes = await fetch(`${API_URL}/orgs/${options.org}/sites/${options.site}/domains`, {
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+    if (!listRes.ok) {
+      const error = await listRes.json();
+      throw new Error(error.error || `API Error ${listRes.status}`);
+    }
+    const domains = await listRes.json();
+    const domain = domains.find((d) => d.domain === domainName);
+    if (!domain) {
+      console.error(`
+❌ Domain not found: ${domainName}`);
+      console.log();
+      console.log("List domains with:");
+      console.log(`  zerodeploy domain list --org ${options.org} --site ${options.site}`);
+      return;
+    }
+    const res = await fetch(`${API_URL}/orgs/${options.org}/sites/${options.site}/domains/${domain.id}`, {
       method: "DELETE",
       headers: {
         Authorization: `Bearer ${token}`
@@ -3612,12 +3662,77 @@ var domainRemoveCommand = new Command2("remove").description("Remove a custom do
   }
 });
 
+// src/commands/domain/redirect.ts
+function formatRedirectMode(mode) {
+  switch (mode) {
+    case "none":
+      return "No redirect";
+    case "www_to_apex":
+      return "www → apex (e.g., www.example.com → example.com)";
+    case "apex_to_www":
+      return "apex → www (e.g., example.com → www.example.com)";
+    default:
+      return mode;
+  }
+}
+var domainRedirectCommand = new Command2("redirect").description("Set redirect mode for a custom domain").argument("<domain>", "Domain name (e.g., example.com)").requiredOption("--org <orgSlug>", "Organization slug").requiredOption("--site <siteSlug>", "Site slug").requiredOption("--mode <mode>", "Redirect mode: none, www_to_apex, or apex_to_www").action(async (domain, options) => {
+  const token = loadToken();
+  if (!token) {
+    console.log("Not logged in. Run: zerodeploy login");
+    return;
+  }
+  const validModes = ["none", "www_to_apex", "apex_to_www"];
+  if (!validModes.includes(options.mode)) {
+    console.error(`Invalid mode: ${options.mode}`);
+    console.error("Valid modes: none, www_to_apex, apex_to_www");
+    return;
+  }
+  try {
+    const listRes = await fetch(`${API_URL}/orgs/${options.org}/sites/${options.site}/domains`, {
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+    if (!listRes.ok) {
+      const error = await listRes.json();
+      throw new Error(error.error || `API Error ${listRes.status}`);
+    }
+    const domains = await listRes.json();
+    const targetDomain = domains.find((d) => d.domain === domain.toLowerCase());
+    if (!targetDomain) {
+      console.error(`Domain not found: ${domain}`);
+      console.error(`Run 'zerodeploy domain list --org ${options.org} --site ${options.site}' to see configured domains.`);
+      return;
+    }
+    const res = await fetch(`${API_URL}/orgs/${options.org}/sites/${options.site}/domains/${targetDomain.id}/redirect`, {
+      method: "PATCH",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ redirectMode: options.mode })
+    });
+    if (!res.ok) {
+      const error = await res.json();
+      throw new Error(error.error || `API Error ${res.status}`);
+    }
+    const data = await res.json();
+    console.log(`
+✅ Redirect mode updated for ${data.domain}`);
+    console.log(`   Mode: ${formatRedirectMode(data.redirect_mode)}`);
+    console.log();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    console.error("Failed to update redirect mode:", message);
+  }
+});
+
 // src/commands/domain/index.ts
-var domainCommand = new Command2("domain").description("Manage custom domains").addCommand(domainAddCommand).addCommand(domainListCommand).addCommand(domainVerifyCommand).addCommand(domainRemoveCommand);
+var domainCommand = new Command2("domain").description("Manage custom domains").addCommand(domainAddCommand).addCommand(domainListCommand).addCommand(domainVerifyCommand).addCommand(domainRemoveCommand).addCommand(domainRedirectCommand);
 
 // src/commands/deploy/index.ts
-import { resolve as resolve3 } from "node:path";
-import { stat as stat2 } from "node:fs/promises";
+import { resolve as resolve3, basename } from "node:path";
+import { stat as stat2, writeFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
 
 // src/utils/files.ts
@@ -4335,6 +4450,29 @@ function getConfigPath(cwd = process.cwd()) {
   return resolve2(cwd, CONFIG_FILENAME);
 }
 
+// src/utils/prompt.ts
+import * as readline3 from "node:readline";
+async function confirm(message, defaultValue = true) {
+  const rl = readline3.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const hint = defaultValue ? "[Y/n]" : "[y/N]";
+  return new Promise((resolve3) => {
+    rl.question(`${message} ${hint} `, (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      if (normalized === "") {
+        resolve3(defaultValue);
+      } else if (normalized === "y" || normalized === "yes") {
+        resolve3(true);
+      } else {
+        resolve3(false);
+      }
+    });
+  });
+}
+
 // src/commands/deploy/list.ts
 var deployListCommand = new Command2("list").description("List deployments for a site").argument("<siteSlug>", "Site slug").requiredOption("--org <orgSlug>", "Organization slug").option("--limit <number>", "Number of deployments to show", "10").action(async (siteSlug, options) => {
   const token = loadToken();
@@ -4414,7 +4552,37 @@ var deployRollbackCommand = new Command2("rollback").description("Rollback to a
   }
 });
 
+// src/commands/deploy/promote.ts
+var deployPromoteCommand = new Command2("promote").description("Promote a preview deployment to production").argument("<deploymentId>", "Deployment ID (or first 8 chars) to promote").action(async (deploymentId) => {
+  const token = loadToken();
+  if (!token) {
+    console.log("Not logged in. Run: zerodeploy login");
+    return;
+  }
+  try {
+    const client = getClient(token);
+    const res = await client.deployments[":id"].rollback.$post({
+      param: { id: deploymentId }
+    });
+    if (!res.ok) {
+      const error = await res.json();
+      console.error(`Error: ${error.error}`);
+      return;
+    }
+    const result = await res.json();
+    console.log("Deployment promoted to production!");
+    console.log(`   Deployment: ${result.deployment.id}`);
+    console.log(`   URL: ${result.deployment.url}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    console.error("Failed to promote deployment:", message);
+  }
+});
+
 // src/commands/deploy/index.ts
+function slugify(input) {
+  return input.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)+/g, "");
+}
 async function runCommand(command, cwd) {
   return new Promise((promiseResolve) => {
     const [cmd, ...args] = command.split(" ");
@@ -4473,26 +4641,63 @@ async function uploadArchive(token, uploadUrl, archive) {
   });
   return res.ok;
 }
-var deployCommand = new Command2("deploy").description("Deploy a site").argument("[site]", "Site slug").option("--org <org>", "Organization slug").option("--dir <directory>", "Directory to deploy (default: auto-detect)").option("--build", "Run build command before deploying").option("--no-build", "Skip build step").option("--build-command <command>", "Override build command").option("--install", "Run install command before building").option("--pr <number>", "PR number (for GitHub Actions)").option("--pr-title <title>", "PR title").option("--commit <sha>", "Commit SHA").option("--commit-message <message>", "Commit message").option("--branch <branch>", "Branch name").option("--github-output", "Output deployment info in GitHub Actions format").enablePositionalOptions().addCommand(deployListCommand).addCommand(deployRollbackCommand).action(async (siteSlugArg, options) => {
+var deployCommand = new Command2("deploy").description("Deploy a site").argument("[site]", "Site slug").option("--org <org>", "Organization slug").option("--dir <directory>", "Directory to deploy (default: auto-detect)").option("--build", "Run build command before deploying").option("--no-build", "Skip build step").option("--build-command <command>", "Override build command").option("--install", "Run install command before building").option("--preview", "Deploy without setting as current (preview only)").option("--pr <number>", "PR number (for GitHub Actions)").option("--pr-title <title>", "PR title").option("--commit <sha>", "Commit SHA").option("--commit-message <message>", "Commit message").option("--branch <branch>", "Branch name").option("--github-output", "Output deployment info in GitHub Actions format").enablePositionalOptions().addCommand(deployListCommand).addCommand(deployRollbackCommand).addCommand(deployPromoteCommand).action(async (siteSlugArg, options) => {
   const cwd = process.cwd();
-  const config = loadProjectConfig(cwd);
-  const siteSlug = siteSlugArg || config.site;
-  const orgSlug = options.org || config.org;
-  const dirOption = options.dir || config.dir;
-  if (!siteSlug) {
-    console.log("Error: Site is required. Provide as argument or in zerodeploy.json");
-    deployCommand.help();
-    return;
-  }
-  if (!orgSlug) {
-    console.log('Error: --org is required (or set "org" in zerodeploy.json)');
-    return;
-  }
   const token = loadToken();
   if (!token) {
     console.log("Not logged in. Run: zerodeploy login");
     return;
   }
+  const config = loadProjectConfig(cwd);
+  let siteSlug = siteSlugArg || config.site;
+  let orgSlug = options.org || config.org;
+  const dirOption = options.dir || config.dir;
+  if (!siteSlug || !orgSlug) {
+    const client = getClient(token);
+    const meRes = await client.auth.me.$get();
+    if (!meRes.ok) {
+      console.log("Error: Failed to fetch user info");
+      return;
+    }
+    const userInfo = await meRes.json();
+    if (!orgSlug) {
+      if (!userInfo.personalOrg) {
+        console.log("Error: No personal org found. Please create one with: zerodeploy org create <name>");
+        return;
+      }
+      orgSlug = userInfo.personalOrg.slug;
+    }
+    if (!siteSlug) {
+      const folderName = basename(cwd);
+      const suggestedName = slugify(folderName) || "my-site";
+      console.log("");
+      const shouldCreate = await confirm(`No site configured. Create site "${suggestedName}"?`, true);
+      if (!shouldCreate) {
+        console.log("Deploy cancelled. Create a site first with: zerodeploy site create");
+        return;
+      }
+      console.log("");
+      console.log(`Creating site "${suggestedName}"...`);
+      const createRes = await client.orgs[":orgSlug"].sites.$post({
+        param: { orgSlug },
+        json: { name: suggestedName, subdomain: suggestedName }
+      });
+      if (!createRes.ok) {
+        const error = await createRes.json();
+        console.log(`Error: ${error.error || "Failed to create site"}`);
+        return;
+      }
+      const site = await createRes.json();
+      siteSlug = site.slug;
+      console.log(`Created site: ${site.subdomain}.zerodeploy.app`);
+      const configPath = getConfigPath(cwd);
+      const newConfig = { org: orgSlug, site: siteSlug, dir: dirOption || config.dir };
+      await writeFile(configPath, JSON.stringify(newConfig, null, 2) + `
+`);
+      console.log(`Saved config to zerodeploy.json`);
+      console.log("");
+    }
+  }
   const framework = await detectFramework(cwd);
   if (framework) {
     console.log(`Detected: ${framework.name}`);
@@ -4635,16 +4840,24 @@ Error: Build failed`);
         "Content-Type": "application/json",
         Authorization: `Bearer ${token}`
       },
-      body: JSON.stringify({})
+      body: JSON.stringify({ preview: options.preview || false })
     });
     if (!finalizeRes.ok) {
       console.log("Error: Failed to finalize deployment");
       return;
     }
     console.log("");
-    console.log("Deployment successful!");
-    console.log(`URL:     ${deployment.url}`);
-    console.log(`Preview: ${deployment.previewUrl}`);
+    if (options.preview) {
+      console.log("Preview deployment created!");
+      console.log(`Preview: ${deployment.previewUrl}`);
+      console.log("");
+      console.log(`To make this deployment live, run:`);
+      console.log(`  zerodeploy deploy promote ${deployment.id.slice(0, 8)}`);
+    } else {
+      console.log("Deployment successful!");
+      console.log(`URL:     ${deployment.url}`);
+      console.log(`Preview: ${deployment.previewUrl}`);
+    }
     if (options.githubOutput) {
       const githubOutputFile = process.env.GITHUB_OUTPUT;
       if (githubOutputFile) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zerodeploy/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "bin": {
     "zerodeploy": "dist/cli.js"
@@ -23,11 +23,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/zerodeploy/zerodeploy.git",
-    "directory": "apps/cli"
-  },
   "keywords": [
     "deploy",
     "spa",