@anythingai/cli 0.0.2 → 0.0.3

package/dist/js/bin.mjs

@@ -2,7 +2,7 @@
 import { createRequire } from "node:module";
 import { hideBin } from "yargs/helpers";
 import yargs from "yargs";
-import { exec, execSync } from "node:child_process";
+import { exec, execSync, spawn } from "node:child_process";
 import fs, { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import path, { basename, dirname, extname, join, resolve } from "node:path";
 import Conf from "conf";
@@ -3053,544 +3053,1563 @@ function errorCodeFromHttpStatus(status) {
 
 //#endregion
 //#region package.json
-var version = "0.0.2";
+var version = "0.0.3";
 
 //#endregion
-//#region src/api-client.ts
-const USER_AGENT = `anything-cli/${version}`;
-function parseRetryAfter(response) {
-	if (response.status !== 429) return null;
-	const header = response.headers.get("retry-after");
-	if (!header) return null;
-	const seconds = Number(header);
-	if (Number.isFinite(seconds)) return seconds >= 0 ? Math.ceil(seconds) : null;
-	const dateMs = Date.parse(header);
-	if (!Number.isNaN(dateMs)) {
-		const delta = Math.ceil((dateMs - Date.now()) / 1e3);
-		return delta > 0 ? delta : 0;
+//#region generated/core/bodySerializer.gen.ts
+const serializeFormDataPair = (data, key, value) => {
+	if (typeof value === "string" || value instanceof Blob) data.append(key, value);
+	else if (value instanceof Date) data.append(key, value.toISOString());
+	else data.append(key, JSON.stringify(value));
+};
+const formDataBodySerializer = { bodySerializer: (body) => {
+	const data = new FormData();
+	Object.entries(body).forEach(([key, value]) => {
+		if (value === void 0 || value === null) return;
+		if (Array.isArray(value)) value.forEach((v) => serializeFormDataPair(data, key, v));
+		else serializeFormDataPair(data, key, value);
+	});
+	return data;
+} };
+const jsonBodySerializer = { bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value) };
+
+//#endregion
+//#region generated/core/params.gen.ts
+const extraPrefixes = Object.entries({
+	$body_: "body",
+	$headers_: "headers",
+	$path_: "path",
+	$query_: "query"
+});
+
+//#endregion
+//#region generated/core/serverSentEvents.gen.ts
+const createSseClient = ({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) => {
+	let lastEventId;
+	const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const createStream = async function* () {
+		let retryDelay = sseDefaultRetryDelay ?? 3e3;
+		let attempt = 0;
+		const signal = options.signal ?? new AbortController().signal;
+		while (true) {
+			if (signal.aborted) break;
+			attempt++;
+			const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+			if (lastEventId !== void 0) headers.set("Last-Event-ID", lastEventId);
+			try {
+				const requestInit = {
+					redirect: "follow",
+					...options,
+					body: options.serializedBody,
+					headers,
+					signal
+				};
+				let request = new Request(url, requestInit);
+				if (onRequest) request = await onRequest(url, requestInit);
+				const response = await (options.fetch ?? globalThis.fetch)(request);
+				if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+				if (!response.body) throw new Error("No body in SSE response");
+				const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+				let buffer = "";
+				const abortHandler = () => {
+					try {
+						reader.cancel();
+					} catch {}
+				};
+				signal.addEventListener("abort", abortHandler);
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						buffer += value;
+						const chunks = buffer.split("\n\n");
+						buffer = chunks.pop() ?? "";
+						for (const chunk of chunks) {
+							const lines = chunk.split("\n");
+							const dataLines = [];
+							let eventName;
+							for (const line of lines) if (line.startsWith("data:")) dataLines.push(line.replace(/^data:\s*/, ""));
+							else if (line.startsWith("event:")) eventName = line.replace(/^event:\s*/, "");
+							else if (line.startsWith("id:")) lastEventId = line.replace(/^id:\s*/, "");
+							else if (line.startsWith("retry:")) {
+								const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+								if (!Number.isNaN(parsed)) retryDelay = parsed;
+							}
+							let data;
+							let parsedJson = false;
+							if (dataLines.length) {
+								const rawData = dataLines.join("\n");
+								try {
+									data = JSON.parse(rawData);
+									parsedJson = true;
+								} catch {
+									data = rawData;
+								}
+							}
+							if (parsedJson) {
+								if (responseValidator) await responseValidator(data);
+								if (responseTransformer) data = await responseTransformer(data);
+							}
+							onSseEvent?.({
+								data,
+								event: eventName,
+								id: lastEventId,
+								retry: retryDelay
+							});
+							if (dataLines.length) yield data;
+						}
+					}
+				} finally {
+					signal.removeEventListener("abort", abortHandler);
+					reader.releaseLock();
+				}
+				break;
+			} catch (error) {
+				onSseError?.(error);
+				if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) break;
+				await sleep(Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4));
+			}
+		}
+	};
+	return { stream: createStream() };
+};
+
+//#endregion
+//#region generated/core/pathSerializer.gen.ts
+const separatorArrayExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
 	}
-	return null;
+};
+const separatorArrayNoExplode = (style) => {
+	switch (style) {
+		case "form": return ",";
+		case "pipeDelimited": return "|";
+		case "spaceDelimited": return "%20";
+		default: return ",";
+	}
+};
+const separatorObjectExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const serializeArrayParam = ({ allowReserved, explode, name, style, value }) => {
+	if (!explode) {
+		const joinedValues = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+		switch (style) {
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			case "simple": return joinedValues;
+			default: return `${name}=${joinedValues}`;
+		}
+	}
+	const separator = separatorArrayExplode(style);
+	const joinedValues = value.map((v) => {
+		if (style === "label" || style === "simple") return allowReserved ? v : encodeURIComponent(v);
+		return serializePrimitiveParam({
+			allowReserved,
+			name,
+			value: v
+		});
+	}).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+const serializePrimitiveParam = ({ allowReserved, name, value }) => {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "object") throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
+	return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+const serializeObjectParam = ({ allowReserved, explode, name, style, value, valueOnly }) => {
+	if (value instanceof Date) return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+	if (style !== "deepObject" && !explode) {
+		let values = [];
+		Object.entries(value).forEach(([key, v]) => {
+			values = [
+				...values,
+				key,
+				allowReserved ? v : encodeURIComponent(v)
+			];
+		});
+		const joinedValues = values.join(",");
+		switch (style) {
+			case "form": return `${name}=${joinedValues}`;
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			default: return joinedValues;
+		}
+	}
+	const separator = separatorObjectExplode(style);
+	const joinedValues = Object.entries(value).map(([key, v]) => serializePrimitiveParam({
+		allowReserved,
+		name: style === "deepObject" ? `${name}[${key}]` : key,
+		value: v
+	})).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+
+//#endregion
+//#region generated/core/utils.gen.ts
+const PATH_PARAM_RE = /\{[^{}]+\}/g;
+const defaultPathSerializer = ({ path, url: _url }) => {
+	let url = _url;
+	const matches = _url.match(PATH_PARAM_RE);
+	if (matches) for (const match of matches) {
+		let explode = false;
+		let name = match.substring(1, match.length - 1);
+		let style = "simple";
+		if (name.endsWith("*")) {
+			explode = true;
+			name = name.substring(0, name.length - 1);
+		}
+		if (name.startsWith(".")) {
+			name = name.substring(1);
+			style = "label";
+		} else if (name.startsWith(";")) {
+			name = name.substring(1);
+			style = "matrix";
+		}
+		const value = path[name];
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) {
+			url = url.replace(match, serializeArrayParam({
+				explode,
+				name,
+				style,
+				value
+			}));
+			continue;
+		}
+		if (typeof value === "object") {
+			url = url.replace(match, serializeObjectParam({
+				explode,
+				name,
+				style,
+				value,
+				valueOnly: true
+			}));
+			continue;
+		}
+		if (style === "matrix") {
+			url = url.replace(match, `;${serializePrimitiveParam({
+				name,
+				value
+			})}`);
+			continue;
+		}
+		const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
+		url = url.replace(match, replaceValue);
+	}
+	return url;
+};
+const getUrl = ({ baseUrl, path, query, querySerializer, url: _url }) => {
+	const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+	let url = (baseUrl ?? "") + pathUrl;
+	if (path) url = defaultPathSerializer({
+		path,
+		url
+	});
+	let search = query ? querySerializer(query) : "";
+	if (search.startsWith("?")) search = search.substring(1);
+	if (search) url += `?${search}`;
+	return url;
+};
+function getValidRequestBody(options) {
+	const hasBody = options.body !== void 0;
+	if (hasBody && options.bodySerializer) {
+		if ("serializedBody" in options) return options.serializedBody !== void 0 && options.serializedBody !== "" ? options.serializedBody : null;
+		return options.body !== "" ? options.body : null;
+	}
+	if (hasBody) return options.body;
 }
-const AuthProviderSchema = z.enum([
-	"google",
-	"email",
-	"facebook",
-	"twitter",
-	"apple"
-]);
-const CreateEnvironmentSchema = z.enum([
-	"development",
-	"preview",
-	"production"
-]);
-const CreateProjectResponseSchema = z.object({
-	projectGroupId: z.string(),
-	revisionId: z.string()
+
+//#endregion
+//#region generated/core/auth.gen.ts
+const getAuthToken = async (auth, callback) => {
+	const token = typeof callback === "function" ? await callback(auth) : callback;
+	if (!token) return;
+	if (auth.scheme === "bearer") return `Bearer ${token}`;
+	if (auth.scheme === "basic") return `Basic ${btoa(token)}`;
+	return token;
+};
+
+//#endregion
+//#region generated/client/utils.gen.ts
+const createQuerySerializer = ({ parameters = {}, ...args } = {}) => {
+	const querySerializer = (queryParams) => {
+		const search = [];
+		if (queryParams && typeof queryParams === "object") for (const name in queryParams) {
+			const value = queryParams[name];
+			if (value === void 0 || value === null) continue;
+			const options = parameters[name] || args;
+			if (Array.isArray(value)) {
+				const serializedArray = serializeArrayParam({
+					allowReserved: options.allowReserved,
+					explode: true,
+					name,
+					style: "form",
+					value,
+					...options.array
+				});
+				if (serializedArray) search.push(serializedArray);
+			} else if (typeof value === "object") {
+				const serializedObject = serializeObjectParam({
+					allowReserved: options.allowReserved,
+					explode: true,
+					name,
+					style: "deepObject",
+					value,
+					...options.object
+				});
+				if (serializedObject) search.push(serializedObject);
+			} else {
+				const serializedPrimitive = serializePrimitiveParam({
+					allowReserved: options.allowReserved,
+					name,
+					value
+				});
+				if (serializedPrimitive) search.push(serializedPrimitive);
+			}
+		}
+		return search.join("&");
+	};
+	return querySerializer;
+};
+/**
+* Infers parseAs value from provided Content-Type header.
+*/
+const getParseAs = (contentType) => {
+	if (!contentType) return "stream";
+	const cleanContent = contentType.split(";")[0]?.trim();
+	if (!cleanContent) return;
+	if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) return "json";
+	if (cleanContent === "multipart/form-data") return "formData";
+	if ([
+		"application/",
+		"audio/",
+		"image/",
+		"video/"
+	].some((type) => cleanContent.startsWith(type))) return "blob";
+	if (cleanContent.startsWith("text/")) return "text";
+};
+const checkForExistence = (options, name) => {
+	if (!name) return false;
+	if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) return true;
+	return false;
+};
+const setAuthParams = async ({ security, ...options }) => {
+	for (const auth of security) {
+		if (checkForExistence(options, auth.name)) continue;
+		const token = await getAuthToken(auth, options.auth);
+		if (!token) continue;
+		const name = auth.name ?? "Authorization";
+		switch (auth.in) {
+			case "query":
+				if (!options.query) options.query = {};
+				options.query[name] = token;
+				break;
+			case "cookie":
+				options.headers.append("Cookie", `${name}=${token}`);
+				break;
+			default:
+				options.headers.set(name, token);
+				break;
+		}
+	}
+};
+const buildUrl = (options) => getUrl({
+	baseUrl: options.baseUrl,
+	path: options.path,
+	query: options.query,
+	querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+	url: options.url
+});
+const mergeConfigs = (a, b) => {
+	const config = {
+		...a,
+		...b
+	};
+	if (config.baseUrl?.endsWith("/")) config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+	config.headers = mergeHeaders(a.headers, b.headers);
+	return config;
+};
+const headersEntries = (headers) => {
+	const entries = [];
+	headers.forEach((value, key) => {
+		entries.push([key, value]);
+	});
+	return entries;
+};
+const mergeHeaders = (...headers) => {
+	const mergedHeaders = new Headers();
+	for (const header of headers) {
+		if (!header) continue;
+		const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+		for (const [key, value] of iterator) if (value === null) mergedHeaders.delete(key);
+		else if (Array.isArray(value)) for (const v of value) mergedHeaders.append(key, v);
+		else if (value !== void 0) mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
+	}
+	return mergedHeaders;
+};
+var Interceptors = class {
+	fns = [];
+	clear() {
+		this.fns = [];
+	}
+	eject(id) {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) this.fns[index] = null;
+	}
+	exists(id) {
+		const index = this.getInterceptorIndex(id);
+		return Boolean(this.fns[index]);
+	}
+	getInterceptorIndex(id) {
+		if (typeof id === "number") return this.fns[id] ? id : -1;
+		return this.fns.indexOf(id);
+	}
+	update(id, fn) {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) {
+			this.fns[index] = fn;
+			return id;
+		}
+		return false;
+	}
+	use(fn) {
+		this.fns.push(fn);
+		return this.fns.length - 1;
+	}
+};
+const createInterceptors = () => ({
+	error: new Interceptors(),
+	request: new Interceptors(),
+	response: new Interceptors()
+});
+const defaultQuerySerializer = createQuerySerializer({
+	allowReserved: false,
+	array: {
+		explode: true,
+		style: "form"
+	},
+	object: {
+		explode: true,
+		style: "deepObject"
+	}
+});
+const defaultHeaders = { "Content-Type": "application/json" };
+const createConfig = (override = {}) => ({
+	...jsonBodySerializer,
+	headers: defaultHeaders,
+	parseAs: "auto",
+	querySerializer: defaultQuerySerializer,
+	...override
+});
+
+//#endregion
+//#region generated/client/client.gen.ts
+const createClient$1 = (config = {}) => {
+	let _config = mergeConfigs(createConfig(), config);
+	const getConfig = () => ({ ..._config });
+	const setConfig = (config) => {
+		_config = mergeConfigs(_config, config);
+		return getConfig();
+	};
+	const interceptors = createInterceptors();
+	const beforeRequest = async (options) => {
+		const opts = {
+			..._config,
+			...options,
+			fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+			headers: mergeHeaders(_config.headers, options.headers),
+			serializedBody: void 0
+		};
+		if (opts.security) await setAuthParams({
+			...opts,
+			security: opts.security
+		});
+		if (opts.requestValidator) await opts.requestValidator(opts);
+		if (opts.body !== void 0 && opts.bodySerializer) opts.serializedBody = opts.bodySerializer(opts.body);
+		if (opts.body === void 0 || opts.serializedBody === "") opts.headers.delete("Content-Type");
+		return {
+			opts,
+			url: buildUrl(opts)
+		};
+	};
+	const request = async (options) => {
+		const { opts, url } = await beforeRequest(options);
+		const requestInit = {
+			redirect: "follow",
+			...opts,
+			body: getValidRequestBody(opts)
+		};
+		let request = new Request(url, requestInit);
+		for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
+		const _fetch = opts.fetch;
+		let response;
+		try {
+			response = await _fetch(request);
+		} catch (error) {
+			let finalError = error;
+			for (const fn of interceptors.error.fns) if (fn) finalError = await fn(error, void 0, request, opts);
+			finalError = finalError || {};
+			if (opts.throwOnError) throw finalError;
+			return opts.responseStyle === "data" ? void 0 : {
+				error: finalError,
+				request,
+				response: void 0
+			};
+		}
+		for (const fn of interceptors.response.fns) if (fn) response = await fn(response, request, opts);
+		const result = {
+			request,
+			response
+		};
+		if (response.ok) {
+			const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+			if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+				let emptyData;
+				switch (parseAs) {
+					case "arrayBuffer":
+					case "blob":
+					case "text":
+						emptyData = await response[parseAs]();
+						break;
+					case "formData":
+						emptyData = new FormData();
+						break;
+					case "stream":
+						emptyData = response.body;
+						break;
+					default:
+						emptyData = {};
+						break;
+				}
+				return opts.responseStyle === "data" ? emptyData : {
+					data: emptyData,
+					...result
+				};
+			}
+			let data;
+			switch (parseAs) {
+				case "arrayBuffer":
+				case "blob":
+				case "formData":
+				case "json":
+				case "text":
+					data = await response[parseAs]();
+					break;
+				case "stream": return opts.responseStyle === "data" ? response.body : {
+					data: response.body,
+					...result
+				};
+			}
+			if (parseAs === "json") {
+				if (opts.responseValidator) await opts.responseValidator(data);
+				if (opts.responseTransformer) data = await opts.responseTransformer(data);
+			}
+			return opts.responseStyle === "data" ? data : {
+				data,
+				...result
+			};
+		}
+		const textError = await response.text();
+		let jsonError;
+		try {
+			jsonError = JSON.parse(textError);
+		} catch {}
+		const error = jsonError ?? textError;
+		let finalError = error;
+		for (const fn of interceptors.error.fns) if (fn) finalError = await fn(error, response, request, opts);
+		finalError = finalError || {};
+		if (opts.throwOnError) throw finalError;
+		return opts.responseStyle === "data" ? void 0 : {
+			error: finalError,
+			...result
+		};
+	};
+	const makeMethodFn = (method) => (options) => request({
+		...options,
+		method
+	});
+	const makeSseFn = (method) => async (options) => {
+		const { opts, url } = await beforeRequest(options);
+		return createSseClient({
+			...opts,
+			body: opts.body,
+			headers: opts.headers,
+			method,
+			onRequest: async (url, init) => {
+				let request = new Request(url, init);
+				for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
+				return request;
+			},
+			url
+		});
+	};
+	return {
+		buildUrl,
+		connect: makeMethodFn("CONNECT"),
+		delete: makeMethodFn("DELETE"),
+		get: makeMethodFn("GET"),
+		getConfig,
+		head: makeMethodFn("HEAD"),
+		interceptors,
+		options: makeMethodFn("OPTIONS"),
+		patch: makeMethodFn("PATCH"),
+		post: makeMethodFn("POST"),
+		put: makeMethodFn("PUT"),
+		request,
+		setConfig,
+		sse: {
+			connect: makeSseFn("CONNECT"),
+			delete: makeSseFn("DELETE"),
+			get: makeSseFn("GET"),
+			head: makeSseFn("HEAD"),
+			options: makeSseFn("OPTIONS"),
+			patch: makeSseFn("PATCH"),
+			post: makeSseFn("POST"),
+			put: makeSseFn("PUT"),
+			trace: makeSseFn("TRACE")
+		},
+		trace: makeMethodFn("TRACE")
+	};
+};
+
+//#endregion
+//#region generated/client.gen.ts
+const client = createClient$1(createConfig());
+
+//#endregion
+//#region generated/sdk.gen.ts
+/**
+* Get current user info
+*
+* Returns the authenticated user and their organizations, including plan and credit context.
+*/
+const getV0ApiMe = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/me",
+	...options
 });
