@doriandev/devcc 0.1.2 → 0.2.0

package/src/devcc/app/controlPlaneCommands.ts

@@ -0,0 +1,197 @@
+import type { AgentAdapter } from "../agents/agents.js"
+import type { CommandContext, CommandDefinition } from "../core/commands.js"
+import type { RemoteMachineConfig } from "../core/config.js"
+import { isActive } from "../processes/ManagedProcess.js"
+import { errorMessage } from "../utils/errors.js"
+
+export interface ControlPlaneCommandOptions {
+  agents: readonly AgentAdapter[]
+  machines: readonly RemoteMachineConfig[]
+}
+
+/** The directory commands act on: the selected worktree, else the project root. */
+function targetPath(context: CommandContext): string {
+  return context.selectedWorktree()?.path ?? context.store.getState().project.rootDir
+}
+
+/**
+ * Palette commands for worktrees, agents, verification, environment and remote
+ * machines. They resolve their target at run time (`selectedWorktree`), so
+ * "Launch Claude" from the Worktrees view acts on the highlighted worktree.
+ */
+export function createControlPlaneCommands(options: ControlPlaneCommandOptions): CommandDefinition[] {
+  const inRepository = (context: CommandContext) => context.store.getState().git.isRepository
+
+  const commands: CommandDefinition[] = [
+    // --- Worktrees ---------------------------------------------------------
+    {
+      id: "worktree.create",
+      title: "Worktree: create…",
+      category: "Worktree",
+      shortcut: "n",
+      keywords: ["new", "branch", "add", "git"],
+      when: inRepository,
+      execute: (context) => context.createWorktree(),
+    },
+    {
+      id: "worktree.remove",
+      title: "Worktree: remove the selected worktree",
+      category: "Worktree",
+      shortcut: "d",
+      keywords: ["delete", "git"],
+      when: (context) => {
+        const worktree = context.selectedWorktree()
+        return worktree !== undefined && !worktree.isMain && !worktree.isCurrent
+      },
+      execute: async (context) => {
+        const worktree = context.selectedWorktree()
+        if (worktree) await context.removeWorktree(worktree)
+      },
+    },
+    {
+      id: "worktree.openProject",
+      title: "Worktree: open in devcc",
+      category: "Worktree",
+      shortcut: "o",
+      keywords: ["switch", "project", "workspace"],
+      when: (context) => {
+        const worktree = context.selectedWorktree()
+        return worktree !== undefined && !worktree.isCurrent && !worktree.bare
+      },
+      execute: async (context) => {
+        const worktree = context.selectedWorktree()
+        if (worktree) await context.switchProject(worktree.path)
+      },
+    },
+    {
+      id: "worktree.openTerminal",
+      title: "Worktree: open terminal",
+      category: "Worktree",
+      shortcut: "t",
+      keywords: ["shell", "console"],
+      execute: (context) => context.openInTerminal(targetPath(context)),
+    },
+    {
+      id: "worktree.openEditor",
+      title: "Worktree: open in editor",
+      category: "Worktree",
+      shortcut: "e",
+      keywords: ["ide", "code", "zed", "cursor", "webstorm"],
+      execute: (context) => context.openInEditor(targetPath(context)),
+    },
+    {
+      id: "worktree.list",
+      title: "Worktree: show worktrees and agents",
+      category: "Worktree",
+      keywords: ["list", "agents"],
+      when: inRepository,
+      execute: async (context) => {
+        context.navigate("worktrees")
+        await context.git.refresh()
+      },
+    },
+
+    // --- AI agents ---------------------------------------------------------
+    ...options.agents.map((agent): CommandDefinition => ({
+      id: `agent.launch.${agent.id}`,
+      title: `AI: launch ${agent.name}`,
+      category: "AI",
+      shortcut: agent.id === "claude" ? "c" : agent.id === "codex" ? "x" : undefined,
+      keywords: ["agent", "ai", agent.id, agent.command],
+      execute: (context) => context.launchAgent(agent.id),
+    })),
+    {
+      id: "agent.stopAll",
+      title: "AI: stop all running agents",
+      category: "AI",
+      keywords: ["agent", "kill", "cancel"],
+      when: (context) => context.store.getState().agents.some((session) => isActive(session.status)),
+      confirm: { title: "Stop every running agent?", message: "Their work so far stays in the worktrees." },
+      execute: async (context) => {
+        const running = context.store.getState().agents.filter((session) => isActive(session.status))
+        await Promise.all(running.map((session) => context.agents.stop(session.id)))
+        context.notify("info", `Stopped ${running.length} agent(s)`)
+      },
+    },
+
+    // --- Verification ------------------------------------------------------
+    {
+      id: "verify.run",
+      title: "Project: verify (run every verification step)",
+      category: "Project",
+      shortcut: "V",
+      keywords: ["check", "ci", "test", "lint", "gate", "ship"],
+      execute: (context) => context.runVerify(),
+    },
+
+    // --- Environment -------------------------------------------------------
+    {
+      id: "environment.refresh",
+      title: "Environment: refresh tools, runtimes and direnv",
+      category: "Environment",
+      keywords: ["mise", "direnv", "versions", "doctor", "health"],
+      execute: async (context) => {
+        context.navigate("system")
+        const snapshot = await context.environment.refresh()
+        const problems = snapshot.tools.filter((tool) => tool.status === "error" || tool.status === "warning")
+        context.notify(
+          problems.length > 0 ? "warn" : "success",
+          problems.length > 0
+            ? `Environment: ${problems.map((tool) => tool.name).join(", ")} need attention`
+            : "Environment checked",
+        )
+      },
+    },
+    {
+      id: "environment.direnvAllow",
+      title: "Environment: direnv allow this project's .envrc",
+      category: "Environment",
+      keywords: ["direnv", "envrc", "approve", "trust"],
+      when: (context) => {
+        const { direnv } = context.store.getState().environment
+        return direnv.installed && direnv.rcPath !== undefined && direnv.approval !== "allowed"
+      },
+      execute: async (context) => {
+        const { rcPath } = context.store.getState().environment.direnv
+        const confirmed = await context.confirm(
+          "Allow this .envrc?",
+          `direnv will run ${rcPath ?? ".envrc"} whenever a shell enters the project. Only allow files you have read.`,
+        )
+        if (!confirmed) return
+        try {
+          await context.environment.allowDirenv()
+          context.notify("success", "direnv: .envrc allowed")
+        } catch (error) {
+          context.notify("error", errorMessage(error))
+        }
+      },
+    },
+  ]
+
+  // --- Remote machines -----------------------------------------------------
+  for (const machine of options.machines) {
+    commands.push({
+      id: `remote.ssh.${machine.id}`,
+      title: `Remote: SSH to ${machine.name}`,
+      category: "Remote",
+      keywords: ["ssh", "remote", "connect", machine.host],
+      execute: (context) => context.sshTo(machine.id),
+    })
+  }
+  commands.push({
+    id: "remote.refresh",
+    title: "Remote: refresh machine and Tailscale status",
+    category: "Remote",
+    keywords: ["ssh", "tailscale", "ollama", "reachability"],
+    when: (context) =>
+      context.remoteMachines().length > 0 ||
+      context.store.getState().services.some((service) => service.category === "remote"),
+    execute: async (context) => {
+      context.navigate("services")
+      await context.services.refresh()
+      context.notify("info", "Remote status refreshed")
+    },
+  })
+
+  return commands
+}

