@jungjaehoon/mama-os 0.53.1 → 0.58.0

package/dist/cli/commands/daemon.js

@@ -0,0 +1,632 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDeliveryRoutes = validateDeliveryRoutes;
+exports.ensureDaemonIsolation = ensureDaemonIsolation;
+exports.bootDaemon = bootDaemon;
+exports.runDaemon = runDaemon;
+exports.daemonStatus = daemonStatus;
+exports.requestDaemonStop = requestDaemonStop;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_child_process_1 = require("node:child_process");
+const node_os_1 = require("node:os");
+const telegram_js_1 = require("../../gateways/telegram.js");
+const discord_js_1 = require("../../gateways/discord.js");
+const slack_js_1 = require("../../gateways/slack.js");
+const telegram_message_ledger_js_1 = require("../../gateways/telegram-message-ledger.js");
+const stimulus_delivery_js_1 = require("../../runtime/stimulus-delivery.js");
+const owner_runtime_js_1 = require("../../runtime/owner-runtime.js");
+const action_surface_js_1 = require("../../runtime/action-surface.js");
+const connectors_js_1 = require("../../runtime/connectors.js");
+const config_js_1 = require("../../runtime/config.js");
+const model_cache_js_1 = require("../../runtime/model-cache.js");
+const session_credential_js_1 = require("../../runtime/session-credential.js");
+const action_mcp_config_js_1 = require("../runtime/action-mcp-config.js");
+const index_js_1 = require("../../connectors/index.js");
+const owner_policy_js_1 = require("../../runtime/owner-policy.js");
+const viewer_server_js_1 = require("../../api/viewer-server.js");
+const package_version_js_1 = require("../../package-version.js");
+const viewer_data_js_1 = require("../../api/viewer-data.js");
+const report_scheduler_js_1 = require("../../runtime/report-scheduler.js");
+const timezone_js_1 = require("../../runtime/timezone.js");
+const OWNER_PRINCIPAL_ID = 'owner';
+const OWNER_AGENT_ID = 'owner-agent';
+const OWNER_MEMORY_SCOPES = (0, action_surface_js_1.ownerMemoryScopes)(OWNER_PRINCIPAL_ID, index_js_1.LOADABLE_CONNECTORS);
+const defaultLogger = {
+    info: (line) => console.log(line),
+    error: (line) => console.error(line),
+};
+/**
+ * A failed stage names what failed. Messages from this codebase never carry
+ * secrets (tokens are read from the environment and never formatted into errors).
+ */
+function errorName(error) {
+    if (!(error instanceof Error))
+        return String(error);
+    const name = error.name.trim() !== '' ? error.name : 'Error';
+    return `${name}: ${error.message}`;
+}
+function stage(logger, name) {
+    logger.info(`boot stage=${name}`);
+}
+function stageFailed(logger, name, error) {
+    logger.error(`boot stage=${name} failed error=${errorName(error)}`);
+}
+function stimulusAccepted(logger, kind, id, receipt) {
+    logger.info(`stimulus accepted kind=${kind} id=${id} state=${receipt.state}`);
+}
+function stimulusFailed(logger, kind, id, error, modelRunId = null) {
+    logger.error(`stimulus failed kind=${kind} id=${id} model_run_id=${modelRunId} reason=${(0, stimulus_delivery_js_1.stimulusFailureReason)(error)}`);
+}
+function stimulusDelivered(logger, row, modelRunId) {
+    logger.info(`stimulus delivered kind=${row.kind ?? 'unknown'} id=${row.stimulusId} model_run_id=${modelRunId}`);
+}
+function pathsOverlap(left, right) {
+    const inside = (parent, child) => {
+        const local = (0, node_path_1.relative)((0, node_path_1.resolve)(parent), (0, node_path_1.resolve)(child));
+        return local === '' || (local !== '..' && !local.startsWith(`..${node_path_1.sep}`) && !(0, node_path_1.isAbsolute)(local));
+    };
+    return inside(left, right) || inside(right, left);
+}
+function sourceForRef(ref) {
+    if (ref.startsWith('telegram:'))
+        return 'telegram';
+    if (ref.startsWith('discord:'))
+        return 'discord';
+    if (ref.startsWith('slack:'))
+        return 'slack';
+    throw new Error('Owner message reference has no supported messenger prefix');
+}
+function validateDeliveryRoutes(config) {
+    const active = {
+        telegram: config.telegram.enabled &&
+            Boolean(config.telegram.owner_chat_id &&
+                config.telegram.allowed_chats.includes(config.telegram.owner_chat_id)),
+        discord: Boolean(config.discord?.enabled &&
+            config.discord.owner_channel_id &&
+            config.discord.allowed_channels.includes(config.discord.owner_channel_id)),
+        slack: Boolean(config.slack?.enabled &&
+            config.slack.owner_channel_id &&
+            config.slack.allowed_channels.includes(config.slack.owner_channel_id)),
+    };
+    const routes = config.delivery ?? {
+        reports: 'telegram',
+        notifications: 'telegram',
+        security_alerts: 'telegram',
+    };
+    for (const [purpose, messenger] of Object.entries(routes)) {
+        if (!active[messenger])
+            throw new Error(`delivery.${purpose} targets ${messenger}, which is disabled or has no allowlisted owner channel`);
+    }
+}
+function pathsFor(configPath, config) {
+    const mamaRoot = (0, node_path_1.dirname)(configPath);
+    const runtimeRoot = (0, node_path_1.join)(mamaRoot, 'runtime');
+    const workspaceDir = config.agent.codex_cwd ?? (0, node_path_1.join)(mamaRoot, 'workspace');
+    const pluginDir = (0, node_path_1.join)(mamaRoot, '.empty-plugins');
+    const mcpConfigPath = config.agent.tools?.mcp_config ?? (0, node_path_1.join)(runtimeRoot, 'mama-mcp-config.json');
+    const connectorsRoot = (0, node_path_1.join)(mamaRoot, 'connectors');
+    const downloadsDir = (0, node_path_1.join)(mamaRoot, 'downloads');
+    // The unsandboxed daemon writes downloads; the agent writes the workspace. Overlap would let the
+    // agent swap download directories for symlinks and redirect the daemon's writes.
+    if (pathsOverlap(workspaceDir, downloadsDir)) {
+        throw new Error(`agent.codex_cwd must not contain or sit inside ${downloadsDir}`);
+    }
+    return {
+        mamaRoot,
+        runtimeRoot,
+        workspaceDir,
+        downloadsDir,
+        pluginDir,
+        mcpConfigPath,
+        socketPath: (0, node_path_1.join)(mamaRoot, 'runtime.sock'),
+        credentialPath: (0, session_credential_js_1.sessionCredentialPath)(mamaRoot),
+        connectorsConfigPath: (0, node_path_1.join)(mamaRoot, 'connectors.json'),
+        connectorsRoot,
+        trelloStatePath: (0, node_path_1.join)(connectorsRoot, 'trello-state.json'),
+        // Kagemusha's own database, read-only (archive connector: ~/.kagemusha/kagemusha.db).
+        kagemushaDbPath: (0, node_path_1.join)((0, node_path_1.dirname)(mamaRoot), '.kagemusha', 'kagemusha.db'),
+        ownerMessageLedgerPath: (0, node_path_1.join)(runtimeRoot, 'owner-message-ledger.json'),
+    };
+}
+/** Create only the native-process isolation files; never remove product state. */
+function ensureDaemonIsolation(options) {
+    const { config, paths } = options;
+    (0, node_fs_1.mkdirSync)(paths.downloadsDir, { recursive: true, mode: 0o700 });
+    (0, node_fs_1.mkdirSync)(paths.workspaceDir, { recursive: true });
+    const gitDir = (0, node_path_1.join)(paths.workspaceDir, '.git');
+    (0, node_fs_1.mkdirSync)(gitDir, { recursive: true });
+    const headPath = (0, node_path_1.join)(gitDir, 'HEAD');
+    if (!(0, node_fs_1.existsSync)(headPath))
+        (0, node_fs_1.writeFileSync)(headPath, 'ref: refs/heads/main\n', { mode: 0o600 });
+    if (config.agent.backend === 'claude') {
+        (0, node_fs_1.mkdirSync)(paths.pluginDir, { recursive: true });
+        (0, action_mcp_config_js_1.ensureMamaMcpConfig)({
+            mcpConfigPath: paths.mcpConfigPath,
+            serverPath: options.mcpServerPath ?? (0, action_mcp_config_js_1.resolveActionServerPath)(),
+            mamaHome: paths.mamaRoot,
+        });
+    }
+}
+function loggedOwnerIntake(intake, logger) {
+    return {
+        acceptOwnerMessage: (input) => {
+            try {
+                const receipt = intake.acceptOwnerMessage(input);
+                stimulusAccepted(logger, 'owner_message', input.id, receipt);
+                return receipt;
+            }
+            catch (error) {
+                stimulusFailed(logger, 'owner_message', input.id, error);
+                throw error;
+            }
+        },
+        ...(intake.isPending === undefined ? {} : { isPending: intake.isPending }),
+    };
+}
+async function stopOne(logger, name, stop, errors) {
+    try {
+        await stop();
+    }
+    catch (error) {
+        errors.push(error);
+        logger.error(`shutdown stage=${name} failed error=${errorName(error)}`);
+    }
+}
+/** Open the W1 owner subject, then activate producers in their dependency order. */
+async function bootDaemon(options = {}) {
+    const logger = options.logger ?? defaultLogger;
+    const dependencies = options.dependencies ?? {};
+    const configPath = options.configPath ?? (0, config_js_1.defaultConfigPath)(options.home ?? (0, node_os_1.homedir)());
+    let config;
+    let paths;
+    let owner;
+    let viewer = null;
+    let connectors;
+    let gateway = null;
+    const gateways = new Map();
+    let reportScheduler;
+    let stopped = false;
+    let deliveryReady = options.mode === 'replay';
+    const startedAt = Date.now();
+    let currentStage = 'config';
+    const stopResources = async () => {
+        if (stopped)
+            return;
+        stopped = true;
+        const errors = [];
+        if (reportScheduler)
+            await stopOne(logger, 'report_scheduler', () => reportScheduler.stop(), errors);
+        if (connectors)
+            await stopOne(logger, 'connectors', () => connectors.stop(), errors);
+        if (viewer)
+            await stopOne(logger, 'viewer', () => viewer.stop(), errors);
+        if (owner)
+            await stopOne(logger, 'owner_runtime', () => owner.stop(), errors);
+        // The owner drains active result writers before their delivery port closes.
+        for (const [name, active] of gateways)
+            await stopOne(logger, name, () => active.stop(), errors);
+        if (errors.length > 0)
+            throw new AggregateError(errors, 'Daemon shutdown failed');
+    };
+    try {
+        currentStage = 'config';
+        stage(logger, 'config');
+        config = options.config ?? (0, config_js_1.loadConfig)({ path: configPath, home: options.home });
+        const timeZone = (0, timezone_js_1.createTimeZoneSetting)(config.timezone);
+        validateDeliveryRoutes(config);
+        // launchd may have created the redirected log already; preserve its contents and tighten it.
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(config.logging.file), { recursive: true });
+        const logDescriptor = (0, node_fs_1.openSync)(config.logging.file, 'a', 0o600);
+        try {
+            (0, node_fs_1.fchmodSync)(logDescriptor, 0o600);
+        }
+        finally {
+            (0, node_fs_1.closeSync)(logDescriptor);
+        }
+        (0, model_cache_js_1.declareModelCache)();
+        paths = pathsFor(configPath, config);
+        currentStage = 'isolation';
+        const ensureIsolation = dependencies.ensureIsolation ?? ensureDaemonIsolation;
+        ensureIsolation({
+            config,
+            paths,
+            ...(options.mcpServerPath ? { mcpServerPath: options.mcpServerPath } : {}),
+        });
+        stage(logger, 'isolation');
+        currentStage = 'owner_runtime';
+        const ownerPolicyProvider = (0, owner_policy_js_1.createOwnerPolicyProvider)(paths.mamaRoot);
+        const ownerPolicy = ownerPolicyProvider();
+        logger.info(`owner policy: ${ownerPolicy.loaded ? 'loaded' : 'none'}`);
+        const deliverOwnerResponse = async (row, result) => {
+            const messenger = sourceForRef(row.stimulusId);
+            const selected = gateways.get(messenger);
+            if (!selected)
+                throw new Error(`${messenger} gateway is not available for an owner response`);
+            await selected.deliverResponse(row.stimulusId, result.response);
+        };
+        const deliverSourceResponse = async (row, result) => {
+            const text = result.response.trim();
+            const tagIndex = Math.max(text.lastIndexOf('[notify]'), text.lastIndexOf('[ack]'));
+            const routed = tagIndex >= 0 ? text.slice(tagIndex) : '';
+            const route = routed.startsWith('[notify]')
+                ? 'notify'
+                : routed.startsWith('[ack]')
+                    ? 'ack'
+                    : 'untagged';
+            logger.info(`delta report route=${route} id=${row.stimulusId}`);
+            if (route !== 'notify')
+                return;
+            const content = routed.slice('[notify]'.length).trim();
+            if (!content) {
+                logger.error(`delta report route=notify has no message after the marker id=${row.stimulusId}`);
+                return;
+            }
+            const selected = gateways.get(config.delivery?.notifications ?? 'telegram');
+            if (!selected)
+                throw new Error('Notification delivery messenger is not available');
+            await selected.sendToOwner(content, row.stimulusId);
+        };
+        const ownerFactory = dependencies.createOwnerRuntime ?? owner_runtime_js_1.createOwnerRuntime;
+        owner = await ownerFactory({
+            backend: config.agent.backend,
+            model: config.agent.model,
+            databasePath: config.database.path,
+            socketPath: paths.socketPath,
+            credentialPath: paths.credentialPath,
+            runtimeRoot: paths.mamaRoot,
+            timeZone,
+            replayKeyFile: config.jev?.keyFile,
+            workspaceDir: paths.workspaceDir,
+            ownerPrincipalId: OWNER_PRINCIPAL_ID,
+            agentId: OWNER_AGENT_ID,
+            scopes: OWNER_MEMORY_SCOPES,
+            connectors: index_js_1.LOADABLE_CONNECTORS,
+            rawPath: paths.connectorsRoot,
+            effort: config.agent.effort,
+            maxTurns: config.agent.max_turns,
+            timeout: config.agent.timeout,
+            runTokenBudget: config.agent.run_token_budget,
+            ...(config.agent.codex_home === undefined ? {} : { codexHome: config.agent.codex_home }),
+            codexSandbox: config.agent.codex_sandbox ?? 'workspace-write',
+            ...(config.agent.backend === 'claude' ? { mcpConfigPath: paths.mcpConfigPath } : {}),
+            pluginDir: paths.pluginDir,
+            attachmentPorts: {
+                downloadsDir: paths.downloadsDir,
+                connectors: () => connectors?.registry ?? null,
+                telegram: () => gateways.get('telegram') ?? null,
+                discord: () => gateways.get('discord') ?? null,
+                slack: () => gateways.get('slack') ?? null,
+            },
+            ...(config.wiki?.enabled
+                ? {
+                    wiki: {
+                        enabled: true,
+                        vaultPath: config.wiki.vaultPath,
+                        wikiDir: config.wiki.wikiDir,
+                    },
+                }
+                : {}),
+            formattingRoutes: {
+                reports: config.delivery?.reports ?? 'telegram',
+                notifications: config.delivery?.notifications ?? 'telegram',
+            },
+            ownerPolicyProvider,
+            deliveryReady: () => deliveryReady,
+            recentDeliveredOwnerMessages: () => [...gateways.values()].flatMap((active) => active.recentDeliveredMessageRefs()),
+            ...(options.mode === 'replay'
+                ? {}
+                : {
+                    onOwnerResult: deliverOwnerResponse,
+                    onStimulusUncertain: async (row) => {
+                        logger.error(`stimulus parked uncertain kind=${row.kind ?? 'unknown'} mailbox_id=${row.id}`);
+                        if (row.kind !== 'owner_message')
+                            return;
+                        const selected = gateways.get(sourceForRef(row.stimulusId));
+                        if (!selected)
+                            throw new Error('Owner messenger is not available for an interrupted response');
+                        await selected.recoverPendingResponses();
+                    },
+                    onSourceResult: deliverSourceResponse,
+                    onScheduledResult: async (row, result) => {
+                        if (!reportScheduler)
+                            throw new Error('Report scheduler is not available for a scheduled result');
+                        await reportScheduler.onResult(row, result);
+                    },
+                }),
+            onStimulusDead: (row, reason) => logger.error(`stimulus parked dead kind=${row.kind ?? 'unknown'} mailbox_id=${row.id} reason=${(0, stimulus_delivery_js_1.stimulusFailureReason)(reason)}`),
+            onLessonSearchFailed: (reason) => logger.error(`lesson recall failed reason=${reason}`),
+            onStimulusSkipped: (row, reason) => logger.info(`stimulus skipped kind=${row.kind ?? 'unknown'} mailbox_id=${row.id} reason=${reason}`),
+            onRecordOrderEvent: (event) => {
+                const line = `record order ${event.type} delta=${event.deltaStimulusId} attempt=${event.attempt}${'reason' in event ? ` reason=${(0, stimulus_delivery_js_1.stimulusFailureReason)(event.reason)}` : ''}`;
+                if (event.type === 'lost')
+                    logger.error(line);
+                else
+                    logger.info(line);
+            },
+            onStimulusDelivered: (row, modelRunId) => stimulusDelivered(logger, row, modelRunId),
+            onStimulusFailed: (row, reason, modelRunId) => stimulusFailed(logger, row.kind ?? 'unknown', row.stimulusId, reason, modelRunId),
+        });
+        stage(logger, 'owner_runtime');
+        currentStage = 'viewer';
+        const viewerFactory = dependencies.createViewerServer ?? viewer_server_js_1.createViewerServer;
+        viewer = viewerFactory({
+            dispatch: owner.surface.dispatch,
+            ownerAccess: owner.surface.ownerAccess,
+            timeZone,
+            reportStore: owner.reportStore,
+            reportSseClients: owner.reportSseClients,
+            wikiRoot: owner.wikiRoot,
+            logPath: config.logging.file,
+            securityEvents: {
+                path: (0, node_path_1.join)(paths.mamaRoot, 'logs', 'security-events.jsonl'),
+                replay: options.mode === 'replay',
+                timeZone,
+                sendToOwner: async (text, key) => {
+                    const selected = gateways.get(config.delivery?.security_alerts ?? 'telegram');
+                    if (!selected)
+                        throw new Error('Security alert delivery messenger is not available');
+                    await selected.sendToOwner(text, key);
+                },
+            },
+            getMemoryStats: () => (0, viewer_data_js_1.readViewerMemoryStats)(owner.database.adapter),
+            getRuntimeStatus: () => ({
+                running: true,
+                version: (0, package_version_js_1.resolvePackageVersion)(),
+                backend: config.agent.backend,
+                model: config.agent.model,
+                startedAt,
+                health: null,
+                connectors: (connectors?.enabledConnectorNames ?? []).map((name) => ({
+                    name,
+                    enabled: true,
+                    state: connectors?.registry.get(name) ? 'connected' : 'unknown',
+                })),
+            }),
+            getConnectorStatus: async () => {
+                if (!connectors)
+                    return [];
+                const connectorRuntime = connectors;
+                const health = await connectorRuntime.registry.healthCheckAll();
+                return connectorRuntime.enabledConnectorNames.map((name) => {
+                    const current = health[name];
+                    return {
+                        name,
+                        enabled: true,
+                        healthy: current?.healthy === true,
+                        lastPoll: current?.lastPollTime?.toISOString() ?? null,
+                        channelCount: connectorRuntime.channelCounts[name] ?? null,
+                    };
+                });
+            },
+        });
+        await viewer.start();
+        logger.info(`viewer server listening on port=${String(viewer.port)}`);
+        stage(logger, 'viewer');
+        if (options.mode === 'replay') {
+            logger.info('replay collectors: disabled');
+            currentStage = 'replay';
+            if (!options.replay)
+                throw new Error('Replay mode requires a replay feeder');
+            await options.replay({ config, paths, owner, logger, timeZone });
+            stage(logger, 'replay');
+            return {
+                config,
+                paths,
+                owner,
+                viewer,
+                connectors: null,
+                gateway: null,
+                gateways,
+                stop: stopResources,
+            };
+        }
+        currentStage = 'connectors';
+        const acceptSourceDelta = async (delta) => {
+            const id = (0, stimulus_delivery_js_1.sourceDeltaStimulusId)(delta);
+            try {
+                const receipt = owner.acceptSourceDelta(delta);
+                stimulusAccepted(logger, 'source_delta', id, receipt);
+            }
+            catch (error) {
+                stimulusFailed(logger, 'source_delta', id, error);
+                throw error;
+            }
+        };
+        const connectorFactory = dependencies.startConnectorRuntime ?? connectors_js_1.startConnectorRuntime;
+        connectors = await connectorFactory({
+            configPath: paths.connectorsConfigPath,
+            timeZone,
+            ...(config.wiki?.enabled
+                ? { wikiRoot: (0, node_path_1.resolve)(config.wiki.vaultPath, config.wiki.wikiDir) }
+                : {}),
+            rawPath: paths.connectorsRoot,
+            statePath: paths.connectorsRoot,
+            trelloStatePath: paths.trelloStatePath,
+            kagemushaDbPath: paths.kagemushaDbPath,
+            coreAdapter: owner.database?.adapter,
+            acceptSourceDelta,
+        });
+        stage(logger, 'connectors');
+        currentStage = 'messengers';
+        const intake = loggedOwnerIntake(owner.intake, logger);
+        const ledgerPath = paths.ownerMessageLedgerPath;
+        const messageLedger = new telegram_message_ledger_js_1.OwnerMessageLedger(ledgerPath, { log: (line) => logger.info(line) });
+        const filesRoot = (0, node_path_1.join)(paths.workspaceDir, 'files');
+        if (config.telegram.enabled) {
+            const token = process.env.MAMA_TELEGRAM_TOKEN;
+            if (!token?.trim())
+                throw new Error('MAMA_TELEGRAM_TOKEN is required');
+            const factory = dependencies.createTelegramGateway ?? ((options) => new telegram_js_1.TelegramGateway(options));
+            gateway = factory({
+                token,
+                intake,
+                config: {
+                    enabled: true,
+                    allowedChats: config.telegram.allowed_chats,
+                    ownerUserIds: config.telegram.owner_user_ids,
+                    ownerChatId: config.telegram.owner_chat_id,
+                    polling: config.telegram.polling,
+                },
+                messageLedgerPath: ledgerPath,
+                messageLedger,
+                log: (line) => logger.info(line),
+                onFatalError: (error) => {
+                    logger.error(`telegram fatal polling error=${(0, stimulus_delivery_js_1.stimulusFailureReason)(error)}`);
+                    process.exit(1);
+                },
+                filesRoot,
+                downloadsDir: paths.downloadsDir,
+            });
+            gateways.set('telegram', gateway);
+            await gateway.start();
+            stage(logger, 'telegram');
+        }
+        else
+            stage(logger, 'telegram:disabled');
+        if (config.discord?.enabled) {
+            const token = process.env.MAMA_DISCORD_TOKEN;
+            if (!token?.trim())
+                throw new Error('MAMA_DISCORD_TOKEN is required');
+            const factory = dependencies.createDiscordGateway ?? ((options) => new discord_js_1.DiscordGateway(options));
+            const active = factory({
+                token,
+                intake,
+                config: {
+                    enabled: true,
+                    ownerChannelId: config.discord.owner_channel_id,
+                    allowedChannels: config.discord.allowed_channels,
+                    ownerUserIds: config.discord.owner_user_ids,
+                },
+                messageLedgerPath: ledgerPath,
+                messageLedger,
+                filesRoot,
+                downloadsDir: paths.downloadsDir,
+                log: (line) => logger.info(line),
+            });
+            gateways.set('discord', active);
+            await active.start();
+            stage(logger, 'discord');
+        }
+        if (config.slack?.enabled) {
+            const token = process.env.MAMA_SLACK_TOKEN;
+            const appToken = process.env.MAMA_SLACK_APP_TOKEN;
+            if (!token?.trim())
+                throw new Error('MAMA_SLACK_TOKEN is required');
+            if (!appToken?.trim())
+                throw new Error('MAMA_SLACK_APP_TOKEN is required');
+            const factory = dependencies.createSlackGateway ?? ((options) => new slack_js_1.SlackGateway(options));
+            const active = factory({
+                token,
+                appToken,
+                intake,
+                config: {
+                    enabled: true,
+                    ownerChannelId: config.slack.owner_channel_id,
+                    allowedChannels: config.slack.allowed_channels,
+                    ownerUserIds: config.slack.owner_user_ids,
+                },
+                messageLedgerPath: ledgerPath,
+                messageLedger,
+                filesRoot,
+                downloadsDir: paths.downloadsDir,
+                log: (line) => logger.info(line),
+            });
+            gateways.set('slack', active);
+            await active.start();
+            stage(logger, 'slack');
+        }
+        const reportRoute = config.delivery?.reports ?? 'telegram';
+        if (gateways.has(reportRoute)) {
+            currentStage = 'report_scheduler';
+            const schedulerFactory = dependencies.createReportScheduler ?? report_scheduler_js_1.createReportScheduler;
+            reportScheduler = schedulerFactory({
+                config: config.reports,
+                timeZone,
+                statePath: (0, node_path_1.join)(paths.runtimeRoot, 'report-schedule-state.json'),
+                intake: {
+                    acceptScheduled: (input) => {
+                        const receipt = owner.intake.acceptScheduled(input);
+                        stimulusAccepted(logger, 'scheduled', input.id, receipt);
+                        return receipt;
+                    },
+                },
+                hasPendingReport: () => Boolean(owner.database.adapter
+                    .prepare(`SELECT 1 FROM mailbox_inputs m LEFT JOIN native_input_deliveries n ON n.input_id = m.id WHERE m.principal_id = ? AND m.kind = 'scheduled' AND m.channel_key = 'schedule' AND m.status IN ('pending', 'claimed') AND (n.state IS NULL OR n.state != 'uncertain') LIMIT 1`)
+                    .get(OWNER_PRINCIPAL_ID)),
+                sendToOwner: (text, key) => gateways.get(reportRoute).sendToOwner(text, key),
+                onError: (error) => logger.error(`report scheduler failed reason=${(0, stimulus_delivery_js_1.stimulusFailureReason)(error)}`),
+            });
+            reportScheduler.start();
+            stage(logger, 'report_scheduler');
+        }
+        else
+            stage(logger, 'report_scheduler:route_unavailable');
+        deliveryReady = true;
+        return {
+            config,
+            paths,
+            owner,
+            viewer,
+            connectors,
+            gateway,
+            gateways,
+            stop: stopResources,
+        };
+    }
+    catch (error) {
+        stageFailed(logger, currentStage, error);
+        try {
+            await stopResources();
+        }
+        catch {
+            // Preserve the boot error; each cleanup failure was already logged by stopOne.
+        }
+        throw error;
+    }
+}
+/** Foreground launchd entry: wait until SIGTERM/SIGINT, then close reverse-order stages. */
+async function runDaemon(options = {}) {
+    const daemon = await bootDaemon(options);
+    await new Promise((resolve, reject) => {
+        let finished = false;
+        const finish = async () => {
+            if (finished)
+                return;
+            finished = true;
+            try {
+                await daemon.stop();
+                resolve();
+            }
+            catch (error) {
+                reject(error);
+            }
+        };
+        process.once('SIGTERM', () => void finish());
+        process.once('SIGINT', () => void finish());
+    });
+}
+function launchdService(command) {
+    const result = (0, node_child_process_1.spawnSync)('launchctl', [command, `gui/${process.getuid()}/com.mama.server`], {
+        encoding: 'utf8',
+    });
+    if (result.error)
+        throw result.error;
+    // launchctl print exits 113 when this user's service is not registered.
+    if (result.status !== 0 && !(command === 'print' && result.status === 113)) {
+        throw Object.assign(new Error(`launchctl ${command} failed`), {
+            code: `LAUNCHCTL_${result.status ?? result.signal ?? 'UNKNOWN'}`,
+        });
+    }
+    return result;
+}
+function daemonStatus() {
+    const result = launchdService('print');
+    return result.status === 0 && /^\s*state = running\s*$/m.test(result.stdout)
+        ? 'running'
+        : 'stopped';
+}
+function requestDaemonStop() {
+    launchdService('bootout');
+}
+//# sourceMappingURL=daemon.js.map