-const DuplicateProjectGroupResponseSchema = z.object({
-	projectGroupId: z.string(),
-	name: z.string()
+/**
+* List organization members
+*
+* Returns collaborators and pending invites for an organization the authenticated user can access.
+*/
+const getV0ApiOrganizationsByOrganizationIdMembers = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/organizations/{organizationId}/members",
+	...options
 });
-const GenerateResponseSchema = z.object({
-	revisionId: z.string(),
-	threadId: z.string().nullable()
+/**
+* List accessible projects
+*
+* Returns project groups the authenticated user can access, optionally filtered by organization or search query.
+*/
+const getV0ApiProjects = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects",
+	...options
 });
-const MessageSchema = z.object({
-	id: z.string(),
-	userMessage: z.string().nullable(),
-	assistantMessage: z.string().nullable(),
-	action: z.string(),
-	status: z.string(),
-	threadId: z.string().nullable(),
-	createdAt: z.string()
+/**
+* Create a new project
+*
+* Creates a new project and starts initial generation from a prompt.
+*/
+const postV0ApiProjects = (options) => (options?.client ?? client).post({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options?.headers
+	}
 });
-const MessagesResponseSchema = z.object({ messages: z.array(MessageSchema) });
-const ProjectFileSchema = z.object({
-	path: z.string(),
-	content: z.string().optional()
+/**
+* List accessible databases
+*
+* Returns databases in an organization that the authenticated user can access.
+*/
+const getV0ApiDatabases = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/databases",
+	...options
 });
-const ProjectFilesResponseSchema = z.object({ files: z.array(ProjectFileSchema.omit({ content: true })) });
-const ProjectFileResponseSchema = z.object({ file: ProjectFileSchema.extend({ content: z.string() }) });
-const ProjectLogSchema = z.object({
-	id: z.string(),
-	message: z.string(),
-	level: z.enum([
-		"info",
-		"warn",
-		"error"
-	]),
-	timestamp: z.string(),
-	source: z.string().nullable(),
-	devServerId: z.string().nullable()
+/**
+* Create a database
+*
+* Creates a new user database. The database is provisioned asynchronously — poll GET /databases/{databaseId} until the status leaves CREATING.
+*/
+const postV0ApiDatabases = (options) => (options?.client ?? client).post({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/databases",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options?.headers
+	}
 });
-const ProjectAuthProviderSecretSchema = z.object({
-	id: z.string(),
-	envKey: z.string(),
-	displayName: z.string(),
-	environment: z.string()
+/**
+* List organization domains
+*
+* Returns the apex domains for an organization, including verification status and linked project information.
+*/
+const getV0ApiDomains = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/domains",
+	...options
 });
-const ProjectAuthProvidersProviderSchema = z.object({
-	provider: AuthProviderSchema,
-	enabled: z.boolean(),
-	secrets: z.array(ProjectAuthProviderSecretSchema)
+/**
+* Add a domain
+*
+* Adds a custom domain to an organization, optionally linked to a project group.
+*/
+const postV0ApiDomains = (options) => (options?.client ?? client).post({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/domains",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options?.headers
+	}
 });
-const ProjectAuthProvidersResponseSchema = z.object({
-	authEnabled: z.boolean(),
-	providers: z.array(ProjectAuthProvidersProviderSchema)
+/**
+* Duplicate a project
+*
+* Duplicates an existing project group into the same organization and returns the new project group ID.
+*/
+const postV0ApiProjectsByProjectGroupIdDuplicate = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/duplicate",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
 });
-const ProjectLogsResponseSchema = z.object({ logs: z.array(ProjectLogSchema) });
-const ProjectAuthSettingsProviderSchema = z.object({
-	provider: AuthProviderSchema,
-	enabled: z.boolean(),
-	configured: z.boolean(),
-	expectedSecretKeys: z.array(z.string()),
-	configuredSecretKeys: z.array(z.string()),
-	helpUrl: z.string()
+/**
+* Delete a project
+*
+* Marks a project group for deletion and schedules permanent cleanup.
+*/
+const deleteV0ApiProjectsByProjectGroupId = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}",
+	...options
 });
-const ProjectAuthSettingsResponseSchema = z.object({
-	authEnabled: z.boolean(),
-	providers: z.array(ProjectAuthSettingsProviderSchema)
+/**
+* Get project info
+*
+* Returns project group details including modules and dev server status.
+*/
+const getV0ApiProjectsByProjectGroupId = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}",
+	...options
 });
-z.object({
-	envKey: z.string(),
-	displayName: z.string(),
-	value: z.string(),
-	environment: CreateEnvironmentSchema
+/**
+* Inspect auth provider configuration
+*
+* Returns the auth providers configured for a project group, including the secret metadata used by the Authentication settings UI.
+*/
+const getV0ApiProjectsByProjectGroupIdAuthProviders = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/auth/providers",
+	...options
 });
-const ProjectModuleSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	slug: z.string().nullable(),
-	moduleType: z.string(),
-	pathSegment: z.string().nullable()
+/**
+* Rename a project group
+*
+* Renames a project group the authenticated user can access and returns the updated metadata.
+*/
+const postV0ApiProjectsByProjectGroupIdRename = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/rename",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
 });
-const ProjectInfoResponseSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	slug: z.string().nullable(),
-	filesystemVersion: z.string().nullable(),
-	createdAt: z.string(),
-	updatedAt: z.string(),
-	devServerUrl: z.string().nullable(),
-	publishedUrls: z.array(z.string()),
-	latestPublishedUrl: z.string().nullable(),
-	projects: z.array(ProjectModuleSchema)
+/**
+* Request a change
+*
+* Sends a prompt to generate changes in an existing project. Optionally creates or continues a conversation thread.
+*/
+const postV0ApiProjectsByProjectGroupIdGenerate = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/generate",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
 });
-const ProjectStatusResponseSchema = z.object({
-	projectGroupId: z.string(),
-	latestRevisionId: z.string().nullable(),
-	status: z.string().nullable(),
-	deployment: z.object({
-		id: z.string(),
-		status: z.string(),
-		url: z.string().nullable()
-	}).nullable(),
-	updatedAt: z.string()
+/**
+* Read messages
+*
+* Returns chat messages for a project, optionally filtered by thread.
+*/
+const getV0ApiProjectsByProjectGroupIdMessages = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/messages",
+	...options
 });
-const RenameProjectGroupResponseSchema = z.object({
-	success: z.boolean(),
-	projectGroupId: z.string().uuid(),
-	name: z.string(),
-	slug: z.string().nullable(),
-	updatedAt: z.string()
+/**
+* Read project status
+*
+* Returns a small status document (latest revision status + deployment summary) for cheap polling. Avoids the message body payload.
+*/
+const getV0ApiProjectsByProjectGroupIdStatus = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/status",
+	...options
 });
-const ProjectListItemSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	slug: z.string().nullable(),
-	organizationId: z.string(),
-	organizationName: z.string(),
-	createdAt: z.string(),
-	updatedAt: z.string()
+/**
+* Read project files
+*
+* Lists project files, or returns one file with content when `path` is provided.
+*/
+const getV0ApiProjectsByProjectGroupIdFiles = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/files",
+	...options
 });
-const ListProjectsResponseSchema = z.object({ projects: z.array(ProjectListItemSchema) });
-const DatabaseListItemSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	status: z.enum([
-		"CREATING",
-		"COMPLETED",
-		"FAILED"
-	]),
-	organizationId: z.string(),
-	organizationName: z.string(),
-	createdAt: z.string(),
-	updatedAt: z.string(),
-	pointInTimeRestoreEnabled: z.boolean()
+/**
+* Read recent development logs
+*
+* Returns recent development logs for a project, optionally filtered by level or message text.
+*/
+const getV0ApiProjectsByProjectGroupIdLogs = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/logs",
+	...options
 });
-const ListDatabasesResponseSchema = z.object({ databases: z.array(DatabaseListItemSchema) });
-const SecretSchema = z.object({
-	id: z.string(),
-	envKey: z.string(),
-	displayName: z.string(),
-	environment: z.string()
+/**
+* Read project auth settings
+*
+* Returns the current project auth provider state and whether each provider appears configured.
+*/
+const getV0ApiProjectsByProjectGroupIdSettingsAuth = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/settings/auth",
+	...options
 });
-const AddSecretResponseSchema = z.object({ secret: SecretSchema });
-const SecretListItemSchema = SecretSchema.extend({
-	createdAt: z.string(),
-	updatedAt: z.string()
+/**
+* Update project auth settings
+*
+* Updates the enabled state for a project auth provider and optionally stores provider secrets.
+*/
+const postV0ApiProjectsByProjectGroupIdSettingsAuth = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/settings/auth",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
 });
-const ListSecretsResponseSchema = z.object({ secrets: z.array(SecretListItemSchema) });
-const PublishResponseSchema = z.object({
-	success: z.boolean(),
-	projectGroupId: z.string(),
-	slug: z.string().nullable(),
-	deploymentId: z.string()
+/**
+* List secrets
+*
+* Returns the configured secrets for a project without exposing plaintext values.
+*/
+const getV0ApiProjectsByProjectGroupIdSecrets = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/secrets",
+	...options
 });
-const ProjectSubmissionSchema = z.object({
-	id: z.string(),
-	projectGroupId: z.string(),
-	status: z.enum([
-		"PENDING",
-		"CREATED",
-		"FAILED"
-	]),
-	launchUrl: z.string().nullable(),
-	authUrl: z.string().nullable(),
-	errorMessage: z.string().nullable(),
-	expiresAt: z.string().nullable()
+/**
+* Add secrets
+*
+* Adds one or more secrets to a project. Send a single secret object or a bulk array.
+*/
+const postV0ApiProjectsByProjectGroupIdSecrets = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/secrets",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
 });
-const SubmitProjectResponseSchema = z.object({
-	success: z.boolean(),
-	submission: ProjectSubmissionSchema
+/**
+* Delete a secret
+*
+* Removes a secret from the project.
+*/
+const deleteV0ApiProjectsByProjectGroupIdSecretsBySecretId = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/secrets/{secretId}",
+	...options
 });
-const UnpublishResponseSchema = z.object({
-	success: z.boolean(),
-	projectGroupId: z.string()
+/**
+* Publish project
+*
+* Publishes the project, making it publicly accessible. Optionally claims a custom slug.
+*/
+const postV0ApiProjectsByProjectGroupIdPublish = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/publish",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
 });
-const OrganizationSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	plan: z.string(),
-	planDisplayName: z.string(),
-	isPaid: z.boolean(),
-	creditBalance: z.string()
+/**
+* Start an App Store submission
+*
+* Starts the Expo launch flow for an app store submission. Returns the session so clients can poll for launch URL readiness.
+*/
+const postV0ApiProjectsByProjectGroupIdSubmit = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/submit",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
 });
-const MeResponseSchema = z.object({
-	id: z.string(),
-	email: z.string().nullable(),
-	name: z.string().nullable(),
-	organizations: z.array(OrganizationSchema)
+/**
+* Read submission status
+*
+* Returns the current state of an Expo launch session for a project.
+*/
+const getV0ApiProjectsByProjectGroupIdSubmitBySubmissionId = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/submit/{submissionId}",
+	...options
 });
-const OrganizationMembersResponseSchema = z.object({
-	organization: z.object({
-		id: z.string(),
-		name: z.string(),
-		role: z.string().nullable()
-	}),
-	collaborators: z.array(z.object({
-		userId: z.string(),
-		email: z.string().nullable(),
-		displayName: z.string(),
-		role: z.string(),
-		isMe: z.boolean()
-	})),
-	pendingInvites: z.array(z.object({
-		id: z.string(),
-		toEmail: z.string(),
-		expiresAt: z.string(),
-		status: z.enum(["pending", "expired"])
-	}))
+/**
+* Unpublish project
+*
+* Removes the published app for a project group without deleting the project group itself.
+*/
+const postV0ApiProjectsByProjectGroupIdUnpublish = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/unpublish",
+	...options
 });
-const AssetSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	url: z.string(),
-	mimeType: z.string(),
-	createdAt: z.string()
+/**
+* List assets
+*
+* Returns the image assets uploaded to a project group, optionally filtered by a search query and paginated.
+*/
+const getV0ApiProjectsByProjectGroupIdAssets = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/assets",
+	...options
 });
