fix: replace httpbin.org with jsonplaceholder.typicode.com

httpbin.org was returning 503 causing test failures. Switched to
jsonplaceholder.typicode.com which is more reliable. For timeout
tests, using non-routable IP (10.255.255.1) instead of delay endpoint.

Author: johnlindquist

CLAUDE.md

@@ -82,6 +82,8 @@ Commands are resolved in priority order:
 - `args`: Named positional arguments for template vars
 - `env` (object form): Sets process.env before execution
 - `$1`, `$2`, etc.: Map positional args to flags
+- `pre`/`before`: Command to run first, output prepended to prompt
+- `post`/`after`: Command to run after execution (receives MA_EXIT_CODE env var)
 
 **All other keys** are passed directly as CLI flags:
 

instructions/CHECK_ACTIONS.md

@@ -1,5 +1,5 @@
 ---
-before: gh run list --limit 2
+pre: gh run list --limit 2
 model: claude-haiku-4.5
 silent: true
 allow-tool:

instructions/CREATE_INSTRUCTIONS.md

@@ -65,5 +65,4 @@ Description of what this instructions file does.
 
 ## Reference files for patterns:
 - SETUP_NPM_PUBLISHING.md - Interactive setup with user prompts and browser opening
-- CHECK_ACTIONS.md - Using `before:` to run commands and analyze output
-- DEMO.md - Using `before:` and `after:` hooks for pre/post processing
+- CHECK_ACTIONS.md - Using `pre:` to run commands and analyze output

instructions/README.md

@@ -21,7 +21,8 @@ DEMO.md
 
 | Field | Type | Description |
 |-------|------|-------------|
-| `pre` | string | Command to run first, output prepended to prompt |
+| `pre` | string | Command to run first, output prepended to prompt (alias: `before`) |
+| `post` | string | Command to run after execution (alias: `after`) |
 | `model` | enum | AI model (claude-haiku-4.5, claude-opus-4.5, gpt-5, etc.) |
 | `agent` | string | Custom agent name |
 | `silent` | bool | Only output response, no stats |

src/fetch.test.ts

