Your terminal.Your team.One room.

Opens KODEO in your browser; you choose what the CLI may do (read or write, Git, all or some workspaces) and approve. The sign-in is kept in your OS keychain and bound to this computer — a copy of it doesn’t work anywhere else. It also offers to set git up for git.kodeo.website.

--device

Print a code to enter at kodeo.website/device instead — for SSH, containers and machines without a browser.

--vscode

Use KODEO for VS Code’s sign-in on this computer (2.1+): VS Code asks you to confirm, and the CLI gets a new sign-in of its own — never wider than VS Code’s, never with the Git remote.

--read-only

Ask for read-only access (clone, pull, status; no push).

--no-git

Don’t set git up for git.kodeo.website.

--no-browser

Print the sign-in link instead of opening a browser.

Ends the session on KODEO (it disappears from Settings → Local access) and deletes it from this computer.

Shows the account, the computer, its access (read or write, which workspaces, Git) and when it expires.

Lists your tokens (name, prefix, access, expiry, last use). create opens Settings → Local access, because tokens are made in the browser behind “Confirm it’s you” — a token can never make more tokens. revoke takes the id or the token’s prefix and stops it at once.

Every computer signed in to the CLI, VS Code or Git (with the client’s version, what it may do and when it was last active) and your personal access tokens. revoke ends one at once; with no id it asks which. Never shows an IP address or a place — Settings → Local access, behind your browser sign-in, does.

--all

Include sign-ins that have ended recently.

Per workspace: storage used of the plan’s, runtime hours used and left this period (add-ons included), projects of the plan’s allowance and how many people can edit live at once. Near a limit it says so, with the billing link.

--workspace <slug>

Only this workspace.

theme (auto follows your KODEO theme, or one of the 20), background (dark/light, when the terminal can’t say), popups (important/all/off), desktop (off by default; on shows titles only, full adds the text), telemetry (off by default; anonymous speed numbers), editor (what kodeo code opens), plain (screen-reader mode), motion (on/reduced) and icons (unicode/ascii/nerd). With a key and no value it asks (or shows it); with nothing it lists them all. Theme and pop-ups are shared with KODEO for VS Code on this computer; telemetry never is.

--reset

Put every setting back to its default (your sign-in is untouched).

Ends this computer’s sign-in on KODEO and deletes it from the keychain, removes the CLI’s settings, caches and history, takes kodeo out of your global Git config, and unlinks linked folders (their .kodeo/local state — your files are never touched). Nothing on KODEO is deleted.

--keep-folders

Leave linked folders linked.

Each with your role, branch, file count, size, last change and who is live in it right now (browser, VS Code and CLI counts), or that it’s on this computer.

--names

Print only workspace/project, one per line (for scripts).

--workspace <slug>

Only this workspace.

Like VS Code’s Switch Project (Alt+K): your recent projects first, then the rest, searchable. Outside a linked folder, who, chat, comments, git, pr, terminals and ui then use it; inside one, the folder’s project wins. Tells you where the project lives on this computer, if it does.

--clear

Forget the switched project.

The browser’s templates (Blank, Next.js, React + Vite, Node + Express, FastAPI, Go, Rust, HTML/CSS/JS) — their starter files written in the same transaction. Then clone it into a folder, open it in the browser or the dashboard.

--workspace <slug>

Where to create it (asked when you can create in several).

--template <id>

blank, nextjs, react-vite, node-express, python-fastapi, go, rust or static.

--clone [folder]

Clone it straight away (into ./<project> by default).

--open

Open it in the browser.

Byte-identical, binary files and empty folders included. Writes a starter .kodeoignore for your framework (build output and caches stay on your machine). Refuses a folder that isn’t empty.

Asks which workspace (or takes --workspace), creates the project and pushes the folder — ignore rules, secret checks and plan limits apply.

--workspace <slug>

The workspace to create it in.

--name <name>

The project’s name (default: the folder’s name).

--allow-secrets <path>

Upload a file that looks like a secret (repeatable).

Nothing is overwritten: files on both sides that differ are merged, or marked as conflicts. Then kodeo status shows what differs and kodeo push sends your side.

--diff3

Conflict markers include the common base.

Removes .kodeo/local. Your files and the project on KODEO are untouched.

Lists your changes (A added, M modified, D deleted, renames), KODEO’s changes and files changed on both sides. Only files whose size or time changed are hashed, so it’s fast on big folders.

