redmine-context 1.0.0

package/dist/surfaces/tui/screens/onboarding/onboarding-context.d.ts

@@ -0,0 +1,221 @@
+/**
+ * Estado local do fluxo de onboarding (M2-05.1, issue #27, evoluído na #28)
+ * URL da instância + modo de autenticação + a resolução do login, tudo
+ * compartilhado entre as telas do fluxo (`url.tsx` → `mode.tsx` →
+ * `login.tsx`/`api-key.tsx` → `validating.tsx` → `success.tsx`) sem
+ * prop-drilling — como toda tela do roteador é renderizada sem props
+ * (`../../screen.ts`), o único jeito de uma tela passar estado para a
+ * próxima é via contexto.
+ *
+ * Os callbacks de submissão (`onUrlSubmit`, `onModeSelect`, `onLoginSubmit`,
+ * `onApiKeySubmit`) são injetáveis, todos no-op por padrão — o wiring real
+ * (chamada a `loginWithPassword`/`validateApiKey` do core + persistência via
+ * `MigratingCredentialCascade`) vive em `../../hooks/use-onboarding-callbacks.ts`,
+ * o único ponto que importa o core para este fluxo (ADR-005); quem instancia
+ * o provider com os callbacks reais é `../../app.tsx`.
+ *
+ * M2-13 (issue #36) acrescenta o MODO RE-AUTH (`reAuth`/`beginReAuth`/
+ * `resolveReAuth`/`abortReAuth`): quando uma tela de dados (#29+) recebe um
+ * 401 (`RedmineAuthError`) numa chamada ao core, ela usa
+ * `../../hooks/use-auth-guard.ts` para empilhar `onboarding-login` de novo,
+ * reaproveitando este mesmo fluxo de login para o usuário reautenticar sem
+ * perder o que estava fazendo — ver o JSDoc de `useAuthGuard` para o
+ * contrato completo consumido pelas telas de dados, e `validating.tsx`/
+ * `api-key.tsx` para onde o sucesso do re-login é detectado e a operação
+ * original retomada.
+ *
+ * Fix do review do PR #119: dois 401 concorrentes (duas telas de dados, ou
+ * a mesma tela com duas chamadas em voo) podem cair em re-auth ao mesmo
+ * tempo — em vez de o segundo `beginReAuth` sobrescrever silenciosamente o
+ * primeiro (perdendo seu retry/reject para sempre), `reAuth` agora acumula
+ * uma LISTA de pendências (`pending`); uma única passagem de login bem
+ * sucedida atende todas elas (`resolveReAuth`). Esc durante o re-login
+ * (`../../app.tsx`) agora também tem uma saída explícita: `abortReAuth`
+ * rejeita todas as pendências em vez de deixar a(s) `Promise`(s) do
+ * `guard()` penduradas para sempre.
+ */
+import { type ReactNode } from 'react';
+import type { ScreenName } from '../../screen.js';
+/** Modo de autenticação escolhido na tela de modo (`mode.tsx`). */
+export type OnboardingMode = 'password' | 'api-key';
+/** Credenciais coletadas na tela de login (`login.tsx`). */
+export interface OnboardingLoginCredentials {
+    /** Usuário/login digitado (eco normal). */
+    username: string;
+    /** Senha digitada (mascarada na tela, nunca ecoada em texto). */
+    password: string;
+}
+/** Identidade mínima do usuário autenticado — nunca inclui a api_key. */
+export interface OnboardingUser {
+    /** Id numérico do usuário no Redmine. */
+    id: number;
+    /** Login do usuário. */
+    login: string;
+    /** Nome de exibição (`firstname lastname`, ou `login` se ausentes). */
+    name: string;
+}
+/**
+ * Resultado de uma tentativa de login (por senha ou api_key colada),
+ * classificado pelo que a tela de validação (`validating.tsx`) precisa
+ * decidir: mostrar a splash de sucesso, oferecer o fallback de api_key
+ * (401/2FA), ou mostrar uma mensagem de erro acionável (rede/TLS).
+ */
+export type OnboardingLoginOutcome = {
+    kind: 'success';
+    user: OnboardingUser;
+} | {
+    kind: 'auth-error';
+    message: string;
+} | {
+    kind: 'network-error';
+    message: string;
+};
+/**
+ * Uma pendência individual de re-auth (fix do review #119) — um par
+ * retry/reject correspondente a UMA chamada de `guard()`
+ * (`../../hooks/use-auth-guard.ts`) que recebeu 401. `OnboardingReAuth`
+ * acumula uma lista destas: com dois 401 concorrentes, ambas as pendências
+ * são atendidas por uma única passagem de login (`resolveReAuth`) ou
+ * canceladas juntas (`abortReAuth`).
+ */
+export interface OnboardingReAuthPending {
+    /**
+     * Reexecuta a operação original que falhou com 401. Chamado automaticamente
+     * por `resolveReAuth()` quando o login é refeito com sucesso — nenhuma tela
+     * precisa chamá-lo diretamente.
+     */
+    retry: () => void;
+    /**
+     * Rejeita a `Promise` de `guard()` correspondente a esta pendência com o
+     * motivo do abandono (tipicamente `ReAuthAbortedError`,
+     * `../../hooks/use-auth-guard.ts`). Chamado automaticamente por
+     * `abortReAuth()` — nenhuma tela precisa chamá-lo diretamente.
+     */
+    reject: (reason: Error) => void;
+}
+/**
+ * Estado de um fluxo de re-autenticação em andamento (M2-13, issue #36) —
+ * criado por `useAuthGuard` (`../../hooks/use-auth-guard.ts`) ao capturar um
+ * `RedmineAuthError` (401) numa operação de uma tela de dados (#29+).
+ */
+export interface OnboardingReAuth {
+    /**
+     * Tela que estava ativa quando o PRIMEIRO 401 deste ciclo aconteceu — a
+     * navegação volta para ela (`popTo`, `../../navigation.tsx`) assim que o
+     * re-login for concluído (com sucesso) ou abandonado (Esc). Pendências
+     * subsequentes (401 concorrentes) reaproveitam esta mesma origem — a TUI
+     * só sustenta uma tela de dados ativa por vez, então não há origem
+     * divergente de fato.
+     */
+    origin: ScreenName;
+    /**
+     * Todas as pendências acumuladas desde que o modo re-auth foi ativado
+     * (fix do review #119) — ver {@link OnboardingReAuthPending}.
+     */
+    pending: readonly OnboardingReAuthPending[];
+}
+/** Callbacks de submissão injetáveis — todos no-op por padrão (wiring real na #28, ver topo do arquivo). */
+export interface OnboardingCallbacks {
+    /** Chamado quando a URL é validada (esquema) e confirmada (Enter na tela de URL). */
+    onUrlSubmit: (url: string) => void;
+    /** Chamado quando o usuário escolhe um modo de autenticação. */
+    onModeSelect: (mode: OnboardingMode) => void;
+    /**
+     * Chamado quando o formulário de login (usuário/senha) é confirmado.
+     * Resolve para o {@link OnboardingLoginOutcome} — consumido por
+     * `validating.tsx` via `pendingLogin`.
+     */
+    onLoginSubmit: (credentials: OnboardingLoginCredentials) => Promise<OnboardingLoginOutcome>;
+    /**
+     * Chamado quando uma api_key colada é confirmada (`api-key.tsx`) — valida
+     * a key contra o Redmine ANTES de salvar.
+     */
+    onApiKeySubmit: (apiKey: string) => Promise<OnboardingLoginOutcome>;
+}
+/** Valor exposto pelo contexto de onboarding. */
+export interface OnboardingValue {
+    /** URL digitada na tela de URL — sobrevive à navegação para trás (Esc). */
+    url: string;
+    /** Atualiza a URL — ligado diretamente ao `onChange` do `TextInput` da tela de URL. */
+    setUrl: (url: string) => void;
+    /** Modo de autenticação escolhido, ou `undefined` antes da tela de modo. */
+    mode: OnboardingMode | undefined;
+    /** Atualiza o modo escolhido. */
+    setMode: (mode: OnboardingMode) => void;
+    /**
+     * Promise do login em andamento — definida por `login.tsx` ao confirmar o
+     * formulário (via `callbacks.onLoginSubmit`) e consumida por
+     * `validating.tsx`, que decide a próxima tela a partir do
+     * {@link OnboardingLoginOutcome} resolvido. `undefined` fora desse fluxo.
+     */
+    pendingLogin: Promise<OnboardingLoginOutcome> | undefined;
+    /** Atualiza `pendingLogin`. */
+    setPendingLogin: (pending: Promise<OnboardingLoginOutcome>) => void;
+    /** Usuário autenticado com sucesso — preenchido por `validating.tsx`/`api-key.tsx`, exibido em `success.tsx`. */
+    user: OnboardingUser | undefined;
+    /** Atualiza `user`. */
+    setUser: (user: OnboardingUser) => void;
+    /** Callbacks de submissão injetáveis (ver {@link OnboardingCallbacks}). */
+    callbacks: OnboardingCallbacks;
+    /**
+     * Fluxo de re-autenticação em andamento (M2-13, issue #36), ou `undefined`
+     * fora dele. Consumido por `validating.tsx`/`api-key.tsx` para desviar do
+     * caminho normal de sucesso (splash) e, em vez disso, retomar a operação de
+     * origem — ver {@link OnboardingReAuth}.
+     */
+    reAuth: OnboardingReAuth | undefined;
+    /**
+     * Inicia (ou ADICIONA a) o modo re-auth — chamado por `useAuthGuard()`
+     * (`../../hooks/use-auth-guard.ts`), nunca diretamente pelas telas.
+     *
+     * Fix do review #119: se já houver um `reAuth` ativo (401 concorrente),
+     * `pending` é apenas ACRESCENTADO à lista existente — a `origin` recebida
+     * aqui é ignorada nesse caso (a origem do ciclo já foi fixada na primeira
+     * chamada) — uma única passagem de login atende todas as pendências.
+     * Senão, ativa o modo com `origin` e uma lista iniciada só com `pending`.
+     *
+     * @returns `true` se este chamado ATIVOU o modo re-auth (nenhum estava em
+     *   andamento antes) — o chamador (`useAuthGuard`) usa isso para decidir
+     *   se deve empilhar `onboarding-login` (só na primeira vez; pendências
+     *   subsequentes reaproveitam a tela já empilhada).
+     */
+    beginReAuth: (origin: ScreenName, pending: OnboardingReAuthPending) => boolean;
+    /**
+     * Encerra o modo re-auth com SUCESSO: dispara `retry()` de TODAS as
+     * pendências acumuladas (fix do review #119 — antes só a mais recente era
+     * atendida) e limpa o estado. Chamado por `validating.tsx`/`api-key.tsx`
+     * quando o re-login resolve com `{ kind: 'success' }` enquanto `reAuth`
+     * está definido. No-op se não houver `reAuth` em andamento.
+     */
+    resolveReAuth: () => void;
+    /**
+     * Encerra o modo re-auth com ABANDONO (fix do review #119 — Esc durante o
+     * re-login, ver `../../app.tsx`): rejeita TODAS as pendências acumuladas
+     * com `reason` (tipicamente `ReAuthAbortedError`,
+     * `../../hooks/use-auth-guard.ts`) e limpa o estado — sem isso, a(s)
+     * `Promise`(s) de `guard()` ficariam penduradas para sempre. No-op se não
+     * houver `reAuth` em andamento.
+     */
+    abortReAuth: (reason: Error) => void;
+}
+/** Props do `OnboardingProvider`. */
+export interface OnboardingProviderProps {
+    /** Callbacks reais de submissão (injetados pela #28); no-op por padrão. */
+    callbacks?: OnboardingCallbacks;
+    children: ReactNode;
+}
+/**
+ * Provider do contexto de onboarding — instanciado uma vez em `../../app.tsx`,
+ * envolvendo toda a árvore de telas (não só as de onboarding), para que
+ * `useOnboarding()` esteja sempre disponível quando o roteador troca para
+ * qualquer tela `onboarding-*`.
+ */
+export declare function OnboardingProvider({ callbacks, children }: OnboardingProviderProps): import("react").JSX.Element;
+/**
+ * Hook de onboarding consumido pelas telas `url.tsx`/`mode.tsx`/`login.tsx`/
+ * `api-key.tsx`/`validating.tsx`/`success.tsx`.
+ *
+ * @throws {Error} Se chamado fora de um `<OnboardingProvider>` — indica erro
+ *   de composição (tela renderizada sem passar pelo roteador).
+ */
+export declare function useOnboarding(): OnboardingValue;

