@barnum/barnum 0.0.0-main-ccc32185 → 0.0.0-main-d44f0a8e

package/cli.cjs

@@ -1,56 +1,33 @@
 #!/usr/bin/env node
-'use strict';
+"use strict";
 
-var path = require('path');
-var spawn = require('child_process').spawn;
-var chmodSync = require('fs').chmodSync;
+const { execFileSync } = require("child_process");
+const path = require("path");
+const os = require("os");
+const fs = require("fs");
 
-var bin;
+const platform = os.platform();
+const arch = os.arch();
 
-if (process.platform === 'darwin' && process.arch === 'x64') {
-  bin = path.join(__dirname, 'artifacts', 'macos-x64', 'barnum');
-} else if (process.platform === 'darwin' && process.arch === 'arm64') {
-  bin = path.join(__dirname, 'artifacts', 'macos-arm64', 'barnum');
-} else if (process.platform === 'linux' && process.arch === 'x64') {
-  bin = path.join(__dirname, 'artifacts', 'linux-x64', 'barnum');
-} else if (process.platform === 'linux' && process.arch === 'arm64') {
-  bin = path.join(__dirname, 'artifacts', 'linux-arm64', 'barnum');
-} else if (process.platform === 'win32' && process.arch === 'x64') {
-  bin = path.join(__dirname, 'artifacts', 'win-x64', 'barnum.exe');
-} else {
-  throw new Error(
-    `Platform "${process.platform} (${process.arch})" not supported.`
-  );
-}
+let binaryName = "barnum";
+let artifactDir;
 
-// --executor and --run-handler-path are internal. Error if the user passed them directly.
-var userArgs = process.argv.slice(2);
-var internalFlags = ['--executor', '--run-handler-path'];
-for (var flag of internalFlags) {
-  if (userArgs.includes(flag)) {
-    console.error('Error: ' + flag + ' is an internal flag and cannot be passed directly.');
-    process.exit(1);
-  }
-}
+if (platform === "darwin" && arch === "arm64") artifactDir = "macos-arm64";
+else if (platform === "darwin") artifactDir = "macos-x64";
+else if (platform === "linux" && arch === "arm64") artifactDir = "linux-arm64";
+else if (platform === "linux") artifactDir = "linux-x64";
+else if (platform === "win32") { artifactDir = "win-x64"; binaryName = "barnum.exe"; }
+else { console.error(`Unsupported platform: ${platform}-${arch}`); process.exit(1); }
 
-var executorPath = path.resolve(__dirname, 'actions', 'executor.ts');
-var runHandlerPath = path.resolve(__dirname, 'actions', 'run-handler.ts');
+const binaryPath = path.join(__dirname, "artifacts", artifactDir, binaryName);
 
-function resolveExecutorCommand() {
-  if (typeof Bun !== 'undefined') {
-    // Bun runs .ts natively
-    return process.execPath + ' ' + executorPath;
-  }
-  // Node: use tsx
-  var tsxPath = require.resolve('tsx/cli');
-  return 'node ' + tsxPath + ' ' + executorPath;
+if (!fs.existsSync(binaryPath)) {
+  console.error(`Binary not found: ${binaryPath}`);
+  process.exit(1);
 }
 
-var executor = resolveExecutorCommand();
-var args = userArgs.concat('--executor', executor, '--run-handler-path', runHandlerPath);
-
 try {
-  chmodSync(bin, 0o755);
-} catch {}
-
-spawn(bin, args, { stdio: 'inherit' }).on('exit', process.exit);
+  execFileSync(binaryPath, process.argv.slice(2), { stdio: "inherit" });
+} catch (e) {
+  process.exit(e.status || 1);
+}

package/index.js

@@ -0,0 +1,2 @@
+// @barnum/barnum - workflow engine
+// Not yet implemented.

package/package.json

