openclaw-zero-video 0.0.0-stage → 0.1.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ghirne
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,148 @@
-# Temporary Holding Version
+# Zero Video
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Generate videos through signed-in consumer AI video sites on the estate Chromium lane.
+
+The plugin is a thin CDP driver plus a durable job store. It does not use provider APIs, does not read cookies or credentials, and does not authenticate. Login is performed manually in the Webtop on cosmos; the plugin reuses that persistent profile.
+
+## Tool
+
+`zero_video` with four operations:
+
+| Operation | Purpose |
+|---|---|
+| `submit` | Fill the prompt, apply options, submit, return a `jobId` |
+| `status` | Poll a job; auto-download and verify on success |
+| `cancel` | Best-effort cancel; reports whether the credit may already be spent |
+| `providers` | `list`, `add`, `configure`, `remove`, `test` provider profiles |
+
+Jobs are asynchronous. A render can take 1–15 minutes, so `submit` returns immediately and `status` is polled. `waitSec` (0–10) lets one status call wait inside the tool. Tool calls are kept under the Gateway's 60 s plugin-drain budget; long waits are split across calls.
+
+## Provider profiles
+
+Providers live in `~/.openclaw/zero-video/providers.json`, managed by the tool. They are not in `openclaw.json`, so adding or changing a provider does not require a gateway restart.
+
+Minimum profile:
+
+```json
+{
+  "id": "pixverse-main",
+  "label": "PixVerse",
+  "url": "https://app.pixverse.ai/",
+  "promptInput": "textarea",
+  "submitButton": "button[type=submit]",
+  "downloadButton": "button[aria-label=Download]"
+}
+```
+
+Full profile:
+
+```json
+{
+  "id": "flow-main",
+  "label": "Google Flow",
+  "url": "https://labs.google/fx/tools/flow",
+  "enabled": true,
+  "loginCheck": "[data-testid=account-avatar]",
+  "promptInput": "textarea",
+  "submitButton": "button[data-testid=generate]",
+  "busyIndicator": "[data-testid=generating]",
+  "readyIndicator": "[data-testid=clip-ready]",
+  "errorText": "[role=alert]",
+  "downloadButton": "button[aria-label=Download]",
+  "downloadConfirm": "[role=menuitem]:has-text('720p')",
+  "creditBalance": "[data-testid=credits]",
+  "creditCost": 10,
+  "dailyCap": 50,
+  "timeoutMs": 1200000,
+  "readinessMs": 3000,
+  "options": [
+    { "name": "duration", "value": "8", "selector": "[data-value='8s']", "action": "click" },
+    { "name": "aspect", "value": "16:9", "selector": "[data-value='16:9']", "action": "click" }
+  ],
+  "imageInput": "input[type=file]",
+  "cancelButton": "button[aria-label=Cancel]",
+  "libraryUrl": "https://labs.google/fx/tools/flow/project",
+  "libraryItem": "[data-testid=clip-card]",
+  "notes": "Visible watermark is forced in India.",
+  "verifiedAt": "2026-10-21"
+}
+```
+
+`downloadConfirm` is for a second click after the download button opens a menu. `options` map a requested `durationSec`, `aspect` or `model` to a concrete control; if the request names a value that is not configured, the tool returns `OPTION_NOT_CONFIGURED` rather than guessing.
+
+At least one of `busyIndicator` or `readyIndicator` is required before `submit`; `providers test` still works without them so selectors can be discovered first. `readinessMs` defaults to 3000 and is the SPA mount delay after the prompt input appears.
+
+`imageInput` enables image-to-video. The image is copied to the Chromium container first, then set on the file input with CDP `DOM.setFileInputFiles`.
+
+## Provider management examples
+
+```json
+{"op":"providers","providersAction":"list"}
+{"op":"providers","providersAction":"add","provider":{"id":"pixverse-main","label":"PixVerse","url":"https://app.pixverse.ai/","promptInput":"textarea","submitButton":"button[type=submit]","downloadButton":"button[aria-label=Download]"}}
+{"op":"providers","providersAction":"configure","providerId":"pixverse-main","provider":{"dailyCap":20,"creditCost":5}}
+{"op":"providers","providersAction":"test","providerId":"pixverse-main"}
+{"op":"providers","providersAction":"remove","providerId":"pixverse-main"}
+```
+
+`test` opens the provider URL, checks the login marker, prompt input, submit button and download button, then closes the tab. It does not spend credits. On success it stamps `verifiedAt`.
+
+## Generation
+
+```json
+{"op":"submit","site":"pixverse-main","prompt":"A slow dolly shot through a rain-soaked market at dusk","durationSec":5,"aspect":"16:9"}
+{"op":"status","jobId":"pixverse-main-m1abc2-3f9c11","waitSec":30}
+{"op":"status","jobId":"pixverse-main-m1abc2-3f9c11","waitSec":60}
+{"op":"cancel","jobId":"pixverse-main-m1abc2-3f9c11"}
+```
+
+On success, `status` returns an artifact with `path`, `bytes`, `sha256`, `durationSec`, `width`, `height` and `codec`. Files are stored under `~/.openclaw/media/zero-video/<YYYY>/<MM>/` with a sidecar `.json` manifest.
+
+If the tab is lost (gateway or Chromium restart), the job becomes `needs_attention` with `BROWSER_LOST`. The render may still exist in the provider library; the tool does not guess which item to download. Recover manually in the Webtop, or resubmit deliberately.
+
+## Credit control
+
+The ledger uses balance delta, not a calendar:
+
+- `spentToday += max(0, balanceBefore - balanceAfter)`.
+- A balance increase is treated as a refill and resets `spentToday`.
+- `dailyCap` and `creditCost` are per provider. `dailyCap: 0` means no cap.
+- One job per provider at a time, `maxParallel` globally, 5 s status polling.
+- No automatic retry after submit. A failed download leaves the job in `needs_attention`; `status` with `retryDownload: true` retries the transfer.
+
+## Configuration
+
+| Key | Default |
+|---|---|
+| `cdpUrl` | `http://127.0.0.1:9222` |
+| `allowRemoteCdp` | `false` |
+| `providersFile` | `~/.openclaw/zero-video/providers.json` |
+| `stateDir` | `~/.openclaw/zero-video` |
+| `mediaDir` | `~/.openclaw/media/zero-video` |
+| `maxParallel` | `2` |
+| `jobTimeoutMs` | `1200000` |
+| `downloadTimeoutMs` | `30000` |
+| `maxDownloadBytes` | `52428800` |
+| `maxPromptChars` | `2000` |
+| `sshHost` | `192.168.1.12` |
+| `containerName` | `Chromium` |
+| `sshKey` | `~/.ssh/ghirnemox_ed25519` |
+| `cosmosDownloadsDir` | `/config/Downloads/zero-video` |
+| `keepContainerCopyHours` | `24` |
+| `storePrompts` | `true` |
+| `retentionDays` | `30` |
+
+## Error codes
+
+`INVALID_REQUEST`, `UNKNOWN_PROVIDER`, `PROVIDER_DISABLED`, `PROVIDER_BUSY`, `PROVIDER_INCOMPLETE`, `TOO_MANY_JOBS`, `PROMPT_REQUIRED`, `PROMPT_TOO_LONG`, `LOGIN_REQUIRED`, `INPUT_NOT_FOUND`, `SUBMIT_DISABLED`, `MODERATION_BLOCKED`, `QUOTA_EXHAUSTED`, `DAILY_CAP_REACHED`, `OPTION_NOT_CONFIGURED`, `IMAGE_INPUT_NOT_CONFIGURED`, `DOWNLOAD_FAILED`, `TRANSFER_FAILED`, `VERIFY_FAILED`, `INVALID_MEDIA`, `TOO_LARGE`, `TIMEOUT`, `BROWSER_LOST`, `CANCELLED`.
+
+## Build
+
+```bash
+npm install
+npm run typecheck
+npm test
+npm run build
+npm pack
+```
+
+Runtime requires Node 22+, Chromium reachable over CDP, and `ffprobe` on the gateway.

