@just-be/deploy 0.1.1 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # @just-be/deploy
 
-Deploy static files to Cloudflare R2 and configure subdomain routing in KV for wildcard subdomain services.
+Deploy static sites and setup routing for the wildcard subdomain service.
 
 ## Requirements
 
@@ -24,83 +24,186 @@ bun install -g @just-be/deploy
 
 ## Usage
 
-### Interactive Mode
+### Basic Usage
+
+Create a `deploy.json` file in your project:
+
+```json
+{
+  "rules": [
+    {
+      "subdomain": "myapp",
+      "type": "static",
+      "path": "apps/myapp",
+      "dir": "./dist",
+      "spa": true
+    },
+    {
+      "subdomain": "old-site",
+      "type": "redirect",
+      "url": "https://new-site.com",
+      "permanent": true
+    }
+  ]
+}
+```
 
-Simply run without arguments to be prompted for all configuration:
+Then run:
 
 ```bash
 bunx @just-be/deploy
 ```
 
-The interactive mode will ask you for:
-- Subdomain name
-- R2 path prefix
-- Local directory to upload
-- Whether to enable SPA mode
-- Whether to use a custom fallback file
+### Specify Config Path
 
-### Command-Line Mode
+```bash
+bunx @just-be/deploy path/to/config.json
+```
 
-Provide all arguments upfront:
+## Rule Types
 
-```bash
-bunx @just-be/deploy --subdomain=NAME --path=PATH --dir=DIR [--spa] [--fallback=FILE]
+### Static Site
+
+Deploy static files to R2 and serve them via a subdomain.
+
+```json
+{
+  "subdomain": "myapp",
+  "type": "static",
+  "path": "apps/myapp",
+  "dir": "./dist",
+  "spa": true
+}
 ```
 
-### Arguments
+**Options:**
 
-- `--subdomain`: Subdomain name (e.g., "myapp" for myapp.just-be.dev)
-- `--path`: R2 path prefix where files will be stored (e.g., "apps/myapp")
-- `--dir`: Local directory to upload
-- `--spa`: (Optional) Enable SPA mode - all routes serve index.html
-- `--fallback`: (Optional) Custom fallback file for 404s (only in non-SPA mode)
+- `subdomain` (required): Subdomain name (e.g., "myapp" for myapp.just-be.dev)
+- `type` (required): Must be "static"
+- `path` (required): R2 path prefix where files will be stored
+- `dir` (required): Local directory containing files to upload
+- `spa` (optional): Enable SPA mode - all routes serve index.html
+- `fallback` (optional): Custom 404 file (cannot be used with `spa`)
 
-### Examples
+### Redirect
 
-**Interactive deployment:**
-```bash
-bunx @just-be/deploy
+Configure an HTTP redirect from a subdomain to another URL.
+
+```json
+{
+  "subdomain": "old-site",
+  "type": "redirect",
+  "url": "https://new-site.com",
+  "permanent": true
+}
 ```
 
-**Deploy a static site:**
-```bash
-bunx @just-be/deploy \
-  --subdomain=portfolio \
-  --path=sites/portfolio \
-  --dir=./dist
+**Options:**
+
+- `subdomain` (required): Subdomain name
+- `type` (required): Must be "redirect"
+- `url` (required): Target URL (must be http/https)
+- `permanent` (optional): Use 301 (permanent) redirect instead of 302 (temporary)
+
+### Rewrite (Reverse Proxy)
+
+Proxy requests from a subdomain to another URL.
+
+```json
+{
+  "subdomain": "api",
+  "type": "rewrite",
+  "url": "https://api.example.com",
+  "allowedMethods": ["GET", "POST", "PUT", "DELETE"]
+}
 ```
 
-**Deploy a single-page application:**
-```bash
-bunx @just-be/deploy \
-  --subdomain=myapp \
-  --path=apps/myapp \
-  --dir=./build \
-  --spa
+**Options:**
+
+- `subdomain` (required): Subdomain name
+- `type` (required): Must be "rewrite"
+- `url` (required): Target URL to proxy to (must be http/https)
+- `allowedMethods` (optional): HTTP methods allowed (default: ["GET", "HEAD", "OPTIONS"])
+
+## Examples
+
+### Multiple Static Sites
+
+```json
+{
+  "rules": [
+    {
+      "subdomain": "portfolio",
+      "type": "static",
+      "path": "sites/portfolio",
+      "dir": "./build",
+      "fallback": "404.html"
+    },
+    {
+      "subdomain": "docs",
+      "type": "static",
+      "path": "sites/docs",
+      "dir": "./out",
+      "spa": true
+    },
+    {
+      "subdomain": "blog",
+      "type": "static",
+      "path": "sites/blog",
+      "dir": "./dist"
+    }
+  ]
+}
 ```
 