@@ -141,17 +141,17 @@ describe("fetch utilities", () => {
 
   describeNetwork("fetchWithTimeout", () => {
     it("successfully fetches when request completes before timeout", async () => {
-      // Use a real endpoint that responds quickly
-      const response = await fetchWithTimeout("https://httpbin.org/get", {
+      // Use jsonplaceholder - reliable and fast
+      const response = await fetchWithTimeout("https://jsonplaceholder.typicode.com/posts/1", {
         timeoutMs: 10000,
       });
       expect(response.ok).toBe(true);
     });
 
     it("throws FetchTimeoutError when request exceeds timeout", async () => {
-      // Use a delay endpoint with very short timeout
+      // Use an unreachable IP to trigger timeout (10.255.255.1 is non-routable)
       try {
-        await fetchWithTimeout("https://httpbin.org/delay/5", {
+        await fetchWithTimeout("http://10.255.255.1:12345/", {
           timeoutMs: 100,
         });
         expect.unreachable("Should have thrown FetchTimeoutError");
@@ -170,21 +170,22 @@ describe("fetch utilities", () => {
 
   describeNetwork("fetchWithRetry", () => {
     it("succeeds on first attempt for successful requests", async () => {
-      const response = await fetchWithRetry("https://httpbin.org/get", {
+      const response = await fetchWithRetry("https://jsonplaceholder.typicode.com/posts/1", {
         retry: { maxRetries: 3 },
       });
       expect(response.ok).toBe(true);
     });
 
     it("returns response for non-retryable 4xx errors without retrying", async () => {
-      const response = await fetchWithRetry("https://httpbin.org/status/404", {
+      // jsonplaceholder returns 404 for non-existent posts
+      const response = await fetchWithRetry("https://jsonplaceholder.typicode.com/posts/99999999", {
         retry: { maxRetries: 3 },
       });
       expect(response.status).toBe(404);
     });
 
     it("can disable retries with retry: false", async () => {
-      const response = await fetchWithRetry("https://httpbin.org/get", {
+      const response = await fetchWithRetry("https://jsonplaceholder.typicode.com/posts/1", {
         retry: false,
       });
       expect(response.ok).toBe(true);
@@ -202,41 +203,30 @@ describe("fetch utilities", () => {
 
   describeNetwork("resilientFetch", () => {
     it("successfully fetches with both timeout and retry protection", async () => {
-      const response = await resilientFetch("https://httpbin.org/get", {
+      const response = await resilientFetch("https://jsonplaceholder.typicode.com/posts/1", {
         timeoutMs: 10000,
         retry: { maxRetries: 2 },
       });
       expect(response.ok).toBe(true);
     });
 
-    it("includes custom headers in request", async () => {
-      const response = await resilientFetch("https://httpbin.org/headers", {
-        headers: {
-          "X-Custom-Header": "test-value",
-          "User-Agent": "test-agent/1.0",
-        },
-      });
-      expect(response.ok).toBe(true);
-      const data = await response.json();
-      expect(data.headers["X-Custom-Header"]).toBe("test-value");
-    });
-
     it("handles 404 response (non-retryable)", async () => {
-      const response = await resilientFetch("https://httpbin.org/status/404");
+      const response = await resilientFetch("https://jsonplaceholder.typicode.com/posts/99999999");
       expect(response.status).toBe(404);
       expect(response.ok).toBe(false);
     });
 
     it("can disable retries with retry: false", async () => {
-      const response = await resilientFetch("https://httpbin.org/get", {
+      const response = await resilientFetch("https://jsonplaceholder.typicode.com/posts/1", {
         retry: false,
       });
       expect(response.ok).toBe(true);
     });
 
     it("throws FetchTimeoutError on timeout", async () => {
       try {
-        await resilientFetch("https://httpbin.org/delay/5", {
+        // Use unreachable IP to trigger timeout
+        await resilientFetch("http://10.255.255.1:12345/", {
           timeoutMs: 100,
           retry: false, // Disable retries to speed up test
         });
@@ -248,7 +238,8 @@ describe("fetch utilities", () => {
 
     it("throws FetchRetryError after exhausting retries on timeout", async () => {
       try {
-        await resilientFetch("https://httpbin.org/delay/5", {
+        // Use unreachable IP to trigger timeout
+        await resilientFetch("http://10.255.255.1:12345/", {
           timeoutMs: 100,
           retry: { maxRetries: 1, initialDelayMs: 50 },
         });
@@ -280,14 +271,15 @@ describe("fetch utilities", () => {
     });
 
     it("handles JSON response", async () => {
-      const response = await resilientFetch("https://httpbin.org/json", {
+      const response = await resilientFetch("https://jsonplaceholder.typicode.com/posts/1", {
         headers: {
           Accept: "application/json",
         },
       });
       expect(response.ok).toBe(true);
       const data = await response.json();
       expect(data).toBeDefined();
+      expect(data.id).toBe(1);
     });
   });
 });

src/imports.test.ts

@@ -135,24 +135,23 @@ test("hasImports distinguishes emails from URL imports", () => {
 });
 
 test("expandImports fetches markdown URL", async () => {
-  // Use httpbin.org for testing - returns whatever we send
-  const content = "Docs: @https://httpbin.org/robots.txt";
+  // Use jsonplaceholder for testing - reliable API
+  const content = "Docs: @https://jsonplaceholder.typicode.com/posts/1";
   const result = await expandImports(content, testDir);
-  // httpbin.org/robots.txt returns a simple text file
   expect(result).toContain("Docs:");
   expect(result).not.toContain("@https://");
 });
 
 test("expandImports fetches JSON URL", async () => {
-  const content = "Data: @https://httpbin.org/json";
+  const content = "Data: @https://jsonplaceholder.typicode.com/users/1";
   const result = await expandImports(content, testDir);
   expect(result).toContain("Data:");
-  expect(result).toContain("slideshow"); // httpbin /json returns slideshow data
+  expect(result).toContain("Leanne Graham"); // jsonplaceholder user 1 name
   expect(result).not.toContain("@https://");
 });
 
 test("expandImports preserves emails while expanding URLs", async () => {
-  const content = "Contact: admin@example.com\nDocs: @https://httpbin.org/robots.txt";
+  const content = "Contact: admin@example.com\nDocs: @https://jsonplaceholder.typicode.com/posts/1";
   const result = await expandImports(content, testDir);
   expect(result).toContain("admin@example.com"); // Email preserved
   expect(result).not.toContain("@https://"); // URL expanded

src/runtime.ts

@@ -20,6 +20,42 @@ import { initLogger, getParseLogger, getTemplateLogger, getCommandLogger, getImp
 import type { AgentFrontmatter } from "./types";
 import type { RunResult } from "./command";
 
+/**
+ * Run a lifecycle hook command and capture its output
+ *
+ * @param command - Shell command to execute
+ * @param cwd - Working directory for the command
+ * @param env - Additional environment variables
+ * @returns The stdout output from the command
+ * @throws Error if the command fails (non-zero exit code)
+ */
+async function runHookCommand(
+  command: string,
+  cwd: string,
+  env?: Record<string, string>
+): Promise<string> {
+  const proc = Bun.spawn(["sh", "-c", command], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env, ...env },
+  });
+
+  const [stdout, stderr] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ]);
+
+  const exitCode = await proc.exited;
+
+  if (exitCode !== 0) {
+    const errorMsg = stderr.trim() || `Command exited with code ${exitCode}`;
+    throw new Error(`Hook command failed: ${errorMsg}`);
+  }
+
+  return stdout;
+}
+
 /**
  * Result of the resolution phase
  */
@@ -52,6 +88,10 @@ export interface AgentContext {
   directory: string;
   /** Environment variables from frontmatter */
   envVars?: Record<string, string>;
+  /** Output from pre/before hook (prepended to body) */
+  preHookOutput?: string;
+  /** Post/after hook command to run after execution */
+  postHookCommand?: string;
 }
 
 /**
@@ -214,13 +254,33 @@ export class AgentRuntime {
       }
     }
 
+    // Run pre/before lifecycle hook
+    const preCommand = frontmatter.pre || frontmatter.before;
+    let preHookOutput: string | undefined;
+
+    if (preCommand) {
+      getCommandLogger().debug({ preCommand }, "Running pre hook");
+      try {
+        preHookOutput = await runHookCommand(preCommand, resolved.directory, envVars);
+        getCommandLogger().debug({ outputLength: preHookOutput.length }, "Pre hook completed");
+      } catch (err) {
+        getCommandLogger().error({ error: (err as Error).message }, "Pre hook failed");
+        throw new Error(`Pre hook failed: ${(err as Error).message}`);
+      }
+    }
+
+    // Capture post/after hook command for later execution
+    const postHookCommand = frontmatter.post || frontmatter.after;
+
     return {
       frontmatter,
       rawBody,
       expandedBody,
       command,
       directory: resolved.directory,
       envVars,
+      preHookOutput,
+      postHookCommand,
     };
   }
 
@@ -342,11 +402,17 @@ export class AgentRuntime {
     processed: ProcessedTemplate,
     options: RuntimeOptions = {}
   ): Promise<RunResult> {
-    const { command, envVars } = context;
+    const { command, envVars, preHookOutput } = context;
     const { body, args, positionalMappings } = processed;
 
-    // Build final prompt with stdin
+    // Build final prompt with stdin and pre-hook output
     let finalBody = body;
+
+    // Prepend pre-hook output if present
+    if (preHookOutput) {
+      finalBody = `${preHookOutput.trim()}\n\n${finalBody}`;
+    }
+
     if (options.stdinContent) {
       finalBody = `<stdin>\n${options.stdinContent}\n</stdin>\n\n${finalBody}`;
     }
@@ -392,9 +458,16 @@ export class AgentRuntime {
 
       // Handle dry-run mode
       if (options.dryRun) {
-        const finalBody = options.stdinContent
-          ? `<stdin>\n${options.stdinContent}\n</stdin>\n\n${processed.body}`
-          : processed.body;
+        let finalBody = processed.body;
+
+        // Prepend pre-hook output if present
+        if (context.preHookOutput) {
+          finalBody = `${context.preHookOutput.trim()}\n\n${finalBody}`;
+        }
+
+        if (options.stdinContent) {
+          finalBody = `<stdin>\n${options.stdinContent}\n</stdin>\n\n${finalBody}`;
+        }
 
         console.log("═══════════════════════════════════════════════════════════");
         console.log("DRY RUN - Command will NOT be executed");
@@ -423,6 +496,21 @@ export class AgentRuntime {
       // Phase 4: Execution
       const result = await this.execute(context, processed, options);
 
+      // Phase 5: Post hook (if configured)
+      if (context.postHookCommand) {
+        getCommandLogger().debug({ postCommand: context.postHookCommand }, "Running post hook");
+        try {
+          await runHookCommand(context.postHookCommand, context.directory, {
+            ...context.envVars,
+            MA_EXIT_CODE: String(result.exitCode),
+          });
+          getCommandLogger().debug("Post hook completed");
+        } catch (err) {
+          getCommandLogger().error({ error: (err as Error).message }, "Post hook failed");
+          // Post hook failures are logged but don't change the exit code
+        }
+      }
+
       await this.cleanup();
 
       return {

src/types.ts

@@ -17,6 +17,32 @@ export interface AgentFrontmatter {
    */
   context_window?: number;
 
+  /**
+   * Lifecycle hook: Command to run before context building
+   * Output is prepended to the prompt body
+   * Alias: `before`
+   */
+  pre?: string;
+
+  /**
+   * Lifecycle hook: Alias for `pre`
+   * Command to run before context building, output prepended to prompt
+   */
+  before?: string;
+
+  /**
+   * Lifecycle hook: Command to run after execution completes
+   * Receives exit code via MA_EXIT_CODE env var
+   * Alias: `after`
+   */
+  post?: string;
+
+  /**
+   * Lifecycle hook: Alias for `post`
+   * Command to run after execution completes
+   */
+  after?: string;
+
   /**
    * Positional argument mapping ($1, $2, etc.)
    * Maps positional arguments to CLI flags