@jackwener/opencli 1.7.0 → 1.7.2

package/dist/src/errors.d.ts

@@ -70,7 +70,21 @@ export declare class EmptyResultError extends CliError {
 export declare class SelectorError extends CliError {
     constructor(selector: string, hint?: string);
 }
+export declare class PluginError extends CliError {
+    constructor(message: string, hint?: string);
+}
+/** Structured error output — unified contract for all consumers (AI agents, scripts, humans). */
+export interface ErrorEnvelope {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+        help?: string;
+        exitCode: number;
+        stack?: string;
+    };
+}
 /** Extract a human-readable message from an unknown caught value. */
 export declare function getErrorMessage(error: unknown): string;
-/** Error code → emoji mapping for CLI output rendering. */
-export declare const ERROR_ICONS: Record<string, string>;
+/** Build an ErrorEnvelope from any caught value. */
+export declare function toEnvelope(err: unknown): ErrorEnvelope;

package/dist/src/errors.js

@@ -96,24 +96,36 @@ export class SelectorError extends CliError {
         super('SELECTOR', `Could not find element: ${selector}`, hint ?? 'The page UI may have changed. Please report this issue.', EXIT_CODES.GENERIC_ERROR);
     }
 }
+export class PluginError extends CliError {
+    constructor(message, hint) {
+        super('PLUGIN', message, hint, EXIT_CODES.GENERIC_ERROR);
+    }
+}
 // ── Utilities ───────────────────────────────────────────────────────────────
 /** Extract a human-readable message from an unknown caught value. */
 export function getErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
-/** Error code → emoji mapping for CLI output rendering. */
-export const ERROR_ICONS = {
-    AUTH_REQUIRED: '🔒',
-    BROWSER_CONNECT: '🔌',
-    TIMEOUT: '⏱ ',
-    ARGUMENT: '❌',
-    EMPTY_RESULT: '📭',
-    SELECTOR: '🔍',
-    COMMAND_EXEC: '💥',
-    ADAPTER_LOAD: '📦',
-    NETWORK: '🌐',
-    API_ERROR: '🚫',
-    RATE_LIMITED: '⏳',
-    PAGE_CHANGED: '🔄',
-    CONFIG: '⚙️ ',
-};
+/** Build an ErrorEnvelope from any caught value. */
+export function toEnvelope(err) {
+    if (err instanceof CliError) {
+        return {
+            ok: false,
+            error: {
+                code: err.code,
+                message: err.message,
+                ...(err.hint ? { help: err.hint } : {}),
+                exitCode: err.exitCode,
+            },
+        };
+    }
+    const msg = getErrorMessage(err);
+    return {
+        ok: false,
+        error: {
+            code: 'UNKNOWN',
+            message: msg,
+            exitCode: EXIT_CODES.GENERIC_ERROR,
+        },
+    };
+}

