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

package/dist/index-j5aphr5x.js

@@ -0,0 +1,185 @@
+import {
+  resolveConfigForEnvironment
+} from "./index-wnnbbbkt.js";
+
+// src/cli/commands/previews-support/family.ts
+function compareConfiguredWorkerFamilies(left, right) {
+  if (left.role === "primary" && right.role !== "primary") {
+    return -1;
+  }
+  if (left.role !== "primary" && right.role === "primary") {
+    return 1;
+  }
+  return left.baseName.localeCompare(right.baseName);
+}
+function comparePreviewScopeRows(left, right) {
+  const leftTime = left.updatedAt?.getTime() ?? 0;
+  const rightTime = right.updatedAt?.getTime() ?? 0;
+  if (rightTime !== leftTime) {
+    return rightTime - leftTime;
+  }
+  return left.scope.localeCompare(right.scope);
+}
+function collectConfiguredWorkerFamilies(config, environment) {
+  const resolvedConfig = resolveConfigForEnvironment(config, environment);
+  const families = new Map;
+  families.set(resolvedConfig.name, {
+    baseName: resolvedConfig.name,
+    roleLabel: "primary",
+    role: "primary"
+  });
+  for (const [bindingName, binding] of Object.entries(resolvedConfig.bindings?.services ?? {})) {
+    const existing = families.get(binding.service);
+    if (existing) {
+      continue;
+    }
+    families.set(binding.service, {
+      baseName: binding.service,
+      roleLabel: bindingName,
+      role: "service"
+    });
+  }
+  return Array.from(families.values()).sort(compareConfiguredWorkerFamilies);
+}
+function getWorkerUrl(workerName, workersSubdomain) {
+  if (!workersSubdomain) {
+    return;
+  }
+  return `https://${workerName}.${workersSubdomain}.workers.dev`;
+}
+function getWorkerScopeSuffix(workerName, baseName) {
+  if (!workerName.startsWith(`${baseName}-`)) {
+    return;
+  }
+  const suffix = workerName.slice(baseName.length + 1).trim();
+  return suffix || undefined;
+}
+function buildStableWorkerRowsFromLiveWorkers(families, workers, workersSubdomain) {
+  const workersByName = new Map(workers.map((worker) => [worker.name, worker]));
+  return families.map((family) => {
+    const worker = workersByName.get(family.baseName);
+    const status = worker ? "active" : "missing";
+    return {
+      workerName: family.baseName,
+      role: family.roleLabel,
+      status,
+      updatedAt: worker?.modifiedOn,
+      url: worker ? getWorkerUrl(family.baseName, workersSubdomain) : undefined
+    };
+  });
+}
+function getDedicatedPreviewFamilyNamesFromWorkers(families, workers) {
+  const familyNames = new Set;
+  const workerNames = workers.map((worker) => worker.name);
+  for (const family of families) {
+    if (family.role === "primary") {
+      familyNames.add(family.baseName);
+      continue;
+    }
+    if (workerNames.some((workerName) => Boolean(getWorkerScopeSuffix(workerName, family.baseName)))) {
+      familyNames.add(family.baseName);
+    }
+  }
+  return familyNames;
+}
+function buildPreviewScopeRowsFromLiveWorkers(families, workers, workersSubdomain) {
+  const workersByName = new Map(workers.map((worker) => [worker.name, worker]));
+  const previewFamilyNames = getDedicatedPreviewFamilyNamesFromWorkers(families, workers);
+  const expectedFamilies = families.filter((family) => previewFamilyNames.has(family.baseName));
+  const workerCandidatesByScope = buildPreviewWorkerCandidatesByScope(families, workers);
+  return Array.from(workerCandidatesByScope.keys()).map((scope) => {
+    const resolvedFamilies = expectedFamilies.map((family) => ({
+      family,
+      worker: workersByName.get(`${family.baseName}-${scope}`)
+    }));
+    const presentFamilies = resolvedFamilies.filter((entry) => entry.worker);
+    const updatedAt = presentFamilies.reduce((latest, entry) => {
+      const currentDate = entry.worker?.modifiedOn;
+      if (!currentDate) {
+        return latest;
+      }
+      if (!latest || currentDate.getTime() > latest.getTime()) {
+        return currentDate;
+      }
+      return latest;
+    }, undefined);
+    const primaryEntry = resolvedFamilies.find((entry) => entry.family.role === "primary");
+    const entryWorker = primaryEntry?.worker ?? presentFamilies[0]?.worker;
+    const missingLabels = resolvedFamilies.filter((entry) => !entry.worker).map((entry) => entry.family.role === "primary" ? "primary" : entry.family.roleLabel);
+    const notes = [];
+    if (missingLabels.length > 0) {
+      notes.push(`missing ${missingLabels.join(", ")}`);
+    }
+    const strategy = "dedicated workers";
+    const status = presentFamilies.length === resolvedFamilies.length ? "ready" : "partial";
+    return {
+      scope,
+      strategy,
+      workersLabel: `${presentFamilies.length}/${resolvedFamilies.length}`,
+      status,
+      updatedAt,
+      notes: notes.length > 0 ? notes.join(" · ") : undefined,
+      entryUrl: entryWorker ? getWorkerUrl(entryWorker.name, workersSubdomain) : undefined
+    };
+  }).sort(comparePreviewScopeRows);
+}
+function buildPreviewWorkerCandidatesByScope(families, workers) {
+  const candidates = new Map;
+  for (const worker of workers) {
+    for (const family of families) {
+      const scope = getWorkerScopeSuffix(worker.name, family.baseName);
+      if (!scope) {
+        continue;
+      }
+      const names = candidates.get(scope) ?? new Set;
+      names.add(worker.name);
+      candidates.set(scope, names);
+    }
+  }
+  return new Map(Array.from(candidates.entries()).map(([scope, workerNames]) => {
+    return [scope, Array.from(workerNames).sort((left, right) => left.localeCompare(right))];
+  }));
+}
+function orderPreviewWorkerNamesForDeletion(workerNames, scope, families) {
+  const familyPriority = new Map;
+  for (const family of families) {
+    familyPriority.set(family.baseName, {
+      priority: family.role === "primary" ? 0 : 1,
+      roleLabel: family.roleLabel
+    });
+  }
+  const resolveFamilyForWorker = (workerName) => {
+    for (const family of families) {
+      if (getWorkerScopeSuffix(workerName, family.baseName) === scope) {
+        const resolved = familyPriority.get(family.baseName);
+        if (resolved) {
+          return {
+            priority: resolved.priority,
+            roleLabel: resolved.roleLabel,
+            baseName: family.baseName
+          };
+        }
+      }
+    }
+    return {
+      priority: 2,
+      roleLabel: workerName
+    };
+  };
+  return [...workerNames].sort((left, right) => {
+    const leftFamily = resolveFamilyForWorker(left);
+    const rightFamily = resolveFamilyForWorker(right);
+    if (leftFamily.priority !== rightFamily.priority) {
+      return leftFamily.priority - rightFamily.priority;
+    }
+    if (leftFamily.roleLabel !== rightFamily.roleLabel) {
+      return leftFamily.roleLabel.localeCompare(rightFamily.roleLabel);
+    }
+    if (leftFamily.baseName && rightFamily.baseName && leftFamily.baseName !== rightFamily.baseName) {
+      return leftFamily.baseName.localeCompare(rightFamily.baseName);
+    }
+    return left.localeCompare(right);
+  });
+}
+
+export { collectConfiguredWorkerFamilies, buildStableWorkerRowsFromLiveWorkers, buildPreviewScopeRowsFromLiveWorkers, buildPreviewWorkerCandidatesByScope, orderPreviewWorkerNamesForDeletion };

