@jackwener/opencli 1.7.6 → 1.7.8

package/dist/src/download/article-download.test.js

@@ -15,6 +15,20 @@ afterEach(() => {
     }
     tempDirs.length = 0;
 });
+async function runAndRead(contentHtml, opts = {}) {
+    const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-article-'));
+    tempDirs.push(tempDir);
+    const result = await downloadArticle({
+        title: 'Test Article',
+        contentHtml,
+    }, {
+        output: tempDir,
+        downloadImages: false,
+        ...(opts.cleanSelectors && { cleanSelectors: opts.cleanSelectors }),
+    });
+    expect(result[0].status).toBe('success');
+    return fs.readFileSync(result[0].saved, 'utf8');
+}
 describe('downloadArticle', () => {
     it('returns the saved markdown file path on success', async () => {
         const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-article-'));
@@ -36,4 +50,186 @@ describe('downloadArticle', () => {
         expect(fs.existsSync(result[0].saved)).toBe(true);
         expect(fs.readFileSync(result[0].saved, 'utf8')).toContain('Hello world');
     });
+    describe('markdown pipeline', () => {
+        it('converts GFM tables', async () => {
+            const md = await runAndRead('<table><thead><tr><th>a</th><th>b</th></tr></thead>' +
+                '<tbody><tr><td>1</td><td>2</td></tr></tbody></table>');
+            expect(md).toMatch(/\|\s*a\s*\|\s*b\s*\|/);
+            expect(md).toMatch(/\|\s*---\s*\|\s*---\s*\|/);
+            expect(md).toMatch(/\|\s*1\s*\|\s*2\s*\|/);
+        });
+        it('converts strikethrough and task lists', async () => {
+            const md = await runAndRead('<p><del>gone</del></p>' +
+                '<ul><li><input type="checkbox" checked>done</li><li><input type="checkbox">todo</li></ul>');
+            expect(md).toContain('~~gone~~');
+            expect(md).toContain('[x] done');
+            expect(md).toContain('[ ] todo');
+        });
+        it('strips script / style / noscript / form but keeps iframe as a link', async () => {
+            const md = await runAndRead('<p>keep</p>' +
+                '<script>alert(1)</script>' +
+                '<style>.x{color:red}</style>' +
+                '<noscript>nojs</noscript>' +
+                '<iframe src="https://www.youtube.com/embed/abc" title="Demo video"></iframe>' +
+                '<form><button>click</button></form>');
+            expect(md).toContain('keep');
+            expect(md).not.toContain('alert');
+            expect(md).not.toContain('color:red');
+            expect(md).not.toContain('nojs');
+            expect(md).not.toContain('click');
+            // Iframe degrades to a link preserving the embedded URL.
+            expect(md).toContain('[Demo video](https://www.youtube.com/embed/abc)');
+        });
+        it('strips SVG nodes entirely', async () => {
+            const md = await runAndRead('<p>before</p><svg><circle cx="5" cy="5" r="4"/></svg><p>after</p>');
+            expect(md).toContain('before');
+            expect(md).toContain('after');
+            expect(md).not.toContain('svg');
+            expect(md).not.toContain('circle');
+        });
+        it('drops base64 data URI images but keeps regular images', async () => {
+            const md = await runAndRead('<p><img alt="inline" src="data:image/png;base64,iVBORw0KGgo="></p>' +
+                '<p><img alt="keep" src="https://example.com/a.jpg"></p>');
+            expect(md).not.toContain('data:image');
+            expect(md).toContain('![keep](https://example.com/a.jpg)');
+        });
+        it('collapses 3+ blank lines and strips lone bullet / middle-dot residue', async () => {
+            const md = await runAndRead('<p>top</p>' +
+                '<p>-</p>' +
+                '<p>·</p>' +
+                '<p>bottom</p>');
+            expect(md).not.toMatch(/\n{3,}/);
+            expect(md).not.toMatch(/^\s*-\s*$/m);
+            expect(md).not.toMatch(/^\s*·\s*$/m);
+            expect(md).toContain('top');
+            expect(md).toContain('bottom');
+        });
+        it('strips page chrome (header / footer / nav / aside)', async () => {
+            const md = await runAndRead('<header><p>page-header-text</p></header>' +
+                '<nav><a href="/">home-link</a></nav>' +
+                '<p>article-body</p>' +
+                '<aside><p>sidebar-text</p></aside>' +
+                '<footer><p>page-footer-text</p></footer>');
+            expect(md).toContain('article-body');
+            expect(md).not.toContain('page-header-text');
+            expect(md).not.toContain('home-link');
+            expect(md).not.toContain('sidebar-text');
+            expect(md).not.toContain('page-footer-text');
+        });
+        it('cleanSelectors removes matching nodes before conversion', async () => {
+            const md = await runAndRead('<p>keep-me</p>' +
+                '<div class="vote-card">折叠卡</div>' +
+                '<section class="reward-panel">赞赏栏</section>' +
+                '<p>also-keep</p>', { cleanSelectors: ['.vote-card', '.reward-panel'] });
+            expect(md).toContain('keep-me');
+            expect(md).toContain('also-keep');
+            expect(md).not.toContain('折叠卡');
+            expect(md).not.toContain('赞赏栏');
+        });
+        it('cleanSelectors silently ignores invalid selectors', async () => {
+            const md = await runAndRead('<p>survives</p><div class="x">and-this-too</div>', { cleanSelectors: ['!!!not-a-valid-selector', '.missing'] });
+            expect(md).toContain('survives');
+            expect(md).toContain('and-this-too');
+        });
+        it('cleanSelectors keeps valid selectors active when one selector is invalid', async () => {
+            const md = await runAndRead('<p>keep</p><div class="vote-card">strip-me</div><p>also-keep</p>', { cleanSelectors: ['!!!not-a-valid-selector', '.vote-card'] });
+            expect(md).toContain('keep');
+            expect(md).toContain('also-keep');
+            expect(md).not.toContain('strip-me');
+        });
+        it('preserves <video> as inline HTML with src + poster', async () => {
+            const md = await runAndRead('<p>before</p>' +
+                '<video src="https://cdn.example.com/clip.mp4" poster="https://cdn.example.com/poster.jpg"></video>' +
+                '<p>after</p>');
+            expect(md).toContain('<video src="https://cdn.example.com/clip.mp4" controls poster="https://cdn.example.com/poster.jpg"></video>');
+            expect(md).toContain('before');
+            expect(md).toContain('after');
+        });
+        it('falls back to <source> inside <video> when src attribute is absent', async () => {
+            const md = await runAndRead('<video><source src="https://cdn.example.com/clip.mp4" type="video/mp4"></video>');
+            expect(md).toContain('<video src="https://cdn.example.com/clip.mp4" controls></video>');
+        });
+        it('drops <video> with no src and no <source>', async () => {
+            const md = await runAndRead('<p>before</p><video></video><p>after</p>');
+            expect(md).not.toContain('<video');
+            expect(md).toContain('before');
+            expect(md).toContain('after');
+        });
+        it('preserves <audio> as inline HTML', async () => {
+            const md = await runAndRead('<audio src="https://cdn.example.com/podcast.mp3"></audio>');
+            expect(md).toContain('<audio src="https://cdn.example.com/podcast.mp3" controls></audio>');
+        });
+        it('degrades <iframe> to a markdown link with title', async () => {
+            const md = await runAndRead('<iframe src="https://codepen.io/pen/abc" title="Live demo"></iframe>');
+            expect(md).toContain('[Live demo](https://codepen.io/pen/abc)');
+        });
+        it('defaults iframe title to "Embedded content" when missing', async () => {
+            const md = await runAndRead('<iframe src="https://example.com/embed"></iframe>');
+            expect(md).toContain('[Embedded content](https://example.com/embed)');
+        });
+        it('drops <iframe> with no src', async () => {
+            const md = await runAndRead('<p>before</p><iframe></iframe><p>after</p>');
+            expect(md).not.toContain('iframe');
+            expect(md).toContain('before');
+            expect(md).toContain('after');
+        });
+    });
+    describe('stdout mode', () => {
+        it('writes markdown to process.stdout and skips file write', async () => {
+            const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-article-'));
+            tempDirs.push(tempDir);
+            const chunks = [];
+            const originalWrite = process.stdout.write.bind(process.stdout);
+            process.stdout.write = ((chunk) => {
+                chunks.push(typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8'));
+                return true;
+            });
+            try {
+                const result = await downloadArticle({
+                    title: 'Piped',
+                    contentHtml: '<p>Streaming body</p>',
+                    sourceUrl: 'https://example.com/a',
+                }, {
+                    output: tempDir,
+                    stdout: true,
+                });
+                expect(result[0].status).toBe('success');
+                expect(result[0].saved).toBe('-');
+                expect(fs.readdirSync(tempDir)).toHaveLength(0);
+                const emitted = chunks.join('');
+                expect(emitted).toContain('# Piped');
+                expect(emitted).toContain('Streaming body');
+                expect(emitted.endsWith('\n')).toBe(true);
+            }
+            finally {
+                process.stdout.write = originalWrite;
+            }
+        });
+        it('keeps remote image URLs intact in stdout mode (no download)', async () => {
+            const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-article-'));
+            tempDirs.push(tempDir);
+            const chunks = [];
+            const originalWrite = process.stdout.write.bind(process.stdout);
+            process.stdout.write = ((chunk) => {
+                chunks.push(typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8'));
+                return true;
+            });
+            try {
+                await downloadArticle({
+                    title: 'WithImage',
+                    contentHtml: '<p><img src="https://example.com/a.jpg"></p>',
+                    imageUrls: ['https://example.com/a.jpg'],
+                }, {
+                    output: tempDir,
+                    downloadImages: true,
+                    stdout: true,
+                });
+                expect(fs.readdirSync(tempDir)).toHaveLength(0);
+                expect(chunks.join('')).toContain('https://example.com/a.jpg');
+            }
+            finally {
+                process.stdout.write = originalWrite;
+            }
+        });
+    });
 });

package/dist/src/download/index.js

@@ -60,94 +60,79 @@ export function requiresYtdlp(url) {
  */
 export async function httpDownload(url, destPath, options = {}, redirectCount = 0) {
     const { cookies, headers = {}, timeout = 30000, onProgress, maxRedirects = 10 } = options;
-    return new Promise((resolve) => {
-        const requestHeaders = {
-            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36',
-            ...headers,
-        };
-        if (cookies) {
-            requestHeaders['Cookie'] = cookies;
+    const requestHeaders = {
+        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36',
+        ...headers,
+    };
+    if (cookies) {
+        requestHeaders['Cookie'] = cookies;
+    }
+    const tempPath = `${destPath}.tmp`;
+    const cleanupTempFile = async () => {
+        try {
+            await fs.promises.rm(tempPath, { force: true });
         }
-        const tempPath = `${destPath}.tmp`;
-        let settled = false;
-        const finish = (result) => {
-            if (settled)
-                return;
-            settled = true;
-            resolve(result);
-        };
-        const cleanupTempFile = async () => {
-            try {
-                await fs.promises.rm(tempPath, { force: true });
-            }
-            catch {
-                // Ignore cleanup errors so the original failure is preserved.
-            }
-        };
-        void (async () => {
-            const controller = new AbortController();
-            const timer = setTimeout(() => controller.abort(), timeout);
-            try {
-                const response = await fetchWithNodeNetwork(url, {
-                    headers: requestHeaders,
-                    signal: controller.signal,
-                    redirect: 'manual',
-                });
-                clearTimeout(timer);
-                // Handle redirects before creating any file handles.
-                if (response.status >= 300 && response.status < 400) {
-                    const location = response.headers.get('location');
-                    if (location) {
-                        if (redirectCount >= maxRedirects) {
-                            finish({ success: false, size: 0, error: `Too many redirects (> ${maxRedirects})` });
-                            return;
-                        }
-                        const redirectUrl = resolveRedirectUrl(url, location);
-                        const originalHost = new URL(url).hostname;
-                        const redirectHost = new URL(redirectUrl).hostname;
-                        const redirectOptions = originalHost === redirectHost
-                            ? options
-                            : { ...options, cookies: undefined, headers: stripCookieHeaders(options.headers) };
-                        finish(await httpDownload(redirectUrl, destPath, redirectOptions, redirectCount + 1));
-                        return;
-                    }
-                }
-                if (response.status !== 200) {
-                    finish({ success: false, size: 0, error: `HTTP ${response.status}` });
-                    return;
-                }
-                if (!response.body) {
-                    finish({ success: false, size: 0, error: 'Empty response body' });
-                    return;
-                }
-                const totalSize = parseInt(response.headers.get('content-length') || '0', 10);
-                let received = 0;
-                const progressStream = new Transform({
-                    transform(chunk, _encoding, callback) {
-                        received += chunk.length;
-                        if (onProgress)
-                            onProgress(received, totalSize);
-                        callback(null, chunk);
-                    },
-                });
-                try {
-                    await fs.promises.mkdir(path.dirname(destPath), { recursive: true });
-                    await pipeline(Readable.fromWeb(response.body), progressStream, fs.createWriteStream(tempPath));
-                    await fs.promises.rename(tempPath, destPath);
-                    finish({ success: true, size: received });
-                }
-                catch (err) {
-                    await cleanupTempFile();
-                    finish({ success: false, size: 0, error: getErrorMessage(err) });
+        catch {
+            // Ignore cleanup errors so the original failure is preserved.
+        }
+    };
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+    try {
+        const response = await fetchWithNodeNetwork(url, {
+            headers: requestHeaders,
+            signal: controller.signal,
+            redirect: 'manual',
+        });
+        clearTimeout(timer);
+        // Handle redirects before creating any file handles.
+        if (response.status >= 300 && response.status < 400) {
+            const location = response.headers.get('location');
+            if (location) {
+                if (redirectCount >= maxRedirects) {
+                    return { success: false, size: 0, error: `Too many redirects (> ${maxRedirects})` };
                 }
+                const redirectUrl = resolveRedirectUrl(url, location);
+                const originalHost = new URL(url).hostname;
+                const redirectHost = new URL(redirectUrl).hostname;
+                const redirectOptions = originalHost === redirectHost
+                    ? options
+                    : { ...options, cookies: undefined, headers: stripCookieHeaders(options.headers) };
+                return httpDownload(redirectUrl, destPath, redirectOptions, redirectCount + 1);
             }
-            catch (err) {
-                clearTimeout(timer);
-                await cleanupTempFile();
-                finish({ success: false, size: 0, error: err instanceof Error ? err.message : String(err) });
-            }
-        })();
-    });
+        }
+        if (response.status !== 200) {
+            return { success: false, size: 0, error: `HTTP ${response.status}` };
+        }
+        if (!response.body) {
+            return { success: false, size: 0, error: 'Empty response body' };
+        }
+        const totalSize = parseInt(response.headers.get('content-length') || '0', 10);
+        let received = 0;
+        const progressStream = new Transform({
+            transform(chunk, _encoding, callback) {
+                received += chunk.length;
+                if (onProgress)
+                    onProgress(received, totalSize);
+                callback(null, chunk);
+            },
+        });
+        try {
+            await fs.promises.mkdir(path.dirname(destPath), { recursive: true });
+            await pipeline(Readable.fromWeb(response.body), progressStream, fs.createWriteStream(tempPath));
+            await fs.promises.rename(tempPath, destPath);
+            return { success: true, size: received };
+        }
+        catch (err) {
+            await cleanupTempFile();
+            return { success: false, size: 0, error: getErrorMessage(err) };
+        }
+    }
+    catch (err) {
+        clearTimeout(timer);
+        await cleanupTempFile();
+        return { success: false, size: 0, error: err instanceof Error ? err.message : String(err) };
+    }
 }
 export function resolveRedirectUrl(currentUrl, location) {
     return new URL(location, currentUrl).toString();
@@ -172,7 +157,9 @@ export function exportCookiesToNetscape(cookies, filePath) {
         const includeSubdomains = 'TRUE';
         const cookiePath = cookie.path || '/';
         const secure = cookie.secure ? 'TRUE' : 'FALSE';
-        const expiry = Math.floor(Date.now() / 1000) + 86400 * 365; // 1 year from now
+        const expiry = typeof cookie.expirationDate === 'number' && cookie.expirationDate > 0
+            ? Math.floor(cookie.expirationDate)
+            : Math.floor(Date.now() / 1000) + 86400 * 365; // fallback: 1 year from now
         const safeName = cookie.name.replace(/[\t\n\r]/g, '');
         const safeValue = cookie.value.replace(/[\t\n\r]/g, '');
         lines.push(`${domain}\t${includeSubdomains}\t${cookiePath}\t${secure}\t${expiry}\t${safeName}\t${safeValue}`);

package/dist/src/errors.js

@@ -107,11 +107,13 @@ export function getErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
 /** Serialize an error cause chain into a readable string. */
-function serializeCause(cause) {
+function serializeCause(cause, depth = 0) {
+    if (depth > 10)
+        return '(cause chain truncated)';
     if (cause instanceof Error) {
         const parts = [cause.message];
         if (cause.cause)
-            parts.push(`  caused by: ${serializeCause(cause.cause)}`);
+            parts.push(`  caused by: ${serializeCause(cause.cause, depth + 1)}`);
         return parts.join('\n');
     }
     return String(cause);

package/dist/src/errors.test.js

@@ -93,4 +93,17 @@ describe('toEnvelope', () => {
         expect(envelope.error.code).toBe('UNKNOWN');
         expect(envelope.error.message).toBe('string error');
     });
+    it('serializes deep cause chains without stack overflow', () => {
+        // Build a 20-level deep cause chain — should truncate at depth 10
+        let deepErr = new Error('root');
+        for (let i = 0; i < 20; i++) {
+            deepErr = new Error(`level-${i}`, { cause: deepErr });
+        }
+        const topErr = new CommandExecutionError('top');
+        topErr.cause = deepErr;
+        const envelope = toEnvelope(topErr);
+        const causeStr = envelope.error.cause ?? '';
+        expect(causeStr).toContain('(cause chain truncated)');
+        expect(causeStr).not.toContain('root'); // root is beyond depth 10
+    });
 });

package/dist/src/launcher.d.ts

@@ -22,7 +22,7 @@ export declare function detectProcess(processName: string): boolean;
 /**
  * Kill a process by name. Sends SIGTERM first, then SIGKILL after grace period.
  */
-export declare function killProcess(processName: string): void;
+export declare function killProcess(processName: string): Promise<void>;
 /**
  * Discover the app installation path on macOS.
  * Uses osascript to resolve the app name to a POSIX path.

package/dist/src/launcher.js

@@ -52,7 +52,7 @@ export function detectProcess(processName) {
 /**
  * Kill a process by name. Sends SIGTERM first, then SIGKILL after grace period.
  */
-export function killProcess(processName) {
+export async function killProcess(processName) {
     if (process.platform === 'win32')
         return; // pkill not available on Windows
     try {
@@ -65,7 +65,7 @@ export function killProcess(processName) {
     while (Date.now() < deadline) {
         if (!detectProcess(processName))
             return;
-        execFileSync('sleep', ['0.2'], { stdio: 'pipe' });
+        await new Promise((r) => setTimeout(r, 200));
     }
     try {
         execFileSync('pkill', ['-9', '-x', processName], { stdio: 'pipe' });
@@ -190,7 +190,7 @@ export async function resolveElectronEndpoint(site) {
             throw new CommandExecutionError(`${label} needs to be restarted with CDP enabled.`, `Manually restart: kill the app and relaunch with --remote-debugging-port=${port}`);
         }
         process.stderr.write(`  Restarting ${label}...\n`);
-        killProcess(processName);
+        await killProcess(processName);
     }
     // Step 3: Discover path
     const appPath = discoverAppPath(label);

package/dist/src/output.js

@@ -74,7 +74,7 @@ function renderTable(data, opts) {
     console.log(table.toString());
     const footer = [];
     footer.push(`${rows.length} items`);
-    if (opts.elapsed)
+    if (opts.elapsed !== undefined)
         footer.push(`${opts.elapsed.toFixed(1)}s`);
     if (opts.source)
         footer.push(opts.source);

package/dist/src/output.test.js

@@ -30,6 +30,12 @@ describe('output TTY detection', () => {
         const out = logSpy.mock.calls.map((c) => c[0]).join('\n');
         expect(JSON.parse(out)).toEqual([{ name: 'alice' }]);
     });
+    it('shows elapsed time when elapsed is 0', () => {
+        Object.defineProperty(process.stdout, 'isTTY', { value: true, writable: true });
+        render([{ name: 'alice' }], { fmt: 'table', columns: ['name'], elapsed: 0 });
+        const out = logSpy.mock.calls.map((c) => c[0]).join('\n');
+        expect(out).toContain('0.0s');
+    });
     it('explicit -f table overrides non-TTY auto-downgrade', () => {
         Object.defineProperty(process.stdout, 'isTTY', { value: false, writable: true });
         render([{ name: 'alice' }], { fmt: 'table', fmtExplicit: true, columns: ['name'] });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "1.7.6",
+  "version": "1.7.8",
   "publishConfig": {
     "access": "public"
   },
@@ -74,18 +74,22 @@
     "url": "git+https://github.com/jackwener/opencli.git"
   },
   "dependencies": {
+    "@mozilla/readability": "^0.6.0",
     "cli-table3": "^0.6.5",
     "commander": "^14.0.3",
     "js-yaml": "^4.1.0",
     "turndown": "^7.2.2",
+    "turndown-plugin-gfm": "^1.0.2",
     "undici": "^8.0.2",
     "ws": "^8.18.0"
   },
   "devDependencies": {
+    "@types/jsdom": "^27.0.0",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^25.5.2",
     "@types/turndown": "^5.0.6",
     "@types/ws": "^8.5.13",
+    "jsdom": "^29.0.2",
     "tsx": "^4.19.3",
     "typescript": "^6.0.2",
     "vitepress": "^1.6.4",