Skip to content
MLReps
Back to the ways to connect

Connect with CLI

One install, then one command in your project.

Your source never leaves your machine; the report is uploaded so you can open and share it.. One install on your machine, then one command inside your project — on your laptop now, and later in the build pipeline you already have, so the map stays up to date as you merge.

The scan runs where your code already is and sends only the graph it built, so your code never leaves your machines. A terminal, or GitHub Actions, GitLab, Jenkins, CircleCI or Bitbucket.

  1. Run it

    in your repository

    npm install -g mlreps
    
    export MLREPS_ENDPOINT=https://dev.mlreps.com
    
    mlreps setup

    The second command reads this folder’s git remote, opens your browser with a code to match, and asks you to approve this machine, for this one repository.Then it keeps the key for this repository in your own config directory — readable only by you, outside every working tree — and publishes the first scan. Nothing is written into your repository, and you paste nothing.

    Or export a key and scan, by hand

    with a key you already have

    npm install -g mlreps
    
    export MLREPS_API_KEY=<your project key>
    export MLREPS_ENDPOINT=https://dev.mlreps.com
    
    mlreps scan . --publish

    Node.js 20 or newer on your machine, or a build that needs no Node at all from the install script or Homebrew. Teams without Node use the GitHub App instead, which installs nothing. One command, in every language — the install does not touch your project. Every command is on the commands page. Without installing anything, npx mlreps@latest works in place of mlreps in any command here, and mlreps doctor says what it found on this machine.

  2. Your key

    A key belongs to an account, and setup makes both in the browser — so there is nothing to do here first. Or make an account now. It publishes scans and does nothing else: it can send but never read, so if it leaks somebody could put a wrong picture in front of you and could see nothing of yours.

  3. What it costs

    Verify your email and you get $3 of balance — 3 published audits, with nothing to enter.

    The scan runs on your own machine and prints what it found for nothing, every time. Publishing the audit to your dashboard — where it is kept, and can be read and shared — is what costs $1.

    Paid scanning is not live yet, and there is no way to add balance — so when the free balance is spent, publishing stops until it is. Nothing can be charged to anybody today.

    Never charged: a commit we have already audited · the scan itself, on any repository · an audit we could not do · the rest of the day's included audits, through any door · anything that broke on our side.

    Set a monthly limit in billing and nothing is charged past it — unless you pass --over-limit yourself, which the ledger records as exactly that.

    What is never charged, in full
  4. Where the report appears

    The terminal prints the link. Your repository is then at your dashboard — what the audit found, your architecture, and what a change would touch, one click along the rail. The key is for writing only: nothing on those screens can be read with it.

  5. Optional · keep it current on every push

    in your CI's shell step

    # in a checkout of the default branch, with full history
    npm install
    
    export MLREPS_API_KEY="<from your CI's secret store>"
    export MLREPS_ENDPOINT=https://dev.mlreps.com
    npx mlreps@latest scan . --publish

    It keeps the dashboard up to date, so you never need a terminal for this again. It runs on your default branch only — reports from every branch would make this a picture of whichever job finished last.

    Each push to that branch that changes code is one audit, $1. A push that changes no code returns the audit we already have and costs nothing. --publish is what makes it appear here. Your source never leaves your machine; the report is uploaded so you can open and share it. The endpoint is /api/scan/v1/report, and the response to every publish is the diagnostic: what we stored, what we could not read, and what was swept out of it.

Pull-request checks, and what the CLI reads — reference, not a step. The same two lines also post a check: mlreps check . with the workflow on this page.

`mlreps check` compares this pull request against its merge base and reports what the change adds — not every finding in the repository. It needs the full history (`fetch-depth: 0`): in a shallow checkout, or where the base tree cannot be read, it says so and reports nothing rather than reporting every finding as new. A rule that could not run on the base is named too.

What is in your scrollback

Before publishing, the command prints the counts it is about to send, and ends on Published … and the link to it. Nothing is sent on a run without --publish.

If nothing arrives

