@jackwener/opencli 1.7.0 → 1.7.2

package/dist/src/completion.js

@@ -7,25 +7,10 @@
  */
 import { getRegistry } from './registry.js';
 import { CliError } from './errors.js';
+import { BUILTIN_COMMANDS, bashCompletionScript, zshCompletionScript, fishCompletionScript, } from './completion-shared.js';
+// Re-export shell scripts so existing callers (cli.ts) don't break
+export { bashCompletionScript, zshCompletionScript, fishCompletionScript };
 // ── Dynamic completion logic ───────────────────────────────────────────────
-/**
- * Built-in (non-dynamic) top-level commands.
- */
-const BUILTIN_COMMANDS = [
-    'list',
-    'validate',
-    'verify',
-    'explore',
-    'probe', // alias for explore
-    'synthesize',
-    'generate',
-    'cascade',
-    'doctor',
-    'plugin',
-    'install',
-    'register',
-    'completion',
-];
 /**
  * Return completion candidates given the current command-line words and cursor index.
  * Requires full CLI discovery to have been run (uses getRegistry()).
@@ -63,44 +48,6 @@ export function getCompletions(words, cursor) {
     return [];
 }
 // ── Shell script generators ────────────────────────────────────────────────
-export function bashCompletionScript() {
-    return `# Bash completion for opencli
-# Add to ~/.bashrc:  eval "$(opencli completion bash)"
-_opencli_completions() {
-  local cur words cword
-  _get_comp_words_by_ref -n : cur words cword
-
-  local completions
-  completions=$(opencli --get-completions --cursor "$cword" "\${words[@]:1}" 2>/dev/null)
-
-  COMPREPLY=( $(compgen -W "$completions" -- "$cur") )
-  __ltrim_colon_completions "$cur"
-}
-complete -F _opencli_completions opencli
-`;
-}
-export function zshCompletionScript() {
-    return `# Zsh completion for opencli
-# Add to ~/.zshrc:  eval "$(opencli completion zsh)"
-_opencli() {
-  local -a completions
-  local cword=$((CURRENT - 1))
-  completions=(\${(f)"$(opencli --get-completions --cursor "$cword" "\${words[@]:1}" 2>/dev/null)"})
-  compadd -a completions
-}
-compdef _opencli opencli
-`;
-}
-export function fishCompletionScript() {
-    return `# Fish completion for opencli
-# Add to ~/.config/fish/config.fish:  opencli completion fish | source
-complete -c opencli -f -a '(
-  set -l tokens (commandline -cop)
-  set -l cursor (count (commandline -cop))
-  opencli --get-completions --cursor $cursor $tokens[2..] 2>/dev/null
-)'
-`;
-}
 /**
  * Print the completion script for the requested shell.
  */

package/dist/src/daemon.js

@@ -22,6 +22,7 @@ import { createServer } from 'node:http';
 import { WebSocketServer, WebSocket } from 'ws';
 import { DEFAULT_DAEMON_PORT } from './constants.js';
 import { EXIT_CODES } from './errors.js';
+import { log } from './logger.js';
 const PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
 // ─── State ───────────────────────────────────────────────────────────
 let extensionWs = null;
