@mingchuno/agent-workflows 0.1.0

package/dist/src/store.d.ts

@@ -0,0 +1,87 @@
+import { Pool } from "pg";
+import type { RunRecord } from "./domain.js";
+export interface EventRecord {
+    sequence: number;
+    runId: string | null;
+    kind: string;
+    payload: unknown;
+    createdAt: string;
+}
+export interface ProjectState {
+    id: string;
+    paused: boolean;
+    blocked: string | null;
+}
+export interface InvocationRecord {
+    id: string;
+    runId: string;
+    projectId: string;
+    step: string;
+    stepId: number;
+    attempt: number;
+    provider: string;
+    sessionId: string | null;
+    sessionState: "pending" | "available" | "unavailable";
+    requested: unknown;
+    effective: unknown;
+    prompt: string;
+    skills: unknown;
+    outcome: string;
+    startedAt: string;
+    finishedAt?: string;
+    log: string;
+}
+interface RetryAdmission {
+    commandId?: string;
+    checkSafety: (previous: RunRecord) => Promise<{
+        checkout: string;
+        branchTemplate: string;
+    }>;
+}
+/** Public persisted query surface. All queries work without a running executor. */
+export declare class Store {
+    readonly scope: string;
+    private readonly redact;
+    readonly pool: Pool;
+    private readonly db;
+    private ownership?;
+    constructor(databaseUrl: string, scope: string, redact?: (text: string) => string);
+    initialize(): Promise<void>;
+    acquire(keys: string[], onLost: () => void): Promise<void>;
+    release(): Promise<void>;
+    close(): Promise<void>;
+    registerProject(id: string): Promise<void>;
+    projects(): Promise<ProjectState[]>;
+    project(id: string): Promise<ProjectState>;
+    setProject(id: string, change: {
+        paused?: boolean;
+        blocked?: string | null;
+    }): Promise<void>;
+    insertRun(run: RunRecord): Promise<boolean>;
+    /**
+     * Admit a retry and its events atomically. Safety checks run under the project
+     * lock only for new admissions; they must not write through this Store.
+     */
+    admitRetry(runId: string, admission: RetryAdmission): Promise<string>;
+    run(id: string): Promise<RunRecord>;
+    runs(): Promise<RunRecord[]>;
+    patchRun(id: string, patch: Partial<RunRecord>): Promise<RunRecord>;
+    saveInvocation(record: InvocationRecord): Promise<void>;
+    invocations(runId: string): Promise<InvocationRecord[]>;
+    emit(runId: string | null, kind: string, payload: unknown): Promise<void>;
+    events(after?: number, runId?: string): Promise<EventRecord[]>;
+    subscribe(listener: (event: EventRecord) => void, options?: {
+        after?: number;
+        intervalMs?: number;
+    }): () => void;
+    request(kind: "pause" | "resume" | "stop" | "retry", target: string): Promise<string>;
+    commands(): Promise<Array<{
+        id: string;
+        kind: string;
+        target: string;
+        status: string;
+        error: string | null;
+    }>>;
+    finishCommand(id: string, error?: string): Promise<void>;
+}
+export {};

package/dist/src/store.js

