Sf Datacloud

{
  "developerName": "CRM_Target",
  "displayName": "CRM Target",
  "description": "Example activation target definition for a downstream destination"
}

{
  "developerName": "High_Value_Customers_Activation",
  "displayName": "High Value Customers Activation",
  "description": "Example activation linking a published segment to a destination target",
  "segmentName": "High_Value_Customers",
  "activationTargetName": "CRM_Target"
}

{
  "developerName": "Lifetime_Value",
  "displayName": "Lifetime Value",
  "description": "Example calculated insight over an order-style DMO",
  "definitionType": "CALCULATED_METRIC",
  "expression": "SELECT ssot__IndividualId__c, SUM(ssot__TotalAmount__c) AS total_spend FROM ssot__SalesOrder__dlm GROUP BY ssot__IndividualId__c"
}

{
  "developerName": "Webhook_Target",
  "displayName": "Webhook Target",
  "description": "Example data action target for downstream delivery"
}

{
  "developerName": "Notify_High_Value_Customer_System",
  "displayName": "Notify High Value Customer System",
  "description": "Example data action definition that uses a downstream data action target"
}

{
  "developerName": "Customer_360_Graph",
  "displayName": "Customer 360 Graph",
  "description": "Example Data Graph rooted on a unified customer entity",
  "sourceObject": {
    "name": "UnifiedssotIndividualMain__dlm",
    "type": "derived",
    "fields": [
      {
        "name": "ssot__Id__c"
      },
      {
        "name": "ssot__FirstName__c"
      },
      {
        "name": "ssot__LastName__c"
      }
    ],
    "relatedObjects": []
  }
}

{
  "name": "Customer_Stream",
  "label": "Customer Stream",
  "datasource": "SalesforceDotCom_Home",
  "datastreamType": "CONNECTORSFRAMEWORK",
  "connectorInfo": {
    "connectorType": "SalesforceDotCom",
    "connectorDetails": {
      "name": "SalesforceDotCom_Home",
      "sourceObject": "Custom_Object__c"
    }
  },
  "dataLakeObjectInfo": {
    "label": "Customer",
    "name": "Customer__dll",
    "category": "Profile",
    "dataspaceInfo": [
      {
        "name": "Default"
      }
    ],
    "dataLakeFieldInputRepresentations": [
      {
        "name": "Id",
        "label": "Record ID",
        "dataType": "Text",
        "isPrimaryKey": true
      },
      {
        "name": "External_Id_c",
        "label": "External ID",
        "dataType": "Text",
        "isPrimaryKey": false
      }
    ]
  },
  "sourceFields": [
    {
      "name": "Id",
      "dataType": "Text"
    },
    {
      "name": "External_Id__c",
      "dataType": "Text"
    }
  ],
  "mappings": [],
  "refreshConfig": {
    "isAccelerationEnabled": true,
    "refreshMode": "UPSERT",
    "frequency": {
      "frequencyType": "HOURLY"
    }
  }
}

{
  "developerName": "Customer_Profile__dlm",
  "label": "Customer Profile",
  "category": "Profile",
  "fields": [
    {
      "name": "External_Id_c__c",
      "label": "External ID",
      "type": "Text"
    },
    {
      "name": "Preferred_Tier_c__c",
      "label": "Preferred Tier",
      "type": "Text"
    }
  ]
}

{
  "label": "Main",
  "description": "Generic identity resolution ruleset using customer identifiers and contact points",
  "configurationType": "individual",
  "rulesetId": "main",
  "doesRunAutomatically": false,
  "matchRules": [
    {
      "label": "Exact Email",
      "criteria": [
        {
          "entityName": "ssot__ContactPointEmail__dlm",
          "fieldName": "ssot__EmailAddress__c",
          "matchMethodType": "exactnormalized",
          "caseSensitiveMatch": false,
          "shouldMatchOnBlank": false
        }
      ]
    }
  ],
  "reconciliationRules": [
    {
      "entityName": "ssot__Individual__dlm",
      "ruleType": "lastupdated",
      "shouldIgnoreEmptyValue": true,
      "sources": [],
      "fields": []
    }
  ]
}

