wawesome 0.0.7 → 0.0.9

package/README.md

@@ -52,8 +52,9 @@ npx wawesome init --template stripe-webhook
 
 This goes from nothing to a deployed Function in one command. The template is downloaded over
 plain HTTP and unpacked — **git is not required**, on any platform — and its files land exactly as
-they are published. Only two are touched: the `name` in `package.json`, and the App and Function
-names in `wawesome-function.json`.
+they are published. Only the `name` in `package.json`, the App and Function names in
+`wawesome-function.json`, and the `wawesome` dependency are touched — the last so the project you
+get depends on the CLI that scaffolded it rather than the one the template was released against.
 
 Templates declare what they need rather than shipping placeholders, so the CLI then asks for each
 environment variable the template requires — showing where in the provider's own dashboard to find
@@ -61,6 +62,22 @@ the value — stores them (secrets write-only), enables any outbound providers t
 and deploys. If a value does not exist yet, leave it blank; the CLI tells you the `env set` command
 to run once it does.
 
+Dependencies are installed for you (with whatever package manager launched the CLI — `npx`, `pnpm
+dlx`, `bun x`), so the types are there when you open the project and the bundler can resolve the
+template's imports. Pass `--no-install` to do it yourself. A failed install never stops the flow;
+the command to re-run is printed.
+
+Before any of that is sent anywhere, the CLI shows you the **public URL your Function will have**
+and offers to change your workspace address — the part of that URL that is yours rather than this
+project's, and the same one `wawesome workspace show` prints. It is randomly minted at signup and
+stays changeable until your first deploy, at which point it locks for good, because live URLs carry
+it. Press enter to keep it. If it is already locked, the offer is not made and the reason is said
+plainly.
+
+Being logged in is checked **before** the first question, not at the deploy: an expired session
+offers you a login there and then, and declining still leaves you the project plus the two commands
+that finish it.
+
 Run it in an empty directory: if any file would be overwritten, nothing is written at all and the
 collision is named.
 

package/dist/index.mjs

@@ -5,8 +5,9 @@ import { build } from "esbuild";
 import os from "node:os";
 import http from "node:http";
 import readline from "node:readline";
+import { confirm, select } from "@inquirer/prompts";
+import { spawnSync } from "node:child_process";
 import zlib from "node:zlib";