package/dist/surfaces/tui/screens/onboarding/onboarding-context.js

@@ -0,0 +1,131 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Estado local do fluxo de onboarding (M2-05.1, issue #27, evoluído na #28)
+ * URL da instância + modo de autenticação + a resolução do login, tudo
+ * compartilhado entre as telas do fluxo (`url.tsx` → `mode.tsx` →
+ * `login.tsx`/`api-key.tsx` → `validating.tsx` → `success.tsx`) sem
+ * prop-drilling — como toda tela do roteador é renderizada sem props
+ * (`../../screen.ts`), o único jeito de uma tela passar estado para a
+ * próxima é via contexto.
+ *
+ * Os callbacks de submissão (`onUrlSubmit`, `onModeSelect`, `onLoginSubmit`,
+ * `onApiKeySubmit`) são injetáveis, todos no-op por padrão — o wiring real
+ * (chamada a `loginWithPassword`/`validateApiKey` do core + persistência via
+ * `MigratingCredentialCascade`) vive em `../../hooks/use-onboarding-callbacks.ts`,
+ * o único ponto que importa o core para este fluxo (ADR-005); quem instancia
+ * o provider com os callbacks reais é `../../app.tsx`.
+ *
+ * M2-13 (issue #36) acrescenta o MODO RE-AUTH (`reAuth`/`beginReAuth`/
+ * `resolveReAuth`/`abortReAuth`): quando uma tela de dados (#29+) recebe um
+ * 401 (`RedmineAuthError`) numa chamada ao core, ela usa
+ * `../../hooks/use-auth-guard.ts` para empilhar `onboarding-login` de novo,
+ * reaproveitando este mesmo fluxo de login para o usuário reautenticar sem
+ * perder o que estava fazendo — ver o JSDoc de `useAuthGuard` para o
+ * contrato completo consumido pelas telas de dados, e `validating.tsx`/
+ * `api-key.tsx` para onde o sucesso do re-login é detectado e a operação
+ * original retomada.
+ *
+ * Fix do review do PR #119: dois 401 concorrentes (duas telas de dados, ou
+ * a mesma tela com duas chamadas em voo) podem cair em re-auth ao mesmo
+ * tempo — em vez de o segundo `beginReAuth` sobrescrever silenciosamente o
+ * primeiro (perdendo seu retry/reject para sempre), `reAuth` agora acumula
+ * uma LISTA de pendências (`pending`); uma única passagem de login bem
+ * sucedida atende todas elas (`resolveReAuth`). Esc durante o re-login
+ * (`../../app.tsx`) agora também tem uma saída explícita: `abortReAuth`
+ * rejeita todas as pendências em vez de deixar a(s) `Promise`(s) do
+ * `guard()` penduradas para sempre.
+ */
+import { createContext, useCallback, useContext, useRef, useState } from 'react';
+/** Callbacks padrão: no-op — usados quando `<OnboardingProvider>` não recebe `callbacks`. */
+const NOOP_CALLBACKS = {
+    onUrlSubmit: () => undefined,
+    onModeSelect: () => undefined,
+    onLoginSubmit: () => Promise.resolve({ kind: 'network-error', message: 'onLoginSubmit não configurado.' }),
+    onApiKeySubmit: () => Promise.resolve({ kind: 'network-error', message: 'onApiKeySubmit não configurado.' }),
+};
+const OnboardingContext = createContext(undefined);
+/**
+ * Provider do contexto de onboarding — instanciado uma vez em `../../app.tsx`,
+ * envolvendo toda a árvore de telas (não só as de onboarding), para que
+ * `useOnboarding()` esteja sempre disponível quando o roteador troca para
+ * qualquer tela `onboarding-*`.
+ */
+export function OnboardingProvider({ callbacks = NOOP_CALLBACKS, children }) {
+    const [url, setUrl] = useState('');
+    const [mode, setMode] = useState(undefined);
+    const [pendingLogin, setPendingLogin] = useState(undefined);
+    const [user, setUser] = useState(undefined);
+    const [reAuth, setReAuth] = useState(undefined);
+    // Ref espelhando `reAuth` (fix do review #119): `beginReAuth` precisa
+    // decidir SINCRONAMENTE (para devolver o `boolean` de ativação ao
+    // chamador) se já existe um ciclo em andamento, mas o setter funcional do
+    // `useState` só executa o callback no próximo render — não dá pra
+    // confiar nele para essa decisão. A ref é a única fonte de verdade
+    // síncrona; `setReAuth` continua sendo chamado em paralelo só para
+    // provocar o re-render de quem lê `reAuth` do contexto.
+    const reAuthRef = useRef(undefined);
+    // Handlers estáveis (useCallback) — mesmo padrão dos demais hooks da TUI
+    // (ver `../../hooks/use-exit-guard.ts`): identidade fixa evita
+    // re-subscrições desnecessárias em quem os usa como dependência de efeito.
+    const beginReAuth = useCallback((origin, pending) => {
+        const current = reAuthRef.current;
+        if (current !== undefined) {
+            // Já em andamento (401 concorrente) — apenas acrescenta à lista,
+            // mantendo a origem original.
+            const next = { origin: current.origin, pending: [...current.pending, pending] };
+            reAuthRef.current = next;
+            setReAuth(next);
+            return false;
+        }
+        const next = { origin, pending: [pending] };
+        reAuthRef.current = next;
+        setReAuth(next);
+        return true;
+    }, []);
+    const resolveReAuth = useCallback(() => {
+        const current = reAuthRef.current;
+        reAuthRef.current = undefined;
+        setReAuth(undefined);
+        current?.pending.forEach((item) => {
+            item.retry();
+        });
+    }, []);
+    const abortReAuth = useCallback((reason) => {
+        const current = reAuthRef.current;
+        reAuthRef.current = undefined;
+        setReAuth(undefined);
+        current?.pending.forEach((item) => {
+            item.reject(reason);
+        });
+    }, []);
+    const value = {
+        url,
+        setUrl,
+        mode,
+        setMode,
+        pendingLogin,
+        setPendingLogin,
+        user,
+        setUser,
+        callbacks,
+        reAuth,
+        beginReAuth,
+        resolveReAuth,
+        abortReAuth,
+    };
+    return _jsx(OnboardingContext.Provider, { value: value, children: children });
+}
+/**
+ * Hook de onboarding consumido pelas telas `url.tsx`/`mode.tsx`/`login.tsx`/
+ * `api-key.tsx`/`validating.tsx`/`success.tsx`.
+ *
+ * @throws {Error} Se chamado fora de um `<OnboardingProvider>` — indica erro
+ *   de composição (tela renderizada sem passar pelo roteador).
+ */
+export function useOnboarding() {
+    const value = useContext(OnboardingContext);
+    if (value === undefined) {
+        throw new Error('useOnboarding() usado fora de <OnboardingProvider>.');
+    }
+    return value;
+}

package/dist/surfaces/tui/screens/onboarding/success.d.ts

@@ -0,0 +1,2 @@
+/** Tela de onboarding: sucesso — `Enter` segue para a home (pilha zerada via `resetTo`). */
+export declare function OnboardingSuccessScreen(): import("react").JSX.Element;

package/dist/surfaces/tui/screens/onboarding/success.js

@@ -0,0 +1,41 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Tela de onboarding: sucesso (#28) — splash comemorativa mostrando o usuário
+ * autenticado (`OnboardingContext.user`, preenchido por `validating.tsx`/
+ * `api-key.tsx` ao concluir com sucesso).
+ *
+ * Único lugar da TUI onde um capricho visual mais forte é permitido pelo
+ * guideline do tema (`../../theme.tsx`): borda DUPLA + `theme.accent` em
+ * destaque, para marcar visualmente a conclusão do fluxo — em qualquer outra
+ * tela isso seria decoração em excesso (o guideline pede moderação com
+ * `accent`), mas aqui é o clímax de um fluxo que só acontece uma vez por
+ * instância configurada.
+ *
+ * `Enter` segue para a home (M2-06, #29) com a PILHA ZERADA (`resetTo`) —
+ * sem telas do onboarding sobrando por baixo para um Esc alcançar. A home é
+ * o destino pós-onboarding: lista "minhas issues" com a credencial recém
+ * salva.
+ */
+import { Box, Text, useInput } from 'ink';
+import { useCallback, useRef } from 'react';
+import { useNavigation } from '../../navigation.js';
+import { symbols } from '../../symbols.js';
+import { useTheme } from '../../theme.js';
+import { useOnboarding } from './onboarding-context.js';
+/** Tela de onboarding: sucesso — `Enter` segue para a home (pilha zerada via `resetTo`). */
+export function OnboardingSuccessScreen() {
+    const theme = useTheme();
+    const { resetTo } = useNavigation();
+    const { user } = useOnboarding();
+    // Handler ESTÁVEL (useCallback + refs, padrão do repo — ver text-input.tsx/app.tsx):
+    // identidade nova a cada render des/re-subscreve o useInput e pode perder um Enter rápido.
+    const resetToRef = useRef(resetTo);
+    resetToRef.current = resetTo;
+    const handleInput = useCallback((_input, key) => {
+        if (key.return) {
+            resetToRef.current('home');
+        }
+    }, []);
+    useInput(handleInput);
+    return (_jsxs(Box, { flexDirection: "column", alignItems: "center", paddingX: 3, paddingY: 1, borderStyle: "double", borderColor: theme.accent, children: [_jsxs(Text, { color: theme.accent, children: [symbols.star, " Login conclu\u00EDdo com sucesso! ", symbols.star] }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.primary, children: [symbols.tick, " Bem-vindo", user !== undefined ? `, ${user.name}` : '', "!"] }) }), user !== undefined ? (_jsx(Box, { children: _jsxs(Text, { color: theme.muted, children: ["Usu\u00E1rio: ", user.login] }) })) : null, _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.muted, children: ["Pressione", ' ', _jsx(Text, { color: theme.accent, children: "Enter" }), ' ', "para come\u00E7ar."] }) })] }));
+}

