@peernova/cuneiform-sf 1.0.2 → 1.0.4-beta.10

package/lib/services/OrgInfoService.js

@@ -0,0 +1,1142 @@
+/*
+ * Copyright (c) 2026, PeerNova, Inc. All Rights Reserved.
+ * PROPRIETARY AND CONFIDENTIAL. Unauthorized copying, modification,
+ * or distribution is strictly prohibited. Use is governed by the
+ * Master Subscription Agreement (MSA) between PeerNova, Inc. and the
+ * licensee. See LICENSE file in the repo root.
+ */
+import { createSuccessResult, createFailureResult } from '../models/service-result.js';
+import { ServiceErrorCodes, sanitizeSoqlIdentifier } from '../adapters/errors.js';
+import { CuneiformQueryBuilder } from '../adapters/soql/cuneiform-query-builder.js';
+import { CUNEIFORM_NAMESPACE, CUNEIFORM_MAIN_PACKAGE_NAMES, getProductName, CLOUD_NAMESPACE_MAP, } from './namespace-constants.js';
+/**
+ * License name patterns that indicate Sales Cloud.
+ */
+const SALES_CLOUD_LICENSE_PATTERNS = ['Salesforce', 'Sales Cloud', 'Sales User'];
+/**
+ * License name patterns that indicate Service Cloud.
+ */
+const SERVICE_CLOUD_LICENSE_PATTERNS = ['Salesforce', 'Service Cloud', 'Service User'];
+/**
+ * PermissionSetLicense patterns that indicate installed cloud products.
+ * Each entry maps label/name patterns to a cloud product name.
+ */
+const PSL_CLOUD_PATTERNS = [
+    { patterns: ['Einstein Analytics', 'CRM Analytics', 'Einstein Prediction'], cloudName: 'Analytics Cloud' },
+    { patterns: ['CPQ', 'Configure Price Quote', 'Revenue Cloud'], cloudName: 'Revenue Cloud' },
+    { patterns: ['B2C Commerce', 'B2B Commerce', 'Commerce Cloud'], cloudName: 'Commerce Cloud' },
+    { patterns: ['Marketing Cloud', 'Pardot', 'Account Engagement'], cloudName: 'Marketing Cloud' },
+    { patterns: ['Tableau', 'Tableau CRM'], cloudName: 'Tableau' },
+    { patterns: ['Education Cloud', 'EDA '], cloudName: 'Education Cloud' },
+];
+/**
+ * Service for aggregating org-level metadata.
+ *
+ * Provides methods to retrieve org identity, API limits, installed packages,
+ * active namespaces, and Cuneiform version information.
+ *
+ * @example
+ * ```typescript
+ * const service = new OrgInfoService({
+ *   connectionFacade,
+ *   soqlAdapter,
+ *   toolingAdapter, // optional
+ * });
+ *
+ * const result = await service.getOrgInfo();
+ * if (result.success) {
+ *   console.log(`Org: ${result.data.identity.organizationName}`);
+ *   console.log(`Cuneiform: ${result.data.cuneiformVersion ?? 'Not installed'}`);
+ * }
+ * ```
+ */
+export class OrgInfoService {
+    connectionFacade;
+    soqlAdapter;
+    toolingAdapter;
+    restAdapter;
+    logger;
+    restClient;
+    constructor(config) {
+        this.connectionFacade = config.connectionFacade;
+        this.soqlAdapter = config.soqlAdapter;
+        this.toolingAdapter = config.toolingAdapter;
+        this.restAdapter = config.restAdapter;
+        this.logger = config.logger;
+        this.restClient = config.restClient;
+    }
+    /**
+     * Classifies the org type based on Organization record data.
+     *
+     * @param isSandbox - Whether the org is marked as sandbox
+     * @param orgType - The OrganizationType field value
+     * @param trialExpirationDate - Trial expiration date if set
+     * @returns The classified OrgType
+     */
+    static classifyOrgType(isSandbox, orgType, trialExpirationDate) {
+        if (isSandbox) {
+            return 'Sandbox';
+        }
+        const normalizedType = orgType?.toLowerCase() ?? '';
+        if (normalizedType.includes('scratch')) {
+            return 'Scratch';
+        }
+        if (normalizedType.includes('developer')) {
+            return 'Developer';
+        }
+        if (trialExpirationDate) {
+            return 'Trial';
+        }
+        return 'Production';
+    }
+    // ── Private static methods ──────────────────────────────────────────
+    /**
+     * Transforms raw limits response to OrgLimit format.
+     *
+     * Calculates percentage utilization from Max and Remaining values.
+     * Returns 0% if Max is 0 to avoid division by zero.
+     */
+    static transformLimit(name, rawLimit) {
+        const used = rawLimit.Max - rawLimit.Remaining;
+        const percentUsed = rawLimit.Max > 0 ? Math.round((used / rawLimit.Max) * 100 * 10) / 10 : 0;
+        return { name, max: rawLimit.Max, used, percentUsed };
+    }
+    /**
+     * Maps InstalledPackageRecord to InstalledPackage.
+     *
+     * Formats version as semantic version string (Major.Minor.Patch.Build)
+     * and looks up human-readable product name by namespace prefix.
+     */
+    static mapPackage(record) {
+        const version = record.SubscriberPackageVersion;
+        const versionNumber = `${version.MajorVersion}.${version.MinorVersion}.${version.PatchVersion}.${version.BuildNumber}`;
+        const namespace = record.SubscriberPackage.NamespacePrefix;
+        return {
+            id: record.Id,
+            namespacePrefix: namespace,
+            name: record.SubscriberPackage.Name,
+            versionNumber,
+            isManaged: Boolean(namespace),
+            productName: namespace ? getProductName(namespace) : undefined,
+        };
+    }
+    /**
+     * Extracts active namespaces from installed packages.
+     */
+    static extractActiveNamespaces(packages) {
+        const namespaces = packages.filter((p) => p.namespacePrefix).map((p) => p.namespacePrefix);
+        return [...new Set(namespaces)].sort();
+    }
+    /**
+     * Finds the Cuneiform installed package by namespace + identity signal.
+     *
+     * Disambiguates orgs where multiple records share `NamespacePrefix='pnova'` (CLI-3416, CLI-3417).
+     * Resolution order: (1) a candidate whose `name` matches `CUNEIFORM_MAIN_PACKAGE_NAMES`
+     * (e.g., 'Cuneiform for Salesforce'); (2) a candidate without a colon in its name — extension
+     * packages follow the `Main: Subtitle` convention (e.g., 'Cuneiform for CRM: Data Health
+     * Reports'), so a non-colon name is preferred over an extension; (3) the first namespace
+     * candidate — ensures the helper never returns `undefined` when at least one `pnova`-namespace
+     * package exists.
+     */
+    static findCuneiformPackage(packages) {
+        const candidates = packages.filter((p) => p.namespacePrefix === CUNEIFORM_NAMESPACE);
+        if (candidates.length === 0)
+            return undefined;
+        const canonical = candidates.find((p) => CUNEIFORM_MAIN_PACKAGE_NAMES.includes(p.name));
+        if (canonical)
+            return canonical;
+        const nonExtension = candidates.find((p) => !p.name.includes(':'));
+        return nonExtension ?? candidates[0];
+    }
+    /**
+     * Finds the Cuneiform package version from installed packages.
+     */
+    static findCuneiformVersion(packages) {
+        return OrgInfoService.findCuneiformPackage(packages)?.versionNumber ?? null;
+    }
+    /**
+     * Detects additional cloud products from PermissionSetLicense data.
+     */
+    static detectPslClouds(licenses) {
+        const pslLicenses = licenses.filter((lic) => lic.type === 'permissionSet');
+        const clouds = [];
+        for (const pslEntry of PSL_CLOUD_PATTERNS) {
+            const match = pslLicenses.find((lic) => pslEntry.patterns.some((pattern) => lic.masterLabel.includes(pattern) || lic.name.includes(pattern)));
+            if (match) {
+                clouds.push({
+                    name: pslEntry.cloudName,
+                    type: 'license',
+                    installed: true,
+                    totalLicenses: match.totalLicenses,
+                    usedLicenses: match.usedLicenses,
+                    status: match.status,
+                });
+            }
+        }
+        return clouds;
+    }
+    /**
+     * Groups objects by namespace from global describe result.
+     *
+     * Extracts namespace prefixes from custom object names matching pattern:
+     * Namespace__ObjectName__c
+     *
+     * @param globalDescribe - The global describe result
+     * @returns Map of namespace prefix to object names and count
+     */
+    static groupNamespaceObjects(globalDescribe) {
+        const namespaceGroups = new Map();
+        for (const obj of globalDescribe.sobjects) {
+            // Custom objects with namespaces: Namespace__ObjectName__c (standard/custom only)
+            // Excludes __mdt (custom metadata), __e (platform events), __b (big objects)
+            const match = obj.name.match(/^([A-Za-z0-9]+)__\w+__c$/);
+            if (match) {
+                const namespace = match[1];
+                const group = namespaceGroups.get(namespace) ?? { count: 0, objects: [] };
+                group.count++;
+                group.objects.push(obj.name);
+                namespaceGroups.set(namespace, group);
+            }
+        }
+        return namespaceGroups;
+    }
+    /**
+     * Builds the SOQL string for a LIMIT 0 field-existence probe, sanitizing both
+     * identifiers via sanitizeSoqlIdentifier. Returns null when either identifier
+     * is invalid — callers MUST treat null as "field cannot exist" without invoking
+     * the SOQL adapter.
+     *
+     * Pure, side-effect-free, and exposed at the class level so the sanitizer
+     * hardening introduced in CLI-3174 can be unit-tested directly.
+     */
+    static buildProbeQuery(objectName, fieldName) {
+        try {
+            const obj = sanitizeSoqlIdentifier(objectName);
+            const field = sanitizeSoqlIdentifier(fieldName);
+            return `SELECT ${field} FROM ${obj} LIMIT 0`;
+        }
+        catch {
+            return null;
+        }
+    }
+    // ── Public instance methods ─────────────────────────────────────────
+    /**
+     * Retrieves complete org information.
+     *
+     * Executes multiple API calls in parallel for performance:
+     * - Identity + Organization SOQL (getOrgIdentity)
+     * - Limits API (getOrgLimits)
+     * - Installed packages via Tooling API (getInstalledPackages)
+     *
+     * @returns ServiceResult containing complete OrgInfo
+     */
+    async getOrgInfo() {
+        const startTime = Date.now();
+        const warnings = [];
+        const emptyResult = {
+            identity: { userId: '', organizationId: '', username: '' },
+            limits: { limits: {} },
+            packages: [],
+            activeNamespaces: [],
+            cuneiformVersion: null,
+        };
+        // REST API path: delegate to server when restClient is available
+        if (this.restClient) {
+            return this.getOrgInfoViaRest(startTime);
+        }
+        try {
+            this.logger?.log('Fetching org info...');
+            // Execute parallel API calls
+            const [identityResult, limitsResult, packagesResult] = await Promise.all([
+                this.getOrgIdentity(),
+                this.getOrgLimits(),
+                this.getInstalledPackages(),
+            ]);
+            // Handle identity result
+            if (!identityResult.success) {
+                return createFailureResult(emptyResult, ServiceErrorCodes.ORG_INFO_QUERY_FAILED, identityResult.message ?? 'Failed to get org identity', {
+                    metadata: { duration: Date.now() - startTime },
+                });
+            }
+            // Handle limits result (warning if failed, not fatal)
+            let limits = emptyResult.limits;
+            if (!limitsResult.success) {
+                warnings.push(`Limits query failed: ${limitsResult.message ?? 'Unknown error'}`);
+            }
+            else {
+                limits = limitsResult.data;
+            }
+            // Handle packages result (warning if failed, not fatal)
+            let packages = emptyResult.packages;
+            if (!packagesResult.success) {
+                warnings.push(`Package query failed: ${packagesResult.message ?? 'Unknown error'}`);
+            }
+            else {
+                packages = packagesResult.data;
+            }
+            // Extract namespaces and Cuneiform version
+            const activeNamespaces = OrgInfoService.extractActiveNamespaces(packages);
+            const cuneiformVersion = OrgInfoService.findCuneiformVersion(packages);
+            const orgInfo = {
+                identity: identityResult.data,
+                limits,
+                packages,
+                activeNamespaces,
+                cuneiformVersion,
+            };
+            const duration = Date.now() - startTime;
+            this.logger?.log(`Org info retrieved in ${duration}ms`);
+            return createSuccessResult(orgInfo, {
+                message: `Org info retrieved for ${identityResult.data.organizationName ?? identityResult.data.organizationId}`,
+                warnings: warnings.length > 0 ? warnings : undefined,
+                metadata: { duration },
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger?.log(`Org info query failed: ${errorMessage}`);
+            return createFailureResult(emptyResult, ServiceErrorCodes.ORG_INFO_QUERY_FAILED, errorMessage, {
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+    }
+    /**
+     * Retrieves org identity information.
+     *
+     * Combines connection.identity() with Organization SOQL query for complete info.
+     *
+     * @returns ServiceResult containing OrgIdentity
+     */
+    async getOrgIdentity() {
+        const startTime = Date.now();
+        const emptyResult = { userId: '', organizationId: '', username: '' };
+        try {
+            this.logger?.log('Fetching org identity...');
+            // Build Organization SOQL using CuneiformQueryBuilder
+            const orgSoql = new CuneiformQueryBuilder()
+                .select(['Id', 'Name', 'IsSandbox', 'OrganizationType', 'NamespacePrefix'])
+                .from('Organization')
+                .limit(1)
+                .toSOQL();
+            // Execute identity and org query in parallel
+            const [identity, orgResult] = await Promise.all([
+                this.connectionFacade.identity(),
+                this.soqlAdapter.query(orgSoql),
+            ]);
+            const orgRecord = orgResult.success && orgResult.data.records.length > 0 ? orgResult.data.records[0] : null;
+            const result = {
+                userId: identity.user_id,
+                organizationId: identity.organization_id,
+                username: identity.username,
+                organizationName: orgRecord?.Name,
+                isSandbox: orgRecord?.IsSandbox,
+                organizationType: orgRecord?.OrganizationType,
+                namespacePrefix: orgRecord?.NamespacePrefix ?? undefined,
+            };
+            const duration = Date.now() - startTime;
+            this.logger?.log(`Org identity retrieved: ${result.organizationName ?? result.organizationId}`);
+            return createSuccessResult(result, {
+                message: `Identity retrieved for ${result.username}`,
+                metadata: { duration },
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger?.log(`Org identity failed: ${errorMessage}`);
+            return createFailureResult(emptyResult, ServiceErrorCodes.ORG_IDENTITY_FAILED, errorMessage, {
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+    }
+    /**
+     * Retrieves org API limits.
+     *
+     * Calls /limits REST endpoint and transforms to OrgLimits format.
+     *
+     * @returns ServiceResult containing OrgLimits
+     */
+    async getOrgLimits() {
+        const startTime = Date.now();
+        const emptyResult = { limits: {} };
+        try {
+            this.logger?.log('Fetching org limits...');
+            const response = await this.connectionFacade.request('/limits');
+            // Transform response
+            const limits = {};
+            for (const [name, rawLimit] of Object.entries(response)) {
+                limits[name] = OrgInfoService.transformLimit(name, rawLimit);
+            }
+            const result = {
+                limits,
+                dailyApiRequests: limits['DailyApiRequests'],
+                dataStorageMB: limits['DataStorageMB'],
+                fileStorageMB: limits['FileStorageMB'],
+                dailyBulkApiRequests: limits['DailyBulkApiRequests'],
+                dailyBulkV2QueryJobs: limits['DailyBulkV2QueryJobs'],
+                dailyAsyncApexExecutions: limits['DailyAsyncApexExecutions'],
+                dailyStreamingApiEvents: limits['DailyStreamingApiEvents'],
+            };
+            const duration = Date.now() - startTime;
+            this.logger?.log(`Org limits retrieved: ${Object.keys(limits).length} limits`);
+            return createSuccessResult(result, {
+                message: `Retrieved ${Object.keys(limits).length} limits`,
+                metadata: { duration },
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger?.log(`Org limits failed: ${errorMessage}`);
+            return createFailureResult(emptyResult, ServiceErrorCodes.ORG_LIMITS_FAILED, errorMessage, {
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+    }
+    /**
+     * Retrieves installed packages via Tooling API.
+     *
+     * If Tooling adapter is not provided, returns empty array with warning.
+     *
+     * @returns ServiceResult containing array of InstalledPackage
+     */
+    async getInstalledPackages() {
+        const startTime = Date.now();
+        if (!this.toolingAdapter) {
+            this.logger?.log('Tooling adapter not provided, skipping package query');
+            return createSuccessResult([], {
+                message: 'Package query skipped (no Tooling adapter)',
+                warnings: ['Tooling adapter not provided, cannot query installed packages'],
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+        try {
+            this.logger?.log('Fetching installed packages...');
+            // PTA-1436: Cuneiform version is sourced from InstalledSubscriberPackage (Tooling API).
+            // The version number is constructed from MajorVersion.MinorVersion.PatchVersion.BuildNumber
+            // on the SubscriberPackageVersion relationship. License status is not exposed via standard
+            // Salesforce APIs — see getCuneiformPackageInfo() which defaults to 'Active' if installed.
+            const soql = new CuneiformQueryBuilder()
+                .select([
+                'Id',
+                'SubscriberPackage.Id',
+                'SubscriberPackage.Name',
+                'SubscriberPackage.NamespacePrefix',
+                'SubscriberPackageVersion.Id',
+                'SubscriberPackageVersion.MajorVersion',
+                'SubscriberPackageVersion.MinorVersion',
+                'SubscriberPackageVersion.PatchVersion',
+                'SubscriberPackageVersion.BuildNumber',
+            ])
+                .from('InstalledSubscriberPackage')
+                .orderBy('SubscriberPackage.Name', 'ASC')
+                .toSOQL();
+            const result = await this.toolingAdapter.query(soql);
+            if (!result.success) {
+                return createFailureResult([], ServiceErrorCodes.ORG_PACKAGE_QUERY_FAILED, result.message ?? 'Package query failed', {
+                    metadata: { duration: Date.now() - startTime },
+                });
+            }
+            const packages = result.data.records.map((record) => OrgInfoService.mapPackage(record));
+            const duration = Date.now() - startTime;
+            this.logger?.log(`Found ${packages.length} installed packages`);
+            return createSuccessResult(packages, {
+                message: `Found ${packages.length} installed packages`,
+                metadata: { duration },
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger?.log(`Package query failed: ${errorMessage}`);
+            return createFailureResult([], ServiceErrorCodes.ORG_PACKAGE_QUERY_FAILED, errorMessage, {
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+    }
+    /**
+     * Retrieves active namespaces from installed packages.
+     *
+     * @returns ServiceResult containing array of namespace strings
+     */
+    async getActiveNamespaces() {
+        const startTime = Date.now();
+        try {
+            const packagesResult = await this.getInstalledPackages();
+            if (!packagesResult.success) {
+                return createFailureResult([], ServiceErrorCodes.ORG_NAMESPACE_QUERY_FAILED, packagesResult.message ?? 'Failed to get namespaces', {
+                    metadata: { duration: Date.now() - startTime },
+                });
+            }
+            const namespaces = OrgInfoService.extractActiveNamespaces(packagesResult.data);
+            const duration = Date.now() - startTime;
+            return createSuccessResult(namespaces, {
+                message: `Found ${namespaces.length} active namespaces`,
+                metadata: { duration },
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return createFailureResult([], ServiceErrorCodes.ORG_NAMESPACE_QUERY_FAILED, errorMessage, {
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+    }
+    /**
+     * Retrieves the Cuneiform version if installed.
+     *
+     * @returns ServiceResult containing version string or null if not installed
+     */
+    async getCuneiformVersion() {
+        const startTime = Date.now();
+        try {
+            const packagesResult = await this.getInstalledPackages();
+            if (!packagesResult.success) {
+                return createFailureResult(null, ServiceErrorCodes.ORG_CUNEIFORM_VERSION_FAILED, packagesResult.message ?? 'Failed to get Cuneiform version', {
+                    metadata: { duration: Date.now() - startTime },
+                });
+            }
+            const version = OrgInfoService.findCuneiformVersion(packagesResult.data);
+            const duration = Date.now() - startTime;
+            return createSuccessResult(version, {
+                message: version ? `Cuneiform version: ${version}` : 'Cuneiform not installed',
+                metadata: { duration },
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return createFailureResult(null, ServiceErrorCodes.ORG_CUNEIFORM_VERSION_FAILED, errorMessage, {
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+    }
+    /**
+     * Fetches the describeGlobal result from the REST adapter.
+     *
+     * Used by OrgDetailsOperation to cache the result across multiple service calls,
+     * avoiding redundant API round-trips for features, clouds, and namespace detection.
+     *
+     * @returns ServiceResult containing DescribeGlobalResult
+     */
+    async fetchDescribeGlobal() {
+        if (!this.restAdapter) {
+            return createFailureResult({ maxBatchSize: 0, sobjects: [] }, ServiceErrorCodes.ORG_FEATURES_QUERY_FAILED, 'REST adapter not available');
+        }
+        return this.restAdapter.describeGlobal();
+    }
+    /**
+     * Detects org features via object/field probing.
+     *
+     * Checks for:
+     * - Multi-Currency: CurrencyType object exists in describeGlobal
+     * - Enhanced Notes: ContentNote object is queryable
+     * - State/Country Picklists: BillingCountryCode field exists on Account
+     * - Territory Management: Territory2 object exists
+     * - Person Accounts: IsPersonAccount field exists on Account
+     * - Digital Experiences: Network object exists in describeGlobal
+     * - Einstein AI: AIRecordInsight object exists in describeGlobal
+     *
+     * @param cachedGlobal - Optional pre-fetched describeGlobal result to avoid redundant API calls
+     * @returns ServiceResult containing OrgFeatures
+     */
+    async getOrgFeatures(cachedGlobal) {
+        const startTime = Date.now();
+        const emptyResult = {
+            multiCurrency: false,
+            enhancedNotes: false,
+            stateCountryPicklists: false,
+            territoryManagement: false,
+            personAccounts: false,
+            digitalExperiences: false,
+            einsteinAI: false,
+        };
+        if (!this.restAdapter) {
+            this.logger?.log('REST adapter not provided, skipping feature detection');
+            return createSuccessResult(emptyResult, {
+                message: 'Feature detection skipped (no REST adapter)',
+                warnings: ['REST adapter not provided, cannot detect org features'],
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+        try {
+            this.logger?.log('Detecting org features...');
+            // Use provided cache if available; otherwise fetch fresh
+            const globalResult = cachedGlobal ?? (await this.restAdapter.describeGlobal());
+            if (!globalResult.success) {
+                return createFailureResult(emptyResult, ServiceErrorCodes.ORG_FEATURES_QUERY_FAILED, globalResult.message ?? 'Failed to detect org features', {
+                    metadata: { duration: Date.now() - startTime },
+                });
+            }
+            const sobjectNames = new Set(globalResult.data.sobjects.map((obj) => obj.name));
+            // Check Multi-Currency: CurrencyType object exists
+            const multiCurrency = sobjectNames.has('CurrencyType');
+            // Check Enhanced Notes: ContentNote object exists and is queryable
+            const contentNoteObj = globalResult.data.sobjects.find((obj) => obj.name === 'ContentNote');
+            const enhancedNotes = contentNoteObj?.queryable ?? false;
+            // Check Territory Management: Territory2 object exists
+            const territoryManagement = sobjectNames.has('Territory2');
+            // Check Digital Experiences: Network object exists (Communities/Experience Cloud)
+            const digitalExperiences = sobjectNames.has('Network');
+            // Check Einstein AI: AIRecordInsight object exists (Einstein scoring features)
+            const einsteinAI = sobjectNames.has('AIRecordInsight');
+            // Check State/Country Picklists and Person Accounts via lightweight SOQL probes.
+            // A LIMIT 0 query succeeds if the field exists, fails with INVALID_FIELD if not.
+            // This avoids a full Account describe (~100-300KB for 2 boolean checks).
+            const [stateCountryPicklists, personAccounts] = await Promise.all([
+                this.probeFieldExists('Account', 'BillingCountryCode'),
+                this.probeFieldExists('Account', 'IsPersonAccount'),
+            ]);
+            const features = {
+                multiCurrency,
+                enhancedNotes,
+                stateCountryPicklists,
+                territoryManagement,
+                personAccounts,
+                digitalExperiences,
+                einsteinAI,
+            };
+            const duration = Date.now() - startTime;
+            const enabledCount = Object.values(features).filter(Boolean).length;
+            this.logger?.log(`Org features detected: ${enabledCount}/7 enabled`);
+            return createSuccessResult(features, {
+                message: `Detected ${enabledCount}/7 org features enabled`,
+                metadata: { duration },
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger?.log(`Org features detection failed: ${errorMessage}`);
+            return createFailureResult(emptyResult, ServiceErrorCodes.ORG_FEATURES_QUERY_FAILED, errorMessage, {
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+    }
+    /**
+     * Retrieves license information from UserLicense and PermissionSetLicense.
+     *
+     * @returns ServiceResult containing array of LicenseInfo
+     */
+    async getLicenseInfo() {
+        const startTime = Date.now();
+        try {
+            this.logger?.log('Fetching license information...');
+            // Query UserLicense
+            const userLicenseQuery = new CuneiformQueryBuilder()
+                .select(['Id', 'Name', 'MasterLabel', 'TotalLicenses', 'UsedLicenses', 'Status'])
+                .from('UserLicense')
+                .where('TotalLicenses', '>', 0)
+                .orderBy('Name')
+                .toSOQL();
+            // Query PermissionSetLicense
+            const pslQuery = new CuneiformQueryBuilder()
+                .select(['Id', 'MasterLabel', 'DeveloperName', 'TotalLicenses', 'UsedLicenses'])
+                .from('PermissionSetLicense')
+                .where('TotalLicenses', '>', 0)
+                .orderBy('MasterLabel')
+                .toSOQL();
+            // Execute queries in parallel
+            const [userLicenseResult, pslResult] = await Promise.all([
+                this.soqlAdapter.query(userLicenseQuery),
+                this.soqlAdapter.query(pslQuery),
+            ]);
+            const licenses = [];
+            const warnings = [];
+            // Process UserLicense results
+            if (userLicenseResult.success) {
+                for (const record of userLicenseResult.data.records) {
+                    licenses.push({
+                        id: record.Id,
+                        name: record.Name,
+                        masterLabel: record.MasterLabel,
+                        totalLicenses: record.TotalLicenses,
+                        usedLicenses: record.UsedLicenses,
+                        status: record.Status,
+                        type: 'user',
+                    });
+                }
+            }
+            else {
+                warnings.push(`UserLicense query failed: ${userLicenseResult.message ?? 'Unknown error'}`);
+            }
+            // Process PermissionSetLicense results
+            if (pslResult.success) {
+                for (const record of pslResult.data.records) {
+                    licenses.push({
+                        id: record.Id,
+                        name: record.DeveloperName,
+                        masterLabel: record.MasterLabel,
+                        totalLicenses: record.TotalLicenses,
+                        usedLicenses: record.UsedLicenses,
+                        status: 'Active', // PSL doesn't have status field
+                        type: 'permissionSet',
+                    });
+                }
+            }
+            else {
+                warnings.push(`PermissionSetLicense query failed: ${pslResult.message ?? 'Unknown error'}`);
+            }
+            const duration = Date.now() - startTime;
+            this.logger?.log(`Found ${licenses.length} licenses`);
+            return createSuccessResult(licenses, {
+                message: `Found ${licenses.length} licenses`,
+                warnings: warnings.length > 0 ? warnings : undefined,
+                metadata: { duration },
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger?.log(`License query failed: ${errorMessage}`);
+            return createFailureResult([], ServiceErrorCodes.ORG_NAMESPACE_QUERY_FAILED, errorMessage, {
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+    }
+    /**
+     * Detects installed Salesforce Clouds (Sales Cloud, Service Cloud, Industry Clouds).
+     *
+     * Combines license-based detection (Sales/Service Cloud via UserLicense) with
+     * package-based detection (Industry Clouds via namespace lookup).
+     *
+     * @param cachedGlobal - Optional pre-fetched describeGlobal result to avoid redundant API calls
+     * @returns ServiceResult containing array of DetectedCloud
+     */
+    async getDetectedClouds(cachedGlobal, cachedPackages) {
+        const startTime = Date.now();
+        try {
+            this.logger?.log('Detecting installed clouds...');
+            // Get licenses and packages in parallel (use cached packages if provided)
+            const [licensesResult, packagesResult] = await Promise.all([
+                this.getLicenseInfo(),
+                cachedPackages ?? this.getInstalledPackages(),
+            ]);
+            const clouds = [];
+            const warnings = [];
+            // Detect Sales Cloud and Service Cloud via licenses
+            if (licensesResult.success) {
+                clouds.push(...(await this.detectLicenseClouds(licensesResult.data, cachedGlobal)));
+            }
+            else {
+                warnings.push(`License query failed: ${licensesResult.message ?? 'Unknown error'}`);
+            }
+            // Detect Industry Clouds via packages
+            if (packagesResult.success) {
+                for (const [namespace, cloudName] of Object.entries(CLOUD_NAMESPACE_MAP)) {
+                    const pkg = packagesResult.data.find((p) => p.namespacePrefix === namespace || p.namespacePrefix === `${namespace}__`);
+                    clouds.push({
+                        name: cloudName,
+                        type: 'package',
+                        installed: Boolean(pkg),
+                        namespace: pkg ? pkg.namespacePrefix : namespace,
+                        version: pkg?.versionNumber,
+                    });
+                }
+            }
+            else {
+                warnings.push(`Package query failed: ${packagesResult.message ?? 'Unknown error'}`);
+            }
+            // Detect additional clouds from PermissionSetLicense data
+            if (licensesResult.success) {
+                clouds.push(...OrgInfoService.detectPslClouds(licensesResult.data));
+            }
+            const duration = Date.now() - startTime;
+            const installedCount = clouds.filter((c) => c.installed).length;
+            this.logger?.log(`Detected ${installedCount}/${clouds.length} clouds installed`);
+            return createSuccessResult(clouds, {
+                message: `Detected ${installedCount} installed clouds`,
+                warnings: warnings.length > 0 ? warnings : undefined,
+                metadata: { duration },
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger?.log(`Cloud detection failed: ${errorMessage}`);
+            return createFailureResult([], ServiceErrorCodes.ORG_FEATURES_QUERY_FAILED, errorMessage, {
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+    }
+    /**
+     * Discovers installed namespaces via describeGlobal() with object counts.
+     *
+     * Extracts unique namespaces from custom object names (pattern: Namespace__ObjectName__c)
+     * and counts objects per namespace. Maps known namespaces to product names.
+     *
+     * @param cachedGlobal - Optional pre-fetched describeGlobal result to avoid redundant API calls
+     * @returns ServiceResult containing NamespaceSummary
+     */
+    async getInstalledNamespaces(cachedGlobal) {
+        const startTime = Date.now();
+        const emptyResult = { count: 0, namespaces: [] };
+        if (!this.restAdapter) {
+            this.logger?.log('REST adapter not provided, skipping namespace discovery');
+            return createSuccessResult(emptyResult, {
+                message: 'Namespace discovery skipped (no REST adapter)',
+                warnings: ['REST adapter not provided, cannot discover namespaces'],
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+        try {
+            this.logger?.log('Discovering installed namespaces...');
+            // Use provided cache if available; otherwise fetch fresh
+            const globalResult = cachedGlobal ?? (await this.restAdapter.describeGlobal());
+            if (!globalResult.success) {
+                return createFailureResult(emptyResult, ServiceErrorCodes.ORG_NAMESPACE_QUERY_FAILED, globalResult.message ?? 'Failed to discover namespaces', {
+                    metadata: { duration: Date.now() - startTime },
+                });
+            }
+            // Group objects by namespace
+            const namespaceGroups = OrgInfoService.groupNamespaceObjects(globalResult.data);
+            // Fetch record counts for all namespace objects
+            const allObjects = Array.from(namespaceGroups.values()).flatMap((g) => g.objects);
+            const recordCounts = allObjects.length > 0 ? await this.restAdapter.getRecordCounts(allObjects) : undefined;
+            // Build namespace summary with populated/empty classification
+            const namespaces = [];
+            for (const [prefix, group] of namespaceGroups.entries()) {
+                let populated = 0;
+                let empty = 0;
+                if (recordCounts?.success) {
+                    for (const objName of group.objects) {
+                        if ((recordCounts.data.get(objName) ?? 0) > 0)
+                            populated++;
+                        else
+                            empty++;
+                    }
+                }
+                else {
+                    // If record counts failed, fall back to all objects as empty
+                    empty = group.count;
+                }
+                // Unrecognized namespaces show blank product name (not "Unknown") per PTA-1437
+                const productName = getProductName(prefix) ?? getProductName(`${prefix}__`) ?? '';
+                namespaces.push({
+                    prefix,
+                    productName,
+                    objectCount: group.count,
+                    populatedCount: populated,
+                    emptyCount: empty,
+                });
+            }
+            // Sort by object count descending
+            namespaces.sort((a, b) => b.objectCount - a.objectCount);
+            const summary = {
+                count: namespaces.length,
+                namespaces,
+            };
+            const duration = Date.now() - startTime;
+            this.logger?.log(`Discovered ${summary.count} namespaces`);
+            return createSuccessResult(summary, {
+                message: `Discovered ${summary.count} namespaces`,
+                metadata: { duration },
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger?.log(`Namespace discovery failed: ${errorMessage}`);
+            return createFailureResult(emptyResult, ServiceErrorCodes.ORG_NAMESPACE_QUERY_FAILED, errorMessage, {
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+    }
+    /**
+     * Retrieves enhanced Cuneiform package information with license details.
+     *
+     * @returns ServiceResult containing CuneiformPackageInfo
+     */
+    async getCuneiformPackageInfo(cachedPackages) {
+        const startTime = Date.now();
+        const notInstalledResult = {
+            installed: false,
+            licenseStatus: 'Not Installed',
+        };
+        try {
+            this.logger?.log('Fetching Cuneiform package info...');
+            const packagesResult = cachedPackages ?? (await this.getInstalledPackages());
+            if (!packagesResult.success) {
+                return createFailureResult(notInstalledResult, ServiceErrorCodes.ORG_CUNEIFORM_VERSION_FAILED, packagesResult.message ?? 'Failed to get Cuneiform info', {
+                    metadata: { duration: Date.now() - startTime },
+                });
+            }
+            const cuneiformPkg = OrgInfoService.findCuneiformPackage(packagesResult.data);
+            if (!cuneiformPkg) {
+                // CLI-1569: InstalledSubscriberPackage is empty in scratch orgs where packages are
+                // deployed as source (dev hub push) rather than installed from AppExchange.
+                // Fall back to namespace-based detection by querying a known Cuneiform CMT object.
+                const namespaceDetected = await this.detectCuneiformNamespace();
+                if (namespaceDetected) {
+                    const duration = Date.now() - startTime;
+                    this.logger?.log('Cuneiform detected via namespace (not subscriber package)');
+                    return createSuccessResult({
+                        installed: true,
+                        licenseStatus: 'Active',
+                    }, {
+                        message: 'Cuneiform detected via namespace (not via subscriber package)',
+                        metadata: { duration, detectionMethod: 'namespace' },
+                    });
+                }
+                const duration = Date.now() - startTime;
+                return createSuccessResult(notInstalledResult, {
+                    message: 'Cuneiform not installed',
+                    metadata: { duration },
+                });
+            }
+            // Package is installed - license status is assumed Active (Salesforce doesn't expose license expiration via standard APIs)
+            const info = {
+                installed: true,
+                version: cuneiformPkg.versionNumber,
+                licenseStatus: 'Active', // Default to Active if installed
+            };
+            const duration = Date.now() - startTime;
+            const versionStr = info.version ?? 'unknown';
+            this.logger?.log(`Cuneiform package info: v${versionStr}, ${info.licenseStatus}`);
+            return createSuccessResult(info, {
+                message: `Cuneiform v${versionStr} installed`,
+                metadata: { duration },
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger?.log(`Cuneiform package info failed: ${errorMessage}`);
+            return createFailureResult(notInstalledResult, ServiceErrorCodes.ORG_CUNEIFORM_VERSION_FAILED, errorMessage, {
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+    }
+    /**
+     * Retrieves business processes with associated record type counts.
+     *
+     * Queries BusinessProcess records and enriches each with the count and names
+     * of RecordTypes linked via BusinessProcessId. If no business processes exist,
+     * the RecordType query is skipped entirely.
+     *
+     * @returns ServiceResult containing BusinessProcessSummary
+     */
+    async getBusinessProcesses() {
+        const startTime = Date.now();
+        const emptyResult = { count: 0, processes: [] };
+        try {
+            this.logger?.log('Fetching business processes...');
+            // Query BusinessProcess records
+            const bpQuery = new CuneiformQueryBuilder()
+                .select(['Id', 'Name', 'TableEnumOrId', 'IsActive', 'Description'])
+                .from('BusinessProcess')
+                .orderBy('TableEnumOrId', 'ASC')
+                .toSOQL();
+            const bpResult = await this.soqlAdapter.query(bpQuery);
+            if (!bpResult.success) {
+                return createFailureResult(emptyResult, ServiceErrorCodes.ORG_BUSINESS_PROCESS_QUERY_FAILED, bpResult.message ?? 'BusinessProcess query failed', { metadata: { duration: Date.now() - startTime } });
+            }
+            const bpRecords = bpResult.data.records;
+            // Short-circuit if no business processes exist
+            if (bpRecords.length === 0) {
+                const duration = Date.now() - startTime;
+                return createSuccessResult(emptyResult, {
+                    message: 'No business processes found',
+                    metadata: { duration },
+                });
+            }
+            // Query RecordTypes linked to business processes
+            const warnings = [];
+            let rtRecords = [];
+            const rtQuery = new CuneiformQueryBuilder()
+                .select(['Id', 'Name', 'SobjectType', 'BusinessProcessId', 'IsActive'])
+                .from('RecordType')
+                .andWhereNull('BusinessProcessId', false)
+                .orderBy('Name', 'ASC')
+                .toSOQL();
+            const rtResult = await this.soqlAdapter.query(rtQuery);
+            if (rtResult.success) {
+                rtRecords = rtResult.data.records;
+            }
+            else {
+                warnings.push(`RecordType query failed: ${rtResult.message ?? 'Unknown error'}`);
+            }
+            // Group record types by BusinessProcessId
+            const rtByProcessId = new Map();
+            for (const rt of rtRecords) {
+                const group = rtByProcessId.get(rt.BusinessProcessId) ?? [];
+                group.push(rt);
+                rtByProcessId.set(rt.BusinessProcessId, group);
+            }
+            // Build process info with record type enrichment
+            const processes = bpRecords.map((bp) => {
+                const linkedRts = rtByProcessId.get(bp.Id) ?? [];
+                return {
+                    name: bp.Name,
+                    objectName: bp.TableEnumOrId,
+                    isActive: bp.IsActive,
+                    description: bp.Description ?? undefined,
+                    recordTypeCount: linkedRts.length,
+                    recordTypeNames: linkedRts.map((rt) => rt.Name),
+                };
+            });
+            const summary = {
+                count: processes.length,
+                processes,
+            };
+            const duration = Date.now() - startTime;
+            this.logger?.log(`Found ${summary.count} business processes`);
+            return createSuccessResult(summary, {
+                message: `Found ${summary.count} business processes`,
+                warnings: warnings.length > 0 ? warnings : undefined,
+                metadata: { duration },
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger?.log(`Business process query failed: ${errorMessage}`);
+            return createFailureResult(emptyResult, ServiceErrorCodes.ORG_BUSINESS_PROCESS_QUERY_FAILED, errorMessage, {
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+    }
+    // ── Private instance methods ────────────────────────────────────────
+    /**
+     * Delegates org info retrieval to the ISV REST API.
+     *
+     * @param startTime - Timestamp for duration tracking
+     * @returns ServiceResult containing OrgInfo from REST endpoint
+     */
+    async getOrgInfoViaRest(startTime) {
+        this.logger?.log('Delegating org info to ISV REST API (org-info)');
+        const emptyResult = {
+            identity: { userId: '', organizationId: '', username: '' },
+            limits: { limits: {} },
+            packages: [],
+            activeNamespaces: [],
+            cuneiformVersion: null,
+        };
+        const restResult = await this.restClient.getOrgInfo();
+        if (!restResult.success) {
+            return createFailureResult(emptyResult, ServiceErrorCodes.ORG_INFO_QUERY_FAILED, restResult.message ?? 'REST org-info failed', {
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+        const response = restResult.data;
+        if (!response.success) {
+            const errorMsg = response.errors?.length > 0 ? response.errors[0] : 'Server-side org info query failed';
+            return createFailureResult(emptyResult, ServiceErrorCodes.ORG_INFO_QUERY_FAILED, errorMsg, {
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+        return createSuccessResult(response.result ?? emptyResult, {
+            message: 'Org info retrieved via REST API',
+            metadata: { duration: Date.now() - startTime, strategyUsed: 'rest-api' },
+        });
+    }
+    /**
+     * Detects whether the Cuneiform namespace exists by querying a known CMT object.
+     *
+     * CLI-1569: InstalledSubscriberPackage is empty in scratch orgs where packages are
+     * deployed as source metadata. This method queries pnova__Active_Configuration__mdt
+     * as a lightweight namespace presence check — if the query succeeds (even with 0
+     * records), the namespace exists. If it fails with "sObject type not supported",
+     * the namespace is absent.
+     *
+     * @returns true if the pnova namespace is present, false otherwise
+     */
+    async detectCuneiformNamespace() {
+        try {
+            const soql = new CuneiformQueryBuilder()
+                .select(['Id'])
+                .from(`${CUNEIFORM_NAMESPACE}__Active_Configuration__mdt`)
+                .limit(1)
+                .toSOQL();
+            const result = await this.soqlAdapter.query(soql);
+            // If the query succeeds (regardless of record count), the namespace exists
+            return result.success;
+        }
+        catch {
+            // Any exception means namespace detection failed — treat as not installed
+            return false;
+        }
+    }
+    /**
+     * Probes whether a field exists on an object using a LIMIT 0 SOQL query.
+     * Returns true if the query succeeds (field exists), false if it fails or the
+     * sanitizer rejects the inputs. Much lighter than a full describe.
+     *
+     * **Input source contract**: callers must pass Salesforce API names already
+     * classified as safe (hardcoded constants, describeGlobal results, or upstream
+     * validated values). The sanitizer in buildProbeQuery defends against malformed
+     * identifiers as a last line of defence, but this method is NOT a user-input
+     * gateway — never wire it directly to a flag value or untrusted external input.
+     *
+     * Today's only call sites pass hardcoded constants from getOrgFeatures()
+     * (Account / BillingCountryCode / IsPersonAccount). The sanitizer is in place
+     * defensively so a future caller cannot accidentally introduce SOQL injection.
+     */
+    async probeFieldExists(objectName, fieldName) {
+        const soql = OrgInfoService.buildProbeQuery(objectName, fieldName);
+        if (soql === null) {
+            return false;
+        }
+        try {
+            const result = await this.soqlAdapter.query(soql);
+            return result.success;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Detects Sales Cloud and Service Cloud from license data and global describe.
+     *
+     * Uses license patterns to find Sales/Service Cloud licenses, then confirms
+     * by checking for Opportunity (Sales) and Case (Service) objects in the org.
+     */
+    async detectLicenseClouds(licenses, cachedGlobal) {
+        const salesCloudLicense = licenses.find((lic) => SALES_CLOUD_LICENSE_PATTERNS.some((pattern) => lic.masterLabel.includes(pattern) || lic.name.includes(pattern)));
+        const serviceCloudLicense = licenses.find((lic) => SERVICE_CLOUD_LICENSE_PATTERNS.some((pattern) => lic.masterLabel.includes(pattern) || lic.name.includes(pattern)));
+        // Check for Opportunity/Case objects to confirm Sales/Service Cloud
+        const { hasOpportunity, hasCase } = await this.resolveCloudObjects(cachedGlobal);
+        const clouds = [];
+        if (salesCloudLicense && hasOpportunity) {
+            clouds.push({
+                name: 'Sales Cloud',
+                type: 'license',
+                installed: true,
+                totalLicenses: salesCloudLicense.totalLicenses,
+                usedLicenses: salesCloudLicense.usedLicenses,
+                status: salesCloudLicense.status,
+            });
+        }
+        else {
+            clouds.push({ name: 'Sales Cloud', type: 'license', installed: false });
+        }
+        if (serviceCloudLicense && hasCase) {
+            clouds.push({
+                name: 'Service Cloud',
+                type: 'license',
+                installed: true,
+                totalLicenses: serviceCloudLicense.totalLicenses,
+                usedLicenses: serviceCloudLicense.usedLicenses,
+                status: serviceCloudLicense.status,
+            });
+        }
+        else {
+            clouds.push({ name: 'Service Cloud', type: 'license', installed: false });
+        }
+        return clouds;
+    }
+    /**
+     * Resolves whether Opportunity and Case objects exist in the org.
+     * Uses cached global describe if available, otherwise fetches fresh.
+     */
+    async resolveCloudObjects(cachedGlobal) {
+        if (cachedGlobal?.success) {
+            const sobjectNames = new Set(cachedGlobal.data.sobjects.map((obj) => obj.name));
+            return { hasOpportunity: sobjectNames.has('Opportunity'), hasCase: sobjectNames.has('Case') };
+        }
+        if (this.restAdapter) {
+            try {
+                const globalResult = await this.restAdapter.describeGlobal();
+                if (globalResult.success) {
+                    const sobjectNames = new Set(globalResult.data.sobjects.map((obj) => obj.name));
+                    return { hasOpportunity: sobjectNames.has('Opportunity'), hasCase: sobjectNames.has('Case') };
+                }
+            }
+            catch {
+                // Ignore error, use license-only detection
+            }
+        }
+        return { hasOpportunity: false, hasCase: false };
+    }
+}
+//# sourceMappingURL=OrgInfoService.js.map