-import { select } from "@inquirer/prompts";
 //#region src/config.ts
 /**
 * Hardcoded Supabase project config for the wawesome.io platform.
@@ -150,6 +151,18 @@ async function buildJs(entryInput, options) {
 	}
 }
 //#endregion
+//#region src/cli-version.ts
+/**
+* The version of the CLI that is running, read from the package it ships in.
+*
+* Compiled in at bundle time rather than resolved from disk, because `dist/` is
+* what gets published and the manifest next to it is not where a `npx` cache,
+* a global install, and a workspace checkout all agree it will be. Anything
+* that has to name this version — `--version`, the dependency a scaffolded
+* project pins — reads it here, so a release bumps one file.
+*/
+const CLI_VERSION = "0.0.9";
+//#endregion
 //#region src/prompt.ts
 /**
 * Open a prompt session on stdin, queueing lines as they arrive.
@@ -271,6 +284,34 @@ async function resolveWorkspace(creds) {
 	};
 }
 /**
+* What a refused rename means for whoever asked for it.
+*
+* Shared by the two places that offer a rename, so they cannot drift into
+* telling a user different things about the same reason — and `retryable` is
+* what separates a name worth retyping from one that no name would fix.
+*/
+function renameAdvice(reason) {
+	switch (reason) {
+		case "taken":
+		case "reserved": return {
+			text: "Pick a different name.",
+			retryable: true
+		};
+		case "malformed": return {
+			text: "Use lowercase letters, numbers and single hyphens.",
+			retryable: true
+		};
+		case "locked": return {
+			text: "A deploy landed while this was running, which fixed the address for good.",
+			retryable: false
+		};
+		default: return {
+			text: "",
+			retryable: false
+		};
+	}
+}
+/**
 * 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
@@ -288,9 +329,8 @@ async function renameTenantSlug(creds, 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,
+	writeCredentials({
+		...readCredentials() ?? creds,
 		tenant_slug: result.tenant_slug
 	});
 	return result;
@@ -806,6 +846,58 @@ async function envCommand(action, key, value, options) {
 	process.exit(1);
 }
 //#endregion
+//#region src/install.ts
+/** Package managers whose `install` this understands. */
+const KNOWN_MANAGERS = [
+	"npm",
+	"pnpm",
+	"yarn",
+	"bun"
+];
+/**
+* Which package manager to install with.
+*
+* Taken from the one that launched this process — `pnpm dlx wawesome init`
+* should not leave a `package-lock.json` behind — and npm otherwise, since that
+* is what `npx` is.
+*/
+function packageManager(userAgent = process.env.npm_config_user_agent) {
+	const name = (userAgent ?? "").split("/")[0];
+	return KNOWN_MANAGERS.includes(name) ? name : "npm";
+}
+function installDependencies(dir, options = {}) {
+	const manager = packageManager();
+	const command = `${manager} install`;
+	if (!fs.existsSync(path.join(dir, "package.json"))) return {
+		command,
+		ok: false
+	};
+	console.log(`\n[wawesome] Installing dependencies (${command})...`);
+	const result = spawnSync(manager, ["install"], {
+		cwd: dir,
+		stdio: options.verbose ? "inherit" : [
+			"ignore",
+			"ignore",
+			"pipe"
+		],
+		shell: process.platform === "win32"
+	});
+	if (result.status === 0) {
+		console.log("[wawesome] ✅ Dependencies installed.");
+		return {
+			command,
+			ok: true
+		};
+	}
+	const stderr = result.stderr?.toString().trim();
+	console.log(`[wawesome] ${command} did not finish. Run it yourself when you can.`);
+	if (stderr) console.log(`[wawesome] ${stderr.split("\n").slice(-3).join("\n[wawesome] ")}`);
+	return {
+		command,
+		ok: false
+	};
+}
+//#endregion
 //#region src/provision.ts
 /** The gateway's own words for a failure, or a plain HTTP status if it gave none. */
 async function rejected(res, fallback) {
@@ -902,15 +994,61 @@ function applyTemplateIdentity(dir, identity) {
 		function: identity.functionName
 	}));
 }