-**Deploy with custom 404 page:**
-```bash
-bunx @just-be/deploy \
-  --subdomain=docs \
-  --path=sites/docs \
-  --dir=./out \
-  --fallback=404.html
+### Mixed Deployments
+
+```json
+{
+  "rules": [
+    {
+      "subdomain": "app",
+      "type": "static",
+      "path": "apps/main",
+      "dir": "./dist",
+      "spa": true
+    },
+    {
+      "subdomain": "legacy",
+      "type": "redirect",
+      "url": "https://app.just-be.dev",
+      "permanent": true
+    },
+    {
+      "subdomain": "api",
+      "type": "rewrite",
+      "url": "https://backend.example.com",
+      "allowedMethods": ["GET", "POST", "PUT", "DELETE", "PATCH"]
+    }
+  ]
+}
 ```
 
+## Editor Support
+
+The package includes a JSON Schema (`deploy.schema.json`) for editor validation and autocomplete. Many editors will automatically provide validation and suggestions for `deploy.json` files.
+
 ## How It Works
 
-1. **Parses arguments** using Node's `util.parseArgs` API
-2. **Prompts for missing values** if any required arguments are not provided
-3. **Validates configuration** using Zod schemas from `@just-be/wildcard-schemas`
-4. **Scans** the target directory for all files
-5. **Uploads** each file to R2 at `content-bucket/{path}/{relative-path}`
-6. **Creates** a KV entry with routing configuration for the subdomain
-7. **Configures** the wildcard service to serve your site at `https://{subdomain}.just-be.dev`
+1. **Parses configuration** from `deploy.json`
+2. **Validates** all rules using Zod schemas from `@just-be/wildcard`
+3. **For static sites**:
+   - Scans the local directory for all files
+   - Uploads each file to R2 at `content-bucket/{path}/{relative-path}`
+   - Creates a KV entry with routing configuration
+4. **For redirects/rewrites**:
+   - Creates a KV entry with the routing configuration
+5. **Configures** the wildcard service to route requests for each subdomain
 
 ## Configuration
 
 The script expects your wildcard service to use:
+
 - **R2 Bucket**: `content-bucket`
 - **KV Binding**: `ROUTING_RULES`
 - **Wrangler Config**: `services/wildcard/wrangler.toml`
@@ -108,13 +211,15 @@ The script expects your wildcard service to use:
 ## Validation
 
 Configuration is validated using Zod schemas to ensure:
+
+- Valid subdomain format (alphanumeric with hyphens, 1-63 characters)
 - SPA mode and fallback file are not used together
-- R2 path is not empty
-- All required fields are present
+- Required fields are present for each rule type
+- URLs are safe (http/https only)
 
 ## Related Packages
 
-- [`@just-be/wildcard-schemas`](../wildcard-schemas) - Shared Zod schemas for configuration validation
+- [`@just-be/wildcard`](../wildcard) - Shared Zod schemas and routing handlers for wildcard subdomain configuration
 
 ## License
 

package/index.ts

