@jackwener/opencli 1.7.2 → 1.7.3

package/dist/src/daemon.js

@@ -27,6 +27,7 @@ const PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_P
 // ─── State ───────────────────────────────────────────────────────────
 let extensionWs = null;
 let extensionVersion = null;
+let extensionCompatRange = null;
 const pending = new Map();
 const LOG_BUFFER_SIZE = 200;
 const logBuffer = [];
@@ -111,6 +112,7 @@ async function handleRequest(req, res) {
             uptime,
             extensionConnected: extensionWs?.readyState === WebSocket.OPEN,
             extensionVersion,
+            extensionCompatRange,
             pending: pending.size,
             memoryMB: Math.round(mem.rss / 1024 / 1024 * 10) / 10,
             port: PORT,
@@ -188,6 +190,7 @@ wss.on('connection', (ws) => {
     log.info('[daemon] Extension connected');
     extensionWs = ws;
     extensionVersion = null; // cleared until hello message arrives
+    extensionCompatRange = null;
     // ── Heartbeat: ping every 15s, close if 2 pongs missed ──
     let missedPongs = 0;
     const heartbeatInterval = setInterval(() => {
@@ -213,6 +216,7 @@ wss.on('connection', (ws) => {
             // Handle hello message from extension (version handshake)
             if (msg.type === 'hello') {
                 extensionVersion = typeof msg.version === 'string' ? msg.version : null;
+                extensionCompatRange = typeof msg.compatRange === 'string' ? msg.compatRange : null;
                 return;
             }
             // Handle log messages from extension
@@ -244,6 +248,7 @@ wss.on('connection', (ws) => {
         if (extensionWs === ws) {
             extensionWs = null;
             extensionVersion = null;
+            extensionCompatRange = null;
             // Reject all pending requests since the extension is gone
             for (const [id, p] of pending) {
                 clearTimeout(p.timer);

package/dist/src/doctor.d.ts

@@ -21,6 +21,7 @@ export type DoctorReport = {
     extensionConnected: boolean;
     extensionFlaky?: boolean;
     extensionVersion?: string;
+    latestExtensionVersion?: string;
     connectivity?: ConnectivityResult;
     sessions?: Array<{
         workspace: string;

package/dist/src/doctor.js

@@ -9,7 +9,37 @@ import { BrowserBridge } from './browser/index.js';
 import { getDaemonHealth, listSessions } from './browser/daemon-client.js';
 import { getErrorMessage } from './errors.js';
 import { getRuntimeLabel } from './runtime-detect.js';
+import { getCachedLatestExtensionVersion } from './update-check.js';
 const DOCTOR_LIVE_TIMEOUT_SECONDS = 8;
+/** Parse a semver string into [major, minor, patch]. Returns null on invalid input. */
+function parseSemver(v) {
+    const parts = v.replace(/^v/, '').split('-')[0].split('.').map(Number);
+    if (parts.length < 3 || parts.some(isNaN))
+        return null;
+    return [parts[0], parts[1], parts[2]];
+}
+/** Returns true if `a` is strictly newer than `b`. */
+function isNewerVersion(a, b) {
+    const va = parseSemver(a);
+    const vb = parseSemver(b);
+    if (!va || !vb)
+        return false;
+    const cmp = va[0] - vb[0] || va[1] - vb[1] || va[2] - vb[2];
+    return cmp > 0;
+}
+/** Check if version satisfies a simple range like ">=1.7.0". */
+function satisfiesRange(version, range) {
+    const match = range.match(/^(>=?)\s*(\S+)$/);
+    if (!match)
+        return true; // Unknown range format — don't block
+    const [, op, rangeVer] = match;
+    const v = parseSemver(version);
+    const r = parseSemver(rangeVer);
+    if (!v || !r)
+        return true;
+    const cmp = v[0] - r[0] || v[1] - r[1] || v[2] - r[2];
+    return op === '>=' ? cmp >= 0 : cmp > 0;
+}
 /**
  * Test connectivity by attempting a real browser command.
  */
@@ -80,7 +110,16 @@ export async function runBrowserDoctor(opts = {}) {
         issues.push(`Browser connectivity test failed: ${connectivity.error ?? 'unknown'}`);
     }
     const extensionVersion = health.status?.extensionVersion;
-    if (extensionVersion && opts.cliVersion) {
+    const extensionCompatRange = health.status?.extensionCompatRange;
+    if (extensionVersion && opts.cliVersion && extensionCompatRange) {
+        if (!satisfiesRange(opts.cliVersion, extensionCompatRange)) {
+            issues.push(`CLI version incompatible with extension: extension v${extensionVersion} requires CLI ${extensionCompatRange}, but CLI is v${opts.cliVersion}\n` +
+                '  Update the CLI: npm install -g @jackwener/opencli\n' +
+                '  Or download a compatible extension from: https://github.com/jackwener/opencli/releases');
+        }
+    }
+    else if (extensionVersion && opts.cliVersion) {
+        // Fallback for older extensions that don't send compatRange
         const extMajor = extensionVersion.split('.')[0];
         const cliMajor = opts.cliVersion.split('.')[0];
         if (extMajor !== cliMajor) {
@@ -88,6 +127,12 @@ export async function runBrowserDoctor(opts = {}) {
                 '  Download the latest extension from: https://github.com/jackwener/opencli/releases');
         }
     }
+    // Extension update check (from cached background fetch)
+    const latestExtensionVersion = getCachedLatestExtensionVersion();
+    if (extensionVersion && latestExtensionVersion && isNewerVersion(latestExtensionVersion, extensionVersion)) {
+        issues.push(`Extension update available: v${extensionVersion} → v${latestExtensionVersion}\n` +
+            '  Download from: https://github.com/jackwener/opencli/releases');
+    }
     return {
         cliVersion: opts.cliVersion,
         daemonRunning,
@@ -95,6 +140,7 @@ export async function runBrowserDoctor(opts = {}) {
         extensionConnected,
         extensionFlaky,
         extensionVersion,
+        latestExtensionVersion,
         connectivity,
         sessions,
         issues,
@@ -114,7 +160,10 @@ export function renderBrowserDoctorReport(report) {
     const extIcon = report.extensionFlaky
         ? styleText('yellow', '[WARN]')
         : report.extensionConnected ? styleText('green', '[OK]') : styleText('yellow', '[MISSING]');
-    const extVersion = report.extensionVersion ? styleText('dim', ` (v${report.extensionVersion})`) : '';
+    const extUpdateHint = report.extensionVersion && report.latestExtensionVersion && isNewerVersion(report.latestExtensionVersion, report.extensionVersion)
+        ? styleText('yellow', ` → v${report.latestExtensionVersion} available`)
+        : '';
+    const extVersion = report.extensionVersion ? styleText('dim', ` (v${report.extensionVersion})`) + extUpdateHint : '';
     const extLabel = report.extensionFlaky
         ? 'unstable (connected during live check, then disconnected)'
         : report.extensionConnected ? 'connected' : 'not connected';

package/dist/src/electron-apps.js

@@ -22,7 +22,7 @@ export const builtinApps = {
         bundleId: 'dev.antigravity.app',
         displayName: 'Antigravity',
     },
-    chatgpt: { port: 9236, processName: 'ChatGPT', bundleId: 'com.openai.chat', displayName: 'ChatGPT' },
+    'chatgpt-app': { port: 9236, processName: 'ChatGPT', bundleId: 'com.openai.chat', displayName: 'ChatGPT' },
 };
 /** Merge builtin + user-defined apps. User entries are additive only. */
 export function loadApps(userApps) {

package/dist/src/errors.d.ts

@@ -82,6 +82,7 @@ export interface ErrorEnvelope {
         help?: string;
         exitCode: number;
         stack?: string;
+        cause?: string;
     };
 }
 /** Extract a human-readable message from an unknown caught value. */

package/dist/src/errors.js

@@ -106,8 +106,19 @@ export class PluginError extends CliError {
 export function getErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+/** Serialize an error cause chain into a readable string. */
+function serializeCause(cause) {
+    if (cause instanceof Error) {
+        const parts = [cause.message];
+        if (cause.cause)
+            parts.push(`  caused by: ${serializeCause(cause.cause)}`);
+        return parts.join('\n');
+    }
+    return String(cause);
+}
 /** Build an ErrorEnvelope from any caught value. */
 export function toEnvelope(err) {
+    const cause = err instanceof Error && err.cause ? serializeCause(err.cause) : undefined;
     if (err instanceof CliError) {
         return {
             ok: false,
@@ -116,6 +127,7 @@ export function toEnvelope(err) {
                 message: err.message,
                 ...(err.hint ? { help: err.hint } : {}),
                 exitCode: err.exitCode,
+                ...(cause ? { cause } : {}),
             },
         };
     }
@@ -126,6 +138,7 @@ export function toEnvelope(err) {
             code: 'UNKNOWN',
             message: msg,
             exitCode: EXIT_CODES.GENERIC_ERROR,
+            ...(cause ? { cause } : {}),
         },
     };
 }

package/dist/src/execution.js

@@ -11,16 +11,20 @@
  */
 import { getRegistry, fullName } from './registry.js';
 import { pathToFileURL } from 'node:url';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
 import { executePipeline } from './pipeline/index.js';
 import { AdapterLoadError, ArgumentError, CommandExecutionError, getErrorMessage } from './errors.js';
 import { isDiagnosticEnabled, collectDiagnostic, emitDiagnostic } from './diagnostic.js';
 import { shouldUseBrowserSession } from './capabilityRouting.js';
 import { getBrowserFactory, browserSession, runWithTimeout, DEFAULT_BROWSER_COMMAND_TIMEOUT } from './runtime.js';
 import { emitHook } from './hooks.js';
-import { log } from './logger.js';
 import { isElectronApp } from './electron-apps.js';
 import { probeCDP, resolveElectronEndpoint } from './launcher.js';
-const _loadedModules = new Set();
+const _loadedModules = new Map();
+/** Track mtime of loaded user adapter files for hot-reload in daemon mode. */
+const _moduleMtimes = new Map();
+const _userClisDir = `${os.homedir()}/.opencli/clis/`;
 export function coerceAndValidateArgs(cmdArgs, kwargs) {
     const result = { ...kwargs };
     for (const argDef of cmdArgs) {
@@ -67,15 +71,34 @@ async function runCommand(cmd, page, kwargs, debug) {
     const internal = cmd;
     if (internal._lazy && internal._modulePath) {
         const modulePath = internal._modulePath;
-        if (!_loadedModules.has(modulePath)) {
+        // Hot-reload: if a user adapter's file has changed on disk, invalidate cache
+        const isUserAdapter = modulePath.startsWith(_userClisDir);
+        if (isUserAdapter && _loadedModules.has(modulePath)) {
             try {
-                await import(pathToFileURL(modulePath).href);
-                _loadedModules.add(modulePath);
+                const stat = fs.statSync(modulePath);
+                const prevMtime = _moduleMtimes.get(modulePath);
+                if (prevMtime !== undefined && stat.mtimeMs !== prevMtime) {
+                    _loadedModules.delete(modulePath);
+                    _moduleMtimes.delete(modulePath);
+                }
             }
-            catch (err) {
+            catch { /* file may have been deleted; let import below handle it */ }
+        }
+        if (!_loadedModules.has(modulePath)) {
+            const url = pathToFileURL(modulePath).href;
+            const importUrl = _moduleMtimes.has(modulePath) ? `${url}?t=${Date.now()}` : url;
+            const loadPromise = import(importUrl).then(() => {
+                try {
+                    _moduleMtimes.set(modulePath, fs.statSync(modulePath).mtimeMs);
+                }
+                catch { }
+            }, (err) => {
+                _loadedModules.delete(modulePath);
                 throw new AdapterLoadError(`Failed to load adapter module ${modulePath}: ${getErrorMessage(err)}`, 'Check that the adapter file exists and has no syntax errors.');
-            }
+            });
+            _loadedModules.set(modulePath, loadPromise);
         }
+        await _loadedModules.get(modulePath);
         const updated = getRegistry().get(fullName(cmd));
         if (updated?.func) {
             if (!page && updated.browser !== false) {
@@ -159,7 +182,7 @@ export async function executeCommand(cmd, rawKwargs, debug = false, opts = {}) {
                         await page.goto(preNavUrl);
                     }
                     catch (err) {
-                        log.warn(`Pre-navigation to ${preNavUrl} failed: ${err instanceof Error ? err.message : err}`);
+                        throw new CommandExecutionError(`Pre-navigation to ${preNavUrl} failed: ${err instanceof Error ? err.message : err}`, 'Check that the site is reachable and the browser extension is running.');
                     }
                 }
                 try {
@@ -173,13 +196,17 @@ export async function executeCommand(cmd, rawKwargs, debug = false, opts = {}) {
                     return result;
                 }
                 catch (err) {
-                    // Collect diagnostic while page is still alive (before browserSession closes it).
+                    // Collect diagnostic while page is still alive (before closing the window).
                     if (isDiagnosticEnabled()) {
                         const internal = cmd;
                         const ctx = await collectDiagnostic(err, internal, page);
                         emitDiagnostic(ctx);
                         diagnosticEmitted = true;
                     }
+                    // Close the automation window on failure too — without this, the window
+                    // lingers until the extension's idle timer fires (unreliable on Windows
+                    // where MV3 service workers may be suspended before setTimeout triggers).
+                    await page.closeWindow?.().catch(() => { });
                     throw err;
                 }
             }, { workspace: `site:${cmd.site}`, cdpEndpoint });

package/dist/src/execution.test.js

@@ -3,6 +3,8 @@ import { executeCommand, prepareCommandArgs } from './execution.js';
 import { TimeoutError } from './errors.js';
 import { cli, Strategy } from './registry.js';
 import { withTimeoutMs } from './runtime.js';
+import * as runtime from './runtime.js';
+import * as capRouting from './capabilityRouting.js';
 describe('executeCommand — non-browser timeout', () => {
     it('applies timeoutSeconds to non-browser commands', async () => {
         const cmd = cli({
@@ -37,6 +39,27 @@ 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('calls closeWindow on browser command failure', async () => {
+        const closeWindow = vi.fn().mockResolvedValue(undefined);
+        const mockPage = { closeWindow };
+        // Mock shouldUseBrowserSession to return true
+        vi.spyOn(capRouting, 'shouldUseBrowserSession').mockReturnValue(true);
+        // Mock browserSession to invoke the callback with our mock page
+        vi.spyOn(runtime, 'browserSession').mockImplementation(async (_Factory, fn) => {
+            return fn(mockPage);
+        });
+        const cmd = cli({
+            site: 'test-execution',
+            name: 'browser-close-on-error',
+            description: 'test closeWindow on failure',
+            browser: true,
+            strategy: Strategy.PUBLIC,
+            func: async () => { throw new Error('adapter failure'); },
+        });
+        await expect(executeCommand(cmd, {})).rejects.toThrow('adapter failure');
+        expect(closeWindow).toHaveBeenCalledTimes(1);
+        vi.restoreAllMocks();
+    });
     it('does not re-run custom validation when args are already prepared', async () => {
         const validateArgs = vi.fn();
         const cmd = {

package/dist/src/logger.d.ts

@@ -15,9 +15,9 @@ export declare const log: {
     warn(msg: string): void;
     /** Error (always shown) */
     error(msg: string): void;
-    /** Verbose output (only when OPENCLI_VERBOSE is set or -v flag) */
+    /** Verbose output (shown when -v flag, OPENCLI_VERBOSE, or DEBUG=opencli is set) */
     verbose(msg: string): void;
-    /** Debug output (only when DEBUG includes 'opencli') */
+    /** @deprecated Use log.verbose() instead. Kept as alias for backward compatibility. */
     debug(msg: string): void;
     /** Step-style debug (for pipeline steps, etc.) */
     step(stepNum: number, total: number, op: string, preview?: string): void;

package/dist/src/logger.js

@@ -6,10 +6,7 @@
  */
 import { styleText } from 'node:util';
 function isVerbose() {
-    return !!process.env.OPENCLI_VERBOSE;
-}
-function isDebug() {
-    return !!process.env.DEBUG?.includes('opencli');
+    return !!process.env.OPENCLI_VERBOSE || !!process.env.DEBUG?.includes('opencli');
 }
 export const log = {
     /** Informational message (always shown) */
@@ -32,17 +29,15 @@ export const log = {
     error(msg) {
         process.stderr.write(`${styleText('red', '✖')}  ${msg}\n`);
     },
-    /** Verbose output (only when OPENCLI_VERBOSE is set or -v flag) */
+    /** Verbose output (shown when -v flag, OPENCLI_VERBOSE, or DEBUG=opencli is set) */
     verbose(msg) {
         if (isVerbose()) {
             process.stderr.write(`${styleText('dim', '[verbose]')} ${msg}\n`);
         }
     },
-    /** Debug output (only when DEBUG includes 'opencli') */
+    /** @deprecated Use log.verbose() instead. Kept as alias for backward compatibility. */
     debug(msg) {
-        if (isDebug()) {
-            process.stderr.write(`${styleText('dim', '[debug]')} ${msg}\n`);
-        }
+        this.verbose(msg);
     },
     /** Step-style debug (for pipeline steps, etc.) */
     step(stepNum, total, op, preview = '') {

package/dist/src/registry.js

@@ -77,10 +77,9 @@ export function registerCommand(cmd) {
     const normalized = normalizeCommand(cmd);
     const canonicalKey = fullName(normalized);
     const existing = _registry.get(canonicalKey);
-    if (existing) {
-        for (const [key, value] of _registry.entries()) {
-            if (value === existing && key !== canonicalKey)
-                _registry.delete(key);
+    if (existing?.aliases) {
+        for (const alias of existing.aliases) {
+            _registry.delete(`${existing.site}/${alias}`);
         }
     }
     const aliases = normalizeAliases(normalized.aliases, normalized.name);

package/dist/src/types.d.ts

@@ -44,6 +44,8 @@ export interface IPage {
         settleMs?: number;
     }): Promise<void>;
     evaluate(js: string): Promise<any>;
+    /** Safely evaluate JS with pre-serialized arguments — prevents injection. */
+    evaluateWithArgs?(js: string, args: Record<string, unknown>): Promise<any>;
     getCookies(opts?: {
         domain?: string;
         url?: string;

package/dist/src/update-check.d.ts

@@ -8,6 +8,13 @@
  * - Notice appears AFTER command output, not before (same as npm/gh/yarn)
  * - Never delays or blocks the CLI command
  */
+interface GitHubReleaseAsset {
+    name: string;
+}
+interface GitHubRelease {
+    tag_name: string;
+    assets?: GitHubReleaseAsset[];
+}
 /**
  * Register a process exit hook that prints an update notice if a newer
  * version was found on the last background check.
@@ -15,8 +22,15 @@
  * Skipped during --get-completions to avoid polluting shell completion output.
  */
 export declare function registerUpdateNoticeOnExit(): void;
+declare function extractLatestExtensionVersionFromReleases(releases: GitHubRelease[]): string | undefined;
 /**
  * Kick off a background fetch to npm registry. Writes to cache for next run.
  * Fully non-blocking — never awaited.
  */
 export declare function checkForUpdateBackground(): void;
+/**
+ * Get the cached latest extension version (if available).
+ * Used by `opencli doctor` to report extension updates.
+ */
+export declare function getCachedLatestExtensionVersion(): string | undefined;
+export { extractLatestExtensionVersionFromReleases as _extractLatestExtensionVersionFromReleases, };

package/dist/src/update-check.js

@@ -17,6 +17,7 @@ const CACHE_DIR = path.join(os.homedir(), '.opencli');
 const CACHE_FILE = path.join(CACHE_DIR, 'update-check.json');
 const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24h
 const NPM_REGISTRY_URL = 'https://registry.npmjs.org/@jackwener/opencli/latest';
+const GITHUB_RELEASES_URL = 'https://api.github.com/repos/jackwener/OpenCLI/releases?per_page=20';
 // Read cache once at module load — shared by both exported functions
 const _cache = (() => {
     try {
@@ -26,10 +27,13 @@ const _cache = (() => {
         return null;
     }
 })();
-function writeCache(latestVersion) {
+function writeCache(latestVersion, latestExtensionVersion) {
     try {
         fs.mkdirSync(CACHE_DIR, { recursive: true });
-        fs.writeFileSync(CACHE_FILE, JSON.stringify({ lastCheck: Date.now(), latestVersion }), 'utf-8');
+        const data = { lastCheck: Date.now(), latestVersion };
+        if (latestExtensionVersion)
+            data.latestExtensionVersion = latestExtensionVersion;
+        fs.writeFileSync(CACHE_FILE, JSON.stringify(data), 'utf-8');
     }
     catch {
         // Best-effort; never fail
@@ -80,6 +84,38 @@ export function registerUpdateNoticeOnExit() {
         }
     });
 }
+function extractLatestExtensionVersionFromReleases(releases) {
+    for (const release of releases) {
+        for (const asset of release.assets ?? []) {
+            const assetMatch = asset.name.match(/^opencli-extension-v(.+)\.zip$/);
+            if (assetMatch)
+                return assetMatch[1];
+        }
+        const tagMatch = release.tag_name.match(/^ext-v(.+)$/);
+        if (tagMatch)
+            return tagMatch[1];
+    }
+    return undefined;
+}
+/** Fetch the latest extension version from GitHub Releases. */
+async function fetchLatestExtensionVersion() {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 3000);
+        const res = await fetch(GITHUB_RELEASES_URL, {
+            signal: controller.signal,
+            headers: { 'User-Agent': `opencli/${PKG_VERSION}`, Accept: 'application/vnd.github+json' },
+        });
+        clearTimeout(timer);
+        if (!res.ok)
+            return undefined;
+        const releases = await res.json();
+        return extractLatestExtensionVersionFromReleases(releases);
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Kick off a background fetch to npm registry. Writes to cache for next run.
  * Fully non-blocking — never awaited.
@@ -102,7 +138,8 @@ export function checkForUpdateBackground() {
                 return;
             const data = await res.json();
             if (typeof data.version === 'string') {
-                writeCache(data.version);
+                const extVersion = await fetchLatestExtensionVersion();
+                writeCache(data.version, extVersion);
             }
         }
         catch {
@@ -110,3 +147,11 @@ export function checkForUpdateBackground() {
         }
     })();
 }
+/**
+ * Get the cached latest extension version (if available).
+ * Used by `opencli doctor` to report extension updates.
+ */
+export function getCachedLatestExtensionVersion() {
+    return _cache?.latestExtensionVersion;
+}
+export { extractLatestExtensionVersionFromReleases as _extractLatestExtensionVersionFromReleases, };

package/dist/src/update-check.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/update-check.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+import { _extractLatestExtensionVersionFromReleases as extractLatestExtensionVersionFromReleases } from './update-check.js';
+describe('extractLatestExtensionVersionFromReleases', () => {
+    it('reads the extension version from a versioned asset on a normal CLI release', () => {
+        expect(extractLatestExtensionVersionFromReleases([
+            {
+                tag_name: 'v1.7.3',
+                assets: [
+                    { name: 'opencli-extension.zip' },
+                    { name: 'opencli-extension-v1.0.2.zip' },
+                ],
+            },
+        ])).toBe('1.0.2');
+    });
+    it('falls back to ext-v tags for extension-only releases', () => {
+        expect(extractLatestExtensionVersionFromReleases([
+            {
+                tag_name: 'ext-v1.1.0',
+                assets: [{ name: 'opencli-extension.zip' }],
+            },
+        ])).toBe('1.1.0');
+    });
+    it('returns undefined when no extension version source exists', () => {
+        expect(extractLatestExtensionVersionFromReleases([
+            {
+                tag_name: 'v1.7.3',
+                assets: [{ name: 'opencli-extension.zip' }],
+            },
+        ])).toBeUndefined();
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "1.7.2",
+  "version": "1.7.3",
   "publishConfig": {
     "access": "public"
   },

package/scripts/fetch-adapters.js

@@ -21,7 +21,7 @@
 
 import { existsSync, mkdirSync, rmSync, readFileSync, writeFileSync, readdirSync, statSync, unlinkSync } from 'node:fs';
 import { createHash } from 'node:crypto';
-import { join, resolve, dirname } from 'node:path';
+import { join, resolve, dirname, relative } from 'node:path';
 import { homedir } from 'node:os';
 
 const OPENCLI_DIR = join(homedir(), '.opencli');
@@ -82,8 +82,11 @@ function walkFiles(dir, prefix = '') {
  * Remove empty parent directories up to (but not including) stopAt.
  */
 function pruneEmptyDirs(filePath, stopAt) {
-  let dir = dirname(filePath);
-  while (dir !== stopAt && dir.startsWith(stopAt)) {
+  const boundary = resolve(stopAt);
+  let dir = resolve(dirname(filePath));
+  while (dir !== boundary) {
+    const rel = relative(boundary, dir);
+    if (!rel || rel.startsWith('..')) break;
     try {
       const entries = readdirSync(dir);
       if (entries.length > 0) break;
@@ -113,7 +116,15 @@ export function fetchAdapters() {
 
   const newOfficialFiles = new Set(walkFiles(BUILTIN_CLIS));
   const oldOfficialFiles = new Set(oldManifest?.files ?? []);
-  const oldHashes = oldManifest?.hashes ?? {};
+  const rawHashes = oldManifest?.hashes;
+  // Guard against corrupted manifest: if hashes is a non-object type (string, number,
+  // array), skip sync to avoid false-positive "changed" detection that deletes overrides.
+  // null/undefined are treated as empty (old manifests may lack the field).
+  if (rawHashes != null && (typeof rawHashes !== 'object' || Array.isArray(rawHashes))) {
+    log('Warning: adapter-manifest.json has corrupted hashes — skipping sync. Will fix on next run.');
+    return;
+  }
+  const oldHashes = rawHashes ?? {};
   mkdirSync(USER_CLIS_DIR, { recursive: true });
 
   // 1. Compute new hashes and detect which sites have changes
@@ -175,6 +186,24 @@ export function fetchAdapters() {
   }
   if (tsCleaned > 0) log(`Cleaned up ${tsCleaned} stale .ts adapter files`);
 
+  // 3b. Clean up stale .yaml/.yml adapter files left by older versions (pre-1.7.0)
+  // Older versions shipped adapters as YAML; current versions use .js only.
+  // These cause "Ignoring YAML adapter" warnings on every run (issue #953).
+  let yamlCleaned = 0;
+  for (const relPath of walkFiles(USER_CLIS_DIR)) {
+    if (relPath.endsWith('.yaml') || relPath.endsWith('.yml')) {
+      const jsCounterpart = relPath.replace(/\.ya?ml$/, '.js');
+      if (newOfficialFiles.has(jsCounterpart)) {
+        try {
+          unlinkSync(join(USER_CLIS_DIR, relPath));
+          pruneEmptyDirs(join(USER_CLIS_DIR, relPath), USER_CLIS_DIR);
+          yamlCleaned++;
+        } catch { /* ignore */ }
+      }
+    }
+  }
+  if (yamlCleaned > 0) log(`Cleaned up ${yamlCleaned} stale .yaml adapter files`);
+
   // 4. Clean up legacy compat shim files from ~/.opencli/
   // These were created by an older approach that placed re-export shims directly
   // in ~/.opencli/ (e.g., registry.js, errors.js, browser/). The current approach
@@ -245,15 +274,13 @@ export function fetchAdapters() {
   }, null, 2));
 
   log(`Synced adapters: ${cleared} local override(s) cleared` +
-    (tsCleaned > 0 ? `, ${tsCleaned} stale .ts files removed` : ''));
+    (tsCleaned > 0 ? `, ${tsCleaned} stale .ts files removed` : '') +
+    (yamlCleaned > 0 ? `, ${yamlCleaned} stale .yaml files removed` : ''));
 }
 
 function main() {
   // Skip in CI
   if (process.env.CI || process.env.CONTINUOUS_INTEGRATION) return;
-  // Allow opt-out
-  if (process.env.OPENCLI_SKIP_FETCH === '1') return;
-
   // Only run on global install, explicit trigger, or first-run fallback
   const isGlobal = process.env.npm_config_global === 'true';
   const isExplicit = process.env.OPENCLI_FETCH === '1';