@doxbrix/doxloop 0.1.4 → 0.2.0

package/dist/schedule.d.ts

@@ -0,0 +1,78 @@
+import type { SyncTrigger } from './types.js';
+export declare const SYNC_LOG_FILE: string;
+export interface DailyTime {
+    hour: number;
+    minute: number;
+}
+export type ScheduleFrequency = {
+    kind: 'interval';
+    minutes: number;
+} | {
+    kind: 'daily';
+    time: DailyTime;
+} | {
+    kind: 'weekdays';
+    time: DailyTime;
+} | {
+    kind: 'weekly';
+    weekday: number;
+    time: DailyTime;
+} | {
+    kind: 'monthly';
+    day: number;
+    time: DailyTime;
+};
+export interface ScheduleState {
+    installed: boolean;
+    label: string;
+    path?: string;
+    time?: DailyTime;
+    frequency?: ScheduleFrequency;
+    registered?: boolean;
+    running?: boolean;
+    runs?: number;
+    lastExitCode?: number;
+    logPath?: string;
+}
+/** The first `daily@HH:MM` trigger, or undefined when none is configured. */
+export declare function dailyTime(triggers: readonly SyncTrigger[]): DailyTime | undefined;
+export declare function scheduleFrequency(triggers: readonly SyncTrigger[]): ScheduleFrequency | undefined;
+export declare function formatScheduleFrequency(frequency: ScheduleFrequency): string;
+export declare function formatDailyTime(time: DailyTime): string;
+/**
+ * A stable per-project identifier. The directory name keeps it recognizable in
+ * `launchctl list` or `systemctl --user`, and the path hash keeps two projects
+ * with the same directory name apart.
+ */
+export declare function scheduleLabel(root: string): string;
+export declare function renderLaunchAgent(options: {
+    label: string;
+    root: string;
+    frequency: ScheduleFrequency;
+}): string;
+export declare function renderSystemdService(options: {
+    root: string;
+}): string;
+export declare function renderSystemdTimer(options: {
+    root: string;
+    frequency: ScheduleFrequency;
+}): string;
+/** `Persistent=true` and launchd both run a missed job once the machine wakes. */
+export declare function cronLine(options: {
+    label: string;
+    root: string;
+    frequency: ScheduleFrequency;
+}): string;
+export declare function installSchedule(root: string, frequency: ScheduleFrequency, platform?: NodeJS.Platform): Promise<ScheduleState>;
+export declare function removeSchedule(root: string, platform?: NodeJS.Platform): Promise<ScheduleState>;
+export declare function scheduleState(root: string, platform?: NodeJS.Platform): Promise<ScheduleState>;
+export declare function parseLaunchctlState(output: string): {
+    running: boolean;
+    runs?: number;
+    lastExitCode?: number;
+};
+/** Rewrite the user's crontab, preserving every line that is not ours. */
+export declare function withoutLabel(crontab: string, label: string, add?: string): string;
+export declare function readSyncLog(root: string, lines?: number): Promise<string[]>;
+export declare function appendSyncLog(root: string, message: string): Promise<void>;
+//# sourceMappingURL=schedule.d.ts.map

package/dist/schedule.js

