puter-cli 1.8.6 → 2.0.0

package/tests/login.test.js

@@ -1,18 +1,16 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { login, logout, getUserInfo, isAuthenticated, getAuthToken, getCurrentUserName, 
-  getCurrentDirectory, getUsageInfo } from '../src/commands/auth.js';
-import inquirer from 'inquirer';
-import ora from 'ora';
+import {
+  login, logout, getUserInfo, isAuthenticated, getAuthToken, getCurrentUserName,
+  getUsageInfo
+} from '../src/commands/auth.js';
 import chalk from 'chalk';
-import fetch from 'node-fetch';
 import Conf from 'conf';
-import { BASE_URL, PROJECT_NAME, API_BASE } from '../src/commons.js';
-import { ProfileAPI } from '../src/modules/ProfileModule.js';
-import * as contextHelpers from '../src/temporary/context_helpers.js';
+import { PROJECT_NAME } from '../src/commons.js';
+import * as PuterModule from '../src/modules/PuterModule.js';
 
 // Mock console to prevent actual logging
-vi.spyOn(console, 'log').mockImplementation(() => {});
-vi.spyOn(console, 'error').mockImplementation(() => {});
+vi.spyOn(console, 'log').mockImplementation(() => { });
+vi.spyOn(console, 'error').mockImplementation(() => { });
 
 // Mock dependencies
 vi.mock('inquirer');
@@ -25,7 +23,19 @@ vi.mock('chalk', () => ({
     cyan: vi.fn(text => text),
   }
 }));
-vi.mock('node-fetch');
+vi.mock('../src/modules/PuterModule.js');
+
+// Mock ProfileModule
+const mockProfileModule = {
+  switchProfileWizard: vi.fn(),
+  getAuthToken: vi.fn(),
+  getCurrentProfile: vi.fn(),
+};
+
+vi.mock('../src/modules/ProfileModule.js', () => ({
+  getProfileModule: vi.fn(() => mockProfileModule),
+  initProfileModule: vi.fn(),
+}));
 
 // Create a mock spinner object
 const mockSpinner = {
@@ -51,19 +61,6 @@ vi.mock('conf', () => {
   };
 });
 
