wawesome 0.0.1 → 0.0.5

package/README.md

@@ -0,0 +1,193 @@
+# 🚀 wawesome
+
+> Official CLI for building, bundling, and deploying serverless WebAssembly functions on the
+> **[wawesome.io](https://wawesome.io)** platform.
+
+[![npm version](https://img.shields.io/npm/v/wawesome.svg?color=cyan)](https://www.npmjs.com/package/wawesome)
+
+Deploy ultra-fast, lightweight serverless WebAssembly functions directly from your terminal in under 60 seconds.
+
+---
+
+## ⚡ Quick Start
+
+### 1. Create an account
+
+Sign up for free at **[https://wawesome.io](https://wawesome.io)** to set up your workspace.
+
+### 2. Authenticate CLI
+
+Login via browser OAuth:
+
+```bash
+npx wawesome login
+```
+
+### 3. Initialize a project
+
+Create a new directory and scaffold a WebAssembly TypeScript starter function:
+
+```bash
+mkdir my-wasm-app && cd my-wasm-app
+npx wawesome init
+```
+
+### 4. Build & Deploy
+
+Deploy your serverless function to Wawesome Cloud instantly:
+
+```bash
+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 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.
+
+---
+
+## ⚙️ Configuration & Custom Gateway
+
+### `wawesome-function.json`
+
+Every project directory includes a `wawesome-function.json` file generated during `npx wawesome init`:
+
+```json
+{
+  "app": "my-app",
+  "function": "hello-world",
+  "entry": "src/index.ts"
+}
+```
+
+### 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
+following:
+
+#### 1. Custom Settings (`~/.wawesome/settings.json`)
+
+Create `~/.wawesome/settings.json`:
+
+```json
+{
+  "gateway_url": "http://localhost:3000"
+}
+```
+
+#### 2. Environment Variables
+
+```bash
+export WAWESOME_GATEWAY_URL="http://localhost:3000"
+```
+
+#### 3. CLI Flag
+
+```bash
+npx wawesome login --gateway http://localhost:3000
+```
+
+---
+
+## 🔒 Security & Secrets
+
+Wawesome encrypts environment variables at rest using two-tier envelope encryption (AES-256-GCM with per-app data keys
+and AAD context binding). Use `--secret` when setting sensitive keys:
+
+```bash
+npx wawesome env set STRIPE_SECRET_KEY sk_live_xxx --secret
+```
+
+---
+
+## 🌐 Resources & Support
+
+- **Platform Homepage**: [https://wawesome.io](https://wawesome.io)
+- **Documentation**: [https://docs.wawesome.io](https://docs.wawesome.io)
+

package/dist/index.mjs

@@ -837,6 +837,492 @@ 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/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));
@@ -856,6 +1342,27 @@ cli.command("login", "Authenticate with the wawesome.io platform").option("--api
 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.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,10 +1,10 @@
 {
   "name": "wawesome",
-  "version": "0.0.1",
+  "version": "0.0.5",
   "description": "CLI tool for building and deploying serverless functions on wawesome.io platform",
   "type": "module",
   "bin": {
-    "wawesome": "./bin/wawesome.js"
+    "wawesome": "bin/wawesome.js"
   },
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
@@ -16,7 +16,7 @@
     "build": "tsdown",
     "dev": "tsdown --watch",
     "test": "vitest run",
-    "check": "publint",
+    "check": "publint --pack npm",
     "changeset": "changeset"
   },
   "dependencies": {