puter-cli 1.8.6 → 2.0.0

package/tests/commons.test.js

@@ -0,0 +1,380 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { getAuthToken } from '../src/commands/auth.js';
+import { formatSize } from '../src/utils.js';
+import { readFile } from 'fs/promises';
+
+vi.mock('../src/commands/auth.js');
+vi.mock('../src/utils.js');
+vi.mock('fs/promises');
+vi.mock('dotenv', () => ({
+  default: {
+    config: vi.fn(),
+  },
+}));
+
+vi.spyOn(console, 'log').mockImplementation(() => { });
+vi.spyOn(console, 'error').mockImplementation(() => { });
+
+let commons;
+
+beforeEach(async () => {
+  vi.resetModules();
+  vi.clearAllMocks();
+
+  vi.mocked(getAuthToken).mockReturnValue('mock-token');
+  vi.mocked(formatSize).mockImplementation((size) => `${size} bytes`);
+
+  commons = await import('../src/commons.js');
+});
+
+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');
+  });
+
+  it('should have default API_BASE', () => {
+    expect(commons.API_BASE).toBeDefined();
+  });
+
+  it('should have default BASE_URL', () => {
+    expect(commons.BASE_URL).toBeDefined();
+  });
+});
+
+describe('reconfigureURLs', () => {
+  it('should update API_BASE and BASE_URL', async () => {
+    vi.resetModules();
+    const freshCommons = await import('../src/commons.js');
+
+    freshCommons.reconfigureURLs({ api: 'https://new-api.example.com', base: 'https://new.example.com' });
+
+    expect(freshCommons.API_BASE).toBe('https://new-api.example.com');
+    expect(freshCommons.BASE_URL).toBe('https://new.example.com');
+  });
+});
+
+describe('getHeaders', () => {
+  it('should return headers with default content type', () => {
+    const headers = commons.getHeaders();
+
+    expect(headers['Content-Type']).toBe('application/json');
+    expect(headers['Authorization']).toBe('Bearer mock-token');
+    expect(headers['Accept']).toBe('*/*');
+    expect(headers['Accept-Language']).toBe('en-US,en;q=0.9');
+    expect(headers['Connection']).toBe('keep-alive');
+  });
+
+  it('should return headers with custom content type', () => {
+    const headers = commons.getHeaders('multipart/form-data');
+
+    expect(headers['Content-Type']).toBe('multipart/form-data');
+  });
+
+  it('should include Origin and Referer based on BASE_URL', async () => {
+    vi.resetModules();
+    const freshCommons = await import('../src/commons.js');
+    freshCommons.reconfigureURLs({ api: 'https://api.test.com', base: 'https://test.com' });
+
+    const headers = freshCommons.getHeaders();
+
+    expect(headers['Origin']).toBe('https://test.com');
+    expect(headers['Referer']).toBe('https://test.com/');
+  });
+});
+
+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');
+
+    const data = {
+      capacity: '1000000000',
+      used: '500000000',
+    };
+
+    commons.showDiskSpaceUsage(data);
+
+    expect(consoleLogSpy).toHaveBeenCalled();
+    expect(formatSize).toHaveBeenCalledWith('1000000000'); // capacity
+    expect(formatSize).toHaveBeenCalledWith('500000000'); // used
+    expect(formatSize).toHaveBeenCalledWith(500000000); // free space
+  });
+
+  it('should calculate usage percentage correctly', () => {
+    const consoleLogSpy = vi.spyOn(console, 'log');
+
+    const data = {
+      capacity: '100',
+      used: '25',
+    };
+
+    commons.showDiskSpaceUsage(data);
+
+    const calls = consoleLogSpy.mock.calls.flat().join(' ');
+    expect(calls).toContain('25.00%');
+  });
+});
+
+describe('resolvePath', () => {
+  it('should resolve simple relative path', () => {
+    expect(commons.resolvePath('/home/user', 'documents')).toBe('/home/user/documents');
+  });
+
+  it('should resolve parent directory', () => {
+    expect(commons.resolvePath('/home/user/documents', '..')).toBe('/home/user');
+  });
+
+  it('should resolve current directory', () => {
+    expect(commons.resolvePath('/home/user', '.')).toBe('/home/user');
+  });
+
+  it('should resolve multiple parent directories', () => {
+    expect(commons.resolvePath('/home/user/documents/files', '../..')).toBe('/home/user');
+  });
+
+  it('should handle trailing slashes', () => {
+    expect(commons.resolvePath('/home/user/', 'documents')).toBe('/home/user/documents');
+  });
+
+  it('should handle empty relative path', () => {
+    expect(commons.resolvePath('/home/user', '')).toBe('/home/user');
+  });
+
+  it('should return root when going above root', () => {
+    expect(commons.resolvePath('/home', '../../../..')).toBe('/');
+  });
+
+  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 resolve relative path', () => {
+    expect(commons.resolveRemotePath('/home/user', 'relative/path')).toBe('/home/user/relative/path');
+  });
+});
+
+describe('isValidAppName', () => {
+  it('should return true for valid app name', () => {
+    expect(commons.isValidAppName('my-app')).toBe(true);
+  });
+
+  it('should return true for app name with spaces', () => {
+    expect(commons.isValidAppName('my app')).toBe(true);
+  });
+
+  it('should return false for empty string', () => {
+    expect(commons.isValidAppName('')).toBe(false);
+  });
+
+  it('should return false for whitespace only', () => {
+    expect(commons.isValidAppName('   ')).toBe(false);
+  });
+
+  it('should return false for reserved name "."', () => {
+    expect(commons.isValidAppName('.')).toBe(false);
+  });
+
+  it('should return false for reserved name ".."', () => {
+    expect(commons.isValidAppName('..')).toBe(false);
+  });
+
+  it('should return false for name with forward slash', () => {
+    expect(commons.isValidAppName('my/app')).toBe(false);
+  });
+
+  it('should return false for name with backslash', () => {
+    expect(commons.isValidAppName('my\\app')).toBe(false);
+  });
+
+  it('should return false for name with wildcard', () => {
+    expect(commons.isValidAppName('my*app')).toBe(false);
+  });
+
+  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);
+  });
+});
+
+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!');
+  });
+
+  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 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>');
+  });
+
+  it('should use id="root" when react is included', () => {
+    const html = commons.getDefaultHomePage('TestApp', ['react.js']);
+
+    expect(html).toContain('id="root"');
+  });
+
+  it('should use id="app" when no react', () => {
+    const html = commons.getDefaultHomePage('TestApp', ['vanilla.js']);
+
+    expect(html).toContain('id="app"');
+  });
+});
+
+describe('getVersionFromPackage', () => {
+  it('should return version from package.json', async () => {
+    vi.mocked(readFile).mockResolvedValueOnce(JSON.stringify({ version: '1.2.3' }));
+
+    const version = await commons.getVersionFromPackage();
+
+    expect(version).toBe('1.2.3');
+  });
+
+  it('should fallback to production package.json on dev error', async () => {
+    vi.mocked(readFile)
+      .mockRejectedValueOnce(new Error('File not found'))
+      .mockResolvedValueOnce(JSON.stringify({ version: '2.0.0' }));
+
+    const version = await commons.getVersionFromPackage();
+
+    expect(version).toBe('2.0.0');
+  });
+
+  it('should return null on error', async () => {
+    vi.mocked(readFile).mockRejectedValue(new Error('Read error'));
+
+    const version = await commons.getVersionFromPackage();
+
+    expect(version).toBeNull();
+  });
+});
+
+describe('getLatestVersion', () => {
+  beforeEach(() => {
+    global.fetch = vi.fn();
+  });
+
+  it('should return up-to-date status when versions match', async () => {
+    vi.mocked(readFile).mockResolvedValueOnce(JSON.stringify({ version: '1.0.0' }));
+    vi.mocked(global.fetch).mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve({ version: '1.0.0' }),
+    });
+
+    const result = await commons.getLatestVersion('puter-cli');
+
+    expect(result).toBe('v1.0.0 (up-to-date)');
+  });
+
+  it('should return latest version when different', async () => {
+    vi.mocked(readFile).mockResolvedValueOnce(JSON.stringify({ version: '1.0.0' }));
+    vi.mocked(global.fetch).mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve({ version: '2.0.0' }),
+    });
+
+    const result = await commons.getLatestVersion('puter-cli');
+
+    expect(result).toBe('v1.0.0 (latest: 2.0.0)');
+  });
+
+  it('should return offline status when fetch fails', async () => {
+    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');
+
+    expect(result).toBe('v1.0.0 (offline)');
+  });
+
+  it('should handle unknown current version', async () => {
+    vi.mocked(readFile).mockRejectedValue(new Error('Read error'));
+    vi.mocked(global.fetch).mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve({ version: '2.0.0' }),
+    });
+
+    const result = await commons.getLatestVersion('puter-cli');
+
+    expect(result).toBe('vunknown (latest: 2.0.0)');
+  });
+});