package/src/devcc/app/keymap.ts

@@ -12,8 +12,10 @@ export const VIEW_SHORTCUTS: Readonly<Record<string, ViewId>> = {
   "7": "dependencies",
   "8": "system",
   "9": "settings",
+  "0": "worktrees",
   p: "processes",
   g: "git",
+  w: "worktrees",
   l: "logs",
   d: "dependencies",
 }
@@ -51,9 +53,10 @@ export const HELP_SECTIONS: HelpSection[] = [
       { keys: "Services", description: "things detected on this machine: Docker, databases, Ollama" },
       { keys: "Scripts", description: "package.json scripts, run through your package manager" },
       { keys: "Git", description: "branch, changes, commits; stage, commit, pull, push" },
+      { keys: "Worktrees", description: "git worktrees, and the AI agents (Claude, Codex) working in them" },
       { keys: "Logs", description: "output of everything devcc started, per source or merged" },
       { keys: "Dependencies", description: "outdated packages, checked only when you ask" },
-      { keys: "System", description: "host, toolchain versions, CPU, memory, disk" },
+      { keys: "System", description: "environment health (tools, mise, direnv), CPU, memory, disk, host" },
       { keys: "Settings", description: "detection results, config issues, diagnostics history" },
     ],
   },
@@ -74,8 +77,8 @@ export const HELP_SECTIONS: HelpSection[] = [
       { keys: "← / h", description: "previous section" },
       { keys: "→", description: "next section" },
       { keys: "tab / S-tab", description: "cycle sections" },
-      { keys: "1…9", description: "jump to a section" },
-      { keys: "p / g / l / d", description: "processes / git / logs / dependencies" },
+      { keys: "1…9, 0", description: "jump to a section (0 is Worktrees)" },
+      { keys: "p / g / w / l / d", description: "processes / git / worktrees / logs / dependencies" },
       { keys: "enter", description: "open or activate" },
       { keys: "esc", description: "close overlay / back" },
     ],
