<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Henry Huang</title>
    <description>The latest articles on DEV Community by Henry Huang (@hslcalgary).</description>
    <link>https://dev.to/hslcalgary</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4217612%2F6cd50cc3-3183-407d-b165-b83fa82cd781.png</url>
      <title>DEV Community: Henry Huang</title>
      <link>https://dev.to/hslcalgary</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/hslcalgary"/>
    <language>en</language>
    <item>
      <title>Import a Postman collection, run it headlessly with HTTP Forge, emit JUnit, and wire it into GitHub Actions — no Postman or Newman required</title>
      <dc:creator>Henry Huang</dc:creator>
      <pubDate>Fri, 30 Oct 2026 22:08:30 +0000</pubDate>
      <link>https://dev.to/hslcalgary/import-a-postman-collection-run-it-headlessly-with-http-forge-emit-junit-and-wire-it-into-github-53k6</link>
      <guid>https://dev.to/hslcalgary/import-a-postman-collection-run-it-headlessly-with-http-forge-emit-junit-and-wire-it-into-github-53k6</guid>
      <description>&lt;div class="ltag__link--embedded"&gt;
  &lt;div class="crayons-story "&gt;
  &lt;a href="https://dev.to/hslcalgary/how-to-run-postman-collections-in-ci-without-postman-125m" class="crayons-story__hidden-navigation-link"&gt;How to run Postman collections in CI without Postman or Newman&lt;/a&gt;


  &lt;div class="crayons-story__body crayons-story__body-full_post"&gt;
    &lt;div class="crayons-story__top"&gt;
      &lt;div class="crayons-story__meta"&gt;
        &lt;div class="crayons-story__author-pic"&gt;

          &lt;a href="/hslcalgary" class="crayons-avatar  crayons-avatar--l  "&gt;
            &lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4217612%2F6cd50cc3-3183-407d-b165-b83fa82cd781.png" alt="hslcalgary profile" class="crayons-avatar__image"&gt;
          &lt;/a&gt;
        &lt;/div&gt;
        &lt;div&gt;
          &lt;div&gt;
            &lt;a href="/hslcalgary" class="crayons-story__secondary fw-medium m:hidden"&gt;
              Henry Huang
            &lt;/a&gt;
            &lt;div class="profile-preview-card relative mb-4 s:mb-0 fw-medium hidden m:inline-block"&gt;
              
                Henry Huang
                
                
              
              &lt;div id="story-author-preview-content-4948812" class="profile-preview-card__content crayons-dropdown branded-7 p-4 pt-0"&gt;
                &lt;div class="gap-4 grid"&gt;
                  &lt;div class="-mt-4"&gt;
                    &lt;a href="/hslcalgary" class="flex"&gt;
                      &lt;span class="crayons-avatar crayons-avatar--xl mr-2 shrink-0"&gt;
                        &lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4217612%2F6cd50cc3-3183-407d-b165-b83fa82cd781.png" class="crayons-avatar__image" alt=""&gt;
                      &lt;/span&gt;
                      &lt;span class="crayons-link crayons-subtitle-2 mt-5"&gt;Henry Huang&lt;/span&gt;
                    &lt;/a&gt;
                  &lt;/div&gt;
                  &lt;div class="print-hidden"&gt;
                    
                      Follow
                    
                  &lt;/div&gt;
                  &lt;div class="author-preview-metadata-container"&gt;&lt;/div&gt;
                &lt;/div&gt;
              &lt;/div&gt;
            &lt;/div&gt;

          &lt;/div&gt;
          &lt;a href="https://dev.to/hslcalgary/how-to-run-postman-collections-in-ci-without-postman-125m" class="crayons-story__tertiary fs-xs"&gt;&lt;time&gt;Oct 30&lt;/time&gt;&lt;span class="time-ago-indicator-initial-placeholder"&gt;&lt;/span&gt;&lt;/a&gt;
        &lt;/div&gt;
      &lt;/div&gt;

    &lt;/div&gt;

    &lt;div class="crayons-story__indention"&gt;
      &lt;h2 class="crayons-story__title crayons-story__title-full_post"&gt;
        &lt;a href="https://dev.to/hslcalgary/how-to-run-postman-collections-in-ci-without-postman-125m" id="article-link-4948812"&gt;
          How to run Postman collections in CI without Postman or Newman
        &lt;/a&gt;
      &lt;/h2&gt;
        &lt;div class="crayons-story__tags"&gt;
            &lt;a class="crayons-tag  crayons-tag--monochrome " href="/t/postman"&gt;&lt;span class="crayons-tag__prefix"&gt;#&lt;/span&gt;postman&lt;/a&gt;
            &lt;a class="crayons-tag  crayons-tag--monochrome " href="/t/api"&gt;&lt;span class="crayons-tag__prefix"&gt;#&lt;/span&gt;api&lt;/a&gt;
            &lt;a class="crayons-tag  crayons-tag--monochrome " href="/t/ci"&gt;&lt;span class="crayons-tag__prefix"&gt;#&lt;/span&gt;ci&lt;/a&gt;
            &lt;a class="crayons-tag  crayons-tag--monochrome " href="/t/githubactions"&gt;&lt;span class="crayons-tag__prefix"&gt;#&lt;/span&gt;githubactions&lt;/a&gt;
        &lt;/div&gt;
      &lt;div class="crayons-story__bottom"&gt;
        &lt;div class="crayons-story__details"&gt;
          &lt;a href="https://dev.to/hslcalgary/how-to-run-postman-collections-in-ci-without-postman-125m" class="crayons-btn crayons-btn--s crayons-btn--ghost crayons-btn--icon-left"&gt;
            &lt;div class="multiple_reactions_aggregate"&gt;
              &lt;span class="multiple_reactions_icons_container"&gt;
                  &lt;span class="crayons_icon_container"&gt;
                    &lt;img src="https://assets.dev.to/assets/sparkle-heart-5f9bee3767e18deb1bb725290cb151c25234768a0e9a2bd39370c382d02920cf.svg" width="18" height="18"&gt;
                  &lt;/span&gt;
              &lt;/span&gt;
              &lt;span class="aggregate_reactions_counter"&gt;1&lt;span class="hidden s:inline"&gt;&amp;nbsp;reaction&lt;/span&gt;&lt;/span&gt;
            &lt;/div&gt;
          &lt;/a&gt;
            &lt;a href="https://dev.to/hslcalgary/how-to-run-postman-collections-in-ci-without-postman-125m#comments" class="crayons-btn crayons-btn--s crayons-btn--ghost crayons-btn--icon-left flex items-center"&gt;
              

              &lt;span class="hidden s:inline"&gt;Add&amp;nbsp;Comment&lt;/span&gt;
            &lt;/a&gt;
        &lt;/div&gt;
        &lt;div class="crayons-story__save"&gt;
          &lt;small class="crayons-story__tertiary fs-xs mr-2"&gt;
            6 min read
          &lt;/small&gt;
          
          &lt;div class="only-sidebar-menu-item trusted-visible-block print-hidden align-center"&gt;
                
                    
                
          &lt;/div&gt;

        &lt;/div&gt;
      &lt;/div&gt;
    &lt;/div&gt;
  &lt;/div&gt;
&lt;/div&gt;

&lt;/div&gt;


</description>
      <category>github</category>
      <category>automation</category>
      <category>testing</category>
      <category>ci</category>
    </item>
    <item>
      <title>Why I built HTTP Forge when Postman, Thunder Client, Bruno, and Insomnia already exist</title>
      <dc:creator>Henry Huang</dc:creator>
      <pubDate>Fri, 30 Oct 2026 18:25:25 +0000</pubDate>
      <link>https://dev.to/hslcalgary/why-i-built-http-forge-when-postman-thunder-client-bruno-and-insomnia-already-exist-4f03</link>
      <guid>https://dev.to/hslcalgary/why-i-built-http-forge-when-postman-thunder-client-bruno-and-insomnia-already-exist-4f03</guid>
      <description>&lt;h1&gt;
  
  
  Why I built &lt;strong&gt;HTTP Forge&lt;/strong&gt; when Postman, Thunder Client, Bruno, and Insomnia already exist
&lt;/h1&gt;

&lt;p&gt;A fair question: the API testing space is crowded. Postman is the default, Thunder Client is inside VS Code, Bruno made collections git-native, and Insomnia has a loyal following. Why build another one?&lt;/p&gt;

&lt;p&gt;Because none of them solved the problem I actually had — and the biggest part of that problem was making the whole test lifecycle something an &lt;strong&gt;AI agent could actually drive&lt;/strong&gt;, not just a chat panel bolted onto a request composer.&lt;/p&gt;

&lt;p&gt;That's the most important win of HTTP Forge: it is &lt;strong&gt;AI-native and AI-driven&lt;/strong&gt;. Everything else in this article — the source discovery, the file model, the CLI, the drift detection — exists to make that possible.&lt;/p&gt;

&lt;h2&gt;
  
  
  The problem wasn't "send an HTTP request"
&lt;/h2&gt;

&lt;p&gt;Sending a request is a solved problem. Every one of those tools does it well. My problem was the lifecycle &lt;em&gt;after&lt;/em&gt; the first request worked:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;The API grows to dozens of endpoints.&lt;/li&gt;
&lt;li&gt;Someone hand-authors requests and assertions in a collection.&lt;/li&gt;
&lt;li&gt;The backend changes — a route moves, a DTO gains a field, an auth header changes.&lt;/li&gt;
&lt;li&gt;The collection goes stale.&lt;/li&gt;
&lt;li&gt;Nobody trusts it, so nobody runs it.&lt;/li&gt;
&lt;li&gt;Six months later it's deleted and rewritten from scratch.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;That cycle is the maintenance tax. It's not a tooling bug; it's a structural problem. A collection is a &lt;em&gt;copy&lt;/em&gt; of your API, maintained by hand, with no link back to the source of truth.&lt;/p&gt;

&lt;p&gt;I wanted a tool where the tests could be &lt;strong&gt;derived from the code&lt;/strong&gt; and &lt;strong&gt;regenerated when the code changed&lt;/strong&gt; — without losing the assertions I'd hand-edited.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the existing tools get right
&lt;/h2&gt;

&lt;p&gt;I don't think the incumbents are bad. They're good at different things:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Postman&lt;/strong&gt; — the best onboarding, the biggest ecosystem, great for sharing with non-developers. If your team already lives in it, the switching cost is real.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Thunder Client&lt;/strong&gt; — the lowest-friction option if you're already in VS Code. Open the panel, send a request, done.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Bruno&lt;/strong&gt; — collections as plain text files. A genuine improvement for version control, and a strong local-first stance.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Insomnia&lt;/strong&gt; — a polished UI and a good developer experience, especially for GraphQL.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The gap wasn't the request composer. It was the connection between the request composer and the codebase.&lt;/p&gt;

&lt;h2&gt;
  
  
  The gap, and the loop that closes it
&lt;/h2&gt;

&lt;p&gt;Most tools treat the collection as the artifact. For an existing backend, HTTP Forge treats the &lt;strong&gt;source code&lt;/strong&gt; as the source of truth and lets the collection be derived from it. For a greenfield API, the designed OpenAPI spec fills that role until there's source to discover.&lt;br&gt;
&lt;/p&gt;

