@method-ai-hq/sdk 0.0.0-stage → 0.14.2

package/dist/packages/sdk/src/outbox.d.ts

@@ -0,0 +1,120 @@
+import type { MethodClient } from './method-client.js';
+/**
+ * The outbox on this computer holds what must reach the account: package file uploads, version saves, and run records.
+ * It sends them in parallel (6 at a time), retries with backoff, and stops when no bytes moved for 60 s, or after 3
+ * failures in a row that have no response, a server error, or too many requests. What is left stays here; any later method command sends it.
+ *
+ * Order: a version is sent after its files; a run record after its version. Every request is idempotent, so two
+ * processes that send the same item do no harm.
+ */
+export type FileItem = {
+    kind: 'file';
+    server: string;
+    sha256: string;
+    size: number;
+};
+export type VersionItem = {
+    kind: 'version';
+    server: string;
+    method_id: string;
+    version_id: string;
+    file?: string;
+    body: {
+        workflow: unknown;
+        package: {
+            files: Array<{
+                sha256: string;
+            }>;
+            digest: string;
+        };
+        parent_version_id?: string;
+        reason: string;
+    };
+};
+export type RunItem = {
+    kind: 'run';
+    server: string;
+    run_dir: string;
+    version_id: string;
+    pid: number;
+};
+export type Item = FileItem | VersionItem | RunItem;
+type Saved = {
+    method_id: string;
+    version_number: number;
+};
+export declare const outboxDir: () => string;
+/** Versions this computer knows the server has: version_id -> {method_id, version_number}. */
+export declare function savedVersions(server: string): Record<string, Saved>;
+/** The last version this computer saved of a Method, for the parent and the change reason of the next one. */
+export declare function lastSaved(server: string, methodId: string): {
+    version_id: string;
+    version_number?: number;
+    workflow: any;
+} | undefined;
+/** Note a version that the server is known to have (a saved Method run by ID). */
+export declare function recordKnownVersion(server: string, methodId: string, versionId: string, versionNumber: number): void;
+/** A checkout of a saved version: the next save of this Method on this computer has it as its parent. */
+export declare function recordCheckout(server: string, methodId: string, versionId: string, versionNumber: number, workflow: unknown): void;
+/** Errors that a retry can fix: no response, a stalled transfer, a server error, or too many requests. */
+export declare function retryable(error: any): boolean;
+export declare class Outbox {
+    readonly client: MethodClient;
+    readonly options: {
+        stallMs?: number;
+        concurrency?: number;
+        send?: (item: RunItem) => Promise<void>;
+        write?: (line: string) => void;
+    };
+    private running;
+    private wake;
+    private lastProgress;
+    private networkFailures;
+    /** Set when sending stopped after repeated failures. A later command tries again; this process does not wait again. */
+    private gaveUp;
+    private stopped;
+    private foreground;
+    private retryAt;
+    private waiters;
+    private failures;
+    private owned;
+    private activated;
+    private signInNoted;
+    constructor(client: MethodClient, options?: {
+        stallMs?: number;
+        concurrency?: number;
+        send?: (item: RunItem) => Promise<void>;
+        write?: (line: string) => void;
+    });
+    /** Add an item. A file item copies the bytes now, so later edits to the file cannot change what is uploaded. */
+    add(item: Item, source?: string): void;
+    /** Remove a run item that this process sent itself. */
+    remove(item: Item): void;
+    release(item: RunItem): void;
+    items(): Item[];
+    pending(): number;
+    /**
+     * Resolves true when the version is on the server (or this computer has no record of it: the server decides), and
+     * false when it cannot be saved now: it is still in the outbox after sending stopped, or the server refused it.
+     */
+    whenSaved(versionId: string): Promise<boolean>;
+    failure(versionId: string): string | undefined;
+    /** Start sending in the background. Never throws. */
+    start(): void;
+    /**
+     * Send what is left. Resolves when the outbox is empty, no bytes moved for stallMs, or the server is unreachable.
+     * After this outbox gave up on a failing server, it resolves at once: the items stay for a later command.
+     */
+    drain(): Promise<{
+        pending: number;
+    }>;
+    stop(): void;
+    private settleWaiters;
+    private ready;
+    private loop;
+    private skipPresent;
+    private send;
+}
+/** Send what earlier commands left in the outbox, in the background. Never throws and never delays the command. */
+export declare function sendLeftovers(client: MethodClient): void;
+export {};

