qaos 0.0.1 → 0.0.2

package/dist/app.d.ts

@@ -1,2 +1,3 @@
 import React from 'react';
-export default function App(): React.JSX.Element;
+import { AppProps } from './types/app-props.js';
+export default function App(args: AppProps): React.JSX.Element;

package/dist/app.js

@@ -1,5 +1,255 @@
-import React from 'react';
+import React, { useEffect, useState } from 'react';
 import Splash from './components/landing/splash.js';
-export default function App() {
-    return React.createElement(Splash, null);
+import { Text } from 'ink';
+import { run, runWorkflow, getActions } from './entry-functions.js';
+import RunUi, { RunConnecting, RunError } from './components/run/run-ui.js';
+import SettingsUI from './components/settings/settings-ui.js';
+import { useLanguage } from './contexts/language-context.js';
+import AuthUI from './components/auth/auth-ui.js';
+import HistUI from './components/hist/hist-ui.js';
+import { authenticate, logout, getAuthStatus } from './commands/auth.js';
+// Exit delay constants (in milliseconds)
+const EXIT_DELAY_SUCCESS = 1000;
+const EXIT_DELAY_INFO = 1500;
+const EXIT_DELAY_ERROR = 2000;
+export default function App(args) {
+    const { input: command, flags } = args.args;
+    const { t } = useLanguage();
+    const [runResult, setRunResult] = useState(null);
+    const [loading, setLoading] = useState(false);
+    const [runUiState, setRunUiState] = useState(null);
+    const [authStatus, setAuthStatus] = useState('idle');
+    const [authMessage, setAuthMessage] = useState('');
+    const [authError, setAuthError] = useState('');
+    const createInitialRunUiState = () => ({
+        phase: 'idle',
+        connection: 'connecting',
+        thinking: '',
+        tasks: [],
+        actions: [],
+    });
+    const reduceRunUiState = (prevState, event) => {
+        const baseState = prevState ?? createInitialRunUiState();
+        switch (event.type) {
+            case 'config_loaded':
+                return {
+                    ...baseState,
+                    tasks: event.tasks,
+                };
+            case 'connection_status':
+                return {
+                    ...baseState,
+                    connection: event.status,
+                    phase: event.status === 'connected'
+                        ? 'connected'
+                        : baseState.phase === 'idle'
+                            ? 'connecting'
+                            : baseState.phase,
+                };
+            case 'run_started':
+                return {
+                    ...baseState,
+                    phase: 'running',
+                    runId: event.runId,
+                    reportUrl: event.reportUrl,
+                    errorMessage: undefined,
+                };
+            case 'run_completed':
+                return {
+                    ...baseState,
+                    phase: 'completed',
+                };
+            case 'server_state': {
+                const taskStatusMap = event.taskStatus ?? {};
+                const updatedTasks = baseState.tasks.length > 0
+                    ? baseState.tasks.map(task => ({
+                        ...task,
+                        status: taskStatusMap[task.id] ?? task.status,
+                    }))
+                    : Object.keys(taskStatusMap).map(taskId => ({
+                        id: taskId,
+                        description: `Task ${taskId}`,
+                        status: taskStatusMap[taskId],
+                    }));
+                return {
+                    ...baseState,
+                    thinking: event.thinking,
+                    tasks: updatedTasks,
+                    actions: event.actions ?? baseState.actions,
+                    qaosProgress: event.qaosProgress ?? baseState.qaosProgress,
+                };
+            }
+            case 'error':
+                return {
+                    ...baseState,
+                    phase: 'error',
+                    errorMessage: event.message,
+                };
+            default:
+                return baseState;
+        }
+    };
+    useEffect(() => {
+        if (command === 'run') {
+            setRunUiState(createInitialRunUiState());
+            run({
+                configFilePath: flags.config || './qaos-config.json',
+                headed: flags.headed,
+                onUiEvent: event => {
+                    setRunUiState(prevState => reduceRunUiState(prevState, event));
+                },
+            }, t)
+                .then(res => {
+                setRunResult(res);
+            })
+                .catch(err => {
+                setRunResult({ error: err.message });
+                setRunUiState(prevState => reduceRunUiState(prevState, {
+                    type: 'error',
+                    message: err.message,
+                }));
+            });
+        }
+        if (command === 'workflow') {
+            setLoading(true);
+            const actions = getActions();
+            runWorkflow(actions, t)
+                .then(res => {
+                setRunResult(res);
+                setLoading(false);
+            })
+                .catch(err => {
+                setRunResult({ error: err.message });
+                setLoading(false);
+            });
+        }
+        if (command === 'auth') {
+            setAuthStatus('validating');
+            setAuthMessage(t('run.processingAuth'));
+            (async () => {
+                try {
+                    // Handle logout
+                    if (flags.logout) {
+                        const result = await logout(t);
+                        setAuthMessage(result.message);
+                        setAuthStatus('success');
+                        setTimeout(() => process.exit(0), EXIT_DELAY_SUCCESS);
+                        return;
+                    }
+                    // Handle API token authentication
+                    if (flags.api) {
+                        const result = await authenticate({
+                            method: 'api',
+                            token: flags.api,
+                        }, t);
+                        setAuthMessage(result.message);
+                        if (result.success) {
+                            setAuthStatus('success');
+                            setTimeout(() => process.exit(0), EXIT_DELAY_SUCCESS);
+                        }
+                        else {
+                            setAuthStatus('error');
+                            setAuthError(result.error || t('auth.unknownError'));
+                            setTimeout(() => process.exit(1), EXIT_DELAY_ERROR);
+                        }
+                        return;
+                    }
+                    // Handle UI authentication (default when no flags provided and not authenticated)
+                    const status = await getAuthStatus();
+                    if (!status.authenticated) {
+                        // User is not authenticated, initiate UI auth flow
+                        setAuthStatus('validating');
+                        setAuthMessage(t('run.openingBrowser'));
+                        const result = await authenticate({
+                            method: 'ui',
+                            onProgress: (authStatus) => {
+                                if (authStatus === 'opening_browser') {
+                                    setAuthMessage(t('run.openingBrowserShort'));
+                                }
+                                else if (authStatus === 'waiting_auth') {
+                                    setAuthMessage(t('run.waitingAuth'));
+                                    setAuthStatus('validating');
+                                }
+                                else if (authStatus === 'success') {
+                                    setAuthMessage(t('run.authComplete'));
+                                    setAuthStatus('success');
+                                }
+                            },
+                        }, t);
+                        setAuthMessage(result.message);
+                        if (result.success) {
+                            setAuthStatus('success');
+                            setTimeout(() => process.exit(0), EXIT_DELAY_SUCCESS);
+                        }
+                        else {
+                            setAuthStatus('error');
+                            setAuthError(result.error || t('auth.unknownError'));
+                            setTimeout(() => process.exit(1), EXIT_DELAY_ERROR);
+                        }
+                    }
+                    else {
+                        // User is already authenticated, show status
+                        setAuthMessage(t('auth.alreadyLoggedIn'));
+                        setAuthStatus('success');
+                        setTimeout(() => process.exit(0), EXIT_DELAY_INFO);
+                    }
+                }
+                catch (err) {
+                    setAuthStatus('error');
+                    setAuthMessage('Authentication failed');
+                    setAuthError(err instanceof Error ? err.message : t('auth.unknownError'));
+                    setTimeout(() => process.exit(1), EXIT_DELAY_ERROR);
+                }
+            })();
+        }
+    }, [command]);
+    switch (command) {
+        case undefined:
+            return React.createElement(Splash, null);
+        case 'run':
+            if (!runUiState)
+                return React.createElement(Text, null, t('run.preparing'));
+            if (runUiState.phase === 'error') {
+                return (React.createElement(RunError, { message: runUiState.errorMessage || t('auth.unknownError') }));
+            }
+            if (runUiState.phase === 'completed') {
+                // TODO : Antoine rendre ca mieux
+                setTimeout(() => {
+                    process.exit(0);
+                }, EXIT_DELAY_SUCCESS);
+                return (React.createElement(React.Fragment, null,
+                    React.createElement(Text, { color: "green", bold: true }, t('workflow.allTasksComplete')),
+                    runUiState.reportUrl && (React.createElement(Text, null,
+                        t('run.reportReady'),
+                        ' ',
+                        React.createElement(Text, { color: "cyan", bold: true }, `\x1b]8;;${runUiState.reportUrl}\x07${runUiState.reportUrl}\x1b]8;;\x07`))),
+                    React.createElement(Text, { dimColor: true }, t('workflow.exiting'))));
+            }
+            if (runUiState.phase !== 'running') {
+                return React.createElement(RunConnecting, { uiState: runUiState });
+            }
+            return React.createElement(RunUi, { uiState: runUiState });
+        case 'workflow':
+            if (loading)
+                return React.createElement(Text, null, t('run.executing'));
+            if (!runResult)
+                return React.createElement(Text, null, t('run.noResult'));
+            if (runResult.error) {
+                return React.createElement(Text, { color: "red" },
+                    "Error: ",
+                    runResult.error);
+            }
+            // Workflow outputs to console, just show completion message
+            return (React.createElement(React.Fragment, null,
+                React.createElement(Text, { color: "green", bold: true }, t('run.complete')),
+                React.createElement(Text, null, t('run.checkConsole'))));
+        case 'hist':
+            return (React.createElement(HistUI, { limit: flags.limit, projectId: flags.project }));
+        case 'auth':
+            return (React.createElement(AuthUI, { status: authStatus, message: authMessage, errorMessage: authError }));
+        case 'settings':
+            return React.createElement(SettingsUI, { onExit: () => process.exit(0) });
+        default:
+            return React.createElement(Text, { color: "red" }, t('errors.unknownCommand', { command }));
+    }
 }

package/dist/cli.js

@@ -1,25 +1,97 @@
 #!/usr/bin/env node
-import React from 'react';
-import { render } from 'ink';
-// import meow from 'meow';
-import App from './app.js';
-// const cli = meow(
-// 	`
-// 	Usage
-// 	  $ qaos
-// 	Options
-// 		--name  Your name
-// 	Examples
-// 	  $ qaos --name=Jane
-// 	  Hello, Jane
-// `,
-// 	{
-// 		importMeta: import.meta,
-// 		flags: {
-// 			name: {
-// 				type: 'string',
-// 			},
-// 		},
-// 	},
-// );
-render(React.createElement(App, null));
+const originalEmitWarning = process.emitWarning.bind(process);
+process.emitWarning = ((warning, ...args) => {
+    const warningMessage = typeof warning === 'string' ? warning : warning.message;
+    const warningTypeOutput = typeof args[0] === 'string' ? args[0] : undefined;
+    const warningType = typeof warning === 'string' ? warningTypeOutput : warning.name;
+    if (warningType === 'ExperimentalWarning' &&
+        warningMessage.includes('Importing JSON modules is an experimental feature')) {
+        return;
+    }
+    return originalEmitWarning(warning, ...args);
+});
+const [{ default: React }, { render, Text }, { default: meow }, { default: App }, { getHelpInstructions }, { validCommands }, { LanguageProvider }, { authService }, { createTranslator },] = await Promise.all([
+    import('react'),
+    import('ink'),
+    import('meow'),
+    import('./app.js'),
+    import('./constants/help-instructions.js'),
+    import('./constants/commands.js'),
+    import('./contexts/language-context.js'),
+    import('./services/auth-service.js'),
+    import('./i18n/language-service.js'),
+]);
+// Load language preference synchronously for CLI initialization
+const userLanguage = authService.getLanguageSync();
+const t = createTranslator(userLanguage);
+const cli = meow(getHelpInstructions(t), {
+    importMeta: import.meta,
+    flags: {
+        config: {
+            type: 'string',
+            alias: 'c',
+            description: 'Path to config file (default: ./qaos-config.json)',
+        },
+        headed: {
+            type: 'boolean',
+            alias: 'h',
+            description: 'Run browser in headed mode (default: headless)',
+            default: false,
+        },
+        api: {
+            type: 'string',
+            alias: 'a',
+            description: 'Authenticate with API token',
+        },
+        ui: {
+            type: 'boolean',
+            alias: 'u',
+            description: 'Authenticate with browser UI (OAuth)',
+            default: false,
+        },
+        logout: {
+            type: 'boolean',
+            description: 'Logout and remove credentials',
+            default: false,
+        },
+        settings: {
+            type: 'boolean',
+            alias: 's',
+            description: 'Open settings interface',
+            default: false,
+        },
+        limit: {
+            type: 'number',
+            alias: 'l',
+            description: 'Number of recent runs to display (default: 10, max: 50)',
+        },
+        project: {
+            type: 'string',
+            alias: 'p',
+            description: 'Filter runs by project ID',
+        },
+    },
+});
+const command = cli.input[0];
+if (cli.input.length > 1 && !validCommands.includes(command)) {
+    render(React.createElement(LanguageProvider, null,
+        React.createElement(Text, { color: "red" },
+            "Error: Unknown command '$",
+            command,
+            "'. Use 'qaos --help' for details.")));
+    process.exit(1);
+}
+render(React.createElement(LanguageProvider, null,
+    React.createElement(App, { args: {
+            input: command,
+            flags: {
+                ...cli.flags,
+                api: cli.flags['api'],
+                ui: cli.flags['ui'],
+                logout: cli.flags['logout'],
+                settings: cli.flags['settings'],
+                limit: cli.flags['limit'],
+                project: cli.flags['project'],
+            },
+        } })));
+export {};

package/dist/commands/auth.d.ts

@@ -0,0 +1,41 @@
+type TranslationFunction = (key: string, params?: Record<string, string | number>) => string;
+export interface AuthArgs {
+    method?: 'api' | 'ui';
+    token?: string;
+    onProgress?: (status: 'opening_browser' | 'waiting_auth' | 'success') => void;
+}
+/**
+ * Handle CLI authentication via browser UI
+ * Opens a browser to the auth page and captures the token from a local server
+ */
+export declare function authenticateViaUI(websiteUrl: string, t: TranslationFunction, onProgress?: (status: 'opening_browser' | 'waiting_auth' | 'success') => void): Promise<{
+    success: boolean;
+    message: string;
+    token?: string;
+    error?: string;
+}>;
+/**
+ * Handle CLI authentication
+ * Supports both API token and UI-based authentication
+ */
+export declare function authenticate(args: AuthArgs, t: TranslationFunction): Promise<{
+    success: boolean;
+    message: string;
+    error?: string;
+    token?: string;
+}>;
+/**
+ * Get current authentication status
+ */
+export declare function getAuthStatus(): Promise<{
+    authenticated: boolean;
+    serverUrl?: string;
+}>;
+/**
+ * Clear authentication (logout)
+ */
+export declare function logout(t: TranslationFunction): Promise<{
+    success: boolean;
+    message: string;
+}>;
+export {};

package/dist/commands/auth.js

@@ -0,0 +1,137 @@
+import { authService } from '../services/auth-service.js';
+import { startAuthServer } from '../services/auth-server.js';
+import open from 'open';
+import { randomBytes } from 'crypto';
+import { configPromise } from '../config.js';
+/**
+ * Handle CLI authentication via browser UI
+ * Opens a browser to the auth page and captures the token from a local server
+ */
+export async function authenticateViaUI(websiteUrl, t, onProgress) {
+    const callbackPort = 9999;
+    try {
+        // Start local server to receive auth callback
+        onProgress?.('opening_browser');
+        const allowedOrigin = new URL(websiteUrl).origin;
+        const callbackState = randomBytes(16).toString('hex');
+        const authServer = await startAuthServer(callbackPort, {
+            allowedOrigin,
+            callbackState,
+        });
+        const callbackUrl = authServer.getCallbackUrl();
+        // Build auth URL with callback
+        const authUrl = new URL('/cli-auth', websiteUrl);
+        authUrl.searchParams.set('callback_url', callbackUrl);
+        // Open browser
+        await open(authUrl.toString());
+        onProgress?.('waiting_auth');
+        // Wait for token from browser
+        const tokenData = await Promise.race([
+            authServer.waitForToken(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(t('auth.timeout'))), 5 * 60 * 1000)),
+        ]);
+        await authServer.close();
+        // Validate and save token
+        const validationResult = await authService.validateToken(tokenData.token, websiteUrl);
+        if (!validationResult.valid) {
+            return {
+                success: false,
+                message: t('auth.tokenValidationFailed'),
+                error: validationResult.error || t('auth.invalidToken'),
+            };
+        }
+        await authService.saveToken(tokenData.token, websiteUrl, validationResult.userId);
+        onProgress?.('success');
+        return {
+            success: true,
+            message: t('auth.successWithPath', {
+                path: authService.getAuthFilePath(),
+            }),
+            token: tokenData.token,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: 'Authentication failed',
+            error: error instanceof Error ? error.message : t('auth.unknownError'),
+        };
+    }
+}
+/**
+ * Handle CLI authentication
+ * Supports both API token and UI-based authentication
+ */
+export async function authenticate(args, t) {
+    try {
+        const method = args.method || 'ui ';
+        const config = await configPromise;
+        const serverUrl = config.API_SERVER_URL;
+        const websiteUrl = config.WEBSITE_URL;
+        if (method === 'api') {
+            if (!args.token) {
+                return {
+                    success: false,
+                    message: t('auth.noTokenProvided'),
+                    error: t('auth.usage'),
+                };
+            }
+            const validationResult = await authService.validateToken(args.token, serverUrl);
+            if (!validationResult.valid) {
+                return {
+                    success: false,
+                    message: t('auth.tokenValidationFailed'),
+                    error: validationResult.error || t('auth.invalidToken'),
+                };
+            }
+            await authService.saveToken(args.token, serverUrl, validationResult.userId);
+            return {
+                success: true,
+                message: t('auth.successWithPath', {
+                    path: authService.getAuthFilePath(),
+                }),
+                token: args.token,
+            };
+        }
+        else {
+            // UI method - open browser for authentication
+            return await authenticateViaUI(websiteUrl, t, args.onProgress);
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: 'Authentication failed',
+            error: error instanceof Error ? error.message : t('auth.unknownError'),
+        };
+    }
+}
+/**
+ * Get current authentication status
+ */
+export async function getAuthStatus() {
+    const isAuthenticated = await authService.isAuthenticated();
+    const serverUrl = await authService.getServerUrl();
+    return {
+        authenticated: isAuthenticated,
+        serverUrl: serverUrl || undefined,
+    };
+}
+/**
+ * Clear authentication (logout)
+ */
+export async function logout(t) {
+    try {
+        await authService.clearAuth();
+        return {
+            success: true,
+            message: t('auth.logoutSuccess'),
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Failed to logout: ${error instanceof Error ? error.message : t('auth.unknownError')}`,
+        };
+    }
+}

package/dist/commands/hist.d.ts

@@ -0,0 +1,21 @@
+export interface RunSummary {
+    id: string;
+    project_id: string;
+    title: string;
+    site_url: string;
+    status: string;
+    score: number | null;
+    problem_count: number;
+    test_count: number;
+    length_ms: number;
+    created_at: string;
+}
+export interface FetchRunsResult {
+    success: boolean;
+    runs?: RunSummary[];
+    error?: string;
+}
+export declare function fetchRuns(options: {
+    limit?: number;
+    projectId?: string;
+}): Promise<FetchRunsResult>;

package/dist/commands/hist.js

@@ -0,0 +1,41 @@
+import { authService } from '../services/auth-service.js';
+import { configPromise } from '../config.js';
+export async function fetchRuns(options) {
+    const token = await authService.getAccessToken();
+    if (!token) {
+        return { success: false, error: 'not_authenticated' };
+    }
+    const defaultServerUrl = (await configPromise).API_SERVER_URL;
+    const serverUrl = (await authService.getServerUrl()) || defaultServerUrl;
+    const url = new URL('/api/cli/runs', serverUrl);
+    if (options.limit) {
+        url.searchParams.set('limit', String(options.limit));
+    }
+    if (options.projectId) {
+        url.searchParams.set('projectId', options.projectId);
+    }
+    try {
+        const response = await fetch(url.toString(), {
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        const data = (await response.json());
+        if (!response.ok) {
+            if (response.status === 404) {
+                return {
+                    success: false,
+                    error: `project_not_found:${options.projectId}`,
+                };
+            }
+            return { success: false, error: data.error || `HTTP ${response.status}` };
+        }
+        return { success: true, runs: data.runs || [] };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `network_error:${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}

package/dist/components/auth/auth-ui.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export type AuthStatus = 'idle' | 'validating' | 'success' | 'error';
+export interface AuthUIProps {
+    status: AuthStatus;
+    message: string;
+    errorMessage?: string;
+}
+export default function AuthUI({ status, message, errorMessage }: AuthUIProps): React.JSX.Element;