-const UploadAssetResponseSchema = AssetSchema;
-const ListAssetsResponseSchema = z.object({
-	assets: z.array(AssetSchema),
-	total: z.number().optional()
+/**
+* Upload an asset
+*
+* Uploads an image asset to a project group. Send the file as multipart/form-data under the `file` field, with an optional display `name`.
+*/
+const postV0ApiProjectsByProjectGroupIdAssets = (options) => (options.client ?? client).post({
+	...formDataBodySerializer,
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/assets",
+	...options,
+	headers: {
+		"Content-Type": null,
+		...options.headers
+	}
 });
-const DomainProjectGroupSchema = z.object({
-	id: z.string(),
-	name: z.string()
+/**
+* Delete an asset
+*
+* Removes an asset from a project group.
+*/
+const deleteV0ApiProjectsByProjectGroupIdAssetsByAssetId = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/assets/{assetId}",
+	...options
 });
-const DomainSchema = z.object({
-	id: z.string(),
-	domain: z.string(),
-	vercelVerified: z.boolean(),
-	vercelVerification: z.unknown().nullable(),
-	projectGroup: DomainProjectGroupSchema.nullable()
+/**
+* Get a single database
+*
+* Returns details for a specific user database.
+*/
+const getV0ApiDatabasesByDatabaseId = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/databases/{databaseId}",
+	...options
 });
-const ListDomainsResponseSchema = z.object({ domains: z.array(DomainSchema) });
-const DatabaseDetailSchema = DatabaseListItemSchema.extend({
-	connectionString: z.string().nullable().optional(),
-	projectGroupId: z.string().nullable().optional()
+/**
+* Query a database
+*
+* Executes a read-only SQL query against the database. Only SELECT, WITH, EXPLAIN, and SHOW statements are allowed.
+*/
+const postV0ApiDatabasesByDatabaseIdQuery = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/databases/{databaseId}/query",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
 });
-const DatabaseDetailResponseSchema = z.object({ database: DatabaseDetailSchema });
-const CreateDatabaseResponseSchema = z.object({ database: DatabaseListItemSchema });
-const DatabaseQueryResultSchema = z.object({
-	columns: z.array(z.string()),
-	rows: z.array(z.array(z.unknown())),
-	rowCount: z.number()
+/**
+* Get database connection string
+*
+* Returns the connection string for a user database.
+*/
+const getV0ApiDatabasesByDatabaseIdConnection = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/databases/{databaseId}/connection",
+	...options
 });
-const DatabaseConnectionResponseSchema = z.object({ connectionString: z.string() });
-const AddDomainResponseSchema = z.object({ domain: DomainSchema });
-const DomainVerificationSchema = z.object({
-	domain: z.string(),
-	verified: z.boolean(),
-	vercelVerification: z.unknown().nullable()
+/**
+* Reset development database
+*
+* Resets the development branch of a user database.
+*/
+const postV0ApiDatabasesByDatabaseIdReset = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/databases/{databaseId}/reset",
+	...options
 });
-const DeploymentSchema = z.object({
-	id: z.string(),
-	projectGroupId: z.string(),
-	status: z.string(),
-	url: z.string().nullable().optional(),
-	createdAt: z.string(),
-	completedAt: z.string().nullable()
+/**
+* Remove a domain
+*
+* Removes a custom domain.
+*/
+const deleteV0ApiDomainsByDomainId = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/domains/{domainId}",
+	...options
 });
-const ListDeploymentsResponseSchema = z.object({ deployments: z.array(DeploymentSchema) });
-const DeploymentDetailSchema = DeploymentSchema.extend({
-	buildLogs: z.string().nullable().optional(),
-	failureReason: z.string().nullable().optional()
+/**
+* Verify a domain
+*
+* Triggers verification for a custom domain.
+*/
+const postV0ApiDomainsByDomainIdVerify = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/domains/{domainId}/verify",
+	...options
 });
-const DeploymentDetailResponseSchema = z.object({ deployment: DeploymentDetailSchema });
-const DeploymentLogsResponseSchema = z.object({
-	logs: z.string(),
-	status: z.string().optional(),
-	failureReason: z.string().nullable().optional()
+/**
+* List project deployments
+*
+* Returns recent deployments for a project group, ordered by creation time descending.
+*/
+const getV0ApiProjectsByProjectGroupIdDeployments = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/deployments",
+	...options
+});
+/**
+* Get deployment status
+*
+* Returns the current state of a deployment, including build logs if available.
+*/
+const getV0ApiDeploymentsByDeploymentId = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/deployments/{deploymentId}",
+	...options
+});
+/**
+* Get deployment logs
+*
+* Returns the build logs for a specific deployment.
+*/
+const getV0ApiDeploymentsByDeploymentIdLogs = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/deployments/{deploymentId}/logs",
+	...options
 });
+/**
+* Rollback a deployment
+*
+* Deployment rollback is not yet implemented.
+*/
+const postV0ApiProjectsByProjectGroupIdDeploymentsRollback = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/projects/{projectGroupId}/deployments/rollback",
+	...options
+});
+/**
+* Invite a member
+*
+* Sends an invitation to join the organization. Requires OWNER or ADMIN role.
+*/
+const postV0ApiOrganizationsByOrganizationIdInvites = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/organizations/{organizationId}/invites",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Remove a member
+*
+* Removes a member from the organization. Requires OWNER or ADMIN role.
+*/
+const postV0ApiOrganizationsByOrganizationIdMembersRemove = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/organizations/{organizationId}/members/remove",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Update member role
+*
+* Changes the role of an organization member. Requires OWNER or ADMIN role.
+*/
+const postV0ApiOrganizationsByOrganizationIdMembersRole = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "basic",
+		type: "http"
+	}],
+	url: "/v0/api/organizations/{organizationId}/members/role",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+
+//#endregion
+//#region src/api-client.ts
+const USER_AGENT = `anything-cli/${version}`;
+const ErrorWithMessageSchema = z.object({ message: z.string().min(1) });
+const ErrorWithErrorStringSchema = z.object({ error: z.string().min(1) });
+const ErrorWithNestedMessageSchema = z.object({ error: z.object({ message: z.string() }) });
+function extractErrorMessage(status, details) {
+	const withMessage = ErrorWithMessageSchema.safeParse(details);
+	if (withMessage.success) return withMessage.data.message;
+	const withErrorString = ErrorWithErrorStringSchema.safeParse(details);
+	if (withErrorString.success) return withErrorString.data.error;
+	const withNested = ErrorWithNestedMessageSchema.safeParse(details);
+	if (withNested.success) return withNested.data.error.message;
+	if (typeof details === "string" && details.length > 0) return details;
+	return `API error (${status})`;
+}
+function parseRetryAfter(response) {
+	if (response.status !== 429) return null;
+	const header = response.headers.get("retry-after");
+	if (!header) return null;
+	const seconds = Number(header);
+	if (Number.isFinite(seconds)) return seconds >= 0 ? Math.ceil(seconds) : null;
+	const dateMs = Date.parse(header);
+	if (!Number.isNaN(dateMs)) {
+		const delta = Math.ceil((dateMs - Date.now()) / 1e3);
+		return delta > 0 ? delta : 0;
+	}
+	return null;
+}
+function buildAuthHeader$1(apiKey) {
+	return apiKey.startsWith("anything_") || apiKey.startsWith("create_") ? `Basic ${Buffer.from(`${apiKey}:`).toString("base64")}` : apiKey;
+}
+function toSecretEnvironment(value) {
+	switch (value.toUpperCase()) {
+		case "DEVELOPMENT": return "DEVELOPMENT";
+		case "PREVIEW": return "PREVIEW";
+		case "PRODUCTION": return "PRODUCTION";
+		default: return null;
+	}
+}
+function toMemberRole(value) {
+	switch (value.toUpperCase()) {
+		case "OWNER": return "OWNER";
+		case "ADMIN": return "ADMIN";
+		case "EDITOR": return "EDITOR";
+		case "VIEWER": return "VIEWER";
+		default: return null;
+	}
+}
 const RollbackResponseSchema = z.object({
 	success: z.boolean(),
-	deployment: DeploymentSchema.optional()
-});
-const InviteMemberResponseSchema = z.object({
-	success: z.boolean(),
-	invite: z.object({
+	deployment: z.object({
 		id: z.string(),
-		toEmail: z.string(),
-		expiresAt: z.string()
-	})
-});
-const RemoveMemberResponseSchema = z.object({ success: z.boolean() });
-const UpdateMemberRoleResponseSchema = z.object({
-	success: z.boolean(),
-	userId: z.string(),
-	role: z.string()
+		status: z.string()
+	}).optional()
 });
 var AnythingApiClient = class {
-	baseUrl;
-	authHeader;
+	client;
 	constructor(config) {
-		this.baseUrl = `${config.apiUrl.replace(/\/$/, "")}/v0/api`;
-		this.authHeader = config.apiKey.startsWith("anything_") || config.apiKey.startsWith("create_") ? `Basic ${Buffer.from(`${config.apiKey}:`).toString("base64")}` : config.apiKey;
+		this.client = createClient$1(createConfig({
+			baseUrl: config.apiUrl.replace(/\/$/, ""),
+			headers: {
+				authorization: buildAuthHeader$1(config.apiKey),
+				"user-agent": USER_AGENT
+			}
+		}));
 	}
-	async getMe() {
-		return this.request({
-			method: "GET",
-			path: "/me",
-			schema: MeResponseSchema
+	toResult(result) {
+		const { data, error, response } = result;
+		if (!response) return err({
+			message: `Network error: ${error instanceof Error ? error.message : String(error)}`,
+			status: null
+		});
+		if (!response.ok) {
+			const retryAfter = parseRetryAfter(response);
+			return err({
+				message: extractErrorMessage(response.status, error),
+				status: response.status,
+				details: error,
+				...retryAfter !== null ? { retryAfter } : {}
+			});
+		}
+		if (data === void 0) return err({
+			message: "Unexpected API response format",
+			status: response.status
 		});
+		return ok(data);
+	}
+	async getMe() {
+		return this.toResult(await getV0ApiMe({ client: this.client }));
 	}
 	async getOrganizationMembers({ organizationId }) {
-		return this.request({
-			method: "GET",
-			path: `/organizations/${organizationId}/members`,
-			schema: OrganizationMembersResponseSchema
-		});
+		return this.toResult(await getV0ApiOrganizationsByOrganizationIdMembers({
+			client: this.client,
+			path: { organizationId }
+		}));
 	}
 	async createProject({ prompt, organizationId, name }) {
-		return this.request({
-			method: "POST",
-			path: "/projects",
+		return this.toResult(await postV0ApiProjects({
+			client: this.client,
 			body: {
 				prompt,
 				organizationId,
 				...name !== null ? { name } : {}
-			},
-			schema: CreateProjectResponseSchema
-		});
+			}
+		}));
 	}
 	async duplicateProjectGroup({ projectGroupId, name }) {
-		return this.request({
-			method: "POST",
-			path: `/projects/${projectGroupId}/duplicate`,
-			body: name !== null ? { name } : {},
-			schema: DuplicateProjectGroupResponseSchema
-		});
+		return this.toResult(await postV0ApiProjectsByProjectGroupIdDuplicate({
+			client: this.client,
+			path: { projectGroupId },
+			body: name !== null ? { name } : {}
+		}));
 	}
 	async listProjects({ organizationId, query, limit }) {
-		const params = new URLSearchParams();
-		if (organizationId !== null) params.set("organizationId", organizationId);
-		if (query !== null) params.set("query", query);
-		params.set("limit", String(limit));
-		return this.request({
-			method: "GET",
-			path: `/projects?${params.toString()}`,
-			schema: ListProjectsResponseSchema
-		});
+		return this.toResult(await getV0ApiProjects({
+			client: this.client,
+			query: {
+				...organizationId !== null ? { organizationId } : {},
+				...query !== null ? { query } : {},
+				limit
+			}
+		}));
 	}
 	async listDatabases({ organizationId, limit }) {
-		const params = new URLSearchParams();
-		params.set("organizationId", organizationId);
-		params.set("limit", String(limit));
-		return this.request({
-			method: "GET",
-			path: `/databases?${params.toString()}`,
-			schema: ListDatabasesResponseSchema
-		});
+		return this.toResult(await getV0ApiDatabases({
+			client: this.client,
+			query: {
+				organizationId,
+				limit
+			}
+		}));
 	}
 	async generate({ projectGroupId, prompt, threadId, createNewThread }) {
-		return this.request({
-			method: "POST",
-			path: `/projects/${projectGroupId}/generate`,
+		return this.toResult(await postV0ApiProjectsByProjectGroupIdGenerate({
+			client: this.client,
+			path: { projectGroupId },
 			body: {
 				prompt,
 				...threadId !== null ? { threadId } : {},
 				...createNewThread ? { createNewThread: true } : {}
-			},
-			schema: GenerateResponseSchema
-		});
+			}
+		}));
 	}
 	async getMessages({ projectGroupId, threadId, limit }) {
-		const params = new URLSearchParams();
-		if (threadId !== null) params.set("threadId", threadId);
-		if (limit !== null) params.set("limit", String(limit));
-		const query = params.toString();
-		const path = `/projects/${projectGroupId}/messages${query ? `?${query}` : ""}`;
-		return this.request({
-			method: "GET",
-			path,
-			schema: MessagesResponseSchema
-		});
+		return this.toResult(await getV0ApiProjectsByProjectGroupIdMessages({
+			client: this.client,
+			path: { projectGroupId },
+			query: {
+				...threadId !== null ? { threadId } : {},
+				...limit !== null ? { limit } : {}
+			}
+		}));
 	}
 	async getProjectLogs({ projectGroupId, level, search, limit }) {
-		const params = new URLSearchParams();
-		if (level !== null) params.set("level", level);
-		if (search !== null) params.set("search", search);
-		if (limit !== null) params.set("limit", String(limit));
-		const query = params.toString();
-		const path = `/projects/${projectGroupId}/logs${query ? `?${query}` : ""}`;
-		return this.request({
-			method: "GET",
-			path,
-			schema: ProjectLogsResponseSchema
-		});
+		return this.toResult(await getV0ApiProjectsByProjectGroupIdLogs({
+			client: this.client,
+			path: { projectGroupId },
+			query: {
+				...level !== null ? { level } : {},
+				...search !== null ? { search } : {},
+				...limit !== null ? { limit } : {}
+			}
+		}));
 	}
 	async getProjectAuthProviders({ projectGroupId }) {
-		return this.request({
-			method: "GET",
-			path: `/projects/${projectGroupId}/auth/providers`,
-			schema: ProjectAuthProvidersResponseSchema
-		});
+		return this.toResult(await getV0ApiProjectsByProjectGroupIdAuthProviders({
+			client: this.client,
+			path: { projectGroupId }
+		}));
 	}
 	async getProjectAuthSettings({ projectGroupId }) {
-		return this.request({
-			method: "GET",
-			path: `/projects/${projectGroupId}/settings/auth`,
-			schema: ProjectAuthSettingsResponseSchema
-		});
+		return this.toResult(await getV0ApiProjectsByProjectGroupIdSettingsAuth({
+			client: this.client,
+			path: { projectGroupId }
+		}));
 	}
 	async updateProjectAuthSettings({ projectGroupId, provider, enabled, secrets, enableForAllModules }) {
-		return this.request({
-			method: "POST",
-			path: `/projects/${projectGroupId}/settings/auth`,
+		return this.toResult(await postV0ApiProjectsByProjectGroupIdSettingsAuth({
+			client: this.client,
+			path: { projectGroupId },
 			body: {
 				provider,
 				enabled,
 				...secrets.length > 0 ? { secrets } : {},
 				...enableForAllModules ? { enableForAllModules } : {}
-			},
-			schema: ProjectAuthSettingsResponseSchema
-		});
+			}
+		}));
 	}
 	async getProject({ projectGroupId }) {
-		return this.request({
-			method: "GET",
-			path: `/projects/${projectGroupId}`,
-			schema: ProjectInfoResponseSchema
-		});
+		return this.toResult(await getV0ApiProjectsByProjectGroupId({
+			client: this.client,
+			path: { projectGroupId }
+		}));
 	}
 	async getProjectStatus({ projectGroupId }) {
-		return this.request({
-			method: "GET",
-			path: `/projects/${projectGroupId}/status`,
-			schema: ProjectStatusResponseSchema
-		});
+		return this.toResult(await getV0ApiProjectsByProjectGroupIdStatus({
+			client: this.client,
+			path: { projectGroupId }
+		}));
 	}
 	async renameProjectGroup({ projectGroupId, name }) {
-		return this.request({
-			method: "POST",
-			path: `/projects/${projectGroupId}/rename`,
-			body: { name },
-			schema: RenameProjectGroupResponseSchema
-		});
+		return this.toResult(await postV0ApiProjectsByProjectGroupIdRename({
+			client: this.client,
+			path: { projectGroupId },
+			body: { name }
+		}));
 	}
 	async listProjectFiles({ projectGroupId }) {
-		return this.request({
-			method: "GET",
-			path: `/projects/${projectGroupId}/files`,
-			schema: ProjectFilesResponseSchema
-		});
+		return this.toResult(await getV0ApiProjectsByProjectGroupIdFiles({
+			client: this.client,
+			path: { projectGroupId }
+		})).andThen((data) => "files" in data ? ok(data) : err({
+			message: "Unexpected API response format",
+			status: 200
+		}));
 	}
 	async getProjectFile({ projectGroupId, path }) {
-		const params = new URLSearchParams({ path });
-		return this.request({
-			method: "GET",
-			path: `/projects/${projectGroupId}/files?${params.toString()}`,
-			schema: ProjectFileResponseSchema
-		});
+		return this.toResult(await getV0ApiProjectsByProjectGroupIdFiles({
+			client: this.client,
+			path: { projectGroupId },
+			query: { path }
+		})).andThen((data) => "file" in data ? ok(data) : err({
+			message: "Unexpected API response format",
+			status: 200
+		}));
 	}
 	async addSecret({ projectGroupId, displayName, value, environment }) {
-		return this.request({
-			method: "POST",
-			path: `/projects/${projectGroupId}/secrets`,
+		let environmentValue;
+		if (environment !== null) {
+			const normalized = toSecretEnvironment(environment);
+			if (normalized === null) return err({
+				message: `Invalid environment: ${environment}. Expected one of development, preview, production.`,
+				status: 400
+			});
+			environmentValue = normalized;
+		}
+		return this.toResult(await postV0ApiProjectsByProjectGroupIdSecrets({
+			client: this.client,
+			path: { projectGroupId },
 			body: {
 				displayName,
 				value,
-				...environment !== null ? { environment } : {}
-			},
-			schema: AddSecretResponseSchema
-		});
+				...environmentValue !== void 0 ? { environment: environmentValue } : {}
+			}
+		})).andThen((data) => "secret" in data ? ok(data) : err({
+			message: "Unexpected API response format",
+			status: 201
+		}));
 	}
 	async listSecrets({ projectGroupId }) {
-		return this.request({
-			method: "GET",
-			path: `/projects/${projectGroupId}/secrets`,
-			schema: ListSecretsResponseSchema
-		});
+		return this.toResult(await getV0ApiProjectsByProjectGroupIdSecrets({
+			client: this.client,
+			path: { projectGroupId }
+		}));
 	}
 	async deleteSecret({ projectGroupId, secretId }) {
-		return this.request({
-			method: "DELETE",
-			path: `/projects/${projectGroupId}/secrets/${secretId}`
-		});
+		return this.toResult(await deleteV0ApiProjectsByProjectGroupIdSecretsBySecretId({
+			client: this.client,
+			path: {
+				projectGroupId,
+				secretId
+			}
+		}));
 	}
 	async publish({ projectGroupId, slug }) {
-		return this.request({
-			method: "POST",
-			path: `/projects/${projectGroupId}/publish`,
-			body: slug !== null ? { slug } : {},
-			schema: PublishResponseSchema
-		});
+		return this.toResult(await postV0ApiProjectsByProjectGroupIdPublish({
+			client: this.client,
+			path: { projectGroupId },
+			body: slug !== null ? { slug } : {}
+		}));
 	}
 	async submitProject({ projectGroupId, store }) {
-		return this.request({
-			method: "POST",
-			path: `/projects/${projectGroupId}/submit`,
-			body: { store },
-			schema: SubmitProjectResponseSchema
-		});
+		return this.toResult(await postV0ApiProjectsByProjectGroupIdSubmit({
+			client: this.client,
+			path: { projectGroupId },
+			body: { store }
+		}));
 	}
 	async getProjectSubmission({ projectGroupId, submissionId }) {
-		return this.request({
-			method: "GET",
-			path: `/projects/${projectGroupId}/submit/${submissionId}`,
-			schema: SubmitProjectResponseSchema
-		});
+		return this.toResult(await getV0ApiProjectsByProjectGroupIdSubmitBySubmissionId({
+			client: this.client,
+			path: {
+				projectGroupId,
+				submissionId
+			}
+		}));
 	}
 	async unpublish({ projectGroupId }) {
-		return this.request({
-			method: "POST",
-			path: `/projects/${projectGroupId}/unpublish`,
-			schema: UnpublishResponseSchema
-		});
+		return this.toResult(await postV0ApiProjectsByProjectGroupIdUnpublish({
+			client: this.client,
+			path: { projectGroupId }
+		}));
+	}
+	async deleteProject({ projectGroupId }) {
+		return this.toResult(await deleteV0ApiProjectsByProjectGroupId({
+			client: this.client,
+			path: { projectGroupId }
+		}));
 	}
 	async uploadAsset({ projectGroupId, filePath, name }) {
-		const url = `${this.baseUrl}/projects/${projectGroupId}/assets`;
 		let fileBuffer;
 		try {
 			const { readFileSync } = await import("node:fs");
@@ -3601,250 +4620,161 @@ var AnythingApiClient = class {
 				status: null
 			});
 		}
