fraim-framework 2.0.166 → 2.0.168

package/dist/src/cli/utils/github-workflow-sync.js

@@ -3,67 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GITHUB_WORKFLOW_ASSET_PREFIX = exports.GITHUB_WORKFLOW_HEADER = exports.GITHUB_WORKFLOW_MANIFEST_RELATIVE_PATH = void 0;
-exports.isGitHubWorkflowAutomationEnabled = isGitHubWorkflowAutomationEnabled;
-exports.decorateManagedGitHubWorkflow = decorateManagedGitHubWorkflow;
-exports.isFraimManagedGitHubWorkflow = isFraimManagedGitHubWorkflow;
-exports.loadGitHubWorkflowManifest = loadGitHubWorkflowManifest;
 exports.loadLocalGitHubWorkflowBundle = loadLocalGitHubWorkflowBundle;
 exports.fetchGitHubWorkflowBundle = fetchGitHubWorkflowBundle;
-exports.reconcileGitHubWorkflowAssets = reconcileGitHubWorkflowAssets;
+exports.installGitHubWorkflowAssets = installGitHubWorkflowAssets;
 exports.formatGitHubWorkflowSyncSummary = formatGitHubWorkflowSyncSummary;
 const axios_1 = __importDefault(require("axios"));
-const crypto_1 = __importDefault(require("crypto"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const config_loader_1 = require("../../core/config-loader");
 const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
-exports.GITHUB_WORKFLOW_MANIFEST_RELATIVE_PATH = path_1.default.join('fraim', 'managed-assets', 'github-workflows.json');
-exports.GITHUB_WORKFLOW_HEADER = '# FRAIM-MANAGED: github-workflow';
-exports.GITHUB_WORKFLOW_ASSET_PREFIX = '# FRAIM-ASSET-ID: ';
-function sha256(content) {
-    return `sha256:${crypto_1.default.createHash('sha256').update(content).digest('hex')}`;
-}
-function getManifestPath(projectRoot) {
-    return path_1.default.join(projectRoot, exports.GITHUB_WORKFLOW_MANIFEST_RELATIVE_PATH);
-}
-function isGitHubWorkflowAutomationEnabled(config) {
-    return config?.customizations?.githubWorkflows?.enabled === true;
-}
-function decorateManagedGitHubWorkflow(assetId, content) {
-    const normalized = content.replace(/^\uFEFF/, '');
-    const assetHeader = `${exports.GITHUB_WORKFLOW_HEADER}\n${exports.GITHUB_WORKFLOW_ASSET_PREFIX}${assetId}`;
-    if (normalized.includes(exports.GITHUB_WORKFLOW_HEADER) && normalized.includes(`${exports.GITHUB_WORKFLOW_ASSET_PREFIX}${assetId}`)) {
-        return normalized;
-    }
-    return `${assetHeader}\n${normalized}`;
-}
-function isFraimManagedGitHubWorkflow(content, assetId) {
-    if (!content.includes(exports.GITHUB_WORKFLOW_HEADER)) {
-        return false;
-    }
-    if (!assetId) {
-        return true;
-    }
-    return content.includes(`${exports.GITHUB_WORKFLOW_ASSET_PREFIX}${assetId}`);
-}
-function loadGitHubWorkflowManifest(projectRoot) {
-    const manifestPath = getManifestPath(projectRoot);
-    if (!fs_1.default.existsSync(manifestPath)) {
-        return {
-            version: 1,
-            enabled: true,
-            provider: 'github',
-            managedFiles: []
-        };
-    }
-    return JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf8'));
-}
-function writeGitHubWorkflowManifest(projectRoot, manifest) {
-    const manifestPath = getManifestPath(projectRoot);
-    fs_1.default.mkdirSync(path_1.default.dirname(manifestPath), { recursive: true });
-    fs_1.default.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
-}
 function loadLocalGitHubWorkflowBundle(registryRoot) {
     const workflowsRoot = path_1.default.join(registryRoot, 'github', 'workflows');
     if (!fs_1.default.existsSync(workflowsRoot)) {
@@ -77,8 +25,7 @@ function loadLocalGitHubWorkflowBundle(registryRoot) {
         return {
             path: entry.name,
             content,
-            type: 'github-workflow',
-            digest: sha256(content)
+            type: 'github-workflow'
         };
     });
     return files.sort((a, b) => a.path.localeCompare(b.path));
@@ -98,7 +45,7 @@ function readProjectConfig(projectRoot, config) {
     }
     return (0, config_loader_1.loadFraimConfig)((0, project_fraim_paths_1.getWorkspaceConfigPath)(projectRoot));
 }
-function reconcileGitHubWorkflowAssets(options) {
+function installGitHubWorkflowAssets(options) {
     const config = readProjectConfig(options.projectRoot, options.config);
     const provider = config.repository?.provider || null;
     if (provider !== 'github') {
@@ -109,108 +56,27 @@ function reconcileGitHubWorkflowAssets(options) {
             results: []
         };
     }
-    if (!isGitHubWorkflowAutomationEnabled(config)) {
-        return {
-            enabled: false,
-            provider,
-            skippedReason: 'GitHub workflow automation disabled',
-            results: []
-        };
-    }
-    const manifest = loadGitHubWorkflowManifest(options.projectRoot);
-    const manifestEntries = new Map(manifest.managedFiles.map((entry) => [entry.path, entry]));
     const workflowsDir = path_1.default.join(options.projectRoot, '.github', 'workflows');
     fs_1.default.mkdirSync(workflowsDir, { recursive: true });
     const results = [];
-    const nextManagedFiles = [];
     for (const file of options.files) {
-        const assetId = path_1.default.basename(file.path);
         const relativeWorkflowPath = path_1.default.join('.github', 'workflows', file.path).replace(/[\\/]/g, '/');
-        const destinationPath = path_1.default.join(options.projectRoot, '.github', 'workflows', file.path);
-        const desiredContent = decorateManagedGitHubWorkflow(assetId, file.content);
-        const desiredInstalledDigest = sha256(desiredContent);
-        const previousEntry = manifestEntries.get(relativeWorkflowPath);
-        if (!fs_1.default.existsSync(destinationPath)) {
-            fs_1.default.mkdirSync(path_1.default.dirname(destinationPath), { recursive: true });
-            fs_1.default.writeFileSync(destinationPath, desiredContent, 'utf8');
-            nextManagedFiles.push({
-                path: relativeWorkflowPath,
-                assetId,
-                sourceDigest: file.digest,
-                installedDigest: desiredInstalledDigest
-            });
-            results.push({
-                path: relativeWorkflowPath,
-                assetId,
-                status: 'installed'
-            });
-            continue;
-        }
-        const currentContent = fs_1.default.readFileSync(destinationPath, 'utf8');
-        const currentDigest = sha256(currentContent);
-        const ownedByFraim = isFraimManagedGitHubWorkflow(currentContent, assetId) || Boolean(previousEntry);
-        if (!ownedByFraim) {
-            if (previousEntry) {
-                nextManagedFiles.push(previousEntry);
-            }
-            results.push({
-                path: relativeWorkflowPath,
-                assetId,
-                status: 'conflict',
-                reason: 'same-named file exists without FRAIM ownership marker'
-            });
-            continue;
-        }
-        if (currentDigest === desiredInstalledDigest) {
-            nextManagedFiles.push({
-                path: relativeWorkflowPath,
-                assetId,
-                sourceDigest: file.digest,
-                installedDigest: desiredInstalledDigest
-            });
+        const destinationPath = path_1.default.join(workflowsDir, file.path);
+        if (fs_1.default.existsSync(destinationPath)) {
             results.push({
                 path: relativeWorkflowPath,
-                assetId,
-                status: 'already current'
+                status: 'skipped',
+                reason: 'already exists'
             });
             continue;
         }
-        if (previousEntry && currentDigest === previousEntry.installedDigest) {
-            fs_1.default.writeFileSync(destinationPath, desiredContent, 'utf8');
-            nextManagedFiles.push({
-                path: relativeWorkflowPath,
-                assetId,
-                sourceDigest: file.digest,
-                installedDigest: desiredInstalledDigest
-            });
-            results.push({
-                path: relativeWorkflowPath,
-                assetId,
-                status: 'updated'
-            });
-            continue;
-        }
-        nextManagedFiles.push(previousEntry || {
-            path: relativeWorkflowPath,
-            assetId,
-            sourceDigest: file.digest,
-            installedDigest: currentDigest
-        });
+        fs_1.default.mkdirSync(path_1.default.dirname(destinationPath), { recursive: true });
+        fs_1.default.writeFileSync(destinationPath, file.content, 'utf8');
         results.push({
             path: relativeWorkflowPath,
-            assetId,
-            status: 'conflict',
-            reason: previousEntry
-                ? 'managed file has local edits that do not match the last installed digest'
-                : 'FRAIM-managed header exists without manifest baseline'
+            status: 'installed'
         });
     }
-    writeGitHubWorkflowManifest(options.projectRoot, {
-        version: 1,
-        enabled: true,
-        provider: 'github',
-        managedFiles: nextManagedFiles.sort((a, b) => a.path.localeCompare(b.path))
-    });
     return {
         enabled: true,
         provider,
@@ -219,10 +85,10 @@ function reconcileGitHubWorkflowAssets(options) {
 }
 function formatGitHubWorkflowSyncSummary(result) {
     if (!result.enabled) {
-        return [`GitHub workflow reconciliation skipped: ${result.skippedReason || 'not enabled'}`];
+        return [`GitHub workflow install skipped: ${result.skippedReason || 'not enabled'}`];
     }
     if (result.results.length === 0) {
-        return ['GitHub workflow reconciliation: no workflow assets found'];
+        return ['GitHub workflow install: no workflow assets found'];
     }
     return result.results.map((item) => {
         const suffix = item.reason ? ` (${item.reason})` : '';

package/dist/src/cli/utils/manager-pack-sync.js

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MANAGER_CACHE_MANAGED_HEADER = exports.MANAGER_SYNC_METADATA_FILE = exports.MANAGER_CACHE_DIRNAME = void 0;
+exports.getManagerCacheDir = getManagerCacheDir;
+exports.readManagerCacheMetadata = readManagerCacheMetadata;
+exports.getManagerCacheAgeHours = getManagerCacheAgeHours;
+exports.syncManagerCache = syncManagerCache;
+/**
+ * Manager cache sync (issue #580).
+ *
+ * Materializes the manager's personal context/rules/learnings into the managed
+ * cache at ~/.fraim/manager/, from either backend:
+ *   - git: shallow snapshot of a manager-owned repo
+ *   - fraim-cloud: GET /api/manager/pack from the FRAIM server
+ *
+ * Cache files are managed content: marked, overwritten on every sync, and
+ * never a direct write target for agents.
+ */
+const axios_1 = __importDefault(require("axios"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
+const manager_pack_1 = require("../../core/manager-pack");
+const git_org_sync_1 = require("./git-org-sync");
+const user_config_1 = require("./user-config");
+exports.MANAGER_CACHE_DIRNAME = 'manager';
+exports.MANAGER_SYNC_METADATA_FILE = '.manager-sync-metadata.json';
+exports.MANAGER_CACHE_MANAGED_HEADER = '<!-- FRAIM_MANAGER_SYNC_MANAGED_CONTENT -->';
+const MANAGER_PACK_DIRS = ['context', 'rules', 'learnings'];
+function getManagerCacheDir() {
+    return path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), exports.MANAGER_CACHE_DIRNAME);
+}
+function readManagerCacheMetadata() {
+    try {
+        const metadataPath = path_1.default.join(getManagerCacheDir(), exports.MANAGER_SYNC_METADATA_FILE);
+        if (!fs_1.default.existsSync(metadataPath))
+            return null;
+        return JSON.parse(fs_1.default.readFileSync(metadataPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function getManagerCacheAgeHours() {
+    const metadata = readManagerCacheMetadata();
+    if (!metadata?.syncedAt)
+        return null;
+    const syncedAt = Date.parse(metadata.syncedAt);
+    if (Number.isNaN(syncedAt))
+        return null;
+    return Math.max(0, (Date.now() - syncedAt) / 3_600_000);
+}
+function decorateManagedManagerFile(content, backend) {
+    const normalized = content.replace(/^\uFEFF/, '');
+    if (normalized.startsWith(exports.MANAGER_CACHE_MANAGED_HEADER))
+        return normalized;
+    const writePath = backend === 'git'
+        ? 'open a pull request against your manager storage repo'
+        : 'publish the change through your FRAIM manager storage flow';
+    const marker = [
+        exports.MANAGER_CACHE_MANAGED_HEADER,
+        '> [!IMPORTANT]',
+        '> Synced from your personal manager storage. Local edits are overwritten on the next sync.',
+        `> To change this content, ${writePath}.`,
+        ''
+    ].join('\n');
+    return `${marker}\n${normalized}`;
+}
+function collectGitPackFiles(snapshotDir) {
+    const files = [];
+    for (const dirName of MANAGER_PACK_DIRS) {
+        const dirPath = path_1.default.join(snapshotDir, dirName);
+        if (!fs_1.default.existsSync(dirPath))
+            continue;
+        for (const entry of fs_1.default.readdirSync(dirPath, { withFileTypes: true })) {
+            if (!entry.isFile() || !entry.name.endsWith('.md'))
+                continue;
+            files.push({
+                relativePath: `${dirName}/${entry.name}`,
+                content: fs_1.default.readFileSync(path_1.default.join(dirPath, entry.name), 'utf8')
+            });
+        }
+    }
+    return files;
+}
+async function fetchCloudPack(remoteUrl, apiKey) {
+    const response = await axios_1.default.get(`${remoteUrl.replace(/\/$/, '')}/api/manager/pack`, {
+        headers: { 'x-api-key': apiKey },
+        timeout: 30_000
+    });
+    const files = Array.isArray(response.data?.files) ? response.data.files : [];
+    return {
+        files: files.filter((f) => typeof f?.relativePath === 'string' &&
+            (0, manager_pack_1.isManagerPackRelativePath)(f.relativePath) &&
+            typeof f?.content === 'string'),
+        version: String(response.data?.version ?? '0')
+    };
+}
+function materializeCache(files, metadata) {
+    const cacheDir = getManagerCacheDir();
+    const stagingDir = `${cacheDir}.staging-${process.pid}`;
+    fs_1.default.rmSync(stagingDir, { recursive: true, force: true });
+    fs_1.default.mkdirSync(stagingDir, { recursive: true });
+    for (const file of files) {
+        if (!(0, manager_pack_1.isManagerPackRelativePath)(file.relativePath))
+            continue;
+        const destination = path_1.default.join(stagingDir, file.relativePath);
+        fs_1.default.mkdirSync(path_1.default.dirname(destination), { recursive: true });
+        fs_1.default.writeFileSync(destination, decorateManagedManagerFile(file.content, metadata.backend));
+    }
+    fs_1.default.writeFileSync(path_1.default.join(stagingDir, exports.MANAGER_SYNC_METADATA_FILE), JSON.stringify(metadata, null, 2));
+    fs_1.default.rmSync(cacheDir, { recursive: true, force: true });
+    fs_1.default.renameSync(stagingDir, cacheDir);
+}
+async function discoverCloudManagerStorage(options) {
+    try {
+        const apiKey = options?.apiKey || (0, user_config_1.readUserFraimConfig)().apiKey;
+        if (!apiKey || apiKey === 'local-dev' || apiKey === 'test-mode-key')
+            return null;
+        const remoteUrl = options?.remoteUrl || process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me';
+        const pack = await fetchCloudPack(remoteUrl, apiKey);
+        if (pack.files.length === 0)
+            return null;
+        (0, user_config_1.writeUserFraimConfig)({ managerStorage: { backend: 'fraim-cloud' } });
+        return (0, user_config_1.getManagerStorageConfig)();
+    }
+    catch {
+        return null;
+    }
+}
+function failureOutcome(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const existing = readManagerCacheMetadata();
+    if (existing) {
+        return {
+            status: 'stale',
+            metadata: existing,
+            ageHours: getManagerCacheAgeHours() ?? 0,
+            error: message
+        };
+    }
+    return { status: 'absent', error: message };
+}
+async function syncManagerCache(options) {
+    let managerStorage = (0, user_config_1.getManagerStorageConfig)();
+    if (!managerStorage) {
+        managerStorage = await discoverCloudManagerStorage(options);
+        if (!managerStorage)
+            return { status: 'disabled' };
+    }
+    try {
+        if (managerStorage.backend === 'git') {
+            const snapshot = (0, git_org_sync_1.fetchOrgRepoSnapshot)(managerStorage.gitUrl);
+            try {
+                const metadata = {
+                    version: snapshot.sha,
+                    backend: 'git',
+                    source: managerStorage.gitUrl,
+                    syncedAt: new Date().toISOString()
+                };
+                materializeCache(collectGitPackFiles(snapshot.dir), metadata);
+                return { status: 'synced', metadata };
+            }
+            finally {
+                snapshot.cleanup();
+            }
+        }
+        const remoteUrl = options?.remoteUrl || process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me';
+        const apiKey = options?.apiKey || (0, user_config_1.readUserFraimConfig)().apiKey;
+        if (!apiKey)
+            throw new Error('No FRAIM API key available for the fraim-cloud manager backend.');
+        const pack = await fetchCloudPack(remoteUrl, apiKey);
+        const metadata = {
+            version: pack.version,
+            backend: 'fraim-cloud',
+            source: remoteUrl,
+            syncedAt: new Date().toISOString()
+        };
+        materializeCache(pack.files, metadata);
+        return { status: 'synced', metadata };
+    }
+    catch (error) {
+        return failureOutcome(error);
+    }
+}

package/dist/src/cli/utils/manager-publish.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.managerPackRelativePathFor = managerPackRelativePathFor;
+exports.publishManagerArtifacts = publishManagerArtifacts;
+/**
+ * Publish manager context/rules/learnings to the configured manager backend
+ * (issue #580).
+ */
+const axios_1 = __importDefault(require("axios"));
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const manager_pack_1 = require("../../core/manager-pack");
+const user_config_1 = require("./user-config");
+const ALLOWED_GIT_URL = /^(https?:\/\/|ssh:\/\/|git:\/\/|file:\/\/|[\w.-]+@[\w.-]+:)/;
+function managerPackRelativePathFor(filePath) {
+    const relativePath = (0, manager_pack_1.managerPackRelativePathForFileName)(filePath);
+    if (relativePath)
+        return relativePath;
+    const base = path_1.default.basename(filePath);
+    throw new Error(`Cannot infer manager-pack location for '${base}' (expected manager_context.md, manager_rules.md, or a personal learning file)`);
+}
+function gitCompareUrl(gitUrl, branch) {
+    const httpUrl = gitUrl.replace(/\.git$/, '').replace(/^git@([^:]+):/, 'https://$1/');
+    if (/^https?:\/\//.test(httpUrl))
+        return `${httpUrl}/compare/${branch}?expand=1`;
+    return undefined;
+}
+async function publishManagerArtifacts(artifacts, opts) {
+    const managerStorage = (0, user_config_1.getManagerStorageConfig)();
+    if (!managerStorage) {
+        throw new Error('No manager storage backend configured. Set the managerStorage block in ~/.fraim/config.json.');
+    }
+    if (artifacts.length === 0)
+        throw new Error('No artifacts to publish.');
+    for (const artifact of artifacts) {
+        if (!(0, manager_pack_1.isManagerPackRelativePath)(artifact.relativePath)) {
+            throw new Error(`Invalid manager-pack path '${artifact.relativePath}' (must be context/manager_context.md, rules/manager_rules.md, or learnings/<user>-*.md).`);
+        }
+    }
+    if (managerStorage.backend === 'fraim-cloud') {
+        const remoteUrl = opts?.remoteUrl || process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me';
+        const apiKey = opts?.apiKey || (0, user_config_1.readUserFraimConfig)().apiKey;
+        if (!apiKey)
+            throw new Error('No FRAIM API key available for the fraim-cloud manager backend.');
+        const res = await axios_1.default.post(`${remoteUrl.replace(/\/$/, '')}/api/manager/publish`, { artifacts }, { headers: { 'x-api-key': apiKey }, timeout: 30_000 });
+        return { backend: 'fraim-cloud', version: String(res.data?.version ?? '') };
+    }
+    const gitUrl = managerStorage.gitUrl;
+    if (!ALLOWED_GIT_URL.test(gitUrl))
+        throw new Error(`Manager repo URL has an unsupported scheme: ${gitUrl}`);
+    const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-manager-pub-'));
+    try {
+        (0, child_process_1.execFileSync)('git', ['clone', '--depth=1', '--quiet', '--', gitUrl, '.'], {
+            cwd: dir, stdio: ['ignore', 'pipe', 'pipe'], timeout: 60_000
+        });
+        const branch = `fraim-manager-update-${opts?.branchSuffix || `${process.pid}-${Date.now()}`}`;
+        (0, child_process_1.execFileSync)('git', ['checkout', '-b', branch], { cwd: dir, stdio: ['ignore', 'pipe', 'pipe'] });
+        for (const artifact of artifacts) {
+            const dest = path_1.default.join(dir, artifact.relativePath);
+            fs_1.default.mkdirSync(path_1.default.dirname(dest), { recursive: true });
+            fs_1.default.writeFileSync(dest, artifact.content);
+        }
+        (0, child_process_1.execFileSync)('git', ['add', '-A'], { cwd: dir, stdio: ['ignore', 'pipe', 'pipe'] });
+        (0, child_process_1.execFileSync)('git', ['commit', '-m', 'Update manager context'], { cwd: dir, stdio: ['ignore', 'pipe', 'pipe'] });
+        (0, child_process_1.execFileSync)('git', ['push', '--quiet', 'origin', branch], { cwd: dir, stdio: ['ignore', 'pipe', 'pipe'], timeout: 60_000 });
+        return { backend: 'git', branch, prUrl: gitCompareUrl(gitUrl, branch) };
+    }
+    finally {
+        fs_1.default.rmSync(dir, { recursive: true, force: true });
+    }
+}

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readUserFraimConfig = readUserFraimConfig;
 exports.writeUserFraimConfig = writeUserFraimConfig;
 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.
@@ -66,3 +67,22 @@ function getOrganizationConfig() {
     }
     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/core/config-loader.js

@@ -33,7 +33,8 @@ function normalizeIntegrations(config) {
         itsm: current.itsm && typeof current.itsm === 'object'
             ? {
                 provider: current.itsm.provider,
-                instanceUrl: current.itsm.instanceUrl
+                instanceUrl: current.itsm.instanceUrl,
+                accessScript: current.itsm.accessScript
             }
             : undefined,
         identity: current.identity && typeof current.identity === 'object'
@@ -49,13 +50,16 @@ function normalizeAutomation(config) {
         support: {
             startMode: support.startMode,
             defaultDecisionMode: support.defaultDecisionMode,
-            contextResolver: support.contextResolver && typeof support.contextResolver === 'object'
+            playbooks: support.playbooks && typeof support.playbooks === 'object'
                 ? {
-                    scriptPath: support.contextResolver.scriptPath,
-                    arguments: Array.isArray(support.contextResolver.arguments) ? support.contextResolver.arguments : undefined,
-                    timeoutMs: support.contextResolver.timeoutMs
+                    directory: support.playbooks.directory,
+                    decisionCommand: support.playbooks.decisionCommand,
+                    decisionTimeoutMs: support.playbooks.decisionTimeoutMs
                 }
                 : undefined,
+            actionAdapters: support.actionAdapters && typeof support.actionAdapters === 'object'
+                ? support.actionAdapters
+                : undefined,
             queue: support.queue && typeof support.queue === 'object'
                 ? {
                     provider: support.queue.provider,