package/dist/packages/sdk/src/outbox.js

@@ -0,0 +1,297 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { sha256 } from '../../contracts/src/identity.js';
+import { writePrivateJson } from './files.js';
+import { fileHash } from './method-files.js';
+import { methodCache } from './prepare.js';
+export const outboxDir = () => join(methodCache(), 'outbox');
+const blobPath = (hash) => join(outboxDir(), 'blobs', hash);
+const itemKey = (item) => sha256([item.server, item.kind, item.kind === 'file' ? item.sha256 : item.kind === 'version' ? item.version_id : item.run_dir].join('\n')).slice(0, 32);
+const savedFile = (server) => join(methodCache(), 'versions', `${sha256(server).slice(0, 24)}.json`);
+const methodFile = (server, methodId) => join(methodCache(), 'versions', `${sha256(`${server}\n${methodId}`).slice(0, 24)}.json`);
+const read = (path) => { try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+}
+catch {
+    return undefined;
+} };
+const alive = (pid) => { try {
+    process.kill(pid, 0);
+    return true;
+}
+catch {
+    return false;
+} };
+/** Versions this computer knows the server has: version_id -> {method_id, version_number}. */
+export function savedVersions(server) { return read(savedFile(server)) ?? {}; }
+/** The last version this computer saved of a Method, for the parent and the change reason of the next one. */
+export function lastSaved(server, methodId) { return read(methodFile(server, methodId)); }
+/** Note a version that the server is known to have (a saved Method run by ID). */
+export function recordKnownVersion(server, methodId, versionId, versionNumber) {
+    if (!savedVersions(server)[versionId])
+        writePrivateJson(savedFile(server), { ...savedVersions(server), [versionId]: { method_id: methodId, version_number: versionNumber } });
+}
+/** A checkout of a saved version: the next save of this Method on this computer has it as its parent. */
+export function recordCheckout(server, methodId, versionId, versionNumber, workflow) {
+    recordKnownVersion(server, methodId, versionId, versionNumber);
+    writePrivateJson(methodFile(server, methodId), { version_id: versionId, version_number: versionNumber, workflow });
+}
+function recordSaved(item, versionNumber) {
+    writePrivateJson(savedFile(item.server), { ...savedVersions(item.server), [item.version_id]: { method_id: item.method_id, version_number: versionNumber } });
+    writePrivateJson(methodFile(item.server, item.method_id), { version_id: item.version_id, version_number: versionNumber, workflow: item.body.workflow });
+}
+/** Errors that a retry can fix: no response, a stalled transfer, a server error, or too many requests. */
+export function retryable(error) {
+    const status = error?.status ?? Number(/^(\d{3}):/.exec(String(error?.message))?.[1]);
+    return !status || status >= 500 || status === 429 || status === 408;
+}
+const networkError = (error) => !(error?.status ?? /^\d{3}:/.test(String(error?.message))) && error?.code !== 'stalled';
+export class Outbox {
+    client;
+    options;
+    running;
+    wake;
+    lastProgress = Date.now();
+    networkFailures = 0;
+    /** Set when sending stopped after repeated failures. A later command tries again; this process does not wait again. */
+    gaveUp = false;
+    stopped = false;
+    foreground = false;
+    retryAt = new Map();
+    waiters = new Map();
+    failures = new Map();
+    owned = new Set();
+    activated = false;
+    signInNoted = false;
+    constructor(client, options = {}) {
+        this.client = client;
+        this.options = options;
+    }
+    /** Add an item. A file item copies the bytes now, so later edits to the file cannot change what is uploaded. */
+    add(item, source) {
+        mkdirSync(join(outboxDir(), 'blobs'), { recursive: true, mode: 0o700 });
+        if (item.kind === 'file' && !existsSync(blobPath(item.sha256))) {
+            const temporary = `${blobPath(item.sha256)}.${process.pid}.tmp`;
+            copyFileSync(source, temporary);
+            if (fileHash(readFileSync(temporary)) !== item.sha256) {
+                rmSync(temporary, { force: true });
+                throw Error(`A file changed while it was being saved: ${source}`);
+            }
+            renameSync(temporary, blobPath(item.sha256));
+        }
+        if (item.kind === 'run')
+            this.owned.add(itemKey(item));
+        writePrivateJson(join(outboxDir(), `${itemKey(item)}.json`), item);
+        if (this.activated)
+            this.start();
+        this.wake?.();
+    }
+    /** Remove a run item that this process sent itself. */
+    remove(item) { this.owned.delete(itemKey(item)); rmSync(join(outboxDir(), `${itemKey(item)}.json`), { force: true }); }
+    release(item) { this.owned.delete(itemKey(item)); }
+    items() {
+        let names = [];
+        try {
+            names = readdirSync(outboxDir()).filter(name => /^[a-f0-9]{32}\.json$/.test(name));
+        }
+        catch {
+            return [];
+        }
+        return names.map(name => read(join(outboxDir(), name))).filter((item) => !!item && item.server === this.client.server);
+    }
+    pending() { return this.items().length; }
+    /**
+     * Resolves true when the version is on the server (or this computer has no record of it: the server decides), and
+     * false when it cannot be saved now: it is still in the outbox after sending stopped, or the server refused it.
+     */
+    whenSaved(versionId) {
+        if (savedVersions(this.client.server)[versionId])
+            return Promise.resolve(true);
+        if (this.failures.has(versionId))
+            return Promise.resolve(false);
+        if (!this.items().some(item => item.kind === 'version' && item.version_id === versionId))
+            return Promise.resolve(true);
+        this.start();
+        if (!this.running)
+            return Promise.resolve(false);
+        return new Promise(resolve => this.waiters.set(versionId, [...this.waiters.get(versionId) ?? [], resolve]));
+    }
+    failure(versionId) { return this.failures.get(versionId); }
+    /** Start sending in the background. Never throws. */
+    start() {
+        this.activated = true;
+        try {
+            if (this.running || !this.client.token())
+                return;
+        }
+        catch {
+            return;
+        }
+        this.stopped = false;
+        this.running = this.loop().catch(() => { }).finally(() => { this.running = undefined; this.settleWaiters(); });
+    }
+    /**
+     * Send what is left. Resolves when the outbox is empty, no bytes moved for stallMs, or the server is unreachable.
+     * After this outbox gave up on a failing server, it resolves at once: the items stay for a later command.
+     */
+    async drain() {
+        // A command waits for this: its timers keep the process alive, or Node would end it in the middle.
+        this.foreground = true;
+        this.lastProgress = Date.now();
+        if (!this.gaveUp)
+            this.networkFailures = 0;
+        this.start();
+        await this.running;
+        return { pending: this.items().filter(item => !(item.kind === 'run' && this.owned.has(itemKey(item)))).length };
+    }
+    stop() { this.stopped = true; this.wake?.(); }
+    settleWaiters() {
+        const saved = savedVersions(this.client.server);
+        for (const [id, waiters] of this.waiters) {
+            const waiting = this.items().some(item => item.kind === 'version' && item.version_id === id);
+            if (saved[id] || this.failures.has(id) || !waiting || !this.running) {
+                waiters.forEach(resolve => resolve(!!saved[id] || (!waiting && !this.failures.has(id))));
+                this.waiters.delete(id);
+            }
+        }
+    }
+    ready(item, all) {
+        if (item.kind === 'version')
+            return !all.some(other => other.kind === 'file' && item.body.package.files.some(f => f.sha256 === other.sha256));
+        if (item.kind === 'run')
+            return !this.owned.has(itemKey(item)) && !(item.pid !== process.pid && alive(item.pid))
+                && !all.some(other => other.kind === 'version' && other.version_id === item.version_id) && !this.failures.has(item.version_id);
+        return true;
+    }
+    async loop() {
+        const limit = this.options.concurrency ?? 6, stallMs = this.options.stallMs ?? Number(process.env.METHOD_OUTBOX_STALL_MS || 60_000);
+        const active = new Map();
+        let checked = false;
+        for (;;) {
+            const all = this.items();
+            const waiting = all.filter(item => !(item.kind === 'run' && this.owned.has(itemKey(item))));
+            if (!waiting.length || this.stopped)
+                break;
+            if (Date.now() - this.lastProgress > stallMs)
+                break;
+            // The server is unreachable: stop now and keep the items for a later command.
+            if (this.networkFailures >= 3 && !active.size) {
+                this.gaveUp = true;
+                break;
+            }
+            if (!checked) {
+                checked = true;
+                await this.skipPresent(all.filter((item) => item.kind === 'file'));
+                continue;
+            }
+            const now = Date.now();
+            const next = waiting.filter(item => !active.has(itemKey(item)) && this.ready(item, all) && (this.retryAt.get(itemKey(item))?.at ?? 0) <= now);
+            // Nothing this process can send now or later (the rest belongs to another running Method process): stop.
+            if (!next.length && !active.size && !waiting.some(item => this.retryAt.has(itemKey(item)) || this.ready(item, all)))
+                break;
+            for (const item of next.slice(0, Math.max(0, limit - active.size))) {
+                const key = itemKey(item);
+                active.set(key, this.send(item).then(() => {
+                    rmSync(join(outboxDir(), `${key}.json`), { force: true });
+                    if (item.kind === 'file')
+                        rmSync(blobPath(item.sha256), { force: true });
+                    this.retryAt.delete(key);
+                    this.networkFailures = 0;
+                    this.gaveUp = false;
+                    this.lastProgress = Date.now();
+                }, (error) => {
+                    const status = error?.status ?? Number(/^(\d{3}):/.exec(String(error?.message))?.[1]);
+                    if (status === 401) {
+                        // The sign-in expired: keep everything for the next signed-in command.
+                        this.stopped = true;
+                        if (!this.signInNoted)
+                            (this.options.write ?? (line => process.stderr.write(line + '\n')))('Will save when signed in: run method login.');
+                        this.signInNoted = true;
+                        return;
+                    }
+                    if (!retryable(error)) {
+                        // A request the server refuses will be refused again: keep it out of the outbox, and say why once.
+                        mkdirSync(join(outboxDir(), 'failed'), { recursive: true, mode: 0o700 });
+                        writePrivateJson(join(outboxDir(), 'failed', `${key}.json`), { item, error: String(error.message ?? error) });
+                        rmSync(join(outboxDir(), `${key}.json`), { force: true });
+                        if (item.kind === 'version')
+                            this.failures.set(item.version_id, String(error.message ?? error));
+                        (this.options.write ?? (line => process.stderr.write(line + '\n')))(`Not saved to your Method account: ${String(error.message ?? error)}`);
+                        return;
+                    }
+                    // No response, a server error, or too many requests: after 3 in a row, stop and keep the items for a later
+                    // command. A finished run never waits for a server that keeps failing.
+                    if (networkError(error) || status >= 500 || status === 429)
+                        this.networkFailures++;
+                    const attempt = (this.retryAt.get(key)?.attempt ?? 0) + 1;
+                    this.retryAt.set(key, { at: Date.now() + Math.min(30_000, 500 * 2 ** (attempt - 1)), attempt });
+                }).finally(() => { active.delete(key); this.settleWaiters(); this.wake?.(); }));
+            }
+            // Wait for a send to finish, a new item, or the next retry time.
+            const due = Math.min(1000, ...[...this.retryAt.values()].map(r => Math.max(10, r.at - Date.now())));
+            await new Promise(resolve => {
+                const timer = setTimeout(resolve, due);
+                if (!this.foreground)
+                    timer.unref?.();
+                this.wake = () => { clearTimeout(timer); resolve(); };
+                Promise.race(active.size ? [...active.values()] : [new Promise(() => { })]).then(() => { clearTimeout(timer); resolve(); });
+            });
+            this.wake = undefined;
+        }
+        await Promise.allSettled(active.values());
+    }
+    async skipPresent(files) {
+        if (!files.length)
+            return;
+        try {
+            for (let offset = 0; offset < files.length; offset += 10_000) {
+                const found = await this.client.request('/api/cli/files/check', 'POST', { hashes: files.slice(offset, offset + 10_000).map(f => f.sha256) }, true, { stallMs: this.options.stallMs ?? 60_000 });
+                for (const hash of found.present ?? []) {
+                    const item = files.find(f => f.sha256 === hash);
+                    rmSync(join(outboxDir(), `${itemKey(item)}.json`), { force: true });
+                    rmSync(blobPath(hash), { force: true });
+                }
+            }
+            this.lastProgress = Date.now();
+        }
+        catch (error) {
+            const status = error?.status ?? Number(/^(\d{3}):/.exec(String(error?.message))?.[1]);
+            if (networkError(error) || status >= 500 || status === 429)
+                this.networkFailures++;
+        }
+    }
+    async send(item) {
+        const stallMs = this.options.stallMs ?? Number(process.env.METHOD_OUTBOX_STALL_MS || 60_000);
+        const onProgress = () => { this.lastProgress = Date.now(); };
+        if (item.kind === 'file') {
+            if (!existsSync(blobPath(item.sha256)))
+                return;
+            await this.client.transfer(`/api/cli/files/${item.sha256}`, readFileSync(blobPath(item.sha256)), { stallMs, onProgress, attempts: 1 });
+            return;
+        }
+        if (item.kind === 'version') {
+            const saved = await this.client.request(`/api/cli/methods/${encodeURIComponent(item.method_id)}/versions/${encodeURIComponent(item.version_id)}`, 'PUT', item.body, true, { stallMs, onProgress });
+            if (saved.version_id !== item.version_id)
+                throw Object.assign(Error('The server saved another version ID than this content has.'), { status: 409 });
+            recordSaved(item, saved.version_number);
+            return;
+        }
+        if (!existsSync(join(item.run_dir, 'method-sync.json')))
+            return;
+        if (!this.options.send) {
+            const { MethodSync } = await import('./method-sync.js');
+            await MethodSync.retry(item.run_dir, this.client);
+        }
+        else
+            await this.options.send(item);
+    }
+}
+/** Send what earlier commands left in the outbox, in the background. Never throws and never delays the command. */
+export function sendLeftovers(client) {
+    try {
+        const outbox = new Outbox(client, { write: () => { } });
+        if (outbox.pending())
+            outbox.start();
+    }
+    catch { /* sent by a later command */ }
+}

