@nexical/cli 0.1.0

package/src/commands/project/update.ts

@@ -0,0 +1,63 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../utils/nexical-client.js';
+
+export default class ProjectsUpdateCommand extends BaseCommand {
+    static description = 'Update project details';
+
+    static args = {
+        args: [
+            {
+                name: 'teamId',
+                required: true,
+                description: 'Team ID',
+            },
+            {
+                name: 'projectId',
+                required: true,
+                description: 'Project ID',
+            },
+        ],
+        options: [
+            {
+                name: '--name <name>',
+                description: 'New name',
+            },
+            {
+                name: '--repo <url>',
+                description: 'New repo URL',
+            },
+            {
+                name: '--prod <url>',
+                description: 'New production URL',
+            },
+            {
+                name: '--mode <mode>',
+                description: 'New mode',
+            },
+        ],
+    };
+
+    async run(options: any) {
+        const client = getClient();
+        const { teamId, projectId, name, repo, prod, mode } = options;
+        const tid = parseInt(teamId, 10);
+        const pid = parseInt(projectId, 10);
+
+        if (isNaN(tid) || isNaN(pid)) {
+            this.error('IDs must be numbers.');
+            return;
+        }
+
+        try {
+            const project = await client.projects.update(tid, pid, {
+                name,
+                repoUrl: repo,
+                productionUrl: prod,
+            });
+            this.success(`Project ${project.id} updated!`);
+        } catch (error: any) {
+            this.error(`Failed to update project: ${error.message}`);
+        }
+    }
+}

package/src/commands/team/create.ts

@@ -0,0 +1,43 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../utils/nexical-client.js';
+
+export default class TeamsCreateCommand extends BaseCommand {
+    static description = 'Create a new team';
+
+    static args = {
+        args: [
+            {
+                name: 'name',
+                required: true,
+                description: 'Name of the team',
+            },
+        ],
+        options: [
+            {
+                name: '--slug <slug>',
+                description: 'Custom URL slug for the team',
+            },
+        ],
+    };
+
+    async run(options: any) {
+        const client = getClient();
+        const { name, slug } = options;
+        // Generate slug from name if not provided (simple version)
+        const finalSlug = slug || name.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+
+        try {
+            const team = await client.teams.create({
+                name,
+                slug: finalSlug,
+            });
+
+            this.success(`Team "${team.name}" created successfully!`);
+            this.info(`ID: ${team.id}`);
+            this.info(`Slug: ${team.slug}`);
+        } catch (error: any) {
+            this.error(`Failed to create team: ${error.message}`);
+        }
+    }
+}

package/src/commands/team/delete.ts

@@ -0,0 +1,50 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../utils/nexical-client.js';
+
+export default class TeamsDeleteCommand extends BaseCommand {
+    static description = 'Delete a team';
+
+    static args = {
+        args: [
+            {
+                name: 'teamId',
+                required: true,
+                description: 'Team ID',
+            },
+        ],
+        options: [
+            {
+                name: '--confirm',
+                description: 'Skip confirmation',
+                default: false,
+            },
+        ],
+    };
+
+    async run(options: any) {
+        const client = getClient();
+        const { teamId, confirm } = options;
+        const tid = parseInt(teamId, 10);
+
+        if (isNaN(tid)) {
+            this.error('Team ID must be a number.');
+            return;
+        }
+
+        if (!confirm) {
+            const answer = await this.prompt(`Are you sure you want to delete team ${tid}? (yes/no)`);
+            if (answer.toLowerCase() !== 'yes') {
+                this.info('Aborted.');
+                return;
+            }
+        }
+
+        try {
+            await client.teams.delete(tid);
+            this.success(`Team ${tid} deleted.`);
+        } catch (error: any) {
+            this.error(`Failed to delete team: ${error.message}`);
+        }
+    }
+}

package/src/commands/team/get.ts

