nexusapp-cli 1.0.0

package/src/commands/domain.ts

@@ -0,0 +1,167 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import { client, apiError, unwrap } from '../client.js';
+import { printTable, printJson, success, errorMsg, timeAgo } from '../output.js';
+import chalk from 'chalk';
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+async function resolveDeployment(nameOrId: string): Promise<any> {
+  if (UUID_RE.test(nameOrId)) {
+    try {
+      const res = await client.get(`/api/deployments/${nameOrId}`);
+      return unwrap(res.data);
+    } catch { /* fall through */ }
+  }
+  const listRes = await client.get('/api/deployments');
+  const all: any[] = Array.isArray(unwrap(listRes.data)) ? unwrap(listRes.data) : [];
+  const match = all.find((d) => d.name === nameOrId || d.displayName === nameOrId);
+  if (!match) throw new Error(`Deployment not found: "${nameOrId}"`);
+  const res = await client.get(`/api/deployments/${match.id}`);
+  return unwrap(res.data);
+}
+
+function verificationBadge(status: string): string {
+  switch ((status || '').toUpperCase()) {
+    case 'VERIFIED': return chalk.green('VERIFIED');
+    case 'PENDING':  return chalk.yellow('PENDING');
+    case 'FAILED':   return chalk.red('FAILED');
+    default:         return chalk.gray(status || 'UNKNOWN');
+  }
+}
+
+export function registerDomain(program: Command): void {
+  const domain = program.command('domain').description('Custom domain management');
+
+  // list
+  domain
+    .command('list <deployment>')
+    .description('List custom domains for a deployment')
+    .option('--json', 'Output raw JSON')
+    .action(async (nameOrId, opts) => {
+      try {
+        const d = await resolveDeployment(nameOrId);
+        const res = await client.get(`/api/deployments/${d.id}/domains`);
+        const domains: any[] = unwrap(res.data) || [];
+
+        if (opts.json) { printJson(domains); return; }
+        if (!domains.length) {
+          console.log(`No custom domains on "${d.displayName || d.name}".`);
+          return;
+        }
+
+        printTable(
+          ['ID', 'DOMAIN', 'STATUS', 'SSL', 'ADDED'],
+          domains.map((dom: any) => [
+            dom.id,
+            dom.domain,
+            verificationBadge(dom.verificationStatus),
+            dom.sslStatus ? chalk.green('✓') : chalk.gray('—'),
+            dom.createdAt ? timeAgo(dom.createdAt) : '—',
+          ])
+        );
+      } catch (err) {
+        errorMsg(apiError(err));
+        process.exit(1);
+      }
+    });
+
+  // add
+  domain
+    .command('add <deployment> <domain>')
+    .description('Add a custom domain to a deployment')
+    .option('--json', 'Output raw JSON')
+    .action(async (nameOrId, domainName, opts) => {
+      try {
+        const d = await resolveDeployment(nameOrId);
+        const res = await client.post(`/api/deployments/${d.id}/domains`, { domain: domainName });
+        const dom = unwrap(res.data);
+
+        if (opts.json) { printJson(dom); return; }
+
+        success(`Domain "${dom.domain}" added to "${d.displayName || d.name}"`);
+        console.log('');
+        console.log('  Next steps to verify ownership:');
+        if (dom.txtRecord || dom.verificationToken) {
+          console.log(`  1. Add a DNS TXT record:`);
+          console.log(`     Name:  ${chalk.cyan(dom.txtRecordName || `_nexusai-verify.${domainName}`)}`);
+          console.log(`     Value: ${chalk.cyan(dom.txtRecord || dom.verificationToken)}`);
+        } else {
+          console.log(`  1. Point your DNS to the deployment URL`);
+        }
+        console.log(`  2. Run: ${chalk.bold(`nexus domain verify ${nameOrId} ${dom.id}`)}`);
+      } catch (err) {
+        errorMsg(apiError(err));
+        process.exit(1);
+      }
+    });
+
+  // verify
+  domain
+    .command('verify <deployment> <domain-id>')
+    .description('Trigger DNS verification for a custom domain')
+    .option('--json', 'Output raw JSON')
+    .action(async (nameOrId, domainId, opts) => {
+      try {
+        const d = await resolveDeployment(nameOrId);
+        const res = await client.post(`/api/deployments/${d.id}/domains/${domainId}/verify`);
+        const result = unwrap(res.data);
+
+        if (opts.json) { printJson(result); return; }
+
+        const dom = result.domain || result;
+        const status = (dom.verificationStatus || '').toUpperCase();
+
+        if (status === 'VERIFIED') {
+          success(`Domain "${dom.domain}" verified successfully`);
+          if (dom.sslStatus) {
+            console.log(`  SSL: ${chalk.green('active')}`);
+          }
+        } else {
+          console.log(`  Status: ${verificationBadge(status)}`);
+          console.log('');
+          if (result.verificationResult?.error) {
+            console.log(`  ${chalk.yellow('!')} ${result.verificationResult.error}`);
+          }
+          console.log(`  DNS changes can take up to 48h to propagate.`);
+          console.log(`  Run this command again once DNS has updated.`);
+        }
+      } catch (err) {
+        errorMsg(apiError(err));
+        process.exit(1);
+      }
+    });
+
+  // remove
+  domain
+    .command('remove <deployment> <domain-id>')
+    .description('Remove a custom domain from a deployment')
+    .option('--yes', 'Skip confirmation prompt')
+    .action(async (nameOrId, domainId, opts) => {
+      try {
+        const d = await resolveDeployment(nameOrId);
+
+        if (!opts.yes) {
+          // Show the domain name in the prompt
+          let domainName = domainId;
+          try {
+            const listRes = await client.get(`/api/deployments/${d.id}/domains`);
+            const domains: any[] = unwrap(listRes.data) || [];
+            const found = domains.find((dom) => dom.id === domainId);
+            if (found) domainName = found.domain;
+          } catch { /* use id */ }
+
+          const { confirm } = await inquirer.prompt([
+            { type: 'confirm', name: 'confirm', message: `Remove domain "${domainName}" from "${d.displayName || d.name}"?`, default: false },
+          ]);
+          if (!confirm) { console.log('Cancelled.'); return; }
+        }
+
+        await client.delete(`/api/deployments/${d.id}/domains/${domainId}`);
+        success(`Domain removed.`);
+      } catch (err) {
+        errorMsg(apiError(err));
+        process.exit(1);
+      }
+    });
+}

