@agentrhq/webcmd 0.1.1 → 0.2.0

package/dist/src/doctor.js

@@ -0,0 +1,174 @@
+/**
+ * webcmd doctor — diagnose browser connectivity.
+ *
+ * Simplified for the daemon-based architecture.
+ */
+import { DEFAULT_DAEMON_PORT } from './constants.js';
+import { BrowserBridge } from './browser/index.js';
+import { setDaemonCommandTimeoutSeconds } from './browser/daemon-client.js';
+import { getDaemonHealth } from './browser/daemon-transport.js';
+import { getErrorMessage } from './errors.js';
+import { getRuntimeLabel } from './runtime-detect.js';
+import { aliasForContextId, loadProfileConfig } from './browser/profile.js';
+import { formatDaemonVersion, isDaemonStale, staleDaemonIssue } from './browser/daemon-version.js';
+import { findShadowedUserAdapters, formatAdapterShadowIssue } from './adapter-shadow.js';
+const DOCTOR_LIVE_TIMEOUT_SECONDS = 8;
+const DOCTOR_SESSION = '__doctor__';
+/**
+ * Test connectivity by attempting a real browser command.
+ */
+export async function checkConnectivity(opts) {
+    const start = Date.now();
+    const timeoutSeconds = opts?.timeout ?? DOCTOR_LIVE_TIMEOUT_SECONDS;
+    setDaemonCommandTimeoutSeconds(timeoutSeconds);
+    try {
+        const bridge = new BrowserBridge();
+        const page = await bridge.connect({
+            timeout: timeoutSeconds,
+            session: DOCTOR_SESSION,
+            surface: 'browser',
+        });
+        try {
+            // Try a simple eval to verify end-to-end connectivity.
+            await page.evaluate('1 + 1');
+            await page.closeWindow?.();
+        }
+        finally {
+            await bridge.close();
+        }
+        return { ok: true, durationMs: Date.now() - start };
+    }
+    catch (err) {
+        return { ok: false, error: getErrorMessage(err), durationMs: Date.now() - start };
+    }
+    finally {
+        setDaemonCommandTimeoutSeconds(null);
+    }
+}
+export async function runBrowserDoctor(opts = {}) {
+    // Live connectivity check is the core of doctor — it doubles as auto-start
+    // (bridge.connect spawns daemon) and validates end-to-end browser bridge health.
+    const connectivity = await checkConnectivity();
+    // Single status read *after* connectivity side-effects settle.
+    const health = await getDaemonHealth();
+    const daemonRunning = health.state !== 'stopped';
+    const runtimeConnected = health.state === 'ready';
+    const daemonFlaky = connectivity.ok && !daemonRunning;
+    const runtimeFlaky = connectivity.ok && daemonRunning && !runtimeConnected;
+    const daemonStale = isDaemonStale(health.status, opts.cliVersion);
+    const profiles = health.status?.profiles;
+    const runtimeName = health.status?.runtimeName;
+    const runtimeVersion = health.status?.runtimeVersion;
+    const adapterShadows = findShadowedUserAdapters();
+    const issues = [];
+    if (daemonFlaky) {
+        issues.push('Daemon connectivity is unstable. The live browser test succeeded, but the daemon was no longer running immediately afterward.\n' +
+            'This usually means the daemon crashed or exited right after serving the live probe.');
+    }
+    else if (!daemonRunning) {
+        issues.push('Daemon is not running. It should start automatically when you run a webcmd browser command.');
+    }
+    if (daemonStale && opts.cliVersion) {
+        issues.push(staleDaemonIssue(health.status, opts.cliVersion));
+    }
+    if (runtimeFlaky) {
+        issues.push('Cloak runtime connection is unstable. The live browser test succeeded, but the daemon reported the runtime disconnected immediately afterward.\n' +
+            'This usually means Chrome/Chromium or the Cloak runtime is still starting, reconnecting, or was suspended.');
+    }
+    else if (daemonRunning && !runtimeConnected) {
+        if (health.state === 'profile-required') {
+            issues.push('Multiple Chrome profiles are connected to the daemon, but no default profile was selected.\n' +
+                '  Run webcmd profile list, then webcmd profile use <name>, or pass --profile <name>.');
+        }
+        else if (health.state === 'profile-disconnected') {
+            issues.push(`Selected browser profile is not connected: ${health.status?.contextId ?? 'unknown'}.\n` +
+                '  Open that Chrome profile and make sure Cloak is enabled.');
+        }
+        else {
+            issues.push('Daemon is running but the Cloak runtime is not connected.\n' +
+                '  Make sure Chrome/Chromium is open and Cloak is enabled.\n' +
+                '  If Chrome is already open, try: webcmd daemon restart');
+        }
+    }
+    if (!connectivity.ok) {
+        issues.push(`Browser connectivity test failed: ${connectivity.error ?? 'unknown'}`);
+    }
+    if (adapterShadows.length > 0) {
+        issues.push(formatAdapterShadowIssue(adapterShadows));
+    }
+    return {
+        cliVersion: opts.cliVersion,
+        daemonRunning,
+        daemonFlaky,
+        daemonStale,
+        daemonVersion: health.status?.daemonVersion,
+        runtimeConnected,
+        runtimeFlaky,
+        runtimeName,
+        runtimeVersion,
+        connectivity,
+        profiles,
+        adapterShadows,
+        issues,
+    };
+}
+export function renderBrowserDoctorReport(report) {
+    const lines = [`webcmd v${report.cliVersion ?? 'unknown'} doctor` + ` (${getRuntimeLabel()})`, ''];
+    // Daemon status
+    const daemonIcon = report.daemonFlaky
+        ? '[WARN]'
+        : report.daemonStale
+            ? '[WARN]'
+            : report.daemonRunning ? '[OK]' : '[MISSING]';
+    const daemonLabel = report.daemonFlaky
+        ? 'unstable (running during live check, then stopped)'
+        : report.daemonRunning
+            ? `running on port ${DEFAULT_DAEMON_PORT} (${report.daemonStale
+                ? `${formatDaemonVersion(report)}, stale; CLI v${report.cliVersion ?? 'unknown'}`
+                : formatDaemonVersion(report)})`
+            : 'not running';
+    lines.push(`${daemonIcon} Daemon: ${daemonLabel}`);
+    // Runtime status
+    const runtimeIcon = report.runtimeFlaky
+        ? '[WARN]'
+        : report.runtimeConnected ? '[OK]' : '[MISSING]';
+    const runtimeVersion = !report.runtimeConnected
+        ? ''
+        : report.runtimeVersion
+            ? ` (v${report.runtimeVersion})`
+            : ' (version unknown)';
+    const runtimeName = report.runtimeName ?? 'Cloak';
+    const runtimeLabel = report.runtimeFlaky
+        ? 'unstable (connected during live check, then disconnected)'
+        : report.runtimeConnected ? 'connected' : 'not connected';
+    lines.push(`${runtimeIcon} Runtime: ${runtimeName} ${runtimeLabel}${runtimeVersion}`);
+    if (report.profiles && report.profiles.length > 0) {
+        const config = loadProfileConfig();
+        lines.push('', 'Profiles:');
+        for (const profile of report.profiles) {
+            const alias = aliasForContextId(config, profile.contextId);
+            const aliasText = alias ? ` (${alias})` : '';
+            const defaultText = config.defaultContextId === profile.contextId ? ', default' : '';
+            const version = profile.runtimeVersion ? `v${profile.runtimeVersion}` : 'version unknown';
+            lines.push(`  • ${profile.contextId}${aliasText}: connected ${version}${defaultText}`);
+        }
+    }
+    // Connectivity
+    if (report.connectivity) {
+        const connIcon = report.connectivity.ok ? '[OK]' : '[FAIL]';
+        const detail = report.connectivity.ok
+            ? `connected in ${(report.connectivity.durationMs / 1000).toFixed(1)}s`
+            : `failed (${report.connectivity.error ?? 'unknown'})`;
+        lines.push(`${connIcon} Connectivity: ${detail}`);
+    }
+    if (report.issues.length) {
+        lines.push('', 'Issues:');
+        for (const issue of report.issues) {
+            lines.push(`  • ${issue}`);
+        }
+    }
+    else if (report.daemonRunning && report.runtimeConnected) {
+        lines.push('', 'Everything looks good!');
+    }
+    return lines.join('\n');
+}

