creek 0.3.0-alpha.11 → 0.3.0-alpha.13

package/dist/commands/claim.d.ts

@@ -1,4 +1,14 @@
 export declare const claimCommand: import("citty").CommandDef<{
+    json: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    yes: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
     sandboxId: {
         type: "positional";
         description: string;

package/dist/commands/claim.js

@@ -2,6 +2,7 @@ import { defineCommand } from "citty";
 import consola from "consola";
 import { CreekClient } from "@solcreek/sdk";
 import { getToken, getApiUrl, getSandboxApiUrl } from "../utils/config.js";
+import { globalArgs, resolveJsonMode, jsonOutput } from "../utils/output.js";
 export const claimCommand = defineCommand({
     meta: {
         name: "claim",
@@ -13,10 +14,14 @@ export const claimCommand = defineCommand({
             description: "Sandbox ID to claim (shown after sandbox deploy)",
             required: true,
         },
+        ...globalArgs,
     },
     async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
         const token = getToken();
         if (!token) {
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "not_authenticated", message: "Run `creek login` first" }, 1);
             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);
@@ -32,13 +37,14 @@ export const claimCommand = defineCommand({
         }
         const sandbox = (await statusRes.json());
         if (!sandbox.claimable) {
-            if (sandbox.status === "expired") {
-                consola.error("This sandbox has expired and can no longer be claimed.");
+            const msg = sandbox.status === "expired"
+                ? "This sandbox has expired and can no longer be claimed."
+                : `Sandbox is in '${sandbox.status}' state and cannot be claimed.`;
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "not_claimable", status: sandbox.status, message: msg }, 1);
+            consola.error(msg);
+            if (sandbox.status === "expired")
                 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
@@ -73,6 +79,9 @@ export const claimCommand = defineCommand({
         catch {
             // Best effort — claim status update is non-critical
         }
+        if (jsonMode) {
+            jsonOutput({ ok: true, sandboxId, project: project.slug, projectId: project.id });
+        }
         consola.success("Sandbox claimed!");
         consola.info("");
         consola.info("Next steps:");

package/dist/commands/deploy.d.ts

@@ -1,4 +1,19 @@
 export declare const deployCommand: import("citty").CommandDef<{
+    template: {
+        type: "string";
+        description: string;
+        required: false;
+    };
+    json: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    yes: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
     dir: {
         type: "positional";
         description: string;
@@ -14,10 +29,5 @@ export declare const deployCommand: import("citty").CommandDef<{
         description: string;
         default: false;
     };
-    template: {
-        type: "string";
-        description: string;
-        required: false;
-    };
 }>;
 //# sourceMappingURL=deploy.d.ts.map

package/dist/commands/deploy.js

@@ -8,6 +8,22 @@ 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";
+import { isTTY, jsonOutput, resolveJsonMode, globalArgs } from "../utils/output.js";
+function section(name) {
+    consola.log(`\n  \x1b[2m[${name}]\x1b[0m`);
+}
+function assetSummary(fileList) {
+    const byExt = {};
+    for (const f of fileList) {
+        const ext = f.includes(".") ? `.${f.split(".").pop()}` : "(other)";
+        byExt[ext] = (byExt[ext] ?? 0) + 1;
+    }
+    const parts = Object.entries(byExt)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 4)
+        .map(([ext, n]) => `${n} ${ext}`);
+    return parts.join(", ");
+}
 export const deployCommand = defineCommand({
     meta: {
         name: "deploy",
@@ -29,6 +45,7 @@ export const deployCommand = defineCommand({
             description: "Deploy a sample site to see Creek in action",
             default: false,
         },
+        ...globalArgs,
         template: {
             type: "string",
             description: "Deploy a template (e.g., react-dashboard, astro-landing)",
@@ -36,9 +53,10 @@ export const deployCommand = defineCommand({
         },
     },
     async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
         // --- Demo deploy (zero-friction showcase) ---
         if (args.demo) {
-            return await deployDemo();
+            return await deployDemo(jsonMode);
         }
         // --- Template deploy ---
         if (args.template) {
@@ -52,33 +70,40 @@ export const deployCommand = defineCommand({
         // --- Explicit directory (creek deploy ./dist) ---
         if (args.dir) {
             if (!existsSync(cwd)) {
+                if (jsonMode)
+                    jsonOutput({ error: "not_found", message: `Directory not found: ${args.dir}` }, 1);
                 consola.error(`Directory not found: ${args.dir}`);
                 process.exit(1);
             }
-            return await deployDirectory(cwd);
+            return await deployDirectory(cwd, jsonMode);
         }
         // --- Authenticated deploy (creek.toml present) ---
         if (hasConfig) {
             if (!token) {
+                if (jsonMode)
+                    jsonOutput({ error: "not_authenticated", message: "Run `creek login` first" }, 1);
                 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"]);
+            return await deployAuthenticated(cwd, configPath, token, args["skip-build"], jsonMode);
         }
         // --- Sandbox deploy (has package.json → auto-detect + build) ---
         if (existsSync(join(cwd, "package.json"))) {
-            return await deploySandbox(cwd, args["skip-build"]);
+            return await deploySandbox(cwd, args["skip-build"], jsonMode);
         }
         // --- 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);
+                if (!jsonMode)
+                    consola.info(`Found build output: ${dir}/`);
+                return await deployDirectory(fullPath, jsonMode);
             }
         }
         // --- Nothing found → guide the user ---
+        if (jsonMode)
+            jsonOutput({ error: "no_project", message: "No project found in this directory" }, 1);
         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)");
@@ -124,15 +149,27 @@ code{background:#1a1a2e;padding:2px 8px;border-radius:4px;font-size:0.85rem;colo
 <script>document.title="Creek Deploy Demo — "+new Date().toLocaleTimeString()</script>
 </body>
 </html>`;
-async function deployDemo() {
-    consola.start("Deploying demo site...");
+async function deployDemo(jsonMode) {
+    if (!jsonMode)
+        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...");
+        if (!jsonMode)
+            consola.start("Waiting for deployment...");
         const status = await pollSandboxStatus(result.statusUrl);
+        if (jsonMode) {
+            jsonOutput({
+                ok: true,
+                sandboxId: result.sandboxId,
+                url: status.previewUrl,
+                deployDurationMs: status.deployDurationMs,
+                expiresAt: result.expiresAt,
+                mode: "demo",
+            });
+        }
         const duration = status.deployDurationMs
             ? `in ${(status.deployDurationMs / 1000).toFixed(1)}s`
             : "in seconds";
@@ -142,50 +179,67 @@ async function deployDemo() {
         consola.info("  cd your-project && npx creek deploy");
     }
     catch (err) {
-        consola.error(err instanceof Error ? err.message : "Demo deploy failed");
+        const message = err instanceof Error ? err.message : "Demo deploy failed";
+        if (jsonMode)
+            jsonOutput({ ok: false, error: "deploy_failed", message }, 1);
+        consola.error(message);
         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...");
+async function deployDirectory(dir, jsonMode) {
+    if (!jsonMode)
+        section("Upload");
     const { assets, fileList } = collectAssets(dir);
     if (fileList.length === 0) {
+        if (jsonMode)
+            jsonOutput({ ok: false, error: "no_files", message: `No files found in ${dir}` }, 1);
         consola.error(`No files found in ${dir}\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)");
         process.exit(1);
     }
-    consola.info(`Found ${fileList.length} files`);
-    consola.start("Deploying...");
+    if (!jsonMode) {
+        consola.info(`  ${fileList.length} files (${assetSummary(fileList)})`);
+        consola.info("  Mode: sandbox (60 min preview)");
+        section("Deploy");
+        consola.start("  Deploying to edge...");
+    }
     try {
         const result = await sandboxDeploy({ assets, source: "cli" });
-        consola.start("Waiting for deployment...");
         const status = await pollSandboxStatus(result.statusUrl);
+        if (jsonMode) {
+            jsonOutput({
+                ok: true,
+                sandboxId: result.sandboxId,
+                url: status.previewUrl,
+                deployDurationMs: status.deployDurationMs,
+                expiresAt: result.expiresAt,
+                assetCount: fileList.length,
+                mode: "sandbox",
+            });
+        }
         printSandboxSuccess(status.previewUrl, result.expiresAt, result.sandboxId);
     }
     catch (err) {
-        consola.error(err instanceof Error ? err.message : "Deploy failed");
+        const message = err instanceof Error ? err.message : "Deploy failed";
+        if (jsonMode)
+            jsonOutput({ ok: false, error: "deploy_failed", message }, 1);
+        consola.error(message);
         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("");
+async function deploySandbox(cwd, skipBuild, jsonMode = false) {
     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)");
-    }
+    section("Detect");
+    consola.info(`  Framework: ${framework ?? "static site"}`);
+    consola.info("  Mode: sandbox (60 min preview)");
     // Build
     const buildCommand = pkg.scripts?.build ? "npm run build" : null;
     const outputDir = resolve(cwd, getDefaultBuildOutput(framework));
@@ -195,20 +249,20 @@ async function deploySandbox(cwd, skipBuild) {
             consola.info("Add a 'build' script or use --skip-build if already built.");
             process.exit(1);
         }
-        consola.start(`Building with: ${buildCommand}`);
+        section("Build");
+        consola.start(`  ${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}`);
+            consola.info("  Common fixes:");
+            consola.info("    npm install (missing dependencies?)");
+            consola.info("    Check for TypeScript errors");
             process.exit(1);
         }
-        consola.success("Build complete");
+        consola.success("  Build complete");
     }
     if (!existsSync(outputDir)) {
         consola.error(`Build output not found: ${outputDir}`);
@@ -226,24 +280,27 @@ async function deploySandbox(cwd, skipBuild) {
         if (subdir)
             clientAssetsDir = resolve(outputDir, subdir);
     }
-    consola.start("Collecting assets...");
+    section("Upload");
     const { assets: clientAssets, fileList } = collectAssets(clientAssetsDir);
-    consola.info(`Found ${fileList.length} assets`);
+    consola.info(`  ${fileList.length} assets (${assetSummary(fileList)})`);
     let serverFiles;
     if (isSSR && framework) {
         const serverEntry = getSSRServerEntry(framework);
         if (serverEntry) {
             const serverEntryPath = resolve(outputDir, serverEntry);
             if (existsSync(serverEntryPath)) {
-                consola.start("Bundling SSR server...");
+                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)`);
+                consola.success(`  SSR bundled (${Math.round(bundled.length / 1024)}KB)`);
             }
         }
     }
     // Deploy to sandbox
-    consola.start("Deploying...");
+    if (!jsonMode) {
+        section("Deploy");
+        consola.start("  Deploying to edge...");
+    }
     try {
         const result = await sandboxDeploy({
             assets: clientAssets,
@@ -251,12 +308,26 @@ async function deploySandbox(cwd, skipBuild) {
             framework: framework ?? undefined,
             source: "cli",
         });
-        consola.start("Waiting for deployment...");
         const status = await pollSandboxStatus(result.statusUrl);
+        if (jsonMode) {
+            jsonOutput({
+                ok: true,
+                sandboxId: result.sandboxId,
+                url: status.previewUrl,
+                deployDurationMs: status.deployDurationMs,
+                expiresAt: result.expiresAt,
+                framework: framework ?? null,
+                assetCount: fileList.length,
+                mode: "sandbox",
+            });
+        }
         printSandboxSuccess(status.previewUrl, result.expiresAt, result.sandboxId);
     }
     catch (err) {
-        consola.error(err instanceof Error ? err.message : "Sandbox deploy failed");
+        const message = err instanceof Error ? err.message : "Sandbox deploy failed";
+        if (jsonMode)
+            jsonOutput({ ok: false, error: "deploy_failed", message }, 1);
+        consola.error(message);
         process.exit(1);
     }
 }
@@ -325,44 +396,49 @@ function cleanupDir(dir) {
 // ============================================================================
 // Authenticated deploy — existing flow
 // ============================================================================
-async function deployAuthenticated(cwd, configPath, token, skipBuild) {
+async function deployAuthenticated(cwd, configPath, token, skipBuild, jsonMode = false) {
     try {
         const config = parseConfig(readFileSync(configPath, "utf-8"));
         const client = new CreekClient(getApiUrl(), token);
-        // Show who we're deploying as
+        section("Auth");
         const session = await client.getSession();
         if (!session?.user) {
             consola.error("Token is invalid or expired. Run `creek login` to re-authenticate.");
             process.exit(1);
         }
-        consola.info(`Deploying as ${session.user.email}`);
-        consola.info(`Project: ${config.project.name}`);
+        consola.info(`  Deploying as ${session.user.email}`);
+        consola.info(`  Project: ${config.project.name}`);
         // Ensure project exists — confirm before auto-creating
         let project;
         try {
             project = await client.getProject(config.project.name);
         }
         catch {
-            const confirm = await consola.prompt(`Project "${config.project.name}" does not exist. Create it?`, { type: "confirm" });
-            if (!confirm) {
-                consola.info("Deploy cancelled.");
-                process.exit(0);
+            // In --yes / non-TTY / JSON mode, auto-create without prompting (agent-friendly)
+            if (!jsonMode && isTTY) {
+                const confirm = await consola.prompt(`Project "${config.project.name}" does not exist. Create it?`, { type: "confirm" });
+                if (!confirm) {
+                    consola.info("Deploy cancelled.");
+                    process.exit(0);
+                }
             }
             const res = await client.createProject({
                 slug: config.project.name,
                 framework: config.project.framework,
             });
             project = res.project;
-            consola.success(`Created project: ${project.slug}`);
+            if (!jsonMode)
+                consola.success(`  Created project: ${project.slug}`);
         }
-        // Build — creek.toml build.command is user-defined, analogous to npm scripts
+        // Build
         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}`);
+            section("Build");
+            consola.start(`  ${buildCmd}`);
             try {
                 execSync(buildCmd, { cwd, stdio: "inherit" });
             }
@@ -370,7 +446,7 @@ async function deployAuthenticated(cwd, configPath, token, skipBuild) {
                 consola.error("Build failed");
                 process.exit(1);
             }
-            consola.success("Build complete");
+            consola.success("  Build complete");
         }
         const outputDir = resolve(cwd, config.build.output);
         if (!existsSync(outputDir)) {
@@ -387,27 +463,28 @@ async function deployAuthenticated(cwd, configPath, token, skipBuild) {
                 clientAssetsDir = resolve(outputDir, clientSubdir);
             }
         }
-        consola.start("Collecting assets...");
+        section("Upload");
         const { assets: clientAssets, fileList } = collectAssets(clientAssetsDir);
-        consola.info(`Found ${fileList.length} client assets`);
+        consola.info(`  ${fileList.length} assets (${assetSummary(fileList)})`);
         let serverFiles;
         if (isSSR && framework) {
             const serverEntry = getSSRServerEntry(framework);
             if (serverEntry) {
                 const serverEntryPath = resolve(outputDir, serverEntry);
                 if (existsSync(serverEntryPath)) {
-                    consola.start("Bundling SSR server...");
+                    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.success(`  SSR bundled (${Math.round(bundled.length / 1024)}KB)`);
                 }
             }
         }
-        consola.start("Creating deployment...");
+        section("Deploy");
+        consola.start("  Creating deployment...");
         const { deployment } = await client.createDeployment(project.id);
-        consola.start("Uploading...");
+        consola.start("  Uploading bundle...");
         const bundle = {
             manifest: {
                 assets: fileList,
@@ -426,10 +503,10 @@ async function deployAuthenticated(cwd, configPath, token, skipBuild) {
         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...",
+            queued: "  Waiting...",
+            uploading: "  Uploading...",
+            provisioning: "  Provisioning resources...",
+            deploying: "  Deploying to edge...",
         };
         let lastStatus = "";
         const start = Date.now();
@@ -446,24 +523,40 @@ async function deployAuthenticated(cwd, configPath, token, skipBuild) {
                 lastStatus = status;
             }
             if (status === "active") {
-                consola.success(`Deployed! ${res.url ?? res.previewUrl}`);
+                if (jsonMode) {
+                    jsonOutput({
+                        ok: true,
+                        url: res.url ?? res.previewUrl,
+                        previewUrl: res.previewUrl,
+                        deploymentId: deployment.id,
+                        project: project.slug,
+                        mode: "production",
+                    });
+                }
+                consola.success(`  Deployed! ${res.url ?? res.previewUrl}`);
                 if (res.url && res.previewUrl) {
-                    consola.info(`Preview:  ${res.previewUrl}`);
+                    consola.info(`  Preview: ${res.previewUrl}`);
                 }
                 return;
             }
             if (status === "failed") {
                 const step = failed_step ? ` at ${failed_step}` : "";
                 const msg = error_message ?? "Unknown error";
+                if (jsonMode)
+                    jsonOutput({ ok: false, error: "deploy_failed", message: msg, failedStep: failed_step }, 1);
                 consola.error(`Deploy failed${step}: ${msg}`);
                 process.exit(1);
             }
             if (status === "cancelled") {
+                if (jsonMode)
+                    jsonOutput({ ok: false, error: "cancelled", message: "Deploy was cancelled" }, 1);
                 consola.warn("Deploy was cancelled");
                 process.exit(1);
             }
             await new Promise((r) => setTimeout(r, POLL_INTERVAL));
         }
+        if (jsonMode)
+            jsonOutput({ ok: false, error: "timeout", message: "Deploy timed out after 2 minutes" }, 1);
         consola.error("Deploy timed out after 2 minutes");
         process.exit(1);
     }

package/dist/commands/env.js

@@ -1,10 +1,10 @@
 import { defineCommand } from "citty";
 import consola from "consola";
-import { CreekClient } from "@solcreek/sdk";
+import { CreekClient, parseConfig } 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";
+import { globalArgs, resolveJsonMode, jsonOutput } from "../utils/output.js";
 function getProjectSlug() {
     const configPath = join(process.cwd(), "creek.toml");
     if (!existsSync(configPath)) {
@@ -26,11 +26,15 @@ const envSet = defineCommand({
     args: {
         key: { type: "positional", description: "Variable name (e.g. DATABASE_URL)", required: true },
         value: { type: "positional", description: "Variable value", required: true },
+        ...globalArgs,
     },
     async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
         const client = getClient();
         const slug = getProjectSlug();
         await client.setEnvVar(slug, args.key, args.value);
+        if (jsonMode)
+            jsonOutput({ ok: true, key: args.key, project: slug });
         consola.success(`Set ${args.key}`);
     },
 });
@@ -43,11 +47,20 @@ const envGet = defineCommand({
     meta: { name: "ls", description: "List environment variables" },
     args: {
         show: { type: "boolean", description: "Show values in plaintext (default: redacted)", default: false },
+        ...globalArgs,
     },
     async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
         const client = getClient();
         const slug = getProjectSlug();
         const vars = await client.listEnvVars(slug);
+        if (jsonMode) {
+            jsonOutput({
+                ok: true,
+                project: slug,
+                vars: vars.map((v) => ({ key: v.key, value: args.show ? v.value : redact(v.value) })),
+            });
+        }
         if (vars.length === 0) {
             consola.info("No environment variables set.");
             return;
@@ -65,11 +78,15 @@ const envRm = defineCommand({
     meta: { name: "rm", description: "Remove an environment variable" },
     args: {
         key: { type: "positional", description: "Variable name to remove", required: true },
+        ...globalArgs,
     },
     async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
         const client = getClient();
         const slug = getProjectSlug();
         await client.deleteEnvVar(slug, args.key);
+        if (jsonMode)
+            jsonOutput({ ok: true, key: args.key, removed: true, project: slug });
         consola.success(`Removed ${args.key}`);
     },
 });

package/dist/commands/init.d.ts

@@ -1,4 +1,14 @@
 export declare const initCommand: import("citty").CommandDef<{
+    json: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    yes: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
     name: {
         type: "string";
         description: string;

package/dist/commands/init.js

@@ -4,6 +4,7 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join, basename } from "node:path";
 import { stringify } from "smol-toml";
 import { detectFramework } from "@solcreek/sdk";
+import { globalArgs, resolveJsonMode, jsonOutput, shouldAutoConfirm } from "../utils/output.js";
 export const initCommand = defineCommand({
     meta: {
         name: "init",
@@ -15,15 +16,19 @@ export const initCommand = defineCommand({
             description: "Project name",
             required: false,
         },
+        ...globalArgs,
     },
     async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
         const cwd = process.cwd();
         const configPath = join(cwd, "creek.toml");
         if (existsSync(configPath)) {
-            consola.warn("creek.toml already exists");
-            const overwrite = await consola.prompt("Overwrite?", { type: "confirm" });
-            if (!overwrite)
-                return;
+            if (!shouldAutoConfirm(args)) {
+                consola.warn("creek.toml already exists");
+                const overwrite = await consola.prompt("Overwrite?", { type: "confirm" });
+                if (!overwrite)
+                    return;
+            }
         }
         // Detect framework
         const pkgPath = join(cwd, "package.json");
@@ -33,7 +38,8 @@ export const initCommand = defineCommand({
             const detected = detectFramework(pkg);
             if (detected) {
                 framework = detected;
-                consola.info(`Detected framework: ${framework}`);
+                if (!jsonMode)
+                    consola.info(`Detected framework: ${framework}`);
             }
         }
         const defaultName = basename(cwd).toLowerCase().replace(/[^a-z0-9-]/g, "-");
@@ -54,6 +60,9 @@ export const initCommand = defineCommand({
             },
         };
         writeFileSync(configPath, stringify(config));
+        if (jsonMode) {
+            jsonOutput({ ok: true, name, framework: framework ?? null, path: configPath });
+        }
         consola.success(`Created creek.toml for "${name}"`);
     },
 });

package/dist/commands/login.d.ts

@@ -1,4 +1,14 @@
 export declare const loginCommand: import("citty").CommandDef<{
+    json: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    yes: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
     token: {
         type: "string";
         description: string;

package/dist/commands/login.js

@@ -4,6 +4,7 @@ import { execFileSync } from "node:child_process";
 import { CreekClient } from "@solcreek/sdk";
 import { writeCliConfig, readCliConfig, getApiUrl } from "../utils/config.js";
 import { startAuthServer } from "../utils/auth-server.js";
+import { globalArgs, resolveJsonMode, jsonOutput } from "../utils/output.js";
 function getDashboardUrl() {
     const apiUrl = getApiUrl();
     // http://localhost:8787 → http://localhost:3000
@@ -41,11 +42,13 @@ export const loginCommand = defineCommand({
             description: "Use headless mode (paste API key manually, for SSH/remote)",
             default: false,
         },
+        ...globalArgs,
     },
     async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
         // Mode 1: --token (CI/CD)
         if (args.token) {
-            return await saveAndVerify(args.token);
+            return await saveAndVerify(args.token, jsonMode);
         }
         // Mode 2: --headless (SSH/remote — prompt for API key)
         if (args.headless) {
@@ -96,16 +99,22 @@ async function headlessLogin() {
 /**
  * Validate key against API, save to config, print success.
  */
-async function saveAndVerify(apiKey) {
-    consola.start("Verifying...");
+async function saveAndVerify(apiKey, jsonMode = false) {
+    if (!jsonMode)
+        consola.start("Verifying...");
     const client = new CreekClient(getApiUrl(), apiKey);
     const session = await client.getSession();
     if (!session?.user) {
+        if (jsonMode)
+            jsonOutput({ ok: false, error: "invalid_token", message: "Invalid API key" }, 1);
         consola.error("Invalid API key. Please check and try again.");
         process.exit(1);
     }
     const config = readCliConfig();
     writeCliConfig({ ...config, token: apiKey });
+    if (jsonMode) {
+        jsonOutput({ ok: true, user: session.user.name, email: session.user.email });
+    }
     consola.success(`Logged in as ${session.user.name} (${session.user.email})`);
 }
 //# sourceMappingURL=login.js.map

package/dist/commands/whoami.d.ts

@@ -1,2 +1,13 @@
-export declare const whoamiCommand: import("citty").CommandDef<import("citty").ArgsDef>;
+export declare const whoamiCommand: import("citty").CommandDef<{
+    json: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    yes: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+}>;
 //# sourceMappingURL=whoami.d.ts.map

package/dist/commands/whoami.js

@@ -2,23 +2,39 @@ import { defineCommand } from "citty";
 import consola from "consola";
 import { CreekClient } from "@solcreek/sdk";
 import { getToken, getApiUrl } from "../utils/config.js";
+import { globalArgs, resolveJsonMode, jsonOutput } from "../utils/output.js";
 export const whoamiCommand = defineCommand({
     meta: {
         name: "whoami",
         description: "Show the currently authenticated user",
     },
-    async run() {
+    args: { ...globalArgs },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
         const token = getToken();
         if (!token) {
+            if (jsonMode)
+                jsonOutput({ ok: false, authenticated: false, error: "not_authenticated" }, 1);
             consola.error("Not authenticated. Run `creek login` first.");
             process.exit(1);
         }
         const client = new CreekClient(getApiUrl(), token);
         const session = await client.getSession();
         if (!session?.user) {
+            if (jsonMode)
+                jsonOutput({ ok: false, authenticated: false, error: "session_expired" }, 1);
             consola.error("Session expired or invalid. Run `creek login` to re-authenticate.");
             process.exit(1);
         }
+        if (jsonMode) {
+            jsonOutput({
+                ok: true,
+                authenticated: true,
+                user: session.user.name,
+                email: session.user.email,
+                api: getApiUrl(),
+            });
+        }
         consola.log(`  User:  ${session.user.name}`);
         consola.log(`  Email: ${session.user.email}`);
         consola.log(`  API:   ${getApiUrl()}`);

package/dist/utils/output.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Shared output utilities for agent-friendly CLI.
+ *
+ * --json flag + non-TTY auto-detection ensures every command
+ * can produce structured output for agents, CI/CD, and pipes.
+ */
+export declare const isTTY: boolean;
+/** Output structured JSON and exit. */
+export declare function jsonOutput(data: Record<string, unknown>, exitCode?: number): never;
+/** Resolve JSON mode: explicit --json flag OR non-TTY environment. */
+export declare function resolveJsonMode(args: {
+    json?: boolean;
+}): boolean;
+/**
+ * Common --json and --yes args to spread into any command's args definition.
+ *
+ * Usage:
+ *   args: { ...globalArgs, myArg: { ... } }
+ */
+export declare const globalArgs: {
+    json: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    yes: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+};
+/** Should we skip interactive prompts? */
+export declare function shouldAutoConfirm(args: {
+    yes?: boolean;
+}): boolean;
+/** Output an error in the appropriate format and exit. */
+export declare function exitError(jsonMode: boolean, error: string, message: string, exitCode?: number): never;
+//# sourceMappingURL=output.d.ts.map

package/dist/utils/output.js

@@ -0,0 +1,45 @@
+/**
+ * Shared output utilities for agent-friendly CLI.
+ *
+ * --json flag + non-TTY auto-detection ensures every command
+ * can produce structured output for agents, CI/CD, and pipes.
+ */
+export const isTTY = process.stdout.isTTY ?? false;
+/** Output structured JSON and exit. */
+export function jsonOutput(data, exitCode = 0) {
+    process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+    process.exit(exitCode);
+}
+/** Resolve JSON mode: explicit --json flag OR non-TTY environment. */
+export function resolveJsonMode(args) {
+    return args.json === true || !isTTY;
+}
+/**
+ * Common --json and --yes args to spread into any command's args definition.
+ *
+ * Usage:
+ *   args: { ...globalArgs, myArg: { ... } }
+ */
+export const globalArgs = {
+    json: {
+        type: "boolean",
+        description: "Output results as JSON (auto-enabled in CI/CD and pipes)",
+        default: false,
+    },
+    yes: {
+        type: "boolean",
+        description: "Skip confirmation prompts (auto-enabled in non-TTY)",
+        default: false,
+    },
+};
+/** Should we skip interactive prompts? */
+export function shouldAutoConfirm(args) {
+    return args.yes === true || !isTTY;
+}
+/** Output an error in the appropriate format and exit. */
+export function exitError(jsonMode, error, message, exitCode = 1) {
+    if (jsonMode)
+        jsonOutput({ ok: false, error, message }, exitCode);
+    return process.exit(exitCode);
+}
+//# sourceMappingURL=output.js.map

package/dist/utils/sandbox.js

@@ -46,12 +46,9 @@ export async function pollSandboxStatus(statusUrl) {
  * Print sandbox success message with claim instructions.
  */
 export function printSandboxSuccess(previewUrl, expiresAt, sandboxId) {
-    consola.success(`Deployed! ${previewUrl}`);
+    consola.success(`  Live → ${previewUrl}`);
     consola.info("");
-    consola.info("This is a free sandbox preview — it will be available for 60 minutes.");
-    consola.info("");
-    consola.info("Want to keep it? Make it permanent:");
-    consola.info(`  creek login`);
-    consola.info(`  creek claim ${sandboxId}`);
+    consola.info("  Free preview — available for 60 minutes.");
+    consola.info("  Make it permanent: creek login && creek claim " + sandboxId);
 }
 //# sourceMappingURL=sandbox.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "creek",
-  "version": "0.3.0-alpha.11",
+  "version": "0.3.0-alpha.13",
   "description": "CLI for the Creek deployment platform",
   "type": "module",
   "bin": {