@xwss/agentbell 0.1.0

package/dist/commands/verify.js

@@ -0,0 +1,725 @@
+import { access, readFile } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { loadConfig, resolveConfigPath } from '../config.js';
+import { createProvider } from '../notify/index.js';
+import { sendLocalNotification } from '../notify/local.js';
+import { logger } from '../utils/logger.js';
+import { maskSecret } from '../utils/mask.js';
+import { claudeNotificationWrapperPath, claudeSettingsPath, claudeStopWrapperPath, codexHooksPath, codexStopWrapperPath, copilotStopWrapperPath, currentCliInvocation, projectRoot, vscodeAgentHookPath } from '../utils/paths.js';
+const execFileAsync = promisify(execFile);
+function selectedTargets(target) {
+    if (!target || target === 'all') {
+        return ['codex', 'claude-code', 'vscode-agent'];
+    }
+    return [target];
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readText(filePath) {
+    try {
+        return { exists: true, text: await readFile(filePath, 'utf8') };
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError.code === 'ENOENT') {
+            return { exists: false };
+        }
+        return { exists: true, error: error.message };
+    }
+}
+async function readJson(filePath) {
+    const text = await readText(filePath);
+    if (!text.exists || text.error || text.text === undefined) {
+        return text;
+    }
+    try {
+        return { exists: true, text: text.text, value: JSON.parse(text.text) };
+    }
+    catch (error) {
+        return { exists: true, text: text.text, error: error.message };
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function getNested(value, pathParts) {
+    let current = value;
+    for (const part of pathParts) {
+        if (typeof part === 'number') {
+            if (!Array.isArray(current)) {
+                return undefined;
+            }
+            current = current[part];
+        }
+        else {
+            if (!isRecord(current)) {
+                return undefined;
+            }
+            current = current[part];
+        }
+    }
+    return current;
+}
+function addError(report, message) {
+    report.errors.push(message);
+    report.status = 'error';
+}
+function addWarning(report, message) {
+    report.warnings.push(message);
+    if (report.status === 'ok') {
+        report.status = 'warning';
+    }
+}
+const legacyProjectName = ['Hook', 'Ping'].join('');
+const legacyProjectPattern = new RegExp(legacyProjectName, 'i');
+function staleReferences(text) {
+    if (!text) {
+        return [];
+    }
+    return text.split(/\r?\n/).filter((line) => legacyProjectPattern.test(line));
+}
+function normalizeForCompare(value) {
+    return value.replaceAll('\\', '/').toLowerCase();
+}
+function toGitBashPath(filePath) {
+    const normalized = filePath.replaceAll('\\', '/');
+    const driveMatch = /^([A-Za-z]):\/(.*)$/.exec(normalized);
+    if (!driveMatch) {
+        return normalized;
+    }
+    return `/${driveMatch[1].toLowerCase()}/${driveMatch[2]}`;
+}
+function fromGitBashPath(filePath) {
+    const match = /^\/([a-zA-Z])\/(.*)$/.exec(filePath);
+    if (!match) {
+        return filePath;
+    }
+    return `${match[1].toUpperCase()}:\\${match[2].replaceAll('/', '\\')}`;
+}
+async function executableExists(filePath) {
+    try {
+        await access(filePath, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function findOnPath(command, options = {}) {
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? process.platform;
+    const exists = options.exists ?? executableExists;
+    const pathDirs = (env.PATH ?? '').split(path.delimiter).filter(Boolean);
+    const extensions = platform === 'win32' ? (env.PATHEXT ?? '.EXE;.CMD;.BAT').split(';') : [''];
+    for (const directory of pathDirs) {
+        for (const extension of extensions) {
+            const candidate = path.join(directory, platform === 'win32' ? `${command}${extension}` : command);
+            if (await exists(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return undefined;
+}
+const defaultWindowsBashPaths = [
+    'C:\\Program Files\\Git\\bin\\bash.exe',
+    'C:\\Program Files\\Git\\usr\\bin\\bash.exe',
+    'C:\\Program Files (x86)\\Git\\bin\\bash.exe',
+    'C:\\Program Files (x86)\\Git\\usr\\bin\\bash.exe'
+];
+export async function resolveBashPath(options = {}) {
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? process.platform;
+    const exists = options.exists ?? executableExists;
+    const find = options.findOnPath ?? ((command) => findOnPath(command, { env, platform, exists }));
+    const commonPaths = options.commonPaths ?? defaultWindowsBashPaths;
+    const envPath = env.AGENTBELL_BASH_PATH?.trim();
+    if (envPath) {
+        const resolved = path.resolve(envPath);
+        if (await exists(resolved)) {
+            return { path: resolved };
+        }
+        return { error: `AGENTBELL_BASH_PATH is set but file does not exist: ${envPath}` };
+    }
+    const pathBash = await find('bash');
+    if (pathBash) {
+        return { path: pathBash };
+    }
+    if (platform === 'win32') {
+        for (const candidate of commonPaths) {
+            if (await exists(candidate)) {
+                return { path: candidate };
+            }
+        }
+    }
+    return { error: 'Git Bash was not found. Set AGENTBELL_BASH_PATH or install Git for Windows.' };
+}
+function expectedCliMatches(content, expectedCliPath) {
+    const normalized = normalizeForCompare(content);
+    const candidates = [expectedCliPath, expectedCliPath.replaceAll('\\', '/'), toGitBashPath(expectedCliPath)];
+    return candidates.some((candidate) => normalized.includes(normalizeForCompare(candidate)));
+}
+function extractCliPaths(content) {
+    const quoted = [...content.matchAll(/["']([^"'\r\n]+)["']/g)].map((match) => match[1]);
+    return quoted
+        .filter((value) => normalizeForCompare(value).includes('dist/cli.js'))
+        .map((value) => fromGitBashPath(value));
+}
+async function inspectWrapper(report, wrapperPath, expectedCommand, expectedCliPath) {
+    report.details.wrapperPath = wrapperPath;
+    const wrapper = await readText(wrapperPath);
+    report.checks.wrapper = wrapper.exists && !wrapper.error ? 'ok' : 'error';
+    if (!wrapper.exists) {
+        addError(report, `Wrapper file is missing: ${wrapperPath}`);
+        return undefined;
+    }
+    if (wrapper.error || wrapper.text === undefined) {
+        addError(report, `Wrapper file is not readable: ${wrapper.error ?? wrapperPath}`);
+        return undefined;
+    }
+    if (!wrapper.text.includes(expectedCommand)) {
+        addError(report, `Wrapper does not contain expected command: ${expectedCommand}`);
+    }
+    if (!expectedCliMatches(wrapper.text, expectedCliPath)) {
+        addError(report, `Wrapper does not reference current dist/cli.js: ${expectedCliPath}`);
+    }
+    const stale = staleReferences(wrapper.text);
+    if (stale.length > 0) {
+        report.details.staleReferences = stale;
+        addError(report, 'Wrapper contains stale legacy project references.');
+        report.suggestedFixes.push('Run node dist\\cli.js init-hooks --target all');
+    }
+    const cliPaths = extractCliPaths(wrapper.text);
+    report.details.cliPaths = cliPaths;
+    if (cliPaths.length === 0) {
+        addError(report, 'Wrapper does not contain a detectable dist/cli.js path.');
+    }
+    for (const cliPath of cliPaths) {
+        if (!(await fileExists(cliPath))) {
+            addError(report, `Wrapper points to missing cli.js: ${cliPath}`);
+            report.suggestedFixes.push('Run node dist\\cli.js init-hooks --target all');
+        }
+    }
+    return wrapper.text;
+}
+function logBlockMarkerPattern(target) {
+    if (target === 'codex') {
+        return /Codex Stop hook fired/i;
+    }
+    if (target === 'claude-code') {
+        return /Claude(?: Code)?(?: stop| notification)? hook fired|Claude/i;
+    }
+    return /(?:VS Code )?Copilot Stop hook fired/i;
+}
+function splitLogBlocks(text, target) {
+    const marker = logBlockMarkerPattern(target);
+    const blocks = [];
+    let current;
+    for (const line of text.split(/\r?\n/)) {
+        if (marker.test(line) || /hook fired/i.test(line)) {
+            if (current && current.length > 0) {
+                blocks.push(current.join('\n'));
+            }
+            current = [line];
+        }
+        else if (current) {
+            current.push(line);
+        }
+    }
+    if (current && current.length > 0) {
+        blocks.push(current.join('\n'));
+    }
+    return blocks.filter((block) => marker.test(block));
+}
+function logSignals(block) {
+    return {
+        notificationSent: /Notification sent/i.test(block),
+        exitCode0: /(?:AgentBell )?exit code 0/i.test(block),
+        cannotFindModule: /Cannot find module/i.test(block),
+        moduleNotFound: /MODULE_NOT_FOUND/i.test(block),
+        exitCode1: /(?:AgentBell )?exit code 1/i.test(block),
+        hookPing: legacyProjectPattern.test(block)
+    };
+}
+async function inspectLog(report, logPath) {
+    report.details.logPath = logPath;
+    const log = await readText(logPath);
+    if (!log.exists) {
+        report.checks.log = 'warning';
+        addWarning(report, `Log file does not exist yet: ${logPath}`);
+        return;
+    }
+    if (log.error || log.text === undefined) {
+        report.checks.log = 'warning';
+        addWarning(report, `Log file is not readable: ${log.error ?? logPath}`);
+        return;
+    }
+    const blocks = splitLogBlocks(log.text, report.target);
+    report.details.logBlockCount = blocks.length;
+    if (blocks.length === 0) {
+        report.checks.log = 'warning';
+        addWarning(report, `Log file exists but no ${report.target} hook run block was found.`);
+        return;
+    }
+    const latestBlock = blocks[blocks.length - 1];
+    const latestSignals = logSignals(latestBlock);
+    const historicalBlocks = blocks.slice(0, -1).join('\n');
+    const historicalHasErrors = new RegExp('Cannot find module|MODULE_NOT_FOUND|exit code 1|' + legacyProjectName, 'i').test(historicalBlocks);
+    report.details.recentLogSignals = latestSignals;
+    report.details.latestLogBlockStatus = latestSignals.notificationSent && latestSignals.exitCode0 ? 'ok' : 'unknown';
+    report.details.historicalStaleErrorsIgnored = historicalHasErrors && latestSignals.notificationSent && latestSignals.exitCode0;
+    report.checks.log = 'ok';
+    if (latestSignals.cannotFindModule || latestSignals.moduleNotFound || latestSignals.exitCode1) {
+        addError(report, 'Latest wrapper log block contains module/load failure or exit code 1.');
+        report.suggestedFixes.push('Run node dist\\cli.js init-hooks --target all');
+    }
+    if (latestSignals.hookPing) {
+        addError(report, 'Latest wrapper log block contains a stale legacy project path.');
+        report.suggestedFixes.push('Run node dist\\cli.js init-hooks --target all');
+    }
+    if (historicalHasErrors && latestSignals.notificationSent && latestSignals.exitCode0) {
+        addWarning(report, 'Historical stale log errors were ignored because the latest hook run block succeeded.');
+    }
+}
+async function defaultRunner(target, wrapperPath, runnerOptions = {}) {
+    try {
+        if (target === 'claude-code') {
+            const command = runnerOptions.bashPath ?? 'bash';
+            const args = [wrapperPath];
+            const result = await execFileAsync(command, args, { timeout: 30000, shell: false });
+            return { exitCode: 0, stdout: result.stdout, stderr: result.stderr, command, args };
+        }
+        if (process.platform === 'win32') {
+            const command = 'cmd';
+            const args = ['/d', '/s', '/c', wrapperPath];
+            const result = await execFileAsync(command, args, { timeout: 30000, shell: false });
+            return { exitCode: 0, stdout: result.stdout, stderr: result.stderr, command, args };
+        }
+        const command = 'sh';
+        const args = [wrapperPath];
+        const result = await execFileAsync(command, args, { timeout: 30000, shell: false });
+        return { exitCode: 0, stdout: result.stdout, stderr: result.stderr, command, args };
+    }
+    catch (error) {
+        const execError = error;
+        return {
+            exitCode: typeof execError.code === 'number' ? execError.code : 1,
+            stdout: execError.stdout ?? '',
+            stderr: execError.stderr ?? execError.message,
+            command: execError.path,
+            args: execError.spawnargs
+        };
+    }
+}
+async function maybeRunWrapper(report, options, wrapperPath, runnerOptions = {}) {
+    if (!options.runWrapper) {
+        addWarning(report, 'Wrapper was not run. Use --run-wrapper for a manual wrapper execution test.');
+        return;
+    }
+    const runner = options.runner ?? defaultRunner;
+    const result = await runner(report.target, wrapperPath, runnerOptions);
+    report.details.runWrapper = result;
+    if (result.exitCode !== 0) {
+        report.details.runWrapperExitCode = result.exitCode;
+    }
+}
+function reconcileRunWrapperWithLog(report) {
+    const runWrapper = report.details.runWrapper;
+    if (!runWrapper) {
+        return;
+    }
+    const signals = report.details.recentLogSignals;
+    const latestSucceeded = Boolean(signals?.notificationSent && signals.exitCode0);
+    const logBlockCount = typeof report.details.logBlockCount === 'number' ? report.details.logBlockCount : 0;
+    if (runWrapper.exitCode === 0 && latestSucceeded) {
+        return;
+    }
+    if (runWrapper.exitCode === 0 && !latestSucceeded) {
+        addWarning(report, 'Wrapper returned 0 but log was not updated with a successful latest block.');
+        return;
+    }
+    if (runWrapper.exitCode !== 0 && latestSucceeded) {
+        addWarning(report, `Wrapper execution returned exit code ${runWrapper.exitCode}, but the latest log block shows Notification sent and AgentBell exit code 0.`);
+        report.details.executionResultMismatch = true;
+        return;
+    }
+    if (logBlockCount === 0) {
+        addError(report, `Wrapper execution failed with exit code ${runWrapper.exitCode}, and no latest log block was found.`);
+        return;
+    }
+    addError(report, `Wrapper execution failed with exit code ${runWrapper.exitCode}.`);
+}
+function createTargetReport(target) {
+    return {
+        target,
+        status: 'ok',
+        checks: {},
+        details: {},
+        warnings: [],
+        errors: [],
+        suggestedFixes: []
+    };
+}
+async function verifyCodex(expectedCliPath, options) {
+    const report = createTargetReport('codex');
+    const hooksPath = codexHooksPath();
+    report.details.hooksPath = hooksPath;
+    const hooks = await readJson(hooksPath);
+    report.checks.hooksJson = hooks.exists && !hooks.error ? 'ok' : 'error';
+    if (!hooks.exists) {
+        addError(report, `Codex hooks.json is missing: ${hooksPath}`);
+    }
+    else if (hooks.error) {
+        addError(report, `Codex hooks.json is not valid JSON: ${hooks.error}`);
+    }
+    else {
+        const handler = getNested(hooks.value, ['hooks', 'Stop', 0, 'hooks', 0]);
+        const commandWindows = isRecord(handler) ? handler.commandWindows : undefined;
+        if (!Array.isArray(getNested(hooks.value, ['hooks', 'Stop']))) {
+            addError(report, 'Codex hooks.json does not contain hooks.Stop.');
+        }
+        if (!isRecord(handler) || handler.type !== 'command') {
+            addError(report, 'Codex Stop handler is not type: command.');
+        }
+        if (typeof commandWindows !== 'string') {
+            addError(report, 'Codex Stop handler does not contain commandWindows.');
+        }
+        else if (!commandWindows.includes('codex-stop.cmd')) {
+            addError(report, 'Codex commandWindows does not point to codex-stop.cmd.');
+        }
+        const stale = staleReferences(hooks.text);
+        if (stale.length > 0) {
+            report.details.staleReferences = stale;
+            addError(report, 'Codex hooks.json contains stale legacy project references.');
+            report.suggestedFixes.push('Run node dist\\cli.js init-hooks --target all');
+        }
+    }
+    const wrapperPath = codexStopWrapperPath();
+    await inspectWrapper(report, wrapperPath, 'send --tool codex --event stop', expectedCliPath);
+    await maybeRunWrapper(report, options, wrapperPath);
+    await inspectLog(report, path.join(path.dirname(path.dirname(wrapperPath)), 'codex-hook-fired.log'));
+    reconcileRunWrapperWithLog(report);
+    return report;
+}
+async function verifyClaude(expectedCliPath, options) {
+    const report = createTargetReport('claude-code');
+    const settingsPath = claudeSettingsPath();
+    report.details.settingsPath = settingsPath;
+    const settings = await readJson(settingsPath);
+    report.checks.settingsJson = settings.exists && !settings.error ? 'ok' : 'error';
+    if (!settings.exists) {
+        addError(report, `Claude settings.json is missing: ${settingsPath}`);
+    }
+    else if (settings.error) {
+        addError(report, `Claude settings.json is not valid JSON: ${settings.error}`);
+    }
+    else {
+        const stopCommand = getNested(settings.value, ['hooks', 'Stop', 0, 'hooks', 0, 'command']);
+        const notificationHooks = getNested(settings.value, ['hooks', 'Notification']);
+        if (!Array.isArray(getNested(settings.value, ['hooks', 'Stop']))) {
+            addError(report, 'Claude settings.json does not contain hooks.Stop.');
+        }
+        if (!Array.isArray(notificationHooks)) {
+            addError(report, 'Claude settings.json does not contain hooks.Notification.');
+        }
+        if (typeof stopCommand !== 'string' || !stopCommand.includes('bash')) {
+            addError(report, 'Claude Stop command does not use bash.');
+        }
+        if (typeof stopCommand !== 'string' || !stopCommand.includes('.agentbell-hooks') || !stopCommand.includes('claude-stop.sh')) {
+            addError(report, 'Claude Stop command does not point to .agentbell-hooks/claude-stop.sh.');
+        }
+        const stale = staleReferences(settings.text);
+        if (stale.length > 0) {
+            report.details.staleReferences = stale;
+            addError(report, 'Claude settings.json contains stale legacy project references.');
+            report.suggestedFixes.push('Run node dist\\cli.js init-hooks --target all');
+        }
+    }
+    const stopWrapper = claudeStopWrapperPath();
+    await inspectWrapper(report, stopWrapper, 'send --tool claude-code --event stop', expectedCliPath);
+    await inspectWrapper(report, claudeNotificationWrapperPath(), 'send --tool claude-code --event notification', expectedCliPath);
+    let bashPath;
+    if (process.platform === 'win32') {
+        const bash = options.bashResolver ? await options.bashResolver() : await resolveBashPath();
+        report.details.bashPath = bash.path ?? 'not found';
+        if (bash.error) {
+            addError(report, bash.error);
+        }
+        else {
+            bashPath = bash.path;
+        }
+    }
+    if (options.runWrapper && process.platform === 'win32' && !bashPath) {
+        report.details.runWrapperSkipped = true;
+    }
+    else {
+        await maybeRunWrapper(report, options, stopWrapper, { bashPath });
+    }
+    await inspectLog(report, path.join(projectRoot(), '.agentbell-hooks', 'claude-hook-fired.log'));
+    reconcileRunWrapperWithLog(report);
+    return report;
+}
+async function verifyVscodeAgent(expectedCliPath, options) {
+    const report = createTargetReport('vscode-agent');
+    const hookPath = vscodeAgentHookPath();
+    report.details.hookPath = hookPath;
+    const hook = await readJson(hookPath);
+    report.checks.hookFile = hook.exists && !hook.error ? 'ok' : 'error';
+    if (!hook.exists) {
+        addError(report, `VS Code Agent hook file is missing: ${hookPath}`);
+    }
+    else if (hook.error) {
+        addError(report, `VS Code Agent hook file is not valid JSON: ${hook.error}`);
+    }
+    else {
+        const handler = getNested(hook.value, ['hooks', 'Stop', 0]);
+        const windows = isRecord(handler) ? handler.windows : undefined;
+        if (!Array.isArray(getNested(hook.value, ['hooks', 'Stop']))) {
+            addError(report, 'VS Code Agent hook file does not contain hooks.Stop.');
+        }
+        if (typeof windows !== 'string') {
+            addError(report, 'VS Code Agent Stop hook does not contain windows field.');
+        }
+        else {
+            if (!windows.includes('cmd /d /s /c')) {
+                addError(report, 'VS Code Agent windows command does not use cmd /d /s /c.');
+            }
+            if (windows.includes("'")) {
+                addError(report, 'VS Code Agent windows command uses single quotes.');
+            }
+            if (!windows.includes('"')) {
+                addError(report, 'VS Code Agent windows command does not double-quote wrapper path.');
+            }
+            if (!windows.includes('copilot-stop.cmd')) {
+                addError(report, 'VS Code Agent windows command does not point to copilot-stop.cmd.');
+            }
+        }
+        if (isRecord(handler) && 'commandWindows' in handler) {
+            addError(report, 'VS Code Agent hook should not use Codex commandWindows field.');
+        }
+        const stale = staleReferences(hook.text);
+        if (stale.length > 0) {
+            report.details.staleReferences = stale;
+            addError(report, 'VS Code Agent hook file contains stale legacy project references.');
+            report.suggestedFixes.push('Run node dist\\cli.js init-hooks --target all');
+        }
+    }
+    const wrapperPath = copilotStopWrapperPath();
+    await inspectWrapper(report, wrapperPath, 'send --tool vscode-agent --event stop', expectedCliPath);
+    await inspectLog(report, path.join(projectRoot(), '.agentbell-hooks', 'copilot-hook-fired.log'));
+    reconcileRunWrapperWithLog(report);
+    await maybeRunWrapper(report, options, wrapperPath);
+    return report;
+}
+async function canAccessServer(url) {
+    try {
+        const response = await fetch(url, { method: 'GET', signal: AbortSignal.timeout(5000) });
+        return response.status < 500;
+    }
+    catch {
+        return false;
+    }
+}
+async function sendVerifyTest(config) {
+    const machine = config.profile.name || os.hostname();
+    const inputData = {
+        tool: 'custom',
+        event: 'custom',
+        title: 'AgentBell verify test',
+        message: `${machine} verify test succeeded.`,
+        priority: config.ntfy.priority,
+        tags: config.ntfy.tags,
+        config
+    };
+    await createProvider(config).send(inputData);
+    await sendLocalNotification(inputData);
+}
+function mergeTargetIntoReport(report, targetReport) {
+    targetReport.suggestedFixes = [...new Set(targetReport.suggestedFixes)];
+    report.targets[targetReport.target] = targetReport;
+    report.warnings.push(...targetReport.warnings);
+    report.errors.push(...targetReport.errors);
+    report.suggestedFixes.push(...targetReport.suggestedFixes);
+}
+function finalizeReport(report) {
+    report.suggestedFixes = [...new Set(report.suggestedFixes)];
+    if (report.errors.length > 0) {
+        report.overallStatus = 'error';
+    }
+    else if (report.warnings.length > 0) {
+        report.overallStatus = 'warning';
+    }
+    else {
+        report.overallStatus = 'ok';
+    }
+    return report;
+}
+export async function buildVerifyReport(options = {}) {
+    const configPath = resolveConfigPath(options.config);
+    const expectedCliPath = path.join(projectRoot(), 'dist', 'cli.js');
+    const report = {
+        overallStatus: 'ok',
+        platform: process.platform,
+        cwd: process.cwd(),
+        nodePath: process.execPath,
+        cliInvocation: currentCliInvocation(),
+        expectedCliPath,
+        config: {
+            path: configPath,
+            exists: false,
+            readable: false
+        },
+        provider: {
+            supported: false
+        },
+        localNotification: {
+            windowsSkipped: process.platform === 'win32'
+        },
+        targets: {},
+        warnings: [],
+        errors: [],
+        suggestedFixes: []
+    };
+    let config;
+    try {
+        const loaded = await loadConfig(options.config);
+        config = loaded.config;
+        report.config.exists = true;
+        report.config.readable = true;
+        report.config.provider = config.provider;
+        report.config.ntfyServer = config.ntfy.server;
+        report.config.topicPresent = Boolean(config.ntfy.topic.trim());
+        report.config.topicMasked = maskSecret(config.ntfy.topic);
+        report.config.profileName = config.profile.name;
+        report.provider.supported = config.provider === 'ntfy';
+        if (!config.ntfy.topic.trim()) {
+            report.errors.push('ntfy topic is empty.');
+        }
+        if (!options.dryRun) {
+            report.provider.ntfyServerReachable = await canAccessServer(config.ntfy.server);
+            if (!report.provider.ntfyServerReachable) {
+                report.warnings.push('ntfy server was not reachable.');
+            }
+        }
+        if (options.sendTest) {
+            await sendVerifyTest(config);
+        }
+    }
+    catch (error) {
+        report.errors.push(`Config is missing or invalid: ${error.message}`);
+    }
+    if (process.platform === 'win32') {
+        report.warnings.push('Windows local desktop notification is skipped in this MVP; phone push is unaffected.');
+    }
+    for (const target of selectedTargets(options.target)) {
+        const targetReport = target === 'codex'
+            ? await verifyCodex(expectedCliPath, options)
+            : target === 'claude-code'
+                ? await verifyClaude(expectedCliPath, options)
+                : await verifyVscodeAgent(expectedCliPath, options);
+        mergeTargetIntoReport(report, targetReport);
+    }
+    return finalizeReport(report);
+}
+function formatTargetName(target) {
+    if (target === 'codex') {
+        return 'Codex';
+    }
+    if (target === 'claude-code') {
+        return 'Claude Code';
+    }
+    return 'VS Code Copilot Agent';
+}
+function formatTextReport(report) {
+    const lines = ['AgentBell verify', '================'];
+    lines.push(`Config: ${report.config.readable ? 'ok' : 'error'}`);
+    lines.push(`Provider: ${report.provider.supported ? `${report.config.provider} ok` : 'error'}`);
+    lines.push(`Topic: ${report.config.topicMasked ?? '<missing>'}`);
+    lines.push(`Machine: ${report.config.profileName ?? os.hostname()}`);
+    lines.push(`CWD: ${report.cwd}`);
+    lines.push(`Node: ${report.nodePath}`);
+    lines.push(`CLI: ${report.cliInvocation}`);
+    lines.push('');
+    lines.push('Targets:');
+    for (const target of selectedTargets(undefined)) {
+        const targetReport = report.targets[target];
+        if (!targetReport) {
+            continue;
+        }
+        lines.push(`[${formatTargetName(target)}]`);
+        for (const [name, status] of Object.entries(targetReport.checks)) {
+            lines.push(`  ${name}: ${status}`);
+        }
+        if (targetReport.details.bashPath) {
+            lines.push(`  bash: ${targetReport.details.bashPath}`);
+        }
+        if (targetReport.details.staleReferences) {
+            lines.push('  stale legacy project references: found');
+            for (const stale of targetReport.details.staleReferences) {
+                lines.push(`  stale path: ${stale.trim()}`);
+            }
+        }
+        const logSignals = targetReport.details.recentLogSignals;
+        if (logSignals) {
+            const active = Object.entries(logSignals)
+                .filter(([, value]) => value)
+                .map(([key]) => key)
+                .join(', ');
+            lines.push(`  last log: ${active || 'no known signals'}`);
+        }
+        lines.push(`  status: ${targetReport.status}`);
+        for (const error of targetReport.errors) {
+            lines.push(`  error: ${error}`);
+        }
+        for (const warning of targetReport.warnings) {
+            lines.push(`  warning: ${warning}`);
+        }
+        for (const fix of targetReport.suggestedFixes) {
+            lines.push(`  fix: ${fix}`);
+        }
+        lines.push('');
+    }
+    if (report.warnings.length > 0) {
+        lines.push('Warnings:');
+        for (const warning of report.warnings) {
+            lines.push(`- ${warning}`);
+        }
+        lines.push('');
+    }
+    if (report.errors.length > 0) {
+        lines.push('Errors:');
+        for (const error of report.errors) {
+            lines.push(`- ${error}`);
+        }
+        lines.push('');
+    }
+    if (report.suggestedFixes.length > 0) {
+        lines.push('Suggested fixes:');
+        for (const fix of report.suggestedFixes) {
+            lines.push(`- ${fix}`);
+        }
+        lines.push('');
+    }
+    lines.push(`Overall: ${report.overallStatus}`);
+    return lines.join('\n');
+}
+export async function runVerify(options) {
+    const allowed = ['codex', 'claude-code', 'vscode-agent', 'all', undefined];
+    if (!allowed.includes(options.target)) {
+        throw new Error(`Invalid verify target: ${options.target}. Expected codex, claude-code, vscode-agent, or all.`);
+    }
+    const report = await buildVerifyReport(options);
+    logger.info(options.json ? JSON.stringify(report, null, 2) : formatTextReport(report));
+}
+//# sourceMappingURL=verify.js.map