@murphai/murph 0.1.15 → 0.1.18

package/node_modules/@murphai/setup-cli/dist/setup-services.js

@@ -0,0 +1,679 @@
+import { mkdir } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createIntegratedInboxServices, } from '@murphai/assistant-engine/inbox-services';
+import { createIntegratedVaultServices, } from '@murphai/assistant-engine/vault-services';
+import { VaultCliError } from '@murphai/operator-config/vault-cli-errors';
+import { resolveEffectiveTopLevelToken } from '@murphai/operator-config/command-helpers';
+import { normalizeVaultForConfig, readOperatorConfig, saveAssistantOperatorDefaultsPatch, saveDefaultVaultConfig, } from '@murphai/operator-config/operator-config';
+import {} from '@murphai/operator-config/setup-cli-contracts';
+import { configureSetupChannels, normalizeSetupChannels, } from './setup-services/channels.js';
+import { configureSetupScheduledUpdates } from './setup-services/scheduled-updates.js';
+import { createSetupAgentmailSelectionResolver, } from './setup-agentmail.js';
+import { assistantOperatorDefaultsMatch, assistantSelectionToOperatorDefaults, formatAssistantDefaultsSummary, } from './setup-assistant-defaults.js';
+import { createDefaultCommandRunner, defaultDownloadFile, defaultFileExists, defaultLogger, } from './setup-services/process.js';
+import { ensureCliShims, redactHomePath, redactHomePathInText, redactHomePathsInValue, redactNullableHomePath, } from './setup-services/shell.js';
+import { buildBaseFormulaSpecs, createStep, DEFAULT_TOOLCHAIN_DIRECTORY, resolveWhisperModelPath, whisperModelDownloadUrl, } from './setup-services/steps.js';
+import { ensureBrewFormula, ensureHomebrew, ensureWhisperModel, resolveExecutablePath, } from './setup-services/toolchain.js';
+import { describeSelectedSetupWearables } from '@murphai/operator-config/setup-runtime-env';
+export function createSetupServices(dependencies = {}) {
+    const getArch = dependencies.arch ?? (() => process.arch);
+    const getBaseEnv = dependencies.env ?? (() => ({ ...process.env }));
+    const fileExists = dependencies.fileExists ?? defaultFileExists;
+    const getCwd = dependencies.getCwd ?? (() => process.cwd());
+    const getHomeDirectory = dependencies.getHomeDirectory ?? (() => os.homedir());
+    const getPlatform = dependencies.platform ?? (() => process.platform);
+    const log = dependencies.log ?? defaultLogger;
+    const resolveCliBinPath = dependencies.resolveCliBinPath ?? defaultResolveCliBinPath;
+    const runCommand = dependencies.runCommand ?? createDefaultCommandRunner(log);
+    const downloadFile = dependencies.downloadFile ?? defaultDownloadFile;
+    const vaultServices = dependencies.vaultServices ?? createIntegratedVaultServices();
+    const inboxServices = dependencies.inboxServices ?? createIntegratedInboxServices();
+    const resolveAgentmailInboxSelection = dependencies.resolveAgentmailInboxSelection ??
+        createSetupAgentmailSelectionResolver();
+    async function setupHost(input) {
+        const platform = getPlatform();
+        if (platform !== 'darwin' && platform !== 'linux') {
+            throw unsupportedSetupPlatform(platform);
+        }
+        const arch = getArch();
+        const dryRun = input.dryRun ?? false;
+        const strict = input.strict ?? true;
+        const vault = path.resolve(getCwd(), input.vault);
+        const requestId = input.requestId ?? null;
+        const whisperModel = input.whisperModel ?? 'base.en';
+        const homeDirectory = path.resolve(getHomeDirectory());
+        const cliBinPath = path.resolve(resolveCliBinPath());
+        const defaultToolchainRoot = path.join(homeDirectory, DEFAULT_TOOLCHAIN_DIRECTORY);
+        const toolchainRoot = path.resolve(getCwd(), input.toolchainRoot ?? defaultToolchainRoot);
+        const notes = [];
+        const steps = [];
+        const effectiveEnv = {
+            ...getBaseEnv(),
+            ...(input.envOverrides ?? {}),
+        };
+        log(`Murph setup targeting ${redactHomePathInText(vault, homeDirectory)} on ${describeSetupHost(platform)} (${arch}).`);
+        await ensureDirectoryStep({
+            absolutePath: toolchainRoot,
+            detailWhenCreated: `Created local toolchain root at ${toolchainRoot}.`,
+            detailWhenExisting: `Reusing local toolchain root at ${toolchainRoot}.`,
+            dryRun,
+            fileExists,
+            id: 'toolchain-root',
+            kind: 'configure',
+            steps,
+            title: 'Local toolchain root',
+        });
+        const provisioning = platform === 'darwin'
+            ? await provisionMacosToolchain({
+                arch,
+                downloadFile,
+                dryRun,
+                env: effectiveEnv,
+                fileExists,
+                log,
+                notes,
+                runCommand,
+                steps,
+                toolchainRoot,
+                whisperModel,
+            })
+            : await provisionLinuxToolchain({
+                arch,
+                downloadFile,
+                dryRun,
+                env: effectiveEnv,
+                fileExists,
+                log,
+                notes,
+                runCommand,
+                steps,
+                toolchainRoot,
+                whisperModel,
+            });
+        const toolchainEnv = provisioning.env;
+        const tools = provisioning.tools;
+        let bootstrap = null;
+        const vaultMetadataPath = path.join(vault, 'vault.json');
+        const hasExistingVault = await fileExists(vaultMetadataPath);
+        if (dryRun) {
+            steps.push(createStep({
+                detail: hasExistingVault
+                    ? `Would reuse the existing vault at ${vault} and refresh its runtime state.`
+                    : `Would initialize a new vault at ${vault}.`,
+                id: 'vault-init',
+                kind: 'configure',
+                status: hasExistingVault ? 'reused' : 'planned',
+                title: 'Vault initialization',
+            }));
+            steps.push(createStep({
+                detail: 'Would bootstrap the inbox runtime, parser toolchain config, and post-setup doctor checks.',
+                id: 'inbox-bootstrap',
+                kind: 'configure',
+                status: 'planned',
+                title: 'Inbox bootstrap',
+            }));
+        }
+        else {
+            if (!hasExistingVault) {
+                await vaultServices.core.init({
+                    requestId,
+                    vault,
+                });
+            }
+            steps.push(createStep({
+                detail: hasExistingVault
+                    ? `Reusing the existing vault at ${vault}.`
+                    : `Initialized a new vault scaffold at ${vault}.`,
+                id: 'vault-init',
+                kind: 'configure',
+                status: hasExistingVault ? 'reused' : 'completed',
+                title: 'Vault initialization',
+            }));
+            bootstrap = await inboxServices.bootstrap({
+                ffmpegCommand: tools.ffmpegCommand ?? undefined,
+                pdftotextCommand: tools.pdftotextCommand ?? undefined,
+                rebuild: input.rebuild,
+                requestId,
+                strict,
+                vault,
+                whisperCommand: tools.whisperCommand ?? undefined,
+                whisperModelPath: tools.whisperModelPath,
+            });
+            steps.push(createStep({
+                detail: 'Wrote parser toolchain config under .runtime/operations/parsers/toolchain.json and completed inbox doctor checks.',
+                id: 'inbox-bootstrap',
+                kind: 'configure',
+                status: 'completed',
+                title: 'Inbox bootstrap',
+            }));
+        }
+        await ensureCliShims({
+            cliBinPath,
+            dryRun,
+            env: toolchainEnv,
+            fileExists,
+            homeDirectory,
+            notes,
+            steps,
+        });
+        await ensureDefaultVaultSelection({
+            dryRun,
+            homeDirectory,
+            steps,
+            vault,
+        });
+        const assistant = input.assistant == null
+            ? null
+            : await ensureAssistantDefaultSelection({
+                assistant: input.assistant,
+                dryRun,
+                homeDirectory,
+                notes,
+                steps,
+            });
+        const channels = input.channels == null
+            ? []
+            : await configureSetupChannels({
+                allowPrompt: input.allowChannelPrompts ?? false,
+                channels: normalizeSetupChannels(input.channels),
+                dryRun,
+                env: toolchainEnv,
+                inboxServices,
+                platform,
+                requestId,
+                resolveAgentmailInboxSelection,
+                steps,
+                vault,
+            });
+        const wearables = input.wearables == null
+            ? []
+            : describeSelectedSetupWearables({
+                env: toolchainEnv,
+                wearables: input.wearables,
+            });
+        const scheduledUpdates = input.scheduledUpdatePresetIds == null
+            ? []
+            : await configureSetupScheduledUpdates({
+                dryRun,
+                presetIds: input.scheduledUpdatePresetIds,
+                steps,
+                vault,
+            });
+        return {
+            arch,
+            bootstrap: bootstrap === null
+                ? null
+                : redactHomePathsInValue(bootstrap, homeDirectory),
+            assistant: assistant === null
+                ? null
+                : {
+                    ...assistant,
+                    detail: redactHomePathInText(assistant.detail, homeDirectory),
+                },
+            scheduledUpdates: scheduledUpdates.map((scheduledUpdate) => redactHomePathsInValue(scheduledUpdate, homeDirectory)),
+            channels: channels.map((channel) => ({
+                ...channel,
+                connectorId: channel.connectorId,
+                detail: redactHomePathInText(channel.detail, homeDirectory),
+            })),
+            wearables: wearables.map((wearable) => ({
+                ...wearable,
+                detail: redactHomePathInText(wearable.detail, homeDirectory),
+            })),
+            dryRun,
+            notes: notes.map((note) => redactHomePathInText(note, homeDirectory)),
+            platform,
+            steps: steps.map((step) => ({
+                ...step,
+                detail: redactHomePathInText(step.detail, homeDirectory),
+            })),
+            toolchainRoot: redactHomePath(toolchainRoot, homeDirectory),
+            tools: {
+                ffmpegCommand: redactNullableHomePath(tools.ffmpegCommand, homeDirectory),
+                pdftotextCommand: redactNullableHomePath(tools.pdftotextCommand, homeDirectory),
+                whisperCommand: redactNullableHomePath(tools.whisperCommand, homeDirectory),
+                whisperModelPath: redactHomePath(tools.whisperModelPath, homeDirectory),
+            },
+            vault: redactHomePath(vault, homeDirectory),
+            whisperModel,
+        };
+    }
+    async function setupMacos(input) {
+        const platform = getPlatform();
+        if (platform !== 'darwin') {
+            throw unsupportedSetupPlatform(platform, 'Murph setup currently supports macOS only through setupMacos(). Use setupHost() for Linux support.');
+        }
+        return await setupHost(input);
+    }
+    return {
+        setupHost,
+        setupMacos,
+    };
+}
+async function ensureProvisionedWhisperModel(input) {
+    const whisperModelPath = resolveWhisperModelPath(input.toolchainRoot, input.whisperModel);
+    await ensureWhisperModel({
+        destinationPath: whisperModelPath,
+        dryRun: input.dryRun,
+        downloadFile: input.downloadFile,
+        downloadUrl: whisperModelDownloadUrl(input.whisperModel),
+        fileExists: input.fileExists,
+        id: 'whisper-model',
+        model: input.whisperModel,
+        steps: input.steps,
+        title: 'Whisper model',
+    });
+    return whisperModelPath;
+}
+async function ensureMacosToolRequirement(input) {
+    const macos = input.requirement.macos;
+    return ensureBrewFormula({
+        brewState: input.brewState,
+        commandCandidates: input.requirement.commandCandidates,
+        dryRun: input.dryRun,
+        formula: macos.formula,
+        id: input.requirement.id,
+        installDetail: macos.installDetail,
+        kind: 'install',
+        missingPlanDetail: macos.missingPlanDetail,
+        runCommand: input.runCommand,
+        steps: input.steps,
+        title: macos.title,
+    });
+}
+async function ensureLinuxToolRequirement(input) {
+    const linux = input.requirement.linux;
+    return ensureLinuxCommand({
+        apt: input.apt,
+        commandCandidates: input.requirement.commandCandidates,
+        completedDetail: linux.completedDetail,
+        dryRun: input.dryRun,
+        env: input.env,
+        id: input.requirement.id,
+        installPackages: linux.installPackages,
+        missingNoteDetail: linux.missingNoteDetail,
+        missingStepDetail: linux.missingStepDetail,
+        missingPlanDetail: linux.missingPlanDetail,
+        notes: input.notes,
+        reuseDetail: linux.reuseDetail,
+        runCommand: input.runCommand,
+        steps: input.steps,
+        title: linux.title,
+        validateResolvedCommand: input.validateResolvedCommand,
+    });
+}
+async function provisionMacosToolchain(input) {
+    let state = await ensureHomebrew({
+        arch: input.arch,
+        dryRun: input.dryRun,
+        env: input.env,
+        log: input.log,
+        runCommand: input.runCommand,
+        steps: input.steps,
+    });
+    const formulaCommands = {
+        ffmpegCommand: null,
+        pdftotextCommand: null,
+        whisperCommand: null,
+    };
+    for (const requirement of buildBaseFormulaSpecs()) {
+        const formulaResult = await ensureMacosToolRequirement({
+            brewState: state,
+            dryRun: input.dryRun,
+            requirement,
+            runCommand: input.runCommand,
+            steps: input.steps,
+        });
+        state = {
+            ...state,
+            env: formulaResult.env,
+        };
+        formulaCommands[requirement.key] = formulaResult.command;
+    }
+    const whisperModelPath = await ensureProvisionedWhisperModel(input);
+    return {
+        env: state.env,
+        tools: {
+            ffmpegCommand: formulaCommands.ffmpegCommand,
+            pdftotextCommand: formulaCommands.pdftotextCommand,
+            whisperCommand: formulaCommands.whisperCommand,
+            whisperModelPath,
+        },
+    };
+}
+async function provisionLinuxToolchain(input) {
+    let apt = await resolveAptRunner(input.env);
+    const resolvedCommands = {
+        ffmpegCommand: null,
+        pdftotextCommand: null,
+        whisperCommand: null,
+    };
+    for (const requirement of buildBaseFormulaSpecs()) {
+        const resolved = await ensureLinuxToolRequirement({
+            apt,
+            dryRun: input.dryRun,
+            env: input.env,
+            notes: input.notes,
+            requirement,
+            runCommand: input.runCommand,
+            steps: input.steps,
+        });
+        apt = resolved.apt;
+        resolvedCommands[requirement.key] = resolved.command;
+    }
+    const whisperModelPath = await ensureProvisionedWhisperModel(input);
+    return {
+        env: input.env,
+        tools: {
+            ffmpegCommand: resolvedCommands.ffmpegCommand,
+            pdftotextCommand: resolvedCommands.pdftotextCommand,
+            whisperCommand: resolvedCommands.whisperCommand,
+            whisperModelPath,
+        },
+    };
+}
+async function ensureLinuxCommand(input) {
+    const resolveValidatedCommand = async () => {
+        const rawCommand = await resolveExecutablePath(input.commandCandidates, input.env);
+        if (!rawCommand) {
+            return {
+                command: null,
+                rawCommand: null,
+            };
+        }
+        if (input.validateResolvedCommand &&
+            !(await input.validateResolvedCommand({
+                command: rawCommand,
+                env: input.env,
+                runCommand: input.runCommand,
+            }))) {
+            return {
+                command: null,
+                rawCommand,
+            };
+        }
+        return {
+            command: rawCommand,
+            rawCommand,
+        };
+    };
+    const existingResolution = await resolveValidatedCommand();
+    const existing = existingResolution.command;
+    if (existing) {
+        input.steps.push(createStep({
+            detail: input.reuseDetail?.(existing) ?? `Reusing ${input.title} from ${existing}.`,
+            id: input.id,
+            kind: 'install',
+            status: 'reused',
+            title: input.title,
+        }));
+        return {
+            apt: input.apt,
+            command: existing,
+        };
+    }
+    if (input.dryRun) {
+        input.steps.push(createStep({
+            detail: input.missingPlanDetail,
+            id: input.id,
+            kind: 'install',
+            status: 'planned',
+            title: input.title,
+        }));
+        return {
+            apt: input.apt,
+            command: existingResolution.rawCommand,
+        };
+    }
+    const install = await ensureAptPackages({
+        apt: input.apt,
+        env: input.env,
+        packages: input.installPackages,
+        runCommand: input.runCommand,
+    });
+    const resolved = (await resolveValidatedCommand()).command;
+    if (resolved) {
+        input.steps.push(createStep({
+            detail: input.completedDetail ?? `Installed ${input.title} through apt-get.`,
+            id: input.id,
+            kind: 'install',
+            status: 'completed',
+            title: input.title,
+        }));
+        return {
+            apt: install.apt,
+            command: resolved,
+        };
+    }
+    input.steps.push(createStep({
+        detail: install.reason ?? input.missingStepDetail,
+        id: input.id,
+        kind: 'install',
+        status: 'skipped',
+        title: input.title,
+    }));
+    input.notes.push(input.missingNoteDetail ?? input.missingStepDetail);
+    if (install.reason && install.reason !== input.missingStepDetail) {
+        input.notes.push(`${input.title} auto-install detail: ${install.reason}`);
+    }
+    return {
+        apt: install.apt,
+        command: null,
+    };
+}
+async function resolveAptRunner(env) {
+    const aptGet = await resolveExecutablePath(['apt-get'], env, ['/usr/bin/apt-get', '/bin/apt-get']);
+    if (!aptGet) {
+        return {
+            command: null,
+            baseArgs: [],
+            updateAttempted: false,
+        };
+    }
+    if (typeof process.getuid === 'function' && process.getuid() === 0) {
+        return {
+            command: aptGet,
+            baseArgs: [],
+            updateAttempted: false,
+        };
+    }
+    const sudo = await resolveExecutablePath(['sudo'], env, ['/usr/bin/sudo', '/bin/sudo']);
+    if (!sudo) {
+        return {
+            command: null,
+            baseArgs: [],
+            updateAttempted: false,
+        };
+    }
+    return {
+        command: sudo,
+        baseArgs: ['-n', aptGet],
+        updateAttempted: false,
+    };
+}
+async function ensureAptPackages(input) {
+    if (!input.apt.command) {
+        return {
+            apt: input.apt,
+            reason: 'apt-get or passwordless sudo is unavailable on this host.',
+        };
+    }
+    let apt = input.apt;
+    const aptCommand = input.apt.command;
+    const aptEnv = {
+        ...input.env,
+        DEBIAN_FRONTEND: 'noninteractive',
+    };
+    if (!apt.updateAttempted) {
+        const updateResult = await input.runCommand({
+            args: [...apt.baseArgs, 'update'],
+            env: aptEnv,
+            file: aptCommand,
+        });
+        apt = {
+            ...apt,
+            updateAttempted: true,
+        };
+        if (updateResult.exitCode !== 0) {
+            return {
+                apt,
+                reason: summarizeCommandFailure(updateResult, 'apt-get update failed during automatic Linux tool provisioning.'),
+            };
+        }
+    }
+    const installResult = await input.runCommand({
+        args: [...apt.baseArgs, 'install', '-y', ...input.packages],
+        env: aptEnv,
+        file: aptCommand,
+    });
+    if (installResult.exitCode !== 0) {
+        return {
+            apt,
+            reason: summarizeCommandFailure(installResult, `apt-get install failed for ${input.packages.join(', ')}.`),
+        };
+    }
+    return {
+        apt,
+        reason: null,
+    };
+}
+function summarizeCommandFailure(result, fallback) {
+    const stderr = result.stderr.trim();
+    if (stderr.length > 0) {
+        return stderr;
+    }
+    const stdout = result.stdout.trim();
+    if (stdout.length > 0) {
+        return stdout;
+    }
+    return fallback;
+}
+function unsupportedSetupPlatform(platform, message = 'Murph setup currently supports macOS and Linux only.') {
+    return new VaultCliError('unsupported_platform', message, {
+        platform,
+    });
+}
+function describeSetupHost(platform) {
+    return platform === 'darwin' ? 'macOS' : platform;
+}
+export function detectSetupProgramName(argv0, shimProgramName = process.env.SETUP_PROGRAM_NAME) {
+    const normalizedShimProgramName = shimProgramName?.trim().toLowerCase();
+    if (normalizedShimProgramName === 'murph') {
+        return 'murph';
+    }
+    const baseName = path.basename(argv0 ?? '').toLowerCase();
+    return baseName === 'murph' ? 'murph' : 'vault-cli';
+}
+export function isSetupInvocation(args, programName = 'vault-cli') {
+    const commandToken = resolveEffectiveTopLevelToken(args);
+    if (commandToken === 'onboard') {
+        return true;
+    }
+    if (programName !== 'murph') {
+        return false;
+    }
+    return commandToken === null || commandToken === 'help';
+}
+async function ensureDirectoryStep(input) {
+    const exists = await input.fileExists(input.absolutePath);
+    if (exists) {
+        input.steps.push(createStep({
+            detail: input.detailWhenExisting,
+            id: input.id,
+            kind: input.kind,
+            status: 'reused',
+            title: input.title,
+        }));
+        return;
+    }
+    if (input.dryRun) {
+        input.steps.push(createStep({
+            detail: input.detailWhenCreated,
+            id: input.id,
+            kind: input.kind,
+            status: 'planned',
+            title: input.title,
+        }));
+        return;
+    }
+    await mkdir(input.absolutePath, { recursive: true });
+    input.steps.push(createStep({
+        detail: input.detailWhenCreated,
+        id: input.id,
+        kind: input.kind,
+        status: 'completed',
+        title: input.title,
+    }));
+}
+async function ensureDefaultVaultSelection(input) {
+    const existing = await readOperatorConfig(input.homeDirectory);
+    const existingDefaultVault = existing?.defaultVault === null || existing?.defaultVault === undefined
+        ? null
+        : existing.defaultVault;
+    const nextDefaultVault = normalizeVaultForConfig(input.vault, input.homeDirectory);
+    const status = existingDefaultVault === nextDefaultVault
+        ? 'reused'
+        : input.dryRun
+            ? 'planned'
+            : 'completed';
+    const detail = existingDefaultVault === nextDefaultVault
+        ? `Reusing ${nextDefaultVault} as the default Murph vault for future CLI commands.`
+        : input.dryRun
+            ? `Would save ${nextDefaultVault} as the default Murph vault for future CLI commands.`
+            : `Saved ${nextDefaultVault} as the default Murph vault for future CLI commands.`;
+    if (!input.dryRun && existingDefaultVault !== nextDefaultVault) {
+        await saveDefaultVaultConfig(input.vault, input.homeDirectory);
+    }
+    input.steps.push(createStep({
+        detail,
+        id: 'default-vault',
+        kind: 'configure',
+        status,
+        title: 'Default vault selection',
+    }));
+}
+async function ensureAssistantDefaultSelection(input) {
+    if (!input.assistant.enabled || input.assistant.provider === null) {
+        input.steps.push(createStep({
+            detail: 'Skipped saving assistant defaults during setup and left any existing assistant config unchanged.',
+            id: 'assistant-defaults',
+            kind: 'configure',
+            status: 'skipped',
+            title: 'Assistant defaults',
+        }));
+        return input.assistant;
+    }
+    const existing = await readOperatorConfig(input.homeDirectory);
+    const nextDefaults = assistantSelectionToOperatorDefaults(input.assistant, existing?.assistant ?? null);
+    const status = assistantOperatorDefaultsMatch(existing?.assistant ?? null, nextDefaults)
+        ? 'reused'
+        : input.dryRun
+            ? 'planned'
+            : 'completed';
+    const summary = formatAssistantDefaultsSummary(input.assistant);
+    const detail = status === 'reused'
+        ? `Reusing ${summary} as the default assistant for future chats and auto-reply.`
+        : input.dryRun
+            ? `Would save ${summary} as the default assistant for future chats and auto-reply.`
+            : `Saved ${summary} as the default assistant for future chats and auto-reply.`;
+    if (status !== 'reused' && !input.dryRun) {
+        await saveAssistantOperatorDefaultsPatch(nextDefaults, input.homeDirectory);
+    }
+    if (input.assistant.provider === 'openai-compatible' && input.assistant.apiKeyEnv) {
+        input.notes.push(`Export ${input.assistant.apiKeyEnv} before using the saved OpenAI-compatible assistant backend.`);
+    }
+    input.steps.push(createStep({
+        detail,
+        id: 'assistant-defaults',
+        kind: 'configure',
+        status,
+        title: 'Assistant defaults',
+    }));
+    return input.assistant;
+}
+function defaultResolveCliBinPath() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), 'bin.js');
+}
+//# sourceMappingURL=setup-services.js.map