--offline

Only look at this folder (no network).

Coloured and numbered; side by side from 160 columns. --json gives each file’s unified patch.

--side

Side by side, whatever the width.

--unified

One column, whatever the width.

A file changed on both sides is merged three-way; if the same lines changed, conflict markers (<<<<<<<) are written and the file isn’t pushed until you fix it. Binary files never get markers: yours stays and KODEO’s is saved beside it as name.kodeo.ext. An interrupted pull is finished next time, never left half-applied.

--ours

Resolve every conflict with your version.

--theirs

Resolve every conflict with KODEO’s version.

--diff3

Conflict markers include the common base.

--switch

Follow the project to the branch it switched to.

--dry-run

Show what would change, change nothing.

Refused as a whole if any file you’re pushing changed on KODEO since your last pull — you’re told who changed it; run kodeo pull, then push. Plan limits are checked before anything uploads, only new content travels, files open in a teammate’s editor are merged into it live, and deletes go to the 7-day trash. Files that look like secrets (.env, keys) ask first, and are refused under CI unless named with --allow-secrets.

--dry-run

Show exactly what would be pushed, push nothing.

--allow-secrets <path>

Push a file that looks like a secret (repeatable; required under CI).

--force

Push files that still contain conflict markers, as they are.

Pushes each save once the file stops changing, and pulls teammates’ edits within about a second. The status line shows ✓ synced / ↻ sending / ↓ receiving / ☁ offline, who is here and which file each has open; teammates’ changes, chat and summons appear above it, and notifications pop up (and, with kodeo config desktop on, on your desktop). Offline, your saves wait in the folder and go out version-checked when you’re back. A conflict pauses only that file — press c to compare, keep yours or use KODEO’s. Only one sync engine runs per folder: if KODEO for VS Code is syncing it, watch stands by and takes over when VS Code stops. Teammates see you as “syncing from a local folder”.

--diff3

Conflict markers include the common base.

--poll <seconds>

How often to double-check KODEO as a backup to the live connection (default 15).

--keep-mine

Settle a file changed on both sides with your version (no markers).

--use-kodeo

Settle a file changed on both sides with KODEO’s version.

--no-popups

Don’t show notifications or chat above the status line.

One screen: the project (people with their clients, who’s typing and following whom, who’s running what, plan & usage), files with teammates’ initials on the ones they have open, activity, chat (with @mentions), comments (reply, resolve), the project’s Git (stage, commit, branches, the commit graph) and teammates’ shared terminals. Tab or 1–7 switches panes; : (or Ctrl+K) runs any kodeo command; ? shows every key; the mouse works where your terminal sends it. Side by side on wide terminals, tabs on narrow ones (t toggles; [ and ] resize, remembered). Everything updates live from the room; leaving restores your terminal exactly.

--project <workspace>/<project>

Which project (default: this folder’s, or the switched one).

--watch

Also keep this linked folder in sync while the dashboard is open.

Everyone in the project now — with browser, VS Code or CLI, the file they’re in, whether they’re typing, whom they follow (and who follows them), who asked not to be followed, who is syncing a folder and who is running the project.

--project <workspace>/<project>

Which project.

--follow

Keep the list live until Ctrl+C.

With a message, sends it (@username mentions notify people; anything that looks like a secret is masked first). Without one, shows the last week’s messages — and on a terminal opens a chat box with @-completion where new messages arrive live. --follow streams new messages (as JSON lines with --json).

--follow

Keep printing new messages until Ctrl+C.

--limit <n>

How many recent messages to show (default 30).

--project <workspace>/<project>

Which project.

People in the room get a toast with a Go button; teammates who aren’t get a notification that opens that line. Editors and above only.

--note <text>

A short note with it (140 characters).

--project <workspace>/<project>

Which project.

Open threads by default, grouped by file with the latest replies. Each has an id for kodeo comment reply|resolve|reopen|show.

--open

Unresolved threads (the default).

--resolved

Resolved threads.

--mine

Threads you started or replied to.

--mentions

Threads that @mention you.

--project <workspace>/<project>

Which project.

The same threads as the editor and VS Code. Ids can be shortened to their first characters; with no id on a terminal you pick from a list. Mentions notify people; secret-looking text is masked before sending. apply (in the project’s linked folder) puts a suggested change into your copy of the file, pushes that one file — merged into the room if someone has it open — and marks the suggestion applied.