@@ -0,0 +1,39 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../utils/nexical-client.js';
+
+export default class TeamsGetCommand extends BaseCommand {
+    static description = 'Get team details';
+
+    static args = {
+        args: [
+            {
+                name: 'teamId',
+                required: true,
+                description: 'Team ID',
+            },
+        ],
+    };
+
+    async run(options: any) {
+        const client = getClient();
+        const { teamId } = options;
+        const tid = parseInt(teamId, 10);
+
+        if (isNaN(tid)) {
+            this.error('Team ID must be a number.');
+            return;
+        }
+
+        try {
+            const team = await client.teams.get(tid);
+            this.info(`Team Details:`);
+            this.info(`  ID:   ${team.id}`);
+            this.info(`  Name: ${team.name}`);
+            this.info(`  Slug: ${team.slug}`);
+            this.info(`  Role: ${team.role || 'member'}`);
+        } catch (error: any) {
+            this.error(`Failed to get team: ${error.message}`);
+        }
+    }
+}

package/src/commands/team/list.ts

@@ -0,0 +1,26 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../utils/nexical-client.js';
+
+export default class TeamsListCommand extends BaseCommand {
+    static description = 'List all teams you belong to';
+
+    async run() {
+        const client = getClient();
+        try {
+            const teams = await client.teams.list();
+
+            if (teams.length === 0) {
+                this.info('You are not a member of any teams.');
+                return;
+            }
+
+            this.info('Your Teams:');
+            for (const team of teams) {
+                this.info(`- ${team.name} (${team.slug}) [${team.role || 'member'}]`);
+            }
+        } catch (error: any) {
+            this.error(`Failed to list teams: ${error.message}`);
+        }
+    }
+}

package/src/commands/team/member/invite.ts

@@ -0,0 +1,56 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../../utils/nexical-client.js';
+
+export default class TeamsInviteCommand extends BaseCommand {
+    static description = 'Invite a user to a team';
+
+    static args = {
+        args: [
+            {
+                name: 'teamId',
+                required: true,
+                description: 'ID of the team',
+            },
+            {
+                name: 'email',
+                required: true,
+                description: 'Email of the user to invite',
+            },
+        ],
+        options: [
+            {
+                name: '--role <role>',
+                description: 'Role for the new member (admin, member)',
+                default: 'member',
+            },
+        ],
+    };
+
+    async run(options: any) {
+        const client = getClient();
+        const { teamId, email, role } = options;
+
+        try {
+            // teamId from args is string, but SDK expects number usually?
+            // Docs say: Team { id: number; ... }
+            // SDK methods: inviteMember(id, data)
+            // BaseCommand options are typically strings from CLI args.
+            // I should parse teamId to number.
+            const tid = parseInt(teamId, 10);
+            if (isNaN(tid)) {
+                this.error('Team ID must be a number.');
+                return;
+            }
+
+            await client.teams.inviteMember(tid, {
+                email,
+                role: role as any, // Cast to expected enum if needed
+            });
+
+            this.success(`Invited ${email} to team ${tid} as ${role}.`);
+        } catch (error: any) {
+            this.error(`Failed to invite member: ${error.message}`);
+        }
+    }
+}

package/src/commands/team/member/remove.ts

@@ -0,0 +1,40 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../../utils/nexical-client.js';
+
+export default class TeamsMembersRemoveCommand extends BaseCommand {
+    static description = 'Remove a member from a team';
+
+    static args = {
+        args: [
+            {
+                name: 'teamId',
+                required: true,
+                description: 'Team ID',
+            },
+            {
+                name: 'userId',
+                required: true,
+                description: 'User ID (UUID)',
+            },
+        ],
+    };
+
+    async run(options: any) {
+        const client = getClient();
+        const { teamId, userId } = options;
+        const tid = parseInt(teamId, 10);
+
+        if (isNaN(tid)) {
+            this.error('Team ID must be a number.');
+            return;
+        }
+
+        try {
+            await client.teams.removeMember(tid, userId);
+            this.success(`User ${userId} removed from team ${tid}.`);
+        } catch (error: any) {
+            this.error(`Failed to remove member: ${error.message}`);
+        }
+    }
+}

package/src/commands/team/update.ts

