minara 0.1.3 → 0.1.5

package/dist/api/auth.d.ts

@@ -1,4 +1,4 @@
-import type { EmailCodeDto, EmailVerifyDto, AuthUser, FavoriteTokensPayload, OAuthProvider } from '../types.js';
+import type { EmailCodeDto, EmailVerifyDto, AuthUser, FavoriteTokensPayload, OAuthProvider, DeviceAuthStartResponse, DeviceAuthStatusResponse } from '../types.js';
 /** Send email verification code */
 export declare function sendEmailCode(dto: EmailCodeDto): Promise<import("../types.js").ApiResponse<void>>;
 /** Verify email code → returns user + access_token */
@@ -28,3 +28,7 @@ export declare function addFavoriteTokens(token: string, payload: FavoriteTokens
 }>>;
 /** Get invite history */
 export declare function getInviteHistory(token: string): Promise<import("../types.js").ApiResponse<Record<string, unknown>[]>>;
+/** Start device authorization flow */
+export declare function startDeviceAuth(): Promise<import("../types.js").ApiResponse<DeviceAuthStartResponse>>;
+/** Poll device authorization status */
+export declare function getDeviceAuthStatus(deviceCode: string): Promise<import("../types.js").ApiResponse<DeviceAuthStatusResponse>>;

package/dist/api/auth.js

@@ -44,3 +44,14 @@ export function addFavoriteTokens(token, payload) {
 export function getInviteHistory(token) {
     return get('/auth/invite-history', { token });
 }
+// ─── Device Authorization Flow (RFC 8628) ─────────────────────────────────
+/** Start device authorization flow */
+export function startDeviceAuth() {
+    return post('/auth/device/start');
+}
+/** Poll device authorization status */
+export function getDeviceAuthStatus(deviceCode) {
+    return post('/auth/device/status', {
+        body: { device_code: deviceCode },
+    });
+}

package/dist/api/chat.js

@@ -11,7 +11,9 @@ export async function sendChatStream(token, dto) {
             'Content-Type': 'application/json',
             'Accept': 'text/event-stream',
             'Authorization': `Bearer ${token}`,
-            'origin': 'https://minara.ai',
+            'Origin': 'https://minara.ai',
+            'Referer': 'https://minara.ai/',
+            'User-Agent': 'Minara-CLI/1.0',
         },
         body: JSON.stringify(dto),
     });

package/dist/api/client.js

