Cross-Cluster Comparison

async () => {
  // Get all clusters
  const clusters = await platform.request({
    method: "GET", path: "/v1/clusters"
  }).then(r => r.body.data);

  const kube = (clusterId, path) => platform.request({
    method: "GET",
    path: `/v1/clusters/${clusterId}/kube_proxy/${path}`,
  }).then(r => r.body).catch(() => null);

  // Parallel fetch across all clusters
  const results = await Promise.all(clusters.map(async (cluster) => {
    const [nodes, version] = await Promise.all([
      kube(cluster.id, "api/v1/nodes"),
      kube(cluster.id, "version"),
    ]);

    if (!nodes) return { cluster: cluster.name, status: "unreachable" };

    return {
      cluster: cluster.name,
      k8s_version: version?.gitVersion,
      nodes: nodes.items.map(n => ({
        name: n.metadata.name,
        kubelet: n.status.nodeInfo.kubeletVersion,
        os: n.status.nodeInfo.osImage,
        runtime: n.status.nodeInfo.containerRuntimeVersion,
        kernel: n.status.nodeInfo.kernelVersion,
      })),
    };
  }));

  // Find drift
  const versions = [...new Set(results.filter(r => r.k8s_version).map(r => r.k8s_version))];
  return {
    cluster_count: clusters.length,
    unique_k8s_versions: versions,
    drift_detected: versions.length > 1,
    clusters: results,
  };
}

async () => {
  const clusters = await platform.request({
    method: "GET", path: "/v1/clusters"
  }).then(r => r.body.data);

  const kube = (clusterId, path) => platform.request({
    method: "GET",
    path: `/v1/clusters/${clusterId}/kube_proxy/${path}`,
  }).then(r => r.body).catch(() => null);

  const results = await Promise.all(clusters.map(async (cluster) => {
    const pods = await kube(cluster.id, "api/v1/pods");
    if (!pods) return { cluster: cluster.name, images: [] };

    // Deduplicate images
    const images = [...new Set(
      pods.items.flatMap(p =>
        p.spec.containers.map(c => c.image)
      )
    )].sort();

    return { cluster: cluster.name, images };
  }));

  // Find images that differ across clusters
  const allImages = new Map();
  for (const r of results) {
    for (const img of r.images) {
      const name = img.split(":")[0];
      if (!allImages.has(name)) allImages.set(name, new Map());
      allImages.get(name).set(r.cluster, img);
    }
  }

  const drift = [];
  for (const [name, clusterVersions] of allImages) {
    const tags = [...new Set(clusterVersions.values())];
    if (tags.length > 1) {
      drift.push({ image: name, versions: Object.fromEntries(clusterVersions) });
    }
  }

  return { drift_count: drift.length, image_drift: drift };
}

async () => {
  const clusters = await platform.request({
    method: "GET", path: "/v1/clusters"
  }).then(r => r.body.data);

  const kube = (clusterId, path) => platform.request({
    method: "GET",
    path: `/v1/clusters/${clusterId}/kube_proxy/${path}`,
  }).then(r => r.body).catch(() => null);

  const results = await Promise.all(clusters.map(async (cluster) => {
    const crds = await kube(cluster.id, "apis/apiextensions.k8s.io/v1/customresourcedefinitions");
    return {
      cluster: cluster.name,
      crds: crds?.items.map(c => c.metadata.name).sort() || [],
    };
  }));

  // Find CRDs unique to specific clusters
  const allCrds = new Set(results.flatMap(r => r.crds));
  const missing = [];
  for (const crd of allCrds) {
    const present = results.filter(r => r.crds.includes(crd)).map(r => r.cluster);
    if (present.length < results.length) {
      const absent = results.filter(r => !r.crds.includes(crd)).map(r => r.cluster);
      missing.push({ crd, present_in: present, missing_from: absent });
    }
  }

  return { total_unique_crds: allCrds.size, inconsistencies: missing };
}