conductor-oss-native-linux-x64 0.21.2 → 0.22.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/README.md +102 -169
  2. package/package.json +1 -1
package/README.md CHANGED
@@ -4,7 +4,7 @@
4
4
 
5
5
  ### The local-first control plane for AI coding agents
6
6
 
7
- **One command. Markdown-native. No cloud relay.**
7
+ **One command. Markdown-native. Real terminals.**
8
8
 
9
9
  [![npm version](https://img.shields.io/npm/v/conductor-oss?style=flat-square&color=0ea5e9)](https://www.npmjs.com/package/conductor-oss)
10
10
  [![CI](https://img.shields.io/github/actions/workflow/status/charannyk06/conductor-oss/ci.yml?branch=main&style=flat-square&label=CI)](https://github.com/charannyk06/conductor-oss/actions/workflows/ci.yml)
@@ -16,22 +16,22 @@
16
16
 
17
17
  ---
18
18
 
19
- Conductor OSS is a local-first orchestration platform for AI coding agents. It takes Markdown kanban boards, turns them into dispatchable work, and launches your installed coding CLIs — Claude Code, Codex, Gemini, and seven others — inside isolated git worktrees with full terminal access from a browser dashboard.
19
+ Conductor OSS is a local-first orchestration layer for AI coding agents. It turns Markdown kanban boards into dispatchable work, launches installed coding CLIs in isolated git worktrees, and gives you a browser dashboard for live terminal sessions, diffs, previews, and recovery workflows.
20
20
 
21
- Everything runs on your machine. State lives in local files and SQLite. Agents keep their own authentication and billing. Conductor is the operating layer around them, not a replacement.
21
+ By default, everything runs on your machine. Conductor keeps board state in Markdown, stores runtime metadata in SQLite, and leaves authentication and billing to the upstream agent CLIs.
22
22
 
23
23
  ## Why Conductor
24
24
 
25
- Running one agent in one terminal works fine for a single task. When you want to queue multiple tasks across multiple repos, dispatch them to different agents, watch them run in parallel, retry failures, review diffs, and coordinate it all from one place — you need an orchestration layer.
25
+ Running one agent in one terminal works for one task. Conductor is for the next step: multiple tasks, multiple repos, multiple agents, shared queues, session recovery, live review, and one dashboard to coordinate all of it.
26
26
 
27
27
  Conductor adds:
28
28
 
29
- - **Planning** — Markdown kanban boards that work in Obsidian and in the browser
30
- - **Dispatch** — Automated task-to-agent assignment with queue management
31
- - **Isolation** — Git worktree-per-session so agents never step on each other
32
- - **Visibility** — Live terminal streaming, session feeds, and diff inspection
33
- - **Recovery** — Session restore after backend restarts, retries, and feedback loops
34
- - **Review** — PR creation, CI check monitoring, and code diff tools built in
29
+ - **Markdown-native planning** with `CONDUCTOR.md` boards that stay readable in Obsidian or any editor
30
+ - **Dispatch orchestration** that turns tagged cards into queued agent work
31
+ - **Worktree isolation** so concurrent sessions do not trample the same branch
32
+ - **Native terminal sessions** over ttyd-backed PTYs instead of synthetic chat shells
33
+ - **Operational visibility** through session feeds, diffs, previews, health views, and cleanup tools
34
+ - **Recovery loops** with retry, restore, reviewer feedback, and session health tracking
35
35
 
36
36
  ## Quick Start
37
37
 
@@ -47,13 +47,11 @@ Conductor adds:
47
47
  npx conductor-oss@latest
48
48
  ```
49
49
 
50
- This starts the Rust backend and Next.js dashboard, then opens the browser.
50
+ Running the package with no arguments defaults to `start --open`.
51
51
 
52
- - Default dashboard port: `http://127.0.0.1:4747` (overridable)
53
- - Backend port: `http://127.0.0.1:4749` in the launcher flow (or whatever you configure for CLI)
54
- - Rust CLI direct `conductor start` defaults to `http://127.0.0.1:4747` unless `--port` is set.
55
-
56
- For source checkouts, `bun run dev:full` launches the same stack with dashboard defaulting to `3000` in this repo.
52
+ - Primary launcher URL: `http://127.0.0.1:4747`
53
+ - Launcher-managed Rust backend: `http://127.0.0.1:4748` by default
54
+ - The native Rust `conductor start` binary uses `4747` unless you override `--port`
57
55
 
58
56
  ### Initialize an existing repo
59
57
 
@@ -62,7 +60,7 @@ npx conductor-oss@latest init
62
60
  npx conductor-oss@latest start --workspace .
63
61
  ```
64
62
 
65
- This scaffolds `conductor.yaml`, `CONDUCTOR.md`, and `.conductor/conductor.db` in the current directory.
63
+ `init` scaffolds `conductor.yaml` and `CONDUCTOR.md`. The SQLite database at `.conductor/conductor.db` is created the first time the backend starts.
66
64
 
67
65
  ### Global install
68
66
 
@@ -75,7 +73,7 @@ The launcher registers three aliases: `conductor-oss`, `conductor`, and `co`.
75
73
 
76
74
  ## Supported Agents
77
75
 
78
- Conductor ships with adapters for 10 coding agent CLIs. Each adapter handles binary detection, launch commands, process monitoring, and prompt delivery.
76
+ Conductor ships adapters for the major coding CLIs it knows how to discover, launch, and monitor today.
79
77
 
80
78
  | Agent | CLI |
81
79
  |-------|-----|
@@ -87,14 +85,12 @@ Conductor ships with adapters for 10 coding agent CLIs. Each adapter handles bin
87
85
  | Cursor Agent | `cursor-agent` |
88
86
  | OpenCode | `opencode` |
89
87
  | Droid | `droid` |
90
- | GitHub Copilot | `gh copilot` |
88
+ | GitHub Copilot | `gh copilot` / `copilot` |
91
89
  | CCR | `ccr` |
92
90
 
93
- Agents appear in the dashboard picker based on what is installed and authenticated on your machine.
94
-
95
91
  ## Native Terminal Experience
96
92
 
97
- Conductor launches agents into their real terminal UIs — not a synthetic chat shell. Claude Code runs as Claude Code. Codex runs as Codex. Interactive sessions are now `ttyd`-first: each live agent gets a real ttyd-backed PTY, the dashboard connects either straight to that loopback ttyd socket on local desktops or through Conductor's authenticated websocket relay on remote/private paths, and reconnecting still preserves the native agent experience.
93
+ Conductor launches agents into their real terminal UIs. Claude Code runs as Claude Code. Codex runs as Codex. Interactive sessions are ttyd-backed PTYs, so reconnects, resize events, and terminal restore behave like a real terminal session rather than a browser chat imitation.
98
94
 
99
95
  <div align="center">
100
96
 
@@ -112,26 +108,25 @@ Conductor launches agents into their real terminal UIs — not a synthetic chat
112
108
 
113
109
  ### Task Lifecycle
114
110
 
115
- ```
116
- Inbox → Ready to Dispatch → Dispatching → In Progress → Review → Done
111
+ ```text
112
+ Inbox -> Ready to Dispatch -> Dispatching -> In Progress -> Review -> Done
117
113
  ```
118
114
 
119
- 1. **Create tasks** in `CONDUCTOR.md` — a Markdown kanban board compatible with Obsidian
120
- 2. **Move tasks** to "Ready to Dispatch" (or let the automation promote them)
121
- 3. **Conductor dispatches** — picks up queued tasks, selects an agent, prepares the workspace
122
- 4. **Agent executes** — launched in an isolated git worktree with a compiled task prompt
123
- 5. **Monitor live** — terminal streaming, normalized session feed, and runtime metadata in the dashboard
124
- 6. **Review output** — inspect diffs, browse changed files, view CI checks, create PRs
125
- 7. **Iterate** — retry, restore, send feedback, or archive
115
+ 1. Create tasks in `CONDUCTOR.md`.
116
+ 2. Move work into `Ready to Dispatch`.
117
+ 3. Conductor selects an agent, prepares the workspace, and launches a session.
118
+ 4. The agent runs in an isolated git worktree with a compiled task prompt and any context attachments.
119
+ 5. You monitor progress from the dashboard and the live terminal.
120
+ 6. You review diffs, preview local apps, send feedback, retry, restore, or clean up.
126
121
 
127
122
  ### Dashboard Surfaces
128
123
 
129
- Each session page provides:
124
+ Each session page includes:
130
125
 
131
- - **Terminal** — live interactive terminal over the agent's PTY session
132
- - **Overview** — normalized conversation feed, runtime state, metadata, and recovery actions
133
- - **Preview** — connect a local dev URL and interact with the running app
134
- - **Diff** — file-level change inspection and workspace file browser
126
+ - **Terminal** for the live interactive PTY session
127
+ - **Overview** for normalized session state, metadata, and recovery actions
128
+ - **Preview** for project dev-server URLs
129
+ - **Diff** for file changes and workspace inspection
135
130
 
136
131
  <div align="center">
137
132
 
@@ -143,98 +138,60 @@ Each session page provides:
143
138
 
144
139
  ## CLI Reference
145
140
 
146
- The npm launcher (`co`) is the primary CLI. Run `co --help` for the full command list.
141
+ The npm launcher (`co`) is the primary user-facing CLI.
147
142
 
148
143
  | Command | Description |
149
144
  |---------|-------------|
150
- | `co start` | Start the backend and dashboard |
145
+ | `co start` | Start the dashboard and Rust backend |
151
146
  | `co init` | Scaffold `conductor.yaml` and `CONDUCTOR.md` |
152
- | `co setup` | Guided first-run configuration |
153
- | `co doctor` | Diagnose backend and runtime issues |
147
+ | `co setup` | Guided first-run setup for agents, editors, and local tooling |
154
148
  | `co spawn` | Create a new session |
155
- | `co list` | List all sessions |
156
- | `co status` | Summarize workspace and session state |
157
- | `co send` | Send a follow-up message to a running session |
158
- | `co feedback` | Send reviewer feedback into a session |
159
- | `co retry` | Create a new attempt from a prior task or session |
149
+ | `co list` | List sessions |
150
+ | `co status` | Show the current attention-oriented status board |
151
+ | `co send` | Send a message to a running session |
152
+ | `co feedback` | Send reviewer feedback and requeue a session |
153
+ | `co retry` | Create a new attempt from an existing task or session |
160
154
  | `co restore` | Restore an exited session |
161
155
  | `co kill` | Terminate a session |
162
156
  | `co cleanup` | Reclaim resources from completed sessions |
157
+ | `co doctor` | Inspect backend and session health |
163
158
  | `co dashboard` | Open the dashboard in a browser |
159
+ | `co task show <taskId>` | Inspect task attempts, parent, and child tasks |
164
160
  | `co mcp-server` | Run Conductor as an MCP server over stdio |
165
161
 
166
- A lower-level Rust CLI also exists in `crates/conductor-cli` for direct backend interaction during development.
162
+ A lower-level Rust CLI also exists for development and internal flows. That native binary is where the current `bridge` subcommands live.
167
163
 
168
- ## Configuration
164
+ ## Remote Access and Bridge
169
165
 
170
- Conductor uses three local files:
166
+ Conductor is local-first, but the current codebase includes several remote and access-control paths:
171
167
 
172
- | File | Purpose |
173
- |------|---------|
174
- | `conductor.yaml` | Workspace config, project definitions, agent defaults, runtime preferences |
175
- | `CONDUCTOR.md` | Markdown kanban board for planning and dispatch |
176
- | `.conductor/conductor.db` | SQLite database for sessions, metadata, and runtime state |
168
+ - **Private remote access** via a Tailscale link managed from the dashboard
169
+ - **Verified edge auth** via Cloudflare Access JWT validation and role bindings
170
+ - **Optional Clerk integration** for hosted sign-in flows in the web app
171
+ - **Bridge and relay components** for paired-device flows and relay-backed terminals
177
172
 
178
- Additional runtime artifacts:
173
+ What is no longer supported:
179
174
 
180
- - `.conductor/rust-backend/detached/` — PTY session data for terminal restore
181
- - `attachments/` — Uploaded files and generated session artifacts
175
+ - Public share-link remote control without an identity layer
176
+ - The old tmux-first terminal model
182
177
 
183
- ## Architecture
178
+ The user-facing paired-device flow is built around the companion `conductor-bridge` binary and the dashboard bridge pages. The repo also contains `bridge-cmd/`, `crates/conductor-relay/`, and native Rust `conductor bridge ...` commands for lower-level bridge and relay development.
184
179
 
185
- ```
186
- ┌─────────────────┐ ┌──────────────────┐ ┌─────────────────┐
187
- │ npm launcher │ │ Next.js 16 UI │ │ Rust backend │
188
- │ packages/cli │ │ packages/web │ │ conductor- │
189
- │ │ │ │ │ server │
190
- │ start, spawn, │───▶│ Dashboard, │◀──▶│ HTTP + SSE + │
191
- │ init, doctor │ │ Terminal, │ │ WebSocket │
192
- │ │ │ Diff, Preview │ │ │
193
- └─────────────────┘ └──────────────────┘ └────────┬────────┘
194
- │
195
- ┌───────────────────────────────────┤
196
- │ │
197
- ┌────────▼────────┐ ┌──────────▼──────────┐
198
- │ conductor-core │ │ conductor-executors │
199
- │ Types, config, │ │ 10 agent adapters, │
200
- │ board parsing │ │ process management │
201
- └─────────────────┘ └──────────────────────┘
202
- │ │
203
- ┌────────▼────────┐ ┌──────────▼──────────┐
204
- │ conductor-db │ │ conductor-git │
205
- │ SQLite via sqlx │ │ Worktree isolation │
206
- └─────────────────┘ └──────────────────────┘
207
- ```
208
-
209
- ### Rust Crates
210
-
211
- | Crate | Purpose |
212
- |-------|---------|
213
- | `conductor-server` | Axum HTTP server — 22 route modules, session manager, PTY runtime, SSE streaming |
214
- | `conductor-core` | Shared types, board parser, configuration, task and session models |
215
- | `conductor-executors` | 10 agent adapters — binary detection, launch commands, prompt delivery |
216
- | `conductor-db` | SQLite persistence via sqlx with compile-time checked queries |
217
- | `conductor-git` | Git operations and worktree lifecycle management |
218
- | `conductor-watcher` | Filesystem watcher for `CONDUCTOR.md` changes |
219
- | `conductor-cli` | Low-level Rust CLI binary |
180
+ ## Local Files and Runtime Artifacts
220
181
 
221
- ### TypeScript Packages
182
+ Conductor uses a small set of local files:
222
183
 
223
- | Package | Purpose |
224
- |---------|---------|
225
- | `packages/cli` | npm launcher — user-facing CLI, binary management, process orchestration |
226
- | `packages/web` | Next.js 16 dashboard — session UI, terminal viewer, board editor, diff tools |
227
- | `packages/core` | Shared TypeScript types and Zod schemas |
184
+ | File | Purpose |
185
+ |------|---------|
186
+ | `conductor.yaml` | Workspace config, project definitions, access rules, and preferences |
187
+ | `CONDUCTOR.md` | Markdown kanban board for planning and dispatch |
188
+ | `.conductor/conductor.db` | SQLite state for sessions, attempts, metadata, and runtime coordination |
228
189
 
229
- ### Key Design Decisions
190
+ Common runtime artifacts:
230
191
 
231
- - **Local-first** — no cloud relay, no credential proxying, all state on disk
232
- - **SQLite-only** — single-file database, no external DB dependency
233
- - **TTyd-backed PTY** — shell-backed sessions via real `ttyd`, not synthetic chat shells
234
- - **Agent-agnostic** — Conductor orchestrates; each agent keeps its own auth and billing
235
- - **Markdown-native** — boards live in `CONDUCTOR.md`, readable in any editor or Obsidian
236
- - **Worktree isolation** — each session gets its own git worktree to prevent conflicts
237
- - **TTYD-first streaming** — real `ttyd` sessions with backend-authenticated relay and restore-aware capture
192
+ - `.conductor/rust-backend/detached/` for restore data and detached PTY runtime state
193
+ - `attachments/` for uploaded files and generated session artifacts
194
+ - `~/.conductor/` for launcher runtime state and optional bridge token/state files
238
195
 
239
196
  ## Develop From Source
240
197
 
@@ -254,69 +211,64 @@ bun install
254
211
  ### Commands
255
212
 
256
213
  ```bash
257
- bun run dev:full # Dashboard (port 3000) + Rust backend (port 4749)
214
+ bun run dev:full # Dashboard on 3000 + Rust backend on 4749
258
215
  bun run dev # Dashboard only
259
- bun run dev:backend # Backend only (or: `cargo run --bin conductor -- --workspace . start --port 4749`)
260
- bun run build # Full production build
216
+ bun run dev:backend # Backend only through the launcher path
217
+ bun run build # Production build
261
218
  bun run typecheck # TypeScript type checking
262
219
 
263
- export CONDUCTOR_DEV_DASHBOARD_PORT=3000 # optional
220
+ export CONDUCTOR_DEV_DASHBOARD_PORT=3000 # optional
264
221
  export CONDUCTOR_DEV_BACKEND_PORT=4749 # optional
265
222
 
266
- cargo test --workspace # Rust tests
267
- cargo clippy --workspace -- -D warnings # Rust linting
223
+ cargo test --workspace
224
+ cargo clippy --workspace -- -D warnings
268
225
  ```
269
226
 
270
- ```bash
271
- # If you want only the frontend on port 3000 and backend separately:
272
- bun run --cwd packages/web dev
273
- cargo run --bin conductor -- --workspace . start --port 4749
274
- ```
227
+ ### Port Reference
275
228
 
276
- ### Dev Ports
277
-
278
- | Service | Port |
279
- |---------|------|
280
- | Dashboard (dev) | `http://localhost:3000` |
281
- | Dashboard (prod) | `http://127.0.0.1:4747` |
282
- | Rust backend | `http://127.0.0.1:4749` |
229
+ | Scenario | Dashboard | Rust backend |
230
+ |----------|-----------|--------------|
231
+ | `co start` launcher defaults | `4747` | `4748` |
232
+ | Source dev scripts in this repo | `3000` | `4749` |
233
+ | Native `cargo run --bin conductor -- start` | n/a | `4747` |
283
234
 
284
235
  ## Project Structure
285
236
 
286
- ```
237
+ ```text
287
238
  conductor-oss/
239
+ ├── bridge-cmd/ # Companion bridge binary used by the pairing flow
288
240
  ├── crates/
289
- │ ├── conductor-server/ # Axum HTTP server, routes, state, SSE
290
- │ ├── conductor-core/ # Types, config, board parsing
291
- │ ├── conductor-executors/ # Agent adapters (10 agents)
292
- │ ├── conductor-db/ # SQLite persistence
293
- │ ├── conductor-git/ # Git/worktree operations
294
- │ ├── conductor-watcher/ # Filesystem watcher
295
- │ ├── conductor-cli/ # Rust CLI binary
296
- │ └── notify-rust/ # Desktop notifications
241
+ │ ├── conductor-cli/ # Native Rust CLI
242
+ │ ├── conductor-core/ # Config, board parsing, task/session models, scaffolding
243
+ │ ├── conductor-db/ # SQLite persistence
244
+ │ ├── conductor-executors/ # Agent adapters and process management
245
+ │ ├── conductor-git/ # Git and worktree operations
246
+ │ ├── conductor-relay/ # Relay server for bridge and remote terminal flows
247
+ │ ├── conductor-server/ # Axum server, routes, runtime state, SSE
248
+ │ ├── conductor-types/ # Shared transport and bridge protocol types
249
+ │ ├── conductor-watcher/ # Filesystem watching
250
+ │ └── notify-rust/ # Desktop notification support
297
251
  ├── packages/
298
- │ ├── cli/ # npm launcher
299
- │ ├── web/ # Next.js dashboard
300
- │ └── core/ # Shared TypeScript types
252
+ │ ├── cli/ # npm launcher
253
+ │ ├── core/ # Shared TypeScript types and schemas
254
+ │ └── web/ # Next.js dashboard
301
255
  ├── docs/
302
- │ ├── screenshots/ # Dashboard and session screenshots
303
- │ ├── demo/ # Workflow demo videos
304
- │ └── terminal-*.md # Terminal protocol and QA docs
305
- ├── .github/workflows/ # CI, release, security, PR checks
306
- ├── Cargo.toml # Rust workspace
307
- ├── package.json # Bun workspace
308
- ├── conductor.yaml # Workspace config (user-created)
309
- ├── CONDUCTOR.md # Kanban board (user-created)
310
- └── LICENSE # MIT
256
+ │ ├── demo/ # Workflow demos
257
+ │ ├── screenshots/ # Dashboard and terminal screenshots
258
+ │ └── terminal-*.md # Terminal protocol and QA docs
259
+ ├── Cargo.toml # Rust workspace
260
+ ├── package.json # Bun workspace
261
+ ├── conductor.yaml # Workspace config (user-created)
262
+ └── CONDUCTOR.md # Board file (user-created)
311
263
  ```
312
264
 
313
265
  ## Known Constraints
314
266
 
315
- - Agent output quality depends entirely on the upstream CLI you install — Conductor orchestrates, it does not modify agent behavior
316
- - GitHub-integrated flows (PR creation, check monitoring) work best with `gh` installed and authenticated
317
- - Preview tooling requires a repo that exposes a local dev server URL
318
- - Remote access was intentionally removed — use your own network or proxy layer for remote setups
319
- - Interactive sessions run through ttyd; legacy tmux and legacy direct sessions are compatibility data that should be archived instead of resumed
267
+ - Output quality depends on the upstream agent CLI you install; Conductor orchestrates it, not its model behavior
268
+ - GitHub-heavy flows work best with `gh` installed and authenticated
269
+ - Preview tooling depends on a project exposing a local dev server or explicit preview URL
270
+ - Public remote admin links were removed; use Tailscale or a verified identity layer instead
271
+ - Legacy tmux and legacy direct sessions are compatibility data that should be archived rather than resumed
320
272
 
321
273
  ## Links
322
274
 
@@ -332,22 +284,3 @@ conductor-oss/
332
284
  ## License
333
285
 
334
286
  MIT. See [LICENSE](LICENSE).
335
-
336
- ## Conductor Bridge
337
-
338
- Conductor Bridge lets you keep the backend on your machine while accessing the dashboard from a browser through a relay.
339
-
340
- ### CLI commands
341
-
342
- ```bash
343
- conductor bridge connect --relay ws://127.0.0.1:8080
344
- conductor bridge status
345
- conductor bridge disconnect
346
- ```
347
-
348
- ### Runtime ports
349
-
350
- - Relay: `http://127.0.0.1:8080`
351
- - Dashboard: `http://127.0.0.1:3000`
352
- - Backend: `http://127.0.0.1:4749`
353
-
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "conductor-oss-native-linux-x64",
3
- "version": "0.21.2",
3
+ "version": "0.22.0",
4
4
  "license": "MIT",
5
5
  "private": false,
6
6
  "os": [