@nexical/cli 0.1.0

package/src/commands/branch/delete.ts

@@ -0,0 +1,47 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../utils/nexical-client.js';
+
+export default class BranchesDeleteCommand extends BaseCommand {
+    static description = 'Delete a branch';
+
+    static args = {
+        args: [
+            {
+                name: 'teamId',
+                required: true,
+                description: 'Team ID',
+            },
+            {
+                name: 'projectId',
+                required: true,
+                description: 'Project ID',
+            },
+            {
+                name: 'branchId',
+                required: true,
+                description: 'Branch ID',
+            },
+        ],
+    };
+
+    async run(options: any) {
+        const client = getClient();
+        const { teamId, projectId, branchId } = options;
+        const tid = parseInt(teamId, 10);
+        const pid = parseInt(projectId, 10);
+        const bid = parseInt(branchId, 10);
+
+        if (isNaN(tid) || isNaN(pid) || isNaN(bid)) {
+            this.error('IDs must be numbers.');
+            return;
+        }
+
+        try {
+            await client.branches.delete(tid, pid, bid);
+            this.success(`Branch ${bid} deleted.`);
+        } catch (error: any) {
+            this.error(`Failed to delete branch: ${error.message}`);
+        }
+    }
+}

package/src/commands/branch/get.ts

@@ -0,0 +1,50 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../utils/nexical-client.js';
+
+export default class BranchesGetCommand extends BaseCommand {
+    static description = 'Get branch details';
+
+    static args = {
+        args: [
+            {
+                name: 'teamId',
+                required: true,
+                description: 'Team ID',
+            },
+            {
+                name: 'projectId',
+                required: true,
+                description: 'Project ID',
+            },
+            {
+                name: 'branchId',
+                required: true,
+                description: 'Branch ID',
+            },
+        ],
+    };
+
+    async run(options: any) {
+        const client = getClient();
+        const { teamId, projectId, branchId } = options;
+        const tid = parseInt(teamId, 10);
+        const pid = parseInt(projectId, 10);
+        const bid = parseInt(branchId, 10);
+
+        if (isNaN(tid) || isNaN(pid) || isNaN(bid)) {
+            this.error('IDs must be numbers.');
+            return;
+        }
+
+        try {
+            const branch = await client.branches.get(tid, pid, bid);
+            this.info(`Branch Details:`);
+            this.info(`  ID:   ${branch.id}`);
+            this.info(`  Name: ${branch.name}`);
+            this.info(`  Preview: ${branch.previewUrl || 'N/A'}`);
+        } catch (error: any) {
+            this.error(`Failed to get branch: ${error.message}`);
+        }
+    }
+}

package/src/commands/branch/list.ts

@@ -0,0 +1,50 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../utils/nexical-client.js';
+
+export default class BranchesListCommand extends BaseCommand {
+    static description = 'List branches in a project';
+
+    static args = {
+        args: [
+            {
+                name: 'teamId',
+                required: true,
+                description: 'Team ID',
+            },
+            {
+                name: 'projectId',
+                required: true,
+                description: 'Project ID',
+            },
+        ],
+    };
+
+    async run(options: any) {
+        const client = getClient();
+        const { teamId, projectId } = 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 branches = await client.branches.list(tid, pid);
+
+            if (branches.length === 0) {
+                this.info('No branches found.');
+                return;
+            }
+
+            this.info(`Branches for Project ${pid}:`);
+            for (const branch of branches) {
+                this.info(`- ${branch.name} (ID: ${branch.id})`);
+            }
+        } catch (error: any) {
+            this.error(`Failed to list branches: ${error.message}`);
+        }
+    }
+}

package/src/commands/job/get.ts

@@ -0,0 +1,59 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../utils/nexical-client.js';
+
+export default class JobsGetCommand extends BaseCommand {
+    static description = 'Get job details';
+
+    static args = {
+        args: [
+            {
+                name: 'teamId',
+                required: true,
+                description: 'Team ID',
+            },
+            {
+                name: 'projectId',
+                required: true,
+                description: 'Project ID',
+            },
+            {
+                name: 'branchId',
+                required: true,
+                description: 'Branch ID',
+            },
+            {
+                name: 'jobId',
+                required: true,
+                description: 'Job ID',
+            },
+        ],
+    };
+
+    async run(options: any) {
+        const client = getClient();
+        const { teamId, projectId, branchId, jobId } = options;
+        const tid = parseInt(teamId, 10);
+        const pid = parseInt(projectId, 10);
+        const bid = parseInt(branchId, 10);
+        const jid = parseInt(jobId, 10);
+
+        if (isNaN(tid) || isNaN(pid) || isNaN(bid) || isNaN(jid)) {
+            this.error('IDs must be numbers.');
+            return;
+        }
+
+        try {
+            const job = await client.jobs.get(tid, pid, bid, jid);
+            this.info(`Job Details:`);
+            this.info(`  ID:      ${job.id}`);
+            this.info(`  Type:    ${job.type}`);
+            this.info(`  Status:  ${job.status}`);
+            this.info(`  Started: ${job.startedAt || 'Waiting'}`);
+            this.info(`  Ended:   ${job.completedAt || 'Running'}`);
+            this.info(`  Queue:   ${job.queue}`);
+        } catch (error: any) {
+            this.error(`Failed to get job: ${error.message}`);
+        }
+    }
+}

