redmine-context 1.0.0

package/dist/surfaces/tui/palettes.js

@@ -0,0 +1,244 @@
+/**
+ * Kits de PALETAS de cores da TUI (#190).
+ *
+ * Cada paleta é um {@link Theme} COMPLETO em truecolor (hex), curado a partir de
+ * esquemas de cor consagrados. Trocar de paleta é escolher um `id` aqui — o
+ * `ThemeProvider` (`./theme.tsx`) recebe o `Theme` resolvido. Este arquivo é a
+ * ÚNICA fonte de literais hex (junto de `theme.tsx`); as telas nunca declaram cor
+ * literal (varredura `no-hardcoded-colors.test.ts`), sempre via `useTheme()`.
+ *
+ * Os valores hex são bem conhecidos dos respectivos projetos de tema. A
+ * degradação para texto puro (NO_COLOR/CI/não-TTY) é decidida ANTES de a TUI
+ * subir (`shouldRenderTui`), então aqui só existem terminais com cor.
+ */
+/**
+ * Lista ORDENADA de paletas (a ordem é a do seletor). A primeira é o default
+ * quando não há escolha persistida ({@link DEFAULT_PALETTE_ID}).
+ */
+export const PALETTES = [
+    // ── Paletas ESCURAS (texto claro sobre fundo escuro) ─────────────────────────
+    {
+        id: 'catppuccin-mocha',
+        label: 'Catppuccin Mocha (escura)',
+        theme: {
+            primary: '#89b4fa', // blue
+            secondary: '#cba6f7', // mauve
+            accent: '#f5c2e7', // pink
+            muted: '#9399b2', // overlay2
+            success: '#a6e3a1', // green
+            warning: '#f9e2af', // yellow
+            danger: '#f38ba8', // red
+            border: '#585b70', // surface2
+            background: '#1e1e2e', // base
+            text: '#cdd6f4', // text
+            gradient: ['#89b4fa', '#cba6f7', '#f5c2e7', '#f38ba8'],
+        },
+    },
+    {
+        id: 'dracula',
+        label: 'Dracula (escura)',
+        theme: {
+            primary: '#bd93f9', // purple
+            secondary: '#8be9fd', // cyan
+            accent: '#ff79c6', // pink
+            muted: '#6272a4', // comment
+            success: '#50fa7b', // green
+            warning: '#f1fa8c', // yellow
+            danger: '#ff5555', // red
+            border: '#44475a', // current line
+            background: '#282a36', // background
+            text: '#f8f8f2', // foreground
+            gradient: ['#8be9fd', '#bd93f9', '#ff79c6', '#ff5555'],
+        },
+    },
+    {
+        id: 'nord',
+        label: 'Nord (escura)',
+        theme: {
+            primary: '#88c0d0', // frost cyan
+            secondary: '#81a1c1', // frost blue
+            accent: '#b48ead', // aurora purple
+            muted: '#7b88a1', // dim
+            success: '#a3be8c', // aurora green
+            warning: '#ebcb8b', // aurora yellow
+            danger: '#bf616a', // aurora red
+            border: '#434c5e', // polar night 2
+            background: '#2e3440', // polar night 0
+            text: '#e5e9f0', // snow storm
+            gradient: ['#8fbcbb', '#88c0d0', '#81a1c1', '#5e81ac'],
+        },
+    },
+    {
+        id: 'tokyo-night',
+        label: 'Tokyo Night (escura)',
+        theme: {
+            primary: '#7aa2f7', // blue
+            secondary: '#7dcfff', // cyan
+            accent: '#bb9af7', // purple
+            muted: '#737aa2', // comment
+            success: '#9ece6a', // green
+            warning: '#e0af68', // yellow
+            danger: '#f7768e', // red
+            border: '#3b4261', // fg gutter
+            background: '#1a1b26', // bg
+            text: '#c0caf5', // fg
+            gradient: ['#7dcfff', '#7aa2f7', '#bb9af7', '#f7768e'],
+        },
+    },
+    {
+        id: 'gruvbox-dark',
+        label: 'Gruvbox Dark (escura)',
+        theme: {
+            primary: '#83a598', // blue
+            secondary: '#8ec07c', // aqua
+            accent: '#d3869b', // purple
+            muted: '#a89984', // gray
+            success: '#b8bb26', // green
+            warning: '#fabd2f', // yellow
+            danger: '#fb4934', // red
+            border: '#504945', // bg2
+            background: '#282828', // bg0
+            text: '#ebdbb2', // fg1
+            gradient: ['#8ec07c', '#83a598', '#d3869b', '#fb4934'],
+        },
+    },
+    {
+        id: 'rose-pine',
+        label: 'Rosé Pine (escura)',
+        theme: {
+            primary: '#c4a7e7', // iris
+            secondary: '#9ccfd8', // foam
+            accent: '#ebbcba', // rose
+            muted: '#908caa', // subtle
+            success: '#31748f', // pine
+            warning: '#f6c177', // gold
+            danger: '#eb6f92', // love
+            border: '#403d52', // highlight med
+            background: '#191724', // base
+            text: '#e0def4', // text
+            gradient: ['#9ccfd8', '#c4a7e7', '#ebbcba', '#eb6f92'],
+        },
+    },
+    {
+        id: 'tokyo-storm',
+        label: 'Tokyo Storm (escura)',
+        theme: {
+            primary: '#7aa2f7',
+            secondary: '#7dcfff',
+            accent: '#bb9af7',
+            muted: '#7982a9',
+            success: '#9ece6a',
+            warning: '#e0af68',
+            danger: '#f7768e',
+            border: '#3b4261',
+            background: '#24283b', // storm bg
+            text: '#c0caf5',
+            gradient: ['#7dcfff', '#7aa2f7', '#bb9af7', '#f7768e'],
+        },
+    },
+    {
+        id: 'one-dark',
+        label: 'One Dark (escura)',
+        theme: {
+            primary: '#61afef', // blue
+            secondary: '#56b6c2', // cyan
+            accent: '#c678dd', // purple
+            muted: '#828997', // comment gray
+            success: '#98c379', // green
+            warning: '#e5c07b', // yellow
+            danger: '#e06c75', // red
+            border: '#3e4451', // gutter
+            background: '#282c34', // bg
+            text: '#abb2bf', // fg
+            gradient: ['#56b6c2', '#61afef', '#c678dd', '#e06c75'],
+        },
+    },
+    // ── Paletas CLARAS (texto escuro sobre fundo claro) ──────────────────────────
+    {
+        id: 'catppuccin-latte',
+        label: 'Catppuccin Latte (clara)',
+        theme: {
+            primary: '#1e66f5', // blue
+            secondary: '#8839ef', // mauve
+            accent: '#ea76cb', // pink
+            muted: '#6c6f85', // subtext0
+            success: '#40a02b', // green
+            warning: '#df8e1d', // yellow
+            danger: '#d20f39', // red
+            border: '#bcc0cc', // surface1
+            background: '#eff1f5', // base
+            text: '#4c4f69', // text
+            gradient: ['#1e66f5', '#8839ef', '#ea76cb', '#d20f39'],
+        },
+    },
+    {
+        id: 'solarized-light',
+        label: 'Solarized Light (clara)',
+        theme: {
+            primary: '#268bd2', // blue
+            secondary: '#2aa198', // cyan
+            accent: '#d33682', // magenta
+            muted: '#93a1a1', // base1
+            success: '#859900', // green
+            warning: '#b58900', // yellow
+            danger: '#dc322f', // red
+            border: '#eee8d5', // base2
+            background: '#fdf6e3', // base3
+            text: '#586e75', // base01
+            gradient: ['#2aa198', '#268bd2', '#6c71c4', '#d33682'],
+        },
+    },
+    {
+        id: 'github-light',
+        label: 'GitHub Light (clara)',
+        theme: {
+            primary: '#0969da', // accent blue
+            secondary: '#1a7f37', // green
+            accent: '#8250df', // purple
+            muted: '#57606a', // fg muted
+            success: '#1a7f37', // green
+            warning: '#9a6700', // attention
+            danger: '#cf222e', // danger red
+            border: '#d0d7de', // border
+            background: '#ffffff', // canvas
+            text: '#1f2328', // fg default
+            gradient: ['#0969da', '#8250df', '#bf3989', '#cf222e'],
+        },
+    },
+    {
+        id: 'one-light',
+        label: 'One Light (clara)',
+        theme: {
+            primary: '#4078f2', // blue
+            secondary: '#0184bc', // cyan
+            accent: '#a626a4', // purple
+            muted: '#696c77', // gray
+            success: '#50a14f', // green
+            warning: '#c18401', // yellow
+            danger: '#e45649', // red
+            border: '#dcdfe4', // gutter
+            background: '#fafafa', // bg
+            text: '#383a42', // fg
+            gradient: ['#0184bc', '#4078f2', '#a626a4', '#e45649'],
+        },
+    },
+];
+/** Id da paleta default (a primeira da lista) — usada sem escolha persistida. */
+export const DEFAULT_PALETTE_ID = PALETTES[0].id;
+/** Índice `id → Palette` para resolução O(1). */
+const BY_ID = new Map(PALETTES.map((p) => [p.id, p]));
+/**
+ * Resolve uma paleta por `id`, com fallback para a default se o `id` for
+ * desconhecido (ex.: settings.json com uma paleta removida numa versão futura).
+ *
+ * @param id - Id persistido (ou `undefined`).
+ * @returns A paleta correspondente, ou a default.
+ */
+export function resolvePalette(id) {
+    if (id !== undefined) {
+        const found = BY_ID.get(id);
+        if (found !== undefined)
+            return found;
+    }
+    return BY_ID.get(DEFAULT_PALETTE_ID);
+}