package/dist/surfaces/tui/screens/onboarding/url.d.ts

@@ -0,0 +1,24 @@
+/** Resultado da classificação de uma URL digitada (ver {@link classifyUrl}). */
+export type UrlClassification = {
+    kind: 'valid';
+} | {
+    kind: 'insecure-allowed';
+} | {
+    kind: 'insecure-blocked';
+} | {
+    kind: 'invalid';
+};
+/**
+ * Classifica a URL digitada pelo esquema (`https://`/`http://`) — parsing
+ * completo da URL fica para a #28.
+ *
+ * @param value - Valor bruto do campo (ainda não `trim()`ado).
+ * @param insecureEnvSet - `true` quando `REDMINE_INSECURE` está definida no
+ *   ambiente (ver {@link isInsecureEnvSet}).
+ * @example
+ * classifyUrl('https://redmine.example', false); // { kind: 'valid' }
+ * classifyUrl('http://redmine.example', false); // { kind: 'insecure-blocked' }
+ */
+export declare function classifyUrl(value: string, insecureEnvSet: boolean): UrlClassification;
+/** Tela de onboarding: URL — Enter confirma (avança para `onboarding-mode`), Esc volta (atalho global, ver `../../app.tsx`). */
+export declare function OnboardingUrlScreen(): import("react").JSX.Element;

