@workflow-manager/runner 0.1.0 → 0.3.0

package/dist/parser.js

@@ -1,7 +1,57 @@
+import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import matter from "gray-matter";
-const SUPPORTED_ADAPTERS = ["mock", "opencode", "codex", "claude-code"];
+import { SUPPORTED_ADAPTERS, resolveTaskAdapter } from "./adapters.js";
+const SKILL_NAME_PATTERN = /^[a-zA-Z0-9_.-]+$/;
+function hashContentSha256(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+function isSafeSkillName(name) {
+    return !!name && SKILL_NAME_PATTERN.test(name);
+}
+function isAllowedLocalSkillSourcePath(source) {
+    if (!source || path.isAbsolute(source) || source.includes("\\") || source.includes(".."))
+        return false;
+    const normalized = path.posix.normalize(source);
+    const withoutDot = normalized.startsWith("./") ? normalized.slice(2) : normalized;
+    if (!withoutDot.startsWith("skills/"))
+        return false;
+    return withoutDot.endsWith("/SKILL.md");
+}
+function validateSkillEntry(name, entry, errors) {
+    if (!isSafeSkillName(name)) {
+        errors.push(`Invalid skill name: ${name}`);
+    }
+    if (!entry.content?.trim() && !entry.source?.trim()) {
+        errors.push(`Skill "${name}" must define content or source`);
+    }
+    if (entry.source && !isAllowedLocalSkillSourcePath(entry.source)) {
+        errors.push(`Skill "${name}" source must be under ./skills/**/SKILL.md`);
+    }
+    if (entry.contentSha256) {
+        if (!/^[a-f0-9]{64}$/.test(entry.contentSha256)) {
+            errors.push(`Skill "${name}" contentSha256 must be a 64-char lowercase hex SHA-256`);
+        }
+        else if (!entry.content?.trim()) {
+            errors.push(`Skill "${name}" defines contentSha256 but has no content`);
+        }
+        else if (hashContentSha256(entry.content) !== entry.contentSha256) {
+            errors.push(`Skill "${name}" contentSha256 does not match content`);
+        }
+    }
+    if (entry.upstream) {
+        if (entry.upstream.repo !== undefined && (!entry.upstream.repo || typeof entry.upstream.repo !== "string")) {
+            errors.push(`Skill "${name}" upstream.repo must be a non-empty string when present`);
+        }
+        if (entry.upstream.ref !== undefined && (!entry.upstream.ref || typeof entry.upstream.ref !== "string")) {
+            errors.push(`Skill "${name}" upstream.ref must be a non-empty string when present`);
+        }
+        if (entry.upstream.path !== undefined && (!entry.upstream.path || typeof entry.upstream.path !== "string")) {
+            errors.push(`Skill "${name}" upstream.path must be a non-empty string when present`);
+        }
+    }
+}
 function normalizeWorkflow(data, source) {
     if (!data.key || !data.title || !Array.isArray(data.steps)) {
         throw new Error(`Invalid workflow ${source}: key, title, and steps are required`);
@@ -14,6 +64,7 @@ function normalizeWorkflow(data, source) {
         inputSchema: data.inputSchema ?? {},
         outputSchema: data.outputSchema ?? {},
         defaultRetryPolicy: data.defaultRetryPolicy ?? { maxAttempts: 1 },
+        skills: data.skills,
         steps: data.steps.map((s) => ({
             ...s,
             dependsOn: s.dependsOn ?? [],
@@ -22,7 +73,7 @@ function normalizeWorkflow(data, source) {
             taskSpec: s.taskSpec
                 ? {
                     ...s.taskSpec,
-                    adapterKey: (s.taskSpec.adapterKey ?? "mock"),
+                    adapterKey: resolveTaskAdapter(s.taskSpec.adapterKey),
                     init: {
                         context: s.taskSpec.init?.context ?? {},
                         skills: s.taskSpec.init?.skills ?? [],
@@ -35,6 +86,44 @@ function normalizeWorkflow(data, source) {
         })),
     };
 }
+function findDependencyCycle(def) {
+    const stepsByKey = new Map(def.steps.map((step) => [step.key, step]));
+    const visiting = new Set();
+    const visited = new Set();
+    const path = [];
+    const visit = (stepKey) => {
+        if (visited.has(stepKey)) {
+            return null;
+        }
+        const pathIndex = path.indexOf(stepKey);
+        if (visiting.has(stepKey) && pathIndex >= 0) {
+            return [...path.slice(pathIndex), stepKey];
+        }
+        const step = stepsByKey.get(stepKey);
+        if (!step) {
+            return null;
+        }
+        visiting.add(stepKey);
+        path.push(stepKey);
+        for (const dependency of step.dependsOn ?? []) {
+            const cycle = visit(dependency);
+            if (cycle) {
+                return cycle;
+            }
+        }
+        path.pop();
+        visiting.delete(stepKey);
+        visited.add(stepKey);
+        return null;
+    };
+    for (const step of def.steps) {
+        const cycle = visit(step.key);
+        if (cycle) {
+            return cycle;
+        }
+    }
+    return null;
+}
 export function parseWorkflowMarkdown(filePath) {
     const raw = fs.readFileSync(filePath, "utf-8");
     const parsed = matter(raw);
@@ -66,6 +155,9 @@ export function validateWorkflow(def) {
         errors.push("Workflow must define at least one step");
         return errors;
     }
+    for (const [name, entry] of Object.entries(def.skills ?? {})) {
+        validateSkillEntry(name, entry, errors);
+    }
     for (const step of def.steps) {
         if (!step.key || !step.key.trim()) {
             errors.push("Each step must define a non-empty key");
@@ -97,5 +189,9 @@ export function validateWorkflow(def) {
             errors.push(`Invalid validation mode for ${step.key}: ${mode}`);
         }
     }
+    const cycle = findDependencyCycle(def);
+    if (cycle) {
+        errors.push(`Circular dependency detected: ${cycle.join(" -> ")}`);
+    }
     return errors;
 }

package/dist/piAgentExecutor.d.ts

@@ -0,0 +1,4 @@
+import type { InputEnvelope, OutputEnvelope, StepDefinition, StepExecutionHooks, WorkflowDefinition } from "./types.js";
+export declare const DEFAULT_PI_COMMAND = "pi";
+export declare function normalizeTimeout(value: unknown, fallbackMs?: number): number;
+export declare function executePiAgentStep(step: StepDefinition, input: InputEnvelope, attempt: number, workflow?: WorkflowDefinition, workflowFilePath?: string, hooks?: StepExecutionHooks): Promise<OutputEnvelope>;

package/dist/piAgentExecutor.js

@@ -0,0 +1,298 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { resolveSkill } from "./skillResolver.js";
+export const DEFAULT_PI_COMMAND = "pi";
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+export function normalizeTimeout(value, fallbackMs = 600000) {
+    const timeout = Number(value ?? fallbackMs);
+    if (!Number.isFinite(timeout) || timeout <= 0)
+        return fallbackMs;
+    return Math.floor(timeout);
+}
+function makeResult(step, input, attempt, startedAt, status, reason, extra = {}, action = "PROCEED") {
+    return {
+        step_id: step.key,
+        execution_status: status,
+        qa_routing: { action, feedback_reason: reason },
+        mutated_payload: {
+            stepKey: step.key,
+            attempt,
+            adapter: input.priming_configuration.adapter ?? "pi-agent",
+            ...extra,
+        },
+        metadata: {
+            execution_time_ms: Date.now() - startedAt,
+            external_intervention_required: false,
+        },
+    };
+}
+function resolveCommand(payload) {
+    if (typeof payload.command === "string" && payload.command.trim())
+        return payload.command;
+    if (process.env.WFM_PI_AGENT_COMMAND?.trim())
+        return process.env.WFM_PI_AGENT_COMMAND;
+    return DEFAULT_PI_COMMAND;
+}
+function resolveArgs(payload) {
+    return Array.isArray(payload.args) ? payload.args.map((arg) => String(arg)) : [];
+}
+function resolveRunDir(payload) {
+    if (typeof payload.runDir === "string" && payload.runDir.trim()) {
+        fs.mkdirSync(payload.runDir, { recursive: true });
+        return payload.runDir;
+    }
+    return fs.mkdtempSync(path.join(os.tmpdir(), "wfm-pi-agent-"));
+}
+function buildInputFile(step, input, attempt, runDir, workflow, workflowFilePath) {
+    const resolvedSkills = [];
+    if (workflow && workflowFilePath) {
+        for (const name of input.priming_configuration.required_skills) {
+            const resolved = resolveSkill(name, workflow, workflowFilePath);
+            if (resolved) {
+                resolvedSkills.push({ name, origin: resolved.origin, content: resolved.content });
+            }
+        }
+    }
+    return {
+        input_envelope: input,
+        step,
+        workflow: workflow
+            ? {
+                key: workflow.key,
+                title: workflow.title,
+                description: workflow.description,
+                objectives: workflow.objectives,
+                inputSchema: workflow.inputSchema,
+                outputSchema: workflow.outputSchema,
+            }
+            : undefined,
+        resolved_skills: resolvedSkills,
+        run: { attempt, runDir },
+    };
+}
+function sanitizeSkillName(name) {
+    const safe = name.replace(/[^a-zA-Z0-9_.-]/g, "-");
+    return safe || "skill";
+}
+function writeSkillFiles(runDir, skills) {
+    const skillPaths = [];
+    skills.forEach((skill, index) => {
+        const skillDir = path.join(runDir, "skills", `${index}-${sanitizeSkillName(skill.name)}`);
+        fs.mkdirSync(skillDir, { recursive: true });
+        const skillPath = path.join(skillDir, "SKILL.md");
+        fs.writeFileSync(skillPath, skill.content, "utf-8");
+        skillPaths.push(skillPath);
+    });
+    return skillPaths;
+}
+function describeContext(context) {
+    if (typeof context === "string") {
+        return context.trim() ? context : null;
+    }
+    if (context && Object.keys(context).length > 0) {
+        return JSON.stringify(context, null, 2);
+    }
+    return null;
+}
+function buildPrompt(step, input, inputPath, outputPath) {
+    const lines = ["You are executing a single step of an orchestrated workflow run."];
+    if (input.global_context.primary_objective.trim()) {
+        lines.push("", `Workflow objective: ${input.global_context.primary_objective}`);
+    }
+    if (input.global_context.workflow_objectives.length > 0) {
+        lines.push(`Workflow goals: ${input.global_context.workflow_objectives.join("; ")}`);
+    }
+    lines.push("", `Step key: ${step.key}`);
+    const objective = step.objective ?? input.step_context.step_objective;
+    if (objective.trim()) {
+        lines.push(`Step objective: ${objective}`);
+    }
+    if (Object.keys(input.step_context.previous_output).length > 0) {
+        lines.push("", "Previous step output:", JSON.stringify(input.step_context.previous_output, null, 2));
+    }
+    const context = describeContext(input.priming_configuration.context);
+    if (context) {
+        lines.push("", "Additional context:", context);
+    }
+    if (input.priming_configuration.mcp_endpoints.length > 0) {
+        lines.push("", `MCP endpoints declared for this step: ${input.priming_configuration.mcp_endpoints.join(", ")}`);
+    }
+    lines.push("", `The full structured step input is available at ${inputPath}.`, "", "Complete the step objective now.", `When you are done, write a JSON result envelope to ${outputPath} with this shape:`, `{"step_id":"${step.key}","execution_status":"SUCCESS"|"FAILED"|"QA_REJECTED","qa_routing":{"action":"PROCEED"|"RETRY_CURRENT"|"ROLLBACK_PREVIOUS"|"RESTART_ALL","feedback_reason":"<short reason>"},"mutated_payload":{<step results>},"metadata":{"execution_time_ms":0,"external_intervention_required":false}}`, "If you cannot write that file, simply finish with a clear final response; a successful exit is recorded as step success and your response text becomes the step output.");
+    return lines.join("\n");
+}
+function buildPiArgs(payload, input, skillPaths, prompt) {
+    const args = resolveArgs(payload);
+    args.push("--print", "--no-session");
+    if (input.priming_configuration.model) {
+        args.push("--model", input.priming_configuration.model);
+    }
+    for (const systemPrompt of input.priming_configuration.system_prompts) {
+        args.push("--append-system-prompt", systemPrompt);
+    }
+    for (const skillPath of skillPaths) {
+        args.push("--skill", skillPath);
+    }
+    args.push(prompt);
+    return args;
+}
+function normalizeOutputEnvelope(raw, step, input, attempt, startedAt) {
+    const record = asRecord(raw);
+    const metadata = asRecord(record.metadata);
+    const qaRouting = asRecord(record.qa_routing);
+    const status = String(record.execution_status ?? "SUCCESS");
+    const action = String(qaRouting.action ?? "PROCEED");
+    return {
+        step_id: typeof record.step_id === "string" && record.step_id.trim() ? record.step_id : step.key,
+        execution_status: status,
+        qa_routing: {
+            action,
+            feedback_reason: typeof qaRouting.feedback_reason === "string" ? qaRouting.feedback_reason : "",
+        },
+        mutated_payload: {
+            stepKey: step.key,
+            attempt,
+            adapter: input.priming_configuration.adapter ?? "pi-agent",
+            ...asRecord(record.mutated_payload),
+        },
+        metadata: {
+            execution_time_ms: typeof metadata.execution_time_ms === "number" ? metadata.execution_time_ms : Date.now() - startedAt,
+            external_intervention_required: metadata.external_intervention_required === true,
+            intervention_details: asRecord(metadata.intervention_details),
+        },
+    };
+}
+export function executePiAgentStep(step, input, attempt, workflow, workflowFilePath, hooks) {
+    const startedAt = Date.now();
+    let payload;
+    let timeoutMs;
+    let runDir;
+    let inputPath;
+    let outputPath;
+    let command;
+    let args;
+    try {
+        payload = asRecord(step.taskSpec?.payload);
+        timeoutMs = normalizeTimeout(payload.timeoutMs);
+        runDir = resolveRunDir(payload);
+        inputPath = path.join(runDir, "input.json");
+        outputPath = path.join(runDir, "output.json");
+        // A fixed runDir is reused across attempts; a leftover output.json would be
+        // read as this attempt's result if the agent exits 0 without writing one.
+        fs.rmSync(outputPath, { force: true });
+        command = resolveCommand(payload);
+        const inputFile = buildInputFile(step, input, attempt, runDir, workflow, workflowFilePath);
+        fs.writeFileSync(inputPath, JSON.stringify(inputFile, null, 2), "utf-8");
+        const skillPaths = writeSkillFiles(runDir, inputFile.resolved_skills);
+        const prompt = buildPrompt(step, input, inputPath, outputPath);
+        fs.writeFileSync(path.join(runDir, "prompt.txt"), prompt, "utf-8");
+        args = buildPiArgs(payload, input, skillPaths, prompt);
+    }
+    catch (err) {
+        const result = makeResult(step, input, attempt, startedAt, "FAILED", `Pi setup failed: ${err.message}`);
+        hooks?.onFinished?.({ executionStatus: result.execution_status });
+        return Promise.resolve(result);
+    }
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn(command, args, {
+                stdio: ["ignore", "pipe", "pipe"],
+                env: { ...process.env, WFM_PI_INPUT_FILE: inputPath, WFM_PI_OUTPUT_FILE: outputPath },
+            });
+        }
+        catch (err) {
+            resolve(makeResult(step, input, attempt, startedAt, "FAILED", err.message, {
+                command,
+                inputPath,
+                outputPath,
+                timeoutMs,
+            }));
+            return;
+        }
+        hooks?.onStarted?.({ command, inputPath, outputPath, timeoutMs });
+        const outChunks = [];
+        const errChunks = [];
+        child.stdout?.setEncoding("utf-8");
+        child.stderr?.setEncoding("utf-8");
+        child.stdout?.on("data", (chunk) => {
+            outChunks.push(chunk);
+            hooks?.onStdout?.(chunk);
+        });
+        child.stderr?.on("data", (chunk) => {
+            errChunks.push(chunk);
+            hooks?.onStderr?.(chunk);
+        });
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+            const result = makeResult(step, input, attempt, startedAt, "FAILED", `timed out after ${timeoutMs}ms`, { command, inputPath, outputPath, timeoutMs, stdout: outChunks.join(""), stderr: errChunks.join("") });
+            hooks?.onFinished?.({ executionStatus: result.execution_status, timedOut: true });
+            resolve(result);
+        }, timeoutMs);
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            if (timedOut)
+                return;
+            const result = makeResult(step, input, attempt, startedAt, "FAILED", err.message, {
+                command,
+                inputPath,
+                outputPath,
+                timeoutMs,
+                stdout: outChunks.join(""),
+                stderr: errChunks.join(""),
+            });
+            hooks?.onFinished?.({ executionStatus: result.execution_status });
+            resolve(result);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (timedOut)
+                return;
+            const stdout = outChunks.join("");
+            const stderr = errChunks.join("");
+            const exitStatus = code ?? 1;
+            if (exitStatus !== 0) {
+                const result = makeResult(step, input, attempt, startedAt, "FAILED", `${command} exited with status ${exitStatus}`, {
+                    command,
+                    inputPath,
+                    outputPath,
+                    exitStatus,
+                    stdout,
+                    stderr,
+                });
+                hooks?.onFinished?.({ executionStatus: result.execution_status, exitStatus });
+                resolve(result);
+                return;
+            }
+            if (!fs.existsSync(outputPath)) {
+                const result = makeResult(step, input, attempt, startedAt, "SUCCESS", "pi completed without a result envelope; using response text", { command, inputPath, outputPath, exitStatus, response: stdout.trim() });
+                hooks?.onFinished?.({ executionStatus: result.execution_status, exitStatus });
+                resolve(result);
+                return;
+            }
+            try {
+                const rawOutput = JSON.parse(fs.readFileSync(outputPath, "utf-8"));
+                const result = normalizeOutputEnvelope(rawOutput, step, input, attempt, startedAt);
+                hooks?.onFinished?.({ executionStatus: result.execution_status, exitStatus });
+                resolve(result);
+            }
+            catch (err) {
+                const result = makeResult(step, input, attempt, startedAt, "FAILED", `Invalid Pi result envelope: ${err.message}`, {
+                    command,
+                    inputPath,
+                    outputPath,
+                    exitStatus,
+                    stdout,
+                    stderr,
+                });
+                hooks?.onFinished?.({ executionStatus: result.execution_status, exitStatus });
+                resolve(result);
+            }
+        });
+    });
+}

