conductor-oss-native-linux-x64 0.21.3 → 0.23.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 (3) hide show
  1. package/README.md +101 -169
  2. package/bin/conductor +0 -0
  3. 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,59 @@ 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
+ ## Access Control and Bridge
169
165
 
170
- Conductor uses three local files:
166
+ Conductor is local-first, but the current codebase includes several access-control and paired-device 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
+ - **Verified edge auth** via Cloudflare Access JWT validation and role bindings
169
+ - **Optional Clerk integration** for hosted sign-in flows in the web app
170
+ - **Bridge and relay components** for paired-device flows and relay-backed terminals
177
171
 
178
- Additional runtime artifacts:
172
+ What is no longer supported:
179
173
 
180
- - `.conductor/rust-backend/detached/` — PTY session data for terminal restore
181
- - `attachments/` — Uploaded files and generated session artifacts
174
+ - Public share-link remote control without an identity layer
175
+ - The old tmux-first terminal model
182
176
 
183
- ## Architecture
177
+ 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
178
 
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 |
179
+ ## Local Files and Runtime Artifacts
220
180
 
221
- ### TypeScript Packages
181
+ Conductor uses a small set of local files:
222
182
 
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 |
183
+ | File | Purpose |
184
+ |------|---------|
185
+ | `conductor.yaml` | Workspace config, project definitions, access rules, and preferences |
186
+ | `CONDUCTOR.md` | Markdown kanban board for planning and dispatch |
187
+ | `.conductor/conductor.db` | SQLite state for sessions, attempts, metadata, and runtime coordination |
228
188
 
229
- ### Key Design Decisions
189
+ Common runtime artifacts:
230
190
 
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
191
+ - `.conductor/rust-backend/detached/` for restore data and detached PTY runtime state
192
+ - `attachments/` for uploaded files and generated session artifacts
193
+ - `~/.conductor/` for launcher runtime state and optional bridge token/state files
238
194
 
239
195
  ## Develop From Source
240
196
 
@@ -254,69 +210,64 @@ bun install
254
210
  ### Commands
255
211
 
256
212
  ```bash
257
- bun run dev:full # Dashboard (port 3000) + Rust backend (port 4749)
213
+ bun run dev:full # Dashboard on 3000 + Rust backend on 4749
258
214
  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
215
+ bun run dev:backend # Backend only through the launcher path
216
+ bun run build # Production build
261
217
  bun run typecheck # TypeScript type checking
262
218
 
263
- export CONDUCTOR_DEV_DASHBOARD_PORT=3000 # optional
219
+ export CONDUCTOR_DEV_DASHBOARD_PORT=3000 # optional
264
220
  export CONDUCTOR_DEV_BACKEND_PORT=4749 # optional
265
221
 
266
- cargo test --workspace # Rust tests
267
- cargo clippy --workspace -- -D warnings # Rust linting
222
+ cargo test --workspace
223
+ cargo clippy --workspace -- -D warnings
268
224
  ```
269
225
 
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
- ```
226
+ ### Port Reference
275
227
 
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` |
228
+ | Scenario | Dashboard | Rust backend |
229
+ |----------|-----------|--------------|
230
+ | `co start` launcher defaults | `4747` | `4748` |
231
+ | Source dev scripts in this repo | `3000` | `4749` |
232
+ | Native `cargo run --bin conductor -- start` | n/a | `4747` |
283
233
 
284
234
  ## Project Structure
285
235
 
286
- ```
236
+ ```text
287
237
  conductor-oss/
238
+ ├── bridge-cmd/ # Companion bridge binary used by the pairing flow
288
239
  ├── 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
240
+ │ ├── conductor-cli/ # Native Rust CLI
241
+ │ ├── conductor-core/ # Config, board parsing, task/session models, scaffolding
242
+ │ ├── conductor-db/ # SQLite persistence
243
+ │ ├── conductor-executors/ # Agent adapters and process management
244
+ │ ├── conductor-git/ # Git and worktree operations
245
+ │ ├── conductor-relay/ # Relay server for bridge and remote terminal flows
246
+ │ ├── conductor-server/ # Axum server, routes, runtime state, SSE
247
+ │ ├── conductor-types/ # Shared transport and bridge protocol types
248
+ │ ├── conductor-watcher/ # Filesystem watching
249
+ │ └── notify-rust/ # Desktop notification support
297
250
  ├── packages/
298
- │ ├── cli/ # npm launcher
299
- │ ├── web/ # Next.js dashboard
300
- │ └── core/ # Shared TypeScript types
251
+ │ ├── cli/ # npm launcher
252
+ │ ├── core/ # Shared TypeScript types and schemas
253
+ │ └── web/ # Next.js dashboard
301
254
  ├── 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
255
+ │ ├── demo/ # Workflow demos
256
+ │ ├── screenshots/ # Dashboard and terminal screenshots
257
+ │ └── terminal-*.md # Terminal protocol and QA docs
258
+ ├── Cargo.toml # Rust workspace
259
+ ├── package.json # Bun workspace
260
+ ├── conductor.yaml # Workspace config (user-created)
261
+ └── CONDUCTOR.md # Board file (user-created)
311
262
  ```
312
263
 
313
264
  ## Known Constraints
314
265
 
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
266
+ - Output quality depends on the upstream agent CLI you install; Conductor orchestrates it, not its model behavior
267
+ - GitHub-heavy flows work best with `gh` installed and authenticated
268
+ - Preview tooling depends on a project exposing a local dev server or explicit preview URL
269
+ - Public remote admin links were removed; use a verified identity layer instead
270
+ - Legacy tmux and legacy direct sessions are compatibility data that should be archived rather than resumed
320
271
 
321
272
  ## Links
322
273
 
@@ -332,22 +283,3 @@ conductor-oss/
332
283
  ## License
333
284
 
334
285
  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/bin/conductor CHANGED
Binary file
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "conductor-oss-native-linux-x64",
3
- "version": "0.21.3",
3
+ "version": "0.23.0",
4
4
  "license": "MIT",
5
5
  "private": false,
6
6
  "os": [