package/src/commands/project.ts

@@ -0,0 +1,81 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import { client, apiError, unwrap } from '../client.js';
+import { printTable, printJson, success, errorMsg, timeAgo } from '../output.js';
+
+export function registerProject(program: Command): void {
+  const project = program.command('project').description('Project management commands');
+
+  // list
+  project
+    .command('list')
+    .description('List projects')
+    .option('--json', 'Output raw JSON')
+    .action(async (opts) => {
+      try {
+        const res = await client.get('/api/projects');
+        const raw = unwrap(res.data);
+        const projects = Array.isArray(raw) ? raw : raw.projects || [];
+
+        if (opts.json) { printJson(projects); return; }
+        if (!projects.length) { console.log('No projects found.'); return; }
+
+        printTable(
+          ['ID', 'NAME', 'CREATED'],
+          projects.map((p: any) => [
+            p.id,
+            p.name,
+            p.createdAt ? timeAgo(p.createdAt) : '—',
+          ])
+        );
+      } catch (err) {
+        errorMsg(apiError(err));
+        process.exit(1);
+      }
+    });
+
+  // create
+  project
+    .command('create')
+    .description('Create a new project')
+    .requiredOption('--name <name>', 'Project name')
+    .option('--json', 'Output raw JSON')
+    .action(async (opts) => {
+      try {
+        const res = await client.post('/api/projects', { name: opts.name });
+        const p = unwrap(res.data);
+        if (opts.json) { printJson(p); return; }
+        success(`Project "${p.name}" created (${p.id})`);
+      } catch (err) {
+        errorMsg(apiError(err));
+        process.exit(1);
+      }
+    });
+
+  // delete
+  project
+    .command('delete <id>')
+    .description('Delete a project')
+    .option('--yes', 'Skip confirmation prompt')
+    .action(async (id, opts) => {
+      if (!opts.yes) {
+        const { confirm } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Delete project "${id}"? All deployments in this project will be removed.`,
+            default: false,
+          },
+        ]);
+        if (!confirm) { console.log('Cancelled.'); return; }
+      }
+
+      try {
+        await client.delete(`/api/projects/${id}`);
+        success(`Project ${id} deleted.`);
+      } catch (err) {
+        errorMsg(apiError(err));
+        process.exit(1);
+      }
+    });
+}

package/src/commands/secret.ts

@@ -0,0 +1,117 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import { client, apiError, unwrap } from '../client.js';
+import { printTable, printJson, success, errorMsg, timeAgo } from '../output.js';
+
+export function registerSecret(program: Command): void {
+  const secret = program.command('secret').description('Secret management commands');
+
+  // list
+  secret
+    .command('list')
+    .description('List secrets')
+    .option('--environment <env>', 'Filter by environment')
+    .option('--json', 'Output raw JSON')
+    .action(async (opts) => {
+      try {
+        const params: Record<string, string> = {};
+        if (opts.environment) params.environment = opts.environment;
+
+        const res = await client.get('/api/secrets', { params });
+        const raw = unwrap(res.data);
+        const secrets = Array.isArray(raw) ? raw : raw.secrets || [];
+
+        if (opts.json) { printJson(secrets); return; }
+        if (!secrets.length) { console.log('No secrets found.'); return; }
+
+        printTable(
+          ['ID', 'NAME', 'ENVIRONMENT', 'CREATED'],
+          secrets.map((s: any) => [
+            s.id,
+            s.name,
+            s.environment || '—',
+            s.createdAt ? timeAgo(s.createdAt) : '—',
+          ])
+        );
+      } catch (err) {
+        errorMsg(apiError(err));
+        process.exit(1);
+      }
+    });
+
+  // create
+  secret
+    .command('create')
+    .description('Create a new secret')
+    .requiredOption('--name <name>', 'Secret name')
+    .requiredOption('--environment <env>', 'Target environment')
+    .option('--value <value>', 'Secret value (prompt if omitted)')
+    .action(async (opts) => {
+      let value = opts.value;
+
+      if (!value) {
+        const ans = await inquirer.prompt([
+          { type: 'password', name: 'value', message: 'Value:', mask: '•' },
+        ]);
+        value = ans.value;
+      }
+
+      try {
+        await client.post('/api/secrets', {
+          name: opts.name,
+          environment: opts.environment,
+          value,
+        });
+        success(`Secret ${opts.name} created (${opts.environment})`);
+      } catch (err) {
+        errorMsg(apiError(err));
+        process.exit(1);
+      }
+    });
+
+  // update
+  secret
+    .command('update <id>')
+    .description('Update a secret value')
+    .option('--value <value>', 'New secret value (prompt if omitted)')
+    .action(async (id, opts) => {
+      let value = opts.value;
+
+      if (!value) {
+        const ans = await inquirer.prompt([
+          { type: 'password', name: 'value', message: 'New value:', mask: '•' },
+        ]);
+        value = ans.value;
+      }
+
+      try {
+        await client.put(`/api/secrets/${id}`, { value });
+        success(`Secret ${id} updated.`);
+      } catch (err) {
+        errorMsg(apiError(err));
+        process.exit(1);
+      }
+    });
+
+  // delete
+  secret
+    .command('delete <id>')
+    .description('Delete a secret')
+    .option('--yes', 'Skip confirmation prompt')
+    .action(async (id, opts) => {
+      if (!opts.yes) {
+        const { confirm } = await inquirer.prompt([
+          { type: 'confirm', name: 'confirm', message: `Delete secret "${id}"?`, default: false },
+        ]);
+        if (!confirm) { console.log('Cancelled.'); return; }
+      }
+
+      try {
+        await client.delete(`/api/secrets/${id}`);
+        success(`Secret ${id} deleted.`);
+      } catch (err) {
+        errorMsg(apiError(err));
+        process.exit(1);
+      }
+    });
+}

package/src/config.ts

@@ -0,0 +1,56 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+export interface Config {
+  apiUrl: string;
+  token: string;
+  tokenId: string;
+}
+
+const CONFIG_DIR = path.join(os.homedir(), '.nexusai');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+
+const DEFAULT_API_URL = 'https://api.nexusai.run';
+
+export function getConfig(): Partial<Config> {
+  const envToken = process.env.NEXUSAI_TOKEN;
+  const envApiUrl = process.env.NEXUSAI_API_URL;
+
+  let fileConfig: Partial<Config> = {};
+  if (fs.existsSync(CONFIG_PATH)) {
+    try {
+      fileConfig = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+    } catch {
+      // ignore malformed config
+    }
+  }
+
+  return {
+    apiUrl: envApiUrl || fileConfig.apiUrl || DEFAULT_API_URL,
+    token: envToken || fileConfig.token || '',
+    tokenId: fileConfig.tokenId || '',
+  };
+}
+
+export function saveConfig(config: Config): void {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  }
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+export function clearConfig(): void {
+  if (fs.existsSync(CONFIG_PATH)) {
+    fs.unlinkSync(CONFIG_PATH);
+  }
+}
+
+export function requireToken(): string {
+  const config = getConfig();
+  if (!config.token) {
+    console.error("Not logged in. Run 'nexus auth login' first.");
+    process.exit(1);
+  }
+  return config.token;
+}

package/src/index.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { registerAuth } from './commands/auth.js';
+import { registerDeploy } from './commands/deploy.js';
+import { registerSecret } from './commands/secret.js';
+import { registerProject } from './commands/project.js';
+import { registerDomain } from './commands/domain.js';
+
+const program = new Command();
+
+program
+  .name('nexus')
+  .description('NEXUS AI command-line interface')
+  .version('1.0.0');
+
+registerAuth(program);
+registerDeploy(program);
+registerSecret(program);
+registerProject(program);
+registerDomain(program);
+
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err.message || String(err));
+  process.exit(1);
+});

package/src/output.ts

@@ -0,0 +1,65 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import ora, { Ora } from 'ora';
+
+const STATUS_COLORS: Record<string, (s: string) => string> = {
+  RUNNING: chalk.green,
+  BUILDING: chalk.yellow,
+  DEPLOYING: chalk.yellow,
+  FAILED: chalk.red,
+  STOPPED: chalk.gray,
+  PENDING: chalk.blue,
+  QUEUED: chalk.blue,
+  TERMINATED: chalk.gray,
+};
+
+export function statusBadge(status: string): string {
+  const colorFn = STATUS_COLORS[status?.toUpperCase()] || chalk.white;
+  return colorFn(status || 'UNKNOWN');
+}
+
+export function printTable(headers: string[], rows: (string | undefined | null)[][]): void {
+  const table = new Table({
+    head: headers.map((h) => chalk.bold(h)),
+    style: { head: [], border: [] },
+    chars: {
+      top: '', 'top-mid': '', 'top-left': '', 'top-right': '',
+      bottom: '', 'bottom-mid': '', 'bottom-left': '', 'bottom-right': '',
+      left: '', 'left-mid': '', mid: '', 'mid-mid': '',
+      right: '', 'right-mid': '', middle: '  ',
+    },
+  });
+
+  for (const row of rows) {
+    table.push(row.map((cell) => cell ?? chalk.gray('—')));
+  }
+
+  console.log(table.toString());
+}
+
+export function printJson(obj: unknown): void {
+  console.log(JSON.stringify(obj, null, 2));
+}
+
+export function spinner(text: string): Ora {
+  return ora(text).start();
+}
+
+export function timeAgo(dateStr: string): string {
+  const diff = Date.now() - new Date(dateStr).getTime();
+  const s = Math.floor(diff / 1000);
+  if (s < 60) return `${s}s ago`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ago`;
+  return `${Math.floor(h / 24)}d ago`;
+}
+
+export function success(msg: string): void {
+  console.log(chalk.green('✓') + ' ' + msg);
+}
+
+export function errorMsg(msg: string): void {
+  console.error(chalk.red('✗') + ' ' + msg);
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}