fraim-hub 2.0.204

package/dist/src/cli/utils/script-sync-utils.js

@@ -0,0 +1,221 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserFraimDir = getUserFraimDir;
+exports.getUserScriptsDir = getUserScriptsDir;
+exports.ensureUserFraimDirectories = ensureUserFraimDirectories;
+exports.getRegistryScripts = getRegistryScripts;
+exports.copyScriptToUserDirectory = copyScriptToUserDirectory;
+exports.syncScriptsToUserDirectory = syncScriptsToUserDirectory;
+exports.cleanupObsoleteUserScripts = cleanupObsoleteUserScripts;
+exports.getUserScriptPath = getUserScriptPath;
+exports.userScriptExists = userScriptExists;
+exports.validateUserScripts = validateUserScripts;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Get the user-level FRAIM directory path
+ * Can be overridden with FRAIM_USER_DIR environment variable for testing
+ */
+function getUserFraimDir() {
+    return process.env.FRAIM_USER_DIR || path_1.default.join(os_1.default.homedir(), '.fraim');
+}
+/**
+ * Get the user-level scripts directory path
+ */
+function getUserScriptsDir() {
+    return path_1.default.join(getUserFraimDir(), 'scripts');
+}
+/**
+ * Ensure the user-level FRAIM directories exist and initialize user config
+ */
+function ensureUserFraimDirectories() {
+    const userFraimDir = getUserFraimDir();
+    const userScriptsDir = getUserScriptsDir();
+    if (!fs_1.default.existsSync(userFraimDir)) {
+        fs_1.default.mkdirSync(userFraimDir, { recursive: true });
+    }
+    if (!fs_1.default.existsSync(userScriptsDir)) {
+        fs_1.default.mkdirSync(userScriptsDir, { recursive: true });
+    }
+    // Initialize user config (~/.fraim/config.json) if it doesn't exist
+    const userConfigPath = path_1.default.join(userFraimDir, 'config.json');
+    if (!fs_1.default.existsSync(userConfigPath)) {
+        fs_1.default.writeFileSync(userConfigPath, JSON.stringify({ workingStyle: 'PR' }, null, 2));
+    }
+}
+/**
+ * Get all script files from the registry (recursively)
+ */
+function getRegistryScripts(registryPath) {
+    const scriptsPath = path_1.default.join(registryPath, 'scripts');
+    if (!fs_1.default.existsSync(scriptsPath)) {
+        return [];
+    }
+    const getAllFiles = (dir, baseDir = dir) => {
+        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        let files = [];
+        for (const entry of entries) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Recursively get files from subdirectories
+                files = files.concat(getAllFiles(fullPath, baseDir));
+            }
+            else {
+                // Include all files (not just specific extensions)
+                files.push(fullPath);
+            }
+        }
+        return files;
+    };
+    return getAllFiles(scriptsPath);
+}
+/**
+ * Copy a script file to the user scripts directory with proper permissions
+ * Preserves directory structure from registry/scripts/
+ */
+function copyScriptToUserDirectory(sourcePath, registryScriptsPath) {
+    const userScriptsDir = getUserScriptsDir();
+    // Calculate relative path from registry/scripts to preserve structure
+    const relativePath = path_1.default.relative(registryScriptsPath, sourcePath);
+    const targetPath = path_1.default.join(userScriptsDir, relativePath);
+    // Ensure target directory exists
+    const targetDir = path_1.default.dirname(targetPath);
+    if (!fs_1.default.existsSync(targetDir)) {
+        fs_1.default.mkdirSync(targetDir, { recursive: true });
+    }
+    // Copy the file
+    fs_1.default.copyFileSync(sourcePath, targetPath);
+    // Set executable permissions on Unix systems for shell scripts
+    if (process.platform !== 'win32' && sourcePath.endsWith('.sh')) {
+        try {
+            fs_1.default.chmodSync(targetPath, 0o755);
+        }
+        catch (error) {
+            console.warn(chalk_1.default.yellow(`⚠️ Could not set executable permissions for ${relativePath}`));
+        }
+    }
+}
+/**
+ * Sync all scripts from registry to user directory
+ */
+function syncScriptsToUserDirectory(registryPath) {
+    ensureUserFraimDirectories();
+    const registryScriptsPath = path_1.default.join(registryPath, 'scripts');
+    const allScripts = getRegistryScripts(registryPath);
+    let syncedCount = 0;
+    console.log(chalk_1.default.gray(`  Syncing all scripts to ~/.fraim/scripts/:`));
+    for (const scriptPath of allScripts) {
+        const relativePath = path_1.default.relative(registryScriptsPath, scriptPath);
+        const userScriptPath = path_1.default.join(getUserScriptsDir(), relativePath);
+        try {
+            // Check if script needs updating
+            let needsUpdate = true;
+            if (fs_1.default.existsSync(userScriptPath)) {
+                const registryContent = fs_1.default.readFileSync(scriptPath, 'utf-8');
+                const userContent = fs_1.default.readFileSync(userScriptPath, 'utf-8');
+                needsUpdate = registryContent !== userContent;
+            }
+            if (needsUpdate) {
+                copyScriptToUserDirectory(scriptPath, registryScriptsPath);
+                syncedCount++;
+                console.log(chalk_1.default.gray(`    + ${relativePath}`));
+            }
+            else {
+                console.log(chalk_1.default.gray(`    = ${relativePath} (up to date)`));
+            }
+        }
+        catch (error) {
+            console.warn(chalk_1.default.yellow(`⚠️ Could not sync script ${relativePath}: ${error}`));
+        }
+    }
+    return { synced: syncedCount, ephemeral: 0 };
+}
+/**
+ * Clean up scripts in user directory that no longer exist in registry
+ */
+function cleanupObsoleteUserScripts(registryPath) {
+    const userScriptsDir = getUserScriptsDir();
+    if (!fs_1.default.existsSync(userScriptsDir)) {
+        return 0;
+    }
+    const registryScriptsPath = path_1.default.join(registryPath, 'scripts');
+    const registryScripts = getRegistryScripts(registryPath);
+    const registryRelativePaths = registryScripts.map(scriptPath => path_1.default.relative(registryScriptsPath, scriptPath));
+    // Get all files in user scripts directory recursively
+    const getAllUserFiles = (dir, baseDir = dir) => {
+        if (!fs_1.default.existsSync(dir))
+            return [];
+        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        let files = [];
+        for (const entry of entries) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                files = files.concat(getAllUserFiles(fullPath, baseDir));
+            }
+            else {
+                files.push(path_1.default.relative(baseDir, fullPath));
+            }
+        }
+        return files;
+    };
+    const userFiles = getAllUserFiles(userScriptsDir);
+    let cleanedCount = 0;
+    for (const userFile of userFiles) {
+        // Normalize path separators for comparison
+        const normalizedUserFile = userFile.replace(/\\/g, '/');
+        const normalizedRegistry = registryRelativePaths.map(p => p.replace(/\\/g, '/'));
+        if (!normalizedRegistry.includes(normalizedUserFile)) {
+            try {
+                const userFilePath = path_1.default.join(userScriptsDir, userFile);
+                fs_1.default.unlinkSync(userFilePath);
+                cleanedCount++;
+                console.log(chalk_1.default.yellow(`  - ${userFile} (removed from registry)`));
+                // Cleanup empty directories
+                try {
+                    const dir = path_1.default.dirname(userFilePath);
+                    if (fs_1.default.existsSync(dir) && fs_1.default.readdirSync(dir).length === 0) {
+                        fs_1.default.rmdirSync(dir);
+                    }
+                }
+                catch (e) { }
+            }
+            catch (error) {
+                console.warn(chalk_1.default.yellow(`⚠️ Could not remove obsolete script ${userFile}: ${error}`));
+            }
+        }
+    }
+    return cleanedCount;
+}
+/**
+ * Get the path to a script in the user directory
+ */
+function getUserScriptPath(scriptName) {
+    return path_1.default.join(getUserScriptsDir(), scriptName);
+}
+/**
+ * Check if a script exists in the user directory
+ */
+function userScriptExists(scriptName) {
+    return fs_1.default.existsSync(getUserScriptPath(scriptName));
+}
+/**
+ * Validate that all expected scripts are present in user directory
+ */
+function validateUserScripts(expectedScripts) {
+    const missing = [];
+    const present = [];
+    for (const scriptName of expectedScripts) {
+        if (userScriptExists(scriptName)) {
+            present.push(scriptName);
+        }
+        else {
+            missing.push(scriptName);
+        }
+    }
+    return { missing, present };
+}

