redmine-context 1.0.0

package/dist/surfaces/cli/commands.js

@@ -0,0 +1,262 @@
+/**
+ * Handlers dos comandos do CLI (M1-11): `issue` e `login`.
+ *
+ * Consomem EXCLUSIVAMENTE a superfície pública do core (`../../index.js`,
+ * fronteira do ADR-005) — a orquestração `fetchIssueBundle`, o `loginWithPassword`
+ * e a cascata de credenciais. Cada handler devolve o exit code do processo; o
+ * mapeamento status→código vive em {@link exitCodeForError} e é documentado no
+ * `--help`.
+ */
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import * as core from '../../index.js';
+/** Exit codes do CLI (documentados no `--help`). */
+export const EXIT = {
+    /** Erro genérico ou uso inválido. */
+    GENERIC: 1,
+    /** Falha de autenticação ou credencial ausente. */
+    AUTH: 2,
+    /** Erro de rede ou HTTP. */
+    NETWORK: 3,
+    /** Issue inexistente. */
+    NOT_FOUND: 4,
+};
+/** Extrai uma mensagem legível de um erro desconhecido. */
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Mapeia um erro para o exit code do CLI.
+ *
+ * Ordem importa: os erros específicos (404, 401) estendem `RedmineHttpError` e
+ * precisam ser testados antes do genérico HTTP. Erros de rede (sem status) são
+ * detectados pela mensagem do client e também caem em {@link EXIT.NETWORK}.
+ *
+ * @param error - Erro capturado durante a operação.
+ * @returns O exit code correspondente.
+ */
+export function exitCodeForError(error) {
+    if (error instanceof core.RedmineNotFoundError)
+        return EXIT.NOT_FOUND;
+    if (error instanceof core.RedmineAuthError)
+        return EXIT.AUTH;
+    if (error instanceof core.RedmineLoginError)
+        return EXIT.AUTH;
+    if (error instanceof core.RedmineHttpError)
+        return EXIT.NETWORK;
+    if (error instanceof Error && /falha de rede|network|fetch failed|econn|enotfound|etimedout/i.test(error.message)) {
+        return EXIT.NETWORK;
+    }
+    return EXIT.GENERIC;
+}
+/** Lê uma flag com valor string, ou `undefined` se ausente/booleana. */
+function stringFlag(parsed, name) {
+    const value = parsed.flags.get(name);
+    return typeof value === 'string' ? value : undefined;
+}
+/**
+ * Comando `issue <id>`: resolve credencial pela cascata, empacota e emite o
+ * bundle (stdout ou `--out <dir>`), com progresso em stderr.
+ *
+ * @param parsed - Argumentos parseados (posicional `<id>` + flags).
+ * @param deps - Dependências injetáveis (I/O, env).
+ * @returns Exit code do processo.
+ */
+export async function runIssue(parsed, deps) {
+    const idRaw = parsed.positionals[1];
+    const issueId = Number(idRaw);
+    if (idRaw === undefined || !Number.isInteger(issueId) || issueId <= 0) {
+        deps.stderr(`Id de issue inválido: ${idRaw ?? '(ausente)'}. Uso: redmine-context issue <id>\n`);
+        return EXIT.GENERIC;
+    }
+    // Instância: --url → REDMINE_URL → URL persistida no login (#187).
+    const persistedUrl = deps.settings ? await deps.settings.getInstanceUrl() : undefined;
+    const resolved = core.resolveInstanceUrl({
+        flagUrl: stringFlag(parsed, 'url'),
+        envUrl: deps.env.REDMINE_URL,
+        persistedUrl,
+    });
+    if (resolved === undefined) {
+        deps.stderr('Instância não configurada. Use --url <url>, defina REDMINE_URL, ou rode `redmine-context login`.\n');
+        return EXIT.GENERIC;
+    }
+    const baseUrl = resolved.url;
+    const insecure = parsed.flags.get('insecure') === true;
+    let apiKey;
+    try {
+        apiKey = await core.resolveApiKey(baseUrl, {
+            env: deps.env,
+            // SEGURANÇA (#187): se a URL veio do settings.json persistido (origem
+            // `config`, fonte mutável), NÃO usar a REDMINE_API_KEY instance-agnóstica —
+            // só credencial pinada à instância (keychain/arquivo). URL de --url/env é
+            // confiável (mesma invocação), então mantém o fallback de ambiente.
+            allowEnvFallback: resolved.origin !== 'config',
+            logger: { warn: (message) => deps.stderr(`${message}\n`) },
+        });
+    }
+    catch (error) {
+        deps.stderr(`${messageOf(error)}\n`);
+        return exitCodeForError(error);
+    }
+    if (apiKey === undefined) {
+        deps.stderr(`Nenhuma credencial encontrada para ${baseUrl}.\nRode: redmine-context login\n`);
+        return EXIT.AUTH;
+    }
+    const format = parsed.flags.get('json') === true ? 'json' : 'md';
+    const outDir = stringFlag(parsed, 'out');
+    // --extract liga a extração de texto dos anexos (OCR) no bundle (M3-13).
+    const extractAttachments = parsed.flags.get('extract') === true;
+    try {
+        let content;
+        for await (const event of core.fetchIssueBundle({
+            baseUrl,
+            apiKey,
+            issueId,
+            format,
+            toolVersion: core.TOOL_VERSION,
+            insecure,
+            extractAttachments,
+        })) {
+            if (event.kind === 'progress') {
+                deps.stderr(`... ${event.message}\n`);
+            }
+            else {
+                content = event.value.content;
+            }
+        }
+        if (content === undefined) {
+            deps.stderr('Operação não produziu um bundle.\n');
+            return EXIT.GENERIC;
+        }
+        if (outDir !== undefined) {
+            const ext = format === 'json' ? 'json' : 'md';
+            const filePath = join(outDir, `${issueId}.${ext}`);
+            await mkdir(outDir, { recursive: true });
+            await writeFile(filePath, content, 'utf8');
+            deps.stderr(`Bundle gravado em ${filePath}\n`);
+        }
+        else {
+            deps.stdout(content);
+        }
+        return 0;
+    }
+    catch (error) {
+        deps.stderr(`${messageOf(error)}\n`);
+        return exitCodeForError(error);
+    }
+}
+/**
+ * Comando `doctor`: diagnostica os binários de mídia (hoje o `tesseract`) e
+ * imprime um relatório em TEXTO PURO no stdout. Degrada naturalmente em
+ * `NO_COLOR`/não-TTY (não emite cor/ANSI). Exit 0 se todos presentes, 1 se
+ * faltar algum — o exit code deixa o resultado programável em scripts.
+ *
+ * @param _parsed - Argumentos parseados (o comando não usa flags hoje).
+ * @param deps - Dependências injetáveis (I/O).
+ * @returns Exit code do processo (0 = tudo ok, 1 = binário faltando).
+ */
+export async function runDoctor(_parsed, deps) {
+    const diagnoses = await core.diagnoseBinaries();
+    deps.stdout('Binários de mídia:\n');
+    let allPresent = true;
+    for (const binary of diagnoses) {
+        if (binary.found) {
+            const version = binary.version !== undefined ? ` v${binary.version}` : '';
+            const location = binary.path !== undefined ? ` (${binary.path})` : '';
+            deps.stdout(`  [ok] ${binary.name}${version}${location}\n`);
+        }
+        else {
+            allPresent = false;
+            deps.stdout(`  [faltando] ${binary.name} — instale com: ${binary.installHint}\n`);
+        }
+    }
+    return allPresent ? 0 : EXIT.GENERIC;
+}
+/**
+ * Descobre a api_key interativamente: login por senha e, no fallback de 2FA
+ * (ou senha inválida), orienta colar a api_key.
+ *
+ * @param baseUrl - URL da instância Redmine.
+ * @param insecure - Permite `http://` sem TLS.
+ * @param deps - Dependências injetáveis (prompts, I/O).
+ * @returns A api_key resolvida.
+ * @throws {RedmineLoginError | RedmineAuthError | Error} Se o login falhar sem
+ *   fallback utilizável.
+ */
+async function resolveKeyInteractively(baseUrl, insecure, deps) {
+    const username = (await deps.prompt('Usuário: ')).trim();
+    const password = await deps.promptPassword('Senha: ');
+    try {
+        const result = await core.loginWithPassword({ baseUrl, username, password, insecure });
+        return result.apiKey;
+    }
+    catch (error) {
+        if (error instanceof core.RedmineAuthError) {
+            deps.stderr(`${messageOf(error)}\n`);
+            deps.stderr('Cole sua api_key para concluir o login (conta com 2FA ou senha inválida):\n');
+            const pasted = (await deps.promptPassword('api_key: ')).trim();
+            if (pasted.length === 0) {
+                throw error;
+            }
+            return pasted;
+        }
+        throw error;
+    }
+}
+/**
+ * Comando `login`: autentica (senha ou `--api-key`) e salva a api_key na
+ * cascata para a instância informada.
+ *
+ * @param parsed - Argumentos parseados (flags `--url`, `--api-key`, `--insecure`).
+ * @param deps - Dependências injetáveis (prompts, I/O, env).
+ * @returns Exit code do processo.
+ */
+export async function runLogin(parsed, deps) {
+    const insecure = parsed.flags.get('insecure') === true;
+    // Mesma precedência do resto (--url → REDMINE_URL → persistida), tratando
+    // string vazia como ausente via o resolvedor único (#187).
+    const persistedUrl = deps.settings ? await deps.settings.getInstanceUrl() : undefined;
+    let baseUrl = core.resolveInstanceUrl({
+        flagUrl: stringFlag(parsed, 'url'),
+        envUrl: deps.env.REDMINE_URL,
+        persistedUrl,
+    })?.url;
+    if (baseUrl === undefined || baseUrl.length === 0) {
+        baseUrl = (await deps.prompt('URL do Redmine: ')).trim();
+    }
+    if (baseUrl.length === 0) {
+        deps.stderr('URL do Redmine é obrigatória.\n');
+        return EXIT.GENERIC;
+    }
+    const directKey = stringFlag(parsed, 'api-key');
+    try {
+        const apiKey = directKey !== undefined && directKey.length > 0
+            ? directKey
+            : await resolveKeyInteractively(baseUrl, insecure, deps);
+        if (apiKey.length === 0) {
+            deps.stderr('api_key vazia; login abortado.\n');
+            return EXIT.AUTH;
+        }
+        // Persiste preferindo o keychain do SO (fallback arquivo se indisponível).
+        await core
+            .createCredentialCascade({
+            env: deps.env,
+            logger: { warn: (message) => deps.stderr(`${message}\n`) },
+        })
+            .set(baseUrl, apiKey);
+        // Persiste a instância (#187) para que TUI/CLI/MCP não dependam de REDMINE_URL.
+        // Falha ao salvar a instância NÃO invalida o login (a credencial já foi salva).
+        try {
+            await deps.settings?.setInstanceUrl(baseUrl);
+        }
+        catch (error) {
+            deps.stderr(`aviso: não foi possível salvar a instância padrão: ${messageOf(error)}\n`);
+        }
+        deps.stderr(`Credencial salva para ${baseUrl}.\n`);
+        return 0;
+    }
+    catch (error) {
+        deps.stderr(`${messageOf(error)}\n`);
+        return exitCodeForError(error);
+    }
+}