&lt;pre data-lang="mermaid"&gt;&lt;code&gt;flowchart TB
    design["Design from intent"] --&amp;gt; generate["Generate&amp;lt;br/&amp;gt;requests + suites"]
    discover["Discover from source"] --&amp;gt; generate
    generate --&amp;gt; edit["Edit&amp;lt;br/&amp;gt;(files in the repo)"]
    edit --&amp;gt; run["Run&amp;lt;br/&amp;gt;editor / CLI / CI / MCP"]
    run --&amp;gt; report["Report&amp;lt;br/&amp;gt;HTML / JUnit"]
    report --&amp;gt; fix["Fix&amp;lt;br/&amp;gt;explain / heal"]
    fix --&amp;gt; edit&lt;/code&gt;&lt;/pre&gt;



&lt;p&gt;That full lifecycle — &lt;strong&gt;design from intent or discover from source → generate → edit → run → report → fix → re-run&lt;/strong&gt; (see &lt;a href="https://github.com/hsl1230/http-forge/blob/HEAD/docs/user-guide/getting-started.md" rel="noopener noreferrer"&gt;Getting Started&lt;/a&gt;) — is the whole idea. Design covers the greenfield case (&lt;code&gt;http-forge architect&lt;/code&gt;, MCP &lt;code&gt;design_api_from_intent&lt;/code&gt;); discovery covers the existing backend and runs at the start of the loop, not only after a change. Everything after that operates on the same files.&lt;/p&gt;

&lt;p&gt;The lifecycle is actor-agnostic. Every step can be driven by a human in the extension or CLI, or by an &lt;strong&gt;AI agent&lt;/strong&gt; through the MCP server and CLI. You can accept the generated requests and suites as-is and run them — &lt;strong&gt;no manual edit is required&lt;/strong&gt; to get a working, runnable suite — or edit any file at any stage. The artifacts are plain files with published schemas, so both a person and an &lt;strong&gt;agent&lt;/strong&gt; can read, validate, and change them.&lt;/p&gt;

&lt;p&gt;The loop changes the maintenance equation:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;You don't hand-author requests for every endpoint.&lt;/li&gt;
&lt;li&gt;You don't lose hand-edited assertions when you regenerate.&lt;/li&gt;
&lt;li&gt;You get told when the source has drifted from the stored index.&lt;/li&gt;
&lt;li&gt;The &lt;strong&gt;agent&lt;/strong&gt; that discovers an endpoint can write the request, generate the suite, run it, read the JUnit report, and propose an assertion fix without a translation layer.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Postman can't do this because it doesn't read your backend. Bruno can't because it's a collection store, not a code analyzer. Thunder Client is a client. That's not a criticism — it's a different category.&lt;/p&gt;

&lt;p&gt;Drift is a separate maintenance check on top of the lifecycle:&lt;br&gt;
&lt;/p&gt;

&lt;pre data-lang="mermaid"&gt;&lt;code&gt;flowchart TB
    scan["Initial discovery"] --&amp;gt; index["Stored index&amp;lt;br/&amp;gt;(git hash + source mtimes)"]
    index --&amp;gt; check{"Source changed?"}
    check --&amp;gt;|"no"| current["Current"]
    check --&amp;gt;|"yes"| stale["Stale"]
    stale --&amp;gt; rescan["Re-discover"]
    rescan --&amp;gt; merge["Regenerate with 3-way diff&amp;lt;br/&amp;gt;(preserves hand edits)"]&lt;/code&gt;&lt;/pre&gt;



&lt;h2&gt;
  
  
  What HTTP Forge actually is
&lt;/h2&gt;

&lt;p&gt;HTTP Forge is three surfaces over one engine:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;VS Code extension&lt;/strong&gt; — request tester, collections tree, test suites, environment editor, discovery view.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;CLI&lt;/strong&gt; — headless runs, CI integration, discovery, suite generation, QA gate, drift checks.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;MCP server&lt;/strong&gt; — 60+ tools so AI agents can discover, generate, run, diagnose, and heal tests.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;They share &lt;code&gt;@http-forge/core&lt;/code&gt;, which is open source (MIT). That matters because it means the behavior is the same everywhere: a collection that runs in the editor runs in CI, and an agent calling &lt;code&gt;run_suite&lt;/code&gt; uses the same engine as &lt;code&gt;http-forge run suite&lt;/code&gt;.&lt;/p&gt;

&lt;h3&gt;
  
  
  The most important win: &lt;strong&gt;the lifecycle is AI-native&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;In most API tools I've used, AI is an assistant inside the UI: "generate an assertion," "explain this response." That's useful, but the agent is still working inside a human's workflow. It can't operate the tool end-to-end.&lt;/p&gt;

&lt;p&gt;HTTP Forge was designed the other way around. The MCP server exposes the whole lifecycle as tools:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;design_api_from_intent&lt;/code&gt; → design a greenfield API.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;create_request_from_endpoint&lt;/code&gt; / &lt;code&gt;generate_test_suite&lt;/code&gt; → discover and generate.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;run_request&lt;/code&gt; / &lt;code&gt;run_collection&lt;/code&gt; / &lt;code&gt;run_suite&lt;/code&gt; → execute.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;get_run_summary&lt;/code&gt; / &lt;code&gt;get_failed_requests&lt;/code&gt; / &lt;code&gt;explain_failure&lt;/code&gt; → diagnose.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;heal_assertions&lt;/code&gt; + &lt;code&gt;set_request_script&lt;/code&gt; → propose and apply a fix.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;An &lt;strong&gt;agent&lt;/strong&gt; can chain those calls to go from source code to a green test run without a human hand-editing a request. A human can also do every step through the extension or CLI. The same files, the same engine, the same results — the only difference is who is driving.&lt;/p&gt;

&lt;p&gt;In practice, the cheapest split is: &lt;strong&gt;CLI for execution&lt;/strong&gt; (one command, compact JSON, low token cost) and &lt;strong&gt;MCP for structured state changes and rich inspection&lt;/strong&gt; (validated arguments, &lt;code&gt;explain_failure&lt;/code&gt;, &lt;code&gt;heal_assertions&lt;/code&gt;). Both operate on the same workspace, so the agent can switch without a translation layer.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Why this works is the file model.&lt;/strong&gt; The agent isn't calling an opaque API and hoping the state is right. It's reading and writing documented JSON files in the same workspace as the code, with published schemas to validate against. It can inspect a &lt;code&gt;request.json&lt;/code&gt;, see the controller it targets, edit the &lt;code&gt;*.suite.json&lt;/code&gt;, run it, read the JUnit report, and fix the assertion — all in one context. That's the difference between "AI-assisted" and "AI-native."&lt;/p&gt;

&lt;h3&gt;
  
  
  One command to a dedicated window
&lt;/h3&gt;

&lt;p&gt;A common objection to "it's a VS Code extension" is setup friction: &lt;em&gt;I don't want to assemble an editor profile just to try an API client.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;So the CLI can do it for you:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;http-forge launch &lt;span class="nt"&gt;--test&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That downloads VS Code if needed, installs HTTP Forge and GitHub Copilot into an isolated &lt;code&gt;"HTTP Forge"&lt;/code&gt; profile, and opens a dedicated window with no other extensions competing for space. Add &lt;code&gt;--examples&lt;/code&gt; and it clones a sample workspace with ready-to-run collections and suites.&lt;/p&gt;

&lt;p&gt;It's still VS Code under the hood — not a standalone desktop app — but it removes the setup step. For someone who just wants to try the tool, that's the difference between "install and go" and "configure an editor first."&lt;/p&gt;

&lt;h2&gt;
  
  
  The workspace is the database
&lt;/h2&gt;

&lt;p&gt;This is the decision I'd make again first: HTTP Forge stores requests and suites as &lt;strong&gt;plain files in the same workspace as the code&lt;/strong&gt;, not in an opaque app database.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;my-project/
├── src/                         # your backend
└── .http-forge/                 # or a configured storage root
    ├── collections/
    │   └── my-api/
    │       ├── collection.json
    │       ├── auth/
    │       │   ├── folder.json
    │       │   └── login/
    │       │       ├── request.json
    │       │       └── scripts/
    │       │           ├── pre-request.js
    │       │           └── post-response.js
    │       └── users/
    │           └── get-users/
    │               └── request.json
    ├── suites/
    │   └── smoke-tests.suite.json
    └── environments/
        └── staging.json
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Why files matter:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;They diff like code.&lt;/strong&gt; A request change shows up in a PR. A suite change is reviewable. Nothing is hidden in a binary store.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;They live with the code.&lt;/strong&gt; An AI agent working in the repo can read the request and the controller it tests in the same context — no export, no copy, no synchronisation step.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;They have schemas.&lt;/strong&gt; Collections, folders, requests, suites, environments, and config all have published JSON Schema definitions (&lt;code&gt;collection.schema.json&lt;/code&gt;, &lt;code&gt;folder.schema.json&lt;/code&gt;, &lt;code&gt;request.schema.json&lt;/code&gt;, &lt;code&gt;suite.schema.json&lt;/code&gt;, &lt;code&gt;environment.schema.json&lt;/code&gt;, &lt;code&gt;http-forge.config.schema.json&lt;/code&gt;). An agent can validate what it writes instead of guessing at a shape.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;They're portable.&lt;/strong&gt; Move the folder, commit it, branch it, or let CI read it. There's no migration tool.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That combination — pure files + published schemas + the code in the same workspace — is what makes agent-driven work practical. The agent isn't calling an opaque API and hoping; it's editing a documented artifact in the repo, and the tool validates it.&lt;/p&gt;

&lt;h3&gt;
  
  
  Source control is the collaboration model
&lt;/h3&gt;

&lt;p&gt;Because the artifacts are files, git is the collaboration layer — not a proprietary sync service.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Reviewable changes.&lt;/strong&gt; &lt;code&gt;git diff&lt;/code&gt; on a &lt;code&gt;request.json&lt;/code&gt; or &lt;code&gt;*.suite.json&lt;/code&gt; shows exactly what changed: URL, headers, assertions, suite nodes. Reviewers can approve or reject a test change the same way they review application code.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Blame and history.&lt;/strong&gt; &lt;code&gt;git blame&lt;/code&gt; tells you who changed an assertion and when. &lt;code&gt;git log -p&lt;/code&gt; shows the evolution of a suite. That context is lost in an opaque tool database.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Branches and PRs.&lt;/strong&gt; A feature branch can change the API and its tests together. The test change is part of the same PR, reviewed by the same people, merged atomically.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Merge conflicts are normal text conflicts.&lt;/strong&gt; Two people editing different requests don't collide. Two people editing the same assertion get a standard conflict to resolve, not a "collection is locked" error.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;CI reads the same commit.&lt;/strong&gt; The pipeline runs the exact tests that were reviewed in the PR — no export, no upload, no "which version is in the cloud?" question.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Works in monorepos.&lt;/strong&gt; Point the storage root at a subfolder and keep API tests next to the service they cover.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That's the practical difference from a cloud collection: version control stops being an afterthought and becomes the way tests are shared, reviewed, and kept honest.&lt;/p&gt;

&lt;h2&gt;
  
  
  Design decisions that came from the problem
&lt;/h2&gt;

