opencode-overclock 0.3.0 → 0.5.0

package/src/lib/ui.ts

@@ -0,0 +1,208 @@
+import type { TuiPluginApi, TuiSlotContext } from "@opencode-ai/plugin/tui"
+import { missingSurfaces } from "./probe.ts"
+import type { Store } from "./state.ts"
+
+/** Raw `@opentui/solid` node factory. Returns a JSX.Element the host can render. */
+type JsxFactory = (type: string, props?: Record<string, unknown> | null) => unknown
+
+type SlotRender = (ctx: TuiSlotContext) => unknown
+
+export interface UiCommand {
+  /** command palette entry */
+  title: string
+  /** slash name, without the leading "/" */
+  slash?: string
+  /** optional slash aliases */
+  aliases?: string[]
+  /** unique command id; defaults to `overclock.<slash ?? title>` */
+  id?: string
+  run(dialog?: unknown): void | Promise<void>
+}
+
+export interface UiNotify {
+  message: string
+  title?: string
+  /** built-in sound name; only played when the terminal is blurred */
+  sound?: "default" | "question" | "permission" | "error" | "done" | "subagent_done"
+}
+
+/**
+ * Thin, failure-tolerant facade over `TuiPluginApi`.
+ *
+ * Two things it buys us. First, *uniform degradation*: every host call is a place the TUI API can
+ * drift out from under us, and a throw inside plugin setup takes down every later registration in
+ * the same function. Each method here is individually guarded and warns with a consistent label,
+ * so one broken surface costs exactly one feature. Second, *disposal by construction*: the host
+ * hands back an unsubscribe from `event.on`, an id from `slots.register` (where cleanup is host-managed), and
+ * nothing from `setInterval` -- contracts that call sites previously tracked
+ * by hand. Listeners and intervals registered through the facade are wired to `lifecycle.onDispose` here.
+ */
+export interface Ui {
+  /** escape hatch for surfaces the facade does not wrap yet */
+  readonly api: TuiPluginApi
+  /** project directory; the root every `Store` path is resolved against */
+  readonly directory: string
+  /** subscribe to a host event, auto-disposed. Returns the unsubscribe for early removal. */
+  readonly on: TuiPluginApi["event"]["on"]
+  /** register a palette/slash command, auto-disposed */
+  command(cmd: UiCommand): void
+  /** desktop notification + sound, fired only when the terminal is blurred */
+  notify(input: UiNotify): void
+  toast(message: string, variant?: "info" | "success" | "warning" | "error"): void
+  /** setInterval, cleared on dispose */
+  every(ms: number, fn: () => void): void
+  /** read a store defined in `platform/storage/store.ts` (or re-exported via `mirror.ts`) */
+  read<T>(store: Store<T>): Promise<T>
+  /** as `read`, but `undefined` when the server half has never written the file */
+  readOptional<T>(store: Store<T>): Promise<T | undefined>
+  /** true when every dot-path resolves to a function on the host api */
+  has(...paths: string[]): boolean
+  /**
+   * Load the host's JSX runtime, enabling `node()`. Separate from `createUi` because
+   * `@opentui/solid` is an optional peer and slot rendering is synchronous: a feature that draws
+   * must await this up front, and one that does not should not pay for the import.
+   */
+  enableJsx(): Promise<void>
+  /** create a renderable node. Throws unless `enableJsx()` resolved first. */
+  node(type: string, props: Record<string, unknown>): unknown
+  /** mount slot renderers. The host owns slot cleanup, so there is nothing to dispose. */
+  slots(map: Record<string, SlotRender>): void
+}
+
+function warn(label: string, e: unknown): void {
+  console.warn(`[overclock-tui] ${label} failed: ${e}`)
+}
+
+/** Run `fn`, swallowing and reporting any throw. Returns undefined on failure. */
+function guard<T>(label: string, fn: () => T): T | undefined {
+  try {
+    return fn()
+  } catch (e) {
+    warn(label, e)
+    return undefined
+  }
+}
+
+export function createUi(api: TuiPluginApi): Ui {
+  const directory = api.state.path.directory
+  let jsx: JsxFactory | undefined
+
+  /** Best-effort disposer registration -- `lifecycle` itself is a surface that can be missing. */
+  const onDispose = (fn: () => void): void => {
+    try {
+      api.lifecycle.onDispose(async () => fn())
+    } catch (e) {
+      warn("lifecycle registration", e)
+    }
+  }
+
+  const noop = () => {}
+
+  // Cast: the host's `on` is generic over the event union, and reproducing that generic on an
+  // ordinary function expression is not expressible without naming `Event`, which
+  // `@opencode-ai/plugin/tui` does not re-export. The cast keeps full narrowing for callers.
+  const on = ((type: string, handler: (event: never) => void) => {
+    const unsub = guard(`subscribe ${type}`, () =>
+      (api.event.on as (t: string, h: (event: never) => void) => () => void)(type, handler),
+    )
+    if (!unsub) return noop
+    onDispose(unsub)
+    return unsub
+  }) as TuiPluginApi["event"]["on"]
+
+  return {
+    api,
+    directory,
+    on,
+
+    command(cmd) {
+      const id = cmd.id ?? `overclock.${cmd.slash ?? cmd.title}`
+      // `api.command` is deprecated upstream in favour of `keymap.registerLayer({commands,
+      // bindings})`, and optional on the api type. Isolated here so that migration is a change
+      // to this one method rather than to every feature that registers a command.
+      const unregister = guard(`command ${id}`, () =>
+        api.command?.register(() => [
+          {
+            title: cmd.title,
+            value: id,
+            ...(cmd.slash
+              ? {
+                  slash: {
+                    name: cmd.slash,
+                    ...(cmd.aliases ? { aliases: cmd.aliases } : {}),
+                  },
+                }
+              : {}),
+            onSelect: async (dialog) => {
+              try {
+                await cmd.run(dialog)
+              } catch (e) {
+                warn(`command ${id}`, e)
+              }
+            },
+          },
+        ]),
+      )
+      if (unregister) onDispose(unregister)
+    },
+
+    notify(input) {
+      guard("notify", () =>
+        api.attention.notify({
+          title: input.title ?? "opencode",
+          message: input.message,
+          notification: { when: "blurred" },
+          ...(input.sound ? { sound: { name: input.sound, when: "blurred" as const } } : {}),
+        }),
+      )
+    },
+
+    toast(message, variant) {
+      guard("toast", () => api.ui.toast({ message, ...(variant ? { variant } : {}) }))
+    },
+
+    every(ms, fn) {
+      const timer = setInterval(() => {
+        try {
+          fn()
+        } catch (e) {
+          warn("interval", e)
+        }
+      }, ms)
+      onDispose(() => clearInterval(timer))
+    },
+
+    read(store) {
+      return store.read(directory)
+    },
+
+    readOptional(store) {
+      return store.readMaybe(directory)
+    },
+
+    has(...paths) {
+      return missingSurfaces(api, paths).length === 0
+    },
+
+    async enableJsx() {
+      // The host must map this specifier to *its own* solid instance. If it does not, the import
+      // throws here -- at the caller's await, where it can degrade to "no drawing" -- rather than
+      // from inside a slot render where nothing can catch it.
+      const mod = (await import("@opentui/solid/jsx-runtime")) as unknown as { jsx: JsxFactory }
+      jsx = mod.jsx
+    },
+
+    node(type, props) {
+      if (!jsx) throw new Error("ui.node() requires await ui.enableJsx()")
+      return jsx(type, props)
+    },
+
+    slots(map) {
+      guard("slot registration", () =>
+        api.slots.register({
+          slots: map as unknown as Parameters<TuiPluginApi["slots"]["register"]>[0]["slots"],
+        }),
+      )
+    },
+  }
+}