@@ -22,6 +22,9 @@ async function requestImpl(path, opts, isRetry) {
     const headers = {
         'Content-Type': 'application/json',
         'Accept': 'application/json',
+        'Origin': 'https://minara.ai',
+        'Referer': 'https://minara.ai/',
+        'User-Agent': 'Minara-CLI/1.0',
         ...extraHeaders,
     };
     if (token) {

package/dist/auth-refresh.js

@@ -42,7 +42,7 @@ export async function attemptReAuth() {
             console.log(chalk.dim(`Sending verification code to ${email}…`));
         }
         // ── Send code ───────────────────────────────────────────────────────
-        const codeRes = await sendEmailCode({ email, platform: 'cli' });
+        const codeRes = await sendEmailCode({ email, platform: 'web' });
         if (!codeRes.success) {
             console.error(chalk.red('✖'), `Failed to send code: ${codeRes.error?.message ?? 'Unknown error'}`);
             return null;
@@ -57,8 +57,8 @@ export async function attemptReAuth() {
         const verifyRes = await verifyEmailCode({
             email,
             code,
-            channel: 'cli',
-            deviceType: 'cli',
+            channel: 'web',
+            deviceType: 'desktop',
         });
         if (!verifyRes.success || !verifyRes.data) {
             console.error(chalk.red('✖'), `Verification failed: ${verifyRes.error?.message ?? 'Invalid code'}`);

package/dist/commands/chat.js

@@ -22,25 +22,58 @@ async function* parseSSE(response) {
             const lines = buffer.split('\n');
             buffer = lines.pop() ?? '';
             for (const line of lines) {
-                if (!line.startsWith('data:'))
+                if (!line)
+                    continue;
+                // Handle AI SDK v5 streaming format: "type:value"
+                // e.g., "0:text", "1:reasoning", "9:tool_call"
+                const colonIndex = line.indexOf(':');
+                if (colonIndex !== -1) {
+                    const type = line.slice(0, colonIndex);
+                    const data = line.slice(colonIndex + 1);
+                    // Type 0 is text content
+                    if (type === '0' && data) {
+                        try {
+                            // Data might be JSON-encoded string like "text" or actual JSON
+                            const parsed = JSON.parse(data);
+                            if (typeof parsed === 'string') {
+                                yield parsed;
+                            }
+                            else if (parsed.text) {
+                                yield parsed.text;
+                            }
+                            else if (parsed.content) {
+                                yield parsed.content;
+                            }
+                        }
+                        catch {
+                            // If parsing fails, treat as raw text
+                            yield data;
+                        }
+                    }
+                    // Type 1 is reasoning (can be skipped or shown differently)
+                    // Type 9 is tool_call (can be skipped for now)
                     continue;
-                const data = line.slice(5).trim();
-                if (data === '[DONE]')
-                    return;
-                try {
-                    const parsed = JSON.parse(data);
-                    const text = parsed?.choices?.[0]?.delta?.content
-                        ?? parsed?.content
-                        ?? parsed?.text
-                        ?? parsed?.data?.text
-                        ?? (typeof parsed === 'string' ? parsed : null);
-                    if (text)
-                        yield text;
                 }
-                catch {
-                    // Non-JSON data line — might be raw text
-                    if (data)
-                        yield data;
+                // Handle standard SSE format: "data:json"
+                if (line.startsWith('data:')) {
+                    const data = line.slice(5).trim();
+                    if (data === '[DONE]')
+                        return;
+                    try {
+                        const parsed = JSON.parse(data);
+                        const text = parsed?.choices?.[0]?.delta?.content
+                            ?? parsed?.content
+                            ?? parsed?.text
+                            ?? parsed?.data?.text
+                            ?? (typeof parsed === 'string' ? parsed : null);
+                        if (text)
+                            yield text;
+                    }
+                    catch {
+                        // Non-JSON data line — might be raw text
+                        if (data)
+                            yield data;
+                    }
                 }
             }
         }
@@ -134,8 +167,31 @@ export const chatCommand = new Command('chat')
             error(`API error ${response.status}: ${body}`);
             return;
         }
-        for await (const chunk of parseSSE(response)) {
-            process.stdout.write(chunk);
+        // Debug: Check if response body exists
+        if (!response.body) {
+            console.log(chalk.dim('(No response body)'));
+            return;
+        }
+        let hasContent = false;
+        try {
+            for await (const chunk of parseSSE(response)) {
+                if (chunk) {
+                    process.stdout.write(chunk);
+                    hasContent = true;
+                }
+            }
+        }
+        catch (err) {
+            // Ignore cancellation errors
+            if (err && typeof err === 'object' && 'name' in err && err.name === 'AbortError') {
+                return;
+            }
+            if (process.env.DEBUG) {
+                console.log(chalk.dim(`\n[Stream error: ${err}]`));
+            }
+        }
+        if (!hasContent) {
+            console.log(chalk.dim('(No response content)'));
         }
         console.log('\n');
     }
@@ -149,6 +205,17 @@ export const chatCommand = new Command('chat')
     console.log(chalk.dim('Type your message. "exit" to quit, "/new" for new chat, "/help" for commands.'));
     console.log('');
     const rl = createInterface({ input: process.stdin, output: process.stdout });
+    // Fix: Pause readline before streaming response to prevent prompt interference
+    async function sendAndPrintWithPause(msg) {
+        rl.pause(); // Pause readline to prevent prompt interference
+        try {
+            await sendAndPrint(msg);
+        }
+        finally {
+            rl.resume(); // Resume readline after streaming is complete
+            process.stdout.write('\n'); // Ensure clean line before next prompt
+        }
+    }
     const prompt = () => new Promise((resolve) => {
         rl.question(chalk.blue('You: '), resolve);
     });
@@ -175,6 +242,6 @@ export const chatCommand = new Command('chat')
             console.log(chalk.dim('  /new  — New conversation\n  /id   — Show chat ID\n  exit  — Quit'));
             continue;
         }
-        await sendAndPrint(userMsg);
+        await sendAndPrintWithPause(userMsg);
     }
 }));

package/dist/commands/login.js

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
 import { input, select, confirm } from '@inquirer/prompts';
 import chalk from 'chalk';
-import { sendEmailCode, verifyEmailCode, getOAuthUrl, getCurrentUser } from '../api/auth.js';
+import { sendEmailCode, verifyEmailCode, getOAuthUrl, getCurrentUser, startDeviceAuth, getDeviceAuthStatus, } from '../api/auth.js';
 import { saveCredentials, loadCredentials } from '../config.js';
 import { success, error, info, warn, spinner, openBrowser, unwrapApi, wrapAction } from '../utils.js';
 import { startOAuthServer } from '../oauth-server.js';
@@ -13,7 +13,7 @@ async function loginWithEmail(emailOpt) {
         validate: (v) => (v.includes('@') ? true : 'Please enter a valid email'),
     });
     const spin = spinner('Sending verification code…');
-    const codeRes = await sendEmailCode({ email, platform: 'cli' });
+    const codeRes = await sendEmailCode({ email, platform: 'web' });
     spin.stop();
     if (!codeRes.success) {
         error(codeRes.error?.message ?? 'Failed to send verification code');
@@ -25,7 +25,7 @@ async function loginWithEmail(emailOpt) {
         validate: (v) => (v.length > 0 ? true : 'Code is required'),
     });
     const spin2 = spinner('Verifying…');
