devflare 1.0.0-next.16 → 1.0.0-next.18

package/dist/{index-na3mnm1k.js → index-1546yrn0.js}

@@ -1,12 +1,12 @@
 import {
   loadConfig,
   resolveConfigPath
-} from "./index-0apbm26n.js";
+} from "./index-bc5pvbbd.js";
 import {
   getEffectiveAccountId,
   getPrimaryAccount,
   getWorkspaceAccountId
-} from "./index-jb75kwa4.js";
+} from "./index-gba371j7.js";
 
 // src/cli/command-utils.ts
 function asOptionalString(value) {

package/dist/index-15fpa5tx.js

@@ -0,0 +1,232 @@
+import {
+  DEVFLARE_KV_NAMESPACE_TITLE,
+  getEffectiveAccountId,
+  getOrCreateNamedKVNamespace,
+  getPrimaryAccount
+} from "./index-1d4jg11n.js";
+import {
+  isAuthenticated,
+  kvGet,
+  kvPut
+} from "./index-mg8vwqxf.js";
+
+// src/cloudflare/usage.ts
+var USAGE_KEY_PREFIX = "usage:";
+var LIMITS_KEY = "limits";
+var DEFAULT_LIMITS = {
+  aiTokensPerDay: 1e4,
+  aiRequestsPerDay: 100,
+  vectorizeOpsPerDay: 1000,
+  enabled: true
+};
+async function getOrCreateUsageNamespace(accountId) {
+  return getOrCreateNamedKVNamespace(accountId, DEVFLARE_KV_NAMESPACE_TITLE);
+}
+function getTodayDate() {
+  return new Date().toISOString().split("T")[0];
+}
+function buildUsageKey(service, date) {
+  return `${USAGE_KEY_PREFIX}${service}:${date}`;
+}
+async function getUsage(accountId, service, date) {
+  const targetDate = date ?? getTodayDate();
+  const namespaceId = await getOrCreateUsageNamespace(accountId);
+  const key = buildUsageKey(service, targetDate);
+  const value = await kvGet(accountId, namespaceId, key);
+  if (value === null) {
+    return null;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+var MAX_RECORD_USAGE_ATTEMPTS = 5;
+async function recordUsage(accountId, service, count = 1, deps = {}) {
+  const kvGetFn = deps.kvGet ?? kvGet;
+  const kvPutFn = deps.kvPut ?? kvPut;
+  const getNamespaceId = deps.getNamespaceId ?? getOrCreateUsageNamespace;
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const now = deps.now ?? (() => new Date);
+  const maxAttempts = deps.maxAttempts ?? MAX_RECORD_USAGE_ATTEMPTS;
+  const warn = deps.warn ?? ((message) => console.warn(message));
+  const today = now().toISOString().split("T")[0];
+  const namespaceId = await getNamespaceId(accountId);
+  const key = buildUsageKey(service, today);
+  let lastWritten = null;
+  let lastObserved = null;
+  for (let attempt = 0;attempt < maxAttempts; attempt++) {
+    const existingRaw = await kvGetFn(accountId, namespaceId, key);
+    let existing = null;
+    if (existingRaw !== null) {
+      try {
+        existing = JSON.parse(existingRaw);
+      } catch {
+        existing = null;
+      }
+    }
+    lastObserved = existing;
+    const record = {
+      service,
+      date: today,
+      count: (existing?.count ?? 0) + count,
+      updatedAt: now().toISOString()
+    };
+    await kvPutFn(accountId, namespaceId, key, JSON.stringify(record));
+    lastWritten = record;
+    const verifyRaw = await kvGetFn(accountId, namespaceId, key);
+    if (verifyRaw !== null) {
+      try {
+        const verify = JSON.parse(verifyRaw);
+        if (verify.updatedAt === record.updatedAt && verify.count === record.count) {
+          return record;
+        }
+      } catch {}
+    }
+    if (attempt < maxAttempts - 1) {
+      const backoffMs = Math.min(25 * 2 ** attempt, 400);
+      await sleep(backoffMs);
+    }
+  }
+  warn(`[devflare] recordUsage: could not confirm usage write for ${service} after ${maxAttempts} attempts ` + "due to concurrent writes; usage counts are best-effort under concurrency.");
+  return lastWritten ?? {
+    service,
+    date: today,
+    count: (lastObserved?.count ?? 0) + count,
+    updatedAt: now().toISOString()
+  };
+}
+async function resetUsage(accountId, service) {
+  const today = getTodayDate();
+  const namespaceId = await getOrCreateUsageNamespace(accountId);
+  const key = buildUsageKey(service, today);
+  const record = {
+    service,
+    date: today,
+    count: 0,
+    updatedAt: new Date().toISOString()
+  };
+  await kvPut(accountId, namespaceId, key, JSON.stringify(record));
+}
+async function getLimits(accountId) {
+  const namespaceId = await getOrCreateUsageNamespace(accountId);
+  const value = await kvGet(accountId, namespaceId, LIMITS_KEY);
+  if (value === null) {
+    return DEFAULT_LIMITS;
+  }
+  try {
+    return { ...DEFAULT_LIMITS, ...JSON.parse(value) };
+  } catch {
+    return DEFAULT_LIMITS;
+  }
+}
+async function setLimits(accountId, limits) {
+  const namespaceId = await getOrCreateUsageNamespace(accountId);
+  const current = await getLimits(accountId);
+  const updated = {
+    ...current,
+    ...limits
+  };
+  await kvPut(accountId, namespaceId, LIMITS_KEY, JSON.stringify(updated));
+  return updated;
+}
+async function setLimitsEnabled(accountId, enabled) {
+  return setLimits(accountId, { enabled });
+}
+async function isWithinLimits(accountId, service) {
+  const limits = await getLimits(accountId);
+  if (!limits.enabled) {
+    return true;
+  }
+  const usage = await getUsage(accountId, service);
+  const currentCount = usage?.count ?? 0;
+  switch (service) {
+    case "ai":
+      if (limits.aiRequestsPerDay && currentCount >= limits.aiRequestsPerDay) {
+        return false;
+      }
+      return true;
+    case "vectorize":
+      if (limits.vectorizeOpsPerDay && currentCount >= limits.vectorizeOpsPerDay) {
+        return false;
+      }
+      return true;
+    default:
+      return true;
+  }
+}
+async function getUsageSummary(accountId, service) {
+  const limits = await getLimits(accountId);
+  const usage = await getUsage(accountId, service);
+  const currentCount = usage?.count ?? 0;
+  let limit;
+  switch (service) {
+    case "ai":
+      limit = limits.aiRequestsPerDay;
+      break;
+    case "vectorize":
+      limit = limits.vectorizeOpsPerDay;
+      break;
+  }
+  const withinLimit = limit === undefined || currentCount < limit;
+  const percentUsed = limit ? currentCount / limit * 100 : undefined;
+  return {
+    service,
+    today: currentCount,
+    limit,
+    withinLimit,
+    percentUsed
+  };
+}
+async function getAllUsageSummaries(accountId) {
+  const trackedServices = ["ai", "vectorize"];
+  return Promise.all(trackedServices.map((s) => getUsageSummary(accountId, s)));
+}
+async function canProceedWithTest(accountId, service) {
+  const limits = await getLimits(accountId);
+  if (!limits.enabled) {
+    return { allowed: true };
+  }
+  const withinLimits = await isWithinLimits(accountId, service);
+  if (!withinLimits) {
+    const summary = await getUsageSummary(accountId, service);
+    return {
+      allowed: false,
+      reason: `Daily limit exceeded for ${service}: ${summary.today}/${summary.limit} (${summary.percentUsed?.toFixed(1)}%)`
+    };
+  }
+  return { allowed: true };
+}
+async function recordTestUsage(accountId, service, count = 1) {
+  await recordUsage(accountId, service, count);
+}
+async function shouldSkip(service) {
+  try {
+    const isAuth = await isAuthenticated();
+    if (!isAuth) {
+      console.log(`⏭️  ${service.toUpperCase()} tests skipped: Not authenticated. Run: bunx wrangler login`);
+      return true;
+    }
+    const primary = await getPrimaryAccount();
+    if (!primary) {
+      console.log(`⏭️  ${service.toUpperCase()} tests skipped: No Cloudflare account found`);
+      return true;
+    }
+    const { accountId } = await getEffectiveAccountId(primary.id);
+    try {
+      const { allowed, reason } = await canProceedWithTest(accountId, service);
+      if (!allowed) {
+        console.log(`⏭️  ${service.toUpperCase()} tests skipped: ${reason}`);
+        return true;
+      }
+    } catch {}
+    return false;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.log(`⏭️  ${service.toUpperCase()} tests skipped: ${message}`);
+    return true;
+  }
+}
+
+export { getUsage, recordUsage, resetUsage, getLimits, setLimits, setLimitsEnabled, isWithinLimits, getUsageSummary, getAllUsageSummaries, canProceedWithTest, recordTestUsage, shouldSkip };

package/dist/{index-jb75kwa4.js → index-18mp5v50.js}

@@ -4,9 +4,10 @@ import {
   apiGetAll,
   apiPatch,
   apiPost,
+  kvDelete,
   kvGet,
   kvPut
-} from "./index-0w826dsr.js";
+} from "./index-a3e13a7m.js";
 import {
   __require
 } from "./index-37x76zdn.js";
@@ -166,11 +167,11 @@ async function deleteD1Database(accountId, databaseId, options) {
   await apiDelete(`/accounts/${accountId}/d1/database/${encodedDatabaseId}`, options);
 }
 async function queryD1Database(accountId, databaseId, query, options) {
-  const { apiPost: apiPost2 } = await import("./api-d6ekexs5.js");
+  const { apiPost: apiPost2 } = await import("./api-swcgnp72.js");
   return apiPost2(`/accounts/${accountId}/d1/database/${databaseId}/query`, query, options);
 }
 async function rawD1DatabaseQuery(accountId, databaseId, query, options) {
-  const { apiPost: apiPost2 } = await import("./api-d6ekexs5.js");
+  const { apiPost: apiPost2 } = await import("./api-swcgnp72.js");
   return apiPost2(`/accounts/${accountId}/d1/database/${databaseId}/raw`, query, options);
 }
 async function listQueues(accountId, options) {
@@ -369,17 +370,17 @@ async function getAccountSummary(accountId) {
 // src/cloudflare/preferences.ts
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync, unlinkSync } from "node:fs";
 
 // src/cloudflare/kv-namespace.ts
 var DEVFLARE_KV_NAMESPACE_TITLE = "devflare-usage";
-async function getOrCreateNamedKVNamespace(accountId, title = DEVFLARE_KV_NAMESPACE_TITLE) {
-  const namespaces = await apiGet(`/accounts/${accountId}/storage/kv/namespaces`);
+async function getOrCreateNamedKVNamespace(accountId, title = DEVFLARE_KV_NAMESPACE_TITLE, options) {
+  const namespaces = await apiGetAll(`/accounts/${accountId}/storage/kv/namespaces`, options);
   const existing = namespaces.find((namespace) => namespace.title === title);
   if (existing) {
     return existing.id;
   }
-  const created = await apiPost(`/accounts/${accountId}/storage/kv/namespaces`, { title });
+  const created = await apiPost(`/accounts/${accountId}/storage/kv/namespaces`, { title }, options);
   return created.id;
 }
 
@@ -387,6 +388,18 @@ async function getOrCreateNamedKVNamespace(accountId, title = DEVFLARE_KV_NAMESP
 var GLOBAL_ACCOUNT_KEY = "settings:defaultAccountId";
 var LOCAL_CACHE_DIR = ".devflare";
 var LOCAL_CACHE_FILE = "preferences.json";
+function writeFileAtomic(path, contents) {
+  const tmpPath = path + ".tmp-" + process.pid + "-" + Date.now();
+  writeFileSync(tmpPath, contents, "utf-8");
+  try {
+    renameSync(tmpPath, path);
+  } catch (error) {
+    try {
+      unlinkSync(tmpPath);
+    } catch {}
+    throw error;
+  }
+}
 function getLocalPreferencesPath() {
   return join(homedir(), LOCAL_CACHE_DIR, LOCAL_CACHE_FILE);
 }
@@ -408,7 +421,7 @@ function writeLocalPreferences(prefs) {
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
   }
-  writeFileSync(path, JSON.stringify(prefs, null, "\t"), "utf-8");
+  writeFileAtomic(path, JSON.stringify(prefs, null, "\t"));
 }
 function findPackageJsonPath(startDir) {
   let dir = startDir ?? process.cwd();
@@ -430,8 +443,8 @@ function readPackageJson(path) {
   }
 }
 function writePackageJson(path, pkg) {
-  writeFileSync(path, JSON.stringify(pkg, null, "\t") + `
-`, "utf-8");
+  writeFileAtomic(path, JSON.stringify(pkg, null, "\t") + `
+`);
 }
 function getWorkspaceAccountId() {
   const pkgPath = findPackageJsonPath();
@@ -478,7 +491,9 @@ async function getGlobalDefaultAccountId(fallbackAccountId) {
       });
       return value;
     }
-  } catch {}
+  } catch (error) {
+    console.debug("[devflare preferences] cloud KV sync failed:", error instanceof Error ? error.message : String(error));
+  }
   return null;
 }
 async function setGlobalDefaultAccountId(accountId, anyAccountId) {
@@ -492,7 +507,9 @@ async function setGlobalDefaultAccountId(accountId, anyAccountId) {
   try {
     const namespaceId = await getOrCreatePreferencesNamespace(kvAccountId);
     await kvPut(kvAccountId, namespaceId, GLOBAL_ACCOUNT_KEY, accountId);
-  } catch {}
+  } catch (error) {
+    console.debug("[devflare preferences] cloud KV sync failed:", error instanceof Error ? error.message : String(error));
+  }
 }
 async function getEffectiveAccountId(primaryAccountId) {
   const workspaceId = getWorkspaceAccountId();
@@ -512,8 +529,10 @@ async function clearGlobalDefaultAccountId(anyAccountId) {
   writeLocalPreferences(local);
   try {
     const namespaceId = await getOrCreatePreferencesNamespace(anyAccountId);
-    await kvPut(anyAccountId, namespaceId, GLOBAL_ACCOUNT_KEY, "");
-  } catch {}
+    await kvDelete(anyAccountId, namespaceId, GLOBAL_ACCOUNT_KEY);
+  } catch (error) {
+    console.debug("[devflare preferences] cloud KV sync failed:", error instanceof Error ? error.message : String(error));
+  }
 }
 
 export { getAccounts, getPrimaryAccount, getAccountById, listWorkers, renameWorker, deleteWorker, listWorkerVersions, getWorkerVersionDetail, listWorkerDeployments, getWorkersSubdomain, listKVNamespaces, createKVNamespace, deleteKVNamespace, listD1Databases, createD1Database, deleteD1Database, queryD1Database, rawD1DatabaseQuery, listQueues, createQueue, deleteQueue, listR2Buckets, createR2Bucket, deleteR2Bucket, listHyperdrives, deleteHyperdrive, listVectorizeIndexes, createVectorizeIndex, deleteVectorizeIndex, listAIModels, getServiceStatus, getAllServiceStatus, hasService, getAccountSummary, DEVFLARE_KV_NAMESPACE_TITLE, getOrCreateNamedKVNamespace, getWorkspaceAccountId, setWorkspaceAccountId, getGlobalDefaultAccountId, setGlobalDefaultAccountId, getEffectiveAccountId, clearGlobalDefaultAccountId };