package/tests/deploy.test.js

@@ -0,0 +1,84 @@
+import { describe, vi, expect, it, beforeEach } from "vitest";
+
+vi.mock('conf', () => ({
+  default: vi.fn(() => ({
+    get: vi.fn(),
+  })),
+}));
+
+vi.mock("../src/commands/files");
+vi.mock("../src/commands/sites");
+vi.mock("../src/modules/PuterModule");
+
+vi.spyOn(console, "log").mockImplementation(() => { });
+
+let deploy;
+let syncDirectory;
+let createSite;
+let getPuter;
+
+beforeEach(async () => {
+  vi.resetModules();
+  vi.clearAllMocks();
+
+  const deployModule = await import("../src/commands/deploy");
+  deploy = deployModule.deploy;
+
+  const filesModule = await import("../src/commands/files");
+  syncDirectory = vi.mocked(filesModule.syncDirectory);
+
+  const sitesModule = await import("../src/commands/sites");
+  createSite = vi.mocked(sitesModule.createSite);
+
+  const puterModule = await import("../src/modules/PuterModule");
+  getPuter = vi.mocked(puterModule.getPuter);
+});
+
+describe("deploy", () => {
+  it("should show usage when no args provided", async () => {
+    await deploy([]);
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining("Usage:"));
+  });
+
+  it("should deploy successfully", async () => {
+    const mockMkdir = vi.fn().mockResolvedValue({
+      path: "~/sites/test-app/deployment"
+    });
+    getPuter.mockReturnValue({
+      fs: {
+        mkdir: mockMkdir
+      }
+    });
+    syncDirectory.mockResolvedValue();
+    createSite.mockResolvedValue({
+      subdomain: "test-app.puter.site"
+    });
+
+    await deploy(["./dist", "--subdomain=test-app"]);
+
+    expect(mockMkdir).toHaveBeenCalledWith("~/sites/test-app/deployment", {
+      dedupeName: true,
+      createMissingParents: true
+    });
+    expect(syncDirectory).toHaveBeenCalled();
+    expect(createSite).toHaveBeenCalled();
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining("Deployment successful!"));
+  });
+
+  it("should show updated message when site already exists", async () => {
+    const mockMkdir = vi.fn().mockResolvedValue({
+      path: "~/sites/test-app/deployment"
+    });
+    getPuter.mockReturnValue({
+      fs: {
+        mkdir: mockMkdir
+      }
+    });
+    syncDirectory.mockResolvedValue();
+    createSite.mockResolvedValue(null);
+
+    await deploy(["./dist", "--subdomain=test-app"]);
+
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining("Deployment successfuly updated!"));
+  });
+});