{
  "sourceObjectName": "Customer__dll",
  "targetObjectName": "Customer_Profile__dlm",
  "fieldMappings": [
    {
      "sourceFieldName": "External_Id_c",
      "targetFieldName": "External_Id_c__c"
    },
    {
      "sourceFieldName": "Preferred_Tier_c",
      "targetFieldName": "Preferred_Tier_c__c"
    }
  ]
}

{
  "relationships": [
    {
      "sourceObjectName": "Order_Header__dlm",
      "targetObjectName": "ssot__Individual__dlm",
      "cardinality": "ManyToOne",
      "sourceFieldName": "Customer_ID_c__c",
      "targetFieldName": "ssot__PartyId__c",
      "relationshipOwner": "DataCloud"
    }
  ]
}

{
  "developerName": "Knowledge_Index",
  "displayName": "Knowledge Index",
  "description": "Example semantic search index for a structured or unstructured Data Cloud source",
  "sourceObject": "KnowledgeArticleVersion__dlm",
  "embeddingModel": "e5_large_v2",
  "chunkingStrategy": "passage_extraction",
  "similarityMetric": "COSINE"
}

{
  "displayName": "High Value Customers",
  "developerName": "High_Value_Customers",
  "description": "Example segment built from a unified DMO",
  "segmentType": "Dbt",
  "includeDbt": {
    "models": {
      "models": [
        {
          "name": "UnifiedCustomers",
          "sql": "SELECT ui.ssot__Id__c FROM UnifiedssotIndividualMain__dlm ui JOIN ssot__SalesOrder__dlm so ON ui.ssot__Id__c = so.ssot__IndividualId__c GROUP BY ui.ssot__Id__c HAVING SUM(so.ssot__TotalAmount__c) > 1000"
        }
      ]
    }
  }
}

MIT License

Copyright (c) 2024-2025 Jag Valaiyapathy

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

#!/usr/bin/env bash
set -euo pipefail

PLUGIN_REPO="${PLUGIN_REPO:-https://github.com/Jaganpro/sf-cli-plugin-data360.git}"
BASE_DIR="${1:-${HOME}/.sf-community-tools/datacloud}"
PLUGIN_DIR="${BASE_DIR}/sf-cli-plugin-data360"
export SF_DATA_DIR="${SF_DATA_DIR:-${HOME}/.local/share/sf}"

need() {
  command -v "$1" >/dev/null 2>&1 || {
    echo "Missing required command: $1" >&2
    exit 1
  }
}

need git
need node
need yarn
need sf
need npx

mkdir -p "${BASE_DIR}"

if [[ -d "${PLUGIN_DIR}/.git" ]]; then
  echo "Updating existing plugin checkout: ${PLUGIN_DIR}"
  git -C "${PLUGIN_DIR}" pull --ff-only
else
  echo "Cloning plugin into: ${PLUGIN_DIR}"
  git clone "${PLUGIN_REPO}" "${PLUGIN_DIR}"
fi

cd "${PLUGIN_DIR}"

echo "Installing dependencies..."
yarn install

echo "Compiling plugin..."
npx tsc

echo "Generating oclif command manifest..."
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
node "${SCRIPT_DIR}/generate-manifest.mjs" "${PLUGIN_DIR}"

echo "Linking plugin into Salesforce CLI..."
mkdir -p "${SF_DATA_DIR}"
sf plugins link .

echo "Verifying runtime..."
sf data360 man >/dev/null

echo "Done. Community Data Cloud runtime is linked."
echo "Location: ${PLUGIN_DIR}"
echo "Try: sf data360 man"

#!/usr/bin/env node
import { spawnSync } from 'node:child_process';

const HELP = `Data Cloud org readiness classifier

Usage:
  node diagnose-org.mjs -o <orgAlias> [--json] [--phase <phase>] [--describe-table <table>] [--timeout <seconds>]

Options:
  -o, --target-org     Salesforce org alias or username (required)
      --json           Print machine-readable JSON
      --phase          Optional phase focus: all | connect | prepare | harmonize | segment | act | retrieve
      --describe-table Optional DMO/DLO table name for a retrieve-plane probe
      --timeout        Per-command timeout in seconds (default: 45)
  -h, --help           Show this help text
`;