package/dist/{index-4v9bc2pc.js → index-195tc6qh.js}

@@ -441,8 +441,8 @@ var CORE_HELP_PAGES = [
       "devflare build [--config <path>] [--env <name>] [--debug]"
     ],
     description: [
-      "Resolves your Devflare config, applies environment overrides, and generates the Wrangler-facing artifacts used by deploy flows.",
-      "This is the safest way to inspect what Devflare will hand to Wrangler before you actually deploy."
+      "Resolves your Devflare config locally, applies environment overrides, and generates the build artifacts used by deploy flows.",
+      "Build preserves named bindings instead of provisioning Cloudflare resources, so it is the safest way to inspect what Devflare will hand to deploy before you actually ship."
     ],
     options: [
       entry("--config <path>", "Use a specific devflare config file"),
@@ -455,24 +455,26 @@ var CORE_HELP_PAGES = [
     ],
     notes: [
       "Build currently writes `.devflare/wrangler.jsonc`, `.devflare/build/wrangler.jsonc`, and `.wrangler/deploy/config.json`.",
-      "`devflare deploy` runs the same artifact preparation step automatically before invoking Wrangler."
+      "Build does not query or provision Cloudflare account resources on its own; name-based bindings stay as names in the generated artifacts until deploy time.",
+      "`devflare deploy` runs the same artifact preparation step automatically before invoking Wrangler, unless you provide `--build <path>` to reuse an existing build artifact."
     ]
   },
   {
     path: ["deploy"],
     summary: "Deploy explicitly to Cloudflare production or preview targets",
     usage: [
-      "devflare deploy --prod [--config <path>] [--message <text>] [--tag <text>] [--debug]",
-      "devflare deploy --production [--config <path>] [--message <text>] [--tag <text>] [--debug]",
-      "devflare deploy --preview <name> [--config <path>] [--message <text>] [--tag <text>]",
-      "devflare deploy --preview [--config <path>] [--branch-name <branch>] [--message <text>] [--tag <text>]",
+      "devflare deploy --prod [--config <path>] [--build <path>] [--message <text>] [--tag <text>] [--debug]",
+      "devflare deploy --production [--config <path>] [--build <path>] [--message <text>] [--tag <text>] [--debug]",
+      "devflare deploy --preview <name> [--config <path>] [--build <path>] [--message <text>] [--tag <text>]",
+      "devflare deploy --preview [--config <path>] [--build <path>] [--branch-name <branch>] [--message <text>] [--tag <text>]",
       "devflare deploy --prod --dry-run [--config <path>]",
       "devflare deploy --preview <name> --dry-run [--config <path>]",
       "devflare deploy --preview --dry-run [--config <path>]"
     ],
     description: [
       "Deploy requires an explicit target: production via `--prod` / `--production`, or preview via `--preview`.",
-      "Named preview deploys such as `--preview next` or `--preview pr-1` target `config.env.preview`, provision preview-scoped resources automatically, and deploy dedicated preview-scope Workers when your config is wired for them. Bare `--preview` keeps the same-worker preview upload flow and can still use `--branch-name` or CI/git metadata for preview-aware naming."
+      "Named preview deploys such as `--preview next` or `--preview pr-1` target `config.env.preview`, provision preview-scoped resources automatically, and deploy dedicated preview-scope Workers when your config is wired for them. Bare `--preview` keeps the same-worker preview upload flow and can still use `--branch-name` or CI/git metadata for preview-aware naming.",
+      "Production and named preview deploys also provision missing deploy-time resources such as KV namespaces, D1 databases, R2 buckets, and Queues when Devflare has enough information to create them."
     ],
     options: [
       entry("--prod", "Deploy to the production environment explicitly"),
@@ -480,6 +482,7 @@ var CORE_HELP_PAGES = [
       entry("--preview", "Deploy a same-worker preview upload"),
       entry("--preview <name>", "Deploy a named preview scope such as `next` or `pr-1`"),
       entry("--config <path>", "Use a specific devflare config file"),
+      entry("--build <path>", "Reuse an existing build artifact such as `.devflare/build` or `.wrangler/deploy/config.json` instead of rebuilding"),
       entry("--env <name>", "Usually unnecessary because the explicit target already pins production vs preview. If you pass it, it must match that target"),
       entry("--dry-run", "Print the synthesized Wrangler config and skip the actual deployment"),
       entry("--branch-name <branch>", "Provide explicit branch metadata for preview-aware naming when your workflow needs it"),
@@ -489,6 +492,7 @@ var CORE_HELP_PAGES = [
     ],
     examples: [
       entry("devflare deploy --prod", "Deploy explicitly to production"),
+      entry("devflare deploy --prod --build .devflare/build", "Deploy a previously built artifact without rebuilding the package"),
       entry('devflare deploy --production --message "Release"', "Deploy to production with an explicit deployment message"),
       entry("devflare deploy --preview next", "Deploy the named `next` preview scope and provision preview-scoped resources automatically"),
       entry("devflare deploy --preview pr-1", "Deploy the named `pr-1` preview scope directly"),
@@ -499,6 +503,7 @@ var CORE_HELP_PAGES = [
       "`devflare deploy` without an explicit target is rejected from the CLI so production and preview destinations stay unmistakable.",
       "`--prod` / `--production` clear preview-scope environment overrides such as `DEVFLARE_PREVIEW_BRANCH` so production deploys stay pointed at stable Worker names.",
       "Named preview deploys automatically provision preview-scoped resources before building and deploying.",
+      "When a build artifact still contains name-based bindings, deploy resolves or provisions the concrete Cloudflare resources and rewrites the generated Wrangler config with the IDs Wrangler requires.",
       "Plain `--preview` still uses Cloudflare preview uploads, so it cannot be the first-ever upload for a brand-new Worker, preview URLs remain limited for Workers that implement Durable Objects, and preview uploads do not apply Durable Object migrations."
     ]
   },
@@ -1301,58 +1306,58 @@ async function runCli(argv, options = {}) {
   }
 }
 async function runInit(parsed, logger, options) {
-  const { runInitCommand } = await import("./init-r4hnxan3.js");
+  const { runInitCommand } = await import("./init-wfh63bfz.js");
   return runInitCommand(parsed, logger, options);
 }
 async function runDev(parsed, logger, options) {
-  const { runDevCommand } = await import("./dev-7ef5e2j1.js");
+  const { runDevCommand } = await import("./dev-s4tpkg60.js");
   return runDevCommand(parsed, logger, options);
 }
 async function runBuild(parsed, logger, options) {
-  const { runBuildCommand } = await import("./build-p3r3117t.js");
+  const { runBuildCommand } = await import("./build-ngfy4v5x.js");
   return runBuildCommand(parsed, logger, options);
 }
 async function runDeploy(parsed, logger, options) {
-  const { runDeployCommand } = await import("./deploy-csfhdr64.js");
+  const { runDeployCommand } = await import("./deploy-bqf3kxy5.js");
   return runDeployCommand(parsed, logger, {
     ...options,
     requireExplicitDeployTarget: true
   });
 }
 async function runTypes(parsed, logger, options) {
-  const { runTypesCommand } = await import("./types-p0gckpn6.js");
+  const { runTypesCommand } = await import("./types-tkgch3xv.js");
   return runTypesCommand(parsed, logger, options);
 }
 async function runDoctor(parsed, logger, options) {
-  const { runDoctorCommand } = await import("./doctor-fmjj65mc.js");
+  const { runDoctorCommand } = await import("./doctor-e1h9mhzp.js");
   return runDoctorCommand(parsed, logger, options);
 }
 async function runConfig(parsed, logger, options) {
-  const { runConfigCommand } = await import("./config-hwdqjse7.js");
+  const { runConfigCommand } = await import("./config-7rbp7aek.js");
   return runConfigCommand(parsed, logger, options);
 }
 async function runAccount(parsed, logger, options) {
-  const { runAccountCommand } = await import("./account-fw8nafav.js");
+  const { runAccountCommand } = await import("./account-p0crq2gh.js");
   return runAccountCommand(parsed, logger, options);
 }
 async function runLogin(parsed, logger, options) {
-  const { runLoginCommand } = await import("./login-5bsxxpvc.js");
+  const { runLoginCommand } = await import("./login-dp0napaz.js");
   return runLoginCommand(parsed, logger, options);
 }
 async function runPreviews(parsed, logger, options) {
-  const { runPreviewsCommand } = await import("./previews-d487qde5.js");
+  const { runPreviewsCommand } = await import("./previews-844bp6kf.js");
   return runPreviewsCommand(parsed, logger, options);
 }
 async function runProductions(parsed, logger, options) {
-  const { runProductionsCommand } = await import("./productions-x9p0pym1.js");
+  const { runProductionsCommand } = await import("./productions-6dr0bmd7.js");
   return runProductionsCommand(parsed, logger, options);
 }
 async function runWorker(parsed, logger, options) {
-  const { runWorkerCommand } = await import("./worker-y9ha6g44.js");
+  const { runWorkerCommand } = await import("./worker-mjzfstv5.js");
   return runWorkerCommand(parsed, logger, options);
 }
 async function runToken(parsed, logger, options) {
-  const { runTokenCommand } = await import("./token-kedhcret.js");
+  const { runTokenCommand } = await import("./token-jkmm44z2.js");
   return runTokenCommand(parsed, logger, options);
 }
 async function runAI() {

package/dist/{index-0kfzdywd.js → index-1bg8w2gf.js}

@@ -3,7 +3,7 @@ import {
 } from "./index-rbht7m9r.js";
 import {
   resolveConfigPath
-} from "./index-yzddwp02.js";
+} from "./index-ngbzr9gz.js";
 
 // src/cli/config-path.ts
 import { stat } from "node:fs/promises";