@nuniapp/cli 0.1.4 → 0.1.6

package/dist/index.mjs

@@ -1,37 +1,25 @@
 #!/usr/bin/env node
-import { join, resolve } from "node:path";
+import { join, relative, resolve } from "node:path";
 import { parseArgs } from "node:util";
-import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { createInterface } from "node:readline";
 //#region package.json
-var version = "0.1.4";
+var version$1 = "0.1.6";
 //#endregion
-//#region ../shared/src/id.ts
-const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-const ID_LENGTH = 22;
-const PREFIX = "nuni_";
-const PROJECT_ID_PATTERN = new RegExp(`^${PREFIX}[${ALPHABET}]{${ID_LENGTH}}$`);
-/** Random base58 string using the platform CSPRNG (browser, Node, Convex). */
-function randomBase58(length) {
-	const bytes = new Uint8Array(length);
-	crypto.getRandomValues(bytes);
-	let out = "";
-	for (const byte of bytes) {
-		let b = byte;
-		while (b >= 232) {
-			const retry = /* @__PURE__ */ new Uint8Array(1);
-			crypto.getRandomValues(retry);
-			b = retry[0];
-		}
-		out += ALPHABET[b % 58];
-	}
-	return out;
-}
-/** Public project identifier, safe to commit into source code. */
-function generateProjectId() {
-	return PREFIX + randomBase58(ID_LENGTH);
-}
-function isProjectId(value) {
-	return typeof value === "string" && PROJECT_ID_PATTERN.test(value);
+//#region ../shared/src/path.ts
+/** URL that opens the page with the comment focused by the widget. */
+function commentUrl(page, id) {
+	const [pathname, hashRoute] = page.path.split("#");
+	const origin = new URL(page.origin).origin;
+	let url = new URL(pathname ?? "/", origin);
+	if (url.origin !== origin) url = new URL("/", origin);
+	const params = new URLSearchParams(page.search ?? "");
+	params.set("nuni", id);
+	url.search = params.toString();
+	if (hashRoute) url.hash = hashRoute;
+	return url.toString();
 }
 //#endregion
 //#region ../shared/src/prompt.ts
@@ -65,10 +53,1733 @@ Steps:
 6. Do not add Nuni to server-only code, and do not load it more than once.
 7. If the site sends a Content-Security-Policy, allow connect-src https://*.convex.cloud wss://*.convex.cloud https://*.convex.site (and script-src cdn.jsdelivr.net for the script tag).
 8. Start the dev server, open the site, and confirm the Nuni button appears in the bottom-right corner.
+9. Tell the user they can let you read and resolve comments later: run npx ${PACKAGES.cli}@latest login once, then add the MCP server (for Claude Code: claude mcp add nuni -- npx -y ${PACKAGES.cli}@latest mcp). Do not run login yourself unless asked.
 
 Docs: ${DOCS_URL}/quickstart`;
 }
 //#endregion
+//#region ../shared/src/comment-prompt.ts
+/** A code fence longer than any backtick run inside `content`. */
+function fence(content, lang = "") {
+	const longest = Math.max(0, ...Array.from(content.matchAll(/`+/g), (m) => m[0].length));
+	const ticks = "`".repeat(Math.max(3, longest + 1));
+	return `${ticks}${lang}\n${content}\n${ticks}`;
+}
+function quote(text) {
+	return text.split("\n").map((line) => line ? `> ${line}` : ">").join("\n");
+}
+function inline(text) {
+	const clean = text.replace(/\s+/g, " ").trim();
+	return clean.includes("`") ? `"${clean}"` : `\`${clean}\``;
+}
+/**
+* One comment as a ready-to-paste task for a coding agent. Single source of
+* truth for the widget, dashboard, CLI and MCP server.
+*/
+function buildCommentPrompt(comment, options = {}) {
+	const includeContext = options.includeContext ?? true;
+	const { anchor, page } = comment;
+	const out = [];
+	out.push("Fix this piece of feedback that was left on the live site with Nuni.", "", "## Comment", "", quote(comment.body), "", `From ${comment.authorName} on ${new Date(comment.createdAt).toISOString().slice(0, 10)}` + (comment.status === "resolved" ? " (already resolved)" : ""));
+	if (comment.replies?.length) {
+		out.push("", `## Replies (${comment.replies.length})`, "");
+		for (const reply of comment.replies) out.push(`${reply.authorName}${reply.isOwner ? " (owner)" : ""}:`, quote(reply.body), "");
+		out.pop();
+	}
+	out.push("", "## Where", "");
+	out.push(`- Page: ${page.title ? `${page.title} ` : ""}(${page.path})`);
+	out.push(`- Open it: ${commentUrl(page, comment._id)}`);
+	out.push(`- Viewport: ${comment.viewport.w}×${comment.viewport.h} at ${comment.viewport.dpr}x`);
+	if (includeContext && comment.userAgent) out.push(`- Browser: ${comment.userAgent}`);
+	out.push("", "## Element", "");
+	out.push(`- Tag: <${anchor.tag}>`);
+	if (anchor.text) out.push(`- Text: ${inline(anchor.text)}`);
+	if (anchor.quote) out.push(`- Selected text: ${inline(anchor.quote.exact)}`);
+	if (anchor.region) {
+		const pct = (n) => `${Math.round(n * 100)}%`;
+		const r = anchor.region;
+		out.push(`- Area: ${pct(r.w)} × ${pct(r.h)} of the element, from ${pct(r.x)} left and ${pct(r.y)} top`);
+	}
+	if (anchor.componentName) out.push(`- React component: ${anchor.componentName}`);
+	if (anchor.selectors.testId) out.push(`- Test ID: ${inline(anchor.selectors.testId)}`);
+	if (anchor.selectors.id) out.push(`- ID: ${inline(anchor.selectors.id)}`);
+	if (anchor.selectors.css) out.push(`- CSS selector: ${inline(anchor.selectors.css)}`);
+	out.push(`- DOM path: ${inline(anchor.selectors.path)}`);
+	const labels = Object.entries(anchor.attrs).filter(([name]) => name !== "class" && name !== "style").map(([name, value]) => `${name}="${value}"`);
+	if (labels.length) out.push(`- Attributes: ${inline(labels.join(" "))}`);
+	const context = includeContext ? comment.context : void 0;
+	if (context?.dom?.html) out.push("", fence(context.dom.html, "html"));
+	const styles = Object.entries(context?.dom?.styles ?? {});
+	if (styles.length) out.push("", "Computed styles:", "", fence(styles.map(([k, v]) => `${k}: ${v};`).join("\n"), "css"));
+	if (context?.console?.length) {
+		out.push("", `## Console (${context.console.length})`, "");
+		out.push(fence(context.console.map((e) => `[${e.level}] ${e.message}`).join("\n"), "text"));
+	}
+	if (context?.network?.length) {
+		out.push("", `## Failed requests (${context.network.length})`, "");
+		for (const r of context.network) out.push(`- ${r.method} ${r.url} → ${r.status === 0 ? "network error" : r.status}`);
+	}
+	if (includeContext && comment.screenshotUrl) out.push("", "## Screenshot", "", comment.screenshotUrl);
+	out.push("", "## Steps", "", "1. Find the code that renders this element. Search for the text, the component name, the test ID or the selector.", "2. Make the change the comment asks for, and keep the fix focused on it.", "3. Tell me what you changed, so the comment can be resolved in Nuni.", `   If the Nuni CLI is signed in to this project (\`npx ${PACKAGES.cli}@latest login\`), resolve it with \`npx ${PACKAGES.cli}@latest resolve ${comment._id}\` or the \`resolve_comment\` MCP tool.`);
+	return out.join("\n");
+}
+//#endregion
+//#region ../shared/src/id.ts
+const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const ID_LENGTH = 22;
+const PREFIX = "nuni_";
+const PROJECT_ID_PATTERN = new RegExp(`^${PREFIX}[${ALPHABET}]{${ID_LENGTH}}$`);
+/** Random base58 string using the platform CSPRNG (browser, Node, Convex). */
+function randomBase58(length) {
+	const bytes = new Uint8Array(length);
+	crypto.getRandomValues(bytes);
+	let out = "";
+	for (const byte of bytes) {
+		let b = byte;
+		while (b >= 232) {
+			const retry = /* @__PURE__ */ new Uint8Array(1);
+			crypto.getRandomValues(retry);
+			b = retry[0];
+		}
+		out += ALPHABET[b % 58];
+	}
+	return out;
+}
+/** Public project identifier, safe to commit into source code. */
+function generateProjectId() {
+	return PREFIX + randomBase58(ID_LENGTH);
+}
+function isProjectId(value) {
+	return typeof value === "string" && PROJECT_ID_PATTERN.test(value);
+}
+//#endregion
+//#region src/credentials.ts
+/** ~/.config/nuni, or $XDG_CONFIG_HOME/nuni, or %APPDATA%\nuni on Windows. */
+function configDir() {
+	if (process.env.NUNI_CONFIG_DIR) return process.env.NUNI_CONFIG_DIR;
+	const base = process.env.XDG_CONFIG_HOME || process.platform === "win32" && process.env.APPDATA || join(homedir(), ".config");
+	return join(base, "nuni");
+}
+function credentialsPath() {
+	return join(configDir(), "credentials.json");
+}
+function read() {
+	try {
+		const value = JSON.parse(readFileSync(credentialsPath(), "utf8"));
+		return value && typeof value === "object" ? value : {};
+	} catch {
+		return {};
+	}
+}
+function write(store) {
+	const dir = configDir();
+	if (!existsSync(dir)) mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+	const path = credentialsPath();
+	writeFileSync(path, `${JSON.stringify(store, null, 2)}\n`, { mode: 384 });
+	chmodSync(path, 384);
+}
+/** The session for a project: $NUNI_TOKEN, or the one saved by `nuni login`. */
+function credentialFor(publicId) {
+	if (process.env.NUNI_TOKEN) return { token: process.env.NUNI_TOKEN };
+	const saved = read()[publicId];
+	if (!saved?.token) return null;
+	if (saved.expiresAt && saved.expiresAt < Date.now()) return null;
+	return saved;
+}
+function saveCredential(publicId, credential) {
+	write({
+		...read(),
+		[publicId]: credential
+	});
+}
+function removeCredential(publicId) {
+	const store = read();
+	if (!store[publicId]) return false;
+	delete store[publicId];
+	write(store);
+	return true;
+}
+//#endregion
+//#region src/env.ts
+/**
+* Backend URLs, set at build time (see tsdown.config.ts). The env vars
+* override them, for local development and tests.
+*/
+const CONVEX_URL = process.env.NUNI_CONVEX_URL ?? "https://greedy-giraffe-33.convex.cloud";
+const CONVEX_SITE_URL = process.env.NUNI_CONVEX_SITE_URL ?? "https://greedy-giraffe-33.convex.site";
+const APP_URL = process.env.NUNI_APP_URL ?? "https://nuni.praveenjuge.com";
+//#endregion
+//#region src/format.ts
+function timeAgo(at, now = Date.now()) {
+	const seconds = Math.max(0, Math.round((now - at) / 1e3));
+	if (seconds < 60) return "just now";
+	const steps = [
+		[60, "minute"],
+		[24, "hour"],
+		[30, "day"],
+		[12, "month"],
+		[Infinity, "year"]
+	];
+	let value = seconds / 60;
+	for (const [size, unit] of steps) {
+		if (value < size) {
+			const n = Math.floor(value);
+			return `${n} ${unit}${n === 1 ? "" : "s"} ago`;
+		}
+		value /= size;
+	}
+	return "a long time ago";
+}
+function oneLine(text, max = 120) {
+	const clean = text.replace(/\s+/g, " ").trim();
+	return clean.length > max ? `${clean.slice(0, max - 1)}…` : clean;
+}
+/** A compact, numbered list: enough to pick a comment, not the full context. */
+function formatCommentList(comments, options) {
+	if (!comments.length) return `No ${options.status} comments.`;
+	const lines = [`${comments.length}${options.more ? "+" : ""} ${options.status} comment${comments.length === 1 ? "" : "s"}, newest first:`, ""];
+	comments.forEach((c, i) => {
+		const element = c.anchor.text ? `<${c.anchor.tag}> "${oneLine(c.anchor.text, 60)}"` : `<${c.anchor.tag}>`;
+		lines.push(`${i + 1}. ${c._id} · ${c.page.path} · ${c.authorName} · ${timeAgo(c.createdAt)}`, `   "${oneLine(c.body)}"`, c.anchor.quote ? `   On the text "${oneLine(c.anchor.quote.exact, 60)}" in ${element}` : `   ${c.anchor.region ? "On an area of" : "On"} ${element}`);
+	});
+	lines.push("", options.detailHint);
+	return lines.join("\n");
+}
+//#endregion
+//#region src/project.ts
+const SKIP_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	".git",
+	"dist",
+	"build",
+	"out",
+	"coverage",
+	"vendor",
+	"target",
+	".next",
+	".nuxt",
+	".output",
+	".svelte-kit",
+	".astro",
+	".turbo",
+	".vercel",
+	".cache"
+]);
+const SOURCE_FILE = /\.(?:[cm]?[jt]sx?|vue|svelte|astro|html?|php|erb|liquid|hbs|njk|mdx?)$/i;
+const ID_IN_TEXT = /nuni_[1-9A-HJ-NP-Za-km-z]{22}/g;
+const MAX_FILES = 5e3;
+const MAX_FILE_BYTES = 524288;
+/**
+* Project IDs used in this codebase, found by scanning source files (the ID
+* is committed in code, next to <Nuni /> or the script tag).
+*/
+function findProjectIds(cwd) {
+	const found = /* @__PURE__ */ new Map();
+	const queue = [cwd];
+	let files = 0;
+	while (queue.length && files < MAX_FILES) {
+		const dir = queue.shift();
+		let entries;
+		try {
+			entries = readdirSync(dir).sort();
+		} catch {
+			continue;
+		}
+		for (const name of entries) {
+			const path = join(dir, name);
+			let stat;
+			try {
+				stat = statSync(path);
+			} catch {
+				continue;
+			}
+			if (stat.isDirectory()) {
+				if (!SKIP_DIRS.has(name) && !name.startsWith(".")) queue.push(path);
+				continue;
+			}
+			if (!SOURCE_FILE.test(name) || stat.size > MAX_FILE_BYTES) continue;
+			if (++files > MAX_FILES) break;
+			let text;
+			try {
+				text = readFileSync(path, "utf8");
+			} catch {
+				continue;
+			}
+			for (const [id] of text.matchAll(ID_IN_TEXT)) if (isProjectId(id) && !found.has(id)) found.set(id, relative(cwd, path));
+		}
+	}
+	return Array.from(found, ([id, file]) => ({
+		id,
+		file
+	}));
+}
+var ProjectError = class extends Error {};
+/**
+* The project to work on: --project, then $NUNI_PROJECT, then the one ID
+* found in the code.
+*/
+function resolveProject(flag, cwd) {
+	const explicit = flag ?? process.env.NUNI_PROJECT;
+	if (explicit) {
+		if (!isProjectId(explicit)) throw new ProjectError(`"${explicit}" is not a valid Nuni project ID (expected nuni_ followed by 22 characters).`);
+		return {
+			id: explicit,
+			source: flag ? "--project" : "NUNI_PROJECT"
+		};
+	}
+	const found = findProjectIds(cwd);
+	if (found.length === 1) return {
+		id: found[0].id,
+		source: found[0].file
+	};
+	if (!found.length) throw new ProjectError(`No Nuni project ID found in ${cwd}. Run this in the project that uses Nuni, or pass --project nuni_...`);
+	throw new ProjectError(`Found more than one Nuni project ID. Pass one with --project:\n${found.map((p) => `  ${p.id}  (${p.file})`).join("\n")}`);
+}
+//#endregion
+//#region ../../node_modules/.bun/convex@1.46.0+0f58469d5b3bd39f/node_modules/convex/dist/esm/values/base64.js
+var lookup = [];
+var revLookup = [];
+var Arr = Uint8Array;
+var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (var i = 0, len = code.length; i < len; ++i) {
+	lookup[i] = code[i];
+	revLookup[code.charCodeAt(i)] = i;
+}
+revLookup["-".charCodeAt(0)] = 62;
+revLookup["_".charCodeAt(0)] = 63;
+function getLens(b64) {
+	var len = b64.length;
+	if (len % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");
+	var validLen = b64.indexOf("=");
+	if (validLen === -1) validLen = len;
+	var placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;
+	return [validLen, placeHoldersLen];
+}
+function _byteLength(_b64, validLen, placeHoldersLen) {
+	return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+}
+function toByteArray(b64) {
+	var tmp;
+	var lens = getLens(b64);
+	var validLen = lens[0];
+	var placeHoldersLen = lens[1];
+	var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+	var curByte = 0;
+	var len = placeHoldersLen > 0 ? validLen - 4 : validLen;
+	var i = 0;
+	for (; i < len; i += 4) {
+		tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
+		arr[curByte++] = tmp >> 16 & 255;
+		arr[curByte++] = tmp >> 8 & 255;
+		arr[curByte++] = tmp & 255;
+	}
+	if (placeHoldersLen === 2) {
+		tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;
+		arr[curByte++] = tmp & 255;
+	}
+	if (placeHoldersLen === 1) {
+		tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;
+		arr[curByte++] = tmp >> 8 & 255;
+		arr[curByte++] = tmp & 255;
+	}
+	return arr;
+}
+function tripletToBase64(num) {
+	return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+}
+function encodeChunk(uint8, start, end) {
+	var tmp;
+	var output = [];
+	for (var i = start; i < end; i += 3) {
+		tmp = (uint8[i] << 16 & 16711680) + (uint8[i + 1] << 8 & 65280) + (uint8[i + 2] & 255);
+		output.push(tripletToBase64(tmp));
+	}
+	return output.join("");
+}
+function fromByteArray(uint8) {
+	var tmp;
+	var len = uint8.length;
+	var extraBytes = len % 3;
+	var parts = [];
+	var maxChunkLength = 16383;
+	for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
+	if (extraBytes === 1) {
+		tmp = uint8[len - 1];
+		parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
+	} else if (extraBytes === 2) {
+		tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+		parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
+	}
+	return parts.join("");
+}
+//#endregion
+//#region ../../node_modules/.bun/convex@1.46.0+0f58469d5b3bd39f/node_modules/convex/dist/esm/common/index.js
+function parseArgs$1(args) {
+	if (args === void 0) return {};
+	if (!isSimpleObject(args)) throw new Error(`The arguments to a Convex function must be an object. Received: ${args}`);
+	return args;
+}
+function validateDeploymentUrl(deploymentUrl) {
+	if (typeof deploymentUrl === "undefined") throw new Error(`Client created with undefined deployment address. If you used an environment variable, check that it's set.`);
+	if (typeof deploymentUrl !== "string") throw new Error(`Invalid deployment address: found ${deploymentUrl}".`);
+	if (!(deploymentUrl.startsWith("http:") || deploymentUrl.startsWith("https:"))) throw new Error(`Invalid deployment address: Must start with "https://" or "http://". Found "${deploymentUrl}".`);
+	try {
+		new URL(deploymentUrl);
+	} catch {
+		throw new Error(`Invalid deployment address: "${deploymentUrl}" is not a valid URL. If you believe this URL is correct, use the \`skipConvexDeploymentUrlCheck\` option to bypass this.`);
+	}
+	if (deploymentUrl.endsWith(".convex.site")) throw new Error(`Invalid deployment address: "${deploymentUrl}" ends with .convex.site, which is used for HTTP Actions. Convex deployment URLs typically end with .convex.cloud? If you believe this URL is correct, use the \`skipConvexDeploymentUrlCheck\` option to bypass this.`);
+}
+function isSimpleObject(value) {
+	const isObject = typeof value === "object";
+	const prototype = Object.getPrototypeOf(value);
+	const isSimple = prototype === null || prototype === Object.prototype || prototype?.constructor?.name === "Object";
+	return isObject && isSimple;
+}
+//#endregion
+//#region ../../node_modules/.bun/convex@1.46.0+0f58469d5b3bd39f/node_modules/convex/dist/esm/values/value.js
+const LITTLE_ENDIAN = true;
+const MIN_INT64 = BigInt("-9223372036854775808");
+const MAX_INT64 = BigInt("9223372036854775807");
+const ZERO = BigInt("0");
+const EIGHT = BigInt("8");
+const TWOFIFTYSIX = BigInt("256");
+const COMMIT_TS_UNRESOLVED = "This commit timestamp is unresolved: its value is assigned when the mutation commits. Read the document after the mutation completes to get its value.";
+var CommitTsPlaceholder = class {
+	[Symbol.toPrimitive](hint) {
+		if (hint === "string") return this.toString();
+		throw new Error(COMMIT_TS_UNRESOLVED);
+	}
+	valueOf() {
+		throw new Error(COMMIT_TS_UNRESOLVED);
+	}
+	toJSON() {
+		throw new Error(COMMIT_TS_UNRESOLVED);
+	}
+	toString() {
+		return "[unresolved commit timestamp]";
+	}
+};
+const commitTsPlaceholder = new CommitTsPlaceholder();
+function isSpecial(n) {
+	return Number.isNaN(n) || !Number.isFinite(n) || Object.is(n, -0);
+}
+function slowBigIntToBase64(value) {
+	if (value < ZERO) value -= MIN_INT64 + MIN_INT64;
+	let hex = value.toString(16);
+	if (hex.length % 2 === 1) hex = "0" + hex;
+	const bytes = new Uint8Array(/* @__PURE__ */ new ArrayBuffer(8));
+	let i = 0;
+	for (const hexByte of hex.match(/.{2}/g).reverse()) {
+		bytes.set([parseInt(hexByte, 16)], i++);
+		value >>= EIGHT;
+	}
+	return fromByteArray(bytes);
+}
+function slowBase64ToBigInt(encoded) {
+	const integerBytes = toByteArray(encoded);
+	if (integerBytes.byteLength !== 8) throw new Error(`Received ${integerBytes.byteLength} bytes, expected 8 for $integer`);
+	let value = ZERO;
+	let power = ZERO;
+	for (const byte of integerBytes) {
+		value += BigInt(byte) * TWOFIFTYSIX ** power;
+		power++;
+	}
+	if (value > MAX_INT64) value += MIN_INT64 + MIN_INT64;
+	return value;
+}
+function modernBigIntToBase64(value) {
+	if (value < MIN_INT64 || MAX_INT64 < value) throw new Error(`BigInt ${value} does not fit into a 64-bit signed integer.`);
+	const buffer = /* @__PURE__ */ new ArrayBuffer(8);
+	new DataView(buffer).setBigInt64(0, value, true);
+	return fromByteArray(new Uint8Array(buffer));
+}
+function modernBase64ToBigInt(encoded) {
+	const integerBytes = toByteArray(encoded);
+	if (integerBytes.byteLength !== 8) throw new Error(`Received ${integerBytes.byteLength} bytes, expected 8 for $integer`);
+	return new DataView(integerBytes.buffer).getBigInt64(0, true);
+}
+const bigIntToBase64 = DataView.prototype.setBigInt64 ? modernBigIntToBase64 : slowBigIntToBase64;
+const base64ToBigInt = DataView.prototype.getBigInt64 ? modernBase64ToBigInt : slowBase64ToBigInt;
+const MAX_IDENTIFIER_LEN = 1024;
+function validateObjectField(k) {
+	if (k.length > MAX_IDENTIFIER_LEN) throw new Error(`Field name ${k} exceeds maximum field name length ${MAX_IDENTIFIER_LEN}.`);
+	if (k.startsWith("$")) throw new Error(`Field name ${k} starts with a '$', which is reserved.`);
+	for (let i = 0; i < k.length; i += 1) {
+		const charCode = k.charCodeAt(i);
+		if (charCode < 32 || charCode >= 127) throw new Error(`Field name ${k} has invalid character '${k[i]}': Field names can only contain non-control ASCII characters`);
+	}
+}
+function jsonToConvex(value) {
+	if (value === null) return value;
+	if (typeof value === "boolean") return value;
+	if (typeof value === "number") return value;
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) return value.map((value2) => jsonToConvex(value2));
+	if (typeof value !== "object") throw new Error(`Unexpected type of ${value}`);
+	const entries = Object.entries(value);
+	if (entries.length === 1) {
+		const key = entries[0][0];
+		if (key === "$bytes") {
+			if (typeof value.$bytes !== "string") throw new Error(`Malformed $bytes field on ${value}`);
+			return toByteArray(value.$bytes).buffer;
+		}
+		if (key === "$integer") {
+			if (typeof value.$integer !== "string") throw new Error(`Malformed $integer field on ${value}`);
+			return base64ToBigInt(value.$integer);
+		}
+		if (key === "$float") {
+			if (typeof value.$float !== "string") throw new Error(`Malformed $float field on ${value}`);
+			const floatBytes = toByteArray(value.$float);
+			if (floatBytes.byteLength !== 8) throw new Error(`Received ${floatBytes.byteLength} bytes, expected 8 for $float`);
+			const float = new DataView(floatBytes.buffer).getFloat64(0, LITTLE_ENDIAN);
+			if (!isSpecial(float)) throw new Error(`Float ${float} should be encoded as a number`);
+			return float;
+		}
+		if (key === "$commitTs") {
+			if (value.$commitTs !== null) throw new Error(`Malformed $commitTs field on ${value}`);
+			return commitTsPlaceholder;
+		}
+		if (key === "$set") throw new Error(`Received a Set which is no longer supported as a Convex type.`);
+		if (key === "$map") throw new Error(`Received a Map which is no longer supported as a Convex type.`);
+	}
+	const out = {};
+	for (const [k, v] of Object.entries(value)) {
+		validateObjectField(k);
+		out[k] = jsonToConvex(v);
+	}
+	return out;
+}
+const MAX_VALUE_FOR_ERROR_LEN = 16384;
+function stringifyValueForError(value) {
+	const str = JSON.stringify(value, (_key, value2) => {
+		if (value2 === void 0) return "undefined";
+		if (typeof value2 === "bigint") return `${value2.toString()}n`;
+		return value2;
+	});
+	if (str.length > MAX_VALUE_FOR_ERROR_LEN) {
+		const rest = "[...truncated]";
+		let truncateAt = 16370;
+		const codePoint = str.codePointAt(truncateAt - 1);
+		if (codePoint !== void 0 && codePoint > 65535) truncateAt -= 1;
+		return str.substring(0, truncateAt) + rest;
+	}
+	return str;
+}
+function convexToJsonInternal(value, originalValue, context, includeTopLevelUndefined) {
+	if (value === void 0) {
+		const contextText = context && ` (present at path ${context} in original object ${stringifyValueForError(originalValue)})`;
+		throw new Error(`undefined is not a valid Convex value${contextText}. To learn about Convex's supported types, see https://docs.convex.dev/using/types.`);
+	}
+	if (value === null) return value;
+	if (typeof value === "bigint") {
+		if (value < MIN_INT64 || MAX_INT64 < value) throw new Error(`BigInt ${value} does not fit into a 64-bit signed integer.`);
+		return { $integer: bigIntToBase64(value) };
+	}
+	if (typeof value === "number") {
+		if (isSpecial(value)) {
+			const buffer = /* @__PURE__ */ new ArrayBuffer(8);
+			new DataView(buffer).setFloat64(0, value, LITTLE_ENDIAN);
+			return { $float: fromByteArray(new Uint8Array(buffer)) };
+		} else return value;
+	}
+	if (typeof value === "boolean") return value;
+	if (typeof value === "string") return value;
+	if (value instanceof ArrayBuffer) return { $bytes: fromByteArray(new Uint8Array(value)) };
+	if (value instanceof CommitTsPlaceholder) return { $commitTs: null };
+	if (Array.isArray(value)) return value.map((value2, i) => convexToJsonInternal(value2, originalValue, context + `[${i}]`, false));
+	if (value instanceof Set) throw new Error(errorMessageForUnsupportedType(context, "Set", [...value], originalValue));
+	if (value instanceof Map) throw new Error(errorMessageForUnsupportedType(context, "Map", [...value], originalValue));
+	if (!isSimpleObject(value)) {
+		const theType = value?.constructor?.name;
+		const typeName = theType ? `${theType} ` : "";
+		throw new Error(errorMessageForUnsupportedType(context, typeName, value, originalValue));
+	}
+	const out = {};
+	const entries = Object.entries(value);
+	entries.sort(([k1, _v1], [k2, _v2]) => k1 === k2 ? 0 : k1 < k2 ? -1 : 1);
+	for (const [k, v] of entries) if (v !== void 0) {
+		validateObjectField(k);
+		out[k] = convexToJsonInternal(v, originalValue, context + `.${k}`, false);
+	} else if (includeTopLevelUndefined) {
+		validateObjectField(k);
+		out[k] = convexOrUndefinedToJsonInternal(v, originalValue, context + `.${k}`);
+	}
+	return out;
+}
+function errorMessageForUnsupportedType(context, typeName, value, originalValue) {
+	if (context) return `${typeName}${stringifyValueForError(value)} is not a supported Convex type (present at path ${context} in original object ${stringifyValueForError(originalValue)}). To learn about Convex's supported types, see https://docs.convex.dev/using/types.`;
+	else return `${typeName}${stringifyValueForError(value)} is not a supported Convex type.`;
+}
+function convexOrUndefinedToJsonInternal(value, originalValue, context) {
+	if (value === void 0) return { $undefined: null };
+	else {
+		if (originalValue === void 0) throw new Error(`Programming error. Current value is ${stringifyValueForError(value)} but original value is undefined`);
+		return convexToJsonInternal(value, originalValue, context, false);
+	}
+}
+function convexToJson(value) {
+	return convexToJsonInternal(value, value, "", false);
+}
+//#endregion
+//#region ../../node_modules/.bun/convex@1.46.0+0f58469d5b3bd39f/node_modules/convex/dist/esm/values/errors.js
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value
+}) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+var _a;
+var _b;
+const IDENTIFYING_FIELD = Symbol.for("ConvexError");
+var ConvexError = class extends (_b = Error, _a = IDENTIFYING_FIELD, _b) {
+	constructor(data) {
+		super(typeof data === "string" ? data : stringifyValueForError(data));
+		__publicField$2(this, "name", "ConvexError");
+		__publicField$2(this, "data");
+		__publicField$2(this, _a, true);
+		this.data = data;
+	}
+};
+//#endregion
+//#region ../../node_modules/.bun/convex@1.46.0+0f58469d5b3bd39f/node_modules/convex/dist/esm/index.js
+const version = "1.46.0";
+//#endregion
+//#region ../../node_modules/.bun/convex@1.46.0+0f58469d5b3bd39f/node_modules/convex/dist/esm/server/functionName.js
+const functionName = Symbol.for("functionName");
+//#endregion
+//#region ../../node_modules/.bun/convex@1.46.0+0f58469d5b3bd39f/node_modules/convex/dist/esm/server/components/paths.js
+const toReferencePath = Symbol.for("toReferencePath");
+function extractReferencePath(reference) {
+	return reference[toReferencePath] ?? null;
+}
+function isFunctionHandle(s) {
+	return s.startsWith("function://");
+}
+function getFunctionAddress(functionReference) {
+	let functionAddress;
+	if (typeof functionReference === "string") {
+		if (isFunctionHandle(functionReference)) functionAddress = { functionHandle: functionReference };
+		else functionAddress = { name: functionReference };
+	} else if (functionReference[functionName]) functionAddress = { name: functionReference[functionName] };
+	else {
+		const referencePath = extractReferencePath(functionReference);
+		if (!referencePath) throw new Error(`${functionReference} is not a functionReference`);
+		functionAddress = { reference: referencePath };
+	}
+	return functionAddress;
+}
+//#endregion
+//#region ../../node_modules/.bun/convex@1.46.0+0f58469d5b3bd39f/node_modules/convex/dist/esm/server/api.js
+function getFunctionName(functionReference) {
+	const address = getFunctionAddress(functionReference);
+	if (address.name === void 0) {
+		if (address.functionHandle !== void 0) throw new Error(`Expected function reference like "api.file.func" or "internal.file.func", but received function handle ${address.functionHandle}`);
+		else if (address.reference !== void 0) throw new Error(`Expected function reference in the current component like "api.file.func" or "internal.file.func", but received reference ${address.reference}`);
+		throw new Error(`Expected function reference like "api.file.func" or "internal.file.func", but received ${JSON.stringify(address)}`);
+	}
+	if (typeof functionReference === "string") return functionReference;
+	const name = functionReference[functionName];
+	if (!name) throw new Error(`${functionReference} is not a functionReference`);
+	return name;
+}
+function createApi(pathParts = []) {
+	return new Proxy({}, { get(_, prop) {
+		if (typeof prop === "string") return createApi([...pathParts, prop]);
+		else if (prop === functionName) {
+			if (pathParts.length < 2) {
+				const found = ["api", ...pathParts].join(".");
+				throw new Error(`API path is expected to be of the form \`api.moduleName.functionName\`. Found: \`${found}\``);
+			}
+			const path = pathParts.slice(0, -1).join("/");
+			const exportName = pathParts[pathParts.length - 1];
+			if (exportName === "default") return path;
+			else return path + ":" + exportName;
+		} else if (prop === Symbol.toStringTag) return "FunctionReference";
+		else return;
+	} });
+}
+const anyApi = createApi();
+//#endregion
+//#region ../../node_modules/.bun/convex@1.46.0+0f58469d5b3bd39f/node_modules/convex/dist/esm/server/components/index.js
+function createChildComponents(root, pathParts) {
+	return new Proxy({}, { get(_, prop) {
+		if (typeof prop === "string") return createChildComponents(root, [...pathParts, prop]);
+		else if (prop === toReferencePath) {
+			if (pathParts.length < 1) {
+				const found = [root, ...pathParts].join(".");
+				throw new Error(`API path is expected to be of the form \`${root}.childComponent.functionName\`. Found: \`${found}\``);
+			}
+			return `_reference/childComponent/` + pathParts.join("/");
+		} else return;
+	} });
+}
+const componentsGeneric = () => createChildComponents("components", []);
+//#endregion
+//#region ../backend/convex/_generated/api.js
+/**
+* Generated `api` utility.
+*
+* THIS CODE IS AUTOMATICALLY GENERATED.
+*
+* To regenerate, run `npx convex dev`.
+* @module
+*/
+/**
+* A utility for referencing Convex functions in your app's API.
+*
+* Usage:
+* ```js
+* const myFunctionReference = api.myModule.myFunction;
+* ```
+*/
+const api = anyApi;
+componentsGeneric();
+//#endregion
+//#region ../../node_modules/.bun/convex@1.46.0+0f58469d5b3bd39f/node_modules/convex/dist/esm/browser/logging.js
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value
+}) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+const INFO_COLOR = "color:rgb(0, 145, 255)";
+function prefix_for_source(source) {
+	switch (source) {
+		case "query": return "Q";
+		case "mutation": return "M";
+		case "action": return "A";
+		case "any": return "?";
+	}
+}
+var DefaultLogger = class {
+	constructor(options) {
+		__publicField$1(this, "_onLogLineFuncs");
+		__publicField$1(this, "_verbose");
+		this._onLogLineFuncs = {};
+		this._verbose = options.verbose;
+	}
+	addLogLineListener(func) {
+		let id = Math.random().toString(36).substring(2, 15);
+		for (let i = 0; i < 10; i++) {
+			if (this._onLogLineFuncs[id] === void 0) break;
+			id = Math.random().toString(36).substring(2, 15);
+		}
+		this._onLogLineFuncs[id] = func;
+		return () => {
+			delete this._onLogLineFuncs[id];
+		};
+	}
+	logVerbose(...args) {
+		if (this._verbose) for (const func of Object.values(this._onLogLineFuncs)) func("debug", `${(/* @__PURE__ */ new Date()).toISOString()}`, ...args);
+	}
+	log(...args) {
+		for (const func of Object.values(this._onLogLineFuncs)) func("info", ...args);
+	}
+	warn(...args) {
+		for (const func of Object.values(this._onLogLineFuncs)) func("warn", ...args);
+	}
+	error(...args) {
+		for (const func of Object.values(this._onLogLineFuncs)) func("error", ...args);
+	}
+};
+function instantiateDefaultLogger(options) {
+	const logger = new DefaultLogger(options);
+	logger.addLogLineListener((level, ...args) => {
+		switch (level) {
+			case "debug":
+				console.debug(...args);
+				break;
+			case "info":
+				console.log(...args);
+				break;
+			case "warn":
+				console.warn(...args);
+				break;
+			case "error":
+				console.error(...args);
+				break;
+			default: console.log(...args);
+		}
+	});
+	return logger;
+}
+function instantiateNoopLogger(options) {
+	return new DefaultLogger(options);
+}
+function logForFunction(logger, type, source, udfPath, message) {
+	const prefix = prefix_for_source(source);
+	if (typeof message === "object") message = `ConvexError ${JSON.stringify(message.errorData, null, 2)}`;
+	if (type === "info") {
+		const match = message.match(/^\[.*?\] /);
+		if (match === null) {
+			logger.error(`[CONVEX ${prefix}(${udfPath})] Could not parse console.log`);
+			return;
+		}
+		const level = message.slice(1, match[0].length - 2);
+		const args = message.slice(match[0].length);
+		logger.log(`%c[CONVEX ${prefix}(${udfPath})] [${level}]`, INFO_COLOR, args);
+	} else logger.error(`[CONVEX ${prefix}(${udfPath})] ${message}`);
+}
+//#endregion
+//#region ../../node_modules/.bun/convex@1.46.0+0f58469d5b3bd39f/node_modules/convex/dist/esm/browser/http_client.js
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value
+}) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var ConvexHttpClient = class {
+	/**
+	* Create a new {@link ConvexHttpClient}.
+	*
+	* @param address - The url of your Convex deployment, often provided
+	* by an environment variable. E.g. `https://small-mouse-123.convex.cloud`.
+	* @param options - An object of options.
+	* - `skipConvexDeploymentUrlCheck` - Skip validating that the Convex deployment URL looks like
+	* `https://happy-animal-123.convex.cloud` or localhost. This can be useful if running a self-hosted
+	* Convex backend that uses a different URL.
+	* - `logger` - A logger or a boolean. If not provided, logs to the console.
+	* You can construct your own logger to customize logging to log elsewhere
+	* or not log at all, or use `false` as a shorthand for a no-op logger.
+	* A logger is an object with 4 methods: log(), warn(), error(), and logVerbose().
+	* These methods can receive multiple arguments of any types, like console.log().
+	* - `auth` - A JWT containing identity claims accessible in Convex functions.
+	* This identity may expire so it may be necessary to call `setAuth()` later,
+	* but for short-lived clients it's convenient to specify this value here.
+	* - `fetch` - A custom fetch implementation to use for all HTTP requests made by this client.
+	*/
+	constructor(address, options) {
+		__publicField(this, "address");
+		__publicField(this, "auth");
+		__publicField(this, "adminAuth");
+		__publicField(this, "encodedTsPromise");
+		__publicField(this, "debug");
+		__publicField(this, "fetchOptions");
+		__publicField(this, "fetch");
+		__publicField(this, "logger");
+		__publicField(this, "mutationQueue", []);
+		__publicField(this, "isProcessingQueue", false);
+		if (typeof options === "boolean") throw new Error("skipConvexDeploymentUrlCheck as the second argument is no longer supported. Please pass an options object, `{ skipConvexDeploymentUrlCheck: true }`.");
+		if ((options ?? {}).skipConvexDeploymentUrlCheck !== true) validateDeploymentUrl(address);
+		this.logger = options?.logger === false ? instantiateNoopLogger({ verbose: false }) : options?.logger !== true && options?.logger ? options.logger : instantiateDefaultLogger({ verbose: false });
+		this.address = address;
+		this.debug = true;
+		this.auth = void 0;
+		this.adminAuth = void 0;
+		this.fetch = options?.fetch;
+		if (options?.auth) this.setAuth(options.auth);
+	}
+	/**
+	* Obtain the {@link ConvexHttpClient}'s URL to its backend.
+	* @deprecated Use url, which returns the url without /api at the end.
+	*
+	* @returns The URL to the Convex backend, including the client's API version.
+	*/
+	backendUrl() {
+		return `${this.address}/api`;
+	}
+	/**
+	* Return the address for this client, useful for creating a new client.
+	*
+	* Not guaranteed to match the address with which this client was constructed:
+	* it may be canonicalized.
+	*/
+	get url() {
+		return this.address;
+	}
+	/**
+	* Set the authentication token to be used for subsequent queries and mutations.
+	*
+	* Should be called whenever the token changes (i.e. due to expiration and refresh).
+	*
+	* @param value - JWT-encoded OpenID Connect identity token.
+	*/
+	setAuth(value) {
+		this.clearAuth();
+		this.auth = value;
+	}
+	/**
+	* Set admin auth token to allow calling internal queries, mutations, and actions
+	* and acting as an identity.
+	*
+	* @internal
+	*/
+	setAdminAuth(token, actingAsIdentity) {
+		this.clearAuth();
+		if (actingAsIdentity !== void 0) {
+			const bytes = new TextEncoder().encode(JSON.stringify(actingAsIdentity));
+			const actingAsIdentityEncoded = btoa(String.fromCodePoint(...bytes));
+			this.adminAuth = `${token}:${actingAsIdentityEncoded}`;
+		} else this.adminAuth = token;
+	}
+	/**
+	* Clear the current authentication token if set.
+	*/
+	clearAuth() {
+		this.auth = void 0;
+		this.adminAuth = void 0;
+	}
+	/**
+	* Sets whether the result log lines should be printed on the console or not.
+	*
+	* @internal
+	*/
+	setDebug(debug) {
+		this.debug = debug;
+	}
+	/**
+	* Used to customize the fetch behavior in some runtimes.
+	*
+	* @internal
+	*/
+	setFetchOptions(fetchOptions) {
+		this.fetchOptions = fetchOptions;
+	}
+	/**
+	* This API is experimental: it may change or disappear.
+	*
+	* Execute a Convex query function at the same timestamp as every other
+	* consistent query execution run by this HTTP client.
+	*
+	* This doesn't make sense for long-lived ConvexHttpClients as Convex
+	* backends can read a limited amount into the past: beyond 30 seconds
+	* in the past may not be available.
+	*
+	* Create a new client to use a consistent time.
+	*
+	* @param name - The name of the query.
+	* @param args - The arguments object for the query. If this is omitted,
+	* the arguments will be `{}`.
+	* @returns A promise of the query's result.
+	*
+	* @deprecated This API is experimental: it may change or disappear.
+	*/
+	async consistentQuery(query, ...args) {
+		const queryArgs = parseArgs$1(args[0]);
+		const timestampPromise = this.getTimestamp();
+		return await this.queryInner(query, queryArgs, { timestampPromise });
+	}
+	async getTimestamp() {
+		if (this.encodedTsPromise) return this.encodedTsPromise;
+		return this.encodedTsPromise = this.getTimestampInner();
+	}
+	async getTimestampInner() {
+		const localFetch = this.fetch || fetch;
+		const headers = {
+			"Content-Type": "application/json",
+			"Convex-Client": `npm-${version}`
+		};
+		const response = await localFetch(`${this.address}/api/query_ts`, {
+			...this.fetchOptions,
+			method: "POST",
+			headers
+		});
+		if (!response.ok) throw new Error(await response.text());
+		const { ts } = await response.json();
+		return ts;
+	}
+	/**
+	* Execute a Convex query function.
+	*
+	* @param name - The name of the query.
+	* @param args - The arguments object for the query. If this is omitted,
+	* the arguments will be `{}`.
+	* @returns A promise of the query's result.
+	*/
+	async query(query, ...args) {
+		const queryArgs = parseArgs$1(args[0]);
+		return await this.queryInner(query, queryArgs, {});
+	}
+	async queryInner(query, queryArgs, options) {
+		const name = getFunctionName(query);
+		const args = [convexToJson(queryArgs)];
+		const headers = {
+			"Content-Type": "application/json",
+			"Convex-Client": `npm-${version}`
+		};
+		if (this.adminAuth) headers["Authorization"] = `Convex ${this.adminAuth}`;
+		else if (this.auth) headers["Authorization"] = `Bearer ${this.auth}`;
+		const localFetch = this.fetch || fetch;
+		const timestamp = options.timestampPromise ? await options.timestampPromise : void 0;
+		const body = JSON.stringify({
+			path: name,
+			format: "convex_encoded_json",
+			args,
+			...timestamp ? { ts: timestamp } : {}
+		});
+		const response = await localFetch(timestamp ? `${this.address}/api/query_at_ts` : `${this.address}/api/query`, {
+			...this.fetchOptions,
+			body,
+			method: "POST",
+			headers
+		});
+		if (!response.ok && response.status !== 560) throw new Error(await response.text());
+		const respJSON = await response.json();
+		if (this.debug) for (const line of respJSON.logLines ?? []) logForFunction(this.logger, "info", "query", name, line);
+		switch (respJSON.status) {
+			case "success": return jsonToConvex(respJSON.value);
+			case "error":
+				if (respJSON.errorData !== void 0) throw forwardErrorData(respJSON.errorData, new ConvexError(respJSON.errorMessage));
+				throw new Error(respJSON.errorMessage);
+			default: throw new Error(`Invalid response: ${JSON.stringify(respJSON)}`);
+		}
+	}
+	async mutationInner(mutation, mutationArgs) {
+		const name = getFunctionName(mutation);
+		const body = JSON.stringify({
+			path: name,
+			format: "convex_encoded_json",
+			args: [convexToJson(mutationArgs)]
+		});
+		const headers = {
+			"Content-Type": "application/json",
+			"Convex-Client": `npm-${version}`
+		};
+		if (this.adminAuth) headers["Authorization"] = `Convex ${this.adminAuth}`;
+		else if (this.auth) headers["Authorization"] = `Bearer ${this.auth}`;
+		const response = await (this.fetch || fetch)(`${this.address}/api/mutation`, {
+			...this.fetchOptions,
+			body,
+			method: "POST",
+			headers
+		});
+		if (!response.ok && response.status !== 560) throw new Error(await response.text());
+		const respJSON = await response.json();
+		if (this.debug) for (const line of respJSON.logLines ?? []) logForFunction(this.logger, "info", "mutation", name, line);
+		switch (respJSON.status) {
+			case "success": return jsonToConvex(respJSON.value);
+			case "error":
+				if (respJSON.errorData !== void 0) throw forwardErrorData(respJSON.errorData, new ConvexError(respJSON.errorMessage));
+				throw new Error(respJSON.errorMessage);
+			default: throw new Error(`Invalid response: ${JSON.stringify(respJSON)}`);
+		}
+	}
+	async processMutationQueue() {
+		if (this.isProcessingQueue) return;
+		this.isProcessingQueue = true;
+		while (this.mutationQueue.length > 0) {
+			const { mutation, args, resolve, reject } = this.mutationQueue.shift();
+			try {
+				resolve(await this.mutationInner(mutation, args));
+			} catch (error) {
+				reject(error);
+			}
+		}
+		this.isProcessingQueue = false;
+	}
+	enqueueMutation(mutation, args) {
+		return new Promise((resolve, reject) => {
+			this.mutationQueue.push({
+				mutation,
+				args,
+				resolve,
+				reject
+			});
+			this.processMutationQueue();
+		});
+	}
+	/**
+	* Execute a Convex mutation function. Mutations are queued by default.
+	*
+	* @param name - The name of the mutation.
+	* @param args - The arguments object for the mutation. If this is omitted,
+	* the arguments will be `{}`.
+	* @param options - An optional object containing
+	* @returns A promise of the mutation's result.
+	*/
+	async mutation(mutation, ...args) {
+		const [fnArgs, options] = args;
+		const mutationArgs = parseArgs$1(fnArgs);
+		if (!options?.skipQueue) return await this.enqueueMutation(mutation, mutationArgs);
+		else return await this.mutationInner(mutation, mutationArgs);
+	}
+	/**
+	* Execute a Convex action function. Actions are not queued.
+	*
+	* @param name - The name of the action.
+	* @param args - The arguments object for the action. If this is omitted,
+	* the arguments will be `{}`.
+	* @returns A promise of the action's result.
+	*/
+	async action(action, ...args) {
+		const actionArgs = parseArgs$1(args[0]);
+		const name = getFunctionName(action);
+		const body = JSON.stringify({
+			path: name,
+			format: "convex_encoded_json",
+			args: [convexToJson(actionArgs)]
+		});
+		const headers = {
+			"Content-Type": "application/json",
+			"Convex-Client": `npm-${version}`
+		};
+		if (this.adminAuth) headers["Authorization"] = `Convex ${this.adminAuth}`;
+		else if (this.auth) headers["Authorization"] = `Bearer ${this.auth}`;
+		const response = await (this.fetch || fetch)(`${this.address}/api/action`, {
+			...this.fetchOptions,
+			body,
+			method: "POST",
+			headers
+		});
+		if (!response.ok && response.status !== 560) throw new Error(await response.text());
+		const respJSON = await response.json();
+		if (this.debug) for (const line of respJSON.logLines ?? []) logForFunction(this.logger, "info", "action", name, line);
+		switch (respJSON.status) {
+			case "success": return jsonToConvex(respJSON.value);
+			case "error":
+				if (respJSON.errorData !== void 0) throw forwardErrorData(respJSON.errorData, new ConvexError(respJSON.errorMessage));
+				throw new Error(respJSON.errorMessage);
+			default: throw new Error(`Invalid response: ${JSON.stringify(respJSON)}`);
+		}
+	}
+	/**
+	* Execute a Convex function of an unknown type. These function calls are not queued.
+	*
+	* @param name - The name of the function.
+	* @param args - The arguments object for the function. If this is omitted,
+	* the arguments will be `{}`.
+	* @returns A promise of the function's result.
+	*
+	* @internal
+	*/
+	async function(anyFunction, componentPath, ...args) {
+		const functionArgs = parseArgs$1(args[0]);
+		const name = typeof anyFunction === "string" ? anyFunction : getFunctionName(anyFunction);
+		const body = JSON.stringify({
+			componentPath,
+			path: name,
+			format: "convex_encoded_json",
+			args: convexToJson(functionArgs)
+		});
+		const headers = {
+			"Content-Type": "application/json",
+			"Convex-Client": `npm-${version}`
+		};
+		if (this.adminAuth) headers["Authorization"] = `Convex ${this.adminAuth}`;
+		else if (this.auth) headers["Authorization"] = `Bearer ${this.auth}`;
+		const response = await (this.fetch || fetch)(`${this.address}/api/function`, {
+			...this.fetchOptions,
+			body,
+			method: "POST",
+			headers
+		});
+		if (!response.ok && response.status !== 560) throw new Error(await response.text());
+		const respJSON = await response.json();
+		if (this.debug) for (const line of respJSON.logLines ?? []) logForFunction(this.logger, "info", "any", name, line);
+		switch (respJSON.status) {
+			case "success": return jsonToConvex(respJSON.value);
+			case "error":
+				if (respJSON.errorData !== void 0) throw forwardErrorData(respJSON.errorData, new ConvexError(respJSON.errorMessage));
+				throw new Error(respJSON.errorMessage);
+			default: throw new Error(`Invalid response: ${JSON.stringify(respJSON)}`);
+		}
+	}
+};
+function forwardErrorData(errorData, error) {
+	error.data = jsonToConvex(errorData);
+	return error;
+}
+//#endregion
+//#region src/remote.ts
+var RemoteError = class extends Error {
+	code;
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+	}
+};
+/** The message from a Convex error, with a stable code. */
+function wrap(error) {
+	const data = error?.data;
+	if (data?.message) return new RemoteError(data.message, data.code ?? "error");
+	const message = error instanceof Error ? error.message : String(error);
+	if (/ArgumentValidationError|Value does not match/.test(message)) return new RemoteError("That is not a valid comment ID", "invalid");
+	return new RemoteError(message, "network");
+}
+async function call(fn) {
+	try {
+		return await fn();
+	} catch (error) {
+		throw wrap(error);
+	}
+}
+async function postJson(path, body) {
+	let res;
+	try {
+		res = await fetch(`${CONVEX_SITE_URL}${path}`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		});
+	} catch (error) {
+		throw new RemoteError(`Could not reach Nuni (${error instanceof Error ? error.message : String(error)})`, "network");
+	}
+	const data = await res.json().catch(() => ({}));
+	return {
+		status: res.status,
+		data
+	};
+}
+function createRemote() {
+	const client = new ConvexHttpClient(CONVEX_URL, {
+		skipConvexDeploymentUrlCheck: !/\.convex\.cloud\/?$/.test(CONVEX_URL),
+		logger: false
+	});
+	return {
+		async startLogin(publicId, clientName) {
+			const { status, data } = await postJson("/cli/login/start", {
+				publicId,
+				client: clientName
+			});
+			if (status !== 201) throw new RemoteError(String(data.message ?? `Sign-in failed (${status})`), String(data.code ?? "error"));
+			return data;
+		},
+		async pollLogin(deviceSecret) {
+			const { status, data } = await postJson("/cli/login/poll", { deviceSecret });
+			if (status === 429) return { status: "slow_down" };
+			if (status >= 500) throw new RemoteError(String(data.message ?? "Server error"), "server");
+			return data;
+		},
+		whoami: (publicId, token) => call(() => client.query(api.sessions.validate, {
+			publicId,
+			sessionToken: token
+		})),
+		logout: (token) => call(async () => {
+			await client.mutation(api.sessions.revokeOwn, { sessionToken: token });
+		}),
+		listComments: (publicId, token, options = {}) => call(async () => {
+			return await client.query(api.comments.listForAgent, {
+				publicId,
+				sessionToken: token,
+				...options
+			});
+		}),
+		getComment: (publicId, token, id) => call(async () => {
+			return await client.query(api.comments.getForOwner, {
+				publicId,
+				id,
+				sessionToken: token
+			});
+		}),
+		setStatus: (token, id, status) => call(async () => {
+			const fn = status === "resolved" ? api.comments.resolve : api.comments.reopen;
+			await client.mutation(fn, {
+				id,
+				sessionToken: token
+			});
+		}),
+		reply: (publicId, token, id, body) => call(async () => {
+			await client.mutation(api.replies.replyAsOwner, {
+				publicId,
+				commentId: id,
+				body,
+				sessionToken: token
+			});
+		})
+	};
+}
+//#endregion
+//#region src/mcp.ts
+/**
+* A Model Context Protocol server over stdio (newline-delimited JSON-RPC),
+* so coding agents can read and resolve comments:
+*
+*   claude mcp add nuni -- npx -y @nuniapp/cli@latest mcp
+*
+* Tools only. Small on purpose, with no dependencies: initialize, ping,
+* tools/list and tools/call.
+*/
+const PROTOCOL_VERSIONS = [
+	"2025-11-25",
+	"2025-06-18",
+	"2025-03-26",
+	"2024-11-05"
+];
+const LOGIN$1 = `npx ${PACKAGES.cli}@latest login`;
+var ToolError = class extends Error {};
+const text = (value) => ({ content: [{
+	type: "text",
+	text: value
+}] });
+function str(args, name) {
+	const value = args[name];
+	if (typeof value !== "string" || !value.trim()) throw new ToolError(`"${name}" is required`);
+	return value.trim();
+}
+async function fetchImage(url) {
+	try {
+		const res = await fetch(url);
+		if (!res.ok) return null;
+		const mimeType = res.headers.get("Content-Type")?.split(";")[0] ?? "image/webp";
+		return {
+			data: Buffer.from(await res.arrayBuffer()).toString("base64"),
+			mimeType
+		};
+	} catch {
+		return null;
+	}
+}
+function createMcpServer(options) {
+	const { remote } = options;
+	let project = null;
+	function session() {
+		try {
+			project ??= resolveProject(options.project, options.cwd).id;
+		} catch (error) {
+			if (error instanceof ProjectError) throw new ToolError(error.message);
+			throw error;
+		}
+		const credential = credentialFor(project);
+		if (!credential) throw new ToolError(`Not signed in to the Nuni project ${project}. Ask the user to run \`${LOGIN$1}\` in this project (it opens the Nuni dashboard to approve), then try again.`);
+		return {
+			publicId: project,
+			token: credential.token
+		};
+	}
+	const tools = [
+		{
+			name: "list_comments",
+			title: "List Nuni comments",
+			description: "List feedback comments left on the live site with Nuni, newest first. Each has an id, the page, the author and the element it is pinned to. Use get_comment for the full context.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					status: {
+						type: "string",
+						enum: ["open", "resolved"],
+						description: "Defaults to open."
+					},
+					page: {
+						type: "string",
+						description: "Only comments on this path, for example /pricing."
+					},
+					limit: {
+						type: "integer",
+						minimum: 1,
+						maximum: 50
+					}
+				},
+				additionalProperties: false
+			},
+			annotations: { readOnlyHint: true },
+			async run(args) {
+				const { publicId, token } = session();
+				const status = args.status === "resolved" ? "resolved" : "open";
+				const page = await remote.listComments(publicId, token, {
+					status,
+					path: typeof args.page === "string" ? args.page : void 0,
+					limit: typeof args.limit === "number" ? args.limit : 20
+				});
+				return text(formatCommentList(page.comments, {
+					status,
+					more: Boolean(page.cursor),
+					detailHint: "Call get_comment with an id for the element, DOM, styles, console errors, failed requests and screenshot."
+				}));
+			}
+		},
+		{
+			name: "get_comment",
+			title: "Get a Nuni comment",
+			description: "One comment with everything needed to fix it: the comment, the page link, the element (text, selectors, React component), its HTML and styles, console errors, failed requests and a screenshot.",
+			inputSchema: {
+				type: "object",
+				properties: { id: {
+					type: "string",
+					description: "The comment id."
+				} },
+				required: ["id"],
+				additionalProperties: false
+			},
+			annotations: { readOnlyHint: true },
+			async run(args) {
+				const { publicId, token } = session();
+				const comment = await remote.getComment(publicId, token, str(args, "id"));
+				if (!comment) throw new ToolError("No comment with that id in this project");
+				const content = [{
+					type: "text",
+					text: buildCommentPrompt(comment)
+				}];
+				if (comment.screenshotUrl) {
+					const image = await (options.fetchImage ?? fetchImage)(comment.screenshotUrl);
+					if (image) content.push({
+						type: "image",
+						...image
+					});
+				}
+				return { content };
+			}
+		},
+		{
+			name: "reply_to_comment",
+			title: "Reply to a Nuni comment",
+			description: "Reply in a comment's thread as the project owner, for example to ask a question or say what changed. Everyone on the site can read replies.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					id: {
+						type: "string",
+						description: "The comment id."
+					},
+					body: {
+						type: "string",
+						description: "The reply."
+					}
+				},
+				required: ["id", "body"],
+				additionalProperties: false
+			},
+			async run(args) {
+				const { publicId, token } = session();
+				const id = str(args, "id");
+				await remote.reply(publicId, token, id, str(args, "body"));
+				return text(`Replied to ${id}.`);
+			}
+		},
+		{
+			name: "resolve_comment",
+			title: "Resolve a Nuni comment",
+			description: "Mark a comment as resolved once the change it asks for is made. Visitors see it as resolved on the site. Add a note to say what changed; it is posted as a reply.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					id: { type: "string" },
+					note: {
+						type: "string",
+						description: "Optional: what was changed, posted as a reply first."
+					}
+				},
+				required: ["id"],
+				additionalProperties: false
+			},
+			annotations: { idempotentHint: true },
+			async run(args) {
+				const { publicId, token } = session();
+				const id = str(args, "id");
+				await remote.setStatus(token, id, "resolved");
+				if (typeof args.note === "string" && args.note.trim()) await remote.reply(publicId, token, id, args.note.trim());
+				return text(`Resolved ${id}.`);
+			}
+		},
+		{
+			name: "reopen_comment",
+			title: "Reopen a Nuni comment",
+			description: "Reopen a resolved comment.",
+			inputSchema: {
+				type: "object",
+				properties: { id: { type: "string" } },
+				required: ["id"],
+				additionalProperties: false
+			},
+			annotations: { idempotentHint: true },
+			async run(args) {
+				const { token } = session();
+				const id = str(args, "id");
+				await remote.setStatus(token, id, "open");
+				return text(`Reopened ${id}.`);
+			}
+		}
+	];
+	async function callTool(params) {
+		const tool = tools.find((t) => t.name === params.name);
+		if (!tool) throw new RpcError(-32602, `Unknown tool: ${String(params.name)}`);
+		try {
+			return await tool.run(params.arguments ?? {});
+		} catch (error) {
+			if (error instanceof ToolError || error instanceof RemoteError) return {
+				content: [{
+					type: "text",
+					text: error instanceof RemoteError && error.code === "unauthenticated" ? `${error.message}. Ask the user to run \`${LOGIN$1}\` in this project, then try again.` : error.message
+				}],
+				isError: true
+			};
+			throw error;
+		}
+	}
+	/** Handle one message. Notifications get no response (null). */
+	async function handle(message) {
+		const id = message.id ?? null;
+		const isNotification = message.id === void 0;
+		try {
+			let result;
+			switch (message.method) {
+				case "initialize": {
+					const requested = String(message.params?.protocolVersion ?? "");
+					result = {
+						protocolVersion: PROTOCOL_VERSIONS.includes(requested) ? requested : PROTOCOL_VERSIONS[0],
+						capabilities: { tools: {} },
+						serverInfo: {
+							name: "nuni",
+							title: "Nuni",
+							version: options.version
+						},
+						instructions: "Nuni comments are feedback pinned to elements on the live site. List them, read one with its full context, fix the code, then resolve it."
+					};
+					break;
+				}
+				case "ping":
+					result = {};
+					break;
+				case "tools/list":
+					result = { tools: tools.map(({ run: _run, ...tool }) => tool) };
+					break;
+				case "tools/call":
+					result = await callTool(message.params ?? {});
+					break;
+				default:
+					if (isNotification) return null;
+					throw new RpcError(-32601, `Method not found: ${message.method}`);
+			}
+			return isNotification ? null : {
+				jsonrpc: "2.0",
+				id,
+				result
+			};
+		} catch (error) {
+			if (isNotification) return null;
+			const rpc = error instanceof RpcError ? error : new RpcError(-32603, error instanceof Error ? error.message : String(error));
+			return {
+				jsonrpc: "2.0",
+				id,
+				error: {
+					code: rpc.code,
+					message: rpc.message
+				}
+			};
+		}
+	}
+	return {
+		handle,
+		tools
+	};
+}
+var RpcError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+/** Serve on stdin/stdout until stdin closes. Logs go to stderr only. */
+async function serveStdio(server) {
+	const write = (message) => {
+		process.stdout.write(`${JSON.stringify(message)}\n`);
+	};
+	const pending = /* @__PURE__ */ new Set();
+	const lines = createInterface({
+		input: process.stdin,
+		crlfDelay: Infinity
+	});
+	for await (const line of lines) {
+		if (!line.trim()) continue;
+		let message;
+		try {
+			message = JSON.parse(line);
+		} catch {
+			write({
+				jsonrpc: "2.0",
+				id: null,
+				error: {
+					code: -32700,
+					message: "Parse error"
+				}
+			});
+			continue;
+		}
+		for (const request of Array.isArray(message) ? message : [message]) {
+			const task = server.handle(request).then((response) => {
+				if (response) write(response);
+			});
+			pending.add(task);
+			task.finally(() => pending.delete(task));
+		}
+	}
+	await Promise.all(pending);
+}
+//#endregion
+//#region src/commands.ts
+const LOGIN = `npx ${PACKAGES.cli}@latest login`;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var CommandError = class extends Error {};
+function signedIn(ctx) {
+	const project = resolveProject(ctx.project, ctx.cwd);
+	const credential = credentialFor(project.id);
+	if (!credential) throw new CommandError(`Not signed in to ${project.id}. Run \`${LOGIN}\` first.`);
+	return {
+		publicId: project.id,
+		token: credential.token
+	};
+}
+/** Try to open the approval page, quietly: there may be no browser at all. */
+function openInBrowser(url) {
+	if (!process.stdout.isTTY || process.env.CI || process.env.SSH_CONNECTION) return;
+	const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", [
+		"/c",
+		"start",
+		"",
+		url
+	]] : ["xdg-open", [url]];
+	try {
+		const child = spawn(command, args, {
+			stdio: "ignore",
+			detached: true
+		});
+		child.on("error", () => {});
+		child.unref();
+	} catch {}
+}
+async function login(ctx) {
+	const project = resolveProject(ctx.project, ctx.cwd);
+	const client = `nuni-cli ${ctx.version} (${process.platform}; node ${process.versions.node})`;
+	const start = await ctx.remote.startLogin(project.id, client);
+	const url = `${APP_URL}/dashboard/cli?code=${start.userCode}`;
+	if (ctx.json) ctx.out(JSON.stringify({
+		status: "waiting",
+		url,
+		code: start.userCode
+	}));
+	else ctx.out(`Signing in to ${project.id} (${project.source}).
+
+  Open  ${url}
+  Code  ${start.userCode}
+
+Check that the code matches, then approve. Waiting…`);
+	(ctx.openBrowser ?? openInBrowser)(url);
+	let delay = ctx.pollMs ?? 2e3;
+	for (;;) {
+		await sleep(delay);
+		const result = await ctx.remote.pollLogin(start.deviceSecret);
+		if (result.status === "pending") continue;
+		if (result.status === "slow_down") {
+			delay *= 2;
+			continue;
+		}
+		if (result.status === "approved") {
+			saveCredential(project.id, {
+				token: result.token,
+				ownerName: result.ownerName,
+				projectName: result.projectName,
+				expiresAt: result.expiresAt
+			});
+			if (ctx.json) ctx.out(JSON.stringify({
+				status: "signed_in",
+				project: project.id,
+				owner: result.ownerName
+			}));
+			else ctx.out(`Signed in as ${result.ownerName} to ${result.projectName}. Saved to ${credentialsPath()}`);
+			return 0;
+		}
+		const message = result.status === "denied" ? "The sign-in was denied." : "The code expired. Run login again.";
+		if (ctx.json) ctx.out(JSON.stringify({
+			status: result.status,
+			message
+		}));
+		else ctx.err(message);
+		return 1;
+	}
+}
+async function logout(ctx) {
+	const project = resolveProject(ctx.project, ctx.cwd);
+	const credential = credentialFor(project.id);
+	if (credential && !process.env.NUNI_TOKEN) await ctx.remote.logout(credential.token).catch(() => {});
+	const removed = removeCredential(project.id);
+	ctx.out(removed ? `Signed out of ${project.id}.` : `Not signed in to ${project.id}.`);
+	return 0;
+}
+async function whoami(ctx) {
+	const project = resolveProject(ctx.project, ctx.cwd);
+	const credential = credentialFor(project.id);
+	const result = credential ? await ctx.remote.whoami(project.id, credential.token) : { valid: false };
+	if (ctx.json) ctx.out(JSON.stringify({
+		project: project.id,
+		signedIn: result.valid,
+		owner: result.ownerName ?? null
+	}));
+	else if (result.valid) ctx.out(`Signed in to ${project.id} as ${result.ownerName}.`);
+	else ctx.out(`Not signed in to ${project.id}. Run \`${LOGIN}\`.`);
+	return result.valid ? 0 : 1;
+}
+async function listComments(ctx, options) {
+	const { publicId, token } = signedIn(ctx);
+	if (options.status && options.status !== "open" && options.status !== "resolved") throw new CommandError(`--status must be open or resolved`);
+	const status = options.status ?? "open";
+	const limit = options.limit ? Number(options.limit) : 20;
+	if (!Number.isInteger(limit) || limit < 1) throw new CommandError(`--limit must be a positive number`);
+	const page = await ctx.remote.listComments(publicId, token, {
+		status,
+		path: options.page,
+		limit
+	});
+	if (ctx.json) {
+		ctx.out(JSON.stringify(page, null, 2));
+		return 0;
+	}
+	ctx.out(formatCommentList(page.comments, {
+		status,
+		more: Boolean(page.cursor),
+		detailHint: `Full context: npx ${PACKAGES.cli}@latest comment <id>`
+	}));
+	return 0;
+}
+async function showComment(ctx, id, options) {
+	if (!id) throw new CommandError("Pass a comment id: comment <id>");
+	const { publicId, token } = signedIn(ctx);
+	const comment = await ctx.remote.getComment(publicId, token, id);
+	if (!comment) throw new CommandError(`No comment ${id} in ${publicId}.`);
+	let saved = null;
+	if (options.saveScreenshot && comment.screenshotUrl) {
+		const image = await fetchImage(comment.screenshotUrl);
+		if (image) {
+			const dir = resolve(ctx.cwd, options.saveScreenshot);
+			mkdirSync(dir, { recursive: true });
+			const ext = image.mimeType.split("/")[1] ?? "webp";
+			saved = join(dir, `nuni-${comment._id}.${ext}`);
+			writeFileSync(saved, Buffer.from(image.data, "base64"));
+		}
+	}
+	if (ctx.json) {
+		ctx.out(JSON.stringify({
+			...comment,
+			screenshotFile: saved
+		}, null, 2));
+		return 0;
+	}
+	ctx.out(buildCommentPrompt(comment));
+	if (saved) ctx.out(`\nScreenshot saved to ${saved}`);
+	return 0;
+}
+async function reply(ctx, id, body) {
+	if (!id || !body?.trim()) throw new CommandError("Pass a comment id and a message: reply <id> \"message\"");
+	const { publicId, token } = signedIn(ctx);
+	await ctx.remote.reply(publicId, token, id, body);
+	ctx.out(ctx.json ? JSON.stringify({
+		id,
+		replied: true
+	}) : `Replied to ${id}.`);
+	return 0;
+}
+async function setStatus(ctx, id, status, note) {
+	const verb = status === "resolved" ? "resolve" : "reopen";
+	if (!id) throw new CommandError(`Pass a comment id: ${verb} <id>`);
+	const { publicId, token } = signedIn(ctx);
+	await ctx.remote.setStatus(token, id, status);
+	if (note?.trim()) await ctx.remote.reply(publicId, token, id, note);
+	ctx.out(ctx.json ? JSON.stringify({
+		id,
+		status
+	}) : `${status === "resolved" ? "Resolved" : "Reopened"} ${id}.`);
+	return 0;
+}
+//#endregion
 //#region src/detect.ts
 function readPackage(cwd) {
 	try {
@@ -285,7 +1996,7 @@ init({ project: "${projectId}" })`;
 }
 //#endregion
 //#region src/cli.ts
-const VERSION = version;
+const VERSION = version$1;
 const HELP = `nuni ${VERSION}: pinned comments on your live site
 
 Usage
@@ -293,38 +2004,81 @@ Usage
   npx @nuniapp/cli@latest prompt [--id <project-id>]
   npx @nuniapp/cli@latest id
 
+  npx @nuniapp/cli@latest login              sign in to this project's comments
+  npx @nuniapp/cli@latest comments [--status open|resolved] [--page /path] [--limit 20]
+  npx @nuniapp/cli@latest comment <id> [--save-screenshot <dir>]
+  npx @nuniapp/cli@latest reply <id> "message"
+  npx @nuniapp/cli@latest resolve <id> [--note "what changed"]
+  npx @nuniapp/cli@latest reopen <id>
+  npx @nuniapp/cli@latest whoami | logout
+  npx @nuniapp/cli@latest mcp                MCP server for coding agents (stdio)
+
 Commands
-  init     Generate a project ID and print the install steps for this project
-  prompt   Print the ready-made prompt for Codex, Claude Code, Cursor, etc.
-  id       Print a new project ID
+  init      Generate a project ID and print the install steps for this project
+  prompt    Print the ready-made prompt for Codex, Claude Code, Cursor, etc.
+  id        Print a new project ID
+  login     Approve this terminal in the Nuni dashboard (works over SSH too)
+  comments  List comments, newest first
+  comment   One comment with the element, DOM, styles, console and screenshot
+  reply     Reply in a comment's thread, as the owner
+  resolve   Mark a comment resolved (with an optional note); reopen does the opposite
+  mcp       Run the MCP server: claude mcp add nuni -- npx -y @nuniapp/cli@latest mcp
+
+The project comes from --project, $NUNI_PROJECT, or the nuni_ ID in your code.
+Add --json to any command for machine-readable output.
 
 Docs: ${DOCS_URL}`;
 const bold = (s) => process.stdout.isTTY ? `\x1b[1m${s}\x1b[22m` : s;
 const dim = (s) => process.stdout.isTTY ? `\x1b[2m${s}\x1b[22m` : s;
-function run(argv) {
-	const { values, positionals } = parseArgs({
-		args: argv,
-		allowPositionals: true,
-		options: {
-			id: { type: "string" },
-			cwd: { type: "string" },
-			json: {
-				type: "boolean",
-				default: false
-			},
-			help: {
-				type: "boolean",
-				short: "h",
-				default: false
-			},
-			version: {
-				type: "boolean",
-				short: "v",
-				default: false
-			}
-		}
-	});
+const OPTIONS = {
+	id: { type: "string" },
+	project: {
+		type: "string",
+		short: "p"
+	},
+	cwd: { type: "string" },
+	status: { type: "string" },
+	page: { type: "string" },
+	limit: { type: "string" },
+	"save-screenshot": { type: "string" },
+	note: { type: "string" },
+	json: {
+		type: "boolean",
+		default: false
+	},
+	help: {
+		type: "boolean",
+		short: "h",
+		default: false
+	},
+	version: {
+		type: "boolean",
+		short: "v",
+		default: false
+	}
+};
+const ACCOUNT_COMMANDS = /* @__PURE__ */ new Set([
+	"login",
+	"logout",
+	"whoami",
+	"comments",
+	"comment",
+	"reply",
+	"resolve",
+	"reopen",
+	"mcp"
+]);
+async function run(argv, options = {}) {
+	let parsed;
+	try {
+		parsed = parse(argv);
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : String(error));
+		return 1;
+	}
+	const { values, positionals } = parsed;
 	const command = positionals[0] ?? "init";
+	if (ACCOUNT_COMMANDS.has(command) && !values.help) return runAccountCommand(command, positionals, values, options);
 	if (values.version) {
 		console.log(VERSION);
 		return 0;
@@ -389,8 +2143,58 @@ ${dim(`Docs: ${DOCS_URL}`)}
 `);
 	return 0;
 }
+function parse(argv) {
+	return parseArgs({
+		args: argv,
+		allowPositionals: true,
+		options: OPTIONS
+	});
+}
+async function runAccountCommand(command, positionals, values, options) {
+	const arg = positionals[1];
+	const ctx = {
+		remote: options.remote ?? createRemote(),
+		version: VERSION,
+		cwd: resolve(values.cwd ?? process.cwd()),
+		project: values.project ?? values.id,
+		json: values.json,
+		out: options.out ?? ((line) => console.log(line)),
+		err: options.err ?? ((line) => console.error(line)),
+		pollMs: options.pollMs,
+		openBrowser: options.openBrowser
+	};
+	try {
+		switch (command) {
+			case "login": return await login(ctx);
+			case "logout": return await logout(ctx);
+			case "whoami": return await whoami(ctx);
+			case "comments": return await listComments(ctx, values);
+			case "comment": return await showComment(ctx, arg, { saveScreenshot: values["save-screenshot"] });
+			case "reply": return await reply(ctx, arg, positionals[2]);
+			case "resolve": return await setStatus(ctx, arg, "resolved", values.note);
+			case "reopen": return await setStatus(ctx, arg, "open");
+			default:
+				await serveStdio(createMcpServer({
+					remote: ctx.remote,
+					version: VERSION,
+					project: ctx.project,
+					cwd: ctx.cwd
+				}));
+				return 0;
+		}
+	} catch (error) {
+		if (error instanceof CommandError || error instanceof ProjectError || error instanceof RemoteError) {
+			const hint = error instanceof RemoteError && error.code === "unauthenticated" ? ` Run \`npx ${PACKAGES.cli}@latest login\`.` : "";
+			ctx.err(`${error.message.replace(/\.$/, "")}.${hint}`);
+			return 1;
+		}
+		throw error;
+	}
+}
 //#endregion
 //#region src/index.ts
-process.exitCode = run(process.argv.slice(2));
+run(process.argv.slice(2)).then((code) => {
+	process.exitCode = code;
+});
 //#endregion
 export {};