@@ -1,19 +1,17 @@
 {
   "name": "@barnum/barnum",
-  "version": "0.0.0-main-ccc32185",
+  "version": "0.0.0-main-d44f0a8e",
+  "description": "Barnum workflow engine",
   "type": "module",
-  "description": "Barnum CLI - workflow engine for agents.",
-  "main": "index.ts",
-  "types": "index.ts",
-  "exports": {
-    ".": "./index.ts",
-    "./schema": "./barnum-config-schema.zod.ts",
-    "./cli-schema": "./barnum-cli-schema.zod.ts",
-    "./binary": "./index.cjs"
-  },
+  "main": "index.js",
   "bin": {
     "barnum": "cli.cjs"
   },
+  "scripts": {
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "oxlint src/"
+  },
   "author": "Robert Balicki",
   "license": "MIT",
   "repository": {
@@ -24,35 +22,21 @@
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
-  "keywords": [
-    "barnum",
-    "ai",
-    "agents",
-    "automation",
-    "cli"
-  ],
   "files": [
-    "index.ts",
-    "index.cjs",
+    "index.js",
     "cli.cjs",
-    "artifacts/**/*",
-    "barnum-config-schema.json",
-    "barnum-config-schema.zod.ts",
-    "barnum-cli-schema.zod.ts",
-    "run.ts",
-    "types.ts",
-    "actions/**/*.ts"
+    "artifacts/**/*"
   ],
-  "scripts": {
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "zod": "^3.0.0",
-    "zod-to-json-schema": "^3.25.1"
-  },
+  "sideEffects": false,
   "devDependencies": {
+    "@oxlint/binding-darwin-arm64": "^1.57.0",
     "@types/node": "^25.5.0",
-    "typescript": "^5.9.3"
+    "oxlint": "^1.57.0",
+    "prettier": "^3.8.1",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
   },
-  "sideEffects": false
+  "dependencies": {
+    "zod": "^4.3.6"
+  }
 }

package/README.md

@@ -1,19 +0,0 @@
-# @barnum/barnum
-
-Barnum CLI - workflow engine for agents.
-
-## Installation
-
-```bash
-npm install -g @barnum/barnum
-```
-
-## Usage
-
-```bash
-barnum --help
-```
-
-## About
-
-Barnum is a task automation tool that orchestrates AI agents to execute multi-step workflows defined in configuration files.

package/actions/run-handler.ts

@@ -1,12 +0,0 @@
-const [handlerPath, exportName = "default"] = process.argv.slice(2);
-
-const chunks: Buffer[] = [];
-for await (const chunk of process.stdin) chunks.push(chunk);
-const envelope = JSON.parse(Buffer.concat(chunks).toString());
-
-const mod = await import(handlerPath);
-const handler = mod[exportName];
-
-const results = await handler.handle(envelope);
-
-process.stdout.write(JSON.stringify(results));

package/barnum-cli-schema.zod.ts

@@ -1,68 +0,0 @@
-import { z } from "zod";
-
-const SchemaType = z.union([
-  z.literal("zod").describe("Zod TypeScript schema."),
-  z.literal("json").describe("JSON Schema."),
-]).describe("Output format for `barnum config schema`.");
-
-const ConfigCommand = z.discriminatedUnion("kind", [
-  z.object({
-    config: z.string().describe("Config (JSON string or path to file)"),
-    kind: z.literal("Docs"),
-  }).describe("Generate markdown documentation from config"),
-  z.object({
-    config: z.string().describe("Config (JSON string or path to file)"),
-    kind: z.literal("Validate"),
-  }).describe("Validate a config file"),
-  z.object({
-    config: z.string().describe("Config (JSON string or path to file)"),
-    kind: z.literal("Graph"),
-  }).describe("Generate DOT visualization of config (for `GraphViz`)"),
-  z.object({
-    kind: z.literal("Schema"),
-    schemaType: SchemaType.describe("Output format: zod (default) or json"),
-  }).describe("Print the config schema (Zod by default, JSON with --type json)"),
-]).describe("Subcommands for `barnum config`.");
-
-const Command = z.discriminatedUnion("kind", [
-  z.object({
-    config: z.string().nullable().optional().describe("Config (JSON string or path to file). Required unless `--resume-from` is used."),
-    entrypointValue: z.string().nullable().optional().describe("Initial value for the entrypoint step (JSON string or path to file). Only valid when config has an `entrypoint`. Defaults to `{}` if not provided."),
-    executor: z.string().describe("Executor command for TypeScript handlers, injected by cli.cjs and run.ts."),
-    initialState: z.string().nullable().optional().describe("Initial tasks (JSON string or path to file). Required if config has no `entrypoint`. Cannot be used with `--entrypoint-value`."),
-    kind: z.literal("Run"),
-    logFile: z.string().nullable().optional().describe("Log file path (logs emitted in addition to stderr)"),
-    resumeFrom: z.string().nullable().optional().describe("Resume from a previous state log file. Incompatible with `--config`, `--initial-state`, and `--entrypoint-value`."),
-    runHandlerPath: z.string().describe("Path to run-handler.ts, injected by cli.cjs and run.ts."),
-    stateLog: z.string().nullable().optional().describe("State log file path (NDJSON file for persistence/resume)"),
-    wake: z.string().nullable().optional().describe("Wake script to call before starting"),
-  }).describe("Run the task queue"),
-  z.object({
-    command: ConfigCommand.describe("Config subcommand to run."),
-    kind: z.literal("Config"),
-  }).describe("Config file operations (docs, validate, graph, schema)"),
-  z.object({
-    json: z.boolean().describe("Output as JSON (for programmatic access)"),
-    kind: z.literal("Version"),
-  }).describe("Print version information"),
-]).describe("Barnum subcommands.");
-
-const LogLevel = z.union([
-  z.literal("off").describe("No logging"),
-  z.literal("error").describe("Error messages only"),
-  z.literal("warn").describe("Warnings and errors"),
-  z.literal("info").describe("Informational messages (default)"),
-  z.literal("debug").describe("Debug messages (includes task return values)"),
-  z.literal("trace").describe("Trace messages (very verbose)"),
-]).describe("Log level for barnum output.");
-
-export const cliSchema = z.object({
-  command: Command.describe("Subcommand to run."),
-  logLevel: LogLevel.describe("Log level (debug shows task return values)"),
-}).describe("Top-level CLI arguments for barnum.");
-
-export type Cli = z.infer<typeof cliSchema>;
-export type SchemaType = z.infer<typeof SchemaType>;
-export type ConfigCommand = z.infer<typeof ConfigCommand>;
-export type Command = z.infer<typeof Command>;
-export type LogLevel = z.infer<typeof LogLevel>;

package/barnum-config-schema.json

@@ -1,271 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "title": "Config",
-  "description": "Top-level Barnum configuration.\n\nDefines a workflow as a directed graph of steps. Each step processes tasks and can spawn follow-up tasks on other steps.",
-  "type": "object",
-  "required": [
-    "steps"
-  ],
-  "properties": {
-    "entrypoint": {
-      "description": "Name of the step that starts the workflow. When set, the CLI accepts `--entrypoint-value` to provide the initial task value (defaults to `{}`). When omitted, `--initial-state` must provide explicit `[{\"kind\": \"StepName\", \"value\": ...}]` tasks.",
-      "default": null,
-      "type": [
-        "string",
-        "null"
-      ]
-    },
-    "options": {
-      "description": "Global runtime options (timeout, retries, concurrency). Individual steps can override these via their own `options` field.",
-      "default": {
-        "maxConcurrency": null,
-        "maxRetries": 0,
-        "retryOnInvalidResponse": true,
-        "retryOnTimeout": true,
-        "timeout": null
-      },
-      "allOf": [
-        {
-          "$ref": "#/definitions/Options"
-        }
-      ]
-    },
-    "steps": {
-      "description": "The steps that make up this workflow. Each step defines how to process a task and which steps it can spawn follow-up tasks on.",
-      "type": "array",
-      "items": {
-        "$ref": "#/definitions/Step"
-      }
-    }
-  },
-  "additionalProperties": false,
-  "definitions": {
-    "ActionKind": {
-      "description": "How a step processes tasks.",
-      "oneOf": [
-        {
-          "description": "Run a shell command.",
-          "type": "object",
-          "required": [
-            "kind",
-            "script"
-          ],
-          "properties": {
-            "kind": {
-              "type": "string",
-              "enum": [
-                "Bash"
-              ]
-            },
-            "script": {
-              "description": "Shell script to execute.\n\n**Input (stdin):** JSON object: `{\"kind\": \"<step name>\", \"value\": <payload>}`. Use `jq '.value'` to extract the payload, or `jq -r '.value.fieldName'` for a specific field.\n\n**Output (stdout):** JSON array of follow-up tasks to spawn: `[{\"kind\": \"NextStep\", \"value\": {...}}, ...]`. Each `kind` must be a step name listed in this step's `next` array. Return `[]` to spawn no follow-ups.",
-              "type": "string"
-            }
-          }
-        },
-        {
-          "description": "Run a TypeScript handler.",
-          "type": "object",
-          "required": [
-            "kind",
-            "path"
-          ],
-          "properties": {
-            "exportedAs": {
-              "description": "Named export to invoke from the handler module.",
-              "default": "default",
-              "type": "string"
-            },
-            "kind": {
-              "type": "string",
-              "enum": [
-                "TypeScript"
-              ]
-            },
-            "path": {
-              "description": "Path to the handler file (absolute — JS layer resolves before passing to Rust).",
-              "type": "string"
-            },
-            "stepConfig": {
-              "description": "Step configuration passed through to the handler. Rust stores this as-is and includes it in the envelope.",
-              "default": null
-            },
-            "valueSchema": {
-              "description": "JSON Schema for this step's input value. Produced by JS from Zod. Used to validate transition values targeting this step.",
-              "default": null
-            }
-          }
-        }
-      ]
-    },
-    "FinallyHook": {
-      "description": "Finally hook. Runs after a task and all its descendants complete.\n\nIn JSON: `{\"kind\": \"Bash\", \"script\": \"./finally-hook.sh\"}`\n\n**stdin:** JSON object: `{\"kind\": \"<step name>\", \"value\": <payload>}`. **stdout:** JSON array of follow-up tasks: `[{\"kind\": \"StepName\", \"value\": {...}}, ...]`. Return `[]` for no follow-ups.",
-      "oneOf": [
-        {
-          "description": "Run a shell command as the finally hook.",
-          "type": "object",
-          "required": [
-            "kind",
-            "script"
-          ],
-          "properties": {
-            "kind": {
-              "type": "string",
-              "enum": [
-                "Bash"
-              ]
-            },
-            "script": {
-              "description": "Shell script to execute.",
-              "type": "string"
-            }
-          }
-        }
-      ]
-    },
-    "Options": {
-      "description": "Global runtime options for task execution. All fields have sensible defaults.",
-      "type": "object",
-      "properties": {
-        "maxConcurrency": {
-          "description": "Maximum concurrent tasks (None = unlimited).",
-          "default": null,
-          "type": [
-            "integer",
-            "null"
-          ],
-          "format": "uint",
-          "minimum": 0.0
-        },
-        "maxRetries": {
-          "description": "Maximum retries per task (default: 0).",
-          "default": 0,
-          "type": "integer",
-          "format": "uint32",
-          "minimum": 0.0
-        },
-        "retryOnInvalidResponse": {
-          "description": "Whether to retry when agent returns invalid response (default: true).",
-          "default": true,
-          "type": "boolean"
-        },
-        "retryOnTimeout": {
-          "description": "Whether to retry when agent times out (default: true).",
-          "default": true,
-          "type": "boolean"
-        },
-        "timeout": {
-          "description": "Timeout in seconds for each task (None = no timeout).",
-          "default": null,
-          "type": [
-            "integer",
-            "null"
-          ],
-          "format": "uint64",
-          "minimum": 0.0
-        }
-      },
-      "additionalProperties": false
-    },
-    "Step": {
-      "description": "A named step in the workflow. Steps are the nodes of the task graph.\n\nThe `finally` hook runs after the task **and all of its descendant tasks** complete.",
-      "type": "object",
-      "required": [
-        "action",
-        "name"
-      ],
-      "properties": {
-        "action": {
-          "description": "How this step processes tasks.",
-          "allOf": [
-            {
-              "$ref": "#/definitions/ActionKind"
-            }
-          ]
-        },
-        "finally": {
-          "description": "Shell script that runs after this task **and all tasks it spawned (recursively)** have completed.\n\n**stdin:** JSON object: `{\"kind\": \"<step name>\", \"value\": <payload>}`. Same envelope format as command action scripts.\n\n**stdout:** A JSON array of follow-up tasks to spawn: `[{\"kind\": \"StepName\", \"value\": {...}}, ...]`. Each `kind` must be a valid step name. Return `[]` to spawn no follow-ups.\n\nUse this for cleanup, aggregation, or spawning a final summarization step after an entire subtree of work completes.",
-          "default": null,
-          "anyOf": [
-            {
-              "$ref": "#/definitions/FinallyHook"
-            },
-            {
-              "type": "null"
-            }
-          ]
-        },
-        "name": {
-          "description": "Unique name for this step (e.g., `\"Analyze\"`, `\"Implement\"`, `\"Review\"`). This is the string used as `kind` when creating tasks: `{\"kind\": \"ThisStepName\", \"value\": {...}}`.",
-          "type": "string"
-        },
-        "next": {
-          "description": "Step names this step is allowed to spawn follow-up tasks on. Each string must match the `name` of another step in this config. An empty array means this is a terminal step (no follow-ups).",
-          "default": [],
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        },
-        "options": {
-          "description": "Per-step options that override the global `options`. Only the fields you set here take effect; everything else falls through to the global defaults.",
-          "default": {
-            "maxRetries": null,
-            "retryOnInvalidResponse": null,
-            "retryOnTimeout": null,
-            "timeout": null
-          },
-          "allOf": [
-            {
-              "$ref": "#/definitions/StepOptions"
-            }
-          ]
-        }
-      },
-      "additionalProperties": false
-    },
-    "StepOptions": {
-      "description": "Per-step option overrides. Only set the fields you want to override; omitted fields inherit from the global `options`.",
-      "type": "object",
-      "properties": {
-        "maxRetries": {
-          "description": "Maximum retries for tasks on this step (overrides global `max_retries`).",
-          "default": null,
-          "type": [
-            "integer",
-            "null"
-          ],
-          "format": "uint32",
-          "minimum": 0.0
-        },
-        "retryOnInvalidResponse": {
-          "description": "Whether to retry when an agent returns an invalid response on this step (overrides global `retry_on_invalid_response`).",
-          "default": null,
-          "type": [
-            "boolean",
-            "null"
-          ]
-        },
-        "retryOnTimeout": {
-          "description": "Whether to retry when an agent times out on this step (overrides global `retry_on_timeout`).",
-          "default": null,
-          "type": [
-            "boolean",
-            "null"
-          ]
-        },
-        "timeout": {
-          "description": "Timeout in seconds for tasks on this step (overrides global `timeout`).",
-          "default": null,
-          "type": [
-            "integer",
-            "null"
-          ],
-          "format": "uint64",
-          "minimum": 0.0
-        }
-      },
-      "additionalProperties": false
-    }
-  }
-}

