@boxes-dev/dvb-runtime 1.0.297 → 1.0.299

package/dist/devbox/commands/providerClient.js

@@ -1,719 +0,0 @@
-import { createCliProviderClient, ProviderClientError, ProviderNotImplementedError, resolveModalCredentials, resolveModalCredentialsAsync, } from "@boxes-dev/core";
-import { createManagedCheckpoint, fetchManagedDaemonConnectInfo, fetchResolvedModalCredentials, } from "../controlPlane.js";
-import { createModalRuntimeClient } from "./provider/modalRuntime.js";
-import { defaultE2bProviderOperations, mapE2bRecordToProviderInstance, requireE2bControlPlaneToken, } from "./provider/e2bLifecycleShared.js";
-import { findModalSandbox, provisionModalSandbox, terminateModalSandboxesByAlias, } from "./provider/modalLifecycle.js";
-const CORE_SERVICE_NAMES = new Set(["devbox-sprite-daemon", "devbox-sshd"]);
-const DEFAULT_MODAL_APP_NAME = "sandbox-modal-smoke";
-const normalizeServiceStatus = (status) => {
-    if (status === "starting")
-        return "starting";
-    if (status === "running")
-        return "running";
-    if (status === "failed")
-        return "failed";
-    return "stopped";
-};
-const mapSpriteServiceToProviderRecord = (service) => {
-    const nowIso = new Date().toISOString();
-    return {
-        spec: {
-            name: service.name,
-            scope: CORE_SERVICE_NAMES.has(service.name) ? "core" : "user",
-            cmd: service.cmd ?? "",
-            args: service.args ?? [],
-            httpPort: typeof service.httpPort === "number" ? service.httpPort : null,
-            workingDir: null,
-            autostart: true,
-            restartPolicy: "always",
-            createdAt: nowIso,
-            updatedAt: nowIso,
-        },
-        state: {
-            status: normalizeServiceStatus(service.state?.status),
-            pid: typeof service.state?.pid === "number" &&
-                Number.isFinite(service.state.pid)
-                ? service.state.pid
-                : null,
-            startedAt: typeof service.state?.startedAt === "string"
-                ? service.state.startedAt
-                : null,
-            lastExitAt: null,
-            lastExitCode: null,
-            restartCount: 0,
-            nextRestartAt: null,
-        },
-    };
-};
-const mapProviderUpsertToSpriteInput = (input) => ({
-    cmd: input.cmd,
-    args: input.args,
-    ...(typeof input.httpPort === "number" ? { httpPort: input.httpPort } : {}),
-});
-const trimToNull = (value) => {
-    if (typeof value !== "string")
-        return null;
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : null;
-};
-const normalizeEpochToIso = (value) => {
-    if (!Number.isFinite(value) || value <= 0)
-        return null;
-    const milliseconds = value >= 1_000_000_000_000 ? value : value * 1000;
-    const date = new Date(milliseconds);
-    return Number.isNaN(date.getTime()) ? null : date.toISOString();
-};
-const resolveModalRuntimeSeedAppName = () => {
-    const configured = process.env.MODAL_SANDBOX_APP?.trim();
-    if (configured && configured.length > 0) {
-        return configured;
-    }
-    return DEFAULT_MODAL_APP_NAME;
-};
-const createProviderCredentialContext = (options = {}) => ({
-    mode: options.mode ?? "auto",
-    controlPlaneToken: trimToNull(options.controlPlaneToken),
-    spritesToken: trimToNull(options.spritesToken),
-    modalTokenId: trimToNull(options.modalTokenId),
-    modalTokenSecret: trimToNull(options.modalTokenSecret),
-    e2bApiKey: trimToNull(options.e2bApiKey),
-});
-const resolveModalCommandOperationOptions = async (options = {}) => {
-    const providedCredentialContext = options.credentials ??
-        createProviderCredentialContext({
-            ...(options.credentialMode ? { mode: options.credentialMode } : {}),
-        });
-    const baseCredentialContext = {
-        ...providedCredentialContext,
-        // Modal runtime command flows resolve credentials from control plane only.
-        modalTokenId: null,
-        modalTokenSecret: null,
-    };
-    const resolveSharedCredentials = options.resolveSharedCredentials ??
-        (async (controlPlaneToken) => await fetchResolvedModalCredentials(controlPlaneToken));
-    const resolved = await resolveModalCredentialsAsync({
-        ...(options.credentialMode
-            ? { credentialMode: options.credentialMode }
-            : {}),
-        credentials: baseCredentialContext,
-        ...(options.cwd ? { cwd: options.cwd } : {}),
-        resolveSharedCredentials,
-    });
-    const credentials = {
-        ...baseCredentialContext,
-        mode: resolved.mode,
-        modalTokenId: resolved.tokenId,
-        modalTokenSecret: resolved.tokenSecret,
-    };
-    return {
-        credentialMode: resolved.mode,
-        credentials,
-        ...(options.cwd ? { cwd: options.cwd } : {}),
-    };
-};
-const throwModalConnectUnsupported = (method) => {
-    throw new Error(`${method} is not supported for modal devboxes yet.`);
-};
-const createModalConnectSpritesClient = ({ alias, appName, sandboxId, operationOptions, ensureActive, runtimeClient, }) => {
-    const runtime = runtimeClient ??
-        createModalRuntimeClient({
-            alias,
-            appName,
-            sandboxId,
-            serviceRole: "user",
-            ...(ensureActive ? { ensureActive } : {}),
-            credentialMode: operationOptions.credentialMode,
-            credentials: operationOptions.credentials,
-            ...(operationOptions.cwd ? { cwd: operationOptions.cwd } : {}),
-        });
-    return {
-        listSprites: async () => throwModalConnectUnsupported("listSprites (modal connect client)"),
-        getSprite: async () => throwModalConnectUnsupported("getSprite (modal connect client)"),
-        createSprite: async () => throwModalConnectUnsupported("createSprite (modal connect client)"),
-        deleteSprite: async () => throwModalConnectUnsupported("deleteSprite (modal connect client)"),
-        writeFile: runtime.writeFile,
-        readFile: runtime.readFile,
-        exec: runtime.exec,
-        listExecSessions: runtime.listExecSessions,
-        killExecSession: runtime.killExecSession,
-        createCheckpoint: runtime.createCheckpoint,
-        listServices: runtime.listServices,
-        getService: runtime.getService,
-        createService: runtime.createService,
-        startService: runtime.startService,
-        stopService: runtime.stopService,
-        signalService: runtime.signalService,
-        deleteService: runtime.deleteService,
-        readServiceLogs: runtime.readServiceLogs,
-        openExecSession: runtime.openExecSession,
-        attachExecSession: runtime.attachExecSession,
-        openProxySocket: () => throwModalConnectUnsupported("openProxySocket (modal connect client)"),
-    };
-};
-const throwModalNotImplemented = (capability) => {
-    throw new ProviderNotImplementedError({
-        provider: "modal",
-        capability,
-        message: `Modal provider capability "${capability}" is not implemented yet.`,
-    });
-};
-const throwE2bNotImplemented = (capability) => {
-    throw new ProviderNotImplementedError({
-        provider: "e2b",
-        capability,
-        message: `E2B provider capability "${capability}" is not implemented yet.`,
-    });
-};
-const MODAL_AUTH_ERROR_CODES = new Set(["16", "UNAUTHENTICATED"]);
-const normalizeModalErrorCode = (value) => {
-    if (typeof value === "number" && Number.isFinite(value)) {
-        return String(value);
-    }
-    if (typeof value !== "string") {
-        return null;
-    }
-    const trimmed = value.trim();
-    if (!trimmed) {
-        return null;
-    }
-    if (/^\d+$/.test(trimmed)) {
-        return String(Number.parseInt(trimmed, 10));
-    }
-    return trimmed.toUpperCase();
-};
-const extractModalErrorCode = (error) => {
-    if (!error || typeof error !== "object") {
-        return null;
-    }
-    const withCode = error;
-    const directCode = normalizeModalErrorCode(withCode.code);
-    if (directCode) {
-        return directCode;
-    }
-    const statusCode = normalizeModalErrorCode(withCode.status);
-    if (statusCode) {
-        return statusCode;
-    }
-    if (withCode.status && typeof withCode.status === "object") {
-        const nested = withCode.status;
-        const nestedCode = normalizeModalErrorCode(nested.code);
-        if (nestedCode) {
-            return nestedCode;
-        }
-    }
-    return null;
-};
-const isModalAuthError = (error) => {
-    if (error instanceof ProviderClientError) {
-        return error.code === "authentication_required";
-    }
-    if (!error || typeof error !== "object") {
-        return false;
-    }
-    const directCode = extractModalErrorCode(error);
-    if (directCode && MODAL_AUTH_ERROR_CODES.has(directCode)) {
-        return true;
-    }
-    const withCause = error;
-    const causeCode = extractModalErrorCode(withCause.cause);
-    return Boolean(causeCode && MODAL_AUTH_ERROR_CODES.has(causeCode));
-};
-const rethrowModalOperationError = (error) => {
-    if (error instanceof ProviderClientError) {
-        throw error;
-    }
-    if (isModalAuthError(error)) {
-        throw new ProviderClientError({
-            provider: "modal",
-            code: "authentication_required",
-            capability: null,
-            message: "Modal authentication failed. Run `dvb setup` or provide Modal BYO credentials.",
-        });
-    }
-    throw error;
-};
-const mapModalRecordToProviderInstance = (alias, record) => {
-    if (!record)
-        return null;
-    return {
-        provider: "modal",
-        providerInstanceId: alias,
-        status: record.status,
-        organization: null,
-        createdAt: normalizeEpochToIso(record.createdAt),
-        updatedAt: null,
-        url: null,
-    };
-};
-const createModalCommandProviderClient = (options = {}) => {
-    const providedCredentialContext = options.credentials ??
-        createProviderCredentialContext({
-            ...(options.credentialMode ? { mode: options.credentialMode } : {}),
-        });
-    const baseCredentialContext = {
-        ...providedCredentialContext,
-        modalTokenId: null,
-        modalTokenSecret: null,
-    };
-    const resolvedCredentials = resolveModalCredentials({
-        ...(options.credentialMode
-            ? { credentialMode: options.credentialMode }
-            : {}),
-        credentials: baseCredentialContext,
-        ...(options.cwd ? { cwd: options.cwd } : {}),
-    });
-    const syncOperationOptions = {
-        credentialMode: resolvedCredentials.mode,
-        credentials: {
-            ...baseCredentialContext,
-            mode: resolvedCredentials.mode,
-            modalTokenId: resolvedCredentials.tokenId,
-            modalTokenSecret: resolvedCredentials.tokenSecret,
-        },
-        ...(options.cwd ? { cwd: options.cwd } : {}),
-    };
-    const modalOperations = options.operations ?? {
-        findSandbox: findModalSandbox,
-        provisionSandbox: provisionModalSandbox,
-        terminateSandboxesByAlias: terminateModalSandboxesByAlias,
-    };
-    const modalRuntimeByAlias = new Map();
-    let modalOperationOptionsPromise = null;
-    const resolveModalOperationOptions = async () => {
-        if (!modalOperationOptionsPromise) {
-            modalOperationOptionsPromise = resolveModalCommandOperationOptions({
-                ...(options.credentialMode
-                    ? { credentialMode: options.credentialMode }
-                    : {}),
-                credentials: baseCredentialContext,
-                ...(options.cwd ? { cwd: options.cwd } : {}),
-                ...(options.resolveSharedCredentials
-                    ? { resolveSharedCredentials: options.resolveSharedCredentials }
-                    : {}),
-            }).catch((error) => {
-                modalOperationOptionsPromise = null;
-                throw error;
-            });
-        }
-        return await modalOperationOptionsPromise;
-    };
-    const createModalRuntime = (args) => {
-        const controlPlaneToken = trimToNull(args.operationOptions.credentials.controlPlaneToken);
-        const issueConnectToken = controlPlaneToken
-            ? async (intent) => {
-                const connectInfo = await fetchManagedDaemonConnectInfo(controlPlaneToken, args.alias, intent);
-                if (connectInfo.provider !== "modal") {
-                    throw new Error(`Managed daemon connect returned provider "${connectInfo.provider}" for modal alias "${args.alias}".`);
-                }
-                return connectInfo;
-            }
-            : undefined;
-        const createCheckpoint = controlPlaneToken
-            ? async (comment) => await createManagedCheckpoint(controlPlaneToken, args.alias, comment)
-            : undefined;
-        const runtimeOptions = {
-            alias: args.alias,
-            appName: args.appName,
-            sandboxId: args.sandboxId,
-            operationOptions: args.operationOptions,
-            ...(options.ensureActive ? { ensureActive: options.ensureActive } : {}),
-        };
-        if (options.runtimeClientFactory) {
-            return options.runtimeClientFactory(runtimeOptions);
-        }
-        return createModalRuntimeClient({
-            alias: runtimeOptions.alias,
-            appName: runtimeOptions.appName,
-            sandboxId: runtimeOptions.sandboxId,
-            serviceRole: "user",
-            credentialMode: runtimeOptions.operationOptions.credentialMode,
-            credentials: runtimeOptions.operationOptions.credentials,
-            ...(issueConnectToken
-                ? {
-                    createConnectToken: async (intent) => {
-                        const token = await issueConnectToken(intent);
-                        return { url: token.url, token: token.token };
-                    },
-                }
-                : {}),
-            ...(createCheckpoint
-                ? {
-                    createCheckpoint,
-                }
-                : {}),
-            ...(runtimeOptions.operationOptions.cwd
-                ? { cwd: runtimeOptions.operationOptions.cwd }
-                : {}),
-            ...(runtimeOptions.ensureActive
-                ? { ensureActive: runtimeOptions.ensureActive }
-                : {}),
-        });
-    };
-    const resolveModalRuntimeClientSync = (alias) => {
-        const cached = modalRuntimeByAlias.get(alias);
-        if (cached) {
-            return cached;
-        }
-        const runtime = createModalRuntime({
-            alias,
-            operationOptions: syncOperationOptions,
-            appName: resolveModalRuntimeSeedAppName(),
-            sandboxId: "pending",
-        });
-        modalRuntimeByAlias.set(alias, runtime);
-        return runtime;
-    };
-    return {
-        provider: "modal",
-        credentialMode: resolvedCredentials.mode,
-        listInstances: async () => throwModalNotImplemented("instances.list"),
-        getInstance: async (name) => {
-            try {
-                const operationOptions = await resolveModalOperationOptions();
-                return mapModalRecordToProviderInstance(name, await modalOperations.findSandbox({ alias: name, includeFinished: true }, operationOptions));
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        createInstance: async (name) => {
-            try {
-                const operationOptions = await resolveModalOperationOptions();
-                const created = await modalOperations.provisionSandbox(name, operationOptions);
-                return {
-                    provider: "modal",
-                    providerInstanceId: name,
-                    status: "running",
-                    organization: null,
-                    createdAt: null,
-                    updatedAt: created.sandboxId.trim().length > 0
-                        ? new Date().toISOString()
-                        : null,
-                    url: null,
-                };
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        deleteInstance: async (name) => {
-            try {
-                const operationOptions = await resolveModalOperationOptions();
-                await modalOperations.terminateSandboxesByAlias(name, {
-                    includeFinished: true,
-                    ...operationOptions,
-                });
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        writeFile: async (name, remotePath, data, writeOptions) => {
-            try {
-                const runtime = resolveModalRuntimeClientSync(name);
-                await runtime.writeFile(name, remotePath, data, writeOptions);
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        readFile: async (name, readOptions) => {
-            try {
-                const runtime = resolveModalRuntimeClientSync(name);
-                return await runtime.readFile(name, readOptions);
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        exec: async (name, cmd, execOptions) => {
-            try {
-                const runtime = resolveModalRuntimeClientSync(name);
-                return await runtime.exec(name, cmd, execOptions);
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        listExecSessions: async (name) => {
-            try {
-                const runtime = resolveModalRuntimeClientSync(name);
-                return await runtime.listExecSessions(name);
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        killExecSession: async (name, sessionId, options) => {
-            try {
-                const runtime = resolveModalRuntimeClientSync(name);
-                return await runtime.killExecSession(name, sessionId, options);
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        createCheckpoint: async () => throwModalNotImplemented("checkpoints.create"),
-        listServices: async (name) => {
-            try {
-                const runtime = resolveModalRuntimeClientSync(name);
-                return await runtime.listServices(name);
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        getService: async (name, service) => {
-            try {
-                const runtime = resolveModalRuntimeClientSync(name);
-                return await runtime.getService(name, service);
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        createService: async (name, service, input) => {
-            try {
-                const runtime = resolveModalRuntimeClientSync(name);
-                return await runtime.createService(name, service, input);
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        startService: async (name, service, options) => {
-            try {
-                const runtime = resolveModalRuntimeClientSync(name);
-                return await runtime.startService(name, service, options);
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        stopService: async (name, service, options) => {
-            try {
-                const runtime = resolveModalRuntimeClientSync(name);
-                return await runtime.stopService(name, service, options);
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        listServiceRecords: async (name) => {
-            try {
-                const runtime = resolveModalRuntimeClientSync(name);
-                if (runtime.listServiceRecords) {
-                    return await runtime.listServiceRecords(name);
-                }
-                const services = await runtime.listServices(name);
-                return services.map((service) => mapSpriteServiceToProviderRecord(service));
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        getServiceRecord: async (name, service) => {
-            try {
-                const runtime = resolveModalRuntimeClientSync(name);
-                if (runtime.getServiceRecord) {
-                    return await runtime.getServiceRecord(name, service);
-                }
-                const found = await runtime.getService(name, service);
-                return found ? mapSpriteServiceToProviderRecord(found) : null;
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        upsertService: async (name, service, input) => {
-            try {
-                const runtime = resolveModalRuntimeClientSync(name);
-                if (runtime.upsertServiceRecord) {
-                    return await runtime.upsertServiceRecord(name, service, input);
-                }
-                const created = await runtime.createService(name, service, mapProviderUpsertToSpriteInput(input));
-                if (created?.state?.status !== "running") {
-                    await runtime.startService(name, service, { duration: "0" });
-                }
-                const refreshed = await runtime.getService(name, service);
-                return refreshed ? mapSpriteServiceToProviderRecord(refreshed) : null;
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        signalService: async (name, service, options) => {
-            try {
-                const runtime = resolveModalRuntimeClientSync(name);
-                return await runtime.signalService(name, service, options);
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        deleteService: async (name, service) => {
-            try {
-                const runtime = resolveModalRuntimeClientSync(name);
-                await runtime.deleteService(name, service);
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        readServiceLogs: async (name, service, options) => {
-            try {
-                const runtime = resolveModalRuntimeClientSync(name);
-                return await runtime.readServiceLogs(name, service, options);
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        openExecSession: (name, openOptions) => {
-            try {
-                const runtime = resolveModalRuntimeClientSync(name);
-                return runtime.openExecSession(name, openOptions);
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        attachExecSession: (name, sessionId) => {
-            try {
-                const runtime = resolveModalRuntimeClientSync(name);
-                return runtime.attachExecSession(name, sessionId);
-            }
-            catch (error) {
-                return rethrowModalOperationError(error);
-            }
-        },
-        openProxySocket: () => throwModalNotImplemented("proxy.open"),
-    };
-};
-const createE2bCommandProviderClient = (options) => {
-    const e2bOperations = options.operations ?? defaultE2bProviderOperations;
-    const resolveControlPlaneToken = () => requireE2bControlPlaneToken(options.credentials);
-    const runtime = options.runtimeClient;
-    return {
-        provider: "e2b",
-        credentialMode: options.credentialMode ?? "shared",
-        listInstances: async () => {
-            const controlPlaneToken = resolveControlPlaneToken();
-            const records = await e2bOperations.listDevboxes(controlPlaneToken);
-            return {
-                instances: records
-                    .map((record) => mapE2bRecordToProviderInstance(record))
-                    .filter((record) => record !== null),
-                nextContinuationToken: null,
-                hasMore: false,
-            };
-        },
-        getInstance: async (name) => mapE2bRecordToProviderInstance(await e2bOperations.getDevbox(resolveControlPlaneToken(), name)),
-        createInstance: async (name) => {
-            const created = await e2bOperations.provisionDevbox(resolveControlPlaneToken(), name);
-            return {
-                provider: "e2b",
-                providerInstanceId: created.sandboxId,
-                status: created.status,
-                organization: null,
-                createdAt: null,
-                updatedAt: new Date().toISOString(),
-                url: null,
-            };
-        },
-        deleteInstance: async (name) => {
-            await e2bOperations.destroyDevbox(resolveControlPlaneToken(), name);
-        },
-        writeFile: runtime.writeFile,
-        readFile: runtime.readFile,
-        exec: runtime.exec,
-        listExecSessions: runtime.listExecSessions,
-        killExecSession: runtime.killExecSession,
-        createCheckpoint: runtime.createCheckpoint,
-        listServices: runtime.listServices,
-        getService: runtime.getService,
-        createService: runtime.createService,
-        startService: runtime.startService,
-        stopService: runtime.stopService,
-        listServiceRecords: async (name) => {
-            if (runtime.listServiceRecords) {
-                return await runtime.listServiceRecords(name);
-            }
-            const services = await runtime.listServices(name);
-            return services.map((service) => mapSpriteServiceToProviderRecord(service));
-        },
-        getServiceRecord: async (name, service) => {
-            if (runtime.getServiceRecord) {
-                return await runtime.getServiceRecord(name, service);
-            }
-            const found = await runtime.getService(name, service);
-            return found ? mapSpriteServiceToProviderRecord(found) : null;
-        },
-        upsertService: async (name, service, input) => {
-            if (runtime.upsertServiceRecord) {
-                return await runtime.upsertServiceRecord(name, service, input);
-            }
-            const created = await runtime.createService(name, service, mapProviderUpsertToSpriteInput(input));
-            if (created?.state?.status !== "running") {
-                await runtime.startService(name, service, { duration: "0" });
-            }
-            const refreshed = await runtime.getService(name, service);
-            return refreshed ? mapSpriteServiceToProviderRecord(refreshed) : null;
-        },
-        signalService: runtime.signalService,
-        deleteService: runtime.deleteService,
-        readServiceLogs: runtime.readServiceLogs,
-        openExecSession: runtime.openExecSession,
-        attachExecSession: runtime.attachExecSession,
-        openProxySocket: () => throwE2bNotImplemented("proxy.open"),
-    };
-};
-const createCommandProviderClient = (options) => {
-    if (options.provider === "sprites") {
-        return createCliProviderClient({
-            provider: "sprites",
-            ...(options.credentialMode
-                ? { credentialMode: options.credentialMode }
-                : {}),
-            ...(options.credentials !== undefined
-                ? { credentials: options.credentials }
-                : {}),
-            sprites: {
-                apiBaseUrl: options.sprites.apiBaseUrl,
-                token: options.sprites.token,
-                ...(options.sprites.client ? { client: options.sprites.client } : {}),
-            },
-        });
-    }
-    if (options.provider === "e2b") {
-        return createE2bCommandProviderClient({
-            ...(options.credentials !== undefined
-                ? { credentials: options.credentials }
-                : {}),
-            ...(options.credentialMode
-                ? { credentialMode: options.credentialMode }
-                : {}),
-            runtimeClient: options.runtimeClient,
-            ...(options.operations ? { operations: options.operations } : {}),
-        });
-    }
-    return createModalCommandProviderClient({
-        ...(options.credentialMode
-            ? { credentialMode: options.credentialMode }
-            : {}),
-        ...(options.credentials !== undefined
-            ? { credentials: options.credentials }
-            : {}),
-        ...(options.cwd ? { cwd: options.cwd } : {}),
-        ...(options.operations ? { operations: options.operations } : {}),
-        ...(options.ensureActive ? { ensureActive: options.ensureActive } : {}),
-        ...(options.resolveSharedCredentials
-            ? { resolveSharedCredentials: options.resolveSharedCredentials }
-            : {}),
-        ...(options.runtimeClientFactory
-            ? { runtimeClientFactory: options.runtimeClientFactory }
-            : {}),
-    });
-};
-export { createCommandProviderClient, createModalConnectSpritesClient, createProviderCredentialContext, resolveModalCommandOperationOptions, };
-//# sourceMappingURL=providerClient.js.map