explorbot 0.1.9 → 0.1.11

package/src/api/request-store.ts

@@ -7,6 +7,8 @@ const AUTH_HEADERS = ['authorization', 'cookie', 'x-api-key', 'x-csrf-token'];
 export class RequestStore {
   private capturedRequests: RequestResult[] = [];
   private madeRequests: RequestResult[] = [];
+  private failedRequests: RequestResult[] = [];
+  private onFailedListeners: Array<(r: RequestResult) => void> = [];
   private outputDir: string;
 
   constructor(outputDir: string) {
@@ -18,6 +20,25 @@ export class RequestStore {
     result.save(this.outputDir);
   }
 
+  addFailedRequest(result: RequestResult): void {
+    this.failedRequests.push(result);
+    for (const cb of this.onFailedListeners) {
+      cb(result);
+    }
+  }
+
+  getFailedRequests(): RequestResult[] {
+    return this.failedRequests;
+  }
+
+  onFailedRequest(cb: (r: RequestResult) => void): () => void {
+    this.onFailedListeners.push(cb);
+    return () => {
+      const idx = this.onFailedListeners.indexOf(cb);
+      if (idx !== -1) this.onFailedListeners.splice(idx, 1);
+    };
+  }
+
   addMadeRequest(result: RequestResult): void {
     this.madeRequests.push(result);
     result.save(this.outputDir);
@@ -122,6 +143,7 @@ export class RequestStore {
   clear(): void {
     this.capturedRequests = [];
     this.madeRequests = [];
+    this.failedRequests = [];
   }
 }
 

package/src/api/xhr-capture.ts

@@ -38,15 +38,33 @@ export class XhrCapture {
     if (resourceType !== 'xhr' && resourceType !== 'fetch') return;
 
     const method = request.method();
-    if (!WRITE_METHODS.has(method)) return;
-
     const url = request.url();
     if (!url.startsWith(this.baseOrigin)) return;
 
+    const status = response.status();
+
+    if (status >= 400) {
+      const failedUrl = new URL(url);
+      const failure = new RequestResult({
+        id: generateRequestId(method, failedUrl.pathname, 'fail_'),
+        method,
+        path: failedUrl.pathname,
+        fullUrl: failedUrl.pathname + failedUrl.search,
+        requestHeaders: {},
+        status,
+        statusText: response.statusText(),
+        responseHeaders: {},
+        timing: 0,
+        timestamp: new Date(),
+      });
+      this.store.addFailedRequest(failure);
+    }
+
+    if (!WRITE_METHODS.has(method)) return;
+
     const contentType = response.headers()['content-type'] || '';
     if (!JSON_CONTENT_TYPES.test(contentType)) return;
 
-    const status = response.status();
     if (status === 304) return;
 
     const parsedUrl = new URL(url);

package/src/browser-server.ts

@@ -2,7 +2,9 @@ import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from '
 import path from 'node:path';
 import { chromium, firefox, webkit } from 'playwright-core';
 import { ConfigParser } from './config.js';
-import { log, tag } from './utils/logger.js';
+import { getCliName } from './utils/cli-name.ts';
+import { log } from './utils/logger.js';
+import { type NextStepSection, printNextSteps } from './utils/next-steps.ts';
 
 const ENDPOINT_FILENAME = '.browser-endpoint';
 
@@ -57,8 +59,20 @@ async function launchServer(opts: { browser?: string; show?: boolean }): Promise
   writeEndpoint(wsEndpoint);
 
   log(`Browser server started: ${browserName} (${opts.show ? 'headed' : 'headless'})`);
-  tag('info').log(`WebSocket endpoint: ${wsEndpoint}`);
-  tag('info').log(`Endpoint saved to: ${getEndpointFilePath()}`);
+
+  const cli = getCliName();
+  const sections: NextStepSection[] = [
+    {
+      label: 'Browser server',
+      path: getEndpointFilePath(),
+      commands: [
+        { label: 'Endpoint', command: wsEndpoint },
+        { label: 'Status', command: `${cli} browser status` },
+        { label: 'Stop', command: `${cli} browser stop` },
+      ],
+    },
+  ];
+  printNextSteps(sections);
 
   return server;
 }

package/src/command-handler.ts

@@ -155,7 +155,7 @@ export class CommandHandler implements InputManager {
         this.runningCommands.add(command.name);
         try {
           await command.execute(argsString);
-          command.suggestions.forEach((s) => tag('step').log(s));
+          command.printSuggestions();
         } catch (error: any) {
           if (error?.name === 'AbortError') throw error;
           tag('error').log(`/${command.name} failed: ${error instanceof Error ? error.message : String(error)}`);

package/src/commands/add-rule-command.ts

@@ -3,12 +3,13 @@ import { join } from 'node:path';
 import { render } from 'ink';
 import React from 'react';
 import { tag } from '../utils/logger.js';
-import { BaseCommand } from './base-command.js';
+import { type NextStepSection, printNextSteps, relativeToCwd } from '../utils/next-steps.ts';
+import { BaseCommand, type Suggestion } from './base-command.js';
 
 export class AddRuleCommand extends BaseCommand {
   name = 'add-rule';
   description = 'Create a rule file for an agent';
-  suggestions = ['/add-rule researcher check-tooltips'];
+  suggestions: Suggestion[] = [{ command: 'add-rule researcher check-tooltips', hint: 'example — add a rule for the researcher agent' }];
 
   async execute(args: string): Promise<void> {
     const parts = args.trim().split(/\s+/);
@@ -43,19 +44,22 @@ export class AddRuleCommand extends BaseCommand {
 
     const filePath = join(rulesDir, `${ruleName}.md`);
     if (existsSync(filePath)) {
-      tag('warning').log(`Rule file already exists: ${filePath}`);
+      tag('warning').log(`Rule file already exists: ${relativeToCwd(filePath)}`);
       return null;
     }
 
     const content = opts?.content || `Instructions for ${agentName} agent.`;
     writeFileSync(filePath, `${content.trim()}\n`);
-    tag('success').log(`Rule created: ${filePath}`);
 
-    if (opts?.urlPattern) {
-      tag('info').log(`Add to config: ai.agents.${agentName}.rules: [{ '${opts.urlPattern}': '${ruleName}' }]`);
-    } else {
-      tag('info').log(`Add to config: ai.agents.${agentName}.rules: ['${ruleName}']`);
-    }
+    const configLine = opts?.urlPattern ? `ai.agents.${agentName}.rules: [{ '${opts.urlPattern}': '${ruleName}' }]` : `ai.agents.${agentName}.rules: ['${ruleName}']`;
+    const sections: NextStepSection[] = [
+      {
+        label: 'Rule',
+        path: filePath,
+        commands: [{ label: 'Add to config', command: configLine }],
+      },
+    ];
+    printNextSteps(sections);
 
     return filePath;
   }

package/src/commands/base-command.ts

@@ -1,18 +1,27 @@
+import chalk from 'chalk';
 import { Command } from 'commander';
+import { isInteractive } from '../ai/task-agent.js';
 import type { ExplorBot } from '../explorbot.js';
+import { getCliName } from '../utils/cli-name.js';
+import { tag } from '../utils/logger.js';
 
 export interface CommandOption {
   flags: string;
   description: string;
 }
 
+export interface Suggestion {
+  command?: string;
+  hint: string;
+}
+
 export abstract class BaseCommand {
   abstract name: string;
   abstract description: string;
   aliases: string[] = [];
   options: CommandOption[] = [];
   tuiEnabled = true;
-  suggestions: string[] = [];
+  suggestions: Suggestion[] = [];
 
   protected explorBot: ExplorBot;
 
@@ -26,6 +35,22 @@ export abstract class BaseCommand {
     return this.name === commandName || this.aliases.includes(commandName);
   }
 
+  printSuggestions(): void {
+    if (this.suggestions.length === 0) return;
+    const prefix = isInteractive() ? '/' : `${getCliName()} `;
+    tag('info').log('');
+    tag('info').log(chalk.bold('Suggested:'));
+    for (const { command, hint } of this.suggestions) {
+      tag('info').log('');
+      if (!command) {
+        tag('info').log(chalk.dim(hint));
+        continue;
+      }
+      tag('info').log(chalk.dim(`${hint}:`));
+      tag('info').log(`  ${chalk.yellow(`${prefix}${command}`)}`);
+    }
+  }
+
   protected parseArgs(args: string): { opts: Record<string, string | boolean>; args: string[] } {
     const cmd = new Command();
     cmd.exitOverride();

package/src/commands/clean-command.ts

@@ -2,12 +2,13 @@ import { existsSync, readdirSync, rmSync, statSync, unlinkSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { ConfigParser, outputPath } from '../config.js';
 import { tag } from '../utils/logger.js';
-import { BaseCommand } from './base-command.js';
+import { BaseCommand, type Suggestion } from './base-command.js';
 
 export const CLEAN_TARGETS: Record<string, { description: string; getDir: () => string }> = {
   states: { description: 'page states', getDir: () => outputPath('states') },
   research: { description: 'research cache', getDir: () => outputPath('research') },
   plans: { description: 'test plans', getDir: () => outputPath('plans') },
+  tests: { description: 'generated tests', getDir: () => outputPath('tests') },
   experiences: { description: 'experience files', getDir: () => getExperienceDir() },
   output: { description: 'all output files', getDir: () => outputPath() },
 };
@@ -40,8 +41,8 @@ function cleanDirectoryContents(dirPath: string): number {
 
 export class CleanCommand extends BaseCommand {
   name = 'clean';
-  description = 'Clean files: clean [states|research|plans|experiences|output]';
-  suggestions = Object.keys(CLEAN_TARGETS).map((t) => `/clean ${t}`);
+  description = 'Clean files: clean [states|research|plans|tests|experiences|output]';
+  suggestions: Suggestion[] = Object.entries(CLEAN_TARGETS).map(([name, target]) => ({ command: `clean ${name}`, hint: `clean ${target.description}` }));
 
   async execute(args: string): Promise<void> {
     const target = args.trim().toLowerCase();

package/src/commands/compact-command.ts

@@ -0,0 +1,156 @@
+import { basename } from 'node:path';
+import chalk from 'chalk';
+import type { ExperienceFile } from '../ai/experience-compactor.js';
+import type { ExperienceTracker } from '../experience-tracker.js';
+import { tag } from '../utils/logger.js';
+import { BaseCommand, type Suggestion } from './base-command.js';
+
+const COMPACT_THRESHOLD = 5000;
+
+export class CompactCommand extends BaseCommand {
+  name = 'compact';
+  description = 'Compact stored experience files; optionally filtered by filename or URL substring';
+  options = [
+    { flags: '--dry-run', description: 'Preview without running AI or writing files' },
+    { flags: '--no-merge', description: 'Skip the cross-URL merge step when compacting all' },
+  ];
+  suggestions: Suggestion[] = [];
+
+  async execute(args: string): Promise<void> {
+    const { opts, args: remaining } = this.parseArgs(args);
+    const target = remaining[0];
+    const dryRun = !!opts.dryRun;
+    const merge = opts.merge !== false;
+
+    const tracker = this.explorBot.getExperienceTracker();
+    const files = this.resolveTarget(tracker, target);
+
+    if (files === null) {
+      tag('info').log('No experience files found.');
+      return;
+    }
+    if (files.length === 0) {
+      tag('info').log(`No experience files match target "${target}"`);
+      return;
+    }
+
+    const compactor = this.explorBot.agentExperienceCompactor();
+
+    if (dryRun) {
+      this.printDryRun(compactor, files, target, !target && merge);
+      this.suggestions = this.buildDryRunSuggestions(compactor, files, target);
+      return;
+    }
+
+    if (!target) {
+      const { merged, compacted } = await this.runFullSweep(compactor, merge);
+      tag('success').log(`Done. ${merged} merged, ${compacted} compacted.`);
+      this.suggestions = [{ command: 'experience', hint: 'list stored experiences' }];
+      return;
+    }
+
+    tag('info').log(`Compacting ${files.length} experience file${files.length === 1 ? '' : 's'}…`);
+    const compacted = await compactor.compactFiles(files);
+    if (compacted === 0) {
+      tag('info').log('No experience changes — nothing to strip and all content under size limit.');
+    } else {
+      tag('success').log(`Compacted ${compacted}/${files.length} experience file${files.length === 1 ? '' : 's'}.`);
+    }
+    this.suggestions = [{ command: `experience ${target}`, hint: 'view updated file' }];
+  }
+
+  private buildDryRunSuggestions(compactor: ReturnType<typeof this.explorBot.agentExperienceCompactor>, files: ExperienceFile[], target?: string): Suggestion[] {
+    const wouldTouch = files.filter((f) => {
+      const stripped = compactor.stripNonUsefulEntries(f.content);
+      return stripped !== f.content || stripped.length >= COMPACT_THRESHOLD || compactor.isRecent(f);
+    });
+    if (wouldTouch.length === 0) return [];
+    const argsPart = target ? ` ${target}` : '';
+    const count = wouldTouch.length;
+    return [{ command: `compact${argsPart}`, hint: `run compaction for real (${count} file${count === 1 ? '' : 's'} will be touched)` }];
+  }
+
+  private async runFullSweep(compactor: ReturnType<typeof this.explorBot.agentExperienceCompactor>, merge: boolean): Promise<{ merged: number; compacted: number }> {
+    if (!merge) {
+      tag('info').log('Compacting all experience files (merge skipped)…');
+      const compacted = await compactor.compactFiles(this.explorBot.getExperienceTracker().getAllExperience());
+      return { merged: 0, compacted };
+    }
+
+    tag('info').log('Merging experience files with similar URLs, then compacting all…');
+    return compactor.compactAllExperiences();
+  }
+
+  private resolveTarget(tracker: ExperienceTracker, target?: string): ExperienceFile[] | null {
+    const all = tracker.getAllExperience();
+    if (all.length === 0) return null;
+    if (!target) return all;
+
+    if (target.endsWith('.md')) {
+      const bare = target.slice(0, -3);
+      const byFilename = all.find((f) => basename(f.filePath, '.md') === bare);
+      return byFilename ? [byFilename] : [];
+    }
+
+    const filter = target.toLowerCase();
+    return all.filter((f) => (f.data.url || '').toLowerCase().includes(filter));
+  }
+
+  private printDryRun(compactor: ReturnType<typeof this.explorBot.agentExperienceCompactor>, files: ExperienceFile[], target: string | undefined, willMerge: boolean): void {
+    const lines: string[] = [];
+    const title = target ? `Dry run — target: "${target}"` : 'Dry run — full sweep';
+    lines.push(chalk.bold.underline.cyan(title));
+
+    if (willMerge) {
+      lines.push(chalk.dim('Merge step would run across all files before compaction.'));
+    }
+
+    let wouldStrip = 0;
+    let wouldAiReview = 0;
+    let wouldAiCompact = 0;
+    let totalChars = 0;
+
+    for (const file of files) {
+      const chars = file.content.length;
+      totalChars += chars;
+
+      const stripped = compactor.stripNonUsefulEntries(file.content);
+      const strippedChars = stripped.length;
+      const charsRemoved = chars - strippedChars;
+      const willStrip = stripped !== file.content;
+      const willReview = compactor.isRecent(file);
+      const willAi = strippedChars >= COMPACT_THRESHOLD;
+
+      if (willStrip) wouldStrip++;
+      if (willReview) wouldAiReview++;
+      if (willAi) wouldAiCompact++;
+
+      const name = basename(file.filePath);
+      const url = file.data.url || chalk.dim('(no url)');
+
+      const markers: string[] = [];
+      if (willStrip) {
+        const label = charsRemoved > 0 ? `✂ strip -${charsRemoved} chars` : '✂ strip (rewrite)';
+        markers.push(chalk.yellow(label));
+      }
+      if (willReview) markers.push(chalk.magenta('✓ ai-review'));
+      if (willAi) markers.push(chalk.yellow('✎ ai-compact'));
+      if (markers.length === 0) markers.push(chalk.dim('· skip'));
+
+      lines.push('');
+      lines.push(chalk.bold.green(name));
+      lines.push(`    ${chalk.cyan(url)}`);
+      lines.push(`    ${chalk.dim('size:')} ${chars} chars  ${markers.join('  ')}`);
+    }
+
+    lines.push('');
+    lines.push(chalk.bold('Summary'));
+    lines.push(`  ${chalk.dim('Files matched:')}      ${chalk.bold(String(files.length))}`);
+    lines.push(`  ${chalk.dim('Would strip:')}        ${chalk.bold(String(wouldStrip))} ${chalk.dim('(remove legacy / FAILED / Visual click, rename to FLOW/ACTION)')}`);
+    lines.push(`  ${chalk.dim('Would ai-review:')}    ${chalk.bold(String(wouldAiReview))} ${chalk.dim('(recent files ≤30d — quality/reusability check)')}`);
+    lines.push(`  ${chalk.dim('Would ai-compact:')}   ${chalk.bold(String(wouldAiCompact))} ${chalk.dim(`(over ${COMPACT_THRESHOLD} chars after strip)`)}`);
+    lines.push(`  ${chalk.dim('Total chars:')}        ${chalk.bold(String(totalChars))}`);
+
+    tag('info').log(lines.join('\n'));
+  }
+}

package/src/commands/context-command.ts

@@ -4,12 +4,18 @@ import { outputPath } from '../config.js';
 import { type ContextData, type ContextMode, formatContextSummary } from '../utils/context-formatter.js';
 import { tag } from '../utils/logger.js';
 import { extractValidContainers } from '../utils/research-parser.js';
-import { BaseCommand } from './base-command.js';
+import { BaseCommand, type Suggestion } from './base-command.js';
 
 export class ContextCommand extends BaseCommand {
   name = 'context';
   description = 'Show page context summary (URL, headings, experience, knowledge, ARIA, HTML, research)';
-  suggestions = ['context:aria', 'context:html', 'context:knowledge', 'context:experience', 'context:data'];
+  suggestions: Suggestion[] = [
+    { command: 'context:aria', hint: 'show page ARIA snapshot' },
+    { command: 'context:html', hint: 'show page HTML' },
+    { command: 'context:knowledge', hint: 'show relevant knowledge' },
+    { command: 'context:experience', hint: 'show relevant experience' },
+    { command: 'context:data', hint: 'show captured page data' },
+  ];
   options = [
     { flags: '--visual', description: 'Include annotated screenshot' },
     { flags: '--screenshot', description: 'Include annotated screenshot' },

package/src/commands/drill-command.ts

@@ -1,9 +1,12 @@
-import { BaseCommand } from './base-command.js';
+import { BaseCommand, type Suggestion } from './base-command.js';
 
 export class DrillCommand extends BaseCommand {
   name = 'drill';
   description = 'Drill all components on current page to learn interactions';
-  suggestions = ['/research - to see UI map first', '/navigate <page> - to go to another page'];
+  suggestions: Suggestion[] = [
+    { command: 'research', hint: 'see UI map first' },
+    { command: 'navigate <page>', hint: 'go to another page' },
+  ];
 
   async execute(args: string): Promise<void> {
     const knowledgePath = this.parseKnowledgeArg(args);

package/src/commands/experience-command.ts

@@ -0,0 +1,125 @@
+import chalk from 'chalk';
+import type { ExperienceTocEntry, ExperienceTracker } from '../experience-tracker.js';
+import { tag } from '../utils/logger.js';
+import { BaseCommand, type Suggestion } from './base-command.js';
+
+export class ExperienceCommand extends BaseCommand {
+  name = 'experience';
+  description = 'List stored experiences; filter by filename or URL substring; expand a section by ref (e.g. LW1)';
+  options = [
+    { flags: '--recent', description: 'Only files modified within the last 30 days' },
+    { flags: '--old', description: 'Only files modified more than 30 days ago' },
+  ];
+  suggestions: Suggestion[] = [];
+
+  async execute(args: string): Promise<void> {
+    const { opts, args: remaining } = this.parseArgs(args);
+    if (opts.recent && opts.old) {
+      tag('info').log('Flags --recent and --old are mutually exclusive.');
+      return;
+    }
+    const recency = opts.recent ? 'recent' : opts.old ? 'old' : undefined;
+
+    const tracker = this.explorBot.getExperienceTracker();
+    const [first, second] = remaining;
+
+    const combinedRef = first?.match(/^([A-Z]+)[.\-]?(\d+)$/i);
+    if (combinedRef) {
+      this.expand(tracker, combinedRef[1].toUpperCase(), Number(combinedRef[2]));
+      return;
+    }
+
+    if (first && /^[A-Z]+$/i.test(first) && second && /^\d+$/.test(second)) {
+      this.expand(tracker, first.toUpperCase(), Number(second));
+      return;
+    }
+
+    const secondRef = second?.match(/^([A-Z]+)[.\-]?(\d+)$/i);
+    if (first && secondRef) {
+      this.expand(tracker, secondRef[1].toUpperCase(), Number(secondRef[2]), first);
+      return;
+    }
+
+    if (first && second && /^\d+$/.test(second)) {
+      const toc = tracker.listAllExperienceToc(first, { recency });
+      if (toc.length === 0) {
+        tag('info').log(`No experience found matching: ${first}`);
+        return;
+      }
+      this.expand(tracker, toc[0].fileTag, Number(second), first);
+      return;
+    }
+
+    const toc = tracker.listAllExperienceToc(first, { recency });
+    if (toc.length === 0) {
+      const scope = recency === 'recent' ? ' (recent only)' : recency === 'old' ? ' (old only)' : '';
+      tag('info').log(first ? `No experience found matching: ${first}${scope}` : `No experience files found${scope}. Experience is recorded automatically during test sessions.`);
+      return;
+    }
+
+    tag('info').log(this.formatToc(toc, first, recency));
+
+    const hints: Suggestion[] = [];
+    const exampleRef = `${toc[0].fileTag}1`;
+    hints.push({ command: `experience ${exampleRef}`, hint: 'read a section' });
+
+    const overloaded = toc.filter((entry) => entry.sections.length >= 10);
+    for (const entry of overloaded) {
+      hints.push({ command: `compact ${entry.fileHash}.md`, hint: `compact this file (${entry.sections.length} sections)` });
+    }
+
+    this.suggestions = hints;
+  }
+
+  private expand(tracker: ExperienceTracker, fileTag: string, sectionIndex: number, urlFilter?: string): void {
+    const section = tracker.getExperienceSectionByTag(fileTag, sectionIndex, urlFilter);
+    if (!section) {
+      tag('info').log(`No section ${fileTag}${sectionIndex} found${urlFilter ? ` for URL matching: ${urlFilter}` : ''}`);
+      return;
+    }
+
+    tag('info').log(`${chalk.dim('File:')} ${chalk.bold.green(`${section.fileHash}.md`)}`);
+    tag('info').log(`${chalk.dim('URL:')}  ${chalk.bold.cyan(section.url)}`);
+    tag('info').log(`${chalk.green(`${fileTag}${sectionIndex}`)} ${chalk.bold(section.title)}`);
+    tag('multiline').log(this.stripLeadingHeading(section.content.trim()));
+  }
+
+  private formatToc(toc: ExperienceTocEntry[], urlFilter?: string, recency?: 'recent' | 'old'): string {
+    const totalSections = toc.reduce((sum, entry) => sum + entry.sections.length, 0);
+    const lines: string[] = [];
+
+    const scope = recency === 'recent' ? ' (recent, ≤30d)' : recency === 'old' ? ' (old, >30d)' : '';
+    const title = urlFilter ? `Experience matching "${urlFilter}"${scope}` : `Stored experience${scope}`;
+    lines.push(chalk.bold.underline.cyan(title));
+
+    for (const entry of toc) {
+      lines.push('');
+      lines.push(chalk.bold.green(`${entry.fileHash}.md`));
+      lines.push(`    ${chalk.cyan(entry.url)}`);
+      for (let i = 0; i < entry.sections.length; i++) {
+        const section = entry.sections[i];
+        const isLast = i === entry.sections.length - 1;
+        const branch = isLast ? '└─' : '├─';
+        const ref = chalk.yellow(`${entry.fileTag}${section.index}`);
+        lines.push(`    ${chalk.dim(branch)} ${ref} ${chalk.dim(':')} ${section.title}`);
+      }
+    }
+
+    const urls = new Set(toc.map((e) => e.url)).size;
+    lines.push('');
+    lines.push(chalk.bold('Summary'));
+    lines.push(`  ${chalk.dim('URLs:')}     ${chalk.bold(String(urls))}`);
+    lines.push(`  ${chalk.dim('Files:')}    ${chalk.bold(String(toc.length))}`);
+    lines.push(`  ${chalk.dim('Entries:')}  ${chalk.bold(String(totalSections))}`);
+
+    return lines.join('\n');
+  }
+
+  private stripLeadingHeading(body: string): string {
+    const lines = body.split('\n');
+    if (lines[0]?.match(/^#{1,6}\s/)) {
+      return lines.slice(1).join('\n').trimStart();
+    }
+    return body;
+  }
+}