const FEATURE_GUIDANCE = {
  CdpDataStreams: 'Data Streams are unavailable for this org/user. Review Data Cloud Setup provisioning, ingestion-related feature availability, and source connector permissions before using sf-datacloud-prepare.',
  CdpIdentityResolution: 'Identity Resolution is unavailable for this org/user. Review Data Cloud harmonization/identity-resolution entitlements and the user\'s Data Cloud permissions before using sf-datacloud-harmonize for IR work.',
  CdpActivationTarget: 'Activation Targets are unavailable for this org/user. Review activation permissions, destination setup, and any org-specific activation enablement before using sf-datacloud-act.',
  CdpActivationExternalPlatform: 'Activation destination platforms are unavailable for this org/user. Review Activation Targets setup, destination auth/configuration, and any feature toggles exposed in Data Cloud Setup → Feature Manager.',
  CdpDataSpace: 'Data Spaces are unavailable for this org/user. Review core Data Cloud provisioning and user permissions in Data Cloud Setup before assuming downstream phases can work.',
};

const CAVEATS = [
  'sf data360 doctor is advisory only: the current upstream command checks the search-index endpoint, not every Data Cloud module.',
  'Do not use query describe as a universal tenant probe. Run it only after confirming broader readiness and only against a known DMO or DLO table.',
  'Core Data Cloud provisioning, tenant creation, and license assignment are not reliably exposed as a full CLI enablement flow. Use CLI detection plus Setup guidance instead of promising fully programmatic enablement.',
];

function parseArgs(argv) {
  const args = { phase: 'all', timeout: 45, json: false, describeTable: null };
  for (let i = 0; i < argv.length; i += 1) {
    const arg = argv[i];
    switch (arg) {
      case '-o':
      case '--target-org':
        args.targetOrg = argv[++i];
        break;
      case '--phase':
        args.phase = argv[++i] ?? 'all';
        break;
      case '--describe-table':
        args.describeTable = argv[++i] ?? null;
        break;
      case '--timeout':
        args.timeout = Number(argv[++i] ?? '45');
        break;
      case '--json':
        args.json = true;
        break;
      case '-h':
      case '--help':
        args.help = true;
        break;
      default:
        throw new Error(`Unknown argument: ${arg}`);
    }
  }
  return args;
}

function trimText(text) {
  return (text || '').replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, '').trim();
}

function runCommand(command, args, { json = false, timeoutSeconds = 45 } = {}) {
  const finalArgs = [...args];
  if (json && !finalArgs.includes('--json')) finalArgs.push('--json');
  const result = spawnSync(command, finalArgs, {
    encoding: 'utf8',
    timeout: timeoutSeconds * 1000,
  });

  const stdout = result.stdout || '';
  const stderr = result.stderr || '';
  let parsed = null;
  if (stdout.trim()) {
    try {
      parsed = JSON.parse(stdout);
    } catch {
      parsed = null;
    }
  }

  let errorMessage = null;
  if (result.error) {
    if (result.error.code === 'ENOENT') {
      errorMessage = `${command} is not installed or not on PATH.`;
    } else if (result.error.code === 'ETIMEDOUT') {
      errorMessage = `Timed out after ${timeoutSeconds}s`;
    } else {
      errorMessage = result.error.message;
    }
  }

  return {
    command: [command, ...finalArgs].join(' '),
    exitCode: typeof result.status === 'number' ? result.status : 1,
    stdout: trimText(stdout),
    stderr: trimText(stderr),
    parsed,
    errorMessage,
  };
}

function extractSuccessSample(parsed) {
  const result = parsed?.result ?? {};

  if (Array.isArray(result?.data)) {
    return result.data[0] ?? null;
  }
  if (Array.isArray(result?.data?.platforms)) {
    return result.data.platforms[0] ?? null;
  }
  if (Array.isArray(result?.semanticSearchDefinitionDetails)) {
    return result.semanticSearchDefinitionDetails[0] ?? null;
  }
  return null;
}

