@salesforce/afv-skills 1.60.0 → 1.62.0

package/skills/crm-analytics-wave-generate/scripts/find_unused_dataset_fields.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+// Given a dataset name, list every XMD field that no deployed dashboard SAQL references.
+// Caveat: aggregateflex steps, multi-dataset SAQL, and archived app dashboards are out of scope.
+// Usage: node scripts/find_unused_dataset_fields.js <alias> <datasetName>
+
+const { execSync, execFileSync } = require("child_process");
+
+function getOrgCredentials(alias) {
+  const result = execFileSync('sf', ['org', 'display', '-o', alias, '--json'], { encoding: "utf8" });
+  const json = JSON.parse(result);
+  return { accessToken: json.result.accessToken, instanceUrl: json.result.instanceUrl };
+}
+
+function apiFetch(instanceUrl, accessToken, apiPath) {
+  const url = `${instanceUrl}${apiPath}`;
+  const args = ["-s", "-H", `Authorization: Bearer ${accessToken}`, "-w", "\\nHTTP_STATUS:%{http_code}", url];
+  const raw = execSync(`curl ${args.map(a => `'${String(a).replace(/'/g, "'\\''")}'`).join(" ")}`, {
+    encoding: "utf8", maxBuffer: 20 * 1024 * 1024,
+  });
+  const parts = raw.split("\nHTTP_STATUS:");
+  const httpStatus = parseInt(parts[1] || "0", 10);
+  if (httpStatus < 200 || httpStatus >= 300) {
+    throw new Error(`HTTP ${httpStatus} on GET ${apiPath}: ${parts[0]}`);
+  }
+  return JSON.parse(parts[0]);
+}
+
+function decodeHtmlEntities(s) {
+  let prev = null;
+  while (prev !== s) {
+    prev = s;
+    s = s.replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, '&');
+  }
+  return s;
+}
+
+const [,, alias, datasetName] = process.argv;
+if (!alias || !datasetName) {
+  console.error("Usage: node find_unused_dataset_fields.js <alias> <datasetName>");
+  process.exit(1);
+}
+
+const { accessToken, instanceUrl } = getOrgCredentials(alias);
+
+// Fetch dataset XMD
+const datasets = apiFetch(instanceUrl, accessToken, "/services/data/v59.0/wave/datasets");
+const dataset = (datasets.datasets || []).find(d => d.name === datasetName || d.developerName === datasetName);
+if (!dataset) {
+  console.error(`Dataset "${datasetName}" not found.`);
+  process.exit(1);
+}
+
+const versionId = dataset.currentVersionId;
+const xmdResult = apiFetch(instanceUrl, accessToken,
+  `/services/data/v59.0/wave/datasets/${dataset.id}/versions/${versionId}/xmd`
+);
+const xmd = xmdResult.xmd || xmdResult;
+
+const allFields = [
+  ...(xmd.dimensions || []).map(d => d.fieldName || d.name),
+  ...(xmd.measures || []).map(m => m.fieldName || m.name),
+  ...(xmd.dates || []).map(d => d.fieldName || d.name),
+];
+
+// Collect all SAQL from deployed dashboards
+const dashboards = apiFetch(instanceUrl, accessToken, "/services/data/v59.0/wave/dashboards");
+let allSaql = "";
+
+for (const dash of (dashboards.dashboards || [])) {
+  try {
+    const detail = apiFetch(instanceUrl, accessToken, `/services/data/v59.0/wave/dashboards/${dash.id}`);
+    const steps = detail.state?.steps || {};
+    for (const step of Object.values(steps)) {
+      if (step.query) allSaql += " " + decodeHtmlEntities(step.query);
+    }
+  } catch {
+    // Skip inaccessible dashboards
+  }
+}
+
+// Check which fields are referenced
+const unusedFields = allFields.filter(field => {
+  const escaped = field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return !new RegExp(escaped).test(allSaql);
+});
+
+const usedFields = allFields.filter(f => !unusedFields.includes(f));
+
+console.log(JSON.stringify({
+  datasetName,
+  totalFields: allFields.length,
+  usedCount: usedFields.length,
+  unusedCount: unusedFields.length,
+  unusedFields,
+  note: "aggregateflex steps, multi-dataset SAQL, and archived app dashboards are not scanned",
+}, null, 2));