@@ -109,6 +112,18 @@ export const HELP_SECTIONS: HelpSection[] = [
       { keys: "r", description: "refresh status" },
     ],
   },
+  {
+    title: "Worktrees & agents",
+    entries: [
+      { keys: "n", description: "new worktree (branch, base, directory)" },
+      { keys: "d", description: "remove the worktree (confirmed, never forced)" },
+      { keys: "o / enter", description: "open the worktree in devcc; on an agent, its logs" },
+      { keys: "t / e", description: "open a terminal / the editor in the worktree" },
+      { keys: "c / x", description: "launch Claude Code / Codex with a task in the worktree" },
+      { keys: "s", description: "stop the selected agent" },
+      { keys: "r", description: "refresh the worktree list" },
+    ],
+  },
   {
     title: "Logs",
     entries: [
@@ -148,6 +163,7 @@ export const HELP_SECTIONS: HelpSection[] = [
       { keys: "ctrl+p / ctrl+o", description: "open / cycle projects" },
       { keys: "?", description: "this help" },
       { keys: "R", description: "refresh everything" },
+      { keys: "V", description: "verify the project (every verify step)" },
       { keys: "q / ctrl+c", description: "quit" },
     ],
   },
@@ -162,6 +178,11 @@ export const HELP_SECTIONS: HelpSection[] = [
       { keys: "services[]", description: "extra ports to watch: id, name, port, healthPath" },
       { keys: "projects[]", description: "extra paths offered by the project switcher" },
       { keys: "refresh", description: "{ system, services, git, clock } intervals in ms" },
+      { keys: "verify[]", description: "command ids, script names or { id, command }: devcc verify" },
+      { keys: "agents", description: "{ claude: { command, args }, codex: {...} } overrides" },
+      { keys: "editor / terminal", description: "{ command } or { application } for open actions" },
+      { keys: "remoteMachines[]", description: "id, name, host (an SSH alias works), services" },
+      { keys: "services[] ollama", description: '{ id, type: "ollama", baseUrl }: remote models' },
     ],
   },
 ]

package/src/devcc/automation.ts

