create-ts-saas 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -1,3 +1,793 @@
-#!/usr/bin/env node
-import { n as runCli, t as router } from "./src-D4guDFsb.mjs";
+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.2";
+}
+function getCliPlatform() {
+	return `${process.platform}-${process.arch}`;
+}
+//#endregion
+//#region src/lib/api.ts
+var ApiError = class extends Error {
+	constructor(code, message, retryable = false, status, minCliVersion) {
+		super(message);
+		this.code = code;
+		this.retryable = retryable;
+		this.status = status;
+		this.minCliVersion = minCliVersion;
+		this.name = "ApiError";
+	}
+};
+function parseApiErrorBody(text) {
+	try {
+		const data = JSON.parse(text);
+		if (typeof data.code === "string" && typeof data.message === "string") return {
+			code: data.code,
+			message: data.message,
+			retryable: Boolean(data.retryable)
+		};
+		const nested = data.error;
+		if (nested && typeof nested.code === "string" && typeof nested.message === "string") return {
+			code: nested.code,
+			message: nested.message,
+			retryable: Boolean(data.retryable)
+		};
+	} catch {}
+	return null;
+}
+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 = new Headers(init.headers);
+		headers.set("Accept", "application/json");
+		headers.set("x-cli-version", cliVersion);
+		headers.set("x-cli-platform", cliPlatform);
+		if (deviceId) headers.set("x-cli-device-id", deviceId);
+		if (accessToken) headers.set("Authorization", `Bearer ${accessToken}`);
+		let res;
+		try {
+			res = await fetch(url, {
+				...init,
+				headers
+			});
+		} catch {
+			throw new ApiError("NETWORK_ERROR", "Network error — could not connect to the server.", true);
+		}
+		const minCli = res.headers.get("x-min-supported-cli");
+		if (minCli && semver.valid(cliVersion) && semver.valid(minCli) && semver.lt(cliVersion, minCli)) throw new ApiError("UPGRADE_REQUIRED", `CLI version ${cliVersion} is below minimum supported ${minCli}. Please upgrade.`, false, res.status, minCli);
+		const text = await res.text();
+		if (!res.ok) {
+			const body = parseApiErrorBody(text);
+			throw new ApiError(body?.code ?? (res.status === 401 ? "AUTH_INVALID" : "REQUEST_FAILED"), body?.message ?? res.statusText, body?.retryable ?? false, res.status, minCli ?? void 0);
+		}
+		if (!text) return {};
+		return JSON.parse(text);
+	}
+	async function stream(url) {
+		const headers = new Headers();
+		headers.set("x-cli-version", cliVersion);
+		headers.set("x-cli-platform", cliPlatform);
+		if (deviceId) headers.set("x-cli-device-id", deviceId);
+		if (accessToken) headers.set("Authorization", `Bearer ${accessToken}`);
+		let res;
+		try {
+			res = await fetch(url, { headers });
+		} catch {
+			throw new ApiError("NETWORK_ERROR", "Network error — could not connect to the server.", true);
+		}
+		if (!res.ok) {
+			const body = parseApiErrorBody(await res.text());
+			throw new ApiError(body?.code ?? "DOWNLOAD_FAILED", body?.message ?? "Template download failed", false, 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/constants.ts
+const DEFAULT_API_BASE_URL = "https://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://api.ts-saas.com/api/v1",
+				disableTelemetry: data.disableTelemetry ?? fromEnv.disableTelemetry ?? false
+			};
+		}
+	} catch {}
+	return {
+		apiBaseUrl: fromEnv.apiBaseUrl ?? "https://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;
+}
+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 e = error;
+			if (e.code === "AUTH_PENDING" || e.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 = 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.name} (${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/prompts/variant.ts
+async function promptVariant(template) {
+	const first = template.variants[0];
+	if (!first) throw new Error(`Template "${template.slug}" has no variants.`);
+	const value = await select({
+		message: "Select variant",
+		options: template.variants.map((v) => ({
+			value: v.slug,
+			label: v.name,
+			hint: v.slug
+		})),
+		initialValue: first.slug
+	});
+	if (isCancel(value) || typeof value !== "string") throw new Error("Operation cancelled.");
+	return value;
+}
+//#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 = cause.code;
+		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 Error) {
+		log.error(pc.red(error.message || "Something went wrong"));
+		if (DEBUG_FLAG) console.error(error);
+		process.exit(1);
+	}
+	log.error(pc.red("Something went wrong"));
+	if (DEBUG_FLAG) console.error(error);
+	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 selectedVariant = options.variant && selectedTemplate.variants.some((variant) => variant.slug === options.variant) ? options.variant : await promptVariant(selectedTemplate);
+		const s = spinner();
+		s.start("Authorizing template download...");
+		try {
+			const authz = await api.authorizeInit({
+				templateSlug: selectedTemplate.slug,
+				variantSlug: selectedVariant
+			});
+			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} 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"));
+	const config = await loadConfig();
+	await logout((session) => createApiClient({
+		config,
+		accessToken: session?.accessToken ?? null,
+		deviceId: session?.deviceId ?? null
+	}));
+	log.success(pc.green("Logged out and local session cleared."));
+}
+//#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();
+		const session = await ensureSession((current) => createApiClient({
+			config,
+			accessToken: current?.accessToken ?? null,
+			deviceId: current?.deviceId ?? null
+		}));
+		const data = await createApiClient({
+			config,
+			accessToken: session.accessToken,
+			deviceId: session.deviceId
+		}).me();
+		note(`Email: ${data.email}\nPlan: ${data.plan}\nActive devices: ${data.activeDevices}\nTemplates: ${data.templates.join(", ") || "none"}`, "Account");
+		log.success(pc.green("Account lookup completed."));
+	} catch (error) {
+		handleCliError(error);
+	}
+}
+//#endregion
+//#region src/index.ts
+const router = os.router({
+	create: os.meta({
+		description: "Create a new project from your paid SaaS template",
+		default: true,
+		negateBooleans: true
+	}).input(z.tuple([z.string().optional(), z.object({
+		dir: z.string().optional(),
+		yes: z.boolean().optional().default(false),
+		template: z.string().optional(),
+		variant: z.string().optional(),
+		packageManager: z.enum([
+			"npm",
+			"pnpm",
+			"bun"
+		]).optional(),
+		install: z.boolean().optional(),
+		git: z.boolean().optional()
+	})])).handler(async ({ input }) => {
+		const [projectName, options] = input;
+		await initCommand({ ...projectName ? {
+			...options,
+			projectName
+		} : options });
+	}),
+	init: os.meta({ description: "Alias for create command" }).input(z.tuple([z.string().optional(), z.object({
+		dir: z.string().optional(),
+		yes: z.boolean().optional().default(false),
+		template: z.string().optional(),
+		variant: z.string().optional(),
+		packageManager: z.enum([
+			"npm",
+			"pnpm",
+			"bun"
+		]).optional(),
+		install: z.boolean().optional(),
+		git: z.boolean().optional()
+	})])).handler(async ({ input }) => {
+		const [projectName, options] = input;
+		await initCommand({ ...projectName ? {
+			...options,
+			projectName
+		} : options });
+	}),
+	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
 export { router, runCli };
+
+//# sourceMappingURL=index.mjs.map