package/skills/crm-analytics-wave-generate/scripts/gen_synthetic_dataset.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+// Schema-driven synthetic data generator. Reads live XMD, classifies each column by name pattern
+// (*Id → id, *Industry/*Type/*Status → category, *Year/*Month → date, *Amount/*Revenue/*Count → numeric),
+// renames dotted fields to underscored, writes CSV + Wave-compatible metadata.json.
+// Default output dataset: <sourceDatasetName>_Synthetic
+// Usage: node scripts/gen_synthetic_dataset.js <alias> <sourceDatasetName>
+
+const { execSync, execFileSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+function getOrgCredentials(alias) {
+  const result = execFileSync('sf', ['org', 'display', '-o', alias, '--json'], { encoding: "utf8" });
+  const json = JSON.parse(result);
+  return { accessToken: json.result.accessToken, instanceUrl: json.result.instanceUrl };
+}
+
+function apiFetch(instanceUrl, accessToken, apiPath) {
+  const url = `${instanceUrl}${apiPath}`;
+  const args = ["-s", "-H", `Authorization: Bearer ${accessToken}`, "-w", "\\nHTTP_STATUS:%{http_code}", url];
+  const raw = execSync(`curl ${args.map(a => `'${String(a).replace(/'/g, "'\\''")}'`).join(" ")}`, {
+    encoding: "utf8", maxBuffer: 10 * 1024 * 1024,
+  });
+  const parts = raw.split("\nHTTP_STATUS:");
+  const httpStatus = parseInt(parts[1] || "0", 10);
+  if (httpStatus < 200 || httpStatus >= 300) {
+    throw new Error(`HTTP ${httpStatus} on GET ${apiPath}: ${parts[0]}`);
+  }
+  return JSON.parse(parts[0]);
+}
+
+function classifyField(name) {
+  const n = name.toLowerCase();
+  if (/id$/.test(n)) return "id";
+  if (/(industry|type|status|stage|source|region|category|priority)/.test(n)) return "category";
+  if (/(year|month|quarter)/.test(n)) return "date_part";
+  if (/(amount|revenue|count|qty|quantity|size|value|total|sum)/.test(n)) return "numeric";
+  return "text";
+}
+
+function generateValue(fieldName, type, rowIndex) {
+  switch (type) {
+    case "id": return `00Q${String(rowIndex).padStart(15, "0")}`;
+    case "category": {
+      const categories = ["Tech", "Finance", "Healthcare", "Retail", "Manufacturing"];
+      return categories[rowIndex % categories.length];
+    }
+    case "date_part": return String(2020 + (rowIndex % 5));
+    case "numeric": return String(Math.round(10000 + rowIndex * 1337.7));
+    default: return `Value_${rowIndex % 10}`;
+  }
+}
+
+const [,, alias, sourceDatasetName] = process.argv;
+if (!alias || !sourceDatasetName) {
+  console.error("Usage: node gen_synthetic_dataset.js <alias> <sourceDatasetName>");
+  process.exit(1);
+}
+
+const { accessToken, instanceUrl } = getOrgCredentials(alias);
+
+// Fetch dataset and XMD
+const datasets = apiFetch(instanceUrl, accessToken, "/services/data/v59.0/wave/datasets");
+const dataset = (datasets.datasets || []).find(d => d.name === sourceDatasetName || d.developerName === sourceDatasetName);
+if (!dataset) {
+  console.error(`Dataset "${sourceDatasetName}" not found.`);
+  process.exit(1);
+}
+
+const versionId = dataset.currentVersionId;
+const xmdResult = apiFetch(instanceUrl, accessToken,
+  `/services/data/v59.0/wave/datasets/${dataset.id}/versions/${versionId}/xmd`
+);
+const xmd = xmdResult.xmd || xmdResult;
+
+// Collect fields from XMD
+const fields = [];
+const dimensions = xmd.dimensions || [];
+const measures = xmd.measures || [];
+const dates = xmd.dates || [];
+
+dimensions.forEach(d => fields.push({ name: d.fieldName || d.name, type: "text" }));
+measures.forEach(m => fields.push({ name: m.fieldName || m.name, type: "numeric" }));
+dates.forEach(d => fields.push({ name: d.fieldName || d.name, type: "date_part" }));
+
+if (fields.length === 0) {
+  console.error("No fields found in XMD. Cannot generate synthetic data.");
+  process.exit(1);
+}
+
+// Rename dotted field names to underscored
+const sanitized = fields.map(f => ({
+  ...f,
+  name: f.name.replace(/\./g, "_"),
+  originalName: f.name,
+}));
+
+const ROW_COUNT = 50;
+const headers = sanitized.map(f => f.name);
+const rows = [headers.join(",")];
+for (let i = 0; i < ROW_COUNT; i++) {
+  const row = sanitized.map(f => {
+    const val = generateValue(f.name, f.type === "text" ? classifyField(f.name) : f.type, i);
+    return val.includes(",") ? `"${val}"` : val;
+  });
+  rows.push(row.join(","));
+}
+
+const outputDir = path.join(process.cwd(), "synthetic_data");
+fs.mkdirSync(outputDir, { recursive: true });
+
+const csvPath = path.join(outputDir, `${sourceDatasetName}_Synthetic.csv`);
+const metaPath = path.join(outputDir, `${sourceDatasetName}_Synthetic_metadata.json`);
+
+fs.writeFileSync(csvPath, rows.join("\n"), "utf8");
+
+// Wave-compatible metadata.json
+const metadata = {
+  fileFormat: { charsetName: "UTF-8", fieldsDelimitedBy: ",", linesTerminatedBy: "\n" },
+  objects: [{
+    connector: "CSV",
+    fullyQualifiedName: `${sourceDatasetName}_Synthetic`,
+    label: `${sourceDatasetName} Synthetic`,
+    name: `${sourceDatasetName}_Synthetic`,
+    fields: sanitized.map(f => ({
+      fullyQualifiedName: f.name,
+      name: f.name,
+      label: f.name,
+      type: f.type === "numeric" ? "Numeric" : "Text",
+      ...(f.type === "numeric" ? { precision: 18, scale: 2, defaultValue: "0" } : { length: 255 }),
+    })),
+  }],
+};
+
+fs.writeFileSync(metaPath, JSON.stringify(metadata, null, 2), "utf8");
+
+console.log(JSON.stringify({ csvPath, metaPath, rowCount: ROW_COUNT, fieldCount: fields.length }));

