@trebired/git-host 1.7.0 → 2.0.0

package/dist/internal/core/forge_actions.js

@@ -0,0 +1,730 @@
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { GitHostError } from "#8974ac53d713";
+import { text } from "#sy81xkgkmoa0";
+import { runGit } from "./run_git.js";
+const ACTIVITY_LISTENER_SYMBOL = Symbol.for("@trebired/git-host/actions-activity-listeners");
+const ACTIVITY_WRAPPED_SYMBOL = Symbol.for("@trebired/git-host/actions-activity-wrapped");
+const OUTPUT_PREVIEW_LIMIT = 4000;
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 1000;
+const TERMINAL_RUN_STATUSES = new Set(["cancelled", "failed", "skipped", "success"]);
+function nowIso() {
+    return new Date().toISOString();
+}
+function slugify(value) {
+    const next = text(value)
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return next || "workflow";
+}
+function normalizeEnv(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const next = Object.fromEntries(Object.entries(value)
+        .map(([key, entry]) => [text(key), text(entry)])
+        .filter(([key, entry]) => key && entry));
+    return Object.keys(next).length ? next : undefined;
+}
+function normalizeSteps(steps) {
+    return (Array.isArray(steps) ? steps : []).map((step) => ({
+        env: normalizeEnv(step.env),
+        id: text(step.id, randomUUID()),
+        kind: "shell",
+        name: text(step.name, "Step"),
+        run: text(step.run),
+        shell: text(step.shell),
+    })).filter((step) => step.run);
+}
+function appendOutputPreview(current, chunk) {
+    const next = `${current}${chunk}`;
+    return next.length <= OUTPUT_PREVIEW_LIMIT ? next : next.slice(-OUTPUT_PREVIEW_LIMIT);
+}
+function toDateSortValue(value) {
+    return text(value);
+}
+function matchesWorkflowTrigger(workflow, triggerKind, context) {
+    if (!workflow.enabled || text(workflow.trigger) !== text(triggerKind))
+        return false;
+    const branches = Array.isArray(workflow.source?.branches) ? workflow.source?.branches.map((entry) => text(entry)).filter(Boolean) : [];
+    const tags = Array.isArray(workflow.source?.tags) ? workflow.source?.tags.map((entry) => text(entry)).filter(Boolean) : [];
+    const branch = text(context.branch);
+    const tag = text(context.tag_name, text(context.tag));
+    if (branches.length && !branches.includes(branch))
+        return false;
+    if (tags.length && !tags.includes(tag))
+        return false;
+    return true;
+}
+function isTerminalRunStatus(status) {
+    return TERMINAL_RUN_STATUSES.has(status);
+}
+function ensureActionsStorage(storage) {
+    if (!storage) {
+        throw new GitHostError("forge_actions_not_configured", "Actions storage is required to use repository workflows.");
+    }
+    return storage;
+}
+function normalizeRunner(options) {
+    const runner = options?.runner || {};
+    return {
+        capabilities: Array.isArray(runner.capabilities) ? runner.capabilities.map((entry) => text(entry)).filter(Boolean) : ["shell", "snapshot", "streaming-logs"],
+        host: text(runner.host, os.hostname()),
+        id: text(runner.id, `local-${os.hostname()}`),
+        kind: text(runner.kind, "local-host"),
+        platform_version: text(runner.platform_version, "@trebired/git-host"),
+    };
+}
+function createGitForgeActionsRuntime(options) {
+    const storage = ensureActionsStorage(options.storage);
+    const runListeners = new Map();
+    const runSequences = new Map();
+    const queuedRuns = [];
+    const activeRuns = new Map();
+    const runner = normalizeRunner(options.actions);
+    let processing = false;
+    async function nextRunSequence(runId) {
+        const current = runSequences.get(runId);
+        if (Number.isFinite(current)) {
+            const next = Number(current) + 1;
+            runSequences.set(runId, next);
+            return next;
+        }
+        const existing = await storage.listWorkflowRunEvents(runId);
+        const next = existing.length + 1;
+        runSequences.set(runId, next);
+        return next;
+    }
+    async function emitRunEvent(run, input) {
+        const event = await storage.appendWorkflowRunEvent({
+            ...input,
+            created_at: nowIso(),
+            id: randomUUID(),
+            repository_id: run.repository_id,
+            run_id: run.id,
+            sequence: await nextRunSequence(run.id),
+            workflow_id: run.workflow_id,
+        });
+        const listeners = Array.from(runListeners.get(run.id) || []);
+        await Promise.all(listeners.map(async (listener) => {
+            try {
+                await listener(event);
+            }
+            catch { }
+        }));
+        return event;
+    }
+    async function readRepositoryPath(repositoryId) {
+        const summary = await options.gitHost.readSummary(repositoryId);
+        return summary.repository.path;
+    }
+    async function resolveCommit(repositoryPath, refInput) {
+        const ref = text(refInput, "HEAD");
+        const res = await runGit(["rev-parse", ref], { cwd: repositoryPath });
+        if (!res.ok) {
+            throw new GitHostError("git_command_failed", text(res.stderr, `Failed to resolve ref "${ref}".`), {
+                ref,
+                repositoryPath,
+            });
+        }
+        return text(res.stdout);
+    }
+    async function resolveRunTarget(repositoryId, input) {
+        const summary = await options.gitHost.readSummary(repositoryId);
+        const repositoryPath = summary.repository.path;
+        const branch = text(input.branch, summary.repository.current_branch) || null;
+        const ref = text(input.ref, branch || "HEAD");
+        const commitHash = text(input.commitHash) || await resolveCommit(repositoryPath, ref);
+        return {
+            branch,
+            commitHash,
+            ref,
+            repositoryPath,
+        };
+    }
+    async function materializeRunWorkspace(run) {
+        const repositoryPath = await readRepositoryPath(run.repository_id);
+        const root = path.join(text(options.actions?.workspaceRoot, path.join(os.tmpdir(), "@trebired-git-host-actions")), text(run.repository_id), run.id);
+        const workspacePath = path.join(root, "workspace");
+        fs.rmSync(root, { force: true, recursive: true });
+        fs.mkdirSync(root, { recursive: true });
+        const cloneRes = await runGit(["clone", "--no-checkout", repositoryPath, workspacePath], { cwd: root });
+        if (!cloneRes.ok) {
+            throw new GitHostError("git_command_failed", text(cloneRes.stderr, "Failed to materialize workflow workspace."), {
+                repositoryId: run.repository_id,
+                runId: run.id,
+            });
+        }
+        const checkoutRes = await runGit(["checkout", "--detach", run.commit_hash], { cwd: workspacePath });
+        if (!checkoutRes.ok) {
+            throw new GitHostError("git_command_failed", text(checkoutRes.stderr, "Failed to check out workflow commit."), {
+                commitHash: run.commit_hash,
+                repositoryId: run.repository_id,
+                runId: run.id,
+            });
+        }
+        return workspacePath;
+    }
+    async function readRequiredWorkflow(repositoryId, workflowId) {
+        const workflow = await storage.readWorkflow(repositoryId, workflowId);
+        if (!workflow) {
+            throw new GitHostError("forge_resource_not_found", `Workflow "${workflowId}" was not found.`, {
+                repositoryId,
+                workflowId,
+            });
+        }
+        return workflow;
+    }
+    async function readRequiredRun(repositoryId, runId) {
+        const run = await storage.readWorkflowRun(repositoryId, runId);
+        if (!run) {
+            throw new GitHostError("forge_resource_not_found", `Workflow run "${runId}" was not found.`, {
+                repositoryId,
+                runId,
+            });
+        }
+        return run;
+    }
+    async function updateRun(repositoryId, runId, input) {
+        const run = await storage.updateWorkflowRun(repositoryId, runId, input);
+        if (!run) {
+            throw new GitHostError("forge_resource_not_found", `Workflow run "${runId}" was not found.`, {
+                repositoryId,
+                runId,
+            });
+        }
+        return run;
+    }
+    async function updateRunStep(runId, stepId, input) {
+        const step = await storage.updateWorkflowRunStep(runId, stepId, input);
+        if (!step) {
+            throw new GitHostError("forge_resource_not_found", `Workflow run step "${stepId}" was not found.`, {
+                runId,
+                stepId,
+            });
+        }
+        return step;
+    }
+    function scheduleQueueProcessing() {
+        if (processing)
+            return;
+        queueMicrotask(() => {
+            void processQueue();
+        });
+    }
+    async function markQueuedSteps(runId, fromIndex, status) {
+        const steps = await storage.listWorkflowRunSteps(runId);
+        const now = nowIso();
+        await Promise.all(steps
+            .filter((step) => step.index > fromIndex && step.status === "queued")
+            .map((step) => storage.updateWorkflowRunStep(runId, step.id, {
+            finished_at: now,
+            status,
+        })));
+    }
+    async function finalizeRun(run, input) {
+        const finished = await updateRun(run.repository_id, run.id, {
+            current_step: input.currentStep === undefined ? null : input.currentStep,
+            current_step_index: input.currentStepIndex === undefined ? null : input.currentStepIndex,
+            finished_at: nowIso(),
+            status: input.status,
+            summary: input.summary,
+        });
+        await emitRunEvent(finished, {
+            status: input.status,
+            summary: input.summary,
+            type: input.eventType,
+        });
+        return finished;
+    }
+    async function runShellStep(run, workflow, step, workspacePath) {
+        const active = activeRuns.get(run.id);
+        if (!active) {
+            throw new GitHostError("git_command_failed", "Workflow run is not active.", {
+                runId: run.id,
+            });
+        }
+        const startedStep = await updateRunStep(run.id, step.id, {
+            started_at: nowIso(),
+            status: "running",
+        });
+        const updatedRun = await updateRun(run.repository_id, run.id, {
+            current_step: startedStep.name,
+            current_step_index: startedStep.index,
+            status: "running",
+            summary: `Running ${startedStep.name}.`,
+        });
+        await emitRunEvent(updatedRun, {
+            command: startedStep.command,
+            status: "running",
+            step_id: startedStep.id,
+            step_index: startedStep.index,
+            step_name: startedStep.name,
+            type: "step.started",
+        });
+        let outputPreview = startedStep.output_preview;
+        const shell = text(workflow.steps[startedStep.index]?.shell, text(options.actions?.shell, "bash"));
+        const env = {
+            ...process.env,
+            ...(options.actions?.env || {}),
+            ...(workflow.env || {}),
+            ...(workflow.source?.env || {}),
+            ...(workflow.steps[startedStep.index]?.env || {}),
+            GIT_HOST_ACTIONS_REPOSITORY_ID: run.repository_id,
+            GIT_HOST_ACTIONS_RUN_ID: run.id,
+            GIT_HOST_ACTIONS_TRIGGER: text(run.trigger_kind),
+            GIT_HOST_ACTIONS_WORKFLOW_ID: workflow.id,
+            GIT_HOST_ACTIONS_COMMIT: run.commit_hash,
+            GIT_HOST_ACTIONS_REF: run.ref,
+            GIT_HOST_ACTIONS_BRANCH: text(run.branch),
+            GIT_HOST_ACTIONS_RELEASE_ID: text(run.release_id),
+        };
+        const child = spawn(shell, ["-lc", startedStep.command], {
+            cwd: workspacePath,
+            env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        active.child = child;
+        active.heartbeat = setInterval(() => {
+            void emitRunEvent(updatedRun, {
+                status: "running",
+                step_id: startedStep.id,
+                step_index: startedStep.index,
+                step_name: startedStep.name,
+                type: "step.heartbeat",
+            });
+        }, Math.max(250, Number(options.actions?.heartbeatIntervalMs) || DEFAULT_HEARTBEAT_INTERVAL_MS));
+        async function handleChunk(stream, chunk) {
+            let textChunk = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+            if (options.actions?.redactOutput) {
+                textChunk = await options.actions.redactOutput({
+                    chunk: textChunk,
+                    run: updatedRun,
+                    step: startedStep,
+                    stream,
+                });
+            }
+            outputPreview = appendOutputPreview(outputPreview, textChunk);
+            await emitRunEvent(updatedRun, {
+                chunk: textChunk,
+                status: "running",
+                step_id: startedStep.id,
+                step_index: startedStep.index,
+                step_name: startedStep.name,
+                stream,
+                type: "step.output",
+            });
+        }
+        const exitCode = await new Promise((resolve, reject) => {
+            child.stdout.on("data", (chunk) => {
+                void handleChunk("stdout", chunk);
+            });
+            child.stderr.on("data", (chunk) => {
+                void handleChunk("stderr", chunk);
+            });
+            child.on("error", reject);
+            child.on("close", (code) => resolve(Number(code) || 0));
+        });
+        if (active.heartbeat)
+            clearInterval(active.heartbeat);
+        active.child = undefined;
+        active.heartbeat = undefined;
+        const cancelled = active.cancelRequested === true;
+        const finalStatus = cancelled
+            ? "cancelled"
+            : (exitCode === 0 ? "success" : "failed");
+        const finishedStep = await updateRunStep(run.id, startedStep.id, {
+            exit_code: exitCode,
+            finished_at: nowIso(),
+            output_preview: outputPreview,
+            status: finalStatus,
+        });
+        await emitRunEvent(updatedRun, {
+            command: finishedStep.command,
+            metadata: {
+                exit_code: exitCode,
+            },
+            status: finalStatus,
+            step_id: finishedStep.id,
+            step_index: finishedStep.index,
+            step_name: finishedStep.name,
+            summary: finalStatus === "success" ? `${finishedStep.name} completed.` : `${finishedStep.name} ${cancelled ? "cancelled" : "failed"}.`,
+            type: "step.finished",
+        });
+        return {
+            cancelled,
+            exitCode,
+            status: finalStatus,
+        };
+    }
+    async function executeRun(repositoryId, runId) {
+        let run = await readRequiredRun(repositoryId, runId);
+        if (isTerminalRunStatus(run.status))
+            return run;
+        run = await updateRun(repositoryId, runId, {
+            runner,
+            started_at: nowIso(),
+            status: "starting",
+            summary: "Preparing workflow workspace.",
+        });
+        await emitRunEvent(run, {
+            metadata: {
+                runner,
+            },
+            status: "starting",
+            summary: run.summary,
+            type: "run.status",
+        });
+        const workflow = await readRequiredWorkflow(repositoryId, run.workflow_id);
+        const steps = await storage.listWorkflowRunSteps(run.id);
+        const activeState = {
+            cancelRequested: false,
+        };
+        activeRuns.set(run.id, activeState);
+        try {
+            activeState.workspacePath = await materializeRunWorkspace(run);
+            run = await updateRun(repositoryId, run.id, {
+                status: "running",
+                summary: "Workflow run started.",
+            });
+            await emitRunEvent(run, {
+                status: "running",
+                summary: run.summary,
+                type: "run.status",
+            });
+            for (const step of steps.sort((left, right) => left.index - right.index)) {
+                if (activeState.cancelRequested) {
+                    await markQueuedSteps(run.id, step.index - 1, "cancelled");
+                    return await finalizeRun(run, {
+                        eventType: "run.cancelled",
+                        status: "cancelled",
+                        summary: "Workflow run cancelled.",
+                    });
+                }
+                const result = await runShellStep(run, workflow, step, activeState.workspacePath);
+                if (result.cancelled) {
+                    await markQueuedSteps(run.id, step.index, "cancelled");
+                    return await finalizeRun(run, {
+                        eventType: "run.cancelled",
+                        status: "cancelled",
+                        summary: "Workflow run cancelled.",
+                    });
+                }
+                if (result.exitCode !== 0) {
+                    await markQueuedSteps(run.id, step.index, "skipped");
+                    return await finalizeRun(run, {
+                        eventType: "run.failed",
+                        status: "failed",
+                        summary: `Workflow run failed in step ${step.name}.`,
+                    });
+                }
+            }
+            return await finalizeRun(run, {
+                eventType: "run.finished",
+                status: "success",
+                summary: "Workflow run completed successfully.",
+            });
+        }
+        catch (error) {
+            await markQueuedSteps(run.id, -1, "skipped");
+            return await finalizeRun(run, {
+                eventType: activeState.cancelRequested ? "run.cancelled" : "run.failed",
+                status: activeState.cancelRequested ? "cancelled" : "failed",
+                summary: activeState.cancelRequested
+                    ? "Workflow run cancelled."
+                    : (error instanceof Error ? error.message : "Workflow run failed."),
+            });
+        }
+        finally {
+            if (activeState.heartbeat)
+                clearInterval(activeState.heartbeat);
+            if (activeState.child && !activeState.child.killed) {
+                try {
+                    activeState.child.kill("SIGKILL");
+                }
+                catch { }
+            }
+            activeRuns.delete(run.id);
+        }
+    }
+    async function processQueue() {
+        if (processing)
+            return;
+        processing = true;
+        try {
+            while (queuedRuns.length) {
+                const next = queuedRuns.shift();
+                if (!next)
+                    continue;
+                const run = await storage.readWorkflowRun(next.repositoryId, next.runId);
+                if (!run || isTerminalRunStatus(run.status))
+                    continue;
+                await executeRun(next.repositoryId, next.runId);
+            }
+        }
+        finally {
+            processing = false;
+        }
+    }
+    async function queueWorkflowRun(repositoryId, workflow, input) {
+        const target = await resolveRunTarget(repositoryId, input);
+        const createdAt = nowIso();
+        const createdBy = text(input.actor.id, text(input.actor.name, "system"));
+        const run = await storage.createWorkflowRun({
+            branch: target.branch,
+            commit_hash: target.commitHash,
+            created_at: createdAt,
+            created_by: createdBy,
+            current_step: null,
+            current_step_index: null,
+            finished_at: null,
+            id: randomUUID(),
+            ref: target.ref,
+            release_id: input.releaseId == null ? null : text(input.releaseId),
+            repository_id: repositoryId,
+            runner: null,
+            started_at: null,
+            status: "queued",
+            summary: "Workflow run queued.",
+            trigger_context: input.triggerContext,
+            trigger_kind: input.triggerKind,
+            workflow_id: workflow.id,
+        });
+        await Promise.all(workflow.steps.map(async (step, index) => {
+            await storage.createWorkflowRunStep({
+                command: step.run,
+                exit_code: null,
+                finished_at: null,
+                id: randomUUID(),
+                index,
+                kind: "shell",
+                metadata: step.env ? { env: step.env, shell: text(step.shell) } : (text(step.shell) ? { shell: text(step.shell) } : undefined),
+                name: text(step.name, `Step ${index + 1}`),
+                output_preview: "",
+                run_id: run.id,
+                started_at: null,
+                status: "queued",
+            });
+        }));
+        await emitRunEvent(run, {
+            metadata: {
+                branch: run.branch,
+                ref: run.ref,
+            },
+            status: "queued",
+            summary: run.summary,
+            type: "run.accepted",
+        });
+        queuedRuns.push({
+            repositoryId,
+            runId: run.id,
+        });
+        scheduleQueueProcessing();
+        return run;
+    }
+    async function enqueueWorkflowsForTrigger(repositoryId, triggerKind, actor, context) {
+        const workflows = await storage.listWorkflows(repositoryId, {
+            enabled: true,
+            trigger: triggerKind,
+        });
+        const createdRuns = [];
+        for (const workflow of workflows) {
+            if (!matchesWorkflowTrigger(workflow, triggerKind, context))
+                continue;
+            createdRuns.push(await queueWorkflowRun(repositoryId, workflow, {
+                actor,
+                branch: text(context.branch),
+                commitHash: text(context.commit_hash, text(context.head_commit)),
+                ref: text(context.ref, text(context.tag_name, text(context.branch, "HEAD"))),
+                releaseId: text(context.release_id) || null,
+                triggerContext: context,
+                triggerKind,
+            }));
+        }
+        return createdRuns;
+    }
+    async function handleActivity(entry) {
+        const actor = {
+            id: text(entry.actor_id, text(entry.actor_label, "system")),
+            name: text(entry.actor_label, entry.actor_id),
+        };
+        if (entry.kind === "repository.push") {
+            await enqueueWorkflowsForTrigger(entry.repository_id, "push", actor, {
+                ...(entry.metadata || {}),
+                activity_id: entry.id,
+            });
+            return;
+        }
+        if (entry.kind === "release.create" || entry.kind === "release.update") {
+            const releaseId = text(entry.metadata?.release_id);
+            const release = releaseId ? await options.releases.readRelease(entry.repository_id, releaseId) : null;
+            const targetRef = text(release?.target_ref);
+            const repositoryPath = await readRepositoryPath(entry.repository_id);
+            const commitHash = targetRef ? await resolveCommit(repositoryPath, targetRef) : "";
+            await enqueueWorkflowsForTrigger(entry.repository_id, entry.kind, actor, {
+                ...(entry.metadata || {}),
+                activity_id: entry.id,
+                commit_hash: commitHash,
+                ref: text(release?.tag_name, targetRef),
+                release_id: release?.id,
+                tag_name: text(release?.tag_name, text(entry.metadata?.tag_name)),
+            });
+        }
+    }
+    function bindActivityStorage(activityStorage) {
+        const store = activityStorage;
+        if (!store[ACTIVITY_LISTENER_SYMBOL]) {
+            store[ACTIVITY_LISTENER_SYMBOL] = new Set();
+        }
+        store[ACTIVITY_LISTENER_SYMBOL].add(async (entry) => {
+            await handleActivity(entry);
+        });
+        if (store[ACTIVITY_WRAPPED_SYMBOL])
+            return;
+        store[ACTIVITY_WRAPPED_SYMBOL] = true;
+        const original = activityStorage.createActivity.bind(activityStorage);
+        activityStorage.createActivity = async (input) => {
+            const entry = await original(input);
+            const listeners = Array.from(store[ACTIVITY_LISTENER_SYMBOL] || []);
+            await Promise.all(listeners.map(async (listener) => {
+                try {
+                    await listener(entry);
+                }
+                catch { }
+            }));
+            return entry;
+        };
+    }
+    return {
+        bindActivityStorage,
+        async createWorkflow(repositoryId, input) {
+            const workflow = await storage.createWorkflow({
+                created_at: nowIso(),
+                created_by: text(input.actor.id),
+                enabled: input.enabled !== false,
+                env: normalizeEnv(input.env),
+                id: randomUUID(),
+                name: text(input.name),
+                repository_id: repositoryId,
+                slug: text(input.slug, slugify(input.name)),
+                source: input.source ? {
+                    branches: Array.isArray(input.source.branches) ? input.source.branches.map((entry) => text(entry)).filter(Boolean) : undefined,
+                    env: normalizeEnv(input.source.env),
+                    tags: Array.isArray(input.source.tags) ? input.source.tags.map((entry) => text(entry)).filter(Boolean) : undefined,
+                } : undefined,
+                steps: normalizeSteps(input.steps),
+                trigger: text(input.trigger),
+                updated_at: nowIso(),
+                updated_by: text(input.actor.id),
+            });
+            return workflow;
+        },
+        async updateWorkflow(repositoryId, workflowId, input) {
+            const current = await readRequiredWorkflow(repositoryId, workflowId);
+            const updated = await storage.updateWorkflow(repositoryId, workflowId, {
+                ...(input.enabled != null ? { enabled: input.enabled === true } : {}),
+                ...(input.env !== undefined ? { env: normalizeEnv(input.env) } : {}),
+                ...(input.name !== undefined ? { name: text(input.name) } : {}),
+                ...(input.slug !== undefined ? { slug: text(input.slug, current.slug) } : {}),
+                ...(input.source !== undefined ? {
+                    source: {
+                        branches: Array.isArray(input.source?.branches) ? input.source?.branches.map((entry) => text(entry)).filter(Boolean) : undefined,
+                        env: normalizeEnv(input.source?.env),
+                        tags: Array.isArray(input.source?.tags) ? input.source?.tags.map((entry) => text(entry)).filter(Boolean) : undefined,
+                    },
+                } : {}),
+                ...(input.steps !== undefined ? { steps: normalizeSteps(input.steps) } : {}),
+                ...(input.trigger !== undefined ? { trigger: text(input.trigger) } : {}),
+                updated_at: nowIso(),
+                updated_by: text(input.actor.id),
+            });
+            if (!updated) {
+                throw new GitHostError("forge_resource_not_found", `Workflow "${workflowId}" was not found.`, {
+                    repositoryId,
+                    workflowId,
+                });
+            }
+            return updated;
+        },
+        async listWorkflows(repositoryId, filters) {
+            const entries = await storage.listWorkflows(repositoryId, filters);
+            return Array.from(entries).sort((left, right) => text(left.name).localeCompare(text(right.name)) || text(left.slug).localeCompare(text(right.slug)));
+        },
+        async readWorkflow(repositoryId, workflowId) {
+            return await readRequiredWorkflow(repositoryId, workflowId);
+        },
+        async runWorkflow(repositoryId, workflowId, input) {
+            const workflow = await readRequiredWorkflow(repositoryId, workflowId);
+            return await queueWorkflowRun(repositoryId, workflow, {
+                ...input,
+                triggerKind: "manual",
+            });
+        },
+        async cancelWorkflowRun(repositoryId, runId, actor) {
+            const run = await readRequiredRun(repositoryId, runId);
+            if (isTerminalRunStatus(run.status))
+                return run;
+            const active = activeRuns.get(run.id);
+            if (active) {
+                active.cancelRequested = true;
+                if (active.child && !active.child.killed) {
+                    try {
+                        active.child.kill("SIGTERM");
+                    }
+                    catch { }
+                }
+                return await updateRun(repositoryId, runId, {
+                    summary: `Cancellation requested by ${text(actor.id)}.`,
+                });
+            }
+            const cancelled = await updateRun(repositoryId, runId, {
+                finished_at: nowIso(),
+                status: "cancelled",
+                summary: `Cancelled by ${text(actor.id)}.`,
+            });
+            await emitRunEvent(cancelled, {
+                status: "cancelled",
+                summary: cancelled.summary,
+                type: "run.cancelled",
+            });
+            return cancelled;
+        },
+        async listWorkflowRuns(repositoryId, filters) {
+            return await storage.listWorkflowRuns(repositoryId, filters);
+        },
+        async readWorkflowRun(repositoryId, runId) {
+            return await readRequiredRun(repositoryId, runId);
+        },
+        async listWorkflowRunSteps(repositoryId, runId) {
+            await readRequiredRun(repositoryId, runId);
+            return await storage.listWorkflowRunSteps(runId);
+        },
+        async listWorkflowRunEvents(repositoryId, runId, filters) {
+            await readRequiredRun(repositoryId, runId);
+            return await storage.listWorkflowRunEvents(runId, filters);
+        },
+        subscribeWorkflowRun(repositoryId, runId, listener) {
+            const key = `${repositoryId}:${runId}`;
+            void key;
+            let listeners = runListeners.get(runId);
+            if (!listeners) {
+                listeners = new Set();
+                runListeners.set(runId, listeners);
+            }
+            listeners.add(listener);
+            return {
+                close() {
+                    listeners?.delete(listener);
+                    if (listeners && listeners.size === 0) {
+                        runListeners.delete(runId);
+                    }
+                },
+            };
+        },
+    };
+}
+export { createGitForgeActionsRuntime, isTerminalRunStatus };
+//# sourceMappingURL=forge_actions.js.map