@trendify/cli 0.1.6 → 0.1.8

package/dist/cli-update-service.d.ts

@@ -0,0 +1,29 @@
+export type CliUpdateCheckResult = {
+    readonly currentVersion: string;
+    readonly packageName: string;
+    readonly status: 'checking';
+} | {
+    readonly currentVersion: string;
+    readonly latestVersion: string;
+    readonly packageName: string;
+    readonly status: 'available';
+} | {
+    readonly currentVersion: string;
+    readonly latestVersion: string;
+    readonly packageName: string;
+    readonly status: 'current';
+} | {
+    readonly currentVersion: string;
+    readonly message: string;
+    readonly packageName: string;
+    readonly status: 'error';
+};
+export type CliSelfUpdateResult = {
+    readonly ok: true;
+} | {
+    readonly error: string;
+    readonly ok: false;
+};
+export declare function checkForCliUpdate(currentVersion: string): Promise<CliUpdateCheckResult>;
+export declare function runCliSelfUpdate(packageName: string, latestVersion: string): Promise<CliSelfUpdateResult>;
+//# sourceMappingURL=cli-update-service.d.ts.map

package/dist/cli-update-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-update-service.d.ts","sourceRoot":"","sources":["../src/cli-update-service.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,oBAAoB,GAC5B;IACE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;CAC7B,GACD;IACE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;CAC9B,GACD;IACE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;CAC5B,GACD;IACE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEN,MAAM,MAAM,mBAAmB,GAC3B;IACE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;CACnB,GACD;IACE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;CACpB,CAAC;AA4MN,wBAAsB,iBAAiB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA6B7F;AAED,wBAAsB,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAwB/G"}

package/dist/cli-update-service.js

