devflare 1.0.0-next.2 → 1.0.0-next.21

package/dist/previews-3w4pxqby.js

@@ -0,0 +1,1337 @@
+import {
+  buildPreviewScopeRowsFromLiveWorkers,
+  buildPreviewWorkerCandidatesByScope,
+  buildStableWorkerRowsFromLiveWorkers,
+  collectConfiguredWorkerFamilies,
+  orderPreviewWorkerNamesForDeletion
+} from "./index-06bg0z9y.js";
+import {
+  cleanupPreviewScopedResources
+} from "./index-x12e6fzy.js";
+import {
+  findConfigPathsUnderDirectory
+} from "./index-4by4c7rm.js";
+import {
+  asOptionalString,
+  resolveCloudflareAccountId,
+  resolveNamedSelection
+} from "./index-53pqqpq9.js";
+import {
+  account
+} from "./index-0m6e4mxz.js";
+import"./index-k7m5f1dg.js";
+import"./index-3jme4hgw.js";
+import {
+  getDependencies
+} from "./index-z9gy8w6b.js";
+import {
+  bold,
+  createCliTheme,
+  cyanBold,
+  dim,
+  formatTableLine,
+  green,
+  logLine,
+  red,
+  whiteDim,
+  yellow,
+  yellowBold
+} from "./index-stgn34cr.js";
+import"./index-3t6rypgc.js";
+import"./index-15fpa5tx.js";
+import"./index-rbht7m9r.js";
+import {
+  compileBuildConfig
+} from "./index-c3nxftnp.js";
+import {
+  ConfigNotFoundError,
+  loadConfig,
+  loadResolvedConfig,
+  resolveConfigPath
+} from "./index-syscwrjp.js";
+import"./index-1d4jg11n.js";
+import"./index-mg8vwqxf.js";
+import {
+  resolvePreviewIdentifier
+} from "./index-z40mjts9.js";
+import"./index-q8f4kawk.js";
+import"./index-37x76zdn.js";
+
+// src/cli/preview-bindings.ts
+function normalizeCell(value) {
+  return (value ?? "").trim().replace(/\s+/g, " ");
+}
+function buildAssociationKey(type, resource) {
+  return `${normalizeCell(type).toLowerCase()}\x00${normalizeCell(resource).toLowerCase()}`;
+}
+function uniqueStrings(values) {
+  return Array.from(new Set(values.filter((value) => value.trim().length > 0)));
+}
+function formatSendEmailResource(entry) {
+  const destination = entry.destination_address?.trim();
+  if (destination) {
+    return destination;
+  }
+  const destinations = uniqueStrings(entry.allowed_destination_addresses ?? []);
+  const senders = uniqueStrings(entry.allowed_sender_addresses ?? []);
+  const destinationLabel = destinations.length > 0 ? destinations.join(", ") : "configured destinations";
+  if (senders.length === 0) {
+    return destinationLabel;
+  }
+  return `${destinationLabel} - senders: ${senders.join(", ")}`;
+}
+function addAssociationTarget(targets, input) {
+  const type = normalizeCell(input.type);
+  const resource = normalizeCell(input.resource);
+  const key = buildAssociationKey(type, resource);
+  const existing = targets.get(key);
+  if (existing) {
+    if (input.reference) {
+      existing.referenceLabels = uniqueStrings([...existing.referenceLabels, input.reference]);
+    }
+    if (input.note) {
+      existing.notes = uniqueStrings([...existing.notes, input.note]);
+    }
+    if (!existing.queueName && input.queueName) {
+      existing.queueName = input.queueName;
+    }
+    return;
+  }
+  targets.set(key, {
+    key,
+    referenceLabels: input.reference ? [input.reference] : [],
+    type,
+    resource,
+    notes: input.note ? [input.note] : [],
+    queueName: input.queueName
+  });
+}
+function collectBindingAssociationTargets(config) {
+  const compiled = compileBuildConfig(config);
+  const targets = new Map;
+  for (const binding of compiled.kv_namespaces ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "KV Namespace",
+      resource: "id" in binding ? binding.id : binding.name
+    });
+  }
+  for (const binding of compiled.d1_databases ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "D1 Database",
+      resource: "database_id" in binding ? binding.database_id : binding.database_name
+    });
+  }
+  for (const binding of compiled.r2_buckets ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "R2 Bucket",
+      resource: binding.bucket_name
+    });
+  }
+  for (const binding of compiled.durable_objects?.bindings ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.name,
+      type: "Durable Object Namespace",
+      resource: binding.class_name,
+      note: binding.script_name ? `script ${binding.script_name}` : undefined
+    });
+  }
+  for (const binding of compiled.queues?.producers ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "Queue",
+      resource: binding.queue,
+      note: "producer binding",
+      queueName: binding.queue
+    });
+  }
+  for (const binding of compiled.queues?.consumers ?? []) {
+    addAssociationTarget(targets, {
+      type: "Queue",
+      resource: binding.queue,
+      note: "consumer attachment",
+      queueName: binding.queue
+    });
+    if (binding.dead_letter_queue) {
+      addAssociationTarget(targets, {
+        type: "Queue",
+        resource: binding.dead_letter_queue,
+        note: "dead letter queue",
+        queueName: binding.dead_letter_queue
+      });
+    }
+  }
+  for (const binding of compiled.ratelimits ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.name,
+      type: "Rate Limiting",
+      resource: binding.namespace_id
+    });
+  }
+  if (compiled.version_metadata) {
+    addAssociationTarget(targets, {
+      reference: compiled.version_metadata.binding,
+      type: "Version Metadata",
+      resource: "Version Metadata"
+    });
+  }
+  for (const binding of compiled.worker_loaders ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "Worker Loader",
+      resource: "Worker Loader"
+    });
+  }
+  for (const binding of compiled.mtls_certificates ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "mTLS Certificate",
+      resource: binding.certificate_id
+    });
+  }
+  for (const binding of compiled.dispatch_namespaces ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "Dispatch Namespace",
+      resource: binding.namespace,
+      note: binding.outbound ? `outbound ${binding.outbound.service}` : undefined
+    });
+  }
+  for (const binding of compiled.workflows ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "Workflow",
+      resource: binding.name,
+      note: binding.script_name ? `script ${binding.script_name}` : binding.class_name
+    });
+  }
+  for (const binding of compiled.pipelines ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "Pipeline",
+      resource: binding.pipeline,
+      note: binding.remote ? "remote local binding" : undefined
+    });
+  }
+  if (compiled.images) {
+    addAssociationTarget(targets, {
+      reference: compiled.images.binding,
+      type: "Images",
+      resource: "Images",
+      note: compiled.images.remote ? "remote local binding" : undefined
+    });
+  }
+  if (compiled.media) {
+    addAssociationTarget(targets, {
+      reference: compiled.media.binding,
+      type: "Media Transformations",
+      resource: "Media Transformations",
+      note: compiled.media.remote ? "remote local binding" : undefined
+    });
+  }
+  for (const binding of compiled.artifacts ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "Artifacts",
+      resource: binding.namespace,
+      note: binding.remote ? "remote local binding" : undefined
+    });
+  }
+  for (const binding of compiled.secrets_store_secrets ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "Secrets Store",
+      resource: `${binding.store_id}/${binding.secret_name}`
+    });
+  }
+  for (const consumer of compiled.tail_consumers ?? []) {
+    addAssociationTarget(targets, {
+      type: "Tail Consumer",
+      resource: consumer.service,
+      note: consumer.environment ? `env ${consumer.environment}` : undefined
+    });
+  }
+  for (const binding of compiled.services ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "Worker",
+      resource: binding.entrypoint ? `${binding.service}#${binding.entrypoint}` : binding.service,
+      note: binding.environment ? `env ${binding.environment}` : undefined
+    });
+  }
+  if (compiled.ai?.binding) {
+    addAssociationTarget(targets, {
+      reference: compiled.ai.binding,
+      type: "AI",
+      resource: "Workers AI"
+    });
+  }
+  for (const binding of compiled.vectorize ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "Vectorize",
+      resource: binding.index_name
+    });
+  }
+  for (const binding of compiled.hyperdrive ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "Hyperdrive",
+      resource: "id" in binding ? binding.id : binding.name
+    });
+  }
+  if (compiled.browser?.binding) {
+    addAssociationTarget(targets, {
+      reference: compiled.browser.binding,
+      type: "Browser",
+      resource: "Browser Rendering"
+    });
+  }
+  for (const binding of compiled.analytics_engine_datasets ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "Analytics Engine",
+      resource: binding.dataset
+    });
+  }
+  for (const binding of compiled.send_email ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.name,
+      type: "Send Email",
+      resource: formatSendEmailResource(binding)
+    });
+  }
+  return Array.from(targets.values());
+}
+function getActiveVersionId(deployments) {
+  const sortedDeployments = [...deployments].sort((left, right) => right.createdOn.getTime() - left.createdOn.getTime());
+  for (const deployment of sortedDeployments) {
+    const version = [...deployment.versions].sort((left, right) => right.percentage - left.percentage)[0];
+    if (version?.versionId) {
+      return version.versionId;
+    }
+  }
+  return;
+}
+function extractWorkerNames(value) {
+  return Array.from(value.matchAll(/worker:([^,\s]+)/gi), (match) => match[1]);
+}
+function parseWranglerQueueInfo(output) {
+  const lines = output.split(/\r?\n/);
+  let queueName = "";
+  const producerWorkers = [];
+  const consumerWorkers = [];
+  let currentSection = null;
+  for (const rawLine of lines) {
+    const trimmed = rawLine.trim();
+    if (!trimmed) {
+      currentSection = null;
+      continue;
+    }
+    const queueMatch = trimmed.match(/^Queue Name:\s*(.+)$/i);
+    if (queueMatch) {
+      queueName = normalizeCell(queueMatch[1]);
+      currentSection = null;
+      continue;
+    }
+    const producerMatch = trimmed.match(/^Producers:\s*(.*)$/i);
+    if (producerMatch) {
+      producerWorkers.push(...extractWorkerNames(producerMatch[1]));
+      currentSection = producerMatch[1] ? null : "producers";
+      continue;
+    }
+    const consumerMatch = trimmed.match(/^Consumers:\s*(.*)$/i);
+    if (consumerMatch) {
+      consumerWorkers.push(...extractWorkerNames(consumerMatch[1]));
+      currentSection = consumerMatch[1] ? null : "consumers";
+      continue;
+    }
+    if (!currentSection) {
+      continue;
+    }
+    const extractedWorkers = extractWorkerNames(trimmed);
+    if (currentSection === "producers") {
+      producerWorkers.push(...extractedWorkers);
+    } else {
+      consumerWorkers.push(...extractedWorkers);
+    }
+  }
+  if (!queueName) {
+    return null;
+  }
+  return {
+    queueName,
+    producerWorkers: uniqueStrings(producerWorkers),
+    consumerWorkers: uniqueStrings(consumerWorkers)
+  };
+}
+function parseWranglerVersionBindings(jsonOutput) {
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonOutput);
+  } catch {
+    return [];
+  }
+  const bindings = extractBindingsArray(parsed);
+  if (!bindings) {
+    return [];
+  }
+  const rows = [];
+  for (const raw of bindings) {
+    const row = mapWranglerBindingToRow(raw);
+    if (row) {
+      rows.push(row);
+    }
+  }
+  return rows;
+}
+function extractBindingsArray(parsed) {
+  if (!parsed || typeof parsed !== "object") {
+    return null;
+  }
+  const root = parsed;
+  const bindings = root.resources?.bindings;
+  return Array.isArray(bindings) ? bindings : null;
+}
+function mapWranglerBindingToRow(raw) {
+  if (!raw || typeof raw !== "object") {
+    return null;
+  }
+  const binding = raw;
+  const type = typeof binding.type === "string" ? binding.type : "";
+  const bindingName = typeof binding.name === "string" ? binding.name : "";
+  if (!type || !bindingName) {
+    return null;
+  }
+  const mapped = mapWranglerBindingType(type, binding);
+  if (!mapped) {
+    return null;
+  }
+  return {
+    type: mapped.friendlyType,
+    bindingName,
+    resource: mapped.resource
+  };
+}
+function mapWranglerBindingType(type, binding) {
+  const stringField = (key) => typeof binding[key] === "string" ? binding[key] : "";
+  switch (type) {
+    case "kv_namespace":
+      return { friendlyType: "KV Namespace", resource: stringField("namespace_id") };
+    case "d1":
+      return { friendlyType: "D1 Database", resource: stringField("id") };
+    case "r2_bucket":
+      return { friendlyType: "R2 Bucket", resource: stringField("bucket_name") };
+    case "durable_object_namespace":
+      return {
+        friendlyType: "Durable Object Namespace",
+        resource: stringField("class_name")
+      };
+    case "queue":
+      return { friendlyType: "Queue", resource: stringField("queue_name") };
+    case "ratelimit":
+      return { friendlyType: "Rate Limiting", resource: stringField("namespace_id") };
+    case "service": {
+      const service = stringField("service") || binding.name;
+      const entrypoint = stringField("entrypoint");
+      return {
+        friendlyType: "Worker",
+        resource: entrypoint ? `${service}#${entrypoint}` : service
+      };
+    }
+    case "ai":
+      return { friendlyType: "AI", resource: "Workers AI" };
+    case "vectorize":
+      return { friendlyType: "Vectorize", resource: stringField("index_name") };
+    case "hyperdrive":
+      return { friendlyType: "Hyperdrive", resource: stringField("id") };
+    case "browser":
+      return { friendlyType: "Browser", resource: "Browser Rendering" };
+    case "analytics_engine":
+      return { friendlyType: "Analytics Engine", resource: stringField("dataset") };
+    case "send_email":
+      return {
+        friendlyType: "Send Email",
+        resource: stringField("destination_address") || stringField("name") || binding.name
+      };
+    case "mtls_certificate":
+      return { friendlyType: "mTLS Certificate", resource: stringField("certificate_id") };
+    case "dispatch_namespace":
+      return { friendlyType: "Dispatch Namespace", resource: stringField("namespace") };
+    case "workflow":
+      return {
+        friendlyType: "Workflow",
+        resource: stringField("workflow_name") || stringField("name")
+      };
+    case "pipeline":
+      return { friendlyType: "Pipeline", resource: stringField("pipeline") };
+    case "images":
+      return { friendlyType: "Images", resource: "Images" };
+    case "media":
+      return { friendlyType: "Media Transformations", resource: "Media Transformations" };
+    case "artifacts":
+      return { friendlyType: "Artifacts", resource: stringField("namespace") };
+    case "version_metadata":
+      return { friendlyType: "Version Metadata", resource: "Version Metadata" };
+    case "worker_loader":
+      return { friendlyType: "Worker Loader", resource: "Worker Loader" };
+    case "secrets_store_secret":
+      return {
+        friendlyType: "Secrets Store",
+        resource: `${stringField("store_id")}/${stringField("secret_name")}`
+      };
+    case "plain_text":
+    case "json":
+    case "secret_text":
+      return null;
+    default:
+      return { friendlyType: type, resource: stringField("id") || stringField("name") || "" };
+  }
+}
+async function inspectWorkerBindings(exec, options) {
+  const output = await runWranglerInspectionCommand(exec, ["wrangler", "versions", "view", options.versionId, "--name", options.workerName, "--json"], options, "Wrangler versions view failed");
+  return parseWranglerVersionBindings(output);
+}
+async function runWranglerInspectionCommand(exec, args, options, failureMessage) {
+  const result = await exec.exec("bunx", args, {
+    cwd: options.cwd,
+    env: {
+      ...process.env,
+      CLOUDFLARE_ACCOUNT_ID: options.accountId,
+      FORCE_COLOR: process.env.FORCE_COLOR ?? "0"
+    }
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr || result.stdout || failureMessage);
+  }
+  return `${result.stdout}
+${result.stderr}`;
+}
+async function inspectQueueAssociation(exec, options) {
+  const output = await runWranglerInspectionCommand(exec, ["wrangler", "queues", "info", options.queueName], options, "Wrangler queues info failed");
+  return parseWranglerQueueInfo(output);
+}
+function formatReference(target) {
+  return target.referenceLabels.length > 0 ? target.referenceLabels.join(", ") : "—";
+}
+function formatResource(target) {
+  return target.resource || "—";
+}
+function buildRowNotes(target, queueAssociation) {
+  const notes = [...target.notes];
+  if (queueAssociation) {
+    notes.push(`producers ${queueAssociation.producerWorkers.length}`);
+    notes.push(`consumers ${queueAssociation.consumerWorkers.length}`);
+  }
+  return uniqueStrings(notes);
+}
+async function inspectBindingAssociations(options) {
+  const targets = collectBindingAssociationTargets(options.config);
+  const warnings = [];
+  const bindingUsage = new Map;
+  const scannedWorkers = [];
+  const queueTargets = uniqueStrings(targets.map((target) => target.queueName).filter((queueName) => typeof queueName === "string" && queueName.length > 0));
+  const queueAssociations = new Map;
+  const workers = await account.workers(options.accountId, options.apiOptions);
+  for (const worker of workers) {
+    let versionId;
+    try {
+      const deployments = await account.workerDeployments(options.accountId, worker.name, options.apiOptions);
+      versionId = getActiveVersionId(deployments);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      warnings.push(`Could not resolve active deployment for ${worker.name}: ${message}`);
+      continue;
+    }
+    if (!versionId) {
+      continue;
+    }
+    scannedWorkers.push(worker.name);
+    try {
+      const bindings = await inspectWorkerBindings(options.exec, {
+        accountId: options.accountId,
+        workerName: worker.name,
+        versionId,
+        cwd: options.cwd
+      });
+      for (const binding of bindings) {
+        const key = buildAssociationKey(binding.type, binding.resource);
+        const connectedWorkers = bindingUsage.get(key) ?? new Set;
+        connectedWorkers.add(worker.name);
+        bindingUsage.set(key, connectedWorkers);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      warnings.push(`Could not inspect bindings for ${worker.name}: ${message}`);
+    }
+  }
+  for (const queueName of queueTargets) {
+    try {
+      const queueAssociation = await inspectQueueAssociation(options.exec, {
+        accountId: options.accountId,
+        queueName,
+        cwd: options.cwd
+      });
+      if (queueAssociation) {
+        queueAssociations.set(queueName, queueAssociation);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      warnings.push(`Could not inspect queue ${queueName}: ${message}`);
+    }
+  }
+  const rows = targets.map((target) => {
+    const queueAssociation = target.queueName ? queueAssociations.get(target.queueName) : undefined;
+    const directlyConnectedWorkers = Array.from(bindingUsage.get(target.key) ?? []);
+    const connectedWorkers = uniqueStrings([
+      ...directlyConnectedWorkers,
+      ...queueAssociation?.producerWorkers ?? [],
+      ...queueAssociation?.consumerWorkers ?? []
+    ]).sort((left, right) => left.localeCompare(right));
+    return {
+      reference: formatReference(target),
+      type: target.type,
+      resource: formatResource(target),
+      workerCount: connectedWorkers.length,
+      connectedWorkers,
+      notes: buildRowNotes(target, queueAssociation),
+      producerWorkers: queueAssociation?.producerWorkers,
+      consumerWorkers: queueAssociation?.consumerWorkers
+    };
+  });
+  return {
+    workerName: options.workerName ?? options.config.name,
+    rows,
+    targets: targets.length,
+    scannedWorkers,
+    warnings
+  };
+}
+
+// src/cli/commands/previews-support/theme.ts
+function shouldUseColor(options) {
+  return createCliTheme(options).useColor;
+}
+function formatRecordDate(date) {
+  return date ? date.toISOString().slice(0, 19).replace("T", " ") : "N/A";
+}
+function formatStatus(value, theme) {
+  switch (value) {
+    case "active":
+      return green(value, theme);
+    case "superseded":
+    case "reassigned":
+    case "orphaned":
+      return yellow(value, theme);
+    case "deleted":
+    case "rolled_back":
+      return red(value, theme);
+    default:
+      return value;
+  }
+}
+function formatOverviewStatus(value, theme) {
+  switch (value) {
+    case "ready":
+      return green(value, theme);
+    case "partial":
+      return yellow(value, theme);
+    case "missing":
+      return red(value, theme);
+    default:
+      return formatStatus(value, theme);
+  }
+}
+
+// src/cli/commands/previews-support/cleanup.ts
+function comparePreviewCleanupScopeNames(left, right) {
+  if (left === "preview" && right !== "preview") {
+    return 1;
+  }
+  if (left !== "preview" && right === "preview") {
+    return -1;
+  }
+  return left.localeCompare(right);
+}
+function buildPreviewCleanupTarget(scope, workerCandidatesByScope, environment) {
+  const strategies = new Set;
+  const workerNames = [...workerCandidatesByScope.get(scope) ?? []];
+  if (workerNames.length > 0) {
+    strategies.add("dedicated workers");
+  }
+  if (scope === "preview" && environment === "preview") {
+    strategies.add("default preview scope");
+  }
+  return {
+    scope,
+    strategies: Array.from(strategies),
+    workerNames
+  };
+}
+function buildPreviewCleanupTargets(workerCandidatesByScope, environment) {
+  const scopeNames = new Set;
+  for (const scope of workerCandidatesByScope.keys()) {
+    scopeNames.add(scope);
+  }
+  return Array.from(scopeNames).sort(comparePreviewCleanupScopeNames).map((scope) => buildPreviewCleanupTarget(scope, workerCandidatesByScope, environment));
+}
+function getPreviewCleanupResourceCandidateCount(result) {
+  return result.candidates.kv.length + result.candidates.d1.length + result.candidates.r2.length + result.candidates.queues.length + result.candidates.vectorize.length + result.candidates.hyperdrive.length;
+}
+function buildPreviewCleanupResourceSummary(result) {
+  return [
+    result.candidates.kv.length > 0 ? `KV ${result.candidates.kv.length}` : null,
+    result.candidates.d1.length > 0 ? `D1 ${result.candidates.d1.length}` : null,
+    result.candidates.r2.length > 0 ? `R2 ${result.candidates.r2.length}` : null,
+    result.candidates.queues.length > 0 ? `Queues ${result.candidates.queues.length}` : null,
+    result.candidates.vectorize.length > 0 ? `Vectorize ${result.candidates.vectorize.length}` : null,
+    result.candidates.hyperdrive.length > 0 ? `Hyperdrive ${result.candidates.hyperdrive.length}` : null
+  ].filter((segment) => segment !== null);
+}
+function logResolvedPreviewScopes(logger, targets, theme) {
+  if (targets.length === 0) {
+    logLine(logger, `${dim("preview scopes", theme)} ${dim("none discovered (--all)", theme)}`);
+    logLine(logger);
+    return;
+  }
+  logLine(logger, `${dim("preview scopes", theme)} ${green(targets.map((target) => target.scope).join(", "), theme)} ${dim("(--all)", theme)}`);
+  logLine(logger);
+}
+function logPreviewCleanupScopeBreakdown(logger, executions, theme) {
+  const scopedExecutions = executions.filter((execution) => execution.target);
+  if (scopedExecutions.length === 0) {
+    return;
+  }
+  logLine(logger, `${dim("scope breakdown", theme)}`);
+  for (const execution of scopedExecutions) {
+    const target = execution.target;
+    const strategies = target.strategies.length > 0 ? dim(`(${target.strategies.join(" + ")})`, theme) : "";
+    const summary = [
+      target.workerNames.length > 0 ? `Workers ${target.workerNames.length}` : null,
+      ...buildPreviewCleanupResourceSummary(execution.result)
+    ].filter((segment) => segment !== null);
+    logLine(logger, `  ${green(target.scope, theme)} ${strategies} ${dim("—", theme)} ${summary.length > 0 ? summary.join(" · ") : dim("none", theme)}`);
+  }
+  logLine(logger);
+}
+function showNoPreviewCleanupCandidatesHint(logger, selection, includeAll, theme) {
+  if (includeAll) {
+    logger.warn("No preview-only resources or dedicated preview Worker scripts were discovered across the live preview scopes Devflare could resolve. This usually means those previews were already cleaned up or the remaining previews only share stable Workers and shared account resources.");
+    return;
+  }
+  if (!selection?.identifier) {
+    return;
+  }
+  if (selection.source === "environment") {
+    logger.warn(`No preview-only resources or dedicated preview Worker scripts matched the default "${selection.identifier}" scope. If your previews use branch-style scopes such as "next" or "pr-1", rerun with --scope <name>, use --all, or set DEVFLARE_PREVIEW_BRANCH, DEVFLARE_PREVIEW_PR, or DEVFLARE_PREVIEW_IDENTIFIER.`);
+    return;
+  }
+  logger.warn(`No preview-only resources or dedicated preview Worker scripts matched the resolved "${selection.identifier}" scope. This usually means that scope was already cleaned up or the preview shares stable Workers without preview.scope() resources of its own.`);
+}
+
+// src/cli/commands/previews-support/render.ts
+function logWorkerFamilyHeader(logger, families, theme) {
+  const primaryFamily = families.find((family) => family.role === "primary") ?? families[0];
+  const relatedFamilies = families.filter((family) => family.role !== "primary");
+  logLine(logger, `${dim("worker family", theme)} ${green(primaryFamily?.baseName ?? "unknown", theme)}`);
+  if (relatedFamilies.length > 0) {
+    logLine(logger, `${dim("related workers", theme)} ${whiteDim(String(relatedFamilies.length), theme)}`);
+  }
+  logLine(logger);
+}
+function logSection(logger, title, records, columns, theme) {
+  for (const line of buildSectionLines(title, records, columns, theme)) {
+    logLine(logger, line);
+  }
+}
+function logLiveWorkerFamilyOverview(logger, families, workers, workersSubdomain, theme) {
+  const stableRows = buildStableWorkerRowsFromLiveWorkers(families, workers, workersSubdomain);
+  const previewScopeRows = buildPreviewScopeRowsFromLiveWorkers(families, workers, workersSubdomain);
+  logWorkerFamilyHeader(logger, families, theme);
+  logSection(logger, "Stable workers", stableRows, buildStableWorkerColumns(theme), theme);
+  logLine(logger);
+  if (previewScopeRows.length === 0) {
+    logLine(logger, dim("No dedicated preview scopes found for this worker family.", theme));
+  } else {
+    logSection(logger, "Preview scopes", previewScopeRows, buildPreviewScopeColumns(theme), theme);
+  }
+}
+function buildStableWorkerColumns(theme) {
+  return [
+    {
+      label: "Worker",
+      width: 34,
+      value: (row) => row.workerName
+    },
+    {
+      label: "Role",
+      width: 20,
+      value: (row) => row.role
+    },
+    {
+      label: "Status",
+      width: 8,
+      value: (row) => formatOverviewStatus(row.status, theme)
+    },
+    {
+      label: "Updated",
+      width: 19,
+      value: (row) => whiteDim(formatRecordDate(row.updatedAt), theme)
+    },
+    {
+      label: "URL",
+      value: (row) => row.url ?? "N/A"
+    }
+  ];
+}
+function buildPreviewScopeColumns(theme) {
+  return [
+    {
+      label: "Scope",
+      width: 18,
+      value: (row) => row.scope
+    },
+    {
+      label: "Strategy",
+      width: 18,
+      value: (row) => row.strategy
+    },
+    {
+      label: "Workers",
+      width: 7,
+      value: (row) => row.workersLabel
+    },
+    {
+      label: "Status",
+      width: 10,
+      value: (row) => formatOverviewStatus(row.status, theme)
+    },
+    {
+      label: "Updated",
+      width: 19,
+      value: (row) => whiteDim(formatRecordDate(row.updatedAt), theme)
+    },
+    {
+      label: "Notes",
+      width: 30,
+      value: (row) => row.notes ?? dim("—", theme)
+    },
+    {
+      label: "Entry URL",
+      value: (row) => row.entryUrl ?? "N/A"
+    }
+  ];
+}
+function buildSectionLines(title, records, columns, theme) {
+  if (records.length === 0) {
+    return [];
+  }
+  const widths = columns.map((column) => column.width);
+  const coloredTitle = title === "Preview scopes" ? cyanBold(title, theme) : title === "Stable workers" ? bold(title, theme) : yellowBold(title, theme);
+  return [
+    `${coloredTitle} ${dim(`(${records.length})`, theme)}`,
+    formatTableLine(columns.map((column) => dim(column.label, theme)), widths),
+    ...records.map((record) => formatTableLine(columns.map((column) => column.value(record)), widths))
+  ];
+}
+function showWorkerFamilyOverviewFromLiveWorkers(families, workers, workersSubdomain, logger, theme) {
+  logLine(logger);
+  logLiveWorkerFamilyOverview(logger, families, workers, workersSubdomain, theme);
+  logLine(logger);
+  logLine(logger, dim("Preview scopes are derived from live dedicated preview Worker names and the current config family.", theme));
+  logLine(logger, dim("Use `devflare previews cleanup --scope <name>` to delete one scope or `--all` to clean every discovered scope.", theme));
+  logLine(logger);
+}
+function showWorkspaceWorkerFamilyOverviewFromLiveWorkers(familyGroups, workers, workersSubdomain, logger, theme) {
+  logLine(logger);
+  logLine(logger, `${dim("configured worker families", theme)} ${whiteDim(String(familyGroups.length), theme)}`);
+  logLine(logger);
+  for (const [index, families] of familyGroups.entries()) {
+    if (index > 0) {
+      logLine(logger);
+    }
+    logLiveWorkerFamilyOverview(logger, families, workers, workersSubdomain, theme);
+  }
+  logLine(logger);
+  logLine(logger, dim("Preview scopes are derived from live dedicated preview Worker names and each discovered config family.", theme));
+  logLine(logger, dim("Run inside a configured package or pass `--config <path>` to narrow the summary or clean one family.", theme));
+  logLine(logger);
+}
+function buildBindingAssociationColumns(theme) {
+  return [
+    {
+      label: "Reference",
+      width: 24,
+      value: (row) => row.reference
+    },
+    {
+      label: "Type",
+      width: 24,
+      value: (row) => row.type
+    },
+    {
+      label: "Resource",
+      width: 36,
+      value: (row) => row.resource
+    },
+    {
+      label: "Workers",
+      width: 7,
+      value: (row) => String(row.workerCount)
+    },
+    {
+      label: "Notes",
+      width: 28,
+      value: (row) => row.notes.length > 0 ? row.notes.join(" · ") : dim("—", theme)
+    },
+    {
+      label: "Connected workers",
+      value: (row) => row.connectedWorkers.length > 0 ? row.connectedWorkers.join(", ") : dim("—", theme)
+    }
+  ];
+}
+function showBindingAssociations(logger, inspection, theme) {
+  logLine(logger);
+  logLine(logger, `${dim("worker family", theme)} ${green(inspection.workerName, theme)}`);
+  logLine(logger, `${dim("resolved targets", theme)} ${whiteDim(String(inspection.targets), theme)}`);
+  logLine(logger, `${dim("active deployments scanned", theme)} ${whiteDim(String(inspection.scannedWorkers.length), theme)}`);
+  if (inspection.rows.length === 0) {
+    logLine(logger);
+    logLine(logger, dim("No binding or resource targets were resolved from the current config.", theme));
+    logLine(logger);
+    return;
+  }
+  logLine(logger);
+  logSection(logger, "Bindings", inspection.rows, buildBindingAssociationColumns(theme), theme);
+  if (inspection.warnings.length > 0) {
+    logLine(logger);
+    for (const warning of inspection.warnings) {
+      logger.warn(warning);
+    }
+  }
+  logLine(logger);
+}
+
+// src/cli/commands/previews-support/types.ts
+var PREVIEW_SUBCOMMANDS = ["list", "bindings", "cleanup"];
+
+// src/cli/commands/previews.ts
+var CLI_API_OPTIONS = {
+  timeout: 1e4
+};
+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 sortConfiguredWorkerFamilies(families) {
+  return [...families].sort(compareConfiguredWorkerFamilies);
+}
+function resolvePrimaryWorkerFamilyName(families) {
+  return families.find((family) => family.role === "primary")?.baseName ?? families[0]?.baseName;
+}
+function shouldReplaceConfiguredWorkerFamily(existing, candidate) {
+  return !existing || candidate.role === "primary" && existing.role !== "primary";
+}
+function mergeConfiguredWorkerFamilies(existing, candidates) {
+  const merged = new Map(existing.map((family) => [family.baseName, family]));
+  for (const candidate of candidates) {
+    if (shouldReplaceConfiguredWorkerFamily(merged.get(candidate.baseName), candidate)) {
+      merged.set(candidate.baseName, candidate);
+    }
+  }
+  return sortConfiguredWorkerFamilies(Array.from(merged.values()));
+}
+function comparePreviewConfiguredFamilyGroups(left, right) {
+  const leftName = resolvePrimaryWorkerFamilyName(left.families) ?? left.configPath ?? "";
+  const rightName = resolvePrimaryWorkerFamilyName(right.families) ?? right.configPath ?? "";
+  return leftName.localeCompare(rightName);
+}
+function upsertPreviewConfiguredFamilyGroup(groups, candidate) {
+  const primaryFamilyName = resolvePrimaryWorkerFamilyName(candidate.families);
+  const groupKey = primaryFamilyName ?? candidate.configPath ?? `group-${groups.size}`;
+  const existing = groups.get(groupKey);
+  if (!existing) {
+    groups.set(groupKey, {
+      ...candidate,
+      families: sortConfiguredWorkerFamilies(candidate.families)
+    });
+    return;
+  }
+  groups.set(groupKey, {
+    accountId: existing.accountId ?? candidate.accountId,
+    configPath: existing.configPath ?? candidate.configPath,
+    families: mergeConfiguredWorkerFamilies(existing.families, candidate.families)
+  });
+}
+async function discoverPreviewListConfigs(cwd, configFile, environment) {
+  const groups = new Map;
+  const accountIds = new Set;
+  const loadAndCollect = async (candidateConfigFile) => {
+    try {
+      const config = await loadConfig({ cwd, configFile: candidateConfigFile });
+      const families = collectConfiguredWorkerFamilies(config, environment);
+      const accountId = config.accountId?.trim() || undefined;
+      if (accountId) {
+        accountIds.add(accountId);
+      }
+      upsertPreviewConfiguredFamilyGroup(groups, {
+        accountId,
+        configPath: candidateConfigFile,
+        families
+      });
+      return true;
+    } catch (error) {
+      if (error instanceof ConfigNotFoundError) {
+        return false;
+      }
+      throw error;
+    }
+  };
+  if (configFile) {
+    await loadAndCollect(configFile);
+  } else {
+    const directConfigPath = await resolveConfigPath(cwd);
+    const loadedDirectly = directConfigPath ? await loadAndCollect() : false;
+    if (!loadedDirectly) {
+      const configPaths = await findConfigPathsUnderDirectory(cwd);
+      for (const configPath of configPaths) {
+        await loadAndCollect(configPath);
+      }
+    }
+  }
+  return {
+    accountIds: Array.from(accountIds).sort((left, right) => left.localeCompare(right)),
+    familyGroups: Array.from(groups.values()).sort(comparePreviewConfiguredFamilyGroups)
+  };
+}
+function isPreviewSubcommand(value) {
+  return PREVIEW_SUBCOMMANDS.includes(value);
+}
+function resolvePreviewScopeSelection(parsed, environment) {
+  const explicitScope = asOptionalString(parsed.options.scope) || asOptionalString(parsed.options.identifier);
+  if (explicitScope) {
+    return {
+      identifier: resolvePreviewIdentifier({ identifier: explicitScope }).identifier,
+      source: "scope-option"
+    };
+  }
+  const resolved = resolvePreviewIdentifier({
+    environment,
+    env: process.env
+  });
+  return {
+    identifier: resolved.identifier,
+    source: resolved.source
+  };
+}
+function formatPreviewScopeSource(source) {
+  switch (source) {
+    case "scope-option":
+      return "--scope";
+    case "identifier":
+      return "explicit identifier";
+    case "env-identifier":
+      return "DEVFLARE_PREVIEW_IDENTIFIER";
+    case "env-pr":
+      return "DEVFLARE_PREVIEW_PR";
+    case "env-branch":
+      return "DEVFLARE_PREVIEW_BRANCH";
+    case "environment":
+      return "default preview scope";
+    default:
+      return "no explicit preview scope";
+  }
+}
+function logResolvedPreviewScope(logger, selection, theme) {
+  if (!selection.identifier) {
+    return;
+  }
+  logLine(logger, `${dim("preview scope", theme)} ${green(selection.identifier, theme)} ${dim(`(${formatPreviewScopeSource(selection.source)})`, theme)}`);
+  logLine(logger);
+}
+async function loadLocalConfig(cwd, configFile, needsConfig) {
+  if (!needsConfig) {
+    return;
+  }
+  if (!configFile) {
+    const resolvedConfigPath = await resolveConfigPath(cwd);
+    if (!resolvedConfigPath) {
+      return;
+    }
+    try {
+      const config = await loadConfig({
+        cwd
+      });
+      return {
+        accountId: config.accountId,
+        name: config.name
+      };
+    } catch (error) {
+      if (error instanceof ConfigNotFoundError) {
+        return;
+      }
+      throw error;
+    }
+  }
+  try {
+    const config = await loadConfig({
+      cwd,
+      configFile
+    });
+    return {
+      accountId: config.accountId,
+      name: config.name
+    };
+  } catch (error) {
+    if (error instanceof ConfigNotFoundError) {
+      return;
+    }
+    throw error;
+  }
+}
+async function resolveAccountId(parsed, config) {
+  return resolveCloudflareAccountId({
+    explicitAccountId: asOptionalString(parsed.options.account),
+    configuredAccountId: config?.accountId,
+    apiOptions: CLI_API_OPTIONS
+  });
+}
+function resolveWorkerName(parsed, config) {
+  const selection = resolveNamedSelection({
+    explicitValue: asOptionalString(parsed.options.worker),
+    configuredValue: config?.name
+  });
+  return {
+    workerName: selection.value,
+    source: selection.source
+  };
+}
+async function resolveContext(parsed, options, subcommand) {
+  const cwd = options.cwd ?? process.cwd();
+  const configFile = asOptionalString(parsed.options.config);
+  const explicitAccountId = asOptionalString(parsed.options.account);
+  const environment = asOptionalString(parsed.options.env);
+  if (subcommand === "list") {
+    const listDiscovery = await discoverPreviewListConfigs(cwd, configFile, environment);
+    if (!explicitAccountId && listDiscovery.accountIds.length > 1) {
+      throw new Error("Multiple Cloudflare account ids were discovered across local Devflare configs. Pass --account to select one account explicitly for `devflare previews`.");
+    }
+    const accountId2 = await resolveCloudflareAccountId({
+      explicitAccountId,
+      configuredAccountId: listDiscovery.accountIds[0],
+      apiOptions: CLI_API_OPTIONS
+    });
+    if (!accountId2) {
+      throw new Error("No Cloudflare account could be resolved. Use --account or configure accountId in devflare.config.*.");
+    }
+    return {
+      accountId: accountId2,
+      workerName: undefined,
+      workerNameSource: "none",
+      config: undefined,
+      listDiscovery
+    };
+  }
+  const needsConfig = subcommand === "cleanup" || subcommand === "bindings" || !explicitAccountId;
+  const config = await loadLocalConfig(cwd, configFile, needsConfig);
+  if (needsConfig && !config) {
+    throw new Error("Preview commands now inspect and clean dedicated preview workers for the current package. Run inside a configured package or pass --config <path>.");
+  }
+  const accountId = await resolveAccountId(parsed, config);
+  const workerSelection = resolveWorkerName(parsed, config);
+  if (!accountId) {
+    throw new Error("No Cloudflare account could be resolved. Use --account or configure accountId in devflare.config.*.");
+  }
+  return {
+    accountId,
+    workerName: workerSelection.workerName,
+    workerNameSource: workerSelection.source,
+    config
+  };
+}
+async function runBindingsSubcommand(parsed, context, logger, options, environment, configFile, theme) {
+  const cwd = options.cwd ?? process.cwd();
+  const previewScope = resolvePreviewScopeSelection(parsed, environment);
+  logResolvedPreviewScope(logger, previewScope, theme);
+  const resolvedConfig = await loadResolvedConfig({
+    cwd,
+    configFile,
+    environment,
+    identifier: previewScope.identifier,
+    accountId: context.accountId
+  });
+  const deps = await getDependencies();
+  const inspection = await inspectBindingAssociations({
+    accountId: context.accountId,
+    config: resolvedConfig,
+    workerName: context.workerName ?? resolvedConfig.name,
+    cwd,
+    exec: deps.exec,
+    apiOptions: CLI_API_OPTIONS
+  });
+  showBindingAssociations(logger, inspection, theme);
+  return { exitCode: 0 };
+}
+async function runCleanupSubcommand(parsed, context, logger, options, environment, configFile, includeAll, theme) {
+  const cwd = options.cwd ?? process.cwd();
+  const resolvedEnvironment = environment ?? "preview";
+  const explicitScope = asOptionalString(parsed.options.scope) || asOptionalString(parsed.options.identifier);
+  if (includeAll && explicitScope) {
+    logger.error("Choose either --scope <name> or --all for preview cleanup, not both.");
+    return { exitCode: 1 };
+  }
+  const previewScope = resolvePreviewScopeSelection(parsed, resolvedEnvironment);
+  const config = await loadConfig({ cwd, configFile });
+  const configuredFamilies = collectConfiguredWorkerFamilies(config, resolvedEnvironment);
+  const liveWorkers = await account.workers(context.accountId, CLI_API_OPTIONS);
+  const workerCandidatesByScope = buildPreviewWorkerCandidatesByScope(configuredFamilies, liveWorkers);
+  const cleanupTargets = includeAll ? buildPreviewCleanupTargets(workerCandidatesByScope, resolvedEnvironment) : previewScope.identifier ? [buildPreviewCleanupTarget(previewScope.identifier, workerCandidatesByScope, resolvedEnvironment)] : [];
+  const cleanupRuns = includeAll ? cleanupTargets.map((target) => ({
+    scope: target.scope,
+    target
+  })) : previewScope.identifier ? [{
+    scope: previewScope.identifier,
+    target: cleanupTargets[0]
+  }] : [];
+  const applyCleanup = parsed.options.apply === true;
+  const executions = [];
+  if (includeAll) {
+    logResolvedPreviewScopes(logger, cleanupTargets, theme);
+  } else {
+    logResolvedPreviewScope(logger, previewScope, theme);
+  }
+  for (const cleanupRun of cleanupRuns) {
+    if (applyCleanup) {
+      const orderedWorkerNames = cleanupRun.target ? orderPreviewWorkerNamesForDeletion(cleanupRun.target.workerNames, cleanupRun.target.scope, configuredFamilies) : [];
+      for (const workerName of orderedWorkerNames) {
+        await account.deleteWorker(context.accountId, workerName, CLI_API_OPTIONS);
+      }
+    }
+    const result = await cleanupPreviewScopedResources(config, {
+      environment: resolvedEnvironment,
+      identifier: cleanupRun.scope,
+      accountId: context.accountId,
+      apply: applyCleanup
+    });
+    executions.push({
+      target: cleanupRun.target,
+      result
+    });
+  }
+  const totalWorkerCandidates = executions.reduce((sum, execution) => {
+    return sum + (execution.target?.workerNames.length ?? 0);
+  }, 0);
+  const totalKvCandidates = executions.reduce((sum, execution) => sum + execution.result.candidates.kv.length, 0);
+  const totalD1Candidates = executions.reduce((sum, execution) => sum + execution.result.candidates.d1.length, 0);
+  const totalR2Candidates = executions.reduce((sum, execution) => sum + execution.result.candidates.r2.length, 0);
+  const totalQueueCandidates = executions.reduce((sum, execution) => sum + execution.result.candidates.queues.length, 0);
+  const totalVectorizeCandidates = executions.reduce((sum, execution) => sum + execution.result.candidates.vectorize.length, 0);
+  const totalHyperdriveCandidates = executions.reduce((sum, execution) => sum + execution.result.candidates.hyperdrive.length, 0);
+  const totalResourceCandidates = executions.reduce((sum, execution) => {
+    return sum + getPreviewCleanupResourceCandidateCount(execution.result);
+  }, 0);
+  const totalCandidates = totalWorkerCandidates + totalResourceCandidates;
+  const scopeCountSuffix = cleanupRuns.length > 0 ? ` across ${cleanupRuns.length} preview scope${cleanupRuns.length === 1 ? "" : "s"}` : "";
+  logger.success(applyCleanup ? `Deleted ${totalCandidates} preview-only cleanup candidate${totalCandidates === 1 ? "" : "s"}${scopeCountSuffix}` : `Preview cleanup dry run complete with ${totalCandidates} candidate${totalCandidates === 1 ? "" : "s"}${scopeCountSuffix}`);
+  const resourceSummary = [
+    totalWorkerCandidates > 0 ? `Workers ${totalWorkerCandidates}` : null,
+    totalKvCandidates > 0 ? `KV ${totalKvCandidates}` : null,
+    totalD1Candidates > 0 ? `D1 ${totalD1Candidates}` : null,
+    totalR2Candidates > 0 ? `R2 ${totalR2Candidates}` : null,
+    totalQueueCandidates > 0 ? `Queues ${totalQueueCandidates}` : null,
+    totalVectorizeCandidates > 0 ? `Vectorize ${totalVectorizeCandidates}` : null,
+    totalHyperdriveCandidates > 0 ? `Hyperdrive ${totalHyperdriveCandidates}` : null
+  ].filter((segment) => segment !== null);
+  if (resourceSummary.length > 0) {
+    logger.info(`Candidates: ${resourceSummary.join(" · ")}`);
+  } else {
+    logger.info("Candidates: none");
+    showNoPreviewCleanupCandidatesHint(logger, previewScope, includeAll, theme);
+  }
+  if (includeAll || executions.some((execution) => Boolean(execution.target?.workerNames.length))) {
+    logPreviewCleanupScopeBreakdown(logger, executions, theme);
+  }
+  const warnings = Array.from(new Set(executions.flatMap((execution) => execution.result.warnings)));
+  for (const warning of warnings) {
+    logger.warn(warning);
+  }
+  return { exitCode: 0 };
+}
+async function runListSubcommand(context, logger, theme) {
+  const discoveredFamilyGroups = context.listDiscovery?.familyGroups ?? [];
+  if (discoveredFamilyGroups.length === 0) {
+    throw new Error("Preview listing needs a resolvable devflare config in the current package or workspace so Devflare can identify worker families.");
+  }
+  const matchingFamilyGroups = discoveredFamilyGroups.filter((group) => {
+    return !group.accountId || group.accountId === context.accountId;
+  });
+  if (matchingFamilyGroups.length === 0) {
+    throw new Error(`No configured preview worker families matched Cloudflare account ${context.accountId}. Pass --account or --config <path> to narrow the selection.`);
+  }
+  const liveWorkers = await account.workers(context.accountId, CLI_API_OPTIONS);
+  const workersSubdomain = await account.workersSubdomain(context.accountId, CLI_API_OPTIONS);
+  if (matchingFamilyGroups.length === 1) {
+    showWorkerFamilyOverviewFromLiveWorkers(matchingFamilyGroups[0].families, liveWorkers, workersSubdomain, logger, theme);
+    return { exitCode: 0 };
+  }
+  showWorkspaceWorkerFamilyOverviewFromLiveWorkers(matchingFamilyGroups.map((group) => group.families), liveWorkers, workersSubdomain, logger, theme);
+  return { exitCode: 0 };
+}
+function resolvePreviewSubcommand(rawSubcommand) {
+  if (!rawSubcommand) {
+    return;
+  }
+  if (isPreviewSubcommand(rawSubcommand)) {
+    return rawSubcommand;
+  }
+  return;
+}
+async function runPreviewsCommand(parsed, logger, options) {
+  const isAuth = await account.isAuthenticated();
+  if (!isAuth) {
+    logger.error("Not authenticated with Cloudflare");
+    logger.info("Run `devflare login` first.");
+    return { exitCode: 1 };
+  }
+  const rawSubcommand = parsed.args[0];
+  const subcommand = resolvePreviewSubcommand(rawSubcommand) ?? "list";
+  const includeAll = parsed.options.all === true;
+  const theme = {
+    useColor: shouldUseColor(parsed.options)
+  };
+  if (rawSubcommand && !resolvePreviewSubcommand(rawSubcommand)) {
+    logger.error(`Unknown previews subcommand: ${rawSubcommand}`);
+    logger.info(`Available previews subcommands: ${PREVIEW_SUBCOMMANDS.join(", ")}`);
+    return { exitCode: 1 };
+  }
+  try {
+    const context = await resolveContext(parsed, options, subcommand);
+    const environment = asOptionalString(parsed.options.env);
+    const configFile = asOptionalString(parsed.options.config);
+    switch (subcommand) {
+      case "bindings":
+        return runBindingsSubcommand(parsed, context, logger, options, environment, configFile, theme);
+      case "cleanup":
+        return runCleanupSubcommand(parsed, context, logger, options, environment, configFile, includeAll, theme);
+      case "list":
+      default:
+        return runListSubcommand(context, logger, theme);
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(error.message);
+      return { exitCode: 1 };
+    }
+    throw error;
+  }
+}
+export {
+  runPreviewsCommand
+};