wawesome 0.0.1

package/bin/wawesome.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/index.mjs";

package/dist/index.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/index.mjs

@@ -0,0 +1,863 @@
+import cac from "cac";
+import fs from "node:fs";
+import path from "node:path";
+import { build } from "esbuild";
+import os from "node:os";
+import http from "node:http";
+import readline from "node:readline";
+import { select } from "@inquirer/prompts";
+//#region src/config.ts
+/**
+* Hardcoded Supabase project config for the wawesome.io platform.
+* These are public values — the anon key is designed to be embedded in clients.
+*/
+const SUPABASE_URL = "https://vclasavxxoufwymrutai.supabase.co";
+/** Path to the user-level settings file (~/.wawesome/settings.json) */
+function getSettingsPath() {
+	return path.join(os.homedir(), ".wawesome", "settings.json");
+}
+/**
+* Read stored user settings from ~/.wawesome/settings.json.
+*/
+function readSettings() {
+	const settingsPath = getSettingsPath();
+	if (!fs.existsSync(settingsPath)) return {};
+	try {
+		const raw = fs.readFileSync(settingsPath, "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return {};
+	}
+}
+/**
+* Resolve gateway URL with resolution hierarchy:
+* 1. Explicit override argument (CLI flag --gateway / --api)
+* 2. Environment variables GATEWAY_URL or WAWESOME_GATEWAY_URL
+* 3. User settings file ~/.wawesome/settings.json (gateway_url)
+* 4. Stored login credentials (~/.wawesome/credentials.json)
+* 5. Default fallback: "https://api.wawesome.io"
+*/
+function getGatewayUrl(overrideUrl) {
+	if (overrideUrl) return overrideUrl;
+	if (process.env.GATEWAY_URL) return process.env.GATEWAY_URL;
+	if (process.env.WAWESOME_GATEWAY_URL) return process.env.WAWESOME_GATEWAY_URL;
+	const settings = readSettings();
+	if (settings.gateway_url && typeof settings.gateway_url === "string") return settings.gateway_url;
+	const creds = readCredentials();
+	if (creds?.gateway_url) return creds.gateway_url;
+	return "https://api.wawesome.io";
+}
+getGatewayUrl();
+/** Localhost port used during OAuth callback */
+const OAUTH_CALLBACK_PORT = 9999;
+/** Path to the user-level credentials file */
+function getCredentialsPath() {
+	return path.join(os.homedir(), ".wawesome", "credentials.json");
+}
+/**
+* Read stored credentials. Returns null if not logged in.
+*/
+function readCredentials() {
+	const credPath = getCredentialsPath();
+	if (!fs.existsSync(credPath)) return null;
+	try {
+		const raw = fs.readFileSync(credPath, "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+/**
+* Write credentials to disk, creating the directory if needed.
+*/
+function writeCredentials(creds) {
+	const credPath = getCredentialsPath();
+	const dir = path.dirname(credPath);
+	fs.mkdirSync(dir, { recursive: true });
+	fs.writeFileSync(credPath, JSON.stringify(creds, null, 2), "utf-8");
+}
+/**
+* Delete stored credentials.
+*/
+function deleteCredentials() {
+	const credPath = getCredentialsPath();
+	if (fs.existsSync(credPath)) {
+		fs.rmSync(credPath, { force: true });
+		return true;
+	}
+	return false;
+}
+/**
+* Read wawesome-function.json from the project directory.
+*/
+function readFunctionConfig(projectDir) {
+	const dir = projectDir || process.cwd();
+	const configPath = path.join(dir, "wawesome-function.json");
+	if (!fs.existsSync(configPath)) return null;
+	try {
+		const raw = fs.readFileSync(configPath, "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/build.ts
+/**
+* Bundles user TS/JS entry point into a single optimized ESM JavaScript file using esbuild.
+*/
+async function buildJs(entryInput, options) {
+	const startTime = Date.now();
+	const config = readFunctionConfig();
+	const entry = entryInput || config?.entry || "src/index.ts";
+	const outPath = path.resolve(options.out);
+	const isVerbose = Boolean(options.verbose);
+	if (!fs.existsSync(entry)) {
+		console.error(`[wawesome] Error: Entry file '${entry}' not found.`);
+		process.exit(1);
+	}
+	console.log(`[wawesome] Building ${entry} -> ${options.out}...`);
+	if (isVerbose) {
+		console.log(`[wawesome:verbose] Entry point resolved: ${path.resolve(entry)}`);
+		console.log(`[wawesome:verbose] Target output path: ${outPath}`);
+	}
+	try {
+		await build({
+			entryPoints: [entry],
+			bundle: true,
+			format: "esm",
+			outfile: outPath,
+			platform: "neutral",
+			target: "es2022",
+			treeShaking: true,
+			minify: true,
+			keepNames: true,
+			legalComments: "none",
+			logLevel: isVerbose ? "info" : "silent"
+		});
+		const sizeKb = (fs.statSync(outPath).size / 1024).toFixed(2);
+		const elapsed = Date.now() - startTime;
+		console.log(`[wawesome] Successfully built ${options.out} (${sizeKb} KB) in ${elapsed}ms!`);
+		return outPath;
+	} catch (err) {
+		console.error("[wawesome] Build failed!");
+		if (isVerbose && err instanceof Error) console.error(err.stack || err.message);
+		else if (err instanceof Error) console.error(`[wawesome] ${err.message} (run with --verbose for full stack trace)`);
+		else console.error(err);
+		process.exit(1);
+	}
+}
+//#endregion
+//#region src/auth.ts
+/**
+* OAuth login flow:
+* 1. Build Supabase OAuth URL
+* 2. Open browser
+* 3. Listen on localhost for callback with access_token
+* 4. Exchange Supabase JWT for tenant-scoped JWT via gateway
+* 5. Store credentials in ~/.wawesome/credentials.json
+*/
+async function login(options) {
+	const gatewayUrl = getGatewayUrl(options.gateway || options.api);
+	const provider = options.provider || "github";
+	const isVerbose = Boolean(options.verbose);
+	const authUrl = `${SUPABASE_URL}/auth/v1/authorize?provider=${provider}&redirect_to=${encodeURIComponent(`http://localhost:${OAUTH_CALLBACK_PORT}/callback`)}`;
+	console.log(`[wawesome] Starting ${provider} OAuth login...`);
+	console.log(`[wawesome] Gateway: ${gatewayUrl}`);
+	if (isVerbose) {
+		console.log(`[wawesome:verbose] Supabase URL: ${SUPABASE_URL}`);
+		console.log(`[wawesome:verbose] Auth URL: ${authUrl}`);
+	}
+	return new Promise((resolve, reject) => {
+		const server = http.createServer(async (req, res) => {
+			const reqUrl = new URL(req.url || "/", `http://localhost:${OAUTH_CALLBACK_PORT}`);
+			if (reqUrl.pathname === "/callback") {
+				res.writeHead(200, { "Content-Type": "text/html" });
+				res.end(`
+          <!DOCTYPE html>
+          <html>
+          <head><title>wawesome - Authentication</title></head>
+          <body style="font-family: system-ui; text-align: center; padding: 50px; background: #0f172a; color: #f8fafc;">
+            <h2>🔐 Authenticating with ${provider}...</h2>
+            <p>Transferring auth tokens back to CLI terminal...</p>
+            <script>
+              const hash = window.location.hash.substring(1);
+              const params = new URLSearchParams(hash);
+              const accessToken = params.get('access_token');
+              const refreshToken = params.get('refresh_token');
+
+              if (accessToken) {
+                fetch('/token?access_token=' + encodeURIComponent(accessToken) + '&refresh_token=' + encodeURIComponent(refreshToken || ''))
+                  .then(() => {
+                    document.body.innerHTML = '<h1>✅ Success!</h1><p>You can close this tab and return to your terminal.</p>';
+                  });
+              } else {
+                document.body.innerHTML = '<h1>❌ Error</h1><p>No access token found in URL hash.</p>';
+              }
+            <\/script>
+          </body>
+          </html>
+        `);
+				return;
+			}
+			if (reqUrl.pathname === "/token") {
+				const accessToken = reqUrl.searchParams.get("access_token");
+				res.writeHead(200, { "Content-Type": "text/plain" });
+				res.end("Token received by CLI.");
+				if (!accessToken) {
+					console.error("[wawesome] Error: No access token received.");
+					server.close();
+					reject(/* @__PURE__ */ new Error("No access token received"));
+					return;
+				}
+				if (isVerbose) console.log("[wawesome:verbose] Supabase access token received.");
+				try {
+					console.log("[wawesome] Fetching your workspaces...");
+					const tenantsRes = await fetch(`${gatewayUrl}/api/v1/me/tenants`, { headers: { Authorization: `Bearer ${accessToken}` } });
+					if (!tenantsRes.ok) throw new Error(`Failed to fetch tenants (HTTP ${tenantsRes.status}). Have you completed onboarding?`);
+					const tenants = await tenantsRes.json();
+					let primaryTenantId;
+					if (tenants.length === 0) {
+						console.log("[wawesome] No workspaces found. Initializing default workspace...");
+						const initRes = await fetch(`${gatewayUrl}/api/v1/onboarding/init`, {
+							method: "POST",
+							headers: {
+								Authorization: `Bearer ${accessToken}`,
+								"Content-Type": "application/json"
+							},
+							body: JSON.stringify({ tenant_name: "Personal Workspace" })
+						});
+						if (!initRes.ok) throw new Error(`Failed to initialize workspace (HTTP ${initRes.status}).`);
+						primaryTenantId = (await initRes.json()).tenant_id;
+					} else primaryTenantId = tenants[0].tenant_id;
+					if (isVerbose) console.log(`[wawesome:verbose] Using tenant: ${primaryTenantId}`);
+					console.log("[wawesome] Exchanging for tenant-scoped credentials...");
+					const exchangeRes = await fetch(`${gatewayUrl}/api/v1/auth/token-exchange`, {
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${accessToken}`,
+							"Content-Type": "application/json"
+						},
+						body: JSON.stringify({ tenant_id: primaryTenantId })
+					});
+					if (!exchangeRes.ok) throw new Error(`Token exchange failed (HTTP ${exchangeRes.status}).`);
+					const exchangeData = await exchangeRes.json();
+					let userEmail = exchangeData.email || "unknown";
+					try {
+						const payloadPart = exchangeData.tenant_jwt.split(".")[1];
+						const decoded = JSON.parse(Buffer.from(payloadPart, "base64url").toString("utf-8"));
+						if (decoded.email) userEmail = decoded.email;
+					} catch {}
+					writeCredentials({
+						gateway_url: gatewayUrl,
+						tenant_jwt: exchangeData.tenant_jwt,
+						tenant_id: primaryTenantId,
+						user_email: userEmail
+					});
+					console.log("\n======================================================");
+					console.log("🎉 \x1B[32mLOGIN SUCCESSFUL!\x1B[0m");
+					console.log("======================================================");
+					console.log(`\n  Tenant:  ${primaryTenantId}`);
+					console.log(`  Gateway: ${gatewayUrl}`);
+					console.log(`  Email:   ${userEmail}`);
+					console.log("\n  Credentials saved to ~/.wawesome/credentials.json");
+					console.log("======================================================\n");
+					server.close();
+					resolve();
+				} catch (err) {
+					console.error(`[wawesome] Login failed: ${err instanceof Error ? err.message : err}`);
+					server.close();
+					reject(err);
+				}
+			} else {
+				res.writeHead(404, { "Content-Type": "text/plain" });
+				res.end("Not Found");
+			}
+		});
+		server.listen(OAUTH_CALLBACK_PORT, async () => {
+			console.log(`\n🌐 Listening for OAuth callback on http://localhost:${OAUTH_CALLBACK_PORT}/callback ...`);
+			console.log(`🚀 Opening browser for ${provider} authentication...`);
+			console.log(`👉 ${authUrl}\n`);
+			try {
+				const open = (await import("open")).default;
+				await open(authUrl);
+			} catch {
+				console.log("[wawesome] Could not open browser automatically. Please visit the URL above manually.");
+			}
+		});
+	});
+}
+/**
+* Clear stored credentials.
+*/
+function logout() {
+	if (deleteCredentials()) console.log("[wawesome] ✅ Logged out. Credentials removed.");
+	else console.log("[wawesome] Not logged in (no credentials found).");
+}
+/**
+* Show current login status.
+*/
+function whoami() {
+	const creds = readCredentials();
+	if (!creds) {
+		console.log("[wawesome] Not logged in. Run 'wawesome login' to authenticate.");
+		return;
+	}
+	console.log("\n[wawesome] Current session:");
+	console.log(`  Email:   ${creds.user_email}`);
+	console.log(`  Tenant:  ${creds.tenant_id}`);
+	console.log(`  Gateway: ${creds.gateway_url}\n`);
+}
+//#endregion
+//#region src/deploy.ts
+/**
+* Deploy a function: build → upload JS to gateway → promote.
+*/
+async function deploy(entryInput, options) {
+	const isVerbose = Boolean(options.verbose);
+	const creds = readCredentials();
+	if (!creds) {
+		console.error("[wawesome] Error: Not logged in. Run 'wawesome login' first.");
+		process.exit(1);
+	}
+	const config = readFunctionConfig();
+	if (!config) {
+		console.error("[wawesome] Error: No wawesome-function.json found in the current directory.");
+		console.error("[wawesome] Run 'wawesome init' to create one, or create it manually.");
+		process.exit(1);
+	}
+	const { app, function: funcName } = config;
+	if (isVerbose) {
+		console.log(`[wawesome:verbose] Deploying to app=${app}, function=${funcName}`);
+		console.log(`[wawesome:verbose] Gateway: ${creds.gateway_url}`);
+	}
+	let bundlePath;
+	if (options.skipBuild) {
+		bundlePath = path.resolve(options.out);
+		if (!fs.existsSync(bundlePath)) {
+			console.error(`[wawesome] Error: Built bundle not found at '${bundlePath}'. Run 'wawesome build' first or remove --skip-build.`);
+			process.exit(1);
+		}
+		console.log(`[wawesome] Skipping build, using existing bundle: ${bundlePath}`);
+	} else {
+		const buildOpts = {
+			out: options.out,
+			verbose: options.verbose
+		};
+		bundlePath = await buildJs(entryInput || config.entry, buildOpts);
+	}
+	const jsCode = fs.readFileSync(bundlePath, "utf-8");
+	if (!jsCode.trim()) {
+		console.error("[wawesome] Error: Built bundle is empty.");
+		process.exit(1);
+	}
+	if (isVerbose) console.log(`[wawesome:verbose] Bundle size: ${(Buffer.byteLength(jsCode) / 1024).toFixed(2)} KB`);
+	console.log(`[wawesome] Uploading code for ${app}/${funcName}...`);
+	const uploadUrl = `${creds.gateway_url}/v1/apps/${encodeURIComponent(app)}/functions/${encodeURIComponent(funcName)}/code`;
+	if (isVerbose) console.log(`[wawesome:verbose] POST ${uploadUrl}`);
+	const uploadRes = await fetch(uploadUrl, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${creds.tenant_jwt}`,
+			"Content-Type": "application/javascript"
+		},
+		body: jsCode
+	});
+	if (!uploadRes.ok) {
+		const errorBody = await uploadRes.text();
+		if (uploadRes.status === 401) console.error("[wawesome] Error: Authentication expired. Run 'wawesome login' again.");
+		else if (uploadRes.status === 409) {
+			let msg = "Version with this code bundle already exists.";
+			try {
+				const parsed = JSON.parse(errorBody);
+				if (parsed.error) msg = parsed.error;
+			} catch {}
+			console.error(`\n[wawesome] \x1b[31mError: ${msg}\x1b[0m`);
+			console.error("[wawesome] Code versions are immutable and cannot be overwritten.");
+			console.error("[wawesome] To switch active version, run: \x1B[36mwawesome version switch\x1B[0m\n");
+		} else {
+			console.error(`[wawesome] Error: Code upload failed (HTTP ${uploadRes.status}).`);
+			if (isVerbose) console.error(`[wawesome:verbose] Response: ${errorBody}`);
+		}
+		process.exit(1);
+	}
+	const version = (await uploadRes.json()).version_number;
+	console.log(`[wawesome] ✅ Code uploaded (version ${version ?? "unknown"}).`);
+	console.log(`[wawesome] Promoting to production...`);
+	const deployUrl = `${creds.gateway_url}/v1/apps/${encodeURIComponent(app)}/functions/${encodeURIComponent(funcName)}/deploy`;
+	if (isVerbose) console.log(`[wawesome:verbose] POST ${deployUrl}`);
+	const deployBody = {};
+	if (version !== void 0) deployBody.version_number = version;
+	const deployRes = await fetch(deployUrl, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${creds.tenant_jwt}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify(deployBody)
+	});
+	if (!deployRes.ok) {
+		const errorBody = await deployRes.text();
+		if (deployRes.status === 401) console.error("[wawesome] Error: Authentication expired. Run 'wawesome login' again.");
+		else {
+			console.error(`[wawesome] Error: Deployment failed (HTTP ${deployRes.status}).`);
+			if (isVerbose) console.error(`[wawesome:verbose] Response: ${errorBody}`);
+		}
+		process.exit(1);
+	}
+	console.log("\n======================================================");
+	console.log("🚀 \x1B[32mDEPLOYED SUCCESSFULLY!\x1B[0m");
+	console.log("======================================================");
+	console.log(`\n  App:      ${app}`);
+	console.log(`  Function: ${funcName}`);
+	if (version !== void 0) console.log(`  Version:  ${version}`);
+	console.log("======================================================\n");
+}
+//#endregion
+//#region src/init.ts
+function prompt(question, defaultVal) {
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	return new Promise((resolve) => {
+		rl.question(`${question} (${defaultVal}): `, (answer) => {
+			rl.close();
+			resolve(answer.trim() || defaultVal);
+		});
+	});
+}
+/**
+* Scaffold a new wawesome function project in the current directory.
+*/
+async function init(options) {
+	const isVerbose = Boolean(options.verbose);
+	const cwd = process.cwd();
+	const dirName = path.basename(cwd);
+	console.log("[wawesome] Initializing a new function project...\n");
+	const functionName = await prompt("  Function name?", dirName);
+	const appSlug = await prompt("  App slug?", "default-app");
+	const entry = "src/index.ts";
+	if (isVerbose) console.log(`[wawesome:verbose] function=${functionName}, app=${appSlug}, entry=${entry}`);
+	const configContent = {
+		app: appSlug,
+		function: functionName,
+		entry
+	};
+	const configPath = path.join(cwd, "wawesome-function.json");
+	if (fs.existsSync(configPath)) console.log("[wawesome] wawesome-function.json already exists, skipping.");
+	else {
+		fs.writeFileSync(configPath, JSON.stringify(configContent, null, 2) + "\n", "utf-8");
+		console.log("[wawesome] ✅ Created wawesome-function.json");
+	}
+	const srcDir = path.join(cwd, "src");
+	const indexPath = path.join(srcDir, "index.ts");
+	if (fs.existsSync(indexPath)) console.log("[wawesome] src/index.ts already exists, skipping.");
+	else {
+		fs.mkdirSync(srcDir, { recursive: true });
+		fs.writeFileSync(indexPath, `/**
+ * Serverless Function Handler
+ * Standard HTTP fetch request handler
+ */
+export default {
+  async fetch(request: Request): Promise<Response> {
+    return Response.json({
+      message: "Hello, World!",
+    });
+  },
+};
+`, "utf-8");
+		console.log("[wawesome] ✅ Created src/index.ts");
+	}
+	const pkgPath = path.join(cwd, "package.json");
+	if (fs.existsSync(pkgPath)) console.log("[wawesome] package.json already exists, skipping.");
+	else {
+		const pkgContent = {
+			name: functionName,
+			type: "module",
+			version: "1.0.0",
+			description: `Serverless function: ${functionName}`,
+			scripts: {
+				build: "wawesome build",
+				deploy: "wawesome deploy",
+				typecheck: "tsc --noEmit"
+			},
+			devDependencies: {
+				"wawesome": "^1.0.0",
+				typescript: "^7.0.0"
+			}
+		};
+		fs.writeFileSync(pkgPath, JSON.stringify(pkgContent, null, 2) + "\n", "utf-8");
+		console.log("[wawesome] ✅ Created package.json");
+	}
+	const tsconfigPath = path.join(cwd, "tsconfig.json");
+	if (fs.existsSync(tsconfigPath)) console.log("[wawesome] tsconfig.json already exists, skipping.");
+	else {
+		fs.writeFileSync(tsconfigPath, JSON.stringify({
+			compilerOptions: {
+				target: "ES2022",
+				module: "ESNext",
+				moduleResolution: "bundler",
+				strict: true,
+				noEmit: true,
+				lib: [
+					"ES2022",
+					"DOM",
+					"DOM.Iterable"
+				]
+			},
+			include: ["src"]
+		}, null, 2) + "\n", "utf-8");
+		console.log("[wawesome] ✅ Created tsconfig.json");
+	}
+	const gitignorePath = path.join(cwd, ".gitignore");
+	if (fs.existsSync(gitignorePath)) console.log("[wawesome] .gitignore already exists, skipping.");
+	else {
+		fs.writeFileSync(gitignorePath, "node_modules\ndist\n", "utf-8");
+		console.log("[wawesome] ✅ Created .gitignore");
+	}
+	console.log("\n[wawesome] 🎉 Project initialized! Next steps:");
+	console.log("  1. npm install");
+	console.log("  2. wawesome login");
+	console.log("  3. wawesome deploy\n");
+}
+//#endregion
+//#region src/version.ts
+async function fetchVersions(gatewayUrl, tenantJwt, app, funcName, env, isVerbose) {
+	const url = `${gatewayUrl}/v1/apps/${encodeURIComponent(app)}/functions/${encodeURIComponent(funcName)}/versions?environment=${encodeURIComponent(env)}`;
+	if (isVerbose) console.log(`[wawesome:verbose] GET ${url}`);
+	const res = await fetch(url, {
+		method: "GET",
+		headers: { Authorization: `Bearer ${tenantJwt}` }
+	});
+	if (!res.ok) {
+		const errorBody = await res.text();
+		if (res.status === 401) console.error("[wawesome] Error: Authentication expired. Run 'wawesome login' again.");
+		else {
+			console.error(`[wawesome] Error: Failed to list versions (HTTP ${res.status}).`);
+			if (isVerbose) console.error(`[wawesome:verbose] Response: ${errorBody}`);
+		}
+		process.exit(1);
+	}
+	return await res.json();
+}
+/**
+* List existing function versions.
+*/
+async function listVersions(options) {
+	const isVerbose = Boolean(options.verbose);
+	const env = options.env || "production";
+	const creds = readCredentials();
+	if (!creds) {
+		console.error("[wawesome] Error: Not logged in. Run 'wawesome login' first.");
+		process.exit(1);
+	}
+	const config = readFunctionConfig();
+	if (!config) {
+		console.error("[wawesome] Error: No wawesome-function.json found in the current directory.");
+		process.exit(1);
+	}
+	const { app, function: funcName } = config;
+	const data = await fetchVersions(creds.gateway_url, creds.tenant_jwt, app, funcName, env, isVerbose);
+	if (!data.versions || data.versions.length === 0) {
+		console.log(`[wawesome] No versions found for '${app}/${funcName}'. Deploy code first using 'wawesome deploy'.`);
+		return;
+	}
+	console.log(`\n📦 \x1b[1mVersions for '${app}/${funcName}' (environment: ${env})\x1b[0m\n`);
+	console.log("VERSION | HASH     | CREATED AT           | STATUS    | ACTIVE");
+	console.log("--------|----------|----------------------|-----------|-------");
+	for (const v of data.versions) {
+		const isActive = v.version_number === data.active_version_number;
+		const verStr = `#${v.version_number}`.padEnd(7);
+		const hashStr = v.cwasm_hash.slice(0, 8).padEnd(8);
+		const dateStr = new Date(v.created_at).toISOString().replace("T", " ").slice(0, 19).padEnd(20);
+		const statusStr = v.status.padEnd(9);
+		console.log(`${verStr} | ${hashStr} | ${dateStr} | ${statusStr} | ${isActive ? "\x1B[32m★ [active]\x1B[0m" : ""}`);
+	}
+	console.log("");
+}
+/**
+* Switch active deployment version.
+*/
+async function switchVersion(targetInput, options) {
+	const isVerbose = Boolean(options.verbose);
+	const env = options.env || "production";
+	const creds = readCredentials();
+	if (!creds) {
+		console.error("[wawesome] Error: Not logged in. Run 'wawesome login' first.");
+		process.exit(1);
+	}
+	const config = readFunctionConfig();
+	if (!config) {
+		console.error("[wawesome] Error: No wawesome-function.json found in the current directory.");
+		process.exit(1);
+	}
+	const { app, function: funcName } = config;
+	const data = await fetchVersions(creds.gateway_url, creds.tenant_jwt, app, funcName, env, isVerbose);
+	if (!data.versions || data.versions.length === 0) {
+		console.error(`[wawesome] Error: No versions found for '${app}/${funcName}'. Deploy code first.`);
+		process.exit(1);
+	}
+	let selectedVersionNum;
+	if (targetInput !== void 0 && targetInput.trim() !== "") {
+		const cleaned = targetInput.trim().replace(/^v/, "");
+		const matched = data.versions.find((v) => v.version_number.toString() === cleaned || v.cwasm_hash.startsWith(cleaned) || v.cwasm_hash.slice(0, 8) === cleaned);
+		if (!matched) {
+			console.error(`\n[wawesome] \x1b[31mError: Version '${targetInput}' not found for '${app}/${funcName}'.\x1b[0m`);
+			console.error("\nAvailable versions:");
+			for (const v of data.versions) console.error(`  - v${v.version_number} (${v.cwasm_hash.slice(0, 8)}) created at ${v.created_at}`);
+			console.error("");
+			process.exit(1);
+		}
+		selectedVersionNum = matched.version_number;
+	} else {
+		if (!process.stdout.isTTY) {
+			console.error("[wawesome] Error: Missing version argument in non-interactive environment.");
+			console.error("[wawesome] Usage: wawesome version switch <version_number_or_hash>");
+			process.exit(1);
+		}
+		const choices = data.versions.map((v) => {
+			const isActive = v.version_number === data.active_version_number;
+			const hashShort = v.cwasm_hash.slice(0, 8);
+			const dateStr = new Date(v.created_at).toISOString().replace("T", " ").slice(0, 19);
+			const badge = isActive ? " ★ [active]" : "";
+			return {
+				name: `v${v.version_number} (${hashShort}) • ${dateStr}${badge}`,
+				value: v.version_number
+			};
+		});
+		try {
+			selectedVersionNum = await select({
+				message: `Select active version for '${app}/${funcName}' (${env}):`,
+				choices,
+				pageSize: 10
+			});
+		} catch {
+			console.log("\n[wawesome] Version selection cancelled.");
+			process.exit(0);
+		}
+	}
+	console.log(`[wawesome] Promoting v${selectedVersionNum} to ${env}...`);
+	const deployUrl = `${creds.gateway_url}/v1/apps/${encodeURIComponent(app)}/functions/${encodeURIComponent(funcName)}/deploy`;
+	const deployRes = await fetch(deployUrl, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${creds.tenant_jwt}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify({
+			version_number: selectedVersionNum,
+			environment: env
+		})
+	});
+	if (!deployRes.ok) {
+		const errorBody = await deployRes.text();
+		console.error(`[wawesome] Error: Failed to set active version (HTTP ${deployRes.status}).`);
+		if (isVerbose) console.error(`[wawesome:verbose] Response: ${errorBody}`);
+		process.exit(1);
+	}
+	console.log(`\n======================================================`);
+	console.log(`🚀 \x1b[32mACTIVE VERSION UPDATED!\x1b[0m`);
+	console.log(`======================================================`);
+	console.log(`  App:         ${app}`);
+	console.log(`  Function:    ${funcName}`);
+	console.log(`  Environment: ${env}`);
+	console.log(`  Active Ver:  v${selectedVersionNum}`);
+	console.log(`======================================================\n`);
+}
+//#endregion
+//#region src/env.ts
+const STANDARD_SECRET_MESSAGES = [
+	"Encrypted at rest using AES-256",
+	"This value can't be viewed again after you save it — only updated or deleted",
+	"Only decrypted at the moment your function runs — never returned by the CLI, dashboard, or API after creation."
+];
+/**
+* Load credentials and validate project config.
+*/
+function loadClientContext() {
+	const creds = readCredentials();
+	if (!creds) {
+		console.error("[wawesome] Error: Not logged in. Run 'wawesome login' first.");
+		process.exit(1);
+	}
+	const config = readFunctionConfig();
+	if (!config || !config.app || !config.app.trim()) {
+		console.error("[wawesome] Error: No wawesome-function.json found in the current directory.");
+		console.error("[wawesome] Run 'wawesome init' to create one, or create it manually.");
+		process.exit(1);
+	}
+	return {
+		creds,
+		app: config.app.trim()
+	};
+}
+/**
+* Set or overwrite an environment variable on the current app.
+*/
+async function setEnvVar(key, value, options) {
+	const isVerbose = Boolean(options.verbose);
+	if (!key || value === void 0) {
+		console.error("[wawesome] Error: Missing key or value. Usage: wawesome env set <KEY> <VALUE> [--secret]");
+		process.exit(1);
+	}
+	const { creds, app } = loadClientContext();
+	const isSecret = Boolean(options.secret);
+	const url = `${creds.gateway_url}/v1/apps/${encodeURIComponent(app)}/env`;
+	if (isVerbose) {
+		console.log(`[wawesome:verbose] POST ${url}`);
+		console.log(`[wawesome:verbose] Payload: key=${key}, is_secret=${isSecret}`);
+	}
+	const res = await fetch(url, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${creds.tenant_jwt}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify({
+			key,
+			value,
+			is_secret: isSecret
+		})
+	});
+	if (!res.ok) {
+		const errorBody = await res.text();
+		if (res.status === 401) console.error("[wawesome] Error: Authentication expired. Run 'wawesome login' again.");
+		else {
+			let msg = `HTTP ${res.status}`;
+			try {
+				const parsed = JSON.parse(errorBody);
+				if (parsed.error) msg = parsed.error;
+			} catch {}
+			console.error(`[wawesome] Error: Failed to set variable '${key}' (${msg}).`);
+			if (isVerbose) console.error(`[wawesome:verbose] Response: ${errorBody}`);
+		}
+		process.exit(1);
+	}
+	const data = await res.json();
+	if (data.variable.is_secret || isSecret) {
+		console.log(`\n[wawesome] ✅ Set secret variable '${key}' on app '${app}'.`);
+		const messages = data.notice?.messages?.length ? data.notice.messages : STANDARD_SECRET_MESSAGES;
+		console.log("\n🔒 \x1B[1mSecret Notice:\x1B[0m");
+		for (const msg of messages) console.log(`  • ${msg}`);
+		console.log("");
+	} else console.log(`[wawesome] ✅ Set variable '${key}' on app '${app}'.`);
+}
+function truncate(str, maxLen) {
+	if (str.length <= maxLen) return str;
+	if (maxLen <= 3) return str.slice(0, maxLen);
+	return str.slice(0, maxLen - 1) + "…";
+}
+/**
+* List environment variables on the current app.
+*/
+async function listEnvVars(options) {
+	const isVerbose = Boolean(options.verbose);
+	const { creds, app } = loadClientContext();
+	const url = `${creds.gateway_url}/v1/apps/${encodeURIComponent(app)}/env`;
+	if (isVerbose) console.log(`[wawesome:verbose] GET ${url}`);
+	const res = await fetch(url, {
+		method: "GET",
+		headers: { Authorization: `Bearer ${creds.tenant_jwt}` }
+	});
+	if (!res.ok) {
+		const errorBody = await res.text();
+		if (res.status === 401) console.error("[wawesome] Error: Authentication expired. Run 'wawesome login' again.");
+		else {
+			console.error(`[wawesome] Error: Failed to list variables (HTTP ${res.status}).`);
+			if (isVerbose) console.error(`[wawesome:verbose] Response: ${errorBody}`);
+		}
+		process.exit(1);
+	}
+	const data = await res.json();
+	if (!data.variables || data.variables.length === 0) {
+		console.log(`[wawesome] No environment variables set for app '${app}'.`);
+		return;
+	}
+	const availableWidth = (process.stdout.columns && process.stdout.columns > 40 ? process.stdout.columns : 80) - 12;
+	let rawMaxKeyLen = 15;
+	let rawMaxValLen = 15;
+	for (const item of data.variables) {
+		if (item.key.length > rawMaxKeyLen) rawMaxKeyLen = item.key.length;
+		if (item.value.length > rawMaxValLen) rawMaxValLen = item.value.length;
+	}
+	const maxKeyLen = Math.min(rawMaxKeyLen, Math.max(15, Math.floor(availableWidth * .4)));
+	const maxValLen = Math.min(rawMaxValLen, Math.max(15, availableWidth - maxKeyLen));
+	console.log(`\n📋 \x1b[1mEnvironment variables for '${app}'\x1b[0m\n`);
+	const headerKey = "KEY".padEnd(maxKeyLen);
+	const headerVal = "VALUE".padEnd(maxValLen);
+	console.log(`${headerKey} | ${headerVal} | SECRET`);
+	console.log(`${"-".repeat(maxKeyLen)}-|- ${"-".repeat(maxValLen)} |-------`);
+	for (const item of data.variables) {
+		const truncatedKey = truncate(item.key, maxKeyLen);
+		const truncatedVal = truncate(item.value, maxValLen);
+		const keyStr = truncatedKey.padEnd(maxKeyLen);
+		const valStr = truncatedVal.padEnd(maxValLen);
+		const secretStr = item.is_secret ? "\x1B[33mtrue\x1B[0m" : "false";
+		console.log(`${keyStr} | ${valStr} | ${secretStr}`);
+	}
+	console.log("");
+}
+/**
+* Delete an environment variable on the current app.
+*/
+async function removeEnvVar(key, options) {
+	const isVerbose = Boolean(options.verbose);
+	if (!key) {
+		console.error("[wawesome] Error: Missing variable key. Usage: wawesome env rm <KEY>");
+		process.exit(1);
+	}
+	const { creds, app } = loadClientContext();
+	const url = `${creds.gateway_url}/v1/apps/${encodeURIComponent(app)}/env/${encodeURIComponent(key)}`;
+	if (isVerbose) console.log(`[wawesome:verbose] DELETE ${url}`);
+	const res = await fetch(url, {
+		method: "DELETE",
+		headers: { Authorization: `Bearer ${creds.tenant_jwt}` }
+	});
+	if (!res.ok) {
+		const errorBody = await res.text();
+		if (res.status === 401) console.error("[wawesome] Error: Authentication expired. Run 'wawesome login' again.");
+		else if (res.status === 404) console.error(`[wawesome] Error: Variable '${key}' not found on app '${app}'.`);
+		else {
+			console.error(`[wawesome] Error: Failed to delete variable '${key}' (HTTP ${res.status}).`);
+			if (isVerbose) console.error(`[wawesome:verbose] Response: ${errorBody}`);
+		}
+		process.exit(1);
+	}
+	console.log(`[wawesome] ✅ Deleted variable '${key}' from app '${app}'.`);
+}
+/**
+* Dispatcher function for `wawesome env` CLI command.
+*/
+async function envCommand(action, key, value, options) {
+	if (!action || action === "list" || action === "ls") return listEnvVars(options);
+	if (action === "set") return setEnvVar(key, value, options);
+	if (action === "rm" || action === "remove" || action === "delete" || action === "unset") return removeEnvVar(key, options);
+	console.error(`[wawesome] Error: Unknown env action '${action}'. Available actions: list, set, rm.`);
+	process.exit(1);
+}
+//#endregion
+//#region src/index.ts
+const cli = cac("wawesome");
+cli.command("build [entry]", "Bundle a serverless function to an optimized JS file").option("-o, --out <path>", "Output JS bundle path", { default: "dist/index.js" }).option("-v, --verbose", "Enable verbose debug output").action((entry, options) => buildJs(entry, options));
+cli.command("deploy [entry]", "Build, upload, and promote a serverless function").option("-o, --out <path>", "Output JS bundle path", { default: "dist/index.js" }).option("-v, --verbose", "Enable verbose debug output").option("--skip-build", "Skip the build step, deploy an already-built bundle").action((entry, options) => deploy(entry, options));
+cli.command("version [action] [target]", "Manage versions (e.g. 'version list', 'version switch [version]')").option("-e, --env <environment>", "Target environment (default: production)").option("-v, --verbose", "Enable verbose debug output").action((action, target, options) => {
+	if (!action || action === "list" || action === "ls") return listVersions(options);
+	if (action === "switch" || action === "use" || action === "select") return switchVersion(target, options);
+	return switchVersion(action, options);
+});
+cli.command("versions", "Alias for 'version list'").option("-e, --env <environment>", "Target environment (default: production)").option("-v, --verbose", "Enable verbose debug output").action((options) => listVersions(options));
+cli.command("switch [target]", "Alias for 'version switch'").option("-e, --env <environment>", "Target environment (default: production)").option("-v, --verbose", "Enable verbose debug output").action((target, options) => switchVersion(target, options));
+cli.command("env [action] [key] [value]", "Manage environment variables (set, list, rm)").usage("env <action> [key] [value]\n\nActions:\n  set <key> <value> [--secret]   Set or overwrite an environment variable\n  list                            List environment variables for the current app\n  rm <key>                       Delete an environment variable").example("wawesome env list").example("wawesome env set API_KEY my-secret-val --secret").example("wawesome env rm API_KEY").option("-s, --secret", "Flag variable as secret (write-only)").option("-v, --verbose", "Enable verbose debug output").action((action, key, value, options) => envCommand(action, key, value, options));
+cli.command("env set <key> <value>", "Set or overwrite an environment variable on the current app").option("-s, --secret", "Flag variable as secret (write-only)").option("-v, --verbose", "Enable verbose debug output").action((key, value, options) => setEnvVar(key, value, options));
+cli.command("env list", "List environment variables for the current app").alias("env ls").option("-v, --verbose", "Enable verbose debug output").action((options) => listEnvVars(options));
+cli.command("env rm <key>", "Delete an environment variable from the current app").alias("env remove").alias("env delete").alias("env unset").option("-v, --verbose", "Enable verbose debug output").action((key, options) => removeEnvVar(key, options));
+cli.command("login", "Authenticate with the wawesome.io platform").option("--api <url>", "API URL (default: https://api.wawesome.io)").option("--gateway <url>", "Alias for --api <url>").option("--provider <name>", "OAuth provider (default: github)").option("-v, --verbose", "Enable verbose debug output").action((options) => login(options));
+cli.command("logout", "Clear stored authentication credentials").action(() => logout());
+cli.command("whoami", "Show current login session info").action(() => whoami());
+cli.command("init", "Scaffold a new function project in the current directory").option("-v, --verbose", "Enable verbose debug output").action((options) => init(options));
+cli.help();
+cli.version("1.0.0");
+cli.parse();
+//#endregion
+export {};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "wawesome",
+  "version": "0.0.1",
+  "description": "CLI tool for building and deploying serverless functions on wawesome.io platform",
+  "type": "module",
+  "bin": {
+    "wawesome": "./bin/wawesome.js"
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest run",
+    "check": "publint",
+    "changeset": "changeset"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.5.2",
+    "cac": "^6.7.14",
+    "esbuild": "^0.28.0",
+    "open": "^10.0.0"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.31.1",
+    "@types/node": "^26.1.1",
+    "publint": "^0.3.22",
+    "tsdown": "^0.22.5",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  }
+}