@@ -0,0 +1,480 @@
+import { withProjectLock } from './project-lock.js';
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { appendFile, mkdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+import { DoxloopError } from './errors.js';
+import { pathExists } from './fs.js';
+const run = promisify(execFile);
+export const SYNC_LOG_FILE = join('.doxloop', 'sync.log');
+/** The first `daily@HH:MM` trigger, or undefined when none is configured. */
+export function dailyTime(triggers) {
+    for (const trigger of triggers) {
+        const match = /^daily@(\d{2}):(\d{2})$/.exec(trigger);
+        if (match)
+            return { hour: Number(match[1]), minute: Number(match[2]) };
+    }
+    return undefined;
+}
+export function scheduleFrequency(triggers) {
+    if (triggers.length > 1)
+        throw new DoxloopError('Choose one schedule per project.');
+    for (const trigger of triggers) {
+        const interval = /^every@(\d+)([mh])$/.exec(trigger);
+        if (interval) {
+            const amount = Number(interval[1]);
+            return { kind: 'interval', minutes: interval[2] === 'h' ? amount * 60 : amount };
+        }
+    }
+    for (const trigger of triggers) {
+        const weekdays = /^weekdays@(\d{2}):(\d{2})$/.exec(trigger);
+        if (weekdays)
+            return { kind: 'weekdays', time: { hour: Number(weekdays[1]), minute: Number(weekdays[2]) } };
+        const weekly = /^weekly@(sun|mon|tue|wed|thu|fri|sat)@(\d{2}):(\d{2})$/.exec(trigger);
+        if (weekly)
+            return {
+                kind: 'weekly',
+                weekday: WEEKDAYS.findIndex((day) => day === weekly[1]),
+                time: { hour: Number(weekly[2]), minute: Number(weekly[3]) },
+            };
+        const monthly = /^monthly@(\d{1,2})@(\d{2}):(\d{2})$/.exec(trigger);
+        if (monthly)
+            return {
+                kind: 'monthly',
+                day: Number(monthly[1]),
+                time: { hour: Number(monthly[2]), minute: Number(monthly[3]) },
+            };
+    }
+    const time = dailyTime(triggers);
+    return time ? { kind: 'daily', time } : undefined;
+}
+export function formatScheduleFrequency(frequency) {
+    if (frequency.kind === 'daily')
+        return `daily ${formatDailyTime(frequency.time)}`;
+    if (frequency.kind === 'weekdays')
+        return `weekdays ${formatDailyTime(frequency.time)}`;
+    if (frequency.kind === 'weekly')
+        return `weekly on ${WEEKDAY_LABELS[frequency.weekday]} at ${formatDailyTime(frequency.time)}`;
+    if (frequency.kind === 'monthly')
+        return `monthly on day ${frequency.day} at ${formatDailyTime(frequency.time)}`;
+    if (frequency.minutes % 60 === 0) {
+        const hours = frequency.minutes / 60;
+        return `every ${hours} hour${hours === 1 ? '' : 's'}`;
+    }
+    return `every ${frequency.minutes} minute${frequency.minutes === 1 ? '' : 's'}`;
+}
+export function formatDailyTime(time) {
+    return `${String(time.hour).padStart(2, '0')}:${String(time.minute).padStart(2, '0')}`;
+}
+const WEEKDAYS = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
+const WEEKDAY_LABELS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+function launchCalendar(frequency) {
+    const item = (extra = '') => `<dict>
+    ${extra}<key>Hour</key>
+    <integer>${frequency.time.hour}</integer>
+    <key>Minute</key>
+    <integer>${frequency.time.minute}</integer>
+  </dict>`;
+    if (frequency.kind === 'weekdays') {
+        return `<array>\n    ${[1, 2, 3, 4, 5].map((day) => item(`<key>Weekday</key>\n    <integer>${day}</integer>\n    `)).join('\n    ')}\n  </array>`;
+    }
+    if (frequency.kind === 'weekly')
+        return item(`<key>Weekday</key>\n    <integer>${frequency.weekday}</integer>\n    `);
+    if (frequency.kind === 'monthly')
+        return item(`<key>Day</key>\n    <integer>${frequency.day}</integer>\n    `);
+    return item();
+}
+function cronExpression(frequency) {
+    if (frequency.kind === 'interval') {
+        return '* * * * *'; // The locked elapsed-time gate in runSyncNow handles intervals.
+    }
+    const time = `${frequency.time.minute} ${frequency.time.hour}`;
+    if (frequency.kind === 'weekdays')
+        return `${time} * * 1-5`;
+    if (frequency.kind === 'weekly')
+        return `${time} * * ${frequency.weekday}`;
+    if (frequency.kind === 'monthly')
+        return `${time} ${frequency.day} * *`;
+    return `${time} * * *`;
+}
+function systemdCalendar(frequency) {
+    const time = `${formatDailyTime(frequency.time)}:00`;
+    if (frequency.kind === 'weekdays')
+        return `Mon..Fri *-*-* ${time}`;
+    if (frequency.kind === 'weekly')
+        return `${WEEKDAY_LABELS[frequency.weekday].slice(0, 3)} *-*-* ${time}`;
+    if (frequency.kind === 'monthly')
+        return `*-*-${String(frequency.day).padStart(2, '0')} ${time}`;
+    return `*-*-* ${time}`;
+}
+function windowsSchedule(frequency) {
+    if (frequency.kind === 'interval')
+        return { type: 'minute', arguments: ['/mo', String(frequency.minutes)] };
+    const start = ['/st', formatDailyTime(frequency.time)];
+    if (frequency.kind === 'weekdays')
+        return { type: 'weekly', arguments: ['/d', 'MON,TUE,WED,THU,FRI', ...start] };
+    if (frequency.kind === 'weekly')
+        return { type: 'weekly', arguments: ['/d', WEEKDAYS[frequency.weekday].toUpperCase(), ...start] };
+    if (frequency.kind === 'monthly')
+        return { type: 'monthly', arguments: ['/d', String(frequency.day), ...start] };
+    return { type: 'daily', arguments: start };
+}
+/**
+ * A stable per-project identifier. The directory name keeps it recognizable in
+ * `launchctl list` or `systemctl --user`, and the path hash keeps two projects
+ * with the same directory name apart.
+ */
+export function scheduleLabel(root) {
+    const slug = basename(root)
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '') || 'docs';
+    const digest = createHash('sha256').update(root).digest('hex').slice(0, 8);
+    return `doxloop-${slug}-${digest}`;
+}
+function cliPath() {
+    return fileURLToPath(new URL('cli.js', import.meta.url));
+}
+export function renderLaunchAgent(options) {
+    const escape = (value) => value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    // launchd opens stdout/stderr before spawning the process. macOS can reject
+    // that spawn when the destination is inside a protected Documents folder,
+    // so native scheduler diagnostics live in the user's Library logs instead.
+    const log = nativeScheduleLog(options.label);
+    // LaunchServices may reject a user-managed Node binary as the top-level
+    // executable. Start with Apple's signed shell, then exec the exact Node and
+    // CLI paths selected during setup.
+    const command = [
+        'exec',
+        shellQuote(process.execPath),
+        shellQuote(cliPath()),
+        'sync',
+        'now',
+        '--trigger',
+        'schedule',
+        '--cwd',
+        shellQuote(options.root),
+    ].join(' ');
+    const scheduledPath = process.env.PATH ?? '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin';
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.doxbrix.${escape(options.label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/bin/sh</string>
+    <string>-c</string>
+    <string>${escape(command)}</string>
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${escape(scheduledPath)}</string>
+    <key>HOME</key>
+    <string>${escape(homedir())}</string>
+  </dict>
+  ${options.frequency.kind !== 'interval' ? `<key>StartCalendarInterval</key>
+  ${launchCalendar(options.frequency)}` : `<key>StartInterval</key>
+  <integer>${options.frequency.minutes * 60}</integer>`}
+  <key>StandardOutPath</key>
+  <string>${escape(log)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escape(log)}</string>
+  <key>ProcessType</key>
+  <string>Background</string>
+</dict>
+</plist>
+`;
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+export function renderSystemdService(options) {
+    return `[Unit]
+Description=Doxloop documentation sync for ${options.root}
+
+[Service]
+Type=oneshot
+ExecStart=${process.execPath} ${cliPath()} sync now --trigger schedule --cwd ${options.root}
+StandardOutput=append:${join(options.root, SYNC_LOG_FILE)}
+StandardError=append:${join(options.root, SYNC_LOG_FILE)}
+`;
+}
+export function renderSystemdTimer(options) {
+    return `[Unit]
+Description=Doxloop documentation sync for ${options.root}
+
+[Timer]
+${options.frequency.kind === 'interval' ? `OnUnitActiveSec=${options.frequency.minutes}m` : `OnCalendar=${systemdCalendar(options.frequency)}`}
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`;
+}
+/** `Persistent=true` and launchd both run a missed job once the machine wakes. */
+export function cronLine(options) {
+    if (/[\r\n]/.test(options.root))
+        throw new DoxloopError('Scheduled project paths cannot contain line breaks.');
+    const log = join(options.root, SYNC_LOG_FILE);
+    const expression = cronExpression(options.frequency);
+    const quote = (value) => `'${value.replace(/'/g, `\'\"\'\"\'`).replace(/%/g, '\\%')}'`;
+    return `${expression} ${quote(process.execPath)} ${quote(cliPath())} sync now --trigger schedule --cwd ${quote(options.root)} >> ${quote(log)} 2>&1 # ${options.label}`;
+}
+export async function installSchedule(root, frequency, platform = process.platform) {
+    const label = scheduleLabel(root);
+    if (platform === 'darwin') {
+        const path = join(homedir(), 'Library', 'LaunchAgents', `com.doxbrix.${label}.plist`);
+        await mkdir(join(homedir(), 'Library', 'LaunchAgents'), { recursive: true });
+        await mkdir(join(homedir(), 'Library', 'Logs', 'Doxloop'), { recursive: true });
+        await writeFile(path, renderLaunchAgent({ label, root, frequency }), 'utf8');
+        await launchctl(['bootout', `gui/${process.getuid?.() ?? 0}`, path]);
+        await launchctl(['bootstrap', `gui/${process.getuid?.() ?? 0}`, path], true);
+        try {
+            const health = await smokeLaunchAgent(label);
+            return {
+                installed: true,
+                label,
+                path,
+                ...(frequency.kind !== 'interval' ? { time: frequency.time } : {}),
+                frequency,
+                registered: true,
+                logPath: nativeScheduleLog(label),
+                ...health,
+            };
+        }
+        catch (error) {
+            await launchctl(['bootout', `gui/${process.getuid?.() ?? 0}`, path]);
+            await rm(path, { force: true });
+            await rm(nativeScheduleLog(label), { force: true });
+            throw error;
+        }
+    }
+    if (platform === 'linux') {
+        if (await hasSystemdUser()) {
+            const directory = join(homedir(), '.config', 'systemd', 'user');
+            await mkdir(directory, { recursive: true });
+            await writeFile(join(directory, `${label}.service`), renderSystemdService({ root }), 'utf8');
+            await writeFile(join(directory, `${label}.timer`), renderSystemdTimer({ root, frequency }), 'utf8');
+            await systemctl(['daemon-reload']);
+            await systemctl(['enable', '--now', `${label}.timer`], true);
+            return { installed: true, label, path: join(directory, `${label}.timer`), frequency };
+        }
+        await writeCrontab(await crontabWithout(label, cronLine({ label, root, frequency })));
+        return { installed: true, label, frequency };
+    }
+    if (platform === 'win32') {
+        await run('schtasks', [
+            '/create',
+            '/f',
+            '/tn',
+            label,
+            '/sc',
+            windowsSchedule(frequency).type,
+            ...windowsSchedule(frequency).arguments,
+            '/tr',
+            `"${process.execPath}" "${cliPath()}" sync now --trigger schedule --cwd "${root}"`,
+        ]);
+        return { installed: true, label, frequency };
+    }
+    throw new DoxloopError(`Scheduled documentation sync is not supported on ${platform}. Run \`doxloop sync now\` from your own scheduler instead.`);
+}
+export async function removeSchedule(root, platform = process.platform) {
+    const label = scheduleLabel(root);
+    if (platform === 'darwin') {
+        const path = join(homedir(), 'Library', 'LaunchAgents', `com.doxbrix.${label}.plist`);
+        await launchctl(['bootout', `gui/${process.getuid?.() ?? 0}`, path]);
+        await rm(path, { force: true });
+        await rm(nativeScheduleLog(label), { force: true });
+        return { installed: false, label, path, logPath: nativeScheduleLog(label) };
+    }
+    if (platform === 'linux') {
+        const directory = join(homedir(), '.config', 'systemd', 'user');
+        if (await pathExists(join(directory, `${label}.timer`))) {
+            await systemctl(['disable', '--now', `${label}.timer`]);
+            await rm(join(directory, `${label}.timer`), { force: true });
+            await rm(join(directory, `${label}.service`), { force: true });
+            await systemctl(['daemon-reload']);
+            return { installed: false, label };
+        }
+        await writeCrontab(await crontabWithout(label));
+        return { installed: false, label };
+    }
+    if (platform === 'win32') {
+        await run('schtasks', ['/delete', '/f', '/tn', label]).catch(() => undefined);
+        return { installed: false, label };
+    }
+    return { installed: false, label };
+}
+export async function scheduleState(root, platform = process.platform) {
+    const label = scheduleLabel(root);
+    if (platform === 'darwin') {
+        const path = join(homedir(), 'Library', 'LaunchAgents', `com.doxbrix.${label}.plist`);
+        const installed = await pathExists(path);
+        if (!installed) {
+            return {
+                installed: false,
+                label,
+                path,
+                registered: false,
+                logPath: nativeScheduleLog(label),
+            };
+        }
+        const native = await launchAgentState(label);
+        return native
+            ? {
+                installed: true,
+                label,
+                path,
+                registered: true,
+                logPath: nativeScheduleLog(label),
+                ...native,
+            }
+            : {
+                installed: true,
+                label,
+                path,
+                registered: false,
+                logPath: nativeScheduleLog(label),
+            };
+    }
+    if (platform === 'linux') {
+        const path = join(homedir(), '.config', 'systemd', 'user', `${label}.timer`);
+        if (await pathExists(path))
+            return { installed: true, label, path };
+        return { installed: (await currentCrontab()).includes(`# ${label}`), label };
+    }
+    if (platform === 'win32') {
+        const found = await run('schtasks', ['/query', '/tn', label])
+            .then(() => true)
+            .catch(() => false);
+        return { installed: found, label };
+    }
+    return { installed: false, label };
+}
+function nativeScheduleLog(label) {
+    return join(homedir(), 'Library', 'Logs', 'Doxloop', `${label}.log`);
+}
+export function parseLaunchctlState(output) {
+    const runs = /\bruns = (\d+)/.exec(output);
+    const lastExit = /\blast exit code = (\d+)/.exec(output);
+    return {
+        running: /\bstate = running\b/.test(output),
+        ...(runs ? { runs: Number(runs[1]) } : {}),
+        ...(lastExit ? { lastExitCode: Number(lastExit[1]) } : {}),
+    };
+}
+async function launchAgentState(label) {
+    try {
+        const service = `gui/${process.getuid?.() ?? 0}/com.doxbrix.${label}`;
+        return parseLaunchctlState((await run('launchctl', ['print', service])).stdout);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function smokeLaunchAgent(label) {
+    const before = await launchAgentState(label);
+    const service = `gui/${process.getuid?.() ?? 0}/com.doxbrix.${label}`;
+    await launchctl(['kickstart', '-k', service], true);
+    const deadline = Date.now() + 8_000;
+    while (Date.now() < deadline) {
+        const state = await launchAgentState(label);
+        if (state?.running)
+            return state;
+        if (state && (state.runs ?? 0) > (before?.runs ?? 0)) {
+            // Exit 1 is the documented check-mode signal for detected drift. It
+            // still proves that launchd started Node and reached the Doxloop CLI.
+            if (state.lastExitCode === 0 || state.lastExitCode === 1)
+                return state;
+            if (state.lastExitCode !== undefined) {
+                throw new DoxloopError(`The scheduled sync started but failed its setup smoke test with exit ${state.lastExitCode}.`);
+            }
+        }
+        await new Promise((resolveWait) => setTimeout(resolveWait, 200));
+    }
+    throw new DoxloopError('The scheduled sync did not start during its setup smoke test.');
+}
+async function launchctl(args, required = false) {
+    try {
+        await run('launchctl', args);
+    }
+    catch (error) {
+        // `bootout` fails when nothing is loaded, which is the normal install path.
+        if (required) {
+            throw new DoxloopError(`Could not register the scheduled sync with launchd: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+async function systemctl(args, required = false) {
+    try {
+        await run('systemctl', ['--user', ...args]);
+    }
+    catch (error) {
+        if (required) {
+            throw new DoxloopError(`Could not register the scheduled sync with systemd: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+async function hasSystemdUser() {
+    try {
+        await run('systemctl', ['--user', 'show-environment']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function currentCrontab() {
+    try {
+        return (await run('crontab', ['-l'])).stdout;
+    }
+    catch {
+        return '';
+    }
+}
+/** Rewrite the user's crontab, preserving every line that is not ours. */
+export function withoutLabel(crontab, label, add) {
+    const lines = crontab
+        .split('\n')
+        .filter((line) => line.trim() !== '' && !line.includes(`# ${label}`));
+    if (add)
+        lines.push(add);
+    return lines.length === 0 ? '' : `${lines.join('\n')}\n`;
+}
+async function crontabWithout(label, add) {
+    return withoutLabel(await currentCrontab(), label, add);
+}
+async function writeCrontab(content) {
+    const path = join(homedir(), `.doxloop-crontab-${process.pid}`);
+    await writeFile(path, content, 'utf8');
+    try {
+        await run('crontab', [path]);
+    }
+    finally {
+        await rm(path, { force: true });
+    }
+}
+export async function readSyncLog(root, lines = 20) {
+    const path = join(root, SYNC_LOG_FILE);
+    if (!(await pathExists(path)))
+        return [];
+    const content = await readFile(path, 'utf8');
+    return content.split('\n').filter(Boolean).slice(-lines);
+}
+export async function appendSyncLog(root, message) {
+    await withProjectLock(root, 'monitor-log', async () => {
+        const path = join(root, SYNC_LOG_FILE);
+        const size = await stat(path).then((info) => info.size).catch((error) => { if (error.code === 'ENOENT')
+            return 0; throw error; });
+        if (size >= 1_048_576)
+            await rename(path, `${path}.1`);
+        await appendFile(path, `${new Date().toISOString()}  ${message.replace(/[\r\n]+/g, ' ').slice(0, 8000)}\n`, { mode: 0o600 });
+    });
+}
+//# sourceMappingURL=schedule.js.map

package/dist/screen-capture-provider.d.ts

@@ -0,0 +1,52 @@
+import type { CaptureAuthMaterial, CaptureStorageState } from './capture-auth.js';
+import type { ApplicationConfig } from './types.js';
+export declare const SCREEN_CAPTURE_SERVER = "doxloop_capture";
+export interface ScreenCaptureProvider {
+    name: typeof SCREEN_CAPTURE_SERVER;
+    command: string;
+    args: string[];
+}
+export interface ScreenCaptureBrowserReadiness {
+    available: boolean;
+    message: string;
+}
+/** Launch the same Chrome channel used by the MCP server, then close it. */
+export declare function checkScreenCaptureBrowser(): Promise<ScreenCaptureBrowserReadiness>;
+export interface CaptureSignInSession {
+    /** The page the window opened on. */
+    url: string;
+    /** Where the user currently is, or the last known page once the window closed. */
+    currentUrl(): string;
+    /** Whether the Chrome window is still open. */
+    open(): boolean;
+    /** Snapshot cookies and local storage now, or return the last snapshot if the window has closed. */
+    state(): Promise<CaptureStorageState | undefined>;
+    /** Snapshot the session and close the window. */
+    finish(): Promise<CaptureStorageState>;
+    /** Close the window without keeping anything. */
+    cancel(): Promise<void>;
+}
+/**
+ * Open a visible Chrome window on the application's sign-in page so the user
+ * can authenticate by hand, including MFA, SSO, and passkeys. The session is
+ * snapshotted every couple of seconds while the window is open, so closing
+ * the window early still leaves the last signed-in state to save.
+ */
+export declare function startCaptureSignIn(application: ApplicationConfig): Promise<CaptureSignInSession>;
+/**
+ * Build a private Playwright MCP server for one authoring run. The server is
+ * passed directly to the selected agent, so users do not have to install or
+ * configure a browser plugin in Codex or Claude Code themselves.
+ */
+export declare function screenCaptureProvider(workspace: string, application: ApplicationConfig, auth?: Pick<CaptureAuthMaterial, 'storageStatePath' | 'secretsPath'>, outputDirectory?: string): ScreenCaptureProvider;
+export declare function codexCaptureArguments(provider: ScreenCaptureProvider, required: boolean): string[];
+export declare function claudeCaptureArguments(provider: ScreenCaptureProvider): string[];
+/**
+ * Gemini CLI has no flag for a one-off MCP server: it reads `mcpServers` from
+ * the project's `.gemini/settings.json`. Merge the run's capture server into
+ * that file, keeping every other setting the user has there. `trust` lets the
+ * capture tools run without a confirmation Gemini cannot get unattended.
+ */
+export declare function writeGeminiCaptureSettings(root: string, provider?: ScreenCaptureProvider): Promise<string>;
+export declare function geminiCaptureServer(provider: ScreenCaptureProvider): Record<string, unknown>;
+//# sourceMappingURL=screen-capture-provider.d.ts.map