package/skills/crm-analytics-wave-generate/scripts/patch_t_oppo_view.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+// Full-cycle PATCH template: GET dashboard state → decodeAll every step query → merge dark theme → PATCH.
+// Use as the canonical pattern for future dashboard PATCH scripts.
+// Edit DASH_ID and THEME constants before running.
+// Usage: node scripts/patch_t_oppo_view.js <alias>
+
+const { execSync, execFileSync } = require("child_process");
+
+// ── Edit these constants before running ──────────────────────────────────────
+const DASH_ID = "0FK000000000000AAA";  // Wave Dashboard 18-char ID
+
+const THEME = {
+  layoutStyle: { backgroundColor: "#0d1117", cellSpacingX: 8, cellSpacingY: 8, gutterColor: "#0d1117" },
+  widgetStyle: { backgroundColor: "#161b22", borderColor: "#30363d", borderEdges: ["all"], borderRadius: 8, borderWidth: 1 },
+};
+// ─────────────────────────────────────────────────────────────────────────────
+
+function getOrgCredentials(alias) {
+  const result = execFileSync('sf', ['org', 'display', '-o', alias, '--json'], { encoding: "utf8" });
+  const json = JSON.parse(result);
+  return { accessToken: json.result.accessToken, instanceUrl: json.result.instanceUrl };
+}
+
+function apiFetch(instanceUrl, accessToken, apiPath, method = "GET", body = null) {
+  const url = `${instanceUrl}${apiPath}`;
+  const args = [
+    "-s",
+    "-H", `Authorization: Bearer ${accessToken}`,
+    "-H", "Content-Type: application/json",
+    "-X", method,
+    "-w", "\\nHTTP_STATUS:%{http_code}",
+  ];
+  if (body !== null) args.push("-d", JSON.stringify(body));
+  args.push(url);
+  const raw = execSync(`curl ${args.map(a => `'${String(a).replace(/'/g, "'\\''")}'`).join(" ")}`, {
+    encoding: "utf8", maxBuffer: 20 * 1024 * 1024,
+  });
+  const parts = raw.split("\nHTTP_STATUS:");
+  const httpStatus = parseInt(parts[1] || "0", 10);
+  if (httpStatus < 200 || httpStatus >= 300) {
+    throw new Error(`HTTP ${httpStatus} on ${method} ${apiPath}: ${parts[0]}`);
+  }
+  return JSON.parse(parts[0]);
+}
+
+// Always decode all HTML-entity encoding before any mutation + PATCH.
+// Doing a GET → PATCH without decoding re-encodes SAQL → double-encoded entities → errorCode 119.
+function decodeAll(s) {
+  let prev = null;
+  while (prev !== s) {
+    prev = s;
+    s = s.replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, '&');
+  }
+  return s;
+}
+
+const [,, alias] = process.argv;
+if (!alias) {
+  console.error("Usage: node patch_t_oppo_view.js <alias>");
+  console.error("Edit DASH_ID and THEME constants at the top of this file before running.");
+  process.exit(1);
+}
+
+const { accessToken, instanceUrl } = getOrgCredentials(alias);
+
+// Step 1: GET current dashboard state
+const current = apiFetch(instanceUrl, accessToken, `/services/data/v59.0/wave/dashboards/${DASH_ID}`);
+const state = JSON.parse(JSON.stringify(current.state));
+
+// Step 2: Decode all step queries
+const steps = state.steps || {};
+for (const stepName of Object.keys(steps)) {
+  if (steps[stepName].query) {
+    steps[stepName].query = decodeAll(steps[stepName].query);
+  }
+}
+
+// Step 3: Merge dark theme into layout
+const layouts = state.gridLayouts || [];
+for (const layout of layouts) {
+  layout.style = { ...(layout.style || {}), ...THEME.layoutStyle };
+  const pages = layout.pages || [];
+  for (const page of pages) {
+    const widgets = page.widgets || [];
+    for (const widget of widgets) {
+      widget.widgetStyle = { ...(widget.widgetStyle || {}), ...THEME.widgetStyle };
+    }
+  }
+}
+
+// Step 4: PATCH with decoded + themed state
+const patched = apiFetch(instanceUrl, accessToken, `/services/data/v59.0/wave/dashboards/${DASH_ID}`, "PATCH", { state });
+
+console.log(JSON.stringify({
+  status: "patched",
+  dashboardId: patched.id,
+  label: patched.label,
+  stepsDecoded: Object.keys(steps).length,
+}));