@@ -0,0 +1,206 @@
+import { readFileSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+const DEFAULT_PACKAGE_NAME = '@trendify/cli';
+const VERSION_PATTERN = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/u;
+function getPackageManifestPath() {
+    return new URL('../package.json', import.meta.url);
+}
+function getNpmCommand() {
+    return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+function toErrorMessage(error) {
+    if (error instanceof Error && error.message.trim()) {
+        return error.message;
+    }
+    return 'Nao foi possivel concluir a operacao.';
+}
+function readInstalledPackageMetadata() {
+    try {
+        const manifestContents = readFileSync(getPackageManifestPath(), 'utf8');
+        const manifest = JSON.parse(manifestContents);
+        const packageName = typeof manifest.name === 'string' && manifest.name.trim().length > 0
+            ? manifest.name.trim()
+            : DEFAULT_PACKAGE_NAME;
+        return { packageName };
+    }
+    catch {
+        return { packageName: DEFAULT_PACKAGE_NAME };
+    }
+}
+function parseVersion(version) {
+    const match = VERSION_PATTERN.exec(version.trim());
+    if (!match) {
+        return null;
+    }
+    const [, major, minor, patch, prerelease] = match;
+    if (!major || !minor || !patch) {
+        return null;
+    }
+    return {
+        major: Number.parseInt(major, 10),
+        minor: Number.parseInt(minor, 10),
+        patch: Number.parseInt(patch, 10),
+        prerelease: prerelease ?? null,
+    };
+}
+function compareVersions(left, right) {
+    const parsedLeft = parseVersion(left);
+    const parsedRight = parseVersion(right);
+    if (!parsedLeft || !parsedRight) {
+        return left.localeCompare(right, undefined, { numeric: true, sensitivity: 'base' });
+    }
+    if (parsedLeft.major !== parsedRight.major) {
+        return parsedLeft.major - parsedRight.major;
+    }
+    if (parsedLeft.minor !== parsedRight.minor) {
+        return parsedLeft.minor - parsedRight.minor;
+    }
+    if (parsedLeft.patch !== parsedRight.patch) {
+        return parsedLeft.patch - parsedRight.patch;
+    }
+    if (parsedLeft.prerelease === parsedRight.prerelease) {
+        return 0;
+    }
+    if (parsedLeft.prerelease === null) {
+        return 1;
+    }
+    if (parsedRight.prerelease === null) {
+        return -1;
+    }
+    return parsedLeft.prerelease.localeCompare(parsedRight.prerelease, undefined, {
+        numeric: true,
+        sensitivity: 'base',
+    });
+}
+function runCommand(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, [...args], {
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on('error', (error) => {
+            reject(error);
+        });
+        child.on('close', (code) => {
+            resolve({
+                code: code ?? 1,
+                stderr,
+                stdout,
+            });
+        });
+    });
+}
+async function fetchLatestPublishedVersion(packageName) {
+    const commandResult = await runCommand(getNpmCommand(), ['view', packageName, 'version', '--json', '--silent']);
+    if (commandResult.code !== 0) {
+        const message = commandResult.stderr.trim() || commandResult.stdout.trim() || 'Falha ao consultar o npm.';
+        throw new Error(message);
+    }
+    const stdout = commandResult.stdout.trim();
+    if (!stdout) {
+        throw new Error('O npm nao retornou a versao publicada mais recente.');
+    }
+    try {
+        const parsedOutput = JSON.parse(stdout);
+        if (typeof parsedOutput === 'string' && parsedOutput.trim()) {
+            return parsedOutput.trim();
+        }
+    }
+    catch {
+        if (stdout) {
+            return stdout.replace(/^"+|"+$/gu, '').trim();
+        }
+    }
+    throw new Error('Nao foi possivel interpretar a versao publicada retornada pelo npm.');
+}
+async function runCommandWithInheritedStdio(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, [...args], {
+            env: process.env,
+            stdio: 'inherit',
+        });
+        child.on('error', (error) => {
+            reject(error);
+        });
+        child.on('close', (code) => {
+            resolve(code ?? 1);
+        });
+    });
+}
+async function restartCli() {
+    const entrypoint = process.argv[1];
+    if (!entrypoint) {
+        throw new Error('Nao foi possivel identificar o entrypoint atual da CLI para reiniciar o processo.');
+    }
+    await new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [...process.execArgv, entrypoint, ...process.argv.slice(2)], {
+            env: process.env,
+            stdio: 'inherit',
+        });
+        child.on('error', (error) => {
+            reject(error);
+        });
+        child.on('spawn', () => {
+            resolve();
+        });
+    });
+}
+export async function checkForCliUpdate(currentVersion) {
+    const { packageName } = readInstalledPackageMetadata();
+    try {
+        const latestVersion = await fetchLatestPublishedVersion(packageName);
+        if (compareVersions(latestVersion, currentVersion) > 0) {
+            return {
+                currentVersion,
+                latestVersion,
+                packageName,
+                status: 'available',
+            };
+        }
+        return {
+            currentVersion,
+            latestVersion,
+            packageName,
+            status: 'current',
+        };
+    }
+    catch (error) {
+        return {
+            currentVersion,
+            message: toErrorMessage(error),
+            packageName,
+            status: 'error',
+        };
+    }
+}
+export async function runCliSelfUpdate(packageName, latestVersion) {
+    try {
+        const exitCode = await runCommandWithInheritedStdio(getNpmCommand(), [
+            'install',
+            '--global',
+            `${packageName}@${latestVersion}`,
+        ]);
+        if (exitCode !== 0) {
+            return {
+                error: `O npm encerrou a atualizacao com codigo ${exitCode}.`,
+                ok: false,
+            };
+        }
+        await restartCli();
+        return { ok: true };
+    }
+    catch (error) {
+        return {
+            error: toErrorMessage(error),
+            ok: false,
+        };
+    }
+}

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/cli.js

@@ -2,6 +2,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { render } from 'ink';
 import { App } from './app.js';
+import { runCliSelfUpdate } from './cli-update-service.js';
 import { APP_VERSION } from './version.js';
 const args = process.argv.slice(2);
 const initialInput = args
@@ -25,4 +26,26 @@ if (args.includes('--version') || args.includes('-v')) {
     process.exit(0);
 }
 console.clear();
