@jungjaehoon/mama-os 0.78.0 → 0.79.1

package/dist/cli/commands/init.js

@@ -33,6 +33,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForBoot = waitForBoot;
+exports.viewerHealth = viewerHealth;
 exports.runInit = runInit;
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
@@ -40,384 +42,593 @@ const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const yaml = __importStar(require("js-yaml"));
 const config_js_1 = require("../../runtime/config.js");
+const member_paths_js_1 = require("../../runtime/member-paths.js");
+const tools_paths_js_1 = require("../../runtime/tools-paths.js");
+const backend_security_js_1 = require("../../runtime/backend-security.js");
+const viewer_server_js_1 = require("../../api/viewer-server.js");
 const document_toolkit_js_1 = require("../../tools/document-toolkit.js");
-const tools_js_1 = require("./tools.js");
 const launch_files_js_1 = require("../launch-files.js");
 const prompt_js_1 = require("../prompt.js");
 const secrets_js_1 = require("../secrets.js");
-const connectorNames = [
-    'slack',
-    'chatwork',
-    'trello',
-    'kagemusha',
-    'calendar',
-    'gmail',
-    'drive',
-    'sheets',
-    'notion',
-    'obsidian',
-    'discord',
-    'telegram',
-    'imessage',
-    'claude-code',
-];
-const connectorSecrets = {
-    slack: ['MAMA_SLACK_TOKEN'],
-    chatwork: ['MAMA_CHATWORK_TOKEN'],
-    trello: ['MAMA_TRELLO_KEY', 'MAMA_TRELLO_TOKEN'],
-    kagemusha: [],
-    calendar: [],
-    gmail: [],
-    drive: [],
-    sheets: [],
-    notion: ['MAMA_NOTION_TOKEN'],
-    obsidian: [],
-    discord: ['MAMA_DISCORD_TOKEN'],
-    telegram: ['MAMA_TELEGRAM_SOURCE_TOKEN'],
-    imessage: [],
-    'claude-code': [],
-};
-const gwsConnectorNames = new Set(['calendar', 'gmail', 'drive', 'sheets']);
-const noSecretConnectorNames = new Set(['kagemusha', 'obsidian', 'imessage', 'claude-code']);
-async function yes(prompt, label) {
-    const value = (await prompt.text(`${label} [y/N]`)).trim().toLowerCase();
-    if (['', 'n', 'no'].includes(value))
-        return false;
-    if (['y', 'yes'].includes(value))
-        return true;
-    throw new prompt_js_1.CliInputError('Answer yes or no.');
-}
-async function text(prompt, label) {
-    return (0, prompt_js_1.nonblankLine)(await prompt.text(label)).trim();
+const diagnostics_js_1 = require("../runtime/diagnostics.js");
+const setup_page_js_1 = require("../runtime/setup-page.js");
+const default_roots_js_1 = require("../runtime/default-roots.js");
+const telegram_pairing_js_1 = require("../runtime/telegram-pairing.js");
+const init_state_js_1 = require("../runtime/init-state.js");
+const daemon_control_js_1 = require("../runtime/daemon-control.js");
+const systemd_service_js_1 = require("../runtime/systemd-service.js");
+const daemon_js_1 = require("./daemon.js");
+const init_questions_js_1 = require("./init-questions.js");
+const init_section_js_1 = require("./init-section.js");
+const register_owner_js_1 = require("./register-owner.js");
+const service_js_1 = require("./service.js");
+/** What init says to do about a source's tool the service cannot find. */
+const SOURCE_TOOL_NEXT = 'Do that now; if setup stops waiting for MAMA to start, running the install command again continues it.';
+function requiredVariable(env, name) {
+    const value = env[name]?.trim();
+    if (!value)
+        throw new prompt_js_1.CliInputError(`mama init --non-interactive needs ${name}`);
+    return (0, prompt_js_1.nonblankLine)(value).trim();
 }
-async function optionalText(prompt, label) {
-    const value = (await prompt.text(label)).trim();
-    return value === '' ? undefined : (0, prompt_js_1.nonblankLine)(value).trim();
-}
-async function collectConnectors(prompt, secrets) {
-    const selected = (await prompt.text(`Connectors to enable (${connectorNames.join(', ')}; comma-separated, blank for none)`)).trim();
-    const names = selected === '' ? [] : [...new Set(selected.split(',').map((name) => name.trim()))];
-    if (names.some((name) => !connectorNames.includes(name))) {
-        throw new prompt_js_1.CliInputError(`Choose connectors from: ${connectorNames.join(', ')}`);
-    }
-    const config = {};
-    for (const name of names) {
-        for (const tokenName of connectorSecrets[name])
-            secrets[tokenName] = (0, prompt_js_1.nonblankLine)(await prompt.secret(tokenName));
-        if (name === 'slack')
-            secrets.MAMA_SLACK_APP_TOKEN = (0, prompt_js_1.nonblankLine)(await prompt.secret('MAMA_SLACK_APP_TOKEN'));
-        if (name === 'calendar')
-            prompt.write('Calendar currently reads the primary calendar only; its source channel id is calendar.');
-        if (name === 'gmail') {
-            config.gmail = {
-                enabled: true,
-                pollIntervalMinutes: 5,
-                channels: { inbox: { role: 'hub' } },
-                auth: { type: 'cli', cli: 'gws', cliAuthCommand: 'gws auth login' },
-            };
-            continue;
-        }
-        if (name === 'notion') {
-            config.notion = {
-                enabled: true,
-                pollIntervalMinutes: 5,
-                channels: { workspace: { role: 'hub', name: 'Notion workspace' } },
-                auth: { type: 'token', tokenName: 'MAMA_NOTION_TOKEN' },
-            };
-            continue;
-        }
-        if (name === 'obsidian') {
-            const vaultPath = await text(prompt, 'Obsidian vault path');
-            config.obsidian = {
-                enabled: true,
-                pollIntervalMinutes: 5,
-                channels: { vault: { role: 'hub', name: 'Vault', vaultPath } },
-                auth: { type: 'none' },
-            };
-            continue;
-        }
-        if (name === 'claude-code') {
-            const selectedProjects = (await text(prompt, 'Claude Code project directory names (comma-separated)'))
-                .split(',')
-                .map((project) => project.trim());
-            if (selectedProjects.some((project) => !project || /[/\\\s]/.test(project))) {
-                throw new prompt_js_1.CliInputError('Enter Claude Code project directory names without paths or spaces.');
-            }
-            const channels = {};
-            for (const project of selectedProjects) {
-                const alias = await text(prompt, `Display alias for ${project}`);
-                channels[project] = { role: 'hub', name: alias };
-            }
-            config['claude-code'] = {
-                enabled: true,
-                pollIntervalMinutes: 5,
-                channels,
-                auth: { type: 'none' },
-            };
-            continue;
-        }
-        if (name === 'drive') {
-            const folderIds = (await text(prompt, 'Drive folder ids (comma-separated)'))
-                .split(',')
-                .map((id) => id.trim());
-            if (folderIds.some((id) => !id || /\s/.test(id)))
-                throw new prompt_js_1.CliInputError('Enter Drive folder ids separated by commas without spaces.');
-            config.drive = {
-                enabled: true,
-                pollIntervalMinutes: 5,
-                channels: Object.fromEntries(folderIds.map((folderId) => [folderId, { role: 'hub', folderId }])),
-                auth: { type: 'cli', cli: 'gws', cliAuthCommand: 'gws auth login' },
-            };
-            continue;
-        }
-        if (name === 'sheets') {
-            const spreadsheetId = await text(prompt, 'Google Sheets spreadsheet id');
-            const sheetRange = await text(prompt, 'Google Sheets header-and-data range');
-            const dataRange = await optionalText(prompt, 'Separate data range (blank to use the full range)');
-            config.sheets = {
-                enabled: true,
-                pollIntervalMinutes: 5,
-                channels: {
-                    spreadsheet: {
-                        role: 'hub',
-                        spreadsheetId,
-                        sheetRange,
-                        ...(dataRange ? { dataRange } : {}),
-                    },
-                },
-                auth: { type: 'cli', cli: 'gws', cliAuthCommand: 'gws auth login' },
-            };
-            continue;
-        }
-        const ids = (await text(prompt, `${name} ${name === 'trello' ? 'board' : 'channel'} ids (comma-separated ids only)`))
-            .split(',')
-            .map((id) => id.trim());
-        if (ids.some((id) => !id || /\s/.test(id)))
-            throw new prompt_js_1.CliInputError('Enter channel ids separated by commas, without display names.');
-        if (name === 'calendar' && (ids.length !== 1 || ids[0] !== 'calendar')) {
-            throw new prompt_js_1.CliInputError('Calendar supports only the source channel id calendar (primary calendar).');
-        }
-        config[name] = {
-            enabled: true,
-            pollIntervalMinutes: 5,
-            channels: Object.fromEntries(ids.map((id) => [id, { role: 'hub', ...(name === 'trello' ? { boardId: id } : {}) }])),
-            auth: gwsConnectorNames.has(name)
-                ? { type: 'cli', cli: 'gws', cliAuthCommand: 'gws auth login' }
-                : noSecretConnectorNames.has(name)
-                    ? { type: 'none' }
-                    : { type: 'token', tokenName: connectorSecrets[name].at(-1) },
-        };
+function validChatId(chatId) {
+    if (!/^-[1-9]\d*$/.test(chatId)) {
+        throw new prompt_js_1.CliInputError('Enter a Telegram group or supergroup id (negative); private chats go to personal intake and cannot reach the common session.');
     }
-    return config;
+    return chatId;
 }
-async function runInit(options = {}) {
-    const prompt = options.prompt ?? (0, prompt_js_1.createTerminalPrompt)();
-    (0, prompt_js_1.requireTTY)(prompt);
-    const home = options.home ?? (0, node_os_1.homedir)();
-    const root = (0, node_path_1.join)(home, '.mama');
-    const configPath = (0, node_path_1.join)(root, 'config.yaml');
-    if ((0, node_fs_1.existsSync)(configPath))
-        throw new prompt_js_1.CliInputError('config.yaml already exists; init will not overwrite it.');
-    // A partial manual setup must also be reviewed by the owner before replacing files.
-    for (const name of ['connectors.json', 'start.sh']) {
-        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(root, name)))
-            throw new prompt_js_1.CliInputError(`${name} already exists; init will not overwrite it.`);
-    }
-    const backend = await text(prompt, 'Backend (claude|codex)');
-    if (backend !== 'claude' && backend !== 'codex')
-        throw new prompt_js_1.CliInputError('Backend must be claude or codex.');
-    const model = await text(prompt, 'Model');
-    const machineTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    const timezoneAnswer = (await prompt.text(`Owner timezone [${machineTimeZone}]`)).trim();
-    const timezone = timezoneAnswer || machineTimeZone;
+function validTelegramId(id) {
+    if (!/^[1-9]\d*$/.test(id))
+        throw new prompt_js_1.CliInputError('Enter your numeric Telegram user ID (only digits).');
+    return id;
+}
+/** The variables start.sh exports for a viewer behind a Cloudflare Access tunnel (service.ts). */
+const TUNNEL_VARIABLES = [
+    'MAMA_CF_ACCESS_ISSUER',
+    'MAMA_CF_ACCESS_AUD',
+    'MAMA_VIEWER_HOSTNAMES',
+    'MAMA_VIEWER_OWNER_EMAILS',
+];
+/**
+ * The tunnel, from those variables: none set, no tunnel; any set, the issuer, audience and
+ * hostname are needed and the owner emails stay optional.
+ */
+function tunnelVariables(env) {
+    if (!TUNNEL_VARIABLES.some((name) => env[name]?.trim()))
+        return {};
+    const issuer = requiredVariable(env, 'MAMA_CF_ACCESS_ISSUER');
+    let url;
     try {
-        new Intl.DateTimeFormat('en', { timeZone: timezone });
+        url = new URL(issuer);
     }
     catch {
-        throw new prompt_js_1.CliInputError(`Timezone "${timezone}" is not a valid IANA time zone.`);
+        throw new prompt_js_1.CliInputError('MAMA_CF_ACCESS_ISSUER must be an HTTPS origin.');
     }
-    const secrets = {
-        MAMA_TELEGRAM_TOKEN: (0, prompt_js_1.nonblankLine)(await prompt.secret('Telegram bot token')),
-    };
-    const chatId = await text(prompt, 'Telegram common group/supergroup chat id (negative)');
-    if (!/^-[1-9]\d*$/.test(chatId)) {
-        throw new prompt_js_1.CliInputError('Enter a Telegram group or supergroup id (negative); private chats go to personal intake and cannot reach the common session.');
+    if (url.protocol !== 'https:' ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash ||
+        url.pathname !== '/') {
+        throw new prompt_js_1.CliInputError('MAMA_CF_ACCESS_ISSUER must be an HTTPS origin.');
     }
-    const connectors = await collectConnectors(prompt, secrets);
-    const discordEnabled = await yes(prompt, 'Enable Discord owner messages');
-    let discordConfig = {
-        enabled: false,
-        allowed_channels: [],
-        owner_user_ids: [],
+    const viewer = {
+        MAMA_CF_ACCESS_ISSUER: url.origin,
+        MAMA_CF_ACCESS_AUD: requiredVariable(env, 'MAMA_CF_ACCESS_AUD'),
     };
-    if (discordEnabled) {
-        secrets.MAMA_DISCORD_TOKEN ??= (0, prompt_js_1.nonblankLine)(await prompt.secret('Discord bot token'));
-        const channel = await text(prompt, 'Discord owner channel id');
-        const user = await text(prompt, 'Discord owner user id');
-        discordConfig = {
-            enabled: true,
-            owner_channel_id: channel,
-            allowed_channels: [channel],
-            owner_user_ids: [user],
-        };
+    const hostname = requiredVariable(env, 'MAMA_VIEWER_HOSTNAMES');
+    if (!/^[a-z0-9]+(?:[.-][a-z0-9]+)*$/i.test(hostname))
+        throw new prompt_js_1.CliInputError('MAMA_VIEWER_HOSTNAMES must be one hostname, without scheme or path.');
+    viewer.MAMA_VIEWER_HOSTNAMES = hostname;
+    const emails = env.MAMA_VIEWER_OWNER_EMAILS?.trim();
+    if (emails)
+        viewer.MAMA_VIEWER_OWNER_EMAILS = (0, prompt_js_1.nonblankLine)(emails);
+    return viewer;
+}
+/**
+ * The bot token and the pairing code, entered on the setup page (install.md, W2.4.5b). The token
+ * is checked as Telegram answers it; then pairOwner's `ask` is answered by the code's entry, whose
+ * reply waits for pairOwner: another `ask` means a wrong code, a return the right one. One process
+ * runs from the token to /bind, since the codes and the update offset live in pairOwner's memory.
+ */
+async function pairOnSetupPage(options) {
+    const { call, write } = options;
+    let taken;
+    const tokenTaken = new Promise((resolve) => {
+        taken = resolve;
+    });
+    // pairOwner's first ask: it has dropped what the bot held from before (telegram-pairing.ts).
+    let asked;
+    let notAsked;
+    const firstAsk = new Promise((resolve, reject) => {
+        asked = resolve;
+        notAsked = reject;
+    });
+    firstAsk.catch(() => { });
+    /** The ask waiting for an entry, and the entry waiting for pairOwner's verdict. */
+    let waiting;
+    let entry;
+    /** pairOwner's last line: after a wrong code, the one that says so. */
+    let lastLine = '';
+    const page = await (0, setup_page_js_1.openSetupPage)({
+        fields: [
+            {
+                name: 'token',
+                label: 'Telegram bot token (from BotFather)',
+                secret: true,
+                check: async (value) => {
+                    let token;
+                    let botUsername;
+                    try {
+                        token = (0, prompt_js_1.nonblankLine)(value).trim();
+                        // The page asks again, so a network failure names the entry, not a rerun.
+                        await (0, init_questions_js_1.checkTelegram)(token, undefined, call, write, {
+                            next: 'enter it again on the setup page',
+                        });
+                        botUsername = await (0, telegram_pairing_js_1.botName)({ token, call, write });
+                    }
+                    catch (error) {
+                        if (error instanceof prompt_js_1.CliInputError)
+                            write(error.message);
+                        throw error;
+                    }
+                    write(`bot token accepted for @${botUsername}`);
+                    taken({ token, botUsername });
+                    // A message sent before pairOwner's first poll would be dropped with the held ones.
+                    await firstAsk;
+                    return `The bot token is accepted for @${botUsername}. In Telegram, send @${botUsername} a new private message; it answers with a pairing code.`;
+                },
+            },
+            {
+                name: 'code',
+                label: 'Pairing code (from the bot)',
+                secret: false,
+                check: (value) => new Promise((accept, refuse) => {
+                    const answer = waiting;
+                    // The page takes one entry at a time, and asks for the code only after pairOwner did.
+                    if (answer === undefined)
+                        throw new Error('a pairing code was entered with none asked for');
+                    waiting = undefined;
+                    entry = { accept, refuse };
+                    answer(value);
+                }),
+            },
+        ],
+        write,
+        platform: options.platform,
+        ...(options.openRun ? { openRun: options.openRun } : {}),
+        ...(options.lifetimeMs === undefined ? {} : { lifetimeMs: options.lifetimeMs }),
+    });
+    try {
+        const { token, botUsername } = await Promise.race([tokenTaken, page.stopped]);
+        const owner = await (0, telegram_pairing_js_1.pairOwner)({
+            token,
+            call,
+            botUsername,
+            write: (line) => {
+                lastLine = line;
+                write(line);
+            },
+            ask: (_label, signal) => {
+                // pairOwner asks again only after a wrong code, and wrote why just before.
+                entry?.refuse(new prompt_js_1.CliInputError(lastLine));
+                entry = undefined;
+                asked();
+                return new Promise((resolve, reject) => {
+                    waiting = resolve;
+                    signal.addEventListener('abort', () => reject(new Error('pairing stopped')), {
+                        once: true,
+                    });
+                    page.stopped.catch(reject);
+                });
+            },
+        });
+        write('pairing code accepted');
+        entry?.accept(`The pairing code is accepted. Add @${botUsername} to the group for common work as an administrator, then send /bind in that group. This page has closed.`);
+        const group = await (0, telegram_pairing_js_1.bindCommonGroup)({
+            token,
+            call,
+            write,
+            botUsername,
+            ownerId: owner.ownerId,
+            offset: owner.offset,
+            earlier: owner.groupMessages,
+        });
+        await (0, telegram_pairing_js_1.confirmUpdates)({ token, call, write, offset: group.offset });
+        // The bot's post in the group proved the token; the group's privacy and membership are only
+        // reported, and doctor checks them again later.
+        (0, init_questions_js_1.report)(await (0, diagnostics_js_1.telegramCheck)(token, group.chatId, call), write);
+        return { token, ownerId: owner.ownerId, chatId: group.chatId };
     }
-    const slackEnabled = await yes(prompt, 'Enable Slack owner messages');
-    let slackConfig = {
-        enabled: false,
-        allowed_channels: [],
-        owner_user_ids: [],
-    };
-    if (slackEnabled) {
-        secrets.MAMA_SLACK_TOKEN ??= (0, prompt_js_1.nonblankLine)(await prompt.secret('Slack bot token'));
-        secrets.MAMA_SLACK_APP_TOKEN ??= (0, prompt_js_1.nonblankLine)(await prompt.secret('Slack Socket Mode app token'));
-        const channel = await text(prompt, 'Slack owner channel id');
-        const user = await text(prompt, 'Slack owner user id');
-        slackConfig = {
-            enabled: true,
-            owner_channel_id: channel,
-            allowed_channels: [channel],
-            owner_user_ids: [user],
-        };
+    catch (error) {
+        // An entry still waiting gets the sentence that ends the setup.
+        notAsked(error);
+        entry?.refuse(error);
+        throw error;
     }
-    const viewer = {};
-    // Jev (TypeSafe) is the owner's choice: the agent's judge tool, off unless chosen here.
-    const jevKeyPath = (0, node_path_1.join)(root, 'jev-key');
-    const jevEnabled = await yes(prompt, 'Use Jev (TypeSafe) so the agent can judge many messages or items without reading them all? Owner text in those calls goes to the Jev service');
-    let jevKey;
-    if (jevEnabled && !(0, node_fs_1.existsSync)(jevKeyPath)) {
-        prompt.write('Get a Jev API key from TypeSafe: https://docs.typesafe.ai');
-        jevKey = (0, prompt_js_1.nonblankLine)(await prompt.secret('Jev API key'));
+    finally {
+        page.close();
     }
-    if (await yes(prompt, 'Expose the viewer through a tunnel')) {
-        const issuer = await text(prompt, 'Access issuer (HTTPS URL)');
-        let url;
-        try {
-            url = new URL(issuer);
+}
+/**
+ * The setup's answers. Those from the environment are all checked before the setup page opens,
+ * so a refused one does not make the owner pair again. The page takes the bot token and the
+ * pairing code: a secret never comes from a variable or a flag, which `ps` shows, and no Telegram
+ * ID is typed. Sources, Discord, Slack and Jev are set up afterwards with `mama init --section`.
+ */
+async function environmentAnswers(env, defaults, checks) {
+    const backend = requiredVariable(env, 'MAMA_INIT_BACKEND');
+    if (backend !== 'claude' && backend !== 'codex')
+        throw new prompt_js_1.CliInputError('MAMA_INIT_BACKEND must be claude or codex.');
+    checks.backend(backend);
+    const model = requiredVariable(env, 'MAMA_INIT_MODEL');
+    const timezone = (0, init_questions_js_1.validTimezone)(env.MAMA_INIT_TIMEZONE?.trim() || Intl.DateTimeFormat().resolvedOptions().timeZone);
+    const memberAnswer = env.MAMA_INIT_MEMBER_ROOT?.trim() || defaults?.memberRoot;
+    const toolsAnswer = env.MAMA_INIT_TOOLS_ROOT?.trim() || defaults?.toolsRoot;
+    if (!memberAnswer || !toolsAnswer)
+        throw new prompt_js_1.CliInputError('This platform has no default folders; set MAMA_INIT_MEMBER_ROOT and MAMA_INIT_TOOLS_ROOT.');
+    const { memberRoot, toolsRoot } = checks.roots(memberAnswer, toolsAnswer, {
+        member: !env.MAMA_INIT_MEMBER_ROOT?.trim(),
+        tools: !env.MAMA_INIT_TOOLS_ROOT?.trim(),
+    });
+    const viewer = tunnelVariables(env);
+    const paired = await checks.page();
+    return {
+        backend,
+        model,
+        timezone,
+        secrets: { MAMA_TELEGRAM_TOKEN: paired.token },
+        chatId: validChatId(paired.chatId),
+        ownerTelegramId: validTelegramId(paired.ownerId),
+        memberRoot,
+        toolsRoot,
+        viewer,
+    };
+}
+/**
+ * Wait until the started daemon reports its boot finished, then until the viewer answers. With a
+ * `version`, the daemon must be that version: `mama update` waits for the one it installed.
+ */
+async function waitForBoot(options) {
+    const started = Date.now();
+    let reported = started;
+    let stage = 'not started';
+    const next = options.next ?? 'running the install command again continues from here';
+    for (;;) {
+        // A daemon busy booting may miss one status deadline; that is no answer yet, not a failure.
+        const reply = await options.status().catch(() => null);
+        if (reply?.state === 'running' && reply.reply.ok === true) {
+            const status = (reply.reply.status ?? {});
+            stage = String(status.stage);
+            if (options.version !== undefined && status.version !== options.version) {
+                stage = `${stage} at version ${String(status.version)}, not ${options.version}`;
+            }
+            else if (stage === 'running')
+                break;
         }
-        catch {
-            throw new prompt_js_1.CliInputError('Access issuer must be an HTTPS origin.');
+        if (Date.now() - started >= options.timeoutMs) {
+            throw new prompt_js_1.CliInputError(`MAMA did not finish starting (last stage: ${stage}). mama logs shows why; ${next}.`);
         }
-        if (url.protocol !== 'https:' ||
-            url.username ||
-            url.password ||
-            url.search ||
-            url.hash ||
-            url.pathname !== '/') {
-            throw new prompt_js_1.CliInputError('Access issuer must be an HTTPS origin.');
+        if (Date.now() - reported >= 30_000) {
+            options.write(`still starting (stage: ${stage})`);
+            reported = Date.now();
         }
-        viewer.MAMA_CF_ACCESS_ISSUER = url.origin;
-        viewer.MAMA_CF_ACCESS_AUD = await text(prompt, 'Access audience');
-        const hostname = await text(prompt, 'Viewer hostname (no scheme or path)');
-        if (!/^[a-z0-9]+(?:[.-][a-z0-9]+)*$/i.test(hostname))
-            throw new prompt_js_1.CliInputError('Enter a hostname without scheme or path.');
-        viewer.MAMA_VIEWER_HOSTNAMES = hostname;
-        const emails = (await prompt.text('Viewer owner emails for access monitoring (comma-separated, optional)')).trim();
-        if (emails)
-            viewer.MAMA_VIEWER_OWNER_EMAILS = (0, prompt_js_1.nonblankLine)(emails);
+        await new Promise((resolve) => setTimeout(resolve, options.pollMs));
     }
-    const installLaunchAgent = await yes(prompt, 'Write ~/Library/LaunchAgents/com.mama.server.plist');
-    const plistPath = (0, node_path_1.join)(home, 'Library', 'LaunchAgents', 'com.mama.server.plist');
-    if (installLaunchAgent && (0, node_fs_1.existsSync)(plistPath))
-        throw new prompt_js_1.CliInputError('com.mama.server.plist already exists; init will not overwrite it.');
-    const config = (0, config_js_1.parseConfig)({
-        version: 1,
-        timezone,
-        tools_root: options.toolsRoot ?? (0, tools_js_1.defaultToolsRoot)(options.platform, home),
-        agent: {
-            backend,
-            model,
-            effort: 'medium',
-            max_turns: 100,
-            // A turn is stopped after 10 minutes without progress, or after an hour in all
-            // (owner, 2026-10-03); a full report on 2026-09-29 was cut off at 300 s while working.
-            timeout: 600_000,
-            max_turn_ms: 3_600_000,
-            run_token_budget: 0,
-        },
-        database: { path: (0, node_path_1.join)(root, 'memory.db') },
-        logging: { level: 'info', file: (0, node_path_1.join)(root, 'logs', 'daemon.log') },
-        telegram: {
-            enabled: true,
-            owner_chat_id: chatId,
-            allowed_chats: [chatId],
-            polling: true,
-        },
-        discord: discordConfig,
-        slack: slackConfig,
-        delivery: { reports: 'telegram', notifications: 'telegram', security_alerts: 'telegram' },
-        wiki: {
-            enabled: true,
-            vaultPath: (0, node_path_1.join)(root, 'workspace'),
-            wikiDir: (0, node_path_1.join)(root, 'workspace', 'wiki'),
-        },
-        ...(jevEnabled ? { jev: { enabled: true } } : {}),
-    }, { home });
-    const locate = options.findExecutable ?? launch_files_js_1.findExecutable;
-    const backendPath = locate(backend);
-    const gwsPath = locate('gws');
-    const script = (0, launch_files_js_1.startScript)({
-        home,
-        viewer,
-        logLevel: config.logging.level,
-        nodePath: options.nodePath ?? (0, launch_files_js_1.stableNodePath)(process.execPath),
-        cliPath: options.cliPath ?? (0, node_path_1.join)(__dirname, '..', 'index.js'),
-        executablePaths: [backendPath, gwsPath].filter((path) => path !== undefined),
-    });
-    secrets.MAMA_AUTH_TOKEN = (0, node_crypto_1.randomBytes)(32).toString('hex');
-    (0, node_fs_1.mkdirSync)(root, { recursive: true, mode: 0o700 });
-    (0, node_fs_1.mkdirSync)((0, node_path_1.join)(root, 'logs'), { recursive: true, mode: 0o700 });
-    (0, node_fs_1.mkdirSync)((0, node_path_1.join)(root, 'workspace', 'wiki'), { recursive: true, mode: 0o700 });
-    // Finish all prompts before any write, and publish config last as the setup completion marker.
-    (0, secrets_js_1.updateSecrets)(home, secrets);
-    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(root, 'connectors.json'), `${JSON.stringify(connectors, null, 2)}\n`, {
-        flag: 'wx',
-        mode: 0o600,
-    });
-    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(root, 'start.sh'), script, { flag: 'wx', mode: 0o700 });
-    if (jevKey !== undefined)
-        (0, node_fs_1.writeFileSync)(jevKeyPath, `${jevKey}\n`, { flag: 'wx', mode: 0o600 });
-    if (installLaunchAgent) {
-        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(plistPath), { recursive: true });
-        (0, node_fs_1.writeFileSync)(plistPath, (0, launch_files_js_1.launchAgent)(home), { flag: 'wx', mode: 0o600 });
+    if (!(await options.health())) {
+        throw new prompt_js_1.CliInputError(`MAMA started but its viewer does not answer /health; mama doctor checks the install${options.next === undefined ? '' : `; ${options.next}`}.`);
     }
-    (0, node_fs_1.writeFileSync)(configPath, yaml.dump(config), { flag: 'wx', mode: 0o600 });
-    prompt.write('Setup written. Credentials are stored only in auth.env (0600).');
-    prompt.write('Before starting the daemon, run: mama register-owner <telegram id>.');
-    if (!backendPath)
-        prompt.write(`Install ${backend} and add its bin directory to PATH in ~/.mama/start.sh.`);
-    prompt.write(`If you have not logged in, run: ${backend === 'claude' ? 'claude auth login' : `CODEX_HOME=${(0, secrets_js_1.shellQuote)((0, node_path_1.join)(root, '.codex'))} codex login`}`);
-    if (Object.keys(connectors).some((name) => gwsConnectorNames.has(name))) {
-        if (!gwsPath)
-            prompt.write('Install gws and add its bin directory to PATH in ~/.mama/start.sh.');
-        prompt.write('Log in with the Google scopes your selected connectors need: gws auth login.');
+}
+const DEFAULT_VIEWER_PORT = (0, viewer_server_js_1.resolveApiPort)(undefined);
+/** The first viewer port nothing listens on, from the default up. */
+async function freeViewerPort(answers) {
+    for (let port = DEFAULT_VIEWER_PORT; port < DEFAULT_VIEWER_PORT + 50; port += 1) {
+        if (!(await answers(port, '127.0.0.1')))
+            return port;
     }
-    if (jevEnabled)
-        prompt.write(`Jev is on (jev.enabled in config.yaml); its key is ${(0, secrets_js_1.shellQuote)(jevKeyPath)} (0600). Turn it off by removing jev.enabled.`);
-    if (viewer.MAMA_VIEWER_HOSTNAMES)
-        prompt.write('Configure your tunnel to the local viewer and protect its hostname with the Access application above.');
-    if (installLaunchAgent)
-        prompt.write('After login, start with: mama service start');
-    else
-        prompt.write(`After login, start with: ${(0, secrets_js_1.shellQuote)((0, node_path_1.join)(root, 'start.sh'))}`);
-    // Host provisioning is last; a failure leaves setup available for mama tools install.
-    if (!config.tools_root) {
-        prompt.write('Set tools_root to a writable directory outside HOME in config.yaml, then run mama tools install on the host.');
-        return;
+    throw new prompt_js_1.CliInputError(`Ports ${DEFAULT_VIEWER_PORT}-${DEFAULT_VIEWER_PORT + 49} are all in use; free one, then run the install command again.`);
+}
+async function viewerHealth(port) {
+    try {
+        const response = await fetch(`http://127.0.0.1:${port}/health`, {
+            signal: AbortSignal.timeout(5_000),
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/** How much longer than the daemon's own turn limit init waits for the backend check. */
+const PROBE_MARGIN_MS = 60_000;
+const initUsage = `Usage: mama init --non-interactive | mama init --section <${init_section_js_1.initSections.join('|')}> | mama init --section connectors --non-interactive`;
+async function runInit(args = [], options = {}) {
+    if (args[0] === '--section') {
+        const nonInteractive = args.length === 3 && args[2] === '--non-interactive';
+        if (args.length !== 2 && !nonInteractive)
+            throw new prompt_js_1.CliInputError(initUsage);
+        return (0, init_section_js_1.runInitSection)(args[1], options, nonInteractive);
     }
+    // The setup reads no terminal: the person's agent runs it (owner-setup.md).
+    if (args.length !== 1 || args[0] !== '--non-interactive')
+        throw new prompt_js_1.CliInputError(initUsage);
+    const write = (line) => (options.prompt ? options.prompt.write(line) : console.log(line));
+    const home = options.home ?? (0, node_os_1.homedir)();
+    const platform = options.platform ?? process.platform;
+    const root = (0, node_path_1.join)(home, '.mama');
+    const configPath = (0, node_path_1.join)(root, 'config.yaml');
+    const lockPaths = (0, daemon_control_js_1.daemonControlPaths)(root);
+    // While init writes the install, no daemon, restore or second init may run beside it, and the
+    // step record is read and repaired under the same lock, so a second init cannot act on one the
+    // first is still writing. A setup with only the service step left takes no lock: that step
+    // writes no install files, and the daemon a failed wait left starting holds the lock.
+    const peek = (0, init_state_js_1.readInitState)(root);
+    // An install set up before init kept its steps, or by hand: init will not take it over. Said
+    // before the lock, since that install's running daemon holds it.
+    if (peek === null && (0, node_fs_1.existsSync)(configPath))
+        throw new prompt_js_1.CliInputError('config.yaml already exists; init will not overwrite it. mama doctor checks this install.');
+    const serviceOnly = peek !== null &&
+        ['config', 'owner', 'toolkit'].every((step) => peek.done.includes(step));
+    let lock = (0, node_fs_1.existsSync)(root) && !serviceOnly ? (0, daemon_control_js_1.acquireInstallLock)(lockPaths, 'init') : undefined;
+    let progress = { version: 1, done: [] };
+    const mark = (step) => {
+        progress.done.push(step);
+        (0, init_state_js_1.writeInitState)(root, progress);
+    };
+    const done = (step) => progress.done.includes(step);
     try {
-        if (options.installToolkit)
-            await options.installToolkit(config);
-        else
-            await (0, document_toolkit_js_1.installDocumentToolkit)({
-                toolsRoot: config.tools_root,
+        let state = lock ? (0, init_state_js_1.readInitState)(root) : peek;
+        // The record is written before the setup's files, so one without the config step means an
+        // init stopped part-way through writing them. The files only init creates are removed and the
+        // step starts over; auth.env is merged, and a Codex login made before init stays.
+        if (state !== null && !state.done.includes('config')) {
+            for (const name of ['config.yaml', 'connectors.json', 'jev-key'])
+                (0, node_fs_1.rmSync)((0, node_path_1.join)(root, name), { force: true });
+            write('An earlier mama init stopped while writing its files; that step starts over.');
+            state = null;
+        }
+        if ((0, node_fs_1.existsSync)(configPath)) {
+            // An install set up before init kept its steps, or by hand: init will not take it over.
+            if (state === null)
+                throw new prompt_js_1.CliInputError('config.yaml already exists; init will not overwrite it.');
+            // A status, not a refusal: running the install command again on a set-up install ends here.
+            if ((0, init_state_js_1.initComplete)(state)) {
+                write('MAMA is already set up here; mama doctor checks it, mama service restart restarts it and mama update updates it.');
+                return;
+            }
+            write(`continuing setup: done so far: ${state.done.join(', ')}`);
+        }
+        else {
+            state = null;
+            // A partial manual setup must also be reviewed by the owner before replacing files.
+            for (const name of ['connectors.json', 'start.sh']) {
+                if ((0, node_fs_1.existsSync)((0, node_path_1.join)(root, name)))
+                    throw new prompt_js_1.CliInputError(`${name} already exists; init will not overwrite it.`);
+            }
+        }
+        progress = state ?? { version: 1, done: [] };
+        const locate = options.findExecutable ?? launch_files_js_1.findExecutable;
+        // Questions and checks come first, so a refused or cancelled setup leaves nothing in the MAMA
+        // home. The two folders are made as soon as they are named: a folder that cannot be this
+        // user's alone is refused before pairing, which would otherwise have to be done again.
+        let answers;
+        if (!done('config')) {
+            const defaults = (0, default_roots_js_1.defaultRoots)({
+                platform,
                 home,
-                memberRoot: config.member_root,
-                write: prompt.write,
+                ...(options.user === undefined ? {} : { user: options.user }),
             });
+            const call = options.telegramCall ?? diagnostics_js_1.defaultTelegramCall;
+            const checks = {
+                // A signed-out backend's login is named, with the backend's full path; the agent runs it.
+                backend: (name) => (0, init_questions_js_1.checkBackend)(name, (0, node_path_1.join)(root, '.codex'), locate, options.probeRun, 'run the install command again'),
+                roots: (memberAnswer, toolsAnswer, isDefault) => {
+                    const memberRoot = (0, node_path_1.resolve)(memberAnswer);
+                    const toolsRoot = (0, node_path_1.resolve)(toolsAnswer);
+                    try {
+                        (0, member_paths_js_1.validateMemberRoot)(memberRoot, [home, root]);
+                        (0, tools_paths_js_1.assertRootAncestors)((0, backend_security_js_1.physicalReadPath)(memberRoot), 'member_root');
+                        (0, tools_paths_js_1.validateToolsRoot)(toolsRoot, [home, root, memberRoot]);
+                    }
+                    catch (error) {
+                        throw new prompt_js_1.CliInputError(error.message);
+                    }
+                    for (const [folder, ownParent] of [
+                        [memberRoot, isDefault.member],
+                        [toolsRoot, isDefault.tools],
+                    ]) {
+                        (0, default_roots_js_1.prepareRoot)(folder, {
+                            ownParent,
+                            ...(options.uid === undefined ? {} : { uid: options.uid }),
+                        });
+                    }
+                    return { memberRoot, toolsRoot };
+                },
+                page: () => pairOnSetupPage({
+                    call,
+                    write,
+                    platform,
+                    ...(options.openRun ? { openRun: options.openRun } : {}),
+                    ...(options.setupPageMs === undefined ? {} : { lifetimeMs: options.setupPageMs }),
+                }),
+            };
+            answers = await environmentAnswers(options.env ?? process.env, defaults, checks);
+        }
+        if (lock === undefined && !serviceOnly) {
+            // A new install: the MAMA home is made only once the questions are answered, and another
+            // init may have started one meanwhile.
+            (0, node_fs_1.mkdirSync)(root, { recursive: true, mode: 0o700 });
+            lock = (0, daemon_control_js_1.acquireInstallLock)(lockPaths, 'init');
+            if ((0, init_state_js_1.readInitState)(root) !== null || (0, node_fs_1.existsSync)(configPath))
+                throw new prompt_js_1.CliInputError('Another mama init set up here meanwhile; run the install command again.');
+        }
+        // A restore sets the launch files aside too, so even the service step waits for it.
+        (0, daemon_control_js_1.refuseWhileRestoring)(root);
+        let config;
+        if (answers !== undefined) {
+            const { memberRoot, toolsRoot } = answers;
+            // Each account on a machine runs its own MAMA; another's viewer may already hold the port.
+            const port = await freeViewerPort(options.portAnswers ?? diagnostics_js_1.portAnswers);
+            if (port !== DEFAULT_VIEWER_PORT)
+                answers.viewer.MAMA_API_PORT = String(port);
+            config = (0, config_js_1.parseConfig)({
+                version: 1,
+                timezone: answers.timezone,
+                member_root: memberRoot,
+                tools_root: toolsRoot,
+                agent: {
+                    backend: answers.backend,
+                    model: answers.model,
+                    effort: 'medium',
+                    max_turns: 100,
+                    // A turn is stopped after 10 minutes without progress, or after an hour in all
+                    // (owner, 2026-10-03); a full report on 2026-09-29 was cut off at 300 s while working.
+                    timeout: 600_000,
+                    max_turn_ms: 3_600_000,
+                    run_token_budget: 0,
+                },
+                database: { path: (0, node_path_1.join)(root, 'memory.db') },
+                logging: { level: 'info', file: (0, node_path_1.join)(root, 'logs', 'daemon.log') },
+                telegram: {
+                    enabled: true,
+                    owner_chat_id: answers.chatId,
+                    allowed_chats: [answers.chatId],
+                    polling: true,
+                },
+                discord: { enabled: false, allowed_channels: [], owner_user_ids: [] },
+                slack: { enabled: false, allowed_channels: [], owner_user_ids: [] },
+                delivery: { reports: 'telegram', notifications: 'telegram', security_alerts: 'telegram' },
+                wiki: {
+                    enabled: true,
+                    vaultPath: (0, node_path_1.join)(root, 'workspace'),
+                    wikiDir: (0, node_path_1.join)(root, 'workspace', 'wiki'),
+                },
+            }, { home });
+            answers.secrets.MAMA_AUTH_TOKEN = (0, node_crypto_1.randomBytes)(32).toString('hex');
+            (0, init_state_js_1.writeInitState)(root, progress);
+            (0, node_fs_1.mkdirSync)((0, node_path_1.join)(root, 'logs'), { recursive: true, mode: 0o700 });
+            (0, node_fs_1.mkdirSync)((0, node_path_1.join)(root, 'workspace', 'wiki'), { recursive: true, mode: 0o700 });
+            // All answers are in before any write; the step is marked done once config.yaml exists.
+            (0, secrets_js_1.updateSecrets)(home, answers.secrets);
+            // No source yet: `mama init --section connectors` adds them.
+            (0, node_fs_1.writeFileSync)((0, node_path_1.join)(root, 'connectors.json'), '{}\n', { flag: 'wx', mode: 0o600 });
+            (0, node_fs_1.writeFileSync)(configPath, yaml.dump(config), { flag: 'wx', mode: 0o600 });
+            progress.viewer = answers.viewer;
+            progress.pendingOwner = answers.ownerTelegramId;
+            mark('config');
+            write('Setup written. Credentials are stored only in auth.env (0600).');
+        }
+        else {
+            config = (0, config_js_1.loadConfig)({ home, path: configPath });
+            // A setup that stopped (often at the boot wait, when a source's tool is missing) names the
+            // tools again: the service does not start until they are installed.
+            await (0, init_questions_js_1.writeSourceTools)({ root, home, platform, configPath }, config, options, write, SOURCE_TOOL_NEXT);
+        }
+        if (!done('owner')) {
+            const owner = progress.pendingOwner;
+            if (!owner)
+                throw new prompt_js_1.CliInputError('No owner Telegram ID was recorded; run the install command again.');
+            await (0, register_owner_js_1.registerOwnerHolding)(root, config, config.member_root, owner);
+            delete progress.pendingOwner;
+            mark('owner');
+            write("You are registered as this install's first owner.");
+        }
+        if (!done('toolkit')) {
+            try {
+                if (options.installToolkit)
+                    await options.installToolkit(config);
+                else
+                    await (0, document_toolkit_js_1.installDocumentToolkit)({
+                        toolsRoot: config.tools_root,
+                        home,
+                        memberRoot: config.member_root,
+                        write,
+                    });
+                write('Document toolkit installed for owner and member sessions.');
+            }
+            catch (error) {
+                // MAMA runs without the document tools; their host requirements must not keep it from
+                // starting. The daemon log names them as absent until mama tools install succeeds.
+                write(`The document tools could not be installed: ${error instanceof Error ? error.message : 'unknown error'}. MAMA runs without them; run mama tools install once that is fixed.`);
+            }
+            mark('toolkit');
+        }
     }
-    catch (error) {
-        throw new prompt_js_1.CliInputError(`Document toolkit setup failed. Run mama tools install on the host. ${error instanceof Error ? error.message : ''}`);
+    finally {
+        // The daemon takes this lock at boot; it must be free before the service starts it.
+        lock?.release();
+    }
+    if (!done('service')) {
+        const startServiceFor = options.startService ??
+            (async (viewer) => {
+                const serviceOptions = {
+                    home,
+                    platform,
+                    write,
+                    viewer,
+                    ...(options.serviceRun ? { run: options.serviceRun } : {}),
+                    ...(options.findExecutable ? { findExecutable: options.findExecutable } : {}),
+                    ...(options.nodePath ? { nodePath: options.nodePath } : {}),
+                    ...(options.cliPath ? { cliPath: options.cliPath } : {}),
+                    ...(options.toolDirectoryExists
+                        ? { toolDirectoryExists: options.toolDirectoryExists }
+                        : {}),
+                };
+                // Linux keeps the user's services running after logout only with linger (B4). Enabling it
+                // can need privileges this account lacks; that must not stop the service from starting.
+                if (platform === 'linux') {
+                    const user = options.user ?? (0, node_os_1.userInfo)().username;
+                    const result = (options.serviceRun ?? systemd_service_js_1.defaultServiceRun)('loginctl', [
+                        'enable-linger',
+                        user,
+                    ]);
+                    if (result.error || result.status !== 0)
+                        write(`Linger could not be enabled, so MAMA stops when you log out. Run once: sudo loginctl enable-linger ${user}`);
+                }
+                await (0, service_js_1.installService)([], serviceOptions);
+                await (0, service_js_1.startService)(serviceOptions);
+            });
+        // The port was free when the setup was written; a reboot or another account's MAMA started
+        // since may have taken it. This install's own daemon, if it runs, holds it legitimately.
+        const ownDaemon = await (options.daemonStatus ?? (() => (0, daemon_js_1.askDaemon)('status', { home })))().catch(() => null);
+        const answers = options.portAnswers ?? diagnostics_js_1.portAnswers;
+        if (ownDaemon?.state !== 'running') {
+            const stored = (0, viewer_server_js_1.resolveApiPort)(progress.viewer?.MAMA_API_PORT);
+            if (await answers(stored, '127.0.0.1')) {
+                const port = await freeViewerPort(answers);
+                // Named even when it is the default, so it replaces the port start.sh carries.
+                progress.viewer = { ...progress.viewer, MAMA_API_PORT: String(port) };
+                (0, init_state_js_1.writeInitState)(root, progress);
+            }
+        }
+        await startServiceFor(progress.viewer ?? {});
+        const viewerPort = (0, viewer_server_js_1.resolveApiPort)(progress.viewer?.MAMA_API_PORT);
+        await waitForBoot({
+            status: options.daemonStatus ?? (() => (0, daemon_js_1.askDaemon)('status', { home })),
+            health: options.health ?? (() => viewerHealth(viewerPort)),
+            timeoutMs: options.bootTimeoutMs ?? 600_000,
+            pollMs: options.pollMs ?? 1_000,
+            write,
+        });
+        // The backend's version and login were read from this shell. One real turn through the
+        // daemon proves it answers as the service runs it: its PATH, environment, sandbox and model.
+        // The step is done only then, so running the install command again checks once more after a
+        // fix.
+        write('Checking the backend with one real turn through MAMA…');
+        // A turn that keeps progressing may run until agent.max_turn_ms, and the daemon answers with its
+        // own error before then; wait a little longer than that.
+        const timeoutMs = (0, config_js_1.loadConfig)({ home, path: configPath }).agent.max_turn_ms + PROBE_MARGIN_MS;
+        const probe = await (options.daemonProbe ?? (() => (0, daemon_js_1.askDaemon)('probe', { home, timeoutMs })))().catch((error) => {
+            throw new prompt_js_1.CliInputError(`MAMA did not answer the backend check (${error instanceof Error ? error.message : 'no answer'}). mama logs shows why; then run the install command again.`);
+        });
+        if (probe.state !== 'running')
+            throw new prompt_js_1.CliInputError('MAMA stopped before its backend could be checked. mama logs shows why; then run the install command again.');
+        if (probe.reply.ok !== true)
+            throw new prompt_js_1.CliInputError(`The backend did not answer a real turn: ${String(probe.reply.error)}. mama logs shows more, and mama doctor checks the backend's login; fix it, then run the install command again.`);
+        const probed = probe.reply.probe;
+        write(`${String(probed.backend)} (${String(probed.model)}) answered a real turn in ${String(probed.ms)} ms.`);
+        delete progress.viewer;
+        mark('service');
     }
-    prompt.write('Document toolkit installed for owner and member sessions.');
+    write('MAMA is running. Send your bot a message in Telegram.');
 }
 //# sourceMappingURL=init.js.map