&lt;p&gt;A few choices only make sense in hindsight, but they all trace back to "tests must survive change":&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;1. Discovery reads source, not specs.&lt;/strong&gt;&lt;br&gt;
OpenAPI is great when it exists. It often doesn't, or it's stale. Reading source means there's no spec maintenance step before you can test. Six providers today: Express, NestJS, Fastify, AWS Lambda, Spring, FastAPI.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2. Generated artifacts are marked as generated.&lt;/strong&gt;&lt;br&gt;
Suites generated from discovery carry &lt;code&gt;ai_generated: true&lt;/code&gt; and &lt;code&gt;derived_from: &amp;lt;endpointId&amp;gt;&lt;/code&gt;. That provenance is what makes safe regeneration possible: only generated regions are regenerable; hand edits are preserved.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3. Drift is a first-class concept.&lt;/strong&gt;&lt;br&gt;
The index stores a git hash and source mtimes. In a git work tree, drift compares the current HEAD hash; without git, it degrades to mtime-only. No signal at all? It reports &lt;code&gt;unknown&lt;/code&gt; rather than pretending everything is fine.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;4. The CLI is not an afterthought.&lt;/strong&gt;&lt;br&gt;
Building the CLI early forced the core to stay headless and UI-free. That's why the MCP server and CI integration were straightforward later.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;5. AI-native is the point, not a feature.&lt;/strong&gt;&lt;br&gt;
The MCP tools aren't a chat add-on; they're the lifecycle exposed as tools. An agent can discover, generate, run, diagnose, and heal without hand-editing anything, and every artifact it produces is plain text in the repo, so a human can review, edit, or revert it. Output is bounded, errors are structured, and &lt;code&gt;heal_assertions&lt;/code&gt; is advisory: the agent writes the new script, and the change is visible in git like any other edit. There's no hidden state and no "AI silently rewrites your tests" path. This is the win everything else is built to support.&lt;/p&gt;
&lt;h2&gt;
  
  
  What I deliberately didn't build
&lt;/h2&gt;

&lt;p&gt;Scope is a feature.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Not a standalone desktop app.&lt;/strong&gt; HTTP Forge lives in VS Code and the terminal. If you want a separate app window, Bruno or Postman are better fits.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Not a cloud service.&lt;/strong&gt; No account, no sync, no per-seat pricing. Local-first by default.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Not a replacement for contract testing.&lt;/strong&gt; Pact and schema validation solve a different problem. HTTP Forge generates and runs functional tests; pair it with contract testing when you need it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Not a full API design/management suite.&lt;/strong&gt; &lt;code&gt;http-forge architect&lt;/code&gt; can generate a starting OpenAPI spec, but design-first collaboration and mocking still belong in dedicated tools.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;
  
  
  Who it's for
&lt;/h2&gt;

&lt;p&gt;HTTP Forge is for teams that:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Are willing to work in VS Code or the terminal.&lt;/li&gt;
&lt;li&gt;Have a backend whose source they can point at.&lt;/li&gt;
&lt;li&gt;Are tired of hand-maintaining collections.&lt;/li&gt;
&lt;li&gt;Want tests that run in CI and can be driven by an AI agent.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;It's probably &lt;em&gt;not&lt;/em&gt; for you if:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;You need a standalone desktop client.&lt;/li&gt;
&lt;li&gt;Your API has no accessible source (third-party APIs). In that case, import an OpenAPI spec or use a collection-first tool.&lt;/li&gt;
&lt;li&gt;Your team is deeply invested in Postman's ecosystem (monitors, mock servers, shared workspaces) and the switching cost outweighs the maintenance savings.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;
  
  
  The honest pitch
&lt;/h2&gt;

&lt;p&gt;Postman, Thunder Client, Bruno, and Insomnia are good tools. I used them. HTTP Forge exists because I wanted something they don't do: &lt;strong&gt;make the entire API-test lifecycle something an AI agent can drive, while keeping the tests connected to the code that defines the API.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The AI-native part is the headline. The source discovery, plain-file workspace, published schemas, CLI, and drift detection are what make that headline real instead of a demo.&lt;/p&gt;

&lt;p&gt;That's the bet. If it resonates, try it:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npm &lt;span class="nb"&gt;install&lt;/span&gt; &lt;span class="nt"&gt;-g&lt;/span&gt; @http-forge/cli
http-forge launch &lt;span class="nt"&gt;--examples&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That clones a sample workspace with pre-built requests, environments, and suites, and opens it in VS Code. No account and no manual setup.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;HTTP Forge for VS Code:&lt;/strong&gt; &lt;a href="https://marketplace.visualstudio.com/items?itemName=henry-huang.http-forge" rel="noopener noreferrer"&gt;https://marketplace.visualstudio.com/items?itemName=henry-huang.http-forge&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Open-source core:&lt;/strong&gt; &lt;a href="https://github.com/hsl1230/http-forge.core" rel="noopener noreferrer"&gt;https://github.com/hsl1230/http-forge.core&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;CLI docs:&lt;/strong&gt; &lt;a href="https://github.com/hsl1230/http-forge.cli/blob/main/docs/cli-reference.md" rel="noopener noreferrer"&gt;https://github.com/hsl1230/http-forge.cli/blob/main/docs/cli-reference.md&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If you've solved the "collections rot" problem differently, I'd genuinely like to hear how. That's the conversation this article is meant to start.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>mcp</category>
      <category>api</category>
      <category>agents</category>
    </item>
    <item>
      <title>How to run Postman collections in CI without Postman or Newman</title>
      <dc:creator>Henry Huang</dc:creator>
      <pubDate>Fri, 30 Oct 2026 17:39:22 +0000</pubDate>
      <link>https://dev.to/hslcalgary/how-to-run-postman-collections-in-ci-without-postman-125m</link>
      <guid>https://dev.to/hslcalgary/how-to-run-postman-collections-in-ci-without-postman-125m</guid>
      <description>&lt;p&gt;You have a Postman collection. It works on your machine. Now you want it to run on every pull request without installing Postman, paying for a cloud runner, or asking everyone to learn Newman.&lt;/p&gt;

&lt;p&gt;This is a practical guide to doing exactly that with the HTTP Forge CLI:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Import the Postman collection and environment.&lt;/li&gt;
&lt;li&gt;Run the collection headlessly.&lt;/li&gt;
&lt;li&gt;Emit a JUnit report.&lt;/li&gt;
&lt;li&gt;Wire it into GitHub Actions.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;No GUI required after the import.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why not just use Newman?
&lt;/h2&gt;

&lt;p&gt;Newman is the obvious answer, and it works. But it has a few sharp edges in CI:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;It's a separate runtime from the rest of your tooling.&lt;/li&gt;
&lt;li&gt;Environment/collection files are passed as CLI paths, which makes multi-environment setups awkward.&lt;/li&gt;
&lt;li&gt;Reports are decent but JUnit output needs extra configuration.&lt;/li&gt;
&lt;li&gt;There's no built-in way to re-derive the collection when the API changes.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;HTTP Forge takes a different approach: it imports the Postman collection into a workspace-native format (collections, environments, and suites on disk), then runs that workspace headlessly. The import is a one-time migration step; after that you're running HTTP Forge artifacts, not Postman files.&lt;/p&gt;

&lt;p&gt;If you want to keep Postman as the authoring tool, that's fine too — you can re-import on each CI run. Both patterns are shown below.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step 1 — Import the collection
&lt;/h2&gt;

&lt;p&gt;Export your collection from Postman as &lt;strong&gt;Collection v2.x&lt;/strong&gt; JSON, then:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npm &lt;span class="nb"&gt;install&lt;/span&gt; &lt;span class="nt"&gt;-g&lt;/span&gt; @http-forge/cli

http-forge import collection &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--postman&lt;/span&gt; ./MyApi.postman_collection.json &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--name&lt;/span&gt; &lt;span class="s2"&gt;"My API"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That creates a collection in the current workspace. To target a specific workspace:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;http-forge import collection &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--postman&lt;/span&gt; ./MyApi.postman_collection.json &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--name&lt;/span&gt; &lt;span class="s2"&gt;"My API"&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--workspace&lt;/span&gt; ./.http-forge/assets
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Verify it landed:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;http-forge list collections &lt;span class="nt"&gt;--workspace&lt;/span&gt; &lt;span class="nb"&gt;.&lt;/span&gt;
http-forge list requests &lt;span class="nt"&gt;--collection&lt;/span&gt; &lt;span class="s2"&gt;"My API"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  Import the environment too
&lt;/h3&gt;

&lt;p&gt;Postman collections usually reference variables like &lt;code&gt;{{baseUrl}}&lt;/code&gt; and &lt;code&gt;{{token}}&lt;/code&gt;. Import the environment export:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;http-forge import &lt;span class="nb"&gt;env&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--postman&lt;/span&gt; ./MyEnv.postman_environment.json &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--env&lt;/span&gt; staging &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--overwrite&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Then confirm the values:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;http-forge &lt;span class="nb"&gt;env &lt;/span&gt;get staging &lt;span class="nt"&gt;--workspace&lt;/span&gt; &lt;span class="nb"&gt;.&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If you'd rather not commit secrets, keep the environment file out of git and import it in CI from a secret (more on that below).&lt;/p&gt;

&lt;h2&gt;
  
  
  Step 2 — Run it headlessly
&lt;/h2&gt;

&lt;p&gt;A single collection run:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;http-forge run collection &lt;span class="s2"&gt;"My API"&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--workspace&lt;/span&gt; &lt;span class="nb"&gt;.&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--environment&lt;/span&gt; staging &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--include&lt;/span&gt; failedOnly
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Useful flags for CI:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;--environment &amp;lt;name&amp;gt;&lt;/code&gt; (or &lt;code&gt;--env&lt;/code&gt;) — activate an environment.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;--var KEY=VALUE&lt;/code&gt; — override a variable; repeatable, highest priority.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;--iterations &amp;lt;n&amp;gt;&lt;/code&gt; and &lt;code&gt;--concurrency &amp;lt;n&amp;gt;&lt;/code&gt; — load/parameterized runs.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;--stop-on-error&lt;/code&gt; — fail fast.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;--exit-code&lt;/code&gt; — exit &lt;code&gt;1&lt;/code&gt; when any assertion fails (this is the CI gate).&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;--reporter junit:results/junit.xml&lt;/code&gt; — write machine-readable results.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A realistic CI command:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;http-forge run collection &lt;span class="s2"&gt;"My API"&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--environment&lt;/span&gt; staging &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--var&lt;/span&gt; &lt;span class="nv"&gt;BASE_URL&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="nv"&gt;$STAGING_BASE_URL&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--reporter&lt;/span&gt; junit:results/junit.xml &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--exit-code&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The exit code is what makes CI fail the build. The JUnit file is what makes the failure readable.&lt;/p&gt;

&lt;h3&gt;
  
  
  Prefer suites?
&lt;/h3&gt;

&lt;p&gt;If you've arranged requests into a suite (or generated one), run it the same way:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;http-forge run suite &lt;span class="s2"&gt;"smoke-tests"&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--environment&lt;/span&gt; staging &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--reporter&lt;/span&gt; junit:results/junit.xml &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--exit-code&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Step 3 — Emit a JUnit report
&lt;/h2&gt;

&lt;p&gt;JUnit XML is the lingua franca of CI test reporting. GitHub Actions, GitLab, Jenkins, and Azure DevOps all understand it.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;http-forge run collection &lt;span class="s2"&gt;"My API"&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--environment&lt;/span&gt; staging &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--reporter&lt;/span&gt; junit:results/junit.xml &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--exit-code&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;You can also generate an HTML report in the same run:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;http-forge run collection &lt;span class="s2"&gt;"My API"&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--reporter&lt;/span&gt; junit:results/junit.xml &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--reporter&lt;/span&gt; html:reports/run.html &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--exit-code&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Notes:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;JUnit XML is written even when every request fails, so CI tools can display the failures.&lt;/li&gt;
&lt;li&gt;HTML reports need at least one successful request to have content.&lt;/li&gt;
&lt;li&gt;Reporters are composable — pass &lt;code&gt;--reporter&lt;/code&gt; once per format.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Step 4 — Wire it into GitHub Actions
&lt;/h2&gt;