package/dist/src/doctor.test.d.ts

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

package/dist/src/doctor.test.js

@@ -0,0 +1,309 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { mockGetDaemonHealth, mockConnect, mockClose, mockFindShadowedUserAdapters, mockSetDaemonCommandTimeoutSeconds, } = vi.hoisted(() => ({
+    mockGetDaemonHealth: vi.fn(),
+    mockConnect: vi.fn(),
+    mockClose: vi.fn(),
+    mockFindShadowedUserAdapters: vi.fn(),
+    mockSetDaemonCommandTimeoutSeconds: vi.fn(),
+}));
+vi.mock('./browser/daemon-transport.js', () => ({
+    getDaemonHealth: mockGetDaemonHealth,
+}));
+vi.mock('./browser/index.js', () => ({
+    BrowserBridge: class {
+        connect = mockConnect;
+        close = mockClose;
+    },
+}));
+vi.mock('./browser/daemon-client.js', () => ({
+    setDaemonCommandTimeoutSeconds: mockSetDaemonCommandTimeoutSeconds,
+}));
+vi.mock('./adapter-shadow.js', async () => {
+    const actual = await vi.importActual('./adapter-shadow.js');
+    return {
+        ...actual,
+        findShadowedUserAdapters: mockFindShadowedUserAdapters,
+    };
+});
+import { renderBrowserDoctorReport, runBrowserDoctor } from './doctor.js';
+describe('doctor report rendering', () => {
+    const strip = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockFindShadowedUserAdapters.mockReturnValue([]);
+        mockSetDaemonCommandTimeoutSeconds.mockClear();
+        // Doctor always runs live connectivity. Tests that want connect to fail override.
+        mockConnect.mockResolvedValue({
+            evaluate: vi.fn().mockResolvedValue(2),
+            closeWindow: vi.fn().mockResolvedValue(undefined),
+        });
+        mockClose.mockResolvedValue(undefined);
+    });
+    it('renders OK-style report when daemon and runtime connected', () => {
+        const text = strip(renderBrowserDoctorReport({
+            cliVersion: '1.7.9',
+            daemonRunning: true,
+            daemonVersion: '1.7.9',
+            runtimeConnected: true,
+            runtimeName: 'Cloak',
+            runtimeVersion: '1.6.8',
+            issues: [],
+        }));
+        expect(text).toContain('[OK] Daemon: running on port 19825');
+        expect(text).toContain('(v1.7.9)');
+        expect(text).toContain('[OK] Runtime: Cloak connected (v1.6.8)');
+        expect(text).toContain('Everything looks good!');
+        expect(text).not.toContain('webcmd browser analyze <url>');
+    });
+    it('renders a warning when daemon version is stale', () => {
+        const text = strip(renderBrowserDoctorReport({
+            cliVersion: '1.7.9',
+            daemonRunning: true,
+            daemonVersion: '1.7.6',
+            daemonStale: true,
+            runtimeConnected: true,
+            runtimeName: 'Cloak',
+            runtimeVersion: '1.0.3',
+            issues: ['Stale daemon detected: daemon v1.7.6 != CLI v1.7.9.\n  Run: webcmd daemon restart'],
+        }));
+        expect(text).toContain('[WARN] Daemon: running on port 19825 (v1.7.6, stale; CLI v1.7.9)');
+        expect(text).toContain('Run: webcmd daemon restart');
+        expect(text).not.toContain('Everything looks good!');
+    });
+    it('renders MISSING when daemon not running', () => {
+        const text = strip(renderBrowserDoctorReport({
+            daemonRunning: false,
+            runtimeConnected: false,
+            issues: ['Daemon is not running.'],
+        }));
+        expect(text).toContain('[MISSING] Daemon: not running');
+        expect(text).toContain('[MISSING] Runtime: Cloak not connected');
+        expect(text).toContain('Daemon is not running.');
+    });
+    it('renders runtime not connected when daemon is running', () => {
+        const text = strip(renderBrowserDoctorReport({
+            daemonRunning: true,
+            runtimeConnected: false,
+            issues: ['Daemon is running but the Cloak runtime is not connected.'],
+        }));
+        expect(text).toContain('[OK] Daemon: running on port 19825');
+        expect(text).toContain('[MISSING] Runtime: Cloak not connected');
+    });
+    it('renders OK when the connected Cloak runtime version is unknown', () => {
+        const text = strip(renderBrowserDoctorReport({
+            daemonRunning: true,
+            runtimeConnected: true,
+            runtimeName: 'Cloak',
+            issues: [],
+        }));
+        expect(text).toContain('[OK] Runtime: Cloak connected (version unknown)');
+        expect(text).not.toContain('Cloak runtime is connected but did not report a version.');
+        expect(text).toContain('Everything looks good!');
+    });
+    it('renders connectivity OK when live test succeeds', () => {
+        const text = strip(renderBrowserDoctorReport({
+            daemonRunning: true,
+            runtimeConnected: true,
+            connectivity: { ok: true, durationMs: 1234 },
+            issues: [],
+        }));
+        expect(text).toContain('[OK] Connectivity: connected in 1.2s');
+    });
+    it('renders connected profiles when multiple are present', () => {
+        const text = strip(renderBrowserDoctorReport({
+            daemonRunning: true,
+            runtimeConnected: false,
+            profiles: [
+                { contextId: 'work', runtimeConnected: true, runtimeVersion: '1.2.3', pending: 0 },
+                { contextId: 'personal', runtimeConnected: true, runtimeVersion: '1.2.3', pending: 0 },
+            ],
+            issues: [],
+        }));
+        expect(text).toContain('Profiles:');
+        expect(text).toContain('work: connected v1.2.3');
+        expect(text).toContain('personal: connected v1.2.3');
+    });
+    it('renders unstable runtime state when live connectivity and status disagree', () => {
+        const text = strip(renderBrowserDoctorReport({
+            daemonRunning: true,
+            runtimeConnected: true,
+            runtimeFlaky: true,
+            runtimeName: 'Cloak',
+            connectivity: { ok: true, durationMs: 1234 },
+            issues: ['Cloak runtime connection is unstable.'],
+        }));
+        expect(text).toContain('[WARN] Runtime: Cloak unstable');
+        expect(text).toContain('Cloak runtime connection is unstable.');
+    });
+    it('renders unstable daemon state when live connectivity and status disagree', () => {
+        const text = strip(renderBrowserDoctorReport({
+            daemonRunning: false,
+            daemonFlaky: true,
+            runtimeConnected: false,
+            connectivity: { ok: true, durationMs: 1234 },
+            issues: ['Daemon connectivity is unstable.'],
+        }));
+        expect(text).toContain('[WARN] Daemon: unstable');
+        expect(text).toContain('Daemon connectivity is unstable.');
+    });
+    it('reports daemon not running when connectivity fails and daemon stays stopped', async () => {
+        mockConnect.mockRejectedValueOnce(new Error('Could not start daemon'));
+        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'stopped', status: null });
+        const report = await runBrowserDoctor();
+        expect(report.daemonRunning).toBe(false);
+        expect(report.runtimeConnected).toBe(false);
+        expect(report.connectivity?.ok).toBe(false);
+        expect(report.issues).toEqual(expect.arrayContaining([
+            expect.stringContaining('Daemon is not running'),
+        ]));
+    });
+    it('reports flapping when live check succeeds but final status shows runtime disconnected', async () => {
+        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'no-runtime', status: { runtimeConnected: false, runtimeName: 'Cloak' } });
+        const report = await runBrowserDoctor();
+        expect(report.daemonRunning).toBe(true);
+        expect(report.runtimeConnected).toBe(false);
+        expect(report.runtimeFlaky).toBe(true);
+        expect(report.issues).toEqual(expect.arrayContaining([
+            expect.stringContaining('Cloak runtime connection is unstable'),
+        ]));
+    });
+    it('uses runtime-neutral readiness hints when the runtime is disconnected', async () => {
+        mockConnect.mockRejectedValueOnce(new Error('runtime unavailable'));
+        mockGetDaemonHealth.mockResolvedValueOnce({
+            state: 'no-runtime',
+            status: { runtimeConnected: false, runtimeName: 'Cloak' },
+        });
+        const report = await runBrowserDoctor();
+        const issues = report.issues.join('\n');
+        expect(issues).toContain('Cloak runtime is not connected');
+        expect(issues).toContain('Make sure Chrome/Chromium is open and Cloak is enabled');
+        expect(issues).not.toContain(`Webcmd Browser ${'Bridge'}`);
+        expect(issues).not.toContain(`Load ${'unpacked'}`);
+        expect(issues).not.toContain('Download the latest extension');
+    });
+    it('reports daemon flapping when live check succeeds but daemon disappears afterward', async () => {
+        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'stopped', status: null });
+        const report = await runBrowserDoctor();
+        expect(report.daemonRunning).toBe(false);
+        expect(report.daemonFlaky).toBe(true);
+        expect(report.runtimeConnected).toBe(false);
+        expect(report.issues).toEqual(expect.arrayContaining([
+            expect.stringContaining('Daemon connectivity is unstable'),
+        ]));
+    });
+    it('uses the fast default timeout for live connectivity checks', async () => {
+        let timeoutSeen;
+        const closeWindow = vi.fn().mockResolvedValue(undefined);
+        mockConnect.mockImplementationOnce(async (opts) => {
+            timeoutSeen = opts?.timeout;
+            expect(opts?.session).toBe('__doctor__');
+            expect(opts?.surface).toBe('browser');
+            return {
+                evaluate: vi.fn().mockResolvedValue(2),
+                closeWindow,
+            };
+        });
+        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'ready', status: { runtimeConnected: true, runtimeName: 'Cloak' } });
+        await runBrowserDoctor();
+        expect(timeoutSeen).toBe(8);
+        expect(closeWindow).toHaveBeenCalledTimes(1);
+        expect(mockSetDaemonCommandTimeoutSeconds).toHaveBeenNthCalledWith(1, 8);
+        expect(mockSetDaemonCommandTimeoutSeconds).toHaveBeenLastCalledWith(null);
+    });
+    it('does not report an issue when the connected Cloak runtime does not report a version', async () => {
+        const status = {
+            state: 'ready',
+            status: {
+                runtimeConnected: true,
+                runtimeName: 'Cloak',
+                runtimeVersion: undefined,
+            },
+        };
+        mockGetDaemonHealth.mockResolvedValue(status);
+        const report = await runBrowserDoctor();
+        expect(report.runtimeConnected).toBe(true);
+        expect(report.runtimeVersion).toBeUndefined();
+        expect(report.issues.join('\n')).not.toContain('did not report a version');
+    });
+    it('does not compare runtime version to CLI version or cached extension updates', async () => {
+        const status = {
+            state: 'ready',
+            status: {
+                daemonVersion: '1.7.9',
+                runtimeConnected: true,
+                runtimeName: 'Cloak',
+                runtimeVersion: '99.0.0',
+            },
+        };
+        mockGetDaemonHealth.mockResolvedValue(status);
+        const report = await runBrowserDoctor({ cliVersion: '1.7.9' });
+        expect(report.runtimeVersion).toBe('99.0.0');
+        expect(report.issues.join('\n')).not.toContain('Extension major version mismatch');
+        expect(report.issues.join('\n')).not.toContain('Extension update available');
+        expect(report.issues.join('\n')).not.toContain('Download the latest extension');
+    });
+    it('reports an issue when daemon version differs from CLI version', async () => {
+        const status = {
+            state: 'ready',
+            status: {
+                daemonVersion: '1.7.6',
+                runtimeConnected: true,
+                runtimeName: 'Cloak',
+                runtimeVersion: '1.0.3',
+            },
+        };
+        mockGetDaemonHealth.mockResolvedValue(status);
+        const report = await runBrowserDoctor({ cliVersion: '1.7.9' });
+        expect(report.daemonStale).toBe(true);
+        expect(report.issues).toEqual(expect.arrayContaining([
+            expect.stringContaining('Stale daemon detected: daemon v1.7.6 != CLI v1.7.9'),
+        ]));
+    });
+    it('reports local adapter shadows as a warning issue', async () => {
+        const status = {
+            state: 'ready',
+            status: {
+                daemonVersion: '1.7.9',
+                runtimeConnected: true,
+                runtimeName: 'Cloak',
+                runtimeVersion: '1.0.3',
+            },
+        };
+        mockGetDaemonHealth.mockResolvedValue(status);
+        mockFindShadowedUserAdapters.mockReturnValueOnce([
+            {
+                name: 'instagram/saved',
+                userPath: '/home/me/.webcmd/clis/instagram/saved.js',
+                builtinPath: '/pkg/clis/instagram/saved.js',
+            },
+        ]);
+        const report = await runBrowserDoctor({ cliVersion: '1.7.9' });
+        expect(report.adapterShadows).toHaveLength(1);
+        expect(report.issues).toEqual(expect.arrayContaining([
+            expect.stringContaining('Local adapter overrides shadow packaged adapters'),
+        ]));
+    });
+    it('reports profile-required when multiple profiles are connected without a selection', async () => {
+        const status = {
+            state: 'profile-required',
+            status: {
+                runtimeConnected: false,
+                runtimeName: 'Cloak',
+                profileRequired: true,
+                profiles: [
+                    { contextId: 'work', runtimeConnected: true, pending: 0 },
+                    { contextId: 'personal', runtimeConnected: true, pending: 0 },
+                ],
+            },
+        };
+        mockGetDaemonHealth.mockResolvedValue(status);
+        // Real connectivity would fail in profile-required state; force it here so
+        // the test exercises the profile-required issue path, not the flaky path.
+        mockConnect.mockRejectedValueOnce(new Error('profile required'));
+        const report = await runBrowserDoctor();
+        expect(report.profiles).toHaveLength(2);
+        expect(report.issues).toEqual(expect.arrayContaining([
+            expect.stringContaining('Multiple Chrome profiles are connected'),
+        ]));
+    });
+});