package/skills/crm-analytics-wave-generate/scripts/probe_recipe.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+// Fetch a recipe with ?format=R3 and print compile status + targetDataflowId.
+// Usage: node scripts/probe_recipe.js <alias> <recipeId>
+
+const { execSync, execFileSync } = require("child_process");
+
+function getOrgCredentials(alias) {
+  const result = execFileSync('sf', ['org', 'display', '-o', alias, '--json'], { encoding: "utf8" });
+  const json = JSON.parse(result);
+  return { accessToken: json.result.accessToken, instanceUrl: json.result.instanceUrl };
+}
+
+function apiFetch(instanceUrl, accessToken, path) {
+  const url = `${instanceUrl}${path}`;
+  const args = [
+    "-s",
+    "-H", `Authorization: Bearer ${accessToken}`,
+    "-H", "Content-Type: application/json",
+    "-w", "\\nHTTP_STATUS:%{http_code}",
+    url,
+  ];
+  const raw = execSync(`curl ${args.map(a => `'${String(a).replace(/'/g, "'\\''")}'`).join(" ")}`, { encoding: "utf8" });
+  const parts = raw.split("\nHTTP_STATUS:");
+  const httpStatus = parseInt(parts[1] || "0", 10);
+  if (httpStatus < 200 || httpStatus >= 300) {
+    throw new Error(`HTTP ${httpStatus} on GET ${path}: ${parts[0]}`);
+  }
+  return JSON.parse(parts[0]);
+}
+
+const [,, alias, recipeId] = process.argv;
+if (!alias || !recipeId) {
+  console.error("Usage: node probe_recipe.js <alias> <recipeId>");
+  process.exit(1);
+}
+
+const { accessToken, instanceUrl } = getOrgCredentials(alias);
+const recipe = apiFetch(instanceUrl, accessToken, `/services/data/v59.0/wave/recipes/${recipeId}?format=R3`);
+
+console.log(JSON.stringify({
+  id: recipe.id,
+  name: recipe.name,
+  label: recipe.label,
+  status: recipe.status,
+  targetDataflowId: recipe.targetDataflowId || null,
+  folderId: recipe.folder?.id || null,
+}, null, 2));

