@jackwener/opencli 1.7.1 → 1.7.2

package/clis/binance/prices.js

@@ -0,0 +1,19 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+
+cli({
+  site: 'binance',
+  name: 'prices',
+  description: 'Latest prices for all trading pairs',
+  domain: 'data-api.binance.vision',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'limit', type: 'int', default: 20, help: 'Number of prices' },
+  ],
+  columns: ['rank', 'symbol', 'price'],
+  pipeline: [
+    { fetch: { url: 'https://data-api.binance.vision/api/v3/ticker/price' } },
+    { map: { rank: '${{ index + 1 }}', symbol: '${{ item.symbol }}', price: '${{ item.price }}' } },
+    { limit: '${{ args.limit }}' },
+  ],
+});

package/clis/binance/ticker.js

@@ -0,0 +1,21 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+
+cli({
+  site: 'binance',
+  name: 'ticker',
+  description: '24h ticker statistics for top trading pairs by volume',
+  domain: 'data-api.binance.vision',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'limit', type: 'int', default: 20, help: 'Number of tickers' },
+  ],
+  columns: ['symbol', 'price', 'change_pct', 'high', 'low', 'volume', 'quote_vol', 'trades'],
+  pipeline: [
+    { fetch: { url: 'https://data-api.binance.vision/api/v3/ticker/24hr' } },
+    { map: { symbol: '${{ item.symbol }}', price: '${{ item.lastPrice }}', change_pct: '${{ item.priceChangePercent }}', high: '${{ item.highPrice }}', low: '${{ item.lowPrice }}', volume: '${{ item.volume }}', quote_vol: '${{ item.quoteVolume }}', trades: '${{ item.count }}', sort_volume: '${{ Number(item.quoteVolume) }}' } },
+    { sort: { by: 'sort_volume', order: 'desc' } },
+    { map: { symbol: '${{ item.symbol }}', price: '${{ item.lastPrice }}', change_pct: '${{ item.priceChangePercent }}', high: '${{ item.highPrice }}', low: '${{ item.lowPrice }}', volume: '${{ item.volume }}', quote_vol: '${{ item.quoteVolume }}', trades: '${{ item.count }}' } },
+    { limit: '${{ args.limit }}' },
+  ],
+});

package/clis/binance/top.js

@@ -0,0 +1,21 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+
+cli({
+  site: 'binance',
+  name: 'top',
+  description: 'Top trading pairs by 24h volume on Binance',
+  domain: 'data-api.binance.vision',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'limit', type: 'int', default: 20, help: 'Number of trading pairs' },
+  ],
+  columns: ['rank', 'symbol', 'price', 'change_24h', 'high', 'low', 'volume'],
+  pipeline: [
+    { fetch: { url: 'https://data-api.binance.vision/api/v3/ticker/24hr' } },
+    { map: { symbol: '${{ item.symbol }}', price: '${{ item.lastPrice }}', change_24h: '${{ item.priceChangePercent }}', high: '${{ item.highPrice }}', low: '${{ item.lowPrice }}', volume: '${{ item.quoteVolume }}', sort_volume: '${{ Number(item.quoteVolume) }}' } },
+    { sort: { by: 'sort_volume', order: 'desc' } },
+    { map: { rank: '${{ index + 1 }}', symbol: '${{ item.symbol }}', price: '${{ item.lastPrice }}', change_24h: '${{ item.priceChangePercent }}', high: '${{ item.highPrice }}', low: '${{ item.lowPrice }}', volume: '${{ item.quoteVolume }}' } },
+    { limit: '${{ args.limit }}' },
+  ],
+});

package/clis/binance/trades.js