@@ -0,0 +1,355 @@
+import { randomUUID } from "node:crypto";
+import { and, eq, gt, Param, SQL } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { Pool } from "pg";
+import { tryLock, unlockAll } from "./db/locks.js";
+import { migrateDatabase } from "./db/migrations.js";
+import * as tables from "./db/schema.js";
+import { createQueuedRun } from "./run-record.js";
+import { redactValue } from "./runtime/redaction.js";
+/** Public persisted query surface. All queries work without a running executor. */
+export class Store {
+    scope;
+    redact;
+    pool;
+    db;
+    ownership;
+    constructor(databaseUrl, scope, redact = (text) => text) {
+        this.scope = scope;
+        this.redact = redact;
+        this.pool = new Pool({ connectionString: databaseUrl });
+        this.db = drizzle(this.pool);
+    }
+    async initialize() {
+        await migrateDatabase(this.pool);
+    }
+    async acquire(keys, onLost) {
+        this.ownership = await this.pool.connect();
+        this.ownership.on("error", onLost);
+        try {
+            for (const key of [
+                `runner:${this.scope}`,
+                ...keys.map((key) => `checkout:${key}`),
+            ]) {
+                if (!(await tryLock(this.ownership, key))) {
+                    throw new Error(`Already owned by another runner: ${key}`);
+                }
+            }
+        }
+        catch (error) {
+            await this.release();
+            throw error;
+        }
+    }
+    async release() {
+        const client = this.ownership;
+        if (!client)
+            return;
+        this.ownership = undefined;
+        try {
+            await unlockAll(client);
+        }
+        finally {
+            client.removeAllListeners("error");
+            client.release(true);
+        }
+    }
+    async close() {
+        try {
+            await this.release();
+        }
+        finally {
+            await this.pool.end();
+        }
+    }
+    async registerProject(id) {
+        await this.db
+            .insert(tables.projects)
+            .values({ scope: this.scope, id })
+            .onConflictDoNothing();
+    }
+    async projects() {
+        const { projects } = tables;
+        return this.db
+            .select({
+            id: projects.id,
+            paused: projects.paused,
+            blocked: projects.blocked,
+        })
+            .from(projects)
+            .where(eq(projects.scope, this.scope))
+            .orderBy(projects.id);
+    }
+    async project(id) {
+        const state = (await this.projects()).find((project) => project.id === id);
+        if (!state)
+            throw new Error(`Unknown project: ${id}`);
+        return state;
+    }
+    async setProject(id, change) {
+        const { projects } = tables;
+        if (change.paused !== undefined || change.blocked !== undefined) {
+            await this.db
+                .update(projects)
+                .set(change)
+                .where(and(eq(projects.scope, this.scope), eq(projects.id, id)));
+        }
+        await this.emit(null, "project", { id, ...change });
+    }
+    async insertRun(run) {
+        const { runs } = tables;
+        const inserted = await this.db
+            .insert(runs)
+            .values({
+            scope: this.scope,
+            id: run.id,
+            taskKey: run.taskKey,
+            attempt: run.attempt,
+            record: redactValue(run, this.redact),
+        })
+            .onConflictDoNothing()
+            .returning({ id: runs.id });
+        if (inserted.length)
+            await this.emit(run.id, "run", run);
+        return inserted.length > 0;
+    }
+    /**
+     * Admit a retry and its events atomically. Safety checks run under the project
+     * lock only for new admissions; they must not write through this Store.
+     */
+    async admitRetry(runId, admission) {
+        const original = await this.run(runId);
+        const { projects, runs, events } = tables;
+        const projectPredicate = and(eq(projects.scope, this.scope), eq(projects.id, original.projectId));
+        return this.db.transaction(async (tx) => {
+            // Lock the project, not just the original run: retries of different
+            // attempts of the same task must compete for the same admission.
+            const [project] = await tx
+                .select({ id: projects.id })
+                .from(projects)
+                .where(projectPredicate)
+                .for("update");
+            if (!project)
+                throw new Error(`Unknown project: ${original.projectId}`);
+            if (admission.commandId) {
+                const [existing] = await tx
+                    .select({ record: runs.record })
+                    .from(runs)
+                    .where(and(eq(runs.scope, this.scope), eq(runs.id, admission.commandId)));
+                if (existing) {
+                    if (existing.record.retryOf !== runId)
+                        throw new Error("Retry command identity belongs to a different run");
+                    return existing.record.id;
+                }
+            }
+            const history = await tx
+                .select({ record: runs.record, attempt: runs.attempt })
+                .from(runs)
+                .where(and(eq(runs.scope, this.scope), eq(runs.taskKey, original.taskKey)))
+                .orderBy(runs.id)
+                .for("update");
+            const previous = history.find((row) => row.record.id === runId)?.record;
+            if (!previous)
+                throw new Error(`Unknown run: ${runId}`);
+            if (!["failed", "blocked", "cancelled"].includes(previous.outcome))
+                throw new Error("Only failed, blocked or cancelled runs can be retried");
+            if (history.some(({ record }) => ["queued", "running"].includes(record.outcome)))
+                throw new Error("This task already has a queued or active retry");
+            const target = await admission.checkSafety(previous);
+            const attempt = Math.max(...history.map((row) => row.attempt)) + 1;
+            const id = admission.commandId ?? randomUUID();
+            const now = new Date().toISOString();
+            const retry = createQueuedRun({
+                id,
+                projectId: previous.projectId,
+                checkout: target.checkout,
+                taskKey: previous.taskKey,
+                attempt,
+                retryOf: previous.id,
+                issue: previous.issue,
+                now,
+                branchTemplate: target.branchTemplate,
+            });
+            const persisted = redactValue(retry, this.redact);
+            // A conflict must fail admission, never return an unpersisted run ID.
+            await tx.insert(runs).values({
+                scope: this.scope,
+                id,
+                taskKey: retry.taskKey,
+                attempt,
+                record: persisted,
+            });
+            await tx.update(projects).set({ blocked: null }).where(projectPredicate);
+            await tx.insert(events).values([
+                {
+                    scope: this.scope,
+                    runId: null,
+                    kind: "project",
+                    payload: redactValue({ id: previous.projectId, blocked: null }, this.redact),
+                },
+                { scope: this.scope, runId: id, kind: "run", payload: persisted },
+            ]);
+            return id;
+        });
+    }
+    async run(id) {
+        const { runs } = tables;
+        const [row] = await this.db
+            .select({ record: runs.record })
+            .from(runs)
+            .where(and(eq(runs.scope, this.scope), eq(runs.id, id)));
+        if (!row)
+            throw new Error(`Unknown run: ${id}`);
+        return row.record;
+    }
+    async runs() {
+        const { runs } = tables;
+        const rows = await this.db
+            .select({ record: runs.record, attempt: runs.attempt, id: runs.id })
+            .from(runs)
+            .where(eq(runs.scope, this.scope));
+        // This API returns the full scope; sort JSON fields here without raw SQL expressions.
+        return rows
+            .sort((a, b) => a.record.createdAt.localeCompare(b.record.createdAt) ||
+            a.record.issue.number - b.record.issue.number ||
+            a.attempt - b.attempt ||
+            a.id.localeCompare(b.id))
+            .map((row) => row.record);
+    }
+    async patchRun(id, patch) {
+        const { runs } = tables;
+        const change = { ...patch, updatedAt: new Date().toISOString() };
+        const predicate = and(eq(runs.scope, this.scope), eq(runs.id, id));
+        const record = await this.db.transaction(async (tx) => {
+            // Serialize read/merge/write so concurrent patches cannot lose fields.
+            const [row] = await tx
+                .select({ record: runs.record })
+                .from(runs)
+                .where(predicate)
+                .for("update");
+            if (!row)
+                throw new Error(`Unknown run: ${id}`);
+            // Match JSON serialization: undefined patch fields leave stored fields intact.
+            const persistedChange = JSON.parse(JSON.stringify(redactValue(change, this.redact)));
+            const merged = { ...row.record, ...persistedChange };
+            await tx.update(runs).set({ record: merged }).where(predicate);
+            return merged;
+        });
+        await this.emit(id, "run", change);
+        return record;
+    }
+    async saveInvocation(record) {
+        const { invocations } = tables;
+        const persisted = redactValue(record, this.redact);
+        await this.db
+            .insert(invocations)
+            .values({
+            scope: this.scope,
+            id: record.id,
+            runId: record.runId,
+            record: persisted,
+        })
+            .onConflictDoUpdate({
+            target: invocations.id,
+            set: { record: persisted },
+        });
+        await this.emit(record.runId, "invocation", record);
+    }
+    async invocations(runId) {
+        const { invocations } = tables;
+        const rows = await this.db
+            .select({ record: invocations.record })
+            .from(invocations)
+            .where(and(eq(invocations.scope, this.scope), eq(invocations.runId, runId)));
+        return rows
+            .map((row) => row.record)
+            .sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+    }
+    async emit(runId, kind, payload) {
+        await this.db.insert(tables.events).values({
+            scope: this.scope,
+            runId,
+            kind,
+            // Bind serialized JSON so JSON null is not converted to SQL NULL.
+            payload: new SQL([
+                new Param(JSON.stringify(redactValue(payload, this.redact))),
+            ]),
+        });
+    }
+    async events(after = 0, runId) {
+        const { events } = tables;
+        const rows = await this.db
+            .select({
+            sequence: events.sequence,
+            runId: events.runId,
+            kind: events.kind,
+            payload: events.payload,
+            createdAt: events.createdAt,
+        })
+            .from(events)
+            .where(and(eq(events.scope, this.scope), gt(events.sequence, after), runId === undefined ? undefined : eq(events.runId, runId)))
+            .orderBy(events.sequence)
+            .limit(1000);
+        return rows.map((row) => ({
+            ...row,
+            createdAt: row.createdAt.toISOString(),
+        }));
+    }
+    subscribe(listener, options = {}) {
+        let cursor = options.after ?? 0, closed = false, busy = false;
+        const poll = async () => {
+            if (closed || busy)
+                return;
+            busy = true;
+            try {
+                for (const event of await this.events(cursor)) {
+                    if (closed)
+                        break;
+                    listener(event);
+                    cursor = event.sequence;
+                }
+            }
+            finally {
+                busy = false;
+            }
+        };
+        const timer = setInterval(() => {
+            void poll().catch(() => {
+                /* Next poll retries; callers can query directly for errors. */
+            });
+        }, options.intervalMs ?? 500);
+        void poll().catch(() => { });
+        return () => {
+            closed = true;
+            clearInterval(timer);
+        };
+    }
+    async request(kind, target) {
+        const id = randomUUID();
+        await this.db
+            .insert(tables.commands)
+            .values({ id, scope: this.scope, kind, target });
+        return id;
+    }
+    async commands() {
+        const { commands } = tables;
+        return this.db
+            .select({
+            id: commands.id,
+            kind: commands.kind,
+            target: commands.target,
+            status: commands.status,
+            error: commands.error,
+        })
+            .from(commands)
+            .where(eq(commands.scope, this.scope))
+            .orderBy(commands.createdAt);
+    }
+    async finishCommand(id, error) {
+        const { commands } = tables;
+        await this.db
+            .update(commands)
+            .set({ status: error ? "failed" : "success", error: error ?? null })
+            .where(and(eq(commands.scope, this.scope), eq(commands.id, id)));
+    }
+}

