factory-factory 0.3.9 → 0.3.11

package/dist/src/backend/domains/session/lifecycle/session.config.service.js

@@ -1,635 +0,0 @@
-import { sessionDomainService } from '../../../../backend/domains/session/session-domain.service.js';
-import { userSettingsAccessor } from '../../../../backend/resource_accessors/user-settings.accessor.js';
-import { createLogger } from '../../../../backend/services/logger.service.js';
-import { EMPTY_CHAT_BAR_CAPABILITIES } from '../../../../shared/chat-capabilities.js';
-const logger = createLogger('session');
-export class SessionConfigService {
-    repository;
-    runtimeManager;
-    sessionDomainService;
-    constructor(options) {
-        this.repository = options.repository;
-        this.runtimeManager = options.runtimeManager;
-        this.sessionDomainService = options.sessionDomainService ?? sessionDomainService;
-    }
-    applyConfigOptionsUpdateDelta(sessionId, handle, configOptions) {
-        handle.configOptions = configOptions;
-        void this.persistAcpConfigSnapshot(sessionId, {
-            provider: handle.provider,
-            providerSessionId: handle.providerSessionId,
-            configOptions: handle.configOptions,
-        });
-        this.sessionDomainService.emitDelta(sessionId, {
-            type: 'config_options_update',
-            configOptions,
-        });
-        this.sessionDomainService.emitDelta(sessionId, {
-            type: 'chat_capabilities',
-            capabilities: this.buildAcpChatBarCapabilities(handle),
-        });
-    }
-    async applyStartupModePreset(sessionId, handle, startupModePreset, workflow, options) {
-        if (!startupModePreset) {
-            return;
-        }
-        const modeResult = await this.applyStartupCollaborationModePreset({
-            sessionId,
-            handle,
-            startupModePreset,
-            workflow,
-            configOptions: handle.configOptions,
-        });
-        const executionResult = await this.applyStartupExecutionModePreset({
-            sessionId,
-            handle,
-            startupModePreset,
-            workflow,
-            configOptions: modeResult.configOptions,
-        });
-        const didUpdate = modeResult.didUpdate || executionResult.didUpdate;
-        if (!didUpdate) {
-            return;
-        }
-        const persistSnapshot = options?.persistSnapshot ?? this.persistAcpConfigSnapshot.bind(this);
-        handle.configOptions = executionResult.configOptions;
-        try {
-            await persistSnapshot(sessionId, {
-                provider: handle.provider,
-                providerSessionId: handle.providerSessionId,
-                configOptions: executionResult.configOptions,
-            });
-            this.sessionDomainService.emitDelta(sessionId, {
-                type: 'config_options_update',
-                configOptions: executionResult.configOptions,
-            });
-            this.sessionDomainService.emitDelta(sessionId, {
-                type: 'chat_capabilities',
-                capabilities: this.buildAcpChatBarCapabilities(handle),
-            });
-        }
-        catch (error) {
-            logger.warn('Failed persisting startup mode preset configuration snapshot', {
-                sessionId,
-                provider: handle.provider,
-                workflow,
-                startupModePreset,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async applyConfiguredPermissionPreset(sessionId, session, handle) {
-        if (handle.provider !== 'CODEX') {
-            return;
-        }
-        const executionModeOption = handle.configOptions.find((option) => option.id === 'execution_mode' || option.category === 'permission');
-        if (!executionModeOption) {
-            return;
-        }
-        let permissionPreset = session.workflow === 'ratchet' ? 'YOLO' : 'STRICT';
-        try {
-            const settings = await userSettingsAccessor.get();
-            permissionPreset =
-                session.workflow === 'ratchet'
-                    ? settings.ratchetPermissions
-                    : settings.defaultWorkspacePermissions;
-        }
-        catch (error) {
-            logger.warn('Failed loading user permission presets; using defaults', {
-                sessionId,
-                workflow: session.workflow,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-        const targetExecutionMode = this.resolveConfiguredExecutionModeTarget(executionModeOption, permissionPreset);
-        if (!targetExecutionMode) {
-            return;
-        }
-        const currentExecutionMode = executionModeOption.currentValue
-            ? String(executionModeOption.currentValue)
-            : null;
-        if (currentExecutionMode === targetExecutionMode) {
-            return;
-        }
-        try {
-            const configOptions = await this.runtimeManager.setConfigOption(sessionId, executionModeOption.id, targetExecutionMode);
-            handle.configOptions = configOptions;
-            await this.persistAcpConfigSnapshot(sessionId, {
-                provider: handle.provider,
-                providerSessionId: handle.providerSessionId,
-                configOptions,
-            });
-            this.sessionDomainService.emitDelta(sessionId, {
-                type: 'config_options_update',
-                configOptions,
-            });
-            this.sessionDomainService.emitDelta(sessionId, {
-                type: 'chat_capabilities',
-                capabilities: this.buildAcpChatBarCapabilities(handle),
-            });
-        }
-        catch (error) {
-            logger.warn('Failed applying configured session permission preset', {
-                sessionId,
-                workflow: session.workflow,
-                permissionPreset,
-                targetExecutionMode,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    getSessionConfigOptions(sessionId) {
-        const acpHandle = this.runtimeManager.getClient(sessionId);
-        return acpHandle ? [...acpHandle.configOptions] : [];
-    }
-    async getSessionConfigOptionsWithFallback(sessionId) {
-        const liveConfigOptions = this.getSessionConfigOptions(sessionId);
-        if (liveConfigOptions.length > 0) {
-            return liveConfigOptions;
-        }
-        const session = await this.repository.getSessionById(sessionId);
-        if (!session) {
-            return [];
-        }
-        const cachedSnapshot = this.extractAcpConfigSnapshot(session.providerMetadata);
-        if (cachedSnapshot && cachedSnapshot.provider === session.provider) {
-            return [...cachedSnapshot.configOptions];
-        }
-        return [];
-    }
-    async setSessionModel(sessionId, model) {
-        const acpHandle = this.runtimeManager.getClient(sessionId);
-        if (acpHandle) {
-            const modelOption = acpHandle.configOptions.find((option) => option.category === 'model');
-            if (modelOption && model) {
-                const availableValues = this.getConfigOptionValues(modelOption);
-                if (availableValues.length > 0 && !availableValues.includes(model)) {
-                    logger.debug('Skipping unsupported model for ACP session', {
-                        sessionId,
-                        provider: acpHandle.provider,
-                        model,
-                        availableValues,
-                    });
-                    return;
-                }
-                await this.setSessionConfigOption(sessionId, modelOption.id, model);
-            }
-            return;
-        }
-        logger.debug('No ACP handle for setSessionModel', { sessionId, model });
-    }
-    async setSessionThinkingBudget(sessionId, maxTokens) {
-        const acpHandle = this.runtimeManager.getClient(sessionId);
-        if (acpHandle) {
-            const thoughtOption = acpHandle.configOptions.find((option) => option.category === 'thought_level');
-            if (thoughtOption && maxTokens != null) {
-                await this.setSessionConfigOption(sessionId, thoughtOption.id, String(maxTokens));
-            }
-            return;
-        }
-        logger.debug('No ACP handle for setSessionThinkingBudget', { sessionId, maxTokens });
-    }
-    async setSessionConfigOption(sessionId, configId, value) {
-        const acpHandle = this.runtimeManager.getClient(sessionId);
-        if (!acpHandle) {
-            const configOptions = await this.setCachedSessionConfigOption(sessionId, configId, value);
-            this.sessionDomainService.emitDelta(sessionId, {
-                type: 'config_options_update',
-                configOptions,
-            });
-            return;
-        }
-        const selectedOption = acpHandle.configOptions.find((option) => option.id === configId);
-        const isModeOption = configId === 'mode' || selectedOption?.category === 'mode';
-        const isModelOption = configId === 'model' || selectedOption?.category === 'model';
-        const configOptions = isModeOption
-            ? await this.runtimeManager.setSessionMode(sessionId, value)
-            : isModelOption
-                ? await this.runtimeManager.setSessionModel(sessionId, value)
-                : await this.runtimeManager.setConfigOption(sessionId, configId, value);
-        this.sessionDomainService.emitDelta(sessionId, {
-            type: 'config_options_update',
-            configOptions,
-        });
-        const acpHandleAfterUpdate = this.runtimeManager.getClient(sessionId);
-        if (acpHandleAfterUpdate) {
-            await this.persistAcpConfigSnapshot(sessionId, {
-                provider: acpHandleAfterUpdate.provider,
-                providerSessionId: acpHandleAfterUpdate.providerSessionId,
-                configOptions,
-            });
-        }
-    }
-    async getChatBarCapabilities(sessionId) {
-        const acpHandle = this.runtimeManager.getClient(sessionId);
-        if (acpHandle) {
-            return this.buildAcpChatBarCapabilities(acpHandle);
-        }
-        const session = await this.repository.getSessionById(sessionId);
-        if (!session) {
-            return EMPTY_CHAT_BAR_CAPABILITIES;
-        }
-        const cachedSnapshot = this.extractAcpConfigSnapshot(session.providerMetadata);
-        if (cachedSnapshot && cachedSnapshot.provider === session.provider) {
-            return this.buildCapabilitiesFromConfigOptions(session.provider, cachedSnapshot.configOptions, cachedSnapshot.observedModelId);
-        }
-        if (session.provider === 'CODEX') {
-            return {
-                ...EMPTY_CHAT_BAR_CAPABILITIES,
-                provider: 'CODEX',
-            };
-        }
-        return EMPTY_CHAT_BAR_CAPABILITIES;
-    }
-    buildAcpChatBarCapabilities(handle) {
-        return this.buildCapabilitiesFromConfigOptions(handle.provider, handle.configOptions);
-    }
-    async persistAcpConfigSnapshot(sessionId, params) {
-        if (params.configOptions.length === 0) {
-            return;
-        }
-        const configOptionsForStorage = this.cloneConfigOptionsForStorage(params.configOptions);
-        const observedModelId = this.resolveObservedModel(configOptionsForStorage);
-        const metadataSource = params.existingMetadata ??
-            (await this.repository.getSessionById(sessionId))?.providerMetadata ??
-            null;
-        const snapshot = {
-            provider: params.provider,
-            providerSessionId: params.providerSessionId,
-            capturedAt: new Date().toISOString(),
-            configOptions: configOptionsForStorage,
-            ...(observedModelId ? { observedModelId } : {}),
-        };
-        const persistedUpdate = this.buildSnapshotPersistUpdate(metadataSource, snapshot, observedModelId);
-        try {
-            await this.repository.updateSession(sessionId, persistedUpdate);
-        }
-        catch (error) {
-            logger.warn('Failed persisting ACP config snapshot to session metadata; retrying once', {
-                sessionId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            await this.retryPersistAcpConfigSnapshot(sessionId, snapshot, observedModelId);
-        }
-    }
-    async applyStartupCollaborationModePreset(params) {
-        const modeOption = params.configOptions.find((option) => option.category === 'mode');
-        if (!modeOption) {
-            return { configOptions: params.configOptions, didUpdate: false };
-        }
-        const availableModeValues = this.getConfigOptionValues(modeOption);
-        const targetMode = this.resolveStartupModeTarget(params.handle.provider, params.startupModePreset, availableModeValues);
-        if (!targetMode) {
-            logger.debug('Startup mode preset not available in ACP mode options', {
-                sessionId: params.sessionId,
-                provider: params.handle.provider,
-                workflow: params.workflow,
-                startupModePreset: params.startupModePreset,
-                availableModeValues,
-            });
-            return { configOptions: params.configOptions, didUpdate: false };
-        }
-        const currentMode = modeOption.currentValue ? String(modeOption.currentValue) : null;
-        if (currentMode === targetMode) {
-            return { configOptions: params.configOptions, didUpdate: false };
-        }
-        try {
-            const configOptions = await this.runtimeManager.setSessionMode(params.sessionId, targetMode);
-            return { configOptions, didUpdate: true };
-        }
-        catch (error) {
-            logger.warn('Failed applying startup mode preset', {
-                sessionId: params.sessionId,
-                provider: params.handle.provider,
-                workflow: params.workflow,
-                startupModePreset: params.startupModePreset,
-                targetMode,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return { configOptions: params.configOptions, didUpdate: false };
-        }
-    }
-    async applyStartupExecutionModePreset(params) {
-        const executionModeOption = params.configOptions.find((option) => option.id === 'execution_mode' || option.category === 'permission');
-        const targetExecutionMode = this.resolveStartupExecutionModeTarget(params.handle.provider, params.workflow, params.startupModePreset, executionModeOption);
-        if (!(executionModeOption && targetExecutionMode)) {
-            return { configOptions: params.configOptions, didUpdate: false };
-        }
-        const currentExecutionMode = executionModeOption.currentValue
-            ? String(executionModeOption.currentValue)
-            : null;
-        if (currentExecutionMode === targetExecutionMode) {
-            return { configOptions: params.configOptions, didUpdate: false };
-        }
-        try {
-            const configOptions = await this.runtimeManager.setConfigOption(params.sessionId, executionModeOption.id, targetExecutionMode);
-            return { configOptions, didUpdate: true };
-        }
-        catch (error) {
-            logger.warn('Failed applying startup execution-mode preset', {
-                sessionId: params.sessionId,
-                provider: params.handle.provider,
-                workflow: params.workflow,
-                startupModePreset: params.startupModePreset,
-                targetExecutionMode,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return { configOptions: params.configOptions, didUpdate: false };
-        }
-    }
-    resolveStartupModeTarget(provider, startupModePreset, availableModeValues) {
-        if (availableModeValues.length === 0) {
-            return null;
-        }
-        if (startupModePreset === 'plan') {
-            return this.findModeValue(availableModeValues, ['plan']);
-        }
-        if (provider === 'CLAUDE') {
-            return this.findModeValue(availableModeValues, [
-                'bypassPermissions',
-                'dangerouslySkipPermissions',
-                'dangerousSkipPermissions',
-                'acceptEdits',
-            ]);
-        }
-        return this.findModeValue(availableModeValues, [
-            'fullAccess',
-            'full_access',
-            'full-access',
-            'code',
-        ]);
-    }
-    resolveStartupExecutionModeTarget(provider, workflow, startupModePreset, executionModeOption) {
-        if (provider !== 'CODEX' ||
-            workflow !== 'ratchet' ||
-            startupModePreset !== 'non_interactive' ||
-            !executionModeOption) {
-            return null;
-        }
-        const availableValues = this.getConfigOptionValues(executionModeOption);
-        const yoloByValue = this.findModeValue(availableValues, ['["never","danger-full-access"]']);
-        if (yoloByValue) {
-            return yoloByValue;
-        }
-        const yoloByName = this.getSelectOptions(executionModeOption).find((option) => /yolo/i.test(option.name ?? ''));
-        return yoloByName?.value ?? null;
-    }
-    resolveConfiguredExecutionModeTarget(executionModeOption, permissionPreset) {
-        const availableValues = this.getConfigOptionValues(executionModeOption);
-        const preferredValuesByPreset = {
-            STRICT: [
-                '["on-request","workspace-write"]',
-                '["on-request","read-only"]',
-                '["on-request","danger-full-access"]',
-            ],
-            RELAXED: [
-                '["on-failure","workspace-write"]',
-                '["on-failure","read-only"]',
-                '["on-failure","danger-full-access"]',
-            ],
-            YOLO: [
-                '["never","danger-full-access"]',
-                '["never","workspace-write"]',
-                '["never","read-only"]',
-            ],
-        };
-        const preferredValues = preferredValuesByPreset[permissionPreset];
-        const byValue = this.findModeValue(availableValues, preferredValues);
-        if (byValue) {
-            return byValue;
-        }
-        const byName = this.getSelectOptions(executionModeOption).find((option) => {
-            const name = option.name ?? '';
-            if (permissionPreset === 'STRICT') {
-                return /on request/i.test(name);
-            }
-            if (permissionPreset === 'RELAXED') {
-                return /on failure/i.test(name);
-            }
-            return /yolo|never ask/i.test(name);
-        });
-        return byName?.value ?? null;
-    }
-    findModeValue(availableModeValues, preferredModeValues) {
-        if (availableModeValues.length === 0 || preferredModeValues.length === 0) {
-            return null;
-        }
-        const availableByNormalized = new Map();
-        for (const value of availableModeValues) {
-            availableByNormalized.set(this.normalizeModeValue(value), value);
-        }
-        for (const preferredValue of preferredModeValues) {
-            const match = availableByNormalized.get(this.normalizeModeValue(preferredValue));
-            if (match) {
-                return match;
-            }
-        }
-        return null;
-    }
-    normalizeModeValue(value) {
-        return value.replace(/[^a-z0-9]/gi, '').toLowerCase();
-    }
-    async setCachedSessionConfigOption(sessionId, configId, value) {
-        const session = await this.repository.getSessionById(sessionId);
-        if (!session) {
-            throw new Error(`Session not found: ${sessionId}`);
-        }
-        const snapshot = this.extractAcpConfigSnapshot(session.providerMetadata);
-        if (!snapshot || snapshot.provider !== session.provider) {
-            throw new Error(`Cannot set config option for inactive session ${sessionId}: no cached ACP config available`);
-        }
-        const configOptions = this.updateCachedConfigOptions(snapshot.configOptions, configId, value);
-        await this.persistAcpConfigSnapshot(sessionId, {
-            provider: snapshot.provider,
-            providerSessionId: snapshot.providerSessionId,
-            configOptions,
-            existingMetadata: session.providerMetadata,
-        });
-        return configOptions;
-    }
-    updateCachedConfigOptions(configOptions, configId, value) {
-        let didUpdate = false;
-        const nextConfigOptions = configOptions.map((option) => {
-            if (option.id !== configId) {
-                return option;
-            }
-            const allowedValues = this.getConfigOptionValues(option);
-            if (allowedValues.length > 0 && !allowedValues.includes(value)) {
-                throw new Error(`Unsupported value "${value}" for config option "${configId}"` +
-                    ` (allowed: ${allowedValues.join(', ')})`);
-            }
-            didUpdate = true;
-            return {
-                ...option,
-                currentValue: value,
-            };
-        });
-        if (!didUpdate) {
-            throw new Error(`Unknown config option: ${configId}`);
-        }
-        return nextConfigOptions;
-    }
-    buildCapabilitiesFromConfigOptions(provider, configOptions, fallbackModel) {
-        const modelOption = configOptions.find((option) => option.category === 'model');
-        const modeOption = configOptions.find((option) => option.category === 'mode');
-        const thoughtOption = configOptions.find((option) => option.category === 'thought_level' ||
-            option.id === 'reasoning_effort' ||
-            option.category === 'reasoning');
-        const selectedModel = modelOption?.currentValue
-            ? String(modelOption.currentValue)
-            : (fallbackModel ?? undefined);
-        const modelOptions = this.buildModelOptions(modelOption, selectedModel);
-        const isCodexProvider = provider === 'CODEX';
-        const reasoningOptions = isCodexProvider && thoughtOption
-            ? this.getSelectOptions(thoughtOption).map((option) => ({
-                value: option.value,
-                label: option.name ?? option.value,
-                ...(option.description ? { description: option.description } : {}),
-            }))
-            : [];
-        const reasoningValues = new Set(reasoningOptions.map((option) => option.value));
-        const selectedReasoning = isCodexProvider &&
-            thoughtOption?.currentValue &&
-            typeof thoughtOption.currentValue === 'string' &&
-            reasoningValues.has(thoughtOption.currentValue)
-            ? thoughtOption.currentValue
-            : undefined;
-        const modeDescriptors = modeOption
-            ? [
-                ...this.getConfigOptionValues(modeOption),
-                ...this.getSelectOptions(modeOption)
-                    .map((entry) => entry.name ?? '')
-                    .filter((value) => value.trim().length > 0),
-            ]
-            : [];
-        const planModeEnabled = modeDescriptors.some((entry) => /plan/i.test(entry));
-        return {
-            provider,
-            model: {
-                enabled: modelOptions.length > 0,
-                options: modelOptions,
-                ...(selectedModel ? { selected: selectedModel } : {}),
-            },
-            reasoning: {
-                enabled: reasoningOptions.length > 0,
-                options: reasoningOptions,
-                ...(selectedReasoning ? { selected: selectedReasoning } : {}),
-            },
-            thinking: {
-                enabled: !isCodexProvider && !!thoughtOption,
-            },
-            planMode: { enabled: planModeEnabled },
-            attachments: isCodexProvider
-                ? { enabled: false, kinds: [] }
-                : { enabled: true, kinds: ['image', 'text'] },
-            slashCommands: { enabled: false },
-            usageStats: { enabled: false, contextWindow: false },
-            rewind: { enabled: false },
-        };
-    }
-    buildModelOptions(modelOption, selectedModel) {
-        if (!modelOption) {
-            return selectedModel ? [{ value: selectedModel, label: selectedModel }] : [];
-        }
-        const byValue = new Map();
-        for (const option of this.getSelectOptions(modelOption)) {
-            if (!byValue.has(option.value)) {
-                byValue.set(option.value, option.name ?? option.value);
-            }
-        }
-        if (selectedModel && !byValue.has(selectedModel)) {
-            byValue.set(selectedModel, selectedModel);
-        }
-        return Array.from(byValue.entries()).map(([value, label]) => ({ value, label }));
-    }
-    getSelectOptions(option) {
-        return option.options.flatMap((entry) => {
-            if (typeof entry !== 'object' || entry === null) {
-                return [];
-            }
-            if ('value' in entry && typeof entry.value === 'string') {
-                return [entry];
-            }
-            if ('options' in entry && Array.isArray(entry.options)) {
-                return entry.options.filter((grouped) => typeof grouped === 'object' && grouped !== null && typeof grouped.value === 'string');
-            }
-            return [];
-        });
-    }
-    getConfigOptionValues(option) {
-        return this.getSelectOptions(option).map((entry) => entry.value);
-    }
-    buildSnapshotPersistUpdate(metadataSource, snapshot, observedModelId) {
-        const nextMetadata = {
-            ...this.toMetadataRecord(metadataSource),
-            acpConfigSnapshot: snapshot,
-        };
-        if (observedModelId) {
-            nextMetadata.observedModelId = observedModelId;
-        }
-        return {
-            providerMetadata: nextMetadata,
-            ...(observedModelId ? { model: observedModelId } : {}),
-        };
-    }
-    async retryPersistAcpConfigSnapshot(sessionId, snapshot, observedModelId) {
-        try {
-            const latestMetadataSource = (await this.repository.getSessionById(sessionId))
-                ?.providerMetadata;
-            await this.repository.updateSession(sessionId, this.buildSnapshotPersistUpdate(latestMetadataSource, snapshot, observedModelId));
-        }
-        catch (retryError) {
-            logger.warn('Retry failed persisting ACP config snapshot to session metadata', {
-                sessionId,
-                error: retryError instanceof Error ? retryError.message : String(retryError),
-            });
-        }
-    }
-    cloneConfigOptionsForStorage(configOptions) {
-        try {
-            return structuredClone(configOptions);
-        }
-        catch {
-            return configOptions;
-        }
-    }
-    toMetadataRecord(metadata) {
-        if (typeof metadata !== 'object' || metadata === null || Array.isArray(metadata)) {
-            return {};
-        }
-        return { ...metadata };
-    }
-    extractAcpConfigSnapshot(metadata) {
-        const record = this.toMetadataRecord(metadata);
-        const snapshot = record.acpConfigSnapshot;
-        if (typeof snapshot !== 'object' || snapshot === null || Array.isArray(snapshot)) {
-            return null;
-        }
-        const candidate = snapshot;
-        const provider = candidate.provider;
-        const providerSessionId = candidate.providerSessionId;
-        const configOptions = candidate.configOptions;
-        const observedModelId = candidate.observedModelId;
-        if (provider !== 'CLAUDE' && provider !== 'CODEX') {
-            return null;
-        }
-        if (typeof providerSessionId !== 'string' || providerSessionId.length === 0) {
-            return null;
-        }
-        if (!Array.isArray(configOptions)) {
-            return null;
-        }
-        return {
-            provider,
-            providerSessionId,
-            capturedAt: typeof candidate.capturedAt === 'string' ? candidate.capturedAt : new Date(0).toISOString(),
-            configOptions: configOptions,
-            ...(typeof observedModelId === 'string' ? { observedModelId } : {}),
-        };
-    }
-    resolveObservedModel(configOptions) {
-        const modelOption = configOptions.find((option) => option.category === 'model');
-        const currentValue = modelOption?.currentValue;
-        return currentValue ? String(currentValue) : undefined;
-    }
-}
-//# sourceMappingURL=session.config.service.js.map