komet
Health Gecti
- License — License: NOASSERTION
- Description — Repository has a description
- Active repo — Last push 0 days ago
- Community trust — 18 GitHub stars
Code Basarisiz
- os.homedir — User home directory access in crates/harness/src/cursor/shim.mjs
- process.env — Environment variable access in crates/harness/src/cursor/shim.mjs
- rm -rf — Recursive force deletion command in crates/harness/tests/fixtures/fake-acp.sh
Permissions Gecti
- Permissions — No dangerous permissions requested
Bu listing icin henuz AI raporu yok.
Komet — native control plane for coding agents. One Rust binary drives Claude Code, Codex, Cursor, Copilot, Cline, Grok, Hermes, OpenCode, Pi, Antigravity and Qoder. 100% local-first, optional self-hosted sync.
Komet — native control plane for coding agents
Komet is the native control plane for coding agents. One Rust binary drives Claude Code, Codex, Cursor, Devin, GitHub Copilot, Cline, Grok, Hermes, Muse Code, OpenCode, Pi, Antigravity and Qoder — 100% local by default, with optional self-hosted sync across your devices.
Why Komet
- Native Rust, single binary. UI and engine ship as one executable built on gpui (the framework behind Zed). No Electron, no runtime to install, no account required —
curl | shand you're running. - Local-first, sync optional. Every device keeps its own engine and store; nothing leaves your machine unless you deliberately self-host
komet-sync-server(Loro CRDT, bearer-token auth, SQLite). - 13 agents, one interface. Each agent is wired through its strongest native surface (stream-json, app-server, SDK, ACP, MSP) and normalized into a single session model — switch providers mid-conversation and the transcript carries over.
Status: alpha → beta. Core flows (run, steer, interrupt, questions, diffs, terminals, sync) are implemented and tested, but the architecture is still moving fast — expect breaking changes between releases. See docs/PARITY.md for the honest per-feature status.
Security: komet's sandbox settings constrain the agent CLI's own permissions — they are not an OS-level boundary. Agent processes run with your user's privileges. See docs/security.md and SECURITY.md.
Supported agents
| Agent | Interface | Status |
|---|---|---|
| Claude Code | native stream-json | stable |
| Codex | native codex app-server |
stable |
| Cursor | pinned SDK shim | stable |
| Muse Code | native Muse Session Protocol | stable |
| Devin | ACP (devin acp) |
experimental |
| GitHub Copilot | ACP (copilot --acp) |
experimental |
| Cline | ACP (cline --acp) |
experimental |
| Grok | ACP (grok agent stdio) |
experimental |
| Hermes | ACP (hermes acp) |
experimental |
| OpenCode | ACP (opencode acp) |
experimental |
| Pi | ACP via pi-acp adapter |
experimental |
| Antigravity | native NDJSON run | experimental |
| Qoder | ACP (qoder --acp) |
experimental |
"Stable" means a native protocol driver with end-to-end live verification.
"Experimental" means the adapter is implemented and fixture-tested, but parts of
the interaction surface (questions, compaction, subagent transcripts) are still
gated pending live evidence — the UI shows no affordance it cannot honour.
Details: ARCHITECTURE.md §6 and crates/harness/src/capabilities.rs.
Fork notice
Komet is a fork of Zeron / zeronsh/comet
(MIT, same author lineage — see LICENSE and
THIRD_PARTY_NOTICES.md). The fork diverges on
local-first sync, the self-hosted komet-sync-server, the Rust+gpui UI, and the
agent harness layer; upstream history is preserved via the upstream git
remote (git fetch upstream).
Principles
- Local-first — works fully offline, data stays on device
- Single binary — UI + engine, headed or headless mode
- Multiple agents — native CLI, MSP, and ACP integrations with mid-conversation provider switching
- Optional sync — Loro CRDT via a self-hosted
komet-sync-server(SQLite + bearer token)
Installation
All binaries are available on GitHub Releases.
Linux
One-line install (recommended)
curl -fsSL https://raw.githubusercontent.com/jomvick/komet/main/install.sh | sh
komet status
Installs komet to ~/.komet/app and links it into ~/.local/bin. To run the
engine as a user service, run komet daemon install.
Standalone AppImage
chmod +x komet-*.AppImage
./komet-*.AppImage
Fedora / Ubuntu 24.04+: if double-click does not work, ensure
chmod +xis set and install FUSE (sudo dnf install fuse/sudo apt install libfuse2), or run with--appimage-extract-and-run.
Tarball archive
Download komet-<version>-linux-<arch>.tar.gz then run ./install.sh inside the archive.
macOS
| Method | File | Action |
|---|---|---|
| Disk Image | komet-<version>-macos-arm64.dmg |
Drag Komet.app to Applications |
| CLI / Daemon | — | The installer links no komet CLI: run Komet.app/Contents/MacOS/komet daemon install (or … status) from the bundle |
Windows
| Method | File | Action |
|---|---|---|
| Portable | komet-<version>-windows-x86_64.exe / .zip |
Extract and run komet.exe |
| Service | — | komet.exe daemon install or komet.exe --service |
Updating
The self-updater supports Linux installs made with the one-line installer and
the macOS app bundle:
komet update
On Linux, run the command above. On macOS, click the update banner in Komet and
restart the app when prompted. For other installation types, download the latest
release from GitHub Releases and
install or replace the existing app:
| Platform / install type | Update |
|---|---|
Fedora / RPM (x86_64) |
Download the latest komet-<version>-1.x86_64.rpm, then run sudo dnf install ./komet-<version>-1.x86_64.rpm |
Fedora / RPM (aarch64) |
Download the latest komet-<version>-1.aarch64.rpm, then run sudo dnf install ./komet-<version>-1.aarch64.rpm |
Debian / Ubuntu (amd64) |
Download the latest komet_<version>_amd64.deb, then run sudo apt install ./komet_<version>_amd64.deb |
Debian / Ubuntu (arm64) |
Download the latest komet_<version>_arm64.deb, then run sudo apt install ./komet_<version>_arm64.deb |
| Linux AppImage | Download the latest AppImage and replace the old file |
| Linux tarball | Download and extract the latest tarball, then run its included install.sh |
| macOS DMG | Download the latest DMG and replace Komet.app in Applications |
| Windows portable EXE / ZIP | Download the latest EXE or ZIP and replace the existing komet.exe |
komet update does not update RPM/DEB packages, AppImages, or Windows portable
downloads; use the package manager or replace those files as described above.
Daily usage
komet status # engine status + local/sync mode
komet update # update a Linux install made with the one-line installer
komet engine stop # gracefully stop the desktop app's background engine
komet daemon start|stop|restart|status
komet headless # engine only (no UI)
The desktop app starts its engine as a detached background process when one is not already
running. Closing the window or quitting Komet does not interrupt active sessions. Usekomet engine stop to stop that engine explicitly; komet daemon remains for service-managed
headless deployments.
Multi-device sync (self-hosted)
Disabled by default. To sync across devices via your own server:
1. On your VPS / server:
komet sync-init # prints KOMET_SYNC_TOKEN
export KOMET_SYNC_TOKEN=xxx # or put it in .env for compose
docker compose -f docker-compose.sync.yml up -d
# or locally: KOMET_SYNC_TOKEN=xxx komet sync-server
2. On each device:
export KOMET_EDGE_URL=https://sync.example.com
export KOMET_SYNC_TOKEN=xxx
komet
Plain http:// is only for a LAN you control (e.g. http://192.168.1.10:8787);
the token travels as a bearer, so never expose it unencrypted on the internet.
Full details:
docs/self-hosted-sync.md
Remote devices (a VM or VPS with its own workspace)
An environment is a workspace backed by its own sync server: its sessions run on
that machine and its sidebar stays separate from your local one. Install the
agent CLIs you want to use there first (opencode, hermes, codex, …) — the
environment offers exactly the agents its own machine has. On the remote
machine:
curl -fsSL https://raw.githubusercontent.com/jomvick/komet/main/install.sh \
| sh -s -- --serve --lan
It installs the same komet binary as the desktop app, registers it as a user
service, and prints a komet://pair/… link. komet serve never opens a
window, but the binary still links gpui's system libraries: on a minimal
Debian/Ubuntu image install them first (no display server or desktop session is
needed):
# Debian/Ubuntu
sudo apt install libxcb1 libxkbcommon0 libxkbcommon-x11-0 libdbus-1-3
# Fedora
sudo dnf install libxcb libxkbcommon libxkbcommon-x11 dbus-libs
Paste the link in Komet → Settings → Sync → Add device, then pick the
machine from the Devices menu at the top of the sidebar to chat on it and
manage its agents. --lan serves plain HTTP, so the dialog asks you to confirm
you are on a network you control; behind TLS, usekomet serve --public-url https://sync.example.com --install-service instead.
The token and namespace are generated once and saved in ~/.komet/serve.json
(0600); the link is a secret — it grants the bearer a shell on that machine.
On a VPS, also run loginctl enable-linger $USER so the user service keeps
running after you log out.
To stop being an environment: Settings → Sync → Remove on the desktop (tick
purge to delete its local mirror too), then systemctl --user disable --now komet.service && rm -rf ~/.komet ~/.local/bin/komet on the remote machine.
Full details:
docs/environments.md
Architecture
gpui UI ── RPC (localhost / in-proc) ── engine A ══ komet-sync server ══ engine B ── RPC ── gpui UI
│ self-hosted, bearer-token auth │
└── Loro CRDT sync (rooms + blobs) ──────────────┘
| Crate | Role |
|---|---|
komet-engine |
sessions, agents, terminals, git/worktrees |
komet-ui |
gpui interface (sidebar, transcript, composer, diff) |
komet-doc |
Loro schemas + mirror layer |
komet-sync |
room client + SQLite snapshots |
komet-sync-server |
self-hosted sync server (rooms, blobs, bearer auth) |
komet-harness |
ACP adapters (8 agents) |
Learn more: ARCHITECTURE.md · docs/
Development
cargo run --bin komet # main app (UI + engine)
cargo run --bin komet-sync-server # standalone sync server
The Browser surface uses the Servo webview engine as a sidecar process.
Build servo-webview-engine from the Servo checkout, then point Komet at it:
cargo build --manifest-path ../servo/Cargo.toml \
-p webview-engine --bin servo-webview-engine
SERVO_WEBVIEW_ENGINE="$(realpath ../servo/target/debug/servo-webview-engine)" \
cargo run --bin komet
In packaged builds, place servo-webview-engine beside the Komet executable
or set SERVO_WEBVIEW_ENGINE to its absolute path.
cargo runalone fails: the workspace exposes two binaries, so--binis required.
Credits
Komet is a fork of zeronsh/comet — same MIT license, same author (Wing). The fork diverges on local-first sync, self-hosted komet-sync-server, and gpui UI refinements. Upstream history is preserved via the upstream git remote (git fetch upstream).
License
MIT — contributions welcome. See CONTRIBUTING.md,
CODE_OF_CONDUCT.md and SECURITY.md.
Yorumlar (0)
Yorum birakmak icin giris yap.
Yorum birakSonuc bulunamadi