function extractDetails(parsed) {
  const result = parsed?.result ?? {};
  if (result && typeof result === 'object' && !Array.isArray(result)) {
    const details = { ...result };
    delete details.data;
    if (details.status || details.indexCount !== undefined || details.apiVersion || details.instanceUrl) {
      return details;
    }
  }
  return undefined;
}

function extractCount(parsed) {
  const result = parsed?.result ?? {};
  if (Array.isArray(result?.data)) return result.data.length;
  if (typeof result?.totalSize === 'number') return result.totalSize;
  if (Array.isArray(result?.data?.platforms)) return result.data.platforms.length;
  if (typeof result?.indexCount === 'number') return result.indexCount;
  return null;
}

function classifyError(message) {
  const text = message || '';
  const gateMatch = text.match(/\[([A-Za-z0-9]+)\]/);

  if (text.includes("Couldn't find CDP tenant ID")) {
    return {
      state: 'query_service_unavailable',
      code: 'QUERY_SERVICE_TENANT_LOOKUP_FAILED',
      reason: 'The query service could not resolve a CDP tenant for this org context. Confirm broader readiness with data-space, DMO, or doctor probes before declaring Data Cloud fully disabled.',
    };
  }
  if (text.includes('This feature is not currently enabled for this user type or org')) {
    const featureCode = gateMatch?.[1] ?? 'UNKNOWN_FEATURE_GATE';
    return {
      state: 'feature_gated',
      code: featureCode,
      reason: FEATURE_GUIDANCE[featureCode] ?? 'This capability is gated for the current org or user. Review provisioning, permissions, and any relevant setup toggles before proceeding.',
    };
  }
  if (text.includes('NOT_FOUND: DataModelEntity')) {
    return {
      state: 'table_not_found',
      code: 'DATA_MODEL_ENTITY_NOT_FOUND',
      reason: 'The specified DMO or DLO table name is not queryable in this org. Pick a real table from dmo list / dlo list or use dmo get first.',
    };
  }
  if (text.includes('Request failed')) {
    return {
      state: 'request_failed',
      code: 'REQUEST_FAILED',
      reason: 'The endpoint returned a generic request failure. Treat this as inconclusive and confirm readiness with adjacent read-only probes.',
    };
  }
  if (text.includes('is not a sf command') || text.includes('not installed or not on PATH')) {
    return {
      state: 'runtime_missing',
      code: 'RUNTIME_MISSING',
      reason: 'The sf data360 runtime is not available. Install or relink the community plugin first.',
    };
  }
  if (text.includes('Timed out after')) {
    return {
      state: 'timeout',
      code: 'TIMEOUT',
      reason: 'The probe timed out. Retry, reduce the scope, or fall back to a smaller read-only command family.',
    };
  }
  return {
    state: 'unknown_error',
    code: 'UNKNOWN_ERROR',
    reason: 'The probe failed for an unclassified reason. Inspect the raw message and confirm readiness with neighboring probes.',
  };
}

function normalizeProbe(name, raw, meta = {}) {
  const base = {
    name,
    command: raw.command,
    exitCode: raw.exitCode,
    stderr: raw.stderr || undefined,
    ...meta,
  };

  if (raw.errorMessage) {
    const error = classifyError(raw.errorMessage);
    return { ...base, ...error, message: raw.errorMessage };
  }

  if (raw.parsed && (raw.parsed.status === 0 || raw.exitCode === 0)) {
    const count = extractCount(raw.parsed);
    const sample = extractSuccessSample(raw.parsed);
    const details = extractDetails(raw.parsed);
    let state = 'ok';
    if (count !== null) {
      state = count > 0 ? 'enabled_populated' : 'enabled_empty';
    }
    if (raw.parsed?.result?.status === 'ok') {
      state = 'ok';
    }
    return {
      ...base,
      state,
      count,
      sample: sample ?? undefined,
      details,
    };
  }

  const message = raw.parsed?.message || raw.stdout || raw.stderr || `Command failed with exit code ${raw.exitCode}`;
  const error = classifyError(message);
  return { ...base, ...error, message };
}