package/dist/surfaces/tui/screen.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Registro de telas da TUI (roteador, M2-01; título adicionado no M2-04).
+ *
+ * Cada tela é um componente Ink sem props — recebe apenas o contexto de
+ * navegação via `useNavigation()`. Cada entrada também carrega um `title`
+ * legível, consumido pelo breadcrumb fixo (`components/breadcrumb.tsx`)
+ * para renderizar o caminho da pilha ("Início › Atalhos"). Adicionar uma
+ * tela nova é registrar aqui (`SCREENS`) e estender {@link ScreenName}; o
+ * roteador (`app.tsx`) não muda.
+ */
+import type { ComponentType } from 'react';
+/** Nomes de tela conhecidos pelo roteador (state machine simples). */
+export type ScreenName = 'welcome' | 'about' | 'appearance' | 'doctor' | 'config' | 'home' | 'issue-detail' | 'export' | 'jobs' | 'onboarding-url' | 'onboarding-mode' | 'onboarding-login' | 'onboarding-validating' | 'onboarding-api-key' | 'onboarding-success';
+/** Tela renderizada ao abrir a TUI (base da pilha de navegação). */
+export declare const INITIAL_SCREEN: ScreenName;
+/** Entrada do registro de telas: componente renderizável + título para o breadcrumb. */
+export interface ScreenEntry {
+    /** Componente Ink renderizado para a tela. */
+    component: ComponentType;
+    /** Título legível — usado pelo breadcrumb fixo (`components/breadcrumb.tsx`). */
+    title: string;
+}
+/**
+ * Mapa tela -> entrada, consultado pelo roteador a cada troca e pelo
+ * breadcrumb. As três telas de onboarding (M2-05.1, issue #27) usam
+ * `Onboarding <separador> <passo>` como título — o mesmo separador do
+ * breadcrumb entre frames da pilha (`symbols.pointerSmall`) — para que o
+ * caminho fique auto-descritivo mesmo isolado (ex.: "Início › Onboarding › URL").
+ */
+export declare const SCREENS: Record<ScreenName, ScreenEntry>;

