explorbot 0.1.10 → 0.1.12

package/dist/src/observability.js

@@ -1,125 +1,76 @@
-import { randomBytes } from 'node:crypto';
-import { context, trace } from '@opentelemetry/api';
+import { trace } from '@opentelemetry/api';
 let current = null;
-let depth = 0;
 export const Observability = {
     async run(name, metadata, fn) {
-        const started = Observability.startTrace(name, metadata);
-        try {
-            if (!started) {
-                const parentSpan = current?.span;
-                if (!parentSpan || !current)
-                    return await fn();
-                const tracer = trace.getTracer('ai');
-                const childSpan = tracer.startSpan(name, undefined, trace.setSpan(context.active(), parentSpan));
-                const savedSpan = current.span;
-                const savedName = current.name;
-                current.span = childSpan;
-                current.name = name;
-                return await context.with(trace.setSpan(context.active(), childSpan), async () => {
-                    try {
-                        return await fn();
-                    }
-                    finally {
-                        childSpan.end();
-                        current.span = savedSpan;
-                        current.name = savedName;
-                    }
-                });
-            }
-            const tracer = trace.getTracer('ai');
-            const spanContext = {
-                traceId: current?.traceId || randomBytes(16).toString('hex'),
-                spanId: randomBytes(8).toString('hex'),
-                traceFlags: 1,
-            };
-            const rootContext = trace.setSpanContext(context.active(), spanContext);
-            const initSpan = tracer.startSpan(name, undefined, rootContext);
-            initSpan.setAttribute('langfuse.trace.name', name);
-            initSpan.setAttribute('langfuse.trace.id', current?.traceId || '');
-            if (current?.metadata?.sessionId) {
-                initSpan.setAttribute('langfuse.trace.session_id', String(current.metadata.sessionId));
-            }
-            if (current?.metadata?.userId) {
-                initSpan.setAttribute('langfuse.trace.user_id', String(current.metadata.userId));
-            }
-            if (current?.metadata?.tags && Array.isArray(current.metadata.tags)) {
-                initSpan.setAttribute('langfuse.trace.tags', current.metadata.tags);
-            }
-            if (current?.metadata?.input) {
-                initSpan.setAttribute('langfuse.trace.input', JSON.stringify(current.metadata.input));
-            }
-            initSpan.end();
-            const span = tracer.startSpan(name, undefined, rootContext);
-            current.span = span;
-            return await context.with(trace.setSpan(rootContext, span), async () => {
+        const tracer = trace.getTracer('ai');
+        if (current) {
+            return await tracer.startActiveSpan(name, {}, async (span) => {
+                const saved = current;
+                current = {
+                    metadata: { ...saved.metadata, ...metadata },
+                    name,
+                    span,
+                };
                 try {
                     return await fn();
                 }
                 finally {
                     span.end();
-                    current.span = undefined;
+                    current = saved;
                 }
             });
         }
-        finally {
-            Observability.endTrace(started);
-        }
-    },
-    startTrace(name, metadata) {
-        if (current) {
-            depth += 1;
-            return false;
-        }
-        const langfuseTraceId = metadata.langfuseTraceId || randomBytes(16).toString('hex');
-        current = {
-            metadata: {
-                ...metadata,
-                langfuseTraceId,
-            },
-            traceId: langfuseTraceId,
-            updateParent: true,
-            name,
-        };
-        depth = 1;
-        return true;
-    },
-    endTrace(started) {
-        if (!current) {
-            return;
-        }
-        if (!started) {
-            depth -= 1;
-            return;
-        }
-        depth -= 1;
-        if (depth <= 0) {
-            current = null;
-            depth = 0;
-        }
+        const attributes = buildRootSpanAttributes(name, metadata);
+        return await tracer.startActiveSpan(name, { attributes }, async (span) => {
+            current = { metadata, name, span };
+            try {
+                return await fn();
+            }
+            finally {
+                span.end();
+                current = null;
+            }
+        });
     },
     getTelemetry() {
         if (!current) {
             return undefined;
         }
-        const telemetry = {
+        const metadata = {};
+        if (current.metadata.sessionId)
+            metadata.sessionId = current.metadata.sessionId;
+        if (current.metadata.userId)
+            metadata.userId = current.metadata.userId;
+        if (Array.isArray(current.metadata.tags))
+            metadata.tags = current.metadata.tags;
+        return {
             isEnabled: true,
             functionId: current.name,
-            metadata: {
-                ...current.metadata,
-                langfuseTraceId: current.traceId,
-                langfuseUpdateParent: current.updateParent,
-            },
+            metadata,
         };
-        if (current.updateParent) {
-            current.updateParent = false;
-        }
-        return telemetry;
     },
     isTracing() {
         return Boolean(current);
     },
     getSpan() {
-        return current?.span;
+        return current?.span ?? trace.getActiveSpan();
     },
 };
+function buildRootSpanAttributes(name, metadata) {
+    const attributes = {
+        'langfuse.trace.name': name,
+    };
+    if (metadata.sessionId) {
+        attributes['session.id'] = String(metadata.sessionId);
+    }
+    if (metadata.userId) {
+        attributes['user.id'] = String(metadata.userId);
+    }
+    if (Array.isArray(metadata.tags)) {
+        attributes['langfuse.trace.tags'] = metadata.tags;
+    }
+    if (metadata.input !== undefined) {
+        attributes['langfuse.trace.input'] = JSON.stringify(metadata.input);
+    }
+    return attributes;
+}

package/dist/src/playwright-recorder.js

@@ -0,0 +1,309 @@
+import { readFile } from 'node:fs/promises';
+// @ts-ignore — package ships a .js re-export without typings for this sub-path
+import * as playwrightUtils from 'playwright-core/lib/utils';
+import { createDebug } from "./utils/logger.js";
+const debugLog = createDebug('explorbot:playwright-recorder');
+const RECORDABLE = {
+    Frame: new Set(['click', 'dblclick', 'fill', 'selectOption', 'press', 'type', 'check', 'uncheck', 'hover', 'tap', 'focus', 'setInputFiles', 'scrollIntoViewIfNeeded', 'dragTo', 'goto', 'setContent']),
+    Page: new Set(['goBack', 'goForward', 'reload', 'keyboardPress', 'keyboardType', 'keyboardDown', 'keyboardUp', 'keyboardInsertText', 'mouseClick', 'mouseDblclick', 'mouseMove', 'mouseDown', 'mouseUp', 'mouseWheel']),
+};
+const PLAYWRIGHT_INCOMPATIBLE = "Playwright output is not compatible with this Playwright version (playwright-core/lib/utils does not expose asLocator). Use output.framework: 'codeceptjs' instead, or pin Playwright to a version shipping lib/utils/isomorphic/locatorGenerators.js.";
+function getAsLocator() {
+    const fn = playwrightUtils?.asLocator;
+    if (typeof fn !== 'function')
+        throw new Error(PLAYWRIGHT_INCOMPATIBLE);
+    return fn;
+}
+export class PlaywrightRecorder {
+    context = null;
+    tracing = null;
+    active = false;
+    nextGroupId = 0;
+    verifications = [];
+    recordVerification(steps) {
+        if (!steps?.length)
+            return;
+        const seen = new Set(this.verifications.map((s) => `${s.name}:${JSON.stringify(s.args)}`));
+        for (const step of steps) {
+            const key = `${step.name}:${JSON.stringify(step.args)}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            this.verifications.push(step);
+        }
+    }
+    drainVerifications() {
+        const drained = this.verifications;
+        this.verifications = [];
+        return drained;
+    }
+    async start(browserContext) {
+        if (this.active)
+            return;
+        if (!browserContext?.tracing) {
+            debugLog('start: no tracing on browserContext, recorder inactive');
+            return;
+        }
+        this.context = browserContext;
+        this.tracing = browserContext.tracing;
+        try {
+            await this.tracing.start({});
+            this.active = true;
+            debugLog('tracing started');
+        }
+        catch (err) {
+            debugLog('tracing.start failed:', err);
+        }
+    }
+    async beginAction(title) {
+        if (!this.active)
+            return null;
+        const safe = title.replace(/\s+/g, ' ').slice(0, 80);
+        const groupId = `explorbot#${++this.nextGroupId}:${safe}`;
+        try {
+            await this.tracing.group(groupId);
+            return groupId;
+        }
+        catch (err) {
+            debugLog('tracing.group failed:', err);
+            return null;
+        }
+    }
+    async endAction() {
+        if (!this.active)
+            return;
+        try {
+            await this.tracing.groupEnd();
+        }
+        catch (err) {
+            debugLog('tracing.groupEnd failed:', err);
+        }
+    }
+    async exportChunk() {
+        if (!this.active)
+            return new Map();
+        const channel = this.tracing._channel;
+        if (!channel?.tracingStopChunk || !channel.tracingStartChunk) {
+            debugLog('exportChunk: no _channel access, returning empty');
+            return new Map();
+        }
+        let entries = [];
+        try {
+            const result = await channel.tracingStopChunk({ mode: 'entries' });
+            entries = result?.entries || [];
+        }
+        catch (err) {
+            debugLog('tracingStopChunk failed:', err);
+            return new Map();
+        }
+        const traceEntry = entries.find((e) => e.name === 'trace.trace');
+        let groups = new Map();
+        if (traceEntry) {
+            try {
+                const ndjson = await readFile(traceEntry.value, 'utf8');
+                groups = parseTrace(ndjson);
+            }
+            catch (err) {
+                debugLog('reading trace.trace failed:', err);
+            }
+        }
+        try {
+            await channel.tracingStartChunk({});
+        }
+        catch (err) {
+            debugLog('tracingStartChunk failed after export:', err);
+            this.active = false;
+        }
+        return groups;
+    }
+    async stop() {
+        if (!this.active)
+            return;
+        try {
+            await this.tracing.stop({});
+        }
+        catch (err) {
+            debugLog('tracing.stop failed:', err);
+        }
+        this.active = false;
+    }
+    isActive() {
+        return this.active;
+    }
+}
+function parseTrace(ndjson) {
+    const befores = new Map();
+    const groupTitleByCallId = new Map();
+    for (const line of ndjson.split('\n')) {
+        if (!line)
+            continue;
+        let evt;
+        try {
+            evt = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (evt.type === 'before') {
+            befores.set(evt.callId, {
+                callId: evt.callId,
+                class: evt.class,
+                method: evt.method,
+                params: evt.params || {},
+                parentId: evt.parentId,
+                title: evt.title,
+                failed: false,
+            });
+            if (evt.class === 'Tracing' && evt.method === 'tracingGroup' && typeof evt.title === 'string') {
+                groupTitleByCallId.set(evt.callId, evt.title);
+            }
+            continue;
+        }
+        if (evt.type === 'after') {
+            const rec = befores.get(evt.callId);
+            if (rec && evt.error)
+                rec.failed = true;
+        }
+    }
+    const groups = new Map();
+    for (const title of groupTitleByCallId.values()) {
+        groups.set(title, []);
+    }
+    for (const rec of befores.values()) {
+        if (rec.failed)
+            continue;
+        if (rec.class === 'Tracing')
+            continue;
+        if (!rec.parentId)
+            continue;
+        const groupTitle = groupTitleByCallId.get(rec.parentId);
+        if (!groupTitle)
+            continue;
+        const allowed = RECORDABLE[rec.class];
+        if (!allowed?.has(rec.method))
+            continue;
+        groups.get(groupTitle).push({ class: rec.class, method: rec.method, params: rec.params });
+    }
+    return groups;
+}
+export function renderCall(call) {
+    const asLocator = getAsLocator();
+    const { class: cls, method, params } = call;
+    if (cls === 'Frame') {
+        if (method === 'goto')
+            return `await page.goto(${quote(params.url)});`;
+        if (method === 'setContent')
+            return `await page.setContent(${quote(params.html)});`;
+        const locator = `page.${asLocator('javascript', params.selector || '')}`;
+        if (method === 'click')
+            return `await ${locator}.click();`;
+        if (method === 'dblclick')
+            return `await ${locator}.dblclick();`;
+        if (method === 'fill')
+            return `await ${locator}.fill(${quote(params.value ?? '')});`;
+        if (method === 'press')
+            return `await ${locator}.press(${quote(params.key ?? '')});`;
+        if (method === 'type')
+            return `await ${locator}.type(${quote(params.text ?? '')});`;
+        if (method === 'check')
+            return `await ${locator}.check();`;
+        if (method === 'uncheck')
+            return `await ${locator}.uncheck();`;
+        if (method === 'hover')
+            return `await ${locator}.hover();`;
+        if (method === 'tap')
+            return `await ${locator}.tap();`;
+        if (method === 'focus')
+            return `await ${locator}.focus();`;
+        if (method === 'scrollIntoViewIfNeeded')
+            return `await ${locator}.scrollIntoViewIfNeeded();`;
+        if (method === 'setInputFiles')
+            return `await ${locator}.setInputFiles(${formatFiles(params.localPaths ?? params.files)});`;
+        if (method === 'selectOption')
+            return `await ${locator}.selectOption(${formatSelectOption(params.options)});`;
+        if (method === 'dragTo')
+            return `await ${locator}.dragTo(page.locator(${quote(params.targetSelector ?? '')}));`;
+    }
+    if (cls === 'Page') {
+        if (method === 'goBack')
+            return 'await page.goBack();';
+        if (method === 'goForward')
+            return 'await page.goForward();';
+        if (method === 'reload')
+            return 'await page.reload();';
+        if (method === 'keyboardPress')
+            return `await page.keyboard.press(${quote(params.key ?? '')});`;
+        if (method === 'keyboardType')
+            return `await page.keyboard.type(${quote(params.text ?? '')});`;
+        if (method === 'keyboardDown')
+            return `await page.keyboard.down(${quote(params.key ?? '')});`;
+        if (method === 'keyboardUp')
+            return `await page.keyboard.up(${quote(params.key ?? '')});`;
+        if (method === 'keyboardInsertText')
+            return `await page.keyboard.insertText(${quote(params.text ?? '')});`;
+        if (method === 'mouseClick')
+            return `await page.mouse.click(${params.x ?? 0}, ${params.y ?? 0});`;
+        if (method === 'mouseDblclick')
+            return `await page.mouse.dblclick(${params.x ?? 0}, ${params.y ?? 0});`;
+        if (method === 'mouseMove')
+            return `await page.mouse.move(${params.x ?? 0}, ${params.y ?? 0});`;
+        if (method === 'mouseDown')
+            return 'await page.mouse.down();';
+        if (method === 'mouseUp')
+            return 'await page.mouse.up();';
+        if (method === 'mouseWheel')
+            return `await page.mouse.wheel(${params.deltaX ?? 0}, ${params.deltaY ?? 0});`;
+    }
+    return `// TODO(playwright): ${cls}.${method}(${JSON.stringify(params)})`;
+}
+function quote(value) {
+    return JSON.stringify(String(value ?? ''));
+}
+function formatFiles(files) {
+    if (!files)
+        return '[]';
+    if (Array.isArray(files)) {
+        if (files.length === 1)
+            return quote(files[0]);
+        return `[${files.map((f) => quote(f)).join(', ')}]`;
+    }
+    return quote(files);
+}
+function formatSelectOption(options) {
+    if (!options)
+        return `''`;
+    const list = Array.isArray(options) ? options : [options];
+    const values = list.map((o) => o?.valueOrLabel ?? o?.value ?? o?.label ?? '');
+    if (values.length === 1)
+        return quote(values[0]);
+    return `[${values.map((v) => quote(v)).join(', ')}]`;
+}
+export function renderAssertion(assertion) {
+    const args = assertion.args;
+    if (assertion.name === 'see' && typeof args[0] === 'string') {
+        return `await expect(page).toContainText(${JSON.stringify(args[0])});`;
+    }
+    if (assertion.name === 'dontSee' && typeof args[0] === 'string') {
+        return `await expect(page).not.toContainText(${JSON.stringify(args[0])});`;
+    }
+    if (assertion.name === 'seeElement' && typeof args[0] === 'string') {
+        return `await expect(page.locator(${JSON.stringify(args[0])})).toBeVisible();`;
+    }
+    if (assertion.name === 'dontSeeElement' && typeof args[0] === 'string') {
+        return `await expect(page.locator(${JSON.stringify(args[0])})).toBeHidden();`;
+    }
+    if (assertion.name === 'seeInField' && typeof args[0] === 'string' && args[1] !== undefined) {
+        return `await expect(page.locator(${JSON.stringify(args[0])})).toHaveValue(${JSON.stringify(String(args[1]))});`;
+    }
+    if (assertion.name === 'dontSeeInField' && typeof args[0] === 'string' && args[1] !== undefined) {
+        return `await expect(page.locator(${JSON.stringify(args[0])})).not.toHaveValue(${JSON.stringify(String(args[1]))});`;
+    }
+    if (assertion.name === 'seeInCurrentUrl' && typeof args[0] === 'string') {
+        return `await expect(page).toHaveURL(new RegExp(${JSON.stringify(args[0].replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))}));`;
+    }
+    if (assertion.name === 'dontSeeInCurrentUrl' && typeof args[0] === 'string') {
+        return `await expect(page).not.toHaveURL(new RegExp(${JSON.stringify(args[0].replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))}));`;
+    }
+    return `// TODO(playwright): ${assertion.name}(${assertion.args.map((a) => JSON.stringify(a)).join(', ')})`;
+}
+export { parseTrace };

package/dist/src/reporter.js

@@ -78,6 +78,7 @@ export class Reporter {
         const noteEntries = Object.entries(test.notes)
             .map(([timestampKey, note]) => ({
             startTime: note.startTime,
+            endTime: note.endTime,
             message: note.message,
             status: note.status,
             screenshot: note.screenshot,
@@ -105,7 +106,7 @@ export class Reporter {
             const step = {
                 category: 'user',
                 title: noteEntry.message,
-                duration: 0,
+                duration: Math.max(0, Math.round(noteEntry.endTime - noteEntry.startTime)),
                 status: noteEntry.status || 'none',
                 steps: noteSteps.length > 0 ? noteSteps : undefined,
             };
@@ -148,6 +149,7 @@ export class Reporter {
                 meta = Object.fromEntries(Object.entries(meta).filter(([, v]) => v));
             }
             const steps = this.combineStepsAndNotes(test, screenshotFile);
+            const durationMs = test.getDurationMs();
             const testData = {
                 rid: test.id,
                 title: test.scenario,
@@ -162,6 +164,7 @@ export class Reporter {
                 files: Object.values(test.artifacts) || [],
                 message: test.summary || this.extractLastNoteMessage(test) || '',
                 meta,
+                time: durationMs != null ? Math.round(durationMs) : 0,
             };
             debugLog(testData);
             await this.client.addTestRun(status, testData);

package/dist/src/test-plan.js

@@ -115,6 +115,10 @@ export class Task {
             .map((item) => `${item.type === 'step' ? '  ' : ''}${item.content}`)
             .join('\n');
     }
+    getRunResult() {
+        const hasPassedNotes = Object.values(this.notes).some((n) => n.status === TestResult.PASSED);
+        return hasPassedNotes ? 'partial' : 'failed';
+    }
 }
 export class Test extends Task {
     scenario;
@@ -133,6 +137,7 @@ export class Test extends Task {
     enabled = true;
     startTime;
     endTime;
+    resetCount = 0;
     constructor(scenario, priority, expectedOutcome, startUrl, plannedSteps = []) {
         super(scenario, startUrl);
         this.scenario = scenario;
@@ -182,6 +187,13 @@ export class Test extends Task {
             return Object.values(this.notes).some((note) => note.message === expectation && note.status === TestResult.PASSED);
         });
     }
+    getRunResult() {
+        if (this.isSuccessful)
+            return 'success';
+        if (this.hasAchievedAny())
+            return 'partial';
+        return super.getRunResult();
+    }
     hasAchievedAll() {
         return this.expected.every((expectation) => {
             return Object.values(this.notes).some((note) => note.message === expectation && note.status === TestResult.PASSED);

package/dist/src/utils/aria.js

@@ -601,9 +601,17 @@ const resolveDisplayName = (node) => {
         return `{${childContent}}`;
     return undefined;
 };
+const SIBLING_COLLAPSE_THRESHOLD = 50;
+const SIBLING_COLLAPSE_KEEP_EACH_SIDE = 5;
 const serializeAriaNodes = (nodes, depth = 0) => {
     const lines = [];
-    for (const node of nodes) {
+    const collapsed = collapseSimilarSiblingRuns(nodes, depth);
+    for (const entry of collapsed) {
+        if (entry.placeholder) {
+            lines.push(entry.placeholder);
+            continue;
+        }
+        const node = entry.node;
         const indent = '  '.repeat(depth);
         let line = `${indent}- ${renderNodeLine(node.role, resolveDisplayName(node), node.attributes, node.value)}`;
         if (node.children.length > 0) {
@@ -616,6 +624,34 @@ const serializeAriaNodes = (nodes, depth = 0) => {
     }
     return lines.join('\n');
 };
+const collapseSimilarSiblingRuns = (nodes, depth) => {
+    const result = [];
+    let i = 0;
+    while (i < nodes.length) {
+        const role = nodes[i].role;
+        let j = i;
+        while (j < nodes.length && nodes[j].role === role)
+            j++;
+        const runLength = j - i;
+        if (runLength > SIBLING_COLLAPSE_THRESHOLD) {
+            for (let k = i; k < i + SIBLING_COLLAPSE_KEEP_EACH_SIDE; k++) {
+                result.push({ node: nodes[k] });
+            }
+            const omitted = runLength - SIBLING_COLLAPSE_KEEP_EACH_SIDE * 2;
+            const indent = '  '.repeat(depth);
+            result.push({ placeholder: `${indent}- ...${omitted} similar "${role}" items omitted...` });
+            for (let k = j - SIBLING_COLLAPSE_KEEP_EACH_SIDE; k < j; k++) {
+                result.push({ node: nodes[k] });
+            }
+        }
+        else {
+            for (let k = i; k < j; k++)
+                result.push({ node: nodes[k] });
+        }
+        i = j;
+    }
+    return result;
+};
 export const compactAriaSnapshot = (snapshot, keepNamed = false) => {
     if (!snapshot)
         return '';

package/dist/src/utils/error-page.js

@@ -1,20 +1,33 @@
 import { isBodyEmpty } from './html.js';
 const HTTP_ERRORS = ['400 Bad Request', '401 Unauthorized', '403 Forbidden', '404 Not Found', '405 Method Not Allowed', '408 Request Timeout', '500 Internal Server Error', '502 Bad Gateway', '503 Service Unavailable', '504 Gateway Timeout'];
 const SMALL_PAGE_THRESHOLD = 500;
-export function isErrorPage(actionResult) {
-    const checkFields = [actionResult.title, actionResult.h1, actionResult.h2].filter(Boolean);
-    for (const field of checkFields) {
+const LOADING_WORD = /\bloading\b/i;
+export function detectPageCondition(actionResult) {
+    const headingFields = [actionResult.title, actionResult.h1, actionResult.h2].filter(Boolean);
+    for (const field of headingFields) {
         for (const error of HTTP_ERRORS) {
             if (field.toLowerCase().includes(error.toLowerCase()))
-                return true;
+                return 'error';
         }
     }
+    const aria = actionResult.ariaSnapshot || '';
+    if (/\bprogressbar\b/i.test(aria))
+        return 'loading';
+    if (/\[busy\]/.test(aria))
+        return 'loading';
+    for (const field of headingFields) {
+        if (LOADING_WORD.test(field))
+            return 'loading';
+    }
     if (!actionResult.html || isBodyEmpty(actionResult.html))
-        return true;
+        return 'loading';
     const bodyMatch = actionResult.html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
     if (bodyMatch && bodyMatch[1].trim().length < SMALL_PAGE_THRESHOLD)
-        return true;
-    return false;
+        return 'loading';
+    return 'ok';
+}
+export function isErrorPage(actionResult) {
+    return detectPageCondition(actionResult) === 'error';
 }
 export class ErrorPageError extends Error {
     url;

package/dist/src/utils/next-steps.js

@@ -0,0 +1,37 @@
+import path from 'node:path';
+import { tag } from './logger.js';
+export function relativeToCwd(absPath) {
+    const rel = path.relative(process.cwd(), absPath);
+    return rel || '.';
+}
+export function printNextSteps(sections) {
+    if (sections.length === 0)
+        return;
+    const blocks = [];
+    for (const section of sections) {
+        const lines = [];
+        const headerPath = section.path ? relativeToCwd(section.path) : '';
+        lines.push(headerPath ? `${section.label}: ${headerPath}` : section.label);
+        const commands = section.commands || [];
+        if (commands.length > 0) {
+            const labeled = commands.filter((c) => c.label);
+            const maxLabel = labeled.length > 0 ? Math.max(...labeled.map((c) => c.label.length)) : 0;
+            for (const cmd of commands) {
+                if (!cmd.label) {
+                    lines.push(`  ${cmd.command}`);
+                    continue;
+                }
+                const padded = `${cmd.label}:`.padEnd(maxLabel + 2);
+                lines.push(`  ${padded} ${cmd.command}`);
+            }
+        }
+        blocks.push(lines.join('\n'));
+    }
+    for (let i = 0; i < blocks.length; i++) {
+        if (i > 0)
+            tag('info').log('');
+        for (const line of blocks[i].split('\n')) {
+            tag('info').log(line);
+        }
+    }
+}