wawesome 0.0.5 → 0.0.6

package/README.md

@@ -32,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:
@@ -146,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

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 = {
@@ -1323,6 +1551,105 @@ async function followFunctionLog(gatewayUrl, tenantJwt, funcNameInput, appOverri
 	}
 }
 //#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));
@@ -1338,9 +1665,10 @@ 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]
 

package/package.json

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