devflare 1.0.0-next.3 → 1.0.0-next.31

package/dist/{doctor-fmgb3d28.js → doctor-ztwx1y95.js}

@@ -1,33 +1,69 @@
 import {
-  detectViteProject
-} from "./index-18hvb6gb.js";
+  getGeneratedArtifactPaths
+} from "./index-aabgympv.js";
 import {
-  loadConfig,
-  resolveConfigPath
-} from "./index-hcex3rgh.js";
+  formatSupportedConfigFilenames,
+  resolveConfigCandidatePath
+} from "./index-vez803pp.js";
 import {
   getDependencies
-} from "./index-1xpj0m4r.js";
+} from "./index-z9gy8w6b.js";
+import {
+  detectViteProject
+} from "./index-gn5wy09x.js";
+import {
+  getPackageVersion
+} from "./index-627srx16.js";
+import {
+  bold,
+  createCliTheme,
+  dim,
+  green,
+  logLine,
+  red,
+  yellow
+} from "./index-stgn34cr.js";
+import"./index-3t6rypgc.js";
+import"./index-qwgr4q7s.js";
+import {
+  loadConfig
+} from "./index-dfcp9hsd.js";
+import"./index-1d4jg11n.js";
+import"./index-mg8vwqxf.js";
+import"./index-c8p4njqy.js";
 import"./index-37x76zdn.js";
 
 // src/cli/commands/doctor.ts
