@heyputer/shell 2.1.0 → 3.0.0

package/tests/commons.test.js

@@ -29,11 +29,7 @@ beforeEach(async () => {
 
 describe('constants', () => {
   it('should export PROJECT_NAME', () => {
-    expect(commons.PROJECT_NAME).toBe('puter-cli');
-  });
-
-  it('should export NULL_UUID', () => {
-    expect(commons.NULL_UUID).toBe('00000000-0000-0000-0000-000000000000');
+    expect(commons.PROJECT_NAME).toBe('puter-sh');
   });
 
   it('should have default API_BASE', () => {
@@ -86,65 +82,6 @@ describe('getHeaders', () => {
   });
 });
 
-describe('generateAppName', () => {
-  it('should generate a name with default separator', () => {
-    const name = commons.generateAppName();
-
-    expect(name).toMatch(/^[a-z]+-[a-z]+-\d+$/);
-  });
-
-  it('should generate a name with custom separator', () => {
-    const name = commons.generateAppName('_');
-
-    expect(name).toMatch(/^[a-z]+_[a-z]+_\d+$/);
-  });
-});
-
-describe('displayTable', () => {
-  it('should display a table with headers and data', () => {
-    const consoleLogSpy = vi.spyOn(console, 'log');
-
-    const data = [
-      { name: 'App1', status: 'running' },
-      { name: 'App2', status: 'stopped' },
-    ];
-
-    commons.displayTable(data, {
-      headers: ['Name', 'Status'],
-      columns: ['name', 'status'],
-      columnWidth: 15,
-    });
-
-    expect(consoleLogSpy).toHaveBeenCalled();
-  });
-
-  it('should handle empty data', () => {
-    const consoleLogSpy = vi.spyOn(console, 'log');
-
-    commons.displayTable([], {
-      headers: ['Name'],
-      columns: ['name'],
-    });
-
-    expect(consoleLogSpy).toHaveBeenCalledTimes(2); // header + separator
-  });
-
-  it('should display N/A for missing values', () => {
-    const consoleLogSpy = vi.spyOn(console, 'log');
-
-    const data = [{ name: 'App1' }];
-
-    commons.displayTable(data, {
-      headers: ['Name', 'Status'],
-      columns: ['name', 'status'],
-      columnWidth: 10,
-    });
-
-    const calls = consoleLogSpy.mock.calls.flat();
-    expect(calls.some(call => call.includes('N/A'))).toBe(true);
-  });
-});
-
 describe('showDiskSpaceUsage', () => {
   it('should display disk usage information', () => {
     const consoleLogSpy = vi.spyOn(console, 'log');
@@ -209,94 +146,99 @@ describe('resolvePath', () => {
   it('should normalize duplicate slashes', () => {
     expect(commons.resolvePath('/home//user', 'documents')).toBe('/home/user/documents');
   });
-});
 
-describe('resolveRemotePath', () => {
-  it('should return absolute path as-is', () => {
-    expect(commons.resolveRemotePath('/home/user', '/absolute/path')).toBe('/absolute/path');
+  it('should re-root on an absolute path instead of appending it', () => {
+    expect(commons.resolvePath('/home/user', '/other/place')).toBe('/other/place');
   });
 
-  it('should resolve relative path', () => {
-    expect(commons.resolveRemotePath('/home/user', 'relative/path')).toBe('/home/user/relative/path');
+  it('should leave "~" unexpanded when no home is resolved yet', () => {
+    commons.setHomePath(null);
+    expect(commons.resolvePath('/home/user', '~/Desktop')).toBe('~/Desktop');
+    expect(commons.resolvePath('/home/user', '~')).toBe('~');
   });
-});
 
-describe('isValidAppName', () => {
-  it('should return true for valid app name', () => {
-    expect(commons.isValidAppName('my-app')).toBe(true);
+  it('should walk up within a home-anchored path', () => {
+    commons.setHomePath(null);
+    expect(commons.resolvePath('~/Desktop/notes', '..')).toBe('~/Desktop');
   });
 
-  it('should return true for app name with spaces', () => {
-    expect(commons.isValidAppName('my app')).toBe(true);
+  it('should clamp at the home anchor rather than escaping to root', () => {
+    commons.setHomePath(null);
+    expect(commons.resolvePath('~/Desktop', '../../..')).toBe('~');
   });
+});
 
-  it('should return false for empty string', () => {
-    expect(commons.isValidAppName('')).toBe(false);
-  });
+describe('expandHome', () => {
+  afterEach(() => commons.setHomePath(null));
 
-  it('should return false for whitespace only', () => {
-    expect(commons.isValidAppName('   ')).toBe(false);
+  it('should expand "~" and "~/..." to the resolved home', () => {
+    commons.setHomePath('/alice');
+    expect(commons.expandHome('~')).toBe('/alice');
+    expect(commons.expandHome('~/Desktop')).toBe('/alice/Desktop');
   });
 
-  it('should return false for reserved name "."', () => {
-    expect(commons.isValidAppName('.')).toBe(false);
+  it('should leave non-home paths untouched', () => {
+    commons.setHomePath('/alice');
+    expect(commons.expandHome('/bob/public')).toBe('/bob/public');
+    expect(commons.expandHome('notes.txt')).toBe('notes.txt');
   });
 
-  it('should return false for reserved name ".."', () => {
-    expect(commons.isValidAppName('..')).toBe(false);
+  it('should be a no-op before a home is resolved', () => {
+    commons.setHomePath(null);
+    expect(commons.expandHome('~/Desktop')).toBe('~/Desktop');
   });
 
-  it('should return false for name with forward slash', () => {
-    expect(commons.isValidAppName('my/app')).toBe(false);
+  it('should follow a username change without touching stored paths', () => {
+    commons.setHomePath('/alice');
+    expect(commons.expandHome('~/Desktop')).toBe('/alice/Desktop');
+    commons.setHomePath('/alice-renamed');
+    expect(commons.expandHome('~/Desktop')).toBe('/alice-renamed/Desktop');
   });
+});
 
-  it('should return false for name with backslash', () => {
-    expect(commons.isValidAppName('my\\app')).toBe(false);
-  });
+describe('resolvePath with a resolved home', () => {
+  afterEach(() => commons.setHomePath(null));
 
-  it('should return false for name with wildcard', () => {
-    expect(commons.isValidAppName('my*app')).toBe(false);
+  it('should resolve "~" to the concrete home directory', () => {
+    commons.setHomePath('/alice');
+    expect(commons.resolvePath('/anywhere', '~')).toBe('/alice');
+    expect(commons.resolvePath('/anywhere', '~/Desktop')).toBe('/alice/Desktop');
   });
 
-  it('should return false for non-string input', () => {
-    expect(commons.isValidAppName(123)).toBe(false);
-    expect(commons.isValidAppName(null)).toBe(false);
-    expect(commons.isValidAppName(undefined)).toBe(false);
+  it('should resolve relative paths against a concrete cwd', () => {
+    commons.setHomePath('/alice');
+    expect(commons.resolvePath('/alice', 'Desktop')).toBe('/alice/Desktop');
+    expect(commons.resolvePath('/alice/Desktop', '..')).toBe('/alice');
   });
 });
 
-describe('getDefaultHomePage', () => {
-  it('should generate HTML with app name', () => {
-    const html = commons.getDefaultHomePage('TestApp');
-
-    expect(html).toContain('<title>TestApp</title>');
-    expect(html).toContain('Welcome to TestApp!');
+describe('isAbsolutePath', () => {
+  it('should accept root- and home-anchored paths', () => {
+    expect(commons.isAbsolutePath('/a/b')).toBe(true);
+    expect(commons.isAbsolutePath('~')).toBe(true);
+    expect(commons.isAbsolutePath('~/a')).toBe(true);
   });
 
-  it('should include CSS files when provided', () => {
-    const html = commons.getDefaultHomePage('TestApp', [], ['style.css', 'theme.css']);
-
-    expect(html).toContain('<link href="style.css" rel="stylesheet">');
-    expect(html).toContain('<link href="theme.css" rel="stylesheet">');
+  it('should reject relative paths and non-strings', () => {
+    expect(commons.isAbsolutePath('a/b')).toBe(false);
+    expect(commons.isAbsolutePath('..')).toBe(false);
+    expect(commons.isAbsolutePath(undefined)).toBe(false);
   });
+});
 
-  it('should include JS files when provided', () => {
-    const html = commons.getDefaultHomePage('TestApp', ['app.js', 'utils.js']);
-
-    expect(html).toContain('<script type="text/babel" src="app.js"></script>');
-    expect(html).toContain('<script  src="utils.js"></script>');
+describe('resolveRemotePath', () => {
+  it('should return absolute path as-is', () => {
+    expect(commons.resolveRemotePath('/home/user', '/absolute/path')).toBe('/absolute/path');
   });
 
-  it('should use id="root" when react is included', () => {
-    const html = commons.getDefaultHomePage('TestApp', ['react.js']);
-
-    expect(html).toContain('id="root"');
+  it('should resolve relative path', () => {
+    expect(commons.resolveRemotePath('/home/user', 'relative/path')).toBe('/home/user/relative/path');
   });
 
-  it('should use id="app" when no react', () => {
-    const html = commons.getDefaultHomePage('TestApp', ['vanilla.js']);
-
-    expect(html).toContain('id="app"');
+  it('should expand a home-anchored path against the resolved home', () => {
+    commons.setHomePath('/alice');
+    expect(commons.resolveRemotePath('/home/user', '~/site')).toBe('/alice/site');
+    commons.setHomePath(null);
   });
 });
 
@@ -340,7 +282,7 @@ describe('getLatestVersion', () => {
       json: () => Promise.resolve({ version: '1.0.0' }),
     });
 
-    const result = await commons.getLatestVersion('puter-cli');
+    const result = await commons.getLatestVersion('puter-sh');
 
     expect(result).toBe('v1.0.0 (up-to-date)');
   });
@@ -352,7 +294,7 @@ describe('getLatestVersion', () => {
       json: () => Promise.resolve({ version: '2.0.0' }),
     });
 
-    const result = await commons.getLatestVersion('puter-cli');
+    const result = await commons.getLatestVersion('puter-sh');
 
     expect(result).toBe('v1.0.0 (latest: 2.0.0)');
   });
@@ -361,7 +303,7 @@ describe('getLatestVersion', () => {
     vi.mocked(readFile).mockResolvedValueOnce(JSON.stringify({ version: '1.0.0' }));
     vi.mocked(global.fetch).mockRejectedValueOnce(new Error('Network error'));
 
-    const result = await commons.getLatestVersion('puter-cli');
+    const result = await commons.getLatestVersion('puter-sh');
 
     expect(result).toBe('v1.0.0 (offline)');
   });
@@ -373,7 +315,7 @@ describe('getLatestVersion', () => {
       json: () => Promise.resolve({ version: '2.0.0' }),
     });
 
-    const result = await commons.getLatestVersion('puter-cli');
+    const result = await commons.getLatestVersion('puter-sh');
 
     expect(result).toBe('vunknown (latest: 2.0.0)');
   });

package/tests/executor.test.js

@@ -11,6 +11,14 @@ vi.mock('conf', () => ({
 
 vi.mock('node:child_process');
 
+vi.mock('../src/modules/ProfileModule.js', () => ({
+  initProfileModule: vi.fn(),
+  getProfileModule: vi.fn(() => ({
+    getCwd: () => '/mockuser',
+    setCwd: vi.fn(),
+  })),
+}));
+
 vi.spyOn(console, 'log').mockImplementation(() => {});
 vi.spyOn(console, 'error').mockImplementation(() => {});
 

package/tests/files.test.js

@@ -459,6 +459,9 @@ describe("renameFileOrDirectory", () => {
 describe("getInfo", () => {
   beforeEach(() => {
     vi.clearAllMocks();
+    // Undo the naive resolvePath stub other suites install: getInfo relies on
+    // real "~" and absolute-path resolution.
+    if (vi.isMockFunction(commons.resolvePath)) commons.resolvePath.mockRestore();
     vi.spyOn(PuterModule, "getPuter").mockReturnValue(mockPuter);
     vi.spyOn(auth, "getCurrentDirectory").mockReturnValue("/testuser/files");
     vi.spyOn(utils, "formatSize").mockImplementation((size) => `${size}B`);
@@ -515,6 +518,23 @@ describe("getInfo", () => {
     );
   });
 
+  it("should resolve the argument instead of concatenating it", async () => {
+    mockPuter.fs.stat.mockResolvedValue({
+      name: "files",
+      path: "/testuser/files",
+      is_dir: true,
+      owner: { username: "testuser" },
+    });
+    // Raw concatenation used to produce "/testuser/files/~/Desktop"; delegating
+    // to resolvePath is what makes "~" and absolute paths work here.
+    vi.spyOn(commons, "resolvePath").mockReturnValue("/resolved/path");
+
+    await getInfo(["~/Desktop"]);
+
+    expect(commons.resolvePath).toHaveBeenCalledWith("/testuser/files", "~/Desktop");
+    expect(mockPuter.fs.stat).toHaveBeenCalledWith("/resolved/path");
+  });
+
   it("should use current directory with default argument", async () => {
     mockPuter.fs.stat.mockResolvedValue({
       name: "files",
@@ -529,7 +549,7 @@ describe("getInfo", () => {
 
     await getInfo([]);
 
-    expect(mockPuter.fs.stat).toHaveBeenCalledWith("/testuser/files/.");
+    expect(mockPuter.fs.stat).toHaveBeenCalledWith("/testuser/files");
   });
 });
 
@@ -538,8 +558,8 @@ describe("showCwd", () => {
     vi.clearAllMocks();
   });
 
-  it("should display current working directory from config", async () => {
-    mockConfigStore.cwd = "/testuser/documents";
+  it("should display the selected profile's working directory", async () => {
+    vi.spyOn(auth, "getCurrentDirectory").mockReturnValue("/testuser/documents");
 
     await showCwd();
 

package/tests/shell.test.js

@@ -27,6 +27,7 @@ beforeEach(async () => {
   vi.mocked(getPrompt).mockReturnValue('puter@/> ');
   vi.mocked(getProfileModule).mockReturnValue({
     checkLogin: vi.fn(),
+    setCwd: vi.fn(),
   });
 
   const mockOn = vi.fn().mockReturnThis();
@@ -97,7 +98,7 @@ describe('startShell', () => {
 
     it('should display welcome message', async () => {
       await startShell();
-      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Welcome to Puter-CLI'));
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Welcome to Puter Shell'));
     });
 
     it('should set prompt and call prompt()', async () => {

package/tests/utils.test.js

@@ -1,30 +1,5 @@
 import { describe, it, expect, vi } from 'vitest';
-import { formatDate, formatDateTime, formatSize, displayNonNullValues, parseArgs, isValidAppUuid, is_valid_uuid4 } from '../src/utils.js';
-
-describe('formatDate', () => {
-  it('should format a date string correctly', () => {
-    const dateString = '2024-10-07T15:03:53.000Z';
-    const expected = '10/07/2024, 15:03:53';
-    expect(formatDate(dateString)).toBe(expected);
-  });
-
-  it('should format a date object correctly', () => {
-    const dateObject = new Date(Date.UTC(2024, 9, 7, 15, 3, 53)); // Month is 0-indexed
-    const expected = '10/07/2024, 15:03:53';
-    expect(formatDate(dateObject)).toBe(expected);
-  });
-
-  it('should handle different date and time', () => {
-    const dateString = '2023-01-01T01:30:05.000Z';
-    const expected = '01/01/2023, 01:30:05';
-    expect(formatDate(dateString)).toBe(expected);
-  });
-
-  it('should handle invalid date', () => {
-      const dateString = 'invalid-date';
-      expect(formatDate(dateString)).toBe('Invalid Date');
-  });
-});
+import { formatDateTime, formatSize } from '../src/utils.js';
 
 describe('formatDateTime', () => {
   it('should format as time if within 24 hours', () => {
@@ -76,118 +51,3 @@ describe('formatSize', () => {
     expect(formatSize(undefined)).toBe('0');
   });
 });
-
-describe('displayNonNullValues', () => {
-    it('should display non-null values in a formatted table', () => {
-        const data = {
-            name: 'John Doe',
-            age: 30,
-            address: {
-                street: '123 Main St',
-                city: 'Anytown',
-                zip: null
-            },
-            email: null
-        };
-
-        const consoleLogSpy = vi.spyOn(console, 'log');
-        displayNonNullValues(data);
-        expect(consoleLogSpy).toHaveBeenCalled();
-        consoleLogSpy.mockRestore();
-    });
-
-    it('should handle empty object', () => {
-        const data = {};
-        const consoleLogSpy = vi.spyOn(console, 'log');
-        displayNonNullValues(data);
-        expect(consoleLogSpy).toHaveBeenCalled();
-        consoleLogSpy.mockRestore();
-    });
-
-    it('should handle nested objects with all null values', () => {
-        const data = { a: null, b: { c: null, d: null } };
-        const consoleLogSpy = vi.spyOn(console, 'log');
-        displayNonNullValues(data);
-        expect(consoleLogSpy).toHaveBeenCalledTimes(5);
-        consoleLogSpy.mockRestore();
-    });
-
-    it('should handle non-object input', () => {
-        const data = "not an object";
-        const consoleErrorSpy = vi.spyOn(console, 'error');
-        displayNonNullValues(data);
-        expect(consoleErrorSpy).toHaveBeenCalledWith("Invalid input: Input must be a non-null object.");
-        consoleErrorSpy.mockRestore();
-    });
-});
-
-describe('parseArgs', () => {
-  it('should parse simple arguments', () => {
-    const input = 'command --arg1 val1 --arg2 val2';
-    const expected = { _: ['command'], arg1: 'val1', arg2: 'val2' };
-    expect(parseArgs(input)).toEqual(expect.objectContaining(expected));
-  });
-
-  it('should parse command line arguments with different types', () => {
-    const input = 'command --name="John Doe" --age=30';
-    const result = parseArgs(input);
-    expect(result).toEqual({ _: ['command'], name: 'John Doe', age: 30 });
-  });  
-
-  it('should parse quoted arguments', () => {
-    const input = 'command --arg "quoted value"';
-    const expected = { _: ['command'], arg: 'quoted value' };
-    expect(parseArgs(input)).toEqual(expect.objectContaining(expected));
-  });
-
-  it('should parse arguments with equals sign', () => {
-    const input = 'command --arg1=val1 --arg2=val2';
-    const expected = { _: ['command'], arg1: 'val1', arg2: 'val2' };
-    expect(parseArgs(input)).toEqual(expect.objectContaining(expected));
-  });
-
-  it('should handle empty input', () => {
-    const result = parseArgs('');
-    expect(result).toEqual({ _: []});
-  });
-
-  it('should parse empty arguments', () => {
-      const input = '';
-      const expected = { _: [] };
-      expect(parseArgs(input)).toEqual(expect.objectContaining(expected));
-  });
-});
-
-describe('isValidAppUuid', () => {
-  it('should return true for a valid app UUID', () => {
-    const uuid = 'app-a1b2c3d4-e5f6-4789-8abc-def012345678';
-    expect(isValidAppUuid(uuid)).toBe(true);
-  });
-
-  it('should return false if UUID does not start with "app-"', () => {
-    const uuid = 'a1b2c3d4-e5f6-4789-8abc-def012345678';
-    expect(isValidAppUuid(uuid)).toBe(false);
-  });
-
-  it('should return false for an invalid UUID after "app-"', () => {
-    const uuid = 'app-invalid-uuid';
-    expect(isValidAppUuid(uuid)).toBe(false);
-  });
-});
-
-describe('is_valid_uuid4', () => {
-  it('should return true for a valid UUID v4', () => {
-    const uuid = 'a1b2c3d4-e5f6-4789-8abc-def012345678';
-    expect(is_valid_uuid4(uuid)).toBe(true);
-  });
-
-  it('should return false for an invalid UUID v4', () => {
-    const uuid = 'a1b2c3d4-e5f6-5789-8abc-def012345678'; // Invalid version
-    expect(is_valid_uuid4(uuid)).toBe(false);
-  });
-
-  it('should return false for a completely invalid UUID', () => {
-    const uuid = 'invalid-uuid';
-    expect(is_valid_uuid4(uuid)).toBe(false);
-  });
-});