package/dist/src/download/article-download.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Article download helper — shared logic for downloading articles as Markdown.
+ *
+ * Used by article adapters that export readable web pages as Markdown.
+ *
+ * Flow: ArticleData → TurndownService → image download → frontmatter → .md file
+ */
+import TurndownService from 'turndown';
+export interface ArticleData {
+    title: string;
+    author?: string;
+    publishTime?: string;
+    sourceUrl?: string;
+    contentHtml: string;
+    /** Pre-extracted code blocks to restore after Markdown conversion */
+    codeBlocks?: Array<{
+        lang: string;
+        code: string;
+    }>;
+    /** Image URLs found in the article (pre-collected from DOM) */
+    imageUrls?: string[];
+}
+export interface FrontmatterLabels {
+    author?: string;
+    publishTime?: string;
+    sourceUrl?: string;
+}
+export interface ArticleDownloadOptions {
+    output: string;
+    downloadImages?: boolean;
+    /** Extra headers for image downloads (e.g. { Referer: '...' }) */
+    imageHeaders?: Record<string, string>;
+    maxTitleLength?: number;
+    /** Custom TurndownService configuration callback */
+    configureTurndown?: (td: TurndownService) => void;
+    /** Custom image extension detector (default: infer from URL extension) */
+    detectImageExt?: (url: string) => string;
+    /** Custom frontmatter labels (default: English labels) */
+    frontmatterLabels?: FrontmatterLabels;
+    /**
+     * Extra CSS selectors removed from the article before Turndown conversion.
+     * Use this to drop site-specific noise the adapter can't always trim upstream
+     * (e.g. social widgets, reward panels, wiki infoboxes).
+     */
+    cleanSelectors?: string[];
+    /**
+     * Write the markdown to `process.stdout` instead of a file on disk. Image
+     * download and directory creation are skipped — remote image URLs are kept
+     * as-is so the output is self-contained when piped.
+     */
+    stdout?: boolean;
+}
+export interface ArticleDownloadResult {
+    title: string;
+    author: string;
+    publish_time: string;
+    status: string;
+    size: string;
+    saved: string;
+}
+/**
+ * Download an article to Markdown with optional image localization.
+ *
+ * Handles the full pipeline:
+ * 1. HTML → Markdown (via TurndownService)
+ * 2. Code block placeholder restoration
+ * 3. Batch image downloading with concurrency + deduplication
+ * 4. Image URL replacement in Markdown
+ * 5. Frontmatter generation (customizable labels)
+ * 6. File write
+ */
+export declare function downloadArticle(data: ArticleData, options: ArticleDownloadOptions): Promise<ArticleDownloadResult[]>;