devflare 1.0.0-next.14 → 1.0.0-next.16

package/dist/account-0w8wdzjv.js

@@ -0,0 +1,475 @@
+import {
+  getConfiguredAccountId
+} from "./index-zfhq6s96.js";
+import {
+  account
+} from "./index-e9yw4d6y.js";
+import"./index-72mve6vh.js";
+import"./index-epw1jxz5.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-7g8zyws4.js";
+import"./index-43dq8yx8.js";
+import {
+  getGlobalDefaultAccountId,
+  getWorkspaceAccountId,
+  setGlobalDefaultAccountId,
+  setWorkspaceAccountId
+} from "./index-xk9djfjp.js";
+import {
+  AuthenticationError,
+  CloudflareAPIError
+} from "./index-0w826dsr.js";
+import"./index-6jef5emv.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
+};