@jackwener/opencli 1.6.7 → 1.6.8

package/dist/clis/linux-do/topic-content.js

@@ -0,0 +1,154 @@
+import { AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { htmlToMarkdown, isRecord } from '@jackwener/opencli/utils';
+const LINUX_DO_DOMAIN = 'linux.do';
+const LINUX_DO_HOME = 'https://linux.do';
+function toLocalTime(utcStr) {
+    if (!utcStr)
+        return '';
+    const date = new Date(utcStr);
+    return Number.isNaN(date.getTime()) ? utcStr : date.toLocaleString();
+}
+function normalizeTopicPayload(payload) {
+    if (!isRecord(payload))
+        return null;
+    const postStream = isRecord(payload.post_stream)
+        ? {
+            posts: Array.isArray(payload.post_stream.posts)
+                ? payload.post_stream.posts.filter(isRecord).map((post) => ({
+                    post_number: typeof post.post_number === 'number' ? post.post_number : undefined,
+                    username: typeof post.username === 'string' ? post.username : undefined,
+                    raw: typeof post.raw === 'string' ? post.raw : undefined,
+                    cooked: typeof post.cooked === 'string' ? post.cooked : undefined,
+                    like_count: typeof post.like_count === 'number' ? post.like_count : undefined,
+                    created_at: typeof post.created_at === 'string' ? post.created_at : undefined,
+                }))
+                : undefined,
+        }
+        : undefined;
+    return {
+        title: typeof payload.title === 'string' ? payload.title : undefined,
+        post_stream: postStream,
+    };
+}
+function buildTopicMarkdownDocument(params) {
+    const frontMatterLines = [];
+    const entries = [
+        ['title', params.title || undefined],
+        ['author', params.author || undefined],
+        ['likes', typeof params.likes === 'number' && Number.isFinite(params.likes) ? params.likes : undefined],
+        ['createdAt', params.createdAt || undefined],
+        ['url', params.url || undefined],
+    ];
+    for (const [key, value] of entries) {
+        if (value === undefined)
+            continue;
+        if (typeof value === 'number') {
+            frontMatterLines.push(`${key}: ${value}`);
+        }
+        else {
+            // Quote strings that could be misinterpreted by YAML parsers
+            const needsQuote = /[#{}[\],&*?|>!%@`'"]/.test(value) || /: /.test(value) || /:$/.test(value) || value.includes('\n');
+            frontMatterLines.push(`${key}: ${needsQuote ? `'${value.replace(/'/g, "''")}'` : value}`);
+        }
+    }
+    const frontMatter = frontMatterLines.join('\n');
+    return [
+        frontMatter ? `---\n${frontMatter}\n---` : '',
+        params.body.trim(),
+    ].filter(Boolean).join('\n\n').trim();
+}
+function extractTopicContent(payload, id) {
+    const topic = normalizeTopicPayload(payload);
+    if (!topic) {
+        throw new CommandExecutionError('linux.do returned an unexpected topic payload');
+    }
+    const posts = topic.post_stream?.posts ?? [];
+    const mainPost = posts.find((post) => post.post_number === 1);
+    if (!mainPost) {
+        throw new EmptyResultError('linux-do/topic-content', `Could not find the main post for topic ${id}.`);
+    }
+    const body = typeof mainPost.raw === 'string' && mainPost.raw.trim()
+        ? mainPost.raw.trim()
+        : htmlToMarkdown(mainPost.cooked ?? '');
+    if (!body) {
+        throw new EmptyResultError('linux-do/topic-content', `Topic ${id} does not contain a readable main post body.`);
+    }
+    return {
+        content: buildTopicMarkdownDocument({
+            title: topic.title?.trim() ?? '',
+            author: mainPost.username?.trim() ?? '',
+            likes: typeof mainPost.like_count === 'number' ? mainPost.like_count : undefined,
+            createdAt: toLocalTime(mainPost.created_at ?? ''),
+            url: `${LINUX_DO_HOME}/t/${id}`,
+            body,
+        }),
+    };
+}
+async function fetchTopicPayload(page, id) {
+    const result = await page.evaluate(`(async () => {
+    try {
+      const res = await fetch('/t/${id}.json?include_raw=true', { credentials: 'include' });
+      let data = null;
+      try {
+        data = await res.json();
+      } catch (_error) {
+        data = null;
+      }
+      return {
+        ok: res.ok,
+        status: res.status,
+        data,
+        error: data === null ? 'Response is not valid JSON' : '',
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  })()`);
+    if (!result) {
+        throw new CommandExecutionError('linux.do returned an empty browser response');
+    }
+    if (result.status === 401 || result.status === 403) {
+        throw new AuthRequiredError(LINUX_DO_DOMAIN, 'linux.do requires an active signed-in browser session');
+    }
+    if (result.error === 'Response is not valid JSON') {
+        throw new AuthRequiredError(LINUX_DO_DOMAIN, 'linux.do requires an active signed-in browser session');
+    }
+    if (!result.ok) {
+        throw new CommandExecutionError(result.error || `linux.do request failed: HTTP ${result.status ?? 'unknown'}`);
+    }
+    if (result.error) {
+        throw new CommandExecutionError(result.error, 'Please verify your linux.do session is still valid');
+    }
+    return result.data;
+}
+cli({
+    site: 'linux-do',
+    name: 'topic-content',
+    description: 'Get the main topic body as Markdown',
+    domain: LINUX_DO_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    defaultFormat: 'plain',
+    args: [
+        { name: 'id', positional: true, type: 'int', required: true, help: 'Topic ID' },
+    ],
+    columns: ['content'],
+    func: async (page, kwargs) => {
+        const id = Number(kwargs.id);
+        if (!Number.isInteger(id) || id <= 0) {
+            throw new CommandExecutionError(`Invalid linux.do topic id: ${String(kwargs.id ?? '')}`);
+        }
+        const payload = await fetchTopicPayload(page, id);
+        return [extractTopicContent(payload, id)];
+    },
+});
+export const __test__ = {
+    buildTopicMarkdownDocument,
+    extractTopicContent,
+    normalizeTopicPayload,
+    toLocalTime,
+};

package/dist/clis/linux-do/topic-content.test.d.ts

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

package/dist/clis/linux-do/topic-content.test.js

@@ -0,0 +1,59 @@
+import { getRegistry } from '@jackwener/opencli/registry';
+import fs from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './topic-content.js';
+describe('linux-do topic-content', () => {
+    it('prefers raw markdown when the topic payload includes it', () => {
+        const result = __test__.extractTopicContent({
+            title: 'Hello Linux.do',
+            post_stream: {
+                posts: [
+                    {
+                        post_number: 1,
+                        username: 'neo',
+                        raw: '## Heading\n\n- one\n- two',
+                        cooked: '<h2>Heading</h2><ul><li>one</li><li>two</li></ul>',
+                        like_count: 7,
+                        created_at: '2025-04-05T10:00:00.000Z',
+                    },
+                ],
+            },
+        }, 1234);
+        expect(result.content).toContain('---');
+        expect(result.content).toContain('title: Hello Linux.do');
+        expect(result.content).toContain('author: neo');
+        expect(result.content).toContain('likes: 7');
+        expect(result.content).toContain('url: https://linux.do/t/1234');
+        expect(result.content).toContain('## Heading');
+        expect(result.content).toContain('- one');
+    });
+    it('falls back to cooked html and converts it to markdown', () => {
+        const result = __test__.extractTopicContent({
+            title: 'Converted Topic',
+            post_stream: {
+                posts: [
+                    {
+                        post_number: 1,
+                        username: 'trinity',
+                        cooked: '<p>Hello <strong>world</strong></p><blockquote><p>quoted</p></blockquote>',
+                        like_count: 3,
+                        created_at: '2025-04-05T10:00:00.000Z',
+                    },
+                ],
+            },
+        }, 42);
+        expect(result.content).toContain('Hello **world**');
+        expect(result.content).toContain('> quoted');
+    });
+    it('registers topic-content with plain default output for markdown body rendering', () => {
+        const command = getRegistry().get('linux-do/topic-content');
+        expect(command?.defaultFormat).toBe('plain');
+        expect(command?.columns).toEqual(['content']);
+    });
+    it('keeps topic yaml as a summarized first-page reader after the split', () => {
+        const topicYaml = fs.readFileSync(new URL('./topic.yaml', import.meta.url), 'utf8');
+        expect(topicYaml).not.toContain('main_only');
+        expect(topicYaml).toContain('slice(0, 200)');
+        expect(topicYaml).toContain('帖子首页摘要和回复');
+    });
+});

package/dist/clis/linux-do/topic.yaml

@@ -1,6 +1,6 @@
 site: linux-do
 name: topic
-description: linux.do 帖子详情和回复（首页）
+description: linux.do 帖子首页摘要和回复（首屏）
 domain: linux.do
 strategy: cookie
 browser: true
@@ -15,17 +15,12 @@ args:
     type: int
     default: 20
     description: Number of posts
-  main_only:
-    type: bool
-    default: false
-    description: Only return the main post body without truncation
 
 pipeline:
   - navigate: https://linux.do
 
   - evaluate: |
       (async () => {
-        const mainOnly = ${{ args.main_only }};
         const toLocalTime = (utcStr) => {
           if (!utcStr) return '';
           const date = new Date(utcStr);
@@ -50,16 +45,6 @@ pipeline:
           .replace(/\s+/g, ' ')
           .trim();
         const posts = data?.post_stream?.posts || [];
-        if (mainOnly) {
-          const mainPost = posts.find(p => p.post_number === 1);
-          if (!mainPost) return [];
-          return [{
-            author: mainPost.username || '',
-            content: mainPost.cooked || '',
-            likes: mainPost.like_count || 0,
-            created_at: toLocalTime(mainPost.created_at),
-          }];
-        }
         return posts.slice(0, ${{ args.limit }}).map(p => ({
           author: p.username,
           content: strip(p.cooked).slice(0, 200),

package/dist/clis/xueqiu/groups.yaml

@@ -0,0 +1,23 @@
+site: xueqiu
+name: groups
+description: 获取雪球自选股分组列表（含模拟组合）
+domain: xueqiu.com
+browser: true
+
+pipeline:
+  - navigate: https://xueqiu.com
+  - evaluate: |
+      (async () => {
+        const resp = await fetch('https://stock.xueqiu.com/v5/stock/portfolio/list.json?category=1&size=20', {credentials: 'include'});
+        if (!resp.ok) throw new Error('HTTP ' + resp.status + ' Hint: Not logged in?');
+        const d = await resp.json();
+        if (!d.data || !d.data.stocks) throw new Error('获取失败，可能未登录');
+
+        return d.data.stocks.map(g => ({
+          pid: String(g.id),
+          name: g.name,
+          count: g.symbol_count || 0
+        }));
+      })()
+
+columns: [pid, name, count]

package/dist/clis/xueqiu/kline.yaml

@@ -0,0 +1,65 @@
+site: xueqiu
+name: kline
+description: 获取雪球股票K线（历史行情）数据
+domain: xueqiu.com
+browser: true
+
+args:
+  symbol:
+    positional: true
+    type: str
+    required: true
+    description: 股票代码，如 SH600519、SZ000858、AAPL
+  days:
+    type: int
+    default: 14
+    description: 回溯天数（默认14天）
+
+pipeline:
+  - navigate: https://xueqiu.com
+
+  - evaluate: |
+      (async () => {
+        const symbol = (${{ args.symbol | json }} || '').toUpperCase();
+        const days = parseInt(${{ args.days | json }}) || 14;
+        if (!symbol) throw new Error('Missing argument: symbol');
+
+        // begin = now minus days (for count=-N, returns N items ending at begin)
+        const beginTs = Date.now();
+        const resp = await fetch('https://stock.xueqiu.com/v5/stock/chart/kline.json?symbol=' + encodeURIComponent(symbol) + '&begin=' + beginTs + '&period=day&type=before&count=-' + days, {credentials: 'include'});
+        if (!resp.ok) throw new Error('HTTP ' + resp.status + ' Hint: Not logged in?');
+        const d = await resp.json();
+
+        if (!d.data || !d.data.item || d.data.item.length === 0) return [];
+
+        const columns = d.data.column || [];
+        const items = d.data.item || [];
+        const colIdx = {};
+        columns.forEach((name, i) => { colIdx[name] = i; });
+
+        function fmt(v) { return v == null ? null : v; }
+
+        return items.map(row => ({
+          date: colIdx.timestamp != null ? new Date(row[colIdx.timestamp]).toISOString().split('T')[0] : null,
+          open: fmt(row[colIdx.open]),
+          high: fmt(row[colIdx.high]),
+          low: fmt(row[colIdx.low]),
+          close: fmt(row[colIdx.close]),
+          volume: fmt(row[colIdx.volume]),
+          amount: fmt(row[colIdx.amount]),
+          chg: fmt(row[colIdx.chg]),
+          percent: fmt(row[colIdx.percent]),
+          symbol: symbol
+        }));
+      })()
+
+  - map:
+      date: ${{ item.date }}
+      open: ${{ item.open }}
+      high: ${{ item.high }}
+      low: ${{ item.low }}
+      close: ${{ item.close }}
+      volume: ${{ item.volume }}
+      percent: ${{ item.percent }}
+
+columns: [date, open, high, low, close, volume]

package/dist/clis/xueqiu/watchlist.yaml

@@ -1,14 +1,14 @@
 site: xueqiu
 name: watchlist
-description: 获取雪球自选股列表
+description: 获取雪球自选股/模拟组合股票列表
 domain: xueqiu.com
 browser: true
 
 args:
-  category:
-    type: str # using str to prevent parsing issues like 01
-    default: "1"
-    description: "分类：1=自选(默认) 2=持仓 3=关注"
+  pid:
+    type: str
+    default: "-1"
+    description: "分组ID：-1=全部(默认) -4=模拟 -5=沪深 -6=美股 -7=港股 -10=实盘 0=持仓（通过 xueqiu groups 获取）"
   limit:
     type: int
     default: 100
@@ -18,12 +18,12 @@ pipeline:
   - navigate: https://xueqiu.com
   - evaluate: |
       (async () => {
-        const category = parseInt(${{ args.category | json }}) || 1;
-        const resp = await fetch(`https://stock.xueqiu.com/v5/stock/portfolio/stock/list.json?size=100&category=${category}&pid=-1`, {credentials: 'include'});
+        const pid = ${{ args.pid | json }} || '-1';
+        const resp = await fetch(`https://stock.xueqiu.com/v5/stock/portfolio/stock/list.json?size=100&category=1&pid=${encodeURIComponent(pid)}`, {credentials: 'include'});
         if (!resp.ok) throw new Error('HTTP ' + resp.status + ' Hint: Not logged in?');
         const d = await resp.json();
         if (!d.data || !d.data.stocks) throw new Error('获取失败，可能未登录');
-        
+
         return d.data.stocks.map(s => ({
           symbol: s.symbol,
           name: s.name,
@@ -40,7 +40,7 @@ pipeline:
       name: ${{ item.name }}
       price: ${{ item.price }}
       changePercent: ${{ item.changePercent }}
-      
+
   - limit: ${{ args.limit }}
 
 columns: [symbol, name, price, changePercent]

package/dist/src/analysis.d.ts

@@ -29,6 +29,8 @@ export declare function inferStrategy(authIndicators: string[]): string;
 export declare function detectAuthFromHeaders(headers?: Record<string, string>): string[];
 /** Detect auth indicators from URL and response body (heuristic). */
 export declare function detectAuthFromContent(url: string, body: unknown): string[];
+/** Check whether a URL looks like tracking/telemetry noise rather than a business API. */
+export declare function isNoiseUrl(url: string): boolean;
 /** Extract non-volatile query params and classify them. */
 export declare function classifyQueryParams(url: string): {
     params: string[];

package/dist/src/analysis.js

@@ -148,6 +148,12 @@ export function detectAuthFromContent(url, body) {
         indicators.push('bearer');
     return indicators;
 }
+// ── Noise filtering ─────────────────────────────────────────────────────────
+const NOISE_URL_PATTERN = /\/(track|log|analytics|beacon|pixel|ping|heartbeat|keep.?alive)\b/i;
+/** Check whether a URL looks like tracking/telemetry noise rather than a business API. */
+export function isNoiseUrl(url) {
+    return NOISE_URL_PATTERN.test(url);
+}
 // ── Query param classification ──────────────────────────────────────────────
 /** Extract non-volatile query params and classify them. */
 export function classifyQueryParams(url) {

package/dist/src/browser/cdp.js

@@ -136,6 +136,14 @@ export class CDPBridge {
 class CDPPage extends BasePage {
     bridge;
     _pageEnabled = false;
+    // Network capture state (mirrors extension/src/cdp.ts NetworkCaptureEntry shape)
+    _networkCapturing = false;
+    _networkCapturePattern = '';
+    _networkEntries = [];
+    _pendingRequests = new Map(); // requestId → index in _networkEntries
+    _pendingBodyFetches = new Set(); // track in-flight getResponseBody calls
+    _consoleMessages = [];
+    _consoleCapturing = false;
     constructor(bridge) {
         super();
         this.bridge = bridge;
@@ -186,6 +194,94 @@ class CDPPage extends BasePage {
         }
         return base64;
     }
+    async startNetworkCapture(pattern = '') {
+        this._networkCapturePattern = pattern;
+        this._networkEntries = [];
+        this._pendingRequests.clear();
+        this._pendingBodyFetches.clear();
+        if (!this._networkCapturing) {
+            await this.bridge.send('Network.enable');
+            // Step 1: Record request method/url on requestWillBeSent
+            this.bridge.on('Network.requestWillBeSent', (params) => {
+                const p = params;
+                if (!pattern || p.request.url.includes(pattern)) {
+                    const idx = this._networkEntries.push({
+                        url: p.request.url,
+                        method: p.request.method,
+                        timestamp: p.timestamp,
+                    }) - 1;
+                    this._pendingRequests.set(p.requestId, idx);
+                }
+            });
+            // Step 2: Fill in response metadata on responseReceived
+            this.bridge.on('Network.responseReceived', (params) => {
+                const p = params;
+                const idx = this._pendingRequests.get(p.requestId);
+                if (idx !== undefined) {
+                    this._networkEntries[idx].responseStatus = p.response.status;
+                    this._networkEntries[idx].responseContentType = p.response.mimeType || '';
+                }
+            });
+            // Step 3: Fetch body on loadingFinished (body is only reliably available after this)
+            this.bridge.on('Network.loadingFinished', (params) => {
+                const p = params;
+                const idx = this._pendingRequests.get(p.requestId);
+                if (idx !== undefined) {
+                    const bodyFetch = this.bridge.send('Network.getResponseBody', { requestId: p.requestId }).then((result) => {
+                        const r = result;
+                        if (typeof r?.body === 'string') {
+                            this._networkEntries[idx].responsePreview = r.base64Encoded
+                                ? `base64:${r.body.slice(0, 4000)}`
+                                : r.body.slice(0, 4000);
+                        }
+                    }).catch(() => {
+                        // Body unavailable for some requests (e.g. uploads) — non-fatal
+                    }).finally(() => {
+                        this._pendingBodyFetches.delete(bodyFetch);
+                    });
+                    this._pendingBodyFetches.add(bodyFetch);
+                    this._pendingRequests.delete(p.requestId);
+                }
+            });
+            this._networkCapturing = true;
+        }
+    }
+    async readNetworkCapture() {
+        // Await all in-flight body fetches so entries have responsePreview populated
+        if (this._pendingBodyFetches.size > 0) {
+            await Promise.all([...this._pendingBodyFetches]);
+        }
+        const entries = [...this._networkEntries];
+        this._networkEntries = [];
+        return entries;
+    }
+    async consoleMessages(level = 'all') {
+        if (!this._consoleCapturing) {
+            await this.bridge.send('Runtime.enable');
+            this.bridge.on('Runtime.consoleAPICalled', (params) => {
+                const p = params;
+                const text = (p.args || []).map(a => a.value !== undefined ? String(a.value) : (a.description || '')).join(' ');
+                this._consoleMessages.push({ type: p.type, text, timestamp: p.timestamp });
+                if (this._consoleMessages.length > 500)
+                    this._consoleMessages.shift();
+            });
+            // Capture uncaught exceptions as error-level messages
+            this.bridge.on('Runtime.exceptionThrown', (params) => {
+                const p = params;
+                const desc = p.exceptionDetails?.exception?.description || p.exceptionDetails?.text || 'Unknown exception';
+                this._consoleMessages.push({ type: 'error', text: desc, timestamp: p.timestamp });
+                if (this._consoleMessages.length > 500)
+                    this._consoleMessages.shift();
+            });
+            this._consoleCapturing = true;
+        }
+        if (level === 'all')
+            return [...this._consoleMessages];
+        // 'error' level includes both console.error() and uncaught exceptions
+        if (level === 'error')
+            return this._consoleMessages.filter(m => m.type === 'error' || m.type === 'warning');
+        return this._consoleMessages.filter(m => m.type === level);
+    }
     async tabs() {
         return [];
     }

package/dist/src/build-manifest.d.ts

@@ -6,7 +6,7 @@
  * manifest.json for instant cold-start registration (no runtime YAML parsing).
  *
  * Usage: npx tsx src/build-manifest.ts
- * Output: dist/cli-manifest.json
+ * Output: cli-manifest.json at the package root
  */
 export interface ManifestEntry {
     site: string;
@@ -35,6 +35,8 @@ export interface ManifestEntry {
     type: 'yaml' | 'ts';
     /** Relative path from clis/ dir, e.g. 'bilibili/hot.yaml' or 'bilibili/search.js' */
     modulePath?: string;
+    /** Relative path to the original source file from clis/ dir (for YAML: 'site/cmd.yaml') */
+    sourceFile?: string;
     /** Pre-navigation control — see CliCommand.navigateBefore */
     navigateBefore?: boolean | string;
 }

package/dist/src/build-manifest.js

@@ -6,7 +6,7 @@
  * manifest.json for instant cold-start registration (no runtime YAML parsing).
  *
  * Usage: npx tsx src/build-manifest.ts
- * Output: dist/cli-manifest.json
+ * Output: cli-manifest.json at the package root
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -14,9 +14,10 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import yaml from 'js-yaml';
 import { getErrorMessage } from './errors.js';
 import { fullName, getRegistry } from './registry.js';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const CLIS_DIR = path.resolve(__dirname, '..', 'clis');
-const OUTPUT = path.resolve(__dirname, '..', 'cli-manifest.json');
+import { findPackageRoot, getCliManifestPath } from './package-paths.js';
+const PACKAGE_ROOT = findPackageRoot(fileURLToPath(import.meta.url));
+const CLIS_DIR = path.join(PACKAGE_ROOT, 'clis');
+const OUTPUT = getCliManifestPath(CLIS_DIR);
 import { parseYamlArgs } from './yaml-schema.js';
 import { isRecord } from './utils.js';
 const CLI_MODULE_PATTERN = /\bcli\s*\(/;
@@ -43,7 +44,7 @@ function isCliCommandValue(value, site) {
         && typeof value.name === 'string'
         && Array.isArray(value.args);
 }
-function toManifestEntry(cmd, modulePath) {
+function toManifestEntry(cmd, modulePath, sourceFile) {
     return {
         site: cmd.site,
         name: cmd.name,
@@ -59,6 +60,7 @@ function toManifestEntry(cmd, modulePath) {
         replacedBy: cmd.replacedBy,
         type: 'ts',
         modulePath,
+        sourceFile,
         navigateBefore: cmd.navigateBefore,
     };
 }
@@ -90,6 +92,7 @@ function scanYaml(filePath, site) {
             deprecated: cliDef.deprecated,
             replacedBy: cliDef.replacedBy,
             type: 'yaml',
+            sourceFile: path.relative(CLIS_DIR, filePath),
             navigateBefore: cliDef.navigateBefore,
         };
     }
@@ -130,7 +133,7 @@ export async function loadTsManifestEntries(filePath, site, importer = moduleHre
             return true;
         })
             .sort((a, b) => a.name.localeCompare(b.name))
-            .map(cmd => toManifestEntry(cmd, modulePath));
+            .map(cmd => toManifestEntry(cmd, modulePath, path.relative(CLIS_DIR, filePath)));
     }
     catch (err) {
         // If parsing fails, log a warning (matching scanYaml behaviour) and skip the entry.
@@ -200,7 +203,7 @@ async function main() {
     // entry-point loses its executable permission, causing "Permission denied".
     // See: https://github.com/jackwener/opencli/issues/446
     if (process.platform !== 'win32') {
-        const projectRoot = path.resolve(__dirname, '..', '..');
+        const projectRoot = PACKAGE_ROOT;
         const pkgPath = path.resolve(projectRoot, 'package.json');
         try {
             const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));

package/dist/src/build-manifest.test.js

@@ -87,7 +87,7 @@ describe('manifest helper rules', () => {
                 replacedBy: 'opencli demo new',
             }),
         }));
-        expect(entries).toEqual([
+        expect(entries).toMatchObject([
             {
                 site,
                 name: 'dynamic',
@@ -97,7 +97,7 @@ describe('manifest helper rules', () => {
                 browser: false,
                 aliases: ['metadata'],
                 args: [
-                    {
+                    expect.objectContaining({
                         name: 'model',
                         type: 'str',
                         required: true,
@@ -105,7 +105,7 @@ describe('manifest helper rules', () => {
                         help: 'Choose a model',
                         choices: ['auto', 'thinking'],
                         default: '30',
-                    },
+                    }),
                 ],
                 type: 'ts',
                 modulePath: `${site}/${site}.js`,
@@ -114,6 +114,8 @@ describe('manifest helper rules', () => {
                 replacedBy: 'opencli demo new',
             },
         ]);
+        // Verify sourceFile is included
+        expect(entries[0].sourceFile).toBeDefined();
         getRegistry().delete(key);
     });
     it('falls back to registry delta for side-effect-only cli modules', async () => {
@@ -133,7 +135,7 @@ describe('manifest helper rules', () => {
             });
             return {};
         });
-        expect(entries).toEqual([
+        expect(entries).toMatchObject([
             {
                 site,
                 name: 'legacy',
@@ -147,6 +149,8 @@ describe('manifest helper rules', () => {
                 replacedBy: 'opencli demo new',
             },
         ]);
+        // Verify sourceFile is included
+        expect(entries[0].sourceFile).toBeDefined();
         getRegistry().delete(key);
     });
     it('keeps every command a module exports instead of guessing by site', async () => {