package/skills/crm-analytics-wave-generate/scripts/upload_dataset.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+// Upload a CSV to a new or existing dataset via InsightsExternalData API.
+// Polls InsightsExternalDataPart and InsightsExternalData until ingestion is terminal.
+// Usage: node scripts/upload_dataset.js <alias> <csvPath> <metadataJsonPath> <datasetAlias> <folderId>
+
+const { execSync, execFileSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const TERMINAL_STATUSES = new Set(["Completed", "CompletedWithWarnings", "Failed", "NotProcessed"]);
+const POLL_INTERVAL_MS = 8000;
+const MAX_WAIT_MS = 15 * 60 * 1000;
+
+function getOrgCredentials(alias) {
+  const result = execFileSync('sf', ['org', 'display', '-o', alias, '--json'], { encoding: "utf8" });
+  const json = JSON.parse(result);
+  return { accessToken: json.result.accessToken, instanceUrl: json.result.instanceUrl };
+}
+
+function soqlQuery(instanceUrl, accessToken, soql) {
+  const encoded = encodeURIComponent(soql);
+  const args = [
+    "-s",
+    "-H", `Authorization: Bearer ${accessToken}`,
+    "-w", "\\nHTTP_STATUS:%{http_code}",
+    `${instanceUrl}/services/data/v59.0/query?q=${encoded}`,
+  ];
+  const raw = execSync(`curl ${args.map(a => `'${String(a).replace(/'/g, "'\\''")}'`).join(" ")}`, { encoding: "utf8" });
+  const parts = raw.split("\nHTTP_STATUS:");
+  const httpStatus = parseInt(parts[1] || "0", 10);
+  if (httpStatus < 200 || httpStatus >= 300) {
+    throw new Error(`HTTP ${httpStatus} on SOQL query: ${parts[0]}`);
+  }
+  return JSON.parse(parts[0]);
+}
+
+function apiFetch(instanceUrl, accessToken, apiPath, method = "GET", body = null) {
+  const url = `${instanceUrl}${apiPath}`;
+  const args = [
+    "-s",
+    "-H", `Authorization: Bearer ${accessToken}`,
+    "-H", "Content-Type: application/json",
+    "-X", method,
+    "-w", "\\nHTTP_STATUS:%{http_code}",
+  ];
+  if (body !== null) args.push("-d", JSON.stringify(body));
+  args.push(url);
+  const raw = execSync(`curl ${args.map(a => `'${String(a).replace(/'/g, "'\\''")}'`).join(" ")}`, { encoding: "utf8" });
+  const parts = raw.split("\nHTTP_STATUS:");
+  const httpStatus = parseInt(parts[1] || "0", 10);
+  if (httpStatus < 200 || httpStatus >= 300) {
+    throw new Error(`HTTP ${httpStatus} on ${method} ${apiPath}: ${parts[0]}`);
+  }
+  return JSON.parse(parts[0]);
+}
+
+function sleep(ms) {
+  execSync(`sleep ${ms / 1000}`);
+}
+
+const [,, alias, csvPath, metadataJsonPath, datasetAlias, folderId] = process.argv;
+if (!alias || !csvPath || !metadataJsonPath || !datasetAlias || !folderId) {
+  console.error("Usage: node upload_dataset.js <alias> <csvPath> <metadataJsonPath> <datasetAlias> <folderId>");
+  process.exit(1);
+}
+
+const { accessToken, instanceUrl } = getOrgCredentials(alias);
+
+const metadataJson = fs.readFileSync(path.resolve(metadataJsonPath), "utf8");
+const csvContent = fs.readFileSync(path.resolve(csvPath), "utf8");
+const csvBase64 = Buffer.from(csvContent, "utf8").toString("base64");
+const metaBase64 = Buffer.from(metadataJson, "utf8").toString("base64");
+
+// Create InsightsExternalData record
+const edRecord = apiFetch(instanceUrl, accessToken, "/services/data/v59.0/sobjects/InsightsExternalData", "POST", {
+  EdgemartAlias: datasetAlias,
+  EdgemartLabel: datasetAlias,
+  MetadataJson: metaBase64,
+  Format: "Csv",
+  Operation: "Overwrite",
+  Action: "None",
+  EdgemartContainer: folderId,
+});
+
+const edId = edRecord.id;
+console.log(`InsightsExternalData created: ${edId}`);
+
+// Upload CSV part
+apiFetch(instanceUrl, accessToken, "/services/data/v59.0/sobjects/InsightsExternalDataPart", "POST", {
+  DataFile: csvBase64,
+  InsightsExternalDataId: edId,
+  PartNumber: 1,
+});
+console.log("CSV part uploaded.");
+
+// Trigger processing
+apiFetch(instanceUrl, accessToken, `/services/data/v59.0/sobjects/InsightsExternalData/${edId}`, "PATCH", {
+  Action: "Process",
+});
+console.log("Processing triggered.");
+
+// Poll until terminal
+const deadline = Date.now() + MAX_WAIT_MS;
+while (Date.now() < deadline) {
+  sleep(POLL_INTERVAL_MS);
+  const result = soqlQuery(instanceUrl, accessToken,
+    `SELECT Status, StatusMessage FROM InsightsExternalData WHERE Id = '${edId}'`
+  );
+  const record = result.records?.[0];
+  if (!record) continue;
+  console.log(`Status: ${record.Status}`);
+  if (TERMINAL_STATUSES.has(record.Status)) {
+    console.log(JSON.stringify({ edId, status: record.Status, message: record.StatusMessage || null }));
+    process.exit(record.Status === "Completed" ? 0 : 1);
+  }
+}
+
+console.error("Timed out waiting for ingestion to complete.");
+process.exit(1);

