@testpulse.run/reporter 0.1.6 → 0.2.4

package/dist/live/LiveCaptureService.js

@@ -1,103 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { CaptureScheduler } from "./CaptureScheduler.js";
-import { startEncoderProcess, waitForEncoder } from "./EncoderProcess.js";
-import { resolveLiveCaptureSession } from "./LiveSessionResolver.js";
-import { wireFragmentedMp4Stream } from "./Mp4FragmentParser.js";
-import { SegmentQueue } from "./SegmentQueue.js";
-import { StreamUploader } from "./StreamUploader.js";
-import { createTimingLogger, logTiming } from "./telemetry.js";
-export async function startLiveCapture(page, options = {}) {
-    const session = await resolveLiveCaptureSession(options);
-    const intervalMs = options.intervalMs ?? session.intervalMs;
-    const profile = options.profile ?? session.profile ?? "focus";
-    const descriptor = await buildDescriptor(page, profile, intervalMs);
-    const streamId = randomUUID();
-    const captureStartedAt = Date.now();
-    const logTimingOnce = createTimingLogger(captureStartedAt);
-    const encoder = startEncoderProcess(descriptor, options.ffmpegPath);
-    const uploader = new StreamUploader(session, streamId, descriptor, captureStartedAt);
-    const uploadQueue = new SegmentQueue((error) => {
-        console.warn(`[TestPulse] Live streaming disabled for run ${session.runId}: ${error.message}`);
-    });
-    const scheduler = new CaptureScheduler(page, encoder, descriptor, intervalMs, logTimingOnce);
-    let stopped = false;
-    let previewUploaded = false;
-    let sequence = 0;
-    let gopId = 0;
-    logTiming("captureStart", captureStartedAt);
-    wireFragmentedMp4Stream(encoder.stdout, {
-        onInitSegment(payload) {
-            void enqueueSegment("init", payload);
-        },
-        onMediaSegment(payload) {
-            if ((sequence + 1) % Math.max(1, Math.round(descriptor.gopDurationMs / descriptor.segmentDurationMs)) === 0) {
-                gopId += 1;
-            }
-            void enqueueSegment("media", payload);
-        }
-    });
-    await uploader.start();
-    const initialFrame = await scheduler.captureInitialFrame();
-    if (initialFrame && !previewUploaded && !stopped) {
-        try {
-            await uploader.uploadPreview(initialFrame);
-            previewUploaded = true;
-            logTimingOnce("previewPosted", { bytes: initialFrame.length });
-        }
-        catch (error) {
-            console.warn(`[TestPulse] Live preview upload skipped for run ${session.runId}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    scheduler.writeInitialFrame(initialFrame);
-    scheduler.start();
-    return {
-        async stop() {
-            if (stopped) {
-                return;
-            }
-            stopped = true;
-            scheduler.stop();
-            encoder.stdin.end();
-            await waitForEncoder(encoder);
-            await uploadQueue.flush();
-            await uploader.stop();
-        }
-    };
-    function enqueueSegment(segmentKind, payload) {
-        const segmentSequence = ++sequence;
-        return uploadQueue.enqueue(async () => {
-            await uploader.uploadSegment({
-                sequence: segmentSequence,
-                gopId,
-                segmentKind,
-                payload,
-                publishedAtUtc: new Date().toISOString()
-            });
-        });
-    }
-}
-async function buildDescriptor(page, profile, intervalMs) {
-    const viewport = page.viewportSize() ?? { width: 1280, height: 720 };
-    const focusWidth = Math.min(1280, viewport.width);
-    const focusHeight = even(Math.min(720, viewport.height));
-    const gridWidth = 640;
-    const gridHeight = 360;
-    const sampledFramesPerSecond = profile === "grid"
-        ? Math.max(1, Math.round(1000 / Math.max(250, intervalMs ?? 250)))
-        : Math.max(1, Math.round(1000 / Math.max(83, intervalMs ?? 83)));
-    const framesPerSecond = Math.max(8, sampledFramesPerSecond);
-    return {
-        streamId: randomUUID(),
-        profile,
-        mimeCodec: "video/mp4; codecs=\"avc1.42E01E\"",
-        width: even(profile === "grid" ? gridWidth : focusWidth),
-        height: profile === "grid" ? gridHeight : focusHeight,
-        framesPerSecond,
-        targetBitrateKbps: profile === "grid" ? 300 : 1200,
-        segmentDurationMs: 250,
-        gopDurationMs: 500
-    };
-}
-function even(value) {
-    return value % 2 === 0 ? value : value - 1;
-}

package/dist/live/LiveSessionResolver.d.ts

@@ -1,2 +0,0 @@
-import type { LiveCaptureOptions, LiveCaptureState } from "./types.js";
-export declare function resolveLiveCaptureSession(options: LiveCaptureOptions, now?: () => number, wait?: (ms: number) => Promise<unknown>): Promise<LiveCaptureState>;

package/dist/live/LiveSessionResolver.js

@@ -1,86 +0,0 @@
-import { access, readdir, readFile } from "node:fs/promises";
-import { getLiveCaptureStateDirectory, getLiveCaptureStatePath } from "./LiveSessionState.js";
-export async function resolveLiveCaptureSession(options, now = () => Date.now(), wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) {
-    if (options.endpoint && options.projectId && options.apiKey && options.runId && options.streamPublisherToken) {
-        return {
-            endpoint: options.endpoint,
-            projectId: options.projectId,
-            apiKey: options.apiKey,
-            runId: options.runId,
-            streamPublisherToken: options.streamPublisherToken,
-            createdAt: new Date(now()).toISOString()
-        };
-    }
-    if (!await shouldWaitForState(options)) {
-        const path = options.sessionKey
-            ? getLiveCaptureStatePath(options.sessionKey, options.stateDirectory)
-            : getLiveCaptureStateDirectory(options.stateDirectory);
-        throw new Error(`TestPulse live streaming session state was not found at ${path}.`);
-    }
-    const deadline = now() + 30_000;
-    while (now() < deadline) {
-        const session = options.sessionKey
-            ? await tryReadStateFile(getLiveCaptureStatePath(options.sessionKey, options.stateDirectory), now)
-            : await tryReadLatestStateFile(options.stateDirectory, now);
-        if (session) {
-            return session;
-        }
-        await wait(250);
-    }
-    const path = options.sessionKey
-        ? getLiveCaptureStatePath(options.sessionKey, options.stateDirectory)
-        : getLiveCaptureStateDirectory(options.stateDirectory);
-    throw new Error(`TestPulse live streaming session state was not found at ${path}.`);
-}
-async function shouldWaitForState(options) {
-    if (options.sessionKey) {
-        return true;
-    }
-    try {
-        const directory = getLiveCaptureStateDirectory(options.stateDirectory);
-        await access(directory);
-        const entries = await readdir(directory);
-        return entries.some((entry) => entry.endsWith(".json"));
-    }
-    catch {
-        return false;
-    }
-}
-async function tryReadLatestStateFile(stateDirectory, now) {
-    try {
-        const directory = getLiveCaptureStateDirectory(stateDirectory);
-        const entries = (await readdir(directory))
-            .filter((entry) => entry.endsWith(".json"))
-            .sort();
-        let freshest = null;
-        let freshestCreatedAt = -Infinity;
-        for (const entry of entries) {
-            const candidate = await tryReadStateFile(`${directory}/${entry}`, now);
-            if (!candidate) {
-                continue;
-            }
-            const createdAt = Date.parse(candidate.createdAt);
-            if (createdAt > freshestCreatedAt) {
-                freshest = candidate;
-                freshestCreatedAt = createdAt;
-            }
-        }
-        return freshest;
-    }
-    catch {
-        return null;
-    }
-}
-async function tryReadStateFile(path, now) {
-    try {
-        const payload = JSON.parse(await readFile(path, "utf8"));
-        const createdAt = Date.parse(payload.createdAt);
-        if (payload.endpoint && payload.projectId && payload.apiKey && payload.runId && payload.streamPublisherToken && !Number.isNaN(createdAt) && createdAt > now() - 60_000) {
-            return payload;
-        }
-    }
-    catch {
-        // Reporter may not have created the state file yet.
-    }
-    return null;
-}

package/dist/live/LiveSessionState.d.ts

@@ -1,6 +0,0 @@
-import type { LiveCaptureState } from "./types.js";
-export declare function getLiveCaptureSessionKey(sessionKey?: string): string;
-export declare function getLiveCaptureStateDirectory(stateDirectory?: string): string;
-export declare function getLiveCaptureStatePath(sessionKey?: string, stateDirectory?: string): string;
-export declare function writeLiveCaptureState(state: LiveCaptureState, sessionKey?: string, stateDirectory?: string): Promise<void>;
-export declare function deleteLiveCaptureState(sessionKey?: string, stateDirectory?: string): Promise<void>;

package/dist/live/LiveSessionState.js

@@ -1,20 +0,0 @@
-import { mkdir, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-export function getLiveCaptureSessionKey(sessionKey) {
-    return sessionKey?.trim() || "default";
-}
-export function getLiveCaptureStateDirectory(stateDirectory) {
-    return stateDirectory?.trim() || join(tmpdir(), "testpulse-live-capture");
-}
-export function getLiveCaptureStatePath(sessionKey, stateDirectory) {
-    return join(getLiveCaptureStateDirectory(stateDirectory), `${getLiveCaptureSessionKey(sessionKey)}.json`);
-}
-export async function writeLiveCaptureState(state, sessionKey, stateDirectory) {
-    const path = getLiveCaptureStatePath(sessionKey, stateDirectory);
-    await mkdir(getLiveCaptureStateDirectory(stateDirectory), { recursive: true });
-    await writeFile(path, JSON.stringify(state), "utf8");
-}
-export async function deleteLiveCaptureState(sessionKey, stateDirectory) {
-    await rm(getLiveCaptureStatePath(sessionKey, stateDirectory), { force: true });
-}

package/dist/live/Mp4FragmentParser.d.ts

@@ -1,4 +0,0 @@
-export declare function wireFragmentedMp4Stream(stdout: NodeJS.ReadableStream, handlers: {
-    onInitSegment(payload: Buffer): void;
-    onMediaSegment(payload: Buffer): void;
-}): void;

package/dist/live/Mp4FragmentParser.js

@@ -1,32 +0,0 @@
-export function wireFragmentedMp4Stream(stdout, handlers) {
-    let buffer = Buffer.alloc(0);
-    const initBoxes = [];
-    let initEmitted = false;
-    let pendingFragment = [];
-    stdout.on("data", (chunk) => {
-        buffer = Buffer.concat([buffer, chunk]);
-        while (buffer.length >= 8) {
-            const size = buffer.readUInt32BE(0);
-            if (size <= 0 || buffer.length < size) {
-                return;
-            }
-            const box = buffer.subarray(0, size);
-            buffer = buffer.subarray(size);
-            const type = box.subarray(4, 8).toString("ascii");
-            if (!initEmitted) {
-                initBoxes.push(box);
-                if (type === "moov") {
-                    initEmitted = true;
-                    handlers.onInitSegment(Buffer.concat(initBoxes));
-                    initBoxes.length = 0;
-                }
-                continue;
-            }
-            pendingFragment.push(box);
-            if (type === "mdat") {
-                handlers.onMediaSegment(Buffer.concat(pendingFragment));
-                pendingFragment = [];
-            }
-        }
-    });
-}

package/dist/live/SegmentQueue.d.ts

@@ -1,9 +0,0 @@
-export declare class SegmentQueue {
-    private readonly onError;
-    private chain;
-    private disabled;
-    private firstError;
-    constructor(onError: (error: Error) => void);
-    enqueue(task: () => Promise<void>): Promise<void>;
-    flush(): Promise<void>;
-}

package/dist/live/SegmentQueue.js

@@ -1,32 +0,0 @@
-export class SegmentQueue {
-    onError;
-    chain = Promise.resolve();
-    disabled = false;
-    firstError = null;
-    constructor(onError) {
-        this.onError = onError;
-    }
-    enqueue(task) {
-        if (this.disabled) {
-            return this.chain;
-        }
-        this.chain = this.chain.then(task).catch((error) => {
-            const resolved = error instanceof Error ? error : new Error(String(error));
-            if (!this.firstError) {
-                this.firstError = resolved;
-                this.onError(resolved);
-            }
-            this.disabled = true;
-        });
-        return this.chain;
-    }
-    async flush() {
-        await this.chain.catch((error) => {
-            const resolved = error instanceof Error ? error : new Error(String(error));
-            if (!this.firstError) {
-                this.firstError = resolved;
-                this.onError(resolved);
-            }
-        });
-    }
-}

package/dist/live/StreamUploader.d.ts

@@ -1,21 +0,0 @@
-import type { LiveCaptureState, SegmentKind, StreamDescriptor } from "./types.js";
-export declare class StreamUploader {
-    private readonly session;
-    private readonly streamId;
-    private readonly descriptor;
-    private readonly captureStartedAt;
-    private firstInitUploaded;
-    private firstMediaUploaded;
-    constructor(session: LiveCaptureState, streamId: string, descriptor: StreamDescriptor, captureStartedAt: number);
-    start(): Promise<void>;
-    uploadPreview(frame: Buffer): Promise<void>;
-    uploadSegment(segment: {
-        sequence: number;
-        gopId: number;
-        segmentKind: SegmentKind;
-        payload: Buffer;
-        publishedAtUtc: string;
-    }): Promise<void>;
-    stop(): Promise<void>;
-    private buildHeaders;
-}

package/dist/live/StreamUploader.js

@@ -1,78 +0,0 @@
-import { postJson, postJsonOrThrow } from "../shared/http.js";
-import { logTiming } from "./telemetry.js";
-export class StreamUploader {
-    session;
-    streamId;
-    descriptor;
-    captureStartedAt;
-    firstInitUploaded = false;
-    firstMediaUploaded = false;
-    constructor(session, streamId, descriptor, captureStartedAt) {
-        this.session = session;
-        this.streamId = streamId;
-        this.descriptor = descriptor;
-        this.captureStartedAt = captureStartedAt;
-    }
-    async start() {
-        await postJsonOrThrow(`${this.session.endpoint}/ingest/v1/projects/${encodeURIComponent(this.session.projectId)}/runs/${this.session.runId}/stream/start`, {
-            token: this.session.streamPublisherToken,
-            streamId: this.streamId,
-            profile: this.descriptor.profile,
-            mimeCodec: this.descriptor.mimeCodec,
-            width: this.descriptor.width,
-            height: this.descriptor.height,
-            framesPerSecond: this.descriptor.framesPerSecond,
-            targetBitrateKbps: this.descriptor.targetBitrateKbps,
-            segmentDurationMs: this.descriptor.segmentDurationMs,
-            gopDurationMs: this.descriptor.gopDurationMs
-        }, "TestPulse live request failed with", this.buildHeaders());
-    }
-    async uploadPreview(frame) {
-        await postJsonOrThrow(`${this.session.endpoint}/ingest/v1/projects/${encodeURIComponent(this.session.projectId)}/runs/${this.session.runId}/stream/preview`, {
-            token: this.session.streamPublisherToken,
-            streamId: this.streamId,
-            capturedAtUtc: new Date().toISOString(),
-            contentType: "image/jpeg",
-            payloadBase64: frame.toString("base64"),
-            width: this.descriptor.width,
-            height: this.descriptor.height
-        }, "TestPulse live request failed with", this.buildHeaders());
-    }
-    async uploadSegment(segment) {
-        await postJsonOrThrow(`${this.session.endpoint}/ingest/v1/projects/${encodeURIComponent(this.session.projectId)}/runs/${this.session.runId}/stream/segments`, {
-            token: this.session.streamPublisherToken,
-            streamId: this.streamId,
-            sequence: segment.sequence,
-            segmentKind: segment.segmentKind,
-            gopId: segment.gopId,
-            ptsStart: segment.sequence * this.descriptor.segmentDurationMs,
-            ptsEnd: (segment.sequence + 1) * this.descriptor.segmentDurationMs,
-            durationMs: this.descriptor.segmentDurationMs,
-            publishedAtUtc: segment.publishedAtUtc,
-            discontinuity: false,
-            streamResetRequired: false,
-            mimeCodec: this.descriptor.mimeCodec,
-            payloadBase64: segment.payload.toString("base64")
-        }, "TestPulse live request failed with", this.buildHeaders());
-        if (segment.segmentKind === "init" && !this.firstInitUploaded) {
-            this.firstInitUploaded = true;
-            logTiming("firstInitSegmentUploaded", this.captureStartedAt, { sequence: segment.sequence });
-        }
-        if (segment.segmentKind === "media" && !this.firstMediaUploaded) {
-            this.firstMediaUploaded = true;
-            logTiming("firstMediaSegmentUploaded", this.captureStartedAt, { sequence: segment.sequence });
-        }
-    }
-    async stop() {
-        await postJson(`${this.session.endpoint}/ingest/v1/projects/${encodeURIComponent(this.session.projectId)}/runs/${this.session.runId}/stream/stop`, {
-            token: this.session.streamPublisherToken,
-            streamId: this.streamId,
-            reason: "capture-stopped"
-        }, this.buildHeaders());
-    }
-    buildHeaders() {
-        return {
-            "X-Project-Api-Key": this.session.apiKey
-        };
-    }
-}

package/dist/live/telemetry.d.ts

@@ -1,3 +0,0 @@
-import type { TimingKey } from "./types.js";
-export declare function logTiming(key: TimingKey, captureStartedAt?: number, extra?: Record<string, number | string>): void;
-export declare function createTimingLogger(captureStartedAt: number): (key: TimingKey, extra?: Record<string, number | string>) => void;

package/dist/live/telemetry.js

@@ -1,15 +0,0 @@
-export function logTiming(key, captureStartedAt = Date.now(), extra) {
-    const elapsedMs = Math.max(0, Date.now() - captureStartedAt);
-    const suffix = extra ? ` ${JSON.stringify(extra)}` : "";
-    console.info(`[TestPulse] ${key} ${elapsedMs}ms${suffix}`);
-}
-export function createTimingLogger(captureStartedAt) {
-    const loggedTimings = new Set();
-    return (key, extra) => {
-        if (loggedTimings.has(key)) {
-            return;
-        }
-        loggedTimings.add(key);
-        logTiming(key, captureStartedAt, extra);
-    };
-}

package/dist/live/types.d.ts

@@ -1,42 +0,0 @@
-import type { Page } from "@playwright/test";
-export type LiveCaptureState = {
-    endpoint: string;
-    projectId: string;
-    apiKey: string;
-    runId: string;
-    streamPublisherToken: string;
-    createdAt: string;
-    intervalMs?: number;
-    profile?: StreamProfile;
-};
-export type StreamProfile = "focus" | "grid";
-export type StreamDescriptor = {
-    streamId: string;
-    profile: StreamProfile;
-    mimeCodec: string;
-    width: number;
-    height: number;
-    framesPerSecond: number;
-    targetBitrateKbps: number;
-    segmentDurationMs: number;
-    gopDurationMs: number;
-};
-export type SegmentKind = "init" | "media";
-export type TimingKey = "captureStart" | "firstScreenshotTaken" | "previewPosted" | "firstFrameWrittenToEncoder" | "firstInitSegmentUploaded" | "firstMediaSegmentUploaded";
-export interface LiveCaptureOptions {
-    endpoint?: string;
-    projectId?: string;
-    apiKey?: string;
-    runId?: string;
-    streamPublisherToken?: string;
-    sessionKey?: string;
-    stateDirectory?: string;
-    intervalMs?: number;
-    profile?: StreamProfile;
-    ffmpegPath?: string;
-}
-export interface LiveCaptureHandle {
-    stop(): Promise<void>;
-}
-export interface LivePage extends Pick<Page, "screenshot" | "viewportSize"> {
-}

package/dist/live/types.js

@@ -1 +0,0 @@
-export {};

package/dist/reporter/ArtifactUploader.d.ts

@@ -1,13 +0,0 @@
-import type { TestCase, TestResult } from "@playwright/test/reporter";
-import type { EventQueue } from "./EventQueue.js";
-import type { RunClient } from "./RunClient.js";
-export declare class ArtifactUploader {
-    private readonly eventQueue;
-    private readonly ensureRunStarted;
-    private readonly runClient;
-    private readonly uploadedArtifacts;
-    constructor(eventQueue: EventQueue, ensureRunStarted: () => Promise<string>, runClient: RunClient);
-    enqueueArtifacts(test: TestCase, result: TestResult, eventSequence: number): void;
-}
-export declare function getArtifactType(attachment: TestResult["attachments"][number]): "image" | "video" | null;
-export declare function getContentType(artifactType: "image" | "video"): string;

package/dist/reporter/ArtifactUploader.js

@@ -1,48 +0,0 @@
-export class ArtifactUploader {
-    eventQueue;
-    ensureRunStarted;
-    runClient;
-    uploadedArtifacts = new Set();
-    constructor(eventQueue, ensureRunStarted, runClient) {
-        this.eventQueue = eventQueue;
-        this.ensureRunStarted = ensureRunStarted;
-        this.runClient = runClient;
-    }
-    enqueueArtifacts(test, result, eventSequence) {
-        for (const attachment of result.attachments ?? []) {
-            if (!attachment.path) {
-                continue;
-            }
-            const artifactType = getArtifactType(attachment);
-            if (!artifactType || this.uploadedArtifacts.has(attachment.path)) {
-                continue;
-            }
-            this.uploadedArtifacts.add(attachment.path);
-            this.eventQueue.enqueue(async () => {
-                const runId = await this.ensureRunStarted();
-                await this.runClient.uploadArtifact(runId, {
-                    artifactType,
-                    filePath: attachment.path,
-                    contentType: attachment.contentType ?? getContentType(artifactType),
-                    testId: test.id,
-                    eventSequence: artifactType === "image" ? eventSequence : undefined
-                });
-            });
-        }
-    }
-}
-export function getArtifactType(attachment) {
-    const contentType = attachment.contentType?.toLowerCase() ?? "";
-    const name = attachment.name?.toLowerCase() ?? "";
-    const path = attachment.path?.toLowerCase() ?? "";
-    if (contentType.startsWith("image/") || name.includes("screenshot") || /\.(png|jpe?g|webp)$/i.test(path)) {
-        return "image";
-    }
-    if (contentType.startsWith("video/") || name.includes("video") || /\.(webm|mp4)$/i.test(path)) {
-        return "video";
-    }
-    return null;
-}
-export function getContentType(artifactType) {
-    return artifactType === "image" ? "image/png" : "video/webm";
-}

package/dist/reporter/EventQueue.d.ts

@@ -1,7 +0,0 @@
-export declare class EventQueue {
-    private sequence;
-    private chain;
-    nextSequence(task: (sequence: number) => Promise<void>): number;
-    enqueue(task: () => Promise<void>): void;
-    flush(): Promise<void>;
-}

package/dist/reporter/EventQueue.js

@@ -1,15 +0,0 @@
-export class EventQueue {
-    sequence = 0;
-    chain = Promise.resolve();
-    nextSequence(task) {
-        const sequence = ++this.sequence;
-        this.chain = this.chain.then(() => task(sequence));
-        return sequence;
-    }
-    enqueue(task) {
-        this.chain = this.chain.then(task);
-    }
-    async flush() {
-        await this.chain;
-    }
-}

package/dist/reporter/GitRuntimeMetadataResolver.d.ts

@@ -1,11 +0,0 @@
-type CommandExecutor = (command: string, args: string[], cwd: string) => Promise<string>;
-export interface GitRuntimeMetadataOptions {
-    branch?: string;
-    commitSha?: string;
-}
-export interface GitRuntimeMetadata {
-    branch?: string;
-    commitSha?: string;
-}
-export declare function resolveGitRuntimeMetadata(options: GitRuntimeMetadataOptions, cwd?: string, environment?: NodeJS.ProcessEnv, executor?: CommandExecutor): Promise<GitRuntimeMetadata>;
-export {};

package/dist/reporter/GitRuntimeMetadataResolver.js

@@ -1,91 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-const execFileAsync = promisify(execFile);
-const branchEnvironmentVariables = [
-    "GITHUB_HEAD_REF",
-    "GITHUB_REF_NAME",
-    "CI_COMMIT_REF_NAME",
-    "BUILD_SOURCEBRANCHNAME",
-    "BRANCH_NAME"
-];
-const commitEnvironmentVariables = [
-    "GITHUB_SHA",
-    "CI_COMMIT_SHA",
-    "BUILD_SOURCEVERSION",
-    "COMMIT_SHA"
-];
-export async function resolveGitRuntimeMetadata(options, cwd = process.cwd(), environment = process.env, executor = executeGitCommand) {
-    const branch = options.branch?.trim() || getFirstEnvironmentValue(branchEnvironmentVariables, environment);
-    const configuredCommitSha = options.commitSha?.trim();
-    if (branch && configuredCommitSha) {
-        return {
-            branch,
-            commitSha: configuredCommitSha
-        };
-    }
-    const gitBranch = branch || await tryGetGitBranch(cwd, executor);
-    const commitSha = configuredCommitSha || await tryGetGitCommit(cwd, environment, executor);
-    if (!commitSha) {
-        return {
-            branch: gitBranch || undefined,
-            commitSha: undefined
-        };
-    }
-    const hasPendingChanges = await tryHasPendingChanges(cwd, executor);
-    const displayCommitSha = shortenCommitSha(commitSha);
-    return {
-        branch: gitBranch || undefined,
-        commitSha: hasPendingChanges ? `${displayCommitSha} + pending changes` : displayCommitSha
-    };
-}
-async function tryGetGitBranch(cwd, executor) {
-    try {
-        const branch = await executor("git", ["rev-parse", "--abbrev-ref", "HEAD"], cwd);
-        if (!branch || branch === "HEAD") {
-            return undefined;
-        }
-        return branch;
-    }
-    catch {
-        return undefined;
-    }
-}
-async function tryGetGitCommit(cwd, environment, executor) {
-    const environmentCommit = getFirstEnvironmentValue(commitEnvironmentVariables, environment);
-    if (environmentCommit) {
-        return environmentCommit;
-    }
-    try {
-        return await executor("git", ["rev-parse", "HEAD"], cwd);
-    }
-    catch {
-        return undefined;
-    }
-}
-async function tryHasPendingChanges(cwd, executor) {
-    try {
-        const status = await executor("git", ["status", "--porcelain"], cwd);
-        return status.length > 0;
-    }
-    catch {
-        return false;
-    }
-}
-function getFirstEnvironmentValue(keys, environment) {
-    for (const key of keys) {
-        const value = environment[key]?.trim();
-        if (value) {
-            return value;
-        }
-    }
-    return undefined;
-}
-async function executeGitCommand(command, args, cwd) {
-    const result = await execFileAsync(command, args, { cwd });
-    return result.stdout.trim();
-}
-function shortenCommitSha(commitSha) {
-    return /^[0-9a-f]{8,}$/i.test(commitSha)
-        ? commitSha.slice(0, 7)
-        : commitSha;
-}