condcli 0.1.0

package/CODEOWNERS

@@ -0,0 +1 @@
+* @baptistelaget

package/README.md

@@ -0,0 +1,165 @@
+# conductorcli
+
+> **Unofficial** community tool — not affiliated with, endorsed by, or supported by [Conductor](https://conductor.build).
+
+A CLI for [Conductor](https://conductor.build) — query workspaces, sessions, and launch deep links from your terminal.
+
+Reads directly from Conductor's local SQLite database and triggers actions via `conductor://` deep links.
+
+## Install
+
+Requires [Bun](https://bun.sh) (uses `bun:sqlite` for zero-dependency SQLite access).
+
+```bash
+# run directly
+bunx @baptistelaget/conductorcli status
+
+# or install globally
+bun install -g @baptistelaget/conductorcli
+```
+
+## Commands
+
+### Query
+
+```bash
+# overview + recent activity
+conductorcli status
+
+# list repositories
+conductorcli repos
+
+# list workspaces (active by default)
+conductorcli ws
+conductorcli ws -f all
+conductorcli ws -f archived
+
+# workspace detail (supports partial IDs)
+conductorcli workspace 7d4e
+
+# list sessions
+conductorcli ss
+conductorcli ss -w 7d4e          # filter by workspace
+
+# session detail + message history
+conductorcli session f969
+conductorcli session f969 -m 10  # show last 10 messages
+
+# search by branch, title, PR, or repo name
+conductorcli search auth
+```
+
+### Create
+
+```bash
+# new workspace with a prompt
+conductorcli prompt "Fix the login bug"
+
+# target a specific repo
+conductorcli prompt -r my-repo "Add dark mode"
+conductorcli prompt -d /path/to/repo "Add dark mode"
+
+# new workspace from a Linear issue
+conductorcli linear ENG-123
+conductorcli linear ENG-123 "Implement with full test coverage"
+conductorcli linear -r my-repo ENG-123
+
+# new workspace from a plan file
+conductorcli plan my-repo plan.md
+echo "Fix all the bugs" | conductorcli plan my-repo -
+```
+
+### Server
+
+Expose everything as a REST API:
+
+```bash
+# start on default port 3141
+conductorcli serve
+
+# custom port
+conductorcli serve -p 8080
+```
+
+**Query endpoints:**
+
+```bash
+curl localhost:3141/status
+curl localhost:3141/repos
+curl localhost:3141/workspaces?filter=all&limit=10
+curl localhost:3141/workspaces/7d4e
+curl localhost:3141/sessions?workspace=7d4e&limit=5
+curl localhost:3141/sessions/f969
+curl localhost:3141/sessions/f969/messages?limit=10
+curl localhost:3141/search?q=auth
+```
+
+**Action endpoints:**
+
+```bash
+# new workspace with prompt
+curl -X POST localhost:3141/prompt \
+  -H 'Content-Type: application/json' \
+  -d '{"message": "Fix the login bug", "repo": "my-repo"}'
+
+# new workspace from Linear issue
+curl -X POST localhost:3141/linear \
+  -H 'Content-Type: application/json' \
+  -d '{"issueId": "ENG-123", "prompt": "Implement with tests", "repo": "my-repo"}'
+
+# new workspace from plan
+curl -X POST localhost:3141/plan \
+  -H 'Content-Type: application/json' \
+  -d '{"repo": "my-repo", "plan": "## Plan\n\n- Fix all the bugs"}'
+```
+
+## How it works
+
+**Read operations** query Conductor's SQLite database at:
+```
+~/Library/Application Support/com.conductor.app/conductor.db
+```
+
+**Create operations** trigger `conductor://` deep links via `open`, which Conductor.app handles natively:
+
+| Deep link | Action |
+|---|---|
+| `conductor://prompt=...&path=...` | New workspace with prompt |
+| `conductor://linear_id=...` | New workspace from Linear issue |
+| `conductor://async?repo=...&plan=...` | New workspace from base64 plan |
+
+## Requirements
+
+- macOS (Conductor.app is macOS-only)
+- [Bun](https://bun.sh) >= 1.0
+- [Conductor.app](https://conductor.build) installed and signed in
+
+## Roadmap
+
+These features aren't currently possible because Conductor doesn't expose public APIs or deep links for them. If Conductor adds official support (or if someone finds a clean way to do it), we'd love to add them:
+
+- [ ] **Send follow-up messages** — send a prompt to an existing workspace/session without creating a new one
+- [ ] **Create PR** — trigger the "Create PR" workflow on a workspace from the CLI
+- [ ] **Approve/reject plans** — respond to pending plan reviews programmatically
+- [ ] **Workspace management** — archive, pin, rename branches, or change session config from outside the app
+
+Today, Conductor's sidecar communicates over an internal Unix socket using an undocumented JSON-RPC protocol. Until there's a stable way to interact with running sessions, these will remain on the wishlist.
+
+## Contributing
+
+Feel free to open issues and PRs — contributions are welcome.
+
+If you found a new deep link, found a way to talk to the sidecar, or just want to improve the CLI, go for it.
+
+## Disclaimer
+
+This is an **unofficial, community-built tool**. It is not created, maintained, endorsed, or supported by the Conductor team or any of its affiliates.
+
+- **No warranty.** This software is provided "as is", without warranty of any kind, express or implied. Use at your own risk.
+- **May break at any time.** This tool relies on Conductor's internal SQLite schema and undocumented `conductor://` deep link protocol, both of which may change without notice in any Conductor update.
+- **Read-only database access.** The CLI opens the database in read-only mode and never writes to it. Create operations work exclusively through deep links handled by Conductor.app itself.
+- **"Conductor" _might be_ a trademark** of its respective owner. This project uses the name solely to describe compatibility.
+
+## License
+
+MIT

package/bin/conductorcli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+import "../src/cli.ts";

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "condcli",
+  "version": "0.1.0",
+  "description": "CLI for Conductor.app — query workspaces, sessions, and launch deep links",
+  "type": "module",
+  "bin": {
+    "conductorcli": "./bin/conductorcli.js"
+  },
+  "scripts": {
+    "dev": "bun run src/cli.ts",
+    "typecheck": "tsc --noEmit",
+    "prepare": "husky"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^20.5.0",
+    "@commitlint/config-conventional": "^20.5.0",
+    "@types/bun": "^1.0.0",
+    "husky": "^9.1.7",
+    "typescript": "^5.7.0"
+  },
+  "dependencies": {
+    "commander": "^13.0.0",
+    "chalk": "^5.4.0"
+  },
+  "keywords": [
+    "conductor",
+    "cli",
+    "conductor.build",
+    "workspace",
+    "linear",
+    "deeplink"
+  ],
+  "author": "baptistelaget",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/baptistelaget/conductorcli"
+  },
+  "license": "MIT",
+  "os": [
+    "darwin"
+  ],
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "files": [
+    "bin/conductorcli.js",
+    "src/**/*.ts",
+    "package.json",
+    "README.md",
+    "CODEOWNERS"
+  ]
+}

package/src/cli.ts

@@ -0,0 +1,248 @@
+#!/usr/bin/env bun
+
+import { Command } from "commander";
+import chalk from "chalk";
+import { readFileSync } from "fs";
+import {
+  listRepos,
+  listWorkspaces,
+  getWorkspace,
+  listSessions,
+  getSession,
+  listMessages,
+  searchWorkspaces,
+  getStats,
+} from "./db.js";
+import {
+  formatRepos,
+  formatWorkspaces,
+  formatWorkspaceDetail,
+  formatSessions,
+  formatSessionDetail,
+  formatMessages,
+  formatStats,
+} from "./format.js";
+import { openPrompt, openLinear, openPlan } from "./deeplink.js";
+import { startServer } from "./server.js";
+
+const program = new Command();
+
+function resolveRepoPath(name: string): string {
+  const repos = listRepos();
+  const match = repos.find(
+    (r) => r.name.toLowerCase() === name.toLowerCase()
+  );
+  if (!match) {
+    console.error(chalk.red(`\nRepo not found: ${name}\n`));
+    console.log(chalk.dim("Available repos:"));
+    for (const r of repos)
+      console.log(`  ${chalk.cyan(r.name)}  ${chalk.dim(r.root_path ?? "")}`);
+    console.log();
+    process.exit(1);
+  }
+  if (!match.root_path) {
+    console.error(chalk.red(`\nRepo "${name}" has no local path.\n`));
+    process.exit(1);
+  }
+  return match.root_path;
+}
+
+program
+  .name("conductorcli")
+  .description("CLI for Conductor.app")
+  .version("0.1.0");
+
+// ── status ─────────────────────────────────────────────
+
+program
+  .command("status")
+  .description("Overview and recent activity")
+  .action(() => {
+    const stats = getStats();
+    console.log(chalk.bold("\nConductor Status\n"));
+    console.log(formatStats(stats));
+
+    const active = listWorkspaces("active").slice(0, 5);
+    if (active.length) {
+      console.log(chalk.bold("\n\nRecent Active Workspaces\n"));
+      console.log(formatWorkspaces(active, "active"));
+    }
+    console.log();
+  });
+
+// ── repos ──────────────────────────────────────────────
+
+program
+  .command("repos")
+  .description("List repositories")
+  .action(() => {
+    const repos = listRepos();
+    console.log(chalk.bold("\nRepositories\n"));
+    console.log(formatRepos(repos));
+    console.log();
+  });
+
+// ── workspaces ─────────────────────────────────────────
+
+program
+  .command("workspaces")
+  .alias("ws")
+  .description("List workspaces")
+  .option("-f, --filter <filter>", "active | archived | pinned | all", "active")
+  .option("-n, --limit <n>", "max results", "30")
+  .action((opts) => {
+    const filter = opts.filter as "active" | "archived" | "pinned" | "all";
+    const workspaces = listWorkspaces(filter).slice(0, parseInt(opts.limit));
+    console.log(chalk.bold(`\nWorkspaces`) + chalk.dim(` (${filter})\n`));
+    console.log(formatWorkspaces(workspaces, filter));
+    console.log();
+  });
+
+// ── workspace detail ───────────────────────────────────
+
+program
+  .command("workspace <id>")
+  .description("Show workspace details (supports partial ID)")
+  .action((id) => {
+    const ws = getWorkspace(id);
+    if (!ws) {
+      console.error(chalk.red(`No workspace found matching: ${id}`));
+      process.exit(1);
+    }
+    console.log();
+    console.log(formatWorkspaceDetail(ws));
+    console.log();
+  });
+
+// ── sessions ───────────────────────────────────────────
+
+program
+  .command("sessions")
+  .alias("ss")
+  .description("List sessions")
+  .option("-w, --workspace <id>", "filter by workspace ID prefix")
+  .option("-n, --limit <n>", "max results", "20")
+  .action((opts) => {
+    const sessions = listSessions(opts.workspace).slice(
+      0,
+      parseInt(opts.limit)
+    );
+    const label = opts.workspace ? `workspace ${opts.workspace}` : "all";
+    console.log(chalk.bold(`\nSessions`) + chalk.dim(` (${label})\n`));
+    console.log(formatSessions(sessions));
+    console.log();
+  });
+
+// ── session detail ─────────────────────────────────────
+
+program
+  .command("session <id>")
+  .description("Show session details (supports partial ID)")
+  .option("-m, --messages [n]", "show last N messages", "0")
+  .action((id, opts) => {
+    const session = getSession(id);
+    if (!session) {
+      console.error(chalk.red(`No session found matching: ${id}`));
+      process.exit(1);
+    }
+    console.log();
+    console.log(formatSessionDetail(session));
+
+    const msgCount = parseInt(opts.messages);
+    if (msgCount > 0) {
+      const messages = listMessages(id, msgCount);
+      console.log(chalk.bold("\n\nMessages\n"));
+      console.log(formatMessages(messages));
+    }
+    console.log();
+  });
+
+// ── search ─────────────────────────────────────────────
+
+program
+  .command("search <query>")
+  .description("Search workspaces by branch, title, PR, or repo")
+  .action((query) => {
+    const results = searchWorkspaces(query);
+    console.log(
+      chalk.bold(`\nSearch: `) + chalk.cyan(query) + chalk.dim(` (${results.length} results)\n`)
+    );
+    console.log(formatWorkspaces(results, "search"));
+    console.log();
+  });
+
+// ── prompt ─────────────────────────────────────────────
+
+program
+  .command("prompt <message...>")
+  .alias("p")
+  .description("Create a new workspace with a prompt")
+  .option("-d, --dir <path>", "target repo directory path")
+  .option("-r, --repo <name>", "target repo by name (resolved to path)")
+  .action(async (messageParts, opts) => {
+    const message = messageParts.join(" ");
+    let dir: string | undefined = opts.dir;
+    if (opts.repo && !dir) {
+      dir = resolveRepoPath(opts.repo);
+    }
+    console.log(
+      chalk.bold("\nCreating workspace") +
+        (dir ? chalk.dim(` in ${dir}`) : "") +
+        "\n"
+    );
+    console.log(`  ${chalk.dim("Prompt:")} ${message}`);
+    await openPrompt(message, dir);
+    console.log(chalk.green("\n  ✓ Deep link sent to Conductor.app\n"));
+  });
+
+// ── linear ─────────────────────────────────────────────
+
+program
+  .command("linear <issueId> [prompt...]")
+  .alias("lin")
+  .description("Create a workspace from a Linear issue")
+  .option("-r, --repo <name>", "target repo by name")
+  .action(async (issueId, promptParts, opts) => {
+    const prompt = promptParts?.length ? promptParts.join(" ") : undefined;
+    const repoPath = opts.repo ? resolveRepoPath(opts.repo) : undefined;
+
+    console.log(chalk.bold("\nCreating workspace from Linear issue\n"));
+    console.log(`  ${chalk.dim("Issue:")}  ${chalk.cyan(issueId)}`);
+    if (repoPath) console.log(`  ${chalk.dim("Repo:")}   ${repoPath}`);
+    if (prompt) console.log(`  ${chalk.dim("Prompt:")} ${prompt}`);
+    await openLinear(issueId, prompt, repoPath);
+    console.log(chalk.green("\n  ✓ Deep link sent to Conductor.app\n"));
+  });
+
+// ── plan ───────────────────────────────────────────────
+
+program
+  .command("plan <repo> <file>")
+  .description("Create a workspace from a plan file (use - for stdin)")
+  .action(async (repo, file) => {
+    let content: string;
+    if (file === "-") {
+      const chunks: Buffer[] = [];
+      for await (const chunk of process.stdin) chunks.push(chunk);
+      content = Buffer.concat(chunks).toString("utf-8");
+    } else {
+      content = readFileSync(file, "utf-8");
+    }
+    console.log(chalk.bold("\nCreating workspace from plan\n"));
+    console.log(`  ${chalk.dim("Repo:")} ${chalk.cyan(repo)}`);
+    console.log(`  ${chalk.dim("File:")} ${file}`);
+    await openPlan(repo, content);
+    console.log(chalk.green("\n  ✓ Deep link sent to Conductor.app\n"));
+  });
+
+// ── serve ──────────────────────────────────────────────
+
+program
+  .command("serve")
+  .description("Start a REST API server")
+  .option("-p, --port <port>", "port number", "3141")
+  .action((opts) => {
+    startServer(parseInt(opts.port));
+  });
+
+program.parse();

package/src/db.ts

@@ -0,0 +1,259 @@
+import { Database } from "bun:sqlite";
+import { homedir } from "os";
+import { join } from "path";
+
+const DB_PATH = join(
+  homedir(),
+  "Library",
+  "Application Support",
+  "com.conductor.app",
+  "conductor.db"
+);
+
+let _db: Database | null = null;
+
+export function getDb(): Database {
+  if (!_db) {
+    _db = new Database(DB_PATH, { readonly: true });
+    _db.exec("PRAGMA journal_mode = WAL");
+  }
+  return _db;
+}
+
+// ── Types ──────────────────────────────────────────────
+
+export interface Repo {
+  id: string;
+  name: string;
+  remote_url: string | null;
+  root_path: string | null;
+  default_branch: string;
+  display_order: number;
+  hidden: number;
+  icon: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface Workspace {
+  id: string;
+  repository_id: string;
+  directory_name: string | null;
+  branch: string | null;
+  state: string;
+  derived_status: string;
+  manual_status: string | null;
+  active_session_id: string | null;
+  pinned_at: string | null;
+  pr_title: string | null;
+  pr_description: string | null;
+  notes: string | null;
+  intended_target_branch: string | null;
+  created_at: string;
+  updated_at: string;
+  // joined
+  repo_name?: string;
+  repo_path?: string;
+  session_title?: string;
+  session_status?: string;
+}
+
+export interface Session {
+  id: string;
+  workspace_id: string | null;
+  status: string;
+  title: string;
+  agent_type: string | null;
+  model: string | null;
+  permission_mode: string;
+  thinking_enabled: number;
+  fast_mode: number;
+  context_used_percent: number | null;
+  context_token_count: number;
+  unread_count: number;
+  last_user_message_at: string | null;
+  created_at: string;
+  updated_at: string;
+  // joined
+  branch?: string;
+  repo_name?: string;
+}
+
+export interface SessionMessage {
+  id: string;
+  session_id: string;
+  role: string;
+  content: string | null;
+  sent_at: string | null;
+  cancelled_at: string | null;
+  model: string | null;
+  turn_id: string | null;
+  created_at: string;
+}
+
+// ── Queries ────────────────────────────────────────────
+
+export function listRepos(): Repo[] {
+  return getDb()
+    .prepare(
+      `SELECT * FROM repos WHERE hidden = 0 ORDER BY display_order, name`
+    )
+    .all() as Repo[];
+}
+
+export function listWorkspaces(
+  filter: "active" | "archived" | "pinned" | "all" = "active"
+): Workspace[] {
+  const where: Record<string, string> = {
+    active: "WHERE w.state = 'active'",
+    archived: "WHERE w.state = 'archived'",
+    pinned: "WHERE w.pinned_at IS NOT NULL",
+    all: "",
+  };
+
+  return getDb()
+    .prepare(
+      `
+      SELECT
+        w.*,
+        r.name AS repo_name,
+        r.root_path AS repo_path,
+        s.title AS session_title,
+        s.status AS session_status
+      FROM workspaces w
+      LEFT JOIN repos r ON r.id = w.repository_id
+      LEFT JOIN sessions s ON s.id = w.active_session_id
+      ${where[filter]}
+      ORDER BY w.updated_at DESC
+    `
+    )
+    .all() as Workspace[];
+}
+
+export function getWorkspace(idPrefix: string): Workspace | undefined {
+  return getDb()
+    .prepare(
+      `
+      SELECT
+        w.*,
+        r.name AS repo_name,
+        r.root_path AS repo_path,
+        s.title AS session_title,
+        s.status AS session_status
+      FROM workspaces w
+      LEFT JOIN repos r ON r.id = w.repository_id
+      LEFT JOIN sessions s ON s.id = w.active_session_id
+      WHERE w.id LIKE ? || '%'
+      LIMIT 1
+    `
+    )
+    .get(idPrefix) as Workspace | undefined;
+}
+
+export function listSessions(workspaceId?: string): Session[] {
+  if (workspaceId) {
+    return getDb()
+      .prepare(
+        `
+        SELECT
+          s.*,
+          w.branch,
+          r.name AS repo_name
+        FROM sessions s
+        LEFT JOIN workspaces w ON w.id = s.workspace_id
+        LEFT JOIN repos r ON r.id = w.repository_id
+        WHERE s.workspace_id LIKE ? || '%'
+        ORDER BY s.updated_at DESC
+      `
+      )
+      .all(workspaceId) as Session[];
+  }
+
+  return getDb()
+    .prepare(
+      `
+      SELECT
+        s.*,
+        w.branch,
+        r.name AS repo_name
+      FROM sessions s
+      LEFT JOIN workspaces w ON w.id = s.workspace_id
+      LEFT JOIN repos r ON r.id = w.repository_id
+      ORDER BY s.updated_at DESC
+    `
+    )
+    .all() as Session[];
+}
+
+export function getSession(idPrefix: string): Session | undefined {
+  return getDb()
+    .prepare(
+      `
+      SELECT
+        s.*,
+        w.branch,
+        r.name AS repo_name
+      FROM sessions s
+      LEFT JOIN workspaces w ON w.id = s.workspace_id
+      LEFT JOIN repos r ON r.id = w.repository_id
+      WHERE s.id LIKE ? || '%'
+      LIMIT 1
+    `
+    )
+    .get(idPrefix) as Session | undefined;
+}
+
+export function listMessages(
+  sessionId: string,
+  limit = 20
+): SessionMessage[] {
+  return getDb()
+    .prepare(
+      `
+      SELECT id, session_id, role, content, sent_at, cancelled_at, model, turn_id, created_at
+      FROM session_messages
+      WHERE session_id LIKE ? || '%'
+        AND cancelled_at IS NULL
+      ORDER BY created_at DESC
+      LIMIT ?
+    `
+    )
+    .all(sessionId, limit) as SessionMessage[];
+}
+
+export function searchWorkspaces(query: string): Workspace[] {
+  const pattern = `%${query}%`;
+  return getDb()
+    .prepare(
+      `
+      SELECT
+        w.*,
+        r.name AS repo_name,
+        r.root_path AS repo_path,
+        s.title AS session_title,
+        s.status AS session_status
+      FROM workspaces w
+      LEFT JOIN repos r ON r.id = w.repository_id
+      LEFT JOIN sessions s ON s.id = w.active_session_id
+      WHERE w.branch LIKE ?
+         OR s.title LIKE ?
+         OR w.pr_title LIKE ?
+         OR r.name LIKE ?
+         OR w.notes LIKE ?
+      ORDER BY w.updated_at DESC
+      LIMIT 30
+    `
+    )
+    .all(pattern, pattern, pattern, pattern, pattern) as Workspace[];
+}
+
+export function getStats() {
+  const db = getDb();
+  return {
+    repos: (db.prepare("SELECT COUNT(*) as c FROM repos WHERE hidden = 0").get() as any).c,
+    activeWorkspaces: (db.prepare("SELECT COUNT(*) as c FROM workspaces WHERE state = 'active'").get() as any).c,
+    archivedWorkspaces: (db.prepare("SELECT COUNT(*) as c FROM workspaces WHERE state = 'archived'").get() as any).c,
+    sessions: (db.prepare("SELECT COUNT(*) as c FROM sessions").get() as any).c,
+    messages: (db.prepare("SELECT COUNT(*) as c FROM session_messages").get() as any).c,
+  };
+}

package/src/deeplink.ts

@@ -0,0 +1,31 @@
+import { exec } from "child_process";
+
+function openUrl(url: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    exec(`open ${JSON.stringify(url)}`, (err) => {
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+}
+
+export async function openPrompt(prompt: string, path?: string) {
+  const parts: string[] = [];
+  if (path) parts.push(`path=${encodeURIComponent(path)}`);
+  parts.push(`prompt=${encodeURIComponent(prompt)}`);
+  await openUrl(`conductor://${parts.join("&")}`);
+}
+
+export async function openLinear(issueId: string, prompt?: string, path?: string) {
+  const parts = [`linear_id=${encodeURIComponent(issueId)}`];
+  if (path) parts.push(`path=${encodeURIComponent(path)}`);
+  if (prompt) parts.push(`prompt=${encodeURIComponent(prompt)}`);
+  await openUrl(`conductor://${parts.join("&")}`);
+}
+
+export async function openPlan(repo: string, planContent: string) {
+  const encoded = Buffer.from(planContent).toString("base64");
+  await openUrl(
+    `conductor://async?repo=${encodeURIComponent(repo)}&plan=${encoded}`
+  );
+}

package/src/format.ts

@@ -0,0 +1,248 @@
+import chalk from "chalk";
+import type { Repo, Workspace, Session, SessionMessage } from "./db.js";
+
+export function truncate(str: string, max: number): string {
+  if (str.length <= max) return str;
+  return str.slice(0, max - 1) + "…";
+}
+
+function relativeTime(iso: string): string {
+  const d = new Date(iso.endsWith("Z") ? iso : iso + "Z");
+  const now = Date.now();
+  const diff = now - d.getTime();
+  const mins = Math.floor(diff / 60_000);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  if (days < 30) return `${days}d ago`;
+  return d.toLocaleDateString();
+}
+
+function stateColor(state: string): (s: string) => string {
+  switch (state) {
+    case "active": return chalk.green;
+    case "ready": return chalk.green;
+    case "archived": return chalk.dim;
+    case "initializing": return chalk.yellow;
+    default: return (s: string) => s;
+  }
+}
+
+function statusColor(status: string): (s: string) => string {
+  switch (status) {
+    case "idle": return chalk.dim;
+    case "working": return chalk.green;
+    case "running": return chalk.green;
+    case "error": return chalk.red;
+    case "in-progress": return chalk.yellow;
+    case "ready": return chalk.green;
+    default: return (s: string) => s;
+  }
+}
+
+// ── Table helpers ──────────────────────────────────────
+
+function pad(s: string, n: number): string {
+  return s.length >= n ? s.slice(0, n) : s + " ".repeat(n - s.length);
+}
+
+function row(cols: [string, number][]): string {
+  return cols.map(([s, n]) => pad(s, n)).join("  ");
+}
+
+// ── Formatters ─────────────────────────────────────────
+
+export function formatRepos(repos: Repo[]): string {
+  if (!repos.length) return chalk.dim("  No repositories found.");
+  const lines = [
+    chalk.dim(row([
+      ["NAME", 20], ["PATH", 45], ["BRANCH", 10], ["ID", 36],
+    ])),
+  ];
+  for (const r of repos) {
+    lines.push(row([
+      [chalk.cyan(r.name), 20],
+      [chalk.dim(r.root_path ?? "—"), 45],
+      [r.default_branch, 10],
+      [chalk.dim(r.id), 36],
+    ]));
+  }
+  return lines.join("\n");
+}
+
+export function formatWorkspaces(workspaces: Workspace[], filter: string): string {
+  if (!workspaces.length) return chalk.dim("  No workspaces found.");
+  const lines = [
+    chalk.dim(row([
+      ["ID", 8], ["REPO", 14], ["BRANCH", 28], ["STATE", 10],
+      ["STATUS", 12], ["SESSION", 28], ["UPDATED", 10],
+    ])),
+  ];
+  for (const w of workspaces) {
+    const sc = stateColor(w.state);
+    const stc = statusColor(w.derived_status);
+    lines.push(row([
+      [chalk.dim(w.id.slice(0, 8)), 8],
+      [chalk.cyan(truncate(w.repo_name ?? "—", 14)), 14],
+      [truncate(w.branch ?? "—", 28), 28],
+      [sc(w.state), 10],
+      [stc(w.derived_status ?? "—"), 12],
+      [truncate(w.session_title ?? "—", 28), 28],
+      [chalk.dim(relativeTime(w.updated_at)), 10],
+    ]));
+  }
+  return lines.join("\n");
+}
+
+export function formatWorkspaceDetail(w: Workspace): string {
+  const lines: string[] = [];
+  lines.push(chalk.bold(`Workspace ${w.id}`));
+  lines.push("");
+  lines.push(`  ${chalk.dim("Repo:")}          ${chalk.cyan(w.repo_name ?? "—")}`);
+  lines.push(`  ${chalk.dim("Path:")}          ${w.repo_path ?? "—"}`);
+  lines.push(`  ${chalk.dim("Branch:")}        ${w.branch ?? "—"}`);
+  lines.push(`  ${chalk.dim("Target:")}        ${w.intended_target_branch ?? "—"}`);
+  lines.push(`  ${chalk.dim("State:")}         ${stateColor(w.state)(w.state)}`);
+  lines.push(`  ${chalk.dim("Status:")}        ${statusColor(w.derived_status)(w.derived_status)}`);
+  lines.push(`  ${chalk.dim("Session:")}       ${w.session_title ?? "—"} ${w.session_status ? chalk.dim(`(${w.session_status})`) : ""}`);
+  if (w.pr_title) lines.push(`  ${chalk.dim("PR:")}            ${w.pr_title}`);
+  if (w.notes) lines.push(`  ${chalk.dim("Notes:")}         ${truncate(w.notes, 60)}`);
+  if (w.pinned_at) lines.push(`  ${chalk.dim("Pinned:")}        ${relativeTime(w.pinned_at)}`);
+  lines.push(`  ${chalk.dim("Created:")}       ${relativeTime(w.created_at)}`);
+  lines.push(`  ${chalk.dim("Updated:")}       ${relativeTime(w.updated_at)}`);
+  return lines.join("\n");
+}
+
+export function formatSessions(sessions: Session[]): string {
+  if (!sessions.length) return chalk.dim("  No sessions found.");
+  const lines = [
+    chalk.dim(row([
+      ["ID", 8], ["TITLE", 30], ["STATUS", 9], ["AGENT", 7],
+      ["MODEL", 10], ["MODE", 8], ["BRANCH", 24], ["UPDATED", 10],
+    ])),
+  ];
+  for (const s of sessions) {
+    const sc = statusColor(s.status);
+    lines.push(row([
+      [chalk.dim(s.id.slice(0, 8)), 8],
+      [truncate(s.title ?? "Untitled", 30), 30],
+      [sc(s.status), 9],
+      [s.agent_type ?? "—", 7],
+      [chalk.magenta(s.model ?? "—"), 10],
+      [s.permission_mode ?? "—", 8],
+      [chalk.dim(truncate(s.branch ?? "—", 24)), 24],
+      [chalk.dim(relativeTime(s.updated_at)), 10],
+    ]));
+  }
+  return lines.join("\n");
+}
+
+export function formatSessionDetail(s: Session): string {
+  const lines: string[] = [];
+  lines.push(chalk.bold(`Session ${s.id}`));
+  lines.push("");
+  lines.push(`  ${chalk.dim("Title:")}         ${s.title}`);
+  lines.push(`  ${chalk.dim("Status:")}        ${statusColor(s.status)(s.status)}`);
+  lines.push(`  ${chalk.dim("Agent:")}         ${s.agent_type ?? "—"}`);
+  lines.push(`  ${chalk.dim("Model:")}         ${chalk.magenta(s.model ?? "—")}`);
+  lines.push(`  ${chalk.dim("Mode:")}          ${s.permission_mode}`);
+  lines.push(`  ${chalk.dim("Thinking:")}      ${s.thinking_enabled ? "on" : "off"}${s.fast_mode ? " (fast)" : ""}`);
+  lines.push(`  ${chalk.dim("Repo:")}          ${chalk.cyan(s.repo_name ?? "—")}`);
+  lines.push(`  ${chalk.dim("Branch:")}        ${s.branch ?? "—"}`);
+  if (s.context_used_percent != null) {
+    lines.push(`  ${chalk.dim("Context:")}       ${Math.round(s.context_used_percent)}% (${s.context_token_count.toLocaleString()} tokens)`);
+  }
+  lines.push(`  ${chalk.dim("Unread:")}        ${s.unread_count}`);
+  lines.push(`  ${chalk.dim("Last message:")}  ${s.last_user_message_at ? relativeTime(s.last_user_message_at) : "—"}`);
+  lines.push(`  ${chalk.dim("Created:")}       ${relativeTime(s.created_at)}`);
+  lines.push(`  ${chalk.dim("Updated:")}       ${relativeTime(s.updated_at)}`);
+  return lines.join("\n");
+}
+
+function extractMessageText(raw: string | null): string | null {
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    // Claude session protocol: {"type":"user"|"assistant", "message": {...}}
+    if (parsed.type === "user" && parsed.message?.content) {
+      const content = parsed.message.content;
+      if (typeof content === "string") return content;
+      if (Array.isArray(content)) {
+        const text = content
+          .filter((b: any) => b.type === "text")
+          .map((b: any) => b.text)
+          .join("\n");
+        if (text) return text;
+        // tool results
+        const toolResults = content.filter((b: any) => b.type === "tool_result");
+        if (toolResults.length) return `[${toolResults.length} tool result(s)]`;
+      }
+    }
+    if (parsed.type === "assistant" && parsed.message?.content) {
+      const content = parsed.message.content;
+      if (typeof content === "string") return content;
+      if (Array.isArray(content)) {
+        const parts: string[] = [];
+        for (const b of content) {
+          if (b.type === "text") parts.push(b.text);
+          else if (b.type === "tool_use") parts.push(`[tool: ${b.name}]`);
+        }
+        return parts.join(" ") || null;
+      }
+    }
+    if (parsed.type === "result") {
+      const dur = parsed.duration_ms ? `${(parsed.duration_ms / 1000).toFixed(1)}s` : "";
+      return `[${parsed.subtype}${dur ? ` · ${dur}` : ""}]`;
+    }
+    // fallback: try to get something readable
+    if (typeof parsed === "string") return parsed;
+  } catch {
+    // not JSON, use raw
+  }
+  return raw;
+}
+
+export function formatMessages(messages: SessionMessage[]): string {
+  if (!messages.length) return chalk.dim("  No messages.");
+  const reversed = [...messages].reverse();
+  const lines: string[] = [];
+  for (const m of reversed) {
+    const text = extractMessageText(m.content);
+    // Determine effective role from content
+    let role = m.role;
+    try {
+      const parsed = JSON.parse(m.content ?? "");
+      if (parsed.type === "user") role = "user";
+      else if (parsed.type === "assistant") role = "assistant";
+      else if (parsed.type === "result") role = "system";
+    } catch {}
+
+    const roleColor = role === "user" ? chalk.green : role === "system" ? chalk.yellow : chalk.blue;
+    const header = `${roleColor(role)}  ${chalk.dim(relativeTime(m.created_at))}${m.model ? chalk.dim(` · ${m.model}`) : ""}`;
+    lines.push(header);
+    if (text) {
+      const preview = truncate(text.replace(/\n/g, " "), 120);
+      lines.push(`  ${preview}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+export function formatStats(stats: {
+  repos: number;
+  activeWorkspaces: number;
+  archivedWorkspaces: number;
+  sessions: number;
+  messages: number;
+}): string {
+  return [
+    `  ${chalk.dim("Repositories:")}       ${chalk.cyan(stats.repos)}`,
+    `  ${chalk.dim("Active workspaces:")}  ${chalk.green(stats.activeWorkspaces)}`,
+    `  ${chalk.dim("Archived:")}           ${chalk.dim(stats.archivedWorkspaces)}`,
+    `  ${chalk.dim("Sessions:")}           ${stats.sessions}`,
+    `  ${chalk.dim("Messages:")}           ${stats.messages}`,
+  ].join("\n");
+}

package/src/server.ts

@@ -0,0 +1,161 @@
+import {
+  listRepos,
+  listWorkspaces,
+  getWorkspace,
+  listSessions,
+  getSession,
+  listMessages,
+  searchWorkspaces,
+  getStats,
+} from "./db.js";
+import { openPrompt, openLinear, openPlan } from "./deeplink.js";
+
+function json(data: unknown, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+function err(message: string, status = 400) {
+  return json({ error: message }, status);
+}
+
+function resolveRepo(name: string): string | null {
+  const repos = listRepos();
+  const match = repos.find(
+    (r) => r.name.toLowerCase() === name.toLowerCase()
+  );
+  return match?.root_path ?? null;
+}
+
+async function body(req: Request): Promise<Record<string, any>> {
+  try {
+    return await req.json();
+  } catch {
+    return {};
+  }
+}
+
+function route(req: Request): Response | Promise<Response> {
+  const url = new URL(req.url);
+  const path = url.pathname;
+  const method = req.method;
+
+  // ── GET routes (read-only queries) ──────────────────
+
+  if (method === "GET") {
+    if (path === "/status") {
+      return json(getStats());
+    }
+
+    if (path === "/repos") {
+      return json(listRepos());
+    }
+
+    if (path === "/workspaces") {
+      const filter = (url.searchParams.get("filter") ?? "active") as
+        | "active"
+        | "archived"
+        | "pinned"
+        | "all";
+      const limit = parseInt(url.searchParams.get("limit") ?? "30");
+      return json(listWorkspaces(filter).slice(0, limit));
+    }
+
+    if (path.startsWith("/workspaces/")) {
+      const id = path.slice("/workspaces/".length);
+      const ws = getWorkspace(id);
+      return ws ? json(ws) : err("Workspace not found", 404);
+    }
+
+    if (path === "/sessions") {
+      const workspaceId = url.searchParams.get("workspace") ?? undefined;
+      const limit = parseInt(url.searchParams.get("limit") ?? "20");
+      return json(listSessions(workspaceId).slice(0, limit));
+    }
+
+    if (path.startsWith("/sessions/") && path.endsWith("/messages")) {
+      const id = path.slice("/sessions/".length, -"/messages".length);
+      const limit = parseInt(url.searchParams.get("limit") ?? "20");
+      return json(listMessages(id, limit));
+    }
+
+    if (path.startsWith("/sessions/")) {
+      const id = path.slice("/sessions/".length);
+      const s = getSession(id);
+      return s ? json(s) : err("Session not found", 404);
+    }
+
+    if (path === "/search") {
+      const q = url.searchParams.get("q");
+      if (!q) return err("Missing ?q= parameter");
+      return json(searchWorkspaces(q));
+    }
+  }
+
+  // ── POST routes (trigger deep links) ────────────────
+
+  if (method === "POST") {
+    if (path === "/prompt") {
+      return (async () => {
+        const b = await body(req);
+        const message = b.message ?? b.prompt;
+        if (!message) return err("Missing 'message' field");
+        const dir = b.repo ? resolveRepo(b.repo) : b.dir;
+        await openPrompt(message, dir ?? undefined);
+        return json({ ok: true, action: "prompt", message, dir });
+      })();
+    }
+
+    if (path === "/linear") {
+      return (async () => {
+        const b = await body(req);
+        const issueId = b.issueId ?? b.issue_id ?? b.id;
+        if (!issueId) return err("Missing 'issueId' field");
+        const prompt = b.prompt ?? b.message;
+        const repoPath = b.repo ? resolveRepo(b.repo) : undefined;
+        await openLinear(issueId, prompt, repoPath ?? undefined);
+        return json({ ok: true, action: "linear", issueId, prompt, repo: repoPath });
+      })();
+    }
+
+    if (path === "/plan") {
+      return (async () => {
+        const b = await body(req);
+        if (!b.repo) return err("Missing 'repo' field");
+        if (!b.plan && !b.content) return err("Missing 'plan' or 'content' field");
+        const content = b.plan ?? b.content;
+        await openPlan(b.repo, content);
+        return json({ ok: true, action: "plan", repo: b.repo });
+      })();
+    }
+  }
+
+  return err("Not found", 404);
+}
+
+export function startServer(port: number) {
+  const server = Bun.serve({
+    port,
+    fetch: route,
+  });
+
+  console.log(`conductorcli server listening on http://localhost:${server.port}`);
+  console.log();
+  console.log("  GET   /status");
+  console.log("  GET   /repos");
+  console.log("  GET   /workspaces?filter=active&limit=30");
+  console.log("  GET   /workspaces/:id");
+  console.log("  GET   /sessions?workspace=:id&limit=20");
+  console.log("  GET   /sessions/:id");
+  console.log("  GET   /sessions/:id/messages?limit=20");
+  console.log("  GET   /search?q=query");
+  console.log();
+  console.log("  POST  /prompt     { message, repo?, dir? }");
+  console.log("  POST  /linear     { issueId, prompt?, repo? }");
+  console.log("  POST  /plan       { repo, plan }");
+  console.log();
+
+  return server;
+}