package/barnum-config-schema.zod.ts

@@ -1,62 +0,0 @@
-import { z } from "zod";
-
-const ActionKind = z.discriminatedUnion("kind", [
-  z.object({
-    kind: z.literal("Bash"),
-    script: z.string().describe("Shell script to execute.\n\n**Input (stdin):** JSON object: `{\"kind\": \"<step name>\", \"value\": <payload>}`. Use `jq '.value'` to extract the payload, or `jq -r '.value.fieldName'` for a specific field.\n\n**Output (stdout):** JSON array of follow-up tasks to spawn: `[{\"kind\": \"NextStep\", \"value\": {...}}, ...]`. Each `kind` must be a step name listed in this step's `next` array. Return `[]` to spawn no follow-ups."),
-  }).describe("Run a shell command."),
-  z.object({
-    exportedAs: z.string().optional().default("default").describe("Named export to invoke from the handler module."),
-    kind: z.literal("TypeScript"),
-    path: z.string().describe("Path to the handler file (absolute — JS layer resolves before passing to Rust)."),
-    stepConfig: z.any().optional().default(null).describe("Step configuration passed through to the handler. Rust stores this as-is and includes it in the envelope."),
-    valueSchema: z.any().optional().default(null).describe("JSON Schema for this step's input value. Produced by JS from Zod. Used to validate transition values targeting this step."),
-  }).describe("Run a TypeScript handler."),
-]).describe("How a step processes tasks.");
-
-const FinallyHook = z.discriminatedUnion("kind", [
-  z.object({
-    kind: z.literal("Bash"),
-    script: z.string().describe("Shell script to execute."),
-  }).describe("Run a shell command as the finally hook."),
-]).describe("Finally hook. Runs after a task and all its descendants complete.\n\nIn JSON: `{\"kind\": \"Bash\", \"script\": \"./finally-hook.sh\"}`\n\n**stdin:** JSON object: `{\"kind\": \"<step name>\", \"value\": <payload>}`. **stdout:** JSON array of follow-up tasks: `[{\"kind\": \"StepName\", \"value\": {...}}, ...]`. Return `[]` for no follow-ups.");
-
-const Options = z.object({
-  maxConcurrency: z.number().int().nonnegative().nullable().optional().default(null).describe("Maximum concurrent tasks (None = unlimited)."),
-  maxRetries: z.number().int().nonnegative().optional().default(0).describe("Maximum retries per task (default: 0)."),
-  retryOnInvalidResponse: z.boolean().optional().default(true).describe("Whether to retry when agent returns invalid response (default: true)."),
-  retryOnTimeout: z.boolean().optional().default(true).describe("Whether to retry when agent times out (default: true)."),
-  timeout: z.number().int().nonnegative().nullable().optional().default(null).describe("Timeout in seconds for each task (None = no timeout)."),
-}).strict().describe("Global runtime options for task execution. All fields have sensible defaults.");
-
-const StepOptions = z.object({
-  maxRetries: z.number().int().nonnegative().nullable().optional().default(null).describe("Maximum retries for tasks on this step (overrides global `max_retries`)."),
-  retryOnInvalidResponse: z.boolean().nullable().optional().default(null).describe("Whether to retry when an agent returns an invalid response on this step (overrides global `retry_on_invalid_response`)."),
-  retryOnTimeout: z.boolean().nullable().optional().default(null).describe("Whether to retry when an agent times out on this step (overrides global `retry_on_timeout`)."),
-  timeout: z.number().int().nonnegative().nullable().optional().default(null).describe("Timeout in seconds for tasks on this step (overrides global `timeout`)."),
-}).strict().describe("Per-step option overrides. Only set the fields you want to override; omitted fields inherit from the global `options`.");
-
-const Step = z.object({
-  action: ActionKind.describe("How this step processes tasks."),
-  finally: FinallyHook.nullable().optional().default(null).describe("Shell script that runs after this task **and all tasks it spawned (recursively)** have completed.\n\n**stdin:** JSON object: `{\"kind\": \"<step name>\", \"value\": <payload>}`. Same envelope format as command action scripts.\n\n**stdout:** A JSON array of follow-up tasks to spawn: `[{\"kind\": \"StepName\", \"value\": {...}}, ...]`. Each `kind` must be a valid step name. Return `[]` to spawn no follow-ups.\n\nUse this for cleanup, aggregation, or spawning a final summarization step after an entire subtree of work completes."),
-  name: z.string().describe("Unique name for this step (e.g., `\"Analyze\"`, `\"Implement\"`, `\"Review\"`). This is the string used as `kind` when creating tasks: `{\"kind\": \"ThisStepName\", \"value\": {...}}`."),
-  next: z.array(z.string()).optional().default([]).describe("Step names this step is allowed to spawn follow-up tasks on. Each string must match the `name` of another step in this config. An empty array means this is a terminal step (no follow-ups)."),
-  options: StepOptions.optional().default({"maxRetries": null, "retryOnInvalidResponse": null, "retryOnTimeout": null, "timeout": null}).describe("Per-step options that override the global `options`. Only the fields you set here take effect; everything else falls through to the global defaults."),
-}).strict().describe("A named step in the workflow. Steps are the nodes of the task graph.\n\nThe `finally` hook runs after the task **and all of its descendant tasks** complete.");
-
-export const configSchema = z.object({
-  entrypoint: z.string().nullable().optional().default(null).describe("Name of the step that starts the workflow. When set, the CLI accepts `--entrypoint-value` to provide the initial task value (defaults to `{}`). When omitted, `--initial-state` must provide explicit `[{\"kind\": \"StepName\", \"value\": ...}]` tasks."),
-  options: Options.optional().default({"maxConcurrency": null, "maxRetries": 0, "retryOnInvalidResponse": true, "retryOnTimeout": true, "timeout": null}).describe("Global runtime options (timeout, retries, concurrency). Individual steps can override these via their own `options` field."),
-  steps: z.array(Step).describe("The steps that make up this workflow. Each step defines how to process a task and which steps it can spawn follow-up tasks on."),
-}).strict().describe("Top-level Barnum configuration.\n\nDefines a workflow as a directed graph of steps. Each step processes tasks and can spawn follow-up tasks on other steps.");
-
-export type Config = z.infer<typeof configSchema>;
-export type ActionKind = z.infer<typeof ActionKind>;
-export type FinallyHook = z.infer<typeof FinallyHook>;
-export type Options = z.infer<typeof Options>;
-export type StepOptions = z.infer<typeof StepOptions>;
-export type Step = z.infer<typeof Step>;
-
-export function defineConfig(config: z.input<typeof configSchema>): Config {
-  return configSchema.parse(config);
-}