@@ -0,0 +1,242 @@
+import { loadConfig } from "./core/config.js"
+import { EnvironmentService, type EnvironmentSnapshot } from "./environment/EnvironmentService.js"
+import { GitService } from "./git/GitService.js"
+import { worktreeLabel } from "./git/worktrees.js"
+import { errorMessage } from "./utils/errors.js"
+import { createLogger } from "./utils/logger.js"
+import { detectPackageManager, readPackageJson, readScripts } from "./utils/packageManager.js"
+import { tildify } from "./utils/paths.js"
+import {
+  createSpawnExecutor,
+  isVerifyIssue,
+  resolveVerifySteps,
+  runVerification,
+  summariseVerify,
+  type StepExecutor,
+  type VerifyReport,
+} from "./verify/verify.js"
+
+/**
+ * Non-interactive commands for scripts and AI agents: `devcc verify`,
+ * `devcc worktree list`, `devcc env`. None of them load the TUI, so they run on
+ * plain Node without FFI. With `--json`, stdout carries exactly one JSON
+ * document and nothing else; diagnostics go to stderr.
+ */
+
+export interface AutomationIo {
+  stdout: (text: string) => void
+  stderr: (text: string) => void
+}
+
+export interface AutomationOptions {
+  rootDir: string
+  json: boolean
+  io?: AutomationIo
+  /** Injected for tests; defaults to spawning each step. */
+  executor?: StepExecutor
+  signal?: AbortSignal
+}
+
+export const EXIT_OK = 0
+export const EXIT_FAILED = 1
+/** Misconfiguration or misuse: nothing was verified. */
+export const EXIT_USAGE = 2
+
+const processIo: AutomationIo = {
+  stdout: (text) => process.stdout.write(text),
+  stderr: (text) => process.stderr.write(text),
+}
+
+function printJson(io: AutomationIo, value: unknown): void {
+  io.stdout(`${JSON.stringify(value, null, 2)}\n`)
+}
+
+// ---------------------------------------------------------------------------
+// devcc verify
+// ---------------------------------------------------------------------------
+
+export async function verifyCommand(options: AutomationOptions): Promise<number> {
+  const io = options.io ?? processIo
+  const { rootDir, json } = options
+
+  const packageJson = readPackageJson(rootDir)
+  const packageManager = detectPackageManager({ rootDir, packageJson, userAgent: undefined }).manager
+  const loaded = await loadConfig(rootDir)
+  const { steps, issues } = resolveVerifySteps(loaded.config.verify, {
+    commands: loaded.config.commands,
+    scripts: readScripts(packageJson),
+    packageManager,
+  })
+
+  // A dropped or unresolvable verify entry must fail the gate: silently running
+  // fewer checks than configured would let a broken project pass.
+  const blocking = [
+    ...loaded.issues.filter((issue) => issue.startsWith("Failed to load") || isVerifyIssue(issue)),
+    ...issues,
+  ]
+  if (steps.length === 0 && blocking.length === 0) {
+    blocking.push(
+      loaded.filePath
+        ? `No verification steps: add verify: ["lint", "test"] to ${tildify(loaded.filePath)}`
+        : 'No verification steps: create .devcc.ts with verify: ["lint", "test"]',
+    )
+  }
+  if (blocking.length > 0) {
+    if (json) printJson(io, { ok: false, error: "configuration", issues: blocking })
+    else for (const issue of blocking) io.stderr(`devcc verify: ${issue}\n`)
+    return EXIT_USAGE
+  }
+
+  if (!json) io.stdout(`devcc verify · ${tildify(rootDir)} · ${steps.length} step(s)\n\n`)
+
+  const executor = options.executor ?? createSpawnExecutor({ rootDir })
+  let printed = 0
+  const report = await runVerification(steps, executor, {
+    signal: options.signal,
+    onProgress: (progress) => {
+      if (json) return
+      for (; printed < progress.length; printed += 1) {
+        const step = progress[printed]
+        if (!step || step.status === "pending") break
+        if (step.status === "running") {
+          io.stdout(`→ ${step.name}: ${[step.command, ...step.args].join(" ")}\n`)
+          break
+        }
+        io.stdout(stepLine(step))
+        if (step.status === "failed") io.stdout(failureOutput(step))
+      }
+    },
+  })
+
+  if (json) {
+    printJson(io, { ...report, rootDir, summary: summariseVerify(report) })
+  } else {
+    for (const step of report.steps.slice(printed)) if (step.status === "skipped") io.stdout(stepLine(step))
+    io.stdout(`\n${report.ok ? "✓" : "✗"} ${summariseVerify(report)} in ${seconds(report.durationMs)}\n`)
+  }
+  return report.ok ? EXIT_OK : EXIT_FAILED
+}
+
+function stepLine(step: VerifyReport["steps"][number]): string {
+  const mark = step.status === "passed" ? "✓" : step.status === "skipped" ? "-" : "✗"
+  const detail =
+    step.status === "skipped"
+      ? "skipped"
+      : [
+          seconds(step.durationMs),
+          step.exitCode !== null && step.exitCode !== 0 ? `exit ${step.exitCode}` : undefined,
+          step.error,
+        ]
+          .filter(Boolean)
+          .join(" · ")
+  return `${mark} ${step.name} (${detail})\n`
+}
+
+/** The tail of a failed step's output, indented under it. */
+function failureOutput(step: VerifyReport["steps"][number], maxLines = 60): string {
+  const text = [step.stdout, step.stderr]
+    .filter((part) => part.trim() !== "")
+    .join("\n")
+    .trimEnd()
+  if (text === "") return ""
+  const lines = text.split("\n")
+  const shown = lines.slice(-maxLines)
+  const header = lines.length > maxLines ? [`… ${lines.length - maxLines} earlier line(s) omitted`] : []
+  return `${[...header, ...shown].map((line) => `    ${line}`).join("\n")}\n`
+}
+
+function seconds(ms: number): string {
+  return `${(ms / 1000).toFixed(1)}s`
+}
+
+// ---------------------------------------------------------------------------
+// devcc worktree list
+// ---------------------------------------------------------------------------
+
+export async function worktreeListCommand(options: AutomationOptions): Promise<number> {
+  const io = options.io ?? processIo
+  const git = new GitService({ rootDir: options.rootDir, logger: createLogger(options.rootDir).child("git") })
+  try {
+    const worktrees = await git.listWorktrees()
+    if (options.json) {
+      printJson(io, { rootDir: options.rootDir, worktrees })
+      return EXIT_OK
+    }
+    const width = Math.max(...worktrees.map((worktree) => worktreeLabel(worktree).length), 6)
+    for (const worktree of worktrees) {
+      const flags = [
+        worktree.isMain ? "main" : undefined,
+        worktree.locked ? "locked" : undefined,
+        worktree.prunable ? "prunable" : undefined,
+      ].filter(Boolean)
+      io.stdout(
+        `${worktree.isCurrent ? "*" : " "} ${worktreeLabel(worktree).padEnd(width)}  ${tildify(worktree.path)}${
+          flags.length > 0 ? `  [${flags.join(", ")}]` : ""
+        }\n`,
+      )
+    }
+    return EXIT_OK
+  } catch (error) {
+    const message = errorMessage(error)
+    if (options.json) printJson(io, { error: message, rootDir: options.rootDir, worktrees: [] })
+    else io.stderr(`devcc worktree list: ${message}\n`)
+    return EXIT_FAILED
+  }
+}
+
+// ---------------------------------------------------------------------------
+// devcc env
+// ---------------------------------------------------------------------------
+
+export async function envCommand(
+  options: AutomationOptions & { environment?: EnvironmentService },
+): Promise<number> {
+  const io = options.io ?? processIo
+  const environment = options.environment ?? new EnvironmentService({ rootDir: options.rootDir })
+  const snapshot = await environment.refresh()
+  if (options.json) {
+    const { checking: _checking, ...rest } = snapshot
+    printJson(io, { rootDir: options.rootDir, ...rest })
+  } else {
+    io.stdout(formatEnvironment(snapshot))
+  }
+  return EXIT_OK
+}
+
+export function formatEnvironment(snapshot: EnvironmentSnapshot): string {
+  const lines: string[] = ["TOOLS"]
+  const nameWidth = Math.max(...snapshot.tools.map((tool) => tool.name.length), 4) + 2
+  for (const tool of snapshot.tools) {
+    const mark = !tool.installed ? "·" : tool.status === "ready" ? "✓" : tool.status === "warning" ? "⚠" : "✗"
+    const value = tool.installed ? (tool.version ?? "installed") : "not installed"
+    const note = tool.installed && tool.message ? `  ${tool.message}` : ""
+    lines.push(`  ${mark} ${tool.name.padEnd(nameWidth)}${value}${note}`)
+  }
+
+  if (snapshot.mise.installed) {
+    lines.push("", "RUNTIMES (mise)")
+    if (snapshot.mise.error) lines.push(`  ⚠ ${snapshot.mise.error}`)
+    else if (snapshot.mise.runtimes.length === 0) lines.push("  no tools pinned for this project")
+    for (const runtime of snapshot.mise.runtimes) {
+      lines.push(
+        `  ${runtime.tool.padEnd(nameWidth + 2)}${runtime.version}${runtime.installed ? "" : "  (not installed)"}`,
+      )
+    }
+  }
+
+  const { direnv } = snapshot
+  if (direnv.installed || direnv.rcPath) {
+    lines.push("", "DIRENV")
+    if (direnv.error) lines.push(`  ⚠ ${direnv.error}`)
+    if (direnv.rcPath) {
+      lines.push(`  .envrc    ${tildify(direnv.rcPath)}`)
+      if (direnv.installed) {
+        lines.push(`  approval  ${direnv.approval}`)
+        lines.push(`  loaded    ${direnv.loaded ? "yes" : "no"}`)
+      }
+    } else {
+      lines.push("  no .envrc for this project")
+    }
+  }
+  return `${lines.join("\n")}\n`
+}