-render(_jsx(App, { appVersion: APP_VERSION, initialInput: initialInput }));
+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"}

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

@@ -0,0 +1,180 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import { useEffect, useState } from 'react';
+import { getUserDisplayName } from '../utils/auth-user.util.js';
+import { ActionMenuPage } from '../../../shared/components/action-menu.component.js';
+import { StepHeader } from '../../../shared/components/step-header.component.js';
+import { TextField } from '../../../shared/components/text-field.component.js';
+const PROFILE_ACTIONS = [
+    {
+        value: 'change-display-name',
+        label: 'Alterar display name',
+        description: 'Atualiza o nome exibido diretamente no Supabase.',
+    },
+    {
+        value: 'change-password',
+        label: 'Alterar senha',
+        description: 'Troca a senha da conta autenticada.',
+    },
+    {
+        value: 'back',
+        label: 'Voltar ao menu',
+        description: 'Retorna ao menu principal da CLI.',
+    },
+];
+function isReauthenticationRequired(errorCode) {
+    return errorCode === 'reauthentication_needed' || errorCode === 'reauth_nonce_missing';
+}
+export function ProfilePage({ authService, onBack, onNotificationChange, user }) {
+    const currentDisplayName = getUserDisplayName(user);
+    const [step, setStep] = useState('menu');
+    const [selectedActionIndex, setSelectedActionIndex] = useState(0);
+    const [displayName, setDisplayName] = useState(currentDisplayName ?? '');
+    const [newPassword, setNewPassword] = useState('');
+    const [confirmPassword, setConfirmPassword] = useState('');
+    const [passwordFocus, setPasswordFocus] = useState('new-password');
+    const [nonce, setNonce] = useState('');
+    const [pendingPassword, setPendingPassword] = useState('');
+    const [busy, setBusy] = useState(false);
+    useEffect(() => {
+        setDisplayName(currentDisplayName ?? '');
+    }, [currentDisplayName]);
+    function resetPasswordFlow() {
+        setNewPassword('');
+        setConfirmPassword('');
+        setNonce('');
+        setPendingPassword('');
+        setPasswordFocus('new-password');
+    }
+    function returnToProfileMenu() {
+        setStep('menu');
+        setSelectedActionIndex(0);
+        resetPasswordFlow();
+        setDisplayName(currentDisplayName ?? '');
+    }
+    async function handleDisplayNameSubmit() {
+        const trimmedDisplayName = displayName.trim();
+        if (!trimmedDisplayName) {
+            onNotificationChange('Informe um display name valido para continuar.', 'error');
+            return;
+        }
+        if (trimmedDisplayName === currentDisplayName) {
+            onNotificationChange('O display name informado ja esta em uso na sua conta.', 'info');
+            returnToProfileMenu();
+            return;
+        }
+        setBusy(true);
+        const result = await authService.updateDisplayName(trimmedDisplayName);
+        setBusy(false);
+        if (result.error) {
+            onNotificationChange(result.error, 'error');
+            return;
+        }
+        onNotificationChange(`Display name atualizado para "${trimmedDisplayName}".`, 'success');
+        returnToProfileMenu();
+    }
+    async function requestPasswordReauthentication(password) {
+        const reauthenticationResult = await authService.sendPasswordReauthenticationCode();
+        if (reauthenticationResult.error) {
+            onNotificationChange(reauthenticationResult.error, 'error');
+            return;
+        }
+        setPendingPassword(password);
+        setNonce('');
+        setStep('confirm-password-code');
+        onNotificationChange('O Supabase enviou um codigo de verificacao. Digite esse codigo para concluir a troca de senha.', 'info');
+    }
+    async function handlePasswordSubmit(password, currentNonce) {
+        if (!password.trim()) {
+            onNotificationChange('Informe a nova senha para continuar.', 'error');
+            return;
+        }
+        setBusy(true);
+        const result = await authService.updatePassword(password, currentNonce);
+        setBusy(false);
+        if (result.error) {
+            if (isReauthenticationRequired(result.errorCode) && !currentNonce) {
+                await requestPasswordReauthentication(password);
+                return;
+            }
+            onNotificationChange(result.error, 'error');
+            return;
+        }
+        onNotificationChange('Senha atualizada com sucesso.', 'success');
+        returnToProfileMenu();
+    }
+    async function handleNewPasswordSubmit() {
+        if (!newPassword.trim() || !confirmPassword.trim()) {
+            onNotificationChange('Preencha a nova senha e a confirmacao.', 'error');
+            return;
+        }
+        if (newPassword !== confirmPassword) {
+            onNotificationChange('A confirmacao de senha nao confere.', 'error');
+            return;
+        }
+        await handlePasswordSubmit(newPassword);
+    }
+    async function handlePasswordNonceSubmit() {
+        const trimmedNonce = nonce.trim();
+        if (!trimmedNonce) {
+            onNotificationChange('Informe o codigo de verificacao enviado pelo Supabase.', 'error');
+            return;
+        }
+        await handlePasswordSubmit(pendingPassword, trimmedNonce);
+    }
+    useInput((_input, key) => {
+        if (busy) {
+            return;
+        }
+        if (step === 'menu') {
+            if (key.escape) {
+                onBack();
+                return;
+            }
+            if (key.upArrow) {
+                setSelectedActionIndex((current) => (current === 0 ? PROFILE_ACTIONS.length - 1 : current - 1));
+                return;
+            }
+            if (key.downArrow) {
+                setSelectedActionIndex((current) => (current === PROFILE_ACTIONS.length - 1 ? 0 : current + 1));
+                return;
+            }
+            if (key.return) {
+                const action = PROFILE_ACTIONS[selectedActionIndex];
+                if (!action || action.value === 'back') {
+                    onBack();
+                    return;
+                }
+                onNotificationChange(null);
+                setStep(action.value);
+            }
+            return;
+        }
+        if (key.escape) {
+            onNotificationChange(null);
+            returnToProfileMenu();
+            return;
+        }
+        if (step === 'change-password' && (key.tab || key.upArrow || key.downArrow)) {
+            setPasswordFocus((current) => (current === 'new-password' ? 'confirm-password' : 'new-password'));
+        }
+    });
+    if (step === 'menu') {
+        return (_jsxs(ActionMenuPage, { title: "Profile", subtitle: "Escolha uma acao para gerenciar sua conta autenticada.", options: PROFILE_ACTIONS, selectedIndex: selectedActionIndex, hintText: "Use as setas para navegar. Enter confirma. Esc volta ao menu.", children: [_jsxs(Text, { children: ["Email: ", user.email ?? 'nao informado'] }), _jsxs(Text, { children: ["Display name: ", currentDisplayName ?? 'nao definido'] })] }));
+    }
+    if (step === 'change-display-name') {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(StepHeader, { title: "Alterar display name", subtitle: `Atual: ${currentDisplayName ?? 'nao definido'}. Digite o novo nome e pressione Enter.` }), _jsx(TextField, { placeholder: "Ex.: Leonardo", value: displayName, onChange: setDisplayName, onSubmit: () => {
+                        void handleDisplayNameSubmit();
+                    } }), _jsx(Text, { dimColor: true, children: "Esc volta para o menu de profile." })] }));
+    }
+    if (step === 'confirm-password-code') {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(StepHeader, { title: "Confirmar troca de senha", subtitle: "Digite o codigo recebido por email ou telefone para concluir a troca da senha." }), _jsx(TextField, { placeholder: "Codigo de verificacao", value: nonce, onChange: setNonce, onSubmit: () => {
+                        void handlePasswordNonceSubmit();
+                    } }), _jsx(Text, { dimColor: true, children: "Esc volta para o menu de profile." })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(StepHeader, { title: "Alterar senha", subtitle: "Defina a nova senha. Se o Supabase pedir reautenticacao, um codigo sera enviado automaticamente." }), _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: passwordFocus === 'new-password' ? 'greenBright' : 'white', children: "Nova senha" }), _jsx(TextField, { focus: passwordFocus === 'new-password', mask: "*", placeholder: "Digite a nova senha", value: newPassword, onChange: setNewPassword, onSubmit: () => {
+                            setPasswordFocus('confirm-password');
+                        } })] }), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: passwordFocus === 'confirm-password' ? 'greenBright' : 'white', children: "Confirmar senha" }), _jsx(TextField, { focus: passwordFocus === 'confirm-password', mask: "*", placeholder: "Repita a nova senha", value: confirmPassword, onChange: setConfirmPassword, onSubmit: () => {
+                            void handleNewPasswordSubmit();
+                        } })] }), _jsx(Text, { dimColor: true, children: "Tab ou setas alternam o campo ativo. Enter envia. Esc volta ao menu de profile." })] }));
+}