function summarizePhase(checks) {
  const states = Object.values(checks).map((check) => check.state);
  if (states.length === 0) return 'skipped';
  if (states.every((state) => state === 'skipped')) return 'skipped';
  const hasSuccess = states.some((state) => ['ok', 'enabled_empty', 'enabled_populated'].includes(state));
  const hasPopulated = states.includes('enabled_populated');
  const hasBlocking = states.some((state) => ['feature_gated', 'query_service_unavailable', 'request_failed', 'table_not_found', 'timeout', 'unknown_error'].includes(state));
  if (hasSuccess && hasBlocking) return 'partial';
  if (hasPopulated) return 'ready';
  if (hasSuccess) return 'ready_empty';
  if (states.every((state) => state === 'feature_gated')) return 'feature_gated';
  if (states.every((state) => state === 'query_service_unavailable')) return 'query_unavailable';
  if (states.every((state) => ['request_failed', 'timeout', 'unknown_error'].includes(state))) return 'blocked';
  return 'unknown';
}

function guidanceFromProbe(scope, probe) {
  if (!probe) return [];
  if (['ok', 'enabled_empty', 'enabled_populated', 'skipped'].includes(probe.state)) return [];

  if (probe.state === 'runtime_missing') {
    return [
      'Install or relink the community sf data360 runtime before attempting Data Cloud work.',
      'Use python3 ~/.claude/sf-skills-install.py --with-datacloud-runtime or bash ~/.claude/skills/sf-datacloud/scripts/bootstrap-plugin.sh.',
    ];
  }

  if (probe.state === 'query_service_unavailable') {
    return [
      `${scope}: query-specific tenant lookup failed. Do not treat this as a global Data Cloud outage by itself. Re-check core probes such as data-space list, dmo list, and doctor, then use a known table name if you retry query describe.`,
    ];
  }

  if (probe.state === 'feature_gated') {
    return [`${scope}: ${probe.reason}`];
  }

  if (probe.state === 'table_not_found') {
    return [`${scope}: ${probe.reason}`];
  }

  if (probe.state === 'request_failed') {
    return [
      `${scope}: ${probe.reason}`,
      'If doctor is the failing probe, remember that it only checks search indexes; use adjacent read-only probes before deciding the whole org is blocked.',
    ];
  }

  if (probe.state === 'timeout') {
    return [`${scope}: ${probe.reason}`];
  }

  return [`${scope}: ${probe.reason}`];
}

function parseOrgDisplay(raw, targetOrg) {
  const base = {
    alias: targetOrg,
    state: 'ok',
  };

  if (raw.errorMessage) {
    return { ...base, state: 'org_not_authenticated', message: raw.errorMessage };
  }

  if (raw.parsed && raw.parsed.status === 0) {
    const result = raw.parsed.result || {};
    return {
      ...base,
      alias: result.alias || targetOrg,
      username: result.username,
      instanceUrl: result.instanceUrl,
      apiVersion: result.apiVersion,
      connectedStatus: result.connectedStatus,
    };
  }

  const message = raw.parsed?.message || raw.stdout || raw.stderr || `Failed to resolve org ${targetOrg}`;
  return {
    ...base,
    state: 'org_not_authenticated',
    message,
  };
}

