@workflow-manager/runner 0.1.0

package/dist/opencodeExecutor.js

@@ -0,0 +1,174 @@
+import { spawnSync } from "node:child_process";
+function asRecord(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function normalizeTimeout(value, fallbackMs = 15000) {
+    const timeout = Number(value ?? fallbackMs);
+    if (!Number.isFinite(timeout) || timeout < 0) {
+        return fallbackMs;
+    }
+    return Math.floor(timeout);
+}
+export function shouldUseRealOpencode(step) {
+    const payload = asRecord(step.taskSpec?.payload);
+    return payload.useRealAdapter === true && payload.opencodeSmokeTest === true;
+}
+export function executeOpencodeStep(step, input, attempt) {
+    const startedAt = Date.now();
+    const payload = asRecord(step.taskSpec?.payload);
+    const opencodeArgs = Array.isArray(payload.opencodeArgs)
+        ? payload.opencodeArgs.map((arg) => String(arg))
+        : ["--version"];
+    const timeoutMs = normalizeTimeout(payload.timeoutMs, 15000);
+    let child;
+    try {
+        child = spawnSync("opencode", opencodeArgs, {
+            encoding: "utf-8",
+            timeout: timeoutMs,
+        });
+    }
+    catch (err) {
+        return {
+            step_id: step.key,
+            execution_status: "FAILED",
+            qa_routing: {
+                action: "PROCEED",
+                feedback_reason: err.message,
+            },
+            mutated_payload: {
+                stepKey: step.key,
+                attempt,
+                adapter: input.priming_configuration.adapter ?? "opencode",
+                realOpencode: true,
+                command: "opencode",
+                args: opencodeArgs,
+                timeoutMs,
+            },
+            metadata: {
+                execution_time_ms: Date.now() - startedAt,
+                external_intervention_required: false,
+            },
+        };
+    }
+    const stdout = child.stdout ?? "";
+    const stderr = child.stderr ?? "";
+    const status = typeof child.status === "number" ? child.status : 1;
+    const output = `${stdout}\n${stderr}`;
+    const expectContains = payload.expectContains ? String(payload.expectContains) : undefined;
+    const expectPattern = payload.expectPattern ? String(payload.expectPattern) : undefined;
+    const containsExpected = expectContains
+        ? output.toLowerCase().includes(expectContains.toLowerCase())
+        : true;
+    let matchesPattern = true;
+    if (expectPattern) {
+        try {
+            matchesPattern = new RegExp(expectPattern).test(output);
+        }
+        catch (err) {
+            return {
+                step_id: step.key,
+                execution_status: "FAILED",
+                qa_routing: {
+                    action: "PROCEED",
+                    feedback_reason: `Invalid expectPattern regex: ${err.message}`,
+                },
+                mutated_payload: {
+                    stepKey: step.key,
+                    attempt,
+                    adapter: input.priming_configuration.adapter ?? "opencode",
+                    realOpencode: true,
+                    command: "opencode",
+                    args: opencodeArgs,
+                    exitStatus: status,
+                    stdout,
+                    stderr,
+                    expectPattern,
+                },
+                metadata: {
+                    execution_time_ms: Date.now() - startedAt,
+                    external_intervention_required: false,
+                },
+            };
+        }
+    }
+    if (child.error || status !== 0) {
+        return {
+            step_id: step.key,
+            execution_status: "FAILED",
+            qa_routing: {
+                action: "PROCEED",
+                feedback_reason: child.error?.message ?? `opencode exited with status ${status}`,
+            },
+            mutated_payload: {
+                stepKey: step.key,
+                attempt,
+                adapter: input.priming_configuration.adapter ?? "opencode",
+                realOpencode: true,
+                command: "opencode",
+                args: opencodeArgs,
+                exitStatus: status,
+                stdout,
+                stderr,
+            },
+            metadata: {
+                execution_time_ms: Date.now() - startedAt,
+                external_intervention_required: false,
+            },
+        };
+    }
+    if (!containsExpected || !matchesPattern) {
+        const feedback = !containsExpected
+            ? `Output did not contain expected token: ${expectContains}`
+            : `Output did not match expected pattern: ${expectPattern}`;
+        return {
+            step_id: step.key,
+            execution_status: "QA_REJECTED",
+            qa_routing: {
+                action: "RETRY_CURRENT",
+                feedback_reason: feedback,
+            },
+            mutated_payload: {
+                stepKey: step.key,
+                attempt,
+                adapter: input.priming_configuration.adapter ?? "opencode",
+                realOpencode: true,
+                command: "opencode",
+                args: opencodeArgs,
+                exitStatus: status,
+                stdout,
+                stderr,
+                containsExpected,
+                matchesPattern,
+            },
+            metadata: {
+                execution_time_ms: Date.now() - startedAt,
+                external_intervention_required: false,
+            },
+        };
+    }
+    return {
+        step_id: step.key,
+        execution_status: "SUCCESS",
+        qa_routing: {
+            action: "PROCEED",
+            feedback_reason: "",
+        },
+        mutated_payload: {
+            stepKey: step.key,
+            attempt,
+            adapter: input.priming_configuration.adapter ?? "opencode",
+            realOpencode: true,
+            command: "opencode",
+            args: opencodeArgs,
+            exitStatus: status,
+            stdout,
+            stderr,
+            containsExpected,
+            matchesPattern,
+        },
+        metadata: {
+            execution_time_ms: Date.now() - startedAt,
+            external_intervention_required: false,
+        },
+    };
+}

package/dist/parser.d.ts

@@ -0,0 +1,5 @@
+import type { WorkflowDefinition } from "./types.js";
+export declare function parseWorkflowMarkdown(filePath: string): WorkflowDefinition;
+export declare function parseWorkflowJson(filePath: string): WorkflowDefinition;
+export declare function parseWorkflowFile(filePath: string): WorkflowDefinition;
+export declare function validateWorkflow(def: WorkflowDefinition): string[];

package/dist/parser.js

@@ -0,0 +1,101 @@
+import fs from "node:fs";
+import path from "node:path";
+import matter from "gray-matter";
+const SUPPORTED_ADAPTERS = ["mock", "opencode", "codex", "claude-code"];
+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`);
+    }
+    return {
+        key: data.key,
+        title: data.title,
+        description: data.description,
+        objectives: data.objectives ?? [],
+        inputSchema: data.inputSchema ?? {},
+        outputSchema: data.outputSchema ?? {},
+        defaultRetryPolicy: data.defaultRetryPolicy ?? { maxAttempts: 1 },
+        steps: data.steps.map((s) => ({
+            ...s,
+            dependsOn: s.dependsOn ?? [],
+            retryPolicy: s.retryPolicy ?? data.defaultRetryPolicy ?? { maxAttempts: 1 },
+            validation: s.validation ?? { mode: "none", required: false, autoConfirm: true },
+            taskSpec: s.taskSpec
+                ? {
+                    ...s.taskSpec,
+                    adapterKey: (s.taskSpec.adapterKey ?? "mock"),
+                    init: {
+                        context: s.taskSpec.init?.context ?? {},
+                        skills: s.taskSpec.init?.skills ?? [],
+                        mcps: s.taskSpec.init?.mcps ?? [],
+                        systemPrompts: s.taskSpec.init?.systemPrompts ?? [],
+                        model: s.taskSpec.init?.model,
+                    },
+                }
+                : undefined,
+        })),
+    };
+}
+export function parseWorkflowMarkdown(filePath) {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const parsed = matter(raw);
+    const data = parsed.data;
+    return normalizeWorkflow(data, "markdown");
+}
+export function parseWorkflowJson(filePath) {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(raw);
+    return normalizeWorkflow(data, "json");
+}
+export function parseWorkflowFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === ".json") {
+        return parseWorkflowJson(filePath);
+    }
+    return parseWorkflowMarkdown(filePath);
+}
+export function validateWorkflow(def) {
+    const errors = [];
+    const seen = new Set();
+    if (!def.key.trim()) {
+        errors.push("Workflow key is required");
+    }
+    if (!def.title.trim()) {
+        errors.push("Workflow title is required");
+    }
+    if (!Array.isArray(def.steps) || def.steps.length === 0) {
+        errors.push("Workflow must define at least one step");
+        return errors;
+    }
+    for (const step of def.steps) {
+        if (!step.key || !step.key.trim()) {
+            errors.push("Each step must define a non-empty key");
+            continue;
+        }
+        if (seen.has(step.key))
+            errors.push(`Duplicate step key: ${step.key}`);
+        seen.add(step.key);
+        if (!["task", "approval", "system"].includes(step.kind)) {
+            errors.push(`Invalid step kind for ${step.key}: ${step.kind}`);
+        }
+        if (step.kind === "task" && !step.taskSpec) {
+            errors.push(`Task step ${step.key} is missing taskSpec`);
+        }
+        if (step.kind === "approval" && !step.approvalSpec) {
+            errors.push(`Approval step ${step.key} is missing approvalSpec`);
+        }
+        for (const dep of step.dependsOn ?? []) {
+            if (!def.steps.some((s) => s.key === dep)) {
+                errors.push(`Step ${step.key} depends on unknown step ${dep}`);
+            }
+        }
+        const adapter = step.taskSpec?.adapterKey;
+        if (adapter && !SUPPORTED_ADAPTERS.includes(adapter)) {
+            errors.push(`Unsupported adapter for ${step.key}: ${adapter}`);
+        }
+        const mode = step.validation?.mode ?? step.approvalSpec?.validation?.mode;
+        if (mode && !["none", "human", "external"].includes(mode)) {
+            errors.push(`Invalid validation mode for ${step.key}: ${mode}`);
+        }
+    }
+    return errors;
+}

package/dist/remote/api.d.ts

@@ -0,0 +1,99 @@
+import type { WorkflowDefinition } from "../types.js";
+export interface RemoteSearchResultItem {
+    owner: string;
+    ownerDisplayName: string | null;
+    slug: string;
+    title: string;
+    description: string | null;
+    visibility: string;
+    latestVersion: string | null;
+    sourceFormat: string | null;
+    publishedState: string | null;
+    updatedAt: string;
+    createdAt: string;
+}
+export interface WhoAmIResponse {
+    userId: string;
+    username: string | null;
+    displayName: string | null;
+    authMethod: string;
+    scopes: string[];
+}
+export interface PublishRequest {
+    slug: string;
+    title: string;
+    description?: string | null;
+    visibility: "public" | "private";
+    versionLabel: string;
+    sourceFormat: "markdown" | "json";
+    rawSource: string;
+    definition: WorkflowDefinition;
+    tags?: string[];
+    changelog?: string | null;
+    publishedState: "draft" | "published";
+}
+export interface PullResponse {
+    owner: string;
+    slug: string;
+    title: string;
+    description: string | null;
+    visibility: string;
+    version: string;
+    sourceFormat: "markdown" | "json";
+    rawSource: string;
+    definition: WorkflowDefinition;
+    changelog: string | null;
+    publishedState: string;
+    createdAt: string;
+}
+export interface RunTelemetryPayload {
+    workflowKey: string;
+    workflowTitle?: string | null;
+    runId: string;
+    terminalState: "succeeded" | "failed" | "waiting_for_approval" | "cancelled";
+    totalSteps: number;
+    succeededSteps: number;
+    failedSteps: number;
+    waitingSteps: number;
+    cancelledSteps: number;
+    retriedSteps: number;
+    eventCount: number;
+    durationMs: number;
+    effectivenessScore: number;
+    outputKeys: string[];
+    sourceName?: string | null;
+    sourceFormat?: string | null;
+    cliVersion?: string | null;
+    failureReason?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface WorkflowRunInsightsResponse {
+    items: Array<{
+        workflowKey: string;
+        workflowTitle: string | null;
+        totalRuns: number;
+        successfulRuns: number;
+        failedRuns: number;
+        approvalRuns: number;
+        successRate: number;
+        averageEffectiveness: number;
+        averageDurationMs: number;
+        lastRunAt: string | null;
+        latestRun: Record<string, unknown> | null;
+        recentRuns: Array<Record<string, unknown>>;
+    }>;
+}
+export declare function fetchWhoAmI(): Promise<WhoAmIResponse>;
+export declare function searchRemoteWorkflows(query: string): Promise<{
+    items: RemoteSearchResultItem[];
+    count: number;
+    query: string;
+}>;
+export declare function publishRemoteWorkflow(request: PublishRequest): Promise<Record<string, unknown>>;
+export declare function pullRemoteWorkflow(owner: string, slug: string, version?: string): Promise<PullResponse>;
+export declare function trackRunTelemetry(payload: RunTelemetryPayload): Promise<{
+    id: string;
+    workflowKey: string;
+    terminalState: string;
+}>;
+export declare function fetchWorkflowRunInsights(workflowKey?: string): Promise<WorkflowRunInsightsResponse>;

package/dist/remote/api.js

@@ -0,0 +1,81 @@
+import { resolveAuthToken } from "./config.js";
+const DEFAULT_REMOTE_URL = "https://whairnylpdvxxgbygbzu.supabase.co";
+const DEFAULT_PUBLISHABLE_KEY = "sb_publishable_t5VATQUjIOtHrtK3wFi5Cw_Q088yz0Z";
+function remoteBaseUrl() {
+    return process.env.WORKFLOW_MANAGER_REMOTE_URL ?? DEFAULT_REMOTE_URL;
+}
+function publishableKey() {
+    return process.env.WORKFLOW_MANAGER_REMOTE_PUBLISHABLE_KEY ?? DEFAULT_PUBLISHABLE_KEY;
+}
+function buildHeaders(body, token) {
+    const headers = {
+        apikey: publishableKey(),
+    };
+    if (body !== undefined) {
+        headers["Content-Type"] = "application/json";
+    }
+    if (token) {
+        headers.Authorization = `Bearer ${token}`;
+    }
+    return headers;
+}
+async function remoteFetch(path, init = {}, requireAuth = false) {
+    const token = resolveAuthToken();
+    if (requireAuth && !token) {
+        throw new Error("Not authenticated. Run `wfm auth login --token <token>` first.");
+    }
+    const res = await fetch(`${remoteBaseUrl()}/functions/v1/${path}`, {
+        ...init,
+        headers: {
+            ...buildHeaders(init.body, token),
+            ...(init.headers ?? {}),
+        },
+    });
+    const text = await res.text();
+    const payload = text ? JSON.parse(text) : {};
+    if (!res.ok) {
+        const message = typeof payload.error === "string"
+            ? payload.error
+            : typeof payload.message === "string"
+                ? payload.message
+                : `Remote request failed with status ${res.status}`;
+        throw new Error(message);
+    }
+    return payload;
+}
+export async function fetchWhoAmI() {
+    return remoteFetch("auth-whoami", { method: "GET" }, true);
+}
+export async function searchRemoteWorkflows(query) {
+    const params = new URLSearchParams();
+    if (query.trim()) {
+        params.set("q", query.trim());
+    }
+    return remoteFetch(`search-workflows?${params.toString()}`, { method: "GET" });
+}
+export async function publishRemoteWorkflow(request) {
+    return remoteFetch("publish-workflow", {
+        method: "POST",
+        body: JSON.stringify(request),
+    }, true);
+}
+export async function pullRemoteWorkflow(owner, slug, version) {
+    const params = new URLSearchParams({ owner, slug });
+    if (version) {
+        params.set("version", version);
+    }
+    return remoteFetch(`pull-workflow?${params.toString()}`, { method: "GET" });
+}
+export async function trackRunTelemetry(payload) {
+    return remoteFetch("track-run-telemetry", {
+        method: "POST",
+        body: JSON.stringify(payload),
+    }, true);
+}
+export async function fetchWorkflowRunInsights(workflowKey) {
+    const params = new URLSearchParams();
+    if (workflowKey) {
+        params.set("workflowKey", workflowKey);
+    }
+    return remoteFetch(`workflow-run-insights${params.toString() ? `?${params.toString()}` : ""}`, { method: "GET" }, true);
+}

package/dist/remote/commands.d.ts

@@ -0,0 +1,8 @@
+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>;
+export declare function cmdPull(reference: string, args: string[]): Promise<number>;
+export declare function cmdRemoteInfo(reference: string): Promise<number>;
+export declare function pullOutputPathForTest(reference: string, output?: string, sourceFormat?: "markdown" | "json"): string;
+export declare function slugifyForTest(value: string): string;
+export declare function sourceFormatFromPathForTest(filePath: string): "markdown" | "json";

package/dist/remote/commands.js

@@ -0,0 +1,183 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseWorkflowFile, validateWorkflow } from "../parser.js";
+import { publishRemoteWorkflow, pullRemoteWorkflow, searchRemoteWorkflows, fetchWhoAmI } from "./api.js";
+import { clearRemoteConfig, saveRemoteConfig } from "./config.js";
+function getFlag(args, name) {
+    const idx = args.indexOf(name);
+    if (idx >= 0 && idx + 1 < args.length) {
+        return args[idx + 1];
+    }
+    return undefined;
+}
+function hasFlag(args, name) {
+    return args.includes(name);
+}
+function slugify(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 63);
+}
+function splitOwnerSlug(value) {
+    const [owner, slug, extra] = value.split("/");
+    if (!owner || !slug || extra) {
+        throw new Error("Expected workflow reference in the form <owner>/<slug>");
+    }
+    return { owner, slug };
+}
+function sourceFormatFromPath(filePath) {
+    return path.extname(filePath).toLowerCase() === ".json" ? "json" : "markdown";
+}
+function normalizeTags(raw) {
+    if (!raw) {
+        return [];
+    }
+    return [...new Set(raw.split(",").map((tag) => tag.trim().toLowerCase()).filter(Boolean))];
+}
+export async function cmdAuth(args) {
+    const subcommand = args[0];
+    if (subcommand === "login") {
+        const token = getFlag(args, "--token");
+        if (!token) {
+            console.error("Missing required flag: --token");
+            return 1;
+        }
+        saveRemoteConfig({ token });
+        try {
+            const profile = await fetchWhoAmI();
+            console.log(`Authenticated as ${profile.username ?? profile.userId}`);
+            return 0;
+        }
+        catch (error) {
+            clearRemoteConfig();
+            console.error(`Auth error: ${error.message}`);
+            return 1;
+        }
+    }
+    if (subcommand === "whoami") {
+        try {
+            const profile = await fetchWhoAmI();
+            console.log(JSON.stringify(profile, null, 2));
+            return 0;
+        }
+        catch (error) {
+            console.error(`Auth error: ${error.message}`);
+            return 1;
+        }
+    }
+    if (subcommand === "logout") {
+        clearRemoteConfig();
+        console.log("Removed local remote authentication token");
+        return 0;
+    }
+    console.error("Usage: wfm auth <login|whoami|logout>");
+    return 1;
+}
+export async function cmdSearch(args) {
+    try {
+        const query = args.join(" ").trim();
+        const result = await searchRemoteWorkflows(query);
+        if (result.items.length === 0) {
+            console.log("No workflows found");
+            return 0;
+        }
+        for (const item of result.items) {
+            console.log(`${item.owner}/${item.slug} - ${item.title}`);
+            if (item.description) {
+                console.log(`  ${item.description}`);
+            }
+            console.log(`  version=${item.latestVersion ?? "n/a"} visibility=${item.visibility} format=${item.sourceFormat ?? "n/a"}`);
+        }
+        return 0;
+    }
+    catch (error) {
+        console.error(`Search error: ${error.message}`);
+        return 1;
+    }
+}
+export async function cmdPublish(filePath, args) {
+    try {
+        const resolvedPath = path.resolve(filePath);
+        const rawSource = fs.readFileSync(resolvedPath, "utf-8");
+        const workflow = parseWorkflowFile(resolvedPath);
+        const errors = validateWorkflow(workflow);
+        if (errors.length > 0) {
+            console.error(`Invalid workflow: ${errors.join("; ")}`);
+            return 1;
+        }
+        const slug = slugify(getFlag(args, "--slug") ?? workflow.key);
+        const title = getFlag(args, "--title")?.trim() || workflow.title;
+        const description = getFlag(args, "--description")?.trim() || workflow.description || null;
+        const versionLabel = getFlag(args, "--version")?.trim() || `v${Date.now()}`;
+        const visibility = (getFlag(args, "--visibility")?.trim().toLowerCase() ?? "private");
+        const publishedState = hasFlag(args, "--draft") ? "draft" : "published";
+        const tags = normalizeTags(getFlag(args, "--tag"));
+        const changelog = getFlag(args, "--changelog")?.trim() || null;
+        const result = await publishRemoteWorkflow({
+            slug,
+            title,
+            description,
+            visibility,
+            versionLabel,
+            sourceFormat: sourceFormatFromPath(resolvedPath),
+            rawSource,
+            definition: workflow,
+            tags,
+            changelog,
+            publishedState,
+        });
+        console.log(JSON.stringify(result, null, 2));
+        return 0;
+    }
+    catch (error) {
+        console.error(`Publish error: ${error.message}`);
+        return 1;
+    }
+}
+export async function cmdPull(reference, args) {
+    try {
+        const { owner, slug } = splitOwnerSlug(reference);
+        const version = getFlag(args, "--version");
+        const pulled = await pullRemoteWorkflow(owner, slug, version);
+        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));
+        if (validationErrors.length > 0) {
+            fs.rmSync(outputPath);
+            console.error(`Pulled workflow failed local validation: ${validationErrors.join("; ")}`);
+            return 1;
+        }
+        console.log(`Pulled ${owner}/${slug}@${pulled.version} -> ${path.resolve(outputPath)}`);
+        return 0;
+    }
+    catch (error) {
+        console.error(`Pull error: ${error.message}`);
+        return 1;
+    }
+}
+export async function cmdRemoteInfo(reference) {
+    try {
+        const { owner, slug } = splitOwnerSlug(reference);
+        const pulled = await pullRemoteWorkflow(owner, slug);
+        console.log(JSON.stringify(pulled, null, 2));
+        return 0;
+    }
+    catch (error) {
+        console.error(`Remote info error: ${error.message}`);
+        return 1;
+    }
+}
+export function pullOutputPathForTest(reference, output, sourceFormat = "markdown") {
+    const { slug } = splitOwnerSlug(reference);
+    return output ?? path.resolve(`${slug}.${sourceFormat === "json" ? "json" : "md"}`);
+}
+export function slugifyForTest(value) {
+    return slugify(value);
+}
+export function sourceFormatFromPathForTest(filePath) {
+    return sourceFormatFromPath(filePath);
+}

package/dist/remote/config.d.ts

@@ -0,0 +1,8 @@
+export interface RemoteConfig {
+    token?: string;
+}
+export declare function configFilePath(): string;
+export declare function loadRemoteConfig(): RemoteConfig;
+export declare function saveRemoteConfig(config: RemoteConfig): void;
+export declare function clearRemoteConfig(): void;
+export declare function resolveAuthToken(): string | undefined;