package/dist/surfaces/tui/screens/onboarding/url.js

@@ -0,0 +1,84 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Tela de onboarding 1/3: URL da instância Redmine (M2-05.1, issue #27).
+ *
+ * Valida apenas o ESQUEMA da URL ao confirmar (Enter) — a validação real
+ * (URL bem formada, instância alcançável) fica para a #28, que chama o core
+ * via os callbacks injetáveis do `OnboardingContext`. `http://` só é aceito
+ * quando `REDMINE_INSECURE` já está definida no ambiente do processo (`1`
+ * ou `true`, case-insensitive — mesma convenção de `../../../mcp/server.ts`
+ * e da flag `--insecure` da CLI) — e, mesmo aceito, dispara um aviso em
+ * `theme.warning` porque o tráfego (incluindo a api_key futura) não é
+ * criptografado.
+ */
+import { Box, Text } from 'ink';
+import { useState } from 'react';
+import { TextInput } from '../../components/text-input.js';
+import { useNavigation } from '../../navigation.js';
+import { symbols } from '../../symbols.js';
+import { useTheme } from '../../theme.js';
+import { useOnboarding } from './onboarding-context.js';
+/**
+ * Interpreta `REDMINE_INSECURE` (`1`/`true`, case-insensitive) — mesma
+ * convenção usada pelo MCP (`../../../mcp/server.ts`).
+ */
+function isInsecureEnvSet(env) {
+    const raw = env.REDMINE_INSECURE;
+    return raw !== undefined && /^(1|true)$/i.test(raw.trim());
+}
+/**
+ * Classifica a URL digitada pelo esquema (`https://`/`http://`) — parsing
+ * completo da URL fica para a #28.
+ *
+ * @param value - Valor bruto do campo (ainda não `trim()`ado).
+ * @param insecureEnvSet - `true` quando `REDMINE_INSECURE` está definida no
+ *   ambiente (ver {@link isInsecureEnvSet}).
+ * @example
+ * classifyUrl('https://redmine.example', false); // { kind: 'valid' }
+ * classifyUrl('http://redmine.example', false); // { kind: 'insecure-blocked' }
+ */
+export function classifyUrl(value, insecureEnvSet) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith('https://') && trimmed.length > 'https://'.length) {
+        return { kind: 'valid' };
+    }
+    if (trimmed.startsWith('http://') && trimmed.length > 'http://'.length) {
+        return insecureEnvSet ? { kind: 'insecure-allowed' } : { kind: 'insecure-blocked' };
+    }
+    return { kind: 'invalid' };
+}
+/** Tela de onboarding: URL — Enter confirma (avança para `onboarding-mode`), Esc volta (atalho global, ver `../../app.tsx`). */
+export function OnboardingUrlScreen() {
+    const { push } = useNavigation();
+    const theme = useTheme();
+    const { url, setUrl, callbacks } = useOnboarding();
+    const [feedback, setFeedback] = useState(undefined);
+    function handleSubmit(value) {
+        const classification = classifyUrl(value, isInsecureEnvSet(process.env));
+        const trimmed = value.trim();
+        if (classification.kind === 'valid' || classification.kind === 'insecure-allowed') {
+            setFeedback(classification.kind === 'insecure-allowed'
+                ? {
+                    level: 'warning',
+                    message: 'AVISO: conexão insegura (http://) habilitada via REDMINE_INSECURE — o tráfego não é criptografado.',
+                }
+                : undefined);
+            setUrl(trimmed);
+            callbacks.onUrlSubmit(trimmed);
+            push('onboarding-mode');
+            return;
+        }
+        if (classification.kind === 'insecure-blocked') {
+            setFeedback({
+                level: 'danger',
+                message: 'Conexão http:// recusada: TLS é obrigatório. Use https:// ou defina REDMINE_INSECURE (não recomendado) para permitir.',
+            });
+            return;
+        }
+        setFeedback({
+            level: 'danger',
+            message: 'Informe uma URL começando com https:// (ex.: https://redmine.example).',
+        });
+    }
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, borderStyle: "round", borderColor: theme.border, children: [_jsx(Text, { color: theme.primary, children: "URL do Redmine" }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: theme.muted, children: [symbols.pointer, " "] }), _jsx(TextInput, { value: url, onChange: setUrl, onSubmit: handleSubmit, placeholder: "https://redmine.example" })] }), feedback !== undefined ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: feedback.level === 'danger' ? theme.danger : theme.warning, children: [feedback.level === 'danger' ? symbols.cross : symbols.warning, " ", feedback.message] }) })) : null, _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.muted, children: ["Pressione", ' ', _jsx(Text, { color: theme.accent, children: "Enter" }), ' ', "para confirmar,", ' ', _jsx(Text, { color: theme.accent, children: "Esc" }), ' ', "para voltar."] }) })] }));
+}

