devflare 1.0.0-next.21 → 1.0.0-next.23

package/LLM.md

@@ -13,7 +13,7 @@ It is meant to read like a proper markdown handbook rather than a second source
 - Links use the same `/docs/...` routes as the documentation site.
 
 ## Documentation map
-This export covers 146 pages across 5 top-level groups.
+This export covers 147 pages across 5 top-level groups.
 
 ### Quickstart
 See why Devflare exists, build the smallest safe first worker, and move into routes, bindings, previews, and tests when the app needs them.
@@ -40,6 +40,7 @@ Keep the day-to-day Devflare surfaces easy to scan: runtime model, HTTP split, a
   - [Worker surfaces](/docs/worker-surfaces) — Devflare can compose or wrap several Worker surfaces into one generated entrypoint, but the authored source of truth should stay in explicit files such as `src/fetch.ts`, `src/queue.ts`, `src/scheduled.ts`, and `src/email.ts`.
   - [Generated types](/docs/generated-types) — `devflare types` turns config, discovered Durable Objects, named entrypoints, and cross-worker references into one generated TypeScript contract instead of a pile of hand-maintained env guesswork.
   - [Environments](/docs/config-environments) — Keep one base config, layer environment-specific overrides with `config.env`, and let Devflare resolve preview or production details only in the commands that actually need them.
+  - [Typed env vars](/docs/typed-env-vars) — Use `env.NAME` descriptors inside `defineConfig({ vars })`, parse or default them in config, and read the resulting typed values at runtime with `import { vars } from "devflare"`.
   - [Previews](/docs/config-previews) — Use `preview.scope()` for bindings that should belong to one preview scope. Devflare materializes names like `notes-db-next`, provisions or reuses the preview-only resources it can manage, and lets you clean them up by the same scope later without touching production resources.
   - [Runtime & deploy settings](/docs/runtime-deploy-settings) — Use config for account context, compatibility posture, assets, deployment routes, WebSocket proxy rules, migrations, observability, limits, and preview cron behavior instead of rediscovering those settings in scripts later.
 
