npm - conductor-oss-native-linux-x64 - Versions diffs - 0.6.3 → 0.7.0 - Mend

conductor-oss-native-linux-x64 0.6.3 → 0.7.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

package/README.md CHANGED Viewed

@@ -2,73 +2,139 @@
 # Conductor OSS
-**Local-first orchestration for terminal coding agents, with a browser dashboard, markdown board, tmux runtime, and worktree-aware repo management.**
+### AI agents that write code while you sleep.
-<br>
+**One command. Local-first. No cloud relay.**
 [![npm version](https://img.shields.io/npm/v/conductor-oss?style=flat-square&color=0ea5e9)](https://www.npmjs.com/package/conductor-oss)
 [![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)
 [![License: MIT](https://img.shields.io/badge/license-MIT-22c55e?style=flat-square)](LICENSE)
-[![Bun](https://img.shields.io/badge/bun-1.2+-f59e0b?style=flat-square)](https://bun.sh)
-[![Rust](https://img.shields.io/badge/rust-backend-ce422b?style=flat-square)](https://www.rust-lang.org)
+[![Rust Backend](https://img.shields.io/badge/rust-local_backend-ce422b?style=flat-square)](https://www.rust-lang.org)
 [![GitHub Stars](https://img.shields.io/github/stars/charannyk06/conductor-oss?style=flat-square&color=facc15)](https://github.com/charannyk06/conductor-oss/stargazers)
 </div>
-Conductor OSS is a local-first control plane for coding-agent CLIs. It runs on your machine, talks to the agent tools you already have installed, and keeps project state in local files plus a local SQLite database.
+Conductor turns your repo into a local agent control plane.
-The current app combines:
+Run one command, open a dashboard, drag work into a ready lane, and let your installed coding agents pick it up in parallel. Conductor keeps the state on your machine, runs a local Rust backend, stores data in local SQLite, and streams updates into the dashboard over SSE.
-- a workspace dashboard for projects, sessions, and agents
-- a markdown-backed kanban board stored in `CONDUCTOR.md`
-- tmux-backed session execution with restore/retry/archive flows
-- worktree or in-place repo execution
-- a Rust API/backend with a Next.js dashboard frontend
+If you like Claude Code, Codex, Gemini, Qwen, Amp, Cursor Agent, or Copilot but want orchestration instead of a single terminal session, this is the missing layer.
-## What The App Does Today
+## Why Conductor
-- Add a workspace from an existing local repo or clone one from a Git URL.
-- Persist project settings in `conductor.yaml`, including default agent/model choices and preview-server settings.
-- Create and manage board tasks from the UI, with human-readable task refs, comments, attachments, and linked session attempts.
-- Spawn multiple agent sessions against the same repo, either on the main checkout or in isolated worktrees.
-- Stream session chat and terminal output into the dashboard with interrupt, send, kill, archive, restore, and retry actions.
-- Inspect a session's diff and a live preview tab. The preview surface can capture page context and send screenshots, DOM data, console logs, or network logs back to the active session as attachments.
-- Discover installed agent CLIs, surface model selection where supported, and keep session history resumable instead of treating runs as disposable.
-- Integrate with GitHub repositories and GitHub Projects v2 through `gh`, plus receive signed GitHub webhooks on `/api/github/webhook`.
-- Apply dashboard access controls with viewer/operator/admin roles, trusted-header auth, optional Clerk wiring, and Tailscale-managed private remote access.
+- One command to a working dashboard.
+- Local-first architecture with no hosted relay in the middle.
+- Bring your own agent CLI and auth; Conductor does not proxy provider credentials.
+- Markdown-backed Kanban board in `CONDUCTOR.md`.
+- Multi-session orchestration with retries, restore, archive, and diff review.
+- Worktree-aware repo isolation so multiple agents can work on the same codebase safely.
+- GitHub-aware flows for repos, PRs, checks, and project sync.
-## Current Architecture
+## Quick Start
-### Frontend
+### 1. Make sure the machine has the basics
-- `packages/web`: Next.js 16, React 19, Tailwind CSS 4 dashboard
-- Main surfaces: workspace overview, workspace board, session detail, session diff, session preview, repository/settings panels
-- API routes in the Next app proxy or coordinate with the Rust backend and the local preview/remote-access helpers
+- Node.js `>= 18`
+- `git`
+- `tmux`
+- at least one supported coding-agent CLI installed and already authenticated
-### Backend
+### 2. Launch Conductor
-Rust crates under `crates/`:
+```bash
+npx conductor-oss@latest
+```
+What that does today:
+- starts the local Conductor dashboard
+- launches the local Rust backend
+- opens the app in your browser
+- keeps your project state local
+The published npm package includes platform-native backend packages for:
+- macOS (`arm64` and `x64`)
+- Linux (`x64`)
+- Windows (`x64`)
+### 3. Add a repo and dispatch work
+From the dashboard you can:
+- add an existing local repo
+- clone a Git repo into a managed workspace
+- create tasks in the board
+- drag a task into `Ready to Dispatch`
+Conductor will spin up a session, stream output live, track the diff, and keep the attempt history attached to the task.
-- `conductor-cli`: Rust backend entrypoint
-- `conductor-server`: Axum server and API routes
-- `conductor-db`: SQLite persistence and migrations
-- `conductor-executors`: runtime/session execution plumbing
-- `conductor-git`: Git and worktree operations
-- `conductor-watcher`: watcher support
-- `conductor-core`: shared types and config model
+## Inside An Existing Repo
-### Persistence
+If you want to bootstrap Conductor files inside the repo you are already in:
-Conductor is local-first, but not stateless. Current data lives in:
+```bash
+npx conductor-oss@latest init
+npx conductor-oss@latest start --workspace .
+```
+That scaffolds:
+- `conductor.yaml`
+- `CONDUCTOR.md`
+- `.conductor/conductor.db`
+If you prefer a global install:
+```bash
+npm install -g conductor-oss
+co
+```
-- `conductor.yaml`: workspace and repository configuration
-- `.conductor/conductor.db`: local SQLite state
-- `CONDUCTOR.md`: project-local markdown board
-- `attachments/<project>/...`: uploaded files used in board tasks and session replies
+The CLI exposes `conductor-oss`, `conductor`, and `co`.
+## What You Get
+- Workspace dashboard for repositories, projects, sessions, and agents
+- Markdown-native Kanban board stored in `CONDUCTOR.md`
+- Local Rust backend for orchestration, persistence, and API routes
+- SQLite persistence in `.conductor/conductor.db`
+- Live session chat/output streaming
+- Session diff inspection and preview tooling
+- Retry, restore, archive, kill, and feedback flows
+- Worktree or in-place execution modes
+- GitHub repo discovery, webhook handling, and project sync
+- Access controls for shared/private dashboard setups
+## Why This Exists
+Raw coding-agent CLIs are good at one task in one terminal.
+Conductor adds the missing operating system around them:
+- queueing
+- board automation
+- task history
+- worktree isolation
+- session recovery
+- browser visibility
+- multi-agent coordination
+## Local-First, Explicitly
+Conductor is opinionated about where your code and session state live:
+- your repositories stay on your machine
+- the main backend runs locally
+- state is stored in local files plus local SQLite
+- the dashboard talks to the local backend
+- upstream agent auth and billing stay with the agent vendor you already use
+Conductor is not a hosted agent SaaS and not a relay that forwards your repo through a third-party service.
 ## Supported Agents
-The repo currently ships built-in adapters and UI metadata for:
+Built-in adapters currently exist for:
 - Claude Code
 - Codex
@@ -81,34 +147,44 @@ The repo currently ships built-in adapters and UI metadata for:
 - GitHub Copilot
 - CCR
-Actual availability depends on what is installed and authenticated on your machine. Conductor does not bypass upstream auth, billing, or provider-side limits.
+Availability still depends on what is installed and authenticated on your machine.
-## Runtime Model
+## Current Reality
-The current runtime path is tmux-centric.
+Conductor is already usable, but strangers should know the current edges:
-- Sessions are launched under tmux.
-- Session recovery and `co attach` assume tmux is available.
-- Workspaces can run in `worktree` mode or `local` mode.
-- Preview support depends on either a configured local dev server or a preview URL already associated with the session/PR.
+- The runtime is still `tmux`-first, so `tmux` is effectively required.
+- Agent behavior depends on the upstream CLI you install.
+- GitHub-heavy flows are best with `gh` installed and authenticated.
+- Preview tooling is strongest when a repo has an explicit local dev server configured.
+- The product is currently a hybrid stack: Rust backend plus Next.js dashboard/launcher.
-## Quick Start From Source
+## Important Commands
+- `co start` - start the dashboard and local backend
+- `co init` - scaffold `conductor.yaml` and `CONDUCTOR.md`
+- `co setup` - guided environment setup
+- `co spawn` - start a new session for a project
+- `co list` - list sessions
+- `co status` - summarize active sessions
+- `co send` - send a follow-up to a session
+- `co restore` - relaunch a dead session
+- `co retry` - create a new attempt from a prior task/session
+- `co kill` - terminate a session
+- `co cleanup` - reclaim resources from completed sessions
+- `co mcp-server` - run Conductor as an MCP server
+## Developer Setup
+If you are hacking on Conductor itself:
 ### Requirements
 - Bun `>= 1.2`
-- Node.js `>= 18` if you want to install the published npm CLI
 - Rust toolchain
-- Git
-- tmux
-- one or more supported coding-agent CLIs
-Useful optional tools:
-- GitHub CLI `gh` for repo discovery and GitHub Projects sync
-- Tailscale for managed private remote access
+- Node.js `>= 18`
-### Install and run
+### Run from source
 ```bash
 bun install
@@ -120,7 +196,7 @@ Default dev ports:
 - dashboard: `http://localhost:3000`
 - Rust backend: `http://127.0.0.1:4749`
-Other useful scripts:
+Useful scripts:
 ```bash
 bun run dev
@@ -133,205 +209,37 @@ bun run build:frontend
 bun run clean
 ```
-### Prod-like local stack
-```bash
-bun run prod:prepare
-bun run prod:full
-```
-Default prod-like local ports:
-- dashboard: `http://127.0.0.1:4747`
-- Rust backend: `http://127.0.0.1:4748`
-Notes:
-- Root scripts automatically source `./.env.local` when present.
-- Set `CONDUCTOR_GITHUB_WEBHOOK_SECRET` if you want webhook signature verification.
-- GitHub Projects v2 sync requires a `gh` login with project scopes:
-```bash
-gh auth refresh --scopes read:project,project
-```
-## Getting A Workspace Into Conductor
-You can do this from the dashboard or from the CLI.
-### Dashboard flow
-From the workspace overview, add either:
+## Architecture
-- an existing local repository
-- a Git repository to clone into a managed location
+### User-facing stack
-When a workspace is added, Conductor persists it into `conductor.yaml`, ensures a board file exists, and syncs project support files.
+- npm CLI for install and launch
+- Next.js dashboard for the browser UI
+- Rust backend for orchestration, API routes, session state, Git integration, and persistence
-### CLI flow
-Inside a repo:
-```bash
-co init
-co start --workspace .
-```
-Or, after installing the npm package:
-```bash
-npm install -g conductor-oss
-co
-```
-Or without a global install:
-```bash
-npx conductor-oss@latest
-```
-The CLI package exposes `conductor`, `conductor-oss`, and `co`.
-## CLI Surface
-The current CLI commands include:
-- `co start`: launch the dashboard and backend
-- `co dashboard`: open the dashboard in a browser
-- `co setup`: guided environment/bootstrap flow
-- `co init`: scaffold `conductor.yaml` and `CONDUCTOR.md`
-- `co spawn`: create a new session for a project
-- `co list`: list sessions
-- `co status`: group active sessions by attention level
-- `co send`: send a follow-up message to a session
-- `co attach`: attach to the tmux session
-- `co restore`: relaunch a dead/exited session
-- `co retry`: create a fresh attempt from a prior session or task
-- `co feedback`: send reviewer feedback and requeue work
-- `co kill`: terminate a session
-- `co cleanup`: reclaim completed session resources
-- `co doctor`: diagnose config, board, and watcher issues
-- `co task show`: inspect task graph and attempts
-- `co mcp-server`: start the MCP server command path
-## Configuration
-The app's main configuration file is `conductor.yaml`.
-Representative shape:
-```yaml
-workspace: /absolute/path/to/control-workspace
-server:
-  host: 127.0.0.1
-  port: 4749
-projects:
-  my-app:
-    name: My App
-    repo: https://github.com/acme/my-app.git
-    path: /absolute/path/to/my-app
-    defaultBranch: main
-    runtime: tmux
-    workspace: worktree
-    boardDir: my-app
-    agent: codex
-    agentConfig:
-      permissions: default
-      model: o4-mini
-      reasoningEffort: medium
-    devServer:
-      command: bun dev
-      cwd: packages/web
-      port: 3001
-preferences:
-  codingAgent: codex
-access:
-  requireAuth: false
-```
-Useful project-level fields supported by the current code:
-- `defaultWorkingDirectory`
-- `setupScript`
-- `cleanupScript`
-- `archiveScript`
-- `copyFiles`
-- `devServer.command`
-- `devServer.cwd`
-- `devServer.url`
-- `devServer.port`
-- `devServer.host`
-- `devServer.path`
-- `devServer.https`
-## GitHub Integration
-The current GitHub integration is deeper than simple repo linking:
-- discover accessible repositories via `gh`
-- link a Conductor project to GitHub Projects v2
-- sync board state with a linked GitHub Project
-- accept signed webhook deliveries at `/api/github/webhook`
-This path assumes normal `gh` authentication and GitHub permissions on the local machine.
-## Access Control And Remote Use
-The safest way to run Conductor is on loopback only. The Rust backend explicitly refuses non-loopback binding unless you opt into:
-```bash
-CONDUCTOR_UNSAFE_ALLOW_REMOTE_BACKEND=true
-```
-The current repo also includes support for:
-- viewer/operator/admin roles in config
-- trusted auth headers
-- Cloudflare Access-style trusted-header validation
-- optional Clerk-backed sign-in wiring in the web app
-- Tailscale-managed private remote access from the dashboard
-Relevant env examples live in:
-- [`.env.example`](.env.example)
-- [`packages/web/.env.example`](packages/web/.env.example)
-## Repository Layout
-```text
-crates/
-  conductor-cli/
-  conductor-core/
-  conductor-db/
-  conductor-executors/
-  conductor-git/
-  conductor-server/
-  conductor-watcher/
-packages/
-  cli/
-  core/
-  plugins/
-  web/
-scripts/
-docs/
-```
+### Rust crates
-## Operational Realities
+- `crates/conductor-cli`
+- `crates/conductor-core`
+- `crates/conductor-db`
+- `crates/conductor-executors`
+- `crates/conductor-git`
+- `crates/conductor-server`
+- `crates/conductor-watcher`
-Important current constraints from the codebase:
+### Local data
-- The runtime is tmux-first, so tmux is effectively required for the core session workflow.
-- Agent behavior depends heavily on the upstream CLI you install and how that CLI handles auth, rate limits, prompts, and output formatting.
-- GitHub repo discovery and GitHub Projects sync depend on `gh` being installed and authenticated.
-- Preview tooling is strongest when the repo has an explicit dev-server mapping in config.
-- Conductor is local-first orchestration software, not a hosted agent platform.
+- `conductor.yaml` for workspace and project config
+- `CONDUCTOR.md` for the board
+- `.conductor/conductor.db` for local state
+- `attachments/<project>/...` for uploaded files
 ## Links
 - GitHub: <https://github.com/charannyk06/conductor-oss>
+- npm: <https://www.npmjs.com/package/conductor-oss>
 - Issues: <https://github.com/charannyk06/conductor-oss/issues>
 - Pull requests: <https://github.com/charannyk06/conductor-oss/pulls>
-- npm package: <https://www.npmjs.com/package/conductor-oss>
 ## Star History

package/bin/conductor CHANGED Viewed

Binary file

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "conductor-oss-native-linux-x64",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "license": "MIT",
   "private": false,
   "os": [