@doriandev/devcc 0.1.2 → 0.3.0

package/src/devcc/views/OverviewView.ts

@@ -4,6 +4,7 @@ import { RowList, type ListRow } from "../components/primitives.js"
 import { processGlyph, serviceGlyph } from "../components/StatusBadge.js"
 import { chunk, dim, styled } from "../components/styled.js"
 import { summariseStatus, summariseTracking } from "../git/parse.js"
+import { worktreeLabel } from "../git/worktrees.js"
 import { isActive } from "../processes/ManagedProcess.js"
 import type { AppState, ViewId } from "../core/state.js"
 import { fit, formatDuration, meter, toGigabytes } from "../utils/format.js"
@@ -51,13 +52,57 @@ export class OverviewView extends View {
         ),
       )
       rows.push(info("tracking", summariseTracking(state.git.status), labelWidth))
+      if (state.git.worktrees.length > 1) {
+        const current = state.git.worktrees.find((worktree) => worktree.isCurrent)
+        rows.push(
+          info(
+            "worktree",
+            `${current ? worktreeLabel(current) : "?"} · ${state.git.worktrees.length} worktrees (w)`,
+            labelWidth,
+          ),
+        )
+      }
+    }
+
+    // --- Verification ------------------------------------------------------
+    if (state.verify.configured > 0) {
+      rows.push(blank())
+      rows.push(section("Verify"))
+      rows.push(verifyRow(state, labelWidth))
+    }
+
+    // --- AI agents ---------------------------------------------------------
+    if (state.agents.length > 0) {
+      rows.push(blank())
+      rows.push(section("AI agents"))
+      for (const agent of state.agents.slice(0, compact ? 2 : 4)) {
+        rows.push({
+          key: `agent-${agent.id}`,
+          disabled: true,
+          content: styled(
+            "  ",
+            processGlyph(agent.status).chunks[0] ?? chunk(" "),
+            " ",
+            chunk(fit(agent.agentName, 16), theme.text),
+            dim(fit(agent.branch ?? agent.cwd, 26)),
+            dim(fit(agent.task, 40)),
+          ),
+        })
+      }
     }
 
     // --- Development processes -------------------------------------------
     rows.push(blank())
     rows.push(section("Development"))
     if (state.processes.length === 0) {
-      rows.push(info("", "no managed processes - add some in .devcc.ts"))
+      rows.push(
+        info(
+          "",
+          state.project.configPath
+            ? "no managed processes - add some in .devcc.ts"
+            : "no .devcc.ts yet - press / and run “Project: set up .devcc.ts”",
+        ),
+      )
     } else {
       for (const process of state.processes.slice(0, compact ? 4 : 8)) {
         const detail = process.url ?? (process.pid ? `pid ${process.pid}` : "")
@@ -135,6 +180,16 @@ export class OverviewView extends View {
         rows.push(info("node", `${state.project.host.runtime}`, labelWidth))
       }
     }
+    const attention = environmentAttention(state)
+    if (attention) {
+      rows.push(
+        infoStyled(
+          "environment",
+          styled(chunk(attention, theme.warning), dim("  (8 for details)")),
+          labelWidth,
+        ),
+      )
+    }
 
     this.list.setRows(rows, -1)
   }
@@ -144,7 +199,8 @@ export class OverviewView extends View {
       { keys: "↑↓", label: "navigate" },
       { keys: "p", label: "processes" },
       { keys: "g", label: "git" },
-      { keys: "l", label: "logs" },
+      { keys: "w", label: "worktrees" },
+      { keys: "V", label: "verify" },
       { keys: "/", label: "commands" },
       { keys: "?", label: "help" },
       { keys: "q", label: "quit" },
@@ -180,6 +236,32 @@ function infoStyled(label: string, value: ReturnType<typeof styled>, labelWidth
   }
 }
 