+/** The package the CLI publishes itself as, and which a template depends on. */
+const CLI_PACKAGE = "wawesome";
+/**
+* Point the template's dependency on the CLI at the CLI that is scaffolding it.
+*
+* A template pins the version it was released against, and below 1.0 a caret
+* range is an exact pin — `^0.0.6` never resolves to `0.0.7`. So a template
+* whose repository has not been touched since installs an older CLI than the
+* one the user just ran, and ships types that predate the platform it is about
+* to deploy to. Rewriting it here keeps the two in step without a template
+* release for every CLI release.
+*
+* Only a declaration that already exists is rewritten: what a template depends
+* on is the template's business, and a template that does not use the CLI does
+* not acquire it here.
+*/
+function alignCliDependency(dir, version) {
+	const file = path.join(dir, PACKAGE_FILE);
+	const pkg = readJson(file);
+	const wanted = `^${version}`;
+	for (const field of ["dependencies", "devDependencies"]) {
+		const deps = pkg[field];
+		if (!isRecord(deps)) continue;
+		const current = deps[CLI_PACKAGE];
+		if (typeof current !== "string" || current === wanted) continue;
+		writeJson(file, {
+			...pkg,
+			[field]: {
+				...deps,
+				[CLI_PACKAGE]: wanted
+			}
+		});
+		return {
+			from: current,
+			to: wanted
+		};
+	}
+	return null;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function patchJson(file, patch) {
+	writeJson(file, patch(readJson(file)));
+}
+function readJson(file) {
 	if (!fs.existsSync(file)) throw new Error(`The template is missing ${path.basename(file)}, which scaffolding must patch.`);
-	let current;
 	try {
-		current = JSON.parse(fs.readFileSync(file, "utf-8"));
+		return JSON.parse(fs.readFileSync(file, "utf-8"));
 	} catch (err) {
 		throw new Error(`The template's ${path.basename(file)} is not valid JSON: ${errorText(err)}`);
 	}
-	fs.writeFileSync(file, JSON.stringify(patch(current), null, 2) + "\n", "utf-8");
+}
+function writeJson(file, content) {
+	fs.writeFileSync(file, JSON.stringify(content, null, 2) + "\n", "utf-8");
 }
 /**
 * Which of the files a scaffold is about to write are already there.
@@ -1299,6 +1437,134 @@ async function promptForDeclaredEnv(session, declared) {
 	return answers;
 }
 /**
+* The stored credentials, if the platform still accepts them, with whatever it
+* said about the Tenant while answering.
+*
+* Only a refusal counts as an answer — that is the null. An unreachable gateway
+* says nothing about whether the credentials are good, and treating it as a dead
+* session would send a user who is merely offline through a login they do not
+* need, so it comes back as a session with nothing known about the Tenant.
+*/
+async function probeSession(creds) {
+	try {
+		return {
+			creds,
+			tenant: await fetchTenantDetails(creds)
+		};
+	} catch (err) {
+		return err instanceof GatewayError && (err.status === 401 || err.status === 403) ? null : {
+			creds,
+			tenant: null
+		};
+	}
+}
+/**
+* Get a working session before the first question is asked.
+*
+* The credentials file existing is not the same as being logged in — a JWT
+* expires — and everything this command does after scaffolding needs a live
+* session. Checked here, the two answers a user can get are "log in now" and a
+* project that scaffolds without one. Checked where it used to be, at the first
+* write, the answer was an error *after* they had typed a webhook secret in.
+*
+* Returns null when there is no session to work with, which is a supported way
+* to finish: the files are still worth having.
+*/
+async function ensureSession(options) {
+	const stored = readCredentials();
+	if (stored) {
+		const probed = await probeSession(stored);
+		if (probed) return probed;
+	}
+	console.log(stored ? "\n[wawesome] Your session has expired." : "\n[wawesome] You're not logged in yet — that's what a deploy needs.");
+	if (!isInteractive()) {
+		console.log("[wawesome] Run 'wawesome login', then 'wawesome deploy'.");
+		return null;
+	}
+	let wantsLogin;
+	try {
+		wantsLogin = await confirm({
+			message: "Log in now?",
+			default: true
+		});
+	} catch {
+		console.log("[wawesome] Cancelled. Nothing was written.");
+		process.exit(130);
+	}
+	if (!wantsLogin) return null;
+	try {
+		await login({
+			api: options.api,
+			verbose: options.verbose
+		});
+	} catch (err) {
+		console.error(`[wawesome] Login failed: ${errorText(err)}`);
+		return null;
+	}
+	const fresh = readCredentials();
+	return fresh ? probeSession(fresh) : null;
+}
+/** Bound on the rename loop, so a name the gateway keeps refusing ends the offer. */
+const MAX_RENAME_ATTEMPTS = 3;
+/** Show the address the Function will answer on, once it is deployed. */
+function announceUrl(creds, slug, appSlug, functionName) {
+	console.log("\n[wawesome] Your Function will answer on:\n");
+	console.log(`    \x1b[36m${publicInvokeUrl(creds.gateway_url, slug, appSlug, functionName)}\x1b[0m\n`);
+}
+/**
+* Show the URL, and offer to fix the workspace address while it can still be fixed.
+*
+* This is the last moment that address is free: it locks the first time a
+* version is promoted, which is what the deploy at the end of this flow does.
+* Asking here rather than at signup is the whole reason naming was deferred —
+* it is client-facing branding, and nobody chooses it well before seeing the
+* product work. The URL comes first so the offer is about something concrete.
+*
+* The lock is read from the gateway rather than guessed, so a user who cannot
+* rename is told why instead of being walked into a rejection. Nothing here can
+* fail the flow: the project is already on disk and the deploy still works under
+* the address the workspace has.
+*/
+async function offerWorkspaceAddress(session, creds, tenant, appSlug, functionName) {
+	const current = tenant?.tenant_slug ?? creds.tenant_slug;
+	if (!current) return;
+	announceUrl(creds, current, appSlug, functionName);
+	if (!tenant) {
+		console.log(`  '${current}' is your workspace address. Whether it can still be changed`);
+		console.log("  is a question for the gateway, which did not answer.\n");
+		return;
+	}
+	if (tenant.slug_locked) {
+		console.log(`  🔒 '${current}' is fixed — a Function version has been promoted, and live URLs already carry it.\n`);
+		return;
+	}
+	console.log(`  '${current}' is your workspace address — the part of that URL that is yours`);
+	console.log("  rather than this project's, and this is the moment to change it: it locks");
+	console.log("  for good the first time you deploy, because live URLs carry it.");
+	console.log("  Press enter to keep it.\n");
+	let refusal;
+	for (let attempt = 0; attempt < MAX_RENAME_ATTEMPTS; attempt++) {
+		const answer = await session.ask("  Workspace address?", current);
+		if (answer === current) {
+			console.log(`[wawesome] Keeping '${current}'.`);
+			return;
+		}
+		try {
+			const renamed = await renameTenantSlug(creds, answer);
+			console.log(`\n[wawesome] ✅ Workspace renamed to '${renamed.tenant_slug}'.`);
+			announceUrl(creds, renamed.tenant_slug, appSlug, functionName);
+			return;
+		} catch (err) {
+			console.log(`[wawesome] ${errorText(err)}`);
+			refusal = err instanceof GatewayError ? err.reason : void 0;
+			const { text, retryable } = renameAdvice(refusal);
+			if (text) console.log(`[wawesome] ${text}`);
+			if (!retryable) break;
+		}
+	}
+	console.log(refusal === "locked" ? `[wawesome] Keeping '${current}'.` : `[wawesome] Keeping '${current}'. Change it later with: wawesome workspace rename <name>`);
+}
+/**
 * Satisfy the template's declarations against the platform.
 *
 * The manifest declares; nothing here is template-specific. Each declaration
@@ -1367,10 +1633,11 @@ async function initFromTemplate(templateName, options) {
 		force: true
 	});
 	process.once("exit", sweepStaging);
-	const session = openPromptSession();
 	let functionName;
 	let appSlug;
 	let manifest;
+	let tenantSession;
+	let answers = [];
 	try {
 		let files;
 		try {
@@ -1384,39 +1651,47 @@ async function initFromTemplate(templateName, options) {
 		}
 		const collisions = collidingPaths(cwd, files);
 		if (collisions.length > 0) fail(`${collisions.join(", ")} already exist${collisions.length === 1 ? "s" : ""} here.`, "Run this in an empty directory, or move those files aside first. Nothing was written.");
-		functionName = await promptForSlug(session, "Function name", readFunctionConfig(staging)?.function || dirName);
-		console.log("  (an App groups the Functions of one project — its slug is part of the public URL)");
-		appSlug = await promptForSlug(session, "App slug", dirName);
+		tenantSession = await ensureSession(options);
+		const session = openPromptSession();
 		try {
-			fs.cpSync(staging, cwd, { recursive: true });
-			applyTemplateIdentity(cwd, {
-				app: appSlug,
-				functionName
-			});
-		} catch (err) {
-			fail(errorText(err), `Some of '${template.name}' may have been written to ${cwd}.`);
+			functionName = await promptForSlug(session, "Function name", readFunctionConfig(staging)?.function || dirName);
+			console.log("  (an App groups the Functions of one project — its slug is part of the public URL)");
+			appSlug = await promptForSlug(session, "App slug", dirName);
+			let repinned = null;
+			try {
+				fs.cpSync(staging, cwd, { recursive: true });
+				applyTemplateIdentity(cwd, {
+					app: appSlug,
+					functionName
+				});
+				repinned = alignCliDependency(cwd, CLI_VERSION);
+			} catch (err) {
+				fail(errorText(err), `Some of '${template.name}' may have been written to ${cwd}.`);
+			}
+			console.log(`\n[wawesome] ✅ Scaffolded ${files.length} files from '${template.name}'.`);
+			if (repinned) console.log(`[wawesome] Using wawesome ${repinned.to} — the template pinned ${repinned.from}.`);
+			if (tenantSession) await offerWorkspaceAddress(session, tenantSession.creds, tenantSession.tenant, appSlug, functionName);
+			answers = tenantSession ? await promptForDeclaredEnv(session, manifest.env) : [];
+		} finally {
+			session.close();
 		}
-		console.log(`\n[wawesome] ✅ Scaffolded ${files.length} files from '${template.name}'.`);
 	} finally {
 		sweepStaging();
 		process.off("exit", sweepStaging);
 	}
-	let answers = [];
-	let creds;
-	try {
-		creds = readCredentials();
-		if (creds) answers = await promptForDeclaredEnv(session, manifest.env);
-	} finally {
-		session.close();
-	}
-	if (!creds) {
+	if (!tenantSession) {
+		const installed = options.install === false ? null : installDependencies(cwd, { verbose: options.verbose });
 		console.log("\n[wawesome] 🎉 Project ready. Next steps:");
-		console.log("  1. npm install");
-		console.log("  2. wawesome login");
-		console.log("  3. wawesome deploy\n");
+		[
+			...installed?.ok ? [] : [installed?.command ?? "npm install"],
+			"wawesome login",
+			"wawesome deploy"
+		].forEach((step, index) => console.log(`  ${index + 1}. ${step}`));
+		console.log("");
 		return;
 	}
-	await wireUp(creds, appSlug, manifest, answers);
+	await wireUp(tenantSession.creds, appSlug, manifest, answers);
+	if (options.install !== false) installDependencies(cwd, { verbose: options.verbose });
 	const result = await deploy(void 0, {
 		out: "dist/index.js",
 		verbose: options.verbose
@@ -1491,7 +1766,7 @@ export default {
 				typecheck: "tsc --noEmit"
 			},
 			devDependencies: {
-				"wawesome": "^1.0.0",
+				"wawesome": `^${CLI_VERSION}`,
 				typescript: "^7.0.0"
 			}
 		};
@@ -1524,10 +1799,14 @@ export default {
 		fs.writeFileSync(gitignorePath, "node_modules\ndist\n", "utf-8");
 		console.log("[wawesome] ✅ Created .gitignore");
 	}
+	const installed = options.install === false ? null : installDependencies(cwd, { verbose: options.verbose });
 	console.log("\n[wawesome] 🎉 Project initialized! Next steps:");
-	console.log("  1. npm install");
-	console.log("  2. wawesome login");
-	console.log("  3. wawesome deploy\n");
+	[
+		...installed?.ok ? [] : [installed?.command ?? "npm install"],
+		"wawesome login",
+		"wawesome deploy"
+	].forEach((step, index) => console.log(`  ${index + 1}. ${step}`));
+	console.log("");
 }
 //#endregion
 //#region src/version.ts
@@ -2228,20 +2507,8 @@ async function renameWorkspace(slug, options) {
 	} 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;
-			}
+			const { text } = renameAdvice(err.reason);
+			if (text) console.error(`[wawesome] ${text}`);
 			console.error("");
 			process.exit(1);
 			return;
@@ -2279,7 +2546,7 @@ cli.command("logout", "Clear stored authentication credentials").action(() => lo
 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("templates [action]", "Browse the template catalog").usage("templates [action]\n\nActions:\n  list (ls)           Show every available template (default)").example("wawesome templates").example("wawesome templates list").option("--api <url>", "API URL (default: https://api.wawesome.io)").option("-v, --verbose", "Enable verbose debug output").action((action, options) => templatesCommand(action, options));
-cli.command("init", "Scaffold a new function project in the current directory").usage("init [options]\n\nWith --template, the project is fetched from the template catalog, wired up\nfrom what the template declares it needs, and deployed. Run 'wawesome templates'\nto see what is available.").example("wawesome init").example("wawesome init --template stripe-webhook").option("-t, --template <name>", "Scaffold from a catalog template and deploy it").option("--api <url>", "API URL (default: https://api.wawesome.io)").option("-v, --verbose", "Enable verbose debug output").action((options) => init(options));
+cli.command("init", "Scaffold a new function project in the current directory").usage("init [options]\n\nWith --template, the project is fetched from the template catalog, wired up\nfrom what the template declares it needs, and deployed. Run 'wawesome templates'\nto see what is available.").example("wawesome init").example("wawesome init --template stripe-webhook").option("-t, --template <name>", "Scaffold from a catalog template and deploy it").option("--api <url>", "API URL (default: https://api.wawesome.io)").option("--no-install", "Skip installing dependencies after scaffolding").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:
@@ -2302,7 +2569,7 @@ cli.command("logs [function-name-or-invocation-id]", "View invocation history, f
   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.version(CLI_VERSION);
 cli.parse();
 //#endregion
 export {};

package/package.json

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