puter-cli 1.8.6 → 2.0.0

package/tests/ProfileModule.test.js

@@ -0,0 +1,274 @@
+import { it } from "vitest";
+import { beforeEach } from "vitest";
+import { describe } from "vitest";
+import { expect } from "vitest";
+import { vi } from "vitest";
+
+const mockConfig = {
+  get: vi.fn(),
+  set: vi.fn(),
+  clear: vi.fn(),
+  delete: vi.fn(),
+};
+
+vi.mock('conf', () => {
+  const Conf = vi.fn(() => mockConfig);
+  return { default: Conf };
+});
+
+vi.mock('../src/commons.js', () => ({
+  BASE_URL: 'https://puter.com',
+  NULL_UUID: '00000000-0000-0000-0000-000000000000',
+  PROJECT_NAME: 'puter-cli',
+  getHeaders: vi.fn(() => ({ 'Content-Type': 'application/json' })),
+  reconfigureURLs: vi.fn(),
+}));
+
+vi.mock('./PuterModule.js', () => ({
+  initPuterModule: vi.fn(),
+}));
+
+let initProfileModule;
+let getProfileModule;
+
+beforeEach(async () => {
+  vi.resetModules();
+  vi.clearAllMocks();
+  mockConfig.get.mockReset();
+  mockConfig.set.mockReset();
+  mockConfig.delete.mockReset();
+  const module = await import('../src/modules/ProfileModule');
+  initProfileModule = module.initProfileModule;
+  getProfileModule = module.getProfileModule;
+});
+
+describe("initProfileModule", () => {
+  it("should initialize profile module", () => {
+    initProfileModule();
+    const profileModule = getProfileModule();
+    expect(profileModule).toBeDefined();
+  })
+})
+
+describe('getProfileModule', () => {
+  it('should return profile module if initialized', () => {
+    initProfileModule();
+    const result = getProfileModule();
+    expect(result).toBeDefined();
+  });
+
+  it('should throw error if not initialized', () => {
+    expect(() => getProfileModule()).toThrow('Call initprofileModule() first');
+  });
+});
+
+describe('ProfileModule.getProfiles', () => {
+  it('should return profiles from config', () => {
+    const mockProfiles = [
+      { uuid: '1', username: 'user1', host: 'https://puter.com' },
+      { uuid: '2', username: 'user2', host: 'https://puter.com' },
+    ];
+    mockConfig.get.mockReturnValue(mockProfiles);
+
+    initProfileModule();
+    const profileModule = getProfileModule();
+    const profiles = profileModule.getProfiles();
+
+    expect(profiles).toEqual(mockProfiles);
+    expect(mockConfig.get).toHaveBeenCalledWith('profiles');
+  });
+
+  it('should return empty array if no profiles exist', () => {
+    mockConfig.get.mockReturnValue(undefined);
+
+    initProfileModule();
+    const profileModule = getProfileModule();
+    const profiles = profileModule.getProfiles();
+
+    expect(profiles).toEqual([]);
+  });
+});
+
+describe('ProfileModule.addProfile', () => {
+  it('should add a new profile to existing profiles', () => {
+    const existingProfiles = [
+      { uuid: '1', username: 'user1', host: 'https://puter.com' },
+    ];
+    const newProfile = { uuid: '2', username: 'user2', host: 'https://puter.com' };
+    mockConfig.get.mockReturnValue(existingProfiles);
+
+    initProfileModule();
+    const profileModule = getProfileModule();
+    profileModule.addProfile(newProfile);
+
+    expect(mockConfig.set).toHaveBeenCalledWith('profiles', [...existingProfiles, newProfile]);
+  });
+
+  it('should filter out transient profiles when adding', () => {
+    const existingProfiles = [
+      { uuid: '1', username: 'user1', host: 'https://puter.com', transient: true },
+      { uuid: '2', username: 'user2', host: 'https://puter.com' },
+    ];
+    const newProfile = { uuid: '3', username: 'user3', host: 'https://puter.com' };
+    mockConfig.get.mockReturnValue(existingProfiles);
+
+    initProfileModule();
+    const profileModule = getProfileModule();
+    profileModule.addProfile(newProfile);
+
+    expect(mockConfig.set).toHaveBeenCalledWith('profiles', [
+      { uuid: '2', username: 'user2', host: 'https://puter.com' },
+      newProfile,
+    ]);
+  });
+});
+
+describe('ProfileModule.selectProfile', () => {
+  it('should set selected profile in config', () => {
+    const profile = { uuid: 'test-uuid', username: 'testuser', host: 'https://puter.com' };
+    mockConfig.get.mockImplementation((key) => {
+      if (key === 'profiles') return [profile];
+      if (key === 'selected_profile') return 'test-uuid';
+      return undefined;
+    });
+
+    initProfileModule();
+    const profileModule = getProfileModule();
+    profileModule.selectProfile(profile);
+
+    expect(mockConfig.set).toHaveBeenCalledWith('selected_profile', 'test-uuid');
+    expect(mockConfig.set).toHaveBeenCalledWith('username', 'testuser');
+    expect(mockConfig.set).toHaveBeenCalledWith('cwd', '/testuser');
+  });
+});
+
+describe('ProfileModule.getCurrentProfile', () => {
+  it('should return the currently selected profile', () => {
+    const profiles = [
+      { uuid: '1', username: 'user1', host: 'https://puter.com' },
+      { uuid: '2', username: 'user2', host: 'https://puter.com' },
+    ];
+    mockConfig.get.mockImplementation((key) => {
+      if (key === 'profiles') return profiles;
+      if (key === 'selected_profile') return '2';
+      return undefined;
+    });
+
+    initProfileModule();
+    const profileModule = getProfileModule();
+    const currentProfile = profileModule.getCurrentProfile();
+
+    expect(currentProfile).toEqual(profiles[1]);
+  });
+
+  it('should return undefined if no profile matches', () => {
+    const profiles = [
+      { uuid: '1', username: 'user1', host: 'https://puter.com' },
+    ];
+    mockConfig.get.mockImplementation((key) => {
+      if (key === 'profiles') return profiles;
+      if (key === 'selected_profile') return 'non-existent';
+      return undefined;
+    });
+
+    initProfileModule();
+    const profileModule = getProfileModule();
+    const currentProfile = profileModule.getCurrentProfile();
+
+    expect(currentProfile).toBeUndefined();
+  });
+});
+
+describe('ProfileModule.getAuthToken', () => {
+  it('should return auth token for selected profile', () => {
+    const profiles = [
+      { uuid: '1', username: 'user1', host: 'https://puter.com', token: 'token1' },
+      { uuid: '2', username: 'user2', host: 'https://puter.com', token: 'token2' },
+    ];
+    mockConfig.get.mockImplementation((key) => {
+      if (key === 'profiles') return profiles;
+      if (key === 'selected_profile') return '2';
+      return undefined;
+    });
+
+    initProfileModule();
+    const profileModule = getProfileModule();
+    const token = profileModule.getAuthToken();
+
+    expect(token).toBe('token2');
+  });
+
+  it('should return undefined if no profile is selected', () => {
+    const profiles = [
+      { uuid: '1', username: 'user1', host: 'https://puter.com', token: 'token1' },
+    ];
+    mockConfig.get.mockImplementation((key) => {
+      if (key === 'profiles') return profiles;
+      if (key === 'selected_profile') return undefined;
+      return undefined;
+    });
+
+    initProfileModule();
+    const profileModule = getProfileModule();
+    const token = profileModule.getAuthToken();
+
+    expect(token).toBeUndefined();
+  });
+});
+
+describe('ProfileModule.getDefaultProfile', () => {
+  it('should return default profile if auth_token exists', () => {
+    mockConfig.get.mockImplementation((key) => {
+      if (key === 'auth_token') return 'legacy-token';
+      if (key === 'username') return 'legacyuser';
+      return undefined;
+    });
+
+    initProfileModule();
+    const profileModule = getProfileModule();
+    const defaultProfile = profileModule.getDefaultProfile();
+
+    expect(defaultProfile).toEqual({
+      host: 'puter.com',
+      username: 'legacyuser',
+      token: 'legacy-token',
+    });
+  });
+
+  it('should return undefined if no auth_token exists', () => {
+    mockConfig.get.mockReturnValue(undefined);
+
+    initProfileModule();
+    const profileModule = getProfileModule();
+    const defaultProfile = profileModule.getDefaultProfile();
+
+    expect(defaultProfile).toBeUndefined();
+  });
+});
+
+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;
+    });
+
+    initProfileModule();
+    const profileModule = getProfileModule();
+    profileModule.migrateLegacyConfig();
+
+    expect(mockConfig.set).toHaveBeenCalledWith('profiles', [
+      {
+        host: 'https://puter.com',
+        username: 'legacyuser',
+        cwd: '/legacyuser',
+        token: 'legacy-token',
+        uuid: '00000000-0000-0000-0000-000000000000',
+      },
+    ]);
+    expect(mockConfig.delete).toHaveBeenCalledWith('auth_token');
+    expect(mockConfig.delete).toHaveBeenCalledWith('username');
+  });
+});