&lt;p&gt;Here's a complete workflow. It installs Node, installs the CLI, imports the collection (if you keep Postman as the source of truth), runs it, uploads the report, and publishes the JUnit results.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;API tests&lt;/span&gt;

&lt;span class="na"&gt;on&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;push&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;branches&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;[&lt;/span&gt;&lt;span class="nv"&gt;main&lt;/span&gt;&lt;span class="pi"&gt;]&lt;/span&gt;
  &lt;span class="na"&gt;pull_request&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;

&lt;span class="na"&gt;jobs&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;api-tests&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;runs-on&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;ubuntu-latest&lt;/span&gt;

    &lt;span class="na"&gt;steps&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
      &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;uses&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;actions/checkout@v4&lt;/span&gt;

      &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;uses&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;actions/setup-node@v4&lt;/span&gt;
        &lt;span class="na"&gt;with&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
          &lt;span class="na"&gt;node-version&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;20&lt;/span&gt;

      &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Install HTTP Forge CLI&lt;/span&gt;
        &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;npm install -g @http-forge/cli&lt;/span&gt;

      &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Import Postman collection&lt;/span&gt;
        &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;|&lt;/span&gt;
          &lt;span class="s"&gt;http-forge import collection \&lt;/span&gt;
            &lt;span class="s"&gt;--postman ./postman/MyApi.postman_collection.json \&lt;/span&gt;
            &lt;span class="s"&gt;--name "My API"&lt;/span&gt;

      &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Import Postman environment&lt;/span&gt;
        &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;|&lt;/span&gt;
          &lt;span class="s"&gt;http-forge import env \&lt;/span&gt;
            &lt;span class="s"&gt;--postman ./postman/MyEnv.postman_environment.json \&lt;/span&gt;
            &lt;span class="s"&gt;--env staging \&lt;/span&gt;
            &lt;span class="s"&gt;--overwrite&lt;/span&gt;

      &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Run API tests&lt;/span&gt;
        &lt;span class="na"&gt;env&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
          &lt;span class="na"&gt;BASE_URL&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;${{ secrets.STAGING_BASE_URL }}&lt;/span&gt;
          &lt;span class="na"&gt;API_TOKEN&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;${{ secrets.API_TOKEN }}&lt;/span&gt;
        &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;|&lt;/span&gt;
          &lt;span class="s"&gt;http-forge run collection "My API" \&lt;/span&gt;
            &lt;span class="s"&gt;--environment staging \&lt;/span&gt;
            &lt;span class="s"&gt;--var BASE_URL="$BASE_URL" \&lt;/span&gt;
            &lt;span class="s"&gt;--var TOKEN="$API_TOKEN" \&lt;/span&gt;
            &lt;span class="s"&gt;--reporter junit:results/junit.xml \&lt;/span&gt;
            &lt;span class="s"&gt;--exit-code&lt;/span&gt;

      &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Upload JUnit report&lt;/span&gt;
        &lt;span class="na"&gt;if&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;always()&lt;/span&gt;
        &lt;span class="na"&gt;uses&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;actions/upload-artifact@v4&lt;/span&gt;
        &lt;span class="na"&gt;with&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
          &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;api-test-results&lt;/span&gt;
          &lt;span class="na"&gt;path&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;results/junit.xml&lt;/span&gt;

      &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Publish test report&lt;/span&gt;
        &lt;span class="na"&gt;if&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;always()&lt;/span&gt;
        &lt;span class="na"&gt;uses&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;dorny/test-reporter@v1&lt;/span&gt;
        &lt;span class="na"&gt;with&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
          &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;API tests&lt;/span&gt;
          &lt;span class="na"&gt;path&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;results/junit.xml&lt;/span&gt;
          &lt;span class="na"&gt;reporter&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;java-junit&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  If you commit the imported collection
&lt;/h3&gt;

&lt;p&gt;If you'd rather not import on every run, commit the HTTP Forge workspace (collections + environments) and skip the import steps:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;      &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Run API tests&lt;/span&gt;
        &lt;span class="na"&gt;env&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
          &lt;span class="na"&gt;BASE_URL&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;${{ secrets.STAGING_BASE_URL }}&lt;/span&gt;
        &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;|&lt;/span&gt;
          &lt;span class="s"&gt;http-forge run collection "My API" \&lt;/span&gt;
            &lt;span class="s"&gt;--environment staging \&lt;/span&gt;
            &lt;span class="s"&gt;--var BASE_URL="$BASE_URL" \&lt;/span&gt;
            &lt;span class="s"&gt;--reporter junit:results/junit.xml \&lt;/span&gt;
            &lt;span class="s"&gt;--exit-code&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This is faster and avoids depending on the Postman export staying in sync. The tradeoff is that the Postman collection and the committed HTTP Forge collection can diverge — pick one as the source of truth.&lt;/p&gt;

&lt;h3&gt;
  
  
  The flow at a glance
&lt;/h3&gt;



&lt;pre data-lang="mermaid"&gt;&lt;code&gt;flowchart TB
    postman["Postman export&amp;lt;br/&amp;gt;(collection + env)"] --&amp;gt; import["http-forge import"]
    import --&amp;gt; workspace["Workspace artifacts&amp;lt;br/&amp;gt;(collections, envs, suites)"]
    workspace --&amp;gt; run["http-forge run&amp;lt;br/&amp;gt;--reporter junit --exit-code"]
    run --&amp;gt; junit["results/junit.xml"]
    junit --&amp;gt; artifact["Upload artifact"]
    junit --&amp;gt; report["PR test report"]
    run --&amp;gt; gate{"Exit code 0?"}
    gate --&amp;gt;|"yes"| pass["Build passes"]
    gate --&amp;gt;|"no"| fail["Build fails"]&lt;/code&gt;&lt;/pre&gt;



&lt;h2&gt;
  
  
  Handling auth and secrets
&lt;/h2&gt;

&lt;p&gt;Never commit tokens. Options:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;--var&lt;/code&gt; with a CI secret&lt;/strong&gt; — &lt;code&gt;--var TOKEN="${{ secrets.API_TOKEN }}"&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Environment file from a secret&lt;/strong&gt; — write the JSON to disk in a step, then &lt;code&gt;import env&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;HTTP Forge environment values&lt;/strong&gt; — if you commit the environment, leave secrets out and inject with &lt;code&gt;--var&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Precedence: &lt;code&gt;--var&lt;/code&gt; overrides environment values, which override globals. That's usually what you want for CI.&lt;/p&gt;

&lt;h2&gt;
  
  
  Common pitfalls
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;The collection references &lt;code&gt;{{baseUrl}}&lt;/code&gt; but the environment has &lt;code&gt;{{BASE_URL}}&lt;/code&gt;.&lt;/strong&gt; Variable names are case-sensitive. Check with &lt;code&gt;http-forge env get staging&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Scripts depend on Postman-specific APIs.&lt;/strong&gt; HTTP Forge supports the common &lt;code&gt;pm.*&lt;/code&gt; surface (tests, &lt;code&gt;pm.response.json()&lt;/code&gt;, environment/collection variables, &lt;code&gt;pm.expect&lt;/code&gt;). If your collection uses exotic Postman features, review the imported scripts before relying on them.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The collection imports but requests fail with 401.&lt;/strong&gt; The environment wasn't activated. Pass &lt;code&gt;--environment&lt;/code&gt; explicitly; CI has no "currently selected environment."&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;JUnit file is empty.&lt;/strong&gt; Make sure you passed &lt;code&gt;--reporter junit:&amp;lt;path&amp;gt;&lt;/code&gt;, not &lt;code&gt;--include report&lt;/code&gt;. They're different mechanisms.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The run passes locally but fails in CI.&lt;/strong&gt; Usually a missing variable or a different base URL. Run with &lt;code&gt;--include failedOnly&lt;/code&gt; to see exactly which requests failed without dumping every response.&lt;/p&gt;

&lt;h2&gt;
  
  
  Is this worth migrating?
&lt;/h2&gt;

&lt;p&gt;If you only have a handful of requests, Newman is fine. If you have a collection you actually rely on — one that runs on PRs and gates merges — the import gives you:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A workspace-native artifact you can version, diff, and regenerate.&lt;/li&gt;
&lt;li&gt;A CLI that runs collections, folders, requests, and suites with the same engine.&lt;/li&gt;
&lt;li&gt;JUnit/HTML reporting without extra tooling.&lt;/li&gt;
&lt;li&gt;A path to source-based discovery and drift detection when you're ready to stop maintaining the collection by hand.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That last part is the reason I built it. Importing Postman is the on-ramp; keeping tests from rotting is the destination.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try it
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;CLI reference:&lt;/strong&gt; &lt;a href="https://github.com/hsl1230/http-forge.cli/blob/main/docs/cli-reference.md" rel="noopener noreferrer"&gt;https://github.com/hsl1230/http-forge.cli/blob/main/docs/cli-reference.md&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;CI guide:&lt;/strong&gt; &lt;a href="https://github.com/hsl1230/http-forge.cli/blob/main/docs/ci-guide.md" rel="noopener noreferrer"&gt;https://github.com/hsl1230/http-forge.cli/blob/main/docs/ci-guide.md&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;HTTP Forge for VS Code:&lt;/strong&gt; &lt;a href="https://marketplace.visualstudio.com/items?itemName=henry-huang.http-forge" rel="noopener noreferrer"&gt;https://marketplace.visualstudio.com/items?itemName=henry-huang.http-forge&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Open-source core:&lt;/strong&gt; &lt;a href="https://github.com/hsl1230/http-forge.core" rel="noopener noreferrer"&gt;https://github.com/hsl1230/http-forge.core&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If you want a ready-made workspace to try the run/report flow before importing your own collection:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npm &lt;span class="nb"&gt;install&lt;/span&gt; &lt;span class="nt"&gt;-g&lt;/span&gt; @http-forge/cli
http-forge launch &lt;span class="nt"&gt;--examples&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That clones a sample workspace with pre-built requests and suites and opens it in VS Code.&lt;/p&gt;

</description>
      <category>postman</category>
      <category>api</category>
      <category>ci</category>
      <category>githubactions</category>
    </item>
    <item>
      <title>Why I built a CLI when I already had a VS Code extension</title>
      <dc:creator>Henry Huang</dc:creator>
      <pubDate>Fri, 30 Oct 2026 17:25:28 +0000</pubDate>
      <link>https://dev.to/hslcalgary/why-i-built-a-cli-when-i-already-had-a-vs-code-extension-2kbh</link>
      <guid>https://dev.to/hslcalgary/why-i-built-a-cli-when-i-already-had-a-vs-code-extension-2kbh</guid>
      <description>&lt;p&gt;HTTP Forge started as a VS Code extension. That was the right place to start: the editor is where you write the code, so it's where you want to inspect responses and fix requests.&lt;/p&gt;

&lt;p&gt;But the extension had a ceiling. A GUI can't run on a build server, can't be piped into &lt;code&gt;jq&lt;/code&gt;, and can't be driven cheaply by an AI agent. The more I used HTTP Forge for real work, the more the missing piece was obvious: a CLI.&lt;/p&gt;

&lt;p&gt;This is why I built one, what it's for, and where it still makes sense to use the extension or the MCP server instead.&lt;/p&gt;