@@ -184,7 +185,7 @@ const wss = new WebSocketServer({
     },
 });
 wss.on('connection', (ws) => {
-    console.error('[daemon] Extension connected');
+    log.info('[daemon] Extension connected');
     extensionWs = ws;
     extensionVersion = null; // cleared until hello message arrives
     // ── Heartbeat: ping every 15s, close if 2 pongs missed ──
@@ -195,7 +196,7 @@ wss.on('connection', (ws) => {
             return;
         }
         if (missedPongs >= 2) {
-            console.error('[daemon] Extension heartbeat lost, closing connection');
+            log.warn('[daemon] Extension heartbeat lost, closing connection');
             clearInterval(heartbeatInterval);
             ws.terminate();
             return;
@@ -216,8 +217,12 @@ wss.on('connection', (ws) => {
             }
             // Handle log messages from extension
             if (msg.type === 'log') {
-                const prefix = msg.level === 'error' ? '❌' : msg.level === 'warn' ? '⚠️' : '📋';
-                console.error(`${prefix} [ext] ${msg.msg}`);
+                if (msg.level === 'error')
+                    log.error(`[ext] ${msg.msg}`);
+                else if (msg.level === 'warn')
+                    log.warn(`[ext] ${msg.msg}`);
+                else
+                    log.info(`[ext] ${msg.msg}`);
                 pushLog({ level: msg.level, msg: msg.msg, ts: msg.ts ?? Date.now() });
                 return;
             }
@@ -234,7 +239,7 @@ wss.on('connection', (ws) => {
         }
     });
     ws.on('close', () => {
-        console.error('[daemon] Extension disconnected');
+        log.info('[daemon] Extension disconnected');
         clearInterval(heartbeatInterval);
         if (extensionWs === ws) {
             extensionWs = null;
@@ -263,14 +268,14 @@ wss.on('connection', (ws) => {
 });
 // ─── Start ───────────────────────────────────────────────────────────
 httpServer.listen(PORT, '127.0.0.1', () => {
-    console.error(`[daemon] Listening on http://127.0.0.1:${PORT}`);
+    log.info(`[daemon] Listening on http://127.0.0.1:${PORT}`);
 });
 httpServer.on('error', (err) => {
     if (err.code === 'EADDRINUSE') {
-        console.error(`[daemon] Port ${PORT} already in use — another daemon is likely running. Exiting.`);
+        log.error(`[daemon] Port ${PORT} already in use — another daemon is likely running. Exiting.`);
         process.exit(EXIT_CODES.SERVICE_UNAVAIL);
     }
-    console.error('[daemon] Server error:', err.message);
+    log.error(`[daemon] Server error: ${err.message}`);
     process.exit(EXIT_CODES.GENERIC_ERROR);
 });
 // Graceful shutdown

package/dist/src/diagnostic.d.ts

@@ -47,10 +47,9 @@ export declare function redactText(text: string): string;
  * Resolve the editable source file path for an adapter.
  *
  * Priority:
- * 1. cmd.source (set for FS-scanned YAML/TS and manifest lazy-loaded TS)
- * 2. cmd._modulePath (set for manifest lazy-loaded TS, points to dist/)
+ * 1. cmd.source (set for FS-scanned JS and manifest lazy-loaded JS)
+ * 2. cmd._modulePath (set for manifest lazy-loaded JS)
  *
- * For dist/ paths, attempt to map back to the original .ts source file.
  * Skip manifest: prefixed pseudo-paths (YAML commands inlined in manifest).
  */
 export declare function resolveAdapterSourcePath(cmd: InternalCliCommand): string | undefined;

package/dist/src/diagnostic.js

@@ -12,7 +12,6 @@
  * - Total output is capped to MAX_DIAGNOSTIC_BYTES
  */
 import * as fs from 'node:fs';
-import * as path from 'node:path';
 import { CliError, getErrorMessage } from './errors.js';
 import { fullName } from './registry.js';
 // ── Size budgets ─────────────────────────────────────────────────────────────
@@ -141,9 +140,9 @@ function redactNetworkRequest(req) {
     if (redacted.responseHeaders && typeof redacted.responseHeaders === 'object') {
         redacted.responseHeaders = redactHeaders(redacted.responseHeaders);
     }
-    // Truncate response body
+    // Redact and truncate response body
     if (typeof redacted.body === 'string') {
-        redacted.body = truncate(redacted.body, MAX_REQUEST_BODY_CHARS);
+        redacted.body = redactText(truncate(redacted.body, MAX_REQUEST_BODY_CHARS));
     }
     if ('responseBody' in redacted) {
         redacted.responseBody = sanitizeCapturedValue(redacted.responseBody);
@@ -167,10 +166,9 @@ function withTimeout(promise, ms, fallback) {
  * Resolve the editable source file path for an adapter.
  *
  * Priority:
- * 1. cmd.source (set for FS-scanned YAML/TS and manifest lazy-loaded TS)
- * 2. cmd._modulePath (set for manifest lazy-loaded TS, points to dist/)
+ * 1. cmd.source (set for FS-scanned JS and manifest lazy-loaded JS)
+ * 2. cmd._modulePath (set for manifest lazy-loaded JS)
  *
- * For dist/ paths, attempt to map back to the original .ts source file.
  * Skip manifest: prefixed pseudo-paths (YAML commands inlined in manifest).
  */
 export function resolveAdapterSourcePath(cmd) {
@@ -183,26 +181,11 @@ export function resolveAdapterSourcePath(cmd) {
         candidates.push(cmd._modulePath);
     }
     for (const candidate of candidates) {
-        // Try to map dist/ compiled JS back to source .ts
-        const sourceTs = mapDistToSource(candidate);
-        if (sourceTs && fs.existsSync(sourceTs))
-            return sourceTs;
-        // Try the candidate directly (YAML files, user clis, etc.)
         if (fs.existsSync(candidate))
             return candidate;
     }
     return candidates[0]; // Return best guess even if file doesn't exist
 }
-/** Map a dist/clis/xxx.js path back to clis/xxx.ts source. */
-function mapDistToSource(filePath) {
-    // dist/clis/site/command.js → clis/site/command.ts
-    const normalized = filePath.replace(/\\/g, '/');
-    const distClisMatch = normalized.match(/^(.*)\/dist\/clis\/(.+)\.js$/);
-    if (distClisMatch) {
-        return path.join(distClisMatch[1], 'clis', distClisMatch[2] + '.ts');
-    }
-    return null;
-}
 // ── Diagnostic collection ────────────────────────────────────────────────────
 /** Whether diagnostic mode is enabled. */
 export function isDiagnosticEnabled() {

package/dist/src/diagnostic.test.js

@@ -83,12 +83,12 @@ describe('redactText', () => {
 });
 describe('resolveAdapterSourcePath', () => {
     it('returns source when it is a real file path (not manifest:)', () => {
-        const cmd = makeCmd({ source: '/home/user/.opencli/clis/arxiv/search.ts' });
-        expect(resolveAdapterSourcePath(cmd)).toBe('/home/user/.opencli/clis/arxiv/search.ts');
+        const cmd = makeCmd({ source: '/home/user/.opencli/clis/arxiv/search.js' });
+        expect(resolveAdapterSourcePath(cmd)).toBe('/home/user/.opencli/clis/arxiv/search.js');
     });
     it('skips manifest: pseudo-paths and falls back to _modulePath', () => {
-        const cmd = makeCmd({ source: 'manifest:arxiv/search', _modulePath: '/pkg/dist/clis/arxiv/search.js' });
-        // Should try to map dist→source, but since files don't exist on disk, returns _modulePath
+        const cmd = makeCmd({ source: 'manifest:arxiv/search', _modulePath: '/pkg/clis/arxiv/search.js' });
+        // Should try to map to source, but since files don't exist on disk, returns _modulePath
         const result = resolveAdapterSourcePath(cmd);
         expect(result).toBeDefined();
         expect(result).not.toContain('manifest:');
@@ -97,12 +97,11 @@ describe('resolveAdapterSourcePath', () => {
         const cmd = makeCmd({ source: 'manifest:test/cmd' });
         expect(resolveAdapterSourcePath(cmd)).toBeUndefined();
     });
-    it('prefers _modulePath mapped to .ts over dist .js', () => {
-        // This test verifies the mapping logic without requiring files on disk
-        const cmd = makeCmd({ _modulePath: '/project/dist/clis/site/cmd.js' });
+    it('returns _modulePath when it is the only path available', () => {
+        const cmd = makeCmd({ _modulePath: '/project/clis/site/cmd.js' });
         const result = resolveAdapterSourcePath(cmd);
-        // Since neither .ts nor .js exists, returns _modulePath as best guess
-        expect(result).toBe('/project/dist/clis/site/cmd.js');
+        // Since file doesn't exist, returns _modulePath as best guess
+        expect(result).toBe('/project/clis/site/cmd.js');
     });
 });
 describe('buildRepairContext', () => {

package/dist/src/discovery.d.ts

@@ -1,9 +1,9 @@
 /**
- * CLI discovery: finds TS CLI definitions and registers them.
+ * CLI discovery: finds JS CLI definitions and registers them.
  *
  * Supports two modes:
  * 1. FAST PATH (manifest): If a pre-compiled cli-manifest.json exists,
- *    registers commands instantly. TS modules are loaded lazily only
+ *    registers commands instantly. JS modules are loaded lazily only
  *    when their command is executed.
  * 2. FALLBACK (filesystem scan): Traditional runtime discovery for development.
  */
@@ -23,8 +23,11 @@ export declare const PLUGINS_DIR: string;
  */
 export declare function ensureUserCliCompatShims(baseDir?: string): Promise<void>;
 /**
- * First-run fallback: if postinstall was skipped (--ignore-scripts) or failed,
- * trigger adapter fetch on first CLI invocation when ~/.opencli/clis/ is empty.
+ * Ensure the user adapters directory exists.
+ *
+ * With smart sync, ~/.opencli/clis/ only holds files that differ from the
+ * package baseline (upstream-synced cache + autofix output + user overrides).
+ * Built-in adapters are loaded directly from the installed package.
  */
 export declare function ensureUserAdapters(): Promise<void>;
 /**

package/dist/src/discovery.js

@@ -1,9 +1,9 @@
 /**
- * CLI discovery: finds TS CLI definitions and registers them.
+ * CLI discovery: finds JS CLI definitions and registers them.
  *
  * Supports two modes:
  * 1. FAST PATH (manifest): If a pre-compiled cli-manifest.json exists,
- *    registers commands instantly. TS modules are loaded lazily only
+ *    registers commands instantly. JS modules are loaded lazily only
  *    when their command is executed.
  * 2. FALLBACK (filesystem scan): Traditional runtime discovery for development.
  */
@@ -14,7 +14,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { Strategy, registerCommand } from './registry.js';
 import { getErrorMessage } from './errors.js';
 import { log } from './logger.js';
-import { findPackageRoot, getCliManifestPath, getFetchAdaptersScriptPath } from './package-paths.js';
+import { findPackageRoot, getCliManifestPath } from './package-paths.js';
 /** User runtime directory: ~/.opencli */
 export const USER_OPENCLI_DIR = path.join(os.homedir(), '.opencli');
 /** User CLIs directory: ~/.opencli/clis */
@@ -77,43 +77,15 @@ export async function ensureUserCliCompatShims(baseDir = USER_OPENCLI_DIR) {
         log.warn(`Could not create symlink at ${symlinkPath}: ${getErrorMessage(err)}`);
     }
 }
-const ADAPTER_MANIFEST_PATH = path.join(USER_OPENCLI_DIR, 'adapter-manifest.json');
 /**
- * First-run fallback: if postinstall was skipped (--ignore-scripts) or failed,
- * trigger adapter fetch on first CLI invocation when ~/.opencli/clis/ is empty.
+ * Ensure the user adapters directory exists.
+ *
+ * With smart sync, ~/.opencli/clis/ only holds files that differ from the
+ * package baseline (upstream-synced cache + autofix output + user overrides).
+ * Built-in adapters are loaded directly from the installed package.
  */
 export async function ensureUserAdapters() {
-    // If adapter manifest already exists, adapters were fetched — nothing to do
-    try {
-        await fs.promises.access(ADAPTER_MANIFEST_PATH);
-        return;
-    }
-    catch {
-        // No manifest — first run or postinstall was skipped
-    }
-    // Check if clis dir has any content (could be manually populated)
-    try {
-        const entries = await fs.promises.readdir(USER_CLIS_DIR);
-        if (entries.length > 0)
-            return;
-    }
-    catch {
-        // Dir doesn't exist — needs fetch
-    }
-    log.info('First run detected — copying adapters (one-time setup)...');
-    try {
-        const { execFileSync } = await import('node:child_process');
-        const scriptPath = getFetchAdaptersScriptPath(PACKAGE_ROOT);
-        execFileSync(process.execPath, [scriptPath], {
-            stdio: 'inherit',
-            env: { ...process.env, _OPENCLI_FIRST_RUN: '1' },
-            timeout: 120_000,
-        });
-    }
-    catch (err) {
-        log.warn(`Could not fetch adapters on first run: ${getErrorMessage(err)}`);
-        log.warn('Built-in adapters from the package will be used.');
-    }
+    await fs.promises.mkdir(USER_CLIS_DIR, { recursive: true });
 }
 /**
  * Discover and register CLI commands.
@@ -146,7 +118,6 @@ async function loadFromManifest(manifestPath, clisDir) {
         for (const entry of manifest) {
             if (!entry.modulePath)
                 continue;
-            const strategy = parseStrategy(entry.strategy ?? 'cookie');
             const modulePath = path.resolve(clisDir, entry.modulePath);
             const cmd = {
                 site: entry.site,
@@ -154,8 +125,8 @@ async function loadFromManifest(manifestPath, clisDir) {
                 aliases: entry.aliases,
                 description: entry.description ?? '',
                 domain: entry.domain,
-                strategy,
-                browser: entry.browser ?? true,
+                strategy: parseStrategy(entry.strategy),
+                browser: entry.browser,
                 args: entry.args ?? [],
                 columns: entry.columns,
                 pipeline: entry.pipeline,
@@ -167,6 +138,7 @@ async function loadFromManifest(manifestPath, clisDir) {
                 _lazy: true,
                 _modulePath: modulePath,
             };
+            // normalizeCommand inside registerCommand handles strategy → browser/navigateBefore
             registerCommand(cmd);
         }
         return true;
@@ -196,11 +168,14 @@ async function discoverClisFromFs(dir) {
         await Promise.all(files.map(async (file) => {
             const filePath = path.join(siteDir, file);
             if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-                log.warn(`Ignoring YAML adapter ${filePath} — YAML format is no longer supported. Convert to TypeScript using cli() from '@jackwener/opencli/registry'.`);
+                log.warn(`Ignoring YAML adapter ${filePath} — YAML format is no longer supported. Convert to JavaScript using cli() from '@jackwener/opencli/registry'.`);
+                return;
+            }
+            if (file.endsWith('.ts') && !file.endsWith('.d.ts') && !file.endsWith('.test.ts')) {
+                log.warn(`Ignoring TypeScript adapter ${filePath} — .ts adapters are no longer loaded. Rename to .js or convert to JavaScript.`);
                 return;
             }
-            if ((file.endsWith('.js') && !file.endsWith('.d.js')) ||
-                (file.endsWith('.ts') && !file.endsWith('.d.ts') && !file.endsWith('.test.ts'))) {
+            if (file.endsWith('.js') && !file.endsWith('.d.js') && !file.endsWith('.test.js')) {
                 if (!(await isCliModule(filePath)))
                     return;
                 await import(pathToFileURL(filePath).href).catch((err) => {
@@ -241,7 +216,7 @@ async function discoverPluginDir(dir, site) {
     await Promise.all(files.map(async (file) => {
         const filePath = path.join(dir, file);
         if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-            log.warn(`Ignoring YAML plugin ${filePath} — YAML format is no longer supported. Convert to TypeScript using cli() from '@jackwener/opencli/registry'.`);
+            log.warn(`Ignoring YAML plugin ${filePath} — YAML format is no longer supported. Convert to JavaScript using cli() from '@jackwener/opencli/registry'.`);
             return;
         }
         if (file.endsWith('.js') && !file.endsWith('.d.js')) {

package/dist/src/doctor.js

@@ -3,7 +3,7 @@
  *
  * Simplified for the daemon-based architecture.
  */
-import chalk from 'chalk';
+import { styleText } from 'node:util';
 import { DEFAULT_DAEMON_PORT } from './constants.js';
 import { BrowserBridge } from './browser/index.js';
 import { getDaemonHealth, listSessions } from './browser/daemon-client.js';
@@ -101,54 +101,54 @@ export async function runBrowserDoctor(opts = {}) {
     };
 }
 export function renderBrowserDoctorReport(report) {
-    const lines = [chalk.bold(`opencli v${report.cliVersion ?? 'unknown'} doctor`) + chalk.dim(` (${getRuntimeLabel()})`), ''];
+    const lines = [styleText('bold', `opencli v${report.cliVersion ?? 'unknown'} doctor`) + styleText('dim', ` (${getRuntimeLabel()})`), ''];
     // Daemon status
     const daemonIcon = report.daemonFlaky
-        ? chalk.yellow('[WARN]')
-        : report.daemonRunning ? chalk.green('[OK]') : chalk.red('[MISSING]');
+        ? styleText('yellow', '[WARN]')
+        : report.daemonRunning ? styleText('green', '[OK]') : styleText('red', '[MISSING]');
     const daemonLabel = report.daemonFlaky
         ? 'unstable (running during live check, then stopped)'
         : report.daemonRunning ? `running on port ${DEFAULT_DAEMON_PORT}` : 'not running';
     lines.push(`${daemonIcon} Daemon: ${daemonLabel}`);
     // Extension status
     const extIcon = report.extensionFlaky
-        ? chalk.yellow('[WARN]')
-        : report.extensionConnected ? chalk.green('[OK]') : chalk.yellow('[MISSING]');
-    const extVersion = report.extensionVersion ? chalk.dim(` (v${report.extensionVersion})`) : '';
+        ? styleText('yellow', '[WARN]')
+        : report.extensionConnected ? styleText('green', '[OK]') : styleText('yellow', '[MISSING]');
+    const extVersion = report.extensionVersion ? styleText('dim', ` (v${report.extensionVersion})`) : '';
     const extLabel = report.extensionFlaky
         ? 'unstable (connected during live check, then disconnected)'
         : report.extensionConnected ? 'connected' : 'not connected';
     lines.push(`${extIcon} Extension: ${extLabel}${extVersion}`);
     // Connectivity
     if (report.connectivity) {
-        const connIcon = report.connectivity.ok ? chalk.green('[OK]') : chalk.red('[FAIL]');
+        const connIcon = report.connectivity.ok ? styleText('green', '[OK]') : styleText('red', '[FAIL]');
         const detail = report.connectivity.ok
             ? `connected in ${(report.connectivity.durationMs / 1000).toFixed(1)}s`
             : `failed (${report.connectivity.error ?? 'unknown'})`;
         lines.push(`${connIcon} Connectivity: ${detail}`);
     }
     else {
-        lines.push(`${chalk.dim('[SKIP]')} Connectivity: skipped (--no-live)`);
+        lines.push(`${styleText('dim', '[SKIP]')} Connectivity: skipped (--no-live)`);
     }
     if (report.sessions) {
-        lines.push('', chalk.bold('Sessions:'));
+        lines.push('', styleText('bold', 'Sessions:'));
         if (report.sessions.length === 0) {
-            lines.push(chalk.dim('  • no active automation sessions'));
+            lines.push(styleText('dim', '  • no active automation sessions'));
         }
         else {
             for (const session of report.sessions) {
-                lines.push(chalk.dim(`  • ${session.workspace} → window ${session.windowId}, tabs=${session.tabCount}, idle=${Math.ceil(session.idleMsRemaining / 1000)}s`));
+                lines.push(styleText('dim', `  • ${session.workspace} → window ${session.windowId}, tabs=${session.tabCount}, idle=${Math.ceil(session.idleMsRemaining / 1000)}s`));
             }
         }
     }
     if (report.issues.length) {
-        lines.push('', chalk.yellow('Issues:'));
+        lines.push('', styleText('yellow', 'Issues:'));
         for (const issue of report.issues) {
-            lines.push(chalk.dim(`  • ${issue}`));
+            lines.push(styleText('dim', `  • ${issue}`));
         }
     }
     else if (report.daemonRunning && report.extensionConnected) {
-        lines.push('', chalk.green('Everything looks good!'));
+        lines.push('', styleText('green', 'Everything looks good!'));
     }
     return lines.join('\n');
 }

package/dist/src/download/index.js

@@ -11,6 +11,7 @@ import { URL } from 'node:url';
 import { isBinaryInstalled } from '../external.js';
 import { getErrorMessage } from '../errors.js';
 import { fetchWithNodeNetwork } from '../node-network.js';
+import { log } from '../logger.js';
 /** Check if yt-dlp is available in PATH. */
 export function checkYtdlp() {
     return isBinaryInstalled('yt-dlp');
@@ -206,7 +207,7 @@ export async function ytdlpDownload(url, destPath, options = {}) {
                 args.push('--cookies', cookiesFile);
             }
             else {
-                console.error(`[download] Cookies file not found: ${cookiesFile}, falling back to browser cookies`);
+                log.warn(`[download] Cookies file not found: ${cookiesFile}, falling back to browser cookies`);
                 args.push('--cookies-from-browser', 'chrome');
             }
         }

package/dist/src/download/progress.js

@@ -1,7 +1,7 @@
 /**
  * Download progress display: terminal progress bars, status updates.
  */
-import chalk from 'chalk';
+import { styleText } from 'node:util';
 /**
  * Format bytes as human-readable string (KB, MB, GB).
  */
@@ -35,7 +35,7 @@ export function formatDuration(ms) {
  * Create a simple progress bar for terminal display.
  */
 export function createProgressBar(filename, index, total) {
-    const prefix = chalk.dim(`[${index + 1}/${total}]`);
+    const prefix = styleText('dim', `[${index + 1}/${total}]`);
     const truncatedName = filename.length > 40 ? filename.slice(0, 37) + '...' : filename;
     return {
         update(current, totalBytes, label) {
@@ -46,12 +46,12 @@ export function createProgressBar(filename, index, total) {
             process.stderr.write(`\r${prefix} ${truncatedName} ${bar} ${percent}% ${size}${extra}`);
         },
         complete(success, message) {
-            const icon = success ? chalk.green('✓') : chalk.red('✗');
-            const msg = message ? ` ${chalk.dim(message)}` : '';
+            const icon = success ? styleText('green', '✓') : styleText('red', '✗');
+            const msg = message ? ` ${styleText('dim', message)}` : '';
             process.stderr.write(`\r${prefix} ${icon} ${truncatedName}${msg}\n`);
         },
         fail(error) {
-            process.stderr.write(`\r${prefix} ${chalk.red('✗')} ${truncatedName} ${chalk.red(error)}\n`);
+            process.stderr.write(`\r${prefix} ${styleText('red', '✗')} ${truncatedName} ${styleText('red', error)}\n`);
         },
     };
 }
@@ -61,7 +61,7 @@ export function createProgressBar(filename, index, total) {
 function createBar(percent, width = 20) {
     const filled = Math.round((percent / 100) * width);
     const empty = width - filled;
-    return chalk.cyan('█'.repeat(filled)) + chalk.dim('░'.repeat(empty));
+    return styleText('cyan', '█'.repeat(filled)) + styleText('dim', '░'.repeat(empty));
 }
 /**
  * Multi-file download progress tracker.
@@ -98,19 +98,19 @@ export class DownloadProgressTracker {
         const elapsed = formatDuration(Date.now() - this.startTime);
         const parts = [];
         if (this.completed > 0) {
-            parts.push(chalk.green(`${this.completed} downloaded`));
+            parts.push(styleText('green', `${this.completed} downloaded`));
         }
         if (this.skipped > 0) {
-            parts.push(chalk.yellow(`${this.skipped} skipped`));
+            parts.push(styleText('yellow', `${this.skipped} skipped`));
         }
         if (this.failed > 0) {
-            parts.push(chalk.red(`${this.failed} failed`));
+            parts.push(styleText('red', `${this.failed} failed`));
         }
         return `${parts.join(', ')} in ${elapsed}`;
     }
     finish() {
         if (this.verbose) {
-            process.stderr.write(`\n${chalk.bold('Download complete:')} ${this.getSummary()}\n`);
+            process.stderr.write(`\n${styleText('bold', 'Download complete:')} ${this.getSummary()}\n`);
         }
     }
 }

package/dist/src/engine.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { discoverClis, discoverPlugins, ensureUserCliCompatShims, PLUGINS_DIR } from './discovery.js';
+import { discoverClis, discoverPlugins, ensureUserCliCompatShims, ensureUserAdapters, PLUGINS_DIR } from './discovery.js';
 import { executeCommand } from './execution.js';
 import { getRegistry, cli, Strategy } from './registry.js';
 import { clearAllHooks, onAfterExecute } from './hooks.js';
@@ -15,8 +15,8 @@ describe('discoverClis', () => {
     it('imports only CLI command modules during filesystem discovery', async () => {
         const tempRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-discovery-'));
         const siteDir = path.join(tempRoot, 'temp-site');
-        const helperPath = path.join(siteDir, 'helper.ts');
-        const commandPath = path.join(siteDir, 'hello.ts');
+        const helperPath = path.join(siteDir, 'helper.js');
+        const commandPath = path.join(siteDir, 'hello.js');
         try {
             await fs.promises.mkdir(siteDir, { recursive: true });
             await fs.promises.writeFile(helperPath, `
@@ -48,7 +48,7 @@ cli({
         const tempBuildRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-manifest-fallback-'));
         const distDir = path.join(tempBuildRoot, 'dist');
         const siteDir = path.join(distDir, 'fallback-site');
-        const commandPath = path.join(siteDir, 'hello.ts');
+        const commandPath = path.join(siteDir, 'hello.js');
         const manifestPath = path.join(tempBuildRoot, 'cli-manifest.json');
         try {
             await fs.promises.mkdir(siteDir, { recursive: true });
@@ -75,7 +75,7 @@ cli({
         const tempOpencliRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-user-clis-'));
         const userClisDir = path.join(tempOpencliRoot, 'clis');
         const siteDir = path.join(userClisDir, 'legacy-site');
-        const commandPath = path.join(siteDir, 'hello.ts');
+        const commandPath = path.join(siteDir, 'hello.js');
         try {
             await ensureUserCliCompatShims(tempOpencliRoot);
             await fs.promises.mkdir(siteDir, { recursive: true });
@@ -103,6 +103,34 @@ cli({
         }
     });
 });
+describe('ensureUserAdapters', () => {
+    it('creates user clis directory without triggering full copy', async () => {
+        const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-ensure-'));
+        const clisDir = path.join(tempDir, 'clis');
+        try {
+            // Patch USER_CLIS_DIR is not easy, so we test the function behavior indirectly:
+            // ensureUserAdapters should not throw and should be very fast (no fetch script)
+            const start = Date.now();
+            await ensureUserAdapters();
+            const elapsed = Date.now() - start;
+            // Should complete quickly (< 1s) since it only creates a directory
+            expect(elapsed).toBeLessThan(1000);
+        }
+        finally {
+            await fs.promises.rm(tempDir, { recursive: true, force: true });
+        }
+    });
+    it('discoverClis handles empty user directory gracefully', async () => {
+        const emptyDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-empty-'));
+        try {
+            // Should not throw for an empty directory (no adapters to discover)
+            await expect(discoverClis(emptyDir)).resolves.not.toThrow();
+        }
+        finally {
+            await fs.promises.rm(emptyDir, { recursive: true, force: true });
+        }
+    });
+});
 describe('discoverPlugins', () => {
     const testPluginDir = path.join(PLUGINS_DIR, '__test-plugin__');
     const yamlPath = path.join(testPluginDir, 'greeting.yaml');