puter-cli 1.8.5 → 2.0.0

package/src/modules/ProfileModule.js

@@ -3,57 +3,54 @@ import inquirer from 'inquirer';
 import Conf from 'conf';
 import chalk from 'chalk';
 import ora from 'ora';
+import {getAuthToken} from "@heyputer/puter.js/src/init.cjs";
+import { puter } from "@heyputer/puter.js";
 
 // project
-import { API_BASE, BASE_URL, NULL_UUID, PROJECT_NAME, getHeaders, reconfigureURLs } from '../commons.js'
-import { getAuthToken, login } from '../commands/auth.js';
+import { BASE_URL, NULL_UUID, PROJECT_NAME, getHeaders, reconfigureURLs } from '../commons.js'
 
 // builtin
 import fs from 'node:fs';
 import crypto from 'node:crypto';
+import { initPuterModule } from './PuterModule.js';
 
 // initializations
 const config = new Conf({ projectName: PROJECT_NAME });
 
-export const ProfileAPI = Symbol('ProfileAPI');
+let profileModule;
 
 function toApiSubdomain(inputUrl) {
     const url = new URL(inputUrl);
     const hostParts = url.hostname.split('.');
-    
+
     // Insert 'api' before the domain
     hostParts.splice(-2, 0, 'api');
     url.hostname = hostParts.join('.');
 
     let output = url.toString();
-    if ( output.endsWith('/') ) {
+    if (output.endsWith('/')) {
         output = output.slice(0, -1);
     }
     return output;
 }
 
 class ProfileModule {
-    constructor({ context }) {
-        this.context = context;
-
-        context.events.on('check-login', async () => {
-            if ( config.get('auth_token') ) {
-                await this.migrateLegacyConfig();
-            }
-            if ( ! config.get('selected_profile') ) {
-                console.log(chalk.cyan('Please login first (or use CTRL+C to exit):'));
-                await this.switchProfileWizard();
-                console.log(chalk.red('Please run "puter" command again (issue #11)'));
-                process.exit(0);
-            }
-            this.applyProfileToGlobals();
-        });
-
+    async checkLogin() {
+        if (config.get('auth_token')) {
+            this.migrateLegacyConfig();
+        }
+        if (!config.get('selected_profile')) {
+            console.log(chalk.cyan('Please login first (or use CTRL+C to exit):'));
+            await this.switchProfileWizard();
+            // re init with new authToken
+            initPuterModule();
+        }
+        this.applyProfileToGlobals();
     }
-    migrateLegacyConfig () {
+    migrateLegacyConfig() {
         const auth_token = config.get('auth_token');
         const username = config.get('username');
-        
+
         this.addProfile({
             host: BASE_URL,
             username,
@@ -61,13 +58,13 @@ class ProfileModule {
             token: auth_token,
             uuid: NULL_UUID,
         });
-        
+
         config.delete('auth_token');
         config.delete('username');
     }
     getDefaultProfile() {
         const auth_token = config.get('auth_token');
-        if ( ! auth_token ) return;
+        if (!auth_token) return;
         return {
             host: 'puter.com',
             username: config.get('username'),
@@ -80,7 +77,7 @@ class ProfileModule {
     }
     addProfile(newProfile) {
         const profiles = [
-            ...this.getProfiles().filter(p => ! p.transient),
+            ...this.getProfiles().filter(p => !p.transient),
             newProfile,
         ];
         config.set('profiles', profiles);
@@ -97,26 +94,25 @@ class ProfileModule {
         return profiles.find(p => p.uuid === uuid);
     }
     applyProfileToGlobals(profile) {
-        if ( ! profile ) profile = this.getCurrentProfile();
+        if (!profile) profile = this.getCurrentProfile();
         reconfigureURLs({
             base: profile.host,
             api: toApiSubdomain(profile.host),
         });
     }
-    getAuthToken () {
+    getAuthToken() {
         const uuid = config.get('selected_profile');
         const profiles = this.getProfiles();
         const profile = profiles.find(v => v.uuid === uuid);
         return profile?.token;
     }
-    
-    async switchProfileWizard (args = {}) {
+
+    async switchProfileWizard(args = {}) {
         const profiles = this.getProfiles();
-        if ( profiles.length < 1 ) {
-            return this.addProfileWizard();
+        if (profiles.length < 1) {
+            return this.addProfileWizard(args);
         }
-        
-        // console.log('doing this branch');
+
         const answer = await inquirer.prompt([
             {
                 name: 'profile',
@@ -136,23 +132,81 @@ class ProfileModule {
                 ]
             }
         ]);
-        
-        if ( answer.profile === 'new' ) {
-            return await this.addProfileWizard();
+
+        if (answer.profile === 'new') {
+            return await this.addProfileWizard(args);
         }
-        
+
         this.selectProfile(answer.profile);
     }
 
-    async addProfileWizard (args = {}) {
+    async addProfileWizard(args = {}) {
+        const host = args.host || 'https://puter.com';
+
+        if (args.withCredentials) {
+            return await this.credentialLogin({ ...args, host });
+        }
+
+        // Browser-based login (default)
+        return await this.browserLogin({ ...args, host });
+    }
+
+    async browserLogin(args) {
+        const { host, save } = args;
+        const TIMEOUT_MS = 60000; // 1 minute timeout
+        let spinner;
+
+        try {
+            spinner = ora('Opening browser for login...').start();
+
+            const timeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => reject(new Error('Login timed out after 60 seconds')), TIMEOUT_MS);
+            });
+
+            const authToken = await Promise.race([
+                getAuthToken(),
+                timeoutPromise
+            ]);
+
+            if (!authToken) {
+                spinner.fail(chalk.red('Login failed or was cancelled.'));
+                return;
+            }
+
+            spinner.text = 'Fetching user info...';
+
+            // Set token and fetch user info
+            puter.setAuthToken(authToken);
+            const userInfo = await puter.auth.getUser();
+
+            const profileUUID = crypto.randomUUID();
+            const profile = {
+                host,
+                username: userInfo.username,
+                cwd: `/${userInfo.username}`,
+                token: authToken,
+                uuid: profileUUID,
+            };
+
+            this.addProfile(profile);
+            this.selectProfile(profile);
+            spinner.succeed(chalk.green(`Successfully logged in as ${userInfo.username}!`));
+
+            // Handle --save option
+            this.saveTokenToEnv(authToken, save);
+        } catch (error) {
+            if (spinner) {
+                spinner.fail(chalk.red(`Failed to login: ${error.message}`));
+            } else {
+                console.error(chalk.red(`Failed to login: ${error.message}`));
+            }
+        }
+    }
+
+    async credentialLogin(args) {
+        const { host, save } = args;
+
         const answers = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'host',
-                message: 'Host (leave blank for puter.com):',
-                default: 'https://puter.com',
-                validate: input => input.length >= 1 || 'Host is required'
-            },
             {
                 type: 'input',
                 name: 'username',
@@ -172,103 +226,109 @@ class ProfileModule {
         try {
             spinner = ora('Logging in to Puter...').start();
 
-            const response = await fetch(`${answers.host}/login`, {
+            const apiHost = toApiSubdomain(host);
+            const response = await fetch(`${apiHost}/login`, {
                 method: 'POST',
                 headers: getHeaders(),
                 body: JSON.stringify({
                     username: answers.username,
-                    password: answers.password
-                })
+                    password: answers.password,
+                }),
             });
 
+            const data = await response.json();
 
-            const contentType = response.headers.get('content-type');
-            //console.log('content type?', '|' + contentType + '|');
-
-            // TODO: proper content type parsing
-            if ( ! contentType.trim().startsWith('application/json') ) {
-                throw new Error(await response.text());
-            }
-
-            let data = await response.json();
-
-            while (data.proceed && data.next_step) {
-                if (data.next_step === 'otp') {
-                    spinner.succeed(chalk.green('2FA is enabled'));
-                    const answers2FA = await inquirer.prompt([
-                        {
-                            type: 'input',
-                            name: 'otp',
-                            message: 'Authenticator Code:',
-                            validate: input => input.length === 6 || 'OTP must be 6 digits'
-                        }
-                    ]);
-                    spinner = ora('Logging in to Puter...').start();
-                    const response = await fetch(`${answers.host}/login/otp`, {
-                        method: 'POST',
-                        headers: getHeaders(),
-                        body: JSON.stringify({
-                            token: data.otp_jwt_token,
-                            code: answers2FA.otp,
-                        }),
-                    });
-                    data = await response.json();
-                    continue;
-                }
+            if (data.proceed && data.next_step === 'otp') {
+                // Handle 2FA
+                spinner.stop();
+                const otpAnswer = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'otp',
+                        message: 'Enter your 2FA code:',
+                        validate: input => input.length >= 1 || '2FA code is required'
+                    }
+                ]);
 
-                if (data.next_step === 'complete') break;
+                spinner = ora('Verifying 2FA code...').start();
+                const otpResponse = await fetch(`${apiHost}/login/otp`, {
+                    method: 'POST',
+                    headers: getHeaders(),
+                    body: JSON.stringify({
+                        token: data.otp_jwt_token,
+                        code: otpAnswer.otp,
+                    }),
+                });
 
-                spinner.fail(chalk.red(`Unrecognized login step "${data.next_step}"; you might need to update puter-cli.`));
-                return;
-            }
+                const otpData = await otpResponse.json();
 
-            if (data.proceed && data.token) {
-                const profileUUID = crypto.randomUUID();
-                const profile = {
-                    host: answers.host,
-                    username: answers.username,
-                    cwd: `/${answers.username}`,
-                    token: data.token,
-                    uuid: profileUUID,
-                };
-                this.addProfile(profile);
-                this.selectProfile(profile);
-                if (spinner) {
-                    spinner.succeed(chalk.green('Successfully logged in to Puter!'));
-                }
-                console.log(chalk.dim(`Token: ${data.token.slice(0, 5)}...${data.token.slice(-5)}`));
-                // Save token
-                if (args.save) {
-                    const localEnvFile = '.env';
-                    try {
-                        // Check if the file exists, if so then append the api key to the EOF.
-                        if (fs.existsSync(localEnvFile)) {
-                            console.log(chalk.yellow(`File "${localEnvFile}" already exists... Adding token.`));
-                            fs.appendFileSync(localEnvFile, `\nPUTER_API_KEY="${data.token}"`, 'utf8');
-                        } else {
-                            console.log(chalk.cyan(`Saving token to ${chalk.green(localEnvFile)} file.`));
-                            fs.writeFileSync(localEnvFile, `PUTER_API_KEY="${data.token}"`, 'utf8');
-                        }
-                    } catch (error) {
-                        console.error(chalk.red(`Cannot save token to .env file. Error: ${error.message}`));
-                        console.log(chalk.cyan(`PUTER_API_KEY="${data.token}"`));
-                    }
+                if (otpData.token) {
+                    this.createProfileFromToken(otpData.token, answers.username, host, spinner, save);
+                } else {
+                    spinner.fail(chalk.red('2FA verification failed.'));
                 }
+            } else if (data.token) {
+                this.createProfileFromToken(data.token, answers.username, host, spinner, save);
             } else {
-                spinner.fail(chalk.red('Login failed. Please check your credentials.'));
+                spinner.fail(chalk.red(data.error?.message || 'Login failed. Please check your credentials.'));
             }
         } catch (error) {
             if (spinner) {
                 spinner.fail(chalk.red(`Failed to login: ${error.message}`));
-                console.log(error);
             } else {
                 console.error(chalk.red(`Failed to login: ${error.message}`));
             }
         }
     }
+
+    createProfileFromToken(token, username, host, spinner, save) {
+        const profileUUID = crypto.randomUUID();
+        const profile = {
+            host,
+            username,
+            cwd: `/${username}`,
+            token,
+            uuid: profileUUID,
+        };
+
+        this.addProfile(profile);
+        this.selectProfile(profile);
+        spinner.succeed(chalk.green(`Successfully logged in as ${username}!`));
+
+        // Handle --save option
+        this.saveTokenToEnv(token, save);
+    }
+
+    saveTokenToEnv(token, save) {
+        if (!save) return;
+
+        const localEnvFile = '.env';
+        try {
+            if (fs.existsSync(localEnvFile)) {
+                console.log(chalk.yellow(`File "${localEnvFile}" already exists... Adding token.`));
+                fs.appendFileSync(localEnvFile, `\nPUTER_API_KEY="${token}"`, 'utf8');
+            } else {
+                console.log(chalk.cyan(`Saving token to ${chalk.green(localEnvFile)} file.`));
+                fs.writeFileSync(localEnvFile, `PUTER_API_KEY="${token}"`, 'utf8');
+            }
+        } catch (error) {
+            console.error(chalk.red(`Cannot save token to .env file. Error: ${error.message}`));
+            console.log(chalk.cyan(`PUTER_API_KEY="${token}"`));
+        }
+    }
 }
 
-export default ({ context }) => {
-    const module = new ProfileModule({ context });
-    context[ProfileAPI] = module;
-};
+export const initProfileModule = () => {
+    profileModule = new ProfileModule();
+}
+
+/**
+ * Get ProfileModule object
+ * @returns {ProfileModule} ProfileModule - ProfileModule Object.
+ */
+export const getProfileModule = () => {
+    if (!profileModule) {
+        throw new Error("Call initprofileModule() first");
+    }
+    return profileModule;
+}

package/src/modules/PuterModule.js

@@ -0,0 +1,30 @@
+import Conf from "conf";
+import { PROJECT_NAME } from "../commons.js";
+import { puter } from "@heyputer/puter.js";
+
+const config = new Conf({ projectName: PROJECT_NAME });
+
+let puterModule;
+
+export const initPuterModule = () => {
+  const uuid = config.get("selected_profile");
+  const profiles = config.get("profiles") ?? [];
+  const profile = profiles.find((v) => v.uuid === uuid);
+  const authToken = profile?.token;
+
+  if (authToken) {
+    puter.setAuthToken(authToken);
+    puterModule = puter;
+  }
+};
+
+/**
+ * Get Puter object
+ * @returns {puter} puter - Puter Object.
+ */
+export const getPuter = () => {
+  if (!puterModule) {
+    throw new Error("Call initPuterModule() first");
+  }
+  return puterModule;
+};

package/tests/ErrorModule.test.js

@@ -0,0 +1,42 @@
+import { it, describe, expect, vi, beforeEach } from "vitest";
+
+vi.spyOn(console, "log").mockImplementation(() => { });
+vi.spyOn(console, "error").mockImplementation(() => { });
+
+let errors, report, ERROR_BUFFER_LIMIT, showLast;
+
+beforeEach(async () => {
+  vi.resetModules();
+  const module = await import("../src/modules/ErrorModule");
+  errors = module.errors;
+  report = module.report;
+  ERROR_BUFFER_LIMIT = module.ERROR_BUFFER_LIMIT;
+  showLast = module.showLast;
+});
+
+describe("report", () => {
+  it("should be able to report error", () => {
+    report("hehe")
+    expect(errors).toHaveLength(1)
+  })
+
+  it("should not exceed error buffer limit", () => {
+    for (let i = 0; i < 100; i++) {
+      report(`error ${i}`)
+    }
+    expect(errors.length).lessThanOrEqual(ERROR_BUFFER_LIMIT);
+  })
+})
+
+describe("showLast", () => {
+  it("should not log error if no error exists", () => {
+    showLast();
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining("No errors to report"));
+  })
+
+  it("should log error if error exists", () => {
+    report("hehe")
+    showLast();
+    expect(console.error).toHaveBeenCalledWith(expect.stringContaining("hehe"));
+  })
+})