package/dist/surfaces/cli/main.d.ts

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+/**
+ * Entry point do CLI `redmine-context` (M1-11).
+ *
+ * Superfície fina (ADR-005): faz parse manual de `argv` — sem framework de CLI,
+ * são apenas dois comandos —, despacha para os handlers em `./commands.js` e
+ * devolve o exit code. Progresso vai para stderr; o bundle vai para stdout.
+ *
+ * O core é consumido apenas pela superfície pública (`../../index.js`); nenhum
+ * módulo interno é importado aqui (regra eslint `no-restricted-imports`).
+ */
+import type { ParsedArgs, RunDeps } from './types.js';
+/**
+ * Parse manual de `argv` (após o nome do comando).
+ *
+ * Reconhece `--flag valor` para as flags de {@link VALUE_FLAGS} e `--flag`/`-h`
+ * como booleanas; o restante são posicionais.
+ *
+ * @param argv - Argumentos após `node main.js`.
+ * @returns Posicionais e flags. Ver {@link ParsedArgs}.
+ */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/**
+ * Ponto de entrada testável: faz parse, despacha o comando e devolve o exit code.
+ *
+ * @param argv - Argumentos após `node main.js` (ex.: `process.argv.slice(2)`).
+ * @param overrides - Dependências injetáveis (I/O, prompts, env) para testes.
+ * @returns O exit code do processo (0 = sucesso).
+ * @example
+ * const code = await run(['issue', '42', '--url', 'https://redmine.example']);
+ */
+export declare function run(argv: string[], overrides?: Partial<RunDeps>): Promise<number>;

