@devicecloud.dev/dcd 5.0.0-beta.0 → 5.0.0-beta.2

package/dist/mcp/server.js

@@ -0,0 +1,27 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { getCliVersion } from '../utils/cli.js';
+import { isReadOnly } from './context.js';
+import { registerDownloadArtifacts } from './tools/download-artifacts.js';
+import { registerGetStatus } from './tools/get-status.js';
+import { registerListDevices } from './tools/list-devices.js';
+import { registerListRuns } from './tools/list-runs.js';
+import { registerRunCloudTest } from './tools/run-cloud-test.js';
+/**
+ * Build the devicecloud.dev MCP server with its tool set registered. Read-only
+ * tools are always present; the billable `dcd_run_cloud_test` is omitted in
+ * read-only mode (`DCD_MCP_READONLY=1` or `--read-only`).
+ */
+export function createServer() {
+    const server = new McpServer({
+        name: 'devicecloud',
+        version: getCliVersion(),
+    });
+    registerListDevices(server);
+    registerListRuns(server);
+    registerGetStatus(server);
+    registerDownloadArtifacts(server);
+    if (!isReadOnly()) {
+        registerRunCloudTest(server);
+    }
+    return server;
+}

package/dist/mcp/tools/download-artifacts.d.ts

@@ -0,0 +1,11 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Download a completed run's artifacts (zip) and/or a formatted report to local
+ * disk. This reads cloud state and writes files locally — it does not change
+ * anything cloud-side, so it stays available in read-only mode.
+ *
+ * The underlying service swallows download failures into `warnLogger` rather
+ * than throwing (a missing-artifacts 404 isn't fatal), so we collect those
+ * warnings and return them — an empty `warnings` array means success.
+ */
+export declare function registerDownloadArtifacts(server: McpServer): void;

package/dist/mcp/tools/download-artifacts.js

@@ -0,0 +1,84 @@
+import * as path from 'node:path';
+import { z } from 'zod';
+import { ReportDownloadService } from '../../services/report-download.service.js';
+import { getContext, logStderr } from '../context.js';
+import { jsonResult, runTool } from '../helpers.js';
+/**
+ * Download a completed run's artifacts (zip) and/or a formatted report to local
+ * disk. This reads cloud state and writes files locally — it does not change
+ * anything cloud-side, so it stays available in read-only mode.
+ *
+ * The underlying service swallows download failures into `warnLogger` rather
+ * than throwing (a missing-artifacts 404 isn't fatal), so we collect those
+ * warnings and return them — an empty `warnings` array means success.
+ */
+export function registerDownloadArtifacts(server) {
+    server.registerTool('dcd_download_artifacts', {
+        title: 'Download run artifacts',
+        description: 'Download a completed test run\'s artifacts (videos/logs zip) and/or a formatted report to local disk. ' +
+            'Returns the resolved output paths and any warnings (a non-empty warnings array means a download could not be produced, e.g. no results yet).',
+        inputSchema: {
+            uploadId: z.string().describe('UUID of the upload to download artifacts for'),
+            type: z
+                .enum(['ALL', 'FAILED'])
+                .optional()
+                .describe('Which tests to include artifacts for (default ALL)'),
+            artifactsPath: z
+                .string()
+                .optional()
+                .describe('Local path to write the artifacts zip (default ./artifacts.zip)'),
+            report: z
+                .enum(['junit', 'allure', 'html'])
+                .optional()
+                .describe('Also download a formatted report of this type'),
+            reportPath: z
+                .string()
+                .optional()
+                .describe('Local path for the report file (defaults depend on report type)'),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (args) => runTool('dcd_download_artifacts', async () => {
+        const { apiUrl, auth } = await getContext();
+        const service = new ReportDownloadService();
+        const warnings = [];
+        const warnLogger = (m) => {
+            warnings.push(m);
+            logStderr(m);
+        };
+        const artifactsPath = args.artifactsPath ?? './artifacts.zip';
+        await service.downloadArtifacts({
+            apiUrl,
+            auth,
+            uploadId: args.uploadId,
+            downloadType: args.type ?? 'ALL',
+            artifactsPath,
+            logger: logStderr,
+            warnLogger,
+        });
+        let reportPath;
+        if (args.report) {
+            reportPath = args.reportPath
+                ? path.resolve(args.reportPath)
+                : path.resolve(args.report === 'junit'
+                    ? 'report.xml'
+                    : 'report.html');
+            await service.downloadReports({
+                apiUrl,
+                auth,
+                uploadId: args.uploadId,
+                reportType: args.report,
+                junitPath: args.report === 'junit' ? reportPath : undefined,
+                allurePath: args.report === 'allure' ? reportPath : undefined,
+                htmlPath: args.report === 'html' ? reportPath : undefined,
+                logger: logStderr,
+                warnLogger,
+            });
+        }
+        return jsonResult({
+            uploadId: args.uploadId,
+            artifactsPath: path.resolve(artifactsPath),
+            reportPath,
+            warnings,
+        });
+    }));
+}

package/dist/mcp/tools/get-status.d.ts

@@ -0,0 +1,7 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Status of a single upload by id or name. This is the polling primitive: after
+ * an async `dcd_run_cloud_test`, an agent calls this until `status` leaves
+ * PENDING/QUEUED/RUNNING.
+ */
+export declare function registerGetStatus(server: McpServer): void;

package/dist/mcp/tools/get-status.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { ApiGateway } from '../../gateways/api-gateway.js';
+import { getContext } from '../context.js';
+import { jsonResult, runTool } from '../helpers.js';
+/**
+ * Status of a single upload by id or name. This is the polling primitive: after
+ * an async `dcd_run_cloud_test`, an agent calls this until `status` leaves
+ * PENDING/QUEUED/RUNNING.
+ */
+export function registerGetStatus(server) {
+    server.registerTool('dcd_get_status', {
+        title: 'Get test run status',
+        description: 'Get the status of a single upload (test run) by upload id or name. ' +
+            'Provide exactly one of uploadId or name. ' +
+            'Returns: { status, name, createdAt, tests: [{ name, status, durationSeconds, failReason }] }. ' +
+            'Poll this after an async run until status is no longer PENDING/QUEUED/RUNNING.',
+        inputSchema: {
+            uploadId: z
+                .string()
+                .optional()
+                .describe('UUID of the upload (as returned by dcd_run_cloud_test or dcd_list_runs)'),
+            name: z.string().optional().describe('Name of the upload to look up'),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (args) => runTool('dcd_get_status', async () => {
+        if (args.uploadId && args.name) {
+            throw new Error('Provide only one of uploadId or name, not both.');
+        }
+        if (!args.uploadId && !args.name) {
+            throw new Error('Provide one of uploadId or name.');
+        }
+        const { apiUrl, auth } = await getContext();
+        const status = await ApiGateway.getUploadStatus(apiUrl, auth, {
+            uploadId: args.uploadId,
+            name: args.name,
+        });
+        return jsonResult(status);
+    }));
+}

package/dist/mcp/tools/list-devices.d.ts

@@ -0,0 +1,7 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Discovery tool: the matrix of devices, OS versions, and Maestro versions the
+ * org can run. Agents should call this before `dcd_run_cloud_test` so they pass
+ * valid `iosDevice` / `iosVersion` / `androidDevice` / `androidApiLevel` values.
+ */
+export declare function registerListDevices(server: McpServer): void;

package/dist/mcp/tools/list-devices.js

@@ -0,0 +1,27 @@
+import { fetchCompatibilityData } from '../../utils/compatibility.js';
+import { getContext } from '../context.js';
+import { jsonResult, runTool } from '../helpers.js';
+/**
+ * Discovery tool: the matrix of devices, OS versions, and Maestro versions the
+ * org can run. Agents should call this before `dcd_run_cloud_test` so they pass
+ * valid `iosDevice` / `iosVersion` / `androidDevice` / `androidApiLevel` values.
+ */
+export function registerListDevices(server) {
+    server.registerTool('dcd_list_devices', {
+        title: 'List available devices',
+        description: 'List the iOS and Android devices, OS versions, and Maestro versions available on devicecloud.dev. ' +
+            'Use this to discover valid device/version values before submitting a test run. ' +
+            'Returns: { ios, android, androidPlay, maestro }, where each platform maps OS version → supported device list.',
+        inputSchema: {},
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async () => runTool('dcd_list_devices', async () => {
+        const { apiUrl, auth } = await getContext();
+        const data = await fetchCompatibilityData(apiUrl, auth);
+        return jsonResult({
+            ios: data.ios,
+            android: data.android,
+            androidPlay: data.androidPlay,
+            maestro: data.maestro,
+        });
+    }));
+}

package/dist/mcp/tools/list-runs.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/** List recent flow uploads for the org, with optional filters + pagination. */
+export declare function registerListRuns(server: McpServer): void;

package/dist/mcp/tools/list-runs.js

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { ApiGateway } from '../../gateways/api-gateway.js';
+import { getContext } from '../context.js';
+import { jsonResult, runTool } from '../helpers.js';
+/** List recent flow uploads for the org, with optional filters + pagination. */
+export function registerListRuns(server) {
+    server.registerTool('dcd_list_runs', {
+        title: 'List recent test runs',
+        description: 'List recent flow uploads (test runs) for your organization, most recent first. ' +
+            'Supports name (with * wildcard), date range, and pagination. ' +
+            'Returns: { uploads: [{ id, name, created_at, consoleUrl }], total, limit, offset }. ' +
+            'Use the returned id with dcd_get_status or dcd_download_artifacts.',
+        inputSchema: {
+            name: z
+                .string()
+                .optional()
+                .describe('Filter by upload name; supports a * wildcard, e.g. "nightly-*"'),
+            from: z
+                .string()
+                .optional()
+                .describe('Only uploads created on or after this ISO 8601 date (e.g. 2024-01-01)'),
+            to: z
+                .string()
+                .optional()
+                .describe('Only uploads created on or before this ISO 8601 date'),
+            limit: z
+                .number()
+                .int()
+                .min(1)
+                .max(100)
+                .optional()
+                .describe('Maximum uploads to return (default 20)'),
+            offset: z
+                .number()
+                .int()
+                .min(0)
+                .optional()
+                .describe('Number of uploads to skip, for pagination (default 0)'),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (args) => runTool('dcd_list_runs', async () => {
+        const { apiUrl, auth } = await getContext();
+        for (const [key, value] of [
+            ['from', args.from],
+            ['to', args.to],
+        ]) {
+            if (value && Number.isNaN(Date.parse(value))) {
+                throw new Error(`Invalid --${key} date "${value}". Use ISO 8601 format (e.g. 2024-01-01).`);
+            }
+        }
+        const response = await ApiGateway.listUploads(apiUrl, auth, {
+            name: args.name,
+            from: args.from,
+            to: args.to,
+            limit: args.limit ?? 20,
+            offset: args.offset ?? 0,
+        });
+        return jsonResult(response);
+    }));
+}

package/dist/mcp/tools/run-cloud-test.d.ts

@@ -0,0 +1,14 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Submit a Maestro flow (or directory of flows) to devicecloud.dev.
+ *
+ * This is the only state-changing / billable tool — it consumes test minutes,
+ * so it is hidden in read-only mode and annotated as non-read-only/destructive
+ * so clients can gate it behind confirmation. Defaults to async (submit and
+ * return the upload id); set `wait: true` to block until completion, bounded by
+ * `waitTimeoutSeconds`.
+ *
+ * Mirrors the `dcd cloud` command's submission path but headless: no Expo URL
+ * download, mitm, GitHub metadata, or JSON-file output. Use the CLI for those.
+ */
+export declare function registerRunCloudTest(server: McpServer): void;

package/dist/mcp/tools/run-cloud-test.js

@@ -0,0 +1,233 @@
+import * as path from 'node:path';
+import { z } from 'zod';
+import { ApiError, ApiGateway } from '../../gateways/api-gateway.js';
+import { plan } from '../../services/execution-plan.service.js';
+import { computeCommonRoot, buildTestMetadataMap } from '../../services/flow-paths.js';
+import { DeviceValidationService } from '../../services/device-validation.service.js';
+import { TestSubmissionService } from '../../services/test-submission.service.js';
+import { VersionService } from '../../services/version.service.js';
+import { uploadBinary, uploadFlowZip, verifyAppZip } from '../../methods.js';
+import { getCliVersion } from '../../utils/cli.js';
+import { fetchCompatibilityData } from '../../utils/compatibility.js';
+import { getConsoleUrl } from '../../utils/styling.js';
+import { getContext, logStderr } from '../context.js';
+import { jsonResult, runTool } from '../helpers.js';
+const SUPPORTED_APP_EXTENSIONS = ['.apk', '.app', '.zip'];
+const POLL_INTERVAL_MS = 10_000;
+const TERMINAL_STATUSES = new Set(['PASSED', 'FAILED', 'CANCELLED', 'ERROR']);
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * Submit a Maestro flow (or directory of flows) to devicecloud.dev.
+ *
+ * This is the only state-changing / billable tool — it consumes test minutes,
+ * so it is hidden in read-only mode and annotated as non-read-only/destructive
+ * so clients can gate it behind confirmation. Defaults to async (submit and
+ * return the upload id); set `wait: true` to block until completion, bounded by
+ * `waitTimeoutSeconds`.
+ *
+ * Mirrors the `dcd cloud` command's submission path but headless: no Expo URL
+ * download, mitm, GitHub metadata, or JSON-file output. Use the CLI for those.
+ */
+export function registerRunCloudTest(server) {
+    server.registerTool('dcd_run_cloud_test', {
+        title: 'Run a cloud test',
+        description: 'Submit a Maestro flow (or a directory of flows) to run on devicecloud.dev. ' +
+            'Consumes test minutes (billable). Provide a flowFile plus either appFile (a local .apk/.app/.zip) or appBinaryId (a previously uploaded binary). ' +
+            'Defaults to async: returns { uploadId, consoleUrl, status: "PENDING", tests } immediately — poll dcd_get_status with the uploadId. ' +
+            'Set wait: true to block until the run finishes (bounded by waitTimeoutSeconds). ' +
+            'Set dryRun: true to preview which flows would run without submitting.',
+        inputSchema: {
+            flowFile: z
+                .string()
+                .describe('Path to a Maestro flow .yaml/.yml file, or a directory of flows'),
+            appFile: z
+                .string()
+                .optional()
+                .describe('Path to a local app binary (.apk, .app, or .zip). Mutually exclusive with appBinaryId.'),
+            appBinaryId: z
+                .string()
+                .optional()
+                .describe('ID of a previously uploaded binary. Mutually exclusive with appFile.'),
+            iosVersion: z.string().optional().describe('iOS version, e.g. "17"'),
+            iosDevice: z.string().optional().describe('iOS device, e.g. "iphone-14"'),
+            androidApiLevel: z.string().optional().describe('Android API level, e.g. "34"'),
+            androidDevice: z.string().optional().describe('Android device, e.g. "pixel-7"'),
+            googlePlay: z.boolean().optional().describe('Use a Google Play-enabled Android image'),
+            name: z.string().optional().describe('A name for this run'),
+            env: z
+                .array(z.string())
+                .optional()
+                .describe('Environment variables as KEY=VALUE strings'),
+            includeTags: z.array(z.string()).optional().describe('Only run flows with these tags'),
+            excludeTags: z.array(z.string()).optional().describe('Skip flows with these tags'),
+            excludeFlows: z.array(z.string()).optional().describe('Flow paths/patterns to exclude'),
+            maestroVersion: z.string().optional().describe('Pin a specific Maestro version'),
+            retry: z.number().int().min(0).max(2).optional().describe('Auto-retry failed tests (max 2)'),
+            runnerType: z
+                .enum(['default', 'm4', 'm1', 'gpu1', 'cpu1'])
+                .optional()
+                .describe('Runner type (default "default")'),
+            configFile: z.string().optional().describe('Path to a workspace config.yaml'),
+            ignoreShaCheck: z
+                .boolean()
+                .optional()
+                .describe('Force re-upload of the binary even if an identical one exists'),
+            dryRun: z.boolean().optional().describe('Preview flows that would run without submitting'),
+            wait: z
+                .boolean()
+                .optional()
+                .describe('Block until the run completes instead of returning immediately (default false)'),
+            waitTimeoutSeconds: z
+                .number()
+                .int()
+                .min(30)
+                .max(3600)
+                .optional()
+                .describe('Max seconds to wait when wait is true (default 600)'),
+        },
+        annotations: {
+            title: 'Run a cloud test',
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+    }, async (args) => runTool('dcd_run_cloud_test', async () => {
+        if (args.appFile && args.appBinaryId) {
+            throw new Error('Provide only one of appFile or appBinaryId, not both.');
+        }
+        const { apiUrl, auth } = await getContext();
+        const cliVersion = getCliVersion();
+        const compatibilityData = await fetchCompatibilityData(apiUrl, auth);
+        const deviceValidation = new DeviceValidationService();
+        deviceValidation.validateiOSDevice(args.iosVersion, args.iosDevice, compatibilityData, { logger: logStderr });
+        deviceValidation.validateAndroidDevice(args.androidApiLevel, args.androidDevice, Boolean(args.googlePlay), compatibilityData, { logger: logStderr });
+        const resolvedMaestroVersion = new VersionService().resolveMaestroVersion(args.maestroVersion, compatibilityData, { logger: logStderr });
+        // Directory inputs must end in a separator so the planner treats them
+        // as a workspace rather than a single file.
+        let flowFile = path.resolve(args.flowFile);
+        if (!flowFile.endsWith('.yaml') &&
+            !flowFile.endsWith('.yml') &&
+            !flowFile.endsWith('/')) {
+            flowFile += '/';
+        }
+        const executionPlan = await plan({
+            input: flowFile,
+            includeTags: args.includeTags ?? [],
+            excludeTags: args.excludeTags ?? [],
+            excludeFlows: args.excludeFlows,
+            configFile: args.configFile,
+        });
+        const commonRoot = computeCommonRoot(executionPlan.flowsToRun, executionPlan.referencedFiles);
+        const testMetadataMap = buildTestMetadataMap(executionPlan.flowMetadata, commonRoot);
+        if (args.dryRun) {
+            return jsonResult({
+                dryRun: true,
+                flows: Object.entries(testMetadataMap).map(([file, meta]) => ({
+                    file,
+                    flowName: meta.flowName,
+                    tags: meta.tags,
+                })),
+                sequentialFlowCount: executionPlan.sequence?.flows.length ?? 0,
+            });
+        }
+        // Resolve the binary: existing id, or upload the local file.
+        let appBinaryId = args.appBinaryId;
+        if (!appBinaryId) {
+            if (!args.appFile) {
+                throw new Error('Provide either appFile or appBinaryId.');
+            }
+            if (!SUPPORTED_APP_EXTENSIONS.some((ext) => args.appFile.endsWith(ext))) {
+                throw new Error(`App file must be one of: ${SUPPORTED_APP_EXTENSIONS.join(', ')} (got ${args.appFile}).`);
+            }
+            if (args.appFile.endsWith('.zip')) {
+                await verifyAppZip(args.appFile);
+            }
+            appBinaryId = await uploadBinary({
+                auth,
+                apiUrl,
+                filePath: args.appFile,
+                ignoreShaCheck: Boolean(args.ignoreShaCheck),
+                log: false,
+            });
+        }
+        const { continueOnFailure = true } = executionPlan.sequence ?? {};
+        const testSubmissionService = new TestSubmissionService();
+        const { buffer, fields } = await testSubmissionService.buildTestPayload({
+            appBinaryId,
+            cliVersion,
+            commonRoot,
+            continueOnFailure,
+            executionPlan,
+            flowFile,
+            env: args.env ?? [],
+            googlePlay: Boolean(args.googlePlay),
+            androidApiLevel: args.androidApiLevel,
+            androidDevice: args.androidDevice,
+            iOSDevice: args.iosDevice,
+            iOSVersion: args.iosVersion,
+            name: args.name,
+            runnerType: args.runnerType ?? 'default',
+            maestroVersion: resolvedMaestroVersion,
+            retry: args.retry,
+            logger: logStderr,
+        });
+        // New path: upload the zip to storage, then submit a JSON test
+        // referencing it. Older API deployments lack these endpoints (404/405);
+        // fall back to the legacy multipart POST /uploads/flow. Mirrors
+        // `dcd cloud`.
+        let response;
+        try {
+            const storageRef = await uploadFlowZip({ apiUrl, auth, buffer });
+            response = await ApiGateway.submitFlowTest(apiUrl, auth, {
+                ...fields,
+                ...storageRef,
+            });
+        }
+        catch (error) {
+            if (error instanceof ApiError &&
+                (error.status === 404 || error.status === 405)) {
+                const testFormData = testSubmissionService.buildFormData(fields, buffer);
+                response = await ApiGateway.uploadFlow(apiUrl, auth, testFormData);
+            }
+            else {
+                throw error;
+            }
+        }
+        const { message, results } = response;
+        if (!results?.length) {
+            throw new Error(`No tests were created: ${message}`);
+        }
+        const uploadId = results[0].test_upload_id;
+        const consoleUrl = getConsoleUrl(apiUrl, uploadId, results[0].id);
+        const tests = results.map((r) => ({
+            fileName: r.test_file_name,
+            flowName: testMetadataMap[r.test_file_name]?.flowName ||
+                path.parse(r.test_file_name).name,
+            tags: testMetadataMap[r.test_file_name]?.tags ?? [],
+            status: r.status,
+        }));
+        if (!args.wait) {
+            return jsonResult({ uploadId, consoleUrl, status: 'PENDING', tests, message });
+        }
+        // Bounded poll. The run continues in the cloud regardless of timeout —
+        // the caller can resume with dcd_get_status using the returned uploadId.
+        const deadline = Date.now() + (args.waitTimeoutSeconds ?? 600) * 1000;
+        for (;;) {
+            const status = await ApiGateway.getUploadStatus(apiUrl, auth, { uploadId });
+            if (TERMINAL_STATUSES.has(status.status)) {
+                return jsonResult({ uploadId, consoleUrl, status: status.status, tests: status.tests });
+            }
+            if (Date.now() + POLL_INTERVAL_MS >= deadline) {
+                return jsonResult({
+                    uploadId,
+                    consoleUrl,
+                    status: status.status,
+                    timedOut: true,
+                    tests: status.tests,
+                    message: `Still running after ${args.waitTimeoutSeconds ?? 600}s; poll dcd_get_status with uploadId ${uploadId}.`,
+                });
+            }
+            await sleep(POLL_INTERVAL_MS);
+        }
+    }));
+}

package/dist/methods.d.ts

@@ -1,4 +1,4 @@
-import type { AuthContext } from './types/domain/auth.types';
+import type { AuthContext } from './types/domain/auth.types.js';
 export declare const compressFilesFromRelativePath: (basePath: string, files: string[], commonRoot: string) => Promise<Buffer>;
 export declare const verifyAppZip: (zipPath: string) => Promise<void>;
 interface UploadBinaryConfig {
@@ -10,6 +10,37 @@ interface UploadBinaryConfig {
     log?: boolean;
 }
 export declare const uploadBinary: (config: UploadBinaryConfig) => Promise<string>;
+/**
+ * Storage reference for an already-uploaded flow zip, threaded into the
+ * `submitFlowTest` JSON body so the API can locate the staged file.
+ */
+export interface FlowZipUploadResult {
+    backblazeSuccess: boolean;
+    bytes: number;
+    id: string;
+    path: string;
+    supabaseSuccess: boolean;
+    useTus: boolean;
+}
+/**
+ * Uploads an already-built flow zip directly to storage, mirroring the binary
+ * client-direct path: getFlowUploadUrl → upload to storage (Backblaze if
+ * offered + TUS to Supabase) → return the storage reference for submitFlowTest.
+ *
+ * The zip arrives as an in-memory Buffer (from `compressFilesFromRelativePath`);
+ * it's written to a temp file so the exact same disk-streaming uploaders the
+ * binary path uses can be reused unchanged. `supabaseSuccess`/`backblazeSuccess`
+ * are reported honestly based on which uploads succeeded.
+ *
+ * Errors from `getFlowUploadUrl` propagate untouched so callers can detect a
+ * 404 from an older API and fall back to the legacy multipart endpoint.
+ */
+export declare const uploadFlowZip: (config: {
+    apiUrl: string;
+    auth: AuthContext;
+    buffer: Buffer;
+    debug?: boolean;
+}) => Promise<FlowZipUploadResult>;
 /**
  * Writes JSON data to a file with error handling
  * @param filePath - Path to the output JSON file