&lt;h2&gt;
  
  
  The CLI is the same engine, without the UI
&lt;/h2&gt;

&lt;p&gt;The CLI isn't a separate implementation. It's a thin adapter over the same core (&lt;code&gt;@http-forge/core&lt;/code&gt;) as the extension and the MCP server.&lt;br&gt;
&lt;/p&gt;

&lt;pre data-lang="mermaid"&gt;&lt;code&gt;flowchart TD
    ext["VS Code extension"]
    cli["CLI"]
    mcp["MCP server"]
    core["@http-forge/core&amp;lt;br/&amp;gt;(execution, collections, suites, discovery)"]

    ext --&amp;gt; core
    cli --&amp;gt; core
    mcp --&amp;gt; core&lt;/code&gt;&lt;/pre&gt;



&lt;p&gt;That matters for three reasons:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Parity.&lt;/strong&gt; A bug fixed in the runner is fixed everywhere. A collection that works in the extension works in CI.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;No export step.&lt;/strong&gt; There's no "export for CI" format to maintain. The CLI reads the same workspace files.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;One mental model.&lt;/strong&gt; Collections, environments, suites, assertions, reporters — the same concepts across all three surfaces.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  Reason 1: CI doesn't run GUIs
&lt;/h2&gt;

&lt;p&gt;The first real requirement was running a suite on every pull request. That means:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;No editor, no display, no interactive prompts.&lt;/li&gt;
&lt;li&gt;A deterministic exit code.&lt;/li&gt;
&lt;li&gt;A machine-readable report.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The CLI does that:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;http-forge run suite &lt;span class="s2"&gt;"smoke-tests"&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--environment&lt;/span&gt; staging &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--reporter&lt;/span&gt; junit:results/junit.xml &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--exit-code&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Exit &lt;code&gt;0&lt;/code&gt; when everything passes, &lt;code&gt;1&lt;/code&gt; when an assertion fails. JUnit XML for GitHub Actions, GitLab, Jenkins, Azure DevOps. That's the whole integration.&lt;/p&gt;

&lt;p&gt;The alternative — Newman or a custom script — can work, but it means a second runtime, a second set of flags, and a second place for behavior to drift. Reusing the same engine removes that entire category of "works locally, fails in CI" bugs.&lt;/p&gt;

&lt;h2&gt;
  
  
  Reason 2: AI agents are cheaper with a CLI than a tool schema
&lt;/h2&gt;

&lt;p&gt;This is the part people underestimate.&lt;/p&gt;

&lt;p&gt;An MCP server is a great interface for structured operations: validated arguments, typed results, discoverable tools. But every tool you expose costs context. The agent has to see the tool name, description, and JSON schema — and that overhead is paid on &lt;em&gt;every&lt;/em&gt; turn, whether or not the tool is used.&lt;/p&gt;

&lt;p&gt;A CLI is just text. An agent that has terminal access can run:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;http-forge run collection &lt;span class="s2"&gt;"My API"&lt;/span&gt; &lt;span class="nt"&gt;--environment&lt;/span&gt; staging &lt;span class="nt"&gt;--include&lt;/span&gt; failedOnly &lt;span class="nt"&gt;--output&lt;/span&gt; json
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That's a fraction of the tokens of a tool schema plus a tool call. And the agent already knows how to run shell commands.&lt;/p&gt;

&lt;p&gt;For the common case — "run the tests and tell me what failed" — the CLI is the most token-efficient interface we have.&lt;/p&gt;

&lt;h3&gt;
  
  
  Where MCP still wins
&lt;/h3&gt;

&lt;p&gt;I'm not arguing the CLI replaces MCP. They're good at different things:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;MCP for structured state changes&lt;/strong&gt; — creating requests, editing suite nodes, selecting environments, healing assertions. Validated tools beat string-parsing CLI commands.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;MCP for rich inspection&lt;/strong&gt; — &lt;code&gt;explain_failure&lt;/code&gt; returns the request, response, assertion results, and a diagnosis in one structured payload. Via CLI you'd run a command and parse JSON.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;CLI for execution&lt;/strong&gt; — run the suite, get a compact summary, move on.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The pattern I recommend to agents: &lt;strong&gt;execute via CLI, mutate via MCP.&lt;/strong&gt; It keeps token usage low without giving up structure where structure matters.&lt;/p&gt;

&lt;h2&gt;
  
  
  Reason 3: Composability
&lt;/h2&gt;

&lt;p&gt;A CLI is scriptable by default. The output is JSON, so you can pipe it:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;http-forge run suite smoke-tests &lt;span class="nt"&gt;--output&lt;/span&gt; json | jq &lt;span class="s1"&gt;'.failedRequests[].name'&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# Fail only if the auth suite is broken&lt;/span&gt;
http-forge run folder &lt;span class="s2"&gt;"Auth"&lt;/span&gt; &lt;span class="nt"&gt;--collection&lt;/span&gt; &lt;span class="s2"&gt;"My API"&lt;/span&gt; &lt;span class="nt"&gt;--output&lt;/span&gt; json &lt;span class="se"&gt;\&lt;/span&gt;
  | jq &lt;span class="nt"&gt;-e&lt;/span&gt; &lt;span class="s1"&gt;'.allPassed == true'&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# Loop over environments&lt;/span&gt;
&lt;span class="k"&gt;for &lt;/span&gt;&lt;span class="nb"&gt;env &lt;/span&gt;&lt;span class="k"&gt;in &lt;/span&gt;dev staging production&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="k"&gt;do
  &lt;/span&gt;http-forge run suite &lt;span class="s2"&gt;"smoke-tests"&lt;/span&gt; &lt;span class="nt"&gt;--environment&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="nv"&gt;$env&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt; &lt;span class="nt"&gt;--exit-code&lt;/span&gt; &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="nb"&gt;exit &lt;/span&gt;1
&lt;span class="k"&gt;done&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;None of that is possible in a GUI, and all of it is awkward through a tool-call API. The CLI is where HTTP Forge becomes a Unix citizen.&lt;/p&gt;

&lt;h2&gt;
  
  
  Reason 4: Local-first, no account, no daemon
&lt;/h2&gt;

&lt;p&gt;The CLI runs locally. It doesn't phone home, doesn't need a login, and doesn't start a background service.&lt;/p&gt;

&lt;p&gt;That matters for:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Air-gapped environments&lt;/strong&gt; — CI runners and secure networks where outbound access is restricted.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Reproducibility&lt;/strong&gt; — the same binary and the same workspace produce the same result.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cost&lt;/strong&gt; — no per-seat or per-run pricing.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;It also makes the CLI the easiest way to try HTTP Forge. One &lt;code&gt;npm install -g&lt;/code&gt;, one command, and you're running a real suite.&lt;/p&gt;

&lt;h2&gt;
  
  
  Reason 5: The CLI is the on-ramp to everything else
&lt;/h2&gt;

&lt;p&gt;A lot of HTTP Forge features are easier to discover from the terminal:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;http-forge discover &lt;span class="nt"&gt;--path&lt;/span&gt; ./backend &lt;span class="nt"&gt;--output&lt;/span&gt; table
http-forge generate-suite &lt;span class="nt"&gt;--path&lt;/span&gt; ./backend &lt;span class="nt"&gt;--collection&lt;/span&gt; &lt;span class="s2"&gt;"My API"&lt;/span&gt; &lt;span class="nt"&gt;--dry-run&lt;/span&gt;
http-forge drift &lt;span class="nt"&gt;--path&lt;/span&gt; ./backend
http-forge qa &lt;span class="nt"&gt;--path&lt;/span&gt; ./backend &lt;span class="nt"&gt;--base-url&lt;/span&gt; http://localhost:3000
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Discovery, suite generation, drift checks, and the QA gate all work headlessly. You can see the output, script around it, and only then decide whether to open the editor.&lt;/p&gt;

&lt;p&gt;The CLI is also how I onboard people: &lt;code&gt;http-forge launch --examples&lt;/code&gt; clones a sample workspace and opens it in VS Code, so there's no "set up a project first" step.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the CLI deliberately doesn't do
&lt;/h2&gt;

&lt;p&gt;A few non-goals kept the scope sane:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;It's not a TUI.&lt;/strong&gt; No interactive browser, no menus. If you want to explore responses visually, use the extension.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;It's not a deployment tool.&lt;/strong&gt; It runs tests; it doesn't provision environments or deploy services.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;It doesn't duplicate core logic.&lt;/strong&gt; Every command delegates to the shared engine. If a behavior lives in the CLI only, it's a bug.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;It doesn't hide errors.&lt;/strong&gt; Exit codes are meaningful, and JSON output includes the failure details rather than a generic "something went wrong."&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  The result
&lt;/h2&gt;

&lt;p&gt;The CLI turned HTTP Forge from "a tool I open" into "a tool I can automate." It's the piece that made the project useful in CI, useful to AI agents, and useful in scripts.&lt;/p&gt;

&lt;p&gt;If you're building a developer tool, my advice is to build the CLI early — not as an afterthought after the GUI. It forces you to keep the core headless, testable, and free of UI assumptions. Those constraints make every other surface better.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try it
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npm &lt;span class="nb"&gt;install&lt;/span&gt; &lt;span class="nt"&gt;-g&lt;/span&gt; @http-forge/cli

&lt;span class="c"&gt;# Run a collection in CI&lt;/span&gt;
http-forge run collection &lt;span class="s2"&gt;"My API"&lt;/span&gt; &lt;span class="nt"&gt;--environment&lt;/span&gt; staging &lt;span class="nt"&gt;--reporter&lt;/span&gt; junit:results/junit.xml &lt;span class="nt"&gt;--exit-code&lt;/span&gt;

&lt;span class="c"&gt;# Explore a sample workspace&lt;/span&gt;
http-forge launch &lt;span class="nt"&gt;--examples&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;CLI reference:&lt;/strong&gt; &lt;a href="https://github.com/hsl1230/http-forge.cli/blob/main/docs/cli-reference.md" rel="noopener noreferrer"&gt;https://github.com/hsl1230/http-forge.cli/blob/main/docs/cli-reference.md&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Open-source core:&lt;/strong&gt; &lt;a href="https://github.com/hsl1230/http-forge.core" rel="noopener noreferrer"&gt;https://github.com/hsl1230/http-forge.core&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;HTTP Forge for VS Code:&lt;/strong&gt; &lt;a href="https://marketplace.visualstudio.com/items?itemName=henry-huang.http-forge" rel="noopener noreferrer"&gt;https://marketplace.visualstudio.com/items?itemName=henry-huang.http-forge&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>cli</category>
      <category>ai</category>
      <category>testing</category>
      <category>agents</category>
    </item>
    <item>
      <title>Discovering API endpoints from source code with zero OpenAPI specs</title>
      <dc:creator>Henry Huang</dc:creator>
      <pubDate>Fri, 30 Oct 2026 16:45:46 +0000</pubDate>
      <link>https://dev.to/hslcalgary/discovering-api-endpoints-from-source-code-with-zero-openapi-specs-125a</link>
      <guid>https://dev.to/hslcalgary/discovering-api-endpoints-from-source-code-with-zero-openapi-specs-125a</guid>
      <description>&lt;p&gt;OpenAPI is great when it exists.&lt;/p&gt;

&lt;p&gt;It often doesn't. Or it exists but hasn't been regenerated since the last three sprints. Or it covers the public API but not the internal services. Or it's maintained by hand and is quietly wrong in exactly the places you need it most.&lt;/p&gt;