@@ -0,0 +1,20 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+
+cli({
+  site: 'binance',
+  name: 'trades',
+  description: 'Recent trades for a trading pair',
+  domain: 'data-api.binance.vision',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'symbol', type: 'str', required: true, positional: true, help: 'Trading pair symbol (e.g. BTCUSDT, ETHUSDT)' },
+    { name: 'limit', type: 'int', default: 20, help: 'Number of trades (max 1000)' },
+  ],
+  columns: ['id', 'price', 'qty', 'quote_qty', 'buyer_maker'],
+  pipeline: [
+    { fetch: { url: 'https://data-api.binance.vision/api/v3/trades?symbol=${{ args.symbol }}&limit=${{ args.limit }}' } },
+    { map: { id: '${{ item.id }}', price: '${{ item.price }}', qty: '${{ item.qty }}', quote_qty: '${{ item.quoteQty }}', buyer_maker: '${{ item.isBuyerMaker }}' } },
+    { limit: '${{ args.limit }}' },
+  ],
+});

package/clis/twitter/lists-parser.js

@@ -0,0 +1,77 @@
+const MEMBER_PATTERNS = [
+    /([\d.,]+(?:\s?[KMB千萬万亿])?)\s*members?/i,
+    /([\d.,]+(?:\s?[KMB千萬万亿])?)\s*位成员/,
+];
+const FOLLOWER_PATTERNS = [
+    /([\d.,]+(?:\s?[KMB千萬万亿])?)\s*followers?/i,
+    /([\d.,]+(?:\s?[KMB千萬万亿])?)\s*位关注者/,
+];
+const PRIVATE_PATTERNS = [/\bprivate\b/i, /锁定列表/];
+const EMPTY_STATE_PATTERNS = [
+    /hasn't created any lists/i,
+    /has not created any lists/i,
+    /no lists yet/i,
+    /没有创建任何列表/,
+    /还没有创建任何列表/,
+];
+function normalizeText(text) {
+    return String(text || '').replace(/\s+/g, ' ').trim();
+}
+function matchMetric(text, patterns) {
+    for (const pattern of patterns) {
+        const match = text.match(pattern);
+        if (match)
+            return normalizeText(match[1]);
+    }
+    return '0';
+}
+function looksLikeMetadata(line) {
+    const text = normalizeText(line);
+    if (!text)
+        return true;
+    if (text.startsWith('@'))
+        return true;
+    if (MEMBER_PATTERNS.some((pattern) => pattern.test(text)))
+        return true;
+    if (FOLLOWER_PATTERNS.some((pattern) => pattern.test(text)))
+        return true;
+    if (PRIVATE_PATTERNS.some((pattern) => pattern.test(text)))
+        return true;
+    if (/^(public|pinned)$/i.test(text))
+        return true;
+    if (/^(lists?|你的列表)$/i.test(text))
+        return true;
+    return false;
+}
+export function parseListCards(cards) {
+    const seen = new Set();
+    const results = [];
+    for (const card of cards || []) {
+        const href = normalizeText(card?.href);
+        const rawText = String(card?.text || '');
+        if (!href || seen.has(href))
+            continue;
+        seen.add(href);
+        const text = normalizeText(rawText);
+        if (!text)
+            continue;
+        const lines = rawText
+            .split('\n')
+            .map((line) => normalizeText(line))
+            .filter(Boolean);
+        const name = lines.find((line) => !looksLikeMetadata(line));
+        if (!name)
+            continue;
+        results.push({
+            name,
+            members: matchMetric(text, MEMBER_PATTERNS),
+            followers: matchMetric(text, FOLLOWER_PATTERNS),
+            mode: PRIVATE_PATTERNS.some((pattern) => pattern.test(text)) ? 'private' : 'public',
+        });
+    }
+    return results;
+}
+export function isEmptyListsState(text) {
+    const normalized = normalizeText(text);
+    return EMPTY_STATE_PATTERNS.some((pattern) => pattern.test(normalized));
+}

package/clis/twitter/lists.d.ts

@@ -0,0 +1,5 @@
+import { Argument, Column } from '@jackwener/opencli/types';
+declare const args: Argument[];
+declare const columns: Column[];
+export { args, columns };
+export default {};

