create-ts-saas 0.1.0-canary.0

package/dist/cli.mjs

@@ -0,0 +1,857 @@
+#!/usr/bin/env node
+import { os } from "@orpc/server";
+import { createCli } from "trpc-cli";
+import { z } from "zod";
+import { consola } from "consola";
+import { $ } from "execa";
+import pc from "picocolors";
+import semver from "semver";
+import path from "node:path";
+import fs from "fs-extra";
+import os$1 from "node:os";
+import { confirm, intro, isCancel, log, note, select, spinner, text } from "@clack/prompts";
+import open from "open";
+import { createWriteStream } from "node:fs";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import unzipper from "unzipper";
+//#region src/lib/version.ts
+function getCliVersion() {
+	return "0.1.0-canary.0";
+}
+function getCliPlatform() {
+	return `${process.platform}-${process.arch}`;
+}
+//#endregion
+//#region src/lib/api.ts
+var ApiError = class extends Error {
+	code;
+	retryable;
+	status;
+	minCliVersion;
+	constructor(init) {
+		super(init.message);
+		this.name = "ApiError";
+		this.code = init.code;
+		this.retryable = init.retryable ?? false;
+		if (init.status !== void 0) this.status = init.status;
+		if (init.minCliVersion !== void 0) this.minCliVersion = init.minCliVersion;
+	}
+};
+function parseApiErrorBody(text) {
+	try {
+		const raw = JSON.parse(text);
+		if (raw === null || typeof raw !== "object") return null;
+		const envelope = raw;
+		if (envelope["success"] !== false || envelope["data"] !== null) return null;
+		const error = typeof envelope["error"] === "object" && envelope["error"] !== null ? envelope["error"] : null;
+		if (!error || typeof error["code"] !== "string" || typeof error["message"] !== "string") return null;
+		return {
+			code: error["code"],
+			message: error["message"],
+			...typeof error["retryable"] === "boolean" && { retryable: error["retryable"] }
+		};
+	} catch {
+		return null;
+	}
+}
+function buildRequestHeaders(init, options) {
+	const headers = new Headers(init.headers);
+	headers.set("Accept", "application/json");
+	headers.set("x-cli-version", options.cliVersion);
+	headers.set("x-cli-platform", options.cliPlatform);
+	if (options.deviceId) headers.set("x-cli-device-id", options.deviceId);
+	if (options.accessToken) headers.set("Authorization", `Bearer ${options.accessToken}`);
+	return headers;
+}
+function checkMinCliVersion(cliVersion, minCli, status) {
+	if (minCli && semver.valid(cliVersion) && semver.valid(minCli) && semver.lt(cliVersion, minCli)) throw new ApiError({
+		code: "UPGRADE_REQUIRED",
+		message: `CLI version ${cliVersion} is below minimum supported ${minCli}. Please upgrade.`,
+		status,
+		minCliVersion: minCli
+	});
+}
+function parseSuccessBody(text) {
+	if (!text) return {};
+	const json = JSON.parse(text);
+	if (json !== null && typeof json === "object" && json["success"] === true && "data" in json) return json["data"];
+	throw new ApiError({
+		code: "INVALID_RESPONSE",
+		message: "Unexpected API response shape.",
+		retryable: false
+	});
+}
+function throwApiErrorFromResponse(text, res, minCli) {
+	const body = parseApiErrorBody(text);
+	throw new ApiError({
+		code: body?.code ?? (res.status === 401 ? "AUTH_INVALID" : "REQUEST_FAILED"),
+		message: body?.message ?? res.statusText,
+		retryable: body?.retryable ?? false,
+		status: res.status,
+		minCliVersion: minCli ?? void 0
+	});
+}
+function createApiClient(options) {
+	const { config, accessToken, deviceId } = options;
+	const baseUrl = config.apiBaseUrl.replace(/\/$/, "");
+	const cliVersion = getCliVersion();
+	const cliPlatform = getCliPlatform();
+	async function request(path, init = {}) {
+		const url = `${baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+		const headers = buildRequestHeaders(init, {
+			cliVersion,
+			cliPlatform,
+			deviceId,
+			accessToken
+		});
+		let res;
+		try {
+			res = await fetch(url, {
+				...init,
+				headers
+			});
+		} catch {
+			throw new ApiError({
+				code: "NETWORK_ERROR",
+				message: "Network error — could not connect to the server.",
+				retryable: true
+			});
+		}
+		const minCli = res.headers.get("x-min-supported-cli");
+		checkMinCliVersion(cliVersion, minCli, res.status);
+		const text = await res.text();
+		if (!res.ok) throwApiErrorFromResponse(text, res, minCli);
+		return parseSuccessBody(text);
+	}
+	async function stream(url) {
+		const headers = buildRequestHeaders({}, {
+			cliVersion,
+			cliPlatform,
+			deviceId,
+			accessToken
+		});
+		let res;
+		try {
+			res = await fetch(url, { headers });
+		} catch {
+			throw new ApiError({
+				code: "NETWORK_ERROR",
+				message: "Network error — could not connect to the server.",
+				retryable: true
+			});
+		}
+		if (!res.ok) {
+			const body = parseApiErrorBody(await res.text());
+			throw new ApiError({
+				code: body?.code ?? "DOWNLOAD_FAILED",
+				message: body?.message ?? "Template download failed",
+				status: res.status
+			});
+		}
+		return res;
+	}
+	return {
+		baseUrl,
+		request,
+		stream,
+		deviceInit: () => request("/cli/device/init", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({})
+		}),
+		devicePoll: (deviceCode) => request("/cli/device/poll", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ deviceCode })
+		}),
+		refresh: (refreshToken) => request("/cli/auth/refresh", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ refreshToken })
+		}),
+		logoutDevice: (refreshToken) => request("/cli/device/logout", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ refreshToken })
+		}),
+		me: () => request("/cli/me"),
+		getTemplates: () => request("/cli/templates"),
+		authorizeInit: (input) => request("/cli/init/authorize", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(input)
+		}),
+		getLatestVersion: () => request("/cli/latest-version")
+	};
+}
+//#endregion
+//#region src/constant.ts
+const DEFAULT_API_BASE_URL = "https://dev.api.ts-saas.com/api/v1";
+const CONFIG_DIR_NAME = "ts-saas-cli";
+const CONFIG_FILE_NAME = "config.json";
+const KEYTAR_SERVICE_NAME = "create-ts-saas";
+const KEYTAR_ACCOUNT_NAME = "default";
+//#endregion
+//#region src/lib/config.ts
+function getConfigDir() {
+	const home = os$1.homedir();
+	const configHome = process.env["XDG_CONFIG_HOME"] || path.join(home, ".config");
+	return path.join(configHome, CONFIG_DIR_NAME);
+}
+function getConfigPath() {
+	return path.join(getConfigDir(), CONFIG_FILE_NAME);
+}
+async function loadConfig() {
+	const fromEnv = {
+		apiBaseUrl: DEFAULT_API_BASE_URL,
+		disableTelemetry: process.env["TS_SAAS_CLI_DISABLE_TELEMETRY"] === "1" || process.env["TS_SAAS_CLI_DISABLE_TELEMETRY"] === "true"
+	};
+	const configPath = getConfigPath();
+	try {
+		if (await fs.pathExists(configPath)) {
+			const data = await fs.readJson(configPath);
+			return {
+				apiBaseUrl: data.apiBaseUrl || fromEnv.apiBaseUrl || "https://dev.api.ts-saas.com/api/v1",
+				disableTelemetry: data.disableTelemetry ?? fromEnv.disableTelemetry ?? false
+			};
+		}
+	} catch {}
+	return {
+		apiBaseUrl: fromEnv.apiBaseUrl || "https://dev.api.ts-saas.com/api/v1",
+		disableTelemetry: fromEnv.disableTelemetry ?? false
+	};
+}
+//#endregion
+//#region src/lib/storage.ts
+const FALLBACK_FILE = "session.json";
+let cachedKeytar;
+function getFallbackSessionPath() {
+	return path.join(path.dirname(getConfigPath()), FALLBACK_FILE);
+}
+async function getStoredSession() {
+	const keytar = await getKeytar();
+	try {
+		const value = keytar ? await keytar.getPassword(KEYTAR_SERVICE_NAME, KEYTAR_ACCOUNT_NAME) : null;
+		if (!value) return await getFallbackSession();
+		const parsed = JSON.parse(value);
+		if (typeof parsed.accessToken !== "string" || typeof parsed.refreshToken !== "string" || typeof parsed.deviceId !== "string" || typeof parsed.expiresAt !== "number") return null;
+		return parsed;
+	} catch {
+		return await getFallbackSession();
+	}
+}
+async function setStoredSession(session) {
+	const serialized = JSON.stringify(session);
+	const keytar = await getKeytar();
+	try {
+		if (keytar) {
+			await keytar.setPassword(KEYTAR_SERVICE_NAME, KEYTAR_ACCOUNT_NAME, serialized);
+			return;
+		}
+		await setFallbackSession(session);
+	} catch {
+		await setFallbackSession(session);
+	}
+}
+async function clearStoredSession() {
+	const keytar = await getKeytar();
+	try {
+		if (keytar) await keytar.deletePassword(KEYTAR_SERVICE_NAME, KEYTAR_ACCOUNT_NAME);
+	} catch {}
+	try {
+		await fs.remove(getFallbackSessionPath());
+	} catch {}
+}
+async function getFallbackSession() {
+	const filePath = getFallbackSessionPath();
+	try {
+		if (!await fs.pathExists(filePath)) return null;
+		const value = await fs.readJson(filePath);
+		if (typeof value.accessToken !== "string" || typeof value.refreshToken !== "string" || typeof value.deviceId !== "string" || typeof value.expiresAt !== "number") return null;
+		return value;
+	} catch {
+		return null;
+	}
+}
+async function setFallbackSession(session) {
+	await fs.ensureDir(path.dirname(getFallbackSessionPath()));
+	await fs.writeJson(getFallbackSessionPath(), session, { spaces: 0 });
+	try {
+		await fs.chmod(getFallbackSessionPath(), 384);
+	} catch {}
+}
+async function getKeytar() {
+	if (cachedKeytar !== void 0) return cachedKeytar;
+	try {
+		const imported = await import("keytar");
+		cachedKeytar = imported.default || imported;
+		return cachedKeytar;
+	} catch {
+		cachedKeytar = null;
+		return null;
+	}
+}
+//#endregion
+//#region src/commands/doctor.ts
+async function doctorCommand() {
+	consola.log(pc.bold("Environment checks\n"));
+	const checks = [];
+	checks.push({
+		name: "Node.js",
+		status: Number(process.versions.node.split(".")[0]) >= 20 ? "ok" : "fail",
+		detail: process.version
+	});
+	try {
+		const result = await $`pnpm --version`;
+		checks.push({
+			name: "pnpm",
+			status: "ok",
+			detail: result.stdout.trim()
+		});
+	} catch {
+		checks.push({
+			name: "pnpm",
+			status: "fail",
+			detail: "not found"
+		});
+	}
+	try {
+		await $`git --version`;
+		checks.push({
+			name: "git",
+			status: "ok",
+			detail: "installed"
+		});
+	} catch {
+		checks.push({
+			name: "git",
+			status: "fail",
+			detail: "not found"
+		});
+	}
+	const config = await loadConfig();
+	const session = await getStoredSession();
+	checks.push({
+		name: "session",
+		status: session ? "ok" : "fail",
+		detail: session ? "present" : "missing"
+	});
+	try {
+		await createApiClient({
+			config,
+			accessToken: session?.accessToken || null,
+			deviceId: session?.deviceId || null
+		}).getLatestVersion();
+		checks.push({
+			name: "api",
+			status: "ok",
+			detail: config.apiBaseUrl
+		});
+	} catch {
+		checks.push({
+			name: "api",
+			status: "fail",
+			detail: "unreachable"
+		});
+	}
+	for (const check of checks) {
+		const icon = check.status === "ok" ? pc.green("✓") : pc.red("✗");
+		consola.log(`${icon} ${check.name}: ${check.detail}`);
+	}
+	consola.log(`\nCLI version: ${getCliVersion()}`);
+}
+//#endregion
+//#region src/utils/open-url.ts
+async function openUrl(url) {
+	try {
+		await open(url);
+	} catch {}
+}
+//#endregion
+//#region src/lib/auth.ts
+async function getValidSession() {
+	const session = await getStoredSession();
+	if (!session) return null;
+	if (session.expiresAt <= Date.now() + 6e4) return null;
+	return session;
+}
+const NOT_LOGGED_IN_MESSAGE = "Not logged in. Run `npx create-ts-saas login` first.";
+var NotLoggedInError = class extends Error {
+	constructor() {
+		super(NOT_LOGGED_IN_MESSAGE);
+		this.name = "NotLoggedInError";
+	}
+};
+async function requireSession(apiFactory) {
+	const valid = await getValidSession();
+	if (valid) return valid;
+	const current = await getStoredSession();
+	if (current?.refreshToken) try {
+		const refreshed = await apiFactory(current).refresh(current.refreshToken);
+		const next = {
+			accessToken: refreshed.accessToken,
+			refreshToken: refreshed.refreshToken,
+			deviceId: current.deviceId,
+			expiresAt: Date.now() + refreshed.expiresIn * 1e3
+		};
+		await setStoredSession(next);
+		return next;
+	} catch {
+		await clearStoredSession();
+	}
+	throw new NotLoggedInError();
+}
+async function ensureSession(apiFactory) {
+	const valid = await getValidSession();
+	if (valid) return valid;
+	const current = await getStoredSession();
+	if (current?.refreshToken) try {
+		const refreshed = await apiFactory(current).refresh(current.refreshToken);
+		const next = {
+			accessToken: refreshed.accessToken,
+			refreshToken: refreshed.refreshToken,
+			deviceId: current.deviceId,
+			expiresAt: Date.now() + refreshed.expiresIn * 1e3
+		};
+		await setStoredSession(next);
+		return next;
+	} catch {
+		await clearStoredSession();
+	}
+	return await loginWithDeviceFlow(apiFactory());
+}
+async function loginWithDeviceFlow(api) {
+	const init = await api.deviceInit();
+	const verificationUrlWithCode = `${init.verificationUrl}${init.verificationUrl.includes("?") ? "&" : "?"}code=${encodeURIComponent(init.userCode)}`;
+	note(`Open ${verificationUrlWithCode} and confirm code ${init.userCode}\nCode expires in ${Math.floor(init.expiresIn / 60)} minutes.`, "Device Login");
+	openUrl(verificationUrlWithCode);
+	const deadline = Date.now() + init.expiresIn * 1e3;
+	while (Date.now() < deadline) {
+		await new Promise((resolve) => {
+			setTimeout(resolve, Math.max(init.interval, 3) * 1e3);
+		});
+		try {
+			const token = await api.devicePoll(init.deviceCode);
+			const session = {
+				accessToken: token.accessToken,
+				refreshToken: token.refreshToken,
+				deviceId: token.deviceId,
+				expiresAt: Date.now() + token.expiresIn * 1e3
+			};
+			await setStoredSession(session);
+			return session;
+		} catch (error) {
+			const code = error !== null && typeof error === "object" && "code" in error ? error.code : void 0;
+			const retryable = error !== null && typeof error === "object" && "retryable" in error ? error.retryable : false;
+			if (code === "AUTH_PENDING" || retryable) continue;
+			throw error;
+		}
+	}
+	throw new Error("Device code expired. Run login again.");
+}
+async function logout(apiFactory) {
+	const session = await getStoredSession();
+	if (session?.refreshToken) try {
+		await apiFactory(session).logoutDevice(session.refreshToken);
+	} catch {}
+	await clearStoredSession();
+}
+//#endregion
+//#region src/lib/scaffolder.ts
+const IGNORED_ROOT_ENTRIES = /* @__PURE__ */ new Set(["__MACOSX"]);
+async function streamAndExtractTemplate(downloadResponse, projectDir) {
+	if (!downloadResponse.body) throw new Error("Template response body is empty.");
+	await fs.ensureDir(projectDir);
+	const tempDir = path.join(projectDir, "..", `.create-ts-saas-tmp-${Date.now()}`);
+	const extractDir = path.join(tempDir, "extracted");
+	await fs.ensureDir(tempDir);
+	await fs.ensureDir(extractDir);
+	const zipPath = path.join(tempDir, "template.zip");
+	const writable = createWriteStream(zipPath);
+	await pipeline(Readable.fromWeb(downloadResponse.body), writable);
+	await (await unzipper.Open.file(zipPath)).extract({ path: extractDir });
+	const meaningfulEntries = (await fs.readdir(extractDir)).filter((name) => !IGNORED_ROOT_ENTRIES.has(name));
+	if (meaningfulEntries.length === 1 && meaningfulEntries[0]) {
+		const singleRoot = path.join(extractDir, meaningfulEntries[0]);
+		if ((await fs.stat(singleRoot)).isDirectory()) {
+			const children = await fs.readdir(singleRoot);
+			for (const child of children) await fs.move(path.join(singleRoot, child), path.join(projectDir, child), { overwrite: true });
+		} else await fs.move(singleRoot, path.join(projectDir, meaningfulEntries[0]), { overwrite: true });
+	} else for (const entry of meaningfulEntries) await fs.move(path.join(extractDir, entry), path.join(projectDir, entry), { overwrite: true });
+	await fs.remove(tempDir).catch(() => {});
+}
+async function writeWatermark(projectDir, payload) {
+	const pkgJsonPath = path.join(projectDir, "package.json");
+	if (await fs.pathExists(pkgJsonPath)) {
+		const pkgJson = await fs.readJson(pkgJsonPath);
+		pkgJson["create-ts-saas"] = { wId: payload["watermarkId"] || payload["issuanceId"] };
+		await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
+	}
+}
+//#endregion
+//#region src/prompts/install.ts
+async function promptInstall(defaultValue = true) {
+	const value = await confirm({
+		message: "Install dependencies now?",
+		initialValue: defaultValue
+	});
+	if (isCancel(value)) throw new Error("Operation cancelled.");
+	return value;
+}
+//#endregion
+//#region src/prompts/package-manager.ts
+async function promptPackageManager(initialValue) {
+	const value = await select({
+		message: "Select package manager",
+		options: [
+			{
+				value: "pnpm",
+				label: "pnpm"
+			},
+			{
+				value: "npm",
+				label: "npm"
+			},
+			{
+				value: "bun",
+				label: "bun"
+			}
+		],
+		initialValue
+	});
+	if (isCancel(value)) throw new Error("Operation cancelled.");
+	return value;
+}
+//#endregion
+//#region src/prompts/project-name.ts
+async function promptProjectName(initialValue = "my-saas-app") {
+	const value = await text({
+		message: "Project name",
+		initialValue,
+		validate: (input) => input?.trim() ? void 0 : "Project name is required"
+	});
+	if (isCancel(value) || typeof value !== "string") throw new Error("Operation cancelled.");
+	return value.trim();
+}
+//#endregion
+//#region src/prompts/template.ts
+async function promptTemplate(templates) {
+	const value = await select({
+		message: "Select template",
+		options: templates.map((t) => ({
+			value: t.slug,
+			label: t.slug,
+			hint: `latest ${t.latestVersion}`
+		}))
+	});
+	if (isCancel(value) || typeof value !== "string") throw new Error("Operation cancelled.");
+	const chosen = templates.find((t) => t.slug === value);
+	if (!chosen) throw new Error(`Unknown template "${value}".`);
+	return chosen;
+}
+//#endregion
+//#region src/utils/get-package-manager.ts
+function getUserPackageManager() {
+	const userAgent = process.env["npm_config_user_agent"];
+	if (userAgent?.startsWith("pnpm")) return "pnpm";
+	if (userAgent?.startsWith("bun")) return "bun";
+	return "npm";
+}
+//#endregion
+//#region src/utils/handle-cli-error.ts
+const DEBUG_FLAG = process.env["TS_SAAS_CLI_DEBUG"] === "1" || process.env["TS_SAAS_CLI_DEBUG"] === "true";
+function isNetworkError(error) {
+	if (!(error instanceof Error)) return false;
+	const cause = error.cause;
+	if (cause instanceof Error) {
+		const code = "code" in cause ? cause.code : void 0;
+		if (code === "ECONNREFUSED" || code === "ENOTFOUND" || code === "ETIMEDOUT" || code === "ECONNRESET") return true;
+	}
+	return error.message === "fetch failed";
+}
+function handleCliError(error) {
+	if (isNetworkError(error)) {
+		log.error(pc.red("Network error — could not connect to the server."));
+		if (DEBUG_FLAG) console.error(error);
+		process.exit(1);
+	}
+	if (error instanceof ApiError) {
+		log.error(pc.red(error.message));
+		if (DEBUG_FLAG) console.error(error);
+		process.exit(getExitCode(error));
+	}
+	if (error instanceof NotLoggedInError) {
+		log.info(pc.yellow(error.message));
+		process.exit(2);
+	}
+	if (error instanceof Error) {
+		log.error(pc.red(error.message || "Something went wrong"));
+		console.error(error);
+		process.exit(1);
+	}
+	console.error("Unhandled non-Error:", error);
+	log.error(pc.red(typeof error === "string" ? error : "Something went wrong"));
+	process.exit(1);
+}
+function getExitCode(error) {
+	switch (error.code) {
+		case "AUTH_EXPIRED":
+		case "AUTH_INVALID": return 2;
+		case "PLAN_FORBIDDEN": return 3;
+		case "UPGRADE_REQUIRED": return 4;
+		default: return error.status && error.status >= 500 ? 1 : 1;
+	}
+}
+//#endregion
+//#region src/utils/project-directory.ts
+async function resolveProjectDirectory(initialInput) {
+	const current = initialInput;
+	while (true) {
+		const fullPath = path.resolve(process.cwd(), current);
+		if (!(await fs.pathExists(fullPath) && (await fs.readdir(fullPath)).length > 0)) {
+			await fs.ensureDir(fullPath);
+			return {
+				projectDir: fullPath,
+				projectName: path.basename(fullPath)
+			};
+		}
+		log.warn(`Directory "${pc.yellow(current)}" already exists and is not empty.`);
+		const action = await select({
+			message: "Choose how to proceed",
+			options: [
+				{
+					value: "merge",
+					label: "Merge into existing directory"
+				},
+				{
+					value: "overwrite",
+					label: "Overwrite directory contents"
+				},
+				{
+					value: "cancel",
+					label: "Cancel"
+				}
+			],
+			initialValue: "merge"
+		});
+		if (isCancel(action) || action === "cancel") throw new Error("Operation cancelled.");
+		if (action === "merge") return {
+			projectDir: fullPath,
+			projectName: path.basename(fullPath)
+		};
+		await fs.emptyDir(fullPath);
+		return {
+			projectDir: fullPath,
+			projectName: path.basename(fullPath)
+		};
+	}
+}
+//#endregion
+//#region src/commands/init.ts
+async function initCommand(options) {
+	intro(pc.magenta("Initialize your saas..."));
+	try {
+		const config = await loadConfig();
+		const session = await ensureSession((current) => createApiClient({
+			config,
+			accessToken: current?.accessToken || null,
+			deviceId: current?.deviceId || null
+		}));
+		const api = createApiClient({
+			config,
+			accessToken: session.accessToken,
+			deviceId: session.deviceId
+		});
+		const { projectDir, projectName } = await resolveProjectDirectory(options.projectName || options.dir || await promptProjectName());
+		const templates = (await api.getTemplates()).templates;
+		if (!templates.length) throw new Error("No templates available for this account.");
+		const selectedTemplate = options.template && templates.find((template) => template.slug === options.template) ? templates.find((template) => template.slug === options.template) : await promptTemplate(templates);
+		if (!selectedTemplate) {
+			log.error(pc.red("Selected template not found."));
+			process.exit(1);
+		}
+		const s = spinner();
+		s.start("Authorizing template download...");
+		try {
+			const authz = await api.authorizeInit({ templateSlug: selectedTemplate.slug });
+			s.message("Downloading template...");
+			await streamAndExtractTemplate(await api.stream(authz.downloadUrl), projectDir);
+			await writeWatermark(projectDir, authz.watermark);
+			s.stop("Template ready.");
+		} catch (error) {
+			s.stop(pc.red("Failed to scaffold template."));
+			throw error;
+		}
+		const packageManager = options.packageManager || await promptPackageManager(getUserPackageManager());
+		if (options.install || (options.yes ? true : await promptInstall(true))) {
+			s.start(`Running ${packageManager} install...`);
+			await $({
+				cwd: projectDir,
+				stderr: "inherit"
+			})`${packageManager} install`;
+			s.stop("Dependencies installed.");
+		}
+		if (options.git || (options.yes ? true : await confirm({
+			message: "Initialize git?",
+			initialValue: true
+		}))) try {
+			await $({
+				cwd: projectDir,
+				stderr: "ignore",
+				stdout: "ignore"
+			})`git init`;
+		} catch {
+			log.warn("Git init failed. Continuing without repository setup.");
+		}
+		log.success(pc.green(`Project created at ${projectDir}`));
+		note([
+			`cd ${path.basename(projectDir)}`,
+			``,
+			`Copy ${pc.cyan(".env.example")} → ${pc.cyan(".env")} and fill in your values`,
+			`Run ${pc.cyan(`${packageManager} db:migrate`)} to set up the database`,
+			`Run ${pc.cyan(`${packageManager} db:seed`)} to seed initial data`,
+			`Run ${pc.cyan(`${packageManager} dev`)} to start`
+		].join("\n"), `Next steps (${projectName})`);
+	} catch (error) {
+		handleCliError(error);
+	}
+}
+//#endregion
+//#region src/commands/login.ts
+async function loginCommand() {
+	intro(pc.magenta("Login to ts-saas"));
+	try {
+		await loginWithDeviceFlow(createApiClient({ config: await loadConfig() }));
+		log.success(pc.green("Logged in successfully."));
+	} catch (error) {
+		handleCliError(error);
+	}
+}
+//#endregion
+//#region src/commands/logout.ts
+async function logoutCommand() {
+	intro(pc.magenta("Logout from create-ts-saas"));
+	try {
+		if (!await getStoredSession()) {
+			log.info(pc.yellow("No active session."));
+			return;
+		}
+		const config = await loadConfig();
+		await logout((current) => createApiClient({
+			config,
+			accessToken: current?.accessToken || null,
+			deviceId: current?.deviceId || null
+		}));
+		log.success(pc.green("Logged out and local session cleared."));
+	} catch (error) {
+		handleCliError(error);
+	}
+}
+//#endregion
+//#region src/commands/upgrade.ts
+async function upgradeCommand() {
+	intro(pc.magenta("Checking for updates"));
+	const latest = await createApiClient({ config: await loadConfig() }).getLatestVersion();
+	const current = getCliVersion();
+	if (latest.version !== current) {
+		log.warn(pc.yellow(`Update available: current ${current}, latest ${latest.version}. Run: npx create-ts-saas@latest`));
+		return;
+	}
+	log.success(pc.green(`You are on latest version (${current}).`));
+}
+//#endregion
+//#region src/commands/whoami.ts
+async function whoamiCommand() {
+	intro(pc.magenta("Current CLI account"));
+	try {
+		const config = await loadConfig();
+		if (!(await getStoredSession())?.refreshToken) {
+			log.info(pc.yellow(NOT_LOGGED_IN_MESSAGE));
+			return;
+		}
+		const session = await requireSession((current) => createApiClient({
+			config,
+			accessToken: current?.accessToken || null,
+			deviceId: current?.deviceId || null
+		}));
+		const data = await createApiClient({
+			config,
+			accessToken: session.accessToken,
+			deviceId: session.deviceId
+		}).me();
+		const lastInit = data.lastInitAt ? new Date(data.lastInitAt).toLocaleString() : "never";
+		note([
+			`Email: ${data.email}`,
+			`Plan: ${data.plan}`,
+			`Active devices: ${data.activeDevices}`,
+			`Last init: ${lastInit}`
+		].join("\n"), "Account");
+		log.success(pc.green("Account lookup completed."));
+	} catch (error) {
+		handleCliError(error);
+	}
+}
+//#endregion
+//#region src/index.ts
+const createInputSchema = z.tuple([z.string().optional(), z.object({
+	dir: z.string().optional(),
+	yes: z.boolean().optional().default(false),
+	template: z.string().optional(),
+	packageManager: z.enum([
+		"npm",
+		"pnpm",
+		"bun"
+	]).optional(),
+	install: z.boolean().optional(),
+	git: z.boolean().optional()
+})]);
+async function runCreateCommand({ input }) {
+	const [projectName, options] = input;
+	await initCommand({ ...projectName ? {
+		...options,
+		projectName
+	} : options });
+}
+const router = os.router({
+	create: os.meta({
+		description: "Create a new project from your paid SaaS template",
+		default: true,
+		negateBooleans: true
+	}).input(createInputSchema).handler(runCreateCommand),
+	init: os.meta({ description: "Alias for create command" }).input(createInputSchema).handler(runCreateCommand),
+	login: os.meta({ description: "Login with device flow" }).handler(async () => {
+		await loginCommand();
+	}),
+	logout: os.meta({ description: "Logout and clear local auth session" }).handler(async () => {
+		await logoutCommand();
+	}),
+	doctor: os.meta({ description: "Run local environment checks" }).handler(async () => {
+		await doctorCommand();
+	}),
+	whoami: os.meta({ description: "Show authenticated account details" }).handler(async () => {
+		await whoamiCommand();
+	}),
+	upgrade: os.meta({ description: "Check CLI version status" }).handler(async () => {
+		await upgradeCommand();
+	})
+});
+function createCliApp() {
+	return createCli({
+		router,
+		name: "create-ts-saas",
+		version: getCliVersion()
+	});
+}
+async function runCli() {
+	try {
+		await createCliApp().run();
+	} catch (error) {
+		handleCliError(error);
+	}
+}
+//#endregion
+//#region src/cli.ts
+runCli();
+//#endregion
+export {};