@jackwener/opencli 1.7.11 → 1.7.13

package/dist/src/registry.test.js

@@ -7,13 +7,14 @@ describe('cli() registration', () => {
     it('registers a command and returns it', () => {
         const cmd = cli({
             site: 'test-registry',
-            name: 'hello',
+            name: 'hello', access: 'read',
             description: 'A test command',
             strategy: Strategy.PUBLIC,
             browser: false,
         });
         expect(cmd.site).toBe('test-registry');
         expect(cmd.name).toBe('hello');
+        expect(cmd.access).toBe('read');
         expect(cmd.strategy).toBe(Strategy.PUBLIC);
         expect(cmd.browser).toBe(false);
         expect(cmd.args).toEqual([]);
@@ -21,7 +22,7 @@ describe('cli() registration', () => {
     it('puts registered command in the registry', () => {
         cli({
             site: 'test-registry',
-            name: 'registered',
+            name: 'registered', access: 'read',
             description: 'test',
         });
         const registry = getRegistry();
@@ -30,7 +31,7 @@ describe('cli() registration', () => {
     it('defaults strategy to COOKIE when browser is true', () => {
         const cmd = cli({
             site: 'test-registry',
-            name: 'default-strategy',
+            name: 'default-strategy', access: 'read',
         });
         expect(cmd.strategy).toBe(Strategy.COOKIE);
         expect(cmd.browser).toBe(true);
@@ -38,7 +39,7 @@ describe('cli() registration', () => {
     it('defaults strategy to PUBLIC when browser is false', () => {
         const cmd = cli({
             site: 'test-registry',
-            name: 'no-browser',
+            name: 'no-browser', access: 'read',
             browser: false,
         });
         expect(cmd.strategy).toBe(Strategy.PUBLIC);
@@ -46,7 +47,7 @@ describe('cli() registration', () => {
     it('preserves LOCAL strategy on registration', () => {
         const cmd = cli({
             site: 'test-registry',
-            name: 'local-strategy',
+            name: 'local-strategy', access: 'read',
             description: 'reads local credentials',
             strategy: Strategy.LOCAL,
             browser: false,
@@ -55,15 +56,15 @@ describe('cli() registration', () => {
         expect(cmd.browser).toBe(false);
     });
     it('overwrites existing command on re-registration', () => {
-        cli({ site: 'test-registry', name: 'overwrite', description: 'v1' });
-        cli({ site: 'test-registry', name: 'overwrite', description: 'v2' });
+        cli({ site: 'test-registry', name: 'overwrite', access: 'read', description: 'v1' });
+        cli({ site: 'test-registry', name: 'overwrite', access: 'read', description: 'v2' });
         const reg = getRegistry();
         expect(reg.get('test-registry/overwrite')?.description).toBe('v2');
     });
     it('registers aliases as alternate registry keys for the same command', () => {
         const cmd = cli({
             site: 'test-registry',
-            name: 'canonical',
+            name: 'canonical', access: 'read',
             description: 'test aliases',
             aliases: ['compat', 'legacy-name'],
         });
@@ -76,18 +77,24 @@ describe('cli() registration', () => {
     it('preserves defaultFormat on the registered command', () => {
         const cmd = cli({
             site: 'test-registry',
-            name: 'plain-default',
+            name: 'plain-default', access: 'read',
             description: 'prefers plain output',
             defaultFormat: 'plain',
         });
         expect(cmd.defaultFormat).toBe('plain');
         expect(getRegistry().get('test-registry/plain-default')?.defaultFormat).toBe('plain');
     });
+    it('rejects commands without explicit access metadata', () => {
+        expect(() => cli({
+            site: 'test-registry',
+            name: 'missing-access',
+        })).toThrow("Command test-registry/missing-access must declare access: 'read' | 'write'");
+    });
 });
 describe('fullName', () => {
     it('returns site/name', () => {
         const cmd = {
-            site: 'bilibili', name: 'hot', description: '', args: [],
+            site: 'bilibili', name: 'hot', access: 'read', description: '', args: [],
         };
         expect(fullName(cmd)).toBe('bilibili/hot');
     });
@@ -95,14 +102,14 @@ describe('fullName', () => {
 describe('strategyLabel', () => {
     it('returns strategy string', () => {
         const cmd = {
-            site: 'test', name: 'test', description: '', args: [],
+            site: 'test', name: 'test', access: 'read', description: '', args: [],
             strategy: Strategy.INTERCEPT,
         };
         expect(strategyLabel(cmd)).toBe('intercept');
     });
     it('returns public when no strategy set', () => {
         const cmd = {
-            site: 'test', name: 'test', description: '', args: [],
+            site: 'test', name: 'test', access: 'read', description: '', args: [],
         };
         expect(strategyLabel(cmd)).toBe('public');
     });
@@ -111,21 +118,21 @@ describe('registerCommand', () => {
     it('registers a pre-built command', () => {
         const cmd = {
             site: 'test-registry',
-            name: 'direct-reg',
+            name: 'direct-reg', access: 'read',
             description: 'directly registered',
             args: [],
-            strategy: Strategy.HEADER,
+            strategy: Strategy.COOKIE,
             browser: true,
         };
         registerCommand(cmd);
         const reg = getRegistry();
-        expect(reg.get('test-registry/direct-reg')?.strategy).toBe(Strategy.HEADER);
+        expect(reg.get('test-registry/direct-reg')?.strategy).toBe(Strategy.COOKIE);
     });
 });
 describe('normalizeCommand (via registerCommand)', () => {
     it('COOKIE + domain → navigateBefore is the domain URL', () => {
         registerCommand({
-            site: 'test-norm', name: 'cookie-domain', description: '', args: [],
+            site: 'test-norm', name: 'cookie-domain', access: 'read', description: '', args: [],
             strategy: Strategy.COOKIE, domain: 'x.com',
         });
         const cmd = getRegistry().get('test-norm/cookie-domain');
@@ -134,7 +141,7 @@ describe('normalizeCommand (via registerCommand)', () => {
     });
     it('COOKIE without domain → navigateBefore is true (auth context, no URL)', () => {
         registerCommand({
-            site: 'test-norm', name: 'cookie-nodomain', description: '', args: [],
+            site: 'test-norm', name: 'cookie-nodomain', access: 'read', description: '', args: [],
             strategy: Strategy.COOKIE,
         });
         const cmd = getRegistry().get('test-norm/cookie-nodomain');
@@ -143,7 +150,7 @@ describe('normalizeCommand (via registerCommand)', () => {
     });
     it('INTERCEPT → navigateBefore is true (auth context)', () => {
         registerCommand({
-            site: 'test-norm', name: 'intercept', description: '', args: [],
+            site: 'test-norm', name: 'intercept', access: 'read', description: '', args: [],
             strategy: Strategy.INTERCEPT, domain: 'example.com',
         });
         const cmd = getRegistry().get('test-norm/intercept');
@@ -152,7 +159,7 @@ describe('normalizeCommand (via registerCommand)', () => {
     });
     it('PUBLIC → browser false, navigateBefore undefined', () => {
         registerCommand({
-            site: 'test-norm', name: 'public', description: '', args: [],
+            site: 'test-norm', name: 'public', access: 'read', description: '', args: [],
             strategy: Strategy.PUBLIC,
         });
         const cmd = getRegistry().get('test-norm/public');
@@ -161,7 +168,7 @@ describe('normalizeCommand (via registerCommand)', () => {
     });
     it('LOCAL → browser false, navigateBefore undefined', () => {
         registerCommand({
-            site: 'test-norm', name: 'local', description: '', args: [],
+            site: 'test-norm', name: 'local', access: 'read', description: '', args: [],
             strategy: Strategy.LOCAL,
         });
         const cmd = getRegistry().get('test-norm/local');
@@ -172,7 +179,7 @@ describe('normalizeCommand (via registerCommand)', () => {
     });
     it('explicit navigateBefore: false overrides COOKIE + domain', () => {
         registerCommand({
-            site: 'test-norm', name: 'cookie-override', description: '', args: [],
+            site: 'test-norm', name: 'cookie-override', access: 'read', description: '', args: [],
             strategy: Strategy.COOKIE, domain: 'amazon.com', navigateBefore: false,
         });
         const cmd = getRegistry().get('test-norm/cookie-override');
@@ -181,7 +188,7 @@ describe('normalizeCommand (via registerCommand)', () => {
     });
     it('explicit navigateBefore URL overrides strategy default', () => {
         registerCommand({
-            site: 'test-norm', name: 'explicit-url', description: '', args: [],
+            site: 'test-norm', name: 'explicit-url', access: 'read', description: '', args: [],
             strategy: Strategy.COOKIE, domain: 'x.com',
             navigateBefore: 'https://x.com/explore',
         });

package/dist/src/runtime.d.ts

@@ -6,7 +6,6 @@ import type { IPage } from './types.js';
 export declare function getBrowserFactory(site?: string): new () => IBrowserFactory;
 export declare const DEFAULT_BROWSER_CONNECT_TIMEOUT: number;
 export declare const DEFAULT_BROWSER_COMMAND_TIMEOUT: number;
-export declare const DEFAULT_BROWSER_EXPLORE_TIMEOUT: number;
 /**
  * Timeout with seconds unit. Used for high-level command timeouts.
  */
@@ -28,6 +27,7 @@ export interface IBrowserFactory {
         workspace?: string;
         cdpEndpoint?: string;
         contextId?: string;
+        idleTimeout?: number;
     }): Promise<IPage>;
     close(): Promise<void>;
 }
@@ -35,4 +35,5 @@ export declare function browserSession<T>(BrowserFactory: new () => IBrowserFact
     workspace?: string;
     cdpEndpoint?: string;
     contextId?: string;
+    idleTimeout?: number;
 }): Promise<T>;

package/dist/src/runtime.js

@@ -24,7 +24,6 @@ function parseEnvTimeout(envVar, fallback) {
 }
 export const DEFAULT_BROWSER_CONNECT_TIMEOUT = parseEnvTimeout('OPENCLI_BROWSER_CONNECT_TIMEOUT', 30);
 export const DEFAULT_BROWSER_COMMAND_TIMEOUT = parseEnvTimeout('OPENCLI_BROWSER_COMMAND_TIMEOUT', 60);
-export const DEFAULT_BROWSER_EXPLORE_TIMEOUT = parseEnvTimeout('OPENCLI_BROWSER_EXPLORE_TIMEOUT', 120);
 /**
  * Timeout with seconds unit. Used for high-level command timeouts.
  */
@@ -54,6 +53,7 @@ export async function browserSession(BrowserFactory, fn, opts = {}) {
             workspace: opts.workspace,
             cdpEndpoint: opts.cdpEndpoint,
             contextId: opts.contextId,
+            idleTimeout: opts.idleTimeout,
         });
         return await fn(page);
     }

package/dist/src/serialization.d.ts

@@ -24,15 +24,19 @@ export declare function serializeCommand(cmd: CliCommand): {
     name: string;
     aliases: string[];
     description: string;
+    access: import("./registry.js").CommandAccess;
     strategy: string;
     browser: boolean;
     args: SerializedArg[];
     columns: string[];
     domain: string | null;
-    deprecated: string | boolean | null;
-    replacedBy: string | null;
+    example: string;
+    defaultFormat: "table" | "plain" | "json" | "yaml" | "yml" | "md" | "markdown" | "csv" | null;
+    browserSession: import("./registry.js").BrowserSessionOptions | null;
 };
 /** Human-readable arg summary: `<required> [optional]` style. */
 export declare function formatArgSummary(args: Arg[]): string;
+/** Agent-facing canonical invocation. Adapter authors may override with `example`. */
+export declare function formatCommandExample(cmd: CliCommand): string;
 /** Generate the --help appendix showing registry metadata not exposed by Commander. */
 export declare function formatRegistryHelpText(cmd: CliCommand): string;

package/dist/src/serialization.js

@@ -26,13 +26,15 @@ export function serializeCommand(cmd) {
         name: cmd.name,
         aliases: cmd.aliases ?? [],
         description: cmd.description,
+        access: cmd.access,
         strategy: strategyLabel(cmd),
         browser: !!cmd.browser,
         args: cmd.args.map(serializeArg),
         columns: cmd.columns ?? [],
         domain: cmd.domain ?? null,
-        deprecated: cmd.deprecated ?? null,
-        replacedBy: cmd.replacedBy ?? null,
+        example: formatCommandExample(cmd),
+        defaultFormat: cmd.defaultFormat ?? null,
+        browserSession: cmd.browserSession ?? null,
     };
 }
 // ── Formatting ──────────────────────────────────────────────────────────────
@@ -51,6 +53,29 @@ function summarizeChoices(choices) {
         return choices.join(', ');
     return `${choices.slice(0, 4).join(', ')}, ... (+${choices.length - 4} more)`;
 }
+function formatValuePlaceholder(name) {
+    return `<${name}>`;
+}
+/** Agent-facing canonical invocation. Adapter authors may override with `example`. */
+export function formatCommandExample(cmd) {
+    if (cmd.example?.trim())
+        return cmd.example.trim();
+    const parts = ['opencli', cmd.site, cmd.name];
+    for (const arg of cmd.args) {
+        if (arg.positional && arg.required) {
+            parts.push(formatValuePlaceholder(arg.name));
+        }
+    }
+    for (const arg of cmd.args) {
+        if (arg.positional || !arg.required)
+            continue;
+        parts.push(`--${arg.name}`);
+        if (arg.type !== 'bool' && arg.type !== 'boolean')
+            parts.push(formatValuePlaceholder(arg.name));
+    }
+    parts.push('-f', 'yaml');
+    return parts.join(' ');
+}
 /** Generate the --help appendix showing registry metadata not exposed by Commander. */
 export function formatRegistryHelpText(cmd) {
     const lines = [];
@@ -61,17 +86,16 @@ export function formatRegistryHelpText(cmd) {
         lines.push(`  ${prefix}: ${summarizeChoices(a.choices)}${def}`);
     }
     const meta = [];
-    meta.push(`Strategy: ${strategyLabel(cmd)}`);
+    meta.push(`Access: ${cmd.access}`);
     meta.push(`Browser: ${cmd.browser ? 'yes' : 'no'}`);
     if (cmd.domain)
         meta.push(`Domain: ${cmd.domain}`);
-    if (cmd.deprecated)
-        meta.push(`Deprecated: ${typeof cmd.deprecated === 'string' ? cmd.deprecated : 'yes'}`);
-    if (cmd.replacedBy)
-        meta.push(`Use instead: ${cmd.replacedBy}`);
+    if (cmd.defaultFormat)
+        meta.push(`Default format: ${cmd.defaultFormat}`);
     if (cmd.aliases?.length)
         meta.push(`Aliases: ${cmd.aliases.join(', ')}`);
     lines.push(meta.join(' | '));
+    lines.push(`Example: ${formatCommandExample(cmd)}`);
     if (cmd.columns?.length)
         lines.push(`Output columns: ${cmd.columns.join(', ')}`);
     return '\n' + lines.join('\n') + '\n';

package/dist/src/serialization.test.js

@@ -1,11 +1,11 @@
 import { describe, expect, it } from 'vitest';
 import { Strategy } from './registry.js';
-import { formatRegistryHelpText, serializeCommand } from './serialization.js';
+import { formatCommandExample, formatRegistryHelpText, serializeCommand } from './serialization.js';
 describe('formatRegistryHelpText', () => {
     it('summarizes long choices lists so help text stays readable', () => {
         const cmd = {
             site: 'demo',
-            name: 'dynamic',
+            name: 'dynamic', access: 'read',
             description: 'Demo command',
             strategy: Strategy.PUBLIC,
             browser: false,
@@ -24,6 +24,7 @@ describe('formatRegistryHelpText', () => {
         const cmd = {
             site: 'demo',
             name: 'get',
+            access: 'read',
             aliases: ['metadata'],
             description: 'Demo command',
             strategy: Strategy.COOKIE,
@@ -32,8 +33,46 @@ describe('formatRegistryHelpText', () => {
         };
         expect(serializeCommand(cmd)).toMatchObject({
             command: 'demo/get',
+            access: 'read',
             aliases: ['metadata'],
         });
         expect(formatRegistryHelpText(cmd)).toContain('Aliases: metadata');
     });
+    it('surfaces access and canonical examples instead of strategy as primary help metadata', () => {
+        const cmd = {
+            site: 'bilibili',
+            name: 'hot',
+            access: 'read',
+            description: 'Bilibili hot videos',
+            strategy: Strategy.COOKIE,
+            browser: true,
+            args: [],
+        };
+        expect(formatCommandExample(cmd)).toBe('opencli bilibili hot -f yaml');
+        expect(serializeCommand(cmd)).toMatchObject({
+            command: 'bilibili/hot',
+            access: 'read',
+            example: 'opencli bilibili hot -f yaml',
+        });
+        expect(formatRegistryHelpText(cmd)).toContain('Access: read');
+        expect(formatRegistryHelpText(cmd)).toContain('Example: opencli bilibili hot -f yaml');
+        expect(formatRegistryHelpText(cmd)).not.toContain('Strategy:');
+    });
+    it('surfaces command default output format in structured serialization and help text', () => {
+        const cmd = {
+            site: 'gemini',
+            name: 'ask',
+            access: 'read',
+            description: 'Ask Gemini',
+            strategy: Strategy.COOKIE,
+            browser: true,
+            args: [],
+            defaultFormat: 'plain',
+        };
+        expect(serializeCommand(cmd)).toMatchObject({
+            command: 'gemini/ask',
+            defaultFormat: 'plain',
+        });
+        expect(formatRegistryHelpText(cmd)).toContain('Default format: plain');
+    });
 });

package/dist/src/types.d.ts

@@ -31,6 +31,10 @@ export interface ScreenshotOptions {
     format?: 'png' | 'jpeg';
     quality?: number;
     fullPage?: boolean;
+    /** Override viewport width in CSS pixels for the screenshot only (cleared after). */
+    width?: number;
+    /** Override viewport height in CSS pixels for the screenshot only (ignored when fullPage). */
+    height?: number;
     path?: string;
 }
 export interface FetchJsonOptions {
@@ -87,6 +91,19 @@ export interface IPage {
         matches_n: number;
         match_level: 'exact' | 'stable' | 'reidentified';
     }>;
+    fillText(ref: string, text: string, opts?: {
+        nth?: number;
+        firstOnMulti?: boolean;
+    }): Promise<{
+        filled: boolean;
+        verified: boolean;
+        expected: string;
+        actual: string;
+        length: number;
+        matches_n: number;
+        match_level: 'exact' | 'stable' | 'reidentified';
+        mode?: 'input' | 'textarea' | 'contenteditable';
+    }>;
     pressKey(key: string): Promise<void>;
     scrollTo(ref: string, opts?: {
         nth?: number;
@@ -130,6 +147,8 @@ export interface IPage {
     setActivePage?(page?: string): void;
     /** Send a raw CDP command via chrome.debugger passthrough. */
     cdp?(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    /** Accept or dismiss the currently open JavaScript alert/confirm/prompt dialog. */
+    handleJavaScriptDialog?(accept: boolean, promptText?: string): Promise<void>;
     /** List cross-origin iframe targets in snapshot order. */
     frames?(): Promise<Array<{
         index: number;

package/dist/src/validate.js

@@ -1,12 +1,15 @@
 /** Validate CLI definitions from the registry (JS-first). */
 import { getRegistry, fullName } from './registry.js';
-/** All recognized pipeline step names */
-const KNOWN_STEP_NAMES = new Set([
-    'navigate', 'click', 'type', 'wait', 'press', 'snapshot',
-    'fetch', 'evaluate',
-    'select', 'map', 'filter', 'sort', 'limit',
-    'intercept', 'tap', 'download',
-]);
+import { getRegisteredStepNames } from './pipeline/registry.js';
+/**
+ * Pipeline step names — derived from the live pipeline registry on each
+ * validate call so a new step registered in src/pipeline/registry.ts (or by
+ * a plugin at runtime) is automatically allowlisted here (no parallel
+ * hand-maintained list, no stale-snapshot drift).
+ */
+function getKnownStepNames() {
+    return new Set(getRegisteredStepNames());
+}
 /**
  * Validate registered CLI commands from the in-memory registry.
  *
@@ -66,18 +69,19 @@ function validateCommand(cmd) {
     const warnings = [];
     if (!cmd.description)
         warnings.push('Missing description');
-    // Browser commands should specify a domain for cookie/header context
+    // Browser commands should specify a domain for authenticated browser context
     if (cmd.browser && !cmd.domain) {
-        warnings.push('Browser command without "domain" — cookie/header context may not work');
+        warnings.push('Browser command without "domain" — authenticated browser context may not work');
     }
     // Pipeline validation: check step names for typos
     if (Array.isArray(cmd.pipeline)) {
+        const knownStepNames = getKnownStepNames();
         for (let i = 0; i < cmd.pipeline.length; i++) {
             const step = cmd.pipeline[i];
             if (step && typeof step === 'object') {
                 for (const key of Object.keys(step)) {
-                    if (!KNOWN_STEP_NAMES.has(key)) {
-                        warnings.push(`Pipeline step ${i}: unknown step name "${key}" (did you mean one of: ${[...KNOWN_STEP_NAMES].join(', ')}?)`);
+                    if (!knownStepNames.has(key)) {
+                        warnings.push(`Pipeline step ${i}: unknown step name "${key}" (did you mean one of: ${[...knownStepNames].join(', ')}?)`);
                     }
                 }
             }

package/dist/src/validate.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Tests for src/validate.ts.
+ *
+ * Focus: regression guards for the "single source of truth" link between
+ * pipeline step registry (src/pipeline/registry.ts) and validate.ts step
+ * allowlist. A new step registered via `registerStep()` must automatically
+ * be allowlisted by `opencli validate` — no parallel hand-maintained list.
+ */
+export {};

package/dist/src/validate.test.js

@@ -0,0 +1,90 @@
+/**
+ * Tests for src/validate.ts.
+ *
+ * Focus: regression guards for the "single source of truth" link between
+ * pipeline step registry (src/pipeline/registry.ts) and validate.ts step
+ * allowlist. A new step registered via `registerStep()` must automatically
+ * be allowlisted by `opencli validate` — no parallel hand-maintained list.
+ */
+import { describe, it, expect } from 'vitest';
+import { getRegisteredStepNames, registerStep } from './pipeline/registry.js';
+import { cli, getRegistry, Strategy } from './registry.js';
+import { validateClisWithTarget } from './validate.js';
+describe('validate.ts pipeline step allowlist', () => {
+    it('uses every step name registered in pipeline/registry.ts', () => {
+        const registered = getRegisteredStepNames();
+        expect(registered).toContain('navigate');
+        expect(registered).toContain('click');
+        expect(registered).toContain('type');
+        expect(registered).toContain('fill');
+        expect(registered).toContain('fetch');
+        expect(registered.length).toBeGreaterThanOrEqual(15);
+    });
+    it('does not warn for any step name currently registered in the pipeline registry', () => {
+        // Snapshot the registry before mutating it for the test.
+        const reg = getRegistry();
+        const original = reg.get('validate-allowlist-test/all-steps');
+        if (original)
+            reg.delete('validate-allowlist-test/all-steps');
+        const allRegisteredSteps = getRegisteredStepNames();
+        cli({
+            site: 'validate-allowlist-test',
+            name: 'all-steps',
+            access: 'read',
+            browser: false,
+            strategy: Strategy.PUBLIC,
+            args: [],
+            pipeline: allRegisteredSteps.map(stepName => ({ [stepName]: {} })),
+            func: async () => [],
+        });
+        try {
+            const report = validateClisWithTarget([], 'validate-allowlist-test/all-steps');
+            const r = report.results[0];
+            const unknownStepWarning = r.warnings.find(w => w.startsWith('Pipeline step '));
+            expect(unknownStepWarning).toBeUndefined();
+        }
+        finally {
+            reg.delete('validate-allowlist-test/all-steps');
+            if (original)
+                reg.set('validate-allowlist-test/all-steps', original);
+        }
+    });
+    it('newly registered step automatically appears in validator allowlist', () => {
+        const customStep = '__test_custom_step__';
+        expect(getRegisteredStepNames()).not.toContain(customStep);
+        registerStep(customStep, async (_p, _params, data) => data);
+        try {
+            expect(getRegisteredStepNames()).toContain(customStep);
+            const reg = getRegistry();
+            const original = reg.get('validate-dynamic-test/uses-custom');
+            if (original)
+                reg.delete('validate-dynamic-test/uses-custom');
+            cli({
+                site: 'validate-dynamic-test',
+                name: 'uses-custom',
+                access: 'read',
+                browser: false,
+                strategy: Strategy.PUBLIC,
+                args: [],
+                pipeline: [{ [customStep]: {} }],
+                func: async () => [],
+            });
+            try {
+                const report = validateClisWithTarget([], 'validate-dynamic-test/uses-custom');
+                const r = report.results[0];
+                const unknownStepWarning = r.warnings.find(w => w.includes(customStep));
+                expect(unknownStepWarning).toBeUndefined();
+            }
+            finally {
+                reg.delete('validate-dynamic-test/uses-custom');
+                if (original)
+                    reg.set('validate-dynamic-test/uses-custom', original);
+            }
+        }
+        finally {
+            // Best-effort cleanup of the test step. There is no `unregisterStep` —
+            // leaving it registered is harmless because the test step name is
+            // namespaced and never used outside this file.
+        }
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "1.7.11",
+  "version": "1.7.13",
   "publishConfig": {
     "access": "public"
   },
@@ -57,6 +57,9 @@
     "test:adapter": "vitest run --project adapter",
     "test:all": "vitest run",
     "test:e2e": "vitest run --project e2e",
+    "advise:listing-id-pairing": "node scripts/check-listing-id-pairing.mjs",
+    "check:silent-column-drop": "node scripts/check-silent-column-drop.mjs",
+    "check:typed-error-lint": "node scripts/check-typed-error-lint.mjs",
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs",
     "docs:preview": "vitepress preview docs"