creek 0.2.2 → 0.3.0-alpha.10

package/dist/commands/claim.d.ts

@@ -0,0 +1,8 @@
+export declare const claimCommand: import("citty").CommandDef<{
+    sandboxId: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+}>;
+//# sourceMappingURL=claim.d.ts.map

package/dist/commands/claim.js

@@ -0,0 +1,84 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { CreekClient } from "@solcreek/sdk";
+import { getToken, getApiUrl, getSandboxApiUrl } from "../utils/config.js";
+export const claimCommand = defineCommand({
+    meta: {
+        name: "claim",
+        description: "Claim a sandbox deployment as a permanent project",
+    },
+    args: {
+        sandboxId: {
+            type: "positional",
+            description: "Sandbox ID to claim (shown after sandbox deploy)",
+            required: true,
+        },
+    },
+    async run({ args }) {
+        const token = getToken();
+        if (!token) {
+            consola.error("You need to be logged in to claim a sandbox.");
+            consola.info("Run `creek login` first, then `creek claim` again.");
+            process.exit(1);
+        }
+        const sandboxId = args.sandboxId;
+        // 1. Fetch sandbox info
+        consola.start("Looking up sandbox...");
+        const sandboxApiUrl = getSandboxApiUrl();
+        const statusRes = await fetch(`${sandboxApiUrl}/api/sandbox/${sandboxId}/status`);
+        if (!statusRes.ok) {
+            consola.error("Sandbox not found. It may have expired.");
+            process.exit(1);
+        }
+        const sandbox = (await statusRes.json());
+        if (!sandbox.claimable) {
+            if (sandbox.status === "expired") {
+                consola.error("This sandbox has expired and can no longer be claimed.");
+                consola.info("Run `creek deploy` to deploy your project permanently.");
+            }
+            else {
+                consola.error(`Sandbox is in '${sandbox.status}' state and cannot be claimed.`);
+            }
+            process.exit(1);
+        }
+        // 2. Create permanent project
+        consola.start("Creating permanent project...");
+        const client = new CreekClient(getApiUrl(), token);
+        const slug = sandbox.templateId ?? sandboxId;
+        let project;
+        try {
+            const res = await client.createProject({
+                slug,
+                framework: sandbox.framework,
+            });
+            project = res.project;
+        }
+        catch {
+            // Slug might conflict, try with sandbox ID suffix
+            const res = await client.createProject({
+                slug: `${slug}-${sandboxId}`,
+                framework: sandbox.framework,
+            });
+            project = res.project;
+        }
+        consola.success(`Created project: ${project.slug}`);
+        // 3. Mark sandbox as claimed
+        try {
+            await fetch(`${sandboxApiUrl}/api/sandbox/${sandboxId}/claim`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ projectId: project.id }),
+            });
+        }
+        catch {
+            // Best effort — claim status update is non-critical
+        }
+        consola.success("Sandbox claimed!");
+        consola.info("");
+        consola.info("Next steps:");
+        consola.info(`  cd your-project`);
+        consola.info(`  creek init`);
+        consola.info(`  creek deploy    # deploy permanently`);
+    },
+});
+//# sourceMappingURL=claim.js.map

package/dist/commands/deploy.d.ts