package/dist/surfaces/tui/screen.js

@@ -0,0 +1,51 @@
+import { AboutScreen } from './screens/about.js';
+import { AppearanceScreen } from './screens/appearance.js';
+import { ConfigScreen } from './screens/config.js';
+import { DoctorScreen } from './screens/doctor.js';
+import { ExportScreen } from './screens/export.js';
+import { HomeScreen } from './screens/home.js';
+import { IssueDetailScreen } from './screens/issue-detail.js';
+import { JobsScreen } from './screens/jobs.js';
+import { OnboardingApiKeyScreen } from './screens/onboarding/api-key.js';
+import { OnboardingLoginScreen } from './screens/onboarding/login.js';
+import { OnboardingModeScreen } from './screens/onboarding/mode.js';
+import { OnboardingSuccessScreen } from './screens/onboarding/success.js';
+import { OnboardingUrlScreen } from './screens/onboarding/url.js';
+import { OnboardingValidatingScreen } from './screens/onboarding/validating.js';
+import { WelcomeScreen } from './screens/welcome.js';
+import { symbols } from './symbols.js';
+/** Tela renderizada ao abrir a TUI (base da pilha de navegação). */
+export const INITIAL_SCREEN = 'welcome';
+/**
+ * Mapa tela -> entrada, consultado pelo roteador a cada troca e pelo
+ * breadcrumb. As três telas de onboarding (M2-05.1, issue #27) usam
+ * `Onboarding <separador> <passo>` como título — o mesmo separador do
+ * breadcrumb entre frames da pilha (`symbols.pointerSmall`) — para que o
+ * caminho fique auto-descritivo mesmo isolado (ex.: "Início › Onboarding › URL").
+ */
+export const SCREENS = {
+    welcome: { component: WelcomeScreen, title: 'Início' },
+    about: { component: AboutScreen, title: 'Atalhos' },
+    appearance: { component: AppearanceScreen, title: 'Aparência' },
+    doctor: { component: DoctorScreen, title: 'Doctor' },
+    config: { component: ConfigScreen, title: 'Configuração' },
+    home: { component: HomeScreen, title: 'Minhas issues' },
+    'issue-detail': { component: IssueDetailScreen, title: 'Detalhe da issue' },
+    export: { component: ExportScreen, title: 'Exportar' },
+    jobs: { component: JobsScreen, title: 'Jobs' },
+    'onboarding-url': { component: OnboardingUrlScreen, title: `Onboarding ${symbols.pointerSmall} URL` },
+    'onboarding-mode': { component: OnboardingModeScreen, title: `Onboarding ${symbols.pointerSmall} Modo` },
+    'onboarding-login': { component: OnboardingLoginScreen, title: `Onboarding ${symbols.pointerSmall} Login` },
+    'onboarding-validating': {
+        component: OnboardingValidatingScreen,
+        title: `Onboarding ${symbols.pointerSmall} Validando`,
+    },
+    'onboarding-api-key': {
+        component: OnboardingApiKeyScreen,
+        title: `Onboarding ${symbols.pointerSmall} api_key`,
+    },
+    'onboarding-success': {
+        component: OnboardingSuccessScreen,
+        title: `Onboarding ${symbols.pointerSmall} Sucesso`,
+    },
+};