package/dist/index-j68v36q1.js

@@ -0,0 +1,188 @@
+import {
+  apiDelete,
+  apiGetAll,
+  apiPost,
+  apiPut
+} from "./index-a3e13a7m.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_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 Read$/i,
+  /^Account Settings Read$/i,
+  /^Analytics Read$/i,
+  /^AI /i,
+  /^Browser Rendering /i,
+  /^D1 (Metadata Read|Read|Write)$/i,
+  /^Email (Routing|Sending) /i,
+  /^Hyperdrive /i,
+  /^Queues /i,
+  /^Vectorize /i,
+  /^Workers /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 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) => scope.trim() === ACCOUNT_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-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.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 createdToken = await apiPost(`/accounts/${accountId}/tokens`, {
+    name: options.name,
+    policies: [
+      {
+        effect: "allow",
+        resources: {
+          [`com.cloudflare.api.account.${accountId}`]: "*"
+        },
+        permission_groups: permissionGroupIds.map((id) => ({ id }))
+      }
+    ]
+  }, clientOptions);
+  return mapAccountOwnedAPIToken(createdToken);
+}
+
+export { normalizeDevflareTokenName, stripDevflareTokenNamePrefix, filterDevflareManagedTokens, selectDevflarePermissionGroups, selectAllReusablePermissionGroups, listAccountTokenPermissionGroups, listAccountOwnedAPITokens, deleteAccountOwnedAPIToken, rollAccountOwnedAPITokenValue, createAccountOwnedAPIToken };