-    const verifyRes = await verifyEmailCode({ email, code, channel: 'cli', deviceType: 'cli' });
+    const verifyRes = await verifyEmailCode({ email, code, channel: 'web', deviceType: 'desktop' });
     spin2.stop();
     const user = unwrapApi(verifyRes, 'Verification failed');
     const token = user.access_token;
@@ -107,12 +107,72 @@ async function loginWithOAuth(provider) {
     if (result.email)
         console.log(chalk.dim(`  ${result.email}`));
 }
+// ─── Device login flow (RFC 8628) ─────────────────────────────────────────
+async function loginWithDevice() {
+    info('Starting device login...');
+    const spin = spinner('Requesting device code...');
+    const startRes = await startDeviceAuth();
+    spin.stop();
+    if (!startRes.success || !startRes.data) {
+        error(startRes.error?.message ?? 'Failed to start device login');
+        process.exit(1);
+    }
+    const { device_code, user_code, verification_url, expires_in, interval } = startRes.data;
+    console.log('');
+    console.log(chalk.bold('To complete login:'));
+    console.log('');
+    console.log(`  1. Visit: ${chalk.cyan(verification_url)}`);
+    console.log(`  2. Enter code: ${chalk.bold.yellow(user_code)}`);
+    console.log('');
+    info(`Waiting for authentication (expires in ${Math.floor(expires_in / 60)} minutes)...`);
+    info(chalk.dim('(Press Ctrl+C to cancel)'));
+    console.log('');
+    // Try to open browser
+    openBrowser(`${verification_url}?user_code=${user_code}`);
+    // Poll for completion
+    const startTime = Date.now();
+    const expiresAt = startTime + expires_in * 1000;
+    let pollInterval = interval * 1000;
+    while (Date.now() < expiresAt) {
+        await new Promise((r) => setTimeout(r, pollInterval));
+        const statusRes = await getDeviceAuthStatus(device_code);
+        if (!statusRes.success || !statusRes.data) {
+            // Network error, keep polling
+            continue;
+        }
+        const data = statusRes.data;
+        const { status, access_token, user } = data;
+        if (status === 'expired') {
+            error('Device login expired. Please try again.');
+            process.exit(1);
+        }
+        if (status === 'completed' && access_token && user) {
+            saveCredentials({
+                accessToken: access_token,
+                userId: user.id,
+                email: user.email,
+                displayName: user.displayName,
+            });
+            success('Login successful! Credentials saved to ~/.minara/');
+            if (user.displayName)
+                console.log(chalk.dim(`  Welcome, ${user.displayName}`));
+            if (user.email)
+                console.log(chalk.dim(`  ${user.email}`));
+            return;
+        }
+        // Still pending, show progress
+        process.stdout.write('.');
+    }
+    error('Device login timed out. Please try again.');
+    process.exit(1);
+}
 // ─── Command ──────────────────────────────────────────────────────────────
 export const loginCommand = new Command('login')
     .description('Login to your Minara account')
     .option('-e, --email <email>', 'Login with email verification code')
     .option('--google', 'Login with Google')
     .option('--apple', 'Login with Apple ID')
+    .option('--device', 'Login with device code (for headless environments)')
     .action(wrapAction(async (opts) => {
     // Warn if already logged in
     const existing = loadCredentials();
@@ -135,13 +195,17 @@ export const loginCommand = new Command('login')
     else if (opts.apple) {
         method = 'apple';
     }
+    else if (opts.device) {
+        method = 'device';
+    }
     else {
         method = await select({
             message: 'How would you like to login?',
             choices: [
-                { name: '📧 Email verification code', value: 'email' },
-                { name: '🔵 Google', value: 'google' },
-                { name: '🍎 Apple ID', value: 'apple' },
+                { name: 'Email verification code', value: 'email' },
+                { name: 'Google', value: 'google' },
+                { name: 'Apple ID', value: 'apple' },
+                { name: 'Device code (for headless environments)', value: 'device' },
             ],
         });
     }
@@ -149,6 +213,9 @@ export const loginCommand = new Command('login')
     if (method === 'email') {
         await loginWithEmail(opts.email);
     }
+    else if (method === 'device') {
+        await loginWithDevice();
+    }
     else {
         await loginWithOAuth(method);
     }

package/dist/types.d.ts

@@ -33,6 +33,18 @@ export interface AuthUser {
     invitationCode?: string;
     mfaSettings?: Record<string, unknown>;
 }
+export interface DeviceAuthStartResponse {
+    device_code: string;
+    user_code: string;
+    verification_url: string;
+    expires_in: number;
+    interval: number;
+}
+export interface DeviceAuthStatusResponse {
+    status: 'pending' | 'completed' | 'expired';
+    access_token?: string;
+    user?: AuthUser;
+}
 export interface FavoriteTokensPayload {
     tokens: string[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minara",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "CLI client for Minara.ai — login, trade, deposit/withdraw, chat and more from your terminal.",
   "type": "module",
   "main": "dist/index.js",