package/dist/packages/sdk/src/own-model-key.d.ts

@@ -0,0 +1,22 @@
+import type { HostedModels } from '@withmethod/runtime';
+export declare const ownKeyName = "OPENROUTER_API_KEY";
+/** The name of this computer's own model key, or undefined. A local agent (--agent) replaces it for model steps. */
+export declare const ownKeyEnv: () => string | undefined;
+/** method config model-key [--off]: open the private form for the key, then use it for model and classify steps. */
+export declare function modelKeyCommand(args: string[], set?: (name: string) => Promise<unknown>): Promise<void>;
+/**
+ * Hosted model requests sent to OpenRouter with the own key, in place of the account: the same request, with the same
+ * private options as the account (no training on the data, zero data retention). Every hosted profile uses it, the
+ * Method's own models too.
+ */
+export declare function ownKeyModels(env: string): HostedModels;
+/** Put the own key's value into this process's environment (a shell value is used first). required: fail without one. */
+export declare function loadOwnKey(env: string, required?: boolean): void;
+/** The classifier setting that calls Jev through OpenRouter with the own key. */
+export declare const ownKeyClassification: (env: string) => {
+    provider: string;
+    model: "jev-1.13.0";
+    api_key_env: string;
+};
+/** The run's one line about the own key. */
+export declare function announceOwnKey(write?: (line: string) => void): void;