package/dist/modules/auth/services/auth-storage.service.d.ts

@@ -0,0 +1,11 @@
+import { type SupportedStorage } from '@supabase/supabase-js';
+export declare class FileStorage implements SupportedStorage {
+    private readonly filePath;
+    private queue;
+    constructor(filePath: string);
+    getItem(key: string): Promise<string | null>;
+    removeItem(key: string): Promise<void>;
+    setItem(key: string, value: string): Promise<void>;
+    private runExclusive;
+}
+//# sourceMappingURL=auth-storage.service.d.ts.map

package/dist/modules/auth/services/auth-storage.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-storage.service.d.ts","sourceRoot":"","sources":["../../../../src/modules/auth/services/auth-storage.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AA0C9D,qBAAa,WAAY,YAAW,gBAAgB;IAG/B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAF5C,OAAO,CAAC,KAAK,CAAuC;gBAEhB,QAAQ,EAAE,MAAM;IAEvC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAQ5C,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAatC,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAS/D,OAAO,CAAC,YAAY;CAUrB"}

package/dist/modules/auth/services/auth-storage.service.js

@@ -0,0 +1,65 @@
+import { chmod, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+async function ensureParentDirectory(filePath) {
+    await mkdir(dirname(filePath), { recursive: true });
+}
+async function readStorageMap(filePath) {
+    try {
+        const fileContents = await readFile(filePath, 'utf8');
+        const parsedContents = JSON.parse(fileContents);
+        if (!parsedContents || typeof parsedContents !== 'object' || Array.isArray(parsedContents)) {
+            return {};
+        }
+        return Object.fromEntries(Object.entries(parsedContents).filter((entry) => typeof entry[1] === 'string'));
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            return {};
+        }
+        return {};
+    }
+}
+async function writeStorageMap(filePath, data) {
+    await ensureParentDirectory(filePath);
+    const tempFilePath = `${filePath}.tmp`;
+    await writeFile(tempFilePath, JSON.stringify(data, null, 2), 'utf8');
+    await rename(tempFilePath, filePath);
+    if (process.platform !== 'win32') {
+        await chmod(filePath, 0o600).catch(() => undefined);
+    }
+}
+export class FileStorage {
+    filePath;
+    queue = Promise.resolve();
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    async getItem(key) {
+        return this.runExclusive(async () => {
+            const data = await readStorageMap(this.filePath);
+            return data[key] ?? null;
+        });
+    }
+    async removeItem(key) {
+        await this.runExclusive(async () => {
+            const data = await readStorageMap(this.filePath);
+            if (!(key in data)) {
+                return;
+            }
+            delete data[key];
+            await writeStorageMap(this.filePath, data);
+        });
+    }
+    async setItem(key, value) {
+        await this.runExclusive(async () => {
+            const data = await readStorageMap(this.filePath);
+            data[key] = value;
+            await writeStorageMap(this.filePath, data);
+        });
+    }
+    runExclusive(operation) {
+        const nextOperation = this.queue.then(operation, operation);
+        this.queue = nextOperation.then(() => undefined, () => undefined);
+        return nextOperation;
+    }
+}