package/dist/src/tui-data.d.ts

@@ -0,0 +1,25 @@
+import type { RunRecord } from "./domain.js";
+import type { EventRecord, InvocationRecord, ProjectState, Store } from "./store.js";
+export interface MonitorSource {
+    projects: Store["projects"];
+    runs: Store["runs"];
+    invocations: Store["invocations"];
+    events: Store["events"];
+    request: Store["request"];
+    commands: Store["commands"];
+}
+export declare function useMonitorData(source: MonitorSource, selection: {
+    projectIndex: number;
+    runIndex: number;
+}): {
+    projects: ProjectState[];
+    project: ProjectState | undefined;
+    projectRuns: RunRecord[];
+    run: RunRecord | undefined;
+    sessions: InvocationRecord[];
+    events: EventRecord[];
+    message: string;
+    setMessage: import("react").Dispatch<import("react").SetStateAction<string>>;
+    pending: string | undefined;
+    action: (kind: "pause" | "resume" | "stop" | "retry", target: string) => Promise<void>;
+};

package/dist/src/tui-data.js

@@ -0,0 +1,89 @@
+import { useEffect, useState } from "react";
+export function useMonitorData(source, selection) {
+    const { projectIndex, runIndex } = selection;
+    const [projects, setProjects] = useState([]);
+    const [runs, setRuns] = useState([]);
+    const [sessions, setSessions] = useState([]), [events, setEvents] = useState([]);
+    const [message, setMessage] = useState("Connecting…"), [pending, setPending] = useState();
+    const project = projects[projectIndex];
+    const projectRuns = runs.filter((run) => run.projectId === project?.id);
+    const run = projectRuns[runIndex];
+    const selectedRunId = run?.id;
+    useEffect(() => {
+        let closed = false, busy = false;
+        const update = async () => {
+            if (busy)
+                return;
+            busy = true;
+            try {
+                const [nextProjects, nextRuns] = await Promise.all([
+                    source.projects(),
+                    source.runs(),
+                ]);
+                if (closed)
+                    return;
+                setProjects(nextProjects);
+                setRuns(nextRuns);
+                if (selectedRunId) {
+                    const [nextSessions, nextEvents] = await Promise.all([
+                        source.invocations(selectedRunId),
+                        source.events(0, selectedRunId),
+                    ]);
+                    if (closed)
+                        return;
+                    setSessions(nextSessions);
+                    setEvents(nextEvents.filter((event) => event.runId === selectedRunId));
+                }
+                else {
+                    setSessions([]);
+                    setEvents([]);
+                }
+                if (pending) {
+                    const command = (await source.commands()).find((command) => command.id === pending);
+                    if (command && command.status !== "pending") {
+                        setMessage(`${command.kind}: ${command.status}${command.error ? ` — ${command.error}` : ""}`);
+                        setPending(undefined);
+                    }
+                }
+                else
+                    setMessage((current) => current === "Connecting…" ? "Connected" : current);
+            }
+            catch (error) {
+                if (!closed)
+                    setMessage(`Connection error: ${String(error)}`);
+            }
+            finally {
+                busy = false;
+            }
+        };
+        void update();
+        const timer = setInterval(() => void update(), 400);
+        return () => {
+            closed = true;
+            clearInterval(timer);
+        };
+    }, [source, selectedRunId, pending]);
+    const action = async (kind, target) => {
+        setMessage(`${kind}: pending`);
+        setPending("submitting");
+        try {
+            setPending(await source.request(kind, target));
+        }
+        catch (error) {
+            setPending(undefined);
+            setMessage(`${kind}: failed — ${String(error)}`);
+        }
+    };
+    return {
+        projects,
+        project,
+        projectRuns,
+        run,
+        sessions,
+        events,
+        message,
+        setMessage,
+        pending,
+        action,
+    };
+}