package/skills/crm-analytics-wave-generate/scripts/verify_dashboard_steps.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+// For each step in a deployed dashboard, GET stored SAQL, decode HTML entities,
+// swap dataset name for id/version, POST to /wave/query. Prints HTTP status + row count per step.
+// Edit DASH_ID and DS constants at the top before running.
+// Usage: node scripts/verify_dashboard_steps.js <alias>
+
+const { execSync, execFileSync } = require("child_process");
+
+// ── Edit these constants before running ──────────────────────────────────────
+const DASH_ID = "0FK000000000000AAA";  // Wave Dashboard 18-char ID
+const DS = {
+  name: "MyDataset",     // Name-based load identifier used in stored SAQL
+  id: "0Fb000000000000AAA",          // Dataset 18-char ID
+  versionId: "0Fc000000000000AAA",   // Current version ID
+};
+// ─────────────────────────────────────────────────────────────────────────────
+
+function getOrgCredentials(alias) {
+  const result = execFileSync('sf', ['org', 'display', '-o', alias, '--json'], { encoding: "utf8" });
+  const json = JSON.parse(result);
+  return { accessToken: json.result.accessToken, instanceUrl: json.result.instanceUrl };
+}
+
+function apiFetch(instanceUrl, accessToken, apiPath, method = "GET", body = null) {
+  const url = `${instanceUrl}${apiPath}`;
+  const args = [
+    "-s",
+    "-H", `Authorization: Bearer ${accessToken}`,
+    "-H", "Content-Type: application/json",
+    "-X", method,
+    "-w", "\\nHTTP_STATUS:%{http_code}",
+  ];
+  if (body !== null) args.push("-d", JSON.stringify(body));
+  args.push(url);
+  const raw = execSync(`curl ${args.map(a => `'${String(a).replace(/'/g, "'\\''")}'`).join(" ")}`, {
+    encoding: "utf8", maxBuffer: 10 * 1024 * 1024,
+  });
+  const parts = raw.split("\nHTTP_STATUS:");
+  const httpStatus = parseInt(parts[1] || "0", 10);
+  let parsed = null;
+  try { parsed = JSON.parse(parts[0]); } catch { parsed = parts[0]; }
+  return { httpStatus, body: parsed };
+}
+
+function decodeHtmlEntities(s) {
+  let prev = null;
+  while (prev !== s) {
+    prev = s;
+    s = s.replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, '&');
+  }
+  return s;
+}
+
+const [,, alias] = process.argv;
+if (!alias) {
+  console.error("Usage: node verify_dashboard_steps.js <alias>");
+  console.error("Edit DASH_ID and DS constants at the top of this file before running.");
+  process.exit(1);
+}
+
+const { accessToken, instanceUrl } = getOrgCredentials(alias);
+
+// Fetch dashboard state
+const { httpStatus: dashStatus, body: dash } = apiFetch(instanceUrl, accessToken, `/services/data/v59.0/wave/dashboards/${DASH_ID}`);
+if (dashStatus !== 200) {
+  console.error(`Failed to fetch dashboard ${DASH_ID}: HTTP ${dashStatus}`);
+  process.exit(1);
+}
+
+const steps = dash.state?.steps || {};
+const stepNames = Object.keys(steps);
+const results = [];
+
+for (const stepName of stepNames) {
+  const step = steps[stepName];
+  if (step.type !== "saql") {
+    results.push({ step: stepName, type: step.type, skipped: true, reason: "non-saql step" });
+    continue;
+  }
+
+  const decoded = decodeHtmlEntities(step.query || "");
+  // Swap name-based load for id/version for /wave/query
+  const queryForVerify = decoded.replace(
+    new RegExp(`"${DS.name}"`, "g"),
+    `"${DS.id}/${DS.versionId}"`
+  );
+
+  const { httpStatus, body: queryResult } = apiFetch(
+    instanceUrl, accessToken, "/services/data/v59.0/wave/query", "POST",
+    { query: queryForVerify, queryLanguage: "SAQL" }
+  );
+
+  const rowCount = queryResult.results?.records?.length ?? null;
+  results.push({ step: stepName, httpStatus, rowCount, ok: httpStatus === 200 && rowCount !== null });
+}
+
+const allOk = results.every(r => r.skipped || r.ok);
+console.log(JSON.stringify({ allOk, steps: results }, null, 2));
+process.exit(allOk ? 0 : 1);