package/dist/surfaces/cli/main.js

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+/**
+ * Entry point do CLI `redmine-context` (M1-11).
+ *
+ * Superfície fina (ADR-005): faz parse manual de `argv` — sem framework de CLI,
+ * são apenas dois comandos —, despacha para os handlers em `./commands.js` e
+ * devolve o exit code. Progresso vai para stderr; o bundle vai para stdout.
+ *
+ * O core é consumido apenas pela superfície pública (`../../index.js`); nenhum
+ * módulo interno é importado aqui (regra eslint `no-restricted-imports`).
+ */
+import { realpathSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import { runDoctor, runIssue, runLogin } from './commands.js';
+import { createPromptSession } from './prompts.js';
+import { shouldRenderTui } from './tty.js';
+import { TOOL_VERSION, defaultSettingsStore } from '../../index.js';
+import { runStdioServer } from '../mcp/server.js';
+import { runTui } from '../tui/index.js';
+/** Flags que consomem o próximo token como valor (as demais são booleanas). */
+const VALUE_FLAGS = new Set(['out', 'url', 'api-key']);
+/** Texto do `--help` — limpo, sem referências a ferramentas de IA. */
+const HELP = `redmine-context — contexto completo de issues do Redmine para LLMs
+
+Uso:
+  redmine-context issue <id> [opções]
+  redmine-context login [opções]
+  redmine-context doctor
+  redmine-context mcp
+  redmine-context --version    (imprime a versão e sai)
+  redmine-context --help       (imprime esta ajuda e sai)
+
+Comando issue:
+  Busca a issue, normaliza e imprime o bundle em stdout (Markdown por padrão).
+  O progresso da operação é enviado para stderr.
+
+  --json            Emite o bundle JSON canônico em vez de Markdown.
+  --extract         Extrai o texto (OCR) dos anexos de imagem e o embute no
+                    bundle (adiciona latência de download+OCR; requer tesseract).
+  --out <dir>       Grava o bundle em <dir>/<id>.md|.json em vez de stdout.
+  --url <url>       URL da instância Redmine (ou defina REDMINE_URL).
+  --insecure        Permite http:// sem TLS (não recomendado).
+
+Comando login:
+  Autentica por usuário/senha e salva a api_key para a instância.
+  Em contas com 2FA, cole a api_key quando solicitado (ou use --api-key).
+
+  --url <url>       URL da instância Redmine.
+  --api-key <key>   Salva a api_key diretamente, sem senha.
+  --insecure        Permite http:// sem TLS (não recomendado).
+
+Comando doctor:
+  Diagnostica os binários de mídia (ex.: tesseract p/ OCR) e imprime um
+  relatório em texto puro. Mostra caminho e versão quando presentes, ou a
+  instrução de instalação do seu SO quando ausentes. Exit 0 se tudo ok, 1 se
+  faltar algum.
+
+Comando mcp:
+  Sobe um servidor MCP (stdio) expondo as tools read-only get_issue_context,
+  search_issues e get_attachment_text. A instância vem de REDMINE_URL +
+  credencial da cascata (REDMINE_API_KEY); nenhuma tool aceita URL/host
+  arbitrário. Logs vão para stderr.
+
+Credenciais:
+  A api_key é resolvida na ordem: keychain do sistema -> arquivo de
+  credenciais -> REDMINE_API_KEY (env). O login salva no keychain quando
+  disponível e migra credenciais antigas do arquivo automaticamente.
+  Sem credencial, rode: redmine-context login
+
+Exit codes:
+  0  sucesso
+  1  erro genérico ou uso inválido
+  2  falha de autenticação ou credencial ausente
+  3  erro de rede ou HTTP
+  4  issue inexistente
+`;
+/**
+ * Parse manual de `argv` (após o nome do comando).
+ *
+ * Reconhece `--flag valor` para as flags de {@link VALUE_FLAGS} e `--flag`/`-h`
+ * como booleanas; o restante são posicionais.
+ *
+ * @param argv - Argumentos após `node main.js`.
+ * @returns Posicionais e flags. Ver {@link ParsedArgs}.
+ */
+export function parseArgs(argv) {
+    const positionals = [];
+    const flags = new Map();
+    for (let i = 0; i < argv.length; i++) {
+        const token = argv[i];
+        if (token === undefined)
+            continue;
+        if (token === '-h') {
+            flags.set('help', true);
+            continue;
+        }
+        if (token === '-v') {
+            flags.set('version', true);
+            continue;
+        }
+        if (token.startsWith('--')) {
+            const name = token.slice(2);
+            if (VALUE_FLAGS.has(name)) {
+                const value = argv[i + 1];
+                flags.set(name, value ?? '');
+                i++;
+            }
+            else {
+                flags.set(name, true);
+            }
+            continue;
+        }
+        positionals.push(token);
+    }
+    return { positionals, flags };
+}
+/**
+ * Constrói as dependências default apontando para o processo real.
+ *
+ * Os prompts compartilham UMA sessão readline (bug #106): interfaces
+ * sucessivas sobre o mesmo stdin perdem entrada e pausam o stream. A sessão é
+ * lazy (comandos não interativos nunca tocam o stdin) e é fechada pelo
+ * chamador via `closePrompts`.
+ */
+function defaultDeps() {
+    const session = createPromptSession();
+    return {
+        stdout: (text) => void process.stdout.write(text),
+        stderr: (text) => void process.stderr.write(text),
+        env: process.env,
+        prompt: (q) => session.prompt(q),
+        promptPassword: (q) => session.promptPassword(q),
+        isTTY: process.stdout.isTTY === true,
+        settings: defaultSettingsStore(),
+        closePrompts: () => session.close(),
+    };
+}
+/**
+ * Ponto de entrada testável: faz parse, despacha o comando e devolve o exit code.
+ *
+ * @param argv - Argumentos após `node main.js` (ex.: `process.argv.slice(2)`).
+ * @param overrides - Dependências injetáveis (I/O, prompts, env) para testes.
+ * @returns O exit code do processo (0 = sucesso).
+ * @example
+ * const code = await run(['issue', '42', '--url', 'https://redmine.example']);
+ */
+export async function run(argv, overrides = {}) {
+    const defaults = defaultDeps();
+    const deps = { ...defaults, ...overrides };
+    try {
+        return await dispatch(argv, deps);
+    }
+    finally {
+        // Sem isso, a interface readline mantém o processo vivo após o login.
+        defaults.closePrompts();
+    }
+}
+/** Despacha o comando parseado — extraído para o run() poder fechar a sessão. */
+async function dispatch(argv, deps) {
+    const parsed = parseArgs(argv);
+    const command = parsed.positionals[0];
+    if (parsed.flags.get('version') === true || command === 'version') {
+        deps.stdout(`${TOOL_VERSION}\n`);
+        return 0;
+    }
+    if (parsed.flags.get('help') === true || command === 'help') {
+        deps.stdout(HELP);
+        return 0;
+    }
+    if (command === undefined) {
+        // Sem positionals: abre a TUI (M2-01) somente quando shouldRenderTui()
+        // aprova (M2-03) — NO_COLOR, CI=true ou stdout não-TTY sempre degradam
+        // para o caminho de texto puro da CLI (help em stderr, exit 1).
+        if (shouldRenderTui(deps.env, deps.isTTY === true)) {
+            return runTui();
+        }
+        deps.stderr(HELP);
+        return 1;
+    }
+    if (command === 'issue') {
+        return runIssue(parsed, deps);
+    }
+    if (command === 'login') {
+        return runLogin(parsed, deps);
+    }
+    if (command === 'doctor') {
+        return runDoctor(parsed, deps);
+    }
+    if (command === 'mcp') {
+        // Wire fino: o server bloqueia até o transporte stdio fechar (então exit 0).
+        await runStdioServer({ env: deps.env });
+        return 0;
+    }
+    deps.stderr(`Comando desconhecido: ${command}\n\n${HELP}`);
+    return 1;
+}
+/* c8 ignore start -- wire de execução; coberto pelo teste E2E real (#20). */
+// O npm expõe o `bin` como SYMLINK (node_modules/.bin/redmine-context) — é assim
+// que `npx` e `npm i -g` invocam. `import.meta.url` é o realpath do arquivo, mas
+// `process.argv[1]` é o caminho do symlink; sem resolver o realpath, o guard não
+// dispararia via npx e o CLI/MCP sairia vazio (#76). `realpathSync` alinha os dois.
+const invokedPath = process.argv[1];
+const invokedRealPath = invokedPath !== undefined ? realpathSync(invokedPath) : undefined;
+if (invokedRealPath !== undefined && import.meta.url === pathToFileURL(invokedRealPath).href) {
+    run(process.argv.slice(2)).then((code) => process.exit(code), (error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exit(1);
+    });
+}
+/* c8 ignore stop */

package/dist/surfaces/cli/prompts.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Prompts interativos do CLI (M1-11) — leitura de linha e senha mascarada.
+ *
+ * Implementação mínima sobre o `readline` nativo (sem dependência de terceiros):
+ * `prompt` lê uma linha com echo normal; `promptPassword` desliga o echo dos
+ * caracteres digitados (sem eco — a senha nunca aparece no terminal nem em logs).
+ * Os streams de entrada/saída são injetáveis para permitir testes determinísticos.
+ */
+/** Streams de I/O do prompt; default: `process.stdin` / `process.stdout`. */
+export interface PromptIo {
+    /** Stream de entrada de onde a resposta é lida. */
+    input: NodeJS.ReadableStream;
+    /** Stream de saída onde a pergunta (e o echo) é escrita. */
+    output: NodeJS.WritableStream;
+}
+/**
+ * Sessão de prompts compartilhando UMA única `readline.Interface`.
+ *
+ * Abrir e fechar interfaces sucessivas sobre o mesmo stdin perde entrada
+ * bufferizada e pausa o stream (bug #106: o login travava entre o prompt de
+ * usuário e o de senha). A sessão cria a interface de forma lazy no primeiro
+ * prompt e a mantém viva até `close()`.
+ */
+export interface PromptSession {
+    /** Lê uma linha com echo normal. */
+    prompt(question: string): Promise<string>;
+    /** Lê uma linha sensível SEM ecoar os caracteres. */
+    promptPassword(question: string): Promise<string>;
+    /** Encerra a interface (idempotente). Obrigatório ao fim do fluxo. */
+    close(): void;
+}
+/**
+ * Cria uma {@link PromptSession} sobre os streams informados.
+ *
+ * @param io - Streams de I/O (ver {@link PromptIo}). Default: stdin/stdout.
+ * @returns Sessão com `prompt`/`promptPassword`/`close`.
+ * @example
+ * const session = createPromptSession();
+ * const user = await session.prompt('Usuário: ');
+ * const pass = await session.promptPassword('Senha: ');
+ * session.close();
+ */
+export declare function createPromptSession(io?: PromptIo): PromptSession;
+/**
+ * Lê uma linha do usuário com echo normal.
+ *
+ * @param question - Texto exibido antes da entrada (ex.: `'Usuário: '`).
+ * @param io - Streams de I/O (ver {@link PromptIo}). Default: stdin/stdout.
+ * @returns A linha digitada (sem o `\n` final).
+ * @example
+ * const user = await prompt('Usuário: ');
+ */
+export declare function prompt(question: string, io?: PromptIo): Promise<string>;
+/**
+ * Lê uma linha sensível (senha, api_key) SEM ecoar os caracteres digitados.
+ *
+ * A pergunta é escrita normalmente; a partir daí o writer interno do readline é
+ * silenciado, de modo que nenhum caractere da entrada aparece no terminal.
+ *
+ * @param question - Texto exibido antes da entrada (ex.: `'Senha: '`).
+ * @param io - Streams de I/O (ver {@link PromptIo}). Default: stdin/stdout.
+ * @returns O valor digitado (sem o `\n` final), nunca ecoado.
+ * @example
+ * const password = await promptPassword('Senha: ');
+ */
+export declare function promptPassword(question: string, io?: PromptIo): Promise<string>;