stageflow 0.1.0 → 0.2.0

package/README.md

@@ -12,6 +12,8 @@ Requires **Node.js ≥ 20**.
 npm i -g stageflow
 # or
 npx stageflow
+# or, from a packed tarball
+npm i -g ./stageflow-*.tgz
 ```
 
 `better-sqlite3` ships prebuilds for common platforms. `--ignore-scripts` is fine when a prebuild exists. Benign `node-gyp` warnings during install can be ignored if `require("better-sqlite3")` works.
@@ -31,6 +33,37 @@ sf run --task tasks/foo.yaml --pipeline <pipeline-id>
 
 Connect model providers in the console (Settings → Providers) or via `sf providers …`. Stageflow is a thin Pi shell: reuse an existing Pi login (`pi_home`) or store credentials in an SF-owned file (`sf_owned`). You do not need Pi CLI `/login` as a hard prerequisite.
 
+## Headless / CI
+
+The guest actor is the CLI (`sf` / `stageflow`). `sf ui` and MCP are not required in the job.
+
+```bash
+sf validate --strict --json
+```
+
+Validate exits `0` or `1` only (no waiting / `2`). It checks pipeline and stage YAML only; it does not prove provider auth, Task, or checkout.
+
+```bash
+sf providers login <providerId> --api-key-env <VAR>
+```
+
+If the provider also supports OAuth, pass `--type api_key`.
+
+```bash
+sf run --task tasks/foo.yaml --pipeline <pipeline-id> --json
+```
+
+The process exits `0` when the Run succeeded, `1` when it failed (including a busy start), and `2` when waiting. `sf run --json` prints one stdout document. `ok` is true only for `succeeded`. Busy has no `runId`.
+
+| outcome | ok | runId | exit |
+|---|---|---|---|
+| `succeeded` | true | present | `0` |
+| `failed` | false | present after start; omit when start never created a run | `1` |
+| `waiting` | false | present | `2` |
+| `busy` | false | omit | `1` |
+
+On a mixed Pipeline, default wait parks the Run (exit `2`). `--skip-gates` fails the Stage (exit `1`). A Pipeline with no HITL does not need the flag.
+
 ## State
 
 Runtime state lives in **`.stageflow/`** (SQLite + per-run workspaces under `.stageflow/runs/`). If `.stageflow` is missing and `.software-factory` exists from an older install, the next store open renames it to `.stageflow` once.

package/dist/cli/ciIdentity.d.ts

@@ -0,0 +1,14 @@
+export type CiIdentityFlags = {
+    gitSha?: string;
+    ciPrUrl?: string;
+    ciJobUrl?: string;
+};
+export type CiIdentity = {
+    gitSha?: string;
+    ciPrUrl?: string;
+    ciJobUrl?: string;
+};
+export declare function resolveCiIdentity(input: {
+    flags: CiIdentityFlags;
+    env: Record<string, string | undefined>;
+}): CiIdentity;

package/dist/cli/ciIdentity.js

@@ -0,0 +1,52 @@
+function nonempty(value) {
+    if (value === undefined)
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length === 0 ? undefined : trimmed;
+}
+function prNumberFromEnv(env) {
+    const ref = nonempty(env.GITHUB_REF);
+    if (ref !== undefined) {
+        const match = /^refs\/pull\/(\d+)\//.exec(ref);
+        if (match?.[1] !== undefined)
+            return match[1];
+    }
+    const refName = nonempty(env.GITHUB_REF_NAME);
+    if (refName !== undefined) {
+        const match = /^(\d+)\/merge$/.exec(refName);
+        if (match?.[1] !== undefined)
+            return match[1];
+    }
+    return undefined;
+}
+export function resolveCiIdentity(input) {
+    const result = {};
+    const gitSha = nonempty(input.flags.gitSha) ?? nonempty(input.env.GITHUB_SHA);
+    if (gitSha !== undefined)
+        result.gitSha = gitSha;
+    const flagPrUrl = nonempty(input.flags.ciPrUrl);
+    if (flagPrUrl !== undefined) {
+        result.ciPrUrl = flagPrUrl;
+    }
+    else {
+        const prNumber = prNumberFromEnv(input.env);
+        const server = nonempty(input.env.GITHUB_SERVER_URL);
+        const repo = nonempty(input.env.GITHUB_REPOSITORY);
+        if (prNumber !== undefined && server !== undefined && repo !== undefined) {
+            result.ciPrUrl = `${server}/${repo}/pull/${prNumber}`;
+        }
+    }
+    const flagJobUrl = nonempty(input.flags.ciJobUrl);
+    if (flagJobUrl !== undefined) {
+        result.ciJobUrl = flagJobUrl;
+    }
+    else {
+        const server = nonempty(input.env.GITHUB_SERVER_URL);
+        const repo = nonempty(input.env.GITHUB_REPOSITORY);
+        const runId = nonempty(input.env.GITHUB_RUN_ID);
+        if (server !== undefined && repo !== undefined && runId !== undefined) {
+            result.ciJobUrl = `${server}/${repo}/actions/runs/${runId}`;
+        }
+    }
+    return result;
+}

package/dist/cli/runCommand.d.ts

@@ -0,0 +1,24 @@
+import { type StartRunResult } from "../runtime/runManager.js";
+import { type CliRunReportIo } from "./runOutput.js";
+export declare const RUN_USAGE = "Usage:\n  sf run --task <path> --pipeline <name-or-path> [--checkout <path>] [--json] [--skip-gates] [--git-sha <sha>] [--ci-pr-url <url>] [--ci-job-url <url>]";
+export type RunCommandIo = CliRunReportIo;
+export type StartRunFn = (input: {
+    task: string;
+    pipeline: string;
+    checkoutOverride?: string;
+    skipGates?: boolean;
+    gitSha?: string;
+    ciPrUrl?: string;
+    ciJobUrl?: string;
+}) => Promise<StartRunResult>;
+export declare function completeCliRun(started: Extract<StartRunResult, {
+    ok: true;
+}>, io?: RunCommandIo, options?: {
+    json?: boolean;
+}): Promise<number>;
+export declare function runRunCommand(args: string[], options?: {
+    cwd?: string;
+    io?: Partial<RunCommandIo>;
+    startRun?: StartRunFn;
+    env?: Record<string, string | undefined>;
+}): Promise<number>;

package/dist/cli/runCommand.js

@@ -0,0 +1,168 @@
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { PiAgentAdapter } from "../agent/piAdapter.js";
+import { createRunStore } from "../runstore/createStore.js";
+import { PipelineValidationError } from "../runtime/pipelineRunner.js";
+import { RunManager } from "../runtime/runManager.js";
+import { readStageExecutionMode } from "../runtime/stageConcurrency.js";
+import { reportCliRun, } from "./runOutput.js";
+import { resolveCiIdentity } from "./ciIdentity.js";
+import { exitCodeForValidation, formatValidationHuman, formatValidationJson, } from "./validateOutput.js";
+export const RUN_USAGE = `Usage:
+  sf run --task <path> --pipeline <name-or-path> [--checkout <path>] [--json] [--skip-gates] [--git-sha <sha>] [--ci-pr-url <url>] [--ci-job-url <url>]`;
+const defaultIo = {
+    log: (line) => console.log(line),
+    error: (line) => console.error(line),
+};
+function parseRunArgs(args) {
+    if (args.length === 0) {
+        return { help: false, json: false, skipGates: false };
+    }
+    if (args[0] === "--help" || args[0] === "-h") {
+        return { help: true, json: false, skipGates: false };
+    }
+    let task;
+    let pipeline;
+    let checkout;
+    let gitSha;
+    let ciPrUrl;
+    let ciJobUrl;
+    let json = false;
+    let skipGates = false;
+    let help = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--help" || arg === "-h") {
+            help = true;
+        }
+        else if (arg === "--task") {
+            const value = args[++i];
+            if (value === undefined || value.length === 0) {
+                throw new Error("Missing value for --task");
+            }
+            task = value;
+        }
+        else if (arg === "--pipeline") {
+            const value = args[++i];
+            if (value === undefined || value.length === 0) {
+                throw new Error("Missing value for --pipeline");
+            }
+            pipeline = value;
+        }
+        else if (arg === "--checkout") {
+            const value = args[++i];
+            if (value === undefined || value.length === 0) {
+                throw new Error("Missing value for --checkout");
+            }
+            checkout = value;
+        }
+        else if (arg === "--git-sha") {
+            const value = args[++i];
+            if (value === undefined || value.length === 0) {
+                throw new Error("Missing value for --git-sha");
+            }
+            gitSha = value;
+        }
+        else if (arg === "--ci-pr-url") {
+            const value = args[++i];
+            if (value === undefined || value.length === 0) {
+                throw new Error("Missing value for --ci-pr-url");
+            }
+            ciPrUrl = value;
+        }
+        else if (arg === "--ci-job-url") {
+            const value = args[++i];
+            if (value === undefined || value.length === 0) {
+                throw new Error("Missing value for --ci-job-url");
+            }
+            ciJobUrl = value;
+        }
+        else if (arg === "--json") {
+            json = true;
+        }
+        else if (arg === "--skip-gates") {
+            skipGates = true;
+        }
+        else if (arg.startsWith("-")) {
+            throw new Error(`Unknown flag: ${arg}`);
+        }
+        else {
+            throw new Error(`Unexpected argument: ${arg}`);
+        }
+    }
+    return { help, json, skipGates, task, pipeline, checkout, gitSha, ciPrUrl, ciJobUrl };
+}
+function defaultStartRun(cwd) {
+    return async (input) => {
+        const store = createRunStore({ rootDir: cwd });
+        const manager = new RunManager({
+            agent: new PiAgentAdapter(),
+            store,
+            cwd,
+            operatorCatalog: { cwd, agentDir: getAgentDir() },
+            executionMode: readStageExecutionMode(process.env, "process"),
+        });
+        return manager.startRun(input);
+    };
+}
+export async function completeCliRun(started, io = defaultIo, options = {}) {
+    const result = await started.done;
+    return reportCliRun({ kind: "completion", result }, { json: options.json, io });
+}
+export async function runRunCommand(args, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const out = { ...defaultIo, ...options.io };
+    let parsed;
+    try {
+        parsed = parseRunArgs(args);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        out.error(message);
+        out.error(RUN_USAGE);
+        return 1;
+    }
+    if (parsed.help) {
+        out.error(RUN_USAGE);
+        return 0;
+    }
+    if (!parsed.task || !parsed.pipeline) {
+        out.error("Missing --task and/or --pipeline");
+        out.error(RUN_USAGE);
+        return 1;
+    }
+    const startRun = options.startRun ?? defaultStartRun(cwd);
+    const identity = resolveCiIdentity({
+        flags: {
+            gitSha: parsed.gitSha,
+            ciPrUrl: parsed.ciPrUrl,
+            ciJobUrl: parsed.ciJobUrl,
+        },
+        env: options.env ?? process.env,
+    });
+    try {
+        const started = await startRun({
+            task: parsed.task,
+            pipeline: parsed.pipeline,
+            checkoutOverride: parsed.checkout,
+            ...(parsed.skipGates ? { skipGates: true } : {}),
+            ...identity,
+        });
+        if (!started.ok) {
+            return reportCliRun({ kind: "start-failure", started }, { json: parsed.json, io: out });
+        }
+        return completeCliRun(started, out, { json: parsed.json });
+    }
+    catch (err) {
+        if (err instanceof PipelineValidationError) {
+            if (parsed.json) {
+                out.log(formatValidationJson(err.result));
+            }
+            else {
+                out.error(formatValidationHuman(err.result));
+            }
+            return exitCodeForValidation(err.result);
+        }
+        out.error(err instanceof Error ? err.message : String(err));
+        return 1;
+    }
+}

package/dist/cli/runOutput.d.ts

@@ -0,0 +1,19 @@
+import type { PipelineRunResult } from "../runtime/pipelineRunner.js";
+import type { StartRunResult } from "../runtime/runManager.js";
+export type CliRunReportIo = {
+    log: (line: string) => void;
+    error: (line: string) => void;
+};
+export type CliRunReportEvent = {
+    kind: "start-failure";
+    started: Extract<StartRunResult, {
+        ok: false;
+    }>;
+} | {
+    kind: "completion";
+    result: PipelineRunResult;
+};
+export declare function reportCliRun(event: CliRunReportEvent, options: {
+    json?: boolean;
+    io: CliRunReportIo;
+}): number;

package/dist/cli/runOutput.js

@@ -0,0 +1,125 @@
+function stringify(payload) {
+    return JSON.stringify(payload, null, 2);
+}
+function isBusyCode(code) {
+    return code === "busy_capacity" || code === "busy_checkout";
+}
+function formatRunBusyJson(started) {
+    const payload = {
+        ok: false,
+        outcome: "busy",
+    };
+    if (started.code !== undefined)
+        payload.code = started.code;
+    payload.reason = started.reason;
+    if (started.activeCount !== undefined)
+        payload.activeCount = started.activeCount;
+    if (started.maxConcurrent !== undefined) {
+        payload.maxConcurrent = started.maxConcurrent;
+    }
+    if (started.activeRunIds !== undefined) {
+        payload.activeRunIds = started.activeRunIds;
+    }
+    if (started.conflictingRunId !== undefined) {
+        payload.conflictingRunId = started.conflictingRunId;
+    }
+    if (started.conflictingCheckout !== undefined) {
+        payload.conflictingCheckout = started.conflictingCheckout;
+    }
+    return stringify(payload);
+}
+function formatRunStartFailedJson(started) {
+    const payload = {
+        ok: false,
+        outcome: "failed",
+        reason: started.reason,
+    };
+    if (started.code !== undefined)
+        payload.code = started.code;
+    return stringify(payload);
+}
+function formatStartFailureJson(started) {
+    if (isBusyCode(started.code)) {
+        return formatRunBusyJson(started);
+    }
+    return formatRunStartFailedJson(started);
+}
+function formatRunCompletionJson(result) {
+    if (result.outcome === "succeeded") {
+        return stringify({
+            ok: true,
+            outcome: "succeeded",
+            runId: result.runId,
+            runDir: result.runDir,
+        });
+    }
+    if (result.outcome === "waiting") {
+        return stringify({
+            ok: false,
+            outcome: "waiting",
+            runId: result.runId,
+            runDir: result.runDir,
+        });
+    }
+    const payload = {
+        ok: false,
+        outcome: "failed",
+        runId: result.runId,
+        runDir: result.runDir,
+    };
+    if (result.reason !== undefined)
+        payload.reason = result.reason;
+    return stringify(payload);
+}
+function writeStartFailureHuman(started, io) {
+    const code = started.code ?? "error";
+    io.error(`${code}: ${started.reason}`);
+    if (started.conflictingRunId !== undefined) {
+        io.error(`conflictingRunId: ${started.conflictingRunId}`);
+    }
+    if (started.conflictingCheckout !== undefined) {
+        io.error(`conflictingCheckout: ${started.conflictingCheckout}`);
+    }
+}
+function writeCompletionHuman(result, io) {
+    switch (result.outcome) {
+        case "waiting":
+            io.error(`Pipeline waiting. Run folder: ${result.runDir} (${result.runId})`);
+            return;
+        case "failed":
+            io.error(`Pipeline failed: ${result.reason}`);
+            io.error(`Run folder: ${result.runDir}`);
+            return;
+        case "succeeded":
+            io.log(`Pipeline succeeded. Run folder: ${result.runDir}`);
+            return;
+    }
+}
+function exitCodeForRunOutcome(outcome) {
+    switch (outcome) {
+        case "succeeded":
+            return 0;
+        case "waiting":
+            return 2;
+        case "failed":
+            return 1;
+    }
+}
+export function reportCliRun(event, options) {
+    if (event.kind === "start-failure") {
+        if (options.json) {
+            options.io.log(formatStartFailureJson(event.started));
+        }
+        else {
+            writeStartFailureHuman(event.started, options.io);
+        }
+        return 1;
+    }
+    if (options.json) {
+        options.io.log(formatRunCompletionJson(event.result));
+    }
+    else {
+        writeCompletionHuman(event.result, options.io);
+    }
+    return exitCodeForRunOutcome(event.result.outcome);
+}

package/dist/cli.d.ts

@@ -1,2 +1,12 @@
 #!/usr/bin/env node
-export {};
+import type { OperatorCatalog } from "./runtime/stageAttemptBootstrap.js";
+export declare function parseRunStageArgs(argv: string[]): {
+    runId: string;
+    stageId: string;
+    mode?: "run" | "resume";
+    resumeAnswer?: unknown;
+    attempt?: number;
+    sessionFilePath?: string;
+    operatorCatalog?: OperatorCatalog;
+    skipGates?: boolean;
+};

package/dist/cli.js

@@ -1,19 +1,18 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { realpathSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { PiAgentAdapter } from "./agent/piAdapter.js";
 import { PROVIDERS_USAGE, runProvidersCommand } from "./cli/providersCommand.js";
+import { RUN_USAGE, runRunCommand } from "./cli/runCommand.js";
 import { VALIDATE_USAGE, runValidateCommand } from "./cli/validateCommand.js";
-import { exitCodeForValidation, formatValidationHuman, } from "./cli/validateOutput.js";
 import { createRunStore } from "./runstore/createStore.js";
-import { PipelineValidationError } from "./runtime/pipelineRunner.js";
-import { RunManager } from "./runtime/runManager.js";
-import { readStageExecutionMode } from "./runtime/stageConcurrency.js";
 import { exitForOutcome, runStageWorker } from "./runtime/stageWorker.js";
 import { SF_STAGE_WORKER } from "./runtime/stageWorkerProtocol.js";
 import { DEFAULT_PORT, startUiServer } from "./server/http.js";
 const USAGE = `Usage:
