@agfpd/iapeer 0.4.50 → 0.4.52

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.4.50",
+  "version": "0.4.52",
   "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/enable/index.ts

@@ -24,7 +24,7 @@ import { spawnSync } from 'child_process'
 import { existsSync, readFileSync, realpathSync } from 'fs'
 import { basename, join } from 'path'
 import { homedir } from 'os'
-import { MARKETPLACE_NAME, isMarketplaceRegisteredAs, refreshMarketplace, registerMarketplace } from '../onboard/index.ts'
+import { MARKETPLACE_NAME, isExecutable, isMarketplaceRegisteredAs, refreshMarketplace, registerMarketplace } from '../onboard/index.ts'
 import { findPeer, readPeersIndex } from '../registry/index.ts'
 import { IapError } from '../core/errors.ts'
 import { normalizeNameCandidate } from '../core/normalize.ts'
@@ -205,10 +205,14 @@ function resolvePeer(opts: EnableOptions): { personality: string; cwd: string; r
   return { personality, cwd: rec.cwd, runtimes: agentic }
 }
 
-function isExecutable(bin: string, env: NodeJS.ProcessEnv): boolean {
-  const r = spawnSync(bin, ['--version'], { stdio: 'ignore', env: env as Record<string, string> })
-  return r.error === undefined && r.status !== null
-}
+// В57 — the local `--version` ANSWER probe was removed: it spawned the runtime CLI with NO
+// timeout, so a wedged binary (the known macOS launch-approval park after a cask update —
+// onboard's live incident: probes sat 25+ min) hung `enable` forever. enable now uses
+// onboard's PRESENCE probe (accessSync X_OK / PATH scan — no spawn at all), and every real
+// runtime-CLI invocation below carries a hard timeout, mirroring onboard.
+const LIST_TIMEOUT_MS = 60_000 // read-only queries (plugin list)
+const MUTATE_TIMEOUT_MS = 120_000 // install / enable / add (may clone from GitHub)
+const SETUP_TIMEOUT_MS = 300_000 // a СЛОЖНЫЙ plugin's own installer — the longest legitimate leg
 
 /** Read the peer-scoped entry for this plugin from a fresh `claude plugin list --json`.
  *  CRITICAL: `enabled` is evaluated relative to the CURRENT cwd's project (verified
@@ -227,6 +231,7 @@ function claudeEntry(
     encoding: 'utf8',
     env: env as Record<string, string>,
     maxBuffer: 64 * 1024 * 1024,
+    timeout: LIST_TIMEOUT_MS,
   })
   return findPeerScopedEntry(parseInstalledPlugins(list.stdout ?? ''), plugin, marketplace, peerCwd)
 }
@@ -251,6 +256,7 @@ function enableClaude(plugin: string, marketplace: string, peerCwd: string, env:
       cwd: peerCwd,
       encoding: 'utf8',
       env: env as Record<string, string>,
+      timeout: MUTATE_TIMEOUT_MS,
     })
     if (inst.status !== 0) {
       return { runtime: 'claude', state: 'failed', detail: (inst.stderr || inst.stdout || `exit ${inst.status}`).trim() }
@@ -264,6 +270,7 @@ function enableClaude(plugin: string, marketplace: string, peerCwd: string, env:
       cwd: peerCwd,
       encoding: 'utf8',
       env: env as Record<string, string>,
+      timeout: MUTATE_TIMEOUT_MS,
     })
     const confirmed = claudeEntry(bin, plugin, marketplace, peerCwd, env)
     if (!confirmed?.enabled) {
@@ -300,7 +307,12 @@ export function parseCodexPluginStatus(jsonOutput: string, id: string): 'enabled
 }
 
 function codexState(bin: string, id: string, env: NodeJS.ProcessEnv): 'enabled' | 'disabled' | 'absent' {
-  const r = spawnSync(bin, ['plugin', 'list', '--json'], { encoding: 'utf8', env: env as Record<string, string>, maxBuffer: 64 * 1024 * 1024 })
+  const r = spawnSync(bin, ['plugin', 'list', '--json'], {
+    encoding: 'utf8',
+    env: env as Record<string, string>,
+    maxBuffer: 64 * 1024 * 1024,
+    timeout: LIST_TIMEOUT_MS,
+  })
   return parseCodexPluginStatus(r.stdout ?? '', id)
 }
 
@@ -314,7 +326,11 @@ function enableCodex(plugin: string, marketplace: string, env: NodeJS.ProcessEnv
   const id = `${plugin}@${marketplace}`
   const before = codexState(bin, id, env)
   if (before === 'enabled') return { runtime: 'codex', state: 'already-enabled' }
-  const add = spawnSync(bin, ['plugin', 'add', id], { encoding: 'utf8', env: env as Record<string, string> })
+  const add = spawnSync(bin, ['plugin', 'add', id], {
+    encoding: 'utf8',
+    env: env as Record<string, string>,
+    timeout: MUTATE_TIMEOUT_MS,
+  })
   if (add.status !== 0) {
     return { runtime: 'codex', state: 'failed', detail: (add.stderr || add.stdout || `exit ${add.status}`).trim() }
   }
@@ -346,6 +362,7 @@ function callSetup(
     cwd: installPath,
     encoding: 'utf8',
     env: setupEnv as Record<string, string>,
+    timeout: SETUP_TIMEOUT_MS,
   })
   if (r.error || (r.status ?? 1) !== 0) {
     return { ok: false, detail: (r.stderr || r.stdout || r.error?.message || `exit ${r.status}`).trim() }

package/src/identity/index.ts

@@ -120,6 +120,12 @@ export interface EnsurePeerProfileOptions {
    *  always-on plist so launchd's minimal PATH resolves it. Forwarded to
    *  installAlwaysOnPlist; ignored for warm-on-demand runtimes. */
   runtimeBin?: string