package/dist/src/cli/utils/user-config.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readUserFraimConfig = readUserFraimConfig;
+exports.writeUserFraimConfig = writeUserFraimConfig;
+exports.getInstalledIdes = getInstalledIdes;
+exports.addInstalledIde = addInstalledIde;
+exports.getOrganizationConfig = getOrganizationConfig;
+exports.getManagerStorageConfig = getManagerStorageConfig;
+/**
+ * Typed read/write helpers for the user-level FRAIM config (~/.fraim/config.json),
+ * including the organization block introduced by issue #563.
+ *
+ * The user-level config is machine-scoped and distinct from the workspace
+ * config (fraim/config.json). Honors the FRAIM_USER_DIR override used by tests.
+ */
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
+function getUserConfigPath() {
+    return path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'config.json');
+}
+function readUserFraimConfig() {
+    try {
+        const configPath = getUserConfigPath();
+        if (!fs_1.default.existsSync(configPath))
+            return {};
+        const parsed = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Shallow-merge a patch into the user config and persist it. Existing keys
+ * not named in the patch are preserved. Setting a key to undefined removes it.
+ */
+function writeUserFraimConfig(patch) {
+    const current = readUserFraimConfig();
+    const merged = { ...current, ...patch };
+    for (const key of Object.keys(patch)) {
+        if (patch[key] === undefined)
+            delete merged[key];
+    }
+    const dir = (0, project_fraim_paths_1.getUserFraimDirPath)();
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.writeFileSync(getUserConfigPath(), JSON.stringify(merged, null, 2));
+    return merged;
+}
+function getInstalledIdes() {
+    const raw = readUserFraimConfig().installedIdes;
+    return Array.isArray(raw) ? raw : null;
+}
+function addInstalledIde(configType) {
+    const current = getInstalledIdes() ?? [];
+    if (!current.includes(configType)) {
+        writeUserFraimConfig({ installedIdes: [...current, configType] });
+    }
+}
+/**
+ * Resolve the validated organization configuration, or null when no valid
+ * organization is configured on this machine (R1.1).
+ */
+function getOrganizationConfig() {
+    const raw = readUserFraimConfig().organization;
+    if (!raw || typeof raw !== 'object')
+        return null;
+    if (raw.backend === 'git') {
+        const gitUrl = typeof raw.gitUrl === 'string' ? raw.gitUrl.trim() : '';
+        if (!gitUrl)
+            return null;
+        return { backend: 'git', gitUrl, id: raw.id };
+    }
+    if (raw.backend === 'fraim-cloud') {
+        return { backend: 'fraim-cloud', id: raw.id };
+    }
+    return null;
+}
+/**
+ * Resolve the validated manager storage configuration, or null when no portable
+ * manager backend is configured on this machine.
+ */
+function getManagerStorageConfig() {
+    const raw = readUserFraimConfig().managerStorage;
+    if (!raw || typeof raw !== 'object')
+        return null;
+    if (raw.backend === 'git') {
+        const gitUrl = typeof raw.gitUrl === 'string' ? raw.gitUrl.trim() : '';
+        if (!gitUrl)
+            return null;
+        return { backend: 'git', gitUrl, id: raw.id };
+    }
+    if (raw.backend === 'fraim-cloud') {
+        return { backend: 'fraim-cloud', id: raw.id };
+    }
+    return null;
+}

package/dist/src/cli/utils/version-utils.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFraimVersion = getFraimVersion;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function getFraimVersion() {
+    // Try reliable paths to find package.json relative to this file
+    // locally: src/cli/utils/version-utils.ts -> package.json is ../../../package.json
+    // dist: dist/src/cli/utils/version-utils.js -> package.json is ../../../../package.json
+    // Traverse up from __dirname until we find a FRAIM package.json.
+    // Fixed relative paths break when npx cache layouts differ across OS/npm versions.
+    let dir = __dirname;
+    for (let i = 0; i < 10; i++) {
+        const pkgPath = path_1.default.join(dir, 'package.json');
+        if (fs_1.default.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf-8'));
+                if (pkg.name === 'fraim' || pkg.name === 'fraim-hub' || pkg.name === 'fraim-workspace') {
+                    return pkg.version;
+                }
+            }
+            catch (e) {
+                // Ignore parsing errors
+            }
+        }
+        const parent = path_1.default.dirname(dir);
+        if (parent === dir)
+            break; // Reached filesystem root
+        dir = parent;
+    }
+    return 'unknown'; // Do not return a fake version — unknown is safer than misleading
+}

package/dist/src/config/ai-manager-hiring.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HUMAN_MANAGER_PROFILES = exports.AI_MANAGER_QUALITIES = exports.HIRING_SERVICES = void 0;
+exports.getHumanManagerProfile = getHumanManagerProfile;
+exports.buildSearchQuery = buildSearchQuery;
+exports.buildJobDescription = buildJobDescription;
+exports.buildServiceUrl = buildServiceUrl;
+exports.buildManagerHiringCatalog = buildManagerHiringCatalog;
+/**
+ * Issue #538 — human-manager hiring engine (app side).
+ *
+ * Self-contained on purpose: the app (AI Hub UI modal + bootstrap) must resolve this
+ * at runtime in every packaging context (dev tsx, compiled dist, packed CLI), so it
+ * must NOT import across the app→registry boundary. The `hire-the-right-human-ai-manager`
+ * job uses the mirror engine `registry/scripts/ai-manager-hiring.ts` (self-contained +
+ * CLI). The two are kept identical by a parity test (tests/isolated/test-538-ai-manager-hiring.ts);
+ * that is the DRY contract — one behavior, enforced, with no fragile cross-boundary import.
+ */
+const persona_hiring_1 = require("./persona-hiring");
+exports.HIRING_SERVICES = ['linkedin', 'indeed', 'seekout'];
+/** The qualities of a strong AI manager — embedded in both the query and the JD. */
+exports.AI_MANAGER_QUALITIES = [
+    { title: 'Clear specification & written communication', detail: 'Can brief an AI agent so it executes correctly the first time.' },
+    { title: 'Trust-but-verify judgment', detail: 'Knows when to delegate to the agent and when to review deeply.' },
+    { title: 'Coaching mindset', detail: 'Gives feedback that compounds into reusable rules and learnings.' },
+    { title: 'Outcome ownership & AI fluency', detail: 'Owns results; comfortable directing autonomous agents.' },
+];
+const GENERALIST_PROFILE = {
+    humanTitle: 'Manager',
+    keywords: ['"Manager"', '"Director"', '"Team Lead"', '"Chief of Staff"'],
+};
+/** Role key -> the human manager best suited to manage that AI employee. Mirror of registry/scripts/ai-manager-hiring.ts. */
+exports.HUMAN_MANAGER_PROFILES = {
+    maestro: { humanTitle: 'Co-Founder / General Manager', keywords: ['"Co-Founder"', '"General Manager"', '"Chief of Staff"', '"Founder"'] },
+    beza: { humanTitle: 'Head of Strategy', keywords: ['"Head of Strategy"', '"Strategy Director"', '"Chief of Staff"'] },
+    pam: { humanTitle: 'Head of Product', keywords: ['"Head of Product"', '"Group Product Manager"', '"Director of Product"'] },
+    swen: { humanTitle: 'Engineering Manager', keywords: ['"Engineering Manager"', '"Tech Lead"', '"Staff Software Engineer"'] },
+    qasm: { humanTitle: 'QA Manager', keywords: ['"QA Manager"', '"QA Lead"', '"Head of Quality"'] },
+    huxley: { humanTitle: 'Design Manager', keywords: ['"Design Manager"', '"Head of Design"', '"Design Lead"'] },
+    gautam: { humanTitle: 'Marketing Director', keywords: ['"Head of Growth"', '"Marketing Director"', '"Demand Generation Lead"'] },
+    cela: { humanTitle: 'General Counsel', keywords: ['"General Counsel"', '"Head of Legal"', '"Legal Director"'] },
+    sekhar: { humanTitle: 'Security Manager', keywords: ['"Security Manager"', '"Head of Security"', '"CISO"'] },
+    ashley: { humanTitle: 'Chief of Staff', keywords: ['"Chief of Staff"', '"Executive Operations Manager"', '"Office Manager"'] },
+    mandy: { humanTitle: 'Head of Operations', keywords: ['"Head of Operations"', '"Director of Operations"', '"Program Manager"'] },
+    ricardo: { humanTitle: 'Recruiting Manager', keywords: ['"Recruiting Manager"', '"Head of Talent"', '"Talent Acquisition Lead"'] },
+    hari: { humanTitle: 'HR Manager', keywords: ['"HR Manager"', '"Head of People"', '"HR Business Partner"'] },
+    careena: { humanTitle: 'Head of Talent Development', keywords: ['"Head of Talent Development"', '"L&D Manager"', '"Career Coaching Lead"'] },
+    sade: { humanTitle: 'Salesforce Manager', keywords: ['"Salesforce Manager"', '"CRM Lead"', '"Salesforce Architect"'] },
+    sam: { humanTitle: 'Sales Manager', keywords: ['"Sales Manager"', '"Head of Sales"', '"Director of Sales"'] },
+    casey: { humanTitle: 'Customer Success Manager', keywords: ['"Customer Success Manager"', '"Head of Customer Success"', '"Support Manager"'] },
+    deidre: { humanTitle: 'Head of DEI', keywords: ['"Head of DEI"', '"Director of Inclusion"', '"DEI Program Manager"'] },
+    mona: { humanTitle: 'Finance Manager', keywords: ['"Finance Manager"', '"Head of Finance"', '"Controller"'] },
+    sreya: { humanTitle: 'SRE Manager', keywords: ['"SRE Manager"', '"Head of Reliability"', '"Platform Engineering Lead"'] },
+    procella: { humanTitle: 'Procurement Manager', keywords: ['"Procurement Manager"', '"Head of Procurement"', '"Sourcing Lead"'] },
+    banke: { humanTitle: 'KYC Operations Manager', keywords: ['"KYC Operations Manager"', '"AML Compliance Manager"', '"Banking Compliance Lead"'] },
+    auditya: { humanTitle: 'Audit Manager', keywords: ['"Audit Manager"', '"Internal Audit Lead"', '"Compliance Audit Manager"'] },
+};
+function getHumanManagerProfile(roleKey) {
+    return exports.HUMAN_MANAGER_PROFILES[roleKey] ?? GENERALIST_PROFILE;
+}
+const AI_MANAGER_QUERY_TERMS = '("AI" OR "LLM" OR "agentic") AND ("coaching" OR "mentoring")';
+function buildSearchQuery(roleKey) {
+    const profile = getHumanManagerProfile(roleKey);
+    return `${profile.keywords.join(' OR ')} AND ${AI_MANAGER_QUERY_TERMS}`;
+}
+function buildJobDescription(roleKey) {
+    const profile = getHumanManagerProfile(roleKey);
+    const role = persona_hiring_1.PERSONA_HIRE_CATALOG[roleKey]?.role ?? 'AI Employee';
+    return [
+        `${profile.humanTitle} — manager for an ${role}`,
+        '',
+        `You will manage an ${role} (an autonomous AI agent) and the humans around it, owning the outcomes it ships.`,
+        '',
+        "What you'll do:",
+        `- Write crisp specifications and acceptance criteria the ${role} can execute against.`,
+        `- Review the agent's output with judgment: know when to trust it and when to dig in.`,
+        '- Coach the agent and team so feedback compounds into reusable rules.',
+        '- Own delivery outcomes, not activity; prioritize ruthlessly.',
+        '',
+        'What makes a strong AI manager:',
+        ...exports.AI_MANAGER_QUALITIES.map((q) => `- ${q.title}: ${q.detail}`),
+    ].join('\n');
+}
+function buildServiceUrl(service, query, location) {
+    const q = encodeURIComponent(query);
+    const loc = location && location.trim().length > 0 ? location.trim() : '';
+    switch (service) {
+        case 'linkedin':
+            return `https://www.linkedin.com/search/results/people/?keywords=${q}`;
+        case 'indeed':
+            return `https://www.indeed.com/jobs?q=${q}${loc ? `&l=${encodeURIComponent(loc)}` : ''}`;
+        case 'seekout':
+            return 'https://app.seekout.com/';
+    }
+}
+/**
+ * Catalog projection for the AI Hub bootstrap so the client renders off the server's
+ * source of truth. Defaults to exactly the hireable personas in `PERSONA_HIRE_CATALOG`.
+ */
+function buildManagerHiringCatalog(roleKeys = Object.keys(persona_hiring_1.PERSONA_HIRE_CATALOG)) {
+    const roles = {};
+    for (const key of roleKeys) {
+        const profile = getHumanManagerProfile(key);
+        const query = buildSearchQuery(key);
+        // managedRole is derived from PERSONA_HIRE_CATALOG so the bootstrap response
+        // shape is unchanged even after removing the field from HumanManagerProfile.
+        const managedRole = persona_hiring_1.PERSONA_HIRE_CATALOG[key]?.role ?? 'AI Employee';
+        roles[key] = {
+            ...profile,
+            managedRole,
+            query,
+            jobDescription: buildJobDescription(key),
+            serviceUrls: {
+                linkedin: buildServiceUrl('linkedin', query),
+                indeed: buildServiceUrl('indeed', query),
+                seekout: buildServiceUrl('seekout', query),
+            },
+        };
+    }
+    return { qualities: exports.AI_MANAGER_QUALITIES, services: exports.HIRING_SERVICES, roles };
+}

package/dist/src/config/feature-flags.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFeatureFlags = getFeatureFlags;
+exports.isPersonaEntitlementsEnabled = isPersonaEntitlementsEnabled;
+exports.getPublicFeatureFlags = getPublicFeatureFlags;
+function parseBooleanFlag(value) {
+    if (!value)
+        return false;
+    return ['1', 'true', 'yes', 'on'].includes(value.trim().toLowerCase());
+}
+function getFeatureFlags() {
+    return {
+        personaEntitlements: {
+            enabled: parseBooleanFlag(process.env.FRAIM_FF_PERSONA_ENTITLEMENTS)
+        }
+    };
+}
+function isPersonaEntitlementsEnabled() {
+    return getFeatureFlags().personaEntitlements.enabled;
+}
+function getPublicFeatureFlags() {
+    return {
+        personaEntitlementsEnabled: isPersonaEntitlementsEnabled()
+    };
+}