-  sf run --task <path> --pipeline <name-or-path> [--checkout <path>]
+  sf run --task <path> --pipeline <name-or-path> [--checkout <path>] [--json] [--skip-gates] [--git-sha <sha>] [--ci-pr-url <url>] [--ci-job-url <url>]
   sf validate [--pipeline <name-or-path>] [--strict] [--json]
   sf ui [--port ${DEFAULT_PORT}]
   sf providers list
@@ -28,6 +27,8 @@ Stageflow (sf) runs YAML-defined automatic stage pipelines.
 
 Store backend: SF_STORE=sqlite only. SF_STORE=disk is rejected; disk-era .stageflow/runs trees import when the SQLite store is empty. Data under .stageflow/.
 
+${RUN_USAGE}
+
 ${VALIDATE_USAGE}
 
 ${PROVIDERS_USAGE}`;
@@ -41,7 +42,9 @@ function parseArgs(argv) {
         return { help: true };
     }
     const command = args[0];
-    if (command === "providers" || command === "validate") {
+    if (command === "providers" ||
+        command === "validate" ||
+        command === "run") {
         return { help: false, command };
     }
     if (args.includes("--help") || args.includes("-h")) {
@@ -75,7 +78,7 @@ function parseArgs(argv) {
     }
     return { help: false, command, task, pipeline, port, checkout };
 }
-function parseRunStageArgs(argv) {
+export function parseRunStageArgs(argv) {
     let runId;
     let stageId;
     let mode;
@@ -83,6 +86,7 @@ function parseRunStageArgs(argv) {
     let attempt;
     let sessionFilePath;
     let operatorAgentDir;
+    let skipGates = false;
     for (let i = 0; i < argv.length; i++) {
         if (argv[i] === "--run-id") {
             runId = argv[++i];
@@ -132,6 +136,9 @@ function parseRunStageArgs(argv) {
                 throw new Error("Missing value for --operator-agent-dir");
             }
         }
+        else if (argv[i] === "--skip-gates") {
+            skipGates = true;
+        }
     }
     if (!runId || !stageId) {
         throw new Error("Missing --run-id and/or --stage-id");
@@ -143,6 +150,7 @@ function parseRunStageArgs(argv) {
         resumeAnswer,
         attempt,
         sessionFilePath,
+        skipGates,
         ...(operatorAgentDir !== undefined
             ? { operatorCatalog: { cwd: process.cwd(), agentDir: operatorAgentDir } }
             : {}),
@@ -163,6 +171,7 @@ async function handleInternalRunStage(argv) {
         attempt: parsed.attempt,
         sessionFilePath: parsed.sessionFilePath,
         operatorCatalog: parsed.operatorCatalog,
+        skipGates: parsed.skipGates,
     });
     exitForOutcome(outcome);
 }
@@ -189,6 +198,9 @@ async function main(argv) {
         if (parsed.command === "validate") {
             return runValidateCommand(argv.slice(3), { cwd: rootDir });
         }
+        if (parsed.command === "run") {
+            return runRunCommand(argv.slice(3), { cwd: rootDir });
+        }
         if (parsed.command === "providers") {
             return runProvidersCommand(argv.slice(3), rootDir);
         }
@@ -214,60 +226,31 @@ async function main(argv) {
             }
             return handleInternalRunStage(subArgs.slice(1));
         }
-        if (parsed.command !== "run") {
-            console.error(`Unknown command: ${parsed.command}`);
-            console.error(USAGE);
-            return 1;
-        }
-        if (!parsed.task || !parsed.pipeline) {
-            console.error("Missing --task and/or --pipeline");
-            console.error(USAGE);
-            return 1;
-        }
-        const manager = new RunManager({
-            agent: new PiAgentAdapter(),
-            store,
-            cwd: rootDir,
-            operatorCatalog: { cwd: rootDir, agentDir: getAgentDir() },
-            executionMode: readStageExecutionMode(process.env, "process"),
-        });
-        const started = await manager.startRun({
-            task: parsed.task,
-            pipeline: parsed.pipeline,
-            checkoutOverride: parsed.checkout,
-        });
-        if (!started.ok) {
-            const code = started.code ?? "error";
-            console.error(`${code}: ${started.reason}`);
-            if (started.conflictingRunId !== undefined) {
-                console.error(`conflictingRunId: ${started.conflictingRunId}`);
-            }
-            if (started.conflictingCheckout !== undefined) {
-                console.error(`conflictingCheckout: ${started.conflictingCheckout}`);
-            }
-            return started.status ?? 1;
-        }
-        const result = await started.done;
-        if (result.ok) {
-            console.log(`Pipeline succeeded. Run folder: ${result.runDir}`);
-            return 0;
-        }
-        console.error(`Pipeline failed: ${result.reason}`);
-        console.error(`Run folder: ${result.runDir}`);
+        console.error(`Unknown command: ${parsed.command}`);
+        console.error(USAGE);
         return 1;
     }
     catch (err) {
-        if (err instanceof PipelineValidationError) {
-            console.error(formatValidationHuman(err.result));
-            return exitCodeForValidation(err.result);
-        }
         console.error(err instanceof Error ? err.message : String(err));
         return 1;
     }
 }
-main(process.argv)
-    .then((code) => process.exit(code))
-    .catch((err) => {
-    console.error(err instanceof Error ? err.message : String(err));
-    process.exit(1);
-});
+function isDirectCliInvocation() {
+    const self = fileURLToPath(import.meta.url);
+    return process.argv.slice(1).some((arg) => {
+        try {
+            return realpathSync(path.resolve(arg)) === realpathSync(self);
+        }
+        catch {
+            return false;
+        }
+    });
+}
+if (isDirectCliInvocation()) {
+    main(process.argv)
+        .then((code) => process.exit(code))
+        .catch((err) => {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    });
+}

package/dist/mcp/server.js

@@ -4,7 +4,7 @@ import { registerMcpTools } from "./tools.js";
 export function createStageflowMcpServer(deps) {
     const server = new McpServer({
         name: "stageflow",
-        version: "0.1.0",
+        version: "0.2.0",
     });
     registerMcpTools(server, deps);
     return server;

package/dist/runstore/port.d.ts

@@ -36,6 +36,9 @@ export type RunMeta = {
     task_id?: string;
     updated_at?: string;
     checkout_root?: string;
+    git_sha?: string;
+    ci_pr_url?: string;
+    ci_job_url?: string;
     pipeline_dag?: RunPipelineDagSnapshot;
 };
 export type CreatedRun = {
@@ -108,6 +111,9 @@ export type CreateRunInput = {
     taskYaml: string;
     taskId?: string;
     checkoutRoot?: string;
+    gitSha?: string;
+    ciPrUrl?: string;
+    ciJobUrl?: string;
     pipelineDag?: RunPipelineDagSnapshot;
 };
 /**