+function verifyRow(state: AppState, labelWidth: number): ListRow {
+  const { verify } = state
+  if (verify.steps.length === 0) {
+    return info("status", `${verify.configured} step(s) configured - press V to run`, labelWidth)
+  }
+  const passed = verify.steps.filter((step) => step.status === "passed").length
+  const failed = verify.steps.filter((step) => step.status === "failed")
+  const running = verify.steps.find((step) => step.status === "running")
+  const color = verify.running ? theme.warning : verify.ok ? theme.success : theme.danger
+  const summary = verify.running
+    ? `${passed}/${verify.steps.length} passed · running ${running?.name ?? "…"}`
+    : `${passed}/${verify.steps.length} passed${failed.length > 0 ? ` · failed: ${failed.map((step) => step.name).join(", ")}` : ""}`
+  return infoStyled("status", styled(chunk(summary, color)), labelWidth)
+}
+
+/** One line when the environment needs a look, otherwise nothing. */
+function environmentAttention(state: AppState): string | null {
+  const { tools, direnv, mise } = state.environment
+  const problems = tools
+    .filter((tool) => tool.status === "error" || tool.status === "warning")
+    .map((tool) => tool.name)
+  if (mise.error) problems.push("mise")
+  if (direnv.installed && direnv.rcPath && direnv.approval !== "allowed") problems.push(".envrc not allowed")
+  return problems.length > 0 ? problems.join(", ") : null
+}
+
 function usageColor(ratio: number): string {
   if (ratio > 0.85) return theme.danger
   if (ratio > 0.6) return theme.warning

package/src/devcc/views/ServicesView.ts

@@ -5,11 +5,14 @@ import { RowList, type ListRow } from "../components/primitives.js"
 import { serviceBadge, serviceGlyph } from "../components/StatusBadge.js"
 import { chunk, dim, styled } from "../components/styled.js"
 import { setSelection, type AppState, type ViewId } from "../core/state.js"
+import { remoteServiceId } from "../services/remote.js"
 import type { ServiceSnapshot } from "../services/types.js"
 import { errorMessage } from "../utils/errors.js"
 import { fit } from "../utils/format.js"
 import { View, type ViewDeps } from "./View.js"
 
+const REMOTE_PREFIX = remoteServiceId("")
+
 interface Entry {
   kind: "service" | "item" | "heading"
   service?: ServiceSnapshot
@@ -117,6 +120,9 @@ export class ServicesView extends View {
       case "d":
         void this.composeDown(selected)
         return true
+      case "o":
+        void this.ssh(selected)
+        return true
       default:
         return false
     }
@@ -128,6 +134,7 @@ export class ServicesView extends View {
       { keys: "s", label: "start/stop" },
       { keys: "r", label: "restart" },
       { keys: "d", label: "compose down" },
+      { keys: "o", label: "ssh (remote)" },
       { keys: "/", label: "commands" },
     ]
   }
@@ -176,6 +183,16 @@ export class ServicesView extends View {
     }
   }
 