package/tests/PuterModule.test.js

@@ -0,0 +1,56 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.spyOn(console, 'log').mockImplementation(() => { });
+
+const mockSetAuthToken = vi.hoisted(() => vi.fn());
+
+vi.mock('conf', () => {
+  const Conf = vi.fn(() => ({
+    get: vi.fn((key) => {
+      if (key === 'selected_profile') return 'test-uuid';
+      if (key === 'profiles') return [{
+        uuid: 'test-uuid',
+        token: 'test-token'
+      }];
+      return null;
+    }),
+    set: vi.fn(),
+    clear: vi.fn(),
+  }));
+  return { default: Conf };
+});
+
+vi.mock('@heyputer/puter.js', () => ({
+  puter: {
+    setAuthToken: mockSetAuthToken,
+  }
+}));
+
+let initPuterModule;
+let getPuter;
+
+beforeEach(async () => {
+  vi.resetModules();
+  const module = await import('../src/modules/PuterModule.js');
+  initPuterModule = module.initPuterModule;
+  getPuter = module.getPuter;
+});
+
+describe('initPuterModule', () => {
+  it('should call setAuthToken when initialized', () => {
+    initPuterModule();
+    expect(mockSetAuthToken).toHaveBeenCalledWith(expect.stringContaining('test-token'));
+  });
+});
+
+describe('getPuter', () => {
+  it('should return puter module if initialized', () => {
+    initPuterModule();
+    const result = getPuter();
+    expect(result).toBeDefined();
+  });
+
+  it('should throw error if not initialized', () => {
+    expect(() => getPuter()).toThrow('Call initPuterModule() first');
+  });
+});