+  /** В36 — peer description, persisted into the LOCAL profile (the source of truth the
+   *  registry is reindexed FROM). Writing it only to the registry made it a stale copy:
+   *  the first reindexFromLocals (addRuntime on a dual-runtime create, connect telegram,
+   *  verify --fix) projected the profile's empty description over it, wiping the Layer-3
+   *  addressing signal fleet-wide. */
+  description?: string
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -513,7 +519,9 @@ export function ensurePeerProfile(options: EnsurePeerProfileOptions): PeerProfil
       personality,
       runtime: options.runtime,
       runtimes: discoveredRuntimes,
-      description: '',
+      // В36 — the description lands in the LOCAL profile at birth (source of truth);
+      // the registry row is a projection of this file, not the other way around.
+      description: options.description?.trim() ?? '',
       intelligence: defaultIntelligenceForRuntime(options.runtime),
     }
     ensureLocalRuntimeScopes(cwd, profile.runtimes)
@@ -573,8 +581,17 @@ export function ensurePeerProfile(options: EnsurePeerProfileOptions): PeerProfil
     })
     intelligence = defaultIntelligenceForRuntime(options.runtime)
   }
-  if (mergedRuntimes.length !== existing.runtimes.length || intelligence !== existing.intelligence) {
-    const updated = { ...existing, runtimes: mergedRuntimes, intelligence }
+  // В36 — an explicit description on RE-provision updates the local profile too (H1 in
+  // writePeerProfileAtomic still guards: absent/empty never wipes an existing value).
+  const explicitDescription = options.description?.trim()
+  const descriptionChanged = Boolean(explicitDescription) && explicitDescription !== existing.description
+  if (mergedRuntimes.length !== existing.runtimes.length || intelligence !== existing.intelligence || descriptionChanged) {
+    const updated = {
+      ...existing,
+      runtimes: mergedRuntimes,
+      intelligence,
+      ...(descriptionChanged ? { description: explicitDescription! } : {}),
+    }
     writePeerProfileAtomic(cwd, updated)
     return updated
   }

package/src/launch/invocation.ts

@@ -50,7 +50,13 @@ export function buildLaunchInvocation(
     PEER_PERSONALITY: spec.personality,
     PEER_RUNTIME: spec.runtime,
     PEER_IDENTITY: spec.identity,
-    PATH: env.PATH ?? `${homedir()}/.bun/bin:${homedir()}/.local/bin:/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:/usr/bin:/bin`,
+    // В45 — a per-peer launch.env PATH override WINS: this literal sits after the launchEnv
+    // spread, so `env.PATH ?? default` silently clobbered the operator's override (env.PATH
+    // is nearly always set). The legacy launcher sourced the file — there PATH took effect.
+    PATH:
+      launchEnv.env.PATH ??
+      env.PATH ??
+      `${homedir()}/.bun/bin:${homedir()}/.local/bin:/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:/usr/bin:/bin`,
   }
   // Strip the claude-code-internal session namespace from the inherited env. When a launch is
   // INITIATED from inside a running claude session (an operator CLI, or a claude peer shelling out),

package/src/onboard/index.ts

@@ -71,7 +71,10 @@ function runtimeBin(runtime: OnboardRuntime, env: NodeJS.ProcessEnv): string {
   return env.IAPEER_CODEX_BIN?.trim() || 'codex'
 }
 
-function isExecutable(binOrName: string, env: NodeJS.ProcessEnv = process.env): boolean {
+/** PRESENCE probe (no spawn) — exported for enable/ (В57): the same wedged-runtime class
+ *  (macOS launch-approval parking every invocation pre-main) hung enable's `--version`
+ *  ANSWER probe forever; presence answers "is it installed" without executing anything. */
+export function isExecutable(binOrName: string, env: NodeJS.ProcessEnv = process.env): boolean {
   if (binOrName.includes('/')) {
     try {
       accessSync(binOrName, FS.X_OK)

package/src/provision/index.ts

@@ -89,6 +89,9 @@ export async function provisionPeer(opts: ProvisionPeerOptions): Promise<Provisi
     peers,
     personality: opts.personality,
     runtimeBin,
+    // В36 — description goes into the LOCAL profile (source of truth); the registry
+    // upsert below then persists a value reindexFromLocals can no longer wipe.
+    description: opts.description,
     warn: opts.warn,
   })
   // Birth-time native-memory lever (контракт «Слот памяти» §Native-память рантаймов):

package/src/tui/dashboard/model.ts

@@ -125,3 +125,14 @@ export function ellipsize(s: string, width: number): string {
   const chars = [...s]
   return chars.length <= width ? s : chars.slice(0, Math.max(0, width - 1)).join('') + '…'
 }
+
+// ─── attach-child failure surfacing ─────────────────────────────────────────
+
+/** Why a spawned `iapeer attach <peer>` run needs the operator's attention, or null when it
+ *  ended fine. PURE: a spawn error AND a non-zero/signal exit both surface — a failed child
+ *  silently remounted over reads as "Enter does nothing" to the operator (live incident 03.07). */
+export function attachFailureMessage(r: { error?: Error; status: number | null }): string | null {
+  if (r.error) return r.error.message
+  if ((r.status ?? 1) !== 0) return `iapeer attach exited with ${r.status ?? 'a signal'}`
+  return null
+}

package/src/tui/dashboard/run.tsx

@@ -4,7 +4,11 @@
 //  - alt-screen: the dashboard is a full-screen live surface; it renders on the
 //    alternate screen so quitting restores the operator's scrollback untouched
 //    (Apple Terminal keeps no E3, so repeated in-scrollback repaints would pile up —
-//    the alt-screen sidesteps that class entirely).
+//    the alt-screen sidesteps that class entirely). The alt-screen is owned by INK
+//    (`alternateScreen: true`), NOT written manually: Ink's resize/erase heuristics
+//    (clear-on-width-shrink, fullscreen-frame clears) key on the buffer IT manages —
+//    a manual \x1b[?1049h behind Ink's back left it erasing by stale line-counts, so
+//    a window resize stacked old frames (live incident: the footer repeated ~5×).
 //  - интерактив только в реальном TTY (контракт фазы): stdin+stdout must both be
 //    TTYs, else the caller falls back to the scriptable table (never render + hang;
 //    the same fail-closed belt as the onboard wizard).
@@ -12,7 +16,10 @@
 //    dashboard fully unmounts + leaves the alt-screen + returns the terminal to
 //    cooked mode, then spawns `iapeer attach <peer>` as a CHILD with inherited stdio
 //    (the runtime TUI gets the REAL tty — the readline-class constraint), waits, and
-//    remounts. One full-screen TUI owns the terminal at any moment.
+//    remounts. One full-screen TUI owns the terminal at any moment. A child that
+//    FAILS (spawn error OR exit≠0) is surfaced and acknowledged — never silently
+//    remounted over (live incident: Enter looked dead because the attach child died
+//    instantly and the remount swallowed its error).
 //
 // Self-invocation uses the same `$bunfs` discriminator as supervisor's
 // resolveDaemonSelfArgv: compiled standalone → re-invoke the binary by verb; running
@@ -23,13 +30,11 @@ import { render } from 'ink'
 import { spawnSync } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
 import { DashboardApp, type DashAction } from './app.tsx'
+import { attachFailureMessage } from './model.ts'
 
 /** Sentinel: no real interactive TTY — the caller should print the scriptable table. */
 export const DASHBOARD_NOT_INTERACTIVE = -1
 
-const ALT_SCREEN_ON = '\x1b[?1049h\x1b[H'
-const ALT_SCREEN_OFF = '\x1b[?1049l'
-
 /** argv prefix that re-invokes THIS package's CLI (compiled binary by verb / src via
  *  bun). Same discriminator as supervisor/index.ts resolveDaemonSelfArgv: `$bunfs` in
  *  the module path marks the compiled standalone (existsSync is NO discriminator —
@@ -49,17 +54,16 @@ export interface DashboardOptions {
 /** Mount the dashboard once; resolve with the action that ended it. */
 async function mountOnce(env: NodeJS.ProcessEnv): Promise<DashAction> {
   let action: DashAction = { type: 'quit' }
-  process.stdout.write(ALT_SCREEN_ON)
-  try {
-    const app = render(<DashboardApp env={env} onAction={a => (action = a)} />, {
-      // the dashboard repaints in place on the alt screen; Ctrl-C is handled by the
-      // app itself (quit action) so a half-torn frame never leaks to the main screen
-      exitOnCtrlC: false,
-    })
-    await app.waitUntilExit()
-  } finally {
-    process.stdout.write(ALT_SCREEN_OFF)
-  }
+  const app = render(<DashboardApp env={env} onAction={a => (action = a)} />, {
+    // the dashboard repaints in place on the alt screen; Ctrl-C is handled by the
+    // app itself (quit action) so a half-torn frame never leaks to the main screen
+    exitOnCtrlC: false,
+    // Ink OWNS the alt-screen (enter on mount, exit+cursor-restore on unmount —
+    // BEFORE waitUntilExit resolves, so the attach child always gets the primary
+    // buffer). Manual 1049-writes behind Ink's back broke its resize erase model.
+    alternateScreen: true,
+  })
+  await app.waitUntilExit()
   return action
 }
 
@@ -87,8 +91,12 @@ export async function runDashboard(opts: DashboardOptions = {}): Promise<number>
       stdio: 'inherit',
       env,
     })
-    if (r.error) {
-      process.stdout.write(`attach failed: ${r.error.message}\npress Enter to continue…`)
+    // Surface BOTH failure shapes before remounting: a spawn error AND a child that ran but
+    // FAILED (exit≠0 / signal — its own stderr is already on the primary screen via inherit).
+    // Remounting silently over either reads as "Enter does nothing" (live incident).
+    const failure = attachFailureMessage(r)
+    if (failure) {
+      process.stdout.write(`attach ${action.personality} failed: ${failure}\npress Enter to continue…`)
       // swallow one line so the operator sees the error before the alt-screen returns
       spawnSync('sh', ['-c', 'read _'], { stdio: 'inherit' })
     }