package/dist/src/tui.d.ts

@@ -0,0 +1,5 @@
+import { type MonitorSource } from "./tui-data.js";
+export type { MonitorSource } from "./tui-data.js";
+export declare function Monitor({ source }: {
+    source: MonitorSource;
+}): import("react").JSX.Element;

package/dist/src/tui.js

@@ -0,0 +1,69 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { readFile } from "node:fs/promises";
+import { Box, Text, useApp, useInput } from "ink";
+import { useState } from "react";
+import { useMonitorData } from "./tui-data.js";
+export function Monitor({ source }) {
+    const { exit } = useApp();
+    const [projectIndex, setProjectIndex] = useState(0), [runIndex, setRunIndex] = useState(0), [sessionIndex, setSessionIndex] = useState(0), [stepIndex, setStepIndex] = useState(0), [validationIndex, setValidationIndex] = useState(0);
+    const { projects, project, projectRuns, run, sessions, events, message, setMessage, pending, action, } = useMonitorData(source, { projectIndex, runIndex });
+    const [log, setLog] = useState("");
+    const session = sessions[sessionIndex];
+    const steps = events.filter((event) => event.kind === "step");
+    const selectedStep = steps[stepIndex];
+    const showLog = (path) => {
+        void readFile(path, "utf8").then((text) => setLog(text.split("\n").slice(-8).join("\n")), (error) => setMessage(`Log unavailable: ${String(error)}`));
+    };
+    useInput((input, key) => {
+        if (input === "q") {
+            exit();
+            return;
+        }
+        if (key.leftArrow || key.rightArrow) {
+            setProjectIndex((index) => Math.max(0, Math.min(projects.length - 1, index + (key.rightArrow ? 1 : -1))));
+            setRunIndex(0);
+            setSessionIndex(0);
+            setStepIndex(0);
+            setValidationIndex(0);
+            setLog("");
+        }
+        if (key.upArrow || key.downArrow) {
+            setRunIndex((index) => Math.max(0, Math.min(projectRuns.length - 1, index + (key.downArrow ? 1 : -1))));
+            setSessionIndex(0);
+            setStepIndex(0);
+            setValidationIndex(0);
+            setLog("");
+        }
+        if (key.tab) {
+            setSessionIndex((index) => (index + 1) % Math.max(sessions.length, 1));
+            setLog("");
+        }
+        if (input === "l" && session)
+            showLog(session.log);
+        if (input === "[" || input === "]")
+            setStepIndex((index) => Math.max(0, Math.min(steps.length - 1, index + (input === "]" ? 1 : -1))));
+        if (input === "v" && run?.validation?.length) {
+            const check = run.validation[validationIndex % run.validation.length];
+            setMessage(`Validation: ${check.command} · exit ${check.exitCode}`);
+            showLog(check.log);
+            setValidationIndex((index) => index + 1);
+        }
+        if (pending)
+            return;
+        if (input === "p" && project)
+            void action(project.paused ? "resume" : "pause", project.id);
+        if (input === "s" && run)
+            void action("stop", run.id);
+        if (input === "r" && run)
+            void action("retry", run.id);
+    });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Agent Workflows \u00B7 Monitor" }), _jsx(Text, { children: "\u2190 \u2192 project \u00B7 \u2191 \u2193 run \u00B7 [ ] step/attempt \u00B7 Tab session \u00B7 l agent log \u00B7 v validation log \u00B7 p pause/resume \u00B7 s stop \u00B7 r retry \u00B7 q close" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: project
+                            ? `${project.id} · ${project.paused ? "intake paused" : "intake enabled"} · ${projectRuns.filter((run) => run.outcome === "queued").length} queued`
+                            : "No projects registered. Start the runner to populate this view." }), project?.blocked && (_jsxs(Text, { color: "yellow", children: ["Blocked: ", project.blocked] })), projectRuns
+                        .slice(Math.max(0, runIndex - 1), runIndex + 2)
+                        .map((item) => (_jsxs(Text, { inverse: item.id === run?.id, children: [item.id === run?.id ? ">" : " ", " #", item.issue.number, " \u00B7 attempt", " ", item.attempt, " \u00B7 ", item.outcome, " \u00B7 ", item.phase] }, item.id))), project && projectRuns.length === 0 && (_jsx(Text, { children: "No runs yet. Eligible issues appear after polling." }))] }), run && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { bold: true, children: ["Run ", run.id] }), _jsx(Text, { children: run.issue.title }), run.error && _jsx(Text, { color: "red", children: run.error }), _jsxs(Text, { children: ["Validation:", " ", run.validation
+                                ?.map((check) => `${check.command}: exit ${check.exitCode}`)
+                                .join(" · ") || "No checks recorded"] }), _jsxs(Text, { children: ["Step/attempt event ", steps.length ? stepIndex + 1 : 0, "/", steps.length, ":", " ", selectedStep
+                                ? JSON.stringify(selectedStep.payload)
+                                : "No steps recorded"] }), _jsxs(Text, { bold: true, children: ["Agent sessions \u00B7 ", sessions.length] }), session ? (_jsxs(_Fragment, { children: [_jsxs(Text, { children: [session.step, " \u00B7 invocation ", session.attempt, " \u00B7", " ", session.outcome] }), _jsxs(Text, { children: ["Session: ", session.sessionId ?? session.sessionState] }), _jsxs(Text, { children: ["Requested: ", JSON.stringify(session.requested)] }), _jsxs(Text, { children: ["Effective: ", JSON.stringify(session.effective)] }), _jsxs(Text, { children: ["Log: ", session.log] })] })) : (_jsx(Text, { children: "No agent sessions recorded" })), log && _jsx(Text, { children: log })] })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: message }) }), _jsx(Text, { dimColor: true, children: "Closing this monitor leaves the runner and its tasks running." })] }));
+}

package/dist/src/workspace.d.ts

@@ -0,0 +1,16 @@
+import type { Project } from "./config.js";
+import { type Publication, type Snapshot, type Workspace } from "./domain.js";
+export declare class ExistingCheckout implements Workspace {
+    private readonly processDirectories;
+    private processDirectory;
+    private runGit;
+    private git;
+    check(project: Project): Promise<void>;
+    private assertNoOperation;
+    prepare(project: Project, branch: string, signal?: AbortSignal): Promise<Snapshot>;
+    inspect(project: Project): Promise<Snapshot>;
+    verify(project: Project, expected: Snapshot): Promise<void>;
+    commit(project: Project, expected: Snapshot, publication: Publication, runId: string, signal?: AbortSignal): Promise<string>;
+    push(project: Project, branch: string, head: string, signal?: AbortSignal): Promise<void>;
+    release(project: Project): Promise<void>;
+}