Three different empties with three different fixes — which one, and how to tell.

Where the workflow file lives

In your repository, reviewed in a pull request like any other change. We print it here; we do not write to your repository, and this path never gives us the ability to.

Want nothing to reach us at all? Run it in your own pipeline — checks only, no dashboard

The scan runs in your own build pipeline (CI), on code that is already checked out there, using the access your build job already has, and posts a check on your own pull requests. Nothing reaches us — not your source, not the findings, not a list of your files — because nothing on our side analyses it, so there is nowhere to send it. No account, no key.

  1. Try it where you are standing

    It prints what it found and always finishes with success (exit code zero), so it never breaks a build — including its own.

    in a terminal

    mlreps scan .
    mlreps check . --dry-run

    --dry-run shows the check it would post on a pull request, without posting it, so you can read what your team would see.

  2. Add the workflow

    It already has the two lines people usually forget: the permissions block, without which the job cannot post its check, and the head commit, without which the check lands on a temporary merge commit and the pull request shows nothing.

    .github/workflows/codebase.yml

    name: MLReps
    
    on:
      pull_request:
    
    # Without this, GITHUB_TOKEN cannot write a check run and every run ends in a 403.
    permissions:
      contents: read
      checks: write
    
    jobs:
      scan:
        runs-on: ubuntu-latest
        steps:
          - uses: actions/checkout@v4
          - uses: actions/setup-node@v4
            with:
              node-version: 24
          # Your own dependencies. MLReps does not need them; with them installed it can
          # follow imports into packages, and without them it says those were unresolved.
          - run: npm install
          - run: npx mlreps@latest check .
            env:
              GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
              # On a pull request, GITHUB_SHA is a merge commit that exists nowhere in
              # the repository — a check run posted against it is invisible.
              PLATFORM_HEAD_SHA: ${{ github.event.pull_request.head.sha }}
    

No dashboard, because we hold nothing

There is no architecture, no findings history and no dashboard this way — we can only draw those from data of yours that reaches us, and this way nothing does. You get the check on each pull request. What appears, and where.

You can change your mind later

Publishing is one flag and one key away: the same scan, run the same way, with --publish added.

Nothing arrived? Three different empties, and the line that tells them apart

Two of the three happen on a machine MLReps has never seen, so it cannot tell you which one you are in. Every example below is exactly what the command prints.

It ran, and nothing was sent

A scan run with --local, or with nothing to prove whose scan it is, finishes on your machine and sends nothing — and says so in three lines.

what it printed instead
Nothing was sent: this ran on your machine only.
Add --publish to put this on your dashboard — your architecture, what the audit found, and what a change reaches.
It needs a project key in MLREPS_API_KEY (or MLREPS_KEY, the old name); make one at https://dev.mlreps.com/start

A run that did reach us ends on these, and your scrollback has them or it does not:

the end of a publish that worked
Published acme/storefront at 8f2c1a9d.
See it: https://dev.mlreps.com/platform?repo=acme%2Fstorefront
Next: open it signed in to the account that made this key.

It ran, and the publish was refused

The scan finished and we did not take it. Every refusal is one line beginning Not published: — so a search of a CI log for that phrase finds all of them — and the map stays as it was rather than half-updating. This is the one people meet: a folder with no git remote has no repository name to be filed under.

a refusal, in the product's own words
Not published: this checkout has no git remote, so the scan cannot be filed under a repository name — a folder name is not one. Add a remote (git remote add origin <url>), or publish from CI.

It arrived — under a different repository

A scan is filed under the git remote of the folder it ran in, not under the screen you were watching. The report is not lost — it is on that other repository.

how to tell
$ git remote -v
origin  https://github.com/acme/storefront-v2.git (fetch)

This is the one that looks like a bug and is not. Your repositories lists every one that has published — the scan is under one of them.

What we will not do while it is empty

Show an architecture with no commit on it, a zero where a measurement belongs, or a verdict about the whole repository computed from nothing. An empty screen that says which empty it is costs you one read; a confident wrong one costs you the next three decisions.