package/dist/surfaces/tui/screens/about.d.ts

@@ -0,0 +1,2 @@
+/** Tela de atalhos: `b` (ou `Esc`, atalho global) volta para a tela anterior (ver `app.tsx`). */
+export declare function AboutScreen(): import("react").JSX.Element;

package/dist/surfaces/tui/screens/about.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Tela de atalhos da TUI — placeholder do scaffold M2-01.
+ *
+ * Existe também para provar o roteador: `?` na tela de boas-vindas navega até
+ * aqui, `b` volta — a troca de componente é o que o teste de render valida.
+ * `b` chama `pop()` (M2-04): mesmo efeito do atalho global `Esc`
+ * (`../app.tsx`), mantido aqui como atalho adicional específico desta tela.
+ * Cores vêm do tema central (M2-02, `useTheme()`) — nenhum literal de cor
+ * aqui, ver `theme.ts` para o guideline de uso de cada token.
+ */
+import { Box, Text, useInput } from 'ink';
+import { useNavigation } from '../navigation.js';
+import { useTheme } from '../theme.js';
+/** Lista de atalhos conhecidos pela TUI (crescerá conforme novas telas chegam). */
+const SHORTCUTS = [
+    { key: '?', description: 'abre esta tela' },
+    { key: 'd', description: 'abre o doctor (diagnóstico: Node, instância, credencial, conectividade)' },
+    { key: 'c', description: 'abre a configuração (instância + logout)' },
+    { key: 'a', description: 'abre a aparência (escolher a paleta de cores)' },
+    { key: 't', description: 'abre o painel de jobs da sessão (na home/detalhe)' },
+    { key: 'b / Esc', description: 'volta para a tela anterior' },
+    { key: 'q', description: 'sai da TUI' },
+];
+/** Tela de atalhos: `b` (ou `Esc`, atalho global) volta para a tela anterior (ver `app.tsx`). */
+export function AboutScreen() {
+    const { pop } = useNavigation();
+    const theme = useTheme();
+    useInput((input) => {
+        if (input === 'b') {
+            pop();
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(Text, { color: theme.primary, children: "Atalhos" }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: SHORTCUTS.map((shortcut) => (_jsxs(Text, { children: [_jsx(Text, { color: theme.accent, children: shortcut.key }), ' ', shortcut.description] }, shortcut.key))) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.muted, children: ["Pressione", ' ', _jsx(Text, { color: theme.accent, children: "b" }), ' ', "para voltar."] }) })] }));
+}

package/dist/surfaces/tui/screens/appearance.d.ts

@@ -0,0 +1,2 @@
+/** Tela seletora de paleta com preview ao vivo, salvar (Enter) e cancelar (Esc). */
+export declare function AppearanceScreen(): import("react").JSX.Element;

