wawesome 0.0.4 → 0.0.6

package/README.md

@@ -4,7 +4,6 @@
 > **[wawesome.io](https://wawesome.io)** platform.
 
 [![npm version](https://img.shields.io/npm/v/wawesome.svg?color=cyan)](https://www.npmjs.com/package/wawesome)
-[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
 Deploy ultra-fast, lightweight serverless WebAssembly functions directly from your terminal in under 60 seconds.
 
@@ -33,6 +32,15 @@ mkdir my-wasm-app && cd my-wasm-app
 npx wawesome init
 ```
 
+`init` asks for the function name and for the **App slug** — the App groups the Functions of one
+project, and its slug is part of the public URL your client sees. Both default to the directory
+name, so naming is usually a matter of pressing enter.
+
+An App slug must be a legal hostname label: lowercase letters, numbers, and single hyphens between
+them (no leading or trailing hyphen, 63 characters at most). Type something else — `My Client` —
+and the CLI shows you the slug it would become (`my-client`) and asks again, rather than rewriting
+your answer behind your back.
+
 ### 4. Build & Deploy
 
 Deploy your serverless function to Wawesome Cloud instantly:
@@ -45,19 +53,91 @@ npx wawesome deploy
 
 ## 📖 Command Reference
 
-| Command                            | Description                                                         |
-|:-----------------------------------|:--------------------------------------------------------------------|
-| `npx wawesome login`               | Authenticate CLI with your Wawesome account via browser             |
-| `npx wawesome logout`              | Log out and clear saved credentials from your machine               |
-| `npx wawesome whoami`              | View current logged-in user, workspace, and gateway info            |
-| `npx wawesome init`                | Scaffold a new serverless function project in the current directory |
-| `npx wawesome build`               | Bundle TypeScript entry code into an optimized JS bundle            |
-| `npx wawesome deploy`              | Build, upload, and promote a function version to production         |
-| `npx wawesome version list`        | List version history for the current function                       |
-| `npx wawesome version switch <v>`  | Roll back or promote a specific function version                    |
-| `npx wawesome env list`            | View environment variables for the current app                      |
-| `npx wawesome env set <key> <val>` | Set an environment variable (add `--secret` for write-only)         |
-| `npx wawesome env rm <key>`        | Delete an environment variable                                      |
+| Command                                 | Description                                                         |
+|:----------------------------------------|:--------------------------------------------------------------------|
+| `npx wawesome login`                    | Authenticate CLI with your Wawesome account via browser             |
+| `npx wawesome logout`                   | Log out and clear saved credentials from your machine               |
+| `npx wawesome whoami`                   | View current logged-in user, workspace, and gateway info            |
+| `npx wawesome init`                     | Scaffold a new serverless function project in the current directory |
+| `npx wawesome build`                    | Bundle TypeScript entry code into an optimized JS bundle            |
+| `npx wawesome deploy`                   | Build, upload, and promote a function version to production         |
+| `npx wawesome logs [func]`              | List recent past invocations for a function                         |
+| `npx wawesome logs --invocation <id>`   | Fetch full stdout/stderr log body for a specific invocation         |
+| `npx wawesome logs <func> --follow`     | Follow live output (waits for the next invocation if needed)        |
+| `npx wawesome version list`             | List version history for the current function                       |
+| `npx wawesome version switch <v>`       | Roll back or promote a specific function version                    |
+| `npx wawesome env list`                 | View environment variables for the current app                      |
+| `npx wawesome env set <key> <val>`      | Set an environment variable (add `--secret` for write-only)         |
+| `npx wawesome env rm <key>`             | Delete an environment variable                                      |
+
+---
+
+## 📜 Invocation Logs
+
+Inspect past function runs or view raw `stdout` / `stderr` log outputs directly in your terminal.
+
+### 1. List Recent Invocations
+
+List past executions (including status, trigger type, timestamp, and duration) for the function in the
+current directory:
+
+```bash
+npx wawesome logs
+```
+
+Or list invocations for a specific function by name:
+
+```bash
+npx wawesome logs my-function
+```
+
+Filter by invocation status — only show errors, timeouts, etc.:
+
+```bash
+npx wawesome logs my-function --error
+npx wawesome logs my-function --status timeout
+npx wawesome logs my-function --running
+```
+
+### 2. View Invocation Log Body (`stdout`/`stderr`)
+
+Fetch and print the captured `console.log` / `console.error` text for a specific invocation:
+
+```bash
+npx wawesome logs --invocation 019fb344-ea0c-78f2-8a9b-d04e188b9823
+```
+
+Or pass the UUID directly as the target:
+
+```bash
+npx wawesome logs 019fb344-ea0c-78f2-8a9b-d04e188b9823
+```
+
+### 3. Follow Live Output (`--follow`)
+
+Stream an invocation's output as it runs — like `tail -f` for your serverless function.
+
+#### Follow by function name (recommended)
+
+```bash
+npx wawesome logs my-function --follow
+```
+
+If the function is currently running, its output is streamed immediately. If the latest invocation
+already finished, the CLI **waits for the next invocation** to start and then streams it live.
+Press `Ctrl-C` at any time to stop.
+
+#### Follow a specific invocation by ID
+
+```bash
+npx wawesome logs 019fb344-ea0c-78f2-8a9b-d04e188b9823 --follow
+```
+
+#### Reconnection
+
+On transient network errors or server issues (5xx), the CLI automatically reconnects with
+exponential back-off (up to 3 retries). Non-recoverable errors like authentication failures
+(401) or unknown invocations (404) exit immediately with a clear message.
 
 ---
 
@@ -75,6 +155,9 @@ Every project directory includes a `wawesome-function.json` file generated durin
 }
 ```
 
+`app` is the App this Function is deployed into, and it is client-facing — every deploy from this
+directory is scoped to it.
+
 ### Local Development / Gateway Overrides
 
 If you are running a local gateway or self-hosted instance, you can configure your CLI Gateway URL using any of the
@@ -119,4 +202,4 @@ npx wawesome env set STRIPE_SECRET_KEY sk_live_xxx --secret
 
 - **Platform Homepage**: [https://wawesome.io](https://wawesome.io)
 - **Documentation**: [https://docs.wawesome.io](https://docs.wawesome.io)
-- **License**: MIT
+

package/dist/index.mjs

@@ -148,8 +148,166 @@ async function buildJs(entryInput, options) {
 	}
 }
 //#endregion
+//#region src/prompt.ts
+/**
+* Open a prompt session on stdin, queueing lines as they arrive.
+*
+* Reading one `rl.question` at a time drops piped input: it lands as a single
+* chunk, so every line after the first is emitted with no question pending.
+* End of input answers the remaining questions with their defaults.
+*/
+function openPromptSession() {
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	const queued = [];
+	const waiting = [];
+	let ended = false;
+	rl.on("line", (line) => {
+		const next = waiting.shift();
+		if (next) next(line);
+		else queued.push(line);
+	});
+	rl.on("close", () => {
+		ended = true;
+		while (waiting.length > 0) waiting.shift()?.(null);
+	});
+	function nextLine() {
+		if (queued.length > 0) return Promise.resolve(queued.shift());
+		if (ended) return Promise.resolve(null);
+		return new Promise((resolve) => waiting.push(resolve));
+	}
+	return {
+		async ask(question, defaultVal) {
+			const offered = defaultVal ? ` (${defaultVal})` : "";
+			process.stdout.write(`${question}${offered}: `);
+			const line = await nextLine();
+			if (line === null) {
+				process.stdout.write("\n");
+				return defaultVal;
+			}
+			return line.trim() || defaultVal;
+		},
+		close() {
+			rl.close();
+		}
+	};
+}
+/**
+* Whether a question can actually be put to somebody. A piped or redirected
+* stdin still answers — with end-of-input — so this only tells a caller whether
+* a *default* is going to be what the user gets.
+*/
+function isInteractive() {
+	return Boolean(process.stdin.isTTY);
+}
+//#endregion
+//#region src/tenant.ts
+/** A rejection carrying the gateway's own prose and, where given, its reason. */
+var GatewayError = class extends Error {
+	status;
+	reason;
+	constructor(message, status, reason) {
+		super(message);
+		this.name = "GatewayError";
+		this.status = status;
+		this.reason = reason;
+	}
+};
+async function asGatewayError(res, fallback) {
+	const body = await res.text();
+	try {
+		const parsed = JSON.parse(body);
+		return new GatewayError(parsed.error || fallback, res.status, parsed.reason);
+	} catch {
+		return new GatewayError(fallback, res.status);
+	}
+}
+async function fetchTenantDetails(creds) {
+	const res = await fetch(`${creds.gateway_url}/v1/tenant`, { headers: { Authorization: `Bearer ${creds.tenant_jwt}` } });
+	if (!res.ok) throw await asGatewayError(res, `Failed to read workspace (HTTP ${res.status}).`);
+	return await res.json();
+}
+/**
+* The workspace's name and slug, preferring what login already stored.
+*
+* Credentials written before the slug was stored have neither, so this fetches
+* and writes them back rather than making every later command ask again.
+*/
+async function resolveWorkspace(creds) {
+	if (creds.tenant_slug && creds.tenant_name) return {
+		name: creds.tenant_name,
+		slug: creds.tenant_slug
+	};
+	const tenant = await fetchTenantDetails(creds);
+	writeCredentials({
+		...creds,
+		tenant_slug: tenant.tenant_slug,
+		tenant_name: tenant.name
+	});
+	return {
+		name: tenant.name,
+		slug: tenant.tenant_slug
+	};
+}
+/**
+* Ask for the workspace's public address to become `slug`.
+*
+* The slug is sent exactly as typed. Sanitizing it the way an App slug is
+* sanitized would hand the user a public address they never chose, so an
+* unusable name comes back as a `malformed` rejection instead.
+*/
+async function renameTenantSlug(creds, slug) {
+	const res = await fetch(`${creds.gateway_url}/v1/tenant/slug`, {
+		method: "PUT",
+		headers: {
+			Authorization: `Bearer ${creds.tenant_jwt}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify({ slug })
+	});
+	if (!res.ok) throw await asGatewayError(res, `Rename failed (HTTP ${res.status}).`);
+	const result = await res.json();
+	const stored = readCredentials();
+	if (stored) writeCredentials({
+		...stored,
+		tenant_slug: result.tenant_slug
+	});
+	return result;
+}
+/** The address a deployed Function answers on, for a workspace and app. */
+function publicInvokeUrl(gatewayUrl, tenantSlug, appSlug, functionName) {
+	return `${gatewayUrl}/v1/s/${encodeURIComponent(tenantSlug)}/apps/${encodeURIComponent(appSlug)}/functions/${encodeURIComponent(functionName)}/invoke`;
+}
+//#endregion
 //#region src/auth.ts
 /**
+* Ask what to call the workspace being created.
+*
+* There is no default worth offering: a name nobody typed is exactly what this
+* replaced. A non-interactive login has nobody to ask, so it says what flag to
+* pass rather than inventing one and minting a workspace under it.
+*/
+async function promptForWorkspaceName(options) {
+	const supplied = options.workspace?.trim();
+	if (supplied) return supplied;
+	if (!isInteractive()) throw new Error("No workspace found, and no name to create one with. Re-run with --workspace <name>.");
+	console.log("\n[wawesome] You don't have a workspace yet — let's create one.");
+	console.log("  (this is the name you'll see in the dashboard; its public address is set separately)");
+	const session = openPromptSession();
+	try {
+		for (let attempt = 0; attempt < 3; attempt++) {
+			const answer = await session.ask("  Workspace name?", "");
+			if (answer.trim()) return answer.trim();
+			console.log("[wawesome] A workspace needs a name.");
+		}
+	} finally {
+		session.close();
+	}
+	throw new Error("No workspace name given. Nothing was created.");
+}
+/**
 * OAuth login flow:
 * 1. Build Supabase OAuth URL
 * 2. Open browser
@@ -217,18 +375,24 @@ async function login(options) {
 					if (!tenantsRes.ok) throw new Error(`Failed to fetch tenants (HTTP ${tenantsRes.status}). Have you completed onboarding?`);
 					const tenants = await tenantsRes.json();
 					let primaryTenantId;
+					let workspaceName;
+					let workspaceSlug;
 					if (tenants.length === 0) {
-						console.log("[wawesome] No workspaces found. Initializing default workspace...");
+						const chosenName = await promptForWorkspaceName(options);
+						console.log(`[wawesome] Creating workspace "${chosenName}"...`);
 						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" })
+							body: JSON.stringify({ tenant_name: chosenName })
 						});
 						if (!initRes.ok) throw new Error(`Failed to initialize workspace (HTTP ${initRes.status}).`);
-						primaryTenantId = (await initRes.json()).tenant_id;
+						const initData = await initRes.json();
+						primaryTenantId = initData.tenant_id;
+						workspaceSlug = initData.tenant_slug;
+						workspaceName = initData.tenant_name || chosenName;
 					} else primaryTenantId = tenants[0].tenant_id;
 					if (isVerbose) console.log(`[wawesome:verbose] Using tenant: ${primaryTenantId}`);
 					console.log("[wawesome] Exchanging for tenant-scoped credentials...");
@@ -242,6 +406,8 @@ async function login(options) {
 					});
 					if (!exchangeRes.ok) throw new Error(`Token exchange failed (HTTP ${exchangeRes.status}).`);
 					const exchangeData = await exchangeRes.json();
+					workspaceSlug = exchangeData.tenant_slug || workspaceSlug;
+					workspaceName = exchangeData.tenant_name || workspaceName;
 					let userEmail = exchangeData.email || "unknown";
 					try {
 						const payloadPart = exchangeData.tenant_jwt.split(".")[1];
@@ -252,14 +418,18 @@ async function login(options) {
 						gateway_url: gatewayUrl,
 						tenant_jwt: exchangeData.tenant_jwt,
 						tenant_id: primaryTenantId,
-						user_email: userEmail
+						user_email: userEmail,
+						tenant_slug: workspaceSlug,
+						tenant_name: workspaceName
 					});
 					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}`);
+					if (workspaceName) console.log(`\n  Workspace: ${workspaceName}`);
+					if (workspaceSlug) console.log(`  Address:   ${workspaceSlug}`);
+					console.log(`  Tenant:    ${primaryTenantId}`);
+					console.log(`  Gateway:   ${gatewayUrl}`);
+					console.log(`  Email:     ${userEmail}`);
 					console.log("\n  Credentials saved to ~/.wawesome/credentials.json");
 					console.log("======================================================\n");
 					server.close();
@@ -297,16 +467,26 @@ function logout() {
 /**
 * Show current login status.
 */
-function whoami() {
+async function whoami() {
 	const creds = readCredentials();
 	if (!creds) {
 		console.log("[wawesome] Not logged in. Run 'wawesome login' to authenticate.");
 		return;
 	}
+	let workspace = null;
+	try {
+		workspace = await resolveWorkspace(creds);
+	} catch {
+		workspace = null;
+	}
 	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`);
+	console.log(`  Email:     ${creds.user_email}`);
+	if (workspace) {
+		console.log(`  Workspace: ${workspace.name}`);
+		console.log(`  Address:   ${workspace.slug}`);
+	}
+	console.log(`  Tenant:    ${creds.tenant_id}`);
+	console.log(`  Gateway:   ${creds.gateway_url}\n`);
 }
 //#endregion
 //#region src/deploy.ts
@@ -405,27 +585,67 @@ async function deploy(entryInput, options) {
 		}
 		process.exit(1);
 	}
+	let invokeUrl = null;
+	try {
+		const { slug } = await resolveWorkspace(creds);
+		invokeUrl = publicInvokeUrl(creds.gateway_url, slug, app, funcName);
+	} catch (err) {
+		if (isVerbose) console.log(`[wawesome:verbose] Could not resolve the workspace address: ${err instanceof Error ? err.message : err}`);
+	}
 	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}`);
+	if (invokeUrl) console.log(`\n  URL:      \x1b[36m${invokeUrl}\x1b[0m`);
 	console.log("======================================================\n");
 }
+/**
+* Normalise arbitrary input into a legal DNS label, returning an empty string
+* when nothing legal survives — callers decide whether that is an error.
+*/
+function sanitizeSlug(raw) {
+	let label = "";
+	for (const c of raw.trim().toLowerCase()) if (c >= "a" && c <= "z") label += c;
+	else if (c >= "0" && c <= "9") label += c;
+	else if (label.length > 0 && !label.endsWith("-")) label += "-";
+	label = label.slice(0, 63);
+	while (label.endsWith("-")) label = label.slice(0, -1);
+	return label;
+}
+/**
+* Whether `candidate` is already a legal DNS label — i.e. whether
+* {@link sanitizeSlug} would leave it untouched.
+*/
+function isLegalSlug(candidate) {
+	return candidate.length > 0 && candidate.length <= 63 && !candidate.startsWith("-") && !candidate.endsWith("-") && !candidate.includes("--") && /^[a-z0-9-]+$/.test(candidate);
+}
 //#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);
-		});
-	});
+/** Bound on the re-prompt loop, so unusable input exits instead of looping. */
+const MAX_APP_SLUG_ATTEMPTS = 5;
+/**
+* Ask which App this Function belongs to, defaulting to the directory name.
+*
+* Never falls back to `default-app`, and re-offers an illegal answer as a
+* suggestion rather than rewriting it: the slug is part of the public URL a
+* client reads, so the user sees the name they will get before agreeing to it.
+*/
+async function promptForAppSlug(session, dirName) {
+	let suggestion = sanitizeSlug(dirName);
+	for (let attempt = 0; attempt < MAX_APP_SLUG_ATTEMPTS; attempt++) {
+		const answer = await session.ask("  App slug?", suggestion);
+		if (isLegalSlug(answer)) return answer;
+		const sanitized = sanitizeSlug(answer);
+		if (sanitized) {
+			console.log(`[wawesome] '${answer}' can't be used as an App slug. Suggested: '${sanitized}'.`);
+			suggestion = sanitized;
+		} else console.log("[wawesome] An App slug needs lowercase letters or numbers, separated by single hyphens.");
+	}
+	console.error(`[wawesome] Error: no usable App slug after ${MAX_APP_SLUG_ATTEMPTS} attempts. Nothing was written.`);
+	console.error("[wawesome] Run 'wawesome init' again once you know what to call the App.");
+	process.exit(1);
 }
 /**
 * Scaffold a new wawesome function project in the current directory.
@@ -435,8 +655,16 @@ async function init(options) {
 	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 session = openPromptSession();
+	let functionName;
+	let appSlug;
+	try {
+		functionName = await session.ask("  Function name?", dirName);
+		console.log("  (an App groups the Functions of one project — its slug is part of the public URL)");
+		appSlug = await promptForAppSlug(session, dirName);
+	} finally {
+		session.close();
+	}
 	const entry = "src/index.ts";
 	if (isVerbose) console.log(`[wawesome:verbose] function=${functionName}, app=${appSlug}, entry=${entry}`);
 	const configContent = {
@@ -837,6 +1065,591 @@ async function envCommand(action, key, value, options) {
 	process.exit(1);
 }
 //#endregion
+//#region src/logs.ts
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUuid(str) {
+	return UUID_REGEX.test(str);
+}
+function formatDuration(startedAt, endedAt) {
+	if (!endedAt) return "-";
+	const start = new Date(startedAt).getTime();
+	const end = new Date(endedAt).getTime();
+	if (isNaN(start) || isNaN(end)) return "-";
+	const durationMs = end - start;
+	if (durationMs < 0) return "-";
+	if (durationMs < 1e3) return `${durationMs}ms`;
+	return `${(durationMs / 1e3).toFixed(2)}s`;
+}
+function formatDate(dateStr) {
+	const d = new Date(dateStr);
+	if (isNaN(d.getTime())) return dateStr;
+	return d.toISOString().replace("T", " ").slice(0, 19);
+}
+function colorizeStatus(text, status) {
+	switch (status.toLowerCase()) {
+		case "success": return `\x1b[32m${text}\x1b[0m`;
+		case "error": return `\x1b[31m${text}\x1b[0m`;
+		case "timeout": return `\x1b[33m${text}\x1b[0m`;
+		case "running": return `\x1b[36m${text}\x1b[0m`;
+		default: return text;
+	}
+}
+/**
+* Main handler for `wawesome logs [target] [--invocation <id>] [--app <app>]`
+*/
+async function logsCommand(target, 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);
+	}
+	let invocationId = options.invocation;
+	let funcNameInput;
+	if (!invocationId && target && isUuid(target)) invocationId = target;
+	else if (target && !isUuid(target)) funcNameInput = target;
+	let statusFilter = options.status;
+	if (!statusFilter) {
+		if (options.success) statusFilter = "success";
+		else if (options.error) statusFilter = "error";
+		else if (options.timeout) statusFilter = "timeout";
+		else if (options.running) statusFilter = "running";
+	}
+	if (options.follow) {
+		if (invocationId) return followInvocationLog(creds.gateway_url, creds.tenant_jwt, invocationId, isVerbose);
+		return followFunctionLog(creds.gateway_url, creds.tenant_jwt, funcNameInput, options.app, isVerbose);
+	}
+	if (invocationId) return fetchInvocationLogBody(creds.gateway_url, creds.tenant_jwt, invocationId, isVerbose);
+	else return listInvocations(creds.gateway_url, creds.tenant_jwt, funcNameInput, options.app, statusFilter, isVerbose);
+}
+/**
+* Fetch and display raw log body for a single invocation.
+*/
+async function fetchInvocationLogBody(gatewayUrl, tenantJwt, invocationId, isVerbose) {
+	const url = `${gatewayUrl}/v1/invocations/${encodeURIComponent(invocationId)}/logs`;
+	if (isVerbose) console.log(`[wawesome:verbose] GET ${url}`);
+	const res = await fetch(url, {
+		method: "GET",
+		headers: { Authorization: `Bearer ${tenantJwt}` }
+	});
+	if (!res.ok) {
+		const errorText = 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: Invocation log '${invocationId}' not found or expired (logs are retained for 14 days).`);
+		else if (res.status === 400) console.error(`[wawesome] Error: Invalid invocation ID '${invocationId}'.`);
+		else {
+			console.error(`[wawesome] Error: Failed to fetch invocation logs (HTTP ${res.status}).`);
+			if (isVerbose) console.error(`[wawesome:verbose] Response: ${errorText}`);
+		}
+		process.exit(1);
+	}
+	const body = await res.text();
+	process.stdout.write(body.endsWith("\n") ? body : body + "\n");
+}
+/**
+* List recent invocations for a function.
+*/
+async function listInvocations(gatewayUrl, tenantJwt, funcNameInput, appOverride, statusFilter, isVerbose) {
+	const config = readFunctionConfig();
+	const appSlug = appOverride || config?.app;
+	const funcName = funcNameInput || config?.function;
+	if (!funcName) {
+		console.error("[wawesome] Error: Missing function name or invocation ID.");
+		console.error("[wawesome] Usage: wawesome logs <function-name-or-id> or run inside a function directory with wawesome-function.json.");
+		process.exit(1);
+	}
+	const queryParams = new URLSearchParams();
+	queryParams.set("limit", "50");
+	if (statusFilter && statusFilter.toLowerCase() !== "all") queryParams.set("status", statusFilter.toLowerCase());
+	const res = await fetchInvocationsResponse(gatewayUrl, tenantJwt, funcName, appSlug, appOverride, `?${queryParams.toString()}`, isVerbose);
+	if (!res.ok) {
+		const errorText = 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: Function '${funcName}' not found.`);
+		else {
+			console.error(`[wawesome] Error: Failed to list invocations (HTTP ${res.status}).`);
+			if (isVerbose) console.error(`[wawesome:verbose] Response: ${errorText}`);
+		}
+		process.exit(1);
+	}
+	const data = await res.json();
+	if (!data.invocations || data.invocations.length === 0) {
+		console.log(`[wawesome] No invocations found for function '${funcName}'.`);
+		return;
+	}
+	const displayTarget = appSlug ? `${appSlug}/${funcName}` : funcName;
+	const totalRecords = data.total ?? data.invocations.length;
+	const shownRecords = data.invocations.length;
+	console.log(`\n📜 \x1b[1mInvocations for '${displayTarget}' (Showing ${shownRecords} of ${totalRecords} records)\x1b[0m\n`);
+	console.log("INVOCATION ID                        | STATUS    | TRIGGER | STARTED AT          | DURATION ");
+	console.log("------------------------------------|-----------|---------|---------------------|----------");
+	for (const inv of data.invocations) {
+		const idStr = inv.id.padEnd(36);
+		const statusStr = colorizeStatus(inv.status.padEnd(9), inv.status);
+		const triggerStr = inv.trigger_type.padEnd(7);
+		const dateStr = formatDate(inv.started_at).padEnd(19);
+		const durationStr = formatDuration(inv.started_at, inv.ended_at).padEnd(9);
+		console.log(`${idStr} | ${statusStr} | ${triggerStr} | ${dateStr} | ${durationStr}`);
+	}
+	console.log("\nTo view logs for a specific invocation, run:\n  wawesome logs --invocation <id>\n");
+	console.log("To follow live output (waits for the next invocation if none is running):\n  wawesome logs <function-name> --follow\n");
+	console.log("To follow a specific invocation:\n  wawesome logs --invocation <id> --follow\n");
+}
+/**
+* Fetch a Function's invocations, transparently falling back from the app-scoped
+* route to the unscoped (default-app) route on a 404 when `--app` wasn't given.
+* Shared by the list view and the `--follow` latest-invocation resolver so both
+* hit the same routes and fallback behaviour.
+*/
+async function fetchInvocationsResponse(gatewayUrl, tenantJwt, funcName, appSlug, appOverride, queryString, isVerbose) {
+	const url = appSlug ? `${gatewayUrl}/v1/apps/${encodeURIComponent(appSlug)}/functions/${encodeURIComponent(funcName)}/invocations${queryString}` : `${gatewayUrl}/v1/functions/${encodeURIComponent(funcName)}/invocations${queryString}`;
+	if (isVerbose) console.log(`[wawesome:verbose] GET ${url}`);
+	let res = await fetch(url, {
+		method: "GET",
+		headers: { Authorization: `Bearer ${tenantJwt}` }
+	});
+	if (res.status === 404 && appSlug && !appOverride) {
+		const fallbackUrl = `${gatewayUrl}/v1/functions/${encodeURIComponent(funcName)}/invocations${queryString}`;
+		if (isVerbose) console.log(`[wawesome:verbose] 404 on app-scoped route. Retrying unscoped: GET ${fallbackUrl}`);
+		try {
+			const fallbackRes = await fetch(fallbackUrl, {
+				method: "GET",
+				headers: { Authorization: `Bearer ${tenantJwt}` }
+			});
+			if (fallbackRes) res = fallbackRes;
+		} catch {}
+	}
+	return res;
+}
+/**
+* Split a growing SSE buffer into complete event `data` payloads, returning the
+* still-incomplete remainder. Each SSE event is terminated by a blank line; its
+* `data:` field lines are rejoined with newlines (so a multi-line NDJSON chunk
+* survives intact). Comment/keep-alive events (no `data:` line) are dropped.
+*/
+function splitSseEvents(buffer) {
+	const events = [];
+	let idx;
+	while ((idx = buffer.indexOf("\n\n")) !== -1) {
+		const rawEvent = buffer.slice(0, idx);
+		buffer = buffer.slice(idx + 2);
+		const data = rawEvent.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).replace(/^ /, "")).join("\n");
+		if (data) events.push(data);
+	}
+	return {
+		events,
+		rest: buffer
+	};
+}
+/**
+* Print one NDJSON log line the way `logs` does, colorizing `stderr` records
+* red. Falls back to the raw line if it isn't the expected structured shape.
+*/
+function printFollowLine(line) {
+	const trimmed = line.trim();
+	if (!trimmed) return;
+	try {
+		const entry = JSON.parse(trimmed);
+		if (entry && typeof entry.msg === "string") {
+			if (entry.stream === "stderr") process.stdout.write(`\x1b[31m${entry.msg}\x1b[0m\n`);
+			else process.stdout.write(`${entry.msg}\n`);
+			return;
+		}
+	} catch {}
+	process.stdout.write(trimmed + "\n");
+}
+/** Maximum number of reconnection attempts on transient errors. */
+const MAX_RETRIES = 3;
+/** Base delay in milliseconds for exponential back-off (1 s → 2 s → 4 s). */
+const BASE_RETRY_DELAY_MS = 1e3;
+/**
+* Sleep for `ms` milliseconds, respecting an `AbortSignal` so Ctrl-C doesn't
+* hang during back-off waits.
+*/
+function retrySleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal.aborted) {
+			reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+			return;
+		}
+		const timer = setTimeout(resolve, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/**
+* Calculate exponential back-off delay with jitter for a given attempt.
+* attempt 0 → ~1 s, attempt 1 → ~2 s, attempt 2 → ~4 s.
+*/
+function retryDelay(attempt) {
+	const base = BASE_RETRY_DELAY_MS * Math.pow(2, attempt);
+	return base + Math.random() * base * .25;
+}
+/**
+* Returns `true` for errors that are worth retrying: network-level failures
+* (fetch throws) and 5xx server errors. Client errors (4xx) are not transient.
+*/
+function isTransientError(res) {
+	if (!res) return true;
+	return res.status >= 500;
+}
+/**
+* Follow a single invocation's output live over the SSE endpoint, printing each
+* flushed chunk's lines as they arrive. The connection is consumed with `fetch`
+* + a streaming body reader (rather than `EventSource`) so the tenant `Bearer`
+* token can be sent.
+*
+* On transient network errors or 5xx responses, the connection is retried with
+* exponential back-off (max 3 retries). Non-retriable errors (401, 404, 400)
+* exit immediately.
+*
+* Returns when the invocation finishes, the server closes the stream at its
+* max-duration cap, or the user interrupts with Ctrl-C.
+*/
+async function followInvocationLog(gatewayUrl, tenantJwt, invocationId, isVerbose) {
+	const url = `${gatewayUrl}/v1/invocations/${encodeURIComponent(invocationId)}/logs/stream`;
+	if (isVerbose) console.log(`[wawesome:verbose] GET ${url} (SSE)`);
+	const controller = new AbortController();
+	const onSigint = () => {
+		controller.abort();
+		process.stderr.write("\n[wawesome] Stopped following.\n");
+		process.exit(0);
+	};
+	process.on("SIGINT", onSigint);
+	try {
+		let attempt = 0;
+		while (true) {
+			let res = null;
+			try {
+				res = await fetch(url, {
+					method: "GET",
+					headers: {
+						Authorization: `Bearer ${tenantJwt}`,
+						Accept: "text/event-stream"
+					},
+					signal: controller.signal
+				});
+			} catch (err) {
+				if (controller.signal.aborted) throw err;
+				if (attempt < MAX_RETRIES) {
+					const delay = retryDelay(attempt);
+					if (isVerbose) console.error(`[wawesome:verbose] Connection failed (${String(err)}), retrying in ${Math.round(delay)}ms (attempt ${attempt + 1}/${MAX_RETRIES})...`);
+					else console.error(`[wawesome] Connection lost, reconnecting (${attempt + 1}/${MAX_RETRIES})...`);
+					await retrySleep(delay, controller.signal);
+					attempt++;
+					continue;
+				}
+				console.error("[wawesome] Error: Failed to connect to the live tail after retries.");
+				if (isVerbose) console.error(`[wawesome:verbose] ${String(err)}`);
+				process.exit(1);
+			}
+			if (res.status === 401) {
+				console.error("[wawesome] Error: Authentication expired. Run 'wawesome login' again.");
+				process.exit(1);
+			}
+			if (res.status === 404) {
+				console.error(`[wawesome] Error: Invocation '${invocationId}' not found or expired (logs are retained for 14 days).`);
+				process.exit(1);
+			}
+			if (res.status === 400) {
+				console.error(`[wawesome] Error: Invalid invocation ID '${invocationId}'.`);
+				process.exit(1);
+			}
+			if (!res.ok && isTransientError(res)) {
+				if (attempt < MAX_RETRIES) {
+					const delay = retryDelay(attempt);
+					if (isVerbose) console.error(`[wawesome:verbose] Server error (HTTP ${res.status}), retrying in ${Math.round(delay)}ms (attempt ${attempt + 1}/${MAX_RETRIES})...`);
+					else console.error(`[wawesome] Server error, reconnecting (${attempt + 1}/${MAX_RETRIES})...`);
+					await retrySleep(delay, controller.signal);
+					attempt++;
+					continue;
+				}
+				console.error(`[wawesome] Error: Failed to open live tail (HTTP ${res.status}) after retries.`);
+				process.exit(1);
+			}
+			if (!res.ok) {
+				console.error(`[wawesome] Error: Failed to open live tail (HTTP ${res.status}).`);
+				process.exit(1);
+			}
+			if (!res.body) {
+				console.error("[wawesome] Error: Live tail response had no body stream.");
+				process.exit(1);
+			}
+			attempt = 0;
+			if (isVerbose) console.error(`[wawesome:verbose] Connected to SSE stream.`);
+			console.error(`[wawesome] 📡 Following invocation ${invocationId} (Ctrl-C to stop)...`);
+			try {
+				const reader = res.body.getReader();
+				const decoder = new TextDecoder();
+				let buffer = "";
+				for (;;) {
+					const { value, done } = await reader.read();
+					if (done) break;
+					buffer += decoder.decode(value, { stream: true });
+					const { events, rest } = splitSseEvents(buffer);
+					buffer = rest;
+					for (const chunk of events) for (const line of chunk.split("\n")) printFollowLine(line);
+				}
+				console.error(`[wawesome] ✔ Live tail ended for ${invocationId}.`);
+				return;
+			} catch (streamErr) {
+				if (controller.signal.aborted) throw streamErr;
+				if (attempt < MAX_RETRIES) {
+					const delay = retryDelay(attempt);
+					if (isVerbose) console.error(`[wawesome:verbose] Stream interrupted (${String(streamErr)}), retrying in ${Math.round(delay)}ms (attempt ${attempt + 1}/${MAX_RETRIES})...`);
+					else console.error(`[wawesome] Stream interrupted, reconnecting (${attempt + 1}/${MAX_RETRIES})...`);
+					await retrySleep(delay, controller.signal);
+					attempt++;
+					continue;
+				}
+				console.error("[wawesome] Error: Live tail stream interrupted and retries exhausted.");
+				if (isVerbose) console.error(`[wawesome:verbose] ${String(streamErr)}`);
+				process.exit(1);
+			}
+		}
+	} finally {
+		process.removeListener("SIGINT", onSigint);
+	}
+}
+/**
+* Follow a whole Function's live output over SSE: the gateway streams output from
+* every invocation of the Function as it happens, across invocation boundaries,
+* so this is a continuous `tail -f` for the Function rather than one run.
+*
+* Resolves the Function from the `funcNameInput` argument or the
+* `wawesome-function.json` in the current directory, prefers the App-scoped route
+* and falls back to the unscoped (default-app) route on a 404, and reconnects
+* automatically when the server closes the stream at its max-duration cap so the
+* terminal keeps following. Ctrl-C stops. Auth/'function not found' errors exit
+* immediately; transient network/5xx errors retry with exponential back-off.
+*/
+async function followFunctionLog(gatewayUrl, tenantJwt, funcNameInput, appOverride, isVerbose) {
+	const config = readFunctionConfig();
+	const appSlug = appOverride || config?.app;
+	const funcName = funcNameInput || config?.function;
+	if (!funcName) {
+		console.error("[wawesome] Error: Missing function name.");
+		console.error("[wawesome] Usage: wawesome logs <function-name> --follow, or run inside a function directory with wawesome-function.json.");
+		process.exit(1);
+	}
+	const scopedUrl = appSlug ? `${gatewayUrl}/v1/apps/${encodeURIComponent(appSlug)}/functions/${encodeURIComponent(funcName)}/logs/stream` : null;
+	const unscopedUrl = `${gatewayUrl}/v1/functions/${encodeURIComponent(funcName)}/logs/stream`;
+	const controller = new AbortController();
+	const onSigint = () => {
+		controller.abort();
+		process.stderr.write("\n[wawesome] Stopped following.\n");
+		process.exit(0);
+	};
+	process.on("SIGINT", onSigint);
+	const headers = {
+		Authorization: `Bearer ${tenantJwt}`,
+		Accept: "text/event-stream"
+	};
+	try {
+		let attempt = 0;
+		let announced = false;
+		while (true) {
+			if (controller.signal.aborted) return;
+			let res = null;
+			try {
+				if (scopedUrl) {
+					res = await fetch(scopedUrl, {
+						headers,
+						signal: controller.signal
+					});
+					if (res.status === 404) {
+						if (isVerbose) console.error(`[wawesome:verbose] 404 on app-scoped route, retrying unscoped.`);
+						res = await fetch(unscopedUrl, {
+							headers,
+							signal: controller.signal
+						});
+					}
+				} else res = await fetch(unscopedUrl, {
+					headers,
+					signal: controller.signal
+				});
+			} catch (err) {
+				if (controller.signal.aborted) return;
+				if (attempt < MAX_RETRIES) {
+					const delay = retryDelay(attempt);
+					console.error(`[wawesome] Connection lost, reconnecting (${attempt + 1}/${MAX_RETRIES})...`);
+					if (isVerbose) console.error(`[wawesome:verbose] ${String(err)}`);
+					await retrySleep(delay, controller.signal);
+					attempt++;
+					continue;
+				}
+				console.error("[wawesome] Error: Failed to connect to the live tail after retries.");
+				process.exit(1);
+			}
+			if (res.status === 401) {
+				console.error("[wawesome] Error: Authentication expired. Run 'wawesome login' again.");
+				process.exit(1);
+			}
+			if (res.status === 404) {
+				console.error(`[wawesome] Error: Function '${funcName}' not found.`);
+				process.exit(1);
+			}
+			if (!res.ok && isTransientError(res)) {
+				if (attempt < MAX_RETRIES) {
+					const delay = retryDelay(attempt);
+					console.error(`[wawesome] Server error, reconnecting (${attempt + 1}/${MAX_RETRIES})...`);
+					await retrySleep(delay, controller.signal);
+					attempt++;
+					continue;
+				}
+				console.error(`[wawesome] Error: Failed to open live tail (HTTP ${res.status}) after retries.`);
+				process.exit(1);
+			}
+			if (!res.ok) {
+				console.error(`[wawesome] Error: Failed to open live tail (HTTP ${res.status}).`);
+				process.exit(1);
+			}
+			if (!res.body) {
+				console.error("[wawesome] Error: Live tail response had no body stream.");
+				process.exit(1);
+			}
+			attempt = 0;
+			if (!announced) {
+				const target = appSlug ? `${appSlug}/${funcName}` : funcName;
+				console.error(`[wawesome] 📡 Following function ${target} (Ctrl-C to stop)...`);
+				announced = true;
+			}
+			try {
+				const reader = res.body.getReader();
+				const decoder = new TextDecoder();
+				let buffer = "";
+				for (;;) {
+					const { value, done } = await reader.read();
+					if (done) break;
+					buffer += decoder.decode(value, { stream: true });
+					const { events, rest } = splitSseEvents(buffer);
+					buffer = rest;
+					for (const chunk of events) for (const line of chunk.split("\n")) printFollowLine(line);
+				}
+				if (controller.signal.aborted) return;
+				if (isVerbose) console.error(`[wawesome:verbose] Stream closed by server (cap); reconnecting.`);
+				continue;
+			} catch (streamErr) {
+				if (controller.signal.aborted) return;
+				if (attempt < MAX_RETRIES) {
+					const delay = retryDelay(attempt);
+					console.error(`[wawesome] Stream interrupted, reconnecting (${attempt + 1}/${MAX_RETRIES})...`);
+					if (isVerbose) console.error(`[wawesome:verbose] ${String(streamErr)}`);
+					await retrySleep(delay, controller.signal);
+					attempt++;
+					continue;
+				}
+				console.error("[wawesome] Error: Live tail stream interrupted and retries exhausted.");
+				process.exit(1);
+			}
+		}
+	} finally {
+		process.removeListener("SIGINT", onSigint);
+	}
+}
+//#endregion
+//#region src/workspace.ts
+function requireCredentials() {
+	const creds = readCredentials();
+	if (!creds) {
+		console.error("[wawesome] Error: Not logged in. Run 'wawesome login' first.");
+		process.exit(1);
+	}
+	return creds;
+}
+/**
+* Show the workspace's name, address, and whether that address is still free to
+* change — the rename is offered here rather than discovered by attempting it.
+*/
+async function showWorkspace(options) {
+	const creds = requireCredentials();
+	let tenant;
+	try {
+		tenant = await fetchTenantDetails(creds);
+	} catch (err) {
+		console.error(`[wawesome] Error: ${err instanceof Error ? err.message : err}`);
+		process.exit(1);
+	}
+	console.log("\n[wawesome] Workspace:");
+	console.log(`  Name:     ${tenant.name}`);
+	console.log(`  Address:  ${tenant.tenant_slug}`);
+	console.log(`  Tenant:   ${tenant.id}`);
+	if (options.verbose) console.log(`  Invoke:   ${creds.gateway_url}/v1/s/${tenant.tenant_slug}/apps/<app>/functions/<function>/invoke`);
+	if (tenant.slug_locked) console.log("\n  🔒 The address is fixed — a Function version has been promoted and live URLs carry it.");
+	else {
+		console.log("\n  The address can still be changed: \x1B[36mwawesome workspace rename <name>\x1B[0m");
+		console.log("  It locks for good the first time you deploy.");
+	}
+	console.log("");
+}
+/**
+* Change the workspace's public address.
+*
+* The lock is read from the gateway before asking, so a user who cannot rename
+* is told why instead of being walked into a rejection. The rejection is still
+* handled: a promotion landing between the two calls is the one case where the
+* gateway knows something this command could not.
+*/
+async function renameWorkspace(slug, options) {
+	const creds = requireCredentials();
+	if (!slug || !slug.trim()) {
+		console.error("[wawesome] Error: No name given. Usage: wawesome workspace rename <name>");
+		process.exit(1);
+		return;
+	}
+	try {
+		const tenant = await fetchTenantDetails(creds);
+		if (tenant.slug_locked) {
+			console.error("\n[wawesome] \x1B[31mThe workspace address can no longer be changed.\x1B[0m");
+			console.error(`[wawesome] '${tenant.tenant_slug}' is fixed: a Function version has been promoted, and live URLs already carry it.`);
+			process.exit(1);
+			return;
+		}
+		if (options.verbose) console.log(`[wawesome:verbose] Renaming '${tenant.tenant_slug}' → '${slug}'`);
+		const result = await renameTenantSlug(creds, slug.trim());
+		console.log("\n======================================================");
+		console.log("✅ \x1B[32mWORKSPACE RENAMED\x1B[0m");
+		console.log("======================================================");
+		console.log(`\n  Address:  ${result.tenant_slug}`);
+		console.log(`  Previous: ${result.previous_slug} (still resolves)`);
+		console.log("======================================================\n");
+	} catch (err) {
+		if (err instanceof GatewayError) {
+			console.error(`\n[wawesome] \x1b[31m${err.message}\x1b[0m`);
+			switch (err.reason) {
+				case "taken":
+					console.error("[wawesome] Pick a different name.");
+					break;
+				case "reserved":
+					console.error("[wawesome] Pick a different name.");
+					break;
+				case "malformed":
+					console.error("[wawesome] Use lowercase letters, numbers and single hyphens.");
+					break;
+				case "locked":
+					console.error("[wawesome] A deploy landed while this was running, which fixed the address for good.");
+					break;
+			}
+			console.error("");
+			process.exit(1);
+			return;
+		}
+		console.error(`[wawesome] Error: ${err instanceof Error ? err.message : err}`);
+		process.exit(1);
+	}
+}
+/** Dispatch for `wawesome workspace [action]`. */
+async function workspaceCommand(action, target, options) {
+	if (!action || action === "show" || action === "info") return showWorkspace(options);
+	if (action === "rename") return renameWorkspace(target, options);
+	console.error(`[wawesome] Error: Unknown workspace action '${action}'.`);
+	console.error("[wawesome] Usage: wawesome workspace [show|rename <name>]");
+	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));
@@ -852,10 +1665,32 @@ cli.command("env [action] [key] [value]", "Manage environment variables (set, li
 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("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("--workspace <name>", "Name for the workspace, when signing up without a terminal to prompt").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("workspace [action] [name]", "Show the workspace, or rename its public address").usage("workspace <action> [name]\n\nActions:\n  show                Show the workspace name, address, and whether it can still change\n  rename <name>       Change the public address, while nothing live depends on it").example("wawesome workspace").example("wawesome workspace rename northwind").option("-v, --verbose", "Enable verbose debug output").action((action, name, options) => workspaceCommand(action, name, options));
 cli.command("init", "Scaffold a new function project in the current directory").option("-v, --verbose", "Enable verbose debug output").action((options) => init(options));
+cli.command("logs [function-name-or-invocation-id]", "View invocation history, fetch log output, or follow live").usage(`logs [target] [options]
+
+  The target argument determines what the command does:
+
+  MODE 1 — List invocations (no UUID target)
+    wawesome logs                          # list invocations for the function in the current directory
+    wawesome logs my-function              # list invocations for 'my-function'
+    wawesome logs my-function --error      # only show failed invocations
+    wawesome logs my-function --running    # only show currently running invocations
+
+  MODE 2 — Fetch captured log body (UUID target or --invocation)
+    wawesome logs <invocation-id>                    # print stdout/stderr for a specific invocation
+    wawesome logs my-function --invocation <id>      # same, explicit flag form
+
+  MODE 3 — Follow live output (--follow / -f)
+    wawesome logs my-function --follow               # follow the function: stream output from every invocation as it runs
+    wawesome logs <invocation-id> --follow            # follow one specific in-flight invocation by ID
+
+  With a function name, --follow streams the function's output continuously across
+  invocations — new output appears each time the function runs, no need to catch a
+  specific invocation. Press Ctrl-C to stop at any time.`).option("-f, --follow", "Stream live output (tail -f style). Follows a running invocation or waits for the next one. Ctrl-C to stop").option("-i, --invocation <id>", "Fetch stdout/stderr log body for a specific invocation ID").option("-a, --app <app>", "App slug override (defaults to wawesome-function.json)").option("-s, --status <status>", "Filter invocations by status (success, error, timeout, running)").option("--success", "Shorthand for --status success").option("--error", "Shorthand for --status error").option("--timeout", "Shorthand for --status timeout").option("--running", "Shorthand for --status running").option("-v, --verbose", "Enable verbose debug output").action((target, options) => logsCommand(target, options));
 cli.help();
 cli.version("1.0.0");
 cli.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wawesome",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "CLI tool for building and deploying serverless functions on wawesome.io platform",
   "type": "module",
   "bin": {