@@ -2207,7 +2208,7 @@ That is what this page is for. The example below touches the major current top-l
 Hover any property in the config to see what that lane means. The example is intentionally broad, but the dedicated pages still own the deeper caveats and richer nested variants.
 
 ```ts
-import { defineConfig } from 'devflare/config'
+import { defineConfig, env } from 'devflare/config'
 
 export default defineConfig({
 	name: 'docs-platform',
@@ -2294,7 +2295,12 @@ export default defineConfig({
 		crons: ['0 */6 * * *']
 	},
 	vars: {
-		APP_ENV: 'development'
+		APP_ENV: 'development',
+		mongo: {
+			uri: env.MONGOURI,
+			database: env.MONGODATABASE
+		},
+		retries: env.RETRIES.parse(Number)
 	},
 	secrets: {
 		API_TOKEN: {
@@ -2904,8 +2910,8 @@ The replace-arrays rule is the one most likely to surprise someone arriving from
 
 ##### Key points
 
-- Use `.env` for inputs that exist while `devflare.config.*` is being evaluated. Devflare prefers a workspace-root `.env` when it finds a workspace ancestor, otherwise it falls back to the nearest ancestor `.env`.
-- Use `vars` for string values that should compile into generated Worker-facing output.
+- Use `.env` and `.env.dev` for config-time inputs. Devflare reads those files itself from the config directory upward, with closer files winning and `.env` overriding `.env.dev` in the same directory.
+- Use `vars` for values that should compile into Worker-facing output, including nested typed values produced by `env.NAME` descriptors.
 - Use `secrets` to declare runtime secret binding names, not to store those secret values in config. Today that is mostly schema and type metadata: the schema accepts `{ required: false }`, but generated env typing still treats declared secrets as present and Devflare does not currently turn that flag into a separate deploy-time guarantee.
 - Use `.env.example` to document config-time inputs for the team instead of leaving those values to memory or chat scrollback.
 
@@ -2915,6 +2921,139 @@ The replace-arrays rule is the one most likely to surprise someone arriving from
 
 ---
 
+### Resolve `.env` values through typed config vars instead of scattering process env reads
+
+> Use `env.NAME` descriptors inside `defineConfig({ vars })`, parse or default them in config, and read the resulting typed values at runtime with `import { vars } from "devflare"`.
+
+| Field | Value |
+| --- | --- |
+| Route | [`/docs/typed-env-vars`](/docs/typed-env-vars) |
+| Group | Devflare |
+| Navigation title | Typed env vars |
+| Eyebrow | Configuration |
+
+Devflare vars can now be a typed bridge from local `.env` files into Worker runtime code. The config owns which variables are required, optional, parsed, or dev-only, while application code reads the resolved shape through the `vars` runtime helper.
+
+#### At a glance
+
+| Fact | Value |
+| --- | --- |
+| Config import | `import { defineConfig, env } from 'devflare/config'` |
+| Runtime import | `import { vars } from 'devflare'` |
+| File order | Parents first, then closer directories; `.env.dev` first, `.env` last |
+| Missing build vars | Build fails with a nested missing-variable report |
+
+#### Declare the runtime shape in config
+
+The `env` export from `devflare/config` does not read the variable immediately. It creates a descriptor that Devflare resolves when it starts dev, builds artifacts, or prints a phase-resolved config.
+
+That keeps config import cheap and lets Devflare report every missing variable at once, using the nested path from `vars` instead of a generic process-env crash.
+
+##### Example — Nested vars with required, optional, parsed, defaulted, and dev-only values
+
+```ts
+import { defineConfig, env } from 'devflare/config'
+
+export default defineConfig({
+	name: 'voices-api',
+	vars: {
+		secret: env.SECRET,
+		mongo: {
+			uri: env.MONGOURI,
+			database: env.MONGODATABASE
+		},
+		retries: env.RETRIES.parse(Number),
+		optionalLabel: env.OPTIONAL_LABEL.optional(),
+		mode: env.APP_MODE.default('local'),
+		mockTenantId: env.MOCK_TENANT_ID.dev(123)
+	}
+})
+```
+
+#### Read resolved values through the runtime `vars` helper
+
+At runtime, Devflare exposes the resolved values on the Worker environment and through the `vars` helper. The helper is typed from `devflare types`, so parser return values and nested objects stay visible to TypeScript.
+
+Unparsed environment descriptors resolve to strings. Parsed descriptors use the parser return type, defaults contribute their value type, and optional descriptors become optional properties.
+
+##### Example — Runtime code can use the nested shape directly
+
+###### File — src/fetch.ts
+
+```ts
+import { vars } from 'devflare'
+
+export default {
+	async fetch() {
+		return Response.json({
+			database: vars.mongo.database,
+			retries: vars.retries
+		})
+	}
+}
+```
+
+#### Let Devflare parse `.env` files itself
+
+Devflare reads `.env.dev` and `.env` from the config directory and every parent directory. Parent files load first, then closer files override them. Within one directory, `.env.dev` loads first and `.env` wins last.
+
+The parser does not expand `$OTHER_VARIABLE` references. Values such as passwords, MongoDB connection strings, and shell-looking fragments are read as written instead of being interpreted by Bun.
+
+> **Note — Process env still wins over files**
+>
+> CI-provided environment variables and explicit shell exports override `.env` file values. Dotenv files fill in missing process variables; they do not stomp values the process already had.
+
+##### Example — The later `.env` value overrides the earlier `.env.dev` value
+
+###### File — .env
+
+```dotenv
+# .env.dev
+SECRET=local-secret
+MONGOURI=mongodb://127.0.0.1:27017
+MONGODATABASE=voices_dev
+RETRIES=1
+
+# .env
+MONGODATABASE=voices
+```
+
+#### Missing required values fail build and pause dev
+
+Required is the default because a config variable usually means the Worker cannot run honestly without that value. Build and config-inspection commands fail with a grouped report that points at the nested `vars` path and the missing environment variable name.
+
+Dev mode is gentler. It prints the same report, waits for `.env` or `.env.dev` to change, and then retries startup. That makes the local loop fixable without restarting the command.
+
+##### Example — Missing variables are grouped by the config path that required them
+
+###### File — missing-env-vars.txt
+
+```text
+These environment variables are missing:
+
+	secret: SECRET
+	mongo:
+		uri: MONGOURI
+```
+
+#### Use helpers to make intent explicit
+
+##### Reference table
+
+| Helper | Meaning | Example |
+| --- | --- | --- |
+| `env.NAME` | Required string value. | `env.SECRET` |
+| `.optional()` | Missing value is allowed and omitted. | `env.OPTIONAL_LABEL.optional()` |
+| `.parse(fn)` / `.parser(fn)` | Transform the string from env files into a typed runtime value. | `env.RETRIES.parse(Number)` |
+| `.default(value)` | Use a fallback in every mode when the env value is missing. | `env.APP_MODE.default('local')` |
+| `.dev(value)` | Use a fallback only in dev when the env value is missing. | `env.MOCK_TENANT_ID.dev(123)` |
+
+> **Warning — Dev-only defaults are still required in build**
+>
+> `.dev(value)` is intentionally local-only. If the same variable may be missing in build too, use `.default(value)` or `.optional()` instead.
+
+---
+
 ### Author preview-scoped bindings so preview deploys can own disposable infrastructure
 
 > Use `preview.scope()` for bindings that should belong to one preview scope. Devflare materializes names like `notes-db-next`, provisions or reuses the preview-only resources it can manage, and lets you clean them up by the same scope later without touching production resources.

package/dist/account-j8nfggg4.js

@@ -0,0 +1,475 @@
+import {
+  getConfiguredAccountId
+} from "./index-s0fmwxbk.js";
+import {
+  account
+} from "./index-0m6e4mxz.js";
+import"./index-k7m5f1dg.js";
+import"./index-3jme4hgw.js";
+import {
+  bold,
+  createCliTheme,
+  dim,
+  formatCommand,
+  formatLabelValue,
+  green,
+  logLine,
+  logTable,
+  whiteDim,
+  yellow
+} from "./index-stgn34cr.js";
+import {
+  CYAN,
+  CYAN_BOLD,
+  DIM,
+  RESET
+} from "./index-3t6rypgc.js";
+import"./index-15fpa5tx.js";
+import"./index-0bv2qjs1.js";
+import {
+  getGlobalDefaultAccountId,
+  getWorkspaceAccountId,
+  setGlobalDefaultAccountId,
+  setWorkspaceAccountId
+} from "./index-1d4jg11n.js";
+import {
+  AuthenticationError,
+  CloudflareAPIError
+} from "./index-mg8vwqxf.js";
+import"./index-c8p4njqy.js";
+import"./index-37x76zdn.js";
+
+// src/cli/commands/account.ts
+var ACCOUNT_SUBCOMMANDS = [
+  "info",
+  "workers",
+  "kv",
+  "d1",
+  "r2",
+  "vectorize",
+  "limits",
+  "usage",
+  "global",
+  "workspace"
+];
+function isAccountSubcommand(value) {
+  return ACCOUNT_SUBCOMMANDS.includes(value);
+}
+var 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 === undefined)
+    return "N/A";
+  return `${value.toFixed(1)}%`;
+}
+function logSection(logger, title, theme, count, accent = "cyan") {
+  logLine(logger);
+  const heading = accent === "yellow" ? yellow(title, theme) : accent === "green" ? green(title, theme) : bold(title, theme);
+  logLine(logger, `${heading}${count === undefined ? "" : ` ${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);
+  const isAuth = await account.isAuthenticated();
+  if (!isAuth) {
+    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);
+      case "info":
+      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) => {
+    const isCurrent = acc.id === currentGlobal;
+    return {
+      label: isCurrent ? `${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 pkgPath2 = setWorkspaceAccountId(accounts[0].id);
+    logger.success(`Workspace account set to: ${accounts[0].name}`);
+    logLine(logger, `${dim("saved to", theme)} ${pkgPath2}`);
+    return { exitCode: 0 };
+  }
+  const currentWorkspace = getWorkspaceAccountId();
+  const options = accounts.map((acc) => {
+    const isCurrent = acc.id === currentWorkspace;
+    return {
+      label: isCurrent ? `${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, undefined, "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) {
+  const action = parsed.args[1];
+  switch (action) {
+    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, undefined, "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 = parseInt(limitValue, 10);
+  if (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 };
+}
+export {
+  runAccountCommand
+};