--project <workspace>/<project>

Which project.

open goes where the notification points: a file and line opens in your editor (kodeo code), a ticket shows here, a Help article opens here, anything else opens the browser. --follow prints new ones as they arrive over the CLI’s own live channel — and, with kodeo config desktop on, shows them on your desktop, following KODEO’s pause and quiet hours, never twice on one computer with VS Code.

--unread

Only unread notifications.

--follow

Keep printing new notifications until Ctrl+C.

--limit <n>

How many to show (default 30, at most 50).

--all

With read: mark everything read.

What’s shared right now — terminals, tasks, Run output and Python — with its owner, status, watchers and who has the keyboard.

--project <workspace>/<project>

Which project.

Their screen, full screen in yours. It’s read-only until you ask: press Enter to ask for the keyboard; if they hand it over, your keys go to their terminal — checked by the collab server and again in their browser on every keystroke — until the grant lapses or they take it back. Their output is redrawn by kodeo from a terminal emulator, so nothing in it can act on your terminal. Ctrl+] leaves.

--project <workspace>/<project>

Which project.

Gives the app on localhost:<port> its own address on KODEO’s preview domain — the same links, access rules and viewers list as the browser editor — with a QR code and a live log of every request. It only ever talks to this computer (127.0.0.1 or ::1) on that port; no host name is resolved and no redirect followed. Viewers of a link anyone can open see a one-time notice that it isn’t a KODEO page. Ctrl+C stops sharing and ends the link (--keep leaves it, paused, until it expires). Pro and Team; a Team policy can turn it off.

--team

Workspace members only (the default).

--link

Anyone signed in to KODEO (a Team policy may limit it to some email domains).

--public

Anyone with the link.

--password <pw>

Anyone with the link and this password (6+ characters).

--webhook [path]

A URL for test webhooks — POSTs from GitHub, Cashfree, Stripe… reach your app (only under the path).

--expires <time>

How long the link lasts: 15m, 1h (default), 24h, 7d — up to your plan’s or the workspace’s longest.

--keep

Leave the link when you stop (paused until you share again).

--no-qr

Don’t print the QR code.

--name <label>

A label for the link, shown in the Share menu (e.g. “API demo”).

--project <workspace>/<project>

Which project it belongs to.

Lists the project’s live apps — one per person and port, from the browser editor, kodeo share or VS Code — with how many people are watching each right now, and your links underneath (who they open for, when they end). open opens an app in your browser already signed in (a one-time link); qr prints a QR code for your phone — for a team app it carries a one-time pass (no sign-in on the phone, two minutes, once), for an anyone/password link it’s the link itself; stop ends one you shared (workspace admins can stop anyone’s). Ids can be shortened.

--path <page>

With open or qr: the page to open, e.g. /dashboard.

--project <workspace>/<project>

Which project.

Streamed answers rendered from Markdown, with numbered sources from the Help Center, action cards to pick from, 👍/👎, and past conversations (30 days) to resume. Assist answers questions about KODEO (not your code); it’s told a few state words about the CLI — its version, whether the folder is linked and syncing, your OS family — never your code, files, paths or terminal output. The first time, it asks whether it may look at your account when a question needs it.

--new

Start a new conversation.

--resume <id>

Carry on a past conversation.

--history

List your conversations of the last 30 days.

--delete <id>

Forget a conversation.

Searches every article as you type with the Help Center’s own engine — nothing is sent while you type, and it works offline once the index is cached. Articles open in a pager: y/n says whether it helped, a asks Assist about it, o opens it in the browser. Works signed out.

--category <id>

List one category’s articles (getting-started, account, workspaces, billing, editor, collaboration, runtime, git, troubleshooting).

The same tickets as /tickets: list them, open one (a category, a subject and what happened — kodeo attaches only its state words, never files, code or output; screenshots are added in the browser), read the conversation, reply, mark solved, reopen and rate. Staff replies show in kodeo inbox.

--subject <text>

With new: the subject (otherwise asked).

--category <id>

With new: account, billing, editor, collaboration, runtime, git, bug, feature, security or other.

--message <text>

With new: what happened (otherwise asked).