package/dist/remote/api.d.ts

@@ -9,6 +9,7 @@ export interface RemoteSearchResultItem {
     latestVersion: string | null;
     sourceFormat: string | null;
     publishedState: string | null;
+    tags: string[];
     updatedAt: string;
     createdAt: string;
 }

package/dist/remote/commands.d.ts

@@ -1,3 +1,5 @@
+import type { WorkflowDefinition } from "../types.js";
+export declare function bundleSkills(workflow: WorkflowDefinition, workflowFilePath: string): WorkflowDefinition;
 export declare function cmdAuth(args: string[]): Promise<number>;
 export declare function cmdSearch(args: string[]): Promise<number>;
 export declare function cmdPublish(filePath: string, args: string[]): Promise<number>;

package/dist/remote/commands.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { parseWorkflowFile, validateWorkflow } from "../parser.js";
@@ -31,6 +32,64 @@ function splitOwnerSlug(value) {
 function sourceFormatFromPath(filePath) {
     return path.extname(filePath).toLowerCase() === ".json" ? "json" : "markdown";
 }
+function hashContentSha256(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+function isAllowedLocalSkillSourcePath(source) {
+    if (!source || path.isAbsolute(source) || source.includes("\\") || source.includes(".."))
+        return false;
+    const normalized = path.posix.normalize(source);
+    const withoutDot = normalized.startsWith("./") ? normalized.slice(2) : normalized;
+    if (!withoutDot.startsWith("skills/"))
+        return false;
+    return withoutDot.endsWith("/SKILL.md");
+}
+function resolveAllowedLocalSkillSourcePath(workflowDir, source) {
+    if (!isAllowedLocalSkillSourcePath(source)) {
+        throw new Error(`Skill source must be under ./skills/**/SKILL.md: ${source}`);
+    }
+    const sourcePath = path.resolve(workflowDir, source);
+    const allowedRoot = path.resolve(workflowDir, "skills");
+    if (!sourcePath.startsWith(`${allowedRoot}${path.sep}`)) {
+        throw new Error(`Skill source escapes ./skills directory: ${source}`);
+    }
+    if (path.basename(sourcePath) !== "SKILL.md") {
+        throw new Error(`Skill source must point to SKILL.md: ${source}`);
+    }
+    return sourcePath;
+}
+export function bundleSkills(workflow, workflowFilePath) {
+    if (!workflow.skills)
+        return workflow;
+    const workflowDir = path.dirname(path.resolve(workflowFilePath));
+    const bundled = {};
+    for (const [name, entry] of Object.entries(workflow.skills)) {
+        if (entry.content && entry.content.trim()) {
+            const content = entry.content;
+            bundled[name] = {
+                ...entry,
+                content,
+                contentSha256: hashContentSha256(content),
+            };
+            continue;
+        }
+        if (!entry.source) {
+            throw new Error(`Skill "${name}" has neither content nor source`);
+        }
+        const sourcePath = resolveAllowedLocalSkillSourcePath(workflowDir, entry.source);
+        if (!fs.existsSync(sourcePath)) {
+            throw new Error(`Skill "${name}" source file not found: ${sourcePath}`);
+        }
+        const content = fs.readFileSync(sourcePath, "utf-8");
+        bundled[name] = {
+            source: entry.source,
+            upstream: entry.upstream,
+            content,
+            contentSha256: hashContentSha256(content),
+        };
+    }
+    return { ...workflow, skills: bundled };
+}
 function normalizeTags(raw) {
     if (!raw) {
         return [];
@@ -116,15 +175,19 @@ export async function cmdPublish(filePath, args) {
         const publishedState = hasFlag(args, "--draft") ? "draft" : "published";
         const tags = normalizeTags(getFlag(args, "--tag"));
         const changelog = getFlag(args, "--changelog")?.trim() || null;
+        const bundled = bundleSkills(workflow, resolvedPath);
+        const hasSkills = Object.keys(bundled.skills ?? {}).length > 0;
+        const sourceFormat = hasSkills ? "json" : sourceFormatFromPath(resolvedPath);
+        const publishSource = hasSkills ? JSON.stringify(bundled, null, 2) : rawSource;
         const result = await publishRemoteWorkflow({
             slug,
             title,
             description,
             visibility,
             versionLabel,
-            sourceFormat: sourceFormatFromPath(resolvedPath),
-            rawSource,
-            definition: workflow,
+            sourceFormat,
+            rawSource: publishSource,
+            definition: bundled,
             tags,
             changelog,
             publishedState,
@@ -145,12 +208,21 @@ export async function cmdPull(reference, args) {
         const outputPath = getFlag(args, "--output") ??
             path.resolve(`${slug}.${pulled.sourceFormat === "json" ? "json" : "md"}`);
         fs.writeFileSync(outputPath, pulled.rawSource, "utf-8");
-        const validationErrors = validateWorkflow(parseWorkflowFile(outputPath));
+        const parsed = parseWorkflowFile(outputPath);
+        const validationErrors = validateWorkflow(parsed);
         if (validationErrors.length > 0) {
             fs.rmSync(outputPath);
             console.error(`Pulled workflow failed local validation: ${validationErrors.join("; ")}`);
             return 1;
         }
+        const missingEmbeddedSkills = Object.entries(parsed.skills ?? {})
+            .filter(([, entry]) => !entry.content?.trim())
+            .map(([name]) => name);
+        if (missingEmbeddedSkills.length > 0) {
+            fs.rmSync(outputPath);
+            console.error(`Pulled workflow is missing embedded content for skills: ${missingEmbeddedSkills.join(", ")}`);
+            return 1;
+        }
         console.log(`Pulled ${owner}/${slug}@${pulled.version} -> ${path.resolve(outputPath)}`);
         return 0;
     }

package/dist/runnerApi.d.ts

@@ -0,0 +1,7 @@
+import type { RunnerSessionStore } from "./runnerSession.js";
+interface RunnerApiServer {
+    port: number;
+    close: () => Promise<void>;
+}
+export declare function startRunnerApiServer(store: RunnerSessionStore, requestedPort: number): Promise<RunnerApiServer>;
+export {};