@trendify/cli 0.1.7 → 0.1.8

package/README.md

@@ -37,6 +37,32 @@ npm run build --workspace apps/cli
 npm run check-types --workspace apps/cli
 ```
 
+## Convencao de arquivos
+
+Dentro de `apps/cli/src`, todos os arquivos seguem estas regras:
+
+- nomes sempre em minusculas e `kebab-case`
+- o sufixo final identifica a responsabilidade do arquivo
+- cada tipo de arquivo fica na pasta correspondente sempre que fizer sentido
+
+Padrao adotado:
+
+- `*.component.tsx`: componentes visuais reutilizaveis e composicao de layout
+- `*.page.tsx`: telas e fluxos de interface
+- `*.service.ts`: servicos, integracoes e regras de orquestracao
+- `*.config.ts`: configuracoes compartilhadas
+- `*.constant.ts`: constantes compartilhadas
+- `*.util.ts`: funcoes utilitarias puras
+- `*.entry.tsx`: ponto de entrada executavel da CLI
+
+Organizacao:
+
+- `shared/`: artefatos reutilizados por mais de um modulo
+- `modules/<modulo>/pages`: telas do modulo
+- `modules/<modulo>/services`: servicos e estados internos do modulo
+- `modules/<modulo>/components`: componentes locais do modulo
+- `modules/<modulo>/utils`: utilitarios locais do modulo
+
 ## Release para npm
 
 O fluxo oficial de publicacao fica na raiz do monorepo.

package/dist/app.component.d.ts

@@ -0,0 +1,14 @@
+import { type CliUpdateCheckResult } from './shared/services/cli-update.service.js';
+export type AppProps = {
+    readonly appVersion: string;
+    readonly initialInput: string;
+    readonly initialNotification?: string | null;
+    readonly initialNotificationTone?: NotificationTone;
+    readonly onSelfUpdate: (update: Extract<CliUpdateCheckResult, {
+        status: 'available';
+    }>) => void | Promise<void>;
+};
+type NotificationTone = 'error' | 'info' | 'success';
+export declare function App({ appVersion, initialInput, initialNotification, initialNotificationTone, onSelfUpdate, }: AppProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=app.component.d.ts.map

package/dist/app.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.component.d.ts","sourceRoot":"","sources":["../src/app.component.tsx"],"names":[],"mappings":"AAYA,OAAO,EAAqB,KAAK,oBAAoB,EAAE,MAAM,yCAAyC,CAAC;AAMvG,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7C,QAAQ,CAAC,uBAAuB,CAAC,EAAE,gBAAgB,CAAC;IACpD,QAAQ,CAAC,YAAY,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,oBAAoB,EAAE;QAAE,MAAM,EAAE,WAAW,CAAA;KAAE,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACjH,CAAC;AA6DF,KAAK,gBAAgB,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;AAyFrD,wBAAgB,GAAG,CAAC,EAClB,UAAU,EACV,YAAY,EACZ,mBAA0B,EAC1B,uBAAmC,EACnC,YAAY,GACb,EAAE,QAAQ,2CAmfV"}

package/dist/app.component.js

@@ -0,0 +1,448 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, useApp, useInput } from 'ink';
+import { useEffect, useMemo, useState } from 'react';
+import { DiscoveryPage } from './modules/discovery/pages/discovery.page.js';
+import { getUserDisplayName } from './modules/auth/utils/auth-user.util.js';
+import { getAuthBootstrapResult, } from './modules/auth/services/auth.service.js';
+import { LoginPage } from './modules/auth/pages/login.page.js';
+import { ProfilePage } from './modules/auth/pages/profile.page.js';
+import { checkForCliUpdate } from './shared/services/cli-update.service.js';
+import { ActionMenuPage } from './shared/components/action-menu.component.js';
+import { AppMenu } from './shared/components/app-menu.component.js';
+import { AppShell } from './shared/components/app-shell.component.js';
+const MENU_ITEMS = [
+    {
+        id: 'discovery',
+        titulo: 'Descobrir Temas',
+        comando: 'discovery',
+        aliases: ['descobrir', 'Descobrir', 'temas', 'Temas'],
+        descricao: 'Inicia o fluxo de descoberta e coleta o tema da busca.',
+        palavrasChave: ['tema', 'Tema', 'descoberta', 'Descoberta', 'pesquisa', 'Pesquisa', 'amplo', 'restrito'],
+    },
+    {
+        id: 'profile',
+        titulo: 'Meu Perfil',
+        comando: 'profile',
+        aliases: ['perfil', 'Perfil', 'conta', 'Conta', 'usuário', 'usuario', 'Usuário', 'Usuario'],
+        descricao: 'Abre os fluxos de alteração de senha e display name.',
+        palavrasChave: [
+            'senha',
+            'Senha',
+            'display name',
+            'Display Name',
+            'nome',
+            'Nome',
+            'usuário',
+            'usuario',
+            'Supabase',
+            'supabase',
+        ],
+    },
+    {
+        id: 'logout',
+        titulo: 'Encerrar Sessão',
+        comando: 'logout',
+        aliases: ['sair-da-conta', 'sair da conta', 'Sair da Conta', 'deslogar', 'Deslogar'],
+        descricao: 'Remove a sessão salva localmente e volta para a tela de login.',
+        palavrasChave: ['auth', 'login', 'Login', 'conta', 'Conta', 'sessão', 'sessao', 'Sessão', 'Sessao', 'Supabase'],
+    },
+    {
+        id: 'exit',
+        titulo: 'Sair',
+        comando: 'sair',
+        aliases: ['exit', 'quit', 'sair', 'Sair'],
+        descricao: 'Sai do sistema sem perder a sessão do usuário ativa.',
+        palavrasChave: [
+            'fechar',
+            'Fechar',
+            'encerrar',
+            'Encerrar',
+            'finalizar',
+            'Finalizar',
+            'sessão',
+            'sessao',
+            'usuário',
+            'usuario',
+        ],
+    },
+];
+const LOGOUT_OPTIONS = [
+    {
+        value: 'cancel',
+        label: 'Voltar ao menu',
+        description: 'Cancela a saida da conta e retorna para os comandos.',
+    },
+    {
+        value: 'confirm',
+        label: 'Encerrar sessao',
+        description: 'Remove a sessao local e exige novo login para continuar.',
+    },
+];
+function formatScopeLabel(scope) {
+    return scope === 'amplo' ? 'mais ampla' : 'mais restrita';
+}
+function formatWorkspaceRole(role) {
+    if (role === 'owner') {
+        return 'Proprietario';
+    }
+    if (role === 'admin') {
+        return 'Administrador';
+    }
+    return 'Membro';
+}
+function getAuthenticatedUserLabel(user) {
+    if (!user) {
+        return 'usuario autenticado';
+    }
+    return getUserDisplayName(user) ?? user.email ?? 'usuario autenticado';
+}
+function getActiveWorkspaceLabel(workspace) {
+    return workspace?.name ?? 'espaco de trabalho';
+}
+function getWelcomeTitle(user) {
+    const displayName = user ? getUserDisplayName(user) : null;
+    if (displayName) {
+        return `Bem-vindo de volta, ${displayName} 👋`;
+    }
+    return 'Bem-vindo de volta. 👋';
+}
+function buildMenuItems(cliUpdate) {
+    if (cliUpdate.status !== 'available') {
+        return MENU_ITEMS;
+    }
+    const [discoveryItem, profileItem, logoutItem, exitItem] = MENU_ITEMS;
+    if (!discoveryItem || !profileItem || !logoutItem || !exitItem) {
+        return MENU_ITEMS;
+    }
+    return [
+        discoveryItem,
+        profileItem,
+        {
+            id: 'update-cli',
+            titulo: `Atualizar CLI para v${cliUpdate.latestVersion}`,
+            comando: 'atualizar-cli',
+            aliases: ['update', 'upgrade', 'atualizar', 'atualizar-cli', 'Atualizar CLI'],
+            descricao: `Instala a versao ${cliUpdate.latestVersion} do CLI e reinicia a aplicacao.`,
+            palavrasChave: [
+                'versao',
+                'nova versao',
+                'ultima versao',
+                'npm',
+                'upgrade',
+                'update',
+                'atualizacao',
+                'atualizar',
+            ],
+        },
+        logoutItem,
+        exitItem,
+    ];
+}
+export function App({ appVersion, initialInput, initialNotification = null, initialNotificationTone = 'success', onSelfUpdate, }) {
+    const { exit } = useApp();
+    const authBootstrap = useMemo(() => getAuthBootstrapResult(), []);
+    const authService = authBootstrap.ok ? authBootstrap.authService : null;
+    const sessionStorageFilePath = authService?.getSessionStorageFilePath() ?? '~/.trendify/auth/storage.json';
+    const [screen, setScreen] = useState('menu');
+    const [notification, setNotification] = useState(initialNotification);
+    const [notificationTone, setNotificationTone] = useState(initialNotificationTone);
+    const [menuKey, setMenuKey] = useState(0);
+    const [authStatus, setAuthStatus] = useState(authBootstrap.ok ? 'booting' : 'config-error');
+    const [authUser, setAuthUser] = useState(null);
+    const [availableWorkspaces, setAvailableWorkspaces] = useState([]);
+    const [activeWorkspace, setActiveWorkspace] = useState(null);
+    const [email, setEmail] = useState('');
+    const [password, setPassword] = useState('');
+    const [authBusy, setAuthBusy] = useState(false);
+    const [logoutSelectionIndex, setLogoutSelectionIndex] = useState(0);
+    const [workspaceSelectionIndex, setWorkspaceSelectionIndex] = useState(0);
+    const [cliUpdate, setCliUpdate] = useState({
+        currentVersion: appVersion,
+        packageName: '@trendify/cli',
+        status: 'checking',
+    });
+    const menuItems = useMemo(() => buildMenuItems(cliUpdate), [cliUpdate]);
+    function resetAuthenticatedContext() {
+        setAuthUser(null);
+        setAvailableWorkspaces([]);
+        setActiveWorkspace(null);
+        setWorkspaceSelectionIndex(0);
+    }
+    function applyAuthenticatedSnapshot(snapshot) {
+        setAuthStatus('authenticated');
+        setAuthUser(snapshot.user);
+        setAvailableWorkspaces(snapshot.workspaces);
+        setActiveWorkspace(snapshot.activeWorkspace);
+        setWorkspaceSelectionIndex(0);
+        if (snapshot.requiresWorkspaceSelection) {
+            setScreen('select-workspace');
+            return;
+        }
+        setScreen('menu');
+        setMenuKey((current) => current + 1);
+    }
+    useInput((input, key) => {
+        if (key.ctrl && input === 'c') {
+            exit();
+        }
+    });
+    useInput((_input, key) => {
+        if (screen !== 'confirm-logout' || authBusy) {
+            return;
+        }
+        if (key.escape) {
+            setScreen('menu');
+            setLogoutSelectionIndex(0);
+            return;
+        }
+        if (key.upArrow) {
+            setLogoutSelectionIndex((current) => (current === 0 ? LOGOUT_OPTIONS.length - 1 : current - 1));
+            return;
+        }
+        if (key.downArrow) {
+            setLogoutSelectionIndex((current) => (current === LOGOUT_OPTIONS.length - 1 ? 0 : current + 1));
+            return;
+        }
+        if (key.return) {
+            const option = LOGOUT_OPTIONS[logoutSelectionIndex];
+            if (option?.value === 'confirm') {
+                void handleLogout();
+                return;
+            }
+            setScreen('menu');
+            setLogoutSelectionIndex(0);
+            setNotification('Encerramento de sessao cancelado.');
+            setNotificationTone('info');
+        }
+    });
+    useInput((_input, key) => {
+        if (screen !== 'select-workspace' || authBusy) {
+            return;
+        }
+        if (!availableWorkspaces.length) {
+            return;
+        }
+        if (key.escape) {
+            void handleLogout();
+            return;
+        }
+        if (key.upArrow) {
+            setWorkspaceSelectionIndex((current) => (current === 0 ? availableWorkspaces.length - 1 : current - 1));
+            return;
+        }
+        if (key.downArrow) {
+            setWorkspaceSelectionIndex((current) => (current === availableWorkspaces.length - 1 ? 0 : current + 1));
+            return;
+        }
+        if (key.return) {
+            void handleWorkspaceSelection();
+        }
+    });
+    useEffect(() => {
+        let active = true;
+        const checkUpdates = async () => {
+            const result = await checkForCliUpdate(appVersion);
+            if (!active) {
+                return;
+            }
+            setCliUpdate(result);
+        };
+        void checkUpdates();
+        return () => {
+            active = false;
+        };
+    }, [appVersion]);
+    useEffect(() => {
+        if (!authService) {
+            return;
+        }
+        let active = true;
+        setAuthBusy(true);
+        const restoreSession = async () => {
+            const result = await authService.restoreSession();
+            if (!active) {
+                return;
+            }
+            if (result.error) {
+                setNotification(result.error);
+                setNotificationTone('error');
+            }
+            if (result.data?.user) {
+                applyAuthenticatedSnapshot(result.data);
+                if (result.data.requiresWorkspaceSelection) {
+                    setNotification('Escolha o espaco de trabalho que deseja usar nesta sessao.');
+                    setNotificationTone('info');
+                }
+            }
+            else {
+                setAuthStatus('unauthenticated');
+                resetAuthenticatedContext();
+            }
+            setAuthBusy(false);
+        };
+        void restoreSession();
+        const { data: { subscription }, } = authService.onAuthStateChange((snapshot) => {
+            if (!active) {
+                return;
+            }
+            if (snapshot.user) {
+                setAuthUser(snapshot.user);
+                return;
+            }
+            setAuthStatus('unauthenticated');
+            resetAuthenticatedContext();
+            setScreen('menu');
+            setMenuKey((current) => current + 1);
+        });
+        return () => {
+            active = false;
+            subscription.unsubscribe();
+        };
+    }, [authService]);
+    async function handleLogin() {
+        if (!authService || authBusy) {
+            return;
+        }
+        const trimmedEmail = email.trim();
+        if (!trimmedEmail || !password.trim()) {
+            setNotification('Preencha email e senha para continuar.');
+            setNotificationTone('error');
+            return;
+        }
+        setAuthBusy(true);
+        setNotification(null);
+        const result = await authService.signInWithPassword(trimmedEmail, password);
+        setAuthBusy(false);
+        if (result.error || !result.data?.user) {
+            setPassword('');
+            setNotification(result.error ?? 'Nao foi possivel autenticar este usuario.');
+            setNotificationTone('error');
+            setAuthStatus('unauthenticated');
+            resetAuthenticatedContext();
+            return;
+        }
+        applyAuthenticatedSnapshot(result.data);
+        setPassword('');
+        if (result.data.requiresWorkspaceSelection) {
+            setNotification('Login concluido. Escolha o espaco de trabalho para continuar.');
+            setNotificationTone('info');
+            return;
+        }
+        setNotification(null);
+    }
+    async function handleWorkspaceSelection() {
+        if (!authService || authBusy || !availableWorkspaces.length) {
+            return;
+        }
+        const workspace = availableWorkspaces[workspaceSelectionIndex];
+        if (!workspace) {
+            return;
+        }
+        setAuthBusy(true);
+        const result = await authService.selectWorkspace(workspace.id);
+        setAuthBusy(false);
+        if (result.error || !result.data) {
+            setNotification(result.error ?? 'Nao foi possivel ativar este espaco de trabalho.');
+            setNotificationTone('error');
+            return;
+        }
+        setActiveWorkspace(result.data);
+        setScreen('menu');
+        setMenuKey((current) => current + 1);
+        setNotification(`Espaco de trabalho ativo: ${result.data.name}.`);
+        setNotificationTone('success');
+    }
+    async function handleLogout() {
+        if (!authService || authBusy) {
+            return;
+        }
+        setAuthBusy(true);
+        const result = await authService.signOut();
+        setAuthBusy(false);
+        if (result.error) {
+            setNotification(result.error);
+            setNotificationTone('error');
+            return;
+        }
+        setScreen('menu');
+        setEmail('');
+        setPassword('');
+        resetAuthenticatedContext();
+        setMenuKey((current) => current + 1);
+        setLogoutSelectionIndex(0);
+        setNotification('Sessao local removida. Faca login novamente para continuar.');
+        setNotificationTone('success');
+    }
+    if (!authBootstrap.ok) {
+        return (_jsx(AppShell, { appVersion: appVersion, title: "Configuracao do Supabase pendente.", subtitle: "Defina as variaveis de ambiente antes de usar a CLI.", notification: authBootstrap.error, notificationTone: "error", children: _jsx(Text, { children: "Crie um arquivo .env com base em .env.example e preencha as chaves do projeto Supabase." }) }));
+    }
+    if (authStatus === 'booting') {
+        return (_jsx(AppShell, { appVersion: appVersion, title: "Validando sua sessao.", subtitle: "A CLI esta consultando o Supabase para restaurar a sessao e o espaco de trabalho atual.", notification: notification, notificationTone: notificationTone, children: _jsx(Text, { dimColor: true, children: authBusy ? 'Aguarde alguns instantes...' : 'Pronto para autenticar.' }) }));
+    }
+    if (authStatus === 'unauthenticated') {
+        return (_jsx(AppShell, { appVersion: appVersion, title: "Login obrigatorio.", subtitle: "Somente usuarios vinculados a um espaco de trabalho no Supabase podem usar a CLI.", notification: notification, notificationTone: notificationTone, children: _jsx(LoginPage, { busy: authBusy, email: email, password: password, sessionStorageFilePath: sessionStorageFilePath, onEmailChange: setEmail, onPasswordChange: setPassword, onSubmit: () => {
+                    void handleLogin();
+                } }) }));
+    }
+    if (screen === 'select-workspace') {
+        const workspaceOptions = availableWorkspaces.map((workspace) => ({
+            value: workspace.id,
+            label: workspace.name,
+            description: `${workspace.slug} • ${formatWorkspaceRole(workspace.role)}`,
+        }));
+        return (_jsx(AppShell, { appVersion: appVersion, title: "Escolha o espaco de trabalho", subtitle: `Conta autenticada para ${getAuthenticatedUserLabel(authUser)}. Selecione onde deseja operar.`, notification: notification, notificationTone: notificationTone, children: _jsx(ActionMenuPage, { title: "Espaco de trabalho ativo", subtitle: "Esse contexto sera usado nas consultas protegidas e nas regras de seguranca por linha.", options: workspaceOptions, selectedIndex: workspaceSelectionIndex, hintText: "Use as setas para navegar. Enter ativa o espaco. Esc encerra a sessao.", children: _jsxs(Text, { children: ["Conta: ", authUser?.email ?? 'nao informado'] }) }) }));
+    }
+    if (screen === 'discovery') {
+        return (_jsx(AppShell, { appVersion: appVersion, title: "Discovery", subtitle: `Sessao ativa para ${getAuthenticatedUserLabel(authUser)} em ${getActiveWorkspaceLabel(activeWorkspace)}.`, notification: notification, notificationTone: notificationTone, children: _jsx(DiscoveryPage, { onCancel: () => {
+                    setScreen('menu');
+                    setMenuKey((current) => current + 1);
+                }, onComplete: ({ theme, scope }) => {
+                    setNotification(`Discovery finalizado: tema "${theme}" com abordagem ${formatScopeLabel(scope)}.`);
+                    setNotificationTone('success');
+                    setScreen('menu');
+                    setMenuKey((current) => current + 1);
+                } }) }));
+    }
+    if (screen === 'profile' && authService && authUser) {
+        return (_jsx(AppShell, { appVersion: appVersion, title: "Profile", subtitle: `Sessao ativa para ${getAuthenticatedUserLabel(authUser)} em ${getActiveWorkspaceLabel(activeWorkspace)}.`, notification: notification, notificationTone: notificationTone, children: _jsx(ProfilePage, { authService: authService, user: authUser, onBack: () => {
+                    setScreen('menu');
+                    setMenuKey((current) => current + 1);
+                }, onNotificationChange: (nextNotification, nextTone = 'success') => {
+                    setNotification(nextNotification);
+                    setNotificationTone(nextTone);
+                } }) }));
+    }
+    if (screen === 'confirm-logout') {
+        return (_jsx(AppShell, { appVersion: appVersion, title: "Confirmar encerramento de sessao", subtitle: `Voce esta autenticado como ${getAuthenticatedUserLabel(authUser)} em ${getActiveWorkspaceLabel(activeWorkspace)}.`, notification: notification, notificationTone: notificationTone, children: _jsx(ActionMenuPage, { title: "Tem certeza que deseja encerrar a sessao atual?", subtitle: "Se confirmar, a CLI vai remover a sessao salva localmente e pedir login novamente.", options: LOGOUT_OPTIONS, selectedIndex: logoutSelectionIndex, hintText: "Use as setas para navegar. Enter confirma. Esc volta ao menu." }) }));
+    }
+    return (_jsxs(AppShell, { appVersion: appVersion, title: getWelcomeTitle(authUser), subtitle: `Workspace: ${getActiveWorkspaceLabel(activeWorkspace)}\n\nUse a barra para abrir os comandos.`, notification: notification, notificationTone: notificationTone, children: [cliUpdate.status === 'available' ? (_jsxs(Text, { color: "yellowBright", children: ["Nova versao disponivel: v", cliUpdate.latestVersion, ". Abra o menu com / e escolha \"Atualizar CLI\"."] })) : null, _jsx(AppMenu, { initialInput: menuKey === 0 ? initialInput : '', items: menuItems, onInputChange: () => {
+                    if (notification) {
+                        setNotification(null);
+                    }
+                }, onSelect: (item) => {
+                    if (item.id === 'update-cli' && cliUpdate.status === 'available') {
+                        void onSelfUpdate(cliUpdate);
+                        return;
+                    }
+                    if (item.id === 'logout') {
+                        setNotification(null);
+                        setNotificationTone('info');
+                        setLogoutSelectionIndex(0);
+                        setScreen('confirm-logout');
+                        return;
+                    }
+                    if (item.id === 'profile') {
+                        setNotification(null);
+                        setNotificationTone('success');
+                        setScreen('profile');
+                        return;
+                    }
+                    if (item.id === 'exit') {
+                        exit();
+                        return;
+                    }
+                    setNotification(null);
+                    setNotificationTone('success');
+                    setScreen('discovery');
+                } }, menuKey)] }));
+}

package/dist/cli.entry.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.entry.d.ts.map

package/dist/cli.entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.entry.d.ts","sourceRoot":"","sources":["../src/cli.entry.tsx"],"names":[],"mappings":""}

package/dist/cli.entry.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { App } from './app.component.js';
+import { APP_VERSION } from './shared/constants/app-version.constant.js';
+import { runCliSelfUpdate } from './shared/services/cli-update.service.js';
+const args = process.argv.slice(2);
+const initialInput = args
+    .filter((arg) => !arg.startsWith('-'))
+    .join(' ')
+    .trim();
+if (args.includes('--help') || args.includes('-h')) {
+    process.stdout.write(`CLI
+
+Uso:
+  trendify [opcoes]
+
+Opcoes:
+  -h, --help     Mostra esta ajuda
+  -v, --version  Mostra a versao instalada
+`);
+    process.exit(0);
+}
+if (args.includes('--version') || args.includes('-v')) {
+    process.stdout.write(`${APP_VERSION}\n`);
+    process.exit(0);
+}
+console.clear();
+let appInstance;
+function mountApp(feedback = null) {
+    appInstance = render(_jsx(App, { appVersion: APP_VERSION, initialInput: initialInput, initialNotification: feedback?.message ?? null, initialNotificationTone: feedback?.tone ?? 'success', onSelfUpdate: async (update) => {
+            appInstance.unmount();
+            console.clear();
+            process.stdout.write([
+                `Atualizando o CLI de v${update.currentVersion} para v${update.latestVersion}.`,
+                `Pacote npm: ${update.packageName}`,
+                '',
+            ].join('\n'));
+            const result = await runCliSelfUpdate(update.packageName, update.latestVersion);
+            if (result.ok) {
+                process.exit(0);
+            }
+            process.stdout.write(`\nFalha ao atualizar automaticamente: ${result.error}\n`);
+            process.stdout.write('A CLI atual continuara disponivel.\n');
+            mountApp({
+                message: `Nao foi possivel atualizar a CLI automaticamente. ${result.error}`,
+                tone: 'error',
+            });
+        } }));
+}
+mountApp();

package/dist/modules/auth/pages/login.page.d.ts

@@ -0,0 +1,12 @@
+type LoginPageProps = {
+    readonly busy: boolean;
+    readonly email: string;
+    readonly onEmailChange: (value: string) => void;
+    readonly onPasswordChange: (value: string) => void;
+    readonly onSubmit: () => void;
+    readonly password: string;
+    readonly sessionStorageFilePath: string;
+};
+export declare function LoginPage({ busy, email, onEmailChange, onPasswordChange, onSubmit, password, sessionStorageFilePath, }: LoginPageProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=login.page.d.ts.map

package/dist/modules/auth/pages/login.page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.page.d.ts","sourceRoot":"","sources":["../../../../src/modules/auth/pages/login.page.tsx"],"names":[],"mappings":"AAIA,KAAK,cAAc,GAAG;IACpB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAChD,QAAQ,CAAC,gBAAgB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACnD,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;CACzC,CAAC;AAIF,wBAAgB,SAAS,CAAC,EACxB,IAAI,EACJ,KAAK,EACL,aAAa,EACb,gBAAgB,EAChB,QAAQ,EACR,QAAQ,EACR,sBAAsB,GACvB,EAAE,cAAc,2CAsDhB"}

package/dist/modules/auth/pages/login.page.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import { useState } from 'react';
+import { TextField } from '../../../shared/components/text-field.component.js';
+export function LoginPage({ busy, email, onEmailChange, onPasswordChange, onSubmit, password, sessionStorageFilePath, }) {
+    const [focusField, setFocusField] = useState('email');
+    useInput((_input, key) => {
+        if (busy) {
+            return;
+        }
+        if (key.tab || key.downArrow || key.upArrow) {
+            setFocusField((current) => (current === 'email' ? 'password' : 'email'));
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Entre com um usuario ja cadastrado no Supabase para liberar os comandos internos." }), _jsx(Text, { dimColor: true, children: "Apos o login, a CLI tambem valida o espaco de trabalho vinculado a sua conta." }), _jsx(Text, { dimColor: true, children: "Cadastro nao esta habilitado nesta CLI." }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: focusField === 'email' ? 'greenBright' : 'white', children: "Email" }), _jsx(TextField, { focus: focusField === 'email', placeholder: "voce@empresa.com", value: email, onChange: onEmailChange, onSubmit: (value) => {
+                            if (value.trim()) {
+                                setFocusField('password');
+                            }
+                        } })] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: focusField === 'password' ? 'greenBright' : 'white', children: "Senha" }), _jsx(TextField, { focus: focusField === 'password', mask: "*", placeholder: "Sua senha", value: password, onChange: onPasswordChange, onSubmit: () => {
+                            onSubmit();
+                        } })] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "Enter faz login. Tab ou setas alternam o campo ativo." }), _jsxs(Text, { dimColor: true, children: ["Sessao persistida localmente em: ", sessionStorageFilePath] })] })] }));
+}

package/dist/modules/auth/pages/profile.page.d.ts

@@ -0,0 +1,12 @@
+import { type AuthUser } from '@supabase/supabase-js';
+import { type AuthService } from '../services/auth.service.js';
+type NotificationTone = 'error' | 'info' | 'success';
+type ProfilePageProps = {
+    readonly authService: AuthService;
+    readonly onBack: () => void;
+    readonly onNotificationChange: (notification: string | null, tone?: NotificationTone) => void;
+    readonly user: AuthUser;
+};
+export declare function ProfilePage({ authService, onBack, onNotificationChange, user }: ProfilePageProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=profile.page.d.ts.map

package/dist/modules/auth/pages/profile.page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.page.d.ts","sourceRoot":"","sources":["../../../../src/modules/auth/pages/profile.page.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGtD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAO/D,KAAK,gBAAgB,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;AAKrD,KAAK,gBAAgB,GAAG;IACtB,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC;IAC5B,QAAQ,CAAC,oBAAoB,EAAE,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,EAAE,IAAI,CAAC,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAC9F,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;CACzB,CAAC;AAwBF,wBAAgB,WAAW,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,oBAAoB,EAAE,IAAI,EAAE,EAAE,gBAAgB,2CAwQhG"}