@nexical/cli 0.1.0

package/test/unit/commands/token/generate.test.ts

@@ -0,0 +1,65 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import AuthTokensGenerateCommand from '../../../../src/commands/token/generate.js';
+import { getClient } from '../../../../src/utils/nexical-client.js';
+
+vi.mock('../../../../src/utils/nexical-client.js');
+
+describe('AuthTokensGenerateCommand', () => {
+    let command: AuthTokensGenerateCommand;
+    let mockClient: any;
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+
+        mockClient = {
+            auth: {
+                generateToken: vi.fn(),
+            },
+        };
+        vi.mocked(getClient).mockReturnValue(mockClient);
+
+        command = new AuthTokensGenerateCommand([], {} as any);
+        vi.spyOn(command, 'success').mockImplementation(() => { });
+        vi.spyOn(command, 'warn').mockImplementation(() => { });
+        vi.spyOn(command, 'error').mockImplementation(() => { });
+    });
+
+    it('should generate token successfully', async () => {
+        mockClient.auth.generateToken.mockResolvedValue({
+            name: 'My Token',
+            token: 'secret-token-value'
+        });
+
+        await command.run({ name: 'My Token', scopes: 'read,write' });
+
+        expect(mockClient.auth.generateToken).toHaveBeenCalledWith({
+            name: 'My Token',
+            scopes: ['read', 'write'],
+        });
+        expect(command.success).toHaveBeenCalledWith('Token "My Token" generated!');
+        expect(command.warn).toHaveBeenCalledWith('Token: secret-token-value');
+    });
+
+    it('should generate token without scopes', async () => {
+        mockClient.auth.generateToken.mockResolvedValue({
+            name: 'My Token',
+            token: 'secret-token-value'
+        });
+
+        await command.run({ name: 'My Token' });
+
+        expect(mockClient.auth.generateToken).toHaveBeenCalledWith({
+            name: 'My Token',
+            scopes: undefined,
+        });
+    });
+
+    it('should handle generation failure', async () => {
+        mockClient.auth.generateToken.mockRejectedValue(new Error('Limit reached'));
+
+        await command.run({ name: 'My Token' });
+
+        expect(command.error).toHaveBeenCalledWith('Failed to generate token: Limit reached');
+    });
+});

package/test/unit/commands/token/list.test.ts

@@ -0,0 +1,58 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import AuthTokensListCommand from '../../../../src/commands/token/list.js';
+import { getClient } from '../../../../src/utils/nexical-client.js';
+
+vi.mock('../../../../src/utils/nexical-client.js');
+
+describe('AuthTokensListCommand', () => {
+    let command: AuthTokensListCommand;
+    let mockClient: any;
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+
+        mockClient = {
+            auth: {
+                listTokens: vi.fn(),
+            },
+        };
+        vi.mocked(getClient).mockReturnValue(mockClient);
+
+        command = new AuthTokensListCommand([], {} as any);
+        vi.spyOn(command, 'info').mockImplementation(() => { });
+        vi.spyOn(command, 'error').mockImplementation(() => { });
+    });
+
+    it('should list tokens successfully', async () => {
+        mockClient.auth.listTokens.mockResolvedValue({
+            tokens: [
+                { name: 'Token 1', tokenPrefix: 'abc', expiresAt: '2023-01-01' },
+                { name: 'Token 2', tokenPrefix: 'def' }
+            ]
+        });
+
+        await command.run();
+
+        expect(mockClient.auth.listTokens).toHaveBeenCalled();
+        expect(command.info).toHaveBeenCalledWith('Your API Tokens:');
+        expect(command.info).toHaveBeenCalledWith('- Token 1 (abc...) [Expires: 2023-01-01]');
+        expect(command.info).toHaveBeenCalledWith('- Token 2 (def...) [Expires: Never]');
+    });
+
+    it('should handle empty list', async () => {
+        mockClient.auth.listTokens.mockResolvedValue({ tokens: [] });
+
+        await command.run();
+
+        expect(command.info).toHaveBeenCalledWith('No API tokens found.');
+    });
+
+    it('should handle list failure', async () => {
+        mockClient.auth.listTokens.mockRejectedValue(new Error('Network error'));
+
+        await command.run();
+
+        expect(command.error).toHaveBeenCalledWith('Failed to list tokens: Network error');
+    });
+});

package/test/unit/commands/token/revoke.test.ts