function buildProbeMatrix(orgAlias, describeTable) {
  return {
    core: {
      doctor: ['data360', 'doctor', '-o', orgAlias],
      dataSpaces: ['data360', 'data-space', 'list', '-o', orgAlias],
      dmos: ['data360', 'dmo', 'list', '-o', orgAlias],
    },
    phases: {
      connect: {
        connectorCatalog: ['data360', 'connection', 'connector-list', '-o', orgAlias],
        connectionsSalesforceCRM: ['data360', 'connection', 'list', '-o', orgAlias, '--connector-type', 'SalesforceCRM'],
      },
      prepare: {
        dataStreams: ['data360', 'data-stream', 'list', '-o', orgAlias],
        dlos: ['data360', 'dlo', 'list', '-o', orgAlias],
      },
      harmonize: {
        dmos: ['data360', 'dmo', 'list', '-o', orgAlias],
        identityResolution: ['data360', 'identity-resolution', 'list', '-o', orgAlias],
      },
      segment: {
        segments: ['data360', 'segment', 'list', '-o', orgAlias],
        calculatedInsights: ['data360', 'calculated-insight', 'list', '-o', orgAlias],
      },
      act: {
        activationPlatforms: ['data360', 'activation', 'platforms', '-o', orgAlias],
        activationTargets: ['data360', 'activation-target', 'list', '-o', orgAlias],
        dataActionTargets: ['data360', 'data-action-target', 'list', '-o', orgAlias],
      },
      retrieve: {
        searchIndexes: ['data360', 'search-index', 'list', '-o', orgAlias],
        queryDescribe: describeTable
          ? ['data360', 'query', 'describe', '-o', orgAlias, '--table', describeTable]
          : null,
      },
    },
  };
}

function printTextReport(report) {
  const lines = [];
  lines.push(`Data Cloud readiness for ${report.org.alias}`);
  lines.push(`Runtime: ${report.runtime.state}`);
  if (report.runtime.message) lines.push(`  ${report.runtime.message}`);
  lines.push(`Org auth: ${report.org.state}`);
  if (report.org.username) lines.push(`  User: ${report.org.username}`);
  if (report.org.instanceUrl) lines.push(`  Instance: ${report.org.instanceUrl}`);
  lines.push('');
  lines.push('Core probes:');
  for (const [name, probe] of Object.entries(report.core)) {
    lines.push(`  - ${name}: ${probe.state}${probe.count !== null && probe.count !== undefined ? ` (${probe.count})` : ''}`);
    if (probe.code) lines.push(`      code: ${probe.code}`);
    if (probe.message) lines.push(`      ${probe.message}`);
  }
  lines.push('');
  lines.push('Phase readiness:');
  for (const [phase, entry] of Object.entries(report.phases)) {
    lines.push(`  ${phase}: ${entry.summary}`);
    for (const [name, probe] of Object.entries(entry.checks)) {
      lines.push(`    - ${name}: ${probe.state}${probe.count !== null && probe.count !== undefined ? ` (${probe.count})` : ''}`);
      if (probe.code) lines.push(`        code: ${probe.code}`);
      if (probe.message) lines.push(`        ${probe.message}`);
    }
  }
  lines.push('');
  lines.push('Caveats:');
  for (const caveat of report.caveats) {
    lines.push(`  - ${caveat}`);
  }
  lines.push('');
  lines.push('Guidance:');
  if (report.guidance.length === 0) {
    lines.push('  - No blocking issues detected from the chosen probes. Continue with read-only inspection, then mutate intentionally.');
  } else {
    for (const item of report.guidance) {
      lines.push(`  - ${item}`);
    }
  }
  console.log(lines.join('\n'));
}

