@just-be/deploy 0.1.0

package/README.md

@@ -0,0 +1,121 @@
+# @just-be/deploy
+
+Deploy static files to Cloudflare R2 and configure subdomain routing in KV for wildcard subdomain services.
+
+## Requirements
+
+- [Bun](https://bun.sh/) runtime
+- [Wrangler](https://developers.cloudflare.com/workers/wrangler/) CLI configured with Cloudflare credentials
+- A Cloudflare Workers wildcard subdomain service with R2 and KV configured
+
+## Installation
+
+No installation needed! Run directly with `bunx`:
+
+```bash
+bunx @just-be/deploy
+```
+
+Or install globally:
+
+```bash
+bun install -g @just-be/deploy
+```
+
+## Usage
+
+### Interactive Mode
+
+Simply run without arguments to be prompted for all configuration:
+
+```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
+
+### Command-Line Mode
+
+Provide all arguments upfront:
+
+```bash
+bunx @just-be/deploy --subdomain=NAME --path=PATH --dir=DIR [--spa] [--fallback=FILE]
+```
+
+### Arguments
+
+- `--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)
+
+### Examples
+
+**Interactive deployment:**
+```bash
+bunx @just-be/deploy
+```
+
+**Deploy a static site:**
+```bash
+bunx @just-be/deploy \
+  --subdomain=portfolio \
+  --path=sites/portfolio \
+  --dir=./dist
+```
+
+**Deploy a single-page application:**
+```bash
+bunx @just-be/deploy \
+  --subdomain=myapp \
+  --path=apps/myapp \
+  --dir=./build \
+  --spa
+```
+
+**Deploy with custom 404 page:**
+```bash
+bunx @just-be/deploy \
+  --subdomain=docs \
+  --path=sites/docs \
+  --dir=./out \
+  --fallback=404.html
+```
+
+## 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`
+
+## Configuration
+
+The script expects your wildcard service to use:
+- **R2 Bucket**: `content-bucket`
+- **KV Binding**: `ROUTING_RULES`
+- **Wrangler Config**: `services/wildcard/wrangler.toml`
+
+## Validation
+
+Configuration is validated using Zod schemas to ensure:
+- SPA mode and fallback file are not used together
+- R2 path is not empty
+- All required fields are present
+
+## Related Packages
+
+- [`@just-be/wildcard-schemas`](../wildcard-schemas) - Shared Zod schemas for configuration validation
+
+## License
+
+MIT

package/index.ts

@@ -0,0 +1,263 @@
+#!/usr/bin/env bun
+
+/**
+ * Deploy static files to Cloudflare R2 and configure subdomain routing in KV
+ *
+ * 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
+ *
+ * Or run interactively without arguments:
+ *   bunx @just-be/deploy
+ */
+
+import { $ } from "bun";
+import { readdir, stat } from "fs/promises";
+import { join, relative } from "path";
+import { createInterface } from "readline";
+import { z } from "zod";
+import { StaticConfigSchema, type StaticConfig, isValidSubdomain } from "@just-be/wildcard";
+
+const BUCKET_NAME = "content-bucket";
+const WRANGLER_CONFIG = "services/wildcard/wrangler.toml";
+
+/**
+ * Schema for CLI arguments
+ */
+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>;
+
+/**
+ * Parse command-line arguments from Bun.argv
+ */
+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;
+      }
+    }
+  }
+
+  return CliArgsSchema.parse(args);
+}
+
+interface DeployConfig extends Omit<StaticConfig, "type"> {
+  subdomain: string;
+  dir: string;
+}
+
+/**
+ * Prompt user for input
+ */
+async function prompt(question: string, defaultValue?: string): Promise<string> {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    const promptText = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
+    rl.question(promptText, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue || "");
+    });
+  });
+}
+
+/**
+ * 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";
+}
+
+/**
+ * Parse command-line arguments
+ */
+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");
+  }
+
+  let subdomain =
+    values.subdomain || (await prompt("Subdomain name (e.g., 'myapp' for myapp.just-be.dev)"));
+
+  // Validate subdomain format
+  if (!isValidSubdomain(subdomain)) {
+    console.error(
+      "\n❌ Invalid subdomain format. Must be alphanumeric with hyphens, 1-63 characters."
+    );
+    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);
+  if (!result.success) {
+    console.error("\n❌ Invalid configuration:");
+    console.error(result.error.format());
+    process.exit(1);
+  }
+
+  return {
+    subdomain,
+    path,
+    dir,
+    spa,
+    fallback,
+  };
+}
+
+/**
+ * Recursively find all files in a directory
+ */
+async function findFiles(dir: string): Promise<string[]> {
+  const results: string[] = [];
+
+  async function walk(currentDir: string): Promise<void> {
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+      } else if (entry.isFile()) {
+        results.push(fullPath);
+      }
+    }
+  }
+
+  await walk(dir);
+  return results;
+}
+
+/**
+ * Upload a file to R2
+ */
+async function uploadToR2(localPath: string, r2Key: string): Promise<void> {
+  await $`wrangler r2 object put ${BUCKET_NAME}/${r2Key} --file ${localPath}`;
+}
+
+/**
+ * Create KV entry for subdomain routing
+ */
+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 }),
+  };
+
+  const configJson = JSON.stringify(routingConfig);
+
+  await $`wrangler kv key put --binding ROUTING_RULES ${subdomain} ${configJson} --config ${WRANGLER_CONFIG}`;
+}
+
+/**
+ * Main deployment function
+ */
+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}`);
+  }
+  console.log();
+
+  // Verify directory exists
+  try {
+    const dirStat = await stat(config.dir);
+    if (!dirStat.isDirectory()) {
+      console.error(`❌ Error: ${config.dir} is not a directory`);
+      process.exit(1);
+    }
+  } catch {
+    console.error(`❌ Error: Directory ${config.dir} does not exist`);
+    process.exit(1);
+  }
+
+  // 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`);
+
+  if (filePaths.length === 0) {
+    console.error("❌ No files found to upload");
+    process.exit(1);
+  }
+
+  // Upload files to R2
+  let uploadCount = 0;
+  for (const filePath of filePaths) {
+    const relativePath = relative(config.dir, filePath);
+    const r2Key = `${config.path}/${relativePath}`;
+
+    console.log(`⬆️  ${relativePath} → ${r2Key}`);
+    await uploadToR2(filePath, r2Key);
+    uploadCount++;
+  }
+
+  console.log(`\n✅ Uploaded ${uploadCount} files to R2\n`);
+
+  // Create KV entry for routing
+  console.log(`🔧 Creating KV routing entry for subdomain: ${config.subdomain}`);
+  await createKVEntry(config.subdomain, config);
+
+  console.log(`\n✅ Deployment complete!`);
+  console.log(`\n🌐 Your site is available at: https://${config.subdomain}.just-be.dev`);
+}
+
+deploy().catch((error) => {
+  console.error("\n❌ Fatal error:", error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@just-be/deploy",
+  "version": "0.1.0",
+  "description": "Deploy static files to Cloudflare R2 and configure subdomain routing",
+  "type": "module",
+  "bin": "./index.ts",
+  "files": [
+    "index.ts"
+  ],
+  "keywords": [
+    "cloudflare",
+    "r2",
+    "deploy",
+    "static-site"
+  ],
+  "author": "Justin Bennett",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/justbejyk/just-be.dev.git",
+    "directory": "packages/deploy"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "dependencies": {
+    "@just-be/wildcard": "0.1.0"
+  }
+}