@kuckit/cli 0.1.0

package/dist/bin.js

@@ -0,0 +1,784 @@
+#!/usr/bin/env node
+import { n as addModule, r as generateModule, t as discoverModules } from "./discover-module-DpVX5MIS.js";
+import { program } from "commander";
+import { dirname, join } from "node:path";
+import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { tryLoadKuckitConfig } from "@kuckit/sdk";
+import { spawn } from "child_process";
+import { access, constants as constants$1, mkdir, readFile, writeFile } from "fs/promises";
+import { dirname as dirname$1, join as join$1 } from "path";
+import { homedir } from "node:os";
+
+//#region src/commands/doctor.ts
+const CONFIG_FILES = [
+	"kuckit.config.ts",
+	"kuckit.config.js",
+	"kuckit.config.mjs"
+];
+function findConfigFile(cwd) {
+	let dir = cwd;
+	while (dir !== dirname(dir)) {
+		for (const file of CONFIG_FILES) {
+			const configPath = join(dir, file);
+			if (existsSync(configPath)) return configPath;
+		}
+		dir = dirname(dir);
+	}
+	return null;
+}
+function readPackageJson(packageName, cwd) {
+	const locations = [
+		join(cwd, "node_modules", packageName, "package.json"),
+		join(cwd, "apps", "server", "node_modules", packageName, "package.json"),
+		join(cwd, "apps", "web", "node_modules", packageName, "package.json")
+	];
+	const packageDir = packageName.startsWith("@") ? packageName.split("/")[1] : packageName;
+	locations.push(join(cwd, "packages", packageDir, "package.json"));
+	for (const location of locations) try {
+		const content = readFileSync(location, "utf-8");
+		const pkg = JSON.parse(content);
+		if (pkg.name === packageName) return pkg;
+	} catch {}
+	return null;
+}
+function findPackagePath(packageName, cwd) {
+	const locations = [
+		join(cwd, "node_modules", packageName),
+		join(cwd, "apps", "server", "node_modules", packageName),
+		join(cwd, "apps", "web", "node_modules", packageName)
+	];
+	const packageDir = packageName.startsWith("@") ? packageName.split("/")[1] : packageName;
+	locations.push(join(cwd, "packages", packageDir));
+	for (const location of locations) if (existsSync(location)) {
+		const pkgJsonPath = join(location, "package.json");
+		if (existsSync(pkgJsonPath)) try {
+			const content = readFileSync(pkgJsonPath, "utf-8");
+			if (JSON.parse(content).name === packageName) return location;
+		} catch {}
+	}
+	return null;
+}
+function checkModuleExports(packageName, cwd) {
+	const result = {
+		server: false,
+		client: false
+	};
+	const packagePath = findPackagePath(packageName, cwd);
+	if (!packagePath) return result;
+	result.server = [
+		join(packagePath, "dist", "server", "module.js"),
+		join(packagePath, "dist", "index.js"),
+		join(packagePath, "src", "server", "module.ts"),
+		join(packagePath, "src", "module.ts")
+	].some((p) => existsSync(p));
+	result.client = [
+		join(packagePath, "dist", "client", "index.js"),
+		join(packagePath, "src", "client", "index.tsx"),
+		join(packagePath, "src", "client", "index.ts")
+	].some((p) => existsSync(p));
+	return result;
+}
+async function loadConfig$1(configPath) {
+	try {
+		if (configPath.endsWith(".ts")) {
+			const { createJiti } = await import("jiti");
+			const loaded = await createJiti(process.cwd(), { interopDefault: true }).import(configPath);
+			return {
+				success: true,
+				config: loaded.default ?? loaded
+			};
+		} else {
+			const loaded = await import(configPath);
+			return {
+				success: true,
+				config: loaded.default ?? loaded
+			};
+		}
+	} catch (err) {
+		return {
+			success: false,
+			error: err instanceof Error ? err.message : String(err)
+		};
+	}
+}
+async function doctor(options) {
+	const cwd = process.cwd();
+	const checks = [];
+	if (!options.json) console.log("\nKuckit Doctor - Checking your setup...\n");
+	const configPath = findConfigFile(cwd);
+	if (configPath) checks.push({
+		name: "config-exists",
+		status: "pass",
+		message: `Config file found: ${configPath.replace(cwd, ".")}`
+	});
+	else checks.push({
+		name: "config-exists",
+		status: "warn",
+		message: "No kuckit.config.ts found (using legacy config)"
+	});
+	let configModules = [];
+	if (configPath) {
+		const { success, config, error } = await loadConfig$1(configPath);
+		if (success && config && typeof config === "object") {
+			const cfg = config;
+			if (Array.isArray(cfg.modules)) {
+				checks.push({
+					name: "config-valid",
+					status: "pass",
+					message: "Configuration is valid"
+				});
+				configModules = cfg.modules;
+			} else checks.push({
+				name: "config-valid",
+				status: "fail",
+				message: "Configuration invalid: 'modules' must be an array"
+			});
+		} else checks.push({
+			name: "config-valid",
+			status: "fail",
+			message: `Configuration failed to load: ${error}`
+		});
+	}
+	const enabledModules = configModules.filter((m) => m.package && !m.disabled);
+	if (enabledModules.length > 0) {
+		const moduleDetails = enabledModules.map((m) => `  - ${m.package} ${m.disabled ? "(disabled)" : "(enabled)"}`);
+		checks.push({
+			name: "modules-configured",
+			status: "pass",
+			message: `${enabledModules.length} module(s) configured`,
+			details: moduleDetails
+		});
+	} else if (configModules.length > 0) checks.push({
+		name: "modules-configured",
+		status: "warn",
+		message: "All configured modules are disabled"
+	});
+	else checks.push({
+		name: "modules-configured",
+		status: "warn",
+		message: "No modules configured"
+	});
+	const missingPackages = [];
+	const installedPackages = [];
+	for (const mod of enabledModules) {
+		if (!mod.package) continue;
+		if (readPackageJson(mod.package, cwd)) installedPackages.push(mod.package);
+		else missingPackages.push(mod.package);
+	}
+	if (missingPackages.length > 0) checks.push({
+		name: "packages-installed",
+		status: "fail",
+		message: `${missingPackages.length} package(s) not installed`,
+		details: missingPackages.map((p) => `  - ${p} (missing)`)
+	});
+	else if (installedPackages.length > 0) checks.push({
+		name: "packages-installed",
+		status: "pass",
+		message: "All module packages installed"
+	});
+	const invalidMetadata = [];
+	const validMetadata = [];
+	for (const packageName of installedPackages) if (!readPackageJson(packageName, cwd)?.kuckit?.id) invalidMetadata.push(`${packageName} (missing kuckit.id)`);
+	else validMetadata.push(packageName);
+	if (invalidMetadata.length > 0) checks.push({
+		name: "metadata-valid",
+		status: "warn",
+		message: `${invalidMetadata.length} package(s) with invalid/missing kuckit metadata`,
+		details: invalidMetadata.map((p) => `  - ${p}`)
+	});
+	else if (validMetadata.length > 0) checks.push({
+		name: "metadata-valid",
+		status: "pass",
+		message: "All modules have valid kuckit metadata"
+	});
+	const missingExports = [];
+	const validExports = [];
+	for (const packageName of validMetadata) {
+		const pkgJson = readPackageJson(packageName, cwd);
+		const exports = checkModuleExports(packageName, cwd);
+		if (!exports.server && pkgJson?.kuckit?.server) missingExports.push(`${packageName} (server export not built)`);
+		else if (!exports.client && pkgJson?.kuckit?.client) missingExports.push(`${packageName} (client export not built)`);
+		else validExports.push(packageName);
+	}
+	if (missingExports.length > 0) checks.push({
+		name: "exports-valid",
+		status: "warn",
+		message: `${missingExports.length} module(s) may need building`,
+		details: missingExports.map((p) => `  - ${p}`)
+	});
+	else if (validExports.length > 0) checks.push({
+		name: "exports-valid",
+		status: "pass",
+		message: "Module exports valid"
+	});
+	const sdkPackages = ["@kuckit/sdk", "@kuckit/sdk-react"];
+	const missingSdk = [];
+	for (const sdk of sdkPackages) if (!readPackageJson(sdk, cwd)) missingSdk.push(sdk);
+	if (missingSdk.length > 0) checks.push({
+		name: "sdk-installed",
+		status: "warn",
+		message: `SDK package(s) not found: ${missingSdk.join(", ")}`
+	});
+	else checks.push({
+		name: "sdk-installed",
+		status: "pass",
+		message: "SDK packages installed"
+	});
+	const report = {
+		success: checks.every((c) => c.status !== "fail"),
+		checks,
+		summary: {
+			total: checks.length,
+			passed: checks.filter((c) => c.status === "pass").length,
+			failed: checks.filter((c) => c.status === "fail").length,
+			warnings: checks.filter((c) => c.status === "warn").length
+		}
+	};
+	if (options.json) console.log(JSON.stringify(report, null, 2));
+	else {
+		for (const check of checks) {
+			const icon = check.status === "pass" ? "✓" : check.status === "fail" ? "✗" : "!";
+			const color = check.status === "pass" ? "\x1B[32m" : check.status === "fail" ? "\x1B[31m" : "\x1B[33m";
+			console.log(`${color}${icon} ${check.message}`);
+			if (check.details) for (const detail of check.details) console.log(`  ${detail}`);
+		}
+		console.log("");
+		if (report.success) if (report.summary.warnings > 0) console.log(`All checks passed with ${report.summary.warnings} warning(s). Run 'kuckit doctor --json' for details.`);
+		else console.log("All checks passed!");
+		else {
+			console.log(`${report.summary.failed} check(s) failed. Please fix the issues above and run 'kuckit doctor' again.`);
+			process.exit(1);
+		}
+	}
+}
+
+//#endregion
+//#region src/commands/search.ts
+const NPM_REGISTRY_SEARCH = "https://registry.npmjs.org/-/v1/search";
+function scoreToStars(score) {
+	const normalizedScore = score > 1 ? score / 100 : score;
+	const safeScore = Math.max(0, Math.min(1, normalizedScore || 0));
+	const filled = Math.round(safeScore * 5);
+	return "★".repeat(filled) + "☆".repeat(5 - filled);
+}
+function truncate(str, maxLen) {
+	if (str.length <= maxLen) return str;
+	return str.slice(0, maxLen - 3) + "...";
+}
+async function searchNpm(query, limit) {
+	const url = new URL(NPM_REGISTRY_SEARCH);
+	url.searchParams.set("text", query);
+	url.searchParams.set("size", String(Math.min(limit, 250)));
+	const response = await fetch(url.toString(), { headers: { Accept: "application/json" } });
+	if (!response.ok) throw new Error(`npm registry returned ${response.status}: ${response.statusText}`);
+	return await response.json();
+}
+function isLikelyKuckitModule(pkg) {
+	return (pkg.keywords ?? []).some((k) => k.toLowerCase().includes("kuckit")) || pkg.name.toLowerCase().includes("kuckit");
+}
+function formatResult(result) {
+	const pkg = result.package;
+	return {
+		name: pkg.name,
+		version: pkg.version,
+		description: pkg.description ?? "",
+		score: result.score.final,
+		stars: scoreToStars(result.score.final),
+		isKuckitModule: isLikelyKuckitModule(pkg),
+		npm: pkg.links?.npm,
+		homepage: pkg.links?.homepage
+	};
+}
+async function search(keyword, options) {
+	if (!keyword.trim()) {
+		console.error("Error: Please provide a search keyword");
+		process.exit(1);
+	}
+	try {
+		let response = await searchNpm(`keywords:kuckit-module ${keyword}`, options.limit);
+		let fallback = false;
+		if (response.objects.length === 0) {
+			fallback = true;
+			response = await searchNpm(`kuckit ${keyword}`, options.limit);
+		}
+		const results = response.objects.map(formatResult);
+		const report = {
+			query: keyword,
+			total: results.length,
+			results
+		};
+		if (options.json) {
+			console.log(JSON.stringify(report, null, 2));
+			return;
+		}
+		if (results.length === 0) {
+			console.log(`No Kuckit modules found for "${keyword}"`);
+			console.log("\nTips:");
+			console.log("  - Try different keywords");
+			console.log("  - Check npm directly: npm search kuckit");
+			console.log("  - Create your own: kuckit generate module <name>");
+			return;
+		}
+		console.log(`\nResults for "${keyword}"${fallback ? " (broad search)" : ""}:\n`);
+		const maxNameLen = Math.min(40, Math.max(...results.map((r) => r.name.length)));
+		const maxVerLen = Math.max(...results.map((r) => r.version.length));
+		for (const result of results) {
+			const name = result.name.padEnd(maxNameLen);
+			const version = `v${result.version}`.padEnd(maxVerLen + 1);
+			const desc = truncate(result.description, 50);
+			const kuckitBadge = result.isKuckitModule ? "" : " [?]";
+			console.log(`  ${name}  ${version}  ${result.stars}  ${desc}${kuckitBadge}`);
+		}
+		console.log(`\n${results.length} package${results.length === 1 ? "" : "s"} found`);
+		if (results.some((r) => !r.isKuckitModule)) console.log("\n[?] = May not be a Kuckit module (verify before installing)");
+		if (results.length > 0) console.log(`\nInstall: kuckit add ${results[0].name}`);
+	} catch (error) {
+		if (options.json) console.log(JSON.stringify({
+			error: error instanceof Error ? error.message : "Unknown error",
+			query: keyword,
+			total: 0,
+			results: []
+		}));
+		else console.error(`Error searching npm registry: ${error instanceof Error ? error.message : error}`);
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/commands/db.ts
+const KUCKIT_DIR = ".kuckit";
+const TEMP_CONFIG_NAME = "drizzle.config.ts";
+async function fileExists(path) {
+	try {
+		await access(path, constants$1.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function findProjectRoot(cwd) {
+	let dir = cwd;
+	while (dir !== dirname$1(dir)) {
+		if (await fileExists(join$1(dir, "package.json"))) return dir;
+		dir = dirname$1(dir);
+	}
+	return null;
+}
+async function getDatabaseUrl(cwd, options) {
+	if (options.url) return options.url;
+	if (process.env.DATABASE_URL) return process.env.DATABASE_URL;
+	const envPaths = [
+		join$1(cwd, ".env"),
+		join$1(cwd, "apps", "server", ".env"),
+		join$1(cwd, ".env.local")
+	];
+	for (const envPath of envPaths) if (await fileExists(envPath)) try {
+		const match = (await readFile(envPath, "utf-8")).match(/^DATABASE_URL=(.+)$/m);
+		if (match) return match[1].replace(/^["']|["']$/g, "");
+	} catch {}
+	return null;
+}
+async function discoverModuleSchemas(cwd) {
+	const schemas = [];
+	const config = await tryLoadKuckitConfig(cwd);
+	if (!config) return schemas;
+	for (const moduleSpec of config.modules) {
+		if (moduleSpec.disabled) continue;
+		let packagePath = null;
+		let moduleId = null;
+		if (moduleSpec.package) {
+			const workspacePath = join$1(cwd, "packages", moduleSpec.package.replace(/^@[^/]+\//, ""));
+			if (await fileExists(join$1(workspacePath, "package.json"))) packagePath = workspacePath;
+			else {
+				const nodeModulesPath = join$1(cwd, "node_modules", moduleSpec.package);
+				if (await fileExists(join$1(nodeModulesPath, "package.json"))) packagePath = nodeModulesPath;
+			}
+			if (packagePath) try {
+				moduleId = JSON.parse(await readFile(join$1(packagePath, "package.json"), "utf-8")).kuckit?.id || moduleSpec.package;
+			} catch {
+				moduleId = moduleSpec.package;
+			}
+		}
+		if (!packagePath) continue;
+		const schemaLocations = [
+			join$1(packagePath, "src", "server", "schema", "index.ts"),
+			join$1(packagePath, "src", "server", "schema.ts"),
+			join$1(packagePath, "src", "schema", "index.ts"),
+			join$1(packagePath, "src", "schema.ts")
+		];
+		for (const schemaPath of schemaLocations) if (await fileExists(schemaPath)) {
+			schemas.push({
+				moduleId: moduleId || "unknown",
+				schemaPath
+			});
+			break;
+		}
+	}
+	const centralSchemaPath = join$1(cwd, "packages", "db", "src", "schema");
+	if (await fileExists(centralSchemaPath)) schemas.push({
+		moduleId: "core",
+		schemaPath: centralSchemaPath
+	});
+	return schemas;
+}
+async function generateTempDrizzleConfig(cwd, databaseUrl, schemas) {
+	const kuckitDir = join$1(cwd, KUCKIT_DIR);
+	await mkdir(kuckitDir, { recursive: true });
+	const configPath = join$1(kuckitDir, TEMP_CONFIG_NAME);
+	const schemaPaths = schemas.map((s) => s.schemaPath);
+	await writeFile(configPath, `import { defineConfig } from 'drizzle-kit'
+
+export default defineConfig({
+	schema: ${JSON.stringify(schemaPaths)},
+	out: './drizzle',
+	dialect: 'postgresql',
+	dbCredentials: {
+		url: ${JSON.stringify(databaseUrl)},
+	},
+})
+`, "utf-8");
+	return configPath;
+}
+function runDrizzleKit(command, configPath, cwd) {
+	return new Promise((resolve) => {
+		const proc = spawn("npx", ["drizzle-kit", ...[
+			command,
+			"--config",
+			configPath
+		]], {
+			cwd,
+			stdio: [
+				"inherit",
+				"pipe",
+				"pipe"
+			],
+			shell: true
+		});
+		let stdout = "";
+		let stderr = "";
+		proc.stdout?.on("data", (data) => {
+			stdout += data.toString();
+			process.stdout.write(data);
+		});
+		proc.stderr?.on("data", (data) => {
+			stderr += data.toString();
+			process.stderr.write(data);
+		});
+		proc.on("close", (code) => {
+			resolve({
+				code: code ?? 1,
+				stdout,
+				stderr
+			});
+		});
+	});
+}
+async function runDbCommand(command, options) {
+	const projectRoot = await findProjectRoot(process.cwd());
+	if (!projectRoot) {
+		console.error("Error: Could not find project root (no package.json found)");
+		process.exit(1);
+	}
+	const databaseUrl = await getDatabaseUrl(projectRoot, options);
+	if (!databaseUrl) {
+		console.error("Error: DATABASE_URL not found");
+		console.error("Set it via:");
+		console.error("  - --url flag: kuckit db push --url postgres://...");
+		console.error("  - Environment variable: DATABASE_URL=postgres://...");
+		console.error("  - .env file in project root or apps/server/");
+		process.exit(1);
+	}
+	console.log("Discovering module schemas...");
+	const schemas = await discoverModuleSchemas(projectRoot);
+	if (schemas.length === 0) {
+		console.error("Error: No schemas found");
+		console.error("Make sure your modules have schemas in one of these locations:");
+		console.error("  - src/server/schema/index.ts");
+		console.error("  - src/server/schema.ts");
+		console.error("  - src/schema/index.ts");
+		console.error("  - src/schema.ts");
+		process.exit(1);
+	}
+	console.log(`Found ${schemas.length} schema source(s):`);
+	for (const schema of schemas) console.log(`  - ${schema.moduleId}: ${schema.schemaPath}`);
+	const configPath = await generateTempDrizzleConfig(projectRoot, databaseUrl, schemas);
+	console.log(`Generated drizzle config: ${configPath}`);
+	console.log("");
+	const result = await runDrizzleKit(command, configPath, projectRoot);
+	if (result.code !== 0) process.exit(result.code);
+}
+async function dbPush(options) {
+	await runDbCommand("push", options);
+}
+async function dbGenerate(options) {
+	await runDbCommand("generate", options);
+}
+async function dbStudio(options) {
+	await runDbCommand("studio", options);
+}
+
+//#endregion
+//#region src/lib/credentials.ts
+const DEFAULT_SERVER_URL = "http://localhost:3000";
+const CONFIG_DIR = join(homedir(), ".kuckit");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function loadConfig() {
+	try {
+		if (!existsSync(CONFIG_PATH)) return null;
+		const content = readFileSync(CONFIG_PATH, "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return null;
+	}
+}
+function saveConfig(config) {
+	if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, {
+		recursive: true,
+		mode: 448
+	});
+	writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 384 });
+	chmodSync(CONFIG_PATH, 384);
+}
+function clearConfig() {
+	try {
+		if (existsSync(CONFIG_PATH)) unlinkSync(CONFIG_PATH);
+	} catch {}
+}
+function getServerUrl(config, override) {
+	return override ?? config?.serverUrl ?? DEFAULT_SERVER_URL;
+}
+function isTokenExpired(config) {
+	if (!config.tokenExpiresAt) return false;
+	return new Date(config.tokenExpiresAt) < /* @__PURE__ */ new Date();
+}
+
+//#endregion
+//#region src/commands/auth.ts
+async function openBrowser(url) {
+	try {
+		await (await import("open")).default(url);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatExpiryDate(expiresAt) {
+	return new Date(expiresAt).toLocaleDateString("en-US", {
+		year: "numeric",
+		month: "long",
+		day: "numeric",
+		hour: "2-digit",
+		minute: "2-digit"
+	});
+}
+async function authLogin(options) {
+	const config = loadConfig();
+	const serverUrl = getServerUrl(config, options.server);
+	const scopes = options.scopes?.split(",").map((s) => s.trim()) ?? ["cli"];
+	console.log("\nAuthenticating with Kuckit...\n");
+	let initResponse;
+	try {
+		const response = await fetch(`${serverUrl}/rpc/cliDevice/initiate`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ json: { scopes } })
+		});
+		if (!response.ok) {
+			const error = await response.json().catch(() => ({}));
+			console.error("Failed to initiate authentication:", error.message ?? response.statusText);
+			process.exit(1);
+		}
+		initResponse = (await response.json()).json;
+	} catch (err) {
+		console.error("Failed to connect to server:", err instanceof Error ? err.message : String(err));
+		console.error(`\nMake sure the server is running at ${serverUrl}`);
+		process.exit(1);
+	}
+	const { deviceCode, userCode, verificationUrl, intervalSec } = initResponse;
+	console.log("┌─────────────────────────────────────┐");
+	console.log("│                                     │");
+	console.log("│   Enter this code in your browser   │");
+	console.log("│                                     │");
+	console.log(`│            ${userCode}             │`);
+	console.log("│                                     │");
+	console.log("└─────────────────────────────────────┘");
+	console.log("");
+	console.log(`Open: ${verificationUrl}`);
+	console.log("");
+	if (await openBrowser(verificationUrl)) console.log("Browser opened automatically.");
+	else console.log("Could not open browser. Please open the URL manually.");
+	console.log("\nWaiting for authorization...\n");
+	const pollIntervalMs = intervalSec * 1e3;
+	let attempts = 0;
+	const maxAttempts = 120;
+	while (attempts < maxAttempts) {
+		await sleep(pollIntervalMs);
+		attempts++;
+		try {
+			const response = await fetch(`${serverUrl}/rpc/cliDevice/poll`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ json: { deviceCode } })
+			});
+			if (!response.ok) {
+				const error = await response.json().catch(() => ({}));
+				console.error("Poll failed:", error.message ?? response.statusText);
+				continue;
+			}
+			const pollResult = (await response.json()).json;
+			switch (pollResult.status) {
+				case "pending":
+					process.stdout.write(".");
+					continue;
+				case "approved": {
+					console.log("\n");
+					if (!pollResult.token || !pollResult.expiresIn) {
+						console.error("Authorization succeeded but no token received.");
+						process.exit(1);
+					}
+					const expiresAt = new Date(Date.now() + pollResult.expiresIn * 1e3).toISOString();
+					saveConfig({
+						...config,
+						cliToken: pollResult.token,
+						tokenExpiresAt: expiresAt,
+						serverUrl
+					});
+					console.log("✓ Successfully authenticated!");
+					console.log(`  Token expires: ${formatExpiryDate(expiresAt)}`);
+					console.log("");
+					return;
+				}
+				case "denied":
+					console.log("\n");
+					console.error("Authorization was denied.");
+					process.exit(1);
+					break;
+				case "expired":
+					console.log("\n");
+					console.error("Authorization request expired. Please try again.");
+					process.exit(1);
+					break;
+			}
+		} catch {
+			process.stdout.write("x");
+		}
+	}
+	console.log("\n");
+	console.error("Authorization timed out. Please try again.");
+	process.exit(1);
+}
+async function authWhoami(options) {
+	const config = loadConfig();
+	if (!config?.cliToken) {
+		if (options.json) console.log(JSON.stringify({ authenticated: false }));
+		else console.log("Not logged in. Run 'kuckit auth login' to authenticate.");
+		return;
+	}
+	if (isTokenExpired(config)) {
+		if (options.json) console.log(JSON.stringify({
+			authenticated: false,
+			reason: "token_expired"
+		}));
+		else console.log("Your session has expired. Run 'kuckit auth login' to sign in again.");
+		return;
+	}
+	if (options.json) console.log(JSON.stringify({
+		authenticated: true,
+		userId: config.userId,
+		userName: config.userName,
+		serverUrl: config.serverUrl,
+		tokenExpiresAt: config.tokenExpiresAt
+	}));
+	else {
+		console.log("\nAuthenticated");
+		if (config.userName) console.log(`  User: ${config.userName}`);
+		if (config.userId) console.log(`  ID: ${config.userId}`);
+		if (config.serverUrl) console.log(`  Server: ${config.serverUrl}`);
+		if (config.tokenExpiresAt) console.log(`  Token expires: ${formatExpiryDate(config.tokenExpiresAt)}`);
+		console.log("");
+	}
+}
+async function authLogout() {
+	if (!loadConfig()?.cliToken) {
+		console.log("Already logged out.");
+		return;
+	}
+	clearConfig();
+	console.log("Logged out successfully.");
+}
+function registerAuthCommands(program$1) {
+	const auth = program$1.command("auth").description("Manage CLI authentication");
+	auth.command("login").description("Authenticate with Kuckit using device flow").option("-s, --server <url>", "Server URL (default: http://localhost:3000)").option("--scopes <scopes>", "Comma-separated list of scopes (default: cli)").action(async (options) => {
+		await authLogin(options);
+	});
+	auth.command("whoami").description("Show current authentication status").option("--json", "Output as JSON", false).action(async (options) => {
+		await authWhoami(options);
+	});
+	auth.command("logout").description("Clear stored credentials").action(async () => {
+		await authLogout();
+	});
+}
+
+//#endregion
+//#region src/lib/require-auth.ts
+/**
+* Checks if the user is authenticated with a valid token.
+* Exits the process with an error message if not authenticated.
+*/
+function requireAuth() {
+	const config = loadConfig();
+	if (!config?.cliToken) {
+		console.error("\nError: Not logged in. Run 'kuckit auth login' first.\n");
+		process.exit(1);
+	}
+	if (isTokenExpired(config)) {
+		console.error("\nError: Session expired. Run 'kuckit auth login' to refresh.\n");
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/bin.ts
+program.name("kuckit").description("CLI tools for Kuckit SDK module development").version("0.1.0");
+program.command("generate").description("Generate Kuckit resources").command("module <name>").description("Generate a new Kuckit module").option("-o, --org <org>", "Organization scope for package name", "").option("-d, --dir <directory>", "Target directory", "packages").action(async (name, options) => {
+	requireAuth();
+	await generateModule(name, options);
+});
+program.command("add <package>").description("Install and wire a Kuckit module").option("--skip-install", "Skip package installation", false).action(async (packageName, options) => {
+	requireAuth();
+	await addModule(packageName, options);
+});
+program.command("discover").description("Scan node_modules for installed Kuckit modules").option("--json", "Output as JSON (non-interactive)", false).option("--no-interactive", "Disable interactive prompts").action(async (options) => {
+	requireAuth();
+	await discoverModules(options);
+});
+program.command("doctor").description("Check Kuckit setup and validate module configuration").option("--json", "Output as JSON", false).action(async (options) => {
+	await doctor(options);
+});
+program.command("search <keyword>").description("Search npm registry for Kuckit modules").option("--json", "Output as JSON", false).option("-l, --limit <number>", "Maximum results to return", "10").action(async (keyword, options) => {
+	await search(keyword, {
+		json: options.json,
+		limit: parseInt(options.limit, 10)
+	});
+});
+const db = program.command("db").description("Database schema management for module-owned schemas");
+db.command("push").description("Push all module schemas to database").option("--url <url>", "Database connection URL").action(async (options) => {
+	requireAuth();
+	await dbPush(options);
+});
+db.command("generate").description("Generate migration files for module schemas").option("--url <url>", "Database connection URL").action(async (options) => {
+	requireAuth();
+	await dbGenerate(options);
+});
+db.command("studio").description("Open Drizzle Studio with all module schemas").option("--url <url>", "Database connection URL").action(async (options) => {
+	requireAuth();
+	await dbStudio(options);
+});
+registerAuthCommands(program);
+program.parse();
+
+//#endregion
+export {  };