@agfpd/iapeer 0.2.68 → 0.2.69

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.2.68",
+  "version": "0.2.69",
   "description": "Foundation core for the iapeer multi-agent ecosystem: identity, registry, storage, codec.",
   "type": "module",
   "bin": {

package/src/supervisor/client.attach.test.ts

@@ -0,0 +1,107 @@
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { killSession, sessionAlive, startSupervisorDaemon } from './index.ts'
+
+// SURFACE-5 regression — the interactive attach-and-stay loop. The other supervisor tests attach a
+// RAW socket; none drives the real `runSupervisorClient` under a TTY, so the canary's first live
+// `iapeer attach` exposed a bug invisible to them: runSupervisorClient resolved its Promise the
+// instant Bun.connect returned (setup done), the CLI caller ran `await runSupervisorClient(); return
+// 0` → runCli's `.then(process.exit)`, and the just-attached client was torn down within
+// milliseconds (handshake-then-exit). The fix makes the client BLOCK (never-resolve) after setup so
+// process.exit from a terminal path owns termination — exactly the detached `daemon` case's guard.
+//
+// This is the headless verifier of that fix AND the missing surface-5 automation: allocate a REAL
+// Bun-native pty, run the actual client CLI in it, assert it STAYS attached + renders live frames +
+// Ctrl-] detaches cleanly while the session keeps running. Arthur's live attach is the final human
+// seal; this test makes every iteration of the fix verifiable WITHOUT pulling him in.
+// Gated on Bun-native PTY (≥1.3.5) so a runner without it skips rather than reds.
+const [maj, min, pat] = (Bun.version || '0.0.0').split('.').map(Number) as [number, number, number]
+const bunPty = maj > 1 || (maj === 1 && (min > 3 || (min === 3 && pat >= 5)))
+const d = bunPty ? describe : describe.skip
+
+const sleep = (ms: number): Promise<void> => new Promise(r => setTimeout(r, ms))
+async function waitFor(pred: () => boolean, timeoutMs = 4000, step = 50): Promise<boolean> {
+  const end = Date.now() + timeoutMs
+  while (Date.now() < end) {
+    if (pred()) return true
+    await sleep(step)
+  }
+  return false
+}
+
+// Spawn the real attach client under a real pty (its stdin/stdout is a TTY → raw-mode path runs).
+interface PtyClient {
+  out(): string
+  exited(): boolean
+  sendKey(byte: number): void
+}
+function spawnAttachClient(runDir: string, session: string): PtyClient {
+  let buf = ''
+  let done = false
+  const proc = Bun.spawn(['bun', 'src/supervisor/index.ts', 'attach', session, '--run-dir', runDir], {
+    cwd: process.cwd(),
+    env: { ...process.env },
+    // a real Bun-native pty pair: the client sees a TTY on stdin (isTTY → setRawMode runs).
+    terminal: {
+      cols: 80,
+      rows: 24,
+      name: 'xterm-256color',
+      data(_t: unknown, data: Uint8Array | string) {
+        buf += Buffer.from(data as Uint8Array).toString('latin1')
+      },
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Bun pty spawn opts not yet in @types
+  } as any)
+  proc.exited.then(() => {
+    done = true
+  })
+  return {
+    out: () => buf,
+    exited: () => done,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- proc.terminal is the pty master writer
+    sendKey: (byte: number) => void (proc as any).terminal.write(Buffer.from([byte])),
+  }
+}
+
+d('runSupervisorClient interactive attach (surface-5, Bun-native pty)', () => {
+  let runDir: string
+  const session = 'ptsattach'
+
+  beforeAll(() => {
+    runDir = mkdtempSync(join(tmpdir(), 'iapeer-attach-'))
+    startSupervisorDaemon({ session, runtime: 'tick', runDir })
+  })
+  afterAll(() => {
+    try {
+      killSession(runDir, session)
+    } catch {
+      /* */
+    }
+    rmSync(runDir, { recursive: true, force: true })
+  })
+
+  test('the client STAYS attached after the handshake and keeps rendering live frames', async () => {
+    expect(sessionAlive(runDir, session)).toBe(true)
+    const c = spawnAttachClient(runDir, session)
+
+    // handshake: the attach line lands (connect + attach + terminal-setup succeeded).
+    expect(await waitFor(() => /\[supervisor\] attached to/.test(c.out()))).toBe(true)
+
+    // THE BUG was a handshake-then-exit within ~ms. Assert the client is STILL attached well past
+    // that window AND that live child output (STREAMTICK from the tick runtime) is reaching it —
+    // proving the attach-and-stay loop holds, not just that the process happens to linger.
+    await sleep(2000)
+    expect(c.exited()).toBe(false) // RED on the pre-fix early-resolve (exited ~ms after handshake)
+    expect(/STREAMTICK_\d+/.test(c.out())).toBe(true) // live frames flow through the held attach
+
+    // Ctrl-] (0x1d) detaches: the client exits cleanly, prints the DETACH message (not the
+    // misleading "session ended"), and the session keeps running.
+    c.sendKey(0x1d)
+    expect(await waitFor(() => c.exited())).toBe(true)
+    expect(/detached/.test(c.out())).toBe(true)
+    expect(/session ended/.test(c.out())).toBe(false) // detach must not claim the session ended
+    expect(sessionAlive(runDir, session)).toBe(true) // detach kept the daemon alive
+  })
+})

package/src/supervisor/client.ts

@@ -29,6 +29,10 @@ export async function runSupervisorClient(runDir: string, session: string): Prom
     process.exit(1)
   }
   let restored = false
+  // Set the instant a deliberate Ctrl-] detach begins. `sock.end()` can re-enter the socket close()
+  // handler synchronously, so close() must NOT claim "session ended" on an operator-initiated detach
+  // (the session keeps running) — it stays silent and lets the detach path own the message + exit.
+  let detaching = false
   // writeSync(1, …) works inside a signal handler (no event-loop dependency) — so a
   // SIGHUP/window-close client still resets the terminal before it dies (port-dep #1).
   const restore = (): void => {
@@ -70,6 +74,7 @@ export async function runSupervisorClient(runDir: string, session: string): Prom
       },
       close() {
         restore()
+        if (detaching) process.exit(0) // operator detached; the detach path already wrote its message
         process.stdout.write('\r\n[supervisor] session ended.\r\n')
         process.exit(0)
       },
@@ -82,13 +87,16 @@ export async function runSupervisorClient(runDir: string, session: string): Prom
 
   process.stdin.on('data', b => {
     if (b.includes(DETACH)) {
+      detaching = true
       restore()
+      // Write the detach message BEFORE sock.end() — sock.end() can re-enter close() synchronously,
+      // and close() now exits silently while `detaching`, so the message must already be out.
+      process.stdout.write(`\r\n[supervisor] detached — session still running. reattach: supervisor attach ${session}\r\n`)
       try {
         sock.end()
       } catch {
         /* */
       }
-      process.stdout.write(`\r\n[supervisor] detached — session still running. reattach: supervisor attach ${session}\r\n`)
       process.exit(0)
     }
     sock.write(frame(FRAME_DATA, b))
@@ -115,4 +123,11 @@ export async function runSupervisorClient(runDir: string, session: string): Prom
   }
   process.on('exit', () => restore()) // last-resort sync net
   process.stdout.write(`\x1b[2m[supervisor] attached to "${session}". detach: Ctrl-]  (session keeps running)\x1b[0m\r\n`)
+  // STAY ATTACHED. The client lives on its handles (raw stdin + the socket); EVERY terminal path
+  // (detach Ctrl-], session-end close(), SIGHUP/SIGTERM, socket error) calls process.exit ITSELF.
+  // This promise INTENTIONALLY never resolves: returning here would resolve runSupervisorClient the
+  // instant the handshake completed, and the CLI caller (`await runSupervisorClient(); return 0` →
+  // runCli's `.then(process.exit)`) would tear the just-attached client down in milliseconds — the
+  // surface-5 interactive-attach bug. The detached `daemon` case guards itself the same way.
+  await new Promise<never>(() => {})
 }