@agfpd/iapeer 0.4.65 → 0.4.67

package/docs/16-tray.md

@@ -26,17 +26,25 @@ activation that also installs SwiftBar.app when it is absent.
     `●` live · `○` asleep · `✕` stopped — green when any runtime is live. Badges: `👤`
     a human is attached, `🔒` launchd-managed (H4 read-only), `⏳N` an ephemeral peer's
     queue depth.
-  - **Click a peer → Terminal.app running `iapeer attach <peer>`.** Attach is a terminal
-    handoff the API deliberately keeps client-side (a PTY inside a GUI is out of scope);
-    the same row's submenu carries the lifecycle actions (Wake / Stop / Start / New /
-    Interrupt / Refresh / Compact), each a `POST /fleet/v1/peers/<peer>/<cmd>` via
-    `iapeer tray cmd`.
+  - **Click an agent peer → Terminal.app running `iapeer attach <peer>`.** The row itself is
+    the attach action (no submenu, so a click attaches rather than merely expanding). The
+    handoff goes through `iapeer tray attach-term`, which writes a per-peer `.command`
+    launcher and `open`s it — `open <file>.command` hands the file to Terminal.app with
+    **no Automation/Accessibility permission prompt**. This deliberately avoids SwiftBar's
+    own `terminal=true`, whose Terminal launch drives a `Cmd-T` System-Events keystroke that
+    silently no-ops unless SwiftBar holds Accessibility permission. **Launchd-managed infra
+    peers (telegram / notifier, `🔒`) are not pty-attachable** — their rows are plain status
+    lines. Lifecycle actions (Wake / Stop / Start / New / Interrupt / Refresh / Compact) live
+    in the **Manage** submenu, each a `POST /fleet/v1/peers/<peer>/<cmd>` via `iapeer tray cmd`.
 
 The list updates itself: the plugin is **streamable** — it subscribes to the event stream
 and re-fetches the snapshot on every change (a peer waking, an operator stop/start, a
-death), coalescing bursts. A ~15 s heartbeat keeps ages fresh and self-heals a missed
-event; the stream reconnects across daemon restarts. No manual refresh needed (there is a
-Refresh item anyway).
+death), coalescing bursts. A heartbeat keeps ages fresh and self-heals a missed event; the
+stream reconnects across daemon restarts. Every emitted menu block is prefixed with the
+`~~~` stream separator (SwiftBar's default leading-separator mode = replace), including the
+first — otherwise a manual Refresh, which `terminate()`s and re-`invoke()`s the plugin
+without clearing SwiftBar's held content, would append the restarted block and render the
+whole dashboard twice.
 
 ## Verbs
 

package/docs/ru/16-tray.md

@@ -25,15 +25,23 @@ SwiftBar.app, если его нет.
     `●` живой · `○` спит · `✕` остановлен — зелёный, если хоть один рантайм живой. Бейджи:
     `👤` подключён человек, `🔒` под launchd (H4 read-only), `⏳N` глубина очереди эфемерного
     пира.
-  - **Клик по пиру → Terminal.app с `iapeer attach <peer>`.** Attach — терминальная передача,
-    которую API намеренно оставляет клиенту (PTY внутри GUI вне рамок); подменю той же строки
-    несёт lifecycle-действия (Wake / Stop / Start / New / Interrupt / Refresh / Compact),
-    каждое — `POST /fleet/v1/peers/<peer>/<cmd>` через `iapeer tray cmd`.
+  - **Клик по агент-пиру → Terminal.app с `iapeer attach <peer>`.** Строка сама и есть действие
+    attach (без подменю — клик аттачит, а не раскрывает). Передача идёт через `iapeer tray
+    attach-term`: пишет per-peer `.command`-лаунчер и `open`'ит его — `open <файл>.command`
+    отдаёт файл Terminal.app **без запроса Automation/Accessibility**. Это намеренно обходит
+    родной `terminal=true` SwiftBar, чей запуск Terminal бьёт `Cmd-T` кейстроком через System
+    Events и молча не срабатывает без права Accessibility у SwiftBar. **Launchd-инфра-пиры
+    (telegram / notifier, `🔒`) не pty-аттачатся** — их строки просто статус. Lifecycle-действия
+    (Wake / Stop / Start / New / Interrupt / Refresh / Compact) — в подменю **Manage**, каждое —
+    `POST /fleet/v1/peers/<peer>/<cmd>` через `iapeer tray cmd`.
 
 Список обновляется сам: плагин **streamable** — подписан на поток событий и перечитывает
 снапшот на каждое изменение (пробуждение пира, стоп/старт оператором, смерть), склеивая
-всплески. Хартбит ~15 с держит возрасты свежими и самозалечивает пропущенное событие; поток
-переподключается через рестарты демона. Ручной refresh не нужен (пункт Refresh всё же есть).
+всплески. Хартбит держит возрасты свежими и самозалечивает пропущенное событие; поток
+переподключается через рестарты демона. Каждый выдаваемый блок меню предваряется сепаратором
+`~~~` (дефолтный leading-режим SwiftBar = замена), включая первый — иначе ручной Refresh,
+который `terminate()`'ит и заново `invoke()`'ит плагин НЕ очищая удерживаемый SwiftBar контент,
+пришил бы перезапущенный блок и отрисовал бы весь дашборд дважды.
 
 ## Verb'ы
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.4.65",
+  "version": "0.4.67",
   "description": "Run Claude Code and Codex CLI as local background agents that message each other, wake on demand, and share one memory.",
   "license": "Apache-2.0",
   "author": "agfpd",

package/src/cli/index.ts

@@ -2505,6 +2505,21 @@ export async function runCli(argv: string[], env: NodeJS.ProcessEnv = process.en
             out(await tray.renderTrayOnce(env))
             return 0
           }
+          case 'attach-term': {
+            // Terminal handoff for a tray click: open a system Terminal running
+            // `iapeer attach <peer>` via an `open`ed `.command` (no Accessibility/
+            // Automation TCC — unlike SwiftBar's own terminal=true).
+            const peer = positionals[1]
+            if (!peer) return argErr(errOut, 'usage: iapeer tray attach-term <peer> [runtime]')
+            try {
+              const r = tray.trayAttachTerm({ env, personality: peer, runtime: positionals[2] })
+              out(`opening Terminal → iapeer attach ${peer} (${r.cmdFile})\n`)
+            } catch (e) {
+              errOut(`tray attach-term: ${e instanceof Error ? e.message : String(e)}\n`)
+              return 1
+            }
+            return 0
+          }
           case 'cmd': {
             const command = positionals[1]
             const peer = positionals[2]

package/src/daemon/index.ts

@@ -351,6 +351,26 @@ export function daemonDiscoveryPath(options: StorageOptions = {}): string {
   return join(pluginStateDir('iapeer', options), 'router.json')
 }
 
+/**
+ * Normalize an HTTP request-target to origin-form (path[+query]) for path routing.
+ * A request that traversed an HTTP proxy arrives in ABSOLUTE-FORM (RFC 7230 §5.3.2:
+ * "GET http://host/path"), and Node exposes the whole target as `req.url` — so a
+ * path check like `req.url.startsWith('/fleet/')` misses and the request wrongly
+ * falls to the MCP catch-all (→ 406). Any client with HTTP(S)_PROXY set is affected
+ * (Bun's fetch proxies loopback even when NO_PROXY lists 127.0.0.1). Origin-form and
+ * unparseable targets pass through unchanged. Exported for tests. */
+export function normalizeRequestTarget(url: string | undefined): string | undefined {
+  if (url && /^https?:\/\//i.test(url)) {
+    try {
+      const u = new URL(url)
+      return u.pathname + u.search
+    } catch {
+      /* unparseable — leave as received */
+    }
+  }
+  return url
+}
+
 export interface DaemonHandle {
   socketPath?: string
   host?: string
@@ -498,6 +518,18 @@ export async function startDaemon(opts: StartDaemonOptions = {}): Promise<Daemon
   // gate first, then the fleet-API branch (when wired), then stateless MCP —
   // a fresh Server + transport per request, fully isolated.
   const handle = (req: IncomingMessage, res: ServerResponse): void => {
+    // RFC 7230 §5.3.2 request-target hygiene (FIRST — before ANY path routing). A
+    // request that traversed an HTTP proxy carries the ABSOLUTE-FORM target
+    // ("GET http://127.0.0.1:8765/fleet/v1/snapshot"), and Node puts that whole string
+    // in req.url — so path routing (/fleet vs /mcp) would miss and fall through to MCP
+    // (→ a 406 "must accept text/event-stream" for a plain GET). This bites any client
+    // whose environment has HTTP(S)_PROXY set: Bun's fetch (and others) route loopback
+    // through the proxy even when NO_PROXY lists 127.0.0.1 (Bun ignores NO_PROXY). We
+    // can't fix every client, so the daemon normalizes to origin-form here — a proxied
+    // request then routes identically to a direct one, for BOTH the fleet and MCP
+    // surfaces. (live-proven: HTTP_PROXY pointed at the daemon itself reproduced the
+    // 406; normalization restores /fleet routing.)
+    req.url = normalizeRequestTarget(req.url)
     // H8 bearer layer (FIRST, before any MCP/fleet work): when a token is configured,
     // reject anything not carrying `Authorization: Bearer <token>`. Off when unset.
     if (bearer && req.headers.authorization !== `Bearer ${bearer}`) {

package/src/tray/client.ts

@@ -80,6 +80,7 @@ export class FleetUnreachableError extends Error {
 }
 
 interface FetchAttempt {
+  transport: 'unix' | 'tcp'
   url: string
   init: RequestInit & { unix?: string }
 }
@@ -89,36 +90,66 @@ interface FetchAttempt {
 function attempts(addr: FleetAddress, path: string, base: RequestInit, env: NodeJS.ProcessEnv): FetchAttempt[] {
   const headers = { ...(base.headers as Record<string, string> | undefined), ...bearerHeader(env) }
   const list: FetchAttempt[] = []
-  if (addr.sock) list.push({ url: `http://iapeer${path}`, init: { ...base, headers, unix: addr.sock } })
-  if (addr.tcp) list.push({ url: `${addr.tcp}${path}`, init: { ...base, headers } })
+  if (addr.sock) list.push({ transport: 'unix', url: `http://iapeer${path}`, init: { ...base, headers, unix: addr.sock } })
+  if (addr.tcp) list.push({ transport: 'tcp', url: `${addr.tcp}${path}`, init: { ...base, headers } })
   return list
 }
 
+function debug(env: NodeJS.ProcessEnv, msg: string): void {
+  if (env.IAPEER_TRAY_DEBUG === '1') process.stderr.write(`[tray] ${msg}\n`)
+}
+
+/** The response of a fleet request, carrying the ACTUAL wire transport + URL used —
+ *  so a failure surfaces where the request really went (a proxied request lands on a
+ *  different route than the client's intended path). */
+export interface FleetResponse {
+  res: Response
+  transport: string
+  url: string
+}
+
+/**
+ * Try each transport (unix first, TCP second) until one answers. On a THROW, move to
+ * the next transport. On a NON-OK status the behavior depends on `retryBadStatus`:
+ * GETs (idempotent) retry on the OTHER transport (a single misrouting transport — e.g.
+ * one behind a proxy — cannot then sink the client); POSTs do NOT (never re-execute a
+ * command). Returns the actual transport+URL for honest diagnostics.
+ */
 async function fetchFleet(
   addr: FleetAddress,
   path: string,
   init: RequestInit,
   env: NodeJS.ProcessEnv,
-): Promise<Response> {
+  opts: { retryBadStatus?: boolean } = {},
+): Promise<FleetResponse> {
   const tries = attempts(addr, path, init, env)
   if (tries.length === 0) throw new FleetUnreachableError('no advertised address (router.json missing sock/tcp)')
   let lastErr = ''
+  let firstBad: FleetResponse | undefined
   for (const a of tries) {
+    let res: Response
     try {
-      const res = await fetch(a.url, a.init as RequestInit)
-      return res
+      res = await fetch(a.url, a.init as RequestInit)
     } catch (e) {
       lastErr = e instanceof Error ? e.message : String(e)
-      // try the next transport
+      debug(env, `${a.transport} ${a.url} → THREW ${lastErr}`)
+      continue
     }
+    debug(env, `${a.transport} ${a.url} → ${res.status}`)
+    const wrapped: FleetResponse = { res, transport: a.transport, url: a.url }
+    if (res.ok) return wrapped
+    if (!firstBad) firstBad = wrapped
+    if (!opts.retryBadStatus) return wrapped // POST: return the error as-is (no re-execute)
+    // GET: fall through to the next transport; firstBad is returned if none succeed
   }
-  throw new FleetUnreachableError(lastErr || 'all transports failed')
+  if (firstBad) return firstBad
+  throw new FleetUnreachableError(`${lastErr || 'all transports failed'} (tried ${tries.map(t => `${t.transport}=${t.url}`).join(', ')})`)
 }
 
 export async function fleetGetJson<T = unknown>(addr: FleetAddress, path: string, env: NodeJS.ProcessEnv): Promise<T> {
-  const res = await fetchFleet(addr, path, { method: 'GET' }, env)
+  const { res, transport, url } = await fetchFleet(addr, path, { method: 'GET' }, env, { retryBadStatus: true })
   const text = await res.text()
-  if (!res.ok) throw new Error(`GET ${path} → ${res.status}: ${text.slice(0, 300)}`)
+  if (!res.ok) throw new Error(`GET ${url} (${transport}) → ${res.status}: ${text.slice(0, 300)}`)
   return JSON.parse(text) as T
 }
 
@@ -128,11 +159,12 @@ export async function fleetPostJson<T = unknown>(
   body: Record<string, unknown>,
   env: NodeJS.ProcessEnv,
 ): Promise<{ status: number; body: T }> {
-  const res = await fetchFleet(
+  const { res } = await fetchFleet(
     addr,
     path,
     { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) },
     env,
+    { retryBadStatus: false }, // a command must never re-execute on the other transport
   )
   const text = await res.text()
   let parsed: T
@@ -170,13 +202,14 @@ export async function streamFleetEvents(
   opts: { replay?: number; signal?: AbortSignal; env: NodeJS.ProcessEnv },
 ): Promise<void> {
   const replay = Math.max(0, Math.min(500, opts.replay ?? 0))
-  const res = await fetchFleet(
+  const { res, transport, url } = await fetchFleet(
     addr,
     `/fleet/v1/events?replay=${replay}`,
     { method: 'GET', headers: { accept: 'text/event-stream' }, signal: opts.signal },
     opts.env,
+    { retryBadStatus: true },
   )
-  if (!res.ok || !res.body) throw new Error(`events stream → ${res.status}`)
+  if (!res.ok || !res.body) throw new Error(`events stream ${url} (${transport}) → ${res.status}`)
   const reader = res.body.getReader()
   const decoder = new TextDecoder()
   let buf = ''

package/src/tray/index.ts

@@ -72,14 +72,20 @@ export async function streamTray(
   out: (s: string) => void = s => process.stdout.write(s),
   signal?: AbortSignal,
 ): Promise<void> {
-  let first = true
   // Serialize all emits through a promise chain so a `~~~`+block is never interleaved.
   let chain: Promise<void> = Promise.resolve()
   const emit = (): Promise<void> => {
     chain = chain.then(async () => {
       const block = await renderTrayOnce(env)
-      out(first ? block : `~~~\n${block}`)
-      first = false
+      // EVERY block — including the first — is prefixed with the `~~~` stream separator.
+      // SwiftBar's default (leading-separator) handler sets content = <text after the
+      // last ~~~>, i.e. REPLACE; a block WITHOUT a leading ~~~ is APPENDED to the
+      // current content. On a refresh (SwiftBar terminate()s the process WITHOUT
+      // clearing content, then re-invoke()s), the restarted process's first block would
+      // otherwise append to the stale pre-refresh menu → the whole dashboard renders
+      // twice. Always leading with ~~~ makes every emit a clean replace. (root: SwiftBar
+      // v2.0.1 StreamablePlugin.onOutputUpdate.)
+      out(`~~~\n${block}`)
     })
     return chain
   }

package/src/tray/install.ts

@@ -69,7 +69,17 @@ function setSwiftBarPluginDir(dir: string, run: Runner): RunResult {
 }
 
 function installSwiftBarApp(run: Runner): RunResult {
-  return run('brew', ['install', '--cask', 'swiftbar'])
+  // --no-quarantine: an automated install has no one to click through the Gatekeeper
+  // "app downloaded from the Internet" dialog — quarantine would stall first launch.
+  return run('brew', ['install', '--cask', '--no-quarantine', 'swiftbar'])
+}
+
+/** Strip any residual quarantine xattr from the app (belt-and-suspenders: an already
+ *  brew-installed SwiftBar, or a brew that quarantined despite the flag, would else
+ *  block first launch on a headless / no-click box). Best-effort. */
+function dequarantineApp(run: Runner): void {
+  const app = SWIFTBAR_APP_PATHS.find(p => existsSync(p))
+  if (app) run('xattr', ['-dr', 'com.apple.quarantine', app])
 }
 
 function launchSwiftBar(run: Runner): void {
@@ -93,6 +103,11 @@ export function buildPluginShim(binPath: string): string {
     '# <swiftbar.hideRunInTerminal>true</swiftbar.hideRunInTerminal>',
     '# <swiftbar.hideLastUpdated>true</swiftbar.hideLastUpdated>',
     '# <swiftbar.hideDisablePlugin>true</swiftbar.hideDisablePlugin>',
+    // The dashboard ONLY ever talks to the local daemon (unix socket / loopback), so it
+    // must never route through an HTTP proxy. Bun's fetch caches proxy config at process
+    // start and ignores NO_PROXY for loopback, so clearing the vars must happen in the
+    // ENV before the binary launches (a runtime delete is too late). unset here.
+    'unset HTTP_PROXY HTTPS_PROXY http_proxy https_proxy ALL_PROXY all_proxy',
     `exec "${binPath}" tray render --stream`,
     '',
   ].join('\n')
@@ -195,6 +210,7 @@ export function installTray(opts: InstallTrayOptions = {}): InstallTrayResult {
   // 4 — launch + refresh
   let launched = false
   if (opts.launch && present) {
+    dequarantineApp(run)
     launchSwiftBar(run)
     refreshSwiftBar(run)
     launched = true
@@ -243,6 +259,36 @@ export function uninstallTray(
   return { removed, refreshed }
 }
 
+/**
+ * Open a system Terminal attached to a peer WITHOUT SwiftBar's `terminal=true`. SwiftBar
+ * v2's Terminal.app launch drives a `Cmd-T` keystroke via System Events, which silently
+ * no-ops unless SwiftBar holds Accessibility permission — so tray attach clicks appeared
+ * dead even after the Automation→Terminal grant. Instead: write a per-peer `.command`
+ * launcher and `open` it. `open <file>.command` hands the file to Terminal.app (its
+ * default handler) and runs it — a document-open, needing NO Automation/Accessibility
+ * TCC. This is the tray's terminal handoff (docs/15: attach is client-side). The peer
+ * name is validated (it is interpolated into a shell script). Returns the launcher path.
+ */
+export function trayAttachTerm(opts: {
+  env?: NodeJS.ProcessEnv
+  personality: string
+  runtime?: string
+  run?: Runner
+}): { cmdFile: string } {
+  const env = opts.env ?? process.env
+  const run = opts.run ?? defaultRun
+  const p = opts.personality
+  if (!/^[a-z][a-z0-9-]*$/.test(p)) throw new Error(`invalid peer name "${p}"`)
+  const rt = opts.runtime && /^[a-z][a-z0-9-]*$/.test(opts.runtime) ? opts.runtime : undefined
+  const binPath = iapeerBinPath(env)
+  const dir = join(resolveGlobalRoot(env), 'tray')
+  mkdirSync(dir, { recursive: true })
+  const cmdFile = join(dir, `attach-${p}.command`)
+  writeFileSync(cmdFile, `#!/bin/bash\nexec "${binPath}" attach ${p}${rt ? ` ${rt}` : ''}\n`, { mode: 0o755 })
+  run('open', [cmdFile])
+  return { cmdFile }
+}
+
 export interface TrayStatus {
   daemon: { fleet: boolean; version?: string; sock?: string; tcp?: string }
   swiftbar: { installed: boolean; pluginDir?: string }

package/src/tray/render.ts

@@ -79,11 +79,6 @@ function line(depth: number, text: string, p: Record<string, string | number | b
   return `${'--'.repeat(depth)}${text}${params(p)}`
 }
 
-/** A menu separator at submenu `depth`: the `--`×depth prefix + `---` (SwiftBar: a
- *  top-level separator is `---`, a depth-1 one is `-----`, etc.). */
-function separator(depth: number): string {
-  return `${'--'.repeat(depth)}---`
-}
 
 // ── time helpers ────────────────────────────────────────────────────────────────
 
@@ -154,14 +149,19 @@ export function renderSwiftBar(snapshot: TraySnapshot, opts: RenderOptions): str
   if (providers) lines.push(line(0, providers, { color: COLOR.meta }))
   lines.push('---')
 
-  // ── peers ──
+  // ── peers (each row is a DIRECT attach action — click → Terminal) ──
   if (peers.length === 0) {
     lines.push(line(0, 'no peers registered', { color: COLOR.meta }))
   }
   for (const p of peers) {
-    lines.push(...renderPeerRow(p, bin, now))
+    lines.push(renderPeerRow(p, bin, now))
   }
 
+  // ── Manage submenu (lifecycle commands per peer; kept off the rows so a row click
+  //    attaches instead of just expanding a submenu) ──
+  lines.push('---')
+  lines.push(...renderManage(peers, bin))
+
   // ── footer ──
   lines.push('---')
   lines.push(line(0, 'Refresh', { refresh: true, sfimage: 'arrow.clockwise' }))
@@ -184,7 +184,23 @@ function renderProviders(host: TraySnapshot['host']): string {
   return seg.join(' · ')
 }
 
-function renderPeerRow(p: TrayPeer, bin: string, now: number): string[] {
+/** A peer is attachable when it is NOT launchd-managed: launchd-owned infra peers
+ *  (telegram / notifier) have no attachable pty session, so their rows carry no attach
+ *  action (a plain status line). Agent peers (claude / codex) are attachable. */
+function attachable(p: TrayPeer): boolean {
+  return !p.launchd_managed
+}
+
+/**
+ * One peer row. For an ATTACHABLE peer the row IS a DIRECT attach action (no submenu,
+ * so a click attaches instead of merely expanding): clicking runs `iapeer tray
+ * attach-term <peer>` in the BACKGROUND (terminal=false), which opens a `.command` via
+ * `open` — a system-Terminal handoff that needs NO Accessibility/Automation TCC. This
+ * deliberately AVOIDS SwiftBar's own `terminal=true`, whose Terminal.app launch drives a
+ * `Cmd-T` System-Events keystroke that silently no-ops without Accessibility permission.
+ * Infra (launchd) rows are plain status lines. Lifecycle lives in the Manage submenu.
+ */
+function renderPeerRow(p: TrayPeer, bin: string, now: number): string {
   const agg = aggregate(p)
   const detail = p.runtimes.map(r => `${r.runtime}${GLYPH[r.status]}`).join(' ')
   const badges =
@@ -194,36 +210,30 @@ function renderPeerRow(p: TrayPeer, bin: string, now: number): string[] {
   const ageStr = p.last_active_ms ? `  ${fmtAge(p.last_active_ms, now)}` : ''
   const label = `${p.personality}  ${detail}${badges}${ageStr}`
   const rowColor = agg === 'live' ? COLOR.live : COLOR.meta
+  if (!attachable(p)) return line(0, label, { color: rowColor })
+  return line(0, label, { color: rowColor, bash: bin, param1: 'tray', param2: 'attach-term', param3: p.personality, terminal: false })
+}
 
-  const out: string[] = []
-  // The peer row IS the attach action: click → Terminal.app running `iapeer attach
-  // <peer>` (attach resolves its own runtime — default-anchored last-active, same as
-  // the CLI). terminal=true is the terminal-handoff docs/15 keeps client-side.
-  out.push(
-    line(0, label, {
-      color: rowColor,
-      bash: bin,
-      param1: 'attach',
-      param2: p.personality,
-      terminal: true,
-    }),
-  )
-  // Lifecycle controls live in a submenu (they route through the fleet command
-  // endpoints via `iapeer tray cmd …` — dogfooding POST /fleet/v1/peers/<p>/<cmd>).
-  out.push(line(1, 'Attach…', { bash: bin, param1: 'attach', param2: p.personality, terminal: true, sfimage: 'terminal' }))
-  out.push(separator(1))
-  for (const c of MANAGE_COMMANDS) {
-    out.push(
-      line(1, c.label, {
-        bash: bin,
-        param1: 'tray',
-        param2: 'cmd',
-        param3: c.cmd,
-        param4: p.personality,
-        terminal: false,
-        refresh: true,
-      }),
-    )
+/** The Manage submenu: one sub-submenu per peer with its lifecycle commands, each a
+ *  `iapeer tray cmd <c> <peer>` → POST /fleet/v1/peers/<peer>/<c> (terminal=false,
+ *  refresh to reflect the outcome). Kept OFF the peer rows so a row click attaches. */
+function renderManage(peers: TrayPeer[], bin: string): string[] {
+  const out: string[] = [line(0, 'Manage', { sfimage: 'slider.horizontal.3' })]
+  for (const p of peers) {
+    out.push(line(1, p.personality))
+    for (const c of MANAGE_COMMANDS) {
+      out.push(
+        line(2, c.label, {
+          bash: bin,
+          param1: 'tray',
+          param2: 'cmd',
+          param3: c.cmd,
+          param4: p.personality,
+          terminal: false,
+          refresh: true,
+        }),
+      )
+    }
   }
   return out
 }