@@ -0,0 +1,23 @@
+export declare const deployCommand: import("citty").CommandDef<{
+    dir: {
+        type: "positional";
+        description: string;
+        required: false;
+    };
+    "skip-build": {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    demo: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    template: {
+        type: "string";
+        description: string;
+        required: false;
+    };
+}>;
+//# sourceMappingURL=deploy.d.ts.map

package/dist/commands/deploy.js

@@ -0,0 +1,465 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { execSync, execFileSync } from "node:child_process";
+import { parseConfig, CreekClient, CreekAuthError, isSSRFramework, getSSRServerEntry, getClientAssetsDir, getDefaultBuildOutput, detectFramework, } from "@solcreek/sdk";
+import { getToken, getApiUrl } from "../utils/config.js";
+import { collectAssets } from "../utils/bundle.js";
+import { bundleSSRServer } from "../utils/ssr-bundle.js";
+import { sandboxDeploy, pollSandboxStatus, printSandboxSuccess } from "../utils/sandbox.js";
+export const deployCommand = defineCommand({
+    meta: {
+        name: "deploy",
+        description: "Deploy the current project to Creek",
+    },
+    args: {
+        dir: {
+            type: "positional",
+            description: "Directory to deploy (default: current directory)",
+            required: false,
+        },
+        "skip-build": {
+            type: "boolean",
+            description: "Skip the build step",
+            default: false,
+        },
+        demo: {
+            type: "boolean",
+            description: "Deploy a sample site to see Creek in action",
+            default: false,
+        },
+        template: {
+            type: "string",
+            description: "Deploy a template (e.g., react-dashboard, astro-landing)",
+            required: false,
+        },
+    },
+    async run({ args }) {
+        // --- Demo deploy (zero-friction showcase) ---
+        if (args.demo) {
+            return await deployDemo();
+        }
+        // --- Template deploy ---
+        if (args.template) {
+            return await deployTemplate(args.template);
+        }
+        // --- Resolve target directory ---
+        const cwd = args.dir ? resolve(args.dir) : process.cwd();
+        const configPath = join(cwd, "creek.toml");
+        const hasConfig = existsSync(configPath);
+        const token = getToken();
+        // --- Explicit directory (creek deploy ./dist) ---
+        if (args.dir) {
+            if (!existsSync(cwd)) {
+                consola.error(`Directory not found: ${args.dir}`);
+                process.exit(1);
+            }
+            return await deployDirectory(cwd);
+        }
+        // --- Authenticated deploy (creek.toml present) ---
+        if (hasConfig) {
+            if (!token) {
+                consola.error("Not authenticated. Run `creek login` first.");
+                consola.info("Or deploy without an account: remove creek.toml and run `creek deploy` again.");
+                process.exit(1);
+            }
+            return await deployAuthenticated(cwd, configPath, token, args["skip-build"]);
+        }
+        // --- Sandbox deploy (has package.json → auto-detect + build) ---
+        if (existsSync(join(cwd, "package.json"))) {
+            return await deploySandbox(cwd, args["skip-build"]);
+        }
+        // --- Auto-detect build output dirs ---
+        for (const dir of ["dist", "build", "out", ".output/public"]) {
+            const fullPath = resolve(cwd, dir);
+            if (existsSync(fullPath)) {
+                consola.info(`Found build output: ${dir}/`);
+                return await deployDirectory(fullPath);
+            }
+        }
+        // --- Nothing found → guide the user ---
+        consola.info("No project found in this directory.\n");
+        consola.info("  creek deploy ./dist        Deploy a build output directory");
+        consola.info("  creek deploy --demo        Deploy a sample site (see Creek in 5 seconds)");
+        consola.info("");
+        consola.info("Or create a project first:");
+        consola.info("  npm create vite@latest my-app && cd my-app && npx creek deploy");
+        process.exit(1);
+    },
+});
+// ============================================================================
+// Demo deploy — pre-built page, zero dependencies, instant
+// ============================================================================
+const DEMO_HTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Creek Deploy Demo</title>
+<style>
+*{margin:0;padding:0;box-sizing:border-box}
+body{font-family:system-ui,-apple-system,sans-serif;background:#0a0a0a;color:#f5f5f5;min-height:100vh;display:flex;flex-direction:column;align-items:center;justify-content:center}
+.card{max-width:480px;text-align:center;padding:3rem 2rem}
+h1{font-size:2rem;font-weight:700;letter-spacing:-0.03em;margin-bottom:0.5rem}
+.accent{background:linear-gradient(135deg,#38bdf8,#818cf8);-webkit-background-clip:text;-webkit-text-fill-color:transparent;background-clip:text}
+p{color:#888;line-height:1.6;margin-top:1rem}
+.meta{margin-top:2rem;font-size:0.85rem;color:#555}
+.cta{display:inline-block;margin-top:1.5rem;background:linear-gradient(135deg,#2563eb,#3b82f6);color:#fff;padding:10px 24px;border-radius:8px;text-decoration:none;font-weight:600;font-size:0.9rem;transition:opacity 0.15s}
+.cta:hover{opacity:0.9}
+code{background:#1a1a2e;padding:2px 8px;border-radius:4px;font-size:0.85rem;color:#a5b4fc}
+.pulse{width:12px;height:12px;background:#22c55e;border-radius:50%;display:inline-block;margin-right:8px;animation:pulse 2s infinite}
+@keyframes pulse{0%,100%{opacity:1}50%{opacity:0.4}}
+</style>
+</head>
+<body>
+<div class="card">
+<h1><span class="accent">Creek</span> is live.</h1>
+<p>This site was deployed to the edge in seconds — no build step, no config, no account.</p>
+<p style="margin-top:1.5rem"><span class="pulse"></span>Running on Cloudflare's global network</p>
+<p class="meta">Now try it with your own project:</p>
+<p style="margin-top:0.5rem"><code>cd your-project && npx creek deploy</code></p>
+<a href="https://creek.dev" class="cta">Learn more about Creek</a>
+</div>
+<script>document.title="Creek Deploy Demo — "+new Date().toLocaleTimeString()</script>
+</body>
+</html>`;
+async function deployDemo() {
+    consola.start("Deploying demo site...");
+    try {
+        const result = await sandboxDeploy({
+            assets: { "index.html": Buffer.from(DEMO_HTML).toString("base64") },
+            source: "cli-demo",
+        });
+        consola.start("Waiting for deployment...");
+        const status = await pollSandboxStatus(result.statusUrl);
+        const duration = status.deployDurationMs
+            ? `in ${(status.deployDurationMs / 1000).toFixed(1)}s`
+            : "in seconds";
+        consola.success(`Live ${duration} → ${status.previewUrl}`);
+        consola.info("");
+        consola.info("That's Creek. Now deploy your own project:");
+        consola.info("  cd your-project && npx creek deploy");
+    }
+    catch (err) {
+        consola.error(err instanceof Error ? err.message : "Demo deploy failed");
+        process.exit(1);
+    }
+}
+// ============================================================================
+// Directory deploy — deploy pre-built static files directly
+// ============================================================================
+async function deployDirectory(dir) {
+    consola.info("Deploying to sandbox (60 min preview).");
+    consola.start("Collecting assets...");
+    const { assets, fileList } = collectAssets(dir);
+    if (fileList.length === 0) {
+        consola.error("No files found in directory.");
+        process.exit(1);
+    }
+    consola.info(`Found ${fileList.length} files`);
+    consola.start("Deploying...");
+    try {
+        const result = await sandboxDeploy({ assets, source: "cli" });
+        consola.start("Waiting for deployment...");
+        const status = await pollSandboxStatus(result.statusUrl);
+        printSandboxSuccess(status.previewUrl, result.expiresAt, result.sandboxId);
+    }
+    catch (err) {
+        consola.error(err instanceof Error ? err.message : "Deploy failed");
+        process.exit(1);
+    }
+}
+// ============================================================================
+// Sandbox deploy — auto-detect framework, build, deploy
+// ============================================================================
+async function deploySandbox(cwd, skipBuild) {
+    consola.info("Deploying to sandbox (60 min preview).");
+    consola.info("");
+    const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf-8"));
+    const framework = detectFramework(pkg);
+    if (framework) {
+        consola.info(`Detected: ${framework}`);
+    }
+    else {
+        consola.info("Framework: auto (static site)");
+    }
+    // Build
+    const buildCommand = pkg.scripts?.build ? "npm run build" : null;
+    const outputDir = resolve(cwd, getDefaultBuildOutput(framework));
+    if (!skipBuild) {
+        if (!buildCommand) {
+            consola.error("No build script found in package.json.");
+            consola.info("Add a 'build' script or use --skip-build if already built.");
+            process.exit(1);
+        }
+        consola.start(`Building with: ${buildCommand}`);
+        try {
+            execSync(buildCommand, { cwd, stdio: "inherit" });
+        }
+        catch {
+            consola.error("Build failed");
+            consola.info("");
+            consola.info("Common fixes:");
+            consola.info("  • npm install (missing dependencies?)");
+            consola.info("  • Check for TypeScript errors");
+            consola.info(`  • Verify build works: ${buildCommand}`);
+            process.exit(1);
+        }
+        consola.success("Build complete");
+    }
+    if (!existsSync(outputDir)) {
+        consola.error(`Build output not found: ${outputDir}`);
+        if (framework) {
+            consola.info(`Expected output for ${framework}: ${getDefaultBuildOutput(framework)}`);
+        }
+        process.exit(1);
+    }
+    // Collect assets
+    const isSSR = isSSRFramework(framework);
+    const renderMode = isSSR ? "ssr" : "spa";
+    let clientAssetsDir = outputDir;
+    if (isSSR && framework) {
+        const subdir = getClientAssetsDir(framework);
+        if (subdir)
+            clientAssetsDir = resolve(outputDir, subdir);
+    }
+    consola.start("Collecting assets...");
+    const { assets: clientAssets, fileList } = collectAssets(clientAssetsDir);
+    consola.info(`Found ${fileList.length} assets`);
+    let serverFiles;
+    if (isSSR && framework) {
+        const serverEntry = getSSRServerEntry(framework);
+        if (serverEntry) {
+            const serverEntryPath = resolve(outputDir, serverEntry);
+            if (existsSync(serverEntryPath)) {
+                consola.start("Bundling SSR server...");
+                const bundled = await bundleSSRServer(serverEntryPath);
+                serverFiles = { "server.js": Buffer.from(bundled).toString("base64") };
+                consola.success(`SSR bundled (${Math.round(bundled.length / 1024)}KB)`);
+            }
+        }
+    }
+    // Deploy to sandbox
+    consola.start("Deploying...");
+    try {
+        const result = await sandboxDeploy({
+            assets: clientAssets,
+            serverFiles,
+            framework: framework ?? undefined,
+            source: "cli",
+        });
+        consola.start("Waiting for deployment...");
+        const status = await pollSandboxStatus(result.statusUrl);
+        printSandboxSuccess(status.previewUrl, result.expiresAt, result.sandboxId);
+    }
+    catch (err) {
+        consola.error(err instanceof Error ? err.message : "Sandbox deploy failed");
+        process.exit(1);
+    }
+}
+// ============================================================================
+// Template deploy — clone + build + deploy to sandbox
+// ============================================================================
+async function deployTemplate(templateId) {
+    // Validate template ID — alphanumeric, hyphens, underscores only (no path traversal)
+    if (!/^[a-zA-Z0-9_-]+$/.test(templateId)) {
+        consola.error("Invalid template name. Use only letters, numbers, hyphens, and underscores.");
+        process.exit(1);
+    }
+    consola.info(`Deploying template: ${templateId}`);
+    // Clone template to temp dir
+    const tmpDir = join(process.env.TMPDIR ?? "/tmp", `creek-template-${Date.now()}`);
+    const repoUrl = "https://github.com/solcreek/templates";
+    consola.start("Cloning template...");
+    try {
+        execFileSync("git", [
+            "clone", "--depth", "1", "--filter=blob:none", "--sparse", repoUrl, tmpDir,
+        ], { stdio: "pipe" });
+        execFileSync("git", [
+            "sparse-checkout", "set", templateId,
+        ], { cwd: tmpDir, stdio: "pipe" });
+    }
+    catch {
+        consola.error(`Template '${templateId}' not found.`);
+        consola.info("Available templates: creek deploy --template");
+        cleanupDir(tmpDir);
+        process.exit(1);
+    }
+    const templateDir = join(tmpDir, templateId);
+    // Verify resolved path is still within tmpDir (prevent path traversal)
+    if (!resolve(templateDir).startsWith(resolve(tmpDir))) {
+        consola.error("Invalid template path.");
+        cleanupDir(tmpDir);
+        process.exit(1);
+    }
+    if (!existsSync(templateDir)) {
+        consola.error(`Template directory not found: ${templateId}`);
+        cleanupDir(tmpDir);
+        process.exit(1);
+    }
+    consola.start("Installing dependencies...");
+    try {
+        execFileSync("npm", ["install"], { cwd: templateDir, stdio: "pipe" });
+    }
+    catch {
+        consola.error("Failed to install dependencies");
+        cleanupDir(tmpDir);
+        process.exit(1);
+    }
+    // Deploy as sandbox (reuse sandbox flow)
+    await deploySandbox(templateDir, false);
+    // Cleanup
+    cleanupDir(tmpDir);
+}
+function cleanupDir(dir) {
+    try {
+        rmSync(dir, { recursive: true, force: true });
+    }
+    catch {
+        // ignore
+    }
+}
+// ============================================================================
+// Authenticated deploy — existing flow
+// ============================================================================
+async function deployAuthenticated(cwd, configPath, token, skipBuild) {
+    try {
+        const config = parseConfig(readFileSync(configPath, "utf-8"));
+        consola.info(`Project: ${config.project.name}`);
+        const client = new CreekClient(getApiUrl(), token);
+        // Ensure project exists
+        let project;
+        try {
+            project = await client.getProject(config.project.name);
+        }
+        catch {
+            consola.info("Project not found, creating...");
+            const res = await client.createProject({
+                slug: config.project.name,
+                framework: config.project.framework,
+            });
+            project = res.project;
+            consola.success(`Created project: ${project.slug}`);
+        }
+        // Build — creek.toml build.command is user-defined, analogous to npm scripts
+        if (!skipBuild) {
+            const buildCmd = config.build.command;
+            if (!buildCmd || typeof buildCmd !== "string" || buildCmd.length > 500) {
+                consola.error("Invalid build command in creek.toml");
+                process.exit(1);
+            }
+            consola.start(`Building with: ${buildCmd}`);
+            try {
+                execSync(buildCmd, { cwd, stdio: "inherit" });
+            }
+            catch {
+                consola.error("Build failed");
+                process.exit(1);
+            }
+            consola.success("Build complete");
+        }
+        const outputDir = resolve(cwd, config.build.output);
+        if (!existsSync(outputDir)) {
+            consola.error(`Build output directory not found: ${config.build.output}`);
+            process.exit(1);
+        }
+        const framework = config.project.framework ?? null;
+        const isSSR = isSSRFramework(framework);
+        const renderMode = isSSR ? "ssr" : "spa";
+        let clientAssetsDir = outputDir;
+        if (isSSR && framework) {
+            const clientSubdir = getClientAssetsDir(framework);
+            if (clientSubdir) {
+                clientAssetsDir = resolve(outputDir, clientSubdir);
+            }
+        }
+        consola.start("Collecting assets...");
+        const { assets: clientAssets, fileList } = collectAssets(clientAssetsDir);
+        consola.info(`Found ${fileList.length} client assets`);
+        let serverFiles;
+        if (isSSR && framework) {
+            const serverEntry = getSSRServerEntry(framework);
+            if (serverEntry) {
+                const serverEntryPath = resolve(outputDir, serverEntry);
+                if (existsSync(serverEntryPath)) {
+                    consola.start("Bundling SSR server...");
+                    const bundled = await bundleSSRServer(serverEntryPath);
+                    serverFiles = {
+                        "server.js": Buffer.from(bundled).toString("base64"),
+                    };
+                    consola.success(`SSR server bundled (${Math.round(bundled.length / 1024)}KB)`);
+                }
+            }
+        }
+        consola.start("Creating deployment...");
+        const { deployment } = await client.createDeployment(project.id);
+        consola.start("Uploading...");
+        const bundle = {
+            manifest: {
+                assets: fileList,
+                hasWorker: isSSR,
+                entrypoint: null,
+                renderMode,
+            },
+            workerScript: null,
+            assets: clientAssets,
+            serverFiles,
+            resources: config.resources,
+        };
+        await client.uploadDeploymentBundle(project.id, deployment.id, bundle);
+        // Poll for async deploy progress
+        const POLL_INTERVAL = 1000;
+        const POLL_TIMEOUT = 120_000;
+        const TERMINAL = new Set(["active", "failed", "cancelled"]);
+        const STEP_LABELS = {
+            queued: "Waiting...",
+            uploading: "Uploading bundle...",
+            provisioning: "Provisioning resources...",
+            deploying: "Deploying to edge...",
+        };
+        let lastStatus = "";
+        const start = Date.now();
+        while (Date.now() - start < POLL_TIMEOUT) {
+            const res = await client.getDeploymentStatus(project.id, deployment.id);
+            const { status, failed_step, error_message } = res.deployment;
+            if (status !== lastStatus) {
+                if (lastStatus && STEP_LABELS[lastStatus]) {
+                    consola.success(STEP_LABELS[lastStatus].replace("...", ""));
+                }
+                if (!TERMINAL.has(status) && STEP_LABELS[status]) {
+                    consola.start(STEP_LABELS[status]);
+                }
+                lastStatus = status;
+            }
+            if (status === "active") {
+                consola.success(`Deployed! ${res.url ?? res.previewUrl}`);
+                if (res.url && res.previewUrl) {
+                    consola.info(`Preview:  ${res.previewUrl}`);
+                }
+                return;
+            }
+            if (status === "failed") {
+                const step = failed_step ? ` at ${failed_step}` : "";
+                const msg = error_message ?? "Unknown error";
+                consola.error(`Deploy failed${step}: ${msg}`);
+                process.exit(1);
+            }
+            if (status === "cancelled") {
+                consola.warn("Deploy was cancelled");
+                process.exit(1);
+            }
+            await new Promise((r) => setTimeout(r, POLL_INTERVAL));
+        }
+        consola.error("Deploy timed out after 2 minutes");
+        process.exit(1);
+    }
+    catch (err) {
+        if (err instanceof CreekAuthError) {
+            consola.error("Authentication failed. Run `creek login` to re-authenticate.");
+            process.exit(1);
+        }
+        throw err;
+    }
+}
+//# sourceMappingURL=deploy.js.map

package/dist/commands/env.d.ts

@@ -0,0 +1,2 @@
+export declare const envCommand: import("citty").CommandDef<import("citty").ArgsDef>;
+//# sourceMappingURL=env.d.ts.map

package/dist/commands/env.js

@@ -0,0 +1,87 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { CreekClient } from "@solcreek/sdk";
+import { getToken, getApiUrl } from "../utils/config.js";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseConfig } from "@solcreek/sdk";
+function getProjectSlug() {
+    const configPath = join(process.cwd(), "creek.toml");
+    if (!existsSync(configPath)) {
+        consola.error("No creek.toml found. Run `creek init` first.");
+        process.exit(1);
+    }
+    return parseConfig(readFileSync(configPath, "utf-8")).project.name;
+}
+function getClient() {
+    const token = getToken();
+    if (!token) {
+        consola.error("Not authenticated. Run `creek login` first.");
+        process.exit(1);
+    }
+    return new CreekClient(getApiUrl(), token);
+}
+const envSet = defineCommand({
+    meta: { name: "set", description: "Set an environment variable" },
+    args: {
+        key: { type: "positional", description: "Variable name (e.g. DATABASE_URL)", required: true },
+        value: { type: "positional", description: "Variable value", required: true },
+    },
+    async run({ args }) {
+        const client = getClient();
+        const slug = getProjectSlug();
+        await client.setEnvVar(slug, args.key, args.value);
+        consola.success(`Set ${args.key}`);
+    },
+});
+function redact(value) {
+    if (value.length <= 4)
+        return "••••";
+    return value.slice(0, 2) + "•".repeat(Math.min(value.length - 4, 20)) + value.slice(-2);
+}
+const envGet = defineCommand({
+    meta: { name: "ls", description: "List environment variables" },
+    args: {
+        show: { type: "boolean", description: "Show values in plaintext (default: redacted)", default: false },
+    },
+    async run({ args }) {
+        const client = getClient();
+        const slug = getProjectSlug();
+        const vars = await client.listEnvVars(slug);
+        if (vars.length === 0) {
+            consola.info("No environment variables set.");
+            return;
+        }
+        for (const v of vars) {
+            const displayed = args.show ? v.value : redact(v.value);
+            consola.log(`  ${v.key} = ${displayed}`);
+        }
+        if (!args.show) {
+            consola.info("  (use --show to reveal values)");
+        }
+    },
+});
+const envRm = defineCommand({
+    meta: { name: "rm", description: "Remove an environment variable" },
+    args: {
+        key: { type: "positional", description: "Variable name to remove", required: true },
+    },
+    async run({ args }) {
+        const client = getClient();
+        const slug = getProjectSlug();
+        await client.deleteEnvVar(slug, args.key);
+        consola.success(`Removed ${args.key}`);
+    },
+});
+export const envCommand = defineCommand({
+    meta: {
+        name: "env",
+        description: "Manage environment variables",
+    },
+    subCommands: {
+        set: envSet,
+        ls: envGet,
+        rm: envRm,
+    },
+});
+//# sourceMappingURL=env.js.map

package/dist/commands/init.d.ts

@@ -0,0 +1,8 @@
+export declare const initCommand: import("citty").CommandDef<{
+    name: {
+        type: "string";
+        description: string;
+        required: false;
+    };
+}>;
+//# sourceMappingURL=init.d.ts.map