@build-astron-co/nimbus 0.2.0 → 0.4.0

package/src/commands/help.ts

@@ -39,9 +39,29 @@ interface CommandDoc {
  * Command documentation
  */
 const COMMANDS: Record<string, CommandDoc> = {
+  run: {
+    name: 'run',
+    description: 'Run the Nimbus DevOps agent non-interactively with a prompt',
+    usage: 'nimbus run "<prompt>" [options]',
+    options: [
+      { flag: '--mode <mode>', description: 'Agent mode: plan, build, deploy', default: 'build' },
+      { flag: '--format <fmt>', description: 'Output format: text, json', default: 'text' },
+      { flag: '--auto-approve, -y', description: 'Auto-approve all tool permissions' },
+      { flag: '--stdin', description: 'Read prompt from stdin (pipe support)' },
+      { flag: '--model <model>', description: 'Override LLM model' },
+      { flag: '--max-turns <n>', description: 'Maximum agent turns', default: '50' },
+    ],
+    examples: [
+      'nimbus run "run terraform plan and summarize changes"',
+      'nimbus run "check for k8s pod restarts in production" --mode plan',
+      'nimbus run "apply the staging deployment" --mode deploy --auto-approve',
+      'echo "review my IAM policies" | nimbus run --stdin --format json',
+    ],
+  },
+
   chat: {
     name: 'chat',
-    description: 'Interactive AI chat for cloud engineering assistance',
+    description: 'Interactive DevOps agent — Terraform, Kubernetes, Helm, AWS, GCP, Azure',
     usage: 'nimbus chat [options]',
     options: [
       { flag: '-m, --message <text>', description: 'Send a single message (non-interactive)' },
@@ -298,10 +318,22 @@ const COMMANDS: Record<string, CommandDoc> = {
       { name: 'init', description: 'Initialize configuration interactively' },
       { name: 'reset', description: 'Reset configuration to defaults' },
     ],
+    options: [
+      { flag: 'default-model <model>', description: 'Default LLM model to use', default: 'anthropic/claude-sonnet-4-6' },
+      { flag: 'default-mode <mode>', description: 'Default agent mode: plan | build | deploy', default: 'build' },
+      { flag: 'theme <theme>', description: 'TUI color theme: default | dark | light', default: 'default' },
+      { flag: 'auto-approve <bool>', description: 'Auto-approve all tool permissions (true/false)', default: 'false' },
+      { flag: 'max-tokens <n>', description: 'Maximum output tokens per LLM response', default: '8192' },
+      { flag: 'telemetry <bool>', description: 'Enable anonymous usage analytics (true/false)', default: 'true' },
+      { flag: 'serve.port <port>', description: 'Default port for nimbus serve', default: '4200' },
+      { flag: 'serve.auth <user:pass>', description: 'HTTP Basic Auth for nimbus serve (user:password)' },
+    ],
     examples: [
       'nimbus config list',
-      'nimbus config get llm.provider',
-      'nimbus config set llm.model gpt-4',
+      'nimbus config get default-model',
+      'nimbus config set default-model anthropic/claude-opus-4-6',
+      'nimbus config set auto-approve true',
+      'nimbus config set serve.port 8080',
     ],
   },
 
@@ -406,6 +438,134 @@ const COMMANDS: Record<string, CommandDoc> = {
       'nimbus team members',
     ],
   },
+
+  drift: {
+    name: 'drift',
+    description: 'Detect infrastructure drift between desired state (IaC) and actual cloud state',
+    usage: 'nimbus drift [options]',
+    options: [
+      { flag: '--provider <type>', description: 'IaC provider: terraform, kubernetes, helm', default: 'terraform' },
+      { flag: '--workdir <path>', description: 'Working directory with IaC configs', default: '.' },
+    ],
+    examples: [
+      'nimbus drift',
+      'nimbus drift --provider kubernetes',
+      'nimbus run "check for infrastructure drift" --mode plan',
+    ],
+  },
+
+  cost: {
+    name: 'cost',
+    description: 'Estimate infrastructure costs from Terraform plans or working directory',
+    usage: 'nimbus cost [options]',
+    options: [
+      { flag: '--plan-file <file>', description: 'Path to a saved Terraform plan file' },
+      { flag: '--workdir <path>', description: 'Working directory containing Terraform config', default: '.' },
+    ],
+    examples: [
+      'nimbus cost',
+      'nimbus cost --plan-file tfplan.json',
+      'nimbus run "estimate monthly cost for this infrastructure"',
+    ],
+  },
+
+  'auth-refresh': {
+    name: 'auth-refresh',
+    description: 'Re-validate and refresh cloud provider credentials (AWS SSO, GCP, Azure)',
+    usage: 'nimbus auth-refresh [options]',
+    options: [
+      { flag: '--provider <name>', description: 'Provider to refresh: aws, gcp, azure, all', default: 'all' },
+    ],
+    examples: [
+      'nimbus auth-refresh',
+      'nimbus auth-refresh --provider aws',
+      'nimbus auth-refresh --provider gcp',
+    ],
+  },
+
+  profile: {
+    name: 'profile',
+    description: 'Manage per-project credential profiles (AWS, kubectl, Terraform, GCP)',
+    usage: 'nimbus profile <list|create|set|delete|show> [name]',
+    subcommands: [
+      { name: 'list', description: 'Show all profiles (current marked with *)' },
+      { name: 'create <name>', description: 'Create a new profile (interactive wizard)' },
+      { name: 'set <name>', description: 'Switch to a profile atomically (sets AWS_PROFILE, kubectl context, TF workspace)' },
+      { name: 'delete <name>', description: 'Delete a profile' },
+      { name: 'show [name]', description: 'Display profile details' },
+    ],
+    examples: [
+      'nimbus profile list',
+      'nimbus profile create prod',
+      'nimbus profile set prod',
+      'nimbus profile delete staging',
+    ],
+  },
+
+  incident: {
+    name: 'incident',
+    description: 'Launch an incident response session pre-loaded with alert context (G14)',
+    usage: 'nimbus incident <pagerduty-url-or-id|description> [--notes "observed behavior"]',
+    options: [
+      { flag: '--notes <text>', description: 'Observed behavior or additional context' },
+    ],
+    examples: [
+      'nimbus incident https://example.pagerduty.com/incidents/P1234',
+      'nimbus incident "high CPU on api-service pods" --notes "started after deploy at 14:00"',
+      'nimbus incident PABC123',
+    ],
+  },
+
+  runbook: {
+    name: 'runbook',
+    description: 'Load and execute operational runbooks as agent prompts (G15)',
+    usage: 'nimbus runbook <list|run|create> [name]',
+    subcommands: [
+      { name: 'list', description: 'List available runbooks' },
+      { name: 'run <name>', description: 'Execute a runbook as an agent session' },
+      { name: 'create <name>', description: 'Create a new runbook interactively' },
+    ],
+    examples: [
+      'nimbus runbook list',
+      'nimbus runbook run rotate-certs',
+      'nimbus runbook run cert-rotation --auto',
+      'nimbus runbook create db-backup',
+    ],
+  },
+
+  schedule: {
+    name: 'schedule',
+    description: 'Manage periodic DevOps automation tasks (G13)',
+    usage: 'nimbus schedule <list|add|remove|run-now>',
+    subcommands: [
+      { name: 'list', description: 'List configured schedules with next-run times' },
+      { name: 'add "<cron>" "<prompt>"', description: 'Add a new periodic task' },
+      { name: 'remove <id-or-name>', description: 'Remove a schedule' },
+      { name: 'run-now <id-or-name>', description: 'Execute a schedule immediately' },
+    ],
+    examples: [
+      'nimbus schedule list',
+      'nimbus schedule add "0 8 * * *" "check for infrastructure drift" --name daily-drift',
+      'nimbus schedule add "0 9 * * 1" "generate weekly cost report"',
+      'nimbus schedule run-now daily-drift',
+      'nimbus schedule remove daily-drift',
+    ],
+  },
+
+  export: {
+    name: 'export',
+    description: 'Export session conversation to markdown, HTML, or JSON (G19)',
+    usage: 'nimbus export [session-id] [--format md|html|json] [--output file]',
+    options: [
+      { flag: '--format <fmt>', description: 'Output format: md, html, json', default: 'md' },
+      { flag: '--output <file>', description: 'Save to file instead of stdout' },
+    ],
+    examples: [
+      'nimbus export',
+      'nimbus export abc123 --format html --output session.html',
+      'nimbus export --format json > session.json',
+    ],
+  },
 };
 
 /**
@@ -462,59 +622,75 @@ function showCommandHelp(commandName: string): void {
  * Show general help
  */
 function showGeneralHelp(): void {
-  ui.header('Nimbus CLI');
-  ui.print('AI-powered Cloud Engineering Agent');
+  ui.header('Nimbus — AI-Powered DevOps Terminal');
+  ui.print('Plan, apply, and manage Terraform, Kubernetes, Helm, AWS, GCP, Azure with natural language.');
+  ui.print('Type a DevOps request directly or use any command below.');
   ui.newLine();
 
   ui.print('Usage:');
   ui.print('  nimbus <command> [options]');
+  ui.print('  nimbus                  Open interactive DevOps agent TUI');
+  ui.print('  nimbus run "<prompt>"   Run agent non-interactively');
+  ui.newLine();
+
+  ui.print('DevOps Operations:');
+  ui.print('  plan              Preview infrastructure changes (tf/k8s/helm)');
+  ui.print('  apply             Apply infrastructure changes');
+  ui.print('  tf <cmd>          Terraform init/plan/apply/validate/destroy');
+  ui.print('  k8s <cmd>         Kubernetes get/apply/delete/logs/scale');
+  ui.print('  helm <cmd>        Helm install/upgrade/rollback/list');
+  ui.print('  drift             Detect infrastructure drift (IaC vs actual)');
+  ui.print('  cost              Estimate infrastructure costs');
+  ui.print('  status            Live infra health dashboard (TF + K8s + Helm)');
   ui.newLine();
 
-  ui.print('Chat & AI:');
-  ui.print('  chat              Interactive AI chat');
-  ui.print('  ask               Quick question/answer');
-  ui.print('  explain           Explain code or infrastructure');
-  ui.print('  fix               Fix errors with AI assistance');
+  ui.print('Incident & Automation:');
+  ui.print('  incident          Incident response session with alert pre-loading');
+  ui.print('  runbook           Load and execute operational runbooks');
+  ui.print('  schedule          Manage periodic DevOps automation tasks');
+  ui.print('  rollout           Safe rolling deployment management');
   ui.newLine();
 
   ui.print('Infrastructure Generation:');
-  ui.print('  generate terraform   Generate Terraform from AWS infrastructure');
-  ui.print('  generate k8s         Generate Kubernetes manifests');
+  ui.print('  generate terraform   Generate Terraform from live AWS infrastructure');
+  ui.print('  generate k8s         Generate Kubernetes manifests for your app');
   ui.print('  generate helm        Generate Helm values files');
   ui.newLine();
 
-  ui.print('Infrastructure Operations:');
-  ui.print('  plan              Preview infrastructure changes');
-  ui.print('  apply             Apply infrastructure changes');
-  ui.print('  tf <cmd>          Terraform operations');
-  ui.print('  k8s <cmd>         Kubernetes operations');
-  ui.print('  helm <cmd>        Helm operations');
+  ui.print('Cloud Auth & Profiles:');
+  ui.print('  auth-refresh      Refresh AWS SSO, GCP, Azure credentials');
+  ui.print('  profile           Manage per-project profiles (AWS, kubectl, TF, GCP)');
+  ui.print('  login             Set up LLM provider authentication');
+  ui.print('  logout            Clear stored credentials');
   ui.newLine();
 
-  ui.print('Setup & Configuration:');
-  ui.print('  init              Initialize Nimbus workspace');
-  ui.print('  login             Set up authentication');
-  ui.print('  logout            Clear credentials');
-  ui.print('  config            Manage configuration');
+  ui.print('AI Agent:');
+  ui.print('  chat              Interactive DevOps agent TUI (same as nimbus)');
+  ui.print('  run               Run agent non-interactively with a prompt');
   ui.newLine();
 
-  ui.print('Utilities:');
+  ui.print('Setup & Config:');
+  ui.print('  init              Initialize Nimbus workspace (generates NIMBUS.md)');
+  ui.print('  config            Manage global configuration');
+  ui.print('  doctor            Run diagnostic checks on your installation');
   ui.print('  history           View command history');
-  ui.print('  doctor            Run diagnostic checks');
+  ui.print('  export            Export session to markdown/HTML/JSON');
   ui.print('  version           Show version info');
-  ui.print('  help              Show this help message');
-  ui.newLine();
-
-  ui.print('Git & GitHub:');
-  ui.print('  git <cmd>         Git operations');
-  ui.print('  gh <cmd>          GitHub operations');
+  ui.print('  audit             View audit logs');
   ui.newLine();
 
-  ui.print('Enterprise:');
-  ui.print('  team <cmd>        Team management');
-  ui.print('  billing <cmd>     Billing management');
-  ui.print('  usage             Usage dashboard');
-  ui.print('  audit             Audit logs');
+  ui.print('Slash Commands (in TUI):');
+  ui.print('  /plan             Run infrastructure plan');
+  ui.print('  /apply            Apply infrastructure changes (deploy mode)');
+  ui.print('  /k8s-ctx          Switch Kubernetes context');
+  ui.print('  /tf-ws            Switch Terraform workspace');
+  ui.print('  /mode             Switch agent mode (plan/build/deploy)');
+  ui.print('  /model            Switch LLM model');
+  ui.print('  /cost             Show session cost');
+  ui.print('  /diff             Show file diff modal');
+  ui.print('  /tree             Toggle file tree sidebar');
+  ui.print('  /terminal         Toggle terminal output pane');
+  ui.print('  ?                 Open keyboard shortcuts help');
   ui.newLine();
 
   ui.print('Get detailed help for a command:');

package/src/commands/history.ts

@@ -55,7 +55,7 @@ export async function historyCommand(options: HistoryOptions = {}): Promise<void
 
   ui.header('Command History');
 
-  // Build query options
+  // Build query options — support tool=<name> and last=<N> filter shorthands (L1)
   const queryOptions: HistoryQueryOptions = {
     limit: options.limit || 20,
     command: options.filter,
@@ -64,6 +64,13 @@ export async function historyCommand(options: HistoryOptions = {}): Promise<void
     status: options.status,
   };
 
+  if (options.filter?.startsWith('tool=')) {
+    queryOptions.command = options.filter.slice(5);
+  } else if (options.filter?.startsWith('last=')) {
+    queryOptions.limit = parseInt(options.filter.slice(5), 10) || queryOptions.limit;
+    queryOptions.command = undefined; // clear the default filter pass-through
+  }
+
   const entries = await historyManager.getEntries(queryOptions);
 
   if (entries.length === 0) {

package/src/commands/incident.ts

@@ -0,0 +1,166 @@
+/**
+ * Incident Command (G14)
+ *
+ * Pre-loads incident context (PagerDuty/Opsgenie alert, recent deployments,
+ * pod logs) and launches a focused TUI agent session.
+ *
+ * Usage:
+ *   nimbus incident <pagerduty-url-or-id> [--notes "observed behavior"]
+ *   nimbus incident "high CPU on api-service pod"
+ */
+
+import { execSync } from 'node:child_process';
+
+export interface IncidentOptions {
+  notes?: string;
+  autoApprove?: boolean;
+}
+
+type AlertSource = 'pagerduty' | 'opsgenie' | 'plain';
+
+interface ParsedIncident {
+  source: AlertSource;
+  id: string;
+  rawInput: string;
+}
+
+/**
+ * Detect incident source from URL or plain text.
+ */
+function parseIncidentInput(input: string): ParsedIncident {
+  if (/pagerduty\.com/i.test(input)) {
+    const match = input.match(/incidents?\/(P[A-Z0-9]+)/i);
+    return { source: 'pagerduty', id: match?.[1] ?? input, rawInput: input };
+  }
+  if (/opsgenie\.com/i.test(input) || /app\.opsgenie\.com/i.test(input)) {
+    const match = input.match(/alert\/([a-f0-9-]{36})/i);
+    return { source: 'opsgenie', id: match?.[1] ?? input, rawInput: input };
+  }
+  // Plain text description — use as-is
+  return { source: 'plain', id: input, rawInput: input };
+}
+
+/**
+ * Attempt to fetch PagerDuty incident details via API (if PD_API_TOKEN is set).
+ */
+async function fetchPagerDutyDetails(incidentId: string): Promise<string | null> {
+  const token = process.env.PD_API_TOKEN;
+  if (!token) return null;
+  try {
+    const curlCmd = `curl -sf -H "Authorization: Token token=${token}" -H "Accept: application/vnd.pagerduty+json;version=2" "https://api.pagerduty.com/incidents/${incidentId}"`;
+    const output = execSync(curlCmd, { encoding: 'utf-8', timeout: 10_000 });
+    const data = JSON.parse(output) as { incident?: { title?: string; service?: { summary?: string }; urgency?: string; status?: string; created_at?: string } };
+    if (data.incident) {
+      const inc = data.incident;
+      return [
+        `Title: ${inc.title ?? 'N/A'}`,
+        `Service: ${inc.service?.summary ?? 'N/A'}`,
+        `Urgency: ${inc.urgency ?? 'N/A'}`,
+        `Status: ${inc.status ?? 'N/A'}`,
+        `Created: ${inc.created_at ?? 'N/A'}`,
+      ].join('\n');
+    }
+  } catch {
+    // Non-critical — API fetch failure should not block the incident session
+  }
+  return null;
+}
+
+/**
+ * Try to detect the service name from the incident description.
+ */
+function detectServiceName(incident: ParsedIncident): string | null {
+  // Common patterns: "api-service", "payment-worker", "nginx deployment"
+  const match = incident.rawInput.match(/\b([\w-]+(?:service|worker|api|pod|deploy(?:ment)?|ingress|controller)[\w-]*)\b/i);
+  return match?.[1] ?? null;
+}
+
+/**
+ * Get last 3 Helm releases for a service (best-effort).
+ */
+function getRecentHelmHistory(serviceName: string): string {
+  try {
+    const out = execSync(`helm history ${serviceName} --max 3 --output json 2>/dev/null`, {
+      encoding: 'utf-8', timeout: 10_000,
+    });
+    const history = JSON.parse(out) as Array<{ revision: number; updated: string; status: string; chart: string; description: string }>;
+    if (history.length === 0) return '';
+    const lines = history.map(h => `  Rev ${h.revision}: ${h.chart} [${h.status}] ${h.updated} — ${h.description}`);
+    return `\nRecent Helm releases for ${serviceName}:\n${lines.join('\n')}`;
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Get recent pod logs for a service (best-effort).
+ */
+function getRecentPodLogs(serviceName: string): string {
+  try {
+    const out = execSync(
+      `kubectl logs -l app=${serviceName} --tail=50 --since=30m --all-containers 2>/dev/null | head -c 4096`,
+      { encoding: 'utf-8', timeout: 15_000 }
+    );
+    if (!out.trim()) return '';
+    return `\nRecent pod logs (last 30m, ${serviceName}):\n${out.trim()}`;
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Run the incident command — builds incident context and launches the agent.
+ */
+export async function incidentCommand(
+  incidentInput: string,
+  options: IncidentOptions = {}
+): Promise<void> {
+  if (!incidentInput) {
+    console.error('Usage: nimbus incident <pagerduty-url-or-id|description> [--notes "observed behavior"]');
+    process.exit(1);
+  }
+
+  const incident = parseIncidentInput(incidentInput);
+  const contextParts: string[] = ['# Incident Response Session'];
+
+  // PD API details
+  if (incident.source === 'pagerduty') {
+    console.log(`Fetching PagerDuty incident ${incident.id}...`);
+    const pdDetails = await fetchPagerDutyDetails(incident.id);
+    if (pdDetails) {
+      contextParts.push(`\n## PagerDuty Alert (${incident.id})\n${pdDetails}`);
+    } else {
+      contextParts.push(`\n## Alert\nPagerDuty incident: ${incident.id}`);
+      if (!process.env.PD_API_TOKEN) {
+        contextParts.push('(Set PD_API_TOKEN env var to fetch full alert details)');
+      }
+    }
+  } else if (incident.source === 'opsgenie') {
+    contextParts.push(`\n## Alert\nOpsgenie incident: ${incident.id}`);
+  } else {
+    contextParts.push(`\n## Alert\n${incident.rawInput}`);
+  }
+
+  // Notes
+  if (options.notes) {
+    contextParts.push(`\n## Observed Behavior\n${options.notes}`);
+  }
+
+  // Service auto-detection + recent history
+  const serviceName = detectServiceName(incident);
+  if (serviceName) {
+    contextParts.push(`\n## Detected Service: ${serviceName}`);
+    const helmHistory = getRecentHelmHistory(serviceName);
+    if (helmHistory) contextParts.push(helmHistory);
+    const podLogs = getRecentPodLogs(serviceName);
+    if (podLogs) contextParts.push(podLogs);
+  }
+
+  contextParts.push('\n## Your Task\nHelp resolve this incident. Start by diagnosing root cause from the context above, then suggest and (with permission) execute remediation steps.');
+
+  const initialPrompt = contextParts.join('\n');
+
+  // Launch the TUI chat session with the pre-loaded incident prompt
+  const { chatCommand } = await import('./chat');
+  await chatCommand({ initialPrompt, mode: 'deploy' });
+}

package/src/commands/init.ts

@@ -44,6 +44,11 @@ export interface InitOptions {
   fromExisting?: string;
   /** Maximum directory depth for project scanning */
   maxDepth?: number;
+  /**
+   * Merge mode (M2): append ## Local Overrides to existing NIMBUS.md
+   * instead of overwriting it.
+   */
+  merge?: boolean;
 }
 
 const NIMBUS_DIR = '.nimbus';

package/src/commands/login.ts

@@ -132,7 +132,7 @@ async function welcomeStep(_ctx: LoginWizardContext): Promise<StepResult> {
   ui.box({
     title: 'Welcome to Nimbus',
     content: [
-      'AI-Powered Cloud Engineering Agent',
+      'AI-Powered DevOps Engineering Agent',
       '',
       "Let's get you set up with authentication",
       'and LLM provider configuration.',
@@ -628,4 +628,89 @@ async function runNonInteractive(options: LoginOptions): Promise<boolean> {
   return true;
 }
 
+/**
+ * Login to a cloud provider (AWS, GCP, Azure) via their CLI tools.
+ * G8: Guided cloud provider login flow.
+ */
+export async function loginCloudCommand(provider: 'aws' | 'gcp' | 'azure'): Promise<void> {
+  const { execFileSync } = await import('node:child_process');
+  const { existsSync } = await import('node:fs');
+  const { execSync } = await import('node:child_process');
+
+  const checkInPath = (cmd: string): boolean => {
+    try {
+      execSync(`which ${cmd}`, { stdio: ['pipe', 'pipe', 'pipe'] });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  if (provider === 'aws') {
+    if (!checkInPath('aws')) {
+      ui.error('AWS CLI not found in PATH.');
+      ui.print('Install it:');
+      if (process.platform === 'darwin') {
+        ui.print('  brew install awscli');
+      } else {
+        ui.print('  https://aws.amazon.com/cli/');
+      }
+      return;
+    }
+    ui.info('Starting AWS credential configuration...');
+    ui.newLine();
+    try {
+      execFileSync('aws', ['configure'], { stdio: 'inherit' });
+      ui.newLine();
+      ui.success('AWS credentials configured.');
+      ui.print('For SSO login, run: aws sso login --profile <profile>');
+    } catch (e: unknown) {
+      const msg = e instanceof Error ? e.message : String(e);
+      ui.error(`AWS configure failed: ${msg}`);
+    }
+  } else if (provider === 'gcp') {
+    if (!checkInPath('gcloud')) {
+      ui.error('gcloud CLI not found in PATH.');
+      ui.print('Install it:');
+      if (process.platform === 'darwin') {
+        ui.print('  brew install --cask google-cloud-sdk');
+      } else {
+        ui.print('  https://cloud.google.com/sdk/docs/install');
+      }
+      return;
+    }
+    ui.info('Starting GCP application default credentials login...');
+    ui.newLine();
+    try {
+      execFileSync('gcloud', ['auth', 'application-default', 'login'], { stdio: 'inherit' });
+      ui.newLine();
+      ui.success('GCP credentials configured.');
+    } catch (e: unknown) {
+      const msg = e instanceof Error ? e.message : String(e);
+      ui.error(`GCP login failed: ${msg}`);
+    }
+  } else if (provider === 'azure') {
+    if (!checkInPath('az')) {
+      ui.error('Azure CLI not found in PATH.');
+      ui.print('Install it:');
+      if (process.platform === 'darwin') {
+        ui.print('  brew install azure-cli');
+      } else {
+        ui.print('  https://learn.microsoft.com/en-us/cli/azure/install-azure-cli');
+      }
+      return;
+    }
+    ui.info('Starting Azure login...');
+    ui.newLine();
+    try {
+      execFileSync('az', ['login'], { stdio: 'inherit' });
+      ui.newLine();
+      ui.success('Azure credentials configured.');
+    } catch (e: unknown) {
+      const msg = e instanceof Error ? e.message : String(e);
+      ui.error(`Azure login failed: ${msg}`);
+    }
+  }
+}
+
 export default loginCommand;