@build-astron-co/nimbus 0.2.0 → 0.4.0

package/src/commands/status.ts

@@ -0,0 +1,252 @@
+/**
+ * nimbus status — Infrastructure Status Dashboard
+ *
+ * Runs concurrent checks against common DevOps CLIs and shows a dashboard
+ * of the current cloud/infra context.
+ *
+ * G18: New command added to the gap fix plan.
+ *
+ * Usage:
+ *   nimbus status
+ *   nimbus status --json
+ */
+
+import { ui } from '../wizard';
+
+/** Options for the status command. */
+export interface StatusOptions {
+  /** Output as JSON instead of table. */
+  json?: boolean;
+  /** L3: Show full snapshot including LLM config and active profile. */
+  verbose?: boolean;
+}
+
+interface StatusInfo {
+  k8sContext?: string;
+  tfWorkspace?: string;
+  awsAccount?: string;
+  awsRegion?: string;
+  gcpProject?: string;
+  lastDriftScan?: string;
+  // C2 enhancements
+  sessionCount?: number | string;
+  model?: string;
+  provider?: string;
+  nimbusMdSize?: number;
+  nimbusMdFound?: boolean;
+  dbSizeMB?: number;
+  // M1: Helm and pod health
+  helmFailedCount?: number;
+  helmTotalCount?: number;
+  unhealthyPodCount?: number;
+  errors: string[];
+}
+
+/**
+ * Run the nimbus status command.
+ * Checks k8s context, tf workspace, AWS identity, and GCP project concurrently.
+ */
+export async function statusCommand(options: StatusOptions = {}): Promise<void> {
+  const { execFileSync } = await import('node:child_process');
+  const { existsSync, statSync, readFileSync } = await import('node:fs');
+  const { join } = await import('node:path');
+  const { homedir } = await import('node:os');
+
+  const info: StatusInfo = { errors: [] };
+
+  const run = (cmd: string, args: string[]): string | undefined => {
+    try {
+      return execFileSync(cmd, args, {
+        encoding: 'utf-8',
+        timeout: 8000,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+    } catch {
+      return undefined;
+    }
+  };
+
+  // Run all checks concurrently (M1: add helm + pod health)
+  const [k8sCtx, tfWs, awsIdentityRaw, gcpProject, helmListRaw, podUnhealthyRaw] = await Promise.allSettled([
+    Promise.resolve(run('kubectl', ['config', 'current-context'])),
+    Promise.resolve(run('terraform', ['workspace', 'show'])),
+    Promise.resolve(run('aws', ['sts', 'get-caller-identity', '--output', 'json'])),
+    Promise.resolve(run('gcloud', ['config', 'get-value', 'project'])),
+    Promise.resolve(run('helm', ['list', '-A', '--output', 'json'])),
+    Promise.resolve(run('kubectl', ['get', 'pods', '-A', '--field-selector=status.phase!=Running', '--no-headers'])),
+  ]);
+
+  if (k8sCtx.status === 'fulfilled' && k8sCtx.value) {
+    info.k8sContext = k8sCtx.value;
+  }
+  if (tfWs.status === 'fulfilled' && tfWs.value) {
+    info.tfWorkspace = tfWs.value;
+  }
+  if (awsIdentityRaw.status === 'fulfilled' && awsIdentityRaw.value) {
+    try {
+      const identity = JSON.parse(awsIdentityRaw.value);
+      info.awsAccount = identity.Account;
+      // Try to get region separately
+      const region = run('aws', ['configure', 'get', 'region']);
+      if (region) info.awsRegion = region;
+    } catch {
+      // Could not parse AWS identity
+    }
+  }
+  if (gcpProject.status === 'fulfilled' && gcpProject.value && gcpProject.value !== '(unset)') {
+    info.gcpProject = gcpProject.value;
+  }
+
+  // M1: Parse helm release health
+  if (helmListRaw.status === 'fulfilled' && helmListRaw.value) {
+    try {
+      const releases = JSON.parse(helmListRaw.value) as Array<{ status: string }>;
+      info.helmTotalCount = releases.length;
+      info.helmFailedCount = releases.filter(r => r.status !== 'deployed').length;
+    } catch { /* non-critical */ }
+  }
+
+  // M1: Parse unhealthy pod count
+  if (podUnhealthyRaw.status === 'fulfilled' && podUnhealthyRaw.value) {
+    const lines = podUnhealthyRaw.value.trim().split('\n').filter(Boolean);
+    info.unhealthyPodCount = lines.length;
+  }
+
+  // Check last drift scan from SQLite + session count
+  try {
+    const { getDb } = await import('../state/db');
+    const db = getDb();
+    const row = db.prepare(`
+      SELECT created_at FROM sessions
+      ORDER BY created_at DESC LIMIT 1
+    `).get() as { created_at?: string } | undefined;
+    if (row?.created_at) {
+      info.lastDriftScan = row.created_at;
+    }
+
+    // C2: Count sessions
+    const countRow = db.prepare('SELECT COUNT(*) as cnt FROM sessions').get() as { cnt?: number } | undefined;
+    info.sessionCount = countRow?.cnt ?? 0;
+  } catch {
+    // DB not available
+    info.sessionCount = 'N/A';
+  }
+
+  // C2: Read model and provider from ~/.nimbus/config.json
+  const configJsonPath = join(homedir(), '.nimbus', 'config.json');
+  try {
+    if (existsSync(configJsonPath)) {
+      const configRaw = readFileSync(configJsonPath, 'utf-8');
+      const config = JSON.parse(configRaw) as Record<string, unknown>;
+      info.model = typeof config.model === 'string' ? config.model : 'claude-sonnet-4-6';
+      info.provider = typeof config.provider === 'string' ? config.provider : 'anthropic';
+    } else {
+      info.model = 'claude-sonnet-4-6';
+      info.provider = 'anthropic';
+    }
+  } catch {
+    info.model = 'claude-sonnet-4-6';
+    info.provider = 'anthropic';
+  }
+
+  // C2: Check NIMBUS.md in cwd
+  const nimbusMdPaths = [
+    join(process.cwd(), 'NIMBUS.md'),
+    join(process.cwd(), '.nimbus', 'NIMBUS.md'),
+  ];
+  for (const p of nimbusMdPaths) {
+    try {
+      if (existsSync(p)) {
+        const stat = statSync(p);
+        info.nimbusMdFound = true;
+        info.nimbusMdSize = stat.size;
+        break;
+      }
+    } catch { /* skip */ }
+  }
+
+  // C2: Get DB file size
+  const dbPath = join(homedir(), '.nimbus', 'nimbus.db');
+  try {
+    if (existsSync(dbPath)) {
+      const stat = statSync(dbPath);
+      info.dbSizeMB = Math.round((stat.size / (1024 * 1024)) * 10) / 10;
+    }
+  } catch { /* skip */ }
+
+  if (options.json) {
+    console.log(JSON.stringify(info, null, 2));
+    return;
+  }
+
+  // Pretty-print dashboard
+  // Build session line
+  const sessionLine = typeof info.sessionCount === 'number'
+    ? `${info.sessionCount} sessions`
+    : 'N/A';
+
+  // Build NIMBUS.md line
+  const nimbusMdLine = info.nimbusMdFound && info.nimbusMdSize !== undefined
+    ? `  loaded (${info.nimbusMdSize >= 1024
+        ? `${(info.nimbusMdSize / 1024).toFixed(1)}KB`
+        : `${info.nimbusMdSize}B`})`
+    : '  not found';
+
+  // Build DB size line
+  const dbLine = info.dbSizeMB !== undefined
+    ? `~/.nimbus/nimbus.db (${info.dbSizeMB}MB)`
+    : '~/.nimbus/nimbus.db (not found)';
+
+  ui.newLine();
+  ui.box({
+    title: 'Nimbus Infrastructure Status',
+    content: [
+      '',
+      `  Session:   ${sessionLine}`,
+      `  Model:     ${info.model ?? 'claude-sonnet-4-6'}`,
+      `  Provider:  ${info.provider ?? 'anthropic'} \u2713`,
+      '',
+      '  Infrastructure:',
+      info.k8sContext
+        ? `    Kubernetes: context=${info.k8sContext}`
+        : '    Kubernetes:   (not configured)',
+      info.tfWorkspace
+        ? `    Terraform:  workspace=${info.tfWorkspace}  \u2713 initialized`
+        : '    Terraform:    (not in a terraform directory)',
+      info.awsAccount
+        ? `    AWS:        account=${info.awsAccount}${info.awsRegion ? `  region=${info.awsRegion}` : ''}`
+        : '    AWS:          (not configured)',
+      info.gcpProject
+        ? `    GCP:        project=${info.gcpProject}`
+        : '',
+      // M1: Helm release health
+      ...(info.helmTotalCount !== undefined
+        ? [
+            info.helmFailedCount && info.helmFailedCount > 0
+              ? `  [!] ${info.helmFailedCount} Helm release(s) in failed state (${info.helmTotalCount} total)`
+              : `    Helm:       ${info.helmTotalCount} release(s) deployed`,
+          ]
+        : []),
+      // M1: Pod health warnings
+      ...(info.unhealthyPodCount !== undefined && info.unhealthyPodCount > 0
+        ? [`  [!] ${info.unhealthyPodCount} pod(s) not running`]
+        : []),
+      '',
+      `  NIMBUS.md:${nimbusMdLine}`,
+      `  DB:        ${dbLine}`,
+      '',
+      info.lastDriftScan
+        ? `  Last session: ${new Date(info.lastDriftScan).toLocaleString()}`
+        : '  Last session: (none)',
+      '',
+      '  Quick actions: nimbus plan | nimbus apply | nimbus logs',
+      '',
+    ].filter(line => line !== undefined) as string[],
+    style: 'rounded',
+    borderColor: 'cyan',
+    padding: 0,
+  });
+  ui.newLine();
+}
+
+export default statusCommand;

package/src/commands/team-context.ts

@@ -0,0 +1,220 @@
+/**
+ * Team NIMBUS.md Distribution (L6)
+ *
+ * Share project context files with team members.
+ *
+ *   nimbus team-context push     — share current NIMBUS.md via sharing service
+ *   nimbus team-context pull <url> — download NIMBUS.md, show diff, prompt before overwrite
+ *
+ * Also supports NIMBUS_INSTRUCTIONS_URL env var: on startup, fetch that URL
+ * and use as NIMBUS.md if local file not present.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ui } from '../wizard/ui';
+
+const NIMBUS_MD_PATHS = [
+  path.join(process.cwd(), 'NIMBUS.md'),
+  path.join(process.cwd(), '.nimbus', 'NIMBUS.md'),
+];
+
+function findLocalNimbusMd(): string | null {
+  for (const p of NIMBUS_MD_PATHS) {
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+
+function computeDiff(oldContent: string, newContent: string): string {
+  const oldLines = oldContent.split('\n');
+  const newLines = newContent.split('\n');
+  const lines: string[] = [];
+
+  const maxLen = Math.max(oldLines.length, newLines.length);
+  for (let i = 0; i < maxLen; i++) {
+    const old = oldLines[i];
+    const newLine = newLines[i];
+    if (old === undefined) {
+      lines.push(`+ ${newLine}`);
+    } else if (newLine === undefined) {
+      lines.push(`- ${old}`);
+    } else if (old !== newLine) {
+      lines.push(`- ${old}`);
+      lines.push(`+ ${newLine}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+/** Path to the team.md file in the current project's .nimbus/ directory */
+const TEAM_MD_PATH = path.join(process.cwd(), '.nimbus', 'team.md');
+
+/** Regex to strip lines containing sensitive info */
+const SENSITIVE_PATTERN = /SENSITIVE:/i;
+
+/** Strip lines containing "SENSITIVE:" from NIMBUS.md before sharing */
+function stripSensitiveLines(content: string): string {
+  return content
+    .split('\n')
+    .filter(line => !SENSITIVE_PATTERN.test(line))
+    .join('\n');
+}
+
+/**
+ * Merge non-duplicate sections from teamContent into localContent.
+ * Sections are identified by Markdown headings (## ...).
+ */
+function mergeSections(localContent: string, teamContent: string): string {
+  // Split into sections by heading
+  const sectionRegex = /(?=^#{1,3} .+$)/m;
+  const localSections = localContent.split(sectionRegex);
+  const teamSections = teamContent.split(sectionRegex);
+
+  const localHeadings = new Set(
+    localSections
+      .map(s => s.match(/^(#{1,3} .+)$/m)?.[1]?.trim())
+      .filter(Boolean)
+  );
+
+  const newSections = teamSections.filter(s => {
+    const heading = s.match(/^(#{1,3} .+)$/m)?.[1]?.trim();
+    return heading && !localHeadings.has(heading);
+  });
+
+  if (newSections.length === 0) return localContent;
+
+  const merged = localContent.trimEnd() + '\n\n' + newSections.join('\n').trimStart();
+  return merged;
+}
+
+export async function teamContextCommand(subcommand: string, args: string[]): Promise<void> {
+  switch (subcommand) {
+    case 'push': {
+      // Git-based push: read NIMBUS.md, strip SENSITIVE lines, write to .nimbus/team.md
+      const localPath = findLocalNimbusMd();
+      if (!localPath) {
+        ui.warning('No NIMBUS.md found in current directory. Run `nimbus init` first.');
+        return;
+      }
+
+      const content = fs.readFileSync(localPath, 'utf-8');
+      const sanitized = stripSensitiveLines(content);
+
+      // Ensure .nimbus/ directory exists
+      const nimbusDir = path.dirname(TEAM_MD_PATH);
+      if (!fs.existsSync(nimbusDir)) {
+        fs.mkdirSync(nimbusDir, { recursive: true });
+      }
+
+      fs.writeFileSync(TEAM_MD_PATH, sanitized, 'utf-8');
+      ui.print(`${ui.color('✓', 'green')} Written sanitized context to ${TEAM_MD_PATH}`);
+      ui.dim(`Removed all lines containing "SENSITIVE:"`);
+      ui.newLine();
+
+      // Stage the file with git
+      try {
+        const { execFileSync } = await import('node:child_process');
+        execFileSync('git', ['add', TEAM_MD_PATH], {
+          encoding: 'utf-8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+          timeout: 10_000,
+        });
+        ui.print(`${ui.color('✓', 'green')} Staged .nimbus/team.md with git`);
+        ui.print('  Next step: git commit -m "chore: update team context" && git push');
+      } catch {
+        ui.dim('(git stage skipped — not a git repo or git not in PATH)');
+        ui.print('  Copy .nimbus/team.md to your repository and commit/push it manually.');
+      }
+
+      ui.newLine();
+      ui.info('Note: Add .nimbus/team.md to version control (do NOT add .nimbus/team.md to .gitignore).');
+      ui.dim('Add NIMBUS.md to .gitignore if it contains sensitive local config.');
+      break;
+    }
+
+    case 'pull': {
+      // Git-based pull: read .nimbus/team.md from cwd, diff, merge
+      if (!fs.existsSync(TEAM_MD_PATH)) {
+        ui.error(`.nimbus/team.md not found in ${process.cwd()}`);
+        ui.dim('Run `git pull` to fetch the latest team context, then re-run this command.');
+        return;
+      }
+
+      const teamContent = fs.readFileSync(TEAM_MD_PATH, 'utf-8');
+      const targetPath = NIMBUS_MD_PATHS[0];
+      const existing = fs.existsSync(targetPath) ? fs.readFileSync(targetPath, 'utf-8') : null;
+
+      if (existing) {
+        const diff = computeDiff(existing, teamContent);
+        if (!diff) {
+          ui.info('NIMBUS.md is already up to date with team.md.');
+          return;
+        }
+
+        ui.header('NIMBUS.md vs .nimbus/team.md diff');
+        for (const line of diff.split('\n')) {
+          if (line.startsWith('+')) {
+            ui.print(ui.color(line, 'green'));
+          } else if (line.startsWith('-')) {
+            ui.print(ui.color(line, 'red'));
+          } else {
+            ui.print(line);
+          }
+        }
+        ui.newLine();
+
+        // Prompt for confirmation
+        const { input: inputPrompt } = await import('../wizard/prompts');
+        const answer = await inputPrompt({
+          message: 'Merge new sections from team.md into NIMBUS.md? [y/N]',
+          defaultValue: 'N',
+        });
+        if (answer.toLowerCase() !== 'y') {
+          ui.info('Aborted — NIMBUS.md not changed.');
+          return;
+        }
+
+        // Merge: append non-duplicate sections
+        const merged = mergeSections(existing, teamContent);
+        fs.writeFileSync(targetPath, merged, 'utf-8');
+        ui.print(`${ui.color('✓', 'green')} Merged team context into ${targetPath}`);
+      } else {
+        // No local NIMBUS.md — use team.md as starting point
+        fs.writeFileSync(targetPath, teamContent, 'utf-8');
+        ui.print(`${ui.color('✓', 'green')} Created ${targetPath} from .nimbus/team.md`);
+      }
+
+      ui.newLine();
+      ui.dim('Note: Add NIMBUS.md to .gitignore to keep local config private.');
+      ui.dim('Add .nimbus/team.md to version control to share project context with team.');
+      break;
+    }
+
+    default:
+      ui.print('Usage: nimbus team-context <push|pull>');
+      ui.print('');
+      ui.print('  push   Strip SENSITIVE: lines from NIMBUS.md, write to .nimbus/team.md, and git add');
+      ui.print('  pull   Read .nimbus/team.md, diff against NIMBUS.md, merge on confirmation');
+  }
+}
+
+/**
+ * Fetch NIMBUS.md from NIMBUS_INSTRUCTIONS_URL env var.
+ * Called on startup when no local NIMBUS.md exists.
+ */
+export async function fetchRemoteNimbusMd(): Promise<string | null> {
+  const url = process.env.NIMBUS_INSTRUCTIONS_URL;
+  if (!url) return null;
+
+  const localPath = findLocalNimbusMd();
+  if (localPath) return null; // local file takes priority
+
+  try {
+    const response = await fetch(url, { signal: AbortSignal.timeout(10_000) });
+    if (!response.ok) return null;
+    return await response.text();
+  } catch {
+    return null;
+  }
+}

package/src/commands/template.ts

@@ -4,11 +4,10 @@
  * CLI commands for managing infrastructure templates
  */
 
-import { RestClient } from '../clients';
+import { getDb } from '../state/db';
+import { randomUUID } from 'crypto';
 import { ui } from '../wizard/ui';
 
-const STATE_SERVICE_URL = process.env.STATE_SERVICE_URL || 'http://localhost:3004';
-
 export interface TemplateCommandOptions {
   type?: string;
   name?: string;
@@ -24,34 +23,35 @@ async function templateListCommand(options: TemplateCommandOptions = {}): Promis
   ui.startSpinner({ message: 'Fetching templates...' });
 
   try {
-    const client = new RestClient(STATE_SERVICE_URL);
-    const params = options.type ? `?type=${encodeURIComponent(options.type)}` : '';
-    const result = await client.get<any>(`/api/state/templates${params}`);
-
-    if (result.success && result.data) {
-      const templates = Array.isArray(result.data) ? result.data : [];
-      ui.stopSpinnerSuccess(`Found ${templates.length} template(s)`);
-
-      if (templates.length > 0) {
-        ui.table({
-          columns: [
-            { key: 'id', header: 'ID' },
-            { key: 'name', header: 'Name' },
-            { key: 'type', header: 'Type' },
-            { key: 'createdAt', header: 'Created' },
-          ],
-          data: templates.map((t: any) => ({
-            id: t.id?.substring(0, 8) || '-',
-            name: t.name || '-',
-            type: t.type || '-',
-            createdAt: t.createdAt ? new Date(t.createdAt).toLocaleDateString() : '-',
-          })),
-        });
-      } else {
-        ui.info('No templates found. Use "nimbus template save" to create one.');
-      }
+    const db = getDb();
+    const templates = db
+      .prepare(
+        'SELECT * FROM templates WHERE (? IS NULL OR type=?) ORDER BY created_at DESC'
+      )
+      .all(options.type ?? null, options.type ?? null) as Array<Record<string, unknown>>;
+
+    ui.stopSpinnerSuccess(`Found ${templates.length} template(s)`);
+
+    if (templates.length > 0) {
+      ui.table({
+        columns: [
+          { key: 'id', header: 'ID' },
+          { key: 'name', header: 'Name' },
+          { key: 'type', header: 'Type' },
+          { key: 'createdAt', header: 'Created' },
+        ],
+        data: templates.map((t) => ({
+          id: typeof t.id === 'string' ? t.id.substring(0, 8) : '-',
+          name: typeof t.name === 'string' ? t.name : '-',
+          type: typeof t.type === 'string' ? t.type : '-',
+          createdAt:
+            typeof t.created_at === 'string'
+              ? new Date(t.created_at).toLocaleDateString()
+              : '-',
+        })),
+      });
     } else {
-      ui.stopSpinnerFail('Failed to fetch templates');
+      ui.info('No templates found. Use "nimbus template save" to create one.');
     }
   } catch (error: any) {
     ui.stopSpinnerFail('Error fetching templates');
@@ -70,22 +70,31 @@ async function templateGetCommand(
   ui.startSpinner({ message: 'Fetching template...' });
 
   try {
-    const client = new RestClient(STATE_SERVICE_URL);
-    const result = await client.get<any>(`/api/state/templates/${encodeURIComponent(id)}`);
+    const db = getDb();
+    const template = db
+      .prepare('SELECT * FROM templates WHERE id LIKE ?')
+      .get(id + '%') as Record<string, unknown> | undefined;
 
-    if (result.success && result.data) {
+    if (template) {
       ui.stopSpinnerSuccess('Template retrieved');
-      const template = result.data;
 
       ui.print(`  ${ui.color('Name:', 'cyan')} ${template.name || '-'}`);
       ui.print(`  ${ui.color('Type:', 'cyan')} ${template.type || '-'}`);
       ui.print(`  ${ui.color('ID:', 'cyan')} ${template.id || '-'}`);
-      ui.print(`  ${ui.color('Created:', 'cyan')} ${template.createdAt || '-'}`);
+      ui.print(`  ${ui.color('Created:', 'cyan')} ${template.created_at || '-'}`);
+
+      let variables: Record<string, unknown> = {};
+      try {
+        variables =
+          typeof template.variables === 'string'
+            ? JSON.parse(template.variables)
+            : {};
+      } catch { /* ignore */ }
 
-      if (template.variables && Object.keys(template.variables).length > 0) {
+      if (Object.keys(variables).length > 0) {
         ui.newLine();
         ui.print(`  ${ui.color('Variables:', 'cyan')}`);
-        for (const [key, val] of Object.entries(template.variables)) {
+        for (const [key, val] of Object.entries(variables)) {
           ui.print(`    ${key}: ${JSON.stringify(val)}`);
         }
       }
@@ -134,22 +143,14 @@ async function templateSaveCommand(options: TemplateCommandOptions = {}): Promis
   ui.startSpinner({ message: 'Saving template...' });
 
   try {
-    const client = new RestClient(STATE_SERVICE_URL);
-    const result = await client.post<any>('/api/state/templates', {
-      name: options.name,
-      type: options.type || 'terraform',
-      content,
-      variables: {},
-    });
-
-    if (result.success) {
-      ui.stopSpinnerSuccess(`Template "${options.name}" saved`);
-      if (result.data?.id) {
-        ui.info(`ID: ${result.data.id}`);
-      }
-    } else {
-      ui.stopSpinnerFail('Failed to save template');
-    }
+    const db = getDb();
+    const id = randomUUID();
+    db.prepare(
+      'INSERT INTO templates (id,name,type,content,variables,created_at,updated_at) VALUES (?,?,?,?,?,datetime("now"),datetime("now"))'
+    ).run(id, options.name, options.type || 'terraform', content, '{}');
+
+    ui.stopSpinnerSuccess(`Template "${options.name}" saved`);
+    ui.info(`ID: ${id}`);
   } catch (error: any) {
     ui.stopSpinnerFail('Error saving template');
     ui.error(error.message);
@@ -164,13 +165,13 @@ async function templateDeleteCommand(id: string): Promise<void> {
   ui.startSpinner({ message: 'Deleting template...' });
 
   try {
-    const client = new RestClient(STATE_SERVICE_URL);
-    const result = await client.delete<any>(`/api/state/templates/${encodeURIComponent(id)}`);
+    const db = getDb();
+    const result = db.prepare('DELETE FROM templates WHERE id=?').run(id);
 
-    if (result.success) {
+    if ((result as any).changes > 0) {
       ui.stopSpinnerSuccess('Template deleted');
     } else {
-      ui.stopSpinnerFail('Failed to delete template');
+      ui.stopSpinnerFail('Template not found');
     }
   } catch (error: any) {
     ui.stopSpinnerFail('Error deleting template');