@@ -0,0 +1,53 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../utils/nexical-client.js';
+
+export default class TeamsUpdateCommand extends BaseCommand {
+    static description = 'Update team details';
+
+    static args = {
+        args: [
+            {
+                name: 'teamId',
+                required: true,
+                description: 'Team ID',
+            },
+        ],
+        options: [
+            {
+                name: '--name <name>',
+                description: 'New name',
+            },
+            {
+                name: '--slug <slug>',
+                description: 'New slug',
+            },
+        ],
+    };
+
+    async run(options: any) {
+        const client = getClient();
+        const { teamId, name, slug } = options;
+        const tid = parseInt(teamId, 10);
+
+        if (isNaN(tid)) {
+            this.error('Team ID must be a number.');
+            return;
+        }
+
+        if (!name && !slug) {
+            this.warn('No updates provided. Use --name or --slug.');
+            return;
+        }
+
+        try {
+            const team = await client.teams.update(tid, {
+                name,
+            });
+            this.success(`Team ${team.id} updated!`);
+            this.info(`Name: ${team.name}`);
+        } catch (error: any) {
+            this.error(`Failed to update team: ${error.message}`);
+        }
+    }
+}

package/src/commands/token/generate.ts

@@ -0,0 +1,45 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../utils/nexical-client.js';
+
+export default class AuthTokensGenerateCommand extends BaseCommand {
+    static description = 'Generate a new API token';
+
+    static args = {
+        args: [
+            {
+                name: 'name',
+                required: true,
+                description: 'Name of the token',
+            },
+        ],
+        options: [
+            {
+                name: '--scopes <scopes>',
+                description: 'Comma-separated list of scopes',
+            },
+            {
+                name: '--expires <isoDate>',
+                description: 'Expiration date (ISO 8601)',
+            },
+        ],
+    };
+
+    async run(options: any) {
+        const client = getClient();
+        const { name, scopes, expires } = options;
+
+        try {
+            const token = await client.auth.generateToken({
+                name,
+                scopes: scopes ? scopes.split(',') : undefined,
+            });
+
+            this.success(`Token "${name}" generated!`);
+            this.warn(`Token: ${token.token}`);
+            this.warn('Make sure to copy it now. You won\'t be able to see it again!');
+        } catch (error: any) {
+            this.error(`Failed to generate token: ${error.message}`);
+        }
+    }
+}

package/src/commands/token/list.ts

@@ -0,0 +1,27 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../utils/nexical-client.js';
+
+export default class AuthTokensListCommand extends BaseCommand {
+    static description = 'List your API tokens';
+
+    async run() {
+        const client = getClient();
+        try {
+            const response = await client.auth.listTokens();
+            const tokens = response.tokens;
+
+            if (tokens.length === 0) {
+                this.info('No API tokens found.');
+                return;
+            }
+
+            this.info('Your API Tokens:');
+            for (const token of tokens) {
+                this.info(`- ${token.name} (${token.tokenPrefix}...) [Expires: ${token.expiresAt || 'Never'}]`);
+            }
+        } catch (error: any) {
+            this.error(`Failed to list tokens: ${error.message}`);
+        }
+    }
+}

package/src/commands/token/revoke.ts

@@ -0,0 +1,35 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../utils/nexical-client.js';
+
+export default class AuthTokensRevokeCommand extends BaseCommand {
+    static description = 'Revoke an API token';
+
+    static args = {
+        args: [
+            {
+                name: 'id',
+                required: true,
+                description: 'ID of the token to revoke',
+            },
+        ],
+    };
+
+    async run(options: any) {
+        const client = getClient();
+        const { id } = options;
+        const tid = parseInt(id, 10);
+
+        if (isNaN(tid)) {
+            this.error('Token ID must be a number.');
+            return;
+        }
+
+        try {
+            await client.auth.revokeToken(tid);
+            this.success(`Token ${tid} revoked.`);
+        } catch (error: any) {
+            this.error(`Failed to revoke token: ${error.message}`);
+        }
+    }
+}

package/src/commands/whoami.ts

@@ -0,0 +1,21 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../utils/nexical-client.js';
+
+export default class WhoamiCommand extends BaseCommand {
+    static description = 'Show current logged in user';
+
+    async run() {
+        const client = getClient();
+
+        try {
+            const user = await client.users.me();
+            this.info(`Logged in as:`);
+            this.info(`  Name:  ${user.fullName}`);
+            this.info(`  Email: ${user.email}`);
+            this.info(`  ID:    ${user.id}`);
+        } catch (error: any) {
+            this.error('Not logged in or token expired. Run `astrical login`.');
+        }
+    }
+}

package/src/utils/nexical-client.ts