Per-person staging; commits with co-authors from the room, a secret scan and the branch rules said first; branches switched for everyone (changes parked and brought back); merges with conflicts you resolve in your editor or with --ours/--theirs/--both; stashes; tags; log --graph (a coloured commit graph); blame (shaded by age); diffs; GitHub — pull, push, fetch (--unshallow), publish, link, unlink, clone, CI checks — through KODEO’s GitHub App, with “connect GitHub” in your browser when it’s needed. Not the real git in a folder cloned from git.kodeo.website: kodeo git always acts on the project on KODEO.

--message <text>

The commit (or stash, or tag) message (also -m).

--all

stage/unstage/discard everything · commit everything · branch: include GitHub’s · log: every branch.

--amend

commit: replace the last commit.

--graph

log: draw the commit graph.

--limit <n>

log: how many commits (default 60).

--create <name>

branch: create it and switch everyone to it.

--delete <name>

branch/tag: delete it.

--rename <from> <to>

branch: rename it.

--abort

merge: give the merge up.

--ours

merge: settle every conflict in these files with the project’s side, then stage them.

--theirs

merge: settle them with the merged branch’s side.

--both

merge: keep both sides, ours first.

--unshallow

fetch: the full history of a shallow clone.

--private

publish: a private GitHub repository (the default).

--public

publish: a public GitHub repository.

--force

stage: files that look secret · push: force-push · branch --delete: unmerged.

--staged

diff: what you’ve staged.

--with-secrets

commit: even though the secret scan found something.

--project <workspace>/<project>

Which project.

view shows the description, files, conversation, reviews and CI; diff the changes; review comments, approves or asks for changes — with comments on lines of the new code; merge merges, squashes or rebases; checkout switches the project to its branch (for everyone); create opens one from the current branch (pushing it first).

--approve

review: approve it.

--request-changes

review: ask for changes.

--comment

review: comment without approving.

--message <text>

review: the review’s comment (also -m).

--line "<file>:<line> <text>"

review: a comment on a line of the new code (repeatable).

--squash

merge: squash and merge.

--rebase

merge: rebase and merge (a merge commit by default).

--title <text>

create: the title (merge: the commit title).

--body <text>

create: the description.

--base <branch>

create: the branch to merge into (the repository’s default).

--head <branch>

create: the branch with the changes (the current one).

--draft

create: as a draft.

--state <open|closed|all>

list: which ones (open by default).

--project <workspace>/<project>

Which project.

With --vscode (or another editor’s flag) the project opens in that editor through KODEO for VS Code: this folder if it’s linked, otherwise straight from KODEO. The extension must be installed there.

--vscode

Open in VS Code (KODEO for VS Code).

--insiders

Open in VS Code Insiders.

--cursor

Open in Cursor.

--windsurf

Open in Windsurf.

--vscodium

Open in VSCodium.

Through KODEO for VS Code when it’s installed: this folder if the project is linked here, otherwise straight from KODEO, live with your team. Without the extension, a linked folder still opens with the editor’s own link. Which editor: the flag, then kodeo config editor, then KODEO’s “Open code links in”, then whatever is installed. File names are never put on a shell command line.

--project <workspace>/<project>

Which project (default: this folder’s, or the switched one).

--insiders

VS Code Insiders.

--cursor

Cursor.

--windsurf

Windsurf.

--vscodium

VSCodium.

--web

vscode.dev in the browser.

The same checkpoints as the editor’s history panel. diff shows how a checkpoint differs from the file now — before you restore it. Works in any folder (the project comes from --project or kodeo switch too).

Takes the id (or its first characters) from kodeo checkpoint list.

A push’s deletes are grouped, so one restore brings them all back.

kodeo login sets it up for you (for KODEO’s Git host only). Git then gets a one-hour, Git-only credential for each clone or push — nothing long-lived is stored in ~/.git-credentials. You never run it yourself.

Node.js, proxy, connection and TLS, your clock, the version, the keychain, the sign-in and session, git and the git helper, KODEO for VS Code (installed, up to date, which folder it syncs), your terminal (colours, Unicode, links), desktop notifications, and where the CLI keeps its settings.

--fix

Fix what can be fixed here: install or update KODEO for VS Code in your editor, repair the git helper.

Used by the extension’s “Use My kodeo CLI Sign-In”: the extension makes its own key and PKCE secret and passes only their public halves; this asks KODEO for a one-minute, single-use code that only the extension can trade — for a new VS Code sign-in (its own row in Settings → Local access, never wider than this one). You don’t normally run it yourself.

--challenge

The extension’s PKCE challenge (base64url SHA-256 of its secret).

--key

The extension’s own public device key.