@jackwener/opencli 1.0.3 → 1.0.4

package/src/browser/page.ts

@@ -14,11 +14,22 @@ import { formatSnapshot } from '../snapshotFormatter.js';
 import type { IPage } from '../types.js';
 import { sendCommand } from './daemon-client.js';
 import { wrapForEval } from './utils.js';
+import {
+  clickJs,
+  typeTextJs,
+  pressKeyJs,
+  waitForTextJs,
+  scrollJs,
+  autoScrollJs,
+  networkRequestsJs,
+} from './dom-helpers.js';
 
 /**
  * Page — implements IPage by talking to the daemon via HTTP.
  */
 export class Page implements IPage {
+  constructor(private readonly workspace: string = 'default') {}
+
   /** Active tab ID, set after navigate and used in all subsequent commands */
   private _tabId: number | undefined;
 
@@ -27,9 +38,14 @@ export class Page implements IPage {
     return this._tabId !== undefined ? { tabId: this._tabId } : {};
   }
 
+  private _workspaceOpt(): { workspace: string } {
+    return { workspace: this.workspace };
+  }
+
   async goto(url: string): Promise<void> {
     const result = await sendCommand('navigate', {
       url,
+      ...this._workspaceOpt(),
       ...this._tabOpt(),
     }) as { tabId?: number };
     // Remember the tabId for subsequent exec calls
@@ -41,7 +57,7 @@ export class Page implements IPage {
   /** Close the automation window in the extension */
   async closeWindow(): Promise<void> {
     try {
-      await sendCommand('close-window', {});
+      await sendCommand('close-window', { ...this._workspaceOpt() });
     } catch {
       // Window may already be closed or daemon may be down
     }
@@ -49,7 +65,12 @@ export class Page implements IPage {
 
   async evaluate(js: string): Promise<any> {
     const code = wrapForEval(js);
-    return sendCommand('exec', { code, ...this._tabOpt() });
+    return sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
+  }
+
+  async getCookies(opts: { domain?: string; url?: string } = {}): Promise<any[]> {
+    const result = await sendCommand('cookies', { ...this._workspaceOpt(), ...opts });
+    return Array.isArray(result) ? result : [];
   }
 
   async snapshot(opts: { interactive?: boolean; compact?: boolean; maxDepth?: number; raw?: boolean } = {}): Promise<any> {
@@ -81,57 +102,25 @@ export class Page implements IPage {
         return buildTree(document.body, 0);
       })()
     `;
-    const raw = await sendCommand('exec', { code, ...this._tabOpt() });
+    const raw = await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
     if (opts.raw) return raw;
     if (typeof raw === 'string') return formatSnapshot(raw, opts);
     return raw;
   }
 
   async click(ref: string): Promise<void> {
-    const safeRef = JSON.stringify(ref);
-    const code = `
-      (() => {
-        const ref = ${safeRef};
-        const el = document.querySelector('[data-ref="' + ref + '"]')
-          || document.querySelectorAll('a, button, input, [role="button"], [tabindex]')[parseInt(ref, 10) || 0];
-        if (!el) throw new Error('Element not found: ' + ref);
-        el.scrollIntoView({ behavior: 'instant', block: 'center' });
-        el.click();
-        return 'clicked';
-      })()
-    `;
-    await sendCommand('exec', { code, ...this._tabOpt() });
+    const code = clickJs(ref);
+    await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
   }
 
   async typeText(ref: string, text: string): Promise<void> {
-    const safeRef = JSON.stringify(ref);
-    const safeText = JSON.stringify(text);
-    const code = `
-      (() => {
-        const ref = ${safeRef};
-        const el = document.querySelector('[data-ref="' + ref + '"]')
-          || document.querySelectorAll('input, textarea, [contenteditable]')[parseInt(ref, 10) || 0];
-        if (!el) throw new Error('Element not found: ' + ref);
-        el.focus();
-        el.value = ${safeText};
-        el.dispatchEvent(new Event('input', { bubbles: true }));
-        el.dispatchEvent(new Event('change', { bubbles: true }));
-        return 'typed';
-      })()
-    `;
-    await sendCommand('exec', { code, ...this._tabOpt() });
+    const code = typeTextJs(ref, text);
+    await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
   }
 
   async pressKey(key: string): Promise<void> {
-    const code = `
-      (() => {
-        const el = document.activeElement || document.body;
-        el.dispatchEvent(new KeyboardEvent('keydown', { key: ${JSON.stringify(key)}, bubbles: true }));
-        el.dispatchEvent(new KeyboardEvent('keyup', { key: ${JSON.stringify(key)}, bubbles: true }));
-        return 'pressed';
-      })()
-    `;
-    await sendCommand('exec', { code, ...this._tabOpt() });
+    const code = pressKeyJs(key);
+    await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
   }
 
   async wait(options: number | { text?: string; time?: number; timeout?: number }): Promise<void> {
@@ -145,52 +134,30 @@ export class Page implements IPage {
     }
     if (options.text) {
       const timeout = (options.timeout ?? 30) * 1000;
-      const code = `
-        new Promise((resolve, reject) => {
-          const deadline = Date.now() + ${timeout};
-          const check = () => {
-            if (document.body.innerText.includes(${JSON.stringify(options.text)})) return resolve('found');
-            if (Date.now() > deadline) return reject(new Error('Text not found: ' + ${JSON.stringify(options.text)}));
-            setTimeout(check, 200);
-          };
-          check();
-        })
-      `;
-      await sendCommand('exec', { code, ...this._tabOpt() });
+      const code = waitForTextJs(options.text, timeout);
+      await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
     }
   }
 
   async tabs(): Promise<any> {
-    return sendCommand('tabs', { op: 'list' });
+    return sendCommand('tabs', { op: 'list', ...this._workspaceOpt() });
   }
 
   async closeTab(index?: number): Promise<void> {
-    await sendCommand('tabs', { op: 'close', ...(index !== undefined ? { index } : {}) });
+    await sendCommand('tabs', { op: 'close', ...this._workspaceOpt(), ...(index !== undefined ? { index } : {}) });
   }
 
   async newTab(): Promise<void> {
-    await sendCommand('tabs', { op: 'new' });
+    await sendCommand('tabs', { op: 'new', ...this._workspaceOpt() });
   }
 
   async selectTab(index: number): Promise<void> {
-    await sendCommand('tabs', { op: 'select', index });
+    await sendCommand('tabs', { op: 'select', index, ...this._workspaceOpt() });
   }
 
   async networkRequests(includeStatic: boolean = false): Promise<any> {
-    const code = `
-      (() => {
-        const entries = performance.getEntriesByType('resource');
-        return entries
-          ${includeStatic ? '' : '.filter(e => !["img", "font", "css", "script"].some(t => e.initiatorType === t))'}
-          .map(e => ({
-            url: e.name,
-            type: e.initiatorType,
-            duration: Math.round(e.duration),
-            size: e.transferSize || 0,
-          }));
-      })()
-    `;
-    return sendCommand('exec', { code, ...this._tabOpt() });
+    const code = networkRequestsJs(includeStatic);
+    return sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
   }
 
   /**
@@ -216,6 +183,7 @@ export class Page implements IPage {
     path?: string;
   } = {}): Promise<string> {
     const base64 = await sendCommand('screenshot', {
+      ...this._workspaceOpt(),
       format: options.format,
       quality: options.quality,
       fullPage: options.fullPage,
@@ -226,46 +194,23 @@ export class Page implements IPage {
       const fs = await import('node:fs');
       const path = await import('node:path');
       const dir = path.dirname(options.path);
-      fs.mkdirSync(dir, { recursive: true });
-      fs.writeFileSync(options.path, Buffer.from(base64, 'base64'));
+      await fs.promises.mkdir(dir, { recursive: true });
+      await fs.promises.writeFile(options.path, Buffer.from(base64, 'base64'));
     }
 
     return base64;
   }
 
   async scroll(direction: string = 'down', amount: number = 500): Promise<void> {
-    const dx = direction === 'left' ? -amount : direction === 'right' ? amount : 0;
-    const dy = direction === 'up' ? -amount : direction === 'down' ? amount : 0;
-    await sendCommand('exec', {
-      code: `window.scrollBy(${dx}, ${dy})`,
-      ...this._tabOpt(),
-    });
+    const code = scrollJs(direction, amount);
+    await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
   }
 
   async autoScroll(options: { times?: number; delayMs?: number } = {}): Promise<void> {
     const times = options.times ?? 3;
     const delayMs = options.delayMs ?? 2000;
-    const code = `
-      (async () => {
-        for (let i = 0; i < ${times}; i++) {
-          const lastHeight = document.body.scrollHeight;
-          window.scrollTo(0, lastHeight);
-          await new Promise(resolve => {
-            let timeoutId;
-            const observer = new MutationObserver(() => {
-              if (document.body.scrollHeight > lastHeight) {
-                clearTimeout(timeoutId);
-                observer.disconnect();
-                setTimeout(resolve, 100);
-              }
-            });
-            observer.observe(document.body, { childList: true, subtree: true });
-            timeoutId = setTimeout(() => { observer.disconnect(); resolve(null); }, ${delayMs});
-          });
-        }
-      })()
-    `;
-    await sendCommand('exec', { code, ...this._tabOpt() });
+    const code = autoScrollJs(times, delayMs);
+    await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
   }
 
   async installInterceptor(pattern: string): Promise<void> {

package/src/browser.test.ts

@@ -1,5 +1,6 @@
 import { afterEach, describe, it, expect, vi } from 'vitest';
 import { BrowserBridge, __test__ } from './browser/index.js';
+import * as daemonClient from './browser/daemon-client.js';
 
 describe('browser helpers', () => {
   it('extracts tab entries from string snapshots', () => {
@@ -122,4 +123,13 @@ describe('BrowserBridge state', () => {
 
     await expect(mcp.connect()).rejects.toThrow('Session is closing');
   });
+
+  it('fails fast when daemon is running but extension is disconnected', async () => {
+    vi.spyOn(daemonClient, 'isExtensionConnected').mockResolvedValue(false);
+    vi.spyOn(daemonClient, 'isDaemonRunning').mockResolvedValue(true);
+
+    const mcp = new BrowserBridge();
+
+    await expect(mcp.connect()).rejects.toThrow('Browser Extension is not connected');
+  });
 });

package/src/build-manifest.test.ts

@@ -25,4 +25,40 @@ describe('parseTsArgsBlock', () => {
       },
     ]);
   });
+
+  it('keeps hyphenated arg names from TS adapters', () => {
+    const args = parseTsArgsBlock(`
+      {
+        name: 'tweet-url',
+        help: 'Single tweet URL to download',
+      },
+      {
+        name: 'download-images',
+        type: 'boolean',
+        default: false,
+        help: 'Download images locally',
+      },
+    `);
+
+    expect(args).toEqual([
+      {
+        name: 'tweet-url',
+        type: 'str',
+        default: undefined,
+        required: false,
+        positional: undefined,
+        help: 'Single tweet URL to download',
+        choices: undefined,
+      },
+      {
+        name: 'download-images',
+        type: 'boolean',
+        default: false,
+        required: false,
+        positional: undefined,
+        help: 'Download images locally',
+        choices: undefined,
+      },
+    ]);
+  });
 });

package/src/build-manifest.ts

@@ -114,7 +114,7 @@ export function parseTsArgsBlock(argsBlock: string): ManifestEntry['args'] {
   let cursor = 0;
 
   while (cursor < argsBlock.length) {
-    const nameMatch = argsBlock.slice(cursor).match(/\{\s*name\s*:\s*['"`](\w+)['"`]/);
+    const nameMatch = argsBlock.slice(cursor).match(/\{\s*name\s*:\s*['"`]([^'"`]+)['"`]/);
     if (!nameMatch || nameMatch.index === undefined) break;
 
     const objectStart = cursor + nameMatch.index;
@@ -231,6 +231,7 @@ function scanTs(filePath: string, site: string): ManifestEntry {
     // Extract browser: false (some adapters bypass browser entirely)
     const browserMatch = src.match(/browser\s*:\s*(true|false)/);
     if (browserMatch) entry.browser = browserMatch[1] === 'true';
+    else entry.browser = entry.strategy !== 'public';
 
     // Extract columns
     const colMatch = src.match(/columns\s*:\s*\[([^\]]*)\]/);

package/src/capabilityRouting.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest';
+import { Strategy, type CliCommand } from './registry.js';
+import { shouldUseBrowserSession } from './capabilityRouting.js';
+
+function makeCmd(partial: Partial<CliCommand>): CliCommand {
+  return {
+    site: 'test',
+    name: 'command',
+    description: '',
+    args: [],
+    ...partial,
+  };
+}
+
+describe('shouldUseBrowserSession', () => {
+  it('skips browser session for public fetch-only pipelines', () => {
+    expect(shouldUseBrowserSession(makeCmd({
+      browser: true,
+      strategy: Strategy.PUBLIC,
+      pipeline: [{ fetch: 'https://example.com/api' }, { select: 'items' }],
+    }))).toBe(false);
+  });
+
+  it('keeps browser session for public pipelines with browser-only steps', () => {
+    expect(shouldUseBrowserSession(makeCmd({
+      browser: true,
+      strategy: Strategy.PUBLIC,
+      pipeline: [{ navigate: 'https://example.com' }, { evaluate: '() => []' }],
+    }))).toBe(true);
+  });
+
+  it('keeps browser session for non-public strategies', () => {
+    expect(shouldUseBrowserSession(makeCmd({
+      browser: true,
+      strategy: Strategy.COOKIE,
+      pipeline: [{ fetch: 'https://example.com/api' }],
+    }))).toBe(true);
+  });
+
+  it('keeps browser session for function adapters', () => {
+    expect(shouldUseBrowserSession(makeCmd({
+      browser: true,
+      strategy: Strategy.PUBLIC,
+      func: async () => [],
+    }))).toBe(true);
+  });
+});

package/src/capabilityRouting.ts

@@ -0,0 +1,28 @@
+import { Strategy, type CliCommand } from './registry.js';
+
+const BROWSER_ONLY_STEPS = new Set([
+  'navigate',
+  'click',
+  'type',
+  'wait',
+  'press',
+  'snapshot',
+  'evaluate',
+  'intercept',
+  'tap',
+]);
+
+function pipelineNeedsBrowserSession(pipeline: Record<string, unknown>[]): boolean {
+  return pipeline.some((step) => {
+    if (!step || typeof step !== 'object') return false;
+    return Object.keys(step).some((op) => BROWSER_ONLY_STEPS.has(op));
+  });
+}
+
+export function shouldUseBrowserSession(cmd: CliCommand): boolean {
+  if (!cmd.browser) return false;
+  if (cmd.func) return true;
+  if (!cmd.pipeline || cmd.pipeline.length === 0) return true;
+  if (cmd.strategy !== Strategy.PUBLIC) return true;
+  return pipelineNeedsBrowserSession(cmd.pipeline as Record<string, unknown>[]);
+}

package/src/chaoxing.test.ts

@@ -1,18 +1,26 @@
 import { describe, expect, it } from 'vitest';
 import { formatTimestamp, workStatusLabel } from './chaoxing.js';
 
+function localDatePrefixFromMillis(ts: number): string {
+  const d = new Date(ts);
+  const yyyy = d.getFullYear();
+  const mm = String(d.getMonth() + 1).padStart(2, '0');
+  const dd = String(d.getDate()).padStart(2, '0');
+  return `${yyyy}-${mm}-${dd}`;
+}
+
 describe('formatTimestamp', () => {
   it('formats millisecond timestamp', () => {
-    // 2026-01-15 08:30 UTC+8
     const ts = new Date('2026-01-15T00:30:00Z').getTime();
     const result = formatTimestamp(ts);
-    expect(result).toMatch(/2026-01-15/);
+    expect(result).toMatch(new RegExp(`^${localDatePrefixFromMillis(ts)}\\s`));
   });
 
   it('formats second timestamp', () => {
-    const ts = Math.floor(new Date('2026-06-01T12:00:00Z').getTime() / 1000);
+    const millis = new Date('2026-06-01T12:00:00Z').getTime();
+    const ts = Math.floor(millis / 1000);
     const result = formatTimestamp(ts);
-    expect(result).toMatch(/2026-06-01/);
+    expect(result).toMatch(new RegExp(`^${localDatePrefixFromMillis(millis)}\\s`));
   });
 
   it('returns empty for null/undefined/0', () => {

package/src/cli.ts

@@ -1,13 +1,14 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { executeCommand } from './engine.js';
-import { type CliCommand, fullName, getRegistry, strategyLabel } from './registry.js';
+import { Strategy, type CliCommand, fullName, getRegistry, strategyLabel } from './registry.js';
 import { render as renderOutput } from './output.js';
 import { BrowserBridge, CDPBridge } from './browser/index.js';
 import { browserSession, DEFAULT_BROWSER_COMMAND_TIMEOUT, runWithTimeout } from './runtime.js';
 import { PKG_VERSION } from './version.js';
 import { printCompletionScript } from './completion.js';
 import { CliError } from './errors.js';
+import { shouldUseBrowserSession } from './capabilityRouting.js';
 
 export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
   const program = new Command();
@@ -64,13 +65,13 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
     });
 
   program.command('explore').alias('probe').description('Explore a website: discover APIs, stores, and recommend strategies').argument('<url>').option('--site <name>').option('--goal <text>').option('--wait <s>', '', '3').option('--auto', 'Enable interactive fuzzing (simulate clicks to trigger lazy APIs)').option('--click <labels>', 'Comma-separated labels to click before fuzzing (e.g. "字幕,CC,评论")')
-    .action(async (url, opts) => { const { exploreUrl, renderExploreSummary } = await import('./explore.js'); const clickLabels = opts.click ? opts.click.split(',').map((s: string) => s.trim()) : undefined; const BrowserFactory = process.env.OPENCLI_CDP_ENDPOINT ? CDPBridge : BrowserBridge; console.log(renderExploreSummary(await exploreUrl(url, { BrowserFactory: BrowserFactory as any, site: opts.site, goal: opts.goal, waitSeconds: parseFloat(opts.wait), auto: opts.auto, clickLabels }))); });
+    .action(async (url, opts) => { const { exploreUrl, renderExploreSummary } = await import('./explore.js'); const clickLabels = opts.click ? opts.click.split(',').map((s: string) => s.trim()) : undefined; const BrowserFactory = process.env.OPENCLI_CDP_ENDPOINT ? CDPBridge : BrowserBridge; const workspace = `explore:${opts.site ?? (() => { try { return new URL(url).host; } catch { return 'default'; } })()}`; console.log(renderExploreSummary(await exploreUrl(url, { BrowserFactory: BrowserFactory as any, site: opts.site, goal: opts.goal, waitSeconds: parseFloat(opts.wait), auto: opts.auto, clickLabels, workspace }))); });
 
   program.command('synthesize').description('Synthesize CLIs from explore').argument('<target>').option('--top <n>', '', '3')
     .action(async (target, opts) => { const { synthesizeFromExplore, renderSynthesizeSummary } = await import('./synthesize.js'); console.log(renderSynthesizeSummary(synthesizeFromExplore(target, { top: parseInt(opts.top) }))); });
 
   program.command('generate').description('One-shot: explore → synthesize → register').argument('<url>').option('--goal <text>').option('--site <name>')
-    .action(async (url, opts) => { const { generateCliFromUrl, renderGenerateSummary } = await import('./generate.js'); const BrowserFactory = process.env.OPENCLI_CDP_ENDPOINT ? CDPBridge : BrowserBridge; const r = await generateCliFromUrl({ url, BrowserFactory: BrowserFactory as any, builtinClis: BUILTIN_CLIS, userClis: USER_CLIS, goal: opts.goal, site: opts.site }); console.log(renderGenerateSummary(r)); process.exitCode = r.ok ? 0 : 1; });
+    .action(async (url, opts) => { const { generateCliFromUrl, renderGenerateSummary } = await import('./generate.js'); const BrowserFactory = process.env.OPENCLI_CDP_ENDPOINT ? CDPBridge : BrowserBridge; const workspace = `generate:${opts.site ?? (() => { try { return new URL(url).host; } catch { return 'default'; } })()}`; const r = await generateCliFromUrl({ url, BrowserFactory: BrowserFactory as any, builtinClis: BUILTIN_CLIS, userClis: USER_CLIS, goal: opts.goal, site: opts.site, workspace }); console.log(renderGenerateSummary(r)); process.exitCode = r.ok ? 0 : 1; });
 
   program.command('cascade').description('Strategy cascade: find simplest working strategy').argument('<url>').option('--site <name>')
     .action(async (url, opts) => {
@@ -80,16 +81,17 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
         // Navigate to the site first for cookie context
         try { const siteUrl = new URL(url); await page.goto(`${siteUrl.protocol}//${siteUrl.host}`); await page.wait(2); } catch {}
         return cascadeProbe(page, url);
-      });
+      }, { workspace: `cascade:${opts.site ?? (() => { try { return new URL(url).host; } catch { return 'default'; } })()}` });
       console.log(renderCascadeResult(result));
     });
 
   program.command('doctor')
     .description('Diagnose opencli browser bridge connectivity')
     .option('--live', 'Test browser connectivity (requires Chrome running)', false)
+    .option('--sessions', 'Show active automation sessions', false)
     .action(async (opts) => {
       const { runBrowserDoctor, renderBrowserDoctorReport } = await import('./doctor.js');
-      const report = await runBrowserDoctor({ live: opts.live, cliVersion: PKG_VERSION });
+      const report = await runBrowserDoctor({ live: opts.live, sessions: opts.sessions, cliVersion: PKG_VERSION });
       console.log(renderBrowserDoctorReport(report));
     });
 
@@ -107,10 +109,23 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
       printCompletionScript(shell);
     });
 