package/dist/surfaces/tui/screens/onboarding/validating.d.ts

@@ -0,0 +1 @@
+export declare function OnboardingValidatingScreen(): import("react").JSX.Element;

package/dist/surfaces/tui/screens/onboarding/validating.js

@@ -0,0 +1,86 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Tela de onboarding: validando o login por senha (#28) — consome a
+ * `pendingLogin` (promise) guardada em `OnboardingContext` por `login.tsx` ao
+ * confirmar o formulário, mostra um spinner enquanto ela resolve, e decide a
+ * próxima tela a partir do `OnboardingLoginOutcome`:
+ *
+ * - `success` → grava `user` no contexto e segue para a splash (`replace`,
+ *   troca o topo da pilha — a tela de validação é transitória, não faz
+ *   sentido voltar a ela).
+ * - `auth-error` (401/2FA, ADR-003) → oferece o fallback de colar api_key
+ *   (`replace('onboarding-api-key')`).
+ * - `network-error` (rede/TLS) → fica nesta tela mostrando a mensagem em
+ *   `theme.danger`, sem stack, com a próxima ação sugerida; `Esc` (atalho
+ *   global, `../../app.tsx`) volta para o formulário de login para tentar de
+ *   novo.
+ *
+ * M2-13 (issue #36): quando o sucesso acontece com um fluxo de re-auth em
+ * andamento (`OnboardingContext.reAuth`, empilhado por
+ * `../../hooks/use-auth-guard.ts` após um 401 numa tela de dados), o caminho
+ * de sucesso é DIFERENTE — em vez da splash, a navegação volta à tela de
+ * origem (`popTo`) e a operação original é retomada automaticamente
+ * (`resolveReAuth()`, que dispara o `retry` guardado no contexto).
+ */
+import { Box, Text } from 'ink';
+import { useEffect, useState } from 'react';
+import { Spinner } from '../../components/spinner.js';
+import { useNavigation } from '../../navigation.js';
+import { symbols } from '../../symbols.js';
+import { useTheme } from '../../theme.js';
+import { useOnboarding } from './onboarding-context.js';
+/** Sugestão de próxima ação para erros de rede/TLS (ex.: CA interna). */
+const NETWORK_ERROR_HINT = 'Se a instância usa uma CA interna, configure NODE_EXTRA_CA_CERTS apontando para o certificado. Verifique também a URL e a conexão de rede.';
+export function OnboardingValidatingScreen() {
+    const theme = useTheme();
+    const { replace, popTo } = useNavigation();
+    const { pendingLogin, setUser, reAuth, resolveReAuth } = useOnboarding();
+    const [networkError, setNetworkError] = useState(undefined);
+    useEffect(() => {
+        if (pendingLogin === undefined) {
+            return;
+        }
+        let cancelled = false;
+        pendingLogin
+            .then((outcome) => {
+            if (cancelled) {
+                return;
+            }
+            if (outcome.kind === 'success') {
+                setUser(outcome.user);
+                if (reAuth !== undefined) {
+                    // M2-13 (#36): volta à tela de origem e retoma a operação
+                    // original — não passa pela splash (esse re-login é invisível
+                    // para o fluxo da tela de dados que o disparou).
+                    popTo(reAuth.origin);
+                    resolveReAuth();
+                    return;
+                }
+                replace('onboarding-success');
+                return;
+            }
+            if (outcome.kind === 'auth-error') {
+                replace('onboarding-api-key');
+                return;
+            }
+            setNetworkError(outcome.message);
+        })
+            .catch((cause) => {
+            if (cancelled) {
+                return;
+            }
+            // Reason: defesa em profundidade — `onLoginSubmit` (ver
+            // `../../hooks/use-onboarding-callbacks.ts`) já converte qualquer
+            // falha num `OnboardingLoginOutcome` resolvido, mas um callback
+            // injetado incorretamente (ex.: em teste) pode rejeitar a promise.
+            setNetworkError(cause instanceof Error ? cause.message : String(cause));
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [pendingLogin, replace, popTo, reAuth, resolveReAuth, setUser]);
+    if (networkError !== undefined) {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, borderStyle: "round", borderColor: theme.border, children: [_jsxs(Text, { color: theme.danger, children: [symbols.cross, " N\u00E3o foi poss\u00EDvel entrar"] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.danger, children: networkError }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.danger, children: NETWORK_ERROR_HINT }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.muted, children: ["Pressione", ' ', _jsx(Text, { color: theme.accent, children: "Esc" }), ' ', "para voltar e tentar novamente."] }) })] }));
+    }
+    return (_jsx(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, borderStyle: "round", borderColor: theme.border, children: _jsxs(Text, { color: theme.primary, children: [_jsx(Spinner, {}), " Validando credenciais..."] }) }));
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Tela inicial do roteador: `Enter` vai para `home` (credencial já salva) ou
+ * inicia o onboarding (M2-05.1), `?` atalhos, `d` doctor, `c` config, `q`
+ * sai (ver `app.tsx`).
+ */
+export declare function WelcomeScreen(): import("react").JSX.Element;