&lt;p&gt;For a testing tool, that's a problem: if you can't enumerate the endpoints, you can't generate tests for them. You're back to hand-authoring requests in Postman, which is where collections go to die.&lt;/p&gt;

&lt;p&gt;This is how HTTP Forge discovers endpoints directly from source code — six framework providers, deterministic output, golden fixtures, and drift detection — with no OpenAPI spec required.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why source code beats a spec
&lt;/h2&gt;

&lt;p&gt;An OpenAPI spec is a &lt;em&gt;derived&lt;/em&gt; artifact. Source code is the source of truth.&lt;/p&gt;

&lt;p&gt;If discovery reads the source, three useful things follow:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;No spec maintenance tax.&lt;/strong&gt; There's nothing to regenerate before you can test.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Provenance.&lt;/strong&gt; Every endpoint can point back to &lt;code&gt;file:line&lt;/code&gt; — framework, confidence, and the source that produced it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Drift detection.&lt;/strong&gt; You can fingerprint the source (git hash + mtime) and know when a stored index is stale.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The tradeoff is parser complexity and the risk of false positives. A wrong endpoint that breaks &lt;code&gt;run_request&lt;/code&gt; is worse than a missing endpoint. The design rule I used: &lt;strong&gt;incomplete coverage is fine; false positives are not.&lt;/strong&gt; Unknown patterns get &lt;code&gt;confidence: 'low'&lt;/code&gt; rather than a confident guess.&lt;/p&gt;

&lt;h2&gt;
  
  
  The six providers
&lt;/h2&gt;

&lt;p&gt;One class per framework, all implementing the same &lt;code&gt;ApiDiscoveryProvider&lt;/code&gt; contract:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight typescript"&gt;&lt;code&gt;&lt;span class="k"&gt;export&lt;/span&gt; &lt;span class="kr"&gt;interface&lt;/span&gt; &lt;span class="nx"&gt;ApiDiscoveryProvider&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="k"&gt;readonly&lt;/span&gt; &lt;span class="nx"&gt;id&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kr"&gt;string&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="k"&gt;readonly&lt;/span&gt; &lt;span class="nx"&gt;framework&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;ApiFramework&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

  &lt;span class="nf"&gt;supports&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;fingerprint&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;FrameworkFingerprint&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt; &lt;span class="nx"&gt;ProviderSupport&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

  &lt;span class="nf"&gt;discover&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="nx"&gt;context&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;DiscoveryContext&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="nx"&gt;fingerprint&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;FrameworkFingerprint&lt;/span&gt;
  &lt;span class="p"&gt;):&lt;/span&gt; &lt;span class="nb"&gt;Promise&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="nx"&gt;DiscoveryResult&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

  &lt;span class="nx"&gt;clearCache&lt;/span&gt;&lt;span class="p"&gt;?(&lt;/span&gt;&lt;span class="nx"&gt;projectRoot&lt;/span&gt;&lt;span class="p"&gt;?:&lt;/span&gt; &lt;span class="kr"&gt;string&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt; &lt;span class="k"&gt;void&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Adding a framework means adding a provider and registering it — never editing the orchestrator. That Open/Closed boundary is why the list can grow without destabilizing the existing parsers.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Express&lt;/strong&gt; — detects the &lt;code&gt;express&lt;/code&gt; dependency, scans TS/JS source files, and analyzes route registrations (&lt;code&gt;app.get&lt;/code&gt;, &lt;code&gt;router.post&lt;/code&gt;, mounts, middleware chains). It emits path params, request body schema hints, and provenance.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;NestJS&lt;/strong&gt; — reads decorators on controllers (&lt;code&gt;@Controller&lt;/code&gt;, &lt;code&gt;@Get&lt;/code&gt;, &lt;code&gt;@Post&lt;/code&gt;, &lt;code&gt;@Body&lt;/code&gt;, &lt;code&gt;@Param&lt;/code&gt;) and resolves the controller prefix plus method path.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Fastify&lt;/strong&gt; — follows &lt;code&gt;fastify.get/post/...&lt;/code&gt; registrations and inline &lt;code&gt;register()&lt;/code&gt; plugins with prefixes. (Known limitation: a variable plugin instance passed to &lt;code&gt;register()&lt;/code&gt; isn't traversed.)&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;AWS Lambda&lt;/strong&gt; — finds handler exports and serverless-style route definitions, mapping function names to HTTP methods and paths.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Spring&lt;/strong&gt; — parses Java with &lt;code&gt;java-parser&lt;/code&gt;'s AST, with a regex fallback for patterns the AST misses. It handles &lt;code&gt;@RestController&lt;/code&gt;, &lt;code&gt;@RequestMapping&lt;/code&gt;, &lt;code&gt;@GetMapping&lt;/code&gt;, path variables, and Pydantic-like model → JSON Schema generation for request bodies.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;FastAPI&lt;/strong&gt; — a pure-JS, balance-aware line walker. No Python runtime, no Python parser dependency. It handles &lt;code&gt;FastAPI()&lt;/code&gt;/&lt;code&gt;APIRouter(prefix=...)&lt;/code&gt;, &lt;code&gt;@app.&amp;lt;method&amp;gt;&lt;/code&gt; decorators, &lt;code&gt;{param}&lt;/code&gt; paths, &lt;code&gt;Path/Query/Header/Cookie/Body/File/Form&lt;/code&gt; parameters, Pydantic &lt;code&gt;BaseModel&lt;/code&gt; → JSON Schema, and project-wide &lt;code&gt;include_router&lt;/code&gt; prefix resolution (including &lt;code&gt;import ... as&lt;/code&gt; aliases and tag merge).&lt;/p&gt;

&lt;h2&gt;
  
  
  The pipeline
&lt;/h2&gt;

&lt;p&gt;Discovery isn't just "run the parser." The orchestrator does fingerprinting, framework detection, parallel provider execution, seed merging, enrichment, dedupe, and deterministic sorting.&lt;br&gt;
&lt;/p&gt;

&lt;pre data-lang="mermaid"&gt;&lt;code&gt;flowchart TD
    start["Project root"] --&amp;gt; fp["Build fingerprint&amp;lt;br/&amp;gt;(package.json / build files / source hints)"]
    fp --&amp;gt; detect["Detect frameworks"]
    detect --&amp;gt; eligible["Select eligible providers"]
    eligible --&amp;gt; parallel["Run providers in parallel"]
    parallel --&amp;gt; seed["Merge explicit seed endpoints"]
    seed --&amp;gt; enrich["Enrich path params, auth, validation"]
    enrich --&amp;gt; dedupe["Dedupe + deterministic sort"]
    dedupe --&amp;gt; index["Build git-native index"]
    index --&amp;gt; persist["Persist discovered index"]&lt;/code&gt;&lt;/pre&gt;



&lt;p&gt;A few details that matter:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Language-aware hints.&lt;/strong&gt; Framework detection scans only relevant extensions — TS/JS for the Node providers, &lt;code&gt;.java&lt;/code&gt; for Spring, &lt;code&gt;.py&lt;/code&gt; for FastAPI. Without this, &lt;code&gt;app.get(&lt;/code&gt; in a Python decorator would falsely trigger the Express hint.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Empty source sets fall back.&lt;/strong&gt; If the TS/JS collector finds nothing, the orchestrator leaves &lt;code&gt;fingerprint.sourceFiles&lt;/code&gt; unset so Spring and FastAPI can run their own Java/Python collectors. Otherwise a standalone controller file would never be scanned.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Seed merge.&lt;/strong&gt; If you have an explicit seed (a hand-curated endpoint list), it merges by &lt;code&gt;METHOD + resolvedPath&lt;/code&gt; and keeps unmatched seed endpoints with a warning.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Deterministic IDs.&lt;/strong&gt; Endpoint IDs are derived from method, path, and source location — not from timestamps or random values.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Determinism is a feature, not a nicety
&lt;/h2&gt;

&lt;p&gt;Sorted output is what makes discovery diffable:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight typescript"&gt;&lt;code&gt;&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;compareEndpoints&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;a&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;DiscoveredApi&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;b&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;DiscoveredApi&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt; &lt;span class="kr"&gt;number&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;methodOrder&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
    &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;SORT_METHOD_ORDER&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nx"&gt;a&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;method&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;toUpperCase&lt;/span&gt;&lt;span class="p"&gt;()]&lt;/span&gt; &lt;span class="o"&gt;??&lt;/span&gt; &lt;span class="mi"&gt;99&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;
    &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;SORT_METHOD_ORDER&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nx"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;method&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;toUpperCase&lt;/span&gt;&lt;span class="p"&gt;()]&lt;/span&gt; &lt;span class="o"&gt;??&lt;/span&gt; &lt;span class="mi"&gt;99&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
  &lt;span class="k"&gt;if &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;methodOrder&lt;/span&gt; &lt;span class="o"&gt;!==&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nx"&gt;methodOrder&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

  &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;pathA&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;a&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;resolvedPath&lt;/span&gt; &lt;span class="o"&gt;??&lt;/span&gt; &lt;span class="nx"&gt;a&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;pathExpression&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;pathB&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;resolvedPath&lt;/span&gt; &lt;span class="o"&gt;??&lt;/span&gt; &lt;span class="nx"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;pathExpression&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="k"&gt;if &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;pathA&lt;/span&gt; &lt;span class="o"&gt;!==&lt;/span&gt; &lt;span class="nx"&gt;pathB&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nx"&gt;pathA&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="nx"&gt;pathB&lt;/span&gt; &lt;span class="p"&gt;?&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

  &lt;span class="k"&gt;if &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;a&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;source&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;filePath&lt;/span&gt; &lt;span class="o"&gt;!==&lt;/span&gt; &lt;span class="nx"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;source&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;filePath&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nx"&gt;a&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;source&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;filePath&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="nx"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;source&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;filePath&lt;/span&gt; &lt;span class="p"&gt;?&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nx"&gt;a&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;source&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;line&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt; &lt;span class="nx"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;source&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;line&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Ordering is method ascending (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS), then resolved path, then source file, then line. If two scans of unchanged code produce different output, every downstream diff becomes noise.&lt;/p&gt;

&lt;p&gt;There are no timestamps inside endpoint records. The only time-like fields live in the explicit freshness metadata.&lt;/p&gt;

&lt;h2&gt;
  
  
  Golden fixtures: TDD for parsers
&lt;/h2&gt;

&lt;p&gt;Parser code is easy to write and hard to trust. The anchor is a set of small, real backend projects under &lt;code&gt;test-fixtures/&lt;/code&gt;:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;code&gt;express-app&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;nestjs-app&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;fastify-app&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;lambda-app&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;spring-app&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;fastapi-app&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Each fixture is self-contained and deterministic: 5–8 endpoints, at least one &lt;code&gt;:id&lt;/code&gt; path param, one POST-with-body, one DELETE, no dynamic route registration, no generated code. Each ships an &lt;code&gt;expected.endpoints.golden.json&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;The convention is deliberately strict:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Sort endpoints identically (method, path, file, line).&lt;/li&gt;
&lt;li&gt;Strip volatile fields (&lt;code&gt;id&lt;/code&gt;, &lt;code&gt;projectRoot&lt;/code&gt;, &lt;code&gt;projectName&lt;/code&gt;, timestamps).&lt;/li&gt;
&lt;li&gt;Compare relative source paths, never absolute workspace paths.&lt;/li&gt;
&lt;li&gt;Deep-equal against the golden file.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Golden files are &lt;strong&gt;locked&lt;/strong&gt;. The test starts red; the provider is written until it's green. Regeneration happens only for a deliberate, reviewed change — and the reason goes in the commit message. You never weaken a golden assertion to make a wrong output pass.&lt;/p&gt;

&lt;p&gt;That last rule is the whole game. Without it, "fixing the fixture" becomes the default response to a parser bug, and the suite stops meaning anything.&lt;/p&gt;

&lt;h2&gt;
  
  
  Drift detection: knowing when the index is stale
&lt;/h2&gt;

&lt;p&gt;A discovered index is a snapshot. The question is: when is it no longer true?&lt;/p&gt;

&lt;p&gt;The drift engine computes a freshness fingerprint:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight typescript"&gt;&lt;code&gt;&lt;span class="k"&gt;export&lt;/span&gt; &lt;span class="kr"&gt;interface&lt;/span&gt; &lt;span class="nx"&gt;ProjectFreshness&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;gitHash&lt;/span&gt;&lt;span class="p"&gt;?:&lt;/span&gt; &lt;span class="kr"&gt;string&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="cm"&gt;/** Max mtime (ms) of any scanned source file under the project root. */&lt;/span&gt;
  &lt;span class="nl"&gt;maxSourceMtime&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kr"&gt;number&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;ul&gt;
&lt;li&gt;In a git work tree, freshness is keyed on &lt;code&gt;git rev-parse HEAD&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;In a git-less workspace, it degrades to mtime: a source file newer than the stored &lt;code&gt;scannedAt&lt;/code&gt; marks the project stale.&lt;/li&gt;
&lt;li&gt;No git and no mtime signal means &lt;code&gt;unknown&lt;/code&gt; — never a false claim of freshness.
&lt;/li&gt;
&lt;/ul&gt;

&lt;pre data-lang="mermaid"&gt;&lt;code&gt;flowchart LR
    stored["Stored index&amp;lt;br/&amp;gt;(gitHash + scannedAt)"] --&amp;gt; compare{"Current fingerprint"}
    compare --&amp;gt;|"git HEAD matches"| current["current"]
    compare --&amp;gt;|"git HEAD changed"| stale["stale"]
    compare --&amp;gt;|"no stored entry"| unknown["unknown"]
    compare --&amp;gt;|"git-less: source mtime &amp;gt; scannedAt"| stale
    compare --&amp;gt;|"git-less: no newer source"| current&lt;/code&gt;&lt;/pre&gt;



&lt;p&gt;The engine also implements a 3-way diff and a resolver for regenerated artifacts. The rule is &lt;strong&gt;regenerate, don't patch&lt;/strong&gt;: re-derive the artifact from source, then surface which hunks are AI-generated vs user-edited. Only &lt;code&gt;ai_generated&lt;/code&gt; regions are regenerable; hand-edited assertions survive regeneration.&lt;/p&gt;

&lt;p&gt;That's the part that keeps generated suites from becoming disposable.&lt;/p&gt;

&lt;h2&gt;
  
  
  What it doesn't do (yet)
&lt;/h2&gt;

&lt;p&gt;Being honest about coverage is part of the trust model:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Fastify&lt;/strong&gt; variable plugin instances passed to &lt;code&gt;register()&lt;/code&gt; aren't traversed — routes can be missed or emitted without the mount prefix.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;FastAPI&lt;/strong&gt; f-string/expression decorator paths are emitted with &lt;code&gt;confidence: 'low'&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;No native .NET or Django providers.&lt;/strong&gt; For those, import an OpenAPI spec (Swashbuckle / &lt;code&gt;drf-spectacular&lt;/code&gt;) or let an AI agent infer endpoints from the workspace.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Dynamic route registration&lt;/strong&gt; from config or a database can't be discovered by static analysis. That's a fundamental limit — but it's not a dead end: a &lt;strong&gt;custom seed loader module&lt;/strong&gt; can supply those endpoints at discovery time.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Custom seed loader: the escape hatch for dynamic routes
&lt;/h3&gt;

&lt;p&gt;Set &lt;code&gt;customSeedLoaderModulePath&lt;/code&gt; and the orchestrator loads your module and merges its endpoints with the statically discovered ones:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight typescript"&gt;&lt;code&gt;&lt;span class="c1"&gt;// seed-loader.ts (project-local)&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="kd"&gt;type&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;DiscoveredApi&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;@http-forge/core&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="k"&gt;export&lt;/span&gt; &lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;loadSeedManifestEndpoints&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;projectRoot&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kr"&gt;string&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt; &lt;span class="nx"&gt;DiscoveredApi&lt;/span&gt;&lt;span class="p"&gt;[]&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;routes&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;JSON&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;parse&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;readFileSync&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;`&lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="nx"&gt;projectRoot&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;/routes.json`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;utf8&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;));&lt;/span&gt;
  &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nx"&gt;routes&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;map&lt;/span&gt;&lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="nx"&gt;route&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kr"&gt;any&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;({&lt;/span&gt;
    &lt;span class="na"&gt;id&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;''&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="c1"&gt;// filled in by the orchestrator&lt;/span&gt;
    &lt;span class="na"&gt;method&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;route&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;method&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="na"&gt;pathExpression&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;route&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;path&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="na"&gt;resolvedPath&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;route&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;path&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="na"&gt;framework&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;unknown&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="na"&gt;confidence&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mf"&gt;0.8&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="na"&gt;source&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="na"&gt;filePath&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;routes.json&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="na"&gt;line&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt; &lt;span class="p"&gt;},&lt;/span&gt;
    &lt;span class="c1"&gt;// ...headers, params, body schema as needed&lt;/span&gt;
  &lt;span class="p"&gt;}));&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The loader is resolved relative to the project root (or absolute), called with &lt;code&gt;(projectRoot, discoveryContext)&lt;/code&gt;, and may return either a bare &lt;code&gt;DiscoveredApi[]&lt;/code&gt; or &lt;code&gt;{ endpoints, warnings }&lt;/code&gt;. Matched endpoints merge with the auto-discovered ones; unmatched seed endpoints are kept with a warning rather than silently dropped. Failures surface as &lt;code&gt;seed-loader-failed&lt;/code&gt; warnings instead of aborting the scan.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try it