+  // ── Antigravity serve (built-in, long-running) ──────────────────────────────
+
+  const antigravityCmd = program.command('antigravity').description('antigravity commands');
+  antigravityCmd.command('serve')
+    .description('Start Anthropic-compatible API proxy for Antigravity')
+    .option('--port <port>', 'Server port (default: 8082)', '8082')
+    .action(async (opts) => {
+      const { startServe } = await import('./clis/antigravity/serve.js');
+      await startServe({ port: parseInt(opts.port) });
+    });
+
   // ── Dynamic site commands ──────────────────────────────────────────────────
 
   const registry = getRegistry();
   const siteGroups = new Map<string, Command>();
+  // Pre-seed with the antigravity command registered above to avoid duplicates
+  siteGroups.set('antigravity', antigravityCmd);
 
   for (const [, cmd] of registry) {
     let siteCmd = siteGroups.get(cmd.site);
@@ -157,16 +172,21 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
       try {
         if (actionOpts.verbose) process.env.OPENCLI_VERBOSE = '1';
         let result: any;
-        if (cmd.browser) {
+        if (shouldUseBrowserSession(cmd)) {
           const BrowserFactory = process.env.OPENCLI_CDP_ENDPOINT ? CDPBridge : BrowserBridge;
           result = await browserSession(BrowserFactory as any, async (page) => {
+            // Cookie/header strategies require same-origin context for credentialed fetch.
+            if ((cmd.strategy === Strategy.COOKIE || cmd.strategy === Strategy.HEADER) && cmd.domain) {
+              try { await page.goto(`https://${cmd.domain}`); await page.wait(2); } catch {}
+            }
             return runWithTimeout(executeCommand(cmd, page, kwargs, actionOpts.verbose), { timeout: cmd.timeoutSeconds ?? DEFAULT_BROWSER_COMMAND_TIMEOUT, label: fullName(cmd) });
-          });
+          }, { workspace: `site:${cmd.site}` });
         } else { result = await executeCommand(cmd, null, kwargs, actionOpts.verbose); }
         if (actionOpts.verbose && (!result || (Array.isArray(result) && result.length === 0))) {
           console.error(chalk.yellow(`[Verbose] Warning: Command returned an empty result. If the website structural API changed or requires authentication, check the network or update the adapter.`));
         }
-        renderOutput(result, { fmt: actionOpts.format, columns: cmd.columns, title: `${cmd.site}/${cmd.name}`, elapsed: (Date.now() - startTime) / 1000, source: fullName(cmd) });
+        const resolved = getRegistry().get(fullName(cmd)) ?? cmd;
+        renderOutput(result, { fmt: actionOpts.format, columns: resolved.columns, title: `${resolved.site}/${resolved.name}`, elapsed: (Date.now() - startTime) / 1000, source: fullName(resolved), footerExtra: resolved.footerExtra?.(kwargs) });
       } catch (err: any) { 
         if (err instanceof CliError) {
           console.error(chalk.red(`Error [${err.code}]: ${err.message}`));