package/index.cjs

@@ -1,23 +0,0 @@
-'use strict';
-
-const path = require('path');
-
-let binary;
-
-if (process.platform === 'darwin' && process.arch === 'x64') {
-  binary = path.join(__dirname, 'artifacts', 'macos-x64', 'barnum');
-} else if (process.platform === 'darwin' && process.arch === 'arm64') {
-  binary = path.join(__dirname, 'artifacts', 'macos-arm64', 'barnum');
-} else if (process.platform === 'linux' && process.arch === 'x64') {
-  binary = path.join(__dirname, 'artifacts', 'linux-x64', 'barnum');
-} else if (process.platform === 'linux' && process.arch === 'arm64') {
-  binary = path.join(__dirname, 'artifacts', 'linux-arm64', 'barnum');
-} else if (process.platform === 'win32' && process.arch === 'x64') {
-  binary = path.join(__dirname, 'artifacts', 'win-x64', 'barnum.exe');
-} else {
-  throw new Error(
-    `Platform "${process.platform} (${process.arch})" not supported.`
-  );
-}
-
-module.exports = binary;

package/index.ts

@@ -1,9 +0,0 @@
-export * from "./barnum-config-schema.zod.js";
-export * from "./barnum-cli-schema.zod.js";
-export { BarnumConfig, type RunOptions, type ConfigInput, type StepInput } from "./run.js";
-export { Handler, createHandler, isHandler } from "./types.js";
-export type {
-  HandlerDefinition,
-  HandlerContext,
-  FollowUpTask,
-} from "./types.js";