@@ -1,155 +1,140 @@
 #!/usr/bin/env bun
 
 /**
- * Deploy static files to Cloudflare R2 and configure subdomain routing in KV
+ * Deploy static sites and setup routing for the wildcard subdomain service
  *
  * Usage:
- *   bunx @just-be/deploy --subdomain=myapp --path=apps/myapp --dir=./dist
- *   bunx @just-be/deploy --subdomain=portfolio --path=sites/portfolio --dir=./build --fallback=404.html
- *   bunx @just-be/deploy --subdomain=spa --path=apps/spa --dir=./dist --spa
+ *   bunx @just-be/deploy                        # Looks for deploy.json in current directory
+ *   bunx @just-be/deploy path/to/config.json    # Deploy with specific config file
+ *   bunx @just-be/deploy preview <subdomain>    # Preview deploy with branch name suffix
  *
- * Or run interactively without arguments:
- *   bunx @just-be/deploy
+ * Example deploy.json:
+ *   {
+ *     "rules": [
+ *       {
+ *         "subdomain": "myapp",
+ *         "type": "static",
+ *         "dir": "./dist",
+ *         "spa": true
+ *       },
+ *       {
+ *         "subdomain": "old-site",
+ *         "type": "redirect",
+ *         "url": "https://new-site.com",
+ *         "permanent": true
+ *       }
+ *     ]
+ *   }
+ *
+ * Note: The subdomain is automatically used as the R2 path prefix.
+ * For example, subdomain "myapp" will store files under "myapp/" in R2.
+ *
+ * Preview deploys append the branch name to the subdomain (e.g., "myapp-feature-branch").
  */
 
 import { $ } from "bun";
-import { readdir, stat } from "fs/promises";
-import { join, relative } from "path";
-import { createInterface } from "readline";
+import { readdir, stat, access } from "fs/promises";
+import { join, relative, resolve } from "path";
+import { intro, outro, spinner } from "@clack/prompts";
 import { z } from "zod";
-import { StaticConfigSchema, type StaticConfig, isValidSubdomain } from "@just-be/wildcard";
+import {
+  StaticConfigSchema,
+  RedirectConfigSchema,
+  RewriteConfigSchema,
+  type RouteConfig,
+  subdomain,
+} from "@just-be/wildcard";
 
 const BUCKET_NAME = "content-bucket";
 const WRANGLER_CONFIG = "services/wildcard/wrangler.toml";
 
 /**
- * Schema for CLI arguments
+ * Run wrangler command using bunx to ensure it resolves from package dependencies
  */
-const CliArgsSchema = z.object({
-  subdomain: z.string().optional(),
-  path: z.string().optional(),
-  dir: z.string().optional(),
-  spa: z.boolean().optional(),
-  fallback: z.string().optional(),
-});
-
-type CliArgs = z.infer<typeof CliArgsSchema>;
+function wrangler(command: TemplateStringsArray, ...values: unknown[]) {
+  const cmd = String.raw(command, ...values);
+  return $`bunx wrangler ${cmd}`;
+}
 
 /**
- * Parse command-line arguments from Bun.argv
+ * Route rules extend RouteConfig with subdomain
+ * Static rules also need a `dir` field for the local directory to upload
+ * The subdomain is automatically used as the R2 path prefix
+ * Using safeExtend because base schemas contain refinements
  */
-function parseCliArgs(): CliArgs {
-  const args: Record<string, string | boolean> = {};
-
-  for (const arg of Bun.argv.slice(2)) {
-    if (arg.startsWith("--")) {
-      const [key, value] = arg.slice(2).split("=");
-      if (value === undefined) {
-        // Flag without value (e.g., --spa)
-        args[key] = true;
-      } else {
-        args[key] = value;
-      }
-    }
-  }
+const StaticRuleSchema = StaticConfigSchema.safeExtend({
+  subdomain: subdomain(),
+  dir: z.string().min(1),
+});
 
-  return CliArgsSchema.parse(args);
-}
+const RedirectRuleSchema = RedirectConfigSchema.safeExtend({
+  subdomain: subdomain(),
+});
 
