@trendify/cli 0.1.7 → 0.1.9

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

@@ -0,0 +1,494 @@
+import { createClient, } from '@supabase/supabase-js';
+import { TRENDIFY_AUTH_STORAGE_FILE } from '../../../shared/config/app-paths.config.js';
+import { getCliEnvValidationResult } from '../../../shared/config/env.config.js';
+import { FileStorage } from './auth-storage.service.js';
+const AUTH_STORAGE_KEY = 'trendify.auth.token';
+const ACTIVE_WORKSPACE_STORAGE_KEY = 'trendify.auth.active-workspace-id';
+function toAuthErrorMessage(error, fallbackMessage) {
+    if (error && typeof error === 'object' && 'message' in error && typeof error.message === 'string') {
+        return error.message;
+    }
+    return fallbackMessage;
+}
+function isWorkspaceRole(value) {
+    return value === 'owner' || value === 'admin' || value === 'member';
+}
+function normalizeWorkspaceMembership(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const candidate = value;
+    const id = typeof candidate.workspace_id === 'string' ? candidate.workspace_id.trim() : '';
+    const name = typeof candidate.workspace_name === 'string' ? candidate.workspace_name.trim() : '';
+    const slug = typeof candidate.workspace_slug === 'string' ? candidate.workspace_slug.trim() : '';
+    const role = candidate.role;
+    if (!id || !name || !slug || !isWorkspaceRole(role)) {
+        return null;
+    }
+    return {
+        id,
+        name,
+        role,
+        slug,
+    };
+}
+export class AuthService {
+    client;
+    storage;
+    env;
+    storageFilePath;
+    static create(env) {
+        const storage = new FileStorage(TRENDIFY_AUTH_STORAGE_FILE);
+        const client = createClient(env.supabaseUrl, env.supabasePublishableDefaultKey, {
+            auth: {
+                autoRefreshToken: true,
+                detectSessionInUrl: false,
+                persistSession: true,
+                storage,
+                storageKey: AUTH_STORAGE_KEY,
+            },
+        });
+        return new AuthService(client, storage, env, TRENDIFY_AUTH_STORAGE_FILE);
+    }
+    constructor(client, storage, env, storageFilePath) {
+        this.client = client;
+        this.storage = storage;
+        this.env = env;
+        this.storageFilePath = storageFilePath;
+        this.activeWorkspaceId = null;
+    }
+    activeWorkspaceId;
+    getSessionStorageFilePath() {
+        return this.storageFilePath;
+    }
+    onAuthStateChange(listener) {
+        return this.client.auth.onAuthStateChange((_event, session) => {
+            listener({
+                activeWorkspace: null,
+                requiresWorkspaceSelection: false,
+                session,
+                user: session?.user ?? null,
+                workspaces: [],
+            });
+        });
+    }
+    getActiveWorkspaceId() {
+        return this.activeWorkspaceId;
+    }
+    async getWorkspaceScopedClient() {
+        try {
+            const { data: { session }, error, } = await this.client.auth.getSession();
+            if (error) {
+                return {
+                    data: null,
+                    error: error.message,
+                    errorCode: error.code ?? null,
+                };
+            }
+            if (!session?.access_token) {
+                return {
+                    data: null,
+                    error: 'Nao existe uma sessao ativa para criar um cliente com espaco de trabalho.',
+                    errorCode: null,
+                };
+            }
+            const activeWorkspaceId = this.activeWorkspaceId ?? (await this.readStoredActiveWorkspaceId());
+            if (!activeWorkspaceId) {
+                return {
+                    data: null,
+                    error: 'Selecione um espaco de trabalho antes de consultar dados protegidos.',
+                    errorCode: null,
+                };
+            }
+            const workspaceClient = createClient(this.env.supabaseUrl, this.env.supabasePublishableDefaultKey, {
+                auth: {
+                    autoRefreshToken: false,
+                    detectSessionInUrl: false,
+                    persistSession: false,
+                },
+                global: {
+                    headers: {
+                        Authorization: `Bearer ${session.access_token}`,
+                        'x-tenant-id': activeWorkspaceId,
+                    },
+                },
+            });
+            return {
+                data: workspaceClient,
+                error: null,
+                errorCode: null,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                error: toAuthErrorMessage(error, 'Nao foi possivel preparar o cliente do espaco de trabalho atual.'),
+                errorCode: null,
+            };
+        }
+    }
+    async restoreSession() {
+        try {
+            const { data: { session }, error: sessionError, } = await this.client.auth.getSession();
+            if (sessionError) {
+                return {
+                    data: null,
+                    error: sessionError.message,
+                    errorCode: sessionError.code ?? null,
+                };
+            }
+            if (!session) {
+                return {
+                    data: {
+                        activeWorkspace: null,
+                        requiresWorkspaceSelection: false,
+                        session: null,
+                        user: null,
+                        workspaces: [],
+                    },
+                    error: null,
+                    errorCode: null,
+                };
+            }
+            const { data: { user }, error: userError, } = await this.client.auth.getUser();
+            if (userError || !user) {
+                await this.client.auth.signOut({ scope: 'local' });
+                await this.clearStoredActiveWorkspaceId();
+                return {
+                    data: {
+                        activeWorkspace: null,
+                        requiresWorkspaceSelection: false,
+                        session: null,
+                        user: null,
+                        workspaces: [],
+                    },
+                    error: userError?.message ?? 'Sua sessao expirou. Faca login novamente.',
+                    errorCode: userError?.code ?? null,
+                };
+            }
+            return await this.buildAuthenticatedSnapshot(session, user);
+        }
+        catch (error) {
+            return {
+                data: null,
+                error: toAuthErrorMessage(error, 'Nao foi possivel restaurar a sessao atual.'),
+                errorCode: null,
+            };
+        }
+    }
+    async signInWithPassword(email, password) {
+        try {
+            const { data, error } = await this.client.auth.signInWithPassword({
+                email,
+                password,
+            });
+            if (error) {
+                return {
+                    data: null,
+                    error: error.message,
+                    errorCode: error.code ?? null,
+                };
+            }
+            if (!data.session || !data.user) {
+                return {
+                    data: null,
+                    error: 'O Supabase nao retornou uma sessao valida para este usuario.',
+                    errorCode: null,
+                };
+            }
+            return await this.buildAuthenticatedSnapshot(data.session, data.user);
+        }
+        catch (error) {
+            return {
+                data: null,
+                error: toAuthErrorMessage(error, 'Nao foi possivel concluir o login agora.'),
+                errorCode: null,
+            };
+        }
+    }
+    async signOut() {
+        try {
+            const { error } = await this.client.auth.signOut({ scope: 'local' });
+            if (error) {
+                return {
+                    data: null,
+                    error: error.message,
+                    errorCode: error.code ?? null,
+                };
+            }
+            await this.clearStoredActiveWorkspaceId();
+            return {
+                data: null,
+                error: null,
+                errorCode: null,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                error: toAuthErrorMessage(error, 'Nao foi possivel encerrar a sessao atual.'),
+                errorCode: null,
+            };
+        }
+    }
+    async selectWorkspace(workspaceId) {
+        const trimmedWorkspaceId = workspaceId.trim();
+        if (!trimmedWorkspaceId) {
+            return {
+                data: null,
+                error: 'Informe um espaco de trabalho valido para continuar.',
+                errorCode: null,
+            };
+        }
+        try {
+            const workspaceResult = await this.listMyWorkspaces();
+            if (workspaceResult.error || !workspaceResult.data) {
+                return {
+                    data: null,
+                    error: workspaceResult.error ?? 'Nao foi possivel carregar os espacos de trabalho disponiveis.',
+                    errorCode: workspaceResult.errorCode,
+                };
+            }
+            const selectedWorkspace = workspaceResult.data.find((workspace) => workspace.id === trimmedWorkspaceId);
+            if (!selectedWorkspace) {
+                return {
+                    data: null,
+                    error: 'Esse espaco de trabalho nao esta disponivel para a sua conta.',
+                    errorCode: null,
+                };
+            }
+            await this.storeActiveWorkspaceId(selectedWorkspace.id);
+            return {
+                data: selectedWorkspace,
+                error: null,
+                errorCode: null,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                error: toAuthErrorMessage(error, 'Nao foi possivel selecionar o espaco de trabalho agora.'),
+                errorCode: null,
+            };
+        }
+    }
+    async updateDisplayName(displayName) {
+        try {
+            const { data: { user: currentUser }, error: currentUserError, } = await this.client.auth.getUser();
+            if (currentUserError) {
+                return {
+                    data: null,
+                    error: currentUserError.message,
+                    errorCode: currentUserError.code ?? null,
+                };
+            }
+            if (!currentUser) {
+                return {
+                    data: null,
+                    error: 'Nao existe um usuario autenticado para atualizar o profile.',
+                    errorCode: null,
+                };
+            }
+            const currentMetadata = currentUser.user_metadata &&
+                typeof currentUser.user_metadata === 'object' &&
+                !Array.isArray(currentUser.user_metadata)
+                ? currentUser.user_metadata
+                : {};
+            const { data, error } = await this.client.auth.updateUser({
+                data: {
+                    ...currentMetadata,
+                    display_name: displayName,
+                },
+            });
+            if (error) {
+                return {
+                    data: null,
+                    error: error.message,
+                    errorCode: error.code ?? null,
+                };
+            }
+            if (!data.user) {
+                return {
+                    data: null,
+                    error: 'O Supabase nao retornou o usuario atualizado.',
+                    errorCode: null,
+                };
+            }
+            return {
+                data: data.user,
+                error: null,
+                errorCode: null,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                error: toAuthErrorMessage(error, 'Nao foi possivel atualizar o display name agora.'),
+                errorCode: null,
+            };
+        }
+    }
+    async sendPasswordReauthenticationCode() {
+        try {
+            const { error } = await this.client.auth.reauthenticate();
+            if (error) {
+                return {
+                    data: null,
+                    error: error.message,
+                    errorCode: error.code ?? null,
+                };
+            }
+            return {
+                data: null,
+                error: null,
+                errorCode: null,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                error: toAuthErrorMessage(error, 'Nao foi possivel solicitar o codigo de verificacao.'),
+                errorCode: null,
+            };
+        }
+    }
+    async updatePassword(password, nonce) {
+        try {
+            const { data, error } = await this.client.auth.updateUser(nonce
+                ? {
+                    nonce,
+                    password,
+                }
+                : {
+                    password,
+                });
+            if (error) {
+                return {
+                    data: null,
+                    error: error.message,
+                    errorCode: error.code ?? null,
+                };
+            }
+            if (!data.user) {
+                return {
+                    data: null,
+                    error: 'O Supabase nao retornou o usuario atualizado apos trocar a senha.',
+                    errorCode: null,
+                };
+            }
+            return {
+                data: data.user,
+                error: null,
+                errorCode: null,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                error: toAuthErrorMessage(error, 'Nao foi possivel atualizar a senha agora.'),
+                errorCode: null,
+            };
+        }
+    }
+    async buildAuthenticatedSnapshot(session, user) {
+        const workspaceResult = await this.listMyWorkspaces();
+        if (workspaceResult.error || !workspaceResult.data) {
+            return {
+                data: null,
+                error: workspaceResult.error ?? 'Nao foi possivel carregar os espacos de trabalho desta conta.',
+                errorCode: workspaceResult.errorCode,
+            };
+        }
+        if (workspaceResult.data.length === 0) {
+            await this.clearStoredActiveWorkspaceId();
+            return {
+                data: null,
+                error: 'Sua conta nao esta vinculada a nenhum espaco de trabalho. Fale com um administrador.',
+                errorCode: 'workspace_membership_missing',
+            };
+        }
+        const storedActiveWorkspaceId = await this.readStoredActiveWorkspaceId();
+        const storedWorkspace = storedActiveWorkspaceId
+            ? workspaceResult.data.find((workspace) => workspace.id === storedActiveWorkspaceId)
+            : null;
+        const singleWorkspace = workspaceResult.data.length === 1 ? workspaceResult.data[0] ?? null : null;
+        const activeWorkspace = storedWorkspace ?? singleWorkspace;
+        const requiresWorkspaceSelection = activeWorkspace === null;
+        if (activeWorkspace) {
+            await this.storeActiveWorkspaceId(activeWorkspace.id);
+        }
+        else {
+            await this.clearStoredActiveWorkspaceId();
+        }
+        return {
+            data: {
+                activeWorkspace,
+                requiresWorkspaceSelection,
+                session,
+                user,
+                workspaces: workspaceResult.data,
+            },
+            error: null,
+            errorCode: null,
+        };
+    }
+    async listMyWorkspaces() {
+        try {
+            const { data, error } = await this.client.rpc('list_my_workspaces');
+            if (error) {
+                return {
+                    data: null,
+                    error: error.message,
+                    errorCode: error.code ?? null,
+                };
+            }
+            const workspaces = Array.isArray(data)
+                ? data
+                    .map(normalizeWorkspaceMembership)
+                    .filter((workspace) => workspace !== null)
+                : [];
+            return {
+                data: workspaces,
+                error: null,
+                errorCode: null,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                error: toAuthErrorMessage(error, 'Nao foi possivel consultar os espacos de trabalho desta conta.'),
+                errorCode: null,
+            };
+        }
+    }
+    async readStoredActiveWorkspaceId() {
+        const storedValue = await this.storage.getItem(ACTIVE_WORKSPACE_STORAGE_KEY);
+        const trimmedValue = storedValue?.trim() ?? '';
+        return trimmedValue ? trimmedValue : null;
+    }
+    async storeActiveWorkspaceId(workspaceId) {
+        this.activeWorkspaceId = workspaceId;
+        await this.storage.setItem(ACTIVE_WORKSPACE_STORAGE_KEY, workspaceId);
+    }
+    async clearStoredActiveWorkspaceId() {
+        this.activeWorkspaceId = null;
+        await this.storage.removeItem(ACTIVE_WORKSPACE_STORAGE_KEY);
+    }
+}
+let cachedAuthBootstrap = null;
+export function getAuthBootstrapResult() {
+    if (cachedAuthBootstrap) {
+        return cachedAuthBootstrap;
+    }
+    const envValidation = getCliEnvValidationResult();
+    if (!envValidation.ok) {
+        cachedAuthBootstrap = envValidation;
+        return cachedAuthBootstrap;
+    }
+    cachedAuthBootstrap = {
+        ok: true,
+        env: envValidation.env,
+        authService: AuthService.create(envValidation.env),
+    };
+    return cachedAuthBootstrap;
+}