package/dist/packages/sdk/src/own-model-key.js

@@ -0,0 +1,76 @@
+/**
+ * Your own OpenRouter key on this computer (method config model-key). With it, every hosted model step (the Method's
+ * models, model IDs, and the account default) and every classify step calls OpenRouter directly with that key, in
+ * place of the account's model credit. The value stays in the device secret store; computer.json holds only its name.
+ */
+import { typesafeModel } from '@withmethod/runtime/classification.js';
+import { readComputerSettings, updateComputerSettings } from './computer-settings.js';
+import { findSecrets, importSecrets, resolveSecrets, setSecret } from './secrets.js';
+export const ownKeyName = 'OPENROUTER_API_KEY';
+/** The name of this computer's own model key, or undefined. A local agent (--agent) replaces it for model steps. */
+export const ownKeyEnv = () => readComputerSettings().model_key_env;
+/** method config model-key [--off]: open the private form for the key, then use it for model and classify steps. */
+export async function modelKeyCommand(args, set = setSecret) {
+    if (args.length > 1 || (args[0] !== undefined && args[0] !== '--off'))
+        throw Error('Use method config model-key, or method config model-key --off.');
+    if (args[0] === '--off') {
+        updateComputerSettings(settings => { delete settings.model_key_env; });
+        process.stdout.write('Model and classify steps use the Method account again. The key stays in the secret store; method secret list shows it.\n');
+        return;
+    }
+    if (!resolveSecrets([ownKeyName])[ownKeyName]) {
+        // One nearby key file holds the key (the team's .env, an old pipeline's): import it, without showing it. With
+        // several, the person chooses in the form.
+        const files = findSecrets([ownKeyName]).secrets?.[ownKeyName]?.in_files ?? [];
+        const file = files.length === 1 ? files[0] : undefined;
+        if (file) {
+            importSecrets(file, [ownKeyName]);
+            process.stdout.write(`Imported ${ownKeyName} from ${file}.\n`);
+        }
+        else
+            await set(ownKeyName);
+    }
+    updateComputerSettings(settings => { settings.model_key_env = ownKeyName; });
+    process.stdout.write(`Model and classify steps on this computer use your own OpenRouter key (${ownKeyName}). Turn it off with method config model-key --off.\n`);
+}
+/**
+ * Hosted model requests sent to OpenRouter with the own key, in place of the account: the same request, with the same
+ * private options as the account (no training on the data, zero data retention). Every hosted profile uses it, the
+ * Method's own models too.
+ */
+export function ownKeyModels(env) {
+    loadOwnKey(env);
+    return {
+        async request(body, signal) {
+            const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+                method: 'POST', signal, headers: { authorization: `Bearer ${process.env[env]}`, 'content-type': 'application/json' },
+                body: JSON.stringify({ ...body, provider: { ...(body.provider ?? {}), data_collection: 'deny', zdr: true }, usage: { include: true } }),
+            });
+            const data = await response.json().catch(() => null);
+            if (!response.ok)
+                throw Object.assign(Error(`${response.status}: ${data?.error?.message ?? 'OpenRouter refused the request'} (your own key, ${env})`), { status: response.status });
+            return data;
+        },
+    };
+}
+/** Put the own key's value into this process's environment (a shell value is used first). required: fail without one. */
+export function loadOwnKey(env, required = true) {
+    const value = resolveSecrets([env])[env];
+    if (!value) {
+        if (required)
+            throw Object.assign(Error(`${env} has no value on this computer. Run method config model-key, or method config model-key --off.`), { code: 'needs_input' });
+        return;
+    }
+    if (!process.env[env])
+        process.env[env] = value;
+}
+/** The classifier setting that calls Jev through OpenRouter with the own key. */
+export const ownKeyClassification = (env) => ({ provider: 'typesafe', model: typesafeModel, api_key_env: env });
+let announced = false;
+/** The run's one line about the own key. */
+export function announceOwnKey(write = line => process.stderr.write(line + '\n')) {
+    if (announced)
+        return;
+    announced = true;
+    write('Using your own OpenRouter key');
+}

package/dist/packages/sdk/src/prepare.d.ts

@@ -0,0 +1,24 @@
+export declare const methodCache: () => string;
+export declare const runFolderDays = 30;
+/**
+ * Delete the run folders that the SDK keeps under the cache when nothing in them changed for 30 days and the account
+ * has the run. A folder is kept when it is the only copy of the run: a device-only run, a run that was never sent, or
+ * a run that still waits in the outbox. A project's own .method-runs folder is not touched. A folder that cannot be
+ * read or removed is left as it is.
+ */
+export declare function pruneCachedRuns(root?: string, now?: number): void;
+/**
+ * A folder with a `method` command that runs this CLI. The SDK puts it first on the PATH that scripts get, so a script
+ * that runs `method` (such as improve.method's `method test`) uses the CLI that runs the Method, not an older one.
+ */
+export declare function cliBin(): string;
+export declare function command(program: string, args: string[], cwd: string, env?: NodeJS.ProcessEnv): Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export declare function lockDependencies(root: string): Promise<void>;
+export declare function prepareRuntime(root: string, config: any, method: any): Promise<{
+    config: any;
+    processPath: string;
+    prepareBundle: (bundle: string) => Promise<void>;
+}>;