@agfpd/iapeer 0.4.66 → 0.4.68

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.66",
+  "version": "0.4.68",
   "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/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

@@ -100,9 +100,10 @@ export function buildPluginShim(binPath: string): string {
     '# <xbar.author>iapeer</xbar.author>',
     '# <xbar.desc>iapeer multi-agent fleet — live peer dashboard over the daemon fleet API.</xbar.desc>',
     '# <swiftbar.type>streamable</swiftbar.type>',
-    '# <swiftbar.hideRunInTerminal>true</swiftbar.hideRunInTerminal>',
-    '# <swiftbar.hideLastUpdated>true</swiftbar.hideLastUpdated>',
-    '# <swiftbar.hideDisablePlugin>true</swiftbar.hideDisablePlugin>',
+    // NB: deliberately NOT hiding SwiftBar's own service items (Run-in-Terminal /
+    // Disable / Last-Updated / Preferences / Refresh). They are the right-click "do
+    // stuff" menu the owner expects; hiding them made the icon feel dead. Minimalism is
+    // for OUR content (status + peer rows), not SwiftBar's utility menu.
     // 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
@@ -259,6 +260,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,17 +149,25 @@ 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 ──
+  // No explicit "Refresh" item: the plugin is streamable + SSE-driven, so the menu is
+  // always current on open — a manual refresh gives the user nothing and (being a
+  // SwiftBar refresh) just closes the dropdown. The emergency "restart the plugin" lever
+  // lives in SwiftBar's own service menu (right-click → Refresh).
   lines.push('---')
-  lines.push(line(0, 'Refresh', { refresh: true, sfimage: 'arrow.clockwise' }))
   lines.push(line(0, `iapeer · fleet dashboard`, { color: COLOR.meta, size: 11 }))
   return lines.join('\n') + '\n'
 }
@@ -184,7 +187,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 +213,31 @@ 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) {
+      // No refresh=true: the SSE stream reflects the command's lifecycle event on its
+      // own (streamable is always fresh); a refresh would only restart the stream.
+      out.push(
+        line(2, c.label, {
+          bash: bin,
+          param1: 'tray',
+          param2: 'cmd',
+          param3: c.cmd,
+          param4: p.personality,
+          terminal: false,
+        }),
+      )
+    }
   }
   return out
 }