@@ -0,0 +1,49 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import AuthTokensRevokeCommand from '../../../../src/commands/token/revoke.js';
+import { getClient } from '../../../../src/utils/nexical-client.js';
+
+vi.mock('../../../../src/utils/nexical-client.js');
+
+describe('AuthTokensRevokeCommand', () => {
+    let command: AuthTokensRevokeCommand;
+    let mockClient: any;
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+
+        mockClient = {
+            auth: {
+                revokeToken: vi.fn(),
+            },
+        };
+        vi.mocked(getClient).mockReturnValue(mockClient);
+
+        command = new AuthTokensRevokeCommand([], {} as any);
+        vi.spyOn(command, 'success').mockImplementation(() => { });
+        vi.spyOn(command, 'error').mockImplementation(() => { });
+    });
+
+    it('should revoke token successfully', async () => {
+        mockClient.auth.revokeToken.mockResolvedValue({});
+
+        await command.run({ id: '123' });
+
+        expect(mockClient.auth.revokeToken).toHaveBeenCalledWith(123);
+        expect(command.success).toHaveBeenCalledWith('Token 123 revoked.');
+    });
+
+    it('should validate ID', async () => {
+        await command.run({ id: 'invalid' });
+        expect(command.error).toHaveBeenCalledWith('Token ID must be a number.');
+        expect(mockClient.auth.revokeToken).not.toHaveBeenCalled();
+    });
+
+    it('should handle revocation failure', async () => {
+        mockClient.auth.revokeToken.mockRejectedValue(new Error('Token not found'));
+
+        await command.run({ id: '123' });
+
+        expect(command.error).toHaveBeenCalledWith('Failed to revoke token: Token not found');
+    });
+});

package/test/unit/commands/whoami.test.ts

@@ -0,0 +1,49 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import WhoamiCommand from '../../../src/commands/whoami.js';
+import { getClient } from '../../../src/utils/nexical-client.js';
+
+vi.mock('../../../src/utils/nexical-client.js');
+
+describe('WhoamiCommand', () => {
+    let command: WhoamiCommand;
+    let mockClient: any;
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+
+        mockClient = {
+            users: {
+                me: vi.fn(),
+            },
+        };
+        vi.mocked(getClient).mockReturnValue(mockClient);
+
+        command = new WhoamiCommand([], {} as any);
+        vi.spyOn(command, 'info').mockImplementation(() => { });
+        vi.spyOn(command, 'error').mockImplementation(() => { });
+    });
+
+    it('should display user info when logged in', async () => {
+        mockClient.users.me.mockResolvedValue({
+            fullName: 'Test User',
+            email: 'test@example.com',
+            id: 'user-123'
+        });
+
+        await command.run();
+
+        expect(command.info).toHaveBeenCalledWith('Logged in as:');
+        expect(command.info).toHaveBeenCalledWith('  Name:  Test User');
+        expect(command.info).toHaveBeenCalledWith('  Email: test@example.com');
+        expect(command.info).toHaveBeenCalledWith('  ID:    user-123');
+    });
+
+    it('should display error when not logged in', async () => {
+        mockClient.users.me.mockRejectedValue(new Error('Unauthorized'));
+
+        await command.run();
+
+        expect(command.error).toHaveBeenCalledWith('Not logged in or token expired. Run `astrical login`.');
+    });
+});

package/test/unit/utils/nexical-client.test.ts