package/src/merge.ts

@@ -1,66 +1,2 @@
-import type { Hooks } from "@opencode-ai/plugin"
-import { EMPTY_POLICY, type ToolPolicy } from "./tools.ts"
-
-/**
- * Rewrite declared tool names appearing inside a description ("reversible via
- * checkpoint_restore", "Kill it with task_kill"). Left alone, a remap leaves the model
- * reading instructions that name a tool it was never offered. Word-anchored so a name
- * that is a substring of a longer identifier is not clobbered.
- */
-export function renameInText(text: string, rename: Record<string, string>): string {
-  let out = text
-  for (const [from, to] of Object.entries(rename)) {
-    if (from === to) continue
-    out = out.replace(new RegExp(`\\b${from.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "g"), to)
-  }
-  return out
-}
-
-/**
- * Compose many Partial<Hooks> into one Hooks.
- * - fn hooks: call sequentially, module order. Each sees prior mutations of `output`.
- * - `tool` map: shallow merge. Name collision -> later module wins, warn.
- * - `policy`: declared tool name -> model-visible name, plus tools to withhold. Applied here
- *   because every module's tool map funnels through this one merge, so one pass covers the
- *   whole surface and a module never has to know a policy exists.
- */
-export function mergeHooks(parts: Partial<Hooks>[], policy: ToolPolicy = EMPTY_POLICY): Hooks {
-  const merged: Record<string, unknown> = {}
-  const tools: Record<string, unknown> = {}
-  const { rename, withheld } = policy
-
-  for (const part of parts) {
-    for (const [key, value] of Object.entries(part)) {
-      if (value === undefined) continue
-      if (key === "tool") {
-        const renaming = Object.keys(rename).length > 0
-        for (const [declared, def] of Object.entries(value as Record<string, unknown>)) {
-          // Withheld = no allowlist slot. Dropping it here is the point: one unlisted name
-          // makes the gateway reject the whole request, so the rest of the plugin still works.
-          if (withheld.has(declared)) continue
-          const name = rename[declared] ?? declared
-          if (tools[name]) console.warn(`[overclock] tool collision: ${name} (later module wins)`)
-          const d = def as { description?: unknown }
-          // Clone rather than mutate: the module owns its tool objects and may hold the
-          // same reference elsewhere.
-          tools[name] =
-            renaming && typeof d.description === "string"
-              ? { ...d, description: renameInText(d.description, rename) }
-              : def
-        }
-        continue
-      }
-      const prev = merged[key] as ((...a: unknown[]) => Promise<void>) | undefined
-      const next = value as (...a: unknown[]) => Promise<void>
-      merged[key] = prev
-        ? async (...args: unknown[]) => {
-            await prev(...args)
-            await next(...args)
-          }
-        : next
-    }
-  }
-
-  if (Object.keys(tools).length) merged.tool = tools
-  return merged as Hooks
-}
+export { mergeHooks } from "./core/lifecycle.ts"
+export { applyToolPolicy, EMPTY_POLICY, renameInText, type ToolPolicy } from "./core/policy.ts"

package/src/platform/probe.ts

@@ -0,0 +1,25 @@
+/**
+ * Runtime surface probe (doc: "probe for the surfaces we depend on ... instead of
+ * failing silently when upstream moves"). Dot-paths resolved against the SDK client;
+ * leaf must be a function by default.
+ */
+export function missingSurfaces(
+  client: unknown,
+  paths: string[],
+  requiredType: "function" | "object" | "defined" = "function",
+): string[] {
+  return paths.filter((path) => {
+    let node: unknown = client
+    for (const key of path.split(".")) {
+      if (node == null || typeof node !== "object") return true
+      try {
+        node = (node as Record<string, unknown>)[key]
+      } catch {
+        return true
+      }
+    }
+    if (requiredType === "function") return typeof node !== "function"
+    if (requiredType === "object") return node === null || typeof node !== "object"
+    return node === undefined
+  })
+}

package/src/platform/process/exec.ts

@@ -0,0 +1,317 @@
+/**
+ * POSIX single-quote escape for safe shell argument interpolation.
+ */
+export function shellQuote(s: string): string {
+  return `'${s.replace(/'/g, `'\\''`)}'`
+}
+
+export const NON_INTERACTIVE_ENV: Record<string, string> = {
+  GIT_PAGER: "cat",
+  PAGER: "cat",
+  GIT_EDITOR: "true",
+  CI: "true",
+  DEBIAN_FRONTEND: "noninteractive",
+  TERM: "dumb",
+}
+
+/**
+ * Pattern matching environment variable names that typically store credentials,
+ * secrets, authentication tokens, API keys, or private keys.
+ */
+export const SENSITIVE_ENV_PATTERN =
+  /(?:KEY|SECRET|TOKEN|AUTH|PASS(?:WORD|WD)?|CREDENTIAL|PRIVATE|SIGNING|DATABASE_URL|WEBHOOK|CERT|BEARER|COOKIE)/i
+
+/**
+ * Known system and transport variables that match sensitive keywords but are
+ * necessary for everyday development operations (SSH agent socket, TLS certificates).
+ */
+export const DEFAULT_PRESERVED_ENV: readonly string[] = [
+  "SSH_AUTH_SOCK",
+  "SSL_CERT_FILE",
+  "SSL_CERT_DIR",
+  "NODE_EXTRA_CA_CERTS",
+  "GIT_SSH_COMMAND",
+]
+
+/**
+ * Filter an environment map to remove sensitive keys (API keys, secrets, tokens).
+ * Safe system and build variables (PATH, HOME, USER, SHELL, TEMP, LANG, etc.)
+ * as well as essential operational credentials (SSH_AUTH_SOCK, certificates) are preserved.
+ */
+export function sanitizeEnv(
+  env: Record<string, string | undefined>,
+  allowlist?: string[],
+): Record<string, string | undefined> {
+  const allowed = new Set([
+    ...DEFAULT_PRESERVED_ENV.map((k) => k.toUpperCase()),
+    ...(allowlist?.map((k) => k.toUpperCase()) ?? []),
+  ])
+  const sanitized: Record<string, string | undefined> = {}
+
+  for (const [key, value] of Object.entries(env)) {
+    if (value === undefined) continue
+    if (allowed.has(key.toUpperCase())) {
+      sanitized[key] = value
+      continue
+    }
+    if (SENSITIVE_ENV_PATTERN.test(key)) {
+      continue
+    }
+    sanitized[key] = value
+  }
+
+  return sanitized
+}
+
+/**
+ * Common regex patterns for tokens, API keys, private keys, and credential formats.
+ */
+export const SENSITIVE_OUTPUT_PATTERNS: { pattern: RegExp; replacement: string }[] = [
+  // Private keys
+  {
+    pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+    replacement: "[REDACTED_PRIVATE_KEY]",
+  },
+  // JWT tokens
+  {
+    pattern: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+\b/g,
+    replacement: "[REDACTED_JWT]",
+  },
+  // Bearer tokens
+  {
+    pattern: /\bBearer\s+[A-Za-z0-9_\-\.~+/]+=*/gi,
+    replacement: "Bearer [REDACTED_TOKEN]",
+  },
+  // OpenAI / Anthropic / AI vendor keys
+  {
+    pattern: /\b(?:sk|ant)-[a-zA-Z0-9_\-]{20,}\b/g,
+    replacement: "[REDACTED_API_KEY]",
+  },
+  // GitHub tokens (classic, fine-grained PATs, OAuth)
+  {
+    pattern: /\b(?:gh[pousr]_[A-Za-z0-9_]{36,255}|github_pat_[A-Za-z0-9_]{50,255})\b/g,
+    replacement: "[REDACTED_GITHUB_TOKEN]",
+  },
+  // AWS Access Key ID
+  {
+    pattern: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g,
+    replacement: "[REDACTED_AWS_KEY]",
+  },
+  // Passwords in URLs (e.g. postgres://user:pass@host)
+  {
+    pattern: /([a-zA-Z][a-zA-Z0-9+.-]*:\/\/[^/:]+:)[^/@\s]+(@)/g,
+    replacement: "$1[REDACTED_PASSWORD]$2",
+  },
+  // Authorization headers
+  {
+    pattern: /(Authorization:\s*(?:Basic|Bearer|Token)\s+)[^\r\n]+/gi,
+    replacement: "$1[REDACTED_AUTH]",
+  },
+  // Key / secret / token assignments in key-value output (e.g. api_key="secret", token: secret)
+  {
+    pattern:
+      /((?:api[_-]?key|secret|token|password|passwd)\s*[:=]\s*["']?)[A-Za-z0-9_\-\.~+/]{8,}(["']?)/gi,
+    replacement: "$1[REDACTED]$2",
+  },
+]
+
+/**
+ * Redacts sensitive tokens, API keys, credentials, and known environment secrets
+ * from output strings to prevent data leakage.
+ */
+export function redactSensitiveOutput(text: string, additionalSecrets?: string[]): string {
+  if (!text) return text
+
+  let redacted = text
+
+  // 1. Redact known secrets from process.env (values associated with sensitive keys, length >= 6)
+  const envSecrets: string[] = []
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value && value.length >= 6 && SENSITIVE_ENV_PATTERN.test(key)) {
+      envSecrets.push(value)
+    }
+  }
+
+  const allSecrets = [...envSecrets, ...(additionalSecrets ?? [])]
+  // Sort by length descending to match longest secrets first
+  allSecrets.sort((a, b) => b.length - a.length)
+
+  for (const secret of allSecrets) {
+    if (secret && secret.length >= 6 && redacted.includes(secret)) {
+      redacted = redacted.replaceAll(secret, "[REDACTED_SECRET]")
+    }
+  }
+
+  // 2. Redact pattern matches
+  for (const { pattern, replacement } of SENSITIVE_OUTPUT_PATTERNS) {
+    redacted = redacted.replace(pattern, replacement)
+  }
+
+  return redacted
+}
+
+/**
+ * Discover all descendant PIDs of a given process by inspecting the process tree.
+ */
+export async function getDescendantPids(rootPid: number): Promise<number[]> {
+  const pids: number[] = []
+  try {
+    const proc = Bun.spawn(["ps", "-A", "-o", "pid,ppid"], {
+      stdout: "pipe",
+      stderr: "ignore",
+    })
+    const text = await new Response(proc.stdout).text()
+    await proc.exited
+
+    const parentMap = new Map<number, number[]>()
+    for (const line of text.trim().split("\n").slice(1)) {
+      const parts = line.trim().split(/\s+/)
+      if (parts.length >= 2) {
+        const pid = Number(parts[0])
+        const ppid = Number(parts[1])
+        if (!isNaN(pid) && !isNaN(ppid)) {
+          if (!parentMap.has(ppid)) parentMap.set(ppid, [])
+          parentMap.get(ppid)!.push(pid)
+        }
+      }
+    }
+
+    const queue = [rootPid]
+    while (queue.length > 0) {
+      const curr = queue.shift()!
+      const children = parentMap.get(curr) ?? []
+      for (const child of children) {
+        pids.push(child)
+        queue.push(child)
+      }
+    }
+  } catch {}
+  return pids
+}
+
+/**
+ * Kill a process and its child processes recursively on POSIX systems.
+ */
+export async function killProcessTree(
+  target: Bun.Subprocess | number,
+  signal: "SIGTERM" | "SIGKILL" = "SIGTERM",
+): Promise<void> {
+  const pid = typeof target === "number" ? target : target.pid
+  if (!pid) return
+
+  // 1. Gather all descendants in the process tree before sending signals
+  const descendants = await getDescendantPids(pid)
+
+  // 2. Try killing process group in case target is a process group leader
+  try {
+    process.kill(-pid, signal)
+  } catch {}
+
+  // 3. Kill all descendants (leaves first by iterating in reverse)
+  for (let i = descendants.length - 1; i >= 0; i--) {
+    try {
+      process.kill(descendants[i]!, signal)
+    } catch {}
+  }
+
+  // 4. Fallback pkill -P for any newly spawned direct children
+  try {
+    const pkill = Bun.spawn(["pkill", `-${signal === "SIGKILL" ? "KILL" : "TERM"}`, "-P", String(pid)], {
+      stdout: "ignore",
+      stderr: "ignore",
+    })
+    await pkill.exited
+  } catch {}
+
+  // 5. Kill the root process
+  try {
+    if (typeof target === "number") {
+      process.kill(pid, signal)
+    } else {
+      target.kill(signal)
+    }
+  } catch {}
+}
+
+export interface ExecBashOptions {
+  cwd?: string
+  env?: Record<string, string | undefined>
+  timeoutMs?: number
+  onSpawn?: (proc: Bun.Subprocess) => void
+  /**
+   * If true (default), sensitive environment variables (API keys, secrets, tokens)
+   * are scrubbed from process.env before spawning child processes.
+   */
+  sanitizeEnv?: boolean
+  /**
+   * Specific variable names to keep even if they match sensitive patterns.
+   */
+  envAllowlist?: string[]
+}
+
+export interface ExecBashResult {
+  code: number | null
+  stdout: string
+  stderr: string
+  combined: string
+}
+
+/**
+ * Run a command via `bash -c`, capturing stdout, stderr, and exit code.
+ * Ensures non-interactive environment variables with correct precedence,
+ * environment sanitization against secret leakage, and process termination escalation.
+ */
+export async function execBash(command: string, options: ExecBashOptions = {}): Promise<ExecBashResult> {
+  const baseEnv =
+    options.sanitizeEnv === false ? process.env : sanitizeEnv(process.env, options.envAllowlist)
+
+  const mergedEnv: Record<string, string | undefined> = {
+    ...baseEnv,
+    ...NON_INTERACTIVE_ENV,
+    ...options.env,
+  }
+
+  const proc = Bun.spawn(["bash", "-c", command], {
+    cwd: options.cwd,
+    env: mergedEnv,
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+  options.onSpawn?.(proc)
+
+  let killEscalationTimer: ReturnType<typeof setTimeout> | undefined
+  const killTimer = options.timeoutMs
+    ? setTimeout(() => {
+        void killProcessTree(proc, "SIGTERM")
+        killEscalationTimer = setTimeout(() => {
+          void killProcessTree(proc, "SIGKILL")
+        }, 2000)
+        killEscalationTimer.unref?.()
+      }, options.timeoutMs)
+    : undefined
+
+  // Protect against pipe leaks when background child processes keep stdout/stderr open
+  const streamTimeoutMs = options.timeoutMs ? options.timeoutMs + 2500 : undefined
+  const readStreamWithTimeout = (stream: ReadableStream, timeoutMs?: number): Promise<string> => {
+    const readPromise = new Response(stream).text().catch(() => "")
+    if (!timeoutMs) return readPromise
+    let timer: ReturnType<typeof setTimeout>
+    return Promise.race([
+      readPromise,
+      new Promise<string>((resolve) => {
+        timer = setTimeout(() => resolve(""), timeoutMs)
+      }),
+    ]).finally(() => clearTimeout(timer))
+  }
+
+  const [stdout, stderr, code] = await Promise.all([
+    readStreamWithTimeout(proc.stdout, streamTimeoutMs),
+    readStreamWithTimeout(proc.stderr, streamTimeoutMs),
+    proc.exited,
+  ])
+
+  if (killTimer) clearTimeout(killTimer)
+  if (killEscalationTimer) clearTimeout(killEscalationTimer)
+
+  return { code, stdout, stderr, combined: stdout + stderr }
+}

package/src/platform/process/tmux.ts

@@ -0,0 +1,60 @@
+export interface TmuxPane {
+  paneId: string
+  close: () => Promise<void>
+}
+
+/** Check if current process is running inside a tmux session. */
+export function isInsideTmux(): boolean {
+  return Boolean(process.env.TMUX)
+}
+
+/**
+ * Spawns a background tmux split pane tailing the task log file.
+ * Uses `-d` to avoid stealing terminal focus.
+ * Uses positional parameters to prevent shell injection via title formatting.
+ */
+export async function spawnTaskPane(logPath: string, title?: string): Promise<TmuxPane | null> {
+  if (!isInsideTmux()) return null
+  try {
+    const args = title
+      ? [
+          "tmux",
+          "split-window",
+          "-d",
+          "-P",
+          "-F",
+          "#{pane_id}",
+          "bash",
+          "-c",
+          'printf "=== [%s] ===\\n" "$1" && exec tail -f "$2"',
+          "_",
+          title,
+          logPath,
+        ]
+      : ["tmux", "split-window", "-d", "-P", "-F", "#{pane_id}", "tail", "-f", logPath]
+
+    const proc = Bun.spawn(args, { stdout: "pipe", stderr: "pipe" })
+    const [stdout, code] = await Promise.all([new Response(proc.stdout).text(), proc.exited])
+    if (code !== 0) return null
+
+    const paneId = stdout.trim()
+    if (!paneId.startsWith("%")) return null
+
+    return {
+      paneId,
+      close: async () => {
+        try {
+          const killProc = Bun.spawn(["tmux", "kill-pane", "-t", paneId], {
+            stdout: "ignore",
+            stderr: "ignore",
+          })
+          await killProc.exited
+        } catch {
+          // Pane might have been manually closed by user
+        }
+      },
+    }
+  } catch {
+    return null
+  }
+}