-import { resolve } from "pathe";
+import { basename, dirname, relative, resolve } from "pathe";
 async function runDoctorCommand(parsed, logger, options) {
   const cwd = options.cwd || process.cwd();
+  const theme = createCliTheme(parsed.options);
+  const requestedConfigOption = parsed.options.config;
+  const scope = parsed.options.scope ?? "all";
+  if (!["all", "local", "deploy"].includes(scope)) {
+    logger.error(`Unsupported doctor scope: ${scope}`);
+    logger.info("Supported scopes: all, local, deploy");
+    return { exitCode: 1 };
+  }
+  const requestedConfigPath = requestedConfigOption ? resolve(cwd, requestedConfigOption) : cwd;
   const checks = [];
   const { fs } = await getDependencies();
   const viteProject = await detectViteProject(cwd, fs);
-  logger.info(`Running diagnostics...
-`);
-  try {
-    const configPath = await resolveConfigPath(cwd);
+  logLine(logger);
+  logLine(logger, `${bold("doctor", theme)} ${dim("Running diagnostics", theme)}`);
+  logLine(logger);
+  const configPath = await resolveConfigCandidatePath(requestedConfigPath);
+  if (configPath) {
     checks.push({
       name: "Config File",
       status: "pass",
       message: `Found: ${configPath}`
     });
     try {
-      const config = await loadConfig({ cwd });
+      const config = requestedConfigOption ? await loadConfig({
+        cwd: dirname(configPath),
+        configFile: basename(configPath)
+      }) : await loadConfig({ cwd });
       checks.push({
         name: "Config Valid",
         status: "pass",
@@ -40,11 +76,11 @@ async function runDoctorCommand(parsed, logger, options) {
         message: error instanceof Error ? error.message : "Unknown error"
       });
     }
-  } catch {
+  } else {
     checks.push({
       name: "Config File",
       status: "fail",
-      message: "devflare.config.ts not found. Run `devflare init` to create one."
+      message: `${formatSupportedConfigFilenames()} not found. Run \`devflare init\` to create one.`
     });
   }
   const packageJsonPath = resolve(cwd, "package.json");
@@ -59,10 +95,11 @@ async function runDoctorCommand(parsed, logger, options) {
     });
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
     if (deps.devflare) {
+      const resolvedVersion = await getPackageVersion();
       checks.push({
         name: "devflare dep",
         status: "pass",
-        message: `Version: ${deps.devflare}`
+        message: `package.json: ${deps.devflare}, resolved: ${resolvedVersion}`
       });
     } else {
       checks.push({
@@ -106,8 +143,8 @@ async function runDoctorCommand(parsed, logger, options) {
     } else {
       checks.push({
         name: "@cloudflare/vite-plugin",
-        status: "warn",
-        message: "Not declared in this package.json"
+        status: "pass",
+        message: "Optional: not declared in this package.json. Install it only when your Vite config calls the Cloudflare Vite plugin directly."
       });
     }
     if (viteProject.viteConfigPath) {
@@ -144,36 +181,68 @@ async function runDoctorCommand(parsed, logger, options) {
       message: "tsconfig.json not found"
     });
   }
-  try {
-    await fs.access(resolve(cwd, "wrangler.jsonc"));
-    checks.push({
-      name: "wrangler.jsonc",
-      status: "pass",
-      message: "Found (generated)"
-    });
-  } catch {
-    checks.push({
-      name: "wrangler.jsonc",
-      status: "warn",
-      message: "Not found. Run `devflare dev` or `devflare build` to generate."
-    });
+  const artifactPaths = getGeneratedArtifactPaths(cwd);
+  if (scope === "all" || scope === "local") {
+    try {
+      await fs.access(artifactPaths.devWranglerConfigPath);
+      checks.push({
+        name: "Generated dev config",
+        status: "pass",
+        message: `Found: ${relative(cwd, artifactPaths.devWranglerConfigPath)}`
+      });
+    } catch {
+      checks.push({
+        name: "Generated dev config",
+        status: "warn",
+        message: "Local readiness: not found. Run `devflare dev` or start `devflare/vite` to populate `.devflare/wrangler.jsonc`."
+      });
+    }
+  }
+  if (scope === "all" || scope === "deploy") {
+    try {
+      await fs.access(artifactPaths.buildWranglerConfigPath);
+      checks.push({
+        name: "Generated deploy config",
+        status: "pass",
+        message: `Found: ${relative(cwd, artifactPaths.buildWranglerConfigPath)}`
+      });
+    } catch {
+      checks.push({
+        name: "Generated deploy config",
+        status: "warn",
+        message: "Deploy readiness: not found. Run `devflare build` or `devflare deploy` to generate `.devflare/build/wrangler.jsonc`."
+      });
+    }
+    try {
+      await fs.access(artifactPaths.deployRedirectPath);
+      checks.push({
+        name: "Wrangler deploy redirect",
+        status: "pass",
+        message: `Found: ${relative(cwd, artifactPaths.deployRedirectPath)}`
+      });
+    } catch {
+      checks.push({
+        name: "Wrangler deploy redirect",
+        status: "warn",
+        message: "Deploy readiness: not found. Run `devflare build` or `devflare deploy` to generate `.wrangler/deploy/config.json`."
+      });
+    }
   }
   let hasFailures = false;
   let hasWarnings = false;
   for (const check of checks) {
     const icon = check.status === "pass" ? "✓" : check.status === "warn" ? "⚠" : "✗";
-    const color = check.status === "pass" ? "green" : check.status === "warn" ? "yellow" : "red";
     if (check.status === "pass") {
-      logger.success(`${icon} ${check.name}: ${check.message}`);
+      logLine(logger, `${green(icon, theme)} ${bold(check.name, theme)}${dim(" — ", theme)}${check.message}`);
     } else if (check.status === "warn") {
-      logger.warn(`${icon} ${check.name}: ${check.message}`);
+      logLine(logger, `${yellow(icon, theme)} ${bold(check.name, theme)}${dim(" — ", theme)}${check.message}`);
       hasWarnings = true;
     } else {
-      logger.error(`${icon} ${check.name}: ${check.message}`);
+      logLine(logger, `${red(icon, theme)} ${bold(check.name, theme)}${dim(" — ", theme)}${check.message}`);
       hasFailures = true;
     }
   }
-  logger.info("");
+  logLine(logger);
   if (hasFailures) {
     logger.error("Some checks failed. Please fix the issues above.");
     return { exitCode: 1 };

package/dist/{durable-object-t4kbb0yt.js → durable-object-v3gsnybk.js}

@@ -3,7 +3,7 @@ import {
   findDurableObjectClassesDetailed,
   generateWrapper,
   transformDurableObject
-} from "./index-gz1gndna.js";
+} from "./index-vhqww6tt.js";
 import"./index-37x76zdn.js";
 export {
   transformDurableObject,

package/dist/env.d.ts

@@ -1,6 +1,8 @@
 declare global {
     interface DevflareEnv {
     }
+    interface DevflareVars {
+    }
 }
 /**
  * Called by createTestContext to set up the unified env
@@ -45,4 +47,12 @@ export declare function __clearTestContext(): void;
 export declare const env: DevflareEnv & {
     dispose(): Promise<void>;
 };
+/**
+ * Unified runtime variables proxy.
+ *
+ * This reads from the same active environment object as {@link env}, but is
+ * typed from config `vars` via generated `env.d.ts` declarations. It is useful
+ * for nested typed values authored with `defineConfig({ vars })`.
+ */
+export declare const vars: Readonly<DevflareVars>;
 //# sourceMappingURL=env.d.ts.map

package/dist/env.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../src/env.ts"],"names":[],"mappings":"AAeA,OAAO,CAAC,MAAM,CAAC,CAAC;IAGf,UAAU,WAAW;KAAG;CACxB;AASD;;;GAGG;AACH,wBAAgB,gBAAgB,CAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAC1B,IAAI,CAGN;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAGzC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,GAAG,EAAE,WAAW,GAAG;IAAE,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CA8DzD,CAAA"}
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../src/env.ts"],"names":[],"mappings":"AAqBA,OAAO,CAAC,MAAM,CAAC,CAAC;IAGf,UAAU,WAAW;KAAG;IAGxB,UAAU,YAAY;KAAG;CACzB;AASD;;;GAGG;AACH,wBAAgB,gBAAgB,CAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAC1B,IAAI,CAGN;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAGzC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,GAAG,EAAE,WAAW,GAAG;IAAE,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CA8DzD,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,EAAE,QAAQ,CAAC,YAAY,CAoDvC,CAAA"}

package/dist/index-11p28kxx.js

@@ -0,0 +1,256 @@
+import {
+  apiDelete,
+  apiGetAll,
+  apiPost,
+  apiPut
+} from "./index-mg8vwqxf.js";
+
+// src/cloudflare/known-permission-group-ids.generated.ts
+var KNOWN_PERMISSION_GROUP_IDS_DATA = {
+  WORKERS_SCRIPTS_WRITE: null,
+  WORKERS_SCRIPTS_READ: null,
+  ACCOUNT_SETTINGS_READ: null,
+  WORKERS_KV_STORAGE_WRITE: null,
+  WORKERS_KV_STORAGE_READ: null,
+  ACCOUNT_API_TOKENS_WRITE: null,
+  ACCOUNT_API_TOKENS_READ: null
+};
+
+// src/cloudflare/tokens.ts
+var MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS = 300;
+var DEVFLARE_MANAGED_TOKEN_PREFIX = "devflare-";
+var ACCOUNT_OWNED_TOKEN_SCOPE = "com.cloudflare.api.account";
+var ACCOUNT_ZONE_OWNED_TOKEN_SCOPE = "com.cloudflare.api.account.zone";
+var ACCOUNT_API_TOKENS_PERMISSION_GROUP_NAME_PATTERN = /^Account API Tokens\b/i;
+var DEVFLARE_MANAGED_TOKEN_NAME_PATTERN = /^devflare-/i;
+var DEVFLARE_PERMISSION_GROUP_NAME_PATTERNS = [
+  /^Account Analytics /i,
+  /^Account Settings /i,
+  /^Account Filter Lists /i,
+  /^AI /i,
+  /^Analytics /i,
+  /^Browser Rendering /i,
+  /^Cache Purge\b/i,
+  /^D1 /i,
+  /^DNS /i,
+  /^Email /i,
+  /^Hyperdrive /i,
+  /^Images /i,
+  /^Logs /i,
+  /^Logpush /i,
+  /^Pages /i,
+  /^Queues /i,
+  /^R2 /i,
+  /^SSL and Certificates /i,
+  /^Stream /i,
+  /^Vectorize /i,
+  /^Workers /i,
+  /^Zone Settings /i,
+  /^Zone /i
+];
+function deriveKnownPermissionGroupIds(data) {
+  const result = {};
+  for (const key of Object.keys(data)) {
+    const value = data[key];
+    result[key] = value === null ? undefined : value;
+  }
+  return result;
+}
+var KNOWN_PERMISSION_GROUP_IDS = deriveKnownPermissionGroupIds(KNOWN_PERMISSION_GROUP_IDS_DATA);
+function dedupePermissionGroups(permissionGroups) {
+  const seenIds = new Set;
+  return permissionGroups.filter((permissionGroup) => {
+    if (seenIds.has(permissionGroup.id)) {
+      return false;
+    }
+    seenIds.add(permissionGroup.id);
+    return true;
+  });
+}
+function dedupePermissionGroupIds(permissionGroupIds) {
+  return Array.from(new Set(permissionGroupIds.map((id) => id.trim()).filter(Boolean)));
+}
+function dedupeScopedPermissionGroups(permissionGroups) {
+  const seenIds = new Set;
+  return permissionGroups.filter((permissionGroup) => {
+    const id = permissionGroup.id.trim();
+    if (!id || seenIds.has(id)) {
+      return false;
+    }
+    seenIds.add(id);
+    return true;
+  });
+}
+function permissionGroupHasScope(permissionGroup, scope) {
+  return permissionGroup.scopes.some((value) => value.trim() === scope);
+}
+function buildCreateTokenPoliciesFromPermissionGroups(accountId, permissionGroups) {
+  const dedupedPermissionGroups = dedupeScopedPermissionGroups(permissionGroups);
+  const accountPermissionGroupIds = dedupePermissionGroupIds(dedupedPermissionGroups.filter((permissionGroup) => permissionGroupHasScope(permissionGroup, ACCOUNT_OWNED_TOKEN_SCOPE)).map((permissionGroup) => permissionGroup.id));
+  const zonePermissionGroupIds = dedupePermissionGroupIds(dedupedPermissionGroups.filter((permissionGroup) => permissionGroupHasScope(permissionGroup, ACCOUNT_ZONE_OWNED_TOKEN_SCOPE)).map((permissionGroup) => permissionGroup.id));
+  const policies = [];
+  if (accountPermissionGroupIds.length > 0) {
+    policies.push({
+      effect: "allow",
+      resources: {
+        [`com.cloudflare.api.account.${accountId}`]: "*"
+      },
+      permission_groups: accountPermissionGroupIds.map((id) => ({ id }))
+    });
+  }
+  if (zonePermissionGroupIds.length > 0) {
+    policies.push({
+      effect: "allow",
+      resources: {
+        [`com.cloudflare.api.account.${accountId}`]: {
+          [`${ACCOUNT_ZONE_OWNED_TOKEN_SCOPE}.*`]: "*"
+        }
+      },
+      permission_groups: zonePermissionGroupIds.map((id) => ({ id }))
+    });
+  }
+  return policies;
+}
+function buildCreateTokenPoliciesFromPermissionGroupIds(accountId, permissionGroupIds) {
+  const dedupedPermissionGroupIds = dedupePermissionGroupIds(permissionGroupIds);
+  if (dedupedPermissionGroupIds.length === 0) {
+    return [];
+  }
+  return [
+    {
+      effect: "allow",
+      resources: {
+        [`com.cloudflare.api.account.${accountId}`]: "*"
+      },
+      permission_groups: dedupedPermissionGroupIds.map((id) => ({ id }))
+    }
+  ];
+}
+function excludeAccountApiTokensPermissionGroups(permissionGroups) {
+  return permissionGroups.filter((permissionGroup) => {
+    return !ACCOUNT_API_TOKENS_PERMISSION_GROUP_NAME_PATTERN.test(permissionGroup.name);
+  });
+}
+function keepAccountOwnedTokenCompatiblePermissionGroups(permissionGroups) {
+  return permissionGroups.filter((permissionGroup) => {
+    return permissionGroup.scopes.some((scope) => {
+      const normalizedScope = scope.trim();
+      return normalizedScope === ACCOUNT_OWNED_TOKEN_SCOPE || normalizedScope === ACCOUNT_ZONE_OWNED_TOKEN_SCOPE;
+    });
+  });
+}
+function selectReusableAccountOwnedTokenPermissionGroups(permissionGroups) {
+  return dedupePermissionGroups(excludeAccountApiTokensPermissionGroups(keepAccountOwnedTokenCompatiblePermissionGroups(permissionGroups)));
+}
+function parseOptionalDate(value) {
+  if (!value) {
+    return;
+  }
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+}
+function mapAccountOwnedAPITokenPolicy(policy) {
+  return {
+    id: policy.id,
+    effect: policy.effect,
+    permissionGroups: policy.permission_groups?.map((permissionGroup) => ({
+      id: permissionGroup.id,
+      name: permissionGroup.name
+    }))
+  };
+}
+function mapAccountOwnedAPIToken(token) {
+  return {
+    id: token.id,
+    name: token.name ?? token.id,
+    status: token.status,
+    value: token.value,
+    issuedOn: parseOptionalDate(token.issued_on),
+    modifiedOn: parseOptionalDate(token.modified_on),
+    lastUsedOn: parseOptionalDate(token.last_used_on),
+    policies: token.policies?.map(mapAccountOwnedAPITokenPolicy)
+  };
+}
+function isDevflareManagedTokenName(name) {
+  return DEVFLARE_MANAGED_TOKEN_NAME_PATTERN.test(name.trim());
+}
+function normalizeDevflareTokenName(name) {
+  const trimmedName = name.trim();
+  if (!trimmedName) {
+    throw new Error("Devflare token name cannot be empty");
+  }
+  const suffix = isDevflareManagedTokenName(trimmedName) ? trimmedName.replace(DEVFLARE_MANAGED_TOKEN_NAME_PATTERN, "") : trimmedName;
+  if (!suffix) {
+    throw new Error("Devflare token name cannot be empty");
+  }
+  return `${DEVFLARE_MANAGED_TOKEN_PREFIX}${suffix}`;
+}
+function stripDevflareTokenNamePrefix(name) {
+  const trimmedName = name.trim();
+  if (!trimmedName) {
+    return trimmedName;
+  }
+  const strippedName = trimmedName.replace(DEVFLARE_MANAGED_TOKEN_NAME_PATTERN, "");
+  return strippedName || trimmedName;
+}
+function filterDevflareManagedTokens(tokens) {
+  return tokens.filter((token) => isDevflareManagedTokenName(token.name));
+}
+function selectDevflarePermissionGroups(permissionGroups) {
+  const selectedPermissionGroups = dedupePermissionGroups(selectReusableAccountOwnedTokenPermissionGroups(permissionGroups).filter((permissionGroup) => {
+    return DEVFLARE_PERMISSION_GROUP_NAME_PATTERNS.some((pattern) => {
+      return pattern.test(permissionGroup.name);
+    });
+  }));
+  if (selectedPermissionGroups.length === 0) {
+    throw new Error("Could not map the available Cloudflare permission groups to a Devflare token policy.");
+  }
+  if (selectedPermissionGroups.length > MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS) {
+    throw new Error(`Devflare selected ${selectedPermissionGroups.length} permission groups, which exceeds Cloudflare's ${MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS}-group limit for account-owned tokens.`);
+  }
+  return selectedPermissionGroups;
+}
+function selectAllReusablePermissionGroups(permissionGroups) {
+  const selectedPermissionGroups = selectReusableAccountOwnedTokenPermissionGroups(permissionGroups);
+  if (selectedPermissionGroups.length === 0) {
+    throw new Error("Could not find any reusable account/zone-scoped Cloudflare permission groups for this Devflare token.");
+  }
+  if (selectedPermissionGroups.length > MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS) {
+    throw new Error(`Devflare selected ${selectedPermissionGroups.length} permission groups, which exceeds Cloudflare's ${MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS}-group limit for account-owned tokens.`);
+  }
+  return selectedPermissionGroups;
+}
+async function listAccountTokenPermissionGroups(accountId, options) {
+  const permissionGroups = await apiGetAll(`/accounts/${accountId}/tokens/permission_groups`, options);
+  return dedupePermissionGroups(permissionGroups);
+}
+async function listAccountOwnedAPITokens(accountId, options) {
+  const tokens = await apiGetAll(`/accounts/${accountId}/tokens`, options);
+  return tokens.map(mapAccountOwnedAPIToken);
+}
+async function deleteAccountOwnedAPIToken(accountId, tokenId, options) {
+  return apiDelete(`/accounts/${accountId}/tokens/${tokenId}`, options);
+}
+async function rollAccountOwnedAPITokenValue(accountId, tokenId, options) {
+  return apiPut(`/accounts/${accountId}/tokens/${tokenId}/value`, {}, options);
+}
+async function createAccountOwnedAPIToken(accountId, options, clientOptions) {
+  const permissionGroupIds = dedupePermissionGroupIds(options.permissionGroups?.map((permissionGroup) => permissionGroup.id) ?? options.permissionGroupIds ?? []);
+  if (permissionGroupIds.length === 0) {
+    throw new Error("Cannot create a Devflare token without any permission groups");
+  }
+  if (permissionGroupIds.length > MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS) {
+    throw new Error(`Cannot create a Devflare token with more than ${MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS} permission groups.`);
+  }
+  const policies = options.permissionGroups ? buildCreateTokenPoliciesFromPermissionGroups(accountId, options.permissionGroups) : buildCreateTokenPoliciesFromPermissionGroupIds(accountId, permissionGroupIds);
+  if (policies.length === 0) {
+    throw new Error("Cannot create a Devflare token without any account- or zone-scoped permission groups");
+  }
+  const createdToken = await apiPost(`/accounts/${accountId}/tokens`, {
+    name: options.name,
+    policies
+  }, clientOptions);
+  return mapAccountOwnedAPIToken(createdToken);
+}
+
+export { normalizeDevflareTokenName, stripDevflareTokenNamePrefix, filterDevflareManagedTokens, selectDevflarePermissionGroups, selectAllReusablePermissionGroups, listAccountTokenPermissionGroups, listAccountOwnedAPITokens, deleteAccountOwnedAPIToken, rollAccountOwnedAPITokenValue, createAccountOwnedAPIToken };