@lobu/gateway 2.8.0

package/dist/services/core-services.js

@@ -0,0 +1,728 @@
+#!/usr/bin/env bun
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreServices = void 0;
+const core_1 = require("@lobu/core");
+const agent_metadata_store_1 = require("../auth/agent-metadata-store");
+const api_key_provider_module_1 = require("../auth/api-key-provider-module");
+const chatgpt_1 = require("../auth/chatgpt");
+const oauth_module_1 = require("../auth/claude/oauth-module");
+const client_1 = require("../auth/external/client");
+const config_service_1 = require("../auth/mcp/config-service");
+const proxy_1 = require("../auth/mcp/proxy");
+const tool_cache_1 = require("../auth/mcp/tool-cache");
+const client_2 = require("../auth/oauth/client");
+const providers_1 = require("../auth/oauth/providers");
+const state_store_1 = require("../auth/oauth/state-store");
+const provider_catalog_1 = require("../auth/provider-catalog");
+const settings_1 = require("../auth/settings");
+const model_preference_store_1 = require("../auth/settings/model-preference-store");
+const user_agents_store_1 = require("../auth/user-agents-store");
+const channels_1 = require("../channels");
+const built_in_commands_1 = require("../commands/built-in-commands");
+const file_loader_1 = require("../config/file-loader");
+const gateway_1 = require("../gateway");
+const queue_1 = require("../infrastructure/queue");
+const interactions_1 = require("../interactions");
+const module_system_1 = require("../modules/module-system");
+const scheduled_wakeup_1 = require("../orchestration/scheduled-wakeup");
+const grant_store_1 = require("../permissions/grant-store");
+const secret_proxy_1 = require("../proxy/secret-proxy");
+const token_refresh_job_1 = require("../proxy/token-refresh-job");
+const in_memory_agent_store_1 = require("../stores/in-memory-agent-store");
+const redis_agent_store_1 = require("../stores/redis-agent-store");
+const image_generation_service_1 = require("./image-generation-service");
+const instruction_service_1 = require("./instruction-service");
+const session_manager_1 = require("./session-manager");
+const settings_resolver_1 = require("./settings-resolver");
+const system_config_resolver_1 = require("./system-config-resolver");
+const system_skills_service_1 = require("./system-skills-service");
+const transcription_service_1 = require("./transcription-service");
+const logger = (0, core_1.createLogger)("core-services");
+/**
+ * Core Services - Centralized service initialization and lifecycle management
+ */
+class CoreServices {
+    constructor(config, options) {
+        this.config = config;
+        // File-first architecture state
+        this.fileLoadedAgents = [];
+        this.projectPath = null;
+        this.configAgents = [];
+        this.options = options;
+        if (options === null || options === void 0 ? void 0 : options.configStore)
+            this.configStore = options.configStore;
+        if (options === null || options === void 0 ? void 0 : options.connectionStore)
+            this.connectionStore = options.connectionStore;
+        if (options === null || options === void 0 ? void 0 : options.accessStore)
+            this.accessStore = options.accessStore;
+    }
+    getConfigStore() {
+        return this.configStore;
+    }
+    getConnectionStore() {
+        return this.connectionStore;
+    }
+    getAccessStore() {
+        return this.accessStore;
+    }
+    getSettingsResolver() {
+        return this.settingsResolver;
+    }
+    /**
+     * Initialize all core services in dependency order
+     */
+    async initialize() {
+        logger.debug("Initializing core services...");
+        // 1. Queue (foundation for everything else)
+        await this.initializeQueue();
+        logger.debug("Queue initialized");
+        // 2. Session management
+        await this.initializeSessionServices();
+        logger.debug("Session services initialized");
+        // 3. Auth & provider services
+        await this.initializeClaudeServices();
+        logger.debug("Auth & provider services initialized");
+        // 4. MCP ecosystem (depends on queue and Claude services)
+        await this.initializeMcpServices();
+        logger.debug("MCP services initialized");
+        // 5. Queue producer (depends on queue being ready)
+        await this.initializeQueueProducer();
+        logger.debug("Queue producer initialized");
+        // 6. Scheduled wakeup service (depends on queue)
+        await this.initializeScheduledWakeupService();
+        logger.debug("Scheduled wakeup service initialized");
+        // 7. Command registry (depends on agent settings store)
+        this.initializeCommandRegistry();
+        logger.debug("Command registry initialized");
+        logger.info("Core services initialized successfully");
+    }
+    // ============================================================================
+    // 1. Queue Services Initialization
+    // ============================================================================
+    async initializeQueue() {
+        var _a;
+        if (!((_a = this.config.queues) === null || _a === void 0 ? void 0 : _a.connectionString)) {
+            throw new Error("Queue connection string is required");
+        }
+        const url = new URL(this.config.queues.connectionString);
+        if (url.protocol !== "redis:") {
+            throw new Error(`Unsupported queue protocol: ${url.protocol}. Only redis:// is supported.`);
+        }
+        const config = {
+            host: url.hostname,
+            port: Number.parseInt(url.port, 10) || 6379,
+            password: url.password || undefined,
+            db: url.pathname ? Number.parseInt(url.pathname.slice(1), 10) : 0,
+            maxRetriesPerRequest: 3,
+        };
+        this.queue = new queue_1.RedisQueue(config);
+        await this.queue.start();
+        logger.debug("Queue connection established");
+    }
+    async initializeQueueProducer() {
+        if (!this.queue) {
+            throw new Error("Queue must be initialized before queue producer");
+        }
+        this.queueProducer = new queue_1.QueueProducer(this.queue);
+        await this.queueProducer.start();
+        logger.debug("Queue producer initialized");
+    }
+    // ============================================================================
+    // Scheduled Wakeup Service Initialization
+    // ============================================================================
+    async initializeScheduledWakeupService() {
+        if (!this.queue) {
+            throw new Error("Queue must be initialized before scheduled wakeup service");
+        }
+        this.scheduledWakeupService = new scheduled_wakeup_1.ScheduledWakeupService(this.queue);
+        await this.scheduledWakeupService.start();
+        // Set global reference for BaseDeploymentManager cleanup
+        (0, scheduled_wakeup_1.setScheduledWakeupService)(this.scheduledWakeupService);
+        logger.debug("Scheduled wakeup service initialized");
+    }
+    // ============================================================================
+    // 2. Session Services Initialization
+    // ============================================================================
+    async initializeSessionServices() {
+        var _a, _b, _c;
+        if (!this.queue) {
+            throw new Error("Queue must be initialized before session services");
+        }
+        const redisClient = this.queue.getRedisClient();
+        const sessionStore = new session_manager_1.RedisSessionStore(this.queue);
+        this.sessionManager = new session_manager_1.SessionManager(sessionStore);
+        logger.debug("Session manager initialized");
+        this.interactionService = new interactions_1.InteractionService();
+        logger.debug("Interaction service initialized");
+        // Initialize grant store for unified permissions
+        this.grantStore = new grant_store_1.GrantStore(redisClient);
+        logger.debug("Grant store initialized");
+        // Initialize agent configuration stores
+        this.agentSettingsStore = new settings_1.AgentSettingsStore(redisClient);
+        this.channelBindingService = new channels_1.ChannelBindingService(redisClient);
+        this.userAgentsStore = new user_agents_store_1.UserAgentsStore(redisClient);
+        this.agentMetadataStore = new agent_metadata_store_1.AgentMetadataStore(redisClient);
+        logger.debug("Agent settings, channel binding, user agents & metadata stores initialized");
+        // Initialize agent sub-stores
+        if (!this.configStore || !this.connectionStore || !this.accessStore) {
+            if ((_a = this.config.agents) === null || _a === void 0 ? void 0 : _a.length) {
+                const inMemoryStore = new in_memory_agent_store_1.InMemoryAgentStore();
+                if (!this.configStore)
+                    this.configStore = inMemoryStore;
+                if (!this.connectionStore)
+                    this.connectionStore = inMemoryStore;
+                if (!this.accessStore)
+                    this.accessStore = inMemoryStore;
+                await this.populateStoreFromAgentConfigs(inMemoryStore, this.config.agents);
+                logger.debug(`Agent sub-stores initialized (in-memory, ${this.config.agents.length} agent(s) from config)`);
+            }
+            else {
+                // Check if lobu.toml exists (file-first dev mode)
+                const { existsSync } = await Promise.resolve().then(() => __importStar(require("node:fs")));
+                const { resolve } = await Promise.resolve().then(() => __importStar(require("node:path")));
+                const workspaceRoot = (_b = process.env.LOBU_WORKSPACE_ROOT) === null || _b === void 0 ? void 0 : _b.trim();
+                const candidatePaths = [
+                    ...(workspaceRoot ? [resolve(workspaceRoot, "lobu.toml")] : []),
+                    resolve(process.cwd(), "lobu.toml"),
+                    resolve("/app/lobu.toml"),
+                ];
+                const tomlPath = candidatePaths.find((p) => existsSync(p));
+                if (tomlPath) {
+                    const inMemoryStore = new in_memory_agent_store_1.InMemoryAgentStore();
+                    if (!this.configStore)
+                        this.configStore = inMemoryStore;
+                    if (!this.connectionStore)
+                        this.connectionStore = inMemoryStore;
+                    if (!this.accessStore)
+                        this.accessStore = inMemoryStore;
+                    // File-first dev mode: use InMemoryAgentStore populated from files
+                    this.projectPath = resolve(tomlPath, "..");
+                    // Load agents from files and populate store
+                    this.fileLoadedAgents = await (0, file_loader_1.loadAgentConfigFromFiles)(this.projectPath);
+                    await this.populateStoreFromFiles(inMemoryStore, this.fileLoadedAgents);
+                    logger.debug(`Agent sub-stores initialized (in-memory, ${this.fileLoadedAgents.length} agent(s) from files)`);
+                }
+                else {
+                    if (!this.configStore) {
+                        this.configStore = new redis_agent_store_1.RedisAgentConfigStore(this.agentSettingsStore, this.agentMetadataStore);
+                    }
+                    if (!this.connectionStore) {
+                        this.connectionStore = new redis_agent_store_1.RedisAgentConnectionStore(redisClient, this.channelBindingService);
+                    }
+                    if (!this.accessStore) {
+                        this.accessStore = new redis_agent_store_1.RedisAgentAccessStore(this.grantStore, this.userAgentsStore);
+                    }
+                    logger.debug("Agent sub-stores initialized (Redis-backed defaults)");
+                }
+            }
+        }
+        else {
+            logger.debug("Using host-provided agent sub-stores (embedded mode)");
+        }
+        // Create settings resolver (template fallback logic)
+        this.settingsResolver = new settings_resolver_1.SettingsResolver(this.configStore, this.connectionStore);
+        // Initialize external OAuth client if configured
+        this.externalAuthClient =
+            (_c = client_1.ExternalAuthClient.fromEnv(this.config.mcp.publicGatewayUrl, {
+                get: (key) => redisClient.get(key),
+                set: (key, value, ttlSeconds) => redisClient.setex(key, ttlSeconds, value),
+            })) !== null && _c !== void 0 ? _c : undefined;
+        if (this.externalAuthClient) {
+            logger.debug("External OAuth client initialized");
+        }
+    }
+    // ============================================================================
+    // 3. Auth & Provider Services Initialization
+    // ============================================================================
+    async initializeClaudeServices() {
+        var _a, _b, _c;
+        if (!this.queue) {
+            throw new Error("Queue must be initialized before auth services");
+        }
+        const redisClient = this.queue.getRedisClient();
+        if (!this.agentSettingsStore) {
+            throw new Error("Agent settings store must be initialized before auth services");
+        }
+        if (this.fileLoadedAgents.length > 0) {
+            for (const agent of this.fileLoadedAgents) {
+                await this.syncAgentSettingsToRuntimeStore(agent.agentId, agent.settings);
+            }
+            logger.debug(`Synced settings for ${this.fileLoadedAgents.length} file-loaded agent(s)`);
+        }
+        if (this.configAgents.length > 0) {
+            for (const agent of this.configAgents) {
+                await this.syncAgentSettingsToRuntimeStore(agent.id, this.buildSettingsFromAgentConfig(agent));
+            }
+            logger.debug(`Synced settings for ${this.configAgents.length} config agent(s)`);
+        }
+        // Initialize auth profile and preference stores
+        this.authProfilesManager = new settings_1.AuthProfilesManager(this.agentSettingsStore);
+        this.transcriptionService = new transcription_service_1.TranscriptionService(this.authProfilesManager);
+        this.imageGenerationService = new image_generation_service_1.ImageGenerationService(this.authProfilesManager);
+        this.modelPreferenceStore = new model_preference_store_1.ModelPreferenceStore(redisClient, "claude");
+        // Seed provider credentials from file-loaded agents
+        if (this.authProfilesManager && this.fileLoadedAgents.length > 0) {
+            for (const agent of this.fileLoadedAgents) {
+                for (const cred of agent.credentials) {
+                    await this.authProfilesManager.upsertProfile({
+                        agentId: agent.agentId,
+                        provider: cred.provider,
+                        credential: cred.key,
+                        authType: "api-key",
+                        label: `${cred.provider} (from lobu.toml)`,
+                        makePrimary: true,
+                    });
+                }
+            }
+            logger.debug(`Seeded credentials for ${this.fileLoadedAgents.length} file-loaded agent(s)`);
+        }
+        // Seed provider credentials from config agents (embedded mode)
+        if (this.authProfilesManager && this.configAgents.length > 0) {
+            for (const agent of this.configAgents) {
+                for (const provider of agent.providers || []) {
+                    if (!provider.key)
+                        continue;
+                    await this.authProfilesManager.upsertProfile({
+                        agentId: agent.id,
+                        provider: provider.id,
+                        credential: provider.key,
+                        authType: "api-key",
+                        label: `${provider.id} (from config)`,
+                        makePrimary: true,
+                    });
+                }
+            }
+            logger.debug(`Seeded credentials for ${this.configAgents.length} config agent(s)`);
+        }
+        logger.debug("Auth profile, model preference, transcription, and image generation services initialized");
+        // Initialize secret injection proxy (will be finalized after provider modules are registered)
+        this.secretProxy = new secret_proxy_1.SecretProxy({
+            defaultUpstreamUrl: this.config.anthropicProxy.anthropicBaseUrl ||
+                "https://api.anthropic.com",
+        });
+        this.secretProxy.initialize(redisClient);
+        logger.debug(`Secret proxy initialized (upstream: ${this.config.anthropicProxy.anthropicBaseUrl || "https://api.anthropic.com"})`);
+        // Start background token refresh job
+        if (!this.authProfilesManager) {
+            throw new Error("Auth profiles manager must be initialized before token refresh job");
+        }
+        this.tokenRefreshJob = new token_refresh_job_1.TokenRefreshJob(this.authProfilesManager, redisClient, [{ providerId: "claude", oauthClient: new client_2.OAuthClient(providers_1.CLAUDE_PROVIDER) }]);
+        this.tokenRefreshJob.start();
+        logger.debug("Token refresh job started");
+        // Register Claude OAuth module
+        this.oauthStateStore = (0, state_store_1.createOAuthStateStore)("claude", redisClient);
+        const claudeOAuthModule = new oauth_module_1.ClaudeOAuthModule(this.authProfilesManager, this.modelPreferenceStore);
+        core_1.moduleRegistry.register(claudeOAuthModule);
+        logger.debug(`Claude OAuth module registered (system token: ${claudeOAuthModule.hasSystemKey() ? "available" : "not available"})`);
+        // Register ChatGPT OAuth module
+        const chatgptOAuthModule = new chatgpt_1.ChatGPTOAuthModule(this.agentSettingsStore);
+        core_1.moduleRegistry.register(chatgptOAuthModule);
+        logger.debug(`ChatGPT OAuth module registered (system token: ${chatgptOAuthModule.hasSystemKey() ? "available" : "not available"})`);
+        // Initialize system skills — use injected skills if provided, else load from file
+        if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.systemSkills) {
+            this.systemSkillsService = new system_skills_service_1.SystemSkillsService(undefined, this.options.systemSkills);
+        }
+        else {
+            this.systemSkillsService = new system_skills_service_1.SystemSkillsService("config/system-skills.json");
+        }
+        this.systemConfigResolver = new system_config_resolver_1.SystemConfigResolver(this.systemSkillsService);
+        logger.debug("System skills service initialized");
+        (_b = this.transcriptionService) === null || _b === void 0 ? void 0 : _b.setProviderConfigSource(() => this.systemConfigResolver
+            ? this.systemConfigResolver.getProviderConfigs()
+            : Promise.resolve({}));
+        // Register config-driven providers from system skills
+        const configProviders = await this.systemConfigResolver.getProviderConfigs();
+        const registeredIds = new Set((0, module_system_1.getModelProviderModules)().map((m) => m.providerId));
+        for (const [id, entry] of Object.entries(configProviders)) {
+            if (registeredIds.has(id)) {
+                logger.info(`Skipping config-driven provider "${id}" — already registered`);
+                continue;
+            }
+            const module = new api_key_provider_module_1.ApiKeyProviderModule({
+                providerId: id,
+                providerDisplayName: entry.displayName,
+                providerIconUrl: entry.iconUrl,
+                envVarName: entry.envVarName,
+                slug: id,
+                upstreamBaseUrl: entry.upstreamBaseUrl,
+                modelsEndpoint: entry.modelsEndpoint,
+                sdkCompat: entry.sdkCompat,
+                defaultModel: entry.defaultModel,
+                registryAlias: entry.registryAlias,
+                apiKeyInstructions: entry.apiKeyInstructions,
+                apiKeyPlaceholder: entry.apiKeyPlaceholder,
+                agentSettingsStore: this.agentSettingsStore,
+            });
+            core_1.moduleRegistry.register(module);
+            registeredIds.add(id);
+            logger.debug(`Registered config-driven provider: ${id} (system key: ${module.hasSystemKey() ? "available" : "not available"})`);
+        }
+        // Initialize provider catalog service
+        this.providerCatalogService = new provider_catalog_1.ProviderCatalogService(this.agentSettingsStore, this.authProfilesManager);
+        logger.debug("Provider catalog service initialized");
+        // Register provider upstream configs with the secret proxy for path-based routing
+        if (this.secretProxy) {
+            this.secretProxy.setAuthProfilesManager(this.authProfilesManager);
+            for (const provider of (0, module_system_1.getModelProviderModules)()) {
+                const upstream = (_c = provider.getUpstreamConfig) === null || _c === void 0 ? void 0 : _c.call(provider);
+                if (upstream) {
+                    this.secretProxy.registerUpstream(upstream, provider.providerId);
+                }
+            }
+            // Register system key resolver for fallback when no per-agent auth profile exists
+            const modules = (0, module_system_1.getModelProviderModules)();
+            this.secretProxy.setSystemKeyResolver((providerId) => {
+                const mod = modules.find((m) => m.providerId === providerId);
+                if (!mod)
+                    return undefined;
+                // Use the module's injectSystemKeyFallback to resolve the system key.
+                // The fallback may inject into a different env var than credentialEnvVarName
+                // (e.g., Claude injects ANTHROPIC_API_KEY, not CLAUDE_CODE_OAUTH_TOKEN),
+                // so check all secret env var names.
+                const testEnv = {};
+                mod.injectSystemKeyFallback(testEnv);
+                for (const varName of mod.getSecretEnvVarNames()) {
+                    if (testEnv[varName])
+                        return testEnv[varName];
+                }
+                return testEnv[mod.getCredentialEnvVarName()] || undefined;
+            });
+            logger.debug("Provider upstreams registered with secret proxy");
+        }
+    }
+    // ============================================================================
+    // 4. MCP Services Initialization
+    // ============================================================================
+    async initializeMcpServices() {
+        if (!this.queue) {
+            throw new Error("Queue must be initialized before MCP services");
+        }
+        const redisClient = this.queue.getRedisClient();
+        // Initialize simplified MCP config service (no OAuth discovery)
+        this.mcpConfigService = new config_service_1.McpConfigService({
+            agentSettingsStore: this.agentSettingsStore,
+            configResolver: this.systemConfigResolver,
+        });
+        // Initialize instruction service (needed by WorkerGateway)
+        this.instructionService = new instruction_service_1.InstructionService(this.mcpConfigService, this.agentSettingsStore);
+        logger.debug("Instruction service initialized");
+        // Initialize MCP tool cache and proxy
+        const mcpToolCache = new tool_cache_1.McpToolCache(redisClient);
+        this.mcpProxy = new proxy_1.McpProxy(this.mcpConfigService, this.queue, mcpToolCache, this.grantStore);
+        logger.debug("MCP proxy initialized");
+        // Initialize worker gateway
+        if (!this.sessionManager) {
+            throw new Error("Session manager must be initialized before worker gateway");
+        }
+        this.workerGateway = new gateway_1.WorkerGateway(this.queue, this.config.mcp.publicGatewayUrl, this.sessionManager, this.mcpConfigService, this.instructionService, this.mcpProxy, this.providerCatalogService, this.settingsResolver, this.systemSkillsService);
+        logger.debug("Worker gateway initialized");
+        // Discover and initialize all available modules
+        await core_1.moduleRegistry.registerAvailableModules();
+        await core_1.moduleRegistry.initAll();
+        logger.debug("Modules initialized");
+    }
+    // ============================================================================
+    // 7. Command Registry Initialization
+    // ============================================================================
+    initializeCommandRegistry() {
+        if (!this.agentSettingsStore) {
+            throw new Error("Agent settings store must be initialized before command registry");
+        }
+        this.commandRegistry = new core_1.CommandRegistry();
+        (0, built_in_commands_1.registerBuiltInCommands)(this.commandRegistry, {
+            agentSettingsStore: this.agentSettingsStore,
+        });
+        logger.debug("Command registry initialized with built-in commands");
+    }
+    // ============================================================================
+    // File-First Helpers
+    // ============================================================================
+    async populateStoreFromFiles(store, agents) {
+        for (const agent of agents) {
+            await store.saveMetadata(agent.agentId, {
+                agentId: agent.agentId,
+                name: agent.name,
+                description: agent.description,
+                owner: { platform: "system", userId: "manifest" },
+                createdAt: Date.now(),
+            });
+            await store.saveSettings(agent.agentId, Object.assign(Object.assign({}, agent.settings), { updatedAt: Date.now() }));
+        }
+    }
+    buildSettingsFromAgentConfig(agent) {
+        var _a, _b, _c;
+        const settings = {};
+        if (agent.identityMd)
+            settings.identityMd = agent.identityMd;
+        if (agent.soulMd)
+            settings.soulMd = agent.soulMd;
+        if (agent.userMd)
+            settings.userMd = agent.userMd;
+        if ((_a = agent.providers) === null || _a === void 0 ? void 0 : _a.length) {
+            settings.installedProviders = agent.providers.map((p) => ({
+                providerId: p.id,
+                installedAt: Date.now(),
+            }));
+            settings.modelSelection = { mode: "auto" };
+            const providerModelPreferences = Object.fromEntries(agent.providers
+                .filter((p) => { var _a; return !!((_a = p.model) === null || _a === void 0 ? void 0 : _a.trim()); })
+                .map((p) => [p.id, p.model.trim()]));
+            if (Object.keys(providerModelPreferences).length > 0) {
+                settings.providerModelPreferences = providerModelPreferences;
+            }
+        }
+        if ((_b = agent.skills) === null || _b === void 0 ? void 0 : _b.mcp) {
+            settings.mcpServers = agent.skills.mcp;
+        }
+        if (agent.network) {
+            settings.networkConfig = {
+                allowedDomains: agent.network.allowed,
+                deniedDomains: agent.network.denied,
+            };
+        }
+        if ((_c = agent.nixPackages) === null || _c === void 0 ? void 0 : _c.length) {
+            settings.nixConfig = { packages: agent.nixPackages };
+        }
+        return settings;
+    }
+    async syncAgentSettingsToRuntimeStore(agentId, settings) {
+        if (!this.agentSettingsStore) {
+            throw new Error("Agent settings store must be initialized");
+        }
+        const existing = await this.agentSettingsStore.getSettings(agentId);
+        await this.agentSettingsStore.saveSettings(agentId, Object.assign(Object.assign({}, settings), { authProfiles: existing === null || existing === void 0 ? void 0 : existing.authProfiles, mcpInstallNotified: existing === null || existing === void 0 ? void 0 : existing.mcpInstallNotified }));
+    }
+    async populateStoreFromAgentConfigs(store, agents) {
+        for (const agent of agents) {
+            await store.saveMetadata(agent.id, {
+                agentId: agent.id,
+                name: agent.name,
+                description: agent.description,
+                owner: { platform: "system", userId: "config" },
+                createdAt: Date.now(),
+            });
+            await store.saveSettings(agent.id, Object.assign(Object.assign({}, this.buildSettingsFromAgentConfig(agent)), { updatedAt: Date.now() }));
+        }
+        // Store agent configs for credential seeding and connection seeding later
+        this.configAgents = agents;
+    }
+    /**
+     * Reload agent config from files (dev mode only).
+     * Re-reads lobu.toml + markdown, clears and re-populates the in-memory store.
+     */
+    async reloadFromFiles() {
+        var _a, _b;
+        if (!this.projectPath) {
+            return { reloaded: false, agents: [] };
+        }
+        // Re-load from disk
+        this.fileLoadedAgents = await (0, file_loader_1.loadAgentConfigFromFiles)(this.projectPath);
+        // Re-populate the in-memory store (clear existing data first)
+        if (this.configStore instanceof in_memory_agent_store_1.InMemoryAgentStore) {
+            const store = this.configStore;
+            // Clear existing agents by loading fresh
+            const existing = await store.listAgents();
+            for (const meta of existing) {
+                // Only clear file-managed agents (owner: system/manifest)
+                if (((_a = meta.owner) === null || _a === void 0 ? void 0 : _a.platform) === "system" &&
+                    ((_b = meta.owner) === null || _b === void 0 ? void 0 : _b.userId) === "manifest") {
+                    await store.deleteSettings(meta.agentId);
+                    await store.deleteMetadata(meta.agentId);
+                }
+            }
+            await this.populateStoreFromFiles(store, this.fileLoadedAgents);
+        }
+        if (this.agentSettingsStore) {
+            for (const agent of this.fileLoadedAgents) {
+                await this.syncAgentSettingsToRuntimeStore(agent.agentId, agent.settings);
+            }
+        }
+        // Re-seed credentials
+        if (this.authProfilesManager) {
+            for (const agent of this.fileLoadedAgents) {
+                for (const cred of agent.credentials) {
+                    await this.authProfilesManager.upsertProfile({
+                        agentId: agent.agentId,
+                        provider: cred.provider,
+                        credential: cred.key,
+                        authType: "api-key",
+                        label: `${cred.provider} (from lobu.toml)`,
+                        makePrimary: true,
+                    });
+                }
+            }
+        }
+        const agentIds = this.fileLoadedAgents.map((a) => a.agentId);
+        logger.info(`Reloaded ${agentIds.length} agent(s) from files`);
+        return { reloaded: true, agents: agentIds };
+    }
+    getFileLoadedAgents() {
+        return this.fileLoadedAgents;
+    }
+    getConfigAgents() {
+        return this.configAgents;
+    }
+    getProjectPath() {
+        return this.projectPath;
+    }
+    isFileFirstMode() {
+        return this.projectPath !== null;
+    }
+    // ============================================================================
+    // Shutdown
+    // ============================================================================
+    async shutdown() {
+        logger.info("Shutting down core services...");
+        if (this.tokenRefreshJob) {
+            this.tokenRefreshJob.stop();
+        }
+        if (this.queueProducer) {
+            await this.queueProducer.stop();
+        }
+        if (this.workerGateway) {
+            this.workerGateway.shutdown();
+            logger.info("Worker gateway shutdown complete");
+        }
+        if (this.queue) {
+            await this.queue.stop();
+        }
+        logger.info("Core services shutdown complete");
+    }
+    // ============================================================================
+    // Service Accessors (implements ICoreServices interface)
+    // ============================================================================
+    getQueue() {
+        if (!this.queue)
+            throw new Error("Queue not initialized");
+        return this.queue;
+    }
+    getQueueProducer() {
+        if (!this.queueProducer)
+            throw new Error("Queue producer not initialized");
+        return this.queueProducer;
+    }
+    getSecretProxy() {
+        return this.secretProxy;
+    }
+    getWorkerGateway() {
+        return this.workerGateway;
+    }
+    getMcpProxy() {
+        return this.mcpProxy;
+    }
+    getMcpConfigService() {
+        return this.mcpConfigService;
+    }
+    getModelPreferenceStore() {
+        return this.modelPreferenceStore;
+    }
+    getOAuthStateStore() {
+        return this.oauthStateStore;
+    }
+    getPublicGatewayUrl() {
+        return this.config.mcp.publicGatewayUrl;
+    }
+    getSessionManager() {
+        if (!this.sessionManager)
+            throw new Error("Session manager not initialized");
+        return this.sessionManager;
+    }
+    getInstructionService() {
+        return this.instructionService;
+    }
+    getInteractionService() {
+        if (!this.interactionService)
+            throw new Error("Interaction service not initialized");
+        return this.interactionService;
+    }
+    getAgentSettingsStore() {
+        if (!this.agentSettingsStore)
+            throw new Error("Agent settings store not initialized");
+        return this.agentSettingsStore;
+    }
+    getChannelBindingService() {
+        if (!this.channelBindingService)
+            throw new Error("Channel binding service not initialized");
+        return this.channelBindingService;
+    }
+    getScheduledWakeupService() {
+        return this.scheduledWakeupService;
+    }
+    getTranscriptionService() {
+        return this.transcriptionService;
+    }
+    getImageGenerationService() {
+        return this.imageGenerationService;
+    }
+    getUserAgentsStore() {
+        if (!this.userAgentsStore)
+            throw new Error("User agents store not initialized");
+        return this.userAgentsStore;
+    }
+    getAgentMetadataStore() {
+        if (!this.agentMetadataStore)
+            throw new Error("Agent metadata store not initialized");
+        return this.agentMetadataStore;
+    }
+    getCommandRegistry() {
+        if (!this.commandRegistry)
+            throw new Error("Command registry not initialized");
+        return this.commandRegistry;
+    }
+    getProviderCatalogService() {
+        if (!this.providerCatalogService)
+            throw new Error("Provider catalog service not initialized");
+        return this.providerCatalogService;
+    }
+    getAuthProfilesManager() {
+        return this.authProfilesManager;
+    }
+    getGrantStore() {
+        return this.grantStore;
+    }
+    getSystemSkillsService() {
+        return this.systemSkillsService;
+    }
+    getSystemConfigResolver() {
+        return this.systemConfigResolver;
+    }
+    getExternalAuthClient() {
+        return this.externalAuthClient;
+    }
+}
+exports.CoreServices = CoreServices;
+//# sourceMappingURL=core-services.js.map