nexusapp-cli 2.2.2 → 3.0.0

package/dist/index.js

@@ -12,6 +12,8 @@ const member_js_1 = require("./commands/member.js");
 const database_js_1 = require("./commands/database.js");
 const volume_js_1 = require("./commands/volume.js");
 const bucket_js_1 = require("./commands/bucket.js");
+const managedDb_js_1 = require("./commands/managedDb.js");
+const exec_js_1 = require("./commands/exec.js");
 const program = new commander_1.Command();
 program
     .name('nexus')
@@ -27,6 +29,8 @@ program
 (0, database_js_1.registerDatabase)(program);
 (0, volume_js_1.registerVolume)(program);
 (0, bucket_js_1.registerBucket)(program);
+(0, managedDb_js_1.registerManagedDb)(program);
+(0, exec_js_1.registerExec)(program);
 program.parseAsync(process.argv).catch((err) => {
     console.error(err.message || String(err));
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexusapp-cli",
-  "version": "2.2.2",
+  "version": "3.0.0",
   "description": "NEXUS AI command-line interface",
   "main": "dist/index.js",
   "bin": {

package/src/commands/deploy.ts

@@ -30,6 +30,24 @@ function isInternalDeploymentImage(image?: string): boolean {
   return /^deploy-[0-9a-f-]+(?::|$)/i.test(image.trim());
 }
 
+function parseDurationToDate(value: string): Date {
+  const match = value.match(/^(\d+(?:\.\d+)?)(m|h|d)$/);
+  if (!match) {
+    throw new Error(`Invalid duration "${value}". Use format like: 30m, 4h, 2d`);
+  }
+  const amount = Number(match[1]);
+  const unit = match[2];
+  const msMap: Record<string, number> = { m: 60_000, h: 3_600_000, d: 86_400_000 };
+  return new Date(Date.now() + amount * msMap[unit]);
+}
+
+function formatAutoDestroy(value?: string | null): string {
+  if (!value) return 'disabled';
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return String(value);
+  return `${date.toISOString()} (${timeAgo(value)})`;
+}
+
 async function pollUntilDone(deploymentId: string, spin: ReturnType<typeof spinner>): Promise<void> {
   const terminal = new Set(['RUNNING', 'FAILED', 'TERMINATED', 'STOPPED']);
   while (true) {
@@ -146,6 +164,7 @@ export function registerDeploy(program: Command): void {
           ['Port', String(d.port || '—')],
           ['URL', d.url || d.serviceUrl || '—'],
           ['Replicas', String(d.replicas ?? '—')],
+          ['Auto Destroy', formatAutoDestroy(d.autoDestroyAt)],
           ['Project', d.projectId || '—'],
           ['Created', d.createdAt ? timeAgo(d.createdAt) : '—'],
           ['Updated', d.updatedAt ? timeAgo(d.updatedAt) : '—'],
@@ -211,6 +230,7 @@ export function registerDeploy(program: Command): void {
     .option('--name <name>', 'Deployment name')
     .option('--branch <branch>', 'Git branch')
     .option('--provider <provider>', 'Provider (docker|gcp_cloud_run|aws_ecs_fargate|azure_container_apps)')
+    .option('--region <region>', 'Cloud region to deploy into (e.g. us-central1, canadacentral)')
     .option('--env <pairs...>', 'Environment variables as KEY=VALUE')
     .option('--env-file <file>', 'Load environment variables from a .env file')
     .option('--framework <framework>', 'Framework hint (e.g. node, python, go)')
@@ -222,7 +242,11 @@ export function registerDeploy(program: Command): void {
     .option('--repo-secret <name>', 'Secret name containing private repo token')
     .option('--environment <env>', 'Deployment environment (DEVELOPMENT|STAGING|PRODUCTION)', 'DEVELOPMENT')
     .option('--auto-destroy <hours>', 'Auto-destroy after N hours', parseInt)
-    .option('--services <types>', 'Comma-separated database services to provision (e.g. postgresql,redis)')
+    .option('--services <types>', 'Comma-separated services (e.g. postgres,redis). On cloud providers a database (postgres|mysql) is provisioned as a managed DB; on docker it runs as a sidecar container')
+    .option('--create-db <engine>', 'Alias for --services with a single database (postgres|mysql); provisions a managed cloud DB and injects its connection env')
+    .option('--managed-db <id>', 'Attach an existing managed database by ID and inject its connection env')
+    .option('--db-version <version>', 'Engine version for --create-db (default: postgres 17 / mysql 8.0)')
+    .option('--db-region <region>', 'Cloud region for --create-db (defaults to the deploy region)')
     .option('--worker-command <cmd>', 'Run a background worker sidecar with this command')
     .option('--worker-name <name>', 'Worker service name', 'worker')
     .option('--no-health-check', 'Disable health checks for this deployment')
@@ -241,6 +265,7 @@ export function registerDeploy(program: Command): void {
       if (opts.name) payload.name = opts.name;
       if (opts.branch) payload.repoBranch = opts.branch;
       if (opts.provider) payload.provider = opts.provider;
+      if (opts.region) payload.region = opts.region;
       if (opts.environment) payload.environment = opts.environment;
       if (opts.framework) payload.framework = opts.framework;
       if (opts.buildCommand) payload.buildCommand = opts.buildCommand;
@@ -251,6 +276,10 @@ export function registerDeploy(program: Command): void {
       if (opts.repoSecret) payload.repoSecretName = opts.repoSecret;
       if (opts.autoDestroy) payload.autoDestroyHours = opts.autoDestroy;
       if (opts.healthCheck === false) payload.healthCheckEnabled = false;
+      if (opts.createDb) payload.createDb = opts.createDb;
+      if (opts.managedDb) payload.managedDbId = opts.managedDb;
+      if (opts.dbVersion) payload.dbEngineVersion = opts.dbVersion;
+      if (opts.dbRegion) payload.dbRegion = opts.dbRegion;
       if (opts.services) {
         payload.services = opts.services.split(',').map((s: string) => ({ type: s.trim() }));
       }
@@ -311,17 +340,60 @@ export function registerDeploy(program: Command): void {
         if (!confirm) { console.log('Cancelled.'); return; }
       }
 
-      const baseEnvVars: Record<string, string> = { ...(deployment.envVars || {}) };
-      if (opts.envFile) Object.assign(baseEnvVars, parseEnvFile(opts.envFile));
+      // Env the USER explicitly provides on this redeploy (--env-file / --env).
+      // Kept separate from the deployment's existing env: the API masks secret
+      // values in responses, so re-sending deployment.envVars would overwrite real
+      // values with "***". The in-place redeploy preserves existing env
+      // server-side, so we only send explicit overrides.
+      const explicitOverrides: Record<string, string> = {};
+      if (opts.envFile) Object.assign(explicitOverrides, parseEnvFile(opts.envFile));
       if (opts.env) {
         for (const pair of (opts.env as string[])) {
           const idx = pair.indexOf('=');
-          if (idx > 0) baseEnvVars[pair.slice(0, idx)] = pair.slice(idx + 1);
+          if (idx > 0) explicitOverrides[pair.slice(0, idx)] = pair.slice(idx + 1);
         }
       }
+      // For the legacy "reconstruct as a new deployment" fallback only, start from
+      // the deployment's env. The API masks secret values ("***" or user:***@ in
+      // connection strings); re-sending those would bake literal "***" into the
+      // clone, so drop masked entries (the server regenerates service credentials
+      // and DATABASE_URL for attached services anyway).
+      const baseEnvVars: Record<string, string> = {};
+      for (const [k, v] of Object.entries((deployment.envVars || {}) as Record<string, string>)) {
+        if (v === '***' || /:\/\/[^:/@\s]+:\*\*\*@/.test(String(v))) continue;
+        baseEnvVars[k] = v;
+      }
+      Object.assign(baseEnvVars, explicitOverrides);
       const provider = opts.provider || undefined;
 
       try {
+        // Default: rebuild the SAME deployment in place. This preserves
+        // everything keyed by deployment id — attached managed databases,
+        // volumes, secrets — so "deploy -> attach db -> redeploy" injects the DB
+        // on the rebuild. Renaming or switching provider can't be done in place,
+        // so only the no-override path uses it; anything the server rejects
+        // (zip/folder source, no prior job) falls through to the legacy flow.
+        if (!opts.name && !provider) {
+          try {
+            const body: Record<string, any> = {};
+            // Only send explicit overrides — the server preserves existing env.
+            if (Object.keys(explicitOverrides).length) body.envVars = explicitOverrides;
+            const res = await client.post(`/api/deployments/${deployment.id}/redeploy`, body);
+            const d = unwrap(res.data);
+            if (opts.json) { printJson(d); return; }
+            if (opts.wait) {
+              await pollUntilDone(d.id, spinner(`Rebuilding ${d.name || nameOrId}...`));
+            } else {
+              success(`Redeploy queued (in place): ${d.name || d.id}`);
+              console.log(`  Run 'nexus deploy status ${d.id} --watch' to track progress`);
+            }
+            return;
+          } catch (err: any) {
+            const status = err?.response?.status;
+            if (status !== 400 && status !== 404) throw err;
+          }
+        }
+
         let project: any = null;
         if (deployment.projectId) {
           const projectRes = await client.get(`/api/projects/${deployment.projectId}`);
@@ -763,6 +835,7 @@ export function registerDeploy(program: Command): void {
           ['Provider', d.provider || '—'],
           ['URL', d.url || d.serviceUrl || '—'],
           ['Replicas', String(d.replicas ?? '—')],
+          ['Auto Destroy', formatAutoDestroy(d.autoDestroyAt)],
           ['Updated', d.updatedAt ? timeAgo(d.updatedAt) : '—'],
         ]);
       };
@@ -779,4 +852,53 @@ export function registerDeploy(program: Command): void {
         process.exit(1);
       }
     });
+
+  deploy
+    .command('auto-destroy <name-or-id>')
+    .description('Set, extend, reduce, or disable deployment auto-destroy without restarting the deployment')
+    .option('--in <duration>', 'Destroy after a relative duration, e.g. 30m, 4h, 2d')
+    .option('--at <iso-date>', 'Destroy at an absolute ISO timestamp')
+    .option('--off', 'Disable auto-destroy')
+    .option('--json', 'Output raw JSON')
+    .action(async (nameOrId, opts) => {
+      const selected = [opts.in, opts.at, opts.off].filter(Boolean);
+      if (selected.length !== 1) {
+        errorMsg('Choose exactly one of --in, --at, or --off');
+        process.exit(1);
+      }
+
+      try {
+        const deployment = await resolveDeployment(nameOrId);
+        const payload: Record<string, any> = {};
+
+        if (opts.off) {
+          payload.autoDestroyAt = null;
+        } else if (opts.in) {
+          payload.autoDestroyAt = parseDurationToDate(opts.in).toISOString();
+        } else if (opts.at) {
+          const date = new Date(opts.at);
+          if (Number.isNaN(date.getTime())) {
+            throw new Error(`Invalid ISO date: ${opts.at}`);
+          }
+          payload.autoDestroyAt = date.toISOString();
+        }
+
+        const res = await client.patch(`/api/deployments/${deployment.id}/auto-destroy`, payload);
+        const updated = unwrap(res.data);
+
+        if (opts.json) {
+          printJson(updated);
+          return;
+        }
+
+        success(
+          updated.autoDestroyAt
+            ? `Auto-destroy set for ${updated.displayName || updated.name}: ${formatAutoDestroy(updated.autoDestroyAt)}`
+            : `Auto-destroy disabled for ${updated.displayName || updated.name}`
+        );
+      } catch (err) {
+        errorMsg(apiError(err));
+        process.exit(1);
+      }
+    });
 }

package/src/commands/exec.ts

@@ -0,0 +1,154 @@
+import { Command } from 'commander';
+import * as fs from 'fs';
+import * as path from 'path';
+import { client, apiError, unwrap } from '../client.js';
+import { success, errorMsg, printJson } from '../output.js';
+
+function formatBytes(n: number): string {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  if (n < 1024 * 1024 * 1024) return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(n / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+
+/**
+ * Parse a "<deploymentId>:<path>" argument. Returns null if the arg has no
+ * colon (i.e. it's a local path). UUIDs contain hyphens but no colons, so the
+ * first ":" cleanly separates the two halves.
+ */
+function parseRemoteRef(arg: string): { deploymentId: string; remotePath: string } | null {
+  const idx = arg.indexOf(':');
+  if (idx < 0) return null;
+  const deploymentId = arg.slice(0, idx);
+  const remotePath = arg.slice(idx + 1);
+  if (!deploymentId || !remotePath) return null;
+  return { deploymentId, remotePath };
+}
+
+export function registerExec(program: Command): void {
+  program
+    .command('exec <deploymentId> [command...]')
+    .description('Run a command inside the running deployment container (LOCAL_DOCKER only)')
+    .option('--timeout <seconds>', 'Max seconds before the command is killed (default 60, max 1800)', (v) => parseInt(v, 10))
+    .option('--workdir <path>', 'Working directory inside the container')
+    .option('--json', 'Output raw JSON result')
+    .allowUnknownOption(false)
+    .action(async (deploymentId, commandParts, opts) => {
+      if (!commandParts || commandParts.length === 0) {
+        errorMsg('Provide a command to run, e.g. `nexus exec <id> ls -la /app`');
+        process.exit(2);
+      }
+
+      try {
+        const res = await client.post(
+          `/api/deployments/${deploymentId}/exec`,
+          {
+            command: commandParts,
+            timeoutSeconds: opts.timeout,
+            workingDir: opts.workdir,
+          },
+          { timeout: 0 }
+        );
+        const result = unwrap(res.data);
+
+        if (opts.json) {
+          printJson(result);
+          process.exit(result.exitCode === 0 ? 0 : 1);
+        }
+
+        if (result.stdout) process.stdout.write(result.stdout);
+        if (result.stderr) process.stderr.write(result.stderr);
+        if (result.truncated) {
+          process.stderr.write('\n[output truncated at 2MB per stream]\n');
+        }
+        process.exit(result.exitCode === 0 ? 0 : result.exitCode || 1);
+      } catch (err) {
+        errorMsg(apiError(err));
+        process.exit(1);
+      }
+    });
+
+  program
+    .command('cp <source> <destination>')
+    .description(
+      'Copy a single file between a local path and a running deployment container.\n' +
+      '  Upload:   nexus cp ./index.html <deploymentId>:/app/public/index.html\n' +
+      '  Download: nexus cp <deploymentId>:/app/config.json ./config.json'
+    )
+    .action(async (source, destination) => {
+      const srcRemote = parseRemoteRef(source);
+      const dstRemote = parseRemoteRef(destination);
+
+      if (srcRemote && dstRemote) {
+        errorMsg('Container-to-container copy is not supported. Download first, then upload.');
+        process.exit(2);
+      }
+      if (!srcRemote && !dstRemote) {
+        errorMsg('At least one side must be a container reference (e.g. `<deploymentId>:/app/file.txt`).');
+        process.exit(2);
+      }
+
+      try {
+        if (!srcRemote && dstRemote) {
+          // Upload: local -> container
+          const localPath = path.resolve(source);
+          if (!fs.existsSync(localPath)) {
+            errorMsg(`Local file not found: ${localPath}`);
+            process.exit(1);
+          }
+          const stat = fs.statSync(localPath);
+          if (!stat.isFile()) {
+            errorMsg(`Not a regular file: ${localPath} (directory uploads not supported — tar + exec instead)`);
+            process.exit(1);
+          }
+          const stream = fs.createReadStream(localPath);
+          const res = await client.post(
+            `/api/deployments/${dstRemote.deploymentId}/files`,
+            stream,
+            {
+              params: { path: dstRemote.remotePath },
+              headers: {
+                'Content-Type': 'application/octet-stream',
+                'Content-Length': String(stat.size),
+              },
+              timeout: 0,
+              maxBodyLength: Infinity,
+              maxContentLength: Infinity,
+            }
+          );
+          const data = unwrap(res.data);
+          success(`Uploaded ${formatBytes(data.bytesWritten || stat.size)} → ${dstRemote.deploymentId}:${data.targetPath || dstRemote.remotePath}`);
+          return;
+        }
+
+        // Download: container -> local
+        const remote = srcRemote!;
+        const localPath = path.resolve(destination);
+        const dir = path.dirname(localPath);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+        const res = await client.get(`/api/deployments/${remote.deploymentId}/files`, {
+          params: { path: remote.remotePath },
+          responseType: 'stream',
+          timeout: 0,
+          maxContentLength: Infinity,
+        });
+
+        let bytes = 0;
+        res.data.on('data', (chunk: Buffer) => { bytes += chunk.length; });
+
+        await new Promise<void>((resolve, reject) => {
+          const writer = fs.createWriteStream(localPath);
+          res.data.pipe(writer);
+          writer.on('finish', () => resolve());
+          writer.on('error', reject);
+          res.data.on('error', reject);
+        });
+
+        success(`Downloaded ${formatBytes(bytes)} → ${localPath}`);
+      } catch (err) {
+        errorMsg(apiError(err));
+        process.exit(1);
+      }
+    });
+}

package/src/commands/managedDb.ts

@@ -0,0 +1,170 @@
+import { Command } from 'commander';
+import { client, apiError } from '../client.js';
+import { printTable, printJson, success, errorMsg, timeAgo } from '../output.js';
+
+export function registerManagedDb(program: Command): void {
+  const md = program
+    .command('managed-db')
+    .description('Managed cloud databases (AWS RDS instances)');
+
+  md
+    .command('list')
+    .description('List managed databases')
+    .option('--json', 'Output raw JSON')
+    .action(async (opts) => {
+      try {
+        const res = await client.get('/api/managed-databases');
+        const dbs: any[] = res.data?.managedDatabases || [];
+        if (opts.json) { printJson(dbs); return; }
+        if (!dbs.length) { console.log('No managed databases found.'); return; }
+        printTable(
+          ['ID', 'NAME', 'ENGINE', 'STATUS', 'ENDPOINT', 'CREATED'],
+          dbs.map((d: any) => [
+            d.id,
+            d.displayName ? `${d.name} (${d.displayName})` : d.name,
+            `${d.engine} ${d.engineVersion}`,
+            d.status,
+            d.endpointHost ? `${d.endpointHost}:${d.endpointPort}` : '—',
+            d.createdAt ? timeAgo(d.createdAt) : '—',
+          ])
+        );
+      } catch (err) { errorMsg(apiError(err)); process.exit(1); }
+    });
+
+  md
+    .command('create <name>')
+    .description('Provision a new managed database')
+    .requiredOption('--engine <engine>', 'POSTGRES or MYSQL')
+    .requiredOption('--engine-version <version>', 'e.g. 17.10 (postgres), 8.0.46 (mysql)')
+    .option('--provider <provider>', 'AWS_RDS, GCP_CLOUD_SQL, or AZURE_DATABASE', 'AWS_RDS')
+    .option('--network-mode <mode>', 'public or vpc (AWS only; vpc = private, App Runner-only)')
+    .option('--display-name <name>', 'Friendly display name')
+    .option('--instance-class <class>', 'e.g. db.t3.micro (AWS) / db-custom-1-3840 (GCP)')
+    .option('--allocated-gb <gb>', 'Storage in GB (20-1000)')
+    .option('--region <region>', 'Cloud region')
+    .option('--json', 'Output raw JSON')
+    .action(async (name, opts) => {
+      try {
+        const res = await client.post('/api/managed-databases', {
+          name,
+          provider: opts.provider,
+          networkMode: opts.networkMode,
+          engine: opts.engine,
+          engineVersion: opts.engineVersion,
+          displayName: opts.displayName,
+          instanceClass: opts.instanceClass,
+          allocatedGb: opts.allocatedGb ? Number(opts.allocatedGb) : undefined,
+          region: opts.region,
+        });
+        const db = res.data?.managedDatabase;
+        if (opts.json) { printJson(db); return; }
+        success(`Managed database created: ${db?.id} (${db?.status})`);
+        console.log('Provisioning is async — run `nexus managed-db list` until status is AVAILABLE.');
+      } catch (err) { errorMsg(apiError(err)); process.exit(1); }
+    });
+
+  md
+    .command('delete <id>')
+    .description('Delete a managed database (destroys data)')
+    .option('--json', 'Output raw JSON')
+    .action(async (id, opts) => {
+      try {
+        await client.delete(`/api/managed-databases/${id}`);
+        if (opts.json) { printJson({ success: true }); return; }
+        success(`Managed database ${id} deleted.`);
+      } catch (err) { errorMsg(apiError(err)); process.exit(1); }
+    });
+
+  md
+    .command('attach <id>')
+    .description('Attach a managed database to a deployment')
+    .requiredOption('--deployment <deploymentId>', 'Deployment ID')
+    .option('--env-prefix <prefix>', 'Env var namespace (default DATABASE)')
+    .option('--json', 'Output raw JSON')
+    .action(async (id, opts) => {
+      try {
+        const res = await client.post(`/api/managed-databases/${id}/attach`, {
+          deploymentId: opts.deployment,
+          envPrefix: opts.envPrefix,
+        });
+        if (opts.json) { printJson(res.data?.attachment); return; }
+        success(`Attached to ${opts.deployment}. Redeploy for DATABASE_* env vars to take effect.`);
+      } catch (err) { errorMsg(apiError(err)); process.exit(1); }
+    });
+
+  md
+    .command('detach <id>')
+    .description('Detach a managed database from a deployment')
+    .requiredOption('--deployment <deploymentId>', 'Deployment ID')
+    .option('--json', 'Output raw JSON')
+    .action(async (id, opts) => {
+      try {
+        await client.post(`/api/managed-databases/${id}/detach`, { deploymentId: opts.deployment });
+        if (opts.json) { printJson({ success: true }); return; }
+        success(`Detached from ${opts.deployment}.`);
+      } catch (err) { errorMsg(apiError(err)); process.exit(1); }
+    });
+
+  md
+    .command('snapshot <id>')
+    .description('Create a snapshot backup of a managed database')
+    .option('--notes <notes>', 'Optional notes')
+    .option('--json', 'Output raw JSON')
+    .action(async (id, opts) => {
+      try {
+        const res = await client.post(`/api/managed-databases/${id}/snapshots`, { notes: opts.notes });
+        const snap = res.data?.snapshot;
+        if (opts.json) { printJson(snap); return; }
+        success(`Snapshot ${snap?.id} started (${snap?.status}).`);
+      } catch (err) { errorMsg(apiError(err)); process.exit(1); }
+    });
+
+  md
+    .command('snapshots <id>')
+    .description('List snapshot backups for a managed database')
+    .option('--json', 'Output raw JSON')
+    .action(async (id, opts) => {
+      try {
+        const res = await client.get(`/api/managed-databases/${id}/snapshots`);
+        const snaps: any[] = res.data?.snapshots || [];
+        if (opts.json) { printJson(snaps); return; }
+        if (!snaps.length) { console.log('No snapshots found.'); return; }
+        printTable(
+          ['ID', 'STATUS', 'SIZE (B)', 'NOTES', 'CREATED'],
+          snaps.map((s: any) => [s.id, s.status, String(s.sizeBytes), s.notes || '—', s.createdAt ? timeAgo(s.createdAt) : '—'])
+        );
+      } catch (err) { errorMsg(apiError(err)); process.exit(1); }
+    });
+
+  md
+    .command('query <id> <sql>')
+    .description('Run a SQL statement against a managed database')
+    .option('--json', 'Output raw JSON')
+    .action(async (id, sql, opts) => {
+      try {
+        const res = await client.post(`/api/managed-databases/${id}/query`, { sql });
+        if (opts.json) { printJson(res.data); return; }
+        const rows = res.data?.rows || [];
+        console.log(`${res.data?.classification}: ${res.data?.rowCount} row(s)`);
+        if (rows.length) printJson(rows);
+      } catch (err) { errorMsg(apiError(err)); process.exit(1); }
+    });
+
+  md
+    .command('restore <id>')
+    .description('Restore a snapshot into a NEW managed database (non-destructive)')
+    .requiredOption('--snapshot <snapshotId>', 'Snapshot ID to restore from')
+    .requiredOption('--new-name <name>', 'Name for the restored database')
+    .option('--json', 'Output raw JSON')
+    .action(async (id, opts) => {
+      try {
+        const res = await client.post(`/api/managed-databases/${id}/restore`, {
+          snapshotId: opts.snapshot,
+          newName: opts.newName,
+        });
+        const db = res.data?.managedDatabase;
+        if (opts.json) { printJson(db); return; }
+        success(`Restore started: new database ${db?.id} (${db?.status}). Run \`nexus managed-db list\` until AVAILABLE.`);
+      } catch (err) { errorMsg(apiError(err)); process.exit(1); }
+    });
+}

package/src/index.ts

@@ -10,6 +10,8 @@ import { registerMember } from './commands/member.js';
 import { registerDatabase } from './commands/database.js';
 import { registerVolume } from './commands/volume.js';
 import { registerBucket } from './commands/bucket.js';
+import { registerManagedDb } from './commands/managedDb.js';
+import { registerExec } from './commands/exec.js';
 
 const program = new Command();
 
@@ -28,6 +30,8 @@ registerMember(program);
 registerDatabase(program);
 registerVolume(program);
 registerBucket(program);
+registerManagedDb(program);
+registerExec(program);
 
 program.parseAsync(process.argv).catch((err) => {
   console.error(err.message || String(err));