@uwu/flora-cli 0.0.0 → 0.1.0

package/README.md

@@ -0,0 +1,15 @@
+# @uwu/flora-cli
+
+TypeScript CLI for flora runtime management.
+
+## Generate API types
+
+```bash
+pnpm --filter @uwu/flora-cli run generate:api
+```
+
+## Build
+
+```bash
+pnpm --filter @uwu/flora-cli run build
+```

package/dist/index.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/index.mjs

@@ -0,0 +1,871 @@
+#!/usr/bin/env node
+import process$1 from "node:process";
+import { defineCommand, runMain } from "citty";
+import { colors } from "consola/utils";
+import path from "node:path";
+import { loadConfig } from "c12";
+import Conf from "conf";
+import { readFile, stat } from "node:fs/promises";
+import ignore from "ignore";
+import { glob } from "tinyglobby";
+import { createApiClient } from "@uwu/flora-api-client";
+import { createConsola } from "consola";
+import { cancel, isCancel, text } from "@clack/prompts";
+import { zipSync } from "fflate";
+
+//#region package.json
+var name = "@uwu/flora-cli";
+var version = "0.1.0";
+var description = "flora command line interface";
+
+//#endregion
+//#region src/lib/types.ts
+const DEFAULT_API_URL = "http://localhost:3000/api";
+
+//#endregion
+//#region src/lib/config.ts
+const store = new Conf({
+	projectName: "flora",
+	configName: "cli",
+	defaults: {
+		apiUrl: DEFAULT_API_URL,
+		token: void 0
+	}
+});
+function loadConfig$1() {
+	return {
+		apiUrl: store.get("apiUrl") ?? "http://localhost:3000/api",
+		token: store.get("token")
+	};
+}
+function saveConfig(config) {
+	store.set(config);
+}
+async function loadProjectConfig(cwd = process.cwd()) {
+	const { config } = await loadConfig({
+		cwd,
+		name: "flora",
+		configFile: "flora.config",
+		rcFile: false,
+		packageJson: false,
+		defaults: { deploy: {} }
+	});
+	return config.deploy ?? {};
+}
+
+//#endregion
+//#region src/lib/files.ts
+const ALLOWED_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cts"
+]);
+const EXTRA_FILE_NAMES = new Set([
+	"package.json",
+	"pnpm-lock.yaml",
+	"package-lock.json",
+	"yarn.lock",
+	"bun.lockb",
+	"tsconfig.json"
+]);
+const SKIP_DIRS = new Set([
+	"node_modules",
+	"target",
+	"dist",
+	".output",
+	".next",
+	".nuxt",
+	".svelte-kit",
+	"build",
+	"out",
+	".turbo",
+	".cache",
+	"coverage",
+	".parcel-cache",
+	".vite",
+	".git"
+]);
+async function collectFiles(root) {
+	const rootAbs = path.resolve(root);
+	const ignorePatterns = [...SKIP_DIRS].map((dir) => `**/${dir}/**`);
+	const relPaths = await glob([...[...ALLOWED_EXTENSIONS].map((ext) => `**/*${ext}`), ...[...EXTRA_FILE_NAMES].map((fileName) => `**/${fileName}`)], {
+		cwd: rootAbs,
+		dot: true,
+		onlyFiles: true,
+		ignore: ignorePatterns,
+		followSymbolicLinks: false
+	});
+	const ignoreMatcher = await buildIgnoreMatcher(rootAbs, ignorePatterns);
+	const files = [];
+	for (const rel of relPaths) {
+		if (ignoreMatcher.ignores(rel)) continue;
+		const contents = await readFile(path.join(rootAbs, rel), "utf8");
+		files.push({
+			path: rel.replace(/\\/g, "/"),
+			contents
+		});
+	}
+	if (files.length === 0) throw new Error(`No files found under ${rootAbs}`);
+	return files;
+}
+async function buildIgnoreMatcher(rootAbs, ignorePatterns) {
+	const matcher = ignore();
+	const ignoreFiles = await glob([
+		".gitignore",
+		".ignore",
+		"**/.gitignore",
+		"**/.ignore"
+	], {
+		cwd: rootAbs,
+		dot: true,
+		onlyFiles: true,
+		ignore: ignorePatterns,
+		followSymbolicLinks: false
+	});
+	ignoreFiles.sort((a, b) => depth(a) - depth(b) || a.localeCompare(b));
+	for (const rel of ignoreFiles) {
+		const content = await readFile(path.join(rootAbs, rel), "utf8");
+		const dir = path.posix.dirname(rel);
+		const prefix = dir === "." ? "" : `${dir}/`;
+		const patterns = content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map((pattern) => toRootPattern(pattern, prefix)).filter((pattern) => Boolean(pattern));
+		matcher.add(patterns);
+	}
+	return matcher;
+}
+function toRootPattern(rawPattern, prefix) {
+	const negated = rawPattern.startsWith("!");
+	let pattern = negated ? rawPattern.slice(1) : rawPattern;
+	if (!pattern) return null;
+	const rooted = pattern.startsWith("/");
+	if (rooted) pattern = pattern.slice(1);
+	if (!pattern) return null;
+	const withTree = pattern.endsWith("/") ? `${pattern}**` : pattern;
+	const fullPattern = rooted || withTree.includes("/") ? `${prefix}${withTree}` : `${prefix}**/${withTree}`;
+	return negated ? `!${fullPattern}` : fullPattern;
+}
+function depth(relPath) {
+	return relPath.split("/").length;
+}
+function toRelative(filePath, root) {
+	const rel = path.relative(root, filePath).replace(/\\/g, "/");
+	if (!rel || rel.startsWith("..")) throw new Error(`Entry file is not inside ${root}`);
+	return rel;
+}
+
+//#endregion
+//#region src/lib/http.ts
+function authHeaders(config) {
+	if (!config.token) throw new Error("Missing API token; run `flora login --token <token>`");
+	return { authorization: `Bearer ${config.token}` };
+}
+async function expectOk(promise) {
+	const { data, error, response } = await promise;
+	if (!response.ok) {
+		if (error && typeof error === "object" && "message" in error && typeof error.message === "string") throw new Error(error.message);
+		throw new Error(`Request failed: ${response.status} ${response.statusText}`);
+	}
+	return data;
+}
+
+//#endregion
+//#region src/lib/logger.ts
+const logger = createConsola({ formatOptions: {
+	colors: true,
+	date: false,
+	compact: false
+} });
+
+//#endregion
+//#region src/lib/prompts.ts
+async function promptIfMissing(value, message) {
+	if (value) return value;
+	if (!process.stdout.isTTY) throw new Error(`missing required value: ${message}`);
+	const result = await text({ message });
+	if (isCancel(result)) {
+		cancel("Canceled");
+		process.exit(1);
+	}
+	const next = String(result).trim();
+	if (!next) throw new Error(`missing required value: ${message}`);
+	return next;
+}
+
+//#endregion
+//#region src/lib/zip.ts
+const MAX_FILE_COUNT = 1e3;
+const INCLUDE_PATTERNS = ["src/**"];
+const INCLUDE_FILES = ["package.json", "flora.config.ts"];
+async function zipProject(root) {
+	const rootAbs = path.resolve(root);
+	const sourceFiles = await glob(INCLUDE_PATTERNS, {
+		cwd: rootAbs,
+		onlyFiles: true,
+		followSymbolicLinks: false,
+		ignore: ["node_modules/**", ".git/**"]
+	});
+	const topLevelFiles = [];
+	for (const file of INCLUDE_FILES) if ((await stat(path.join(rootAbs, file)).catch(() => null))?.isFile()) topLevelFiles.push(file);
+	const allFiles = [...sourceFiles, ...topLevelFiles];
+	if (allFiles.length === 0) throw new Error(`No files found under ${rootAbs}`);
+	if (allFiles.length > MAX_FILE_COUNT) throw new Error(`Project has ${allFiles.length} files, exceeding limit of ${MAX_FILE_COUNT}`);
+	const entries = {};
+	for (const rel of allFiles) {
+		const contents = await readFile(path.join(rootAbs, rel));
+		entries[rel.replace(/\\/g, "/")] = new Uint8Array(contents);
+	}
+	return {
+		zip: zipSync(entries),
+		fileCount: allFiles.length
+	};
+}
+
+//#endregion
+//#region src/commands/deployments.ts
+const BUILD_SSE_TIMEOUT = 6e4;
+async function deploy(config, guildArg, entryArg, root) {
+	const guild = await promptIfMissing(guildArg, "Guild ID");
+	const projectConfig = await loadProjectConfig();
+	const entry = entryArg ?? projectConfig.entry ?? "src/main.ts";
+	const projectRoot = root ?? projectConfig.root ?? ".";
+	const projectRootAbs = path.resolve(projectRoot);
+	const entryRel = toRelative(path.resolve(projectRootAbs, entry), projectRootAbs);
+	logger.info("Uploading project...");
+	const { zip, fileCount } = await zipProject(projectRoot);
+	const zipSize = formatBytes(zip.byteLength);
+	logger.success(`Upload complete (${fileCount} files, ${zipSize})`);
+	const formData = new FormData();
+	formData.append("guild_id", guild);
+	formData.append("entry", entryRel);
+	formData.append("project_zip", new Blob([zip]), "project.zip");
+	const baseUrl = config.apiUrl;
+	const headers = authHeaders(config);
+	const createRes = await fetch(`${baseUrl}/builds`, {
+		method: "POST",
+		headers,
+		body: formData
+	});
+	if (!createRes.ok) {
+		const body = await createRes.text().catch(() => "");
+		throw new Error(`Build creation failed (${createRes.status}): ${body}`);
+	}
+	const { build_id } = await createRes.json();
+	logger.info(`Building... (${build_id})`);
+	if (!await streamBuildLogs(`${baseUrl}/builds/${build_id}/logs`, headers, BUILD_SSE_TIMEOUT)) {
+		logger.warn(`Build still running: ${build_id}`);
+		logger.info(`Run ${colors.cyan("flora builds tail")} ${colors.yellow(build_id)} to follow logs.`);
+		return;
+	}
+	const buildRes = await fetch(`${baseUrl}/builds/${build_id}`, { headers });
+	if (!buildRes.ok) throw new Error(`Failed to fetch build result: ${buildRes.status}`);
+	const build = await buildRes.json();
+	if (build.status === "failed") throw new Error(`Build failed: ${build.error ?? "unknown error"}`);
+	if (build.status !== "done") throw new Error(`Build not finished: ${build.status}`);
+	if (!build.artifact?.bundle) throw new Error("Build produced no artifact bundle");
+	const files = await collectFiles(projectRootAbs);
+	const deployRes = await fetch(`${baseUrl}/deployments/${build.guild_id}`, {
+		method: "POST",
+		headers: {
+			...headers,
+			"content-type": "application/json",
+			"x-flora-deploy-source": "cli"
+		},
+		body: JSON.stringify({
+			entry: build.entry,
+			files,
+			bundle: build.artifact.bundle,
+			source_map: build.artifact.source_map ? {
+				path: "bundle.js.map",
+				contents: build.artifact.source_map
+			} : void 0
+		})
+	});
+	if (!deployRes.ok) {
+		const body = await deployRes.text().catch(() => "");
+		throw new Error(`Deployment apply failed (${deployRes.status}): ${body}`);
+	}
+	logger.success(`Deployed guild ${build.guild_id}`);
+	logger.info(`${colors.cyan("•")} ${colors.cyan("entry:")} ${build.entry}`);
+	logger.info(`${colors.gray("•")} ${colors.gray("updated:")} ${(/* @__PURE__ */ new Date()).toISOString()}`);
+}
+async function streamBuildLogs(url, headers, timeout) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeout);
+	try {
+		const res = await fetch(url, {
+			headers,
+			signal: controller.signal
+		});
+		if (!res.ok || !res.body) return false;
+		const reader = res.body.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+		while (true) {
+			const { value, done } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			for (;;) {
+				const eventEnd = buffer.indexOf("\n\n");
+				if (eventEnd < 0) break;
+				const event = buffer.slice(0, eventEnd);
+				buffer = buffer.slice(eventEnd + 2);
+				for (const line of event.split("\n")) {
+					if (line.startsWith("event: done")) return true;
+					if (line.startsWith("data: ")) {
+						const data = line.slice(6);
+						logger.log(`  ${colors.cyan("↳")} ${colors.dim(data)}`);
+					}
+				}
+			}
+		}
+		return true;
+	} catch (err) {
+		if (err instanceof DOMException && err.name === "AbortError") return false;
+		throw err;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${bytes}B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)}kb`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+async function get(config, guildArg) {
+	const guild = await promptIfMissing(guildArg, "Guild ID");
+	const deployment = await expectOk(createApiClient(config).GET("/deployments/{guild_id}", {
+		params: { path: { guild_id: guild } },
+		headers: authHeaders(config)
+	}));
+	logger.log(`Guild ${deployment.guild_id}\n  entry: ${deployment.entry}\n  created: ${deployment.created_at}\n  updated: ${deployment.updated_at}`);
+}
+async function list(_config) {
+	logger.warn("`flora deployments list` was removed; use `flora deployments get --guild <guild_id>`");
+}
+async function health(config) {
+	const response = await expectOk(createApiClient(config).GET("/health/", {
+		headers: authHeaders(config),
+		parseAs: "text"
+	}));
+	logger.log(`${response}`);
+}
+
+//#endregion
+//#region src/commands/kv.ts
+async function createStore(config, guildArg, nameArg) {
+	const guild = await promptIfMissing(guildArg, "Guild ID");
+	const name = await promptIfMissing(nameArg, "Store name");
+	const response = await expectOk(createApiClient(config).POST("/kv/stores", {
+		headers: authHeaders(config),
+		body: {
+			guild_id: guild,
+			store_name: name
+		}
+	}));
+	logger.log(`Created KV store '${response.store.store_name}' for guild ${response.store.guild_id}`);
+}
+async function listStores(config, guildArg) {
+	const guild = await promptIfMissing(guildArg, "Guild ID");
+	const stores = await expectOk(createApiClient(config).GET("/kv/stores", {
+		headers: authHeaders(config),
+		params: { query: { guild_id: guild } }
+	}));
+	if (stores.length === 0) {
+		logger.log(`No KV stores found for guild ${guild}`);
+		return;
+	}
+	logger.log(`KV stores for guild ${guild}:`);
+	for (const store of stores) logger.log(`  - ${store.store_name}`);
+}
+async function deleteStore(config, guildArg, nameArg) {
+	const guild = await promptIfMissing(guildArg, "Guild ID");
+	const name = await promptIfMissing(nameArg, "Store name");
+	await expectOk(createApiClient(config).DELETE("/kv/stores/{guild_id}/{store_name}", {
+		headers: authHeaders(config),
+		params: { path: {
+			guild_id: guild,
+			store_name: name
+		} }
+	}));
+	logger.log(`Deleted KV store '${name}' for guild ${guild}`);
+}
+async function setValue(config, guildArg, storeArg, keyArg, valueArg, expiration, metadata) {
+	const guild = await promptIfMissing(guildArg, "Guild ID");
+	const store = await promptIfMissing(storeArg, "Store name");
+	const key = await promptIfMissing(keyArg, "Key");
+	const value = await promptIfMissing(valueArg, "Value");
+	const metadataValue = metadata ? JSON.parse(metadata) : void 0;
+	await expectOk(createApiClient(config).PUT("/kv/{guild_id}/{store_name}/{key}", {
+		headers: authHeaders(config),
+		params: { path: {
+			guild_id: guild,
+			store_name: store,
+			key
+		} },
+		body: {
+			value,
+			expiration,
+			metadata: metadataValue
+		}
+	}));
+	logger.log(`Set ${key}=${value} in store '${store}' for guild ${guild}`);
+}
+async function getValue(config, guildArg, storeArg, keyArg) {
+	const guild = await promptIfMissing(guildArg, "Guild ID");
+	const store = await promptIfMissing(storeArg, "Store name");
+	const key = await promptIfMissing(keyArg, "Key");
+	const response = await expectOk(createApiClient(config).GET("/kv/{guild_id}/{store_name}/{key}", {
+		headers: authHeaders(config),
+		params: { path: {
+			guild_id: guild,
+			store_name: store,
+			key
+		} }
+	}));
+	if (response.value == null) {
+		logger.log(`Key '${key}' not found`);
+		return;
+	}
+	logger.log(`${response.value}`);
+}
+async function deleteValue(config, guildArg, storeArg, keyArg) {
+	const guild = await promptIfMissing(guildArg, "Guild ID");
+	const store = await promptIfMissing(storeArg, "Store name");
+	const key = await promptIfMissing(keyArg, "Key");
+	await expectOk(createApiClient(config).DELETE("/kv/{guild_id}/{store_name}/{key}", {
+		headers: authHeaders(config),
+		params: { path: {
+			guild_id: guild,
+			store_name: store,
+			key
+		} }
+	}));
+	logger.log(`Deleted key '${key}' from store '${store}' for guild ${guild}`);
+}
+async function listKeys(config, guildArg, storeArg, prefix, limit, cursor) {
+	const guild = await promptIfMissing(guildArg, "Guild ID");
+	const store = await promptIfMissing(storeArg, "Store name");
+	const response = await expectOk(createApiClient(config).GET("/kv/{guild_id}/{store_name}", {
+		headers: authHeaders(config),
+		params: {
+			path: {
+				guild_id: guild,
+				store_name: store
+			},
+			query: {
+				prefix,
+				limit,
+				cursor
+			}
+		}
+	}));
+	if (response.keys.length === 0) {
+		logger.log(`No keys found in store '${store}'`);
+		return;
+	}
+	logger.log(`Keys in store '${store}' (${response.keys.length} shown):`);
+	for (const key of response.keys) {
+		const expires = key.expiration ? ` (expires: ${key.expiration})` : "";
+		const meta = key.metadata ? ` [metadata: ${JSON.stringify(key.metadata)}]` : "";
+		logger.log(`  - ${key.name}${expires}${meta}`);
+	}
+	if (!("list_complete" in response ? response.list_complete : response.listComplete) && response.cursor) logger.log(`More keys available. Use --cursor ${response.cursor}`);
+}
+
+//#endregion
+//#region src/commands/login.ts
+async function login(tokenArg) {
+	const token = await promptIfMissing(tokenArg, "API token");
+	saveConfig({
+		...loadConfig$1(),
+		token
+	});
+	logger.log("Saved token to config");
+}
+
+//#endregion
+//#region src/lib/logs.ts
+function printLogEntry(entry) {
+	const dt = new Date(entry.timestamp);
+	const timestamp = Number.isNaN(dt.getTime()) ? String(entry.timestamp) : dt.toISOString().replace("T", " ").replace("Z", "");
+	const level = colorLevel(entry.level);
+	const guild = entry.guild_id ?? "-";
+	logger.log(`${timestamp} ${level} [${guild}] ${entry.target}: ${entry.message}`);
+}
+function colorLevel(level) {
+	switch (level) {
+		case "error": return "\x1B[31mERROR\x1B[0m";
+		case "warn": return "\x1B[33mWARN\x1B[0m";
+		case "info": return "\x1B[32mINFO\x1B[0m";
+		case "debug": return "\x1B[34mDEBUG\x1B[0m";
+		case "trace": return "\x1B[90mTRACE\x1B[0m";
+		default: return level;
+	}
+}
+async function streamSseLogs(response, onLog) {
+	if (!response.body) throw new Error("SSE stream missing response body");
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	while (true) {
+		const { value, done } = await reader.read();
+		if (done) break;
+		buffer += decoder.decode(value, { stream: true });
+		for (;;) {
+			const eventEnd = buffer.indexOf("\n\n");
+			if (eventEnd < 0) break;
+			const event = buffer.slice(0, eventEnd);
+			buffer = buffer.slice(eventEnd + 2);
+			for (const line of event.split("\n")) {
+				if (!line.startsWith("data: ")) continue;
+				const raw = line.slice(6);
+				try {
+					onLog(JSON.parse(raw));
+				} catch {}
+			}
+		}
+	}
+}
+
+//#endregion
+//#region src/commands/logs.ts
+async function logs(config, guild, limit = 100) {
+	const client = createApiClient(config);
+	const entries = guild ? await expectOk(client.GET("/logs/{guild_id}", {
+		params: {
+			path: { guild_id: guild },
+			query: { limit }
+		},
+		headers: authHeaders(config)
+	})) : await expectOk(client.GET("/logs", {
+		params: { query: { limit } },
+		headers: authHeaders(config)
+	}));
+	if (entries.length === 0) {
+		logger.log("No logs found");
+		return;
+	}
+	for (const entry of entries) printLogEntry(entry);
+}
+async function streamLogs(config, guild) {
+	const headers = authHeaders(config);
+	const streamPath = guild ? `/logs/${guild}/stream` : "/logs/stream";
+	const response = await fetch(`${config.apiUrl}${streamPath}`, { headers });
+	if (!response.ok) throw new Error(`Stream request failed: ${response.status} ${response.statusText}`);
+	logger.log("Streaming logs... (press Ctrl+C to stop)");
+	await streamSseLogs(response, printLogEntry);
+}
+
+//#endregion
+//#region src/index.ts
+function positional(args, index) {
+	const value = (Array.isArray(args._) ? args._ : [])[index];
+	return typeof value === "string" ? value : void 0;
+}
+function resolveConfig(args) {
+	const config = loadConfig$1();
+	const argApiUrl = args["api"];
+	const apiUrl = (typeof argApiUrl === "string" ? argApiUrl : void 0) ?? process$1.env.FLORA_API_URL;
+	if (apiUrl) config.apiUrl = apiUrl;
+	return config;
+}
+const kvCommand = defineCommand({
+	meta: {
+		name: "kv",
+		description: "KV store management"
+	},
+	subCommands: {
+		"create-store": defineCommand({
+			args: {
+				api: {
+					type: "string",
+					required: false,
+					alias: "a"
+				},
+				guild: {
+					type: "string",
+					required: false
+				},
+				name: {
+					type: "string",
+					required: false
+				}
+			},
+			async run({ args }) {
+				await createStore(resolveConfig(args), args.guild, args.name);
+			}
+		}),
+		"list-stores": defineCommand({
+			args: {
+				api: {
+					type: "string",
+					required: false,
+					alias: "a"
+				},
+				guild: {
+					type: "string",
+					required: false
+				}
+			},
+			async run({ args }) {
+				await listStores(resolveConfig(args), args.guild);
+			}
+		}),
+		"delete-store": defineCommand({
+			args: {
+				api: {
+					type: "string",
+					required: false,
+					alias: "a"
+				},
+				guild: {
+					type: "string",
+					required: false
+				},
+				name: {
+					type: "string",
+					required: false
+				}
+			},
+			async run({ args }) {
+				await deleteStore(resolveConfig(args), args.guild, args.name);
+			}
+		}),
+		set: defineCommand({
+			args: {
+				api: {
+					type: "string",
+					required: false,
+					alias: "a"
+				},
+				guild: {
+					type: "string",
+					required: false
+				},
+				store: {
+					type: "string",
+					required: false
+				},
+				key: {
+					type: "string",
+					required: false
+				},
+				expiration: {
+					type: "string",
+					required: false
+				},
+				metadata: {
+					type: "string",
+					required: false
+				}
+			},
+			async run({ args }) {
+				const config = resolveConfig(args);
+				const value = positional(args, 0);
+				const expiration = args.expiration ? Number(args.expiration) : void 0;
+				await setValue(config, args.guild, args.store, args.key, value, expiration, args.metadata);
+			}
+		}),
+		get: defineCommand({
+			args: {
+				api: {
+					type: "string",
+					required: false,
+					alias: "a"
+				},
+				guild: {
+					type: "string",
+					required: false
+				},
+				store: {
+					type: "string",
+					required: false
+				}
+			},
+			async run({ args }) {
+				const config = resolveConfig(args);
+				const key = positional(args, 0);
+				await getValue(config, args.guild, args.store, key);
+			}
+		}),
+		delete: defineCommand({
+			args: {
+				api: {
+					type: "string",
+					required: false,
+					alias: "a"
+				},
+				guild: {
+					type: "string",
+					required: false
+				},
+				store: {
+					type: "string",
+					required: false
+				}
+			},
+			async run({ args }) {
+				const config = resolveConfig(args);
+				const key = positional(args, 0);
+				await deleteValue(config, args.guild, args.store, key);
+			}
+		}),
+		"list-keys": defineCommand({
+			args: {
+				api: {
+					type: "string",
+					required: false,
+					alias: "a"
+				},
+				guild: {
+					type: "string",
+					required: false
+				},
+				store: {
+					type: "string",
+					required: false
+				},
+				prefix: {
+					type: "string",
+					required: false
+				},
+				limit: {
+					type: "string",
+					required: false
+				},
+				cursor: {
+					type: "string",
+					required: false
+				}
+			},
+			async run({ args }) {
+				await listKeys(resolveConfig(args), args.guild, args.store, args.prefix, args.limit ? Number(args.limit) : void 0, args.cursor);
+			}
+		})
+	}
+});
+runMain(defineCommand({
+	meta: {
+		name,
+		description,
+		version
+	},
+	args: { api: {
+		type: "string",
+		required: false,
+		alias: "a"
+	} },
+	subCommands: {
+		deploy: defineCommand({
+			args: {
+				api: {
+					type: "string",
+					required: false,
+					alias: "a"
+				},
+				guild: {
+					type: "string",
+					required: false
+				},
+				root: {
+					type: "string",
+					required: false
+				}
+			},
+			async run({ args }) {
+				const config = resolveConfig(args);
+				const entry = positional(args, 0);
+				await deploy(config, args.guild, entry, args.root);
+			}
+		}),
+		get: defineCommand({
+			args: {
+				api: {
+					type: "string",
+					required: false,
+					alias: "a"
+				},
+				guild: {
+					type: "string",
+					required: false
+				}
+			},
+			async run({ args }) {
+				await get(resolveConfig(args), args.guild);
+			}
+		}),
+		list: defineCommand({
+			args: { api: {
+				type: "string",
+				required: false,
+				alias: "a"
+			} },
+			async run({ args }) {
+				await list(resolveConfig(args));
+			}
+		}),
+		health: defineCommand({
+			args: { api: {
+				type: "string",
+				required: false,
+				alias: "a"
+			} },
+			async run({ args }) {
+				await health(resolveConfig(args));
+			}
+		}),
+		login: defineCommand({
+			args: { token: {
+				type: "string",
+				required: false
+			} },
+			async run({ args }) {
+				const positionalToken = positional(args, 0);
+				await login(args.token ?? positionalToken);
+			}
+		}),
+		logs: defineCommand({
+			args: {
+				api: {
+					type: "string",
+					required: false,
+					alias: "a"
+				},
+				guild: {
+					type: "string",
+					required: false
+				},
+				follow: {
+					type: "boolean",
+					required: false,
+					alias: "f"
+				},
+				limit: {
+					type: "string",
+					required: false,
+					alias: "n"
+				}
+			},
+			async run({ args }) {
+				const config = resolveConfig(args);
+				const follow = Boolean(args.follow);
+				const limit = args.limit ? Number(args.limit) : 100;
+				if (follow) {
+					await streamLogs(config, args.guild);
+					return;
+				}
+				await logs(config, args.guild, limit);
+			}
+		}),
+		kv: kvCommand
+	}
+})).catch((error) => {
+	const message = error instanceof Error ? error.message : String(error);
+	logger.error(message);
+	process$1.exit(1);
+});
+
+//#endregion
+export {  };

package/package.json

@@ -1,14 +1,51 @@
 {
   "name": "@uwu/flora-cli",
-  "version": "0.0.0",
-  "description": "Placeholder for @uwu/flora-cli",
-  "main": "index.js",
-  "scripts": {},
-  "keywords": [],
-  "author": "taskylizard (https://www.npmjs.com/~taskylizard)",
-  "license": "UNLICENSED",
+  "version": "0.1.0",
   "private": false,
+  "description": "flora command line interface",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/uwu/flora",
+    "directory": "packages/cli"
+  },
+  "bin": {
+    "flora": "./dist/index.mjs"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ],
+  "type": "module",
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "typecheck": "tsgo --noEmit",
+    "release": "bumpp",
+    "prepublishOnly": "pnpm run build"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.0.1",
+    "@uwu/flora-api-client": "workspace:*",
+    "c12": "^3.3.2",
+    "citty": "^0.2.1",
+    "conf": "^15.1.0",
+    "consola": "^3.4.2",
+    "fflate": "^0.8.2",
+    "ignore": "^7.0.5",
+    "rolldown": "^0.15.1",
+    "tinyglobby": "^0.2.15"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:",
+    "@typescript/native-preview": "catalog:",
+    "bumpp": "^11.0.0",
+    "typescript": "catalog:",
+    "vite-plus": "catalog:",
+    "vitest": "catalog:"
   }
-}
+}

package/index.js

@@ -1 +0,0 @@
-// Placeholder