devflare 1.0.0-next.7 → 1.0.0-next.71

package/bin/devflare.js

@@ -1,14 +1,30 @@
-#!/usr/bin/env bun
-import { runCli } from '../dist/index.js'
-
-// Pass CLI arguments (skip node and script path)
-const args = process.argv.slice(2)
-
-runCli(args)
-	.then(result => {
-		process.exit(result.exitCode)
-	})
-	.catch(error => {
-		console.error('CLI error:', error)
-		process.exit(1)
-	})
+#!/usr/bin/env node
+import { existsSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const currentDir = dirname(fileURLToPath(import.meta.url))
+const sourceCliEntryPath = resolve(currentDir, '../src/cli/index.ts')
+const distCliEntryPath = resolve(currentDir, '../dist/cli/index.js')
+// Only the bun runtime can execute the TypeScript source directly (it tolerates
+// `.ts` + extensionless relative imports); under node — the default shebang and
+// what published consumers use — always run the built dist. In the monorepo
+// this means `devflare <cmd>` under node needs a prior build, which the
+// build/CI pipeline guarantees. A published install has no `src/`, so it falls
+// through to dist under any runtime.
+const runningBun = Boolean(process.versions.bun)
+const cliEntryPath =
+	runningBun && existsSync(sourceCliEntryPath) ? sourceCliEntryPath : distCliEntryPath
+
+const { runCli } = await import(pathToFileURL(cliEntryPath).href)
+
+const args = process.argv.slice(2)
+
+runCli(args)
+	.then((result) => {
+		process.exit(result.exitCode)
+	})
+	.catch((error) => {
+		console.error('CLI error:', error)
+		process.exit(1)
+	})

package/dist/_chunks/account-B9ULT9HA.js

@@ -0,0 +1,462 @@
+import { n as CloudflareAPIError, t as AuthenticationError } from "./api-BKClUlUf.js";
+import { a as setGlobalDefaultAccountId, i as getWorkspaceAccountId, o as setWorkspaceAccountId, r as getGlobalDefaultAccountId } from "./preferences-CbYERA_m.js";
+import { t as account } from "./cloudflare-D_5UWT84.js";
+import { a as DIM, c as RESET, i as CYAN_BOLD, r as CYAN } from "./colors-D0NVzAFN.js";
+import { c as formatCommand, d as green, f as logLine, g as yellow, h as whiteDim, l as formatLabelValue, n as bold, o as dim, p as logTable, r as createCliTheme } from "./ui-BhCdDC2N.js";
+import { n as getConfiguredAccountId } from "./command-utils-qlsHELwW.js";
+//#region src/cli/commands/account.ts
+const ACCOUNT_SUBCOMMANDS = [
+	"info",
+	"workers",
+	"kv",
+	"d1",
+	"r2",
+	"vectorize",
+	"limits",
+	"usage",
+	"global",
+	"workspace"
+];
+function isAccountSubcommand(value) {
+	return ACCOUNT_SUBCOMMANDS.includes(value);
+}
+const CLI_API_OPTIONS = { timeout: 1e4 };
+function formatDate(date) {
+	if (!date) return "N/A";
+	return date.toLocaleDateString("en-US", {
+		year: "numeric",
+		month: "short",
+		day: "numeric"
+	});
+}
+function formatPercent(value) {
+	if (value === void 0) return "N/A";
+	return `${value.toFixed(1)}%`;
+}
+function logSection(logger, title, theme, count, accent = "cyan") {
+	logLine(logger);
+	logLine(logger, `${accent === "yellow" ? yellow(title, theme) : accent === "green" ? green(title, theme) : bold(title, theme)}${count === void 0 ? "" : ` ${dim(`(${count})`, theme)}`}`);
+}
+function logEmptyState(logger, message, theme) {
+	logLine(logger);
+	logLine(logger, dim(message, theme));
+	logLine(logger);
+	return { exitCode: 0 };
+}
+async function runAccountCommand(parsed, logger, options) {
+	const theme = createCliTheme(parsed.options);
+	if (!await account.isAuthenticated()) {
+		logger.error("Not authenticated with Cloudflare");
+		logLine(logger, dim("Run: devflare login", theme));
+		return { exitCode: 1 };
+	}
+	const subcommand = parsed.args[0];
+	const rawSubcommand = parsed.args[0];
+	if (rawSubcommand && !isAccountSubcommand(rawSubcommand)) {
+		logger.error(`Unknown account subcommand: ${rawSubcommand}`);
+		logLine(logger, dim(`Available account subcommands: ${ACCOUNT_SUBCOMMANDS.join(", ")}`, theme));
+		return { exitCode: 1 };
+	}
+	if (subcommand === "global") return await selectGlobalAccount(logger, theme);
+	if (subcommand === "workspace") return await selectWorkspaceAccount(logger, theme);
+	try {
+		let accountId = parsed.options.account;
+		if (!accountId) accountId = await getConfiguredAccountId(options.cwd ?? process.cwd());
+		if (!accountId) {
+			const primary = await account.getPrimaryAccount();
+			if (!primary) {
+				logger.error("No Cloudflare accounts found");
+				return { exitCode: 1 };
+			}
+			accountId = primary.id;
+		}
+		switch (subcommand) {
+			case "workers": return await showWorkers(accountId, logger, theme);
+			case "kv": return await showKV(accountId, logger, theme);
+			case "d1": return await showD1(accountId, logger, theme);
+			case "r2": return await showR2(accountId, logger, theme);
+			case "vectorize": return await showVectorize(accountId, logger, theme);
+			case "limits": return await handleLimits(accountId, parsed, logger, theme);
+			case "usage": return await showUsage(accountId, logger, theme);
+			default: return await showAccountOverview(accountId, logger, theme);
+		}
+	} catch (error) {
+		if (error instanceof AuthenticationError) {
+			logger.error(error.message);
+			return { exitCode: 1 };
+		}
+		if (error instanceof CloudflareAPIError) {
+			logger.error(`API Error: ${error.message}`);
+			return { exitCode: 1 };
+		}
+		if (error instanceof Error) {
+			if (error.name === "AbortError" || error.message.includes("timed out")) {
+				logger.error("Request timed out. The Cloudflare API is slow or unavailable.");
+				return { exitCode: 1 };
+			}
+			logger.error(`Error: ${error.message}`);
+			return { exitCode: 1 };
+		}
+		throw error;
+	}
+}
+async function showAccountOverview(accountId, logger, theme) {
+	logSection(logger, "Accounts", theme);
+	let accounts = [];
+	let limitedAccountView = false;
+	try {
+		accounts = await account.getAccounts();
+	} catch {
+		const fallbackAccount = await account.getAccountById(accountId);
+		if (!fallbackAccount) {
+			logger.error("Could not inspect Cloudflare accounts with the current credentials");
+			return { exitCode: 1 };
+		}
+		accounts = [fallbackAccount];
+		limitedAccountView = true;
+	}
+	if (accounts.length === 0) {
+		logger.error("No Cloudflare accounts found");
+		return { exitCode: 1 };
+	}
+	const workspaceId = getWorkspaceAccountId();
+	const globalId = await getGlobalDefaultAccountId(accountId);
+	if (limitedAccountView) logLine(logger, dim("Using the configured account directly because the current credentials cannot enumerate all Cloudflare accounts.", theme));
+	for (let i = 0; i < accounts.length; i++) {
+		const acc = accounts[i];
+		const isWorkspace = acc.id === workspaceId;
+		const isGlobal = acc.id === globalId;
+		let badge = "";
+		if (isWorkspace) badge = ` ${CYAN_BOLD}(workspace)${RESET}`;
+		else if (isGlobal) badge = workspaceId ? ` ${DIM}(global)${RESET}` : ` ${CYAN}(global)${RESET}`;
+		if (i > 0) logLine(logger);
+		logLine(logger, `${dim("account", theme)} ${green(acc.name, theme)}${badge}`);
+		logLine(logger, formatLabelValue("id", whiteDim(acc.id, theme), theme, 10));
+		logLine(logger, formatLabelValue("type", acc.type, theme, 10));
+	}
+	logSection(logger, "Commands", theme);
+	logLine(logger, formatCommand("devflare account global", "Set global default account", theme));
+	logLine(logger, formatCommand("devflare account workspace", "Set workspace account", theme));
+	logLine(logger, formatCommand("devflare account workers", "List Workers", theme));
+	logLine(logger, formatCommand("devflare account kv", "List KV namespaces", theme));
+	logLine(logger, formatCommand("devflare account d1", "List D1 databases", theme));
+	logLine(logger, formatCommand("devflare account r2", "List R2 buckets", theme));
+	logLine(logger, formatCommand("devflare account vectorize", "List Vectorize indexes", theme));
+	logLine(logger, formatCommand("devflare account limits", "View or set usage limits", theme));
+	logLine(logger, formatCommand("devflare account usage", "View detailed usage", theme));
+	logLine(logger, formatCommand("devflare ai", "View AI models and pricing", theme));
+	logLine(logger);
+	return { exitCode: 0 };
+}
+async function selectGlobalAccount(logger, theme) {
+	const accounts = await account.getAccounts();
+	if (accounts.length === 0) {
+		logger.error("No Cloudflare accounts found");
+		return { exitCode: 1 };
+	}
+	if (accounts.length === 1) {
+		await setGlobalDefaultAccountId(accounts[0].id);
+		logger.success(`Global default set to: ${accounts[0].name}`);
+		return { exitCode: 0 };
+	}
+	const currentGlobal = await getGlobalDefaultAccountId(accounts[0].id);
+	const options = accounts.map((acc) => {
+		return {
+			label: acc.id === currentGlobal ? `${acc.name} ${CYAN}(default)${RESET}` : acc.name,
+			value: acc.id,
+			hint: acc.id.substring(0, 8) + "..."
+		};
+	});
+	const selected = await logger.prompt("Select global default account:", {
+		type: "select",
+		options,
+		initial: currentGlobal ?? accounts[0].id
+	});
+	if (!selected || typeof selected === "symbol") {
+		logLine(logger, dim("Cancelled", theme));
+		return { exitCode: 0 };
+	}
+	await setGlobalDefaultAccountId(selected, accounts[0].id);
+	const selectedAccount = accounts.find((a) => a.id === selected);
+	logger.success(`Global default set to: ${selectedAccount?.name}`);
+	logLine(logger, `${dim("saved to", theme)} ~/.devflare/preferences.json + cloud KV`);
+	return { exitCode: 0 };
+}
+async function selectWorkspaceAccount(logger, theme) {
+	const accounts = await account.getAccounts();
+	if (accounts.length === 0) {
+		logger.error("No Cloudflare accounts found");
+		return { exitCode: 1 };
+	}
+	if (accounts.length === 1) {
+		const pkgPath = setWorkspaceAccountId(accounts[0].id);
+		logger.success(`Workspace account set to: ${accounts[0].name}`);
+		logLine(logger, `${dim("saved to", theme)} ${pkgPath}`);
+		return { exitCode: 0 };
+	}
+	const currentWorkspace = getWorkspaceAccountId();
+	const options = accounts.map((acc) => {
+		return {
+			label: acc.id === currentWorkspace ? `${acc.name} ${CYAN}(workspace)${RESET}` : acc.name,
+			value: acc.id,
+			hint: acc.id.substring(0, 8) + "..."
+		};
+	});
+	const selected = await logger.prompt("Select workspace account:", {
+		type: "select",
+		options,
+		initial: currentWorkspace ?? accounts[0].id
+	});
+	if (!selected || typeof selected === "symbol") {
+		logLine(logger, dim("Cancelled", theme));
+		return { exitCode: 0 };
+	}
+	const pkgPath = setWorkspaceAccountId(selected);
+	const selectedAccount = accounts.find((a) => a.id === selected);
+	logger.success(`Workspace account set to: ${selectedAccount?.name}`);
+	logLine(logger, `${dim("saved to", theme)} ${pkgPath}`);
+	return { exitCode: 0 };
+}
+async function showWorkers(accountId, logger, theme) {
+	const workers = await account.workers(accountId, CLI_API_OPTIONS);
+	if (workers.length === 0) return logEmptyState(logger, "No Workers found", theme);
+	logSection(logger, "Workers", theme, workers.length, "green");
+	logTable(logger, {
+		title: "Worker list",
+		rows: workers,
+		columns: [{
+			label: "Name",
+			width: 30,
+			value: (worker) => worker.name
+		}, {
+			label: "Modified",
+			width: 20,
+			value: (worker) => whiteDim(formatDate(worker.modifiedOn), theme)
+		}],
+		theme,
+		titleAccent: "green"
+	});
+	logLine(logger);
+	return { exitCode: 0 };
+}
+async function showKV(accountId, logger, theme) {
+	const namespaces = await account.kv(accountId, CLI_API_OPTIONS);
+	if (namespaces.length === 0) return logEmptyState(logger, "No KV namespaces found", theme);
+	logSection(logger, "KV namespaces", theme, namespaces.length);
+	logTable(logger, {
+		title: "Namespace list",
+		rows: namespaces,
+		columns: [{
+			label: "Name",
+			width: 35,
+			value: (ns) => ns.name
+		}, {
+			label: "ID",
+			width: 35,
+			value: (ns) => whiteDim(ns.id, theme)
+		}],
+		theme,
+		titleAccent: "cyan"
+	});
+	logLine(logger);
+	return { exitCode: 0 };
+}
+async function showD1(accountId, logger, theme) {
+	const databases = await account.d1(accountId, CLI_API_OPTIONS);
+	if (databases.length === 0) return logEmptyState(logger, "No D1 databases found", theme);
+	logSection(logger, "D1 databases", theme, databases.length, "yellow");
+	logTable(logger, {
+		title: "Database list",
+		rows: databases,
+		columns: [
+			{
+				label: "Name",
+				width: 25,
+				value: (db) => db.name
+			},
+			{
+				label: "ID",
+				width: 40,
+				value: (db) => whiteDim(db.id, theme)
+			},
+			{
+				label: "Tables",
+				width: 8,
+				value: (db) => String(db.tableCount ?? "N/A")
+			}
+		],
+		theme,
+		titleAccent: "yellow"
+	});
+	logLine(logger);
+	return { exitCode: 0 };
+}
+async function showR2(accountId, logger, theme) {
+	const buckets = await account.r2(accountId, CLI_API_OPTIONS);
+	if (buckets.length === 0) return logEmptyState(logger, "No R2 buckets found", theme);
+	logSection(logger, "R2 buckets", theme, buckets.length, "green");
+	logTable(logger, {
+		title: "Bucket list",
+		rows: buckets,
+		columns: [
+			{
+				label: "Name",
+				width: 30,
+				value: (bucket) => bucket.name
+			},
+			{
+				label: "Created",
+				width: 20,
+				value: (bucket) => whiteDim(formatDate(bucket.createdOn), theme)
+			},
+			{
+				label: "Location",
+				width: 10,
+				value: (bucket) => bucket.location ?? "auto"
+			}
+		],
+		theme,
+		titleAccent: "green"
+	});
+	logLine(logger);
+	return { exitCode: 0 };
+}
+async function showVectorize(accountId, logger, theme) {
+	const indexes = await account.vectorize(accountId, CLI_API_OPTIONS);
+	if (indexes.length === 0) return logEmptyState(logger, "No Vectorize indexes found", theme);
+	logSection(logger, "Vectorize indexes", theme, indexes.length, "yellow");
+	logTable(logger, {
+		title: "Index list",
+		rows: indexes,
+		columns: [
+			{
+				label: "Name",
+				width: 25,
+				value: (idx) => idx.name
+			},
+			{
+				label: "Dimensions",
+				width: 12,
+				value: (idx) => String(idx.dimensions)
+			},
+			{
+				label: "Metric",
+				width: 15,
+				value: (idx) => idx.metric
+			}
+		],
+		theme,
+		titleAccent: "yellow"
+	});
+	logLine(logger);
+	return { exitCode: 0 };
+}
+async function showUsage(accountId, logger, theme) {
+	const usages = await account.getAllUsageSummaries(accountId);
+	const limits = await account.getLimits(accountId);
+	logSection(logger, "Usage", theme, void 0, "yellow");
+	logLine(logger, formatLabelValue("limits", limits.enabled ? green("enabled", theme) : dim("disabled", theme), theme, 12));
+	if (usages.length === 0) return logEmptyState(logger, "No usage tracked yet", theme);
+	logTable(logger, {
+		title: "Usage by service",
+		rows: usages,
+		columns: [
+			{
+				label: "Service",
+				width: 15,
+				value: (usage) => usage.service
+			},
+			{
+				label: "Today",
+				width: 10,
+				value: (usage) => String(usage.today)
+			},
+			{
+				label: "Limit",
+				width: 10,
+				value: (usage) => usage.limit?.toString() ?? "∞"
+			},
+			{
+				label: "%",
+				width: 10,
+				value: (usage) => formatPercent(usage.percentUsed)
+			},
+			{
+				label: "Status",
+				width: 10,
+				value: (usage) => usage.withinLimit ? green("ok", theme) : yellow("limit", theme)
+			}
+		],
+		theme,
+		titleAccent: "yellow"
+	});
+	logLine(logger);
+	return { exitCode: 0 };
+}
+async function handleLimits(accountId, parsed, logger, theme) {
+	switch (parsed.args[1]) {
+		case "set": return await setLimit(accountId, parsed, logger, theme);
+		case "enable":
+			await account.setLimitsEnabled(accountId, true);
+			logger.success("Usage limits enabled");
+			return { exitCode: 0 };
+		case "disable":
+			await account.setLimitsEnabled(accountId, false);
+			logger.success("Usage limits disabled");
+			return { exitCode: 0 };
+		default: return await showLimits(accountId, logger, theme);
+	}
+}
+async function showLimits(accountId, logger, theme) {
+	const limits = await account.getLimits(accountId);
+	logSection(logger, "Usage limits", theme, void 0, "yellow");
+	logLine(logger, formatLabelValue("status", limits.enabled ? green("enabled", theme) : dim("disabled", theme), theme, 16));
+	logLine(logger);
+	logLine(logger, dim("current limits", theme));
+	logLine(logger, formatLabelValue("AI Requests/Day", String(limits.aiRequestsPerDay ?? "Unlimited"), theme, 18));
+	logLine(logger, formatLabelValue("AI Tokens/Day", String(limits.aiTokensPerDay ?? "Unlimited"), theme, 18));
+	logLine(logger, formatLabelValue("Vectorize Ops/Day", String(limits.vectorizeOpsPerDay ?? "Unlimited"), theme, 18));
+	logSection(logger, "Commands", theme);
+	logLine(logger, formatCommand("devflare account limits set ai-requests 50", "Set the AI request daily limit", theme));
+	logLine(logger, formatCommand("devflare account limits set ai-tokens 5000", "Set the AI token daily limit", theme));
+	logLine(logger, formatCommand("devflare account limits set vectorize-ops 500", "Set the Vectorize daily limit", theme));
+	logLine(logger, formatCommand("devflare account limits enable", "Enable usage limits", theme));
+	logLine(logger, formatCommand("devflare account limits disable", "Disable usage limits", theme));
+	logLine(logger);
+	return { exitCode: 0 };
+}
+async function setLimit(accountId, parsed, logger, theme) {
+	const limitName = parsed.args[2];
+	const limitValue = parsed.args[3];
+	if (!limitName || !limitValue) {
+		logger.error("Usage: devflare account limits set <limit-name> <value>");
+		logLine(logger, dim("Limit names: ai-requests, ai-tokens, vectorize-ops", theme));
+		return { exitCode: 1 };
+	}
+	const value = Number.parseInt(limitValue, 10);
+	if (Number.isNaN(value) || value < 0) {
+		logger.error("Limit value must be a positive number");
+		return { exitCode: 1 };
+	}
+	switch (limitName) {
+		case "ai-requests":
+			await account.setLimits(accountId, { aiRequestsPerDay: value });
+			logger.success(`AI requests limit set to ${value}/day`);
+			break;
+		case "ai-tokens":
+			await account.setLimits(accountId, { aiTokensPerDay: value });
+			logger.success(`AI tokens limit set to ${value}/day`);
+			break;
+		case "vectorize-ops":
+			await account.setLimits(accountId, { vectorizeOpsPerDay: value });
+			logger.success(`Vectorize ops limit set to ${value}/day`);
+			break;
+		default:
+			logger.error(`Unknown limit: ${limitName}`);
+			logLine(logger, dim("Valid limits: ai-requests, ai-tokens, vectorize-ops", theme));
+			return { exitCode: 1 };
+	}
+	return { exitCode: 0 };
+}
+//#endregion
+export { runAccountCommand };

package/dist/_chunks/account-resources-BdKj8q1h.js

@@ -0,0 +1,159 @@
+import { a as apiGetAll, n as CloudflareAPIError, r as apiDelete, s as apiPost } from "./api-BKClUlUf.js";
+//#region src/cloudflare/account-resources.ts
+async function listKVNamespaces(accountId, options) {
+	return (await apiGetAll(`/accounts/${accountId}/storage/kv/namespaces`, options)).map((namespace) => ({
+		id: namespace.id,
+		name: namespace.title
+	}));
+}
+async function createKVNamespace(accountId, title, options) {
+	const namespace = await apiPost(`/accounts/${accountId}/storage/kv/namespaces`, { title }, options);
+	return {
+		id: namespace.id,
+		name: namespace.title
+	};
+}
+async function deleteKVNamespace(accountId, namespaceId, options) {
+	await apiDelete(`/accounts/${accountId}/storage/kv/namespaces/${encodeURIComponent(namespaceId)}`, options);
+}
+async function listD1Databases(accountId, options) {
+	return (await apiGetAll(`/accounts/${accountId}/d1/database`, options)).map((database) => ({
+		id: database.uuid,
+		name: database.name,
+		version: database.version,
+		tableCount: database.num_tables,
+		sizeBytes: database.file_size
+	}));
+}
+async function createD1Database(accountId, name, options) {
+	const created = await apiPost(`/accounts/${accountId}/d1/database`, {
+		name,
+		...options?.jurisdiction ? { jurisdiction: options.jurisdiction } : {},
+		...options?.primaryLocationHint ? { primary_location_hint: options.primaryLocationHint } : {}
+	}, options);
+	return {
+		id: created.uuid,
+		name: created.name,
+		version: created.version,
+		tableCount: created.num_tables,
+		sizeBytes: created.file_size
+	};
+}
+async function deleteD1Database(accountId, databaseId, options) {
+	await apiDelete(`/accounts/${accountId}/d1/database/${encodeURIComponent(databaseId)}`, options);
+}
+async function queryD1Database(accountId, databaseId, query, options) {
+	const { apiPost } = await import("./api-BKClUlUf.js").then((n) => n.l);
+	return apiPost(`/accounts/${accountId}/d1/database/${databaseId}/query`, query, options);
+}
+async function rawD1DatabaseQuery(accountId, databaseId, query, options) {
+	const { apiPost } = await import("./api-BKClUlUf.js").then((n) => n.l);
+	return apiPost(`/accounts/${accountId}/d1/database/${databaseId}/raw`, query, options);
+}
+async function listQueues(accountId, options) {
+	return (await apiGetAll(`/accounts/${accountId}/queues`, options)).filter((queue) => {
+		return typeof queue.queue_id === "string" && queue.queue_id.length > 0 && typeof queue.queue_name === "string" && queue.queue_name.length > 0;
+	}).map((queue) => ({
+		id: queue.queue_id,
+		name: queue.queue_name,
+		createdOn: queue.created_on ? new Date(queue.created_on) : void 0,
+		modifiedOn: queue.modified_on ? new Date(queue.modified_on) : void 0,
+		deliveryDelay: queue.settings?.delivery_delay,
+		deliveryPaused: queue.settings?.delivery_paused,
+		messageRetentionPeriod: queue.settings?.message_retention_period
+	}));
+}
+async function createQueue(accountId, queueName, options) {
+	const queue = await apiPost(`/accounts/${accountId}/queues`, { queue_name: queueName }, options);
+	return {
+		id: queue.queue_id ?? "",
+		name: queue.queue_name ?? queueName,
+		createdOn: queue.created_on ? new Date(queue.created_on) : void 0,
+		modifiedOn: queue.modified_on ? new Date(queue.modified_on) : void 0,
+		deliveryDelay: queue.settings?.delivery_delay,
+		deliveryPaused: queue.settings?.delivery_paused,
+		messageRetentionPeriod: queue.settings?.message_retention_period
+	};
+}
+async function deleteQueue(accountId, queueId, options) {
+	await apiDelete(`/accounts/${accountId}/queues/${encodeURIComponent(queueId)}`, options);
+}
+async function listR2Buckets(accountId, options) {
+	return (await apiGetAll(`/accounts/${accountId}/r2/buckets`, options)).map((bucket) => ({
+		name: bucket.name,
+		createdOn: new Date(bucket.creation_date),
+		location: bucket.location
+	}));
+}
+async function createR2Bucket(accountId, name, options) {
+	const bucket = await apiPost(`/accounts/${accountId}/r2/buckets`, {
+		name,
+		...options?.locationHint ? { locationHint: options.locationHint } : {},
+		...options?.storageClass ? { storageClass: options.storageClass } : {}
+	}, options);
+	return {
+		name: bucket.name,
+		createdOn: bucket.creation_date ? new Date(bucket.creation_date) : /* @__PURE__ */ new Date(),
+		location: bucket.location
+	};
+}
+async function deleteR2Bucket(accountId, bucketName, options) {
+	await apiDelete(`/accounts/${accountId}/r2/buckets/${encodeURIComponent(bucketName)}`, options);
+}
+async function listHyperdrives(accountId, options) {
+	return (await apiGetAll(`/accounts/${accountId}/hyperdrive/configs`, options)).map((hyperdrive) => ({
+		id: hyperdrive.id,
+		name: hyperdrive.name,
+		createdOn: hyperdrive.created_on ? new Date(hyperdrive.created_on) : void 0,
+		modifiedOn: hyperdrive.modified_on ? new Date(hyperdrive.modified_on) : void 0
+	}));
+}
+async function deleteHyperdrive(accountId, hyperdriveId, options) {
+	await apiDelete(`/accounts/${accountId}/hyperdrive/configs/${encodeURIComponent(hyperdriveId)}`, options);
+}
+async function listVectorizeIndexes(accountId, options) {
+	try {
+		return (await apiGetAll(`/accounts/${accountId}/vectorize/v2/indexes`, options)).map((index) => ({
+			name: index.name,
+			dimensions: index.config.dimensions,
+			metric: index.config.metric,
+			description: index.description
+		}));
+	} catch (error) {
+		if (error instanceof CloudflareAPIError && error.code === 404) return [];
+		throw error;
+	}
+}
+async function createVectorizeIndex(accountId, index, options) {
+	const created = await apiPost(`/accounts/${accountId}/vectorize/v2/indexes`, {
+		name: index.name,
+		config: {
+			dimensions: index.dimensions,
+			metric: index.metric
+		},
+		...index.description ? { description: index.description } : {}
+	}, options);
+	return {
+		name: created.name,
+		dimensions: created.config.dimensions,
+		metric: created.config.metric,
+		description: created.description
+	};
+}
+async function deleteVectorizeIndex(accountId, indexName, options) {
+	await apiDelete(`/accounts/${accountId}/vectorize/v2/indexes/${encodeURIComponent(indexName)}`, options);
+}
+async function listAIModels(accountId, options) {
+	try {
+		return (await apiGetAll(`/accounts/${accountId}/ai/models/search`, options)).map((model) => ({
+			id: model.id,
+			name: model.name,
+			task: model.task?.name,
+			description: model.description
+		}));
+	} catch {
+		return [];
+	}
+}
+//#endregion
+export { listR2Buckets as _, createVectorizeIndex as a, rawD1DatabaseQuery as b, deleteKVNamespace as c, deleteVectorizeIndex as d, listAIModels as f, listQueues as g, listKVNamespaces as h, createR2Bucket as i, deleteQueue as l, listHyperdrives as m, createKVNamespace as n, deleteD1Database as o, listD1Databases as p, createQueue as r, deleteHyperdrive as s, createD1Database as t, deleteR2Bucket as u, listVectorizeIndexes as v, queryD1Database as y };