package/dist/modules/auth/utils/auth-user.util.d.ts

@@ -0,0 +1,3 @@
+import { type AuthUser } from '@supabase/supabase-js';
+export declare function getUserDisplayName(user: Pick<AuthUser, 'user_metadata'> | null | undefined): string | null;
+//# sourceMappingURL=auth-user.util.d.ts.map

package/dist/modules/auth/utils/auth-user.util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-user.util.d.ts","sourceRoot":"","sources":["../../../../src/modules/auth/utils/auth-user.util.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEtD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,eAAe,CAAC,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAa1G"}

package/dist/modules/auth/utils/auth-user.util.js

@@ -0,0 +1,10 @@
+export function getUserDisplayName(user) {
+    const value = user && user.user_metadata && typeof user.user_metadata === 'object' && !Array.isArray(user.user_metadata)
+        ? user.user_metadata.display_name
+        : null;
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmedValue = value.trim();
+    return trimmedValue ? trimmedValue : null;
+}

package/dist/modules/discovery/components/discovery-step-header.component.d.ts

@@ -0,0 +1,7 @@
+type DiscoveryStepHeaderProps = {
+    readonly subtitle: string;
+    readonly title: string;
+};
+export declare function DiscoveryStepHeader({ subtitle, title }: DiscoveryStepHeaderProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=discovery-step-header.component.d.ts.map

package/dist/modules/discovery/components/discovery-step-header.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery-step-header.component.d.ts","sourceRoot":"","sources":["../../../../src/modules/discovery/components/discovery-step-header.component.tsx"],"names":[],"mappings":"AAEA,KAAK,wBAAwB,GAAG;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,wBAAwB,2CAOhF"}

package/dist/modules/discovery/components/discovery-step-header.component.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export function DiscoveryStepHeader({ subtitle, title }) {
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: "yellow", children: title }), _jsx(Text, { dimColor: true, children: subtitle })] }));
+}