-interface DeployConfig extends Omit<StaticConfig, "type"> {
-  subdomain: string;
-  dir: string;
-}
+const RewriteRuleSchema = RewriteConfigSchema.safeExtend({
+  subdomain: subdomain(),
+});
 
-/**
- * Prompt user for input
- */
-async function prompt(question: string, defaultValue?: string): Promise<string> {
-  const rl = createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
+const RouteRuleSchema = z.discriminatedUnion("type", [
+  StaticRuleSchema,
+  RedirectRuleSchema,
+  RewriteRuleSchema,
+]);
 
-  return new Promise((resolve) => {
-    const promptText = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
-    rl.question(promptText, (answer) => {
-      rl.close();
-      resolve(answer.trim() || defaultValue || "");
-    });
-  });
-}
+export const DeployConfigSchema = z.object({
+  rules: z.array(RouteRuleSchema).min(1, "At least one rule is required"),
+});
 
-/**
- * Prompt user for confirmation
- */
-async function confirm(question: string): Promise<boolean> {
-  const answer = await prompt(`${question} (y/n)`, "n");
-  return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
-}
+type StaticRule = z.infer<typeof StaticRuleSchema>;
+type RedirectRule = z.infer<typeof RedirectRuleSchema>;
+type RewriteRule = z.infer<typeof RewriteRuleSchema>;
+type DeployConfig = z.infer<typeof DeployConfigSchema>;
 
 /**
- * Parse command-line arguments
+ * Find and parse deploy configuration file
  */