&lt;/h2&gt;

&lt;p&gt;Discovery runs in the CLI, the VS Code extension, and the MCP server:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;http-forge discover &lt;span class="nt"&gt;--path&lt;/span&gt; ./backend &lt;span class="nt"&gt;--output&lt;/span&gt; table
http-forge generate-suite &lt;span class="nt"&gt;--path&lt;/span&gt; ./backend &lt;span class="nt"&gt;--collection&lt;/span&gt; &lt;span class="s2"&gt;"my-api"&lt;/span&gt; &lt;span class="nt"&gt;--dry-run&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Or from an agent, via &lt;code&gt;create_request_from_endpoint&lt;/code&gt; and &lt;code&gt;generate_test_suite&lt;/code&gt;.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Getting started:&lt;/strong&gt; &lt;a href="//../user-guide/getting-started.md"&gt;docs/user-guide/getting-started.md&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;CLI reference:&lt;/strong&gt; &lt;a href="https://github.com/hsl1230/http-forge.cli/blob/main/docs/cli-reference.md" rel="noopener noreferrer"&gt;https://github.com/hsl1230/http-forge.cli/blob/main/docs/cli-reference.md&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;HTTP Forge for VS Code:&lt;/strong&gt; &lt;a href="https://marketplace.visualstudio.com/items?itemName=henry-huang.http-forge" rel="noopener noreferrer"&gt;https://marketplace.visualstudio.com/items?itemName=henry-huang.http-forge&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If you're building your own discovery layer, the two ideas worth stealing are the &lt;strong&gt;locked golden fixtures&lt;/strong&gt; and the &lt;strong&gt;deterministic ordering rule&lt;/strong&gt;. They turn a parser from "seems to work" into something you can refactor without fear.&lt;/p&gt;

</description>
      <category>testing</category>
      <category>api</category>
      <category>agents</category>
      <category>ai</category>
    </item>
    <item>
      <title>How I built an MCP server that lets AI agents run my API tests</title>
      <dc:creator>Henry Huang</dc:creator>
      <pubDate>Fri, 30 Oct 2026 16:35:43 +0000</pubDate>
      <link>https://dev.to/hslcalgary/how-i-built-an-mcp-server-that-lets-ai-agents-run-my-api-tests-akm</link>
      <guid>https://dev.to/hslcalgary/how-i-built-an-mcp-server-that-lets-ai-agents-run-my-api-tests-akm</guid>
      <description>&lt;p&gt;I built HTTP Forge because I was tired of maintaining Postman collections by hand. Every time a route changed, a DTO gained a field, or an auth header moved, the collection went stale — and nobody trusted it enough to keep it updated.&lt;/p&gt;

&lt;p&gt;The second problem was more interesting: I wanted an AI agent to be able to drive the whole lifecycle — discover endpoints, generate tests, run them, read the report, diagnose failures, and fix stale assertions. Not just "write me a test" in a chat window, but actually operate the tool.&lt;/p&gt;

&lt;p&gt;That meant building an MCP server.&lt;/p&gt;

&lt;p&gt;This is the story of how it works, what I got wrong, and the transcript of an agent running a real test lifecycle.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why MCP?
&lt;/h2&gt;

&lt;p&gt;The Model Context Protocol (MCP) is a standard way to expose tools to an AI agent. Instead of every agent vendor inventing its own plugin format, the agent discovers a server, lists its tools, and calls them with JSON arguments.&lt;/p&gt;

&lt;p&gt;For a testing tool, that's a natural fit. A test run is a sequence of well-defined operations:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;List collections.&lt;/li&gt;
&lt;li&gt;Run a request or suite.&lt;/li&gt;
&lt;li&gt;Read the results.&lt;/li&gt;
&lt;li&gt;Explain a failure.&lt;/li&gt;
&lt;li&gt;Rewrite a stale assertion.&lt;/li&gt;
&lt;li&gt;Re-run.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Each of those is a tool. The agent doesn't need to know how HTTP Forge stores collections on disk — it just needs a stable contract.&lt;/p&gt;

&lt;h2&gt;
  
  
  The architecture
&lt;/h2&gt;

&lt;p&gt;HTTP Forge has three consumers: a VS Code extension, a CLI, and an MCP server. They all share the same core engine, &lt;code&gt;@http-forge/core&lt;/code&gt;, which is now open source (MIT).&lt;/p&gt;

&lt;p&gt;The important constraint: &lt;strong&gt;core cannot import &lt;code&gt;vscode&lt;/code&gt;&lt;/strong&gt;. That forced a ports-and-adapters design. The core defines interfaces; the extension and CLI inject platform services (file system, workspace state, secret storage).&lt;/p&gt;

&lt;p&gt;The MCP layer sits on top of core like this:&lt;br&gt;
&lt;/p&gt;

&lt;pre data-lang="mermaid"&gt;&lt;code&gt;flowchart LR
    ext["VS Code extension"]
    cli["CLI"]
    mcp["MCP server"]

    core["@http-forge/core"]
    dispatch["dispatchGenericTool()"]

    subgraph handlers["Tool handlers"]
        inspection["inspection"]
        execution["execution"]
        discovery["discovery"]
        suite["suite"]
        environment["environment"]
        ai["AI"]
    end

    ext --&amp;gt; core
    cli --&amp;gt; core
    mcp --&amp;gt; core
    core --&amp;gt; dispatch
    dispatch --&amp;gt; inspection
    dispatch --&amp;gt; execution
    dispatch --&amp;gt; discovery
    dispatch --&amp;gt; suite
    dispatch --&amp;gt; environment
    dispatch --&amp;gt; ai&lt;/code&gt;&lt;/pre&gt;



