runling 0.1.1

package/dist/src/runner.js

@@ -0,0 +1,200 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { cli } from "./cli.js";
+import { observeRunlingEvents, } from "./events.js";
+import { log } from "./log.js";
+import { renderMarkdown } from "./markdown.js";
+import { createRunling, } from "./runtime.js";
+import { TuiReporter } from "./tui.js";
+import { isWorkflow } from "./workflow.js";
+import { formatTokenUsage, getRecordedTokenUsage, resetTokenUsage, totalTokens, withTokenUsage, } from "./usage.js";
+export function formatDuration(ms) {
+    if (ms < 1000) {
+        return `${Math.round(ms)}ms`;
+    }
+    const tenths = Math.round(ms / 100);
+    if (tenths < 600) {
+        return `${(tenths / 10).toFixed(1)}s`;
+    }
+    // Round before splitting the duration so seconds cannot render as `60s`.
+    const totalSeconds = Math.round(ms / 1000);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const parts = [];
+    if (hours > 0)
+        parts.push(`${hours}h`);
+    if (minutes > 0)
+        parts.push(`${minutes}m`);
+    if (seconds > 0)
+        parts.push(`${seconds}s`);
+    return parts.join("") || "0s";
+}
+export function formatWorkflowDetails(details, terminal = process.stdout) {
+    return terminal.isTTY
+        ? renderMarkdown(details, terminal.columns ?? 80)
+        : details;
+}
+function isJsonValue(value, ancestors = new Set()) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean") {
+        return true;
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value);
+    }
+    if (typeof value !== "object" || ancestors.has(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (!Array.isArray(value) &&
+        prototype !== Object.prototype &&
+        prototype !== null) {
+        return false;
+    }
+    ancestors.add(value);
+    // JSON omits undefined object properties. Array entries must remain valid values.
+    const valid = Object.values(value).every((entry) => (entry === undefined && !Array.isArray(value)) || isJsonValue(entry, ancestors));
+    ancestors.delete(value);
+    return valid;
+}
+export function normalizeWorkflowResult(value) {
+    if (value === undefined) {
+        return null;
+    }
+    if (!isJsonValue(value)) {
+        throw new Error("Workflow output must be valid JSON");
+    }
+    if (typeof value === "string") {
+        return { summary: value };
+    }
+    if (typeof value === "object" && value !== null) {
+        const candidate = value;
+        if (typeof candidate.summary === "string" &&
+            (candidate.details === undefined ||
+                typeof candidate.details === "string") &&
+            (candidate.outputs === undefined ||
+                (isJsonValue(candidate.outputs) && !Array.isArray(candidate.outputs)))) {
+            return candidate;
+        }
+    }
+    return { summary: "Workflow completed", outputs: { value } };
+}
+export async function executeWorkflow(run, f, options = {}) {
+    return reportExecution(() => log.indented(() => run(f)), options);
+}
+/** Run a workflow without assuming a terminal, printing, or changing process state. */
+export async function runWorkflow(run, { cwd = process.cwd(), input, verbose = false, onInput, onEvent = () => { }, }) {
+    const f = createRunling({
+        cwd,
+        prompt: typeof input === "string" ? input : "",
+        verbose,
+        handleInput: onInput,
+    });
+    return observeRunlingEvents(onEvent, () => log.withDestination("silent", () => captureExecution(() => log.indented(() => run(f, input)))));
+}
+async function reportExecution(run, { json = false, presentation = "log", terminal = process.stdout, title = "Workflow", } = {}) {
+    const reporter = presentation === "tui" ? new TuiReporter(title) : undefined;
+    try {
+        reporter?.start();
+        const execution = await observeRunlingEvents(reporter?.handle ?? (() => { }), () => log.withDestination(presentation === "tui" ? "silent" : json ? "stderr" : "stdout", async () => {
+            if (presentation === "log")
+                log.info("Runling starting");
+            const execution = await captureExecution(() => run({ handleInput: reporter?.input }));
+            if (execution.error !== null) {
+                log.error(execution.error);
+                process.exitCode = 1;
+            }
+            else if (!json && execution.result !== null) {
+                if (presentation === "log") {
+                    log.success(execution.result.summary);
+                    if (execution.result.details !== undefined) {
+                        console.log(`\n${formatWorkflowDetails(execution.result.details, terminal)}\n`);
+                    }
+                }
+            }
+            if (presentation === "log" && totalTokens(execution.usage) > 0) {
+                log.info(`Total token usage: ${formatTokenUsage(execution.usage)}`);
+            }
+            if (presentation === "log") {
+                log.info(`Finished in ${formatDuration(execution.durationMs)}`);
+            }
+            return execution;
+        }));
+        reporter?.finish(execution);
+        if (json)
+            console.log(JSON.stringify(execution));
+        return execution;
+    }
+    finally {
+        reporter?.stop();
+    }
+}
+async function captureExecution(run) {
+    return withTokenUsage(() => captureExecutionInContext(run));
+}
+async function captureExecutionInContext(run) {
+    resetTokenUsage();
+    const start = performance.now();
+    let result = null;
+    let output = null;
+    let error = null;
+    try {
+        const value = await run();
+        result = normalizeWorkflowResult(value);
+        output = value ?? null;
+    }
+    catch (cause) {
+        error = cause instanceof Error ? cause.message : String(cause);
+    }
+    const usage = getRecordedTokenUsage();
+    const durationMs = performance.now() - start;
+    return {
+        durationMs,
+        usage,
+        output,
+        result,
+        error,
+        ok: error === null,
+    };
+}
+export async function loadWorkflow(path) {
+    const resolvedPath = resolve(path);
+    const module = await import(__rewriteRelativeImportExtension(/* @vite-ignore */ pathToFileURL(resolvedPath).href));
+    if (!isWorkflow(module.default)) {
+        throw new Error(`Workflow ${resolvedPath} must have a schemaful default workflow export`);
+    }
+    return module.default;
+}
+export async function runRunling(argv = process.argv.slice(2)) {
+    const json = argv.includes("--json");
+    const presentation = shouldUseTui(argv) ? "tui" : "log";
+    const title = argv.find((argument) => !argument.startsWith("-")) ?? "Workflow";
+    await reportExecution(async ({ handleInput }) => {
+        const { workflowPath, prompt, verbose } = cli(argv, "runling");
+        const cwd = process.cwd();
+        const run = await loadWorkflow(workflowPath);
+        const f = createRunling({ cwd, prompt, verbose, handleInput });
+        return log.indented(() => run(f, prompt));
+    }, { json, presentation, title });
+}
+export function shouldUseTui(argv, terminal = {
+    stdinIsTTY: process.stdin.isTTY,
+    stdoutIsTTY: process.stdout.isTTY,
+}) {
+    return (terminal.stdinIsTTY === true &&
+        terminal.stdoutIsTTY === true &&
+        !argv.includes("--json") &&
+        !argv.includes("--log") &&
+        !argv.includes("--verbose") &&
+        !argv.includes("-v"));
+}

package/dist/src/runtime.d.ts

@@ -0,0 +1,62 @@
+import { AgentOutcomeError, type AgentOptions, type RunAgentOptions } from "./agent.ts";
+import { randomId } from "./id.ts";
+import { type Input, type InputHandler } from "./input.ts";
+import { createShell, createExec, CommandError, type Shell, type Exec } from "./shell.ts";
+import { step } from "./step.ts";
+import { concat } from "./utils.ts";
+interface RunlingValues {
+    cwd: string;
+    prompt: string;
+    verbose: boolean;
+}
+export interface CreateRunlingOptions extends RunlingValues {
+    handleInput?: InputHandler;
+}
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export interface WorkflowResult {
+    summary: string;
+    /** Human-readable Markdown shown after the summary in interactive mode. */
+    details?: string;
+    outputs?: Record<string, JsonValue>;
+}
+export type WorkflowReturn = WorkflowResult | JsonValue | undefined | void;
+declare function agent(this: RunlingValues, options: AgentOptions): Promise<import("./agent.ts").RunlingAgent>;
+declare function runAgent(this: RunlingValues, prompt: string, options: RunAgentOptions): Promise<import("./agent.ts").AgentResult>;
+declare function getPwd(this: RunlingValues, cwd?: string): Promise<import("./git.ts").WorkingDirectory>;
+declare function workingTreeHash(this: RunlingValues, cwd?: string): Promise<string>;
+declare const runlingPrimitives: Readonly<{
+    agent: typeof agent;
+    AgentOutcomeError: typeof AgentOutcomeError;
+    runAgent: typeof runAgent;
+    getPwd: typeof getPwd;
+    workingTreeHash: typeof workingTreeHash;
+    randomId: typeof randomId;
+    log: {
+        level: import("./log.ts").LogLevel;
+        debug: (message: string) => void;
+        info: (message: string) => void;
+        success: (message: string) => void;
+        error: (message: string) => void;
+        colorize(text: string): string;
+        highlight: (text: string, color?: string) => string;
+        withColor<T>(color: string, work: import("./log.ts").LoggedWork<T>): T;
+        withDestination<T>(destination: "stdout" | "stderr" | "silent", work: import("./log.ts").LoggedWork<T>): T;
+        indented<T>(work: import("./log.ts").LoggedWork<T>): T;
+    };
+    step: typeof step;
+    createShell: typeof createShell;
+    createExec: typeof createExec;
+    CommandError: typeof CommandError;
+    ShellError: typeof CommandError;
+    concat: typeof concat;
+}>;
+type RunlingPrimitives = typeof runlingPrimitives;
+export type Runling = RunlingPrimitives & RunlingValues & {
+    readonly input: Input;
+    readonly shell: Shell;
+    readonly exec: Exec;
+};
+export declare function createRunling({ handleInput, ...values }: CreateRunlingOptions): Runling;
+export {};

package/dist/src/runtime.js

@@ -0,0 +1,44 @@
+import { agent as createAgent, AgentOutcomeError, runAgent as runAgentOnce, } from "./agent.js";
+import { getPwd as captureWorkingDirectory, workingTreeHash as hashWorkingTree, } from "./git.js";
+import { randomId } from "./id.js";
+import { createInput } from "./input.js";
+import { log } from "./log.js";
+import { createShell, createExec, CommandError, ShellError, } from "./shell.js";
+import { step } from "./step.js";
+import { concat } from "./utils.js";
+function agent(options) {
+    return createAgent({ ...options, cwd: options.cwd ?? this.cwd });
+}
+function runAgent(prompt, options) {
+    return runAgentOnce(prompt, { ...options, cwd: options.cwd ?? this.cwd });
+}
+function getPwd(cwd = this.cwd) {
+    return captureWorkingDirectory(cwd);
+}
+function workingTreeHash(cwd = this.cwd) {
+    return hashWorkingTree(cwd);
+}
+const runlingPrimitives = Object.freeze({
+    agent,
+    AgentOutcomeError,
+    runAgent,
+    getPwd,
+    workingTreeHash,
+    randomId,
+    log,
+    step,
+    createShell,
+    createExec,
+    CommandError,
+    ShellError,
+    concat,
+});
+export function createRunling({ handleInput, ...values }) {
+    return Object.freeze({
+        ...runlingPrimitives,
+        ...values,
+        input: createInput(handleInput),
+        shell: createShell({ verbose: values.verbose }),
+        exec: createExec({ verbose: values.verbose }),
+    });
+}

package/dist/src/schema.d.ts

@@ -0,0 +1,3 @@
+import type { TSchema } from "typebox";
+/** Validate an object schema against the JSON Schema 2020-12 meta-schema. */
+export declare function isWorkflowSchema(value: unknown): value is TSchema;

package/dist/src/schema.js

@@ -0,0 +1,17 @@
+import Ajv2020 from "ajv/dist/2020.js";
+const validator = new Ajv2020({
+    strict: false,
+    validateFormats: false,
+});
+/** Validate an object schema against the JSON Schema 2020-12 meta-schema. */
+export function isWorkflowSchema(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    try {
+        return validator.validateSchema(value) === true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/shell.d.ts

@@ -0,0 +1,47 @@
+import { ExecaError, type Options, type TemplateExpression } from "execa";
+export interface ShellOutput {
+    stdout: Buffer;
+    stderr: Buffer;
+    exitCode: number;
+}
+export { ExecaError as ShellError, ExecaError as CommandError };
+type ProcessResult = {
+    stdout?: unknown;
+    stderr?: unknown;
+    exitCode?: number;
+};
+type ShellExpression = string | number | boolean | null | undefined | {
+    raw: string;
+} | readonly ShellExpression[];
+type ShellArguments = [TemplateStringsArray, ...ShellExpression[]];
+/** A configurable, single-execution Execa command with buffered output. */
+export declare class Command implements PromiseLike<ShellOutput> {
+    private readonly launch;
+    private execution?;
+    private directory?;
+    private silent;
+    private throwOnError;
+    constructor(launch: (options: Options) => PromiseLike<ProcessResult>);
+    cwd(path: string): this;
+    quiet(value?: boolean): this;
+    nothrow(): this;
+    then<TResult1 = ShellOutput, TResult2 = never>(fulfilled?: ((value: ShellOutput) => TResult1 | PromiseLike<TResult1>) | null, rejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    text(): Promise<string>;
+    json(): Promise<any>;
+    private run;
+}
+export interface CreateShellOptions {
+    verbose?: boolean;
+    cwd?: string;
+}
+export { Command as ShellCommand };
+export declare function createShell(options?: CreateShellOptions): (this: {
+    cwd?: string;
+} | void, ...args: ShellArguments) => Command;
+/** Execute a program directly. Execa parses the template without a shell. */
+export declare function createExec(options?: CreateShellOptions): (this: {
+    cwd?: string;
+} | void, strings: TemplateStringsArray, ...expressions: TemplateExpression[]) => Command;
+export type Exec = ReturnType<typeof createExec>;
+export type CreateExecOptions = CreateShellOptions;
+export type Shell = ReturnType<typeof createShell>;

package/dist/src/shell.js

@@ -0,0 +1,170 @@
+import { emitRunlingEvent } from "./events.js";
+import { log, logCommand } from "./log.js";
+import { execa, ExecaError, } from "execa";
+const COMMAND_COLOR = "#ae3ec9";
+const COMMAND_PREVIEW_LENGTH = 200;
+export { ExecaError as ShellError, ExecaError as CommandError };
+/** A configurable, single-execution Execa command with buffered output. */
+export class Command {
+    launch;
+    execution;
+    directory;
+    silent = true;
+    throwOnError = true;
+    constructor(launch) {
+        this.launch = launch;
+    }
+    cwd(path) {
+        this.directory = path;
+        return this;
+    }
+    quiet(value = true) {
+        this.silent = value;
+        return this;
+    }
+    nothrow() {
+        this.throwOnError = false;
+        return this;
+    }
+    then(fulfilled, rejected) {
+        return this.run().then(fulfilled, rejected);
+    }
+    async text() {
+        return (await this).stdout.toString();
+    }
+    async json() {
+        return JSON.parse(await this.text());
+    }
+    run() {
+        return (this.execution ??= Promise.resolve().then(async () => {
+            try {
+                const output = await this.launch({
+                    cwd: this.directory,
+                    encoding: "buffer",
+                    stripFinalNewline: false,
+                    reject: this.throwOnError,
+                    stdin: "ignore",
+                    stdout: this.silent ? "pipe" : ["pipe", "inherit"],
+                    stderr: this.silent ? "pipe" : ["pipe", "inherit"],
+                    preferLocal: true,
+                });
+                return {
+                    ...output,
+                    stdout: toBuffer(output.stdout),
+                    stderr: toBuffer(output.stderr),
+                    exitCode: output.exitCode ?? 1,
+                };
+            }
+            catch (error) {
+                if (error instanceof ExecaError) {
+                    Object.assign(error, {
+                        stdout: toBuffer(error.stdout),
+                        stderr: toBuffer(error.stderr),
+                    });
+                }
+                throw error;
+            }
+        }));
+    }
+}
+export { Command as ShellCommand };
+export function createShell(options = {}) {
+    return function (...args) {
+        const [strings, ...expressions] = args;
+        const command = strings
+            .map((part, index) => part +
+            (index < expressions.length
+                ? formatExpression(expressions[index])
+                : ""))
+            .join("");
+        return track(new Command((config) => execa("sh", ["-c", command], config)), formatCommand(...args), options, this?.cwd);
+    };
+}
+/** Execute a program directly. Execa parses the template without a shell. */
+export function createExec(options = {}) {
+    return function (strings, ...expressions) {
+        const preview = strings
+            .map((part, index) => part +
+            (index < expressions.length
+                ? JSON.stringify(expressions[index])
+                : ""))
+            .join("");
+        return track(new Command((config) => execa(config)(strings, ...expressions)), truncateCommand(preview), options, this?.cwd);
+    };
+}
+function track(command, formattedCommand, options, contextCwd) {
+    const id = crypto.randomUUID();
+    const startedAt = performance.now();
+    emitRunlingEvent({
+        type: "command.started",
+        id,
+        command: formattedCommand,
+    });
+    logCommand(id, `${log.highlight("Running", COMMAND_COLOR)} ${formattedCommand}`);
+    command.quiet(!(options.verbose ?? false));
+    const cwd = options.cwd ?? contextCwd;
+    const configured = cwd === undefined ? command : command.cwd(cwd);
+    queueMicrotask(() => {
+        void configured.then((output) => emitRunlingEvent({
+            type: "command.finished",
+            id,
+            status: output.exitCode === 0 ? "completed" : "failed",
+            durationMs: performance.now() - startedAt,
+            output: shellOutput(output),
+        }), (error) => emitRunlingEvent({
+            type: "command.finished",
+            id,
+            status: "failed",
+            durationMs: performance.now() - startedAt,
+            output: shellOutput(error),
+        }));
+    });
+    return configured;
+}
+const shellOutput = (value) => {
+    if (typeof value !== "object" || value === null) {
+        return { stdout: "", stderr: "" };
+    }
+    const output = value;
+    return {
+        stdout: bufferText(output.stdout),
+        stderr: bufferText(output.stderr),
+    };
+};
+const bufferText = (value) => value instanceof Uint8Array ? new TextDecoder().decode(value) : "";
+const toBuffer = (value) => value instanceof Uint8Array
+    ? Buffer.from(value)
+    : Buffer.from(typeof value === "string" ? value : "");
+function formatCommand(...[strings, ...expressions]) {
+    const command = strings
+        .map((part, index) => {
+        const expression = expressions[index];
+        return expression === undefined
+            ? part
+            : `${part}${formatExpression(expression)}`;
+    })
+        .join("")
+        .trim()
+        .replaceAll("\n", " ");
+    return truncateCommand(command);
+}
+function truncateCommand(value) {
+    const command = value.trim().replaceAll("\n", " ");
+    if (command.length <= COMMAND_PREVIEW_LENGTH)
+        return command;
+    return `${command.slice(0, COMMAND_PREVIEW_LENGTH)}… (${(command.length - COMMAND_PREVIEW_LENGTH).toLocaleString()} characters omitted)`;
+}
+function formatExpression(expression) {
+    if (Array.isArray(expression)) {
+        return expression.map(formatExpression).join(" ");
+    }
+    if (typeof expression === "object" &&
+        expression !== null &&
+        "raw" in expression) {
+        return String(expression.raw);
+    }
+    const value = String(expression ?? "");
+    if (/^[a-zA-Z0-9_./:@%+=,-]+$/.test(value))
+        return value;
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}

package/dist/src/step.d.ts

@@ -0,0 +1,5 @@
+export type StepWork<T> = () => T;
+/**
+ * Runs a named workflow step, indenting any log output produced by its work.
+ */
+export declare function step<T>(label: string, work: StepWork<T>): T;

package/dist/src/step.js

@@ -0,0 +1,39 @@
+import { emitRunlingEvent, withRunlingActivity, } from "./events.js";
+import { log, logStep } from "./log.js";
+/**
+ * Runs a named workflow step, indenting any log output produced by its work.
+ */
+export function step(label, work) {
+    const id = crypto.randomUUID();
+    const startedAt = performance.now();
+    emitRunlingEvent({
+        type: "step.started",
+        id,
+        label,
+    });
+    logStep(label);
+    const finish = (status) => emitRunlingEvent({
+        type: "step.finished",
+        id,
+        status,
+        durationMs: performance.now() - startedAt,
+    });
+    try {
+        const result = withRunlingActivity(id, () => log.indented(work));
+        if (isPromiseLike(result)) {
+            void Promise.resolve(result).then(() => finish("completed"), () => finish("failed"));
+        }
+        else {
+            finish("completed");
+        }
+        return result;
+    }
+    catch (error) {
+        finish("failed");
+        throw error;
+    }
+}
+const isPromiseLike = (value) => (typeof value === "object" || typeof value === "function") &&
+    value !== null &&
+    "then" in value &&
+    typeof value.then === "function";

package/dist/src/system-prompt.d.ts

@@ -0,0 +1,2 @@
+export declare const RUNLING_SYSTEM_PROMPT: string;
+export declare function formatAgentInstructions(instructions: readonly string[]): string | undefined;

package/dist/src/system-prompt.js

@@ -0,0 +1,23 @@
+export const RUNLING_SYSTEM_PROMPT = `
+You are running inside Runling, a non-interactive software factory.
+
+Complete the user's request autonomously using the available tools. Do not ask
+follow-up questions when a reasonable interpretation is possible.
+
+Always finish by calling report_outcome as your final action. Do not emit a
+plain-text final response. The report summary must be a direct, concise,
+single-line result. Do not describe your reasoning or restate the request.
+
+Use outcome "completed" only when the request has been fulfilled. Use
+"blocked" when external input or access is required, and "failed" when the
+work was attempted but could not be completed.
+`.trim();
+export function formatAgentInstructions(instructions) {
+    if (instructions.length === 0) {
+        return undefined;
+    }
+    return [
+        "Additional instructions for this run:",
+        ...instructions.map((instruction) => `- ${instruction}`),
+    ].join("\n");
+}

package/dist/src/text.d.ts

@@ -0,0 +1,2 @@
+export declare function toSingleLine(text: string): string;
+export declare function containsMalformedToolCall(text: string): boolean;

package/dist/src/text.js

@@ -0,0 +1,6 @@
+export function toSingleLine(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+export function containsMalformedToolCall(text) {
+    return /functions\.[\w-]+:\d+\s*\{/.test(text);
+}

package/dist/src/tui.d.ts

@@ -0,0 +1,46 @@
+import { type Component, type Terminal } from "@earendil-works/pi-tui";
+import type { RunlingEvent } from "./events.ts";
+import type { InputHandler } from "./input.ts";
+import type { WorkflowExecution } from "./runner.ts";
+export declare class RunlingDashboard implements Component {
+    private readonly title;
+    private readonly startedAt;
+    private readonly nodes;
+    private readonly nodesById;
+    private readonly agents;
+    private readonly inputEditors;
+    private logSequence;
+    private usage;
+    private execution?;
+    constructor(title: string, startedAt?: number);
+    handle: (event: RunlingEvent) => void;
+    finish(execution: WorkflowExecution): void;
+    invalidate(): void;
+    setInputEditor(id: string, editor: Component | undefined): void;
+    render(width: number): string[];
+    renderHeader(width: number): string[];
+    renderTranscript(width: number): string[];
+    renderFooter(width: number): string[];
+    private footer;
+    private addNode;
+    private hasParent;
+    private renderNode;
+    private wrapNode;
+    private spinner;
+}
+export declare class TuiReporter {
+    private readonly onCancel;
+    private readonly dashboard;
+    private readonly tui;
+    private timer?;
+    private started;
+    private stopped;
+    private readonly pendingInputs;
+    private readonly pendingEditors;
+    constructor(title: string, terminal?: Terminal, onCancel?: () => void);
+    handle: (event: RunlingEvent) => void;
+    input: InputHandler;
+    start(): void;
+    finish(execution: WorkflowExecution): void;
+    stop(): void;
+}