@vibemastery/zurf 0.2.2 → 0.3.0

package/dist/commands/fetch/index.js

@@ -1,9 +1,11 @@
 import { Args, Flags } from '@oclif/core';
 import * as fs from 'node:fs/promises';
 import path from 'node:path';
-import { cliError } from '../../lib/cli-errors.js';
+import { cliError, errorCode } from '../../lib/cli-errors.js';
+import { resolveFormat } from '../../lib/config.js';
 import { buildFetchJsonPayload, HUMAN_BODY_PREVIEW_CHARS, humanFetchMetaLines, truncateNote, } from '../../lib/fetch-output.js';
 import { zurfBaseFlags } from '../../lib/flags.js';
+import { htmlToMarkdown } from '../../lib/html-to-markdown.js';
 import { printJson } from '../../lib/json-output.js';
 import { ZurfBrowserbaseCommand } from '../../lib/zurf-browserbase-command.js';
 export default class Fetch extends ZurfBrowserbaseCommand {
@@ -13,12 +15,13 @@ export default class Fetch extends ZurfBrowserbaseCommand {
             required: true,
         }),
     };
-    static description = `Fetch a URL via Browserbase (no browser session; static HTML, 1 MB max).
-Requires authentication. Run \`zurf init --global\` or use a project key before first use.`;
+    static description = `Fetch a URL via Browserbase and return content as markdown (default) or raw HTML (no browser session; static HTML, 1 MB max).
+Requires authentication. Run \`zurf setup\` or use a project key before first use.`;
     static examples = [
         '<%= config.bin %> <%= command.id %> https://example.com',
+        '<%= config.bin %> <%= command.id %> https://example.com --html',
         '<%= config.bin %> <%= command.id %> https://example.com --json',
-        '<%= config.bin %> <%= command.id %> https://example.com -o page.html --proxies',
+        '<%= config.bin %> <%= command.id %> https://example.com -o page.md --proxies',
     ];
     static flags = {
         ...zurfBaseFlags,
@@ -39,7 +42,7 @@ Requires authentication. Run \`zurf init --global\` or use a project key before
             description: 'Route through Browserbase proxies (helps with some blocked sites)',
         }),
     };
-    static summary = 'Fetch a URL via Browserbase';
+    static summary = 'Fetch a URL via Browserbase and return content as markdown';
     async run() {
         const { args, flags } = await this.parse(Fetch);
         const url = args.url.trim();
@@ -68,24 +71,21 @@ Requires authentication. Run \`zurf init --global\` or use a project key before
                 proxies: flags.proxies,
                 url,
             });
+            const format = resolveFormat({ flagHtml: flags.html, globalConfigDir: this.config.configDir });
+            const content = format === 'markdown' ? await htmlToMarkdown(response.content) : response.content;
+            const converted = { ...response, content };
             if (flags.json) {
-                printJson(buildFetchJsonPayload(response));
+                printJson(buildFetchJsonPayload(converted, format));
                 return;
             }
             this.logToStderr(humanFetchMetaLines(response).join('\n'));
             this.logToStderr('');
             if (flags.output) {
                 try {
-                    await fs.writeFile(flags.output, response.content, 'utf8');
+                    await fs.writeFile(flags.output, content, 'utf8');
                 }
                 catch (error) {
-                    const code = error !== null &&
-                        typeof error === 'object' &&
-                        'code' in error &&
-                        typeof error.code === 'string'
-                        ? error.code
-                        : undefined;
-                    if (code === 'ENOENT') {
+                    if (errorCode(error) === 'ENOENT') {
                         cliError({
                             command: this,
                             exitCode: 1,
@@ -95,10 +95,9 @@ Requires authentication. Run \`zurf init --global\` or use a project key before
                     }
                     throw error;
                 }
-                this.logToStderr(`Wrote body to ${flags.output}`);
+                this.logToStderr(`Wrote content to ${flags.output}`);
                 return;
             }
-            const { content } = response;
             if (content.length <= HUMAN_BODY_PREVIEW_CHARS) {
                 this.log(content);
                 return;

package/dist/commands/search/index.d.ts

@@ -7,6 +7,7 @@ export default class Search extends ZurfBrowserbaseCommand {
     static examples: string[];
     static flags: {
         'num-results': import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        html: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     static summary: string;

package/dist/commands/search/index.js

@@ -12,7 +12,7 @@ export default class Search extends ZurfBrowserbaseCommand {
         }),
     };
     static description = `Search the web via Browserbase (Exa-powered).
-Requires authentication. Run \`zurf init --global\` or use a project key before first use.`;
+Requires authentication. Run \`zurf setup\` or use a project key before first use.`;
     static examples = [
         '<%= config.bin %> <%= command.id %> "browserbase documentation"',
         '<%= config.bin %> <%= command.id %> "laravel inertia" --num-results 5 --json',

package/dist/commands/{init → setup}/index.d.ts

@@ -1,15 +1,14 @@
 import { Command } from '@oclif/core';
-export default class Init extends Command {
+export default class Setup extends Command {
     static description: string;
     static examples: string[];
     static flags: {
-        'api-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        gitignore: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         global: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        local: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        local: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     static summary: string;
     run(): Promise<void>;
-    private readApiKeyForInit;
+    private collectProviderKeys;
+    private suggestGitignore;
 }

package/dist/commands/setup/index.js

@@ -0,0 +1,123 @@
+import { Command, Flags } from '@oclif/core';
+import * as fs from 'node:fs/promises';
+import { cliError, errorMessage } from '../../lib/cli-errors.js';
+import { globalConfigFilePath, localConfigPathForCwd, readConfigFile, writeConfig, } from '../../lib/config.js';
+import { zurfJsonFlag } from '../../lib/flags.js';
+import { dotGitignoreMentionsZurf, ensureZurfGitignoreEntry, gitignorePathForCwd, } from '../../lib/gitignore-zurf.js';
+import { printJson } from '../../lib/json-output.js';
+import { promptApiKey, promptProjectId, selectProviders, selectScope, } from '../../lib/setup-prompts.js';
+async function promptBrowserbase() {
+    const apiKey = await promptApiKey('Browserbase');
+    const projectId = await promptProjectId();
+    const browserbase = { apiKey: apiKey.trim() };
+    if (projectId.trim()) {
+        browserbase.projectId = projectId.trim();
+    }
+    return { configured: 'Browserbase', providers: { browserbase } };
+}
+async function promptPerplexity() {
+    const apiKey = await promptApiKey('Perplexity');
+    return { configured: 'Perplexity', providers: { perplexity: { apiKey: apiKey.trim() } } };
+}
+function resolveScope(flags) {
+    if (flags.global)
+        return 'global';
+    if (flags.local)
+        return 'local';
+    return undefined;
+}
+export default class Setup extends Command {
+    static description = `Interactive setup wizard for configuring API keys for all providers (Browserbase, Perplexity).
+Stores keys in global or local config. Re-run to update or add providers.`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --global',
+        '<%= config.bin %> <%= command.id %> --local',
+    ];
+    static flags = {
+        global: Flags.boolean({
+            description: 'Store config in user config directory (skip scope prompt)',
+        }),
+        json: zurfJsonFlag,
+        local: Flags.boolean({
+            description: 'Store config in .zurf/config.json in the current directory (skip scope prompt)',
+        }),
+    };
+    static summary = 'Configure API keys for Browserbase and Perplexity';
+    async run() {
+        const { flags } = await this.parse(Setup);
+        if (flags.global && flags.local) {
+            cliError({ command: this, exitCode: 2, json: flags.json, message: 'Cannot use both --global and --local.' });
+        }
+        const scope = resolveScope(flags) ?? (process.stdin.isTTY
+            ? await selectScope()
+            : cliError({
+                command: this,
+                exitCode: 1,
+                json: flags.json,
+                message: 'Non-interactive environment detected. Use --global or --local flag, or set API keys via environment variables (BROWSERBASE_API_KEY, PERPLEXITY_API_KEY).',
+            }));
+        const targetPath = scope === 'global'
+            ? globalConfigFilePath(this.config.configDir)
+            : localConfigPathForCwd();
+        const existing = readConfigFile(targetPath);
+        const bbConfigured = Boolean(existing?.providers?.browserbase?.apiKey);
+        const pplxConfigured = Boolean(existing?.providers?.perplexity?.apiKey);
+        const selectedProviders = process.stdin.isTTY
+            ? await selectProviders([
+                { configured: bbConfigured, name: 'Browserbase', value: 'browserbase' },
+                { configured: pplxConfigured, name: 'Perplexity', value: 'perplexity' },
+            ])
+            : ['browserbase', 'perplexity'];
+        const { configUpdate, configured } = await this.collectProviderKeys(selectedProviders);
+        try {
+            await writeConfig(targetPath, configUpdate);
+        }
+        catch (error) {
+            cliError({ command: this, exitCode: 1, json: flags.json, message: errorMessage(error) });
+        }
+        if (flags.json) {
+            printJson({ configured, ok: true, path: targetPath, scope });
+            return;
+        }
+        for (const name of configured) {
+            this.log(`Configured ${name} in ${targetPath}`);
+        }
+        if (scope === 'local') {
+            await this.suggestGitignore();
+        }
+    }
+    async collectProviderKeys(selectedProviders) {
+        const configUpdate = { providers: {} };
+        const configured = [];
+        for (const provider of selectedProviders) {
+            // eslint-disable-next-line no-await-in-loop -- sequential prompts, must run in order
+            const result = provider === 'browserbase' ? await promptBrowserbase() : await promptPerplexity();
+            Object.assign(configUpdate.providers, result.providers);
+            configured.push(result.configured);
+        }
+        return { configUpdate, configured };
+    }
+    async suggestGitignore() {
+        let showTip = true;
+        try {
+            const gi = await fs.readFile(gitignorePathForCwd(), 'utf8');
+            if (dotGitignoreMentionsZurf(gi)) {
+                showTip = false;
+            }
+        }
+        catch {
+            // no .gitignore yet
+        }
+        if (showTip) {
+            this.log('Tip: add .zurf/ to .gitignore so keys are not committed.');
+            try {
+                await ensureZurfGitignoreEntry(gitignorePathForCwd());
+                this.log('Added .zurf/ to .gitignore.');
+            }
+            catch {
+                // best effort
+            }
+        }
+    }
+}

package/dist/lib/browse-output.d.ts

@@ -0,0 +1,12 @@
+export interface BrowseJsonPayload {
+    content: string;
+    format: 'html' | 'markdown';
+    statusCode: null | number;
+    url: string;
+}
+export declare function humanBrowseMetaLines(options: {
+    statusCode: null | number;
+    url: string;
+}): string[];
+export declare const HUMAN_BODY_PREVIEW_CHARS = 8000;
+export declare function truncateNote(totalChars: number): string;

package/dist/lib/browse-output.js

@@ -0,0 +1,10 @@
+export function humanBrowseMetaLines(options) {
+    return [
+        `url: ${options.url}`,
+        `statusCode: ${options.statusCode ?? 'unknown'}`,
+    ];
+}
+export const HUMAN_BODY_PREVIEW_CHARS = 8000;
+export function truncateNote(totalChars) {
+    return `… truncated (${totalChars} chars). Use --output FILE to save the full content.`;
+}

package/dist/lib/browserbase-client.js

@@ -10,7 +10,7 @@ export async function createBrowserbaseClient(options) {
 }
 export class MissingApiKeyError extends Error {
     constructor() {
-        super('No Browserbase API key found. Set BROWSERBASE_API_KEY, run `zurf init --global` or `zurf init --local`, or add a project `.zurf/config.json`.');
+        super('No Browserbase API key found. Set BROWSERBASE_API_KEY, run `zurf setup`, or add a project `.zurf/config.json`.');
         this.name = 'MissingApiKeyError';
     }
 }

package/dist/lib/browserbase-session.d.ts

@@ -0,0 +1,7 @@
+import type { Browserbase } from '@browserbasehq/sdk';
+import type { Page } from 'playwright-core';
+export declare function withBrowserbaseSession<T>(options: {
+    client: Browserbase;
+    projectId: string;
+    work: (page: Page) => Promise<T>;
+}): Promise<T>;

package/dist/lib/browserbase-session.js

@@ -0,0 +1,39 @@
+export async function withBrowserbaseSession(options) {
+    const { chromium } = await import('playwright-core');
+    const { client, projectId, work } = options;
+    const session = await client.sessions.create({ projectId });
+    const browser = await chromium.connectOverCDP(session.connectUrl);
+    let cleanedUp = false;
+    const cleanup = async () => {
+        if (cleanedUp)
+            return;
+        cleanedUp = true;
+        try {
+            const pages = browser.contexts()[0]?.pages() ?? [];
+            await Promise.all(pages.map((p) => p.close().catch(() => { })));
+            await browser.close().catch(() => { });
+        }
+        finally {
+            await client.sessions.update(session.id, { status: 'REQUEST_RELEASE' }).catch(() => { });
+        }
+    };
+    const onSignal = () => {
+        // eslint-disable-next-line n/no-process-exit, unicorn/no-process-exit
+        cleanup().then(() => process.exit(1), () => process.exit(1));
+    };
+    process.on('SIGINT', onSignal);
+    process.on('SIGTERM', onSignal);
+    try {
+        const defaultContext = browser.contexts()[0];
+        if (!defaultContext) {
+            throw new Error('No browser context available from Browserbase session');
+        }
+        const page = defaultContext.pages()[0] ?? (await defaultContext.newPage());
+        return await work(page);
+    }
+    finally {
+        process.removeListener('SIGINT', onSignal);
+        process.removeListener('SIGTERM', onSignal);
+        await cleanup();
+    }
+}

package/dist/lib/cli-errors.d.ts

@@ -14,6 +14,7 @@ export declare class CliJsonExitContractError extends Error {
     constructor();
 }
 export declare function errorMessage(err: unknown): string;
+export declare function errorCode(err: unknown): string | undefined;
 export declare function errorStatus(err: unknown): number | undefined;
 /** Print JSON or human error and exit; does not return. */
 export declare function cliError(options: CliErrorOptions): never;

package/dist/lib/cli-errors.js

@@ -15,6 +15,15 @@ export function errorMessage(err) {
     }
     return String(err);
 }
+export function errorCode(err) {
+    if (err !== null &&
+        typeof err === 'object' &&
+        'code' in err &&
+        typeof err.code === 'string') {
+        return err.code;
+    }
+    return undefined;
+}
 export function errorStatus(err) {
     if (err !== null &&
         typeof err === 'object' &&

package/dist/lib/config.d.ts

@@ -18,17 +18,64 @@ export type ResolvedApiKey = {
 export type ActiveApiKey = Extract<ResolvedApiKey, {
     apiKey: string;
 }>;
-export interface ConfigFileShape {
+/** Old flat config shape (v0.2.x and earlier). */
+export interface LegacyConfigFileShape {
     apiKey?: string;
+    format?: 'html' | 'markdown';
+    projectId?: string;
+}
+/** Current config shape (v0.3.0+). */
+export interface ConfigFileShape {
+    format?: 'html' | 'markdown';
+    providers?: {
+        browserbase?: {
+            apiKey?: string;
+            projectId?: string;
+        };
+        perplexity?: {
+            apiKey?: string;
+        };
+    };
 }
+export type ResolvedProjectId = {
+    path: string;
+    projectId: string;
+    source: 'global';
+} | {
+    path: string;
+    projectId: string;
+    source: 'local';
+} | {
+    projectId: string;
+    source: 'env';
+} | {
+    source: 'none';
+};
+/** Alias — structurally identical to ResolvedApiKey; kept for semantic clarity at call sites. */
+export type ResolvedPerplexityApiKey = ResolvedApiKey;
 /**
  * Path to global `config.json` under oclif's `this.config.configDir` (same rules as @oclif/core `Config.dir('config')` for `dirname` zurf).
  */
 export declare function globalConfigFilePath(oclifConfigDir: string): string;
 export declare function localConfigPathForCwd(cwd?: string): string;
 export declare function findLocalConfigPath(startDir?: string): string | undefined;
+export declare function readConfigFile(filePath: string): ConfigFileShape | undefined;
+export declare function resolveFormat(options: {
+    cwd?: string;
+    flagHtml: boolean;
+    globalConfigDir: string;
+}): 'html' | 'markdown';
 export declare function resolveApiKey(options: {
     cwd?: string;
     globalConfigDir: string;
 }): ResolvedApiKey;
+export declare function resolveProjectId(options: {
+    cwd?: string;
+    globalConfigDir: string;
+}): ResolvedProjectId;
+export declare function resolvePerplexityApiKey(options: {
+    cwd?: string;
+    globalConfigDir: string;
+}): ResolvedPerplexityApiKey;
 export declare function writeApiKeyConfig(targetPath: string, apiKey: string): Promise<void>;
+export declare function writeConfig(targetPath: string, fields: Partial<ConfigFileShape>): Promise<void>;

package/dist/lib/config.js

@@ -26,17 +26,84 @@ export function findLocalConfigPath(startDir = process.cwd()) {
     }
     return undefined;
 }
-function readApiKeyFromFile(filePath) {
+/**
+ * Detect whether a parsed config object uses the old flat shape (has `apiKey` at root, no `providers` key).
+ */
+function isLegacyConfig(raw) {
+    if (raw === null || typeof raw !== 'object')
+        return false;
+    const obj = raw;
+    return ('apiKey' in obj || 'projectId' in obj) && !('providers' in obj);
+}
+/**
+ * Migrate a legacy flat config to the new nested shape.
+ */
+function migrateLegacyConfig(legacy) {
+    const config = {};
+    if (legacy.apiKey || legacy.projectId) {
+        config.providers = {
+            browserbase: {},
+        };
+        if (legacy.apiKey)
+            config.providers.browserbase.apiKey = legacy.apiKey;
+        if (legacy.projectId)
+            config.providers.browserbase.projectId = legacy.projectId;
+    }
+    if (legacy.format)
+        config.format = legacy.format;
+    return config;
+}
+export function readConfigFile(filePath) {
     try {
         const raw = fs.readFileSync(filePath, 'utf8');
         const parsed = JSON.parse(raw);
-        const key = typeof parsed.apiKey === 'string' ? parsed.apiKey.trim() : '';
-        return key.length > 0 ? key : undefined;
+        if (isLegacyConfig(parsed)) {
+            return migrateLegacyConfig(parsed);
+        }
+        return parsed;
     }
     catch {
         return undefined;
     }
 }
+function readStringField(filePath, getter) {
+    const parsed = readConfigFile(filePath);
+    if (!parsed)
+        return undefined;
+    const val = getter(parsed)?.trim() ?? '';
+    return val.length > 0 ? val : undefined;
+}
+const readBrowserbaseApiKeyFromFile = (f) => readStringField(f, (c) => c.providers?.browserbase?.apiKey);
+const readBrowserbaseProjectIdFromFile = (f) => readStringField(f, (c) => c.providers?.browserbase?.projectId);
+const readPerplexityApiKeyFromFile = (f) => readStringField(f, (c) => c.providers?.perplexity?.apiKey);
+function readFormatFromFile(filePath) {
+    const parsed = readConfigFile(filePath);
+    if (!parsed)
+        return undefined;
+    const fmt = parsed.format;
+    if (fmt === 'html' || fmt === 'markdown')
+        return fmt;
+    return undefined;
+}
+export function resolveFormat(options) {
+    if (options.flagHtml)
+        return 'html';
+    const envVal = process.env.ZURF_HTML?.trim().toLowerCase();
+    if (envVal === 'true' || envVal === '1')
+        return 'html';
+    const cwd = options.cwd ?? process.cwd();
+    const localPath = findLocalConfigPath(cwd);
+    if (localPath) {
+        const fmt = readFormatFromFile(localPath);
+        if (fmt)
+            return fmt;
+    }
+    const gPath = globalConfigFilePath(options.globalConfigDir);
+    const globalFmt = readFormatFromFile(gPath);
+    if (globalFmt)
+        return globalFmt;
+    return 'markdown';
+}
 export function resolveApiKey(options) {
     const cwd = options.cwd ?? process.cwd();
     const envKey = process.env.BROWSERBASE_API_KEY?.trim();
@@ -45,22 +112,98 @@ export function resolveApiKey(options) {
     }
     const localPath = findLocalConfigPath(cwd);
     if (localPath) {
-        const key = readApiKeyFromFile(localPath);
+        const key = readBrowserbaseApiKeyFromFile(localPath);
+        if (key) {
+            return { apiKey: key, path: localPath, source: 'local' };
+        }
+    }
+    const gPath = globalConfigFilePath(options.globalConfigDir);
+    const globalKey = readBrowserbaseApiKeyFromFile(gPath);
+    if (globalKey) {
+        return { apiKey: globalKey, path: gPath, source: 'global' };
+    }
+    return { source: 'none' };
+}
+export function resolveProjectId(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const envId = process.env.BROWSERBASE_PROJECT_ID?.trim();
+    if (envId) {
+        return { projectId: envId, source: 'env' };
+    }
+    const localPath = findLocalConfigPath(cwd);
+    if (localPath) {
+        const id = readBrowserbaseProjectIdFromFile(localPath);
+        if (id) {
+            return { path: localPath, projectId: id, source: 'local' };
+        }
+    }
+    const gPath = globalConfigFilePath(options.globalConfigDir);
+    const globalId = readBrowserbaseProjectIdFromFile(gPath);
+    if (globalId) {
+        return { path: gPath, projectId: globalId, source: 'global' };
+    }
+    return { source: 'none' };
+}
+export function resolvePerplexityApiKey(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const envKey = process.env.PERPLEXITY_API_KEY?.trim();
+    if (envKey) {
+        return { apiKey: envKey, source: 'env' };
+    }
+    const localPath = findLocalConfigPath(cwd);
+    if (localPath) {
+        const key = readPerplexityApiKeyFromFile(localPath);
         if (key) {
             return { apiKey: key, path: localPath, source: 'local' };
         }
     }
     const gPath = globalConfigFilePath(options.globalConfigDir);
-    const globalKey = readApiKeyFromFile(gPath);
+    const globalKey = readPerplexityApiKeyFromFile(gPath);
     if (globalKey) {
         return { apiKey: globalKey, path: gPath, source: 'global' };
     }
     return { source: 'none' };
 }
 export async function writeApiKeyConfig(targetPath, apiKey) {
+    await writeConfig(targetPath, { providers: { browserbase: { apiKey: apiKey.trim() } } });
+}
+export async function writeConfig(targetPath, fields) {
     const dir = path.dirname(targetPath);
     await fs.promises.mkdir(dir, { recursive: true });
-    const payload = { apiKey: apiKey.trim() };
-    const body = `${JSON.stringify(payload, null, 2)}\n`;
+    let existing = {};
+    try {
+        const raw = await fs.promises.readFile(targetPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        existing = isLegacyConfig(parsed) ? migrateLegacyConfig(parsed) : parsed;
+    }
+    catch {
+        // file doesn't exist yet — start fresh
+    }
+    const merged = {
+        ...existing,
+        ...fields,
+        providers: {
+            ...existing.providers,
+            ...fields.providers,
+            browserbase: {
+                ...existing.providers?.browserbase,
+                ...fields.providers?.browserbase,
+            },
+            perplexity: {
+                ...existing.providers?.perplexity,
+                ...fields.providers?.perplexity,
+            },
+        },
+    };
+    if (merged.providers?.browserbase && Object.keys(merged.providers.browserbase).length === 0) {
+        delete merged.providers.browserbase;
+    }
+    if (merged.providers?.perplexity && Object.keys(merged.providers.perplexity).length === 0) {
+        delete merged.providers.perplexity;
+    }
+    if (merged.providers && Object.keys(merged.providers).length === 0) {
+        delete merged.providers;
+    }
+    const body = `${JSON.stringify(merged, null, 2)}\n`;
     await fs.promises.writeFile(targetPath, body, { encoding: 'utf8', mode: 0o600 });
 }

package/dist/lib/fetch-output.d.ts

@@ -6,10 +6,11 @@ export type FetchResponseForDisplay = {
     id: string;
     statusCode: number;
 };
-export declare function buildFetchJsonPayload(response: FetchResponseForDisplay): {
+export declare function buildFetchJsonPayload(response: FetchResponseForDisplay, format: 'html' | 'markdown'): {
     content: string;
     contentType: string;
     encoding: string;
+    format: 'html' | 'markdown';
     headers: Record<string, string>;
     id: string;
     statusCode: number;

package/dist/lib/fetch-output.js

@@ -1,8 +1,9 @@
-export function buildFetchJsonPayload(response) {
+export function buildFetchJsonPayload(response, format) {
     return {
         content: response.content,
         contentType: response.contentType,
         encoding: response.encoding,
+        format,
         headers: response.headers,
         id: response.id,
         statusCode: response.statusCode,
@@ -19,5 +20,5 @@ export function humanFetchMetaLines(response) {
 /** ~8k chars keeps terminal scrollback usable while showing most HTML pages in preview. */
 export const HUMAN_BODY_PREVIEW_CHARS = 8000;
 export function truncateNote(totalChars) {
-    return `… truncated (${totalChars} chars). Use --output FILE to save the full body (within the 1 MB Fetch limit).`;
+    return `… truncated (${totalChars} chars). Use --output FILE to save the full content (within the 1 MB Fetch limit).`;
 }

package/dist/lib/flags.d.ts

@@ -1,6 +1,9 @@
 /** Machine-readable output; kept separate from oclif `enableJsonFlag` so error payloads match zurf's stdout JSON contract. */
 export declare const zurfJsonFlag: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+/** Output raw HTML instead of the default markdown conversion. */
+export declare const zurfHtmlFlag: import("@oclif/core/interfaces").BooleanFlag<boolean>;
 /** Shared flags for commands that support JSON output (no `--api-key` — use BROWSERBASE_API_KEY or config files). */
 export declare const zurfBaseFlags: {
+    readonly html: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     readonly json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
 };

package/dist/lib/flags.js

@@ -4,7 +4,14 @@ export const zurfJsonFlag = Flags.boolean({
     description: 'Print machine-readable JSON to stdout',
     env: 'ZURF_JSON',
 });
+/** Output raw HTML instead of the default markdown conversion. */
+export const zurfHtmlFlag = Flags.boolean({
+    default: false,
+    description: 'Output raw HTML instead of markdown',
+    env: 'ZURF_HTML',
+});
 /** Shared flags for commands that support JSON output (no `--api-key` — use BROWSERBASE_API_KEY or config files). */
 export const zurfBaseFlags = {
+    html: zurfHtmlFlag,
     json: zurfJsonFlag,
 };