@vibesdotdev/platform 0.0.0-stage → 1.0.0-rc.1

package/dist/fleets/daemon/host-agent/build-job-executor.js

@@ -0,0 +1,803 @@
+import { getLogger } from '@vibesdotdev/logging/contexts';
+import { resolveFileSystemAdapter, createTemporaryDirectoryChecked, chmodChecked, readFileRangeChecked } from '@vibesdotdev/filesystem';
+import { getRuntimePath } from '@vibesdotdev/paths';
+import { JsonValueSchema, JsonObjectSchema } from '@vibesdotdev/kernel/schemas/json';
+import { BuildJobPayloadSchema, BuildPayloadEnvelopeSchema, BrokeredCloneCredentialSchema, ArtifactPublishReceiptSchema } from "../../../schemas/build-execution.js";
+import { FleetBuildCredentialsSchema, FleetInstallCommandSchema } from "../../build-job-install.js";
+import { BuildStepCredentialLeaseSchema } from "../../build-job-credentials-contract.js";
+import { materializeBuildRuntime, materializeBuildSshCredential, parseBuildJobCredentials, shellQuote } from "./build-job-credentials.js";
+import { CapabilityError, settle, valueFreeFailure, composeChildEnv, composeHostEnv, HOST_CREDENTIAL_MANIFEST_KEY, serializeHostCredentialsManifest, SHIM_CHANNEL_KEYS } from '@vibesdotdev/kernel';
+import { VIBES_CI_REGISTRY_AUTHORITY_KEY, VIBES_REGISTRY_READ_TOKEN_KEY } from '@vibesdotdev/registry/publish-authentication';
+import { prepareRegistryStandaloneWorkspace } from '@vibesdotdev/registry/standalone-install';
+import { collectProcessOutput, getRuntimeExecution, whichCommand } from '@vibesdotdev/kernel/execution';
+import { gitChildInheritEnv } from '@vibesdotdev/git-operations/core';
+export const UNCONFIRMED_PROCESS_TERMINATION_REASON = 'build-command-termination-unconfirmed';
+const unconfirmedTerminations = new WeakMap();
+export function getUnconfirmedProcessTermination(error) {
+    if (!(error instanceof Error))
+        return null;
+    const direct = unconfirmedTerminations.get(error);
+    if (direct)
+        return direct;
+    if (error.cause !== undefined) {
+        const fromCause = getUnconfirmedProcessTermination(error.cause);
+        if (fromCause)
+            return fromCause;
+    }
+    if (error instanceof AggregateError) {
+        for (const item of error.errors) {
+            const fromItem = getUnconfirmedProcessTermination(item);
+            if (fromItem)
+                return fromItem;
+        }
+    }
+    return null;
+}
+export function hasUnconfirmedProcessTermination(error) {
+    if (getUnconfirmedProcessTermination(error) !== null)
+        return true;
+    if (!(error instanceof Error))
+        return false;
+    if (error instanceof CapabilityError && error.reason === UNCONFIRMED_PROCESS_TERMINATION_REASON) {
+        return true;
+    }
+    if (error.cause !== undefined && hasUnconfirmedProcessTermination(error.cause)) {
+        return true;
+    }
+    if (error instanceof AggregateError &&
+        error.errors.some((item) => hasUnconfirmedProcessTermination(item))) {
+        return true;
+    }
+    return false;
+}
+const CONTENT_TYPES = new Map(Object.entries({
+    '.txt': 'text/plain; charset=utf-8',
+    '.sh': 'text/x-shellscript; charset=utf-8',
+    '.ps1': 'text/plain; charset=utf-8',
+    '.exe': 'application/vnd.microsoft.portable-executable',
+    '.dll': 'application/vnd.microsoft.portable-executable',
+    '.dylib': 'application/octet-stream',
+    '.so': 'application/octet-stream'
+}));
+function inferContentType(name) {
+    const dot = name.lastIndexOf('.');
+    const ext = dot >= 0 ? name.slice(dot).toLowerCase() : '';
+    return CONTENT_TYPES.get(ext) ?? 'application/octet-stream';
+}
+/**
+ * Streams each resolved artifact to the platform R2-binding proxy:
+ *   `PUT {platformOrigin}/api/hosts/actions/{actionId}/artifacts/{name}`
+ * with `Authorization: Bearer <hostToken>`. NO S3/R2 credentials on this host —
+ * the platform holds the binding and enforces the bucket/prefix allowlist. A
+ * failed upload of a REQUIRED artifact throws (fails the build); a non-required
+ * artifact's failure is logged and skipped.
+ */
+async function publishArtifacts(runtime, actionId, artifacts, publish, append, adapter) {
+    const fetchImpl = publish.fetchImpl ?? fetch;
+    const filesystem = await resolveFileSystemAdapter(runtime);
+    const openFile = publish.openFile ?? ((path) => ({
+        stream: () => {
+            let offset = 0;
+            return new ReadableStream({
+                async pull(controller) {
+                    const bytes = await readFileRangeChecked(filesystem, path, { offset, length: 1024 * 1024 });
+                    if (bytes.length === 0) {
+                        controller.close();
+                        return;
+                    }
+                    offset += bytes.length;
+                    controller.enqueue(bytes);
+                }
+            });
+        }
+    }));
+    const origin = publish.platformOrigin.replace(/\/+$/, '');
+    const published = [];
+    for (const artifact of artifacts) {
+        const url = `${origin}/api/hosts/actions/${actionId}/artifacts/${encodeURIComponent(artifact.name)}`;
+        append(`\n==> publish ${artifact.name} -> ${adapter}\n`);
+        // `duplex: 'half'` is required by Bun/undici to send a streaming request body.
+        // The REQUEST Content-Type is always application/octet-stream: SvelteKit's
+        // CSRF check blocks cross-origin requests carrying a form-submittable
+        // content-type (text/plain, x-www-form-urlencoded, multipart) — a
+        // server-to-server PUT of a `.ps1` (text/plain) would 403 "Cross-site PUT
+        // form submissions are forbidden". octet-stream is never form-submittable,
+        // so every artifact passes. The endpoint applies the REAL content-type to
+        // the R2 object from `X-Vibes-Artifact-Content-Type`.
+        const init = {
+            method: 'PUT',
+            headers: {
+                Authorization: `Bearer ${publish.hostToken}`,
+                'Content-Type': 'application/octet-stream',
+                'X-Vibes-Artifact-Content-Type': inferContentType(artifact.name)
+            },
+            body: openFile(artifact.path).stream(),
+            duplex: 'half'
+        };
+        const uploaded = await settle(() => fetchImpl(url, init));
+        if (!uploaded.ok) {
+            const cause = uploaded.cause;
+            const message = cause instanceof Error ? cause.message : String(cause);
+            if (artifact.required)
+                throw new CapabilityError(`Artifact publish failed for ${artifact.name}: ${message}`, 'UNAVAILABLE', { reason: 'build-artifact-publish-failed', cause });
+            append(`  (non-required artifact ${artifact.name} publish errored: ${message})\n`);
+            continue;
+        }
+        const response = uploaded.value;
+        if (!response.ok) {
+            const text = await response.text();
+            if (artifact.required) {
+                throw new Error(`Artifact publish failed for ${artifact.name}: ${response.status} ${text}`);
+            }
+            append(`  (non-required artifact ${artifact.name} publish -> ${response.status})\n`);
+            continue;
+        }
+        const body = ArtifactPublishReceiptSchema.parse(await response.json());
+        const key = body.key ?? artifact.name;
+        published.push({ name: artifact.name, key });
+        append(`  published -> ${key}\n`);
+    }
+    return published;
+}
+/** Each publish adapter a fleet host honours, by the adapter id a payload declares. */
+const ARTIFACT_PUBLISHERS = new Map([['cloudflare-r2', publishArtifacts]]);
+/**
+ * The publish a payload declares, resolved before any step runs: its adapter
+ * by id and the daemon's publish context. `undefined` when the payload
+ * declares no publish. An adapter this host has no publisher for refuses
+ * `INVALID_INPUT`; a declared publish with no context (the daemon knows no
+ * platform origin) refuses `UNAVAILABLE`. A build never succeeds with a
+ * declared publish it did not perform.
+ */
+function resolveArtifactPublish(actionId, payload, context) {
+    const adapter = payload.publish?.adapter;
+    if (adapter === undefined)
+        return undefined;
+    const publisher = ARTIFACT_PUBLISHERS.get(adapter);
+    if (!publisher) {
+        throw new CapabilityError(`Build-job publish adapter '${adapter}' has no publisher on this host.`, 'INVALID_INPUT', {
+            reason: 'build-publish-adapter-unknown',
+            retryable: false,
+            details: { actionId, adapter, adapters: [...ARTIFACT_PUBLISHERS.keys()] }
+        });
+    }
+    if (!context) {
+        throw new CapabilityError(`Build-job declares a '${adapter}' publish but this host has no publish context.`, 'UNAVAILABLE', {
+            reason: 'build-publish-context-unavailable',
+            details: { actionId, adapter },
+            recoveryHint: 'Start the fleet daemon with its platform origin so it can publish through the platform proxy.'
+        });
+    }
+    return { adapter, publisher, context };
+}
+function asBuildJobPayload(action) {
+    const envelope = BuildPayloadEnvelopeSchema.safeParse(action.payload);
+    if (envelope.success && envelope.data.descriptor)
+        return BuildJobPayloadSchema.parse(envelope.data.descriptor);
+    return BuildJobPayloadSchema.parse(action.payload ?? {});
+}
+/**
+ * The build host's OS comes from its declared scope (`qualifiers.os`, which the
+ * host environment declares from facts it captured once), never `process.platform` (V09).
+ */
+function hostDeclaresWindows(runtime) {
+    return runtime.declaredScope.qualifiers.os === 'win32';
+}
+/**
+ * The host variables a build command reads by name: the build host's toolchain
+ * locations. Every build command runs with the kernel's composition
+ * (`composeChildEnv`): the host set, these names, and what the job declares
+ * (its leased credentials), with `envMode: 'replace'`. No build step sees the
+ * rest of the host's environment, and no host credential reaches one.
+ */
+export const BUILD_STEP_INHERIT_ENV = [
+    'JAVA_HOME',
+    'ANDROID_HOME',
+    'ANDROID_SDK_ROOT',
+    'GOPATH',
+    'GOROOT',
+    'CARGO_HOME',
+    'RUSTUP_HOME',
+    'BUN_INSTALL',
+    'PNPM_HOME',
+    'NVM_DIR',
+    'DOCKER_HOST'
+];
+/** The names a build's own git commands read: the toolchain's plus git's declared set. */
+function gitCommandInheritEnv(runtime) {
+    return [...BUILD_STEP_INHERIT_ENV, ...gitChildInheritEnv(runtime.getEnvSnapshot())];
+}
+async function shellCommand(runtime, command, shell) {
+    const requestedShell = shell?.toLowerCase();
+    if (requestedShell?.includes('powershell') || hostDeclaresWindows(runtime)) {
+        const hostEnv = composeHostEnv(runtime);
+        const exe = (await whichCommand(runtime, 'pwsh', { env: hostEnv })) ? 'pwsh' : 'powershell';
+        return [exe, '-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', command];
+    }
+    return ['/bin/bash', '-c', command];
+}
+async function runCommand(runtime, command, cwd, append, options) {
+    append(`$ ${options?.display ?? command.join(' ')}\n`);
+    const [cmd, ...args] = command;
+    if (!cmd) {
+        throw new CapabilityError('A build command is empty.', 'INVALID_INPUT', { reason: 'build-command-empty' });
+    }
+    if (options?.signal?.aborted) {
+        throw new CapabilityError('Build command terminated because the host action lost its lease or was canceled.', 'UNAVAILABLE', {
+            reason: 'build-action-canceled',
+            retryable: false
+        });
+    }
+    const execution = await getRuntimeExecution(runtime);
+    const timeout = options?.expiresAt === undefined ? undefined : options.expiresAt - Date.now();
+    if (timeout !== undefined && timeout <= 0)
+        throw new Error('Step credential expired before execution');
+    const handle = await execution.spawn({
+        command: cmd,
+        args,
+        cwd,
+        // Ordinary declarations cannot carry the host credential manifest. Only
+        // the validated broker lease is added at this explicit replacement boundary.
+        env: { ...composeChildEnv(runtime, { env: options?.env, inheritEnv: options?.inheritEnv ?? BUILD_STEP_INHERIT_ENV }), ...options?.credentialEnv },
+        envMode: 'replace',
+        unsetEnv: [SHIM_CHANNEL_KEYS.root, SHIM_CHANNEL_KEYS.entry, SHIM_CHANNEL_KEYS.scope],
+        timeout,
+        killTree: true,
+        stdin: 'ignore',
+        stdout: 'pipe',
+        stderr: 'pipe'
+    });
+    let killOutcomePromise;
+    let notifyAborted;
+    const abortedGate = new Promise((resolve) => {
+        notifyAborted = resolve;
+    });
+    let processExited = false;
+    const outputPromise = collectProcessOutput(handle, (_stream, line) => append(`${line}\n`)).then((res) => {
+        processExited = true;
+        return res;
+    });
+    const waitForExitWithin = async (windowMs) => {
+        if (processExited)
+            return true;
+        let stopTimer;
+        const timerPromise = new Promise((resolve) => {
+            stopTimer = runtime.lifecycle.timeout(() => resolve(false), windowMs);
+        });
+        try {
+            return await Promise.race([
+                outputPromise.then(() => true),
+                timerPromise
+            ]);
+        }
+        finally {
+            stopTimer?.();
+        }
+    };
+    const isProcessGoneError = (cause) => cause instanceof CapabilityError && cause.reason === 'execution-process-gone';
+    const terminateHandle = async () => {
+        const sigterm = await settle(async () => {
+            await handle.kill('SIGTERM');
+        });
+        if ((sigterm.ok || isProcessGoneError(sigterm.cause)) && (await waitForExitWithin(200))) {
+            return {};
+        }
+        const sigkill = await settle(async () => {
+            await handle.kill('SIGKILL');
+        });
+        if (!sigkill.ok && !isProcessGoneError(sigkill.cause)) {
+            throw sigterm.ok
+                ? sigkill.cause
+                : new AggregateError([sigterm.cause, sigkill.cause], `Failed to terminate child process (pid ${handle.pid ?? 'unknown'}) with SIGTERM or SIGKILL.`, { cause: sigterm.cause });
+        }
+        if (!(await waitForExitWithin(500))) {
+            throw new Error(`Child process (pid ${handle.pid ?? 'unknown'}) did not exit after SIGTERM and SIGKILL.`);
+        }
+        return sigterm.ok || isProcessGoneError(sigterm.cause)
+            ? {}
+            : { sigtermError: sigterm.cause };
+    };
+    const onAbort = () => {
+        killOutcomePromise ??= settle(terminateHandle);
+        notifyAborted();
+    };
+    const waitForKillFailure = async () => {
+        await abortedGate;
+        const outcome = await (killOutcomePromise ??= settle(terminateHandle));
+        if (!outcome.ok) {
+            throw outcome.cause;
+        }
+        return await new Promise(() => { });
+    };
+    void settle(() => outputPromise);
+    options?.signal?.addEventListener('abort', onAbort, { once: true });
+    if (options?.signal?.aborted)
+        onAbort();
+    let outputOutcome;
+    try {
+        outputOutcome = await settle(() => Promise.race([
+            outputPromise,
+            waitForKillFailure()
+        ]));
+    }
+    finally {
+        options?.signal?.removeEventListener('abort', onAbort);
+    }
+    if (options?.signal?.aborted) {
+        const cancelError = new CapabilityError('Build command terminated because the host action lost its lease or was canceled.', 'UNAVAILABLE', {
+            reason: 'build-action-canceled',
+            retryable: false
+        });
+        const killOutcome = killOutcomePromise ? await killOutcomePromise : undefined;
+        if (killOutcome && !killOutcome.ok) {
+            const unconfirmedError = new CapabilityError(`Build command termination signal submission failed; child process (pid ${handle.pid ?? 'unknown'}) termination is unconfirmed.`, 'UNAVAILABLE', {
+                reason: UNCONFIRMED_PROCESS_TERMINATION_REASON,
+                retryable: false,
+                details: { pid: handle.pid ?? null, processExited },
+                cause: new AggregateError([cancelError, killOutcome.cause], 'Build command termination signal submission failed.', { cause: cancelError })
+            });
+            const unconfirmedProcess = {
+                pid: handle.pid ?? null,
+                exit: outputPromise.then(({ code }) => ({ code }))
+            };
+            unconfirmedTerminations.set(unconfirmedError, unconfirmedProcess);
+            throw unconfirmedError;
+        }
+        if (killOutcome?.ok && killOutcome.value.sigtermError !== undefined) {
+            throw new AggregateError([cancelError, killOutcome.value.sigtermError], 'Build command termination signal submission failed on SIGTERM (escalated to SIGKILL).', { cause: cancelError });
+        }
+        if (!outputOutcome.ok) {
+            throw new AggregateError([cancelError, outputOutcome.cause], 'Build command termination signal submission failed.', { cause: cancelError });
+        }
+        throw cancelError;
+    }
+    if (!outputOutcome.ok) {
+        throw outputOutcome.cause;
+    }
+    const { code } = outputOutcome.value;
+    if (code !== 0) {
+        throw new CapabilityError(`Command failed with exit code ${code}: ${command.join(' ')}`, 'UNAVAILABLE', {
+            reason: 'build-command-failed',
+            retryable: false,
+            details: { exitCode: code }
+        });
+    }
+}
+async function requestCloneCredential(actionId, context, fleetInstall = false) {
+    const fetchImpl = context.fetchImpl ?? fetch;
+    const origin = context.platformOrigin.replace(/\/+$/, '');
+    const response = await fetchImpl(`${origin}/api/hosts/actions/${actionId}/source-credential`, {
+        method: 'POST',
+        headers: fleetInstall ? { Authorization: `Bearer ${context.hostToken}`, 'Content-Type': 'application/json' } : { Authorization: `Bearer ${context.hostToken}` },
+        body: fleetInstall ? JSON.stringify({ kind: 'fleet-build' }) : undefined
+    });
+    if (!response.ok) {
+        throw new Error(`Source credential broker rejected checkout: HTTP ${response.status}`);
+    }
+    return JsonValueSchema.parse(await response.json());
+}
+async function revokeCloneCredential(actionId, tokenId, context, fleetInstall = false) {
+    const fetchImpl = context.fetchImpl ?? fetch;
+    const origin = context.platformOrigin.replace(/\/+$/, '');
+    const response = await fetchImpl(`${origin}/api/hosts/actions/${actionId}/source-credential`, {
+        method: 'DELETE',
+        headers: {
+            Authorization: `Bearer ${context.hostToken}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(fleetInstall ? { kind: 'fleet-build' } : { tokenId })
+    });
+    if (!response.ok && response.status !== 404 && !(!fleetInstall && tokenId === undefined && response.status === 409)) {
+        throw new Error(`Source credential revocation failed: HTTP ${response.status}`);
+    }
+}
+async function requestStepCredential(actionId, step, context) {
+    const origin = context.platformOrigin.replace(/\/+$/, '');
+    const response = await (context.fetchImpl ?? fetch)(`${origin}/api/hosts/actions/${actionId}/step-credential`, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${context.hostToken}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ step })
+    });
+    if (!response.ok)
+        throw new Error(`Step credential broker rejected the step: HTTP ${response.status}`);
+    const parsed = BuildStepCredentialLeaseSchema.safeParse(await response.json());
+    if (!parsed.success || parsed.data.step !== step || Date.parse(parsed.data.expiresAt) <= Date.now()) {
+        throw new Error('Step credential broker returned an invalid or expired lease');
+    }
+    return parsed.data;
+}
+async function retireStepCredential(actionId, step, context) {
+    const origin = context.platformOrigin.replace(/\/+$/, '');
+    const response = await (context.fetchImpl ?? fetch)(`${origin}/api/hosts/actions/${actionId}/step-credential`, {
+        method: 'DELETE',
+        headers: { Authorization: `Bearer ${context.hostToken}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ step })
+    });
+    if (!response.ok)
+        throw new Error(`Step credential retirement failed: HTTP ${response.status}`);
+}
+async function checkoutSource(runtime, actionId, payload, workspace, append, context, ciCredentials, fleetCredentials, signal) {
+    const filesystem = await resolveFileSystemAdapter(runtime);
+    const paths = await getRuntimePath(runtime);
+    const source = payload.source;
+    // A remote action names no host path: every step runs inside a checkout this
+    // action owns. A `workspace` source (or none) would run the queued steps in
+    // the daemon's own bound workspace or at any absolute path on the host; a
+    // local build runs as a local command instead (fleet V03).
+    if (!source || source.kind === 'workspace') {
+        throw new CapabilityError('A remote build-job action must declare a git source; a host path is never a remote source.', 'INVALID_INPUT', { reason: 'build-job-host-path-source', retryable: false, details: { source: source?.kind ?? 'none' } });
+    }
+    if (source.kind !== 'git' || !source.repository) {
+        throw new CapabilityError('The host agent supports only git build-job sources.', 'INVALID_INPUT', {
+            reason: 'build-job-source-unsupported',
+            retryable: false,
+            details: { source: source.kind ?? 'unknown' }
+        });
+    }
+    const sourceDir = paths.join(workspace, 'source');
+    if (ciCredentials) {
+        const credential = await materializeBuildSshCredential(runtime, ciCredentials, source, workspace);
+        const git = { inheritEnv: gitCommandInheritEnv(runtime), signal };
+        try {
+            await filesystem.mkdir(sourceDir);
+            await runCommand(runtime, ['git', 'init', sourceDir], workspace, append, git);
+            await runCommand(runtime, ['git', 'remote', 'add', 'origin', source.repository], sourceDir, append, git);
+            // The key authorizes one upload-pack session: cloning and then fetching
+            // would consume it twice. Fetch the immutable revision once instead.
+            await runCommand(runtime, ['git', 'fetch', '--depth', '1', 'origin', source.ref], sourceDir, append, { ...git, env: credential.env });
+            await runCommand(runtime, ['git', 'checkout', '--detach', 'FETCH_HEAD'], sourceDir, append, git);
+        }
+        finally {
+            await credential.cleanup();
+        }
+        return sourceDir;
+    }
+    const brokered = source.authentication?.mode === 'brokered';
+    if (brokered && (!context || source.authentication?.provider !== 'vibes-forge')) {
+        throw new Error('Brokered Vibes Forge source requires an authenticated platform execution context');
+    }
+    const credential = fleetCredentials?.source ?? (brokered ? BrokeredCloneCredentialSchema.parse(await requestCloneCredential(actionId, context)) : undefined);
+    const askpass = credential ? paths.join(workspace, 'git-askpass.sh') : undefined;
+    if (askpass) {
+        await filesystem.writeFile(askpass, '#!/bin/sh\ncase "$1" in *Username*) printf "%s" "$VIBES_GIT_USERNAME" ;; *) printf "%s" "$VIBES_GIT_TOKEN" ;; esac\n', { mode: 0o700 });
+        await chmodChecked(filesystem, askpass, 0o700);
+    }
+    const authEnv = credential
+        ? {
+            GIT_ASKPASS: askpass,
+            GIT_TERMINAL_PROMPT: '0',
+            VIBES_GIT_USERNAME: credential.username,
+            VIBES_GIT_TOKEN: credential.token
+        }
+        : undefined;
+    const git = { inheritEnv: gitCommandInheritEnv(runtime), signal };
+    try {
+        await runCommand(runtime, ['git', 'clone', '--depth', String(source.depth ?? 1), source.repository, sourceDir], workspace, append, {
+            ...git,
+            env: authEnv,
+            display: `git clone --depth ${source.depth ?? 1} ${source.repository} ${sourceDir}`
+        });
+        if (source.ref) {
+            await runCommand(runtime, ['git', 'fetch', '--depth', '1', 'origin', source.ref], sourceDir, append, {
+                ...git,
+                env: authEnv
+            });
+            await runCommand(runtime, ['git', 'checkout', '--detach', 'FETCH_HEAD'], sourceDir, append, git);
+        }
+    }
+    finally {
+        if (askpass)
+            await filesystem.remove(askpass);
+        if (credential && !fleetCredentials)
+            await revokeCloneCredential(actionId, credential.tokenId, context);
+    }
+    return sourceDir;
+}
+function resolveStepCwd(paths, checkoutDir, cwd) {
+    if (!cwd)
+        return checkoutDir;
+    return resolveInside(paths, checkoutDir, cwd, 'step cwd');
+}
+function resolveInside(paths, root, value, label) {
+    const rootPath = paths.resolve(root);
+    const resolved = paths.resolve(rootPath, value);
+    const rel = paths.relative(rootPath, resolved);
+    if (rel.startsWith('..') || paths.isAbsolute(rel)) {
+        throw new Error(`${label} escapes build workspace: ${value}`);
+    }
+    return resolved;
+}
+function stepLeaseCredentialEnv(actionId, credentials, authority, deployLease) {
+    if (!authority && !deployLease)
+        return undefined;
+    const env = {};
+    const keys = [];
+    const expiries = [];
+    if (authority) {
+        env[VIBES_CI_REGISTRY_AUTHORITY_KEY] = authority.token;
+        env[VIBES_REGISTRY_READ_TOKEN_KEY] = credentials.registry.token;
+        keys.push(VIBES_CI_REGISTRY_AUTHORITY_KEY, VIBES_REGISTRY_READ_TOKEN_KEY);
+        expiries.push(Date.parse(authority.expiresAt), Date.parse(credentials.registry.expiresAt));
+    }
+    if (deployLease) {
+        for (const binding of deployLease.bindings) {
+            env[binding.name] = binding.value;
+            keys.push(binding.name);
+        }
+        expiries.push(Date.parse(deployLease.expiresAt));
+    }
+    env[HOST_CREDENTIAL_MANIFEST_KEY] = serializeHostCredentialsManifest({
+        keys,
+        publisher: {
+            leaseId: authority?.leaseId ?? deployLease?.leaseId ?? actionId,
+            expiresAt: Math.min(...expiries)
+        }
+    });
+    return env;
+}
+export async function executeBuildJobAction(runtime, action, publish, options) {
+    const signal = options?.signal;
+    const filesystem = await resolveFileSystemAdapter(runtime);
+    const paths = await getRuntimePath(runtime);
+    const payload = asBuildJobPayload(action);
+    const steps = payload.steps;
+    if (!steps?.length) {
+        throw new Error('Build-job action payload is missing steps');
+    }
+    const declaredPublish = resolveArtifactPublish(action.id, payload, publish);
+    let logs = '';
+    const secrets = [];
+    const append = (text) => {
+        logs += text;
+        for (const secret of secrets)
+            logs = logs.replaceAll(secret, '[redacted]');
+        if (logs.length > 262_144)
+            logs = logs.slice(logs.length - 262_144);
+    };
+    // The action's scratch workspace lives under the handed runtime's temp root.
+    const scratch = await createTemporaryDirectoryChecked(filesystem);
+    const workspace = scratch.path;
+    let preserveWorkspace = false;
+    let terminationUnconfirmed = false;
+    let unconfirmedProcessHandle = null;
+    let issuedCredentials = false;
+    let credentials;
+    let fleetCredentials;
+    let fleetInstall = false;
+    let runtimeBin;
+    const completed = await settle(async () => {
+        if (BuildPayloadEnvelopeSchema.safeParse(action.payload).data?.ci !== undefined) {
+            if (!publish || payload.source?.authentication?.mode !== 'brokered') {
+                throw new Error('CI build requires an authenticated source broker');
+            }
+            // POST can mint successfully even when its response is lost. Always retire
+            // through the authenticated action, including a failed response decode.
+            issuedCredentials = true;
+            const wire = await requestCloneCredential(action.id, publish);
+            credentials = parseBuildJobCredentials(wire, action);
+            secrets.push(credentials.registry.token, ...credentials.ssh.leases.map((lease) => lease.privateKeyOpenSsh));
+            if (credentials.publish) {
+                secrets.push(...credentials.publish.map((lease) => lease.token));
+                if (credentials.publish.some((lease) => steps.filter((step) => step.name === lease.step).length !== 1)) {
+                    throw new Error('Build publish authority does not match unique action steps');
+                }
+            }
+            if (credentials.secretSteps?.some((name) => steps.filter((step) => step.name === name).length !== 1 || credentials.deploy?.some((lease) => lease.step === name))) {
+                throw new Error('Build step credential does not match unique action steps');
+            }
+            if (credentials.deploy) {
+                secrets.push(...credentials.deploy.flatMap((lease) => lease.bindings.map((binding) => binding.value)));
+                if (credentials.deploy.some((lease) => steps.filter((step) => step.name === lease.step).length !== 1)) {
+                    throw new Error('Build deploy credential does not match unique action steps');
+                }
+            }
+            runtimeBin = await materializeBuildRuntime(runtime, workspace);
+        }
+        else if (payload.source?.authentication?.mode === 'brokered' && steps.some((step) => FleetInstallCommandSchema.safeParse(step.run).success && !step.shell && (!step.cwd || step.cwd === '.'))) {
+            if (!publish || !/^[a-f0-9]{40}$/.test(payload.source.ref ?? '')) {
+                throw new Error('Fleet install requires an authenticated immutable source');
+            }
+            fleetInstall = true;
+            issuedCredentials = true;
+            const parsed = FleetBuildCredentialsSchema.safeParse(await requestCloneCredential(action.id, publish, true));
+            if (!parsed.success)
+                throw new Error('Fleet build broker returned invalid credentials');
+            fleetCredentials = parsed.data;
+            secrets.push(fleetCredentials.registry.token, fleetCredentials.source.token);
+            if (fleetCredentials.registry.owner.type !== action.ownerType || fleetCredentials.registry.owner.id !== action.ownerId ||
+                Date.parse(fleetCredentials.registry.expiresAt) <= Date.now() || Date.parse(fleetCredentials.source.expiresAt) <= Date.now() ||
+                fleetCredentials.installSteps.some(({ index, command }) => {
+                    const step = steps[index];
+                    return !step || step.run !== command || !!step.shell || (!!step.cwd && step.cwd !== '.');
+                }))
+                throw new Error('Fleet install lease does not match the action owner or steps');
+            runtimeBin = await materializeBuildRuntime(runtime, workspace);
+        }
+        const checkoutDir = await checkoutSource(runtime, action.id, payload, workspace, append, publish, credentials, fleetCredentials, signal);
+        for (const [index, step] of steps.entries()) {
+            if (signal?.aborted) {
+                throw new CapabilityError('Build command terminated because the host action lost its lease or was canceled.', 'UNAVAILABLE', {
+                    reason: 'build-action-canceled',
+                    retryable: false
+                });
+            }
+            append(`\n==> ${step.name}\n`);
+            const install = fleetCredentials?.installSteps.find((grant) => grant.index === index && grant.command === step.run);
+            const authority = credentials?.publish?.find((lease) => lease.step === step.name);
+            if (authority && Date.parse(authority.expiresAt) <= Date.now()) {
+                throw new Error('Build publish authority has expired before its step');
+            }
+            if (authority && Date.parse(credentials.registry.expiresAt) <= Date.now()) {
+                throw new Error('Build Registry read lease has expired before its publish step');
+            }
+            const deployLease = credentials?.deploy?.find((lease) => lease.step === step.name);
+            if (deployLease && Date.parse(deployLease.expiresAt) <= Date.now()) {
+                throw new Error('Build deploy credential has expired before its step');
+            }
+            const stepCwd = resolveStepCwd(paths, checkoutDir, step.cwd);
+            const isBunInstallStep = Boolean(install) || /^\s*bun\s+install\b/.test(step.run);
+            const standaloneWorkspace = isBunInstallStep
+                ? await prepareRegistryStandaloneWorkspace(runtime, { cwd: stepCwd })
+                : undefined;
+            const effectiveInstallTokens = install?.command.split(' ').slice(1);
+            let generatedLock = false;
+            try {
+                let requestedStepCredential = false;
+                const stepOutcome = await settle(async () => {
+                    let stepCredential = deployLease;
+                    if (credentials?.secretSteps?.includes(step.name)) {
+                        if (!publish)
+                            throw new Error('Step credentials require an authenticated broker');
+                        requestedStepCredential = true;
+                        stepCredential = await requestStepCredential(action.id, step.name, publish);
+                        secrets.push(...stepCredential.bindings.map((binding) => binding.value));
+                    }
+                    await runCommand(runtime, effectiveInstallTokens
+                        ? [paths.join(runtimeBin, 'bun'), ...effectiveInstallTokens]
+                        : await shellCommand(runtime, runtimeBin
+                            ? `export PATH=${shellQuote(runtimeBin)}:"$PATH"; ${step.run}`
+                            : step.run, step.shell), stepCwd, append, fleetCredentials
+                        ? {
+                            display: step.run,
+                            signal,
+                            env: {
+                                VIBES_REGISTRY_TOKEN: install ? fleetCredentials.registry.token : undefined
+                            }
+                        }
+                        : credentials
+                            ? {
+                                display: step.run,
+                                signal,
+                                env: {
+                                    VIBES_REGISTRY_TOKEN: credentials.installSteps.includes(step.name)
+                                        ? credentials.registry.token
+                                        : undefined
+                                },
+                                credentialEnv: stepLeaseCredentialEnv(action.id, credentials, authority, stepCredential),
+                                expiresAt: authority || stepCredential
+                                    ? Math.min(authority ? Date.parse(authority.expiresAt) : Infinity, authority ? Date.parse(credentials.registry.expiresAt) : Infinity, stepCredential ? Date.parse(stepCredential.expiresAt) : Infinity)
+                                    : undefined
+                            }
+                            : signal
+                                ? { signal }
+                                : undefined);
+                });
+                if (!stepOutcome.ok && hasUnconfirmedProcessTermination(stepOutcome.cause)) {
+                    terminationUnconfirmed = true;
+                    unconfirmedProcessHandle ??= getUnconfirmedProcessTermination(stepOutcome.cause);
+                }
+                const retirement = await settle(async () => {
+                    if (requestedStepCredential && publish)
+                        await retireStepCredential(action.id, step.name, publish);
+                });
+                if (!stepOutcome.ok && !retirement.ok) {
+                    const combined = new AggregateError([
+                        valueFreeFailure(stepOutcome.cause),
+                        valueFreeFailure(retirement.cause)
+                    ], 'Step execution and credential retirement failed');
+                    if (terminationUnconfirmed && unconfirmedProcessHandle) {
+                        unconfirmedTerminations.set(combined, unconfirmedProcessHandle);
+                    }
+                    throw combined;
+                }
+                if (!stepOutcome.ok)
+                    throw stepOutcome.cause;
+                if (!retirement.ok)
+                    throw retirement.cause;
+                generatedLock = FleetInstallCommandSchema.safeParse(step.run).success && step.run.includes('--lockfile-only');
+            }
+            finally {
+                if (terminationUnconfirmed && unconfirmedProcessHandle && standaloneWorkspace) {
+                    const ws = standaloneWorkspace;
+                    unconfirmedProcessHandle = {
+                        ...unconfirmedProcessHandle,
+                        exit: unconfirmedProcessHandle.exit.finally(async () => {
+                            await settle(() => ws.restore(false));
+                        })
+                    };
+                }
+                else if (!terminationUnconfirmed) {
+                    await standaloneWorkspace?.restore(generatedLock);
+                }
+            }
+        }
+        const artifacts = [];
+        for (const artifact of payload.artifacts ?? []) {
+            const path = resolveInside(paths, checkoutDir, artifact.path, 'artifact path');
+            const exists = await filesystem.exists(path);
+            const required = artifact.required ?? true;
+            if (required && !exists)
+                throw new Error(`Required artifact not found: ${artifact.path}`);
+            if (!exists)
+                continue;
+            artifacts.push({ name: artifact.name ?? paths.basename(artifact.path), path, required });
+        }
+        // Publish through the declared adapter's publisher while the workspace
+        // still exists. A required artifact's upload failure throws here (fails
+        // the build); the workspace is cleaned up by the `finally` regardless.
+        let published = [];
+        if (declaredPublish) {
+            published = await declaredPublish.publisher(runtime, action.id, artifacts, declaredPublish.context, append, declaredPublish.adapter);
+        }
+        // Only a completed build keeps its checkout, for the caller to collect the
+        // resolved artifacts; a failed one (a failed upload included) is removed.
+        preserveWorkspace = artifacts.length > 0;
+        const result = JsonObjectSchema.parse({
+            artifacts,
+            workspace: preserveWorkspace ? checkoutDir : null
+        });
+        if (published.length > 0)
+            result.published = published;
+        return { logs, result };
+    });
+    const revoked = await settle(async () => {
+        if (issuedCredentials && publish)
+            await revokeCloneCredential(action.id, undefined, publish, fleetInstall);
+    });
+    if (!completed.ok && hasUnconfirmedProcessTermination(completed.cause)) {
+        terminationUnconfirmed = true;
+        unconfirmedProcessHandle ??= getUnconfirmedProcessTermination(completed.cause);
+    }
+    if (terminationUnconfirmed && unconfirmedProcessHandle) {
+        const cleanupPromise = unconfirmedProcessHandle.exit.then(async (outcome) => {
+            if (!preserveWorkspace) {
+                await settle(() => scratch.cleanup());
+            }
+            return outcome;
+        });
+        void settle(() => cleanupPromise);
+        unconfirmedProcessHandle = {
+            ...unconfirmedProcessHandle,
+            cleanup: cleanupPromise
+        };
+    }
+    const removed = await settle(async () => {
+        if (!preserveWorkspace && !terminationUnconfirmed)
+            await scratch.cleanup();
+    });
+    if (!completed.ok) {
+        const error = completed.cause;
+        if (error instanceof Error) {
+            for (const secret of secrets)
+                error.message = error.message.replaceAll(secret, '[redacted]');
+            Object.defineProperty(error, 'buildLogs', { value: logs, configurable: true });
+            if (terminationUnconfirmed && unconfirmedProcessHandle) {
+                unconfirmedTerminations.set(error, unconfirmedProcessHandle);
+            }
+        }
+        if (!revoked.ok || !removed.ok) {
+            getLogger('platform:build-job', runtime).error('Build cleanup failed after the primary failure.', {
+                revocationFailed: !revoked.ok, workspaceRemovalFailed: !removed.ok,
+                primary: completed.cause, revocation: revoked.ok ? undefined : revoked.cause,
+                workspaceRemoval: removed.ok ? undefined : removed.cause
+            });
+        }
+        throw completed.cause;
+    }
+    if (!revoked.ok)
+        throw revoked.cause;
+    if (!removed.ok)
+        throw removed.cause;
+    return completed.value;
+}
+//# sourceMappingURL=build-job-executor.js.map