package/src/commands/job/list.ts

@@ -0,0 +1,56 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../utils/nexical-client.js';
+
+export default class JobsListCommand extends BaseCommand {
+    static description = 'List jobs for a branch';
+
+    static args = {
+        args: [
+            {
+                name: 'teamId',
+                required: true,
+                description: 'Team ID',
+            },
+            {
+                name: 'projectId',
+                required: true,
+                description: 'Project ID',
+            },
+            {
+                name: 'branchId',
+                required: true,
+                description: 'Branch ID',
+            },
+        ],
+    };
+
+    async run(options: any) {
+        const client = getClient();
+        const { teamId, projectId, branchId } = options;
+        const tid = parseInt(teamId, 10);
+        const pid = parseInt(projectId, 10);
+        const bid = parseInt(branchId, 10);
+
+        if (isNaN(tid) || isNaN(pid) || isNaN(bid)) {
+            this.error('IDs must be numbers.');
+            return;
+        }
+
+        try {
+            const jobs = await client.jobs.list(tid, pid, bid);
+
+            if (jobs.length === 0) {
+                this.info('No jobs found.');
+                return;
+            }
+
+            this.info(`Jobs for Branch ${bid}:`);
+            for (const job of jobs) {
+                this.info(`${job.id} - ${job.type} [${job.status}] (Started: ${job.startedAt || 'Waiting'})`);
+            }
+        } catch (error: any) {
+            this.error(`Failed to list jobs: ${error.message}`);
+        }
+    }
+}

package/src/commands/job/logs.ts

@@ -0,0 +1,67 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../utils/nexical-client.js';
+
+export default class JobsLogsCommand extends BaseCommand {
+    static description = 'Get logs for a job';
+
+    static args = {
+        args: [
+            {
+                name: 'teamId',
+                required: true,
+                description: 'Team ID',
+            },
+            {
+                name: 'projectId',
+                required: true,
+                description: 'Project ID',
+            },
+            {
+                name: 'branchId',
+                required: true,
+                description: 'Branch ID',
+            },
+            {
+                name: 'jobId',
+                required: true,
+                description: 'Job ID',
+            },
+        ],
+    };
+
+    async run(options: any) {
+        const client = getClient();
+        const { teamId, projectId, branchId, jobId } = options;
+        const tid = parseInt(teamId, 10);
+        const pid = parseInt(projectId, 10);
+        const bid = parseInt(branchId, 10);
+        const jid = parseInt(jobId, 10);
+
+        if (isNaN(tid) || isNaN(pid) || isNaN(bid) || isNaN(jid)) {
+            this.error('IDs must be numbers.');
+            return;
+        }
+
+        try {
+            const logs = await client.jobs.getLogs(tid, pid, bid, jid);
+
+            this.info(`Logs for Job ${jid}:`);
+            // Assuming logs is an array of JobLog objects
+            for (const log of (logs as any)) { // Casting because SDK return type might be generic array
+                const timestamp = new Date(log.timestamp).toLocaleTimeString();
+                const color = log.level === 'error' ? 'red' : log.level === 'warn' ? 'yellow' : 'white';
+
+                if (log.level === 'error') {
+                    this.error(`[${timestamp}] ${log.message}`);
+                } else if (log.level === 'warn') {
+                    this.warn(`[${timestamp}] ${log.message}`);
+                } else {
+                    this.info(`[${timestamp}] ${log.message}`);
+                }
+            }
+        } catch (error: any) {
+            this.error(`Failed to get logs: ${error.message}`);
+        }
+    }
+}

package/src/commands/job/trigger.ts

@@ -0,0 +1,73 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../utils/nexical-client.js';
+
+export default class JobsTriggerCommand extends BaseCommand {
+    static description = 'Trigger a new job';
+
+    static args = {
+        args: [
+            {
+                name: 'teamId',
+                required: true,
+                description: 'Team ID',
+            },
+            {
+                name: 'projectId',
+                required: true,
+                description: 'Project ID',
+            },
+            {
+                name: 'branchId',
+                required: true,
+                description: 'Branch ID',
+            },
+            {
+                name: 'type',
+                required: true,
+                description: 'Job type (e.g., deploy, build)',
+            },
+        ],
+        options: [
+            {
+                name: '--input <json>',
+                description: 'Input JSON string',
+            },
+        ],
+    };
+
+    async run(options: any) {
+        const client = getClient();
+        const { teamId, projectId, branchId, type, input } = options;
+        const tid = parseInt(teamId, 10);
+        const pid = parseInt(projectId, 10);
+        const bid = parseInt(branchId, 10);
+
+        if (isNaN(tid) || isNaN(pid) || isNaN(bid)) {
+            this.error('IDs must be numbers.');
+            return;
+        }
+
+        let inputs = {};
+        if (input) {
+            try {
+                inputs = JSON.parse(input);
+            } catch (e) {
+                this.error('Invalid JSON inputs.');
+                return;
+            }
+        }
+
+        try {
+            const job = await client.jobs.create(tid, pid, bid, {
+                type,
+                inputs,
+            });
+
+            this.success(`Job ${job.id} triggered successfully!`);
+            this.info(`Status: ${job.status}`);
+        } catch (error: any) {
+            this.error(`Failed to trigger job: ${error.message}`);
+        }
+    }
+}