package/dist/surfaces/tui/screens/appearance.js

@@ -0,0 +1,74 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Tela de APARÊNCIA — seletor de paleta de cores da TUI (#190).
+ *
+ * Lista as paletas (`../palettes.ts`) com PREVIEW AO VIVO: navegar com ↑/↓
+ * aplica a paleta na hora (via `useThemeController().preview`, sem persistir),
+ * `Enter` confirma e PERSISTE (`select`), `Esc` cancela e REVERTE para a paleta
+ * original (via `useEscapeInterceptor`, que intercepta o Esc global antes do
+ * `pop()`). Cada linha mostra swatches (blocos coloridos) dos tokens daquela
+ * paleta — as cores vêm dos dados da paleta (variáveis), então nenhuma cor
+ * literal aparece aqui (varredura anti-hardcode).
+ */
+import { useCallback, useRef, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { GradientText } from '../components/gradient-text.js';
+import { useEscapeInterceptor } from '../hooks/use-escape-interceptor.js';
+import { useNavigation } from '../navigation.js';
+import { PALETTES } from '../palettes.js';
+import { symbols } from '../symbols.js';
+import { useTheme, useThemeController } from '../theme.js';
+/** Índice da paleta com um dado id (0 se não achar). */
+function indexOfPalette(id) {
+    const i = PALETTES.findIndex((p) => p.id === id);
+    return i >= 0 ? i : 0;
+}
+/** Tela seletora de paleta com preview ao vivo, salvar (Enter) e cancelar (Esc). */
+export function AppearanceScreen() {
+    const { pop } = useNavigation();
+    const theme = useTheme();
+    const controller = useThemeController();
+    const [index, setIndex] = useState(() => indexOfPalette(controller.paletteId));
+    // Paleta ORIGINAL ao abrir a tela — restaurada no cancelamento (Esc).
+    const originalRef = useRef(controller.paletteId);
+    // Refs estáveis (padrão do repo: identidade nova des/re-subscreve o useInput e
+    // perde teclas rápidas).
+    const controllerRef = useRef(controller);
+    controllerRef.current = controller;
+    const popRef = useRef(pop);
+    popRef.current = pop;
+    const indexRef = useRef(index);
+    indexRef.current = index;
+    const move = useCallback((delta) => {
+        const next = (indexRef.current + delta + PALETTES.length) % PALETTES.length;
+        setIndex(next);
+        controllerRef.current.preview(PALETTES[next].id);
+    }, []);
+    // Esc cancela: reverte para a paleta original e volta.
+    useEscapeInterceptor(true, () => {
+        controllerRef.current.preview(originalRef.current);
+        popRef.current();
+    });
+    const handleInput = useCallback((input, key) => {
+        if (key.upArrow || input === 'k') {
+            move(-1);
+            return;
+        }
+        if (key.downArrow || input === 'j') {
+            move(1);
+            return;
+        }
+        if (key.return) {
+            void controllerRef.current.select(PALETTES[indexRef.current].id);
+            popRef.current();
+        }
+    }, [move]);
+    useInput(handleInput);
+    const gradient = theme.gradient ?? [theme.primary];
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(GradientText, { colors: gradient, children: `Aparência ${symbols.pointerSmall} paleta de cores` }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: PALETTES.map((palette, i) => {
+                    const selected = i === index;
+                    const t = palette.theme;
+                    const swatches = [t.primary, t.secondary ?? t.primary, t.accent, t.success, t.warning, t.danger];
+                    return (_jsxs(Box, { children: [_jsx(Box, { width: 30, children: _jsxs(Text, { color: selected ? theme.primary : theme.muted, children: [selected ? symbols.pointer : ' ', " ", palette.label] }) }), swatches.map((color, si) => (_jsx(Text, { backgroundColor: color, children: '  ' }, si))), palette.id === originalRef.current ? (_jsxs(Text, { color: theme.muted, children: [" ", symbols.tick, " atual"] })) : null] }, palette.id));
+                }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.muted, children: [symbols.arrowUp, "/", symbols.arrowDown, " pr\u00E9-visualiza ", symbols.pointerSmall, ' ', _jsx(Text, { color: theme.accent, children: "Enter" }), ' ', "salva ", symbols.pointerSmall, ' ', _jsx(Text, { color: theme.accent, children: "Esc" }), ' ', "cancela"] }) })] }));
+}