function main() {
  let args;
  try {
    args = parseArgs(process.argv.slice(2));
  } catch (error) {
    console.error(error.message);
    console.error('');
    console.error(HELP);
    process.exit(1);
  }

  if (args.help) {
    console.log(HELP);
    process.exit(0);
  }

  if (!args.targetOrg) {
    console.error('Missing required --target-org / -o argument.');
    console.error('');
    console.error(HELP);
    process.exit(1);
  }

  const runtimeCheck = runCommand('sf', ['data360', 'man'], { json: false, timeoutSeconds: args.timeout });
  const runtime = runtimeCheck.exitCode === 0
    ? { state: 'ok', command: runtimeCheck.command }
    : { ...classifyError(runtimeCheck.stderr || runtimeCheck.stdout || runtimeCheck.errorMessage || 'sf data360 runtime is unavailable'), command: runtimeCheck.command };

  const orgDisplay = parseOrgDisplay(
    runCommand('sf', ['org', 'display', '-o', args.targetOrg], { json: true, timeoutSeconds: args.timeout }),
    args.targetOrg
  );

  const matrix = buildProbeMatrix(args.targetOrg, args.describeTable);
  const report = {
    runtime,
    org: orgDisplay,
    core: {},
    phases: {},
    caveats: [...CAVEATS],
    guidance: [],
  };

  if (runtime.state !== 'ok' || orgDisplay.state !== 'ok') {
    report.guidance.push(...guidanceFromProbe('runtime', runtime));
    if (orgDisplay.state !== 'ok') {
      report.guidance.push(`Authenticate the target org first: sf org login web -a ${args.targetOrg}`);
    }
    if (args.json) {
      console.log(JSON.stringify(report, null, 2));
    } else {
      printTextReport(report);
    }
    process.exit(runtime.state === 'ok' && orgDisplay.state === 'ok' ? 0 : 1);
  }

  for (const [name, commandArgs] of Object.entries(matrix.core)) {
    report.core[name] = normalizeProbe(name, runCommand('sf', commandArgs, { json: true, timeoutSeconds: args.timeout }));
  }

  const selectedPhases = args.phase === 'all'
    ? Object.keys(matrix.phases)
    : [args.phase];

  for (const phase of selectedPhases) {
    const checks = {};
    const phaseMatrix = matrix.phases[phase] || {};
    for (const [name, commandArgs] of Object.entries(phaseMatrix)) {
      if (!commandArgs) {
        checks[name] = { name, state: 'skipped', reason: 'No describe table was supplied for the query probe.' };
        continue;
      }
      checks[name] = normalizeProbe(name, runCommand('sf', commandArgs, { json: true, timeoutSeconds: args.timeout }));
    }
    report.phases[phase] = {
      summary: summarizePhase(checks),
      checks,
    };
  }

  const uniqueGuidance = new Set();
  for (const [name, probe] of Object.entries(report.core)) {
    for (const item of guidanceFromProbe(`core.${name}`, probe)) uniqueGuidance.add(item);
  }
  for (const [phase, entry] of Object.entries(report.phases)) {
    for (const [name, probe] of Object.entries(entry.checks)) {
      for (const item of guidanceFromProbe(`${phase}.${name}`, probe)) uniqueGuidance.add(item);
    }
  }

  const coreSignals = Object.values(report.core).map((probe) => probe.state);
  if (coreSignals.some((state) => ['ok', 'enabled_empty', 'enabled_populated'].includes(state))) {
    uniqueGuidance.add('At least one core Data Cloud probe succeeded. Treat individual query or feature-gate failures as scoped issues, not automatic proof that the whole product is disabled.');
  }
  uniqueGuidance.add('For core provisioning, tenant creation, or license assignment gaps, use Setup → Data Cloud Setup and the current standard Data Cloud permission sets. Feature Manager can expose some org-specific toggles, but it is not the source of truth for every missing capability.');
  uniqueGuidance.add('Reference: skills/sf-datacloud/references/feature-readiness.md');

  report.guidance = [...uniqueGuidance];

  if (args.json) {
    console.log(JSON.stringify(report, null, 2));
  } else {
    printTextReport(report);
  }

  process.exit(0);
}

main();

#!/usr/bin/env node
/**
 * Generate oclif.manifest.json for the sf-cli-plugin-data360 community plugin.
 *
 * Why this exists:
 *   `npx oclif manifest` imports every command class, which triggers the
 *   @oclif/core class hierarchy. When the plugin's pinned @oclif/core is
 *   older than what the current Node.js version expects, the import fails
 *   with "Cannot read properties of undefined (reading 'prototype')".
 *
 *   This script avoids importing commands entirely. It walks the compiled
 *   lib/commands/ directory and extracts static metadata from source text
 *   via regex, producing a valid manifest that tells oclif to skip
 *   auto-discovery and auto-transpilation.
 *
 * Usage:
 *   node generate-manifest.mjs            # uses cwd
 *   node generate-manifest.mjs /path/to   # uses explicit plugin root
 */

import { readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
import { join, relative, sep } from 'node:path';

const pluginRoot = process.argv[2] || process.cwd();
const pkg = JSON.parse(readFileSync(join(pluginRoot, 'package.json'), 'utf8'));
const commandsDir = join(pluginRoot, (pkg.oclif?.commands || './lib/commands').replace('./', ''));

function walk(dir) {
  const files = [];
  for (const entry of readdirSync(dir)) {
    const full = join(dir, entry);
    if (statSync(full).isDirectory()) files.push(...walk(full));
    else if (entry.endsWith('.js') && !entry.endsWith('.test.js')) files.push(full);
  }
  return files;
}

function parseCommandSource(source, id) {
  const cmd = { id, pluginName: pkg.name, pluginType: 'link', aliases: [] };

  const summaryMatch = source.match(/static\s+summary\s*=\s*['"`]([^'"`]+)/);
  if (summaryMatch) cmd.summary = summaryMatch[1];

  const descMatch = source.match(/static\s+description\s*=\s*['"`]([^'"`]+)/);
  if (descMatch) cmd.description = descMatch[1];

  if (/static\s+hidden\s*=\s*true/.test(source)) cmd.hidden = true;
  if (/static\s+strict\s*=\s*false/.test(source)) cmd.strict = false;
  if (/static\s+enableJsonFlag\s*=\s*true/.test(source)) cmd.enableJsonFlag = true;

  return cmd;
}

const commands = {};
for (const file of walk(commandsDir)) {
  const rel = relative(commandsDir, file).replace(/\.js$/, '');
  const id = rel.split(sep).join(':');
  try {
    commands[id] = parseCommandSource(readFileSync(file, 'utf8'), id);
  } catch {
    commands[id] = { id, pluginName: pkg.name, pluginType: 'link', aliases: [] };
  }
}

const manifest = { version: pkg.version, commands };
const outPath = join(pluginRoot, 'oclif.manifest.json');
writeFileSync(outPath, JSON.stringify(manifest, null, 2));
console.log(`Generated oclif.manifest.json: ${Object.keys(commands).length} commands (v${pkg.version})`);

#!/usr/bin/env bash
set -euo pipefail

ORG="${1:-}"

if ! command -v sf >/dev/null 2>&1; then
  echo "Salesforce CLI (sf) is not installed or not on PATH." >&2
  exit 1
fi

if ! sf data360 man >/dev/null 2>&1; then
  echo "The community 'sf data360' runtime is not available." >&2
  echo "Run bash ~/.claude/skills/sf-datacloud/scripts/bootstrap-plugin.sh first." >&2
  exit 1
fi

echo "✓ sf data360 runtime detected"

if [[ -n "${ORG}" ]]; then
  if sf org display -o "${ORG}" >/dev/null 2>&1; then
    echo "✓ org alias '${ORG}' is authenticated"
  else
    echo "Org alias '${ORG}' is not authenticated." >&2
    exit 1
  fi

  if sf data360 doctor -o "${ORG}" >/dev/null 2>&1; then
    echo "✓ sf data360 doctor completed for '${ORG}'"
  else
    echo "! sf data360 doctor did not complete cleanly for '${ORG}'. Falling back to read-only smoke checks." >&2

    smoke_passed=0
    while IFS='|' read -r label command; do
      [[ -z "${label}" ]] && continue
      if bash -lc "${command}" >/dev/null 2>&1; then
        echo "✓ ${label} smoke check passed for '${ORG}'"
        smoke_passed=1
      fi
    done <<EOF
connectors|sf data360 connection connector-list -o "${ORG}"
dmos|sf data360 dmo list --all -o "${ORG}"
segments|sf data360 segment list -o "${ORG}"
data-action-targets|sf data360 data-action-target list -o "${ORG}"
EOF

    if [[ "${smoke_passed}" -ne 1 ]]; then
      echo "No fallback Data Cloud smoke checks succeeded for '${ORG}'. Check org access and Data Cloud provisioning." >&2
      exit 1
    fi

    echo "! Doctor remains advisory for partially provisioned orgs; at least one read-only Data Cloud command succeeded." >&2
  fi
fi

echo "Verification complete."
if [[ -n "${ORG}" ]]; then
  echo "Next: node ~/.claude/skills/sf-datacloud/scripts/diagnose-org.mjs -o '${ORG}' --json"
fi