package/tests/apps.test.js

@@ -0,0 +1,194 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { listApps, appInfo, createApp, updateApp, deleteApp } from '../src/commands/apps.js';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import * as PuterModule from '../src/modules/PuterModule.js';
+import * as subdomains from '../src/commands/subdomains.js';
+import * as sites from '../src/commands/sites.js';
+import * as files from '../src/commands/files.js';
+import * as auth from '../src/commands/auth.js';
+import * as commons from '../src/commons.js';
+import * as utils from '../src/utils.js';
+import crypto from '../src/crypto.js';
+
+// Mock console to prevent actual logging
+vi.spyOn(console, 'log').mockImplementation(() => {});
+vi.spyOn(console, 'error').mockImplementation(() => {});
+
+vi.mock("conf", () => {
+  const Conf = vi.fn(() => ({
+    get: vi.fn(),
+    set: vi.fn(),
+    clear: vi.fn(),
+  }));
+  return { default: Conf };
+});
+
+// Mock dependencies
+vi.mock('chalk', () => ({
+  default: {
+    green: vi.fn(text => text),
+    red: vi.fn(text => text),
+    dim: vi.fn(text => text),
+    yellow: vi.fn(text => text),
+    cyan: vi.fn(text => text),
+    cyanBright: vi.fn(text => text),
+    bold: vi.fn(text => text),
+  }
+}));
+vi.mock('cli-table3');
+vi.mock('node-fetch');
+vi.mock('../src/modules/PuterModule.js');
+vi.mock('../src/commands/subdomains.js');
+vi.mock('../src/commands/sites.js');
+vi.mock('../src/commands/files.js');
+vi.mock('../src/commands/auth.js');
+vi.mock('../src/commons.js');
+vi.mock('../src/utils.js');
+vi.mock('../src/crypto.js');
+
+const mockPuter = {
+  apps: {
+    list: vi.fn(),
+    get: vi.fn(),
+    create: vi.fn(),
+    update: vi.fn(),
+    delete: vi.fn(),
+  },
+  fs: {
+    mkdir: vi.fn(),
+  },
+};
+
+describe('apps.js', () => {
+  let mockTable;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(PuterModule, 'getPuter').mockReturnValue(mockPuter);
+    vi.spyOn(auth, 'getCurrentDirectory').mockReturnValue('/testuser');
+    vi.spyOn(commons, 'isValidAppName').mockReturnValue(true);
+    vi.spyOn(commons, 'resolvePath').mockImplementation((_, newPath) => newPath);
+    vi.spyOn(crypto, 'randomUUID').mockReturnValue('mock-uuid');
+
+    mockTable = {
+      push: vi.fn(),
+      toString: vi.fn(() => 'table string'),
+    };
+    Table.mockImplementation(() => mockTable);
+  });
+
+  describe('listApps', () => {
+    it('should list apps successfully', async () => {
+      const mockApps = [
+        { title: 'App 1', name: 'app-1', created_at: new Date().toISOString(), index_url: 'https://app-1.puter.site', stats: { open_count: 10, user_count: 5 } },
+        { title: 'App 2', name: 'app-2', created_at: new Date().toISOString(), index_url: 'https://app-2.puter.site', stats: { open_count: 20, user_count: 15 } },
+      ];
+      mockPuter.apps.list.mockResolvedValue(mockApps);
+      vi.spyOn(utils, 'formatDate').mockReturnValue('formatted-date');
+
+      await listApps();
+
+      expect(mockPuter.apps.list).toHaveBeenCalled();
+      expect(mockTable.push).toHaveBeenCalledTimes(2);
+      expect(console.log).toHaveBeenCalledWith('table string');
+    });
+
+    it('should handle API error when listing apps', async () => {
+      mockPuter.apps.list.mockRejectedValue(new Error('API Error'));
+      await listApps();
+      expect(console.error).toHaveBeenCalledWith('Failed to list apps. Error: API Error');
+    });
+  });
+
+  describe('appInfo', () => {
+    it('should show app info successfully', async () => {
+        const mockApp = { name: 'test-app', title: 'Test App' };
+        mockPuter.apps.get.mockResolvedValue(mockApp);
+        vi.spyOn(utils, 'displayNonNullValues').mockImplementation(() => {});
+
+        await appInfo(['test-app']);
+
+        expect(mockPuter.apps.get).toHaveBeenCalledWith('test-app');
+        expect(utils.displayNonNullValues).toHaveBeenCalledWith(mockApp);
+    });
+
+    it('should show usage if no app name is provided', async () => {
+        await appInfo([]);
+        expect(console.log).toHaveBeenCalledWith(chalk.red('Usage: app <name>'));
+    });
+
+    it('should handle app not found', async () => {
+        mockPuter.apps.get.mockResolvedValue(null);
+        await appInfo(['non-existent-app']);
+        expect(console.error).toHaveBeenCalledWith(chalk.red('Could not find this app.'));
+    });
+  });
+
+  describe('createApp', () => {
+    beforeEach(() => {
+        mockPuter.apps.create.mockResolvedValue({ uid: 'app-uid', name: 'new-app', owner: { username: 'testuser' } });
+        mockPuter.fs.mkdir.mockResolvedValue({ uid: 'dir-uid', name: 'app-mock-uuid' });
+        vi.spyOn(subdomains, 'createSubdomain').mockResolvedValue(true);
+        vi.spyOn(files, 'createFile').mockResolvedValue(true);
+        mockPuter.apps.update.mockResolvedValue(true);
+    })
+    it('should create an app successfully', async () => {
+      await createApp({ name: 'new-app' });
+
+      expect(mockPuter.apps.create).toHaveBeenCalled();
+      expect(mockPuter.fs.mkdir).toHaveBeenCalled();
+      expect(subdomains.createSubdomain).toHaveBeenCalled();
+      expect(files.createFile).toHaveBeenCalled();
+      expect(mockPuter.apps.update).toHaveBeenCalled();
+      expect(console.log).toHaveBeenCalledWith(chalk.green('App deployed successfully at:'));
+    });
+
+    it('should show usage if app name is invalid', async () => {
+        vi.spyOn(commons, 'isValidAppName').mockReturnValue(false);
+        await createApp({ name: 'invalid-' });
+        expect(console.log).toHaveBeenCalledWith(chalk.red('Usage: app:create <name> <directory>'));
+    });
+  });
+
+  describe('updateApp', () => {
+    it('should update an app successfully', async () => {
+        mockPuter.apps.get.mockResolvedValue({ uid: 'app-uid', name: 'test-app', owner: { username: 'testuser' }, index_url: 'https://test.puter.site' });
+        vi.spyOn(files, 'pathExists').mockResolvedValue(true);
+        vi.spyOn(subdomains, 'getSubdomains').mockResolvedValue([{ root_dir: { dirname: 'app-uid', path: '/path/to/app' }, uid: 'sub-uid' }]);
+        vi.spyOn(files, 'listRemoteFiles').mockResolvedValue([{ name: 'index.html' }]);
+        vi.spyOn(files, 'copyFile').mockResolvedValue(true);
+        vi.spyOn(files, 'removeFileOrDirectory').mockResolvedValue(true);
+
+        await updateApp(['test-app', '.']);
+
+        expect(mockPuter.apps.get).toHaveBeenCalledWith('test-app');
+        expect(files.listRemoteFiles).toHaveBeenCalled();
+        expect(files.copyFile).toHaveBeenCalled();
+        expect(console.log).toHaveBeenCalledWith(chalk.green('App updated successfully at:'));
+    });
+  });
+
+  describe('deleteApp', () => {
+    it('should delete an app successfully', async () => {
+        mockPuter.apps.get.mockResolvedValue({ uid: 'app-uid', name: 'test-app', title: 'Test App', created_at: new Date().toISOString() });
+        mockPuter.apps.delete.mockResolvedValue(true);
+        vi.spyOn(subdomains, 'getSubdomains').mockResolvedValue([{ root_dir: { dirname: 'app-uid' }, uid: 'sub-uid' }]);
+        vi.spyOn(sites, 'deleteSite').mockResolvedValue(true);
+
+        const result = await deleteApp('test-app');
+
+        expect(result).toBe(true);
+        expect(mockPuter.apps.delete).toHaveBeenCalledWith('test-app');
+        expect(sites.deleteSite).toHaveBeenCalled();
+        expect(console.log).toHaveBeenCalledWith(chalk.green('App "test-app" deleted successfully!'));
+    });
+
+     it('should return false if app not found', async () => {
+        mockPuter.apps.get.mockResolvedValue(null);
+        const result = await deleteApp('non-existent-app');
+        expect(result).toBe(false);
+        expect(console.log).toHaveBeenCalledWith(chalk.red('App "non-existent-app" not found.'));
+    });
+  });
+});