package/dist/surfaces/tui/screens/config.d.ts

@@ -0,0 +1,2 @@
+/** Tela config: instância + credencial em uso, `l` faz logout, `b` volta. */
+export declare function ConfigScreen(): import("react").JSX.Element;

package/dist/surfaces/tui/screens/config.js

@@ -0,0 +1,82 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Tela config da TUI (M2-12, #35): mostra a instância configurada e a fonte
+ * de credencial em uso (reaproveita `use-doctor-status.js`, sem duplicar a
+ * leitura da cascata) e permite logout — `l` remove a credencial da cascata
+ * INTEIRA (keychain + arquivo, via `core.createCredentialCascade().delete()`);
+ * a variável de ambiente é somente-leitura e NÃO é apagada por aqui — se
+ * ainda resolver a credencial depois do logout, um aviso é mostrado (nunca a
+ * api_key em si, só a fonte, via `describeCredentialSource`).
+ *
+ * Depois do logout, a tela aguarda uma tecla qualquer para voltar ao início
+ * com `resetTo('welcome')` — como `config` só é alcançada a partir da
+ * `welcome` (hint da tela inicial), isso equivale a resetar a pilha de
+ * navegação para a base.
+ */
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { createCredentialCascade, describeCredentialSource } from '../../../index.js';
+import { useDoctorStatus } from '../hooks/use-doctor-status.js';
+import { useInstance } from '../instance.js';
+import { useNavigation } from '../navigation.js';
+import { symbols } from '../symbols.js';
+import { useTheme } from '../theme.js';
+/** Rótulo legível da origem da instância (#187). */
+function originLabel(origin) {
+    if (origin === 'env')
+        return 'via REDMINE_URL';
+    if (origin === 'config')
+        return 'salva neste dispositivo';
+    return '';
+}
+/** Tela config: instância + credencial em uso, `l` faz logout, `b` volta. */
+export function ConfigScreen() {
+    const { pop, resetTo } = useNavigation();
+    const theme = useTheme();
+    const status = useDoctorStatus();
+    const instance = useInstance();
+    const [logoutState, setLogoutState] = useState('idle');
+    const [envStillPresent, setEnvStillPresent] = useState(false);
+    const [errorMessage, setErrorMessage] = useState(undefined);
+    const startLogout = (instanceUrl) => {
+        setLogoutState('working');
+        void (async () => {
+            try {
+                await createCredentialCascade({ env: process.env }).delete(instanceUrl);
+                // Também remove a URL persistida (#187) para não reconfigurar sozinha no
+                // próximo boot. Isolado em try próprio: a parte CRÍTICA (a credencial) já
+                // foi removida acima, então uma falha ao limpar o settings.json NÃO deve
+                // marcar o logout como erro total — degrada silenciosamente.
+                try {
+                    await instance.clearPersisted();
+                }
+                catch {
+                    // Best-effort: a credencial já foi removida; settings.json fica para a próxima.
+                }
+                // Env é somente-leitura: se ainda resolver a credencial, avisa (sem expor a key).
+                const remaining = await describeCredentialSource(instanceUrl, { env: process.env });
+                setEnvStillPresent(remaining === 'env');
+                setLogoutState('done');
+            }
+            catch (cause) {
+                setErrorMessage(cause instanceof Error ? cause.message : String(cause));
+                setLogoutState('error');
+            }
+        })();
+    };
+    useInput((input) => {
+        if (logoutState === 'done' || logoutState === 'error') {
+            // Qualquer tecla confirma e volta ao início — pilha zerada (resetTo).
+            resetTo('welcome');
+            return;
+        }
+        if (input === 'b') {
+            pop();
+            return;
+        }
+        if (input === 'l' && logoutState === 'idle' && status.instanceUrl !== undefined) {
+            startLogout(status.instanceUrl);
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(Text, { color: theme.primary, children: "Configura\u00E7\u00E3o" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: "Inst\u00E2ncia: " }), status.instanceUrl ?? 'não configurada (defina REDMINE_URL ou faça login)', status.instanceUrl !== undefined && instance.origin !== 'none' ? (_jsxs(Text, { color: theme.muted, children: [" (", originLabel(instance.origin), ")"] })) : null] }), _jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: "Credencial: " }), status.credentialMethod] })] }), logoutState === 'working' ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.muted, children: "Removendo credencial..." }) })) : null, logoutState === 'done' ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { color: theme.success, children: [symbols.tick, " Credencial removida do keychain e do arquivo local."] }), envStillPresent ? (_jsxs(Text, { color: theme.warning, children: [symbols.warning, " REDMINE_API_KEY ainda definida no ambiente \u2014 a credencial pode continuar ativa por essa vari\u00E1vel. Remova-a manualmente para desativar por completo."] })) : null, _jsx(Text, { color: theme.muted, children: "Pressione qualquer tecla para voltar ao in\u00EDcio." })] })) : null, logoutState === 'error' ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { color: theme.danger, children: [symbols.cross, " Falha ao remover a credencial: ", errorMessage] }), _jsx(Text, { color: theme.muted, children: "Pressione qualquer tecla para voltar ao in\u00EDcio." })] })) : null, logoutState === 'idle' ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.muted, children: ["Pressione", ' ', _jsx(Text, { color: theme.accent, children: "l" }), ' ', "para fazer logout (remove a credencial salva),", ' ', _jsx(Text, { color: theme.accent, children: "b" }), ' ', "para voltar."] }) })) : null] }));
+}