@@ -0,0 +1,98 @@
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { getConfig, saveToken, getClient } from '../../../src/utils/nexical-client.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { NexicalClient } from '@nexical/sdk';
+
+vi.mock('node:fs');
+vi.mock('node:fs');
+vi.mock('node:os', () => ({
+    default: {
+        homedir: () => '/home/user'
+    }
+}));
+vi.mock('@nexical/sdk');
+
+describe('nexical-client', () => {
+    const mockHomeDir = '/home/user';
+    const configDir = path.join(mockHomeDir, '.nexical');
+    const configFile = path.join(configDir, 'config.json');
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+        // os.homedir is already mocked by factory
+    });
+
+    describe('getConfig', () => {
+        it('should return empty object if config file does not exist', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            expect(getConfig()).toEqual({});
+            expect(fs.existsSync).toHaveBeenCalledWith(configFile);
+        });
+
+        it('should return parsed config if file exists', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ token: 'test-token' }));
+            expect(getConfig()).toEqual({ token: 'test-token' });
+            expect(fs.readFileSync).toHaveBeenCalledWith(configFile, 'utf-8');
+        });
+
+        it('should return empty object on JSON parse error', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue('invalid-json');
+            expect(getConfig()).toEqual({});
+        });
+    });
+
+    describe('saveToken', () => {
+        it('should create directory if it does not exist', () => {
+            vi.mocked(fs.existsSync)
+                .mockReturnValueOnce(false) // config dir check
+                .mockReturnValueOnce(false); // config file check (inside getConfig)
+
+            saveToken('new-token');
+
+            expect(fs.mkdirSync).toHaveBeenCalledWith(configDir, { recursive: true });
+            expect(fs.writeFileSync).toHaveBeenCalledWith(
+                configFile,
+                JSON.stringify({ token: 'new-token' }, null, 2)
+            );
+        });
+
+        it('should update existing config', () => {
+            vi.mocked(fs.existsSync)
+                .mockReturnValueOnce(true) // config dir check
+                .mockReturnValueOnce(true); // config file check (inside getConfig)
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ other: 'value' }));
+
+            saveToken('new-token');
+
+            expect(fs.mkdirSync).not.toHaveBeenCalled();
+            expect(fs.writeFileSync).toHaveBeenCalledWith(
+                configFile,
+                JSON.stringify({ other: 'value', token: 'new-token' }, null, 2)
+            );
+        });
+    });
+
+    describe('getClient', () => {
+        it('should return NexicalClient instance with token from config', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ token: 'saved-token' }));
+
+            getClient();
+
+            expect(NexicalClient).toHaveBeenCalledWith({ token: 'saved-token' });
+        });
+
+        it('should return NexicalClient instance without token if config missing', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+
+            getClient();
+
+            expect(NexicalClient).toHaveBeenCalledWith({ token: undefined });
+        });
+    });
+});

package/test/utils/integration-helpers.ts

@@ -0,0 +1,22 @@
+import path from "node:path";
+import { execa } from "execa";
+import { fileURLToPath } from "node:url";
+
+// Constants
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export const CLI_BIN = path.resolve(__dirname, "../../dist/index.js");
+
+/**
+ * Runs the CLI command against the compiled binary (E2E style)
+ */
+export async function runCLI(args: string[], cwd: string, options: any = {}) {
+  return execa("node", [CLI_BIN, ...args], {
+    cwd,
+    ...options,
+    env: {
+      ...process.env,
+      ...options.env,
+    },
+    reject: false, // Allow checking exit code in tests
+  });
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "ESNext",
+        "moduleResolution": "Bundler",
+        "lib": [
+            "ESNext"
+        ],
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "resolveJsonModule": true,
+        "outDir": "./dist"
+    },
+    "include": [
+        "src/commands/**/*",
+        "src/utils/**/*",
+        "test/**/*",
+        "index.ts"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
+}

package/tsup.config.ts

@@ -0,0 +1,18 @@
+import type { Options } from 'tsup';
+
+export default <Options>{
+    entry: ['index.ts', 'src/**/*.ts'],
+    format: ['esm'],
+    target: 'node18',
+    clean: true,
+    bundle: true,
+    sourcemap: true,
+    dts: true,
+    minify: false,
+    splitting: true,
+    outDir: 'dist',
+    shims: true, // Enable shims (including __require shim for legacy deps)
+    banner: {
+        js: 'import { createRequire } from "module"; const require = createRequire(import.meta.url);'
+    },
+};

package/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+        include: ['test/unit/**/*.test.ts'],
+        coverage: {
+            provider: 'v8',
+            reporter: ['text', 'json', 'html'],
+            include: ['src/**/*.ts'],
+            exclude: ['index.ts', '**/*.d.ts']
+        },
+    },
+});

package/vitest.e2e.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+        include: ['test/e2e/**/*.test.ts'],
+        testTimeout: 60000,
+    },
+});

package/vitest.integration.config.ts

@@ -0,0 +1,22 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+        include: ['test/integration/**/*.test.ts'],
+        // Increase timeout for integration tests as they do real IO
+        testTimeout: 60000,
+        fileParallelism: false,
+        server: {
+            deps: {
+                inline: ['@nexical/cli-core'],
+            },
+        },
+        coverage: {
+            provider: 'v8',
+            reporter: ['text', 'json', 'html'],
+            include: ['src/**/*.ts'],
+        },
+    },
+});