@xyteai/cli 0.1.0

package/dist/tui/app.js

@@ -0,0 +1,711 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateErrorStormState = updateErrorStormState;
+exports.runTuiApp = runTuiApp;
+const blessed_1 = __importDefault(require("blessed"));
+const promises_1 = require("node:timers/promises");
+const layout_1 = require("./layout");
+const keymap_1 = require("./keymap");
+const setup_1 = require("./screens/setup");
+const config_1 = require("./screens/config");
+const dashboard_1 = require("./screens/dashboard");
+const spaces_1 = require("./screens/spaces");
+const devices_1 = require("./screens/devices");
+const incidents_1 = require("./screens/incidents");
+const tickets_1 = require("./screens/tickets");
+const profile_store_1 = require("../secure/profile-store");
+const keychain_1 = require("../secure/keychain");
+const dispatch_1 = require("./dispatch");
+const animation_1 = require("./animation");
+const headless_renderer_1 = require("./headless-renderer");
+const logo_1 = require("./assets/logo");
+const readiness_1 = require("../config/readiness");
+const input_controller_1 = require("./input-controller");
+const runtime_1 = require("./runtime");
+const logger_1 = require("./logger");
+const tabs_1 = require("./tabs");
+function toErrorText(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+async function renderStartupSequence(screen, messageBox, motionEnabled) {
+    const frames = (0, animation_1.startupFrames)();
+    if (!motionEnabled) {
+        const frame = frames[frames.length - 1];
+        messageBox.display(`${frame.banner}\n\n${frame.status}`, 1, () => undefined);
+        screen.render();
+        return;
+    }
+    for (const frame of frames) {
+        messageBox.display(`${frame.banner}\n\n${frame.status}`, 1, () => undefined);
+        screen.render();
+        await (0, promises_1.setTimeout)(180);
+    }
+}
+function canOpenScreen(id, readiness) {
+    if (id === 'setup' || id === 'config') {
+        return true;
+    }
+    return readiness?.state === 'ready';
+}
+function updateErrorStormState(state, message, now = Date.now(), windowMs = 2_000) {
+    if (state.message === message && now - state.startedAt <= windowMs) {
+        return {
+            message,
+            count: state.count + 1,
+            startedAt: state.startedAt
+        };
+    }
+    return {
+        message,
+        count: 1,
+        startedAt: now
+    };
+}
+async function runTuiApp(options) {
+    const profileStore = options.profileStore ?? new profile_store_1.FileProfileStore();
+    const keychain = options.keychain ?? (await (0, keychain_1.createKeychainStore)());
+    const motionEnabled = (0, animation_1.isMotionEnabled)({ headless: options.headless, explicitMotion: options.motionEnabled });
+    const debugEnabled = Boolean(options.debug || options.debugLogPath || process.env.XYTE_TUI_DEBUG === '1' || process.env.XYTE_TUI_DEBUG_LOG);
+    const logger = (0, logger_1.createTuiLogger)({
+        enabled: debugEnabled,
+        path: options.debugLogPath ?? process.env.XYTE_TUI_DEBUG_LOG
+    });
+    logger.log('app.start', {
+        headless: Boolean(options.headless),
+        screen: options.initialScreen ?? 'dashboard',
+        format: options.format ?? 'json',
+        tenantId: options.tenantId,
+        motionEnabled
+    });
+    if (options.headless) {
+        const requestedFormat = options.format ?? 'json';
+        if (requestedFormat !== 'json') {
+            throw new Error('Headless mode only supports JSON output.');
+        }
+        try {
+            await (0, headless_renderer_1.runHeadlessRenderer)({
+                client: options.client,
+                profileStore,
+                keychain,
+                screen: options.initialScreen ?? 'dashboard',
+                format: 'json',
+                motionEnabled,
+                follow: options.follow,
+                intervalMs: options.intervalMs,
+                tenantId: options.tenantId,
+                output: options.output
+            });
+            logger.log('app.headless.complete');
+        }
+        finally {
+            logger.close();
+        }
+        return;
+    }
+    try {
+        await new Promise((resolve) => {
+            const screen = blessed_1.default.screen({
+                smartCSR: true,
+                fullUnicode: true,
+                title: 'XYTE SDK TUI'
+            });
+            const layout = (0, layout_1.createLayout)(screen, { motionEnabled });
+            let activeScreenId = options.initialScreen ?? 'dashboard';
+            let pulsePhase = 0;
+            let readinessState;
+            let isPromptActive = false;
+            let isMessageActive = false;
+            let isShuttingDown = false;
+            let mountTransitionToken = 0;
+            let transitionState = 'idle';
+            let mountedRuntime;
+            let runtimeStatus = {
+                state: 'idle',
+                refreshInFlight: false,
+                refreshQueued: false,
+                staleDiscarded: 0
+            };
+            let footerStatusText = 'Ready';
+            let getInputState = () => ({ queueDepth: 0, droppedEvents: 0, inFlight: false });
+            let lastRuntimeLogLine = '';
+            let lastRenderCounter = 0;
+            let isHandlingFatalError = false;
+            let errorStormState = {
+                message: '',
+                count: 0,
+                startedAt: 0
+            };
+            logger.log('app.interactive.start', {
+                initialScreen: activeScreenId,
+                motionEnabled
+            });
+            const renderFooter = (statusText) => {
+                if (statusText !== undefined) {
+                    footerStatusText = statusText;
+                }
+                const readiness = readinessState
+                    ? `${readinessState.state}/${readinessState.connectionState} tenant=${readinessState.tenantId ?? 'none'}`
+                    : 'status=unknown';
+                const inputState = getInputState();
+                const runtime = `refresh=${runtimeStatus.state}${runtimeStatus.refreshQueued ? '+queued' : ''} stale=${runtimeStatus.staleDiscarded} in=${inputState.queueDepth} drop=${inputState.droppedEvents} tx=${transitionState}`;
+                const detail = runtimeStatus.lastError ? `${footerStatusText} | err=${runtimeStatus.lastError}` : footerStatusText;
+                layout.footer.setContent(` @ ${readiness} | ${runtime} | ${detail}`);
+                screen.render();
+            };
+            const message = blessed_1.default.message({
+                parent: screen,
+                border: 'line',
+                width: '70%',
+                height: 'shrink',
+                top: 'center',
+                left: 'center',
+                label: ' XYTE ',
+                tags: true,
+                hidden: true
+            });
+            const promptWidget = blessed_1.default.prompt({
+                parent: screen,
+                border: 'line',
+                width: '70%',
+                height: 'shrink',
+                top: 'center',
+                left: 'center',
+                label: ' Input ',
+                tags: true,
+                hidden: true
+            });
+            const setMessageModalState = (active) => {
+                isMessageActive = active;
+            };
+            const writeErrorStderr = (source, messageText) => {
+                try {
+                    process.stderr.write(`[xyte-tui] ${source}: ${messageText}\n`);
+                }
+                catch {
+                    // best-effort stderr logging
+                }
+            };
+            const runPrompt = (promptText, initial = '', secret = false) => {
+                const promptInternals = promptWidget;
+                const input = promptInternals._?.input;
+                const prevCensor = input?.censor;
+                const prevSecret = input?.secret;
+                if (input) {
+                    input.censor = secret;
+                    input.secret = false;
+                }
+                isPromptActive = true;
+                logger.log('prompt.open', {
+                    promptText,
+                    secret,
+                    hasInitial: Boolean(initial)
+                });
+                return new Promise((resolvePrompt) => {
+                    promptWidget.input(promptText, initial, (_err, value) => {
+                        if (input) {
+                            input.censor = prevCensor;
+                            input.secret = prevSecret;
+                        }
+                        isPromptActive = false;
+                        logger.log('prompt.close', {
+                            promptText,
+                            secret,
+                            hasValue: value !== undefined && value !== null && String(value).length > 0
+                        });
+                        screen.render();
+                        resolvePrompt(value ?? undefined);
+                    });
+                });
+            };
+            const refreshReadiness = async (checkConnectivity = false) => {
+                logger.log('readiness.refresh.start', { checkConnectivity });
+                readinessState = await (0, readiness_1.evaluateReadiness)({
+                    profileStore,
+                    keychain,
+                    tenantId: options.tenantId,
+                    client: options.client,
+                    checkConnectivity
+                });
+                logger.log('readiness.refresh.complete', {
+                    state: readinessState.state,
+                    connectionState: readinessState.connectionState,
+                    tenantId: readinessState.tenantId
+                });
+                renderFooter();
+                return readinessState;
+            };
+            let shutdownRef;
+            const safeShowError = (source, error) => {
+                const text = toErrorText(error);
+                logger.log('ui.error.safe', {
+                    source,
+                    message: text,
+                    error
+                });
+                if (isShuttingDown) {
+                    writeErrorStderr(source, text);
+                    return;
+                }
+                const now = Date.now();
+                errorStormState = updateErrorStormState(errorStormState, text, now);
+                if (errorStormState.count >= 5) {
+                    logger.log('ui.error.storm', {
+                        source,
+                        message: text,
+                        count: errorStormState.count
+                    });
+                    writeErrorStderr(source, `error storm detected (${errorStormState.count} in 2s): ${text}`);
+                    shutdownRef?.();
+                    return;
+                }
+                runtimeStatus = {
+                    ...runtimeStatus,
+                    state: 'error',
+                    lastError: text
+                };
+                renderFooter(`Error: ${text}`);
+                if (isHandlingFatalError) {
+                    logger.log('ui.error.reentrant', {
+                        source,
+                        message: text
+                    });
+                    writeErrorStderr(source, text);
+                    return;
+                }
+                isHandlingFatalError = true;
+                setMessageModalState(true);
+                try {
+                    message.display(`{red-fg}Error{/red-fg}: ${text}`, 4, () => {
+                        setMessageModalState(false);
+                        isHandlingFatalError = false;
+                        try {
+                            screen.render();
+                        }
+                        catch (renderError) {
+                            logger.log('ui.error.render.failure', {
+                                source,
+                                original: text,
+                                renderError
+                            });
+                            writeErrorStderr(source, `render failure after error modal: ${toErrorText(renderError)}`);
+                            shutdownRef?.();
+                        }
+                    });
+                }
+                catch (displayError) {
+                    isHandlingFatalError = false;
+                    setMessageModalState(false);
+                    logger.log('ui.error.display.failure', {
+                        source,
+                        original: text,
+                        displayError
+                    });
+                    writeErrorStderr(source, `unable to display error modal: ${toErrorText(displayError)} | original: ${text}`);
+                    shutdownRef?.();
+                }
+            };
+            const context = {
+                screen,
+                client: options.client,
+                profileStore,
+                keychain,
+                async getActiveTenantId() {
+                    return options.tenantId ?? (await profileStore.getData()).activeTenantId;
+                },
+                getReadiness() {
+                    return readinessState;
+                },
+                async refreshReadiness(checkConnectivity = false) {
+                    return refreshReadiness(checkConnectivity);
+                },
+                setStatus(text) {
+                    renderFooter(text);
+                },
+                showError(error) {
+                    safeShowError('context.showError', error);
+                },
+                debugLog(event, data) {
+                    logger.log(event, data);
+                },
+                prompt(promptText, initial = '') {
+                    return runPrompt(promptText, initial, false);
+                },
+                promptSecret(promptText, initial = '') {
+                    return runPrompt(promptText, initial, true);
+                },
+                async confirmWrite(actionLabel, token) {
+                    const value = await context.prompt(`Type "${token}" to confirm: ${actionLabel}`, '');
+                    return value === token;
+                }
+            };
+            const screens = {
+                setup: (0, setup_1.createSetupScreen)(),
+                config: (0, config_1.createConfigScreen)(),
+                dashboard: (0, dashboard_1.createDashboardScreen)(),
+                spaces: (0, spaces_1.createSpacesScreen)(),
+                devices: (0, devices_1.createDevicesScreen)(),
+                incidents: (0, incidents_1.createIncidentsScreen)(),
+                tickets: (0, tickets_1.createTicketsScreen)()
+            };
+            let mounted;
+            const mountScreen = async (id) => {
+                const token = ++mountTransitionToken;
+                transitionState = 'switching';
+                logger.log('screen.mount.request', {
+                    requested: id,
+                    token
+                });
+                renderFooter(`Switching to ${id}...`);
+                const nextId = canOpenScreen(id, readinessState) ? id : 'setup';
+                if (nextId !== id) {
+                    logger.log('screen.mount.redirect', {
+                        requested: id,
+                        redirectedTo: nextId,
+                        readinessState: readinessState?.state
+                    });
+                    renderFooter(`Setup required before opening ${id}. Redirected to Setup.`);
+                }
+                mountedRuntime?.cancelPendingForUnmount();
+                mountedRuntime = undefined;
+                if (mounted) {
+                    logger.log('screen.unmount', {
+                        id: mounted.id
+                    });
+                    mounted.unmount();
+                }
+                const next = screens[nextId];
+                next.mount(layout.body, context);
+                activeScreenId = nextId;
+                mounted = next;
+                mountedRuntime = new runtime_1.ScreenRuntime({
+                    refresh: async () => {
+                        if (token !== mountTransitionToken || isShuttingDown) {
+                            logger.log('screen.refresh.skip', {
+                                id: nextId,
+                                token,
+                                latestToken: mountTransitionToken,
+                                isShuttingDown
+                            });
+                            return;
+                        }
+                        logger.log('screen.refresh.start', {
+                            id: nextId,
+                            reason: runtimeStatus.reason
+                        });
+                        await next.refresh();
+                        logger.log('screen.refresh.complete', {
+                            id: nextId
+                        });
+                    },
+                    onStatus(status) {
+                        runtimeStatus = status;
+                        const statusLine = JSON.stringify(status);
+                        if (statusLine !== lastRuntimeLogLine) {
+                            lastRuntimeLogLine = statusLine;
+                            logger.log('screen.runtime.status', {
+                                id: nextId,
+                                ...status
+                            });
+                        }
+                        renderFooter();
+                    },
+                    onError(error) {
+                        logger.log('screen.runtime.error', {
+                            id: nextId,
+                            error
+                        });
+                        safeShowError('screen.runtime', error);
+                    }
+                });
+                mountedRuntime.setMountToken(token);
+                runtimeStatus = mountedRuntime.getStatus();
+                layout.setActiveTab(nextId);
+                layout.header.setContent(` XYTE SDK TUI | ${next.title.toUpperCase()} `);
+                transitionState = 'idle';
+                next.focus?.();
+                logger.log('screen.mount.active', {
+                    id: nextId,
+                    token
+                });
+                renderFooter(`Active screen: ${next.title}`);
+                mountedRuntime.runRefresh('mount');
+                void context
+                    .refreshReadiness(true)
+                    .then((nextReadiness) => {
+                    if (token !== mountTransitionToken || isShuttingDown) {
+                        return;
+                    }
+                    if (nextReadiness.state !== 'ready' && !['setup', 'config'].includes(activeScreenId)) {
+                        renderFooter(`Setup required before opening ${activeScreenId}. Redirected to Setup.`);
+                        void mountScreen('setup');
+                    }
+                })
+                    .catch((error) => {
+                    safeShowError('screen.mount.readiness', error);
+                });
+            };
+            const showHelp = () => {
+                const content = [
+                    '{bold}Global shortcuts{/bold}',
+                    ...keymap_1.GLOBAL_KEYMAP.map((item) => `- ${item.keys}: ${item.description}`),
+                    '',
+                    '{bold}Screen actions{/bold}',
+                    ...keymap_1.SCREEN_ACTION_KEYMAP.map((item) => `- ${item.keys}: ${item.description}`)
+                ].join('\n');
+                setMessageModalState(true);
+                message.display(content, 0, () => {
+                    setMessageModalState(false);
+                    screen.render();
+                });
+            };
+            const handleGlobalKey = async (ch, key) => {
+                logger.log('input.global', {
+                    key: key.name ?? key.full,
+                    ch,
+                    activeScreenId
+                });
+                if (key.name === 'left' || key.name === 'right') {
+                    const target = (0, tabs_1.nextTab)(activeScreenId, key.name);
+                    await mountScreen(target);
+                    return;
+                }
+                if (ch === 'u') {
+                    await mountScreen('setup');
+                    return;
+                }
+                if (ch === 'g') {
+                    await mountScreen('config');
+                    return;
+                }
+                if (ch === 'd') {
+                    await mountScreen('dashboard');
+                    return;
+                }
+                if (ch === 's') {
+                    await mountScreen('spaces');
+                    return;
+                }
+                if (ch === 'v') {
+                    await mountScreen('devices');
+                    return;
+                }
+                if (ch === 'i') {
+                    await mountScreen('incidents');
+                    return;
+                }
+                if (ch === 't') {
+                    await mountScreen('tickets');
+                    return;
+                }
+                if (ch === 'r') {
+                    logger.log('screen.refresh.request', {
+                        id: activeScreenId,
+                        via: 'global-r'
+                    });
+                    mountedRuntime?.runRefresh('manual');
+                    void context
+                        .refreshReadiness(true)
+                        .then((nextReadiness) => {
+                        if (isShuttingDown) {
+                            return;
+                        }
+                        if (nextReadiness.state !== 'ready' && !['setup', 'config'].includes(activeScreenId)) {
+                            renderFooter(`Setup required before opening ${activeScreenId}. Redirected to Setup.`);
+                            void mountScreen('setup');
+                            return;
+                        }
+                        renderFooter('Screen refreshed.');
+                    })
+                        .catch((error) => {
+                        safeShowError('global.refresh', error);
+                    });
+                    return;
+                }
+                if (ch === '?') {
+                    showHelp();
+                    return;
+                }
+                if (key.name === 'escape') {
+                    showHelp();
+                }
+            };
+            const shutdown = () => {
+                if (isShuttingDown) {
+                    return;
+                }
+                isShuttingDown = true;
+                logger.log('app.shutdown.start', {
+                    activeScreenId
+                });
+                try {
+                    mountedRuntime?.cancelPendingForUnmount();
+                    mounted?.unmount();
+                }
+                finally {
+                    screen.destroy();
+                    logger.log('app.shutdown.complete');
+                    resolve();
+                }
+            };
+            shutdownRef = shutdown;
+            const inputController = (0, input_controller_1.createInputController)({
+                maxQueueSize: 64,
+                async handle(event) {
+                    if (isShuttingDown) {
+                        return;
+                    }
+                    if (event.key.full === 'C-c' || event.ch === 'q' || event.key.name === 'q') {
+                        logger.log('input.critical', {
+                            key: event.key.name ?? event.key.full,
+                            full: event.key.full
+                        });
+                        shutdown();
+                        return;
+                    }
+                    const modalActive = isPromptActive || isMessageActive;
+                    const safeCh = modalActive ? undefined : event.ch;
+                    const activeMounted = mounted;
+                    const dispatchResult = await (0, dispatch_1.dispatchKeypress)({
+                        ch: event.ch,
+                        key: event.key,
+                        isModalActive: modalActive,
+                        handleArrow: activeMounted?.handleArrow
+                            ? async (key) => {
+                                try {
+                                    return await activeMounted.handleArrow(key);
+                                }
+                                catch (error) {
+                                    logger.log('input.arrow.error', {
+                                        screen: activeMounted?.id,
+                                        key,
+                                        error
+                                    });
+                                    safeShowError('input.arrow', error);
+                                    return 'handled';
+                                }
+                            }
+                            : undefined,
+                        handleScreen: activeMounted?.handleKey
+                            ? async (ch, key) => {
+                                try {
+                                    return await activeMounted.handleKey(ch, key);
+                                }
+                                catch (error) {
+                                    logger.log('input.screen.error', {
+                                        screen: activeMounted?.id,
+                                        key: key.name ?? key.full,
+                                        error
+                                    });
+                                    safeShowError('input.screen', error);
+                                    return true;
+                                }
+                            }
+                            : undefined,
+                        handleGlobal: async (ch, key) => {
+                            try {
+                                await handleGlobalKey(ch, key);
+                            }
+                            catch (error) {
+                                logger.log('input.global.error', {
+                                    key: key.name ?? key.full,
+                                    error
+                                });
+                                safeShowError('input.global', error);
+                            }
+                        }
+                    });
+                    logger.log('input.dispatch', {
+                        screen: activeMounted?.id,
+                        key: event.key.name ?? event.key.full,
+                        full: event.key.full,
+                        ch: safeCh,
+                        modalActive,
+                        result: dispatchResult,
+                        queueDepth: getInputState().queueDepth,
+                        droppedEvents: getInputState().droppedEvents
+                    });
+                    const renderCount = Number(screen.renders ?? 0);
+                    const renderDelta = Math.max(0, renderCount - lastRenderCounter);
+                    lastRenderCounter = renderCount;
+                    logger.log('nav.render.count', {
+                        screen: activeMounted?.id,
+                        key: event.key.name ?? event.key.full,
+                        renderCount,
+                        delta: renderDelta
+                    });
+                    renderFooter();
+                },
+                onError(error) {
+                    logger.log('input.controller.error', { error });
+                    safeShowError('input.controller', error);
+                }
+            });
+            getInputState = inputController.getState;
+            const onUnhandledRejection = (reason) => {
+                logger.log('process.unhandledRejection', { reason });
+                safeShowError('process.unhandledRejection', reason);
+            };
+            const onUncaughtException = (error) => {
+                logger.log('process.uncaughtException', { error });
+                safeShowError('process.uncaughtException', error);
+            };
+            process.on('unhandledRejection', onUnhandledRejection);
+            process.on('uncaughtException', onUncaughtException);
+            screen.on('keypress', (ch, key) => {
+                const dispatchResult = inputController.dispatch({
+                    ch,
+                    key,
+                    timestamp: Date.now()
+                });
+                const modalActive = isPromptActive || isMessageActive;
+                logger.log('input.enqueue', {
+                    key: key.name ?? key.full,
+                    ch: modalActive ? undefined : ch,
+                    modalActive,
+                    ...dispatchResult
+                });
+                renderFooter();
+            });
+            const pulseTimer = motionEnabled
+                ? setInterval(() => {
+                    pulsePhase += 1;
+                    layout.setPulsePhase(pulsePhase);
+                    screen.render();
+                }, 220)
+                : undefined;
+            void (async () => {
+                await renderStartupSequence(screen, message, motionEnabled);
+                message.hide();
+                layout.header.setContent(` XYTE SDK TUI | ${(0, logo_1.xyteLogoText)().split('\n')[0]} `);
+                const readiness = await context.refreshReadiness(true);
+                if (readiness.state !== 'ready') {
+                    activeScreenId = 'setup';
+                }
+                await mountScreen(activeScreenId);
+                renderFooter();
+            })().catch((error) => {
+                safeShowError('app.startup', error);
+            });
+            screen.on('destroy', () => {
+                inputController.clear();
+                mountedRuntime?.cancelPendingForUnmount();
+                process.removeListener('unhandledRejection', onUnhandledRejection);
+                process.removeListener('uncaughtException', onUncaughtException);
+                if (pulseTimer) {
+                    clearInterval(pulseTimer);
+                }
+                logger.close();
+            });
+        });
+    }
+    finally {
+        logger.close();
+    }
+}
+//# sourceMappingURL=app.js.map