package/dist/surfaces/tui/screens/doctor.d.ts

@@ -0,0 +1,2 @@
+/** Tela doctor: `b` (ou `Esc`, atalho global) volta para a tela anterior (ver `app.tsx`). */
+export declare function DoctorScreen(): import("react").JSX.Element;

package/dist/surfaces/tui/screens/doctor.js

@@ -0,0 +1,109 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Tela doctor da TUI (M2-12, #35): painel de diagnóstico — versão do Node, da
+ * ferramenta, instância configurada, método de credencial em uso (keychain /
+ * arquivo / env, sem NUNCA expor a api_key) e status de conectividade (GET
+ * leve à instância, com timeout curto). Toda a lógica assíncrona vive em
+ * `../hooks/use-doctor-status.js` (testável isoladamente, com deps
+ * injetáveis); esta tela só formata o "painel de status": uma linha por
+ * item, `symbols.tick`/`symbols.cross` coloridos por `theme.success`/
+ * `theme.danger`, rótulos em `theme.muted`.
+ *
+ * M2-16 (#39): `value` de cada `StatusRow` é truncado (`../truncate.js`) ao
+ * espaço restante do terminal — a instância (`REDMINE_URL`) é a candidata
+ * mais provável a estourar a largura, e a linha é um `<Box>` de 3 `<Text>`
+ * IRMÃS (ícone/rótulo/valor): sem truncar, um valor comprido sobrepõe as
+ * demais (o Ink não reflui `<Text>` irmãs; ver o JSDoc de `../truncate.ts`).
+ */
+import { Box, Text, useInput } from 'ink';
+import { useDoctorStatus, } from '../hooks/use-doctor-status.js';
+import { useMediaBinaries } from '../hooks/use-media-binaries.js';
+import { useTerminalWidth } from '../hooks/use-terminal-width.js';
+import { useNavigation } from '../navigation.js';
+import { symbols } from '../symbols.js';
+import { useTheme } from '../theme.js';
+import { truncate } from '../truncate.js';
+/** Largura mínima garantida ao valor de um `StatusRow`, mesmo em terminais muito estreitos. */
+const MIN_VALUE_WIDTH = 8;
+/** `paddingX={1}` dos dois lados do `Box` raiz da tela. */
+const SCREEN_PADDING_X = 2;
+/** Largura da coluna de ícone (`<Box width={2}>`, ver `StatusRow` abaixo). */
+const ICON_COLUMN_WIDTH = 2;
+/** Rótulo legível de cada fonte de credencial (nunca a api_key em si). */
+const CREDENTIAL_LABELS = {
+    keyring: 'keychain do SO',
+    file: 'arquivo local (credentials.json)',
+    env: 'variável de ambiente (REDMINE_API_KEY)',
+    none: 'nenhuma credencial encontrada',
+    checking: 'verificando...',
+};
+/** Uma linha do painel: símbolo de status opcional + rótulo em muted + valor truncado ao espaço disponível. */
+function StatusRow({ label, value, tone }) {
+    const theme = useTheme();
+    const terminalWidth = useTerminalWidth();
+    // "label: " ocupa `label.length + 2` (": ") colunas antes do valor.
+    const overhead = ICON_COLUMN_WIDTH + label.length + 2 + SCREEN_PADDING_X;
+    const valueBudget = Math.max(terminalWidth - overhead, MIN_VALUE_WIDTH);
+    return (_jsxs(Box, { children: [_jsx(Box, { width: ICON_COLUMN_WIDTH, children: tone === 'ok' ? (_jsx(Text, { color: theme.success, children: symbols.tick })) : tone === 'error' ? (_jsx(Text, { color: theme.danger, children: symbols.cross })) : null }), _jsxs(Text, { color: theme.muted, children: [label, ": "] }), _jsx(Text, { children: truncate(value, valueBudget) })] }));
+}
+/** Formata o valor + tom da linha de instância. */
+function instanceRow(status) {
+    if (status.instanceUrl === undefined) {
+        return { value: 'não configurada (defina REDMINE_URL)', tone: 'error' };
+    }
+    return { value: status.instanceUrl, tone: 'ok' };
+}
+/** Formata o valor + tom da linha de credencial. */
+function credentialRow(status) {
+    const value = CREDENTIAL_LABELS[status.credentialMethod];
+    if (status.credentialMethod === 'checking') {
+        return { value, tone: 'neutral' };
+    }
+    return { value, tone: status.credentialMethod === 'none' ? 'error' : 'ok' };
+}
+/** Formata o valor + tom da linha de conectividade a partir do status. */
+function connectivityRow(connectivity, detail) {
+    if (connectivity === 'skipped') {
+        return { value: 'não verificada (nenhuma instância configurada)', tone: 'neutral' };
+    }
+    if (connectivity === 'checking') {
+        return { value: 'verificando...', tone: 'neutral' };
+    }
+    if (connectivity === 'ok') {
+        return { value: 'conectado', tone: 'ok' };
+    }
+    return { value: `falha${detail !== undefined ? ` (${detail})` : ''}`, tone: 'error' };
+}
+/** Formata o valor + tom da linha de um binário de mídia (M3-11, #53). */
+function mediaBinaryRow(binary) {
+    if (!binary.found) {
+        return { value: `ausente — instale com: ${binary.installHint}`, tone: 'error' };
+    }
+    const version = binary.version !== undefined ? `v${binary.version}` : 'instalado';
+    const location = binary.path !== undefined ? ` (${binary.path})` : '';
+    return { value: `${version}${location}`, tone: 'ok' };
+}
+/** Seção "Binários de mídia": consome o mesmo diagnóstico do core que a CLI (#53). */
+function MediaBinariesSection() {
+    const theme = useTheme();
+    const { loading, binaries } = useMediaBinaries();
+    return (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: theme.muted, children: "Bin\u00E1rios de m\u00EDdia" }), loading ? (_jsx(StatusRow, { label: "tesseract", value: "verificando...", tone: "neutral" })) : (binaries.map((binary) => {
+                const row = mediaBinaryRow(binary);
+                return _jsx(StatusRow, { label: binary.name, value: row.value, tone: row.tone }, binary.name);
+            }))] }));
+}
+/** Tela doctor: `b` (ou `Esc`, atalho global) volta para a tela anterior (ver `app.tsx`). */
+export function DoctorScreen() {
+    const { pop } = useNavigation();
+    const theme = useTheme();
+    const status = useDoctorStatus();
+    useInput((input) => {
+        if (input === 'b') {
+            pop();
+        }
+    });
+    const instance = instanceRow(status);
+    const credential = credentialRow(status);
+    const connectivity = connectivityRow(status.connectivity, status.connectivityDetail);
+    return (_jsxs(Box, { flexGrow: 1, flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(Text, { color: theme.primary, children: "Doctor" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(StatusRow, { label: "Node", value: status.nodeVersion, tone: "neutral" }), _jsx(StatusRow, { label: "Ferramenta", value: `${status.toolName} v${status.toolVersion}`, tone: "neutral" }), _jsx(StatusRow, { label: "Inst\u00E2ncia", value: instance.value, tone: instance.tone }), _jsx(StatusRow, { label: "Credencial", value: credential.value, tone: credential.tone }), _jsx(StatusRow, { label: "Conectividade", value: connectivity.value, tone: connectivity.tone })] }), _jsx(MediaBinariesSection, {}), _jsx(Box, { flexGrow: 1 }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.muted, children: ["Pressione", ' ', _jsx(Text, { color: theme.accent, children: "b" }), ' ', "para voltar."] }) })] }));
+}

package/dist/surfaces/tui/screens/export.d.ts

@@ -0,0 +1,2 @@
+/** Tela de exportação: escolhe formato + destino, grava via o core, mostra progresso/sucesso/erro. */
+export declare function ExportScreen(): import("react").JSX.Element;