package/tests/executor.test.js

@@ -0,0 +1,52 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('conf', () => ({
+  default: vi.fn(() => ({
+    get: vi.fn((key) => {
+      if (key === 'cwd') return '/mockuser';
+      return null;
+    }),
+  })),
+}));
+
+vi.mock('node:child_process');
+
+vi.spyOn(console, 'log').mockImplementation(() => {});
+vi.spyOn(console, 'error').mockImplementation(() => {});
+
+let executor;
+let execMock;
+
+beforeEach(async () => {
+  vi.resetModules();
+  vi.clearAllMocks();
+
+  const childProcess = await import('node:child_process');
+  execMock = vi.mocked(childProcess.exec);
+
+  executor = await import('../src/executor.js');
+});
+
+describe('getPrompt', () => {
+  it('should contain puter@<cwd name>', () => {
+    const prompt = executor.getPrompt();
+
+    expect(prompt).toContain('puter@mockuser');
+  });
+});
+
+describe('showHelp', () => {
+  it('should display available commands', async () => {
+    await executor.execCommand('help');
+
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Available commands'));
+  });
+});
+
+describe('host command (!)', () => {
+  it('should call exec with the command after !', async () => {
+    await executor.execCommand('!ls -la');
+
+    expect(execMock).toHaveBeenCalledWith('ls -la', expect.any(Function));
+  });
+});