package/clis/twitter/lists.js

@@ -0,0 +1,62 @@
+import { AuthRequiredError, SelectorError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { isEmptyListsState, parseListCards } from './lists-parser.js';
+
+cli({
+    site: 'twitter',
+    name: 'lists',
+    description: 'Get Twitter/X lists for a user',
+    domain: 'x.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'user', positional: true, type: 'string', required: false },
+        { name: 'limit', type: 'int', default: 50 },
+    ],
+    columns: ['name', 'members', 'followers', 'mode'],
+    func: async (page, kwargs) => {
+        let targetUser = kwargs.user;
+        if (!targetUser) {
+            await page.goto('https://x.com/home');
+            await page.wait({ selector: '[data-testid="primaryColumn"]' });
+            const href = await page.evaluate(`() => {
+            const link = document.querySelector('a[data-testid="AppTabBar_Profile_Link"]');
+            return link ? link.getAttribute('href') : null;
+        }`);
+            if (!href) {
+                throw new AuthRequiredError('x.com', 'Could not find logged-in user profile link. Are you logged in?');
+            }
+            targetUser = href.replace('/', '');
+        }
+        await page.goto(`https://x.com/${targetUser}/lists`);
+        await page.wait(3);
+        const pageData = await page.evaluate(`() => {
+            const cards = [];
+            const seen = new Set();
+            for (const anchor of Array.from(document.querySelectorAll('a[href*="/i/lists/"]'))) {
+                const href = anchor.getAttribute('href') || '';
+                if (!/\\/i\\/lists\\/\\d+/.test(href) || seen.has(href)) continue;
+                seen.add(href);
+                const container = anchor.closest('[data-testid="cellInnerDiv"]') || anchor;
+                const text = (container.innerText || anchor.innerText || '').trim();
+                if (!text) continue;
+                cards.push({ href, text });
+            }
+            return {
+                cards,
+                pageText: document.body.innerText || '',
+            };
+        }`);
+        if (!pageData?.pageText) {
+            throw new SelectorError('Twitter lists', 'Empty page text');
+        }
+        const results = parseListCards(pageData.cards);
+        if (results.length === 0) {
+            if (isEmptyListsState(pageData.pageText)) {
+                return [];
+            }
+            throw new SelectorError('Twitter lists', `Could not parse list data`);
+        }
+        return results.slice(0, kwargs.limit);
+    }
+});

package/clis/twitter/lists.test.js

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+import { isEmptyListsState, parseListCards } from './lists-parser.js';
+
+describe('twitter lists parser', () => {
+    it('parses english list cards without relying on page locale', () => {
+        const result = parseListCards([
+            {
+                href: '/i/lists/123',
+                text: `AI Researchers
+@jack
+124 Members 3.4K Followers
+Private`,
+            },
+        ]);
+        expect(result).toEqual([
+            {
+                name: 'AI Researchers',
+                members: '124',
+                followers: '3.4K',
+                mode: 'private',
+            },
+        ]);
+    });
+
+    it('parses chinese list cards without scanning document.body.innerText', () => {
+        const result = parseListCards([
+            {
+                href: '/i/lists/456',
+                text: `AI观察
+@jack
+321 位成员 8.8K 位关注者
+锁定列表`,
+            },
+        ]);
+        expect(result).toEqual([
+            {
+                name: 'AI观察',
+                members: '321',
+                followers: '8.8K',
+                mode: 'private',
+            },
+        ]);
+    });
+
+    it('detects empty state text in english and chinese', () => {
+        expect(isEmptyListsState(`@jack hasn't created any Lists yet`)).toBe(true);
+        expect(isEmptyListsState('这个账号还没有创建任何列表')).toBe(true);
+        expect(isEmptyListsState('AI Researchers 124 Members')).toBe(false);
+    });
+});

package/clis/weibo/feed.js