package/dist/config.d.ts

@@ -0,0 +1,27 @@
+export interface Config {
+    cdpUrl: string;
+    allowRemoteCdp: boolean;
+    providersFile: string;
+    stateDir: string;
+    mediaDir: string;
+    maxParallel: number;
+    jobTimeoutMs: number;
+    downloadTimeoutMs: number;
+    maxDownloadBytes: number;
+    maxPromptChars: number;
+    sshHost: string;
+    containerName: string;
+    sshKey: string;
+    cosmosDownloadsDir: string;
+    keepContainerCopyHours: number;
+    storePrompts: boolean;
+    retentionDays: number;
+}
+export declare class ToolError extends Error {
+    readonly code: string;
+    constructor(code: string, message?: string);
+}
+export declare function expandHome(value: string, home?: string): string;
+export declare function parseConfig(raw: unknown, home?: string): Config;
+export declare function assertPrompt(prompt: unknown, config: Config): string;
+export declare function assertJobId(jobId: unknown): string;

package/dist/config.js

@@ -0,0 +1,114 @@
+import { homedir } from 'node:os';
+import path from 'node:path';
+const CONFIG_KEYS = new Set([
+    'cdpUrl', 'allowRemoteCdp', 'providersFile', 'stateDir', 'mediaDir',
+    'maxParallel', 'jobTimeoutMs', 'downloadTimeoutMs', 'maxDownloadBytes',
+    'maxPromptChars', 'sshHost', 'sshKey', 'cosmosDownloadsDir', 'containerName',
+    'keepContainerCopyHours', 'storePrompts', 'retentionDays',
+]);
+export class ToolError extends Error {
+    code;
+    constructor(code, message = code) {
+        super(message);
+        this.code = code;
+        this.name = 'ToolError';
+    }
+}
+export function expandHome(value, home = homedir()) {
+    if (value === '~')
+        return home;
+    if (value.startsWith('~/'))
+        return path.join(home, value.slice(2));
+    return value;
+}
+function text(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== 'string')
+        throw new ToolError('INVALID_CONFIG');
+    const trimmed = value.trim();
+    if (!trimmed)
+        throw new ToolError('INVALID_CONFIG');
+    return trimmed;
+}
+function integer(value, fallback, min, max) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isInteger(value) || Number(value) < min || Number(value) > max) {
+        throw new ToolError('INVALID_CONFIG');
+    }
+    return Number(value);
+}
+function boolean(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== 'boolean')
+        throw new ToolError('INVALID_CONFIG');
+    return value;
+}
+export function parseConfig(raw, home = homedir()) {
+    if (raw === undefined || raw === null)
+        raw = {};
+    if (typeof raw !== 'object' || Array.isArray(raw))
+        throw new ToolError('INVALID_CONFIG');
+    const input = raw;
+    for (const key of Object.keys(input)) {
+        if (!CONFIG_KEYS.has(key))
+            throw new ToolError('UNKNOWN_CONFIG_KEY');
+    }
+    let cdp;
+    try {
+        cdp = new URL(text(input.cdpUrl, 'http://127.0.0.1:9222'));
+    }
+    catch {
+        throw new ToolError('INVALID_CDP_URL');
+    }
+    if (!['http:', 'https:'].includes(cdp.protocol) || cdp.username || cdp.password || cdp.search || cdp.hash) {
+        throw new ToolError('INVALID_CDP_URL');
+    }
+    const allowRemoteCdp = boolean(input.allowRemoteCdp, false);
+    const localHosts = new Set(['localhost', '127.0.0.1', '[::1]', '::1']);
+    if (!allowRemoteCdp && !localHosts.has(cdp.hostname)) {
+        throw new ToolError('REMOTE_CDP_DISABLED');
+    }
+    return {
+        cdpUrl: cdp.toString().replace(/\/$/, ''),
+        allowRemoteCdp,
+        providersFile: expandHome(text(input.providersFile, '~/.openclaw/zero-video/providers.json'), home),
+        stateDir: expandHome(text(input.stateDir, '~/.openclaw/zero-video'), home),
+        mediaDir: expandHome(text(input.mediaDir, '~/.openclaw/media/zero-video'), home),
+        maxParallel: integer(input.maxParallel, 2, 1, 3),
+        jobTimeoutMs: integer(input.jobTimeoutMs, 1_200_000, 60_000, 7_200_000),
+        downloadTimeoutMs: integer(input.downloadTimeoutMs, 30_000, 10_000, 35_000),
+        maxDownloadBytes: integer(input.maxDownloadBytes, 52_428_800, 1_048_576, 104_857_600),
+        maxPromptChars: integer(input.maxPromptChars, 2000, 1, 8000),
+        sshHost: text(input.sshHost, '192.168.1.12'),
+        containerName: (() => {
+            const value = text(input.containerName, 'Chromium');
+            if (!/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,63}$/.test(value))
+                throw new ToolError('INVALID_CONFIG');
+            return value;
+        })(),
+        sshKey: expandHome(text(input.sshKey, '~/.ssh/ghirnemox_ed25519'), home),
+        cosmosDownloadsDir: text(input.cosmosDownloadsDir, '/config/Downloads/zero-video').replace(/\/+$/, ''),
+        keepContainerCopyHours: integer(input.keepContainerCopyHours, 24, 0, 168),
+        storePrompts: boolean(input.storePrompts, true),
+        retentionDays: integer(input.retentionDays, 30, 1, 3650),
+    };
+}
+export function assertPrompt(prompt, config) {
+    if (typeof prompt !== 'string')
+        throw new ToolError('INVALID_REQUEST');
+    const trimmed = prompt.trim();
+    if (!trimmed)
+        throw new ToolError('PROMPT_REQUIRED');
+    if (trimmed.length > config.maxPromptChars)
+        throw new ToolError('PROMPT_TOO_LONG');
+    return trimmed;
+}
+export function assertJobId(jobId) {
+    if (typeof jobId !== 'string' || !/^[a-z0-9][a-z0-9-]{2,80}$/.test(jobId)) {
+        throw new ToolError('INVALID_JOB_ID');
+    }
+    return jobId;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    id: string;
+    name: string;
+    description: string;
+    register(api: any): void;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,154 @@
+import { definePluginEntry } from 'openclaw/plugin-sdk/plugin-entry';
+import { parseConfig, ToolError } from './config.js';
+import { ProviderStore, testProvider } from './providers.js';
+import { CdpDriver } from './transport.js';
+import { JobStore, LedgerStore, MediaStore, Runner, Ssh } from './jobs.js';
+const PLUGIN_ID = 'zero-video';
+export default definePluginEntry({
+    id: PLUGIN_ID,
+    name: 'Zero Video',
+    description: 'Generate videos through signed-in consumer AI video sites with runtime-managed providers.',
+    register(api) {
+        const config = parseConfig(api.pluginConfig);
+        const providers = new ProviderStore(config.providersFile);
+        const driver = new CdpDriver(config.cdpUrl);
+        const jobs = new JobStore(config);
+        const ledgers = new LedgerStore(config);
+        const ssh = new Ssh(config);
+        const media = new MediaStore(config);
+        const runner = new Runner(config, driver, providers, jobs, ledgers, media, ssh, (record) => api.logger.info(JSON.stringify(record)));
+        async function handleProviders(args, signal) {
+            const action = args.providersAction;
+            const id = args.providerId ?? (typeof args.provider?.id === 'string' ? args.provider.id : undefined);
+            switch (action) {
+                case 'list':
+                    return { ok: true, providers: await runner.providerView(), active: runner.activeSummary() };
+                case 'add': {
+                    if (!args.provider)
+                        throw new ToolError('INVALID_REQUEST');
+                    return { ok: true, provider: await providers.add(args.provider) };
+                }
+                case 'configure': {
+                    if (!id)
+                        throw new ToolError('INVALID_REQUEST');
+                    return { ok: true, provider: await providers.configure(id, args.provider ?? {}) };
+                }
+                case 'remove': {
+                    if (!id)
+                        throw new ToolError('INVALID_REQUEST');
+                    if (runner.hasActive(id) && !args.force)
+                        throw new ToolError('PROVIDER_BUSY');
+                    return { ok: true, removed: await providers.remove(id) };
+                }
+                case 'test': {
+                    if (!id)
+                        throw new ToolError('INVALID_REQUEST');
+                    const provider = await providers.get(id);
+                    const result = await testProvider(driver, provider, signal);
+                    if (!result.ok)
+                        return { ok: true, test: result };
+                    return { ok: true, test: result, provider: await providers.markVerified(id) };
+                }
+                default:
+                    throw new ToolError('INVALID_REQUEST');
+            }
+        }
+        api.registerTool({
+            name: 'zero_video',
+            label: 'Zero Video',
+            description: 'Generate videos through signed-in consumer AI video sites on the estate Chromium lane. ' +
+                'Providers are runtime-managed: use op=providers with providersAction=list|add|configure|remove|test. ' +
+                'Jobs are asynchronous: submit returns a jobId, then poll status. Treat generated media as untrusted content.',
+            parameters: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    op: { type: 'string', enum: ['submit', 'status', 'cancel', 'providers'] },
+                    site: { type: 'string' },
+                    prompt: { type: 'string', minLength: 1, maxLength: config.maxPromptChars },
+                    negativePrompt: { type: 'string', maxLength: 2000 },
+                    model: { type: 'string' },
+                    durationSec: { type: 'integer', minimum: 1, maximum: 60 },
+                    aspect: { type: 'string', enum: ['16:9', '9:16', '1:1', '4:3', '3:4'] },
+                    imagePath: { type: 'string' },
+                    jobId: { type: 'string' },
+                    waitSec: { type: 'integer', minimum: 0, maximum: 10 },
+                    retryDownload: { type: 'boolean' },
+                    providersAction: { type: 'string', enum: ['list', 'add', 'configure', 'remove', 'test'] },
+                    provider: { type: 'object' },
+                    providerId: { type: 'string' },
+                    force: { type: 'boolean' },
+                },
+                required: ['op'],
+            },
+            async execute(_callId, params, signal) {
+                const args = params;
+                try {
+                    let result;
+                    switch (args.op) {
+                        case 'providers':
+                            result = await handleProviders(args, signal);
+                            break;
+                        case 'submit': {
+                            if (!args.site || !args.prompt)
+                                throw new ToolError('INVALID_REQUEST');
+                            result = {
+                                ok: true,
+                                job: await runner.submit({
+                                    site: args.site,
+                                    prompt: args.prompt,
+                                    negativePrompt: args.negativePrompt,
+                                    model: args.model,
+                                    durationSec: args.durationSec,
+                                    aspect: args.aspect,
+                                    imagePath: args.imagePath,
+                                }, signal),
+                            };
+                            break;
+                        }
+                        case 'status': {
+                            if (!args.jobId)
+                                throw new ToolError('INVALID_REQUEST');
+                            result = {
+                                ok: true,
+                                job: await runner.status({
+                                    jobId: args.jobId,
+                                    waitSec: args.waitSec,
+                                    retryDownload: args.retryDownload,
+                                }, signal),
+                            };
+                            break;
+                        }
+                        case 'cancel': {
+                            if (!args.jobId)
+                                throw new ToolError('INVALID_REQUEST');
+                            result = { ok: true, job: await runner.cancel(args.jobId) };
+                            break;
+                        }
+                        default:
+                            throw new ToolError('INVALID_REQUEST');
+                    }
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(result) }],
+                        details: result,
+                    };
+                }
+                catch (error) {
+                    const code = error instanceof ToolError ? error.code : 'TOOL_FAILED';
+                    const message = error instanceof Error ? error.message : String(error);
+                    const result = { ok: false, error: code, message: message.slice(0, 500) };
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(result) }],
+                        details: result,
+                    };
+                }
+            },
+        });
+        api.logger.info(JSON.stringify({
+            plugin: PLUGIN_ID,
+            cdpTarget: new URL(config.cdpUrl).host,
+            providersFile: config.providersFile,
+            maxParallel: config.maxParallel,
+        }));
+    },
+});