package/dist/modules/discovery/pages/discovery.page.d.ts

@@ -0,0 +1,11 @@
+type DiscoveryScope = 'amplo' | 'restrito';
+type DiscoveryPageProps = {
+    readonly onCancel: () => void;
+    readonly onComplete: (result: {
+        scope: DiscoveryScope;
+        theme: string;
+    }) => void;
+};
+export declare function DiscoveryPage({ onCancel, onComplete }: DiscoveryPageProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=discovery.page.d.ts.map

package/dist/modules/discovery/pages/discovery.page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.page.d.ts","sourceRoot":"","sources":["../../../../src/modules/discovery/pages/discovery.page.tsx"],"names":[],"mappings":"AAOA,KAAK,cAAc,GAAG,OAAO,GAAG,UAAU,CAAC;AAE3C,KAAK,kBAAkB,GAAG;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,cAAc,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;CACjF,CAAC;AAeF,wBAAgB,aAAa,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE,kBAAkB,2CAsEzE"}

package/dist/modules/discovery/pages/discovery.page.js

@@ -0,0 +1,58 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+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 SCOPE_OPTIONS = [
+    {
+        value: 'amplo',
+        label: 'Mais ampla',
+        description: 'Busca caminhos mais abrangentes em torno do tema informado.',
+    },
+    {
+        value: 'restrito',
+        label: 'Mais restrita',
+        description: 'Foca em recortes mais especificos e direcionados do tema.',
+    },
+];
+export function DiscoveryPage({ onCancel, onComplete }) {
+    const [step, setStep] = useState('theme');
+    const [theme, setTheme] = useState('');
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    useInput((input, key) => {
+        if (key.escape) {
+            onCancel();
+            return;
+        }
+        if (step !== 'scope') {
+            return;
+        }
+        if (key.upArrow) {
+            setSelectedIndex((current) => current === 0 ? SCOPE_OPTIONS.length - 1 : current - 1);
+            return;
+        }
+        if (key.downArrow) {
+            setSelectedIndex((current) => current === SCOPE_OPTIONS.length - 1 ? 0 : current + 1);
+            return;
+        }
+        if (key.return) {
+            const option = SCOPE_OPTIONS[selectedIndex];
+            if (option) {
+                onComplete({
+                    scope: option.value,
+                    theme: theme.trim(),
+                });
+            }
+        }
+    });
+    if (step === 'theme') {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(StepHeader, { title: "Qual e o tema da descoberta?", subtitle: "Digite o tema e pressione Enter para continuar." }), _jsx(TextField, { placeholder: "Ex.: IA generativa", value: theme, onChange: setTheme, onSubmit: (value) => {
+                        if (value.trim()) {
+                            setTheme(value);
+                            setStep('scope');
+                        }
+                    } }), _jsx(Text, { dimColor: true, children: "Esc volta para o menu inicial." })] }));
+    }
+    return (_jsx(ActionMenuPage, { title: "Como voce quer seguir com esse tema?", subtitle: `Tema selecionado: "${theme.trim()}". Escolha o tipo de exploracao.`, options: SCOPE_OPTIONS, selectedIndex: selectedIndex, hintText: "Use as setas para navegar. Enter confirma. Esc volta ao menu." }));
+}

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

@@ -0,0 +1,12 @@
+import { type AuthUser } from '@supabase/supabase-js';
+import { type AuthService } from '../../auth/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/profile/pages/profile.page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.page.d.ts","sourceRoot":"","sources":["../../../../src/modules/profile/pages/profile.page.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGtD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qCAAqC,CAAC;AAOvE,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"}