openclaw-zero-video 0.0.0-stage → 0.1.4

package/dist/jobs.js

@@ -0,0 +1,689 @@
+import { createHash, randomBytes, randomUUID } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { copyFile, mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { ToolError, assertJobId, assertPrompt } from './config.js';
+const execFileAsync = promisify(execFile);
+const TERMINAL = new Set(['succeeded', 'failed', 'cancelled']);
+function nowIso() {
+    return new Date().toISOString();
+}
+function isTerminal(state) {
+    return TERMINAL.has(state);
+}
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new ToolError('CANCELLED'));
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(new ToolError('CANCELLED'));
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+function parseBalance(text) {
+    const match = text.replace(/,/g, '').match(/-?\d+(?:\.\d+)?/);
+    if (!match)
+        return null;
+    const value = Number(match[0]);
+    return Number.isFinite(value) ? value : null;
+}
+function sha256Text(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function errorCode(error) {
+    return error instanceof ToolError ? error.code : 'TOOL_FAILED';
+}
+function errorMessage(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.replace(/https?:\/\/\S+/g, '[url]').slice(0, 400);
+}
+function classifySubmitError(message) {
+    if (/moderation|policy|violat|blocked|inappropriate|safety|not allowed/i.test(message)) {
+        return 'MODERATION_BLOCKED';
+    }
+    if (/credit|quota|limit|insufficient/i.test(message))
+        return 'QUOTA_EXHAUSTED';
+    return 'SUBMIT_FAILED';
+}
+function safeName(value) {
+    return value.replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 120) || 'file';
+}
+function quoteRemote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+export class JobStore {
+    config;
+    jobsDir;
+    constructor(config) {
+        this.config = config;
+        this.jobsDir = path.join(config.stateDir, 'jobs');
+    }
+    async init() {
+        await mkdir(this.jobsDir, { recursive: true, mode: 0o700 });
+    }
+    async write(record) {
+        await this.init();
+        const target = path.join(this.jobsDir, `${record.id}.json`);
+        const temp = `${target}.tmp-${process.pid}-${Date.now()}`;
+        await writeFile(temp, `${JSON.stringify(record, null, 2)}\n`, { mode: 0o600 });
+        await rename(temp, target);
+    }
+    async create(record) {
+        await this.write(record);
+        return record;
+    }
+    async get(id) {
+        assertJobId(id);
+        try {
+            const raw = await readFile(path.join(this.jobsDir, `${id}.json`), 'utf8');
+            return JSON.parse(raw);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                throw new ToolError('UNKNOWN_JOB');
+            throw new ToolError('JOB_FILE_INVALID');
+        }
+    }
+    async update(id, patch) {
+        const current = await this.get(id);
+        const next = { ...current, ...patch, updatedAt: nowIso() };
+        await this.write(next);
+        return next;
+    }
+    async listRecent(limit = 20) {
+        await this.init();
+        const names = (await readdir(this.jobsDir)).filter((name) => name.endsWith('.json'));
+        const records = [];
+        for (const name of names) {
+            try {
+                records.push(JSON.parse(await readFile(path.join(this.jobsDir, name), 'utf8')));
+            }
+            catch {
+                // Skip a corrupt record; it is reported by explicit get().
+            }
+        }
+        records.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+        return records.slice(0, limit);
+    }
+    async findActiveByProvider(site) {
+        const records = await this.listRecent(500);
+        return records.find((record) => record.site === site && !isTerminal(record.state));
+    }
+}
+export class LedgerStore {
+    config;
+    ledgerDir;
+    constructor(config) {
+        this.config = config;
+        this.ledgerDir = path.join(config.stateDir, 'ledger');
+    }
+    async read(providerId) {
+        await mkdir(this.ledgerDir, { recursive: true, mode: 0o700 });
+        try {
+            const raw = await readFile(path.join(this.ledgerDir, `${providerId}.json`), 'utf8');
+            return JSON.parse(raw);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw new ToolError('LEDGER_INVALID');
+            return {
+                providerId,
+                lastBalance: null,
+                spentToday: 0,
+                windowStart: nowIso(),
+                updatedAt: nowIso(),
+            };
+        }
+    }
+    async write(ledger) {
+        await mkdir(this.ledgerDir, { recursive: true, mode: 0o700 });
+        const target = path.join(this.ledgerDir, `${ledger.providerId}.json`);
+        const temp = `${target}.tmp-${process.pid}-${Date.now()}`;
+        await writeFile(temp, `${JSON.stringify(ledger, null, 2)}\n`, { mode: 0o600 });
+        await rename(temp, target);
+    }
+    async get(providerId) {
+        return this.read(providerId);
+    }
+    async observe(providerId, balance) {
+        const ledger = await this.read(providerId);
+        if (balance !== null) {
+            if (ledger.lastBalance !== null && balance > ledger.lastBalance) {
+                ledger.spentToday = 0;
+                ledger.windowStart = nowIso();
+            }
+            ledger.lastBalance = balance;
+        }
+        ledger.updatedAt = nowIso();
+        await this.write(ledger);
+        return ledger;
+    }
+    canSpend(provider, ledger, balance) {
+        if (provider.dailyCap > 0 && ledger.spentToday + provider.creditCost > provider.dailyCap) {
+            throw new ToolError('DAILY_CAP_REACHED');
+        }
+        if (balance !== null && balance < provider.creditCost) {
+            throw new ToolError('QUOTA_EXHAUSTED');
+        }
+    }
+    async record(providerId, before, after, fallbackCost) {
+        const ledger = await this.read(providerId);
+        let spent = fallbackCost;
+        if (before !== null && after !== null)
+            spent = Math.max(0, before - after);
+        ledger.spentToday += spent;
+        if (after !== null)
+            ledger.lastBalance = after;
+        ledger.updatedAt = nowIso();
+        await this.write(ledger);
+        return ledger;
+    }
+}
+export class Ssh {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    validate(remote) {
+        const prefix = `${this.config.cosmosDownloadsDir}/`;
+        if (!remote.startsWith(prefix) || remote.includes('..'))
+            throw new ToolError('INVALID_REMOTE_PATH');
+    }
+    async run(command, timeout = 30_000) {
+        const { stdout } = await execFileAsync('ssh', [
+            '-i', this.config.sshKey,
+            '-o', 'BatchMode=yes',
+            '-o', 'ConnectTimeout=6',
+            '-o', 'StrictHostKeyChecking=no',
+            `root@${this.config.sshHost}`,
+            command,
+        ], { timeout, maxBuffer: 8 * 1024 * 1024 });
+        return String(stdout);
+    }
+    container() {
+        return this.config.containerName;
+    }
+    transferDir() {
+        return `/tmp/zero-video-transfer/${randomUUID()}`;
+    }
+    async mkdir(remote) {
+        this.validate(remote);
+        await this.run(`docker exec ${this.container()} mkdir -p ${quoteRemote(remote)}`);
+    }
+    async list(remote) {
+        this.validate(remote);
+        const stdout = await this.run(`docker exec ${this.container()} find ${quoteRemote(remote)} -maxdepth 1 -type f -printf '%T@\\t%f\\t%s\\n' 2>/dev/null | sort -rn | head -20`);
+        return stdout
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => {
+            const [mtime, name, size] = line.split('\t');
+            return { mtime: Number(mtime), name, size: Number(size) };
+        })
+            .filter((item) => item.name && Number.isFinite(item.size));
+    }
+    async copyFrom(remote, local) {
+        this.validate(remote);
+        const hostDir = this.transferDir();
+        const name = path.posix.basename(remote);
+        try {
+            await this.run(`mkdir -p ${quoteRemote(hostDir)}`);
+            await this.run(`docker cp ${quoteRemote(`${this.container()}:${remote}`)} ${quoteRemote(hostDir)}/`, 120_000);
+            await execFileAsync('scp', [
+                '-q',
+                '-i', this.config.sshKey,
+                '-o', 'BatchMode=yes',
+                '-o', 'ConnectTimeout=6',
+                '-o', 'StrictHostKeyChecking=no',
+                `root@${this.config.sshHost}:${hostDir}/${name}`,
+                local,
+            ], { timeout: 120_000, maxBuffer: 8 * 1024 * 1024 });
+        }
+        finally {
+            await this.run(`rm -rf ${quoteRemote(hostDir)}`).catch(() => undefined);
+        }
+    }
+    async put(local, remote) {
+        this.validate(remote);
+        const hostDir = this.transferDir();
+        const name = safeName(path.basename(local));
+        try {
+            await this.run(`mkdir -p ${quoteRemote(hostDir)}`);
+            await execFileAsync('scp', [
+                '-q',
+                '-i', this.config.sshKey,
+                '-o', 'BatchMode=yes',
+                '-o', 'ConnectTimeout=6',
+                '-o', 'StrictHostKeyChecking=no',
+                local,
+                `root@${this.config.sshHost}:${hostDir}/${name}`,
+            ], { timeout: 120_000, maxBuffer: 8 * 1024 * 1024 });
+            await this.run(`docker cp ${quoteRemote(`${hostDir}/${name}`)} ${quoteRemote(`${this.container()}:${remote}`)}`, 120_000);
+        }
+        finally {
+            await this.run(`rm -rf ${quoteRemote(hostDir)}`).catch(() => undefined);
+        }
+    }
+    async remove(remote) {
+        this.validate(remote);
+        await this.run(`docker exec ${this.container()} rm -rf ${quoteRemote(remote)}`);
+    }
+}
+export class MediaStore {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async ffprobe(file) {
+        let stdout;
+        try {
+            const result = await execFileAsync('ffprobe', ['-v', 'error', '-print_format', 'json', '-show_format', '-show_streams', file], { timeout: 30_000, maxBuffer: 8 * 1024 * 1024 });
+            stdout = String(result.stdout);
+        }
+        catch {
+            throw new ToolError('VERIFY_FAILED');
+        }
+        const data = JSON.parse(stdout);
+        const stream = data.streams?.find((item) => item.codec_type === 'video');
+        const durationSec = Number(data.format?.duration ?? stream?.duration ?? 0);
+        if (!stream || !Number.isFinite(durationSec) || durationSec <= 0)
+            throw new ToolError('INVALID_MEDIA');
+        return {
+            durationSec,
+            width: stream.width,
+            height: stream.height,
+            codec: stream.codec_name,
+        };
+    }
+    async sha256(file) {
+        const hash = createHash('sha256');
+        for await (const chunk of createReadStream(file))
+            hash.update(chunk);
+        return hash.digest('hex');
+    }
+    async verify(file) {
+        const info = await stat(file);
+        if (info.size <= 0)
+            throw new ToolError('INVALID_MEDIA');
+        if (info.size > this.config.maxDownloadBytes)
+            throw new ToolError('TOO_LARGE');
+        const ext = path.extname(file).toLowerCase();
+        if (!['.mp4', '.webm', '.mov', '.mkv'].includes(ext))
+            throw new ToolError('INVALID_MEDIA');
+        const probe = await this.ffprobe(file);
+        return {
+            path: file,
+            bytes: info.size,
+            sha256: await this.sha256(file),
+            ...probe,
+        };
+    }
+    async store(tempFile, job) {
+        const artifact = await this.verify(tempFile);
+        const date = new Date();
+        const dir = path.join(this.config.mediaDir, String(date.getUTCFullYear()), String(date.getUTCMonth() + 1).padStart(2, '0'));
+        await mkdir(dir, { recursive: true });
+        const ext = path.extname(tempFile).toLowerCase();
+        const target = path.join(dir, `${job.id}${ext}`);
+        try {
+            await rename(tempFile, target);
+        }
+        catch {
+            await copyFile(tempFile, target);
+            await rm(tempFile, { force: true });
+        }
+        artifact.path = target;
+        const manifest = {
+            ...job,
+            artifact,
+            storedAt: nowIso(),
+        };
+        await writeFile(`${target}.json`, `${JSON.stringify(manifest, null, 2)}\n`, { mode: 0o600 });
+        return artifact;
+    }
+}
+export class Runner {
+    config;
+    driver;
+    providers;
+    jobs;
+    ledgers;
+    media;
+    ssh;
+    log;
+    active = new Map();
+    constructor(config, driver, providers, jobs, ledgers, media, ssh, log = () => undefined) {
+        this.config = config;
+        this.driver = driver;
+        this.providers = providers;
+        this.jobs = jobs;
+        this.ledgers = ledgers;
+        this.media = media;
+        this.ssh = ssh;
+        this.log = log;
+    }
+    async submit(request, signal) {
+        const provider = await this.providers.get(request.site);
+        if (!provider.enabled)
+            throw new ToolError('PROVIDER_DISABLED');
+        if (!provider.busyIndicator && !provider.readyIndicator)
+            throw new ToolError('PROVIDER_INCOMPLETE');
+        if (this.active.has(provider.id))
+            throw new ToolError('PROVIDER_BUSY');
+        if (this.active.size >= this.config.maxParallel)
+            throw new ToolError('TOO_MANY_JOBS');
+        const prompt = assertPrompt(request.prompt, this.config);
+        if (request.negativePrompt !== undefined && request.negativePrompt.length > 2000) {
+            throw new ToolError('INVALID_REQUEST');
+        }
+        if (request.durationSec !== undefined && (!Number.isInteger(request.durationSec) || request.durationSec < 1 || request.durationSec > 60)) {
+            throw new ToolError('INVALID_REQUEST');
+        }
+        if (request.imagePath !== undefined) {
+            const info = await stat(request.imagePath).catch(() => undefined);
+            if (!info?.isFile())
+                throw new ToolError('IMAGE_NOT_FOUND');
+            if (info.size > 50 * 1024 * 1024)
+                throw new ToolError('IMAGE_TOO_LARGE');
+            if (!['.jpg', '.jpeg', '.png', '.webp'].includes(path.extname(request.imagePath).toLowerCase())) {
+                throw new ToolError('INVALID_IMAGE');
+            }
+        }
+        const id = `${provider.id}-${Date.now().toString(36)}-${randomBytes(3).toString('hex')}`;
+        let job = await this.jobs.create({
+            id,
+            site: provider.id,
+            state: 'queued',
+            prompt: this.config.storePrompts ? prompt : undefined,
+            promptHash: sha256Text(prompt),
+            negativePrompt: request.negativePrompt,
+            model: request.model,
+            durationSec: request.durationSec,
+            aspect: request.aspect,
+            imagePath: request.imagePath,
+            createdAt: nowIso(),
+            updatedAt: nowIso(),
+        });
+        let page;
+        try {
+            job = await this.jobs.update(job.id, { state: 'opening' });
+            page = await this.driver.open(provider.url, signal);
+            const promptReady = await page.waitFor(provider.promptInput, 20_000, signal);
+            if (!promptReady) {
+                if (provider.loginCheck && !(await page.isVisible(provider.loginCheck).catch(() => false))) {
+                    throw new ToolError('LOGIN_REQUIRED');
+                }
+                throw new ToolError('INPUT_NOT_FOUND');
+            }
+            if (provider.loginCheck && !(await page.isVisible(provider.loginCheck))) {
+                throw new ToolError('LOGIN_REQUIRED');
+            }
+            // Let the SPA finish mounting the editor and submit handlers before typing.
+            await sleep(provider.readinessMs ?? 3000, signal);
+            if (request.imagePath) {
+                if (!provider.imageInput)
+                    throw new ToolError('IMAGE_INPUT_NOT_CONFIGURED');
+                await this.ssh.mkdir(`${this.config.cosmosDownloadsDir}/uploads/${job.id}`);
+                const remote = `${this.config.cosmosDownloadsDir}/uploads/${job.id}/${safeName(path.basename(request.imagePath))}`;
+                await this.ssh.put(request.imagePath, remote);
+                await page.setFileInput(provider.imageInput, remote);
+                await sleep(750, signal);
+            }
+            await page.fill(provider.promptInput, prompt);
+            await sleep(300, signal);
+            await this.applyOptions(page, provider, request);
+            const balance = await this.readBalance(page, provider);
+            const ledger = await this.ledgers.observe(provider.id, balance);
+            this.ledgers.canSpend(provider, ledger, balance);
+            const enabled = await this.waitEnabled(page, provider.submitButton, 8_000, signal);
+            if (!enabled)
+                throw new ToolError('SUBMIT_DISABLED');
+            if (!(await page.click(provider.submitButton)))
+                throw new ToolError('SUBMIT_DISABLED');
+            await sleep(1000, signal);
+            if (provider.errorText && (await page.isVisible(provider.errorText).catch(() => false))) {
+                const message = (await page.text(provider.errorText).catch(() => '')).slice(0, 500);
+                throw new ToolError(classifySubmitError(message), message || 'SUBMIT_FAILED');
+            }
+            job = await this.jobs.update(job.id, {
+                state: 'submitted',
+                submittedAt: nowIso(),
+                targetId: page.targetId,
+                providerUrl: provider.url,
+                creditsBefore: balance,
+            });
+            this.active.set(provider.id, { jobId: job.id, page });
+            this.log({ event: 'submitted', jobId: job.id, provider: provider.id, balance });
+            return job;
+        }
+        catch (error) {
+            if (page)
+                await page.close().catch(() => undefined);
+            job = await this.jobs.update(job.id, {
+                state: 'failed',
+                errorCode: errorCode(error),
+                errorMessage: errorMessage(error),
+                completedAt: nowIso(),
+            });
+            this.log({ event: 'submit_failed', jobId: job.id, provider: provider.id, errorCode: job.errorCode });
+            throw error;
+        }
+    }
+    async status(request, signal) {
+        let job = await this.jobs.get(assertJobId(request.jobId));
+        if (isTerminal(job.state))
+            return job;
+        const provider = await this.providers.get(job.site);
+        const runtime = this.active.get(provider.id);
+        if (!runtime || runtime.jobId !== job.id) {
+            return this.jobs.update(job.id, {
+                state: 'needs_attention',
+                errorCode: 'BROWSER_LOST',
+                errorMessage: 'The provider tab is no longer attached; the render may still exist in the provider library.',
+            });
+        }
+        if (request.retryDownload) {
+            return this.download(job, provider, runtime.page);
+        }
+        const deadline = Date.now() + Math.min(Math.max(request.waitSec ?? 0, 0), 10) * 1000;
+        do {
+            if (signal?.aborted)
+                throw new ToolError('CANCELLED');
+            if (provider.errorText) {
+                const visible = await runtime.page.isVisible(provider.errorText).catch(() => false);
+                if (visible) {
+                    const message = (await runtime.page.text(provider.errorText).catch(() => '')).slice(0, 500);
+                    return this.jobs.update(job.id, {
+                        state: 'failed',
+                        errorCode: classifySubmitError(message),
+                        errorMessage: message || 'GENERATION_FAILED',
+                        completedAt: nowIso(),
+                    });
+                }
+            }
+            let busy = false;
+            if (provider.busyIndicator) {
+                busy = await runtime.page.isVisible(provider.busyIndicator).catch(() => false);
+            }
+            const readySignal = provider.readyIndicator
+                ? await runtime.page.isVisible(provider.readyIndicator).catch(() => false)
+                : true;
+            const ready = readySignal
+                && await runtime.page.isVisible(provider.downloadButton).catch(() => false)
+                && await runtime.page.enabled(provider.downloadButton).catch(() => false);
+            if (ready && !busy)
+                return this.download(job, provider, runtime.page);
+            if (busy && job.state === 'submitted') {
+                job = await this.jobs.update(job.id, { state: 'generating' });
+            }
+            const started = Date.parse(job.submittedAt ?? job.createdAt);
+            if (Date.now() - started > provider.timeoutMs) {
+                return this.jobs.update(job.id, {
+                    state: 'failed',
+                    errorCode: 'TIMEOUT',
+                    errorMessage: `No downloadable result after ${provider.timeoutMs} ms.`,
+                    completedAt: nowIso(),
+                });
+            }
+            if (Date.now() >= deadline)
+                break;
+            await sleep(5000, signal);
+        } while (Date.now() < deadline);
+        return this.jobs.get(job.id);
+    }
+    async cancel(jobId) {
+        const job = await this.jobs.get(assertJobId(jobId));
+        if (isTerminal(job.state))
+            return job;
+        const provider = await this.providers.get(job.site);
+        const runtime = this.active.get(provider.id);
+        if (runtime && runtime.jobId === job.id) {
+            if (provider.cancelButton)
+                await runtime.page.click(provider.cancelButton).catch(() => false);
+            await runtime.page.close().catch(() => undefined);
+            this.active.delete(provider.id);
+        }
+        return this.jobs.update(job.id, {
+            state: 'cancelled',
+            errorCode: 'CANCELLED',
+            completedAt: nowIso(),
+        });
+    }
+    hasActive(providerId) {
+        return this.active.has(providerId);
+    }
+    activeSummary() {
+        return [...this.active.entries()].map(([providerId, runtime]) => ({
+            providerId,
+            jobId: runtime.jobId,
+        }));
+    }
+    async providerView() {
+        const providers = await this.providers.list();
+        return Promise.all(providers.map(async (provider) => ({
+            ...provider,
+            ledger: await this.ledgers.get(provider.id),
+            activeJobId: this.active.get(provider.id)?.jobId ?? null,
+        })));
+    }
+    async applyOptions(page, provider, request) {
+        const requested = [
+            ['duration', request.durationSec === undefined ? undefined : String(request.durationSec)],
+            ['aspect', request.aspect],
+            ['model', request.model],
+        ];
+        for (const [name, value] of requested) {
+            if (value === undefined)
+                continue;
+            const option = provider.options?.find((item) => item.name === name && item.value === value);
+            if (!option)
+                throw new ToolError('OPTION_NOT_CONFIGURED');
+            if (option.action === 'select') {
+                await page.evaluate(`(a) => {
+            const el = document.querySelector(a.selector);
+            if (!el) throw new Error('SELECTOR_CHANGED');
+            el.value = a.value;
+            el.dispatchEvent(new Event('change', { bubbles: true }));
+          }`, { selector: option.selector, value: option.value });
+            }
+            else if (!(await page.click(option.selector))) {
+                throw new ToolError('SELECTOR_CHANGED');
+            }
+            await sleep(300);
+        }
+    }
+    async readBalance(page, provider) {
+        if (!provider.creditBalance)
+            return null;
+        const text = await page.text(provider.creditBalance).catch(() => '');
+        return parseBalance(text);
+    }
+    async waitEnabled(page, selector, timeoutMs, signal) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            if (signal?.aborted)
+                throw new ToolError('CANCELLED');
+            if (await page.enabled(selector).catch(() => false))
+                return true;
+            await sleep(250, signal);
+        }
+        return false;
+    }
+    async waitForRemoteFile(remoteDir) {
+        const deadline = Date.now() + this.config.downloadTimeoutMs;
+        let last;
+        let stable = 0;
+        while (Date.now() < deadline) {
+            const files = (await this.ssh.list(remoteDir).catch(() => []))
+                .filter((file) => !file.name.endsWith('.crdownload'));
+            if (files.length) {
+                const candidate = files[0];
+                if (last?.name === candidate.name && last.size === candidate.size)
+                    stable += 1;
+                else
+                    stable = 0;
+                last = { name: candidate.name, size: candidate.size };
+                if (stable >= 2)
+                    return candidate.name;
+            }
+            await sleep(3000);
+        }
+        throw new ToolError('DOWNLOAD_FAILED');
+    }
+    async download(job, provider, page) {
+        await this.jobs.update(job.id, { state: 'downloading' });
+        const remoteDir = `${this.config.cosmosDownloadsDir}/${job.id}`;
+        try {
+            await this.ssh.mkdir(remoteDir);
+            await page.setDownloadBehavior(remoteDir);
+            if (!(await page.click(provider.downloadButton)))
+                throw new ToolError('DOWNLOAD_FAILED');
+            if (provider.downloadConfirm) {
+                await sleep(700);
+                await page.click(provider.downloadConfirm);
+            }
+            const remoteName = await this.waitForRemoteFile(remoteDir);
+            const tempDir = path.join(this.config.stateDir, 'tmp');
+            await mkdir(tempDir, { recursive: true, mode: 0o700 });
+            const ext = path.extname(remoteName) || '.mp4';
+            const local = path.join(tempDir, `${job.id}${ext}`);
+            await this.ssh.copyFrom(`${remoteDir}/${remoteName}`, local);
+            const artifact = await this.media.store(local, job);
+            const balance = await this.readBalance(page, provider);
+            await this.ledgers.record(job.site, job.creditsBefore ?? null, balance, provider.creditCost);
+            const done = await this.jobs.update(job.id, {
+                state: 'succeeded',
+                artifact,
+                creditsAfter: balance,
+                completedAt: nowIso(),
+            });
+            this.active.delete(provider.id);
+            await page.close().catch(() => undefined);
+            if (this.config.keepContainerCopyHours === 0) {
+                await this.ssh.remove(remoteDir).catch(() => undefined);
+            }
+            this.log({ event: 'succeeded', jobId: job.id, provider: provider.id, bytes: artifact.bytes });
+            return done;
+        }
+        catch (error) {
+            const failed = await this.jobs.update(job.id, {
+                state: 'needs_attention',
+                errorCode: errorCode(error),
+                errorMessage: errorMessage(error),
+            });
+            this.log({ event: 'download_failed', jobId: job.id, provider: provider.id, errorCode: failed.errorCode });
+            return failed;
+        }
+    }
+}