@@ -1,20 +1,32 @@
 /**
- * Weibo feed — home timeline from followed users.
+ * Weibo feed — for-you or following timeline.
  */
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { getSelfUid } from './utils.js';
+const TIMELINE_ENDPOINTS = {
+    'for-you': 'unreadfriendstimeline',
+    following: 'friendstimeline',
+};
 cli({
     site: 'weibo',
     name: 'feed',
-    description: 'Weibo home timeline (posts from followed users)',
+    description: 'Fetch Weibo timeline (for-you or following)',
     domain: 'weibo.com',
     strategy: Strategy.COOKIE,
     args: [
+        {
+            name: 'type',
+            default: 'for-you',
+            choices: ['for-you', 'following'],
+            help: 'Timeline type: for-you (algorithmic) or following (chronological)',
+        },
         { name: 'limit', type: 'int', default: 15, help: 'Number of posts (max 50)' },
     ],
     columns: ['author', 'text', 'reposts', 'comments', 'likes', 'time', 'url'],
     func: async (page, kwargs) => {
         const count = Math.min(kwargs.limit || 15, 50);
+        const timelineType = kwargs.type === 'following' ? 'following' : 'for-you';
+        const endpoint = TIMELINE_ENDPOINTS[timelineType];
         await page.goto('https://weibo.com');
         await page.wait(2);
         const uid = await getSelfUid(page);
@@ -22,13 +34,14 @@ cli({
       (async () => {
         const uid = ${JSON.stringify(uid)};
         const count = ${count};
+        const endpoint = ${JSON.stringify(endpoint)};
         const listId = '10001' + uid;
         const strip = (html) => (html || '').replace(/<[^>]+>/g, '').replace(/&nbsp;/g, ' ').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&').trim();
 
-        const resp = await fetch('/ajax/feed/unreadfriendstimeline?list_id=' + listId + '&refresh=4&since_id=0&count=' + count, {credentials: 'include'});
-        if (!resp.ok) return {error: 'HTTP ' + resp.status};
+        const resp = await fetch('/ajax/feed/' + endpoint + '?list_id=' + listId + '&refresh=4&since_id=0&count=' + count, { credentials: 'include' });
+        if (!resp.ok) return { error: 'HTTP ' + resp.status };
         const data = await resp.json();
-        if (!data.ok) return {error: 'API error: ' + (data.msg || 'unknown')};
+        if (!data.ok) return { error: 'API error: ' + (data.msg || 'unknown') };
 
         return (data.statuses || []).slice(0, count).map(s => {
           const u = s.user || {};

package/clis/zsxq/topic.js

@@ -1,6 +1,6 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { CliError } from '@jackwener/opencli/errors';
-import { browserJsonRequest, ensureZsxqAuth, ensureZsxqPage, fetchFirstJson, getCommentsFromResponse, getTopicFromResponse, getTopicUrl, summarizeComments, toTopicRow, } from './utils.js';
+import { getActiveGroupId, browserJsonRequest, ensureZsxqAuth, ensureZsxqPage, fetchFirstJson, getCommentsFromResponse, getTopicFromResponse, getTopicUrl, summarizeComments, toTopicRow, } from './utils.js';
 cli({
     site: 'zsxq',
     name: 'topic',
@@ -10,6 +10,7 @@ cli({
     browser: true,
     args: [
         { name: 'id', required: true, positional: true, help: 'Topic ID' },
+        { name: 'group_id', help: 'Group ID (optional; defaults to active group in Chrome)' },
         { name: 'comment_limit', type: 'int', default: 20, help: 'Number of comments to fetch' },
     ],
     columns: ['topic_id', 'type', 'author', 'title', 'comments', 'likes', 'comment_preview', 'url'],
@@ -17,8 +18,9 @@ cli({
         await ensureZsxqPage(page);
         await ensureZsxqAuth(page);
         const topicId = String(kwargs.id);
+        const groupId = String(kwargs.group_id || await getActiveGroupId(page));
         const commentLimit = Math.max(1, Number(kwargs.comment_limit) || 20);
-        const detailUrl = `https://api.zsxq.com/v2/topics/${topicId}`;
+        const detailUrl = `https://api.zsxq.com/v2/groups/${groupId}/topics/${topicId}`;
         const detailResp = await browserJsonRequest(page, detailUrl);
         if (detailResp.status === 404) {
             throw new CliError('NOT_FOUND', `Topic ${topicId} not found`);
@@ -27,7 +29,7 @@ cli({
             throw new CliError('FETCH_ERROR', detailResp.error || `Failed to fetch topic ${topicId}`, `Checked endpoint: ${detailUrl}`);
         }
         const commentsResp = await fetchFirstJson(page, [
-            `https://api.zsxq.com/v2/topics/${topicId}/comments?sort=asc&count=${commentLimit}`,
+            `https://api.zsxq.com/v2/groups/${groupId}/topics/${topicId}/comments?sort=asc&count=${commentLimit}`,
         ]);
         const topic = getTopicFromResponse(detailResp.data);
         if (!topic)

package/clis/zsxq/topic.test.js

@@ -11,11 +11,12 @@ describe('zsxq topic command', () => {
         const mockPage = {
             goto: vi.fn().mockResolvedValue(undefined),
             evaluate: vi.fn()
-                .mockResolvedValueOnce(true)
+                .mockResolvedValueOnce(true) // ensureZsxqAuth
+                .mockResolvedValueOnce('12345') // getActiveGroupId
                 .mockResolvedValueOnce({
                 ok: true,
                 status: 404,
-                url: 'https://api.zsxq.com/v2/topics/404',
+                url: 'https://api.zsxq.com/v2/groups/12345/topics/404',
                 data: null,
             }),
         };
@@ -24,6 +25,6 @@ describe('zsxq topic command', () => {
             message: 'Topic 404 not found',
         });
         expect(mockPage.goto).toHaveBeenCalledWith('https://wx.zsxq.com');
-        expect(mockPage.evaluate).toHaveBeenCalledTimes(2);
+        expect(mockPage.evaluate).toHaveBeenCalledTimes(3);
     });
 });

package/clis/zsxq/utils.js

@@ -168,7 +168,7 @@ export function getTopicFromResponse(payload) {
     const data = unwrapRespData(payload);
     if (Array.isArray(data))
         return data[0] ?? null;
-    if (typeof data.topic_id === 'number')
+    if (typeof data.topic_id === 'number' || typeof data.topic_id === 'string')
         return data;
     const record = asRecord(data);
     if (!record)

package/dist/src/cli.js

@@ -891,6 +891,114 @@ cli({
             process.exitCode = EXIT_CODES.GENERIC_ERROR;
         }
     });
+    // ── Built-in: adapter management ─────────────────────────────────────────
+    const adapterCmd = program.command('adapter').description('Manage CLI adapters');
+    adapterCmd
+        .command('status')
+        .description('Show which sites have local overrides vs using official baseline')
+        .action(async () => {
+        const os = await import('node:os');
+        const userClisDir = path.join(os.homedir(), '.opencli', 'clis');
+        const builtinClisDir = BUILTIN_CLIS;
+        try {
+            const userEntries = await fs.promises.readdir(userClisDir, { withFileTypes: true });
+            const userSites = userEntries.filter(e => e.isDirectory()).map(e => e.name).sort();
+            let builtinSites = [];
+            try {
+                const builtinEntries = await fs.promises.readdir(builtinClisDir, { withFileTypes: true });
+                builtinSites = builtinEntries.filter(e => e.isDirectory()).map(e => e.name).sort();
+            }
+            catch { /* no builtin dir */ }
+            if (userSites.length === 0) {
+                console.log('No local adapter overrides. All sites use the official baseline.');
+                return;
+            }
+            console.log(`Local overrides in ~/.opencli/clis/ (${userSites.length} sites):\n`);
+            for (const site of userSites) {
+                const isOfficial = builtinSites.includes(site);
+                const label = isOfficial ? 'override' : 'custom';
+                console.log(`  ${site} [${label}]`);
+            }
+            console.log(`\nOfficial baseline: ${builtinSites.length} sites in package`);
+        }
+        catch {
+            console.log('No local adapter overrides. All sites use the official baseline.');
+        }
+    });
+    adapterCmd
+        .command('eject')
+        .description('Copy an official adapter to ~/.opencli/clis/ for local editing')
+        .argument('<site>', 'Site name (e.g. twitter, bilibili)')
+        .action(async (site) => {
+        const os = await import('node:os');
+        const userClisDir = path.join(os.homedir(), '.opencli', 'clis');
+        const builtinSiteDir = path.join(BUILTIN_CLIS, site);
+        const userSiteDir = path.join(userClisDir, site);
+        try {
+            await fs.promises.access(builtinSiteDir);
+        }
+        catch {
+            console.error(styleText('red', `Error: Site "${site}" not found in official adapters.`));
+            process.exitCode = EXIT_CODES.USAGE_ERROR;
+            return;
+        }
+        try {
+            await fs.promises.access(userSiteDir);
+            console.error(styleText('yellow', `Site "${site}" already exists in ~/.opencli/clis/. Use "opencli adapter reset ${site}" first to restore official version.`));
+            process.exitCode = EXIT_CODES.USAGE_ERROR;
+            return;
+        }
+        catch { /* good, doesn't exist yet */ }
+        fs.cpSync(builtinSiteDir, userSiteDir, { recursive: true });
+        console.log(styleText('green', `✅ Ejected "${site}" to ~/.opencli/clis/${site}/`));
+        console.log('You can now edit the adapter files. Changes take effect immediately.');
+        console.log(styleText('yellow', 'Note: Official updates to this adapter will overwrite your changes.'));
+    });
+    adapterCmd
+        .command('reset')
+        .description('Remove local override and restore official adapter version')
+        .argument('[site]', 'Site name (e.g. twitter, bilibili)')
+        .option('--all', 'Reset all local overrides')
+        .action(async (site, opts) => {
+        const os = await import('node:os');
+        const userClisDir = path.join(os.homedir(), '.opencli', 'clis');
+        if (opts.all) {
+            try {
+                const userEntries = await fs.promises.readdir(userClisDir, { withFileTypes: true });
+                const dirs = userEntries.filter(e => e.isDirectory());
+                if (dirs.length === 0) {
+                    console.log('No local sites to reset.');
+                    return;
+                }
+                for (const dir of dirs) {
+                    fs.rmSync(path.join(userClisDir, dir.name), { recursive: true, force: true });
+                }
+                console.log(styleText('green', `✅ Reset ${dirs.length} site(s). All adapters now use official baseline.`));
+            }
+            catch {
+                console.log('No local sites to reset.');
+            }
+            return;
+        }
+        if (!site) {
+            console.error(styleText('red', 'Error: Please specify a site name or use --all.'));
+            process.exitCode = EXIT_CODES.USAGE_ERROR;
+            return;
+        }
+        const userSiteDir = path.join(userClisDir, site);
+        try {
+            await fs.promises.access(userSiteDir);
+        }
+        catch {
+            console.error(styleText('yellow', `Site "${site}" has no local override.`));
+            return;
+        }
+        const isOfficial = fs.existsSync(path.join(BUILTIN_CLIS, site));
+        fs.rmSync(userSiteDir, { recursive: true, force: true });
+        console.log(styleText('green', isOfficial
+            ? `✅ Reset "${site}". Now using official baseline.`
+            : `✅ Removed custom site "${site}".`));
+    });
     // ── Built-in: daemon ──────────────────────────────────────────────────────
     const daemonCmd = program.command('daemon').description('Manage the opencli daemon');
     daemonCmd

package/dist/src/discovery.d.ts

@@ -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

@@ -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.

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';
@@ -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');