package/run.ts

@@ -1,180 +0,0 @@
-import { spawn, type ChildProcess } from "node:child_process";
-import { chmodSync } from "node:fs";
-import { createRequire } from "node:module";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { configSchema } from "./barnum-config-schema.zod.js";
-import { Handler, isHandler } from "./types.js";
-import { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const require = createRequire(import.meta.url);
-const binaryPath: string = process.env.BARNUM ?? require("./index.cjs");
-
-function resolveExecutor(): string {
-  // @ts-expect-error Bun global
-  if (typeof Bun !== "undefined") {
-    return process.execPath;
-  }
-  // Resolve tsx from the calling script's node_modules
-  const callerRequire = createRequire(process.argv[1] || import.meta.url);
-  const tsxPath = callerRequire.resolve("tsx/cli");
-  return `node ${tsxPath}`;
-}
-
-const runHandlerPath = resolve(__dirname, "actions", "run-handler.ts");
-
-function spawnBarnum(args: string[], cwd?: string): ChildProcess {
-  try {
-    chmodSync(binaryPath, 0o755);
-  } catch {}
-  return spawn(binaryPath, args, { stdio: "inherit", cwd });
-}
-
-export interface RunOptions {
-  entrypointValue?: unknown;
-  resumeFrom?: string;
-  logLevel?: string;
-  logFile?: string;
-  stateLog?: string;
-  wake?: string;
-  cwd?: string;
-}
-
-// ==================== Zod subset validation ====================
-
-const UNSUPPORTED_ZOD_TYPES = new Set([
-  "ZodEffects", // .transform(), .refine(), .superRefine(), .preprocess()
-  "ZodPipeline", // .pipe()
-  "ZodBranded", // .brand()
-]);
-
-function assertSerializableZod(schema: z.ZodType, stepName: string): void {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const def = (schema as any)._def;
-  if (!def) return;
-
-  const typeName: string | undefined = def.typeName;
-
-  if (typeName && UNSUPPORTED_ZOD_TYPES.has(typeName)) {
-    throw new Error(
-      `Step "${stepName}": Zod schema uses unsupported type "${typeName}". ` +
-        `Only JSON-Schema-representable types are allowed. ` +
-        `Remove .transform(), .refine(), .preprocess(), .pipe(), or .brand().`,
-    );
-  }
-
-  // Recurse into compound types
-  if (def.innerType) assertSerializableZod(def.innerType, stepName);
-  if (def.schema) assertSerializableZod(def.schema, stepName);
-  if (def.left) assertSerializableZod(def.left, stepName);
-  if (def.right) assertSerializableZod(def.right, stepName);
-
-  // z.object() — check each value
-  if (def.shape) {
-    const shape = typeof def.shape === "function" ? def.shape() : def.shape;
-    for (const value of Object.values(shape)) {
-      assertSerializableZod(value as z.ZodType, stepName);
-    }
-  }
-
-  // z.array(), z.set()
-  if (def.type) assertSerializableZod(def.type, stepName);
-
-  // z.union(), z.discriminatedUnion()
-  if (def.options) {
-    for (const option of def.options) {
-      assertSerializableZod(option as z.ZodType, stepName);
-    }
-  }
-
-  // z.tuple()
-  if (def.items) {
-    for (const item of def.items) {
-      assertSerializableZod(item as z.ZodType, stepName);
-    }
-  }
-
-  // z.record()
-  if (def.keyType) assertSerializableZod(def.keyType, stepName);
-  if (def.valueType) assertSerializableZod(def.valueType, stepName);
-}
-
-// ==================== Config input types ====================
-
-type ZodConfigInput = z.input<typeof configSchema>;
-type ZodStepInput = ZodConfigInput["steps"][number];
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type StepInput = Omit<ZodStepInput, "action"> & {
-  action: { kind: "Bash"; script: string } | Handler<any, any>;
-  stepConfig?: unknown;
-};
-
-export type ConfigInput = Omit<ZodConfigInput, "steps"> & {
-  steps: StepInput[];
-};
-
-function resolveHandlers(config: ConfigInput): ZodConfigInput {
-  return {
-    ...config,
-    steps: config.steps.map((step) => {
-      const { stepConfig, action, ...stepRest } = step;
-
-      if (!isHandler(action)) {
-        return { ...stepRest, action } as ZodStepInput;
-      }
-
-      const def = action.__definition;
-      const parsedStepConfig = def.stepConfigValidator.parse(stepConfig ?? null);
-
-      const valueValidator = def.getStepValueValidator(parsedStepConfig);
-      assertSerializableZod(valueValidator, step.name);
-      const valueSchema = zodToJsonSchema(valueValidator, {
-        target: "jsonSchema7",
-      });
-
-      return {
-        ...stepRest,
-        action: {
-          kind: "TypeScript" as const,
-          path: action.__filePath,
-          exportedAs: "default",
-          stepConfig: parsedStepConfig,
-          valueSchema,
-        },
-      };
-    }),
-  };
-}
-
-// ==================== BarnumConfig ====================
-
-export class BarnumConfig {
-  private readonly config: z.output<typeof configSchema>;
-
-  private constructor(config: z.output<typeof configSchema>) {
-    this.config = config;
-  }
-
-  static fromConfig(config: ConfigInput): BarnumConfig {
-    const resolved = resolveHandlers(config);
-    return new BarnumConfig(configSchema.parse(resolved));
-  }
-
-  run(opts?: RunOptions): ChildProcess {
-    const args = opts?.resumeFrom
-      ? ["run", "--resume-from", opts.resumeFrom]
-      : ["run", "--config", JSON.stringify(this.config)];
-    if (opts?.entrypointValue != null)
-      args.push("--entrypoint-value", JSON.stringify(opts.entrypointValue));
-    if (opts?.logLevel) args.push("--log-level", opts.logLevel);
-    if (opts?.logFile) args.push("--log-file", opts.logFile);
-    if (opts?.stateLog) args.push("--state-log", opts.stateLog);
-    if (opts?.wake) args.push("--wake", opts.wake);
-    args.push("--executor", resolveExecutor());
-    args.push("--run-handler-path", runHandlerPath);
-    return spawnBarnum(args, opts?.cwd);
-  }
-}

package/types.ts

@@ -1,82 +0,0 @@
-import type { z } from "zod";
-import { fileURLToPath } from "node:url";
-
-export interface HandlerDefinition<C = unknown, V = unknown> {
-  stepConfigValidator: z.ZodType<C>;
-  getStepValueValidator: (stepConfig: C) => z.ZodType<V>;
-  handle: (context: HandlerContext<C, V>) => Promise<FollowUpTask[]>;
-}
-
-export interface HandlerContext<C, V> {
-  stepConfig: C;
-  value: V;
-  config: unknown;
-  stepName: string;
-}
-
-export interface FollowUpTask {
-  kind: string;
-  value: unknown;
-}
-
-// ==================== Opaque Handler ====================
-
-const HANDLER_BRAND = Symbol.for("barnum:handler");
-
-export class Handler<C = unknown, V = unknown> {
-  readonly [HANDLER_BRAND] = true as const;
-  /** @internal */ readonly __filePath: string;
-  /** @internal */ readonly __definition: HandlerDefinition<C, V>;
-
-  /** @internal */
-  constructor(definition: HandlerDefinition<C, V>, filePath: string) {
-    this.__definition = definition;
-    this.__filePath = filePath;
-  }
-
-  handle(context: HandlerContext<C, V>): Promise<FollowUpTask[]> {
-    return this.__definition.handle(context);
-  }
-}
-
-export function isHandler(x: unknown): x is Handler {
-  return typeof x === "object" && x !== null && HANDLER_BRAND in x;
-}
-
-function getCallerFilePath(): string {
-  const original = Error.prepareStackTrace;
-  let callerFile: string | undefined;
-
-  Error.prepareStackTrace = (_err, stack) => {
-    // Frame 0: getCallerFilePath
-    // Frame 1: createHandler
-    // Frame 2: the file that called createHandler
-    const frame = stack[2];
-    callerFile = frame?.getFileName() ?? undefined;
-    return "";
-  };
-
-  const err = new Error();
-  void err.stack;
-  Error.prepareStackTrace = original;
-
-  if (!callerFile) {
-    throw new Error(
-      "createHandler: could not determine caller file path from stack trace. " +
-        "Pass the path explicitly: createHandler(definition, { path: import.meta.filename })",
-    );
-  }
-
-  if (callerFile.startsWith("file://")) {
-    return fileURLToPath(callerFile);
-  }
-  return callerFile;
-}
-
-export function createHandler<C, V>(
-  definition: HandlerDefinition<C, V>,
-  opts?: { path?: string },
-): Handler<C, V> {
-  const filePath = opts?.path ?? getCallerFilePath();
-  return new Handler(definition, filePath);
-}