&lt;p&gt;The dispatcher is deliberately small. Each tool lives in a handler module, and the registry assembles them:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight typescript"&gt;&lt;code&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;ALL_HANDLERS&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;McpToolHandler&lt;/span&gt;&lt;span class="p"&gt;[]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;
  &lt;span class="p"&gt;...&lt;/span&gt;&lt;span class="nx"&gt;inspectionHandlers&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="p"&gt;...&lt;/span&gt;&lt;span class="nx"&gt;executionHandlers&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="p"&gt;...&lt;/span&gt;&lt;span class="nx"&gt;collectionHandlers&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="p"&gt;...&lt;/span&gt;&lt;span class="nx"&gt;requestHandlers&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="p"&gt;...&lt;/span&gt;&lt;span class="nx"&gt;discoveryHandlers&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="p"&gt;...&lt;/span&gt;&lt;span class="nx"&gt;suiteHandlers&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="p"&gt;...&lt;/span&gt;&lt;span class="nx"&gt;aiHandlers&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="p"&gt;];&lt;/span&gt;

&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;buildRegistry&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt; &lt;span class="nb"&gt;Map&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="nx"&gt;GenericToolName&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;McpToolHandler&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;registry&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;Map&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
  &lt;span class="k"&gt;for &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;handler&lt;/span&gt; &lt;span class="k"&gt;of&lt;/span&gt; &lt;span class="nx"&gt;ALL_HANDLERS&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;for &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;name&lt;/span&gt; &lt;span class="k"&gt;of&lt;/span&gt; &lt;span class="nx"&gt;handler&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;toolNames&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nx"&gt;registry&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;set&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;name&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;handler&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nx"&gt;registry&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Adding a tool means adding a handler — not editing the dispatcher. That Open/Closed boundary kept the MCP layer maintainable as it grew past 60 tools.&lt;/p&gt;

&lt;h2&gt;
  
  
  The tool surface
&lt;/h2&gt;

&lt;p&gt;The MCP server exposes tools in a few groups:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Inspection&lt;/strong&gt; — &lt;code&gt;list_collections&lt;/code&gt;, &lt;code&gt;list_requests&lt;/code&gt;, &lt;code&gt;get_request&lt;/code&gt;, &lt;code&gt;get_run_summary&lt;/code&gt;, &lt;code&gt;get_failed_requests&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Execution&lt;/strong&gt; — &lt;code&gt;run_request&lt;/code&gt;, &lt;code&gt;run_folder&lt;/code&gt;, &lt;code&gt;run_collection&lt;/code&gt;, &lt;code&gt;run_suite&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Discovery&lt;/strong&gt; — &lt;code&gt;create_request_from_endpoint&lt;/code&gt;, &lt;code&gt;generate_test_suite&lt;/code&gt;, &lt;code&gt;suggest_workflow&lt;/code&gt;, &lt;code&gt;check_drift&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;AI&lt;/strong&gt; — &lt;code&gt;suggest_assertions&lt;/code&gt;, &lt;code&gt;explain_failure&lt;/code&gt;, &lt;code&gt;heal_assertions&lt;/code&gt;, &lt;code&gt;generate_scenarios&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Suites and environments&lt;/strong&gt; — create/update nodes, select environments, set variables.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Two design choices matter a lot:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;1. Execution is synchronous by default, async on request.&lt;/strong&gt; A small suite returns its result inline. A large suite can be started with &lt;code&gt;async: true&lt;/code&gt;, returning a &lt;code&gt;runId&lt;/code&gt; that the agent polls with &lt;code&gt;get_run_status&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2. Outputs are bounded.&lt;/strong&gt; MCP responses go into an LLM context window. The server truncates large bodies and offers &lt;code&gt;include&lt;/code&gt; fields (&lt;code&gt;perRequest&lt;/code&gt;, &lt;code&gt;failedOnly&lt;/code&gt;, &lt;code&gt;consoleOutput&lt;/code&gt;) so the agent asks for detail only when it needs it.&lt;/p&gt;

&lt;h2&gt;
  
  
  A real lifecycle transcript
&lt;/h2&gt;

&lt;p&gt;Here's what an agent actually does with the server. I've trimmed the outputs for readability.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 1 — Discover endpoints from source
&lt;/h3&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"tool"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"create_request_from_endpoint"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"arguments"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"path"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"./backend"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"collection"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"user-service"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"endpointId"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"POST /users"&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The agent gets back a created request plus provenance — framework, source file, confidence. No OpenAPI spec required.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 2 — Generate a suite
&lt;/h3&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"tool"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"generate_test_suite"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"arguments"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"path"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"./backend"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"collection"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"user-service"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"suiteName"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"smoke-tests"&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The generator creates one request node per endpoint and asserts the discovered status code. Generated nodes carry &lt;code&gt;ai_generated: true&lt;/code&gt; and &lt;code&gt;derived_from: &amp;lt;endpointId&amp;gt;&lt;/code&gt; so drift detection can find them later.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 3 — Run it
&lt;/h3&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"tool"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"run_suite"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"arguments"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"suite"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"smoke-tests"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"environment"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"staging"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"include"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"failedOnly"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"runId"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"run-20261030-141501"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"status"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"completed"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"allPassed"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="kc"&gt;false&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"failedRequests"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
      &lt;/span&gt;&lt;span class="nl"&gt;"name"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"Create User"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
      &lt;/span&gt;&lt;span class="nl"&gt;"status"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="mi"&gt;500&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
      &lt;/span&gt;&lt;span class="nl"&gt;"assertions"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="w"&gt;
        &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"name"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"Status is 201"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"passed"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="kc"&gt;false&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"actual"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="mi"&gt;500&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
      &lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  Step 4 — Diagnose
&lt;/h3&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"tool"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"explain_failure"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"arguments"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"runId"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"run-20261030-141501"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"request"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"Create User"&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The response includes the full request, the response, every assertion result, any script errors, and a plain-English diagnosis. In this case: the staging database was down, not a test bug.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 5 — Heal a stale assertion
&lt;/h3&gt;

&lt;p&gt;Now suppose the API legitimately changed: &lt;code&gt;Create User&lt;/code&gt; used to return &lt;code&gt;201&lt;/code&gt;, and now returns &lt;code&gt;200&lt;/code&gt;. The test is stale, not the server.&lt;/p&gt;

&lt;p&gt;The agent calls:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"tool"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"heal_assertions"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"arguments"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"collection"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"user-service"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"request"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"Create User"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"runId"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"run-20261030-141501"&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The server returns the current script and the last observed response:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"task"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"currentScript"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"pm.test('Status is 201', () =&amp;gt; pm.response.to.have.status(201));"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"lastResponse"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"status"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="mi"&gt;200&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"body"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"id"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"u1"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nl"&gt;"name"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"Alice"&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;},&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"instructions"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="w"&gt;
      &lt;/span&gt;&lt;span class="s2"&gt;"Rewrite the script to match the observed response"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
      &lt;/span&gt;&lt;span class="s2"&gt;"Call set_request_script with the new script"&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The agent then rewrites and saves:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"tool"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"set_request_script"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"arguments"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"collection"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"user-service"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"request"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"Create User"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"phase"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"post-response"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"script"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"pm.test('Status is 2xx', () =&amp;gt; pm.expect(pm.response.code).to.be.oneOf([200, 201]));&lt;/span&gt;&lt;span class="se"&gt;\n&lt;/span&gt;&lt;span class="s2"&gt;pm.test('Returns an id', () =&amp;gt; pm.expect(pm.response.json()).to.have.property('id'));"&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;And re-runs the suite. Green.&lt;/p&gt;

&lt;h2&gt;
  
  
  Assertion healing: why it's safe
&lt;/h2&gt;

&lt;p&gt;The scary part of AI-driven testing is an agent silently weakening your assertions to make tests pass. I designed &lt;code&gt;heal_assertions&lt;/code&gt; to avoid that:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;It's &lt;strong&gt;advisory&lt;/strong&gt;. The tool returns a task describing what to compare; the &lt;em&gt;agent&lt;/em&gt; writes the new script.&lt;/li&gt;
&lt;li&gt;The agent must explicitly call &lt;code&gt;set_request_script&lt;/code&gt; to persist it. Every change is a normal script edit in the collection, visible in git.&lt;/li&gt;
&lt;li&gt;The prompt instructs the agent to keep valid assertions and only fix stale ones.&lt;/li&gt;
&lt;li&gt;There's no "auto-confirm" path. A human can review the diff like any other code change.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The goal is not "agent makes tests green." It's "agent proposes a fix you can review in the same way you'd review a PR."&lt;/p&gt;

&lt;h2&gt;
  
  
  Lessons learned
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Error messages are prompts.&lt;/strong&gt; When an agent calls &lt;code&gt;run_request&lt;/code&gt; with a collection name that doesn't exist, a bare &lt;code&gt;not found&lt;/code&gt; is useless. Returning the available names — &lt;code&gt;Available: user-service, billing-service&lt;/code&gt; — lets the model self-correct in one turn. I rewrote most error paths for this.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Tool names must survive real IDs.&lt;/strong&gt; MCP tool names have provider length limits, and HTTP Forge IDs embed human-readable names. I added deterministic short hashing for long IDs, with readable slugs where possible. The model picks tools by description, so short names don't hurt discovery.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Determinism matters.&lt;/strong&gt; Discovery output is sorted by method, path, and file. No timestamps inside endpoint records. When the agent diffs two scans, noise kills the signal.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Token budget is a feature.&lt;/strong&gt; Async runs, &lt;code&gt;include&lt;/code&gt; filters, and body truncation aren't optimizations — they're what make the server usable with a 200k-token context.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Keep core UI-free.&lt;/strong&gt; Because MCP, CLI, and the extension share the engine, a bug fixed in one is fixed everywhere. The &lt;code&gt;vscode&lt;/code&gt;-free boundary is the reason that works.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try it
&lt;/h2&gt;

&lt;p&gt;If you want to play with the same lifecycle without wiring up a backend:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npm &lt;span class="nb"&gt;install&lt;/span&gt; &lt;span class="nt"&gt;-g&lt;/span&gt; @http-forge/cli
http-forge launch &lt;span class="nt"&gt;--examples&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That clones a sample workspace with pre-built requests, environments, and suites, then opens it in VS Code. You can run a suite, break an assertion on purpose, and watch the explain/heal flow.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;HTTP Forge for VS Code:&lt;/strong&gt; &lt;a href="https://marketplace.visualstudio.com/items?itemName=henry-huang.http-forge" rel="noopener noreferrer"&gt;https://marketplace.visualstudio.com/items?itemName=henry-huang.http-forge&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Open-source core:&lt;/strong&gt; &lt;a href="https://github.com/hsl1230/http-forge.core" rel="noopener noreferrer"&gt;https://github.com/hsl1230/http-forge.core&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If you're building your own MCP server, the two things I'd steal are the per-tool registry and the "errors as prompts" habit. They made the difference between a demo and something an agent can actually use.&lt;/p&gt;

</description>
      <category>mcp</category>
      <category>ai</category>
      <category>testing</category>
      <category>api</category>
    </item>
  </channel>
</rss>
