@heyputer/shell 2.1.0 → 3.0.0

package/src/modules/ProfileModule.js

@@ -7,16 +7,21 @@ import {getAuthToken} from "@heyputer/puter.js/src/init.cjs";
 import { puter } from "@heyputer/puter.js";
 
 // project
-import { BASE_URL, NULL_UUID, PROJECT_NAME, getHeaders, reconfigureURLs } from '../commons.js'
+import { HOME, PROJECT_NAME, getHeaders, reconfigureURLs, setHomePath } from '../commons.js'
 
 // builtin
 import fs from 'node:fs';
-import crypto from 'node:crypto';
 import { initPuterModule } from './PuterModule.js';
+import { isAuthError } from './ErrorModule.js';
 
 // initializations
 const config = new Conf({ projectName: PROJECT_NAME });
 
+// Outcomes of a session check against the server.
+const SESSION_OK = 'ok';            // token works; identity refreshed
+const SESSION_INVALID = 'invalid';  // token rejected; the user must log in again
+const SESSION_UNKNOWN = 'unknown';  // unreachable or unexpected reply; assume usable
+
 let profileModule;
 
 function toApiSubdomain(inputUrl) {
@@ -36,9 +41,6 @@ function toApiSubdomain(inputUrl) {
 
 class ProfileModule {
     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();
@@ -46,30 +48,106 @@ class ProfileModule {
             initPuterModule();
         }
         this.applyProfileToGlobals();
+
+        if (await this.refreshIdentity() === SESSION_INVALID) {
+            console.log(chalk.yellow('Your session has expired or its token is no longer valid.'));
+            console.log(chalk.cyan('Please log in again (or use CTRL+C to exit):'));
+            this.dropCurrentProfile();
+            await this.switchProfileWizard();
+            initPuterModule();
+            this.applyProfileToGlobals();
+        }
     }
-    migrateLegacyConfig() {
-        const auth_token = config.get('auth_token');
-        const username = config.get('username');
-
-        this.addProfile({
-            host: BASE_URL,
-            username,
-            cwd: `/${username}`,
-            token: auth_token,
-            uuid: NULL_UUID,
-        });
 
-        config.delete('auth_token');
+    /**
+     * Forget the selected profile, whose token the server has rejected. Keeping
+     * a dead token around only makes the next command fail the same way.
+     */
+    dropCurrentProfile() {
+        const selected = config.get('selected_profile');
+        config.set('profiles', this.getProfiles().filter(p => p.uuid !== selected));
+        config.delete('selected_profile');
         config.delete('username');
+        config.delete('cwd');
     }
-    getDefaultProfile() {
-        const auth_token = config.get('auth_token');
-        if (!auth_token) return;
-        return {
-            host: 'puter.com',
-            username: config.get('username'),
-            token: auth_token,
-        };
+
+
+    /**
+     * Re-read the identity from the server using the current token.
+     *
+     * A username is a mutable display label that the user can change at any
+     * time; the token is the identity. Nothing may depend on the cached username
+     * beyond display, and the cache is refreshed here on every run so it never
+     * silently drifts.
+     */
+    async refreshIdentity() {
+        const profile = this.getCurrentProfile();
+        if (!profile?.token) return SESSION_INVALID;
+
+        try {
+            puter.setAuthToken(profile.token);
+            const userInfo = await puter.auth.getUser();
+            if (!userInfo?.username) return SESSION_UNKNOWN;
+
+            if (userInfo.username !== profile.username) {
+                this.rehomePaths(profile.username, userInfo.username);
+                this.updateProfile(profile.uuid, { username: userInfo.username });
+            }
+            setHomePath(`/${userInfo.username}`);
+            return SESSION_OK;
+        } catch (error) {
+            // A rejected token will not start working again, so say so and let
+            // the caller re-authenticate.
+            if (isAuthError(error)) return SESSION_INVALID;
+
+            // Offline or a transient API failure. Keep the cached label and
+            // carry on rather than forcing a login the user cannot complete.
+            return SESSION_UNKNOWN;
+        }
+    }
+
+
+    /**
+     * Ask the server who a token belongs to.
+     * @param {string} token - The auth token to identify
+     * @returns {Promise<{username: string, uuid: string}>} The account identity
+     */
+    async fetchIdentity(token) {
+        puter.setAuthToken(token);
+        const userInfo = await puter.auth.getUser();
+        if (!userInfo?.username) {
+            throw new Error('The server did not return an account for this token.');
+        }
+        return userInfo;
+    }
+
+    /**
+     * The selected profile's current working directory.
+     * @returns {string} The stored cwd, or the home directory as a fallback
+     */
+    getCwd() {
+        return this.getCurrentProfile()?.cwd || HOME;
+    }
+
+    /**
+     * Record the selected profile's current working directory.
+     * @param {string} cwd - The new working directory
+     */
+    setCwd(cwd) {
+        const profile = this.getCurrentProfile();
+        if (profile) this.updateProfile(profile.uuid, { cwd });
+    }
+
+    /**
+     * Merge a patch into a stored profile, matched by its id.
+     * @param {string} profileId - The `uuid` of the profile to patch
+     * @param {Object} patch - Fields to merge into the profile
+     */
+    updateProfile(profileId, patch) {
+        const profiles = this.getProfiles().map(p => (
+            p.uuid === profileId ? { ...p, ...patch } : p
+        ));
+        config.set('profiles', profiles);
     }
     getProfiles() {
         const profiles = config.get('profiles') ?? [];
@@ -77,15 +155,18 @@ class ProfileModule {
     }
     addProfile(newProfile) {
         const profiles = [
-            ...this.getProfiles().filter(p => !p.transient),
+            // Profiles are keyed by account id, so re-authenticating replaces the
+            // existing entry rather than adding a second one for the same account.
+            ...this.getProfiles().filter(p => !p.transient && p.uuid !== newProfile.uuid),
             newProfile,
         ];
         config.set('profiles', profiles);
     }
     selectProfile(profile) {
         config.set('selected_profile', profile.uuid);
-        config.set('username', `${profile.username}`);
-        config.set('cwd', `/${profile.username}`);
+        if (!profile.cwd) {
+            this.updateProfile(profile.uuid, { cwd: `/${profile.username}` });
+        }
         this.applyProfileToGlobals(profile);
     }
     getCurrentProfile() {
@@ -99,6 +180,36 @@ class ProfileModule {
             base: profile.host,
             api: toApiSubdomain(profile.host),
         });
+        // Provisional home from the cached label, so paths resolve before the
+        // network round-trip; refreshIdentity() re-points it at the live value.
+        setHomePath(`/${profile.username}`);
+    }
+
+    /**
+     * Re-point any stored path that lives under the old home directory at the
+     * new one, after the account was renamed.
+     *
+     * Only the home prefix is rewritten: a cwd under some other user's tree is
+     * left alone, since that path did not move.
+     *
+     * @param {string} oldUsername - The username the paths were written with
+     * @param {string} newUsername - The account's current username
+     */
+    rehomePaths(oldUsername, newUsername) {
+        if (!oldUsername || oldUsername === newUsername) return;
+
+        const oldHome = `/${oldUsername}`;
+        const newHome = `/${newUsername}`;
+        const rehome = p => (
+            p === oldHome || p?.startsWith(`${oldHome}/`)
+                ? `${newHome}${p.slice(oldHome.length)}`
+                : p
+        );
+
+        const profile = this.getCurrentProfile();
+        if (profile?.cwd) {
+            this.updateProfile(profile.uuid, { cwd: rehome(profile.cwd) });
+        }
     }
     getAuthToken() {
         const uuid = config.get('selected_profile');
@@ -179,13 +290,14 @@ class ProfileModule {
             puter.setAuthToken(authToken);
             const userInfo = await puter.auth.getUser();
 
-            const profileUUID = crypto.randomUUID();
             const profile = {
                 host,
+                // Display label only; re-resolved from the token on every run.
                 username: userInfo.username,
                 cwd: `/${userInfo.username}`,
                 token: authToken,
-                uuid: profileUUID,
+                // The account's own id, as reported by the server.
+                uuid: userInfo.uuid,
             };
 
             this.addProfile(profile);
@@ -263,12 +375,12 @@ class ProfileModule {
                 const otpData = await otpResponse.json();
 
                 if (otpData.token) {
-                    this.createProfileFromToken(otpData.token, answers.username, host, spinner, save);
+                    await 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);
+                await this.createProfileFromToken(data.token, answers.username, host, spinner, save);
             } else {
                 spinner.fail(chalk.red(data.error?.message || 'Login failed. Please check your credentials.'));
             }
@@ -281,19 +393,23 @@ class ProfileModule {
         }
     }
 
-    createProfileFromToken(token, username, host, spinner, save) {
-        const profileUUID = crypto.randomUUID();
+    async createProfileFromToken(token, username, host, spinner, save) {
+        // The server is the authority on both the account id and the spelling of
+        // the username, so ask it rather than trusting what was typed.
+        const userInfo = await this.fetchIdentity(token);
         const profile = {
             host,
-            username,
-            cwd: `/${username}`,
+            // Display label only; re-resolved from the token on every run.
+            username: userInfo.username,
+            cwd: `/${userInfo.username}`,
             token,
-            uuid: profileUUID,
+            // The account's own id, as reported by the server.
+            uuid: userInfo.uuid,
         };
 
         this.addProfile(profile);
         this.selectProfile(profile);
-        spinner.succeed(chalk.green(`Successfully logged in as ${username}!`));
+        spinner.succeed(chalk.green(`Successfully logged in as ${userInfo.username}!`));
 
         // Handle --save option
         this.saveTokenToEnv(token, save);

package/src/utils.js

@@ -1,24 +1,3 @@
-import chalk from 'chalk';
-import yargsParser from 'yargs-parser';
-
-/**
- * Convert "2024-10-07T15:03:53.000Z" to "10/7/2024, 15:03:53"
- * @param {Date} value date value
- * @returns formatted date string
- */
-export function formatDate(value) {
-    const date = new Date(value);
-    return date.toLocaleString("en-US", {
-        year: "numeric",
-        month: "2-digit",
-        day: "2-digit",
-        hour: "2-digit",
-        minute: "2-digit",
-        second: "2-digit",
-        hour12: false,
-        timeZone: 'UTC'
-    });
-}
 
 /**
  * Format timestamp to date or time
@@ -52,76 +31,6 @@ export function formatSize(size) {
     return `${size.toFixed(1)} ${units[unit]}`;
 }
 
-/**
- * Display non null values in formatted table
- * @param {Object} data Object to display
- * @returns null
- */
-export function displayNonNullValues(data) {
-    if (typeof data !== 'object' || data === null) {
-      console.error("Invalid input: Input must be a non-null object.");
-      return;
-    }
-    const tableData = [];
-    function flattenObject(obj, parentKey = '') {
-      for (const key in obj) {
-        const value = obj[key];
-        const newKey = parentKey ? `${parentKey}.${key}` : key;
-        if (value !== null) {
-          if (typeof value === 'object') {
-            flattenObject(value, newKey);
-          } else {
-            tableData.push({ key: newKey, value: value });
-          }
-        }
-      }
-    }
-  
-    flattenObject(data);
-    // Determine max key length for formatting
-    const maxKeyLength = tableData.reduce((max, item) => Math.max(max, item.key.length), 0);
-    // Format and output the table
-    console.log(chalk.cyan('-'.repeat(maxKeyLength*3)));
-    console.log(chalk.cyan(`| ${'Key'.padEnd(maxKeyLength)} | Value`));
-    console.log(chalk.cyan('-'.repeat(maxKeyLength*3)));
-    tableData.forEach(item => {
-        const key = item.key.padEnd(maxKeyLength);
-        const value = String(item.value);
-        console.log(chalk.green(`| ${chalk.dim(key)} | ${value}`));
-    });
-    console.log(chalk.cyan('-'.repeat(maxKeyLength*3)));
-    console.log(chalk.cyan(`You have ${chalk.green(tableData.length)} key/value pair(s).`));
-  }
-
-  /**
- * Parse command line arguments including quoted strings
- * @param {string} input Raw command line input
- * @returns {Object} Parsed arguments
- */
-export function parseArgs(input, options = {}) {
-  const result = yargsParser(input, options);
-  return result;
-}
-
-/**
- * Checks if a given string is a valid UUID of any version
- * @param {string} uuid - The string to validate.
- * @returns {boolean} - True if the string is a valid UUID, false otherwise.
- */
-export function isValidAppUuid (uuid) {
-  return uuid.startsWith('app-') && is_valid_uuid4(uuid.slice(4));
-}
-
-/**
- * Checks if a given string is a valid UUID version 4.
- * @param {string} uuid - The string to validate.
- * @returns {boolean} - True if the string is a valid UUID version 4, false otherwise.
- */
-export function is_valid_uuid4 (uuid) {
-  const uuidV4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-  return uuidV4Regex.test(uuid);
-}
-
 /**
  * Get system editor
  * @returns {string} - System editor

package/tests/ErrorModule.test.js

@@ -4,6 +4,7 @@ vi.spyOn(console, "log").mockImplementation(() => { });
 vi.spyOn(console, "error").mockImplementation(() => { });
 
 let errors, report, ERROR_BUFFER_LIMIT, showLast;
+let normalizeError, isAuthError, formatError;
 
 beforeEach(async () => {
   vi.resetModules();
@@ -12,6 +13,9 @@ beforeEach(async () => {
   report = module.report;
   ERROR_BUFFER_LIMIT = module.ERROR_BUFFER_LIMIT;
   showLast = module.showLast;
+  normalizeError = module.normalizeError;
+  isAuthError = module.isAuthError;
+  formatError = module.formatError;
 });
 
 describe("report", () => {
@@ -39,4 +43,72 @@ describe("showLast", () => {
     showLast();
     expect(console.error).toHaveBeenCalledWith(expect.stringContaining("hehe"));
   })
-})
+})
+
+describe('normalizeError', () => {
+  it('should turn a plain rejected object into a real Error', () => {
+    // The shape puter.js rejects with, which Node renders as "#<Object>".
+    const err = normalizeError({ status: 401, message: 'Unauthorized' });
+
+    expect(err).toBeInstanceOf(Error);
+    expect(err.message).toBe('Unauthorized');
+    expect(err.status).toBe(401);
+  });
+
+  it('should unwrap a nested driver error', () => {
+    const err = normalizeError({ error: { code: 'permission_denied', message: 'Nope' } });
+
+    expect(err.message).toBe('Nope');
+    expect(err.code).toBe('permission_denied');
+  });
+
+  it('should fall back to the code when there is no message', () => {
+    expect(normalizeError({ code: 'subject_does_not_exist' }).message)
+      .toBe('subject_does_not_exist');
+  });
+
+  it('should never render an object as "#<Object>"', () => {
+    const err = normalizeError({ status: 500 });
+
+    expect(err.message).not.toContain('#<Object>');
+    expect(err.message).toBe('{"status":500}');
+  });
+
+  it('should pass an Error through untouched', () => {
+    const original = new Error('boom');
+    expect(normalizeError(original)).toBe(original);
+  });
+
+  it('should handle non-object throws', () => {
+    expect(normalizeError('bad thing').message).toBe('bad thing');
+    expect(normalizeError(undefined).message).toBe('Unknown error');
+  });
+});
+
+describe('isAuthError', () => {
+  it('should detect the 401 that puter.js rejects with', () => {
+    expect(isAuthError({ status: 401, message: 'Unauthorized' })).toBe(true);
+  });
+
+  it('should detect a 403', () => {
+    expect(isAuthError({ status: 403, message: 'Forbidden' })).toBe(true);
+  });
+
+  it('should detect token failure codes', () => {
+    expect(isAuthError({ code: 'token_auth_failed' })).toBe(true);
+    expect(isAuthError({ error: { code: 'invalid_token' } })).toBe(true);
+  });
+
+  it('should not flag unrelated failures', () => {
+    expect(isAuthError({ status: 500, message: 'Server error' })).toBe(false);
+    expect(isAuthError({ code: 'subject_does_not_exist' })).toBe(false);
+    expect(isAuthError(new Error('ENOTFOUND api.puter.com'))).toBe(false);
+    expect(isAuthError(undefined)).toBe(false);
+  });
+});
+
+describe('formatError', () => {
+  it('should give a readable message for a rejected plain object', () => {
+    expect(formatError({ status: 401, message: 'Unauthorized' })).toBe('Unauthorized');
+  });
+});

package/tests/ProfileModule.test.js

@@ -17,11 +17,12 @@ vi.mock('conf', () => {
 });
 
 vi.mock('../src/commons.js', () => ({
-  BASE_URL: 'https://puter.com',
-  NULL_UUID: '00000000-0000-0000-0000-000000000000',
-  PROJECT_NAME: 'puter-cli',
+  HOME: '~',
+  PROJECT_NAME: 'puter-sh',
   getHeaders: vi.fn(() => ({ 'Content-Type': 'application/json' })),
   reconfigureURLs: vi.fn(),
+  setHomePath: vi.fn(),
+  expandHome: vi.fn((p) => p),
 }));
 
 vi.mock('./PuterModule.js', () => ({
@@ -137,8 +138,12 @@ describe('ProfileModule.selectProfile', () => {
     profileModule.selectProfile(profile);
 
     expect(mockConfig.set).toHaveBeenCalledWith('selected_profile', 'test-uuid');
-    expect(mockConfig.set).toHaveBeenCalledWith('username', 'testuser');
-    expect(mockConfig.set).toHaveBeenCalledWith('cwd', '/testuser');
+    // username and cwd live on the profile now, not at the top level.
+    expect(mockConfig.set).not.toHaveBeenCalledWith('username', expect.anything());
+    expect(mockConfig.set).not.toHaveBeenCalledWith('cwd', expect.anything());
+    expect(mockConfig.set).toHaveBeenCalledWith('profiles', [
+      expect.objectContaining({ uuid: 'test-uuid', cwd: '/testuser' }),
+    ]);
   });
 });
 
@@ -216,59 +221,68 @@ describe('ProfileModule.getAuthToken', () => {
   });
 });
 
-describe('ProfileModule.getDefaultProfile', () => {
-  it('should return default profile if auth_token exists', () => {
+describe('ProfileModule.rehomePaths', () => {
+  const setup = (cwd, profile) => {
+    const stored = { ...profile, cwd };
     mockConfig.get.mockImplementation((key) => {
-      if (key === 'auth_token') return 'legacy-token';
-      if (key === 'username') return 'legacyuser';
+      if (key === 'profiles') return [stored];
+      if (key === 'selected_profile') return stored.uuid;
       return undefined;
     });
-
     initProfileModule();
-    const profileModule = getProfileModule();
-    const defaultProfile = profileModule.getDefaultProfile();
+    return getProfileModule();
+  };
 
-    expect(defaultProfile).toEqual({
-      host: 'puter.com',
-      username: 'legacyuser',
-      token: 'legacy-token',
-    });
+  it('should re-point the cwd at the new home after a rename', () => {
+    const profile = { uuid: 'p1', username: 'oldname', cwd: '/oldname', host: 'https://puter.com' };
+    const profileModule = setup('/oldname/Desktop/notes', profile);
+
+    profileModule.rehomePaths('oldname', 'newname');
+
+    expect(mockConfig.set).toHaveBeenCalledWith('profiles', [
+      expect.objectContaining({ cwd: '/newname/Desktop/notes' }),
+    ]);
   });
 
-  it('should return undefined if no auth_token exists', () => {
-    mockConfig.get.mockReturnValue(undefined);
+  it('should re-point a cwd sitting exactly at the old home', () => {
+    const profile = { uuid: 'p1', username: 'oldname', cwd: '/oldname', host: 'https://puter.com' };
+    const profileModule = setup('/oldname', profile);
 
-    initProfileModule();
-    const profileModule = getProfileModule();
-    const defaultProfile = profileModule.getDefaultProfile();
+    profileModule.rehomePaths('oldname', 'newname');
 
-    expect(defaultProfile).toBeUndefined();
+    expect(mockConfig.set).toHaveBeenCalledWith('profiles', [
+      expect.objectContaining({ cwd: '/newname' }),
+    ]);
   });
-});
 
-describe('ProfileModule.migrateLegacyConfig', () => {
-  it('should migrate legacy config to profile format', () => {
-    mockConfig.get.mockImplementation((key) => {
-      if (key === 'auth_token') return 'legacy-token';
-      if (key === 'username') return 'legacyuser';
-      if (key === 'profiles') return [];
-      return undefined;
-    });
+  it('should leave a cwd under another user\'s tree alone', () => {
+    const profile = { uuid: 'p1', username: 'oldname', cwd: '/oldname', host: 'https://puter.com' };
+    const profileModule = setup('/someoneelse/public', profile);
 
-    initProfileModule();
-    const profileModule = getProfileModule();
-    profileModule.migrateLegacyConfig();
+    profileModule.rehomePaths('oldname', 'newname');
 
     expect(mockConfig.set).toHaveBeenCalledWith('profiles', [
-      {
-        host: 'https://puter.com',
-        username: 'legacyuser',
-        cwd: '/legacyuser',
-        token: 'legacy-token',
-        uuid: '00000000-0000-0000-0000-000000000000',
-      },
+      expect.objectContaining({ cwd: '/someoneelse/public' }),
     ]);
-    expect(mockConfig.delete).toHaveBeenCalledWith('auth_token');
-    expect(mockConfig.delete).toHaveBeenCalledWith('username');
+  });
+
+  it('should not rewrite a prefix that only partially matches', () => {
+    const profile = { uuid: 'p1', username: 'bob', cwd: '/bob', host: 'https://puter.com' };
+    const profileModule = setup('/bobby/files', profile);
+
+    profileModule.rehomePaths('bob', 'robert');
+
+    expect(mockConfig.set).toHaveBeenCalledWith('profiles', [
+      expect.objectContaining({ cwd: '/bobby/files' }),
+    ]);
+  });
+
+  it('should do nothing when the username is unchanged', () => {
+    const profile = { uuid: 'p1', username: 'bob', cwd: '/bob', host: 'https://puter.com' };
+    const profileModule = setup('/bob/files', profile);
+
+    profileModule.rehomePaths('bob', 'bob');
+
+    expect(mockConfig.set).not.toHaveBeenCalled();
   });
 });