package/dist/src/errors.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { CliError, BrowserConnectError, AdapterLoadError, CommandExecutionError, ConfigError, AuthRequiredError, TimeoutError, ArgumentError, EmptyResultError, SelectorError, } from './errors.js';
+import { CliError, BrowserConnectError, AdapterLoadError, CommandExecutionError, ConfigError, AuthRequiredError, TimeoutError, ArgumentError, EmptyResultError, SelectorError, toEnvelope, } from './errors.js';
 describe('Error type hierarchy', () => {
     it('all error types extend CliError', () => {
         const errors = [
@@ -57,3 +57,40 @@ describe('Error type hierarchy', () => {
         expect(err.code).toBe('BROWSER_CONNECT');
     });
 });
+describe('toEnvelope', () => {
+    it('converts CliError to structured envelope', () => {
+        const err = new AuthRequiredError('bilibili.com');
+        const envelope = toEnvelope(err);
+        expect(envelope).toEqual({
+            ok: false,
+            error: {
+                code: 'AUTH_REQUIRED',
+                message: 'Not logged in to bilibili.com',
+                help: expect.stringContaining('https://bilibili.com'),
+                exitCode: 77,
+            },
+        });
+    });
+    it('converts CliError without hint (omits help field)', () => {
+        const err = new CommandExecutionError('Something broke');
+        const envelope = toEnvelope(err);
+        expect(envelope.error.code).toBe('COMMAND_EXEC');
+        expect(envelope.error).not.toHaveProperty('help');
+    });
+    it('converts unknown Error to UNKNOWN envelope', () => {
+        const envelope = toEnvelope(new Error('random failure'));
+        expect(envelope).toEqual({
+            ok: false,
+            error: {
+                code: 'UNKNOWN',
+                message: 'random failure',
+                exitCode: 1,
+            },
+        });
+    });
+    it('converts non-Error values to UNKNOWN envelope', () => {
+        const envelope = toEnvelope('string error');
+        expect(envelope.error.code).toBe('UNKNOWN');
+        expect(envelope.error.message).toBe('string error');
+    });
+});

package/dist/src/execution.d.ts

@@ -11,4 +11,7 @@
  */
 import { type CliCommand, type Arg, type CommandArgs } from './registry.js';
 export declare function coerceAndValidateArgs(cmdArgs: Arg[], kwargs: CommandArgs): CommandArgs;
-export declare function executeCommand(cmd: CliCommand, rawKwargs: CommandArgs, debug?: boolean): Promise<unknown>;
+export declare function executeCommand(cmd: CliCommand, rawKwargs: CommandArgs, debug?: boolean, opts?: {
+    prepared?: boolean;
+}): Promise<unknown>;
+export declare function prepareCommandArgs(cmd: CliCommand, rawKwargs: CommandArgs): CommandArgs;

package/dist/src/execution.js

@@ -9,7 +9,7 @@
  * 5. Lazy-loading of TS modules from manifest
  * 6. Lifecycle hooks (onBeforeExecute / onAfterExecute)
  */
-import { Strategy, getRegistry, fullName } from './registry.js';
+import { getRegistry, fullName } from './registry.js';
 import { pathToFileURL } from 'node:url';
 import { executePipeline } from './pipeline/index.js';
 import { AdapterLoadError, ArgumentError, CommandExecutionError, getErrorMessage } from './errors.js';
@@ -97,9 +97,7 @@ function resolvePreNav(cmd) {
         return null;
     if (typeof cmd.navigateBefore === 'string')
         return cmd.navigateBefore;
-    if ((cmd.strategy === Strategy.COOKIE || cmd.strategy === Strategy.HEADER) && cmd.domain) {
-        return `https://${cmd.domain}`;
-    }
+    // strategy → navigateBefore expansion already happened in normalizeCommand().
     return null;
 }
 function ensureRequiredEnv(cmd) {
@@ -111,11 +109,10 @@ function ensureRequiredEnv(cmd) {
         return;
     throw new CommandExecutionError(`Command ${fullName(cmd)} requires environment variable ${missing.name}.`, missing.help ?? `Set ${missing.name} before running ${fullName(cmd)}.`);
 }
-export async function executeCommand(cmd, rawKwargs, debug = false) {
+export async function executeCommand(cmd, rawKwargs, debug = false, opts = {}) {
     let kwargs;
     try {
-        kwargs = coerceAndValidateArgs(cmd.args, rawKwargs);
-        cmd.validateArgs?.(kwargs);
+        kwargs = opts.prepared ? rawKwargs : prepareCommandArgs(cmd, rawKwargs);
     }
     catch (err) {
         if (err instanceof ArgumentError)
@@ -162,8 +159,7 @@ export async function executeCommand(cmd, rawKwargs, debug = false) {
                         await page.goto(preNavUrl);
                     }
                     catch (err) {
-                        if (debug)
-                            log.debug(`[pre-nav] Failed to navigate to ${preNavUrl}: ${err instanceof Error ? err.message : err}`);
+                        log.warn(`Pre-navigation to ${preNavUrl} failed: ${err instanceof Error ? err.message : err}`);
                     }
                 }
                 try {
@@ -220,3 +216,8 @@ export async function executeCommand(cmd, rawKwargs, debug = false) {
     await emitHook('onAfterExecute', hookCtx, result);
     return result;
 }
+export function prepareCommandArgs(cmd, rawKwargs) {
+    const kwargs = coerceAndValidateArgs(cmd.args, rawKwargs);
+    cmd.validateArgs?.(kwargs);
+    return kwargs;
+}

package/dist/src/execution.test.js

@@ -1,5 +1,5 @@
-import { describe, expect, it } from 'vitest';
-import { executeCommand } from './execution.js';
+import { describe, expect, it, vi } from 'vitest';
+import { executeCommand, prepareCommandArgs } from './execution.js';
 import { TimeoutError } from './errors.js';
 import { cli, Strategy } from './registry.js';
 import { withTimeoutMs } from './runtime.js';
@@ -37,4 +37,20 @@ describe('executeCommand — non-browser timeout', () => {
         // With timeout guard skipped, the sentinel fires instead.
         await expect(withTimeoutMs(executeCommand(cmd, {}), 50, 'sentinel timeout')).rejects.toThrow('sentinel timeout');
     });
+    it('does not re-run custom validation when args are already prepared', async () => {
+        const validateArgs = vi.fn();
+        const cmd = {
+            site: 'test-execution',
+            name: 'prepared-validation',
+            description: 'test prepared validation path',
+            browser: false,
+            strategy: Strategy.PUBLIC,
+            args: [],
+            validateArgs,
+            func: async () => [],
+        };
+        const kwargs = prepareCommandArgs(cmd, {});
+        await executeCommand(cmd, kwargs, false, { prepared: true });
+        expect(validateArgs).toHaveBeenCalledTimes(1);
+    });
 });

package/dist/src/external.js

@@ -4,7 +4,6 @@ import * as os from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { spawnSync, execFileSync } from 'node:child_process';
 import yaml from 'js-yaml';
-import chalk from 'chalk';
 import { log } from './logger.js';
 import { EXIT_CODES, getErrorMessage } from './errors.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -120,26 +119,26 @@ function runInstallCommand(cmd) {
 }
 export function installExternalCli(cli) {
     if (!cli.install) {
-        console.error(chalk.red(`No auto-install command configured for '${cli.name}'.`));
-        console.error(`Please install '${cli.binary}' manually.`);
+        log.error(`No auto-install command configured for '${cli.name}'.`);
+        log.info(`Please install '${cli.binary}' manually.`);
         return false;
     }
     const cmd = getInstallCmd(cli.install);
     if (!cmd) {
-        console.error(chalk.red(`No install command for your platform (${os.platform()}) for '${cli.name}'.`));
+        log.error(`No install command for your platform (${os.platform()}) for '${cli.name}'.`);
         if (cli.homepage)
-            console.error(`See: ${cli.homepage}`);
+            log.info(`See: ${cli.homepage}`);
         return false;
     }
-    console.log(chalk.cyan(`🔹 '${cli.name}' is not installed. Auto-installing...`));
-    console.log(chalk.dim(`$ ${cmd}`));
+    log.info(`'${cli.name}' is not installed. Auto-installing...`);
+    log.verbose(`$ ${cmd}`);
     try {
         runInstallCommand(cmd);
-        console.log(chalk.green(`✅ Installed '${cli.name}' successfully.\n`));
+        log.success(`Installed '${cli.name}' successfully.`);
         return true;
     }
     catch (err) {
-        console.error(chalk.red(`❌ Failed to install '${cli.name}': ${getErrorMessage(err)}`));
+        log.error(`Failed to install '${cli.name}': ${getErrorMessage(err)}`);
         return false;
     }
 }
@@ -161,7 +160,7 @@ export function executeExternalCli(name, args, preloaded) {
     // 3. Passthrough execution with stdio inherited
     const result = spawnSync(cli.binary, args, { stdio: 'inherit' });
     if (result.error) {
-        console.error(chalk.red(`Failed to execute '${cli.binary}': ${result.error.message}`));
+        log.error(`Failed to execute '${cli.binary}': ${result.error.message}`);
         process.exitCode = EXIT_CODES.GENERIC_ERROR;
         return;
     }
@@ -196,14 +195,14 @@ export function registerExternalCli(name, opts) {
         newItem.install = { default: opts.install };
     if (existingIndex >= 0) {
         items[existingIndex] = { ...items[existingIndex], ...newItem };
-        console.log(chalk.green(`Updated '${name}' in user registry.`));
+        log.success(`Updated '${name}' in user registry.`);
     }
     else {
         items.push(newItem);
-        console.log(chalk.green(`Registered '${name}' in user registry.`));
+        log.success(`Registered '${name}' in user registry.`);
     }
     const dump = yaml.dump(items, { indent: 2, sortKeys: true });
     fs.writeFileSync(userPath, dump, 'utf8');
     _cachedExternalClis = null; // Invalidate cache so next load reflects the change
-    console.log(chalk.dim(userPath));
+    log.verbose(userPath);
 }

package/dist/src/generate-verified.js

@@ -239,7 +239,7 @@ async function probeCandidateStrategy(page, endpointUrl) {
     return parseSupportedStrategy(success?.strategy);
 }
 // ── Artifact persistence ──────────────────────────────────────────────────────
-function candidateToTs(candidate) {
+function candidateToJs(candidate) {
     const strategyMap = {
         public: 'Strategy.PUBLIC',
         cookie: 'Strategy.COOKIE',
@@ -250,9 +250,9 @@ function candidateToTs(candidate) {
     const stratEnum = strategyMap[candidate.strategy?.toLowerCase()] ?? 'Strategy.COOKIE';
     const browser = detectBrowserFlag(candidate);
     const argsArray = Object.entries(candidate.args ?? {}).map(([name, def]) => {
-        const parts = [`name: '${name}'`];
+        const parts = [`name: '${name.replace(/'/g, "\\'")}'`];
         if (def.type && def.type !== 'str')
-            parts.push(`type: '${def.type}'`);
+            parts.push(`type: '${def.type.replace(/'/g, "\\'")}'`);
         if (def.required)
             parts.push('required: true');
         if (def.default !== undefined)
@@ -293,12 +293,12 @@ function candidateToTs(candidate) {
     lines.push("import { cli, Strategy } from '@jackwener/opencli/registry';");
     lines.push('');
     lines.push('cli({');
-    lines.push(`  site: '${candidate.site}',`);
-    lines.push(`  name: '${candidate.name}',`);
+    lines.push(`  site: '${candidate.site.replace(/'/g, "\\'")}',`);
+    lines.push(`  name: '${candidate.name.replace(/'/g, "\\'")}',`);
     if (candidate.description)
         lines.push(`  description: '${candidate.description.replace(/'/g, "\\'")}',`);
     if (candidate.domain)
-        lines.push(`  domain: '${candidate.domain}',`);
+        lines.push(`  domain: '${candidate.domain.replace(/'/g, "\\'")}',`);
     lines.push(`  strategy: ${stratEnum},`);
     lines.push(`  browser: ${browser},`);
     if (argsArray.length > 0) {
@@ -320,20 +320,20 @@ function candidateToTs(candidate) {
 }
 async function registerVerifiedAdapter(candidate, metadata) {
     const siteDir = path.join(USER_CLIS_DIR, candidate.site);
-    const adapterPath = path.join(siteDir, `${candidate.name}.ts`);
+    const adapterPath = path.join(siteDir, `${candidate.name}.js`);
     const metadataPath = path.join(siteDir, `${candidate.name}.meta.json`);
     await fs.promises.mkdir(siteDir, { recursive: true });
-    await fs.promises.writeFile(adapterPath, candidateToTs(candidate));
+    await fs.promises.writeFile(adapterPath, candidateToJs(candidate));
     await fs.promises.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
     registerCommand(candidateToCommand(candidate, adapterPath));
     return { adapterPath, metadataPath };
 }
 async function writeVerifiedArtifact(candidate, exploreDir, metadata) {
     const outDir = path.join(exploreDir, 'verified');
-    const adapterPath = path.join(outDir, `${candidate.name}.verified.ts`);
+    const adapterPath = path.join(outDir, `${candidate.name}.verified.js`);
     const metadataPath = path.join(outDir, `${candidate.name}.verified.meta.json`);
     await fs.promises.mkdir(outDir, { recursive: true });
-    await fs.promises.writeFile(adapterPath, candidateToTs(candidate));
+    await fs.promises.writeFile(adapterPath, candidateToJs(candidate));
     await fs.promises.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
     return { adapterPath, metadataPath };
 }

package/dist/src/generate-verified.test.js

@@ -367,7 +367,7 @@ describe('generateVerifiedFromUrl', () => {
             noRegister: true,
         });
         expect(result.status).toBe('success');
-        expect(path.normalize(result.adapter.path).endsWith(path.join('verified', 'search.verified.ts'))).toBe(true);
+        expect(path.normalize(result.adapter.path).endsWith(path.join('verified', 'search.verified.js'))).toBe(true);
         expect(result.adapter?.path).not.toBe(candidatePath);
         expect(path.normalize(result.adapter.metadata_path).endsWith(path.join('verified', 'search.verified.meta.json'))).toBe(true);
         expect(fs.existsSync(result.adapter.path)).toBe(true);

package/dist/src/logger.js

@@ -4,7 +4,7 @@
  * All framework output (warnings, debug info, errors) should go through
  * this module so that verbosity levels are respected consistently.
  */
-import chalk from 'chalk';
+import { styleText } from 'node:util';
 function isVerbose() {
     return !!process.env.OPENCLI_VERBOSE;
 }
@@ -14,42 +14,42 @@ function isDebug() {
 export const log = {
     /** Informational message (always shown) */
     info(msg) {
-        process.stderr.write(`${chalk.blue('ℹ')}  ${msg}\n`);
+        process.stderr.write(`${styleText('blue', 'ℹ')}  ${msg}\n`);
     },
     /** Lightweight status line for adapter progress updates */
     status(msg) {
-        process.stderr.write(`${chalk.dim(msg)}\n`);
+        process.stderr.write(`${styleText('dim', msg)}\n`);
     },
     /** Positive completion/status line without the heavier info prefix */
     success(msg) {
-        process.stderr.write(`${chalk.green(msg)}\n`);
+        process.stderr.write(`${styleText('green', msg)}\n`);
     },
     /** Warning (always shown) */
     warn(msg) {
-        process.stderr.write(`${chalk.yellow('⚠')}  ${msg}\n`);
+        process.stderr.write(`${styleText('yellow', '⚠')}  ${msg}\n`);
     },
     /** Error (always shown) */
     error(msg) {
-        process.stderr.write(`${chalk.red('✖')}  ${msg}\n`);
+        process.stderr.write(`${styleText('red', '✖')}  ${msg}\n`);
     },
     /** Verbose output (only when OPENCLI_VERBOSE is set or -v flag) */
     verbose(msg) {
         if (isVerbose()) {
-            process.stderr.write(`${chalk.dim('[verbose]')} ${msg}\n`);
+            process.stderr.write(`${styleText('dim', '[verbose]')} ${msg}\n`);
         }
     },
     /** Debug output (only when DEBUG includes 'opencli') */
     debug(msg) {
         if (isDebug()) {
-            process.stderr.write(`${chalk.dim('[debug]')} ${msg}\n`);
+            process.stderr.write(`${styleText('dim', '[debug]')} ${msg}\n`);
         }
     },
     /** Step-style debug (for pipeline steps, etc.) */
     step(stepNum, total, op, preview = '') {
-        process.stderr.write(`  ${chalk.dim(`[${stepNum}/${total}]`)} ${chalk.bold.cyan(op)}${preview}\n`);
+        process.stderr.write(`  ${styleText('dim', `[${stepNum}/${total}]`)} ${styleText(['bold', 'cyan'], op)}${preview}\n`);
     },
     /** Step result summary */
     stepResult(summary) {
-        process.stderr.write(`       ${chalk.dim(`→ ${summary}`)}\n`);
+        process.stderr.write(`       ${styleText('dim', `→ ${summary}`)}\n`);
     },
 };

package/dist/src/main.js

@@ -17,12 +17,14 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { getCompletionsFromManifest, hasAllManifests, printCompletionScriptFast } from './completion-fast.js';
-import { getCliManifestPath } from './package-paths.js';
+import { findPackageRoot, getCliManifestPath } from './package-paths.js';
 import { PKG_VERSION } from './version.js';
 import { EXIT_CODES } from './errors.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const BUILTIN_CLIS = path.resolve(__dirname, '..', 'clis');
+// Adapters are JS-first and live at <package-root>/clis/.
+// Use findPackageRoot so the path works both in dev (src/main.ts) and prod (dist/src/main.js).
+const BUILTIN_CLIS = path.join(findPackageRoot(__filename), 'clis');
 const USER_CLIS = path.join(os.homedir(), '.opencli', 'clis');
 // ── Ultra-fast path: lightweight commands bypass full discovery ──────────
 // These are high-frequency or trivial paths that must not pay the startup tax.
@@ -43,14 +45,15 @@ if (argv[0] === 'completion' && argv.length >= 2) {
 // Fast path: --get-completions — read from manifest, skip discovery
 const getCompIdx = process.argv.indexOf('--get-completions');
 if (getCompIdx !== -1) {
-    // Only require manifest for directories that actually exist.
-    // If user clis dir doesn't exist, there are no user adapters to miss.
+    // Only include manifests that actually exist on disk.
+    // With sparse override, the user clis dir may exist but have no manifest.
     const manifestPaths = [getCliManifestPath(BUILTIN_CLIS)];
+    const userManifest = getCliManifestPath(USER_CLIS);
     try {
-        fs.accessSync(USER_CLIS);
-        manifestPaths.push(getCliManifestPath(USER_CLIS));
+        fs.accessSync(userManifest);
+        manifestPaths.push(userManifest);
     }
-    catch { /* no user dir */ }
+    catch { /* no user manifest */ }
     if (hasAllManifests(manifestPaths)) {
         const rest = process.argv.slice(getCompIdx + 1);
         let cursor;
@@ -81,10 +84,20 @@ const { emitHook } = await import('./hooks.js');
 const { installNodeNetwork } = await import('./node-network.js');
 const { registerUpdateNoticeOnExit, checkForUpdateBackground } = await import('./update-check.js');
 installNodeNetwork();
-// Sequential: plugins must run after built-in discovery so they can override built-in commands.
-await ensureUserCliCompatShims();
-await ensureUserAdapters();
-await discoverClis(BUILTIN_CLIS, USER_CLIS);
+// Parallelise independent startup I/O:
+//  - Built-in adapter discovery has no dependency on user-dir setup.
+//  - ensureUserCliCompatShims and ensureUserAdapters operate on different paths
+//    (~/.opencli/node_modules/ vs ~/.opencli/clis/ + adapter-manifest.json).
+//  - registerCommand() overwrites on name collision (see registry.ts), so
+//    user-CLI discovery MUST run after built-in discovery to preserve the
+//    intended override order (user adapters override built-in ones).
+//  - discoverPlugins runs last: plugins may override both built-in and user CLIs.
+const [, ,] = await Promise.all([
+    ensureUserCliCompatShims(),
+    ensureUserAdapters(),
+    discoverClis(BUILTIN_CLIS),
+]);
+await discoverClis(USER_CLIS);
 await discoverPlugins();
 // Register exit hook: notice appears after command output (same as npm/gh/yarn)
 registerUpdateNoticeOnExit();

package/dist/src/output.js

@@ -1,7 +1,7 @@
 /**
  * Output formatting: table, JSON, Markdown, CSV, YAML.
  */
-import chalk from 'chalk';
+import { styleText } from 'node:util';
 import Table from 'cli-table3';
 import yaml from 'js-yaml';
 function normalizeRows(data) {
@@ -55,13 +55,13 @@ export function render(data, opts = {}) {
 function renderTable(data, opts) {
     const rows = normalizeRows(data);
     if (!rows.length) {
-        console.log(chalk.dim('(no data)'));
+        console.log(styleText('dim', '(no data)'));
         return;
     }
     const columns = resolveColumns(rows, opts);
     const header = columns.map(c => capitalize(c));
     const table = new Table({
-        head: header.map(h => chalk.bold(h)),
+        head: header.map(h => styleText('bold', h)),
         style: { head: [], border: [] },
         wordWrap: true,
         wrapOnWordBoundary: true,
@@ -74,7 +74,7 @@ function renderTable(data, opts) {
     }
     console.log();
     if (opts.title)
-        console.log(chalk.dim(`  ${opts.title}`));
+        console.log(styleText('dim', `  ${opts.title}`));
     console.log(table.toString());
     const footer = [];
     footer.push(`${rows.length} items`);
@@ -84,7 +84,7 @@ function renderTable(data, opts) {
         footer.push(opts.source);
     if (opts.footerExtra)
         footer.push(opts.footerExtra);
-    console.log(chalk.dim(footer.join(' · ')));
+    console.log(styleText('dim', footer.join(' · ')));
 }
 function renderJson(data) {
     console.log(JSON.stringify(data, null, 2));

package/dist/src/package-exports.test.js

@@ -14,16 +14,16 @@ import ts from 'typescript';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ROOT = path.resolve(__dirname, '..');
 const CLIS_DIR = path.join(ROOT, 'clis');
-/** Recursively collect all .ts files in a directory. */
-function collectTsFiles(dir, opts) {
+/** Recursively collect all JS adapter files in a directory. */
+function collectAdapterFiles(dir, opts) {
     const results = [];
     for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
         const full = path.join(dir, entry.name);
         if (entry.isDirectory()) {
-            results.push(...collectTsFiles(full, opts));
+            results.push(...collectAdapterFiles(full, opts));
         }
-        else if (entry.name.endsWith('.ts') && !entry.name.endsWith('.d.ts')) {
-            if (opts?.excludeTests && (entry.name.endsWith('.test.ts') || entry.name === 'test-utils.ts'))
+        else if (entry.name.endsWith('.js') && !entry.name.endsWith('.d.js')) {
+            if (opts?.excludeTests && (entry.name.endsWith('.test.js') || entry.name.startsWith('test-')))
                 continue;
             results.push(full);
         }
@@ -53,8 +53,8 @@ const FORBIDDEN_PATTERNS = [
     /(?:from|mock|importActual)\s*\(?['"](?:\.\.\/)+pipeline\//,
 ];
 describe('adapter imports use package exports', () => {
-    const adapterFiles = collectTsFiles(CLIS_DIR);
-    const runtimeAdapterFiles = collectTsFiles(CLIS_DIR, { excludeTests: true });
+    const adapterFiles = collectAdapterFiles(CLIS_DIR);
+    const runtimeAdapterFiles = collectAdapterFiles(CLIS_DIR, { excludeTests: true });
     it('found adapter files to check', () => {
         expect(adapterFiles.length).toBeGreaterThan(100);
     });
@@ -76,7 +76,7 @@ describe('adapter imports use package exports', () => {
         const violations = [];
         for (const file of runtimeAdapterFiles) {
             const source = fs.readFileSync(file, 'utf-8');
-            const module = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+            const module = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
             for (const stmt of module.statements) {
                 if (!ts.isImportDeclaration(stmt) && !ts.isExportDeclaration(stmt))
                     continue;

package/dist/src/pipeline/steps/tap.js

@@ -10,6 +10,7 @@
  */
 import { render } from '../template.js';
 import { generateTapInterceptorJs } from '../../interceptor.js';
+import { CliError } from '../../errors.js';
 export async function stepTap(page, params, data, args) {
     const cfg = typeof params === 'object' && params !== null ? params : {};
     const storeName = String(render(cfg.store ?? '', { args, data }));
@@ -20,7 +21,7 @@ export async function stepTap(page, params, data, args) {
     const framework = cfg.framework ?? null;
     const actionArgs = cfg.args ?? [];
     if (!storeName || !actionName)
-        throw new Error('tap: store and action are required');
+        throw new CliError('TAP_MISSING_PARAMS', 'tap: store and action are required');
     // Build select chain for the captured response
     const selectChain = selectPath
         ? selectPath.split('.').map((p) => `?.[${JSON.stringify(p)}]`).join('')