+  /** Open an SSH session to a remote machine in a terminal. */
+  private async ssh(index: number): Promise<void> {
+    const service = this.selectedService(index)
+    if (!service?.id.startsWith(REMOTE_PREFIX)) {
+      this.deps.app.notify("warn", "Select a remote machine first")
+      return
+    }
+    await this.deps.app.sshTo(service.id.slice(REMOTE_PREFIX.length))
+  }
+
   /** `docker compose down` removes containers; always confirmed. */
   private async composeDown(index: number): Promise<void> {
     const service = this.selectedService(index)

package/src/devcc/views/SystemView.ts

@@ -1,17 +1,28 @@
+import type { KeyEvent } from "@opentui/core"
 import { theme } from "../app/theme.js"
 import type { KeyHint } from "../components/Footer.js"
 import { RowList, type ListRow } from "../components/primitives.js"
 import { chunk, dim, styled } from "../components/styled.js"
 import type { AppState, ViewId } from "../core/state.js"
+import type { DirenvApproval } from "../environment/integrations.js"
+import type { ToolStatus } from "../environment/tools.js"
 import { fit, formatBytes, formatDuration, meter, toGigabytes } from "../utils/format.js"
+import { tildify } from "../utils/paths.js"
 import { View, type ViewDeps } from "./View.js"
 
-/** Host information and live resource usage. Read-only. */
+/**
+ * Environment health, live resource usage and host information.
+ *
+ * Tool, mise and direnv detection runs once in the background and on request
+ * ("Environment: refresh" in the palette); nothing here polls external tools.
+ */
 export class SystemView extends View {
   readonly id: ViewId = "system"
   readonly title = "System"
 
   private readonly list: RowList
+  /** Kept across refreshes: metrics repaint every tick and must not reset the scroll. */
+  private offset = 0
 
   constructor(deps: ViewDeps) {
     super(deps)
@@ -21,28 +32,72 @@ export class SystemView extends View {
 
   update(state: AppState): void {
     const host = state.project.host
-    const tools = state.project.tools
     const metrics = state.system
+    const environment = state.environment
     const rows: ListRow[] = []
 
-    rows.push(heading("Host"))
-    rows.push(row("hostname", host.hostname))
-    rows.push(row("os", `${host.platform} ${host.release}`))
-    rows.push(row("arch", host.arch))
-    rows.push(row("cpu", `${host.cpuModel} (${host.cpuCount} cores)`))
-    rows.push(row("memory", `${toGigabytes(host.totalMemory)} GB total`))
+    rows.push(heading("Environment"))
+    if (!environment.checkedAt) {
+      rows.push(row("", "checking tools…"))
+    } else {
+      for (const tool of environment.tools) rows.push(toolRow(tool))
+      if (environment.checking) rows.push(row("", "re-checking…"))
+    }
+
+    const { mise, direnv } = environment
+    if (mise.installed) {
+      rows.push(blank("mise"))
+      rows.push(heading("Runtimes (mise)"))
+      if (mise.error) rows.push(warningRow("mise", mise.error))
+      else if (mise.runtimes.length === 0) rows.push(row("", "no tools pinned for this project"))
+      for (const runtime of mise.runtimes) {
+        const note = [
+          runtime.requested && runtime.requested !== runtime.version
+            ? `requested ${runtime.requested}`
+            : undefined,
+          runtime.installed ? undefined : "not installed - run `mise install`",
+        ]
+          .filter(Boolean)
+          .join(" · ")
+        rows.push({
+          key: `rt-${runtime.tool}-${runtime.version}`,
+          disabled: true,
+          content: styled(
+            dim(fit(runtime.tool, LABEL_WIDTH)),
+            chunk(fit(runtime.version, 14), runtime.installed ? theme.text : theme.warning),
+            dim(note),
+          ),
+        })
+      }
+    }
+
+    if (direnv.installed || direnv.rcPath) {
+      rows.push(blank("direnv"))
+      rows.push(heading("direnv"))
+      if (direnv.error) rows.push(warningRow("status", direnv.error))
+      if (!direnv.rcPath) {
+        rows.push(row(".envrc", "none for this project"))
+      } else {
+        rows.push(row(".envrc", tildify(direnv.rcPath)))
+        if (direnv.installed) {
+          const approval = APPROVAL_LABELS[direnv.approval]
+          rows.push({
+            key: "direnv-approval",
+            disabled: true,
+            content: styled(
+              dim(fit("approval", LABEL_WIDTH)),
+              chunk(approval, direnv.approval === "allowed" ? theme.success : theme.warning),
+              direnv.approval === "allowed" ? dim("") : dim("   palette: Environment: direnv allow"),
+            ),
+          })
+          rows.push(
+            row("loaded in devcc", direnv.loaded ? "yes" : "no - start devcc from a direnv-enabled shell"),
+          )
+        }
+      }
+    }
 
-    rows.push(blank())
-    rows.push(heading("Toolchain"))
-    rows.push(row("runtime", host.runtime))
-    rows.push(row("node", host.nodeVersion))
-    rows.push(
-      row("package manager", `${state.project.packageManager.manager} ${tools.packageManager ?? ""}`.trim()),
-    )
-    rows.push(row("git", tools.git ?? "not found"))
-    rows.push(row("docker", tools.docker ?? "not found"))
-
-    rows.push(blank())
+    rows.push(blank("usage"))
     rows.push(heading("Usage"))
     if (!metrics) {
       rows.push(row("", "sampling…"))
@@ -67,15 +122,46 @@ export class SystemView extends View {
       rows.push(row("load average", metrics.loadAverage.map((value) => value.toFixed(2)).join("  ")))
       rows.push(row("host uptime", formatDuration(metrics.uptimeMs)))
       rows.push(row("devcc uptime", formatDuration(metrics.processUptimeMs)))
-      rows.push(row("sampled", metrics.sampledAt.toLocaleTimeString()))
     }
 
+    rows.push(blank("host"))
+    rows.push(heading("Host"))
+    rows.push(row("hostname", host.hostname))
+    rows.push(row("os", `${host.platform} ${host.release}`))
+    rows.push(row("cpu", `${host.cpuModel} (${host.cpuCount} cores)`))
+    rows.push(row("memory", `${toGigabytes(host.totalMemory)} GB total`))
+    rows.push(row("devcc runtime", host.runtime))
+    rows.push(row("package manager", state.project.packageManager.manager))
+
     this.list.setRows(rows, -1)
+    if (this.offset > 0) this.list.scrollBy(this.offset)
+    this.offset = this.list.offset
+  }
+
+  override handleKey(key: KeyEvent): boolean {
+    switch (key.name) {
+      case "up":
+      case "k":
+        this.list.scrollBy(-1)
+        this.offset = this.list.offset
+        return true
+      case "down":
+      case "j":
+        this.list.scrollBy(1)
+        this.offset = this.list.offset
+        return true
+      case "r":
+        void this.deps.commands.run("environment.refresh", this.deps.app)
+        return true
+      default:
+        return false
+    }
   }
 
   override hints(): KeyHint[] {
     return [
       { keys: "↑↓", label: "scroll" },
+      { keys: "r", label: "re-check environment" },
       { keys: "/", label: "commands" },
       { keys: "?", label: "help" },
     ]
@@ -88,8 +174,44 @@ function heading(title: string): ListRow {
   return { key: `h-${title}`, disabled: true, content: styled(chunk(title.toUpperCase(), theme.accent)) }
 }
 
-function blank(): ListRow {
-  return { key: `b-${Math.random().toString(36).slice(2)}`, disabled: true, content: "" }
+function blank(id: string): ListRow {
+  return { key: `b-${id}`, disabled: true, content: "" }
+}
+
+const APPROVAL_LABELS: Record<DirenvApproval, string> = {
+  allowed: "allowed",
+  "not-allowed": "not allowed yet",
+  denied: "denied",
+  unknown: "unknown",
+}
+
+function toolRow(tool: ToolStatus): ListRow {
+  const mark = !tool.installed
+    ? chunk("·", theme.textDim)
+    : tool.status === "ready"
+      ? chunk("✓", theme.success)
+      : tool.status === "warning"
+        ? chunk("⚠", theme.warning)
+        : chunk("✖", theme.danger)
+  const value = tool.installed ? (tool.version ?? "installed") : "not installed"
+  return {
+    key: `tool-${tool.id}`,
+    disabled: true,
+    content: styled(
+      dim(fit(tool.name, LABEL_WIDTH)),
+      chunk(fit(value, 16), tool.installed ? theme.text : theme.textDim),
+      mark,
+      tool.message && tool.installed ? chunk(`  ${tool.message}`, theme.warning) : dim(""),
+    ),
+  }
+}
+
+function warningRow(label: string, message: string): ListRow {
+  return {
+    key: `warn-${label}`,
+    disabled: true,
+    content: styled(dim(fit(label, LABEL_WIDTH)), chunk(`⚠ ${message}`, theme.warning)),
+  }
 }
 
 function row(label: string, value: string): ListRow {

package/src/devcc/views/WorktreesView.ts

@@ -0,0 +1,270 @@
+import type { KeyEvent } from "@opentui/core"
+import type { AgentSession } from "../agents/agents.js"
+import { theme } from "../app/theme.js"
+import type { KeyHint } from "../components/Footer.js"
+import { RowList, type ListRow } from "../components/primitives.js"
+import { processBadge } from "../components/StatusBadge.js"
+import { chunk, dim, styled } from "../components/styled.js"
+import { setSelection, updateUi, type AppState, type ViewId } from "../core/state.js"
+import { isInside, worktreeLabel, type GitWorktree } from "../git/worktrees.js"
+import { isActive } from "../processes/ManagedProcess.js"
+import { errorMessage } from "../utils/errors.js"
+import { fit, formatDuration } from "../utils/format.js"
+import { tildify } from "../utils/paths.js"
+import { View, type ViewDeps } from "./View.js"
+
+export interface WorktreeEntry {
+  kind: "heading" | "blank" | "note" | "worktree" | "agent"
+  key: string
+  text?: string
+  worktree?: GitWorktree
+  agent?: AgentSession
+}
+
+/**
+ * The rows of the Worktrees view, derived from state alone so commands can
+ * resolve "the selected worktree" without asking the view.
+ */
+export function worktreeEntries(state: AppState): WorktreeEntry[] {
+  const entries: WorktreeEntry[] = [{ kind: "heading", key: "h-worktrees", text: "Worktrees" }]
+
+  if (!state.git.isRepository) {
+    entries.push({
+      kind: "note",
+      key: "n-repo",
+      text: state.git.lastRefreshedAt ? "Not a git repository." : "Reading git…",
+    })
+  } else {
+    for (const worktree of state.git.worktrees) {
+      entries.push({ kind: "worktree", key: `w-${worktree.path}`, worktree })
+    }
+  }
+
+  entries.push({ kind: "blank", key: "b-agents" })
+  entries.push({ kind: "heading", key: "h-agents", text: "AI agents" })
+  if (state.agents.length === 0) {
+    entries.push({
+      kind: "note",
+      key: "n-agents",
+      text: "No agents started. Select a worktree and press c (Claude) or x (Codex).",
+    })
+  } else {
+    for (const agent of state.agents) entries.push({ kind: "agent", key: `a-${agent.id}`, agent })
+  }
+  return entries
+}
+
+function selectable(entry: WorktreeEntry | undefined): boolean {
+  return entry?.kind === "worktree" || entry?.kind === "agent"
+}
+
+export function selectedWorktreeEntry(state: AppState): WorktreeEntry | undefined {
+  const entry = worktreeEntries(state)[state.ui.selection.worktrees]
+  return selectable(entry) ? entry : undefined
+}
+
+/**
+ * Git worktrees and the AI agents working in them.
+ *
+ * Keys act on the highlighted row: worktree actions on a worktree, stop/logs
+ * on an agent session. Everything here is also in the palette.
+ */
+export class WorktreesView extends View {
+  readonly id: ViewId = "worktrees"
+  readonly title = "Worktrees"
+
+  private readonly list: RowList
+  private entries: WorktreeEntry[] = []
+  /**
+   * The highlighted row's key. Rows shift when worktrees or agents appear, so
+   * the selection follows the row, not its index - `s` must never stop the
+   * wrong agent.
+   */
+  private selectedKey: string | undefined
+
+  constructor(deps: ViewDeps) {
+    super(deps)
+    this.list = new RowList(deps.ctx, { flexGrow: 1 })
+    this.box.add(this.list.box)
+  }
+
+  update(state: AppState): void {
+    this.entries = worktreeEntries(state)
+    const width = Math.max(40, state.ui.width - (state.ui.sidebarVisible ? 26 : 4))
+    const labelWidth = Math.min(30, Math.max(14, Math.floor(width * 0.3)))
+
+    let selected = state.ui.selection.worktrees
+    const followed = this.selectedKey ? this.entries.findIndex((entry) => entry.key === this.selectedKey) : -1
+    if (followed !== -1) selected = followed
+    else if (!selectable(this.entries[selected])) selected = this.entries.findIndex(selectable)
+    if (selected !== -1 && selected !== state.ui.selection.worktrees) {
+      setSelection(this.deps.app.store, "worktrees", selected)
+    }
+    this.selectedKey = this.entries[selected]?.key
+
+    const rows: ListRow[] = this.entries.map((entry) => {
+      switch (entry.kind) {
+        case "heading":
+          return {
+            key: entry.key,
+            disabled: true,
+            content: styled(chunk((entry.text ?? "").toUpperCase(), theme.accent)),
+          }
+        case "blank":
+          return { key: entry.key, disabled: true, content: "" }
+        case "note":
+          return { key: entry.key, disabled: true, content: styled(dim(`  ${entry.text ?? ""}`)) }
+        case "worktree":
+          return {
+            key: entry.key,
+            content: this.worktreeRow(entry.worktree as GitWorktree, state, labelWidth, width),
+          }
+        case "agent":
+          return { key: entry.key, content: this.agentRow(entry.agent as AgentSession, width) }
+      }
+    })
+
+    this.list.setRows(rows, selected)
+  }
+
+  private worktreeRow(worktree: GitWorktree, state: AppState, labelWidth: number, width: number) {
+    const agents = state.agents.filter(
+      (agent) => isActive(agent.status) && isInside(agent.cwd, worktree.path),
+    )
+    const flags = [
+      worktree.isMain ? "main" : undefined,
+      worktree.locked ? "locked" : undefined,
+      worktree.prunable ? "prunable" : undefined,
+    ].filter(Boolean)
+    const pathWidth = Math.max(10, width - labelWidth - 24)
+
+    return styled(
+      chunk(worktree.isCurrent ? "● " : "○ ", worktree.isCurrent ? theme.accent : theme.textDim),
+      chunk(fit(worktreeLabel(worktree), labelWidth), worktree.isCurrent ? theme.textBright : theme.text),
+      dim(fit(tildify(worktree.path), pathWidth)),
+      agents.length > 0
+        ? chunk(fit(` ${agents.length} agent${agents.length === 1 ? "" : "s"} ▸`, 12), theme.success)
+        : dim(fit("", 12)),
+      worktree.locked || worktree.prunable ? chunk(flags.join(" "), theme.warning) : dim(flags.join(" ")),
+    )
+  }
+
+  private agentRow(agent: AgentSession, width: number) {
+    const where = agent.branch ?? tildify(agent.cwd)
+    const elapsed = isActive(agent.status)
+      ? formatDuration(Date.now() - agent.startedAt.getTime())
+      : agent.exitCode !== undefined
+        ? `exit ${agent.exitCode}`
+        : ""
+    return styled(
+      ...processBadge(agent.status).chunks,
+      " ",
+      chunk(fit(agent.agentName, 13), theme.textBright),
+      chunk(fit(where, 24), theme.text),
+      dim(fit(agent.task, Math.max(10, width - 64))),
+      dim(elapsed),
+    )
+  }
+
+  override handleKey(key: KeyEvent, state: AppState): boolean {
+    const index = state.ui.selection.worktrees
+    const entry = this.entries[index]
+    const worktree = entry?.worktree
+    const agent = entry?.agent
+    const app = this.deps.app
+
+    switch (key.name) {
+      case "up":
+      case "k":
+        this.move(index, -1)
+        return true
+      case "down":
+      case "j":
+        this.move(index, 1)
+        return true
+      case "n":
+        void app.createWorktree()
+        return true
+      case "r":
+        void app.git.refresh().then(() => app.notify("info", "Worktrees refreshed"))
+        return true
+      case "d":
+        if (worktree) void app.removeWorktree(worktree)
+        else app.notify("warn", "Select a worktree to remove")
+        return true
+      case "o":
+      case "return":
+        if (agent) this.showLogs(agent)
+        else if (worktree) void this.openProject(worktree)
+        return true
+      case "t":
+        void app.openInTerminal(worktree?.path ?? agent?.cwd ?? state.project.rootDir)
+        return true
+      case "e":
+        void app.openInEditor(worktree?.path ?? agent?.cwd ?? state.project.rootDir)
+        return true
+      case "c":
+        void app.launchAgent("claude", worktree)
+        return true
+      case "x":
+        void app.launchAgent("codex", worktree)
+        return true
+      case "s":
+        if (agent && isActive(agent.status)) void this.stopAgent(agent)
+        else if (agent) app.notify("info", `${agent.agentName} is not running`)
+        return true
+      case "l":
+        if (agent) {
+          this.showLogs(agent)
+          return true
+        }
+        return false
+      default:
+        return false
+    }
+  }
+
+  override hints(): KeyHint[] {
+    return [
+      { keys: "↑↓", label: "select" },
+      { keys: "n", label: "new" },
+      { keys: "d", label: "remove" },
+      { keys: "o", label: "open" },
+      { keys: "t/e", label: "terminal/editor" },
+      { keys: "c/x", label: "claude/codex" },
+      { keys: "s", label: "stop agent" },
+      { keys: "r", label: "refresh" },
+    ]
+  }
+
+  private move(from: number, direction: 1 | -1): void {
+    for (let index = from + direction; index >= 0 && index < this.entries.length; index += direction) {
+      if (selectable(this.entries[index])) {
+        this.selectedKey = this.entries[index]?.key
+        setSelection(this.deps.app.store, "worktrees", index)
+        return
+      }
+    }
+  }
+
+  private async openProject(worktree: GitWorktree): Promise<void> {
+    if (worktree.isCurrent) {
+      this.deps.app.notify("info", "devcc is already showing this worktree")
+      return
+    }
+    await this.deps.app.switchProject(worktree.path)
+  }
+
+  private showLogs(agent: AgentSession): void {
+    updateUi(this.deps.app.store, { logSource: agent.id, view: "logs" })
+  }
+
+  private async stopAgent(agent: AgentSession): Promise<void> {
+    try {
+      await this.deps.app.agents.stop(agent.id)
+      this.deps.app.notify("info", `Stopped ${agent.agentName}`)
+    } catch (error) {
+      this.deps.app.notify("error", errorMessage(error))
+    }
+  }
+}