package/src/commands/login.ts

@@ -0,0 +1,31 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient, saveToken } from '../utils/nexical-client.js';
+
+export default class LoginCommand extends BaseCommand {
+    static description = 'Authenticate with Nexical via Device Flow';
+
+    async run() {
+        const client = getClient();
+
+        this.info('Starting device authentication...');
+
+        try {
+            const token = await client.auth.authenticateDevice('nexical-cli', (userCode, verificationUri) => {
+                this.notice(`Please visit: ${verificationUri}`);
+                this.notice(`And enter code: ${userCode}`);
+
+                // Optionally, we could try to open the browser here
+                // import open from 'open'; open(verificationUri);
+            });
+
+            saveToken(token);
+            client.setToken(token);
+
+            const user = await client.users.me();
+            this.success(`Successfully logged in as ${user.fullName} (${user.email})`);
+        } catch (error: any) {
+            this.error(`Login failed: ${error.message}`);
+        }
+    }
+}

package/src/commands/project/create.ts

@@ -0,0 +1,61 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../utils/nexical-client.js';
+
+export default class ProjectsCreateCommand extends BaseCommand {
+    static description = 'Create a new project';
+
+    static args = {
+        args: [
+            {
+                name: 'teamId',
+                required: true,
+                description: 'ID of the team',
+            },
+            {
+                name: 'name',
+                required: true,
+                description: 'Name of the project',
+            },
+        ],
+        options: [
+            {
+                name: '--repo <url>',
+                description: 'Repository URL',
+            },
+            {
+                name: '--prod <url>',
+                description: 'Production URL',
+            },
+            {
+                name: '--mode <mode>',
+                description: 'Mode (managed, self_hosted)',
+                default: 'managed',
+            },
+        ],
+    };
+
+    async run(options: any) {
+        const client = getClient();
+        const { teamId, name, repo, prod, mode } = options;
+        const tid = parseInt(teamId, 10);
+
+        if (isNaN(tid)) {
+            this.error('Team ID must be a number.');
+            return;
+        }
+
+        try {
+            const project = await client.projects.create(tid, {
+                name,
+                repoUrl: repo,
+                productionUrl: prod
+            });
+
+            this.success(`Project "${project.name}" set up successfully!`);
+            this.info(`ID: ${project.id}`);
+        } catch (error: any) {
+            this.error(`Failed to create project: ${error.message}`);
+        }
+    }
+}

package/src/commands/project/delete.ts

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

package/src/commands/project/get.ts

@@ -0,0 +1,46 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../utils/nexical-client.js';
+
+export default class ProjectsGetCommand extends BaseCommand {
+    static description = 'Get project details';
+
+    static args = {
+        args: [
+            {
+                name: 'teamId',
+                required: true,
+                description: 'Team ID',
+            },
+            {
+                name: 'projectId',
+                required: true,
+                description: 'Project ID',
+            },
+        ],
+    };
+
+    async run(options: any) {
+        const client = getClient();
+        const { teamId, projectId } = 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.get(tid, pid);
+            this.info(`Project Details:`);
+            this.info(`  ID:   ${project.id}`);
+            this.info(`  Name: ${project.name}`);
+            this.info(`  Repo: ${project.repoUrl || 'N/A'}`);
+            this.info(`  Prod: ${project.productionUrl || 'N/A'}`);
+            this.info(`  Mode: ${project.mode}`);
+        } catch (error: any) {
+            this.error(`Failed to get project: ${error.message}`);
+        }
+    }
+}

package/src/commands/project/list.ts

@@ -0,0 +1,44 @@
+
+import { BaseCommand } from '@nexical/cli-core';
+import { getClient } from '../../utils/nexical-client.js';
+
+export default class ProjectsListCommand extends BaseCommand {
+    static description = 'List projects in a team';
+
+    static args = {
+        args: [
+            {
+                name: 'teamId',
+                required: true,
+                description: 'ID of the team',
+            },
+        ],
+    };
+
+    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 projects = await client.projects.list(tid);
+
+            if (projects.length === 0) {
+                this.info(`No projects found in team ${tid}.`);
+                return;
+            }
+
+            this.info(`Projects in Team ${tid}:`);
+            for (const project of projects) {
+                this.info(`- ${project.name} (ID: ${project.id}) [${project.repoUrl || 'No Repo'}]`);
+            }
+        } catch (error: any) {
+            this.error(`Failed to list projects: ${error.message}`);
+        }
+    }
+}