> ## Documentation Index
> Fetch the complete documentation index at: https://kardow.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Kardow CLI

> Pull your job board's source code, run it locally against live data, and deploy it, from your terminal or an AI coding agent.

Your board is a real Next.js codebase. The CLI lets you pull it, edit it with any
tool you like, and ship it back, without opening the dashboard editor.

It is also the interface AI coding agents use. Claude Code, Cursor and Codex can
run these commands directly, so "change my job board" becomes a task you hand to
an agent instead of a ticket you write.

<Note>
  Source: [github.com/Kardow/kardow-cli](https://github.com/Kardow/kardow-cli) (Apache-2.0).
  Prefer working in chat rather than code? The [MCP connector](/docs/guides/mcp/connect-claude)
  covers jobs, pages and analytics without touching the source.
</Note>

## Install

```bash theme={null}
npm install -g kardow
```

Requires Node 18 or newer. Check it worked:

```bash theme={null}
kardow --cli-version
```

## Quickstart

```bash theme={null}
kardow login                 # authorize this machine (opens your browser)
kardow boards                # list the boards you can manage
kardow pull acme-jobs        # download the source into ./acme-jobs
cd acme-jobs
kardow dev                   # run it locally against your live data
kardow deploy                # build and publish your changes
```

`kardow pull` writes a `.env.local` with everything the project needs, so the
folder runs with nothing to configure. `kardow dev` installs dependencies the
first time and reinstalls only when they actually change.

## Commands

| Command                                  | What it does                                                  |
| ---------------------------------------- | ------------------------------------------------------------- |
| `kardow login` / `logout`                | Authorize this machine. Logout revokes the token server side. |
| `kardow whoami`                          | Show the signed-in account.                                   |
| `kardow boards`                          | List boards you can manage.                                   |
| `kardow install [--force]`               | Install dependencies. `dev` calls this for you.               |
| `kardow dev [-p port]`                   | Run the board locally against live data.                      |
| `kardow pull <board> [dir]`              | Download a board's source.                                    |
| `kardow deploy [--dry-run] [-y]`         | Ship changed files to the live board.                         |
| `kardow logs`                            | Build log from the last deploy.                               |
| `kardow status`                          | Live URL, active template, last save.                         |
| `kardow rollback --to <sha>`             | Revert the source to an earlier commit.                       |
| `kardow orgs list` / `create` / `copy`   | Create and clone organizations.                               |
| `kardow template list` / `set <slug>`    | List a board's sites, switch the live one.                    |
| `kardow config get` / `set <key>`        | Colors, languages, navigation, custom code.                   |
| `kardow secrets list` / `set` / `delete` | Vault-backed org secrets.                                     |
| `kardow tokens list` / `revoke`          | Manage this account's CLI tokens.                             |

Inside a pulled folder, the board is inferred, so `--board` is optional.

## Create a whole board in one command

```bash theme={null}
kardow orgs create "Acme Jobs" --template studio
```

That creates the organization, claims a subdomain, deploys a live site, creates
the source repo, and pulls it into a local folder. One command, from nothing to
a running job board you can edit.

To give a new client the same design as an existing board, with their own data:

```bash theme={null}
kardow orgs copy acme-jobs --to-name "Globex Careers"
```

## Preview before you go live

Every site version has its own URL, so you can deploy and check a change before
pointing your domain at it.

```bash theme={null}
kardow template list                 # each version and its own URL
kardow pull acme-jobs --version v2   # pull that version
cd acme-jobs && kardow deploy        # deploys to the version's URL only
kardow template set v2               # promote it to the live domain
```

## Secrets

Values are write only. Store one, then reference it in configuration as
`vault:<name>`.

```bash theme={null}
kardow secrets set PDL_API_KEY       # prompts, nothing is echoed
```

<Warning>
  Passing the value as an argument (`kardow secrets set NAME sk_live_...`) works
  but puts it in your shell history. Omit it to be prompted, or pipe it with
  `--stdin`.
</Warning>

## Working with an AI agent

Point Claude Code, Cursor or Codex at a pulled folder and it can read the code,
make changes, and ship them. A useful first prompt:

```
This is a Kardow job board (Next.js). Run `kardow dev` to preview it and
`kardow deploy` to publish. Don't edit files listed in .kardow/managed.json,
the platform rewrites those on every deploy.
```

For headless environments such as CI or a cloud agent, set `KARDOW_TOKEN`
instead of running `kardow login`.

## Troubleshooting

<AccordionGroup>
  <Accordion title="Dependencies fail to install">
    The CLI installs with `--legacy-peer-deps` already, because boards pin
    React 19 while some packages still declare a React 18 peer range. If you
    installed by hand and hit `ERESOLVE`, run `kardow install` instead.
  </Accordion>

  <Accordion title="My edit did not survive a deploy">
    You edited a platform-managed file. `kardow pull` writes
    `.kardow/managed.json` listing them, and `kardow deploy` warns when you
    change one. Those paths are rewritten from the base template every deploy.
  </Accordion>

  <Accordion title="Deploy says nothing changed">
    Deploy compares against the last pull. Use `--force` to deploy anyway, or
    `--dry-run` to see what it thinks changed.
  </Accordion>
</AccordionGroup>