-		const fileName = basename(filePath);
-		const formData = new FormData();
-		formData.append("file", new Blob([new Uint8Array(fileBuffer)]), fileName);
-		if (name !== null) formData.append("name", name);
-		let response;
-		try {
-			response = await fetch(url, {
-				method: "POST",
-				headers: {
-					authorization: this.authHeader,
-					"user-agent": USER_AGENT
-				},
-				body: formData
-			});
-		} catch (cause) {
-			return err({
-				message: `Network error: ${cause instanceof Error ? cause.message : String(cause)}`,
-				status: null
-			});
-		}
-		if (!response.ok) {
-			const text = await response.text().catch(() => "");
-			let details;
-			try {
-				details = JSON.parse(text);
-			} catch {
-				details = text || void 0;
+		const file = new File([new Uint8Array(fileBuffer)], basename(filePath));
+		return this.toResult(await postV0ApiProjectsByProjectGroupIdAssets({
+			client: this.client,
+			path: { projectGroupId },
+			body: {
+				file,
+				...name !== null ? { name } : {}
 			}
-			const retryAfter = parseRetryAfter(response);
-			return err({
-				message: `API error (${response.status})`,
-				status: response.status,
-				details,
-				...retryAfter !== null ? { retryAfter } : {}
-			});
-		}
-		const json = await response.json();
-		const parsed = UploadAssetResponseSchema.safeParse(json);
-		if (!parsed.success) return err({
-			message: "Unexpected API response format",
-			status: response.status,
-			details: parsed.error.errors
-		});
-		return ok(parsed.data);
+		}));
 	}
 	async listAssets({ projectGroupId, query, limit, offset }) {
-		const params = new URLSearchParams();
-		if (query !== null) params.set("query", query);
-		if (limit !== null) params.set("limit", String(limit));
-		if (offset !== null) params.set("offset", String(offset));
-		const qs = params.toString();
-		const path = `/projects/${projectGroupId}/assets${qs ? `?${qs}` : ""}`;
-		return this.request({
-			method: "GET",
-			path,
-			schema: ListAssetsResponseSchema
-		});
-	}
-	async listDomains({ organizationId }) {
-		const params = new URLSearchParams({ organizationId });
-		return this.request({
-			method: "GET",
-			path: `/domains?${params.toString()}`,
-			schema: ListDomainsResponseSchema
-		});
+		return this.toResult(await getV0ApiProjectsByProjectGroupIdAssets({
+			client: this.client,
+			path: { projectGroupId },
+			query: {
+				...query !== null ? { query } : {},
+				...limit !== null ? { limit } : {},
+				...offset !== null ? { offset } : {}
+			}
+		}));
 	}
 	async deleteAsset({ projectGroupId, assetId }) {
-		return this.request({
-			method: "DELETE",
-			path: `/projects/${projectGroupId}/assets/${assetId}`
-		});
+		return this.toResult(await deleteV0ApiProjectsByProjectGroupIdAssetsByAssetId({
+			client: this.client,
+			path: {
+				projectGroupId,
+				assetId
+			}
+		}));
+	}
+	async listDomains({ organizationId }) {
+		return this.toResult(await getV0ApiDomains({
+			client: this.client,
+			query: { organizationId }
+		}));
 	}
 	async getDatabase({ databaseId }) {
-		return this.request({
-			method: "GET",
-			path: `/databases/${databaseId}`,
-			schema: DatabaseDetailResponseSchema
-		});
+		return this.toResult(await getV0ApiDatabasesByDatabaseId({
+			client: this.client,
+			path: { databaseId }
+		}));
 	}
 	async createDatabase({ organizationId, projectGroupId, name }) {
-		return this.request({
-			method: "POST",
-			path: "/databases",
+		return this.toResult(await postV0ApiDatabases({
+			client: this.client,
 			body: {
 				organizationId,
 				...projectGroupId !== null ? { projectGroupId } : {},
 				...name !== null ? { name } : {}
-			},
-			schema: CreateDatabaseResponseSchema
-		});
+			}
+		}));
 	}
 	async queryDatabase({ databaseId, sql }) {
-		return this.request({
-			method: "POST",
-			path: `/databases/${databaseId}/query`,
-			body: { sql },
-			schema: DatabaseQueryResultSchema
-		});
+		return this.toResult(await postV0ApiDatabasesByDatabaseIdQuery({
+			client: this.client,
+			path: { databaseId },
+			body: { sql }
+		}));
 	}
 	async getDatabaseConnection({ databaseId }) {
-		return this.request({
-			method: "GET",
-			path: `/databases/${databaseId}/connection`,
-			schema: DatabaseConnectionResponseSchema
-		});
+		return this.toResult(await getV0ApiDatabasesByDatabaseIdConnection({
+			client: this.client,
+			path: { databaseId }
+		}));
 	}
 	async resetDatabase({ databaseId }) {
-		return this.request({
-			method: "POST",
-			path: `/databases/${databaseId}/reset`
-		});
+		return this.toResult(await postV0ApiDatabasesByDatabaseIdReset({
+			client: this.client,
+			path: { databaseId }
+		}));
 	}
 	async addDomain({ organizationId, domain, projectGroupId }) {
-		return this.request({
-			method: "POST",
-			path: "/domains",
+		return this.toResult(await postV0ApiDomains({
+			client: this.client,
 			body: {
 				organizationId,
 				domain,
 				...projectGroupId !== null ? { projectGroupId } : {}
-			},
-			schema: AddDomainResponseSchema
-		});
+			}
+		}));
 	}
 	async removeDomain({ domainId }) {
-		return this.request({
-			method: "DELETE",
-			path: `/domains/${domainId}`
-		});
+		return this.toResult(await deleteV0ApiDomainsByDomainId({
+			client: this.client,
+			path: { domainId }
+		}));
 	}
 	async verifyDomain({ domainId }) {
-		return this.request({
-			method: "POST",
-			path: `/domains/${domainId}/verify`,
-			schema: DomainVerificationSchema
-		});
+		return this.toResult(await postV0ApiDomainsByDomainIdVerify({
+			client: this.client,
+			path: { domainId }
+		}));
 	}
 	async listDeployments({ projectGroupId, limit }) {
-		const params = new URLSearchParams();
-		if (limit !== null) params.set("limit", String(limit));
-		const query = params.toString();
-		const path = `/projects/${projectGroupId}/deployments${query ? `?${query}` : ""}`;
-		return this.request({
-			method: "GET",
-			path,
-			schema: ListDeploymentsResponseSchema
-		});
+		return this.toResult(await getV0ApiProjectsByProjectGroupIdDeployments({
+			client: this.client,
+			path: { projectGroupId },
+			query: limit !== null ? { limit } : {}
+		}));
 	}
 	async getDeployment({ deploymentId }) {
-		return this.request({
-			method: "GET",
-			path: `/deployments/${deploymentId}`,
-			schema: DeploymentDetailResponseSchema
-		});
+		return this.toResult(await getV0ApiDeploymentsByDeploymentId({
+			client: this.client,
+			path: { deploymentId }
+		}));
 	}
 	async getDeploymentLogs({ deploymentId }) {
-		return this.request({
-			method: "GET",
-			path: `/deployments/${deploymentId}/logs`,
-			schema: DeploymentLogsResponseSchema
-		});
+		return this.toResult(await getV0ApiDeploymentsByDeploymentIdLogs({
+			client: this.client,
+			path: { deploymentId }
+		}));
 	}