-async function getConfig(): Promise<DeployConfig> {
-  const values = parseCliArgs();
-
-  // Interactive mode if any required argument is missing
-  const needsInteractive = !values.subdomain || !values.path || !values.dir;
-
-  if (needsInteractive) {
-    console.log("🚀 Interactive deployment setup\n");
+async function findAndParseConfig(providedPath?: string): Promise<DeployConfig> {
+  let configPath: string;
+
+  if (providedPath) {
+    // Use provided path
+    configPath = resolve(providedPath);
+  } else {
+    // Look for deploy.json in current directory
+    configPath = join(process.cwd(), "deploy.json");
+
+    const hasJson = await access(configPath)
+      .then(() => true)
+      .catch(() => false);
+
+    if (!hasJson) {
+      console.error("Error: No deploy.json found in current directory");
+      console.error("Run 'bunx @just-be/deploy path/to/config.json' to specify a config file");
+      process.exit(1);
+    }
   }
 
-  let subdomain =
-    values.subdomain || (await prompt("Subdomain name (e.g., 'myapp' for myapp.just-be.dev)"));
+  // Parse JSON file
+  const content = await Bun.file(configPath).text();
+  let parsed: unknown;
 
-  // Validate subdomain format
-  if (!isValidSubdomain(subdomain)) {
-    console.error(
-      "\n❌ Invalid subdomain format. Must be alphanumeric with hyphens, 1-63 characters."
-    );
+  try {
+    parsed = JSON.parse(content);
+  } catch (error) {
+    console.error("Error: Failed to parse JSON config file");
+    console.error(error);
     process.exit(1);
   }
 
-  const path = values.path || (await prompt("R2 path prefix (e.g., 'apps/myapp')"));
-  const dir = values.dir || (await prompt("Local directory to upload", "./dist"));
-
-  let spa = values.spa;
-  let fallback = values.fallback;
-
-  // Only prompt for spa/fallback if not provided
-  if (needsInteractive && spa === undefined && fallback === undefined) {
-    spa = await confirm("Enable SPA mode? (all routes serve index.html)");
-    if (!spa) {
-      const useFallback = await confirm("Use a custom fallback file for 404s?");
-      if (useFallback) {
-        fallback = await prompt("Fallback file name", "404.html");
-      }
-    }
-  }
-
-  // Validate with Zod schema
-  const staticConfig: StaticConfig = {
-    type: "static",
-    path,
-    ...(spa && { spa }),
-    ...(fallback && { fallback }),
-  };
-
-  const result = StaticConfigSchema.safeParse(staticConfig);
+  // Validate with schema
+  const result = DeployConfigSchema.safeParse(parsed);
   if (!result.success) {
-    console.error("\n❌ Invalid configuration:");
-    console.error(result.error.format());
+    console.error("\nInvalid configuration:");
+    console.error(z.prettifyError(result.error));
     process.exit(1);
   }
 
-  return {
-    subdomain,
-    path,
-    dir,
-    spa,
-    fallback,
-  };
+  return result.data;
 }
 
 /**
@@ -177,87 +162,280 @@ async function findFiles(dir: string): Promise<string[]> {
 /**
  * Upload a file to R2
  */
-async function uploadToR2(localPath: string, r2Key: string): Promise<void> {
-  await $`wrangler r2 object put ${BUCKET_NAME}/${r2Key} --file ${localPath}`;
+async function uploadToR2(localPath: string, r2Key: string): Promise<boolean> {
+  try {
+    await wrangler`r2 object put ${BUCKET_NAME}/${r2Key} --file ${localPath}`;
+    return true;
+  } catch (error) {
+    console.error(`\nFailed to upload ${localPath}:`, error);
+    return false;
+  }
 }
 
 /**
- * Create KV entry for subdomain routing
+ * Validate KV access by attempting to list keys
  */
-async function createKVEntry(subdomain: string, config: DeployConfig): Promise<void> {
-  const routingConfig: StaticConfig = {
-    type: "static",
-    path: config.path,
-    ...(config.spa && { spa: config.spa }),
-    ...(config.fallback && { fallback: config.fallback }),
-  };
+async function validateKVAccess(): Promise<boolean> {
+  try {
+    await wrangler`kv key list --binding ROUTING_RULES --config ${WRANGLER_CONFIG}`.quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}
 
-  const configJson = JSON.stringify(routingConfig);
+/**
+ * Get the current git branch name
+ */
+async function getCurrentBranch(): Promise<string> {
+  try {
+    const result = await $`git rev-parse --abbrev-ref HEAD`.text();
+    return result.trim();
+  } catch (error) {
+    throw new Error("Failed to get current git branch. Are you in a git repository?");
+  }
+}
 
-  await $`wrangler kv key put --binding ROUTING_RULES ${subdomain} ${configJson} --config ${WRANGLER_CONFIG}`;
+/**
+ * Sanitize branch name for use in subdomain
+ * Replaces invalid characters with hyphens and converts to lowercase
+ */
+function sanitizeBranchName(branch: string): string {
+  return branch
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
 }
 
 /**
- * Main deployment function
+ * Create KV entry for subdomain routing
  */
-async function deploy() {
-  const config = await getConfig();
-
-  console.log("\n📦 Deploy Configuration:");
-  console.log(`  Subdomain: ${config.subdomain}.just-be.dev`);
-  console.log(`  R2 Path: ${config.path}`);
-  console.log(`  Local Directory: ${config.dir}`);
-  if (config.spa) {
-    console.log(`  Mode: SPA (all routes serve index.html)`);
-  } else if (config.fallback) {
-    console.log(`  Fallback: ${config.fallback}`);
+async function createKVEntry(subdomain: string, routeConfig: RouteConfig): Promise<void> {
+  const configJson = JSON.stringify(routeConfig);
+  await wrangler`kv key put --binding ROUTING_RULES ${subdomain} ${configJson} --config ${WRANGLER_CONFIG}`;
+}
+
+/**
+ * Deploy a static site rule
+ */
+async function deployStaticRule(rule: StaticRule, s: ReturnType<typeof spinner>): Promise<void> {
+  console.log(`\n📦 Deploying static site: ${rule.subdomain}.just-be.dev`);
+  console.log(`   Local Directory: ${rule.dir}`);
+  if (rule.spa) {
+    console.log(`   Mode: SPA`);
+  } else if (rule.fallback) {
+    console.log(`   Fallback: ${rule.fallback}`);
   }
-  console.log();
 
   // Verify directory exists
   try {
-    const dirStat = await stat(config.dir);
+    const dirStat = await stat(rule.dir);
     if (!dirStat.isDirectory()) {
-      console.error(`❌ Error: ${config.dir} is not a directory`);
-      process.exit(1);
+      throw new Error(`${rule.dir} is not a directory`);
     }
-  } catch {
-    console.error(`❌ Error: Directory ${config.dir} does not exist`);
-    process.exit(1);
+  } catch (error) {
+    console.error(`Error: Directory ${rule.dir} does not exist or is not accessible`);
+    throw error;
   }
 
   // Find all files to upload
-  console.log(`📂 Scanning files in: ${config.dir}\n`);
-  const filePaths = await findFiles(config.dir);
-  console.log(`Found ${filePaths.length} files to upload\n`);
+  s.start(`Scanning files in: ${rule.dir}`);
+  const filePaths = await findFiles(rule.dir);
+  s.stop(`Found ${filePaths.length} files to upload`);
 
   if (filePaths.length === 0) {
-    console.error("❌ No files found to upload");
-    process.exit(1);
+    throw new Error("No files found to upload");
   }
 
   // Upload files to R2
   let uploadCount = 0;
+  const failedUploads: string[] = [];
+
   for (const filePath of filePaths) {
-    const relativePath = relative(config.dir, filePath);
-    const r2Key = `${config.path}/${relativePath}`;
+    const relativePath = relative(rule.dir, filePath);
+    const r2Key = `${rule.subdomain}/${relativePath}`;
+
+    s.start(`Uploading ${relativePath}`);
+    const success = await uploadToR2(filePath, r2Key);
+
+    if (success) {
+      uploadCount++;
+      s.stop(`Uploaded ${relativePath}`);
+    } else {
+      s.stop(`Failed to upload ${relativePath}`);
+      failedUploads.push(relativePath);
+    }
+  }
 
-    console.log(`⬆️  ${relativePath} → ${r2Key}`);
-    await uploadToR2(filePath, r2Key);
-    uploadCount++;
+  if (failedUploads.length > 0) {
+    throw new Error(`Failed to upload ${failedUploads.length} file(s)`);
   }
 
-  console.log(`\n✅ Uploaded ${uploadCount} files to R2\n`);
+  console.log(`✓ Uploaded ${uploadCount} files to R2`);
 
-  // Create KV entry for routing
-  console.log(`🔧 Creating KV routing entry for subdomain: ${config.subdomain}`);
-  await createKVEntry(config.subdomain, config);
+  // Create KV entry (path is derived from subdomain at runtime)
+  const routeConfig: RouteConfig = {
+    type: "static",
+    ...(rule.spa && { spa: rule.spa }),
+    ...(rule.fallback && { fallback: rule.fallback }),
+  };
 
-  console.log(`\n✅ Deployment complete!`);
-  console.log(`\n🌐 Your site is available at: https://${config.subdomain}.just-be.dev`);
+  s.start(`Creating KV routing entry`);
+  await createKVEntry(rule.subdomain, routeConfig);
+  s.stop(`✓ KV routing entry created`);
 }
 
-deploy().catch((error) => {
-  console.error("\n❌ Fatal error:", error);
-  process.exit(1);
-});
+/**
+ * Deploy a redirect rule
+ */
+async function deployRedirectRule(
+  rule: RedirectRule,
+  s: ReturnType<typeof spinner>
+): Promise<void> {
+  console.log(`\n🔀 Configuring redirect: ${rule.subdomain}.just-be.dev`);
+  console.log(`   Target URL: ${rule.url}`);
+  console.log(`   Permanent: ${rule.permanent ?? false}`);
+
+  const routeConfig: RouteConfig = {
+    type: "redirect",
+    url: rule.url,
+    ...(rule.permanent !== undefined && { permanent: rule.permanent }),
+  };
+
+  s.start(`Creating KV routing entry`);
+  await createKVEntry(rule.subdomain, routeConfig);
+  s.stop(`✓ KV routing entry created`);
+}
+
+/**
+ * Deploy a rewrite rule
+ */
+async function deployRewriteRule(rule: RewriteRule, s: ReturnType<typeof spinner>): Promise<void> {
+  console.log(`\n🔄 Configuring rewrite: ${rule.subdomain}.just-be.dev`);
+  console.log(`   Target URL: ${rule.url}`);
+  console.log(`   Allowed Methods: ${rule.allowedMethods?.join(", ") || "GET, HEAD, OPTIONS"}`);
+
+  const routeConfig: RouteConfig = {
+    type: "rewrite",
+    url: rule.url,
+    ...(rule.allowedMethods && { allowedMethods: rule.allowedMethods }),
+  };
+
+  s.start(`Creating KV routing entry`);
+  await createKVEntry(rule.subdomain, routeConfig);
+  s.stop(`✓ KV routing entry created`);
+}
+
+/**
+ * Main deployment function
+ */
+async function deploy() {
+  intro("🚀 Just-Be Deploy");
+
+  // Parse CLI arguments
+  const args = Bun.argv.slice(2);
+  const isPreview = args[0] === "preview";
+
+  let config: DeployConfig;
+  let rulesToDeploy: (StaticRule | RedirectRule | RewriteRule)[];
+
+  if (isPreview) {
+    // Preview mode: deploy preview <subdomain> [config-path]
+    const targetSubdomain = args[1];
+    const configPath = args[2];
+
+    if (!targetSubdomain) {
+      console.error("Error: Subdomain is required for preview deploy");
+      console.error("Usage: bunx @just-be/deploy preview <subdomain> [config-path]");
+      process.exit(1);
+    }
+
+    // Get current branch
+    const branch = await getCurrentBranch();
+    const sanitizedBranch = sanitizeBranchName(branch);
+
+    console.log(`\n📋 Preview Deploy Mode`);
+    console.log(`   Branch: ${branch}`);
+    console.log(`   Sanitized: ${sanitizedBranch}`);
+
+    // Load config
+    config = await findAndParseConfig(configPath);
+
+    // Find the matching rule
+    const matchingRule = config.rules.find((rule) => rule.subdomain === targetSubdomain);
+
+    if (!matchingRule) {
+      console.error(`\nError: No rule found with subdomain "${targetSubdomain}"`);
+      console.error(`\nAvailable subdomains: ${config.rules.map((r) => r.subdomain).join(", ")}`);
+      process.exit(1);
+    }
+
+    if (matchingRule.type !== "static") {
+      console.error(`\nError: Preview deploys only support static rules`);
+      console.error(`The rule "${targetSubdomain}" is of type "${matchingRule.type}"`);
+      process.exit(1);
+    }
+
+    // Clone rule and modify subdomain
+    const previewSubdomain = `${targetSubdomain}-${sanitizedBranch}`;
+    const previewRule: StaticRule = {
+      ...matchingRule,
+      subdomain: previewSubdomain,
+    };
+
+    rulesToDeploy = [previewRule];
+    console.log(`   Preview subdomain: ${previewSubdomain}.just-be.dev\n`);
+  } else {
+    // Normal mode: deploy all rules
+    const configPath = args[0];
+    config = await findAndParseConfig(configPath);
+    rulesToDeploy = config.rules;
+    console.log(`\nFound ${config.rules.length} rule(s) to deploy`);
+  }
+
+  // Validate KV access before starting
+  const s = spinner();
+  s.start("Validating KV access");
+  const hasKVAccess = await validateKVAccess();
+  if (!hasKVAccess) {
+    s.stop("Error: Cannot access KV namespace");
+    console.error("Check wrangler configuration and permissions.");
+    process.exit(1);
+  }
+  s.stop("✓ KV access validated");
+
+  // Deploy each rule
+  const deployedSubdomains: string[] = [];
+  for (const rule of rulesToDeploy) {
+    try {
+      switch (rule.type) {
+        case "static":
+          await deployStaticRule(rule, s);
+          deployedSubdomains.push(`https://${rule.subdomain}.just-be.dev`);
+          break;
+        case "redirect":
+          await deployRedirectRule(rule, s);
+          deployedSubdomains.push(`https://${rule.subdomain}.just-be.dev → ${rule.url}`);
+          break;
+        case "rewrite":
+          await deployRewriteRule(rule, s);
+          deployedSubdomains.push(`https://${rule.subdomain}.just-be.dev ⟲ ${rule.url}`);
+          break;
+      }
+    } catch (error) {
+      console.error(`\n❌ Failed to deploy ${rule.subdomain}:`, error);
+      process.exit(1);
+    }
+  }
+
+  outro("\n✅ Deployment complete!\n\nDeployed sites:\n" + deployedSubdomains.join("\n"));
+}
+
+// Only run deploy() when this file is executed directly, not when imported
+if (import.meta.main) {
+  deploy().catch((error) => {
+    console.error("\n❌ Fatal error:", error);
+    process.exit(1);
+  });
+}

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "@just-be/deploy",
-  "version": "0.1.1",
-  "description": "Deploy static files to Cloudflare R2 and configure subdomain routing",
+  "version": "0.3.0",
+  "description": "Deploy static sites to Cloudflare R2 with subdomain routing",
   "type": "module",
-  "bin": "./index.ts",
+  "bin": {
+    "deploy": "index.ts"
+  },
   "files": [
-    "index.ts"
+    "index.ts",
+    "schema.json"
   ],
+  "scripts": {
+    "generate-schema": "bun run scripts/generate-schema.ts"
+  },
   "keywords": [
     "cloudflare",
     "r2",
@@ -17,13 +23,19 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/justbejyk/just-be.dev.git",
+    "url": "git+https://github.com/just-be-dev/just-be.dev.git",
     "directory": "packages/deploy"
   },
   "engines": {
     "bun": ">=1.0.0"
   },
   "dependencies": {
-    "@just-be/wildcard": "0.1.0"
+    "@clack/prompts": "^0.11.0",
+    "@just-be/wildcard": "0.2.0",
+    "wrangler": "4.48.0",
+    "zod": "^4.1.13"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

package/schema.json

@@ -0,0 +1,89 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "rules": {
+      "minItems": 1,
+      "type": "array",
+      "items": {
+        "oneOf": [
+          {
+            "type": "object",
+            "properties": {
+              "type": {
+                "type": "string",
+                "const": "static"
+              },
+              "spa": {
+                "type": "boolean"
+              },
+              "fallback": {
+                "type": "string"
+              },
+              "subdomain": {
+                "type": "string"
+              },
+              "dir": {
+                "type": "string",
+                "minLength": 1
+              }
+            },
+            "required": ["type", "subdomain", "dir"],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "properties": {
+              "type": {
+                "type": "string",
+                "const": "redirect"
+              },
+              "url": {
+                "type": "string",
+                "format": "uri"
+              },
+              "permanent": {
+                "type": "boolean"
+              },
+              "subdomain": {
+                "type": "string"
+              }
+            },
+            "required": ["type", "url", "subdomain"],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "properties": {
+              "type": {
+                "type": "string",
+                "const": "rewrite"
+              },
+              "url": {
+                "type": "string",
+                "format": "uri"
+              },
+              "allowedMethods": {
+                "default": ["GET", "HEAD", "OPTIONS"],
+                "type": "array",
+                "items": {
+                  "type": "string",
+                  "enum": ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]
+                }
+              },
+              "subdomain": {
+                "type": "string"
+              }
+            },
+            "required": ["type", "url", "allowedMethods", "subdomain"],
+            "additionalProperties": false
+          }
+        ]
+      }
+    }
+  },
+  "required": ["rules"],
+  "additionalProperties": false,
+  "title": "Deploy Configuration",
+  "description": "Configuration for deploying static sites and setting up routing for the wildcard subdomain service"
+}