package/dist/jobs.d.ts

@@ -0,0 +1,81 @@
+import type { Config } from './config.js';
+import type { Driver } from './transport.js';
+import type { ProviderStore } from './providers.js';
+import type { JobArtifact, JobRecord, Ledger, ProviderSpec, StatusRequest, SubmitRequest } from './types.js';
+export declare class JobStore {
+    private readonly config;
+    private readonly jobsDir;
+    constructor(config: Config);
+    init(): Promise<void>;
+    private write;
+    create(record: JobRecord): Promise<JobRecord>;
+    get(id: string): Promise<JobRecord>;
+    update(id: string, patch: Partial<JobRecord>): Promise<JobRecord>;
+    listRecent(limit?: number): Promise<JobRecord[]>;
+    findActiveByProvider(site: string): Promise<JobRecord | undefined>;
+}
+export declare class LedgerStore {
+    private readonly config;
+    private readonly ledgerDir;
+    constructor(config: Config);
+    private read;
+    private write;
+    get(providerId: string): Promise<Ledger>;
+    observe(providerId: string, balance: number | null): Promise<Ledger>;
+    canSpend(provider: ProviderSpec, ledger: Ledger, balance: number | null): void;
+    record(providerId: string, before: number | null, after: number | null, fallbackCost: number): Promise<Ledger>;
+}
+export declare class Ssh {
+    private readonly config;
+    constructor(config: Config);
+    private validate;
+    private run;
+    private container;
+    private transferDir;
+    mkdir(remote: string): Promise<void>;
+    list(remote: string): Promise<Array<{
+        name: string;
+        size: number;
+        mtime: number;
+    }>>;
+    copyFrom(remote: string, local: string): Promise<void>;
+    put(local: string, remote: string): Promise<void>;
+    remove(remote: string): Promise<void>;
+}
+export declare class MediaStore {
+    private readonly config;
+    constructor(config: Config);
+    private ffprobe;
+    private sha256;
+    verify(file: string): Promise<JobArtifact>;
+    store(tempFile: string, job: JobRecord): Promise<JobArtifact>;
+}
+export declare class Runner {
+    private readonly config;
+    private readonly driver;
+    private readonly providers;
+    private readonly jobs;
+    private readonly ledgers;
+    private readonly media;
+    private readonly ssh;
+    private readonly log;
+    private readonly active;
+    constructor(config: Config, driver: Driver, providers: ProviderStore, jobs: JobStore, ledgers: LedgerStore, media: MediaStore, ssh: Ssh, log?: (record: Record<string, unknown>) => void);
+    submit(request: SubmitRequest, signal?: AbortSignal): Promise<JobRecord>;
+    status(request: StatusRequest, signal?: AbortSignal): Promise<JobRecord>;
+    cancel(jobId: string): Promise<JobRecord>;
+    hasActive(providerId: string): boolean;
+    activeSummary(): Array<{
+        providerId: string;
+        jobId: string;
+    }>;
+    providerView(): Promise<Array<ProviderSpec & {
+        ledger: Ledger;
+        activeJobId: string | null;
+    }>>;
+    private applyOptions;
+    private readBalance;
+    private waitEnabled;
+    private waitForRemoteFile;
+    private download;
+}