@@ -0,0 +1,40 @@
+
+import { NexicalClient } from '@nexical/sdk';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const CONFIG_DIR = path.join(os.homedir(), '.nexical');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+interface Config {
+    token?: string;
+}
+
+export function getConfig(): Config {
+    if (!fs.existsSync(CONFIG_FILE)) {
+        return {};
+    }
+    try {
+        const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
+        return JSON.parse(content);
+    } catch (error) {
+        return {};
+    }
+}
+
+export function saveToken(token: string) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    const config = getConfig();
+    config.token = token;
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+export function getClient(): NexicalClient {
+    const config = getConfig();
+    return new NexicalClient({
+        token: config.token,
+    });
+}

package/test/integration/commands/admin/create-user.test.ts

@@ -0,0 +1,51 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import AdminUsersCreateSystemCommand from '../../../../src/commands/admin/create-user.js';
+import { getClient } from '../../../../src/utils/nexical-client.js';
+
+vi.mock('../../../../src/utils/nexical-client.js');
+
+describe('AdminUsersCreateSystemCommand Integration', () => {
+    let command: AdminUsersCreateSystemCommand;
+    let mockClient: any;
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+
+        mockClient = {
+            auth: {
+                createSystemUser: vi.fn(),
+            },
+        };
+        vi.mocked(getClient).mockReturnValue(mockClient);
+
+        command = new AdminUsersCreateSystemCommand([], {} as any);
+        vi.spyOn(command, 'info').mockImplementation(() => { });
+        vi.spyOn(command, 'success').mockImplementation(() => { });
+        vi.spyOn(command, 'error').mockImplementation(() => { });
+    });
+
+    it('should create system user successfully', async () => {
+        mockClient.auth.createSystemUser.mockResolvedValue({
+            user: { fullName: 'Integration User', id: 'sys-int' }
+        });
+
+        await command.run({ name: 'Integration User', email: 'sys-int@example.com', password: 'password123' });
+
+        expect(mockClient.auth.createSystemUser).toHaveBeenCalledWith({
+            fullName: 'Integration User',
+            email: 'sys-int@example.com',
+            password: 'password123'
+        });
+        expect(command.success).toHaveBeenCalledWith('System user "Integration User" created!');
+        expect(command.info).toHaveBeenCalledWith('ID: sys-int');
+    });
+
+    it('should handle creation failure', async () => {
+        mockClient.auth.createSystemUser.mockRejectedValue(new Error('Email already exists'));
+
+        await command.run({ name: 'Integration User', email: 'sys-int@example.com', password: 'password123' });
+
+        expect(command.error).toHaveBeenCalledWith('Failed to create system user: Email already exists');
+    });
+});

package/test/integration/commands/branch/create.test.ts

@@ -0,0 +1,51 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import BranchesCreateCommand from '../../../../src/commands/branch/create.js';
+import { getClient } from '../../../../src/utils/nexical-client.js';
+
+vi.mock('../../../../src/utils/nexical-client.js');
+
+describe('BranchesCreateCommand Integration', () => {
+    let command: BranchesCreateCommand;
+    let mockClient: any;
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+
+        mockClient = {
+            branches: {
+                create: vi.fn(),
+            },
+        };
+        vi.mocked(getClient).mockReturnValue(mockClient);
+
+        command = new BranchesCreateCommand([], {} as any);
+        vi.spyOn(command, 'info').mockImplementation(() => { });
+        vi.spyOn(command, 'success').mockImplementation(() => { });
+        vi.spyOn(command, 'error').mockImplementation(() => { });
+    });
+
+    it('should create branch successfully', async () => {
+        mockClient.branches.create.mockResolvedValue({
+            name: 'integration-branch',
+            id: 'br-int'
+        });
+
+        await command.run({ teamId: '1', projectId: '2', name: 'integration-branch', preview: 'http://int.com' });
+
+        expect(mockClient.branches.create).toHaveBeenCalledWith(1, 2, {
+            name: 'integration-branch',
+            previewUrl: 'http://int.com',
+        });
+        expect(command.success).toHaveBeenCalledWith('Branch "integration-branch" created!');
+        expect(command.info).toHaveBeenCalledWith('ID: br-int');
+    });
+
+    it('should handle creation failure', async () => {
+        mockClient.branches.create.mockRejectedValue(new Error('Branch exists'));
+
+        await command.run({ teamId: '1', projectId: '2', name: 'main' });
+
+        expect(command.error).toHaveBeenCalledWith('Failed to create branch: Branch exists');
+    });
+});