-const mockProfileModule = {
-  switchProfileWizard: vi.fn(),
-  getAuthToken: vi.fn(),
-  getCurrentProfile: vi.fn(),
-};
-
-const mockContext = {
-  [ProfileAPI]: mockProfileModule,
-};
-
-vi.spyOn(contextHelpers, 'get_context').mockReturnValue(mockContext);
-
-
 describe('auth.js', () => {
   beforeEach(() => {
     vi.clearAllMocks();
@@ -71,13 +68,13 @@ describe('auth.js', () => {
 
   describe('login', () => {
     it('should login successfully with valid credentials', async () => {
-      await login({}, mockContext);
+      await login({});
       expect(mockProfileModule.switchProfileWizard).toHaveBeenCalled();
     });
 
     it('should fail login with invalid credentials', async () => {
       mockProfileModule.switchProfileWizard.mockRejectedValue(new Error('Invalid credentials'));
-      await expect(login({}, mockContext)).rejects.toThrow('Invalid credentials');
+      await expect(login({})).rejects.toThrow('Invalid credentials');
       expect(mockProfileModule.switchProfileWizard).toHaveBeenCalled();
     });
 
@@ -108,31 +105,40 @@ describe('auth.js', () => {
     it.skip('should handle logout error', async () => {
       // This test needs to be updated to reflect the new login flow
     });
-    
+
   });
-  
+
 
   describe('getUserInfo', () => {
+    const mockPuter = {
+      auth: {
+        getUser: vi.fn(),
+      },
+    };
+
+    beforeEach(() => {
+      vi.spyOn(PuterModule, 'getPuter').mockReturnValue(mockPuter);
+    });
+
     it('should fetch user info successfully', async () => {
-      mockProfileModule.getAuthToken.mockReturnValue('testtoken');
-      fetch.mockResolvedValue({
-        json: () => Promise.resolve({
-          username: 'testuser',
-        }),
-        ok: true,
+      mockPuter.auth.getUser.mockResolvedValue({
+        username: 'testuser',
+        uuid: 'testuuid',
+        email: 'test@puter.com',
+        email_confirmed: true,
+        is_temp: false,
+        human_readable_age: '1 day',
+        feature_flags: {},
       });
 
       await getUserInfo();
 
-      expect(fetch).toHaveBeenCalledWith(`${API_BASE}/whoami`, {
-        method: 'GET',
-        headers: expect.any(Object),
-      });
+      expect(mockPuter.auth.getUser).toHaveBeenCalled();
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('User Information:'));
     });
 
     it('should handle fetch user info error', async () => {
-      mockProfileModule.getAuthToken.mockReturnValue('testtoken');
-      fetch.mockRejectedValue(new Error('Network error'));
+      mockPuter.auth.getUser.mockRejectedValue(new Error('Network error'));
       await getUserInfo();
       expect(console.error).toHaveBeenCalledWith(expect.stringContaining('Failed to get user info.'));
     });
@@ -161,28 +167,40 @@ describe('auth.js', () => {
   });
 
   describe('getUsageInfo', () => {
+    const mockPuter = {
+      auth: {
+        getMonthlyUsage: vi.fn(),
+      },
+    };
+
+    beforeEach(() => {
+      vi.spyOn(PuterModule, 'getPuter').mockReturnValue(mockPuter);
+    });
+
     it('should fetch usage info successfully', async () => {
-      mockProfileModule.getAuthToken.mockReturnValue('testtoken');
-      fetch.mockResolvedValue({
-        json: vi.fn().mockResolvedValue({}),
-        ok: true,
+      mockPuter.auth.getMonthlyUsage.mockResolvedValue({
+        allowanceInfo: {
+          monthUsageAllowance: 1000,
+          remaining: 500,
+        },
+        usage: {
+          total: 500,
+        },
+        appTotals: {},
       });
 
       await getUsageInfo();
 
-      expect(fetch).toHaveBeenCalledWith(`${API_BASE}/drivers/usage`, {
-        method: 'GET',
-        headers: expect.any(Object),
-      });
+      expect(mockPuter.auth.getMonthlyUsage).toHaveBeenCalled();
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Allowance Information:'));
     });
 
     it('should handle fetch usage info error', async () => {
-      mockProfileModule.getAuthToken.mockReturnValue('testtoken');
-      fetch.mockRejectedValue(new Error('Network error'));
+      mockPuter.auth.getMonthlyUsage.mockRejectedValue(new Error('Network error'));
       await getUsageInfo();
       expect(console.error).toHaveBeenCalledWith(expect.stringContaining('Failed to fetch usage information.'));
     });
   });
-  
+
 
 });

package/tests/shell.test.js

@@ -0,0 +1,184 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { execCommand, getPrompt } from '../src/executor.js';
+import { getProfileModule } from '../src/modules/ProfileModule.js';
+import readline from 'node:readline';
+
+vi.mock('../src/executor.js');
+vi.mock('../src/modules/ProfileModule.js');
+vi.mock('node:readline');
+vi.mock('conf', () => {
+  const Conf = vi.fn(() => ({
+    get: vi.fn(),
+    set: vi.fn(),
+  }));
+  return { default: Conf };
+});
+
+vi.spyOn(console, 'log').mockImplementation(() => { });
+vi.spyOn(console, 'error').mockImplementation(() => { });
+
+let updatePrompt;
+let startShell;
+
+beforeEach(async () => {
+  vi.resetModules();
+  vi.clearAllMocks();
+
+  vi.mocked(getPrompt).mockReturnValue('puter@/> ');
+  vi.mocked(getProfileModule).mockReturnValue({
+    checkLogin: vi.fn(),
+  });
+
+  const mockOn = vi.fn().mockReturnThis();
+  vi.mocked(readline.createInterface).mockReturnValue({
+    setPrompt: vi.fn(),
+    prompt: vi.fn(),
+    on: mockOn,
+  });
+
+  const module = await import('../src/commands/shell.js');
+  updatePrompt = module.updatePrompt;
+  startShell = module.startShell;
+});
+
+describe('updatePrompt', () => {
+  it('should call rl.setPrompt with getPrompt result', async () => {
+    await startShell();
+    const rl = readline.createInterface.mock.results[0].value;
+    rl.setPrompt.mockClear();
+
+    updatePrompt('/test/path');
+
+    expect(rl.setPrompt).toHaveBeenCalledWith('puter@/> ');
+  });
+});
+
+describe('startShell', () => {
+  it('should call checkLogin', async () => {
+    await startShell();
+    expect(getProfileModule().checkLogin).toHaveBeenCalled();
+  });
+
+  describe('with command argument', () => {
+    let mockExit;
+
+    beforeEach(() => {
+      mockExit = vi.spyOn(process, 'exit').mockImplementation(() => {
+        throw new Error('process.exit called');
+      });
+    });
+
+    afterEach(() => {
+      mockExit.mockRestore();
+    });
+
+    it('should execute command and exit when command is provided', async () => {
+      await expect(startShell('help')).rejects.toThrow('process.exit called');
+      expect(execCommand).toHaveBeenCalledWith('help');
+      expect(mockExit).toHaveBeenCalledWith(0);
+    });
+
+    it('should not create readline interface when command is provided', async () => {
+      vi.mocked(readline.createInterface).mockClear();
+      await expect(startShell('help')).rejects.toThrow('process.exit called');
+      expect(readline.createInterface).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('without command argument (interactive mode)', () => {
+    it('should create readline interface', async () => {
+      await startShell();
+      expect(readline.createInterface).toHaveBeenCalledWith({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: null,
+      });
+    });
+
+    it('should display welcome message', async () => {
+      await startShell();
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Welcome to Puter-CLI'));
+    });
+
+    it('should set prompt and call prompt()', async () => {
+      await startShell();
+      const rl = readline.createInterface.mock.results[0].value;
+      expect(rl.setPrompt).toHaveBeenCalledWith('puter@/> ');
+      expect(rl.prompt).toHaveBeenCalled();
+    });
+
+    it('should register line and close event handlers', async () => {
+      await startShell();
+      const rl = readline.createInterface.mock.results[0].value;
+      expect(rl.on).toHaveBeenCalledWith('line', expect.any(Function));
+      expect(rl.on).toHaveBeenCalledWith('close', expect.any(Function));
+    });
+  });
+
+  describe('line event handler', () => {
+    let lineHandler;
+    let rl;
+
+    beforeEach(async () => {
+      await startShell();
+      rl = readline.createInterface.mock.results[0].value;
+      lineHandler = rl.on.mock.calls.find(call => call[0] === 'line')[1];
+    });
+
+    it('should execute trimmed command', async () => {
+      await lineHandler('  ls  ');
+      expect(execCommand).toHaveBeenCalledWith('ls');
+    });
+
+    it('should not execute empty line', async () => {
+      vi.mocked(execCommand).mockClear();
+      await lineHandler('   ');
+      expect(execCommand).not.toHaveBeenCalled();
+    });
+
+    it('should call prompt after executing command', async () => {
+      rl.prompt.mockClear();
+      await lineHandler('ls');
+      expect(rl.prompt).toHaveBeenCalled();
+    });
+
+    it('should log error message when execCommand throws', async () => {
+      vi.mocked(execCommand).mockRejectedValueOnce(new Error('Command failed'));
+      await lineHandler('badcmd');
+      expect(console.error).toHaveBeenCalledWith(expect.stringContaining('Command failed'));
+    });
+
+    it('should still call prompt after error', async () => {
+      vi.mocked(execCommand).mockRejectedValueOnce(new Error('Command failed'));
+      rl.prompt.mockClear();
+      await lineHandler('badcmd');
+      expect(rl.prompt).toHaveBeenCalled();
+    });
+  });
+
+  describe('close event handler', () => {
+    let closeHandler;
+    let mockExit;
+
+    beforeEach(async () => {
+      mockExit = vi.spyOn(process, 'exit').mockImplementation(() => { });
+      await startShell();
+      const rl = readline.createInterface.mock.results[0].value;
+      closeHandler = rl.on.mock.calls.find(call => call[0] === 'close')[1];
+    });
+
+    afterEach(() => {
+      mockExit.mockRestore();
+    });
+
+    it('should display goodbye message', () => {
+      closeHandler();
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Goodbye'));
+    });
+
+    it('should exit with code 0', () => {
+      closeHandler();
+      expect(mockExit).toHaveBeenCalledWith(0);
+    });
+  });
+});

package/tests/sites.test.js

@@ -0,0 +1,67 @@
+import { describe, vi, expect, it } from "vitest";
+import { createSite, deleteSite, infoSite, listSites } from "../src/commands/sites";
+import { createSubdomain, deleteSubdomain, getSubdomains } from "../src/commands/subdomains";
+import { getPuter } from "../src/modules/PuterModule.js";
+import { getCurrentDirectory } from "../src/commands/auth.js";
+
+vi.mock("../src/commands/subdomains")
+vi.mock("../src/modules/PuterModule")
+vi.mock('../src/commands/auth.js');
+
+vi.spyOn(console, "log").mockImplementation(() => { });
+
+describe("listSites", () => {
+  it("should list sites successfully", async () => {
+    vi.mocked(getSubdomains).mockResolvedValue([{
+      uid: "123",
+      subdomain: "hehe.puter.site",
+      root_dir: { path: "/some/path" },
+    }])
+    await listSites();
+    expect(getSubdomains).toHaveBeenCalled();
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining("Total Sites: 1"))
+  })
+})
+
+describe("infoSite", () => {
+  it("should get site info successfully", async () => {
+    const mockHostingGet = vi.fn().mockResolvedValue({
+      uid: "123",
+      subdomain: "hehe.puter.site",
+      root_dir: { path: "/some/path" },
+    });
+    vi.mocked(getPuter).mockReturnValue({
+      hosting: {
+        get: mockHostingGet
+      }
+    })
+
+    await infoSite(["hehe.puter.site"])
+    expect(getPuter).toHaveBeenCalled();
+    expect(mockHostingGet).toHaveBeenCalled();
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining("hehe.puter.site"))
+  })
+})
+
+describe("deleteSite", () => {
+  it("should delete site successfully", async () => {
+    vi.mocked(deleteSubdomain)
+    const result = await deleteSite(["hehe.puter.site"]);
+    expect(result).toBe(true);
+  })
+})
+
+describe("createSite", () => {
+  it("should create site successfully", async () => {
+    vi.mocked(createSubdomain).mockResolvedValue({
+      uid: "123",
+      subdomain: "hehe.puter.site",
+      root_dir: { path: "/some/path" },
+    })
+    vi.mocked(getCurrentDirectory).mockReturnValue('/testuser');
+    const result = await createSite(["hehe hehe --subdomain=hehe"]);
+    expect(result).toMatchObject({
+      subdomain: "hehe.puter.site"
+    })
+  })
+})

package/tests/subdomains.test.js

@@ -0,0 +1,90 @@
+import { vi } from "vitest";
+import { it } from "vitest";
+import { describe } from "vitest";
+import { createSubdomain, deleteSubdomain, getSubdomains, updateSubdomain } from "../src/commands/subdomains";
+import { expect } from "vitest";
+import { getPuter } from "../src/modules/PuterModule";
+
+vi.mock("../src/modules/PuterModule")
+vi.mock("conf", () => {
+  const Conf = vi.fn(() => ({
+    get: vi.fn(),
+    set: vi.fn(),
+    clear: vi.fn(),
+  }));
+  return { default: Conf };
+});
+
+vi.spyOn(console, "log").mockImplementation(() => { });
+
+describe("getSubdomains", () => {
+  it("should get subdomains successfully", async () => {
+    const mockHostingList = vi.fn().mockResolvedValue([{
+      uid: "123",
+      subdomain: "hehe.puter.site",
+      root_dir: { path: "/some/path" },
+    }]);
+    vi.mocked(getPuter).mockReturnValue({
+      hosting: {
+        list: mockHostingList
+      }
+    })
+    const result = await getSubdomains();
+    expect(getPuter).toHaveBeenCalled();
+    expect(result).toHaveLength(1)
+  })
+})
+
+describe("deleteSubdomain", () => {
+  it("should delete subdomain successfully", async () => {
+    const mockHostingDelete = vi.fn().mockResolvedValue(true);
+    vi.mocked(getPuter).mockReturnValue({
+      hosting: {
+        delete: mockHostingDelete
+      }
+    })
+    const result = await deleteSubdomain(["hehe.puter.site"]);
+    expect(result).toBe(true);
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining("Subdomain deleted successfully"));
+  })
+})
+
+describe("createSubdomain", () => {
+  it("should create subdomain successfully", async () => {
+    const mockHostingCreate = vi.fn().mockResolvedValue({
+      uid: "123",
+      subdomain: "hehe.puter.site",
+      root_dir: { path: "/some/path" },
+    });
+    vi.mocked(getPuter).mockReturnValue({
+      hosting: {
+        create: mockHostingCreate
+      }
+    })
+    const result = await createSubdomain("hehe", "/mydir")
+    expect(result).toMatchObject({
+      subdomain: "hehe.puter.site"
+    })
+  })
+})
+
+describe("updateSubdomain", () => {
+  it("should update subdomain successfully", async () => {
+    const mockHostingUpdate = vi.fn().mockResolvedValue({
+      uid: "123",
+      subdomain: "hehe.puter.site",
+      root_dir: { path: "/newdir" },
+    });
+    vi.mocked(getPuter).mockReturnValue({
+      hosting: {
+        update: mockHostingUpdate
+      }
+    })
+    const result = await updateSubdomain("hehe", "/newdir")
+    expect(result).toMatchObject({
+      root_dir: {
+        path: "/newdir"
+      }
+    })
+  })
+})

package/src/modules/SetContextModule.js

@@ -1,5 +0,0 @@
-import { set_context } from "../temporary/context_helpers.js";
-
-export default ({ context }) => {
-    set_context(context);
-};

package/src/temporary/context_helpers.js

@@ -1,17 +0,0 @@
-/**
- * Ideally we would always get a context from the caller, but in some places
- * this is not possible without creating a large number of changes
- * (and therefore also a large number of new bugs). This temporary file
- * provides a way to get the context that modules get.
- */
-
-let context;
-
-// This is called by (list all callers so we can keep track):
-// - auth.js:getAuthToken
-export const get_context = () => {
-    return context;
-};
-
-// This is called by SetContextModule
-export const set_context = ctx => context = ctx;