@viewportai/daemon 0.25.12 → 0.26.0

package/dist/cli/worker-runtime.js

@@ -11,99 +11,169 @@ import { GitTracker } from '../tracking/git-tracker.js';
 import { workflowRunToSyncPayload } from '../workflows/platform-sync-payload.js';
 import { WorkflowRunStore } from '../workflows/store.js';
 import { transportFetch } from './network.js';
+import { acquireWorkerProcessLock } from './worker-process-lock.js';
+import { readWorkerPairingRecord, workerProfileIntegrity, } from './worker-profile.js';
+class HttpPollingTransport {
+    profile;
+    mode;
+    constructor(profile, mode) {
+        this.profile = profile;
+        this.mode = mode;
+    }
+    claim(body) {
+        return claimLeaseHttp(this.profile, body);
+    }
+    heartbeat(options) {
+        return heartbeatHttp(this.profile, {
+            ...options,
+            transport: this.mode,
+        });
+    }
+    sync(lease, execution) {
+        return syncLeaseHttp(this.profile, lease, execution);
+    }
+    cleanup(lease) {
+        return cleanupLeaseHttp(this.profile, lease);
+    }
+    pollRuntimeCommands(lease) {
+        return fetchHostedAssignmentHttp(this.profile, lease);
+    }
+}
 const DEFAULT_HOSTED_LEASE_SECONDS = 1_800;
 export async function runStandaloneWorker(options) {
-    const profile = await loadWorkerRuntimeProfile();
-    await validateWorkerWorkspaceRoot(profile.workspaceRoot);
-    const transport = options.transport ?? profile.transport;
-    if (transport === 'inbound') {
-        validateInboundWorkerGate(profile);
-    }
-    if (transport === 'relay') {
-        throw new Error('Relay worker transport is not supported by the standalone runtime yet.');
-    }
-    let lastHeartbeatAt = Date.now();
-    await heartbeat(profile, {
-        status: 'online',
-        healthStatus: 'idle',
-        lifecycle: options.lifecycle,
-        transport,
-    });
-    if (options.leaseToken) {
-        const lease = { id: options.leaseToken, leaseToken: options.leaseToken };
-        await syncLease(profile, lease, { status: 'completed' });
-        await cleanupLease(profile, lease);
-        return { claimed: 1, completed: 1, blocked: 0, failed: 0, cleanup: 1, denied: 0 };
-    }
-    const result = {
-        claimed: 0,
-        completed: 0,
-        blocked: 0,
-        failed: 0,
-        cleanup: 0,
-        denied: 0,
-    };
+    const bootstrap = await loadWorkerRuntimeBootstrap(options.bootstrapPath);
+    const profile = bootstrap.profile;
+    let processLock = null;
     try {
-        while (!options.abortSignal?.aborted) {
-            const lease = await claimLease(profile, {
+        await validateWorkerWorkspaceRoot(profile.workspaceRoot);
+        const transport = options.transport ?? profile.transport;
+        if (transport === 'inbound') {
+            validateInboundWorkerGate(profile);
+        }
+        if (transport === 'relay') {
+            throw new Error('Relay worker transport is not supported by the standalone runtime yet.');
+        }
+        const workerTransport = new HttpPollingTransport(profile, transport);
+        processLock =
+            options.lifecycle === 'persistent' && !options.once
+                ? acquireWorkerProcessLock({
+                    server: profile.serverUrl,
+                    workspaceId: profile.workspaceId ?? profile.publicKeyFingerprint,
+                    executorId: profile.managedExecutorId ?? profile.publicKeyFingerprint,
+                    runnerProfile: runnerPoolFromCapabilities(profile.capabilities),
+                    accessMode: transport,
+                })
+                : null;
+        let lastHeartbeatAt = Date.now();
+        await workerTransport.heartbeat({
+            status: 'online',
+            healthStatus: 'idle',
+            lifecycle: options.lifecycle,
+        });
+        if (bootstrap.lease) {
+            const result = await executeBootstrapLease(profile, workerTransport, bootstrap.lease);
+            await workerTransport.heartbeat({
+                status: 'offline',
+                healthStatus: 'offline',
                 lifecycle: options.lifecycle,
-                transport,
-                leaseSeconds: options.leaseSeconds,
             });
-            if (!lease) {
-                if (options.once || options.lifecycle !== 'persistent')
-                    break;
-                const now = Date.now();
-                if (now - lastHeartbeatAt > 30_000) {
-                    await heartbeat(profile, {
-                        status: 'online',
-                        healthStatus: 'idle',
-                        lifecycle: options.lifecycle,
-                        transport,
-                    });
-                    lastHeartbeatAt = now;
+            return result;
+        }
+        if (options.leaseToken) {
+            const lease = { id: options.leaseToken, leaseToken: options.leaseToken };
+            await workerTransport.sync(lease, { status: 'completed' });
+            await workerTransport.cleanup(lease);
+            return { claimed: 1, completed: 1, blocked: 0, failed: 0, cleanup: 1, denied: 0 };
+        }
+        const result = {
+            claimed: 0,
+            completed: 0,
+            blocked: 0,
+            failed: 0,
+            cleanup: 0,
+            denied: 0,
+        };
+        try {
+            while (!options.abortSignal?.aborted) {
+                const lease = await workerTransport.claim({
+                    lifecycle: options.lifecycle,
+                    transport,
+                    leaseSeconds: options.leaseSeconds,
+                });
+                if (!lease) {
+                    if (options.once || options.lifecycle !== 'persistent')
+                        break;
+                    const now = Date.now();
+                    if (now - lastHeartbeatAt > 30_000) {
+                        await workerTransport.heartbeat({
+                            status: 'online',
+                            healthStatus: 'idle',
+                            lifecycle: options.lifecycle,
+                        });
+                        lastHeartbeatAt = now;
+                    }
+                    await sleepWithAbort(options.pollIntervalMs ?? 5_000, options.abortSignal);
+                    continue;
                 }
-                await sleepWithAbort(options.pollIntervalMs ?? 5_000, options.abortSignal);
-                continue;
-            }
-            result.claimed += 1;
-            let execution = await executeClaim(profile, lease);
-            if (isHostedManagedExecutorProfile(profile) &&
-                execution.status === 'blocked' &&
-                execution.run) {
-                await syncLease(profile, lease, execution);
-                execution = await resumeBlockedHostedExecution(profile, lease, execution);
-                if (execution.status !== 'blocked') {
-                    await syncLease(profile, lease, execution);
+                result.claimed += 1;
+                let execution = await executeClaim(profile, workerTransport, lease);
+                if (isHostedManagedExecutorProfile(profile) &&
+                    execution.status === 'blocked' &&
+                    execution.run) {
+                    await workerTransport.sync(lease, execution);
+                    execution = await resumeBlockedHostedExecution(profile, workerTransport, lease, execution);
+                    if (execution.status !== 'blocked') {
+                        await workerTransport.sync(lease, execution);
+                    }
                 }
+                else {
+                    await workerTransport.sync(lease, execution);
+                }
+                if (execution.status === 'completed') {
+                    result.completed += 1;
+                }
+                else if (execution.status === 'blocked') {
+                    result.blocked += 1;
+                }
+                else {
+                    result.failed += 1;
+                }
+                await workerTransport.cleanup(lease);
+                result.cleanup += 1;
+                if (options.once)
+                    break;
             }
-            else {
-                await syncLease(profile, lease, execution);
-            }
-            if (execution.status === 'completed') {
-                result.completed += 1;
-            }
-            else if (execution.status === 'blocked') {
-                result.blocked += 1;
-            }
-            else {
-                result.failed += 1;
-            }
-            await cleanupLease(profile, lease);
-            result.cleanup += 1;
-            if (options.once)
-                break;
         }
+        finally {
+            await workerTransport.heartbeat({
+                status: 'offline',
+                healthStatus: 'offline',
+                lifecycle: options.lifecycle,
+            });
+        }
+        return result;
     }
     finally {
-        await heartbeat(profile, {
-            status: 'offline',
-            healthStatus: 'offline',
-            lifecycle: options.lifecycle,
-            transport,
-        });
+        processLock?.release();
+        await bootstrap.cleanup?.();
     }
-    return result;
+}
+async function executeBootstrapLease(profile, transport, lease) {
+    const execution = await executeClaim(profile, transport, lease);
+    await transport.sync(lease, execution);
+    await transport.cleanup(lease);
+    return {
+        claimed: 1,
+        completed: execution.status === 'completed' ? 1 : 0,
+        blocked: execution.status === 'blocked' ? 1 : 0,
+        failed: execution.status === 'failed' || execution.status === 'canceled' ? 1 : 0,
+        cleanup: 1,
+        denied: 0,
+    };
+}
+function runnerPoolFromCapabilities(capabilities) {
+    const value = capabilities['runner_pool'] ?? capabilities['runnerPool'];
+    return typeof value === 'string' && value.trim() !== '' ? value : undefined;
 }
 async function validateWorkerWorkspaceRoot(workspaceRoot) {
     const resolved = path.resolve(workspaceRoot);
@@ -124,11 +194,17 @@ async function validateWorkerWorkspaceRoot(workspaceRoot) {
         throw new Error(`Worker workspace root is not readable and writable: ${resolved}.`);
     }
 }
-async function executeClaim(profile, lease) {
+async function executeClaim(profile, transport, lease) {
     if (!isHostedManagedExecutorProfile(profile)) {
         return { status: 'completed' };
     }
-    return executeHostedWorkflowClaim(profile, lease);
+    return executeHostedWorkflowClaim(profile, transport, lease);
+}
+async function loadWorkerRuntimeBootstrap(bootstrapPath) {
+    if (bootstrapPath) {
+        return loadSandboxBootstrap(bootstrapPath);
+    }
+    return { profile: await loadWorkerRuntimeProfile() };
 }
 async function loadWorkerRuntimeProfile() {
     const manager = new ConfigManager();
@@ -144,6 +220,11 @@ async function loadWorkerRuntimeProfile() {
     if (missing.length > 0) {
         throw new Error(`Worker profile is not configured: missing ${missing.join(', ')}.`);
     }
+    const pairing = await readWorkerPairingRecord(worker.stateDir);
+    const integrity = workerProfileIntegrity(worker, pairing);
+    if (!integrity.ok) {
+        throw new Error(`Worker profile does not match the approved pairing record: ${integrity.mismatches.join(', ')}. Run \`vpd worker reset\`, then pair this worker again.`);
+    }
     return {
         serverUrl: worker.serverUrl,
         serverId: worker.serverId,
@@ -161,6 +242,82 @@ async function loadWorkerRuntimeProfile() {
         capabilities: worker.capabilities ?? {},
     };
 }
+async function loadSandboxBootstrap(bootstrapPath) {
+    const raw = JSON.parse(await fs.readFile(bootstrapPath, 'utf8'));
+    if (raw['schema'] !== 'viewport.sandbox_bootstrap/v1') {
+        throw new Error('Sandbox bootstrap file must use schema viewport.sandbox_bootstrap/v1.');
+    }
+    const workspaceRoot = requiredString(raw['workspace_root'] ?? raw['workspaceRoot'], 'workspace_root');
+    const identity = recordValue(raw['identity']);
+    const identityFile = await materializeBootstrapIdentity(identity, workspaceRoot);
+    const profile = {
+        serverUrl: requiredString(raw['server_url'] ?? raw['serverUrl'], 'server_url'),
+        serverId: stringValue(raw['server_id'] ?? raw['serverId']),
+        lifecycle: 'ephemeral',
+        transport: workerTransportValue(raw['transport']) ?? 'polling',
+        workspaceId: requiredString(raw['workspace_id'] ?? raw['workspaceId'], 'workspace_id'),
+        managedExecutorId: requiredString(raw['executor_id'] ?? raw['executorId'], 'executor_id'),
+        credential: requiredString(raw['credential'], 'credential'),
+        workspaceRoot,
+        identityKeyPath: identityFile.path,
+        publicKeyFingerprint: identityFile.publicKeyFingerprint,
+        capabilities: recordValue(raw['capabilities']) ?? {},
+    };
+    return {
+        profile,
+        lease: claimedLeaseFromBootstrap(recordValue(raw['lease'])),
+        cleanup: async () => {
+            if (identityFile.ephemeral) {
+                await fs.rm(identityFile.path, { force: true });
+            }
+        },
+    };
+}
+function claimedLeaseFromBootstrap(rawLease) {
+    if (!rawLease)
+        return undefined;
+    const id = requiredString(rawLease['id'] ?? rawLease['lease_id'] ?? rawLease['leaseId'], 'lease.id');
+    return {
+        id,
+        runId: stringValue(rawLease['workflow_run_id'] ?? rawLease['run_id'] ?? rawLease['runId']),
+        runtimeRunId: stringValue(rawLease['runtime_run_id'] ?? rawLease['runtimeRunId']),
+        leaseToken: stringValue(rawLease['lease_token'] ?? rawLease['leaseToken']),
+        assignmentClaimToken: stringValue(rawLease['assignment_claim_token'] ?? rawLease['assignmentClaimToken']),
+        yamlSnapshot: stringValue(rawLease['yaml_snapshot'] ?? rawLease['yamlSnapshot']),
+        sourceRef: stringValue(rawLease['source_ref'] ?? rawLease['sourceRef']),
+        directoryPath: stringValue(rawLease['directory_path'] ?? rawLease['directoryPath']),
+        inputSnapshot: recordValue(rawLease['input_snapshot'] ?? rawLease['inputSnapshot']),
+        resourceManifest: recordValue(rawLease['resource_manifest'] ?? rawLease['resourceManifest']),
+        workflowAuthorityContract: recordValue(rawLease['workflow_authority_contract'] ?? rawLease['workflowAuthorityContract']),
+        executionProfileSnapshot: recordValue(rawLease['execution_profile_snapshot'] ?? rawLease['executionProfileSnapshot']),
+        workflowSnapshot: recordValue(rawLease['workflow_snapshot'] ?? rawLease['workflowSnapshot']),
+        runtimeTargetId: stringValue(rawLease['runtime_target_id'] ?? rawLease['runtimeTargetId']),
+        dataCapturePolicy: dataCapturePolicyValue(rawLease['data_capture_policy'] ?? rawLease['dataCapturePolicy']),
+    };
+}
+async function materializeBootstrapIdentity(identity, workspaceRoot) {
+    if (!identity) {
+        throw new Error('Sandbox bootstrap file is missing identity.');
+    }
+    const publicKey = requiredString(identity['public_key'] ?? identity['publicKey'], 'identity.public_key');
+    const privateKey = requiredString(identity['private_key'] ?? identity['privateKey'], 'identity.private_key');
+    const publicKeyFingerprint = requiredString(identity['public_key_fingerprint'] ?? identity['publicKeyFingerprint'], 'identity.public_key_fingerprint');
+    const dir = path.join(workspaceRoot, '.viewport', 'bootstrap');
+    await fs.mkdir(dir, { recursive: true, mode: 0o700 });
+    const filePath = path.join(dir, `identity-${crypto.randomUUID()}.json`);
+    await fs.writeFile(filePath, `${JSON.stringify({ publicKey, privateKey, publicKeyFingerprint })}\n`, { mode: 0o600 });
+    return { path: filePath, publicKeyFingerprint, ephemeral: true };
+}
+function workerTransportValue(value) {
+    return value === 'polling' || value === 'relay' || value === 'inbound' ? value : undefined;
+}
+function requiredString(value, label) {
+    const result = stringValue(value);
+    if (!result) {
+        throw new Error(`Sandbox bootstrap file is missing ${label}.`);
+    }
+    return result;
+}
 function validateInboundWorkerGate(profile) {
     const enabled = profile.inbound?.enabled === true || process.env['VPD_WORKER_INBOUND_EXPERIMENTAL'] === '1';
     if (!enabled) {
@@ -179,7 +336,7 @@ function validateInboundWorkerGate(profile) {
     }
     throw new Error('Inbound worker transport listener is not implemented yet; do not enable inbound without the signed listener proof.');
 }
-async function claimLease(profile, body) {
+async function claimLeaseHttp(profile, body) {
     const leaseSeconds = positiveInteger(body['leaseSeconds']) ?? DEFAULT_HOSTED_LEASE_SECONDS;
     const response = isHostedManagedExecutorProfile(profile)
         ? await hostedManagedExecutorFetch(profile, 'POST', 'claim', {
@@ -214,11 +371,13 @@ async function claimLease(profile, body) {
         inputSnapshot: recordValue(data['input_snapshot'] ?? rawLease['input_snapshot']),
         resourceManifest: recordValue(data['resource_manifest'] ?? rawLease['resource_manifest']),
         workflowAuthorityContract: recordValue(data['workflow_authority_contract'] ?? rawLease['workflow_authority_contract']),
+        executionProfileSnapshot: recordValue(data['execution_profile_snapshot'] ?? rawLease['execution_profile_snapshot']),
+        workflowSnapshot: recordValue(data['workflow_snapshot'] ?? rawLease['workflow_snapshot']),
         runtimeTargetId: stringValue(data['runtime_target_id'] ?? rawLease['runtime_target_id']),
         dataCapturePolicy: dataCapturePolicyValue(data['data_capture_policy'] ?? rawLease['data_capture_policy']),
     };
 }
-async function heartbeat(profile, options) {
+async function heartbeatHttp(profile, options) {
     const capabilityPayload = managedExecutorCapabilities(profile.capabilities);
     if (isHostedManagedExecutorProfile(profile)) {
         await hostedManagedExecutorFetch(profile, 'POST', 'heartbeat', {
@@ -253,7 +412,7 @@ async function heartbeat(profile, options) {
         capabilities: profile.capabilities,
     });
 }
-async function syncLease(profile, lease, execution) {
+async function syncLeaseHttp(profile, lease, execution) {
     const status = execution.status;
     if (isHostedManagedExecutorProfile(profile)) {
         if (!lease.runId) {
@@ -318,7 +477,7 @@ async function syncLease(profile, lease, execution) {
         runtime_event_id: `phase8-${lease.id}-${status}`,
     });
 }
-async function executeHostedWorkflowClaim(profile, lease) {
+async function executeHostedWorkflowClaim(profile, transport, lease) {
     if (!lease.leaseToken) {
         return {
             status: 'failed',
@@ -336,8 +495,11 @@ async function executeHostedWorkflowClaim(profile, lease) {
         const existing = await existingHostedRuntimeRun(lease);
         if (existing) {
             if (existing.status === 'blocked') {
-                const body = await fetchHostedAssignment(profile, lease);
-                const applied = await daemon.workflowRunner.applyRuntimeCommandBody(existing.id, body);
+                const body = await transport.pollRuntimeCommands(lease);
+                const runtimeSecretEnv = await materializeHostedRunCredentials(profile, lease);
+                const applied = await daemon.workflowRunner.applyRuntimeCommandBody(existing.id, body, {
+                    runtimeSecretEnv,
+                });
                 if (applied > 0) {
                     const completed = await waitForWorkflowRun(daemon, existing.id);
                     return {
@@ -430,7 +592,10 @@ function credentialHandlesFromLease(lease) {
     const workflow = yamlSnapshotDocument(lease);
     const handles = new Set();
     for (const handle of [
-        ...actionCredentialRefs(isRecord(workflow) ? workflow['nodes'] : undefined),
+        ...workflowNodeCredentialRefs(isRecord(workflow) ? workflow['nodes'] : undefined),
+        ...topLevelCredentialRefs(isRecord(workflow) ? workflow['credentials'] : undefined),
+        ...profileCredentialRefs(lease.executionProfileSnapshot),
+        ...profileCredentialRefs(lease.workflowSnapshot),
         ...providerActionCredentialRefs(lease.workflowAuthorityContract),
     ]) {
         handles.add(handle);
@@ -443,29 +608,72 @@ function repositoryForCredentialHandle(lease, handle) {
     if (!isRecord(nodes))
         return {};
     for (const node of Object.values(nodes)) {
-        if (!isRecord(node) || stringValue(node['type']) !== 'action')
+        if (!isRecord(node))
             continue;
         const withValue = isRecord(node['with']) ? node['with'] : {};
-        const credentialRef = stringValue(withValue['credential_ref']) ?? stringValue(withValue['credentialRef']);
+        const credentialRef = stringValue(withValue['credential_ref']) ??
+            stringValue(withValue['credentialRef']) ??
+            stringValue(node['credential_ref']) ??
+            stringValue(node['credentialRef']);
         if (credentialRef !== handle)
             continue;
-        const repository = renderLeaseTemplate(stringValue(withValue['repository']) ?? stringValue(withValue['repo']), lease);
+        const repository = renderLeaseTemplate(repositoryTemplateForNode(node, withValue), lease);
         if (repository)
             return { repository };
     }
     return {};
 }
-function actionCredentialRefs(nodes) {
+function workflowNodeCredentialRefs(nodes) {
     if (!isRecord(nodes))
         return [];
     return Object.values(nodes).flatMap((node) => {
-        if (!isRecord(node) || stringValue(node['type']) !== 'action')
+        if (!isRecord(node))
+            return [];
+        const type = stringValue(node['type']);
+        if (type !== 'action' && type !== 'checkout' && type !== 'git_publish')
             return [];
         const withValue = isRecord(node['with']) ? node['with'] : {};
-        const credentialRef = stringValue(withValue['credential_ref']) ?? stringValue(withValue['credentialRef']);
+        const credentialRef = stringValue(withValue['credential_ref']) ??
+            stringValue(withValue['credentialRef']) ??
+            stringValue(node['credential_ref']) ??
+            stringValue(node['credentialRef']);
         return credentialRef ? [credentialRef] : [];
     });
 }
+function topLevelCredentialRefs(credentials) {
+    if (!isRecord(credentials))
+        return [];
+    const refs = [];
+    for (const value of Object.values(credentials)) {
+        refs.push(...credentialEntriesFrom(value));
+    }
+    return refs;
+}
+function profileCredentialRefs(snapshot) {
+    const credentials = pathValue(asRecord(snapshot), ['credentials']);
+    if (!isRecord(credentials))
+        return [];
+    const refs = [];
+    for (const value of Object.values(credentials)) {
+        refs.push(...credentialEntriesFrom(value));
+    }
+    return refs;
+}
+function credentialEntriesFrom(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        if (typeof entry === 'string' && entry.trim() !== '')
+            return [entry.trim()];
+        if (!isRecord(entry))
+            return [];
+        const handle = stringValue(entry['handle']) ??
+            stringValue(entry['ref']) ??
+            stringValue(entry['credential_ref']) ??
+            stringValue(entry['credentialRef']);
+        return handle ? [handle] : [];
+    });
+}
 function providerActionCredentialRefs(contract) {
     const entries = pathValue(asRecord(contract), ['credentials', 'provider_actions']);
     if (!Array.isArray(entries))
@@ -481,6 +689,12 @@ function providerActionCredentialRefs(contract) {
         return value ? [value] : [];
     });
 }
+function repositoryTemplateForNode(node, withValue) {
+    return (stringValue(withValue['repository']) ??
+        stringValue(withValue['repo']) ??
+        stringValue(node['repository']) ??
+        stringValue(node['repo']));
+}
 function renderLeaseTemplate(value, lease) {
     if (!value)
         return null;
@@ -514,7 +728,7 @@ async function existingHostedRuntimeRun(lease) {
         return null;
     return existing;
 }
-async function resumeBlockedHostedExecution(profile, lease, execution) {
+async function resumeBlockedHostedExecution(profile, transport, lease, execution) {
     if (!execution.daemon || !execution.run || execution.status !== 'blocked') {
         return execution;
     }
@@ -522,14 +736,17 @@ async function resumeBlockedHostedExecution(profile, lease, execution) {
     const workflowRunId = execution.run.id;
     const deadline = Date.now() + 10 * 60_000;
     while (Date.now() < deadline) {
-        const body = await fetchHostedAssignment(profile, lease);
+        const body = await transport.pollRuntimeCommands(lease);
         if (!hasRuntimeCommands(body)) {
             if (shouldRetryHostedCommandPoll(body)) {
                 continue;
             }
             return execution;
         }
-        const applied = await daemon.workflowRunner.applyRuntimeCommandBody(workflowRunId, body);
+        const runtimeSecretEnv = await materializeHostedRunCredentials(profile, lease);
+        const applied = await daemon.workflowRunner.applyRuntimeCommandBody(workflowRunId, body, {
+            runtimeSecretEnv,
+        });
         if (applied > 0) {
             const completed = await waitForWorkflowRun(daemon, workflowRunId);
             if (completed.status === 'blocked') {
@@ -538,7 +755,7 @@ async function resumeBlockedHostedExecution(profile, lease, execution) {
                     run: completed,
                     daemon,
                 };
-                await syncLease(profile, lease, blockedExecution);
+                await transport.sync(lease, blockedExecution);
                 execution = blockedExecution;
                 continue;
             }
@@ -555,7 +772,7 @@ async function resumeBlockedHostedExecution(profile, lease, execution) {
     }
     return execution;
 }
-async function fetchHostedAssignment(profile, lease) {
+async function fetchHostedAssignmentHttp(profile, lease) {
     if (!lease.runId) {
         throw new Error('Hosted managed executor assignment polling requires a workflow run id.');
     }
@@ -626,7 +843,7 @@ function workflowRunFailure(run) {
         retrySafe: false,
     };
 }
-async function cleanupLease(profile, lease) {
+async function cleanupLeaseHttp(profile, lease) {
     if (isHostedManagedExecutorProfile(profile)) {
         return;
     }