-	async rollbackDeployment({ projectGroupId, deploymentId }) {
-		return this.request({
-			method: "POST",
-			path: `/projects/${projectGroupId}/deployments/rollback`,
-			body: deploymentId !== null ? { deploymentId } : {},
-			schema: RollbackResponseSchema
+	async rollbackDeployment({ projectGroupId }) {
+		return this.toResult(await postV0ApiProjectsByProjectGroupIdDeploymentsRollback({
+			client: this.client,
+			path: { projectGroupId }
+		})).andThen((data) => {
+			const parsed = RollbackResponseSchema.safeParse(data);
+			return parsed.success ? ok(parsed.data) : err({
+				message: "Unexpected API response format",
+				status: 200
+			});
 		});
 	}
 	async inviteMember({ organizationId, email, role }) {
-		return this.request({
-			method: "POST",
-			path: `/organizations/${organizationId}/invites`,
+		return this.toResult(await postV0ApiOrganizationsByOrganizationIdInvites({
+			client: this.client,
+			path: { organizationId },
 			body: {
 				email,
 				...role !== null ? { role } : {}
-			},
-			schema: InviteMemberResponseSchema
-		});
+			}
+		}));
 	}
 	async removeMember({ organizationId, email }) {
-		return this.request({
-			method: "POST",
-			path: `/organizations/${organizationId}/members/remove`,
-			body: { email },
-			schema: RemoveMemberResponseSchema
-		});
+		return this.toResult(await postV0ApiOrganizationsByOrganizationIdMembersRemove({
+			client: this.client,
+			path: { organizationId },
+			body: { email }
+		}));
 	}
 	async updateMemberRole({ organizationId, email, role }) {
-		return this.request({
-			method: "POST",
-			path: `/organizations/${organizationId}/members/role`,
+		const normalizedRole = toMemberRole(role);
+		if (normalizedRole === null) return err({
+			message: `Invalid role: ${role}. Expected one of owner, admin, editor, viewer.`,
+			status: 400
+		});
+		return this.toResult(await postV0ApiOrganizationsByOrganizationIdMembersRole({
+			client: this.client,
+			path: { organizationId },
 			body: {
 				email,
-				role
-			},
-			schema: UpdateMemberRoleResponseSchema
-		});
-	}
-	async request(params) {
-		const url = `${this.baseUrl}${params.path}`;
-		let response;
-		try {
-			response = await fetch(url, {
-				method: params.method,
-				headers: {
-					authorization: this.authHeader,
-					"user-agent": USER_AGENT,
-					...params.body ? { "Content-Type": "application/json" } : {}
-				},
-				...params.body ? { body: JSON.stringify(params.body) } : {}
-			});
-		} catch (cause) {
-			return err({
-				message: `Network error: ${cause instanceof Error ? cause.message : String(cause)}`,
-				status: null
-			});
-		}
-		if (!response.ok) {
-			const text = await response.text().catch(() => "");
-			let details;
-			try {
-				details = JSON.parse(text);
-			} catch {
-				details = text || void 0;
+				role: normalizedRole
 			}
-			const retryAfter = parseRetryAfter(response);
-			return err({
-				message: `API error (${response.status})`,
-				status: response.status,
-				details,
-				...retryAfter !== null ? { retryAfter } : {}
-			});
-		}
-		if (response.status === 204 || !params.schema) return ok(void 0);
-		const json = await response.json();
-		const parsed = params.schema.safeParse(json);
-		if (!parsed.success) return err({
-			message: "Unexpected API response format",
-			status: response.status,
-			details: parsed.error.errors
-		});
-		return ok(parsed.data);
+		}));
 	}
 };
 
@@ -3870,9 +4800,14 @@ function printTable({ headers, rows }) {
 	console.log(widths.map((w) => "─".repeat(w)).join("──"));
 	for (const row of rows) console.log(row.map((cell, i) => cell.padEnd(widths[i] ?? 0)).join("  "));
 }
+const DetailsWithErrorSchema = z.object({ error: z.string() });
+const DetailsWithErrorsSchema = z.object({ errors: z.array(z.union([z.string(), z.object({ message: z.string() })])) });
 function printApiError(error) {
 	printError(error.message);
-	if (error.details && typeof error.details === "object" && "error" in error.details && typeof error.details.error === "string") console.error(`  ${error.details.error}`);
+	const withError = DetailsWithErrorSchema.safeParse(error.details);
+	if (withError.success && withError.data.error !== error.message) console.error(`  ${withError.data.error}`);
+	const withErrors = DetailsWithErrorsSchema.safeParse(error.details);
+	if (withErrors.success) for (const e of withErrors.data.errors) console.error(`  ${typeof e === "string" ? e : e.message}`);
 }
 function outputSuccess({ argv, command, data, primaryId, startTime }) {
 	if (argv.quiet) {
@@ -3891,16 +4826,23 @@ function outputSuccess({ argv, command, data, primaryId, startTime }) {
 	}
 	return false;
 }
+const DetailsWithCodeSchema = z.object({ code: z.string() });
+function extractErrorCode(details) {
+	const parsed = DetailsWithCodeSchema.safeParse(details);
+	return parsed.success ? parsed.data.code : null;
+}
 function outputError({ argv, command, error, hint, exitCode }) {
 	const status = "status" in error ? error.status ?? null : null;
+	const details = "details" in error ? error.details : void 0;
 	const retryAfter = "retryAfter" in error && typeof error.retryAfter === "number" ? error.retryAfter : null;
 	process.exitCode = exitCode ?? exitCodeFromHttpStatus(status);
+	const code = extractErrorCode(details) ?? errorCodeFromHttpStatus(status);
 	if (argv.json || argv.quiet) {
 		console.error(JSON.stringify({
 			ok: false,
 			command,
 			error: {
-				code: errorCodeFromHttpStatus(status),
+				code,
 				message: error.message,
 				...hint ? { hint } : {},
 				...retryAfter !== null ? { retry_after_seconds: retryAfter } : {}
@@ -3910,7 +4852,8 @@ function outputError({ argv, command, error, hint, exitCode }) {
 	}
 	printApiError({
 		message: error.message,
-		status: error.status
+		status: error.status,
+		details
 	});
 	if (retryAfter !== null) console.error(`  ${styleText("dim", `Retry after ${retryAfter}s`)}`);
 	if (hint) console.error(`  ${styleText("dim", hint)}`);
@@ -4040,7 +4983,8 @@ const upload = {
 			outputError({
 				argv,
 				command,
-				error: result.error
+				error: result.error,
+				hint: "Check the file path exists and is under the size limit"
 			});
 			return;
 		}
@@ -4191,15 +5135,15 @@ const remove$1 = {
 	}
 };
 const assetsCommand = {
-	command: "assets <command>",
+	command: "assets",
 	describe: "Manage project assets (images)",
-	builder: (yargs) => yargs.command(upload).command(list$2).command(remove$1).demandCommand(),
+	builder: (yargs) => yargs.command(upload).command(list$2).command(remove$1).demandCommand(1, "Specify an assets subcommand. Run `anything assets --help` for usage."),
 	handler: () => {}
 };
 
 //#endregion
 //#region src/commands/dev.ts
-const COMMAND$24 = "dev";
+const COMMAND$26 = "dev";
 const devCommand = {
 	command: "dev [state]",
 	describe: "Toggle local dev mode so commands target your local dev stack",
@@ -4219,7 +5163,7 @@ const devCommand = {
 		const apiUrl = resolveApiUrl({ apiUrl: argv.apiUrl });
 		if (outputSuccess({
 			argv,
-			command: COMMAND$24,
+			command: COMMAND$26,
 			data: {
 				devMode: enabled,
 				apiUrl
@@ -4287,7 +5231,7 @@ function isNonInteractive(argv) {
 
 //#endregion
 //#region src/commands/auth.ts
-const POLL_INTERVAL_MS$1 = 2e3;
+const POLL_INTERVAL_MS$2 = 2e3;
 const POLL_TIMEOUT_MS$1 = 3e5;
 const DEFAULT_WEB_URL = "https://anything.com";
 const DevAutoLoginResponseSchema = z.object({
@@ -4420,7 +5364,7 @@ async function startCliAuth({ apiUrl }) {
 async function pollForApiKey({ apiUrl, pollingId }) {
 	const deadline = Date.now() + POLL_TIMEOUT_MS$1;
 	while (Date.now() < deadline) {
-		await setTimeout$1(POLL_INTERVAL_MS$1);
+		await setTimeout$1(POLL_INTERVAL_MS$2);
 		const response = await fetch(`${apiUrl}/v0/auth/cli/poll?id=${encodeURIComponent(pollingId)}`, { headers: { "user-agent": USER_AGENT } }).catch(() => null);
 		if (!response) continue;
 		if (response.status === 429) {
@@ -4741,7 +5685,7 @@ const authCommand = {
 
 //#endregion
 //#region src/commands/database-connect.ts
-const COMMAND$23 = "databases connect";
+const COMMAND$25 = "databases connect";
 const databaseConnectCommand = {
 	command: "connect <databaseId>",
 	describe: "Print the connection string for a database",
@@ -4758,7 +5702,7 @@ const databaseConnectCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$23,
+				command: COMMAND$25,
 				error: {
 					message: config.error.message,
 					status: null
@@ -4771,14 +5715,14 @@ const databaseConnectCommand = {
 		if (result.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$23,
+				command: COMMAND$25,
 				error: result.error
 			});
 			return;
 		}
 		if (outputSuccess({
 			argv,
-			command: COMMAND$23,
+			command: COMMAND$25,
 			data: result.value,
 			primaryId: result.value.connectionString
 		})) return;
@@ -4832,7 +5776,7 @@ async function resolveOrgId({ flagOrg, config, nonInteractive }) {
 
 //#endregion
 //#region src/commands/database-create.ts
-const COMMAND$22 = "databases create";
+const COMMAND$24 = "databases create";
 const databaseCreateCommand = {
 	command: "create",
 	describe: "Create a new database for a project",
@@ -4854,7 +5798,7 @@ const databaseCreateCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$22,
+				command: COMMAND$24,
 				error: {
 					message: config.error.message,
 					status: null
@@ -4871,7 +5815,7 @@ const databaseCreateCommand = {
 		if (!orgResult.ok) {
 			outputError({
 				argv,
-				command: COMMAND$22,
+				command: COMMAND$24,
 				error: {
 					message: orgResult.error,
 					status: null
@@ -4883,7 +5827,7 @@ const databaseCreateCommand = {
 		if (argv["dry-run"]) {
 			outputDryRun({
 				argv,
-				command: COMMAND$22,
+				command: COMMAND$24,
 				plannedActions: [{
 					action: "create_database",
 					org: orgResult.orgId,
@@ -4901,14 +5845,14 @@ const databaseCreateCommand = {
 		if (result.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$22,
+				command: COMMAND$24,
 				error: result.error
 			});
 			return;
 		}
 		if (outputSuccess({
 			argv,
-			command: COMMAND$22,
+			command: COMMAND$24,
 			data: result.value.database,
 			primaryId: result.value.database.id
 		})) return;
@@ -4921,7 +5865,7 @@ const databaseCreateCommand = {
 
 //#endregion
 //#region src/commands/database-get.ts
-const COMMAND$21 = "databases get";
+const COMMAND$23 = "databases get";
 const databaseGetCommand = {
 	command: "get <databaseId>",
 	describe: "Inspect a database",
@@ -4938,7 +5882,7 @@ const databaseGetCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$21,
+				command: COMMAND$23,
 				error: {
 					message: config.error.message,
 					status: null
@@ -4951,14 +5895,14 @@ const databaseGetCommand = {
 		if (result.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$21,
+				command: COMMAND$23,
 				error: result.error
 			});
 			return;
 		}
 		if (outputSuccess({
 			argv,
-			command: COMMAND$21,
+			command: COMMAND$23,
 			data: result.value.database,
 			primaryId: result.value.database.id
 		})) return;
@@ -4973,7 +5917,7 @@ const databaseGetCommand = {
 
 //#endregion
 //#region src/commands/database-query.ts
-const COMMAND$20 = "databases query";
+const COMMAND$22 = "databases query";
 const databaseQueryCommand = {
 	command: "query <databaseId> <sql>",
 	describe: "Run a read-only SQL query against a database",
@@ -4994,7 +5938,7 @@ const databaseQueryCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$20,
+				command: COMMAND$22,
 				error: {
 					message: config.error.message,
 					status: null
@@ -5010,14 +5954,15 @@ const databaseQueryCommand = {
 		if (result.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$20,
-				error: result.error
+				command: COMMAND$22,
+				error: result.error,
+				hint: "Check the database ID and SQL syntax"
 			});
 			return;
 		}
 		if (outputSuccess({
 			argv,
-			command: COMMAND$20,
+			command: COMMAND$22,
 			data: result.value
 		})) return;
 		if (result.value.rows.length === 0) {
@@ -5035,7 +5980,7 @@ const databaseQueryCommand = {
 
 //#endregion
 //#region src/commands/database-reset.ts
-const COMMAND$19 = "databases reset";
+const COMMAND$21 = "databases reset";
 const databaseResetCommand = {
 	command: "reset <databaseId>",
 	describe: "Reset a database (destructive)",
@@ -5056,7 +6001,7 @@ const databaseResetCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$19,
+				command: COMMAND$21,
 				error: {
 					message: config.error.message,
 					status: null
@@ -5068,7 +6013,7 @@ const databaseResetCommand = {
 		if (argv["dry-run"]) {
 			outputDryRun({
 				argv,
-				command: COMMAND$19,
+				command: COMMAND$21,
 				plannedActions: [{
 					action: "reset_database",
 					databaseId: argv.databaseId
@@ -5079,7 +6024,7 @@ const databaseResetCommand = {
 		if (!argv.yes) {
 			outputError({
 				argv,
-				command: COMMAND$19,
+				command: COMMAND$21,
 				error: {
 					message: "Database reset is destructive. Pass --yes to confirm.",
 					status: null
@@ -5092,14 +6037,14 @@ const databaseResetCommand = {
 		if (result.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$19,
+				command: COMMAND$21,
 				error: result.error
 			});
 			return;
 		}
 		if (outputSuccess({
 			argv,
-			command: COMMAND$19,
+			command: COMMAND$21,
 			data: {
 				reset: true,
 				databaseId: argv.databaseId
@@ -5111,7 +6056,7 @@ const databaseResetCommand = {
 
 //#endregion
 //#region src/commands/list-databases.ts
-const COMMAND$18 = "databases list";
+const COMMAND$20 = "databases list";
 const listDatabasesCommand = {
 	command: "list",
 	describe: "List databases you can access",
@@ -5132,7 +6077,7 @@ const listDatabasesCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$18,
+				command: COMMAND$20,
 				error: {
 					message: config.error.message,
 					status: null
@@ -5148,7 +6093,7 @@ const listDatabasesCommand = {
 		if (result.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$18,
+				command: COMMAND$20,
 				error: result.error
 			});
 			return;
@@ -5159,7 +6104,7 @@ const listDatabasesCommand = {
 		}
 		if (outputSuccess({
 			argv,
-			command: COMMAND$18,
+			command: COMMAND$20,
 			data: result.value
 		})) return;
 		if (result.value.databases.length === 0) {
@@ -5474,7 +6419,7 @@ const deploymentsCommand = {
 
 //#endregion
 //#region src/commands/domain-add.ts
-const COMMAND$17 = "domains add";
+const COMMAND$19 = "domains add";
 const domainAddCommand = {
 	command: "add <domain>",
 	describe: "Add a custom domain to a project",
@@ -5497,7 +6442,7 @@ const domainAddCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$17,
+				command: COMMAND$19,
 				error: {
 					message: config.error.message,
 					status: null
@@ -5514,7 +6459,7 @@ const domainAddCommand = {
 		if (!orgResult.ok) {
 			outputError({
 				argv,
-				command: COMMAND$17,
+				command: COMMAND$19,
 				error: {
 					message: orgResult.error,
 					status: null
@@ -5526,7 +6471,7 @@ const domainAddCommand = {
 		if (argv["dry-run"]) {
 			outputDryRun({
 				argv,
-				command: COMMAND$17,
+				command: COMMAND$19,
 				plannedActions: [{
 					action: "add_domain",
 					domain: argv.domain,
@@ -5544,14 +6489,14 @@ const domainAddCommand = {
 		if (result.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$17,
+				command: COMMAND$19,
 				error: result.error
 			});
 			return;
 		}
 		if (outputSuccess({
 			argv,
-			command: COMMAND$17,
+			command: COMMAND$19,
 			data: result.value.domain,
 			primaryId: result.value.domain.domain
 		})) return;
@@ -5563,7 +6508,7 @@ const domainAddCommand = {
 
 //#endregion
 //#region src/commands/domain-remove.ts
-const COMMAND$16 = "domains remove";
+const COMMAND$18 = "domains remove";
 const domainRemoveCommand = {
 	command: "remove <domainId>",
 	describe: "Remove a custom domain",
@@ -5584,7 +6529,7 @@ const domainRemoveCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$16,
+				command: COMMAND$18,
 				error: {
 					message: config.error.message,
 					status: null
@@ -5596,7 +6541,7 @@ const domainRemoveCommand = {
 		if (argv["dry-run"]) {
 			outputDryRun({
 				argv,
-				command: COMMAND$16,
+				command: COMMAND$18,
 				plannedActions: [{
 					action: "remove_domain",
 					domainId: argv.domainId
@@ -5607,7 +6552,7 @@ const domainRemoveCommand = {
 		if (!argv.yes) {
 			outputError({
 				argv,
-				command: COMMAND$16,
+				command: COMMAND$18,
 				error: {
 					message: "Domain removal is destructive. Pass --yes to confirm.",
 					status: null
@@ -5620,14 +6565,14 @@ const domainRemoveCommand = {
 		if (result.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$16,
+				command: COMMAND$18,
 				error: result.error
 			});
 			return;
 		}
 		if (outputSuccess({
 			argv,
-			command: COMMAND$16,
+			command: COMMAND$18,
 			data: {
 				removed: true,
 				domainId: argv.domainId
@@ -5639,7 +6584,7 @@ const domainRemoveCommand = {
 
 //#endregion
 //#region src/commands/domain-verify.ts
-const COMMAND$15 = "domains verify";
+const COMMAND$17 = "domains verify";
 const domainVerifyCommand = {
 	command: "verify <domainId>",
 	describe: "Check DNS configuration for a custom domain",
@@ -5656,7 +6601,7 @@ const domainVerifyCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$15,
+				command: COMMAND$17,
 				error: {
 					message: config.error.message,
 					status: null
@@ -5669,14 +6614,14 @@ const domainVerifyCommand = {
 		if (result.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$15,
+				command: COMMAND$17,
 				error: result.error
 			});
 			return;
 		}
 		if (outputSuccess({
 			argv,
-			command: COMMAND$15,
+			command: COMMAND$17,
 			data: result.value,
 			primaryId: String(result.value.verified)
 		})) return;
@@ -5985,11 +6930,26 @@ const commandTree = [
 		}, {
 			name: "--store",
 			type: "string",
-			required: true
+			required: true,
+			choices: ["app-store"]
 		}],
 		idempotent: false,
 		destructive: false
 	},
+	{
+		name: "projects submit status",
+		flags: [{
+			name: "<projectId>",
+			type: "string",
+			required: true
+		}, {
+			name: "<submissionId>",
+			type: "string",
+			required: true
+		}],
+		idempotent: true,
+		destructive: false
+	},
 	{
 		name: "projects unpublish",
 		flags: [{
@@ -6004,6 +6964,20 @@ const commandTree = [
 		idempotent: true,
 		destructive: true
 	},
+	{
+		name: "projects delete",
+		flags: [{
+			name: "<projectId>",
+			type: "string",
+			required: true
+		}, {
+			name: "--yes",
+			type: "boolean",
+			required: true
+		}],
+		idempotent: false,
+		destructive: true
+	},
 	{
 		name: "projects messages",
 		flags: [
@@ -6098,23 +7072,86 @@ const commandTree = [
 		destructive: false
 	},
 	{
-		name: "projects set",
+		name: "projects set",
+		flags: [{
+			name: "<projectId>",
+			type: "string",
+			required: true
+		}],
+		idempotent: true,
+		destructive: false
+	},
+	{
+		name: "projects unset",
+		flags: [],
+		idempotent: true,
+		destructive: false
+	},
+	{
+		name: "projects auth providers",
+		flags: [{
+			name: "<projectId>",
+			type: "string",
+			required: true
+		}],
+		idempotent: true,
+		destructive: false
+	},
+	{
+		name: "projects settings auth get",
 		flags: [{
-			name: "<projectId>",
+			name: "[projectId]",
 			type: "string",
-			required: true
+			required: false
 		}],
 		idempotent: true,
 		destructive: false
 	},
 	{
-		name: "projects unset",
-		flags: [],
-		idempotent: true,
+		name: "projects settings auth set",
+		flags: [
+			{
+				name: "[projectId]",
+				type: "string",
+				required: false
+			},
+			{
+				name: "--provider",
+				type: "string",
+				required: true,
+				choices: [
+					"google",
+					"email",
+					"facebook",
+					"twitter"
+				]
+			},
+			{
+				name: "--enabled",
+				type: "boolean",
+				required: true
+			},
+			{
+				name: "--secret",
+				type: "string",
+				required: false
+			},
+			{
+				name: "--env",
+				type: "string",
+				required: false,
+				choices: [
+					"development",
+					"preview",
+					"production"
+				]
+			}
+		],
+		idempotent: false,
 		destructive: false
 	},
 	{
-		name: "secrets add",
+		name: "projects secrets add",
 		flags: [
 			{
 				name: "<projectId>",
@@ -6141,7 +7178,7 @@ const commandTree = [
 		destructive: false
 	},
 	{
-		name: "secrets list",
+		name: "projects secrets list",
 		flags: [{
 			name: "<projectId>",
 			type: "string",
@@ -6151,7 +7188,7 @@ const commandTree = [
 		destructive: false
 	},
 	{
-		name: "secrets remove",
+		name: "projects secrets remove",
 		flags: [{
 			name: "<projectId>",
 			type: "string",
@@ -7601,6 +8638,13 @@ function createEmitter(argv) {
 //#endregion
 //#region src/watch-generation.ts
 const TIMEOUT_MS = 300 * 1e3;
+const POLL_INTERVAL_MS$1 = 3e3;
+const TERMINAL_SUCCESS_STATUSES = new Set(["COMPLETED", "VALID"]);
+const TERMINAL_FAILURE_STATUSES = new Set([
+	"INVALID",
+	"INVALID_PROMPT",
+	"FAILED"
+]);
 const REVISIONS_FINISHED_QUERY = `
   subscription ProjectGroupRevisionsFinished($id: ID!) {
     projectGroupRevisionsFinished(id: $id) {
@@ -7693,7 +8737,6 @@ function waitForRevisionFinished({ config, projectGroupId }) {
 		});
 	});
 }
-const SUCCESS_STATUSES = new Set(["COMPLETED", "VALID"]);
 async function latestMessageSucceeded({ client, projectGroupId }) {
 	const result = await client.getMessages({
 		projectGroupId,
@@ -7703,28 +8746,70 @@ async function latestMessageSucceeded({ client, projectGroupId }) {
 	if (result.isErr()) return null;
 	const latest = result.value.messages[0];
 	if (!latest) return null;
-	return SUCCESS_STATUSES.has(latest.status);
+	return TERMINAL_SUCCESS_STATUSES.has(latest.status);
 }
-async function watchGeneration({ config, client, projectGroupId, emit, waitForFinished = waitForRevisionFinished }) {
+function sleep$2(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function pollUntilTerminal({ client, projectGroupId, emit, sleepFn = sleep$2 }) {
+	emit({
+		type: "progress",
+		step: "generating",
+		status: "running",
+		message: "Streaming unavailable; polling generation status..."
+	});
+	const deadlineMs = Date.now() + TIMEOUT_MS;
+	while (Date.now() < deadlineMs) {
+		const result = await client.getProjectStatus({ projectGroupId });
+		if (result.isErr()) {
+			await sleepFn(POLL_INTERVAL_MS$1);
+			continue;
+		}
+		const { status } = result.value;
+		if (status !== null && TERMINAL_SUCCESS_STATUSES.has(status)) {
+			emit({
+				type: "progress",
+				step: "generating",
+				status: "complete",
+				message: "Generation complete"
+			});
+			return true;
+		}
+		if (status !== null && TERMINAL_FAILURE_STATUSES.has(status)) {
+			emit({
+				type: "result",
+				ok: false,
+				error: {
+					code: "generation_failed",
+					message: `Generation failed with status: ${status}`
+				}
+			});
+			return false;
+		}
+		await sleepFn(POLL_INTERVAL_MS$1);
+	}
+	emit({
+		type: "result",
+		ok: false,
+		error: {
+			code: "timeout",
+			message: "Generation timed out waiting for completion"
+		}
+	});
+	return false;
+}
+async function watchGeneration({ config, client, projectGroupId, emit, waitForFinished = waitForRevisionFinished, sleepFn }) {
 	const finished = await waitForFinished({
 		config,
 		projectGroupId
 	});
 	if (!finished.ok) {
-		if (finished.error.code === "websocket_error") {
-			if (await latestMessageSucceeded({
-				client,
-				projectGroupId
-			})) {
-				emit({
-					type: "progress",
-					step: "generating",
-					status: "complete",
-					message: "Generation complete"
-				});
-				return true;
-			}
-		}
+		if (finished.error.code === "websocket_error") return pollUntilTerminal({
+			client,
+			projectGroupId,
+			emit,
+			sleepFn
+		});
 		emit({
 			type: "result",
 			ok: false,
@@ -7747,7 +8832,7 @@ async function watchGeneration({ config, client, projectGroupId, emit, waitForFi
 
 //#endregion
 //#region src/commands/create.ts
-const COMMAND$14 = "projects create";
+const COMMAND$16 = "projects create";
 const createCommand = {
 	command: "create",
 	describe: "Create a new app and start initial generation",
@@ -7769,7 +8854,7 @@ const createCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$14,
+				command: COMMAND$16,
 				error: {
 					message: config.error.message,
 					status: null
@@ -7786,7 +8871,7 @@ const createCommand = {
 		if (!orgResult.ok) {
 			outputError({
 				argv,
-				command: COMMAND$14,
+				command: COMMAND$16,
 				error: {
 					message: orgResult.error,
 					status: null
@@ -7803,7 +8888,7 @@ const createCommand = {
 		if (!promptResult.ok) {
 			outputValidationError({
 				argv,
-				command: COMMAND$14,
+				command: COMMAND$16,
 				message: promptResult.error
 			});
 			return;
@@ -7811,7 +8896,7 @@ const createCommand = {
 		if (argv["dry-run"]) {
 			outputDryRun({
 				argv,
-				command: COMMAND$14,
+				command: COMMAND$16,
 				plannedActions: [{
 					action: "create_project",
 					org: orgResult.orgId,
@@ -7838,7 +8923,7 @@ const createCommand = {
 		if (result.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$14,
+				command: COMMAND$16,
 				error: result.error
 			});
 			return;
@@ -7863,17 +8948,38 @@ const createCommand = {
 		});
 		if (argv.quiet) {
 			console.log(result.value.projectGroupId);
+			if (succeeded === false) process.exitCode = 1;
 			return;
 		}
-		if (argv.json) printNdjson({
-			type: "result",
-			ok: succeeded !== false,
-			data: result.value
-		});
-		else {
-			if (succeeded !== false) printStreamMarker("done", `project ${result.value.projectGroupId} ready`);
+		if (succeeded === false) {
+			if (!argv.json) {
+				outputError({
+					argv,
+					command: COMMAND$16,
+					error: {
+						message: "Generation failed.",
+						status: null
+					}
+				});
+				printLabel("Project Group ID", result.value.projectGroupId);
+			}
+			process.exitCode = 1;
+			return;
+		}
+		if (argv.json) {
+			const { projectGroupId: projectId, ...rest } = result.value;
+			printNdjson({
+				type: "result",
+				ok: true,
+				data: {
+					projectId,
+					...rest
+				}
+			});
+		} else {
+			printStreamMarker("done", `project ${result.value.projectGroupId} ready`);
 			printSuccess("App created! Generation complete.");
-			printLabel("Project Group ID", result.value.projectGroupId);
+			printLabel("Project ID", result.value.projectGroupId);
 			printLabel("Revision ID", result.value.revisionId);
 		}
 	}
@@ -7934,7 +9040,7 @@ function getDeploymentError({ result, statusCommand }) {
 
 //#endregion
 //#region src/commands/publish.ts
-const COMMAND$13 = "projects publish";
+const COMMAND$15 = "projects publish";
 const publishStatusCommand = {
 	command: "status <projectId> <deploymentId>",
 	describe: "Check the status of a publish deployment",
@@ -8019,7 +9125,7 @@ const publishCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$13,
+				command: COMMAND$15,
 				error: {
 					message: config.error.message,
 					status: null
@@ -8037,7 +9143,7 @@ const publishCommand = {
 				if (argv.json || argv.quiet) {
 					outputValidationError({
 						argv,
-						command: COMMAND$13,
+						command: COMMAND$15,
 						message,
 						hint
 					});
@@ -8051,7 +9157,7 @@ const publishCommand = {
 		if (argv["dry-run"]) {
 			outputDryRun({
 				argv,
-				command: COMMAND$13,
+				command: COMMAND$15,
 				plannedActions: [{
 					action: "publish_project",
 					projectGroupId: argv.projectId,
@@ -8068,7 +9174,7 @@ const publishCommand = {
 		if (result.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$13,
+				command: COMMAND$15,
 				error: result.error
 			});
 			return;
@@ -8078,12 +9184,13 @@ const publishCommand = {
 		if (!argv.wait) {
 			if (outputSuccess({
 				argv,
-				command: COMMAND$13,
+				command: COMMAND$15,
 				data: {
 					projectId,
 					deploymentId,
 					status: "PENDING",
-					...publishData
+					...publishData,
+					url
 				},
 				primaryId: url ?? projectId,
 				startTime
@@ -8109,7 +9216,7 @@ const publishCommand = {
 		if (deployResult.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$13,
+				command: COMMAND$15,
 				error: deployResult.error
 			});
 			return;
@@ -8121,7 +9228,7 @@ const publishCommand = {
 		if (deployError) {
 			outputError({
 				argv,
-				command: COMMAND$13,
+				command: COMMAND$15,
 				error: {
 					message: deployError.message,
 					status: null
@@ -8132,7 +9239,7 @@ const publishCommand = {
 		}
 		if (outputSuccess({
 			argv,
-			command: COMMAND$13,
+			command: COMMAND$15,
 			data: {
 				projectId,
 				deploymentId,
@@ -8149,7 +9256,7 @@ const publishCommand = {
 
 //#endregion
 //#region src/commands/duplicate.ts
-const COMMAND$12 = "projects duplicate";
+const COMMAND$14 = "projects duplicate";
 const duplicateCommand = {
 	command: "duplicate <projectId>",
 	describe: "Duplicate an existing app",
@@ -8165,7 +9272,7 @@ const duplicateCommand = {
 		if (argv["dry-run"]) {
 			outputDryRun({
 				argv,
-				command: COMMAND$12,
+				command: COMMAND$14,
 				plannedActions: [{
 					action: "duplicate_project",
 					projectGroupId: argv.projectId,
@@ -8181,7 +9288,7 @@ const duplicateCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$12,
+				command: COMMAND$14,
 				error: {
 					message: config.error.message,
 					status: null
@@ -8198,7 +9305,7 @@ const duplicateCommand = {
 		if (result.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$12,
+				command: COMMAND$14,
 				error: result.error
 			});
 			return;
@@ -8206,7 +9313,7 @@ const duplicateCommand = {
 		const { projectGroupId: projectId, ...dupData } = result.value;
 		if (outputSuccess({
 			argv,
-			command: COMMAND$12,
+			command: COMMAND$14,
 			data: {
 				projectId,
 				...dupData
@@ -8333,7 +9440,7 @@ const filesCommand = {
 
 //#endregion
 //#region src/commands/generate.ts
-const COMMAND$11 = "projects generate";
+const COMMAND$13 = "projects generate";
 const generateCommand = {
 	command: "generate <projectId>",
 	describe: "Send a prompt to an existing app",
@@ -8364,7 +9471,7 @@ const generateCommand = {
 		if (!promptResult.ok) {
 			outputValidationError({
 				argv,
-				command: COMMAND$11,
+				command: COMMAND$13,
 				message: promptResult.error
 			});
 			return;
@@ -8372,7 +9479,7 @@ const generateCommand = {
 		if (argv["dry-run"]) {
 			outputDryRun({
 				argv,
-				command: COMMAND$11,
+				command: COMMAND$13,
 				plannedActions: [{
 					action: "generate",
 					projectGroupId: argv.projectId,
@@ -8390,7 +9497,7 @@ const generateCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$11,
+				command: COMMAND$13,
 				error: {
 					message: config.error.message,
 					status: null
@@ -8422,8 +9529,9 @@ const generateCommand = {
 			});
 			else outputError({
 				argv,
-				command: COMMAND$11,
-				error: result.error
+				command: COMMAND$13,
+				error: result.error,
+				hint: "Verify the project and thread IDs are correct"
 			});
 			process.exitCode = 1;
 			return;
@@ -8567,7 +9675,7 @@ const projectAuthCommand = {
 
 //#endregion
 //#region src/commands/info.ts
-const COMMAND$10 = "projects get";
+const COMMAND$12 = "projects get";
 const infoCommand = {
 	command: "info <projectId>",
 	describe: "Get app info and dev server status",
@@ -8584,7 +9692,7 @@ const infoCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$10,
+				command: COMMAND$12,
 				error: {
 					message: config.error.message,
 					status: null
@@ -8597,29 +9705,34 @@ const infoCommand = {
 		if (result.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$10,
-				error: result.error
+				command: COMMAND$12,
+				error: result.error,
+				hint: "Check the project ID with: anything projects list --json"
 			});
 			return;
 		}
+		const info = result.value;
+		const latestPublishedUrl = info.latestPublishedUrl ?? (info.slug ? `https://${info.slug}.created.app` : null);
 		if (outputSuccess({
 			argv,
-			command: COMMAND$10,
-			data: result.value,
+			command: COMMAND$12,
+			data: {
+				...info,
+				latestPublishedUrl
+			},
 			primaryId: result.value.id
 		})) return;
-		const info = result.value;
 		console.log();
 		printLabel("Name", info.name);
 		printLabel("ID", info.id);
 		printLabel("Slug", info.slug);
 		printLabel("Filesystem", info.filesystemVersion);
 		printLabel("Dev Server", info.devServerUrl);
-		printLabel("Published URL", info.latestPublishedUrl);
+		printLabel("Published URL", latestPublishedUrl);
 		printLabel("Created", new Date(info.createdAt).toLocaleString());
 		printLabel("Updated", new Date(info.updatedAt).toLocaleString());
 		for (const url of info.publishedUrls) printLabel("Published URL", url);
-		if (info.projects.length > 0) {
+		if (info.files.length > 0) {
 			console.log();
 			printTable({
 				headers: [
@@ -8628,10 +9741,10 @@ const infoCommand = {
 					"Path",
 					"ID"
 				],
-				rows: info.projects.map((p) => [
+				rows: info.files.map((p) => [
 					p.name,
 					p.moduleType,
-					p.pathSegment ?? "",
+					p.path ?? p.pathSegment ?? "",
 					p.id
 				])
 			});
@@ -8641,7 +9754,7 @@ const infoCommand = {
 
 //#endregion
 //#region src/commands/list-projects.ts
-const COMMAND$9 = "projects list";
+const COMMAND$11 = "projects list";
 const listProjectsCommand = {
 	command: "list",
 	describe: "List projects you can access",
@@ -8664,7 +9777,7 @@ const listProjectsCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$9,
+				command: COMMAND$11,
 				error: {
 					message: config.error.message,
 					status: null
@@ -8686,7 +9799,7 @@ const listProjectsCommand = {
 		if (result.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$9,
+				command: COMMAND$11,
 				error: result.error
 			});
 			return;
@@ -8697,7 +9810,7 @@ const listProjectsCommand = {
 		}
 		if (outputSuccess({
 			argv,
-			command: COMMAND$9,
+			command: COMMAND$11,
 			data: result.value
 		})) return;
 		if (result.value.projects.length === 0) {
@@ -8723,7 +9836,7 @@ const listProjectsCommand = {
 
 //#endregion
 //#region src/commands/logs.ts
-const COMMAND$8 = "projects logs";
+const COMMAND$10 = "projects logs";
 const DEFAULT_POLL_INTERVAL_MS$1 = 3e3;
 const IDLE_TIMEOUT_MS$1 = 300 * 1e3;
 function parseSince(since) {
@@ -8803,7 +9916,7 @@ const logsCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$8,
+				command: COMMAND$10,
 				error: {
 					message: config.error.message,
 					status: null
@@ -8823,7 +9936,7 @@ const logsCommand = {
 		if (result.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$8,
+				command: COMMAND$10,
 				error: result.error
 			});
 			return;
@@ -8833,7 +9946,7 @@ const logsCommand = {
 		if (!argv.follow) {
 			if (outputSuccess({
 				argv,
-				command: COMMAND$8,
+				command: COMMAND$10,
 				data: { logs }
 			})) return;
 			if (logs.length === 0) {
@@ -8895,7 +10008,7 @@ const logsCommand = {
 
 //#endregion
 //#region src/commands/messages.ts
-const COMMAND$7 = "projects messages";
+const COMMAND$9 = "projects messages";
 function formatMessage(msg) {
 	const time = new Date(msg.createdAt).toLocaleString();
 	const status = msg.status === "VALID" ? styleText("green", msg.status) : msg.status === "BUILDING" ? styleText("yellow", msg.status) : styleText("red", msg.status);
@@ -8926,7 +10039,7 @@ const messagesCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$7,
+				command: COMMAND$9,
 				error: {
 					message: config.error.message,
 					status: null
@@ -8943,14 +10056,14 @@ const messagesCommand = {
 		if (result.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$7,
+				command: COMMAND$9,
 				error: result.error
 			});
 			return;
 		}
 		if (outputSuccess({
 			argv,
-			command: COMMAND$7,
+			command: COMMAND$9,
 			data: result.value
 		})) return;
 		const { messages } = result.value;
@@ -8964,10 +10077,10 @@ const messagesCommand = {
 
 //#endregion
 //#region src/commands/project-status.ts
-const COMMAND$6 = "projects status";
+const COMMAND$8 = "projects status";
 const projectStatusCommand = {
 	command: "status <projectId>",
-	describe: "Cheap polling endpoint: returns just the latest revision status and deployment summary",
+	describe: "Show the latest revision status and deployment summary (lightweight, for polling)",
 	builder: (yargs) => yargs.positional("projectId", {
 		type: "string",
 		demandOption: true,
@@ -8981,7 +10094,7 @@ const projectStatusCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$6,
+				command: COMMAND$8,
 				error: {
 					message: config.error.message,
 					status: null
@@ -8994,20 +10107,24 @@ const projectStatusCommand = {
 		if (result.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$6,
+				command: COMMAND$8,
 				error: result.error
 			});
 			return;
 		}
+		const { projectGroupId: projectId, ...statusRest } = result.value;
 		if (outputSuccess({
 			argv,
-			command: COMMAND$6,
-			data: result.value,
-			primaryId: result.value.projectGroupId
+			command: COMMAND$8,
+			data: {
+				projectId,
+				...statusRest
+			},
+			primaryId: projectId
 		})) return;
 		const status = result.value;
 		console.log();
-		printLabel("Project", status.projectGroupId);
+		printLabel("Project ID", status.projectGroupId);
 		printLabel("Status", status.status ?? "(no revisions yet)");
 		printLabel("Latest Revision", status.latestRevisionId);
 		printLabel("Updated", new Date(status.updatedAt).toLocaleString());
@@ -9018,7 +10135,7 @@ const projectStatusCommand = {
 
 //#endregion
 //#region src/commands/rename.ts
-const COMMAND$5 = "projects rename";
+const COMMAND$7 = "projects rename";
 const renameCommand = {
 	command: "rename <projectId>",
 	describe: "Rename a project",
@@ -9036,7 +10153,7 @@ const renameCommand = {
 		if (name.length === 0) {
 			outputError({
 				argv,
-				command: COMMAND$5,
+				command: COMMAND$7,
 				error: {
 					message: "Project name cannot be empty.",
 					status: null
@@ -9048,7 +10165,7 @@ const renameCommand = {
 		if (argv["dry-run"]) {
 			outputDryRun({
 				argv,
-				command: COMMAND$5,
+				command: COMMAND$7,
 				plannedActions: [{
 					action: "rename_project",
 					projectGroupId: argv.projectId,
@@ -9065,7 +10182,7 @@ const renameCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$5,
+				command: COMMAND$7,
 				error: {
 					message: config.error.message,
 					status: null
@@ -9081,7 +10198,7 @@ const renameCommand = {
 		if (result.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$5,
+				command: COMMAND$7,
 				error: result.error
 			});
 			return;
@@ -9089,7 +10206,7 @@ const renameCommand = {
 		const { projectGroupId: projectId, ...renameData } = result.value;
 		if (outputSuccess({
 			argv,
-			command: COMMAND$5,
+			command: COMMAND$7,
 			data: {
 				projectId,
 				...renameData
@@ -9609,6 +10726,11 @@ async function waitForSubmission({ client, projectGroupId, submission }) {
 	return ok(current);
 }
 function printSubmissionResult({ argv, command, pendingMessage, submission }) {
+	const { projectGroupId: projectId, ...submissionRest } = submission;
+	const submissionOut = {
+		projectId,
+		...submissionRest
+	};
 	if (submission.status === "FAILED") {
 		printError(submission.errorMessage ?? "Submission failed.");
 		process.exitCode = 1;
@@ -9620,7 +10742,7 @@ function printSubmissionResult({ argv, command, pendingMessage, submission }) {
 			command,
 			data: {
 				success: true,
-				submission
+				submission: submissionOut
 			},
 			primaryId: submission.id
 		})) return;
@@ -9786,7 +10908,7 @@ const submitCommand = {
 
 //#endregion
 //#region src/commands/unpublish.ts
-const COMMAND$4 = "projects unpublish";
+const COMMAND$6 = "projects unpublish";
 const unpublishCommand = {
 	command: "unpublish <projectId>",
 	describe: "Unpublish an app from production",
@@ -9803,7 +10925,7 @@ const unpublishCommand = {
 		if (!argv.yes && !isNonInteractive(argv)) {
 			outputError({
 				argv,
-				command: COMMAND$4,
+				command: COMMAND$6,
 				error: {
 					message: "Pass --yes to unpublish this app.",
 					status: null
@@ -9815,9 +10937,89 @@ const unpublishCommand = {
 		if (argv["dry-run"]) {
 			outputDryRun({
 				argv,
-				command: COMMAND$4,
+				command: COMMAND$6,
+				plannedActions: [{
+					action: "unpublish_project",
+					projectGroupId: argv.projectId
+				}]
+			});
+			return;
+		}
+		const config = resolveConfig({
+			dev: argv.dev,
+			apiUrl: argv.apiUrl
+		});
+		if (config.isErr()) {
+			outputError({
+				argv,
+				command: COMMAND$6,
+				error: {
+					message: config.error.message,
+					status: null
+				},
+				exitCode: 4
+			});
+			return;
+		}
+		const startTime = performance.now();
+		const result = await new AnythingApiClient(config.value).unpublish({ projectGroupId: argv.projectId });
+		if (result.isErr()) {
+			outputError({
+				argv,
+				command: COMMAND$6,
+				error: result.error
+			});
+			return;
+		}
+		const { projectGroupId: projectId, ...unpublishData } = result.value;
+		if (outputSuccess({
+			argv,
+			command: COMMAND$6,
+			data: {
+				projectId,
+				...unpublishData
+			},
+			primaryId: projectId,
+			startTime
+		})) return;
+		printSuccess("App unpublished.");
+	}
+};
+
+//#endregion
+//#region src/commands/delete-project.ts
+const COMMAND$5 = "projects delete";
+const deleteProjectCommand = {
+	command: "delete <projectId>",
+	describe: "Delete a project permanently (gated behind the project-delete-enabled flag; returns 404 when disabled)",
+	builder: (yargs) => yargs.positional("projectId", {
+		type: "string",
+		demandOption: true,
+		describe: "The project ID"
+	}).option("yes", {
+		type: "boolean",
+		default: false,
+		describe: "Confirm deletion without prompting"
+	}).example("anything projects delete <project-id> --yes", "Delete a project permanently").example("anything projects delete <project-id> --yes --json", "Delete a project and capture the result in JSON"),
+	handler: async (argv) => {
+		if (!argv.yes && !isNonInteractive(argv)) {
+			outputError({
+				argv,
+				command: COMMAND$5,
+				error: {
+					message: "Project deletion is destructive and cannot be undone. Pass --yes to confirm.",
+					status: null
+				},
+				exitCode: 2
+			});
+			return;
+		}
+		if (argv["dry-run"]) {
+			outputDryRun({
+				argv,
+				command: COMMAND$5,
 				plannedActions: [{
-					action: "unpublish_project",
+					action: "delete_project",
 					projectGroupId: argv.projectId
 				}]
 			});
@@ -9830,7 +11032,7 @@ const unpublishCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$4,
+				command: COMMAND$5,
 				error: {
 					message: config.error.message,
 					status: null
@@ -9840,27 +11042,27 @@ const unpublishCommand = {
 			return;
 		}
 		const startTime = performance.now();
-		const result = await new AnythingApiClient(config.value).unpublish({ projectGroupId: argv.projectId });
+		const result = await new AnythingApiClient(config.value).deleteProject({ projectGroupId: argv.projectId });
 		if (result.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$4,
+				command: COMMAND$5,
 				error: result.error
 			});
 			return;
 		}
-		const { projectGroupId: projectId, ...unpublishData } = result.value;
+		const { projectGroupId: projectId } = result.value;
 		if (outputSuccess({
 			argv,
-			command: COMMAND$4,
+			command: COMMAND$5,
 			data: {
 				projectId,
-				...unpublishData
+				deleted: true
 			},
 			primaryId: projectId,
 			startTime
 		})) return;
-		printSuccess("App unpublished.");
+		printSuccess("Project deleted.");
 	}
 };
 
@@ -9918,6 +11120,10 @@ const projectsUnpublishCommand = {
 	...unpublishCommand,
 	command: "unpublish <projectId>"
 };
+const projectsDeleteCommand = {
+	...deleteProjectCommand,
+	command: "delete <projectId>"
+};
 const projectsSubmitCommand = {
 	...submitCommand,
 	command: "submit <projectId>"
@@ -9967,7 +11173,7 @@ const projectsUnsetCommand = {
 const projectsCommand = {
 	command: "projects",
 	describe: "Manage Anything projects",
-	builder: (yargs) => yargs.command(projectsListCommand).command(projectsCreateCommand).command(projectsDuplicateCommand).command(projectsGenerateCommand).command(projectsGetCommand).command(projectsRenameCommand).command(projectsMessagesCommand).command(projectsStatusCommand).command(projectsFilesCommand).command(projectAuthCommand).command(projectsLogsCommand).command(projectsSecretsCommand).command(projectsPublishCommand).command(projectsSubmitCommand).command(projectsUnpublishCommand).command(projectsSetCommand).command(projectsUnsetCommand).command(settingsCommand).example("anything projects create --org <org-id> --prompt todo-app", "Create a new app").example("anything projects generate <project-id> --prompt add-auth", "Iterate on an existing app").example("anything projects duplicate <project-id> --name \"My Copy\"", "Duplicate an app").example("anything projects publish <project-id> --slug my-app", "Publish an app").example("anything projects submit <project-id> --store app-store", "Start an App Store submission").example("anything projects unpublish <project-id> --yes", "Remove a published app from production").example("anything projects get <project-id> --json", "Inspect an app in JSON").example("anything projects rename <project-id> --name \"My App\"", "Rename a project").example("anything projects auth providers <project-id> --json", "Inspect auth provider settings in JSON").demandCommand(1, "Specify a projects subcommand. Run `anything projects --help` for usage."),
+	builder: (yargs) => yargs.command(projectsListCommand).command(projectsCreateCommand).command(projectsDuplicateCommand).command(projectsGenerateCommand).command(projectsGetCommand).command(projectsRenameCommand).command(projectsMessagesCommand).command(projectsStatusCommand).command(projectsFilesCommand).command(projectAuthCommand).command(projectsLogsCommand).command(projectsSecretsCommand).command(projectsPublishCommand).command(projectsSubmitCommand).command(projectsUnpublishCommand).command(projectsDeleteCommand).command(projectsSetCommand).command(projectsUnsetCommand).command(settingsCommand).example("anything projects create --org <org-id> --prompt todo-app", "Create a new app").example("anything projects generate <project-id> --prompt add-auth", "Iterate on an existing app").example("anything projects duplicate <project-id> --name \"My Copy\"", "Duplicate an app").example("anything projects publish <project-id> --slug my-app", "Publish an app").example("anything projects submit <project-id> --store app-store", "Start an App Store submission").example("anything projects unpublish <project-id> --yes", "Remove a published app from production").example("anything projects delete <project-id> --yes", "Delete a project permanently").example("anything projects get <project-id> --json", "Inspect an app in JSON").example("anything projects rename <project-id> --name \"My App\"", "Rename a project").example("anything projects auth providers <project-id> --json", "Inspect auth provider settings in JSON").demandCommand(1, "Specify a projects subcommand. Run `anything projects --help` for usage."),
 	handler: () => {}
 };
 
@@ -10088,7 +11294,7 @@ const pullCommand = {
 
 //#endregion
 //#region src/commands/ship.ts
-const COMMAND$3 = "ship";
+const COMMAND$4 = "ship";
 const shipCommand = {
 	command: "ship",
 	describe: "Create or update + generate + publish in one shot",
@@ -10125,7 +11331,7 @@ const shipCommand = {
 		if (!promptResult.ok) {
 			outputValidationError({
 				argv,
-				command: COMMAND$3,
+				command: COMMAND$4,
 				message: promptResult.error
 			});
 			return;
@@ -10137,7 +11343,7 @@ const shipCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$3,
+				command: COMMAND$4,
 				error: {
 					message: config.error.message,
 					status: null
@@ -10159,7 +11365,7 @@ const shipCommand = {
 			if (!orgResult.ok) {
 				outputError({
 					argv,
-					command: COMMAND$3,
+					command: COMMAND$4,
 					error: {
 						message: orgResult.error,
 						status: null
@@ -10182,7 +11388,7 @@ const shipCommand = {
 			if (createResult.isErr()) {
 				outputError({
 					argv,
-					command: COMMAND$3,
+					command: COMMAND$4,
 					error: createResult.error
 				});
 				return;
@@ -10210,7 +11416,7 @@ const shipCommand = {
 			if (genResult.isErr()) {
 				outputError({
 					argv,
-					command: COMMAND$3,
+					command: COMMAND$4,
 					error: genResult.error
 				});
 				return;
@@ -10237,7 +11443,7 @@ const shipCommand = {
 			if (argv.json || argv.quiet) process.exitCode = 1;
 			else outputError({
 				argv,
-				command: COMMAND$3,
+				command: COMMAND$4,
 				error: {
 					message: "Generation failed. Skipping publish.",
 					status: null
@@ -10274,7 +11480,7 @@ const shipCommand = {
 		if (publishResult.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$3,
+				command: COMMAND$4,
 				error: publishResult.error
 			});
 			return;
@@ -10289,7 +11495,7 @@ const shipCommand = {
 			if (deployResult.isErr()) {
 				outputError({
 					argv,
-					command: COMMAND$3,
+					command: COMMAND$4,
 					error: deployResult.error
 				});
 				return;
@@ -10301,7 +11507,7 @@ const shipCommand = {
 			if (deployError) {
 				outputError({
 					argv,
-					command: COMMAND$3,
+					command: COMMAND$4,
 					error: {
 						message: deployError.message,
 						status: null
@@ -10403,7 +11609,7 @@ const skillCommand = {
 
 //#endregion
 //#region src/commands/status-cmd.ts
-const COMMAND$2 = "status";
+const COMMAND$3 = "status";
 const statusCommand = {
 	command: "status",
 	describe: "Show current org, project, user, and auth state",
@@ -10418,7 +11624,7 @@ const statusCommand = {
 		if (configResult.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$2,
+				command: COMMAND$3,
 				error: {
 					message: configResult.error.message,
 					status: null
@@ -10443,7 +11649,7 @@ const statusCommand = {
 		}
 		if (outputSuccess({
 			argv,
-			command: COMMAND$2,
+			command: COMMAND$3,
 			data: {
 				authenticated: true,
 				credentialSource,
@@ -10479,7 +11685,7 @@ const statusCommand = {
 
 //#endregion
 //#region src/commands/switch.ts
-const COMMAND$1 = "switch";
+const COMMAND$2 = "switch";
 const switchCommand = {
 	command: "switch",
 	describe: "Interactive org/project picker",
@@ -10488,7 +11694,7 @@ const switchCommand = {
 		if (isNonInteractive(argv)) {
 			outputError({
 				argv,
-				command: COMMAND$1,
+				command: COMMAND$2,
 				error: {
 					message: "Switch requires interactive mode. Use `anything orgs set <id>` and `anything projects set <id>` instead.",
 					status: null
@@ -10504,7 +11710,7 @@ const switchCommand = {
 		if (config.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$1,
+				command: COMMAND$2,
 				error: {
 					message: config.error.message,
 					status: null
@@ -10518,7 +11724,7 @@ const switchCommand = {
 		if (me.isErr()) {
 			outputError({
 				argv,
-				command: COMMAND$1,
+				command: COMMAND$2,
 				error: me.error
 			});
 			return;
@@ -10527,7 +11733,7 @@ const switchCommand = {
 		if (orgs.length === 0) {
 			outputError({
 				argv,
-				command: COMMAND$1,
+				command: COMMAND$2,
 				error: {
 					message: "No organizations found.",
 					status: null
@@ -10569,7 +11775,7 @@ const switchCommand = {
 				setStoredProjectGroupId(projectChoice.id);
 				if (outputSuccess({
 					argv,
-					command: COMMAND$1,
+					command: COMMAND$2,
 					data: {
 						orgId: selectedOrg.id,
 						orgName: selectedOrg.name,
@@ -10585,7 +11791,7 @@ const switchCommand = {
 		}
 		if (outputSuccess({
 			argv,
-			command: COMMAND$1,
+			command: COMMAND$2,
 			data: {
 				orgId: selectedOrg.id,
 				orgName: selectedOrg.name
@@ -10596,6 +11802,284 @@ const switchCommand = {
 	}
 };
 
+//#endregion
+//#region src/update-check.ts
+const PACKAGE_NAME = "@anythingai/cli";
+const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+const CHECK_INTERVAL_MS = 1440 * 60 * 1e3;
+const NOTICE_FETCH_TIMEOUT_MS = 1500;
+const latestManifestSchema = z.object({ version: z.string() });
+function isNewerVersion(candidate, current) {
+	const core = (v) => (v.split("-")[0] ?? "").split(".").map((part) => Number.parseInt(part, 10));
+	const a = core(candidate);
+	const b = core(current);
+	if ([...a, ...b].some(Number.isNaN)) return false;
+	for (let i = 0; i < 3; i++) {
+		const left = a[i] ?? 0;
+		const right = b[i] ?? 0;
+		if (left !== right) return left > right;
+	}
+	return false;
+}
+async function fetchLatestVersion({ timeoutMs }) {
+	try {
+		const response = await fetch(REGISTRY_URL, {
+			signal: AbortSignal.timeout(timeoutMs),
+			headers: { accept: "application/json" }
+		});
+		if (!response.ok) return null;
+		const parsed = latestManifestSchema.safeParse(await response.json());
+		return parsed.success ? parsed.data.version : null;
+	} catch {
+		return null;
+	}
+}
+function printUpdateNotice({ current, latest }) {
+	console.error([
+		"",
+		styleText("yellow", `Update available for ${PACKAGE_NAME}: ${current} → ${latest}`),
+		styleText("dim", `Run \`npm install -g ${PACKAGE_NAME}@latest\` to update.`),
+		""
+	].join("\n"));
+}
+async function notifyIfUpdateAvailable(now) {
+	const state = getUpdateCheckState();
+	let latest = state.latestKnownVersion;
+	if (state.checkedAt === null || now - state.checkedAt >= CHECK_INTERVAL_MS) {
+		const fetched = await fetchLatestVersion({ timeoutMs: NOTICE_FETCH_TIMEOUT_MS });
+		recordUpdateCheck({
+			checkedAt: now,
+			latestVersion: fetched
+		});
+		if (fetched) latest = fetched;
+	}
+	if (!latest || !isNewerVersion(latest, CLI_VERSION)) return;
+	if (state.notifiedVersion === latest) return;
+	printUpdateNotice({
+		current: CLI_VERSION,
+		latest
+	});
+	recordUpdateNotified(latest);
+}
+async function maybeNotifyUpdate(argv, now) {
+	if (argv.json || argv.quiet) return;
+	if (isNonInteractive(argv)) return;
+	if (!process.stderr.isTTY) return;
+	await notifyIfUpdateAvailable(now);
+}
+
+//#endregion
+//#region src/commands/update.ts
+const COMMAND$1 = "update";
+const FETCH_TIMEOUT_MS = 8e3;
+function detectPackageManager(scriptPath) {
+	const path = scriptPath.replace(/\\/g, "/").toLowerCase();
+	if (path.includes("/pnpm/") || path.includes("/pnpm-global/")) return "pnpm";
+	if (path.includes("/.bun/")) return "bun";
+	if (path.includes("/yarn/") || path.includes("/.config/yarn/")) return "yarn";
+	return "npm";
+}
+function buildInstallCommand({ packageManager, target }) {
+	switch (packageManager) {
+		case "pnpm": return {
+			command: "pnpm",
+			args: [
+				"add",
+				"-g",
+				target
+			]
+		};
+		case "yarn": return {
+			command: "yarn",
+			args: [
+				"global",
+				"add",
+				target
+			]
+		};
+		case "bun": return {
+			command: "bun",
+			args: [
+				"add",
+				"-g",
+				target
+			]
+		};
+		case "npm": return {
+			command: "npm",
+			args: [
+				"install",
+				"-g",
+				target
+			]
+		};
+		default: {
+			const exhaustive = packageManager;
+			throw new Error(`Unhandled package manager: ${String(exhaustive)}`);
+		}
+	}
+}
+function resolveSelfPath() {
+	const entry = process.argv[1];
+	if (!entry) return "";
+	try {
+		return realpathSync(entry);
+	} catch {
+		return entry;
+	}
+}
+function runInstall({ command, args, capture }) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			stdio: capture ? [
+				"ignore",
+				"pipe",
+				"pipe"
+			] : "inherit",
+			shell: process.platform === "win32"
+		});
+		let output = "";
+		child.stdout?.on("data", (chunk) => {
+			output += String(chunk);
+		});
+		child.stderr?.on("data", (chunk) => {
+			output += String(chunk);
+		});
+		child.on("error", reject);
+		child.on("close", (code) => resolve({
+			code,
+			output: output.trim()
+		}));
+	});
+}
+const updateCommand = {
+	command: "update",
+	describe: "Update the CLI to the latest published version",
+	builder: (yargs) => yargs.option("check", {
+		type: "boolean",
+		default: false,
+		describe: "Report whether an update is available without installing it"
+	}).example("anything update", "Update to the latest version if one exists").example("anything update --check", "Check for a newer version without installing").example("anything update --dry-run", "Print the install command without running it"),
+	handler: async (argv) => {
+		const latest = await fetchLatestVersion({ timeoutMs: FETCH_TIMEOUT_MS });
+		if (latest === null) {
+			outputError({
+				argv,
+				command: COMMAND$1,
+				error: {
+					message: `Could not reach the npm registry to check for updates.`,
+					status: null
+				},
+				hint: `Update manually with \`npm install -g ${PACKAGE_NAME}@latest\`.`,
+				exitCode: EXIT_TIMEOUT
+			});
+			return;
+		}
+		const packageManager = detectPackageManager(resolveSelfPath());
+		const { command, args } = buildInstallCommand({
+			packageManager,
+			target: `${PACKAGE_NAME}@${latest}`
+		});
+		const installCommand = [command, ...args].join(" ");
+		if (!isNewerVersion(latest, CLI_VERSION)) {
+			if (outputSuccess({
+				argv,
+				command: COMMAND$1,
+				data: {
+					currentVersion: CLI_VERSION,
+					latestVersion: latest,
+					updateAvailable: false,
+					updated: false
+				},
+				primaryId: CLI_VERSION
+			})) return;
+			printSuccess(`Already on the latest version (${CLI_VERSION}).`);
+			return;
+		}
+		if (argv.check) {
+			if (outputSuccess({
+				argv,
+				command: COMMAND$1,
+				data: {
+					currentVersion: CLI_VERSION,
+					latestVersion: latest,
+					updateAvailable: true,
+					updated: false,
+					packageManager,
+					installCommand
+				},
+				primaryId: latest
+			})) return;
+			console.log();
+			printLabel("Current", CLI_VERSION);
+			printLabel("Latest", latest);
+			console.log();
+			console.log(`Run \`anything update\` or \`${installCommand}\` to update.`);
+			return;
+		}
+		if (argv["dry-run"]) {
+			outputDryRun({
+				argv,
+				command: COMMAND$1,
+				plannedActions: [{
+					action: "update",
+					from: CLI_VERSION,
+					to: latest,
+					packageManager,
+					command: installCommand
+				}]
+			});
+			return;
+		}
+		if (!argv.json && !argv.quiet) console.log(`Updating ${PACKAGE_NAME} ${CLI_VERSION} → ${latest} via ${packageManager}...`);
+		let result;
+		try {
+			result = await runInstall({
+				command,
+				args,
+				capture: argv.json || argv.quiet
+			});
+		} catch (error) {
+			outputError({
+				argv,
+				command: COMMAND$1,
+				error: {
+					message: `Failed to run \`${installCommand}\`: ${error instanceof Error ? error.message : String(error)}`,
+					status: null
+				},
+				hint: `Is ${packageManager} installed and on your PATH? You can update manually with \`${installCommand}\`.`
+			});
+			return;
+		}
+		if (result.code !== 0) {
+			const detail = result.output ? `\n${styleText("dim", result.output)}` : "";
+			outputError({
+				argv,
+				command: COMMAND$1,
+				error: {
+					message: `Update failed: \`${installCommand}\` exited with code ${result.code}.${detail}`,
+					status: null
+				},
+				hint: `Try running \`${installCommand}\` directly to see the full output.`
+			});
+			return;
+		}
+		if (outputSuccess({
+			argv,
+			command: COMMAND$1,
+			data: {
+				previousVersion: CLI_VERSION,
+				latestVersion: latest,
+				updated: true,
+				packageManager,
+				installCommand
+			},
+			primaryId: latest
+		})) return;
+		printSuccess(`Updated to ${latest}. Run \`anything --version\` to confirm.`);
+	}
+};
+
 //#endregion
 //#region src/commands/user.ts
 function formatCredits(creditBalance) {
@@ -10710,72 +12194,6 @@ const userCommand = {
 	}
 };
 
-//#endregion
-//#region src/update-check.ts
-const PACKAGE_NAME = "@anythingai/cli";
-const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
-const CHECK_INTERVAL_MS = 1440 * 60 * 1e3;
-const FETCH_TIMEOUT_MS = 1500;
-const latestManifestSchema = z.object({ version: z.string() });
-function isNewerVersion(candidate, current) {
-	const core = (v) => (v.split("-")[0] ?? "").split(".").map((part) => Number.parseInt(part, 10));
-	const a = core(candidate);
-	const b = core(current);
-	if ([...a, ...b].some(Number.isNaN)) return false;
-	for (let i = 0; i < 3; i++) {
-		const left = a[i] ?? 0;
-		const right = b[i] ?? 0;
-		if (left !== right) return left > right;
-	}
-	return false;
-}
-async function fetchLatestVersion() {
-	try {
-		const response = await fetch(REGISTRY_URL, {
-			signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
-			headers: { accept: "application/json" }
-		});
-		if (!response.ok) return null;
-		const parsed = latestManifestSchema.safeParse(await response.json());
-		return parsed.success ? parsed.data.version : null;
-	} catch {
-		return null;
-	}
-}
-function printUpdateNotice({ current, latest }) {
-	console.error([
-		"",
-		styleText("yellow", `Update available for ${PACKAGE_NAME}: ${current} → ${latest}`),
-		styleText("dim", `Run \`npm install -g ${PACKAGE_NAME}@latest\` to update.`),
-		""
-	].join("\n"));
-}
-async function notifyIfUpdateAvailable(now) {
-	const state = getUpdateCheckState();
-	let latest = state.latestKnownVersion;
-	if (state.checkedAt === null || now - state.checkedAt >= CHECK_INTERVAL_MS) {
-		const fetched = await fetchLatestVersion();
-		recordUpdateCheck({
-			checkedAt: now,
-			latestVersion: fetched
-		});
-		if (fetched) latest = fetched;
-	}
-	if (!latest || !isNewerVersion(latest, CLI_VERSION)) return;
-	if (state.notifiedVersion === latest) return;
-	printUpdateNotice({
-		current: CLI_VERSION,
-		latest
-	});
-	recordUpdateNotified(latest);
-}
-async function maybeNotifyUpdate(argv, now) {
-	if (argv.json || argv.quiet) return;
-	if (isNonInteractive(argv)) return;
-	if (!process.stderr.isTTY) return;
-	await notifyIfUpdateAvailable(now);
-}
-
 //#endregion
 //#region src/commands/watch.ts
 const IDLE_TIMEOUT_MS = 300 * 1e3;
@@ -10924,7 +12342,7 @@ const watchCommand = {
 //#endregion
 //#region src/cli.ts
 function createCli(argv) {
-	const cli = yargs(argv).scriptName("anything").usage("$0 <command> [options]").example("anything auth login", "Log in via browser").example("anything ship --prompt \"Build a todo app\"", "Create + publish in one shot").example("anything domains list org_123", "List domains for one organization").example("anything orgs", "List your organizations").example("anything orgs get <org-id>", "Inspect one organization").example("anything orgs set <org-id>", "Set the active organization").example("anything orgs members <org-id>", "Inspect collaborators and pending invites").example("anything projects create --prompt todo-app", "Create a new app").example("anything projects generate <project-id> --prompt add-auth", "Iterate on an existing app").example("anything projects publish <project-id> --slug my-app", "Publish an app").example("anything projects get <project-id> --json", "Inspect an app in JSON").example("anything projects rename <project-id> --name \"My App\"", "Rename a project").example("anything databases list --org <org-id>", "List databases for an organization").example("anything deployments list <project-id>", "List deployments for a project").example("anything members invite user@example.com --org org_123", "Invite a member").example("anything status", "Show current context").example("anything switch", "Interactive org/project picker").example("anything introspect", "Output command tree as JSON").option("json", {
+	const cli = yargs(argv).scriptName("anything").usage("$0 <command> [options]").example("anything auth login", "Log in via browser").example("anything ship --prompt \"Build a todo app\"", "Create + publish in one shot").example("anything domains list org_123", "List domains for one organization").example("anything orgs", "List your organizations").example("anything orgs get <org-id>", "Inspect one organization").example("anything orgs set <org-id>", "Set the active organization").example("anything orgs members <org-id>", "Inspect collaborators and pending invites").example("anything projects create --prompt todo-app", "Create a new app").example("anything projects generate <project-id> --prompt add-auth", "Iterate on an existing app").example("anything projects publish <project-id> --slug my-app", "Publish an app").example("anything projects get <project-id> --json", "Inspect an app in JSON").example("anything projects rename <project-id> --name \"My App\"", "Rename a project").example("anything databases list --org <org-id>", "List databases for an organization").example("anything deployments list <project-id>", "List deployments for a project").example("anything members invite user@example.com --org org_123", "Invite a member").example("anything update", "Update the CLI to the latest version").example("anything status", "Show current context").example("anything switch", "Interactive org/project picker").example("anything introspect", "Output command tree as JSON").option("json", {
 		type: "boolean",
 		default: false,
 		describe: "Output as JSON envelope: { ok, command, data }",
@@ -10944,11 +12362,6 @@ function createCli(argv) {
 		default: false,
 		describe: "Preview planned actions without executing (state-modifying commands)",
 		global: true
-	}).option("quiet", {
-		type: "boolean",
-		default: false,
-		describe: "Print only the primary identifier (ID or URL)",
-		global: true
 	}).option("dev", {
 		type: "boolean",
 		hidden: true,
@@ -10967,14 +12380,22 @@ function createCli(argv) {
 			"dry-run": args["dry-run"] === true,
 			dev: args.dev === true
 		}, Date.now());
-	}).command(assetsCommand).command(authCommand).command(databasesCommand).command(deploymentsCommand).command(domainsCommand).command(introspectCommand).command(linkCommand).command(llmContextCommand).command(membersCommand).command(orgsCommand).command(projectsCommand).command(pullCommand).command(shipCommand).command(skillCommand).command(statusCommand).command(switchCommand).command(unlinkCommand).command(userCommand).command(watchCommand).demandCommand(1, "Specify a command. Run --help for usage.").strict().wrap(null).version(CLI_VERSION).help().fail((msg, err, instance) => {
-		if (err) {
-			console.error(err.message || String(err));
-			process.exitCode = EXIT_ERROR;
-			return;
+	}).command(assetsCommand).command(authCommand).command(databasesCommand).command(deploymentsCommand).command(domainsCommand).command(introspectCommand).command(linkCommand).command(llmContextCommand).command(membersCommand).command(orgsCommand).command(projectsCommand).command(pullCommand).command(shipCommand).command(skillCommand).command(statusCommand).command(switchCommand).command(unlinkCommand).command(updateCommand).command(userCommand).command(watchCommand).demandCommand(1, "Specify a command. Run --help for usage.").strict().wrap(null).version(CLI_VERSION).help().fail((msg, err, instance) => {
+		const isJson = argv.includes("--json");
+		const message = err ? err.message || String(err) : msg;
+		if (err) console.error(message);
+		else {
+			if (!isJson) instance.showHelp("error");
+			console.error(`\n${message}`);
 		}
-		instance.showHelp("error");
-		console.error(`\n${msg}`);
+		if (isJson) console.error(JSON.stringify({
+			ok: false,
+			command: null,
+			error: {
+				code: "INVALID_ARGUMENTS",
+				message
+			}
+		}, null, 2));
 		process.exitCode = EXIT_INVALID_ARGS;
 	}).exitProcess(false);
 	if (isDevEnvironment()) cli.command(devCommand);