package/src/devcc/cli.ts

@@ -8,8 +8,9 @@
  * bypassed it.
  */
 import { createRequire } from "node:module"
+import { resolve } from "node:path"
 import { pathToFileURL } from "node:url"
-import { App } from "./app/App.js"
+import { envCommand, EXIT_USAGE, verifyCommand, worktreeListCommand } from "./automation.js"
 import { errorMessage } from "./utils/errors.js"
 import { findProjectRoot } from "./utils/paths.js"
 
@@ -17,6 +18,9 @@ interface CliArgs {
   cwd?: string
   help: boolean
   version: boolean
+  json: boolean
+  /** Subcommand and its arguments, e.g. `["worktree", "list"]`. */
+  positionals: string[]
 }
 
 /**
@@ -37,11 +41,12 @@ function readVersion(): string {
 const VERSION = readVersion()
 
 function parseArgs(argv: readonly string[]): CliArgs {
-  const args: CliArgs = { help: false, version: false }
+  const args: CliArgs = { help: false, version: false, json: false, positionals: [] }
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index]
     if (arg === "--help" || arg === "-h") args.help = true
     else if (arg === "--version" || arg === "-v") args.version = true
+    else if (arg === "--json") args.json = true
     else if (arg === "--cwd" || arg === "-C") {
       const value = argv[index + 1]
       if (value) {
@@ -50,6 +55,8 @@ function parseArgs(argv: readonly string[]): CliArgs {
       }
     } else if (arg?.startsWith("--cwd=")) {
       args.cwd = arg.slice("--cwd=".length)
+    } else if (arg !== undefined && !arg.startsWith("-")) {
+      args.positionals.push(arg)
     }
   }
   return args
@@ -58,13 +65,20 @@ function parseArgs(argv: readonly string[]): CliArgs {
 const USAGE = `dev command center ${VERSION}
 
 Usage:
-  devcc [options]
+  devcc [options]                 Open the dashboard
+  devcc verify [--json]           Run the project's verify steps; exit 0 only if all pass
+  devcc worktree list [--json]    List git worktrees
+  devcc env [--json]              Report tools, mise runtimes and direnv status
 
 Options:
   -C, --cwd <dir>   Project directory (default: nearest project root)
+      --json        Machine-readable output (verify, worktree list, env)
   -h, --help        Show this help
   -v, --version     Show the version
 
+Exit codes (verify):
+  0  every step passed   1  a step failed   2  nothing to verify / bad config
+
 Environment:
   DEVCC_LOG_LEVEL   debug | info | warn | error | silent (default: info)
 
@@ -84,11 +98,24 @@ export async function main(argv: readonly string[] = process.argv.slice(2)): Pro
     return 0
   }
 
+  const [command, ...rest] = args.positionals
+  if (command !== undefined) {
+    const rootDir = args.cwd ? resolve(args.cwd) : findProjectRoot()
+    const options = { rootDir, json: args.json }
+    if (command === "verify" && rest.length === 0) return runVerifyCli(options)
+    if (command === "worktree" && rest.length === 1 && rest[0] === "list") return worktreeListCommand(options)
+    if (command === "env" && rest.length === 0) return envCommand(options)
+    process.stderr.write(`devcc: unknown command "${args.positionals.join(" ")}"\n\n${USAGE}`)
+    return EXIT_USAGE
+  }
+
   if (!process.stdout.isTTY) {
     process.stderr.write("devcc needs an interactive terminal (stdout is not a TTY).\n")
     return 1
   }
 
+  // Loaded lazily: OpenTUI needs FFI, which the automation commands above do not.
+  const { App } = await import("./app/App.js")
   const app = new App({ cwd: args.cwd ? args.cwd : findProjectRoot() })
 
   try {
@@ -107,6 +134,21 @@ export async function main(argv: readonly string[] = process.argv.slice(2)): Pro
   }
 }
 
+/** Ctrl+C stops the running step instead of leaving it orphaned. */
+async function runVerifyCli(options: { rootDir: string; json: boolean }): Promise<number> {
+  const controller = new AbortController()
+  const onSignal = () => controller.abort()
+  process.once("SIGINT", onSignal)
+  process.once("SIGTERM", onSignal)
+  try {
+    const code = await verifyCommand({ ...options, signal: controller.signal })
+    return controller.signal.aborted ? 130 : code
+  } finally {
+    process.off("SIGINT", onSignal)
+    process.off("SIGTERM", onSignal)
+  }
+}
+
 const entry = process.argv[1]
 const isDirectRun = entry !== undefined && import.meta.url === pathToFileURL(entry).href
 

package/src/devcc/components/Sidebar.ts

@@ -16,6 +16,7 @@ export const SIDEBAR_ITEMS: readonly SidebarItem[] = [
   { id: "services", label: "Services" },
   { id: "scripts", label: "Scripts" },
   { id: "git", label: "Git" },
+  { id: "worktrees", label: "Worktrees" },
   { id: "logs", label: "Logs" },
   { id: "dependencies", label: "Dependencies" },
   { id: "system", label: "System" },

package/src/devcc/components/primitives.ts

@@ -98,6 +98,9 @@ export class RowList {
     })
     this.box.onSizeChange = () => {
       const visible = this.visibleCount
+      // The first setRows can happen before layout, when the viewport is one
+      // row tall; re-derive the scroll position now that the real height is known.
+      this.ensureVisible()
       this.paint()
       if (visible !== this.lastVisibleCount) {
         this.lastVisibleCount = visible