@agfpd/iapeer 0.4.53 → 0.4.55

package/package.json

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

@@ -112,7 +112,10 @@ function indexOfOutsideCdata(buffer: string, needle: string, start: number): num
 function readTagContent(xml: string, tag: string): string | undefined {
   const open = `<${tag}>`
   const close = `</${tag}>`
-  const openIdx = xml.indexOf(open)
+  // В37 — the OPEN tag must be located CDATA-aware too (the close-side already was): a
+  // message whose CDATA body QUOTES `<attachments>…</attachments>` otherwise minted
+  // phantom attachments, and a quoted `<message>` corrupted the decoded message.
+  const openIdx = indexOfOutsideCdata(xml, open, 0)
   if (openIdx < 0) return undefined
   let i = openIdx + open.length
   let out = ''
@@ -191,12 +194,36 @@ export function decodeEnvelope(xml: string): IapEnvelope {
   }
 }
 
+// В38 — a real envelope's open tag is bounded: personality/runtime ≤32 chars each,
+// topic ≤200, intelligence one word, plus attr names and escaping. 1 KiB is far above
+// any legitimate open tag; a longer '>'-less run after `<iap ` is prose, not a tag.
+const MAX_OPEN_TAG_LEN = 1024
+
+/** Classify the text at a `<iap ` occurrence: a complete VALID open tag (required attrs
+ *  present), a complete-but-INVALID one / overlong tagless run (prose that merely contains
+ *  the marker), or INCOMPLETE (no '>' yet within bounds — wait for the next chunk). */
+function openTagVerdict(candidate: string): 'valid' | 'invalid' | 'incomplete' {
+  const m = /^<iap\s+([^>]*)>/.exec(candidate)
+  if (!m) {
+    const unclosed = candidate.indexOf('>') < 0
+    return unclosed && candidate.length <= MAX_OPEN_TAG_LEN ? 'incomplete' : 'invalid'
+  }
+  if (m[0].length > MAX_OPEN_TAG_LEN) return 'invalid'
+  return m[1].includes('from-personality="') && m[1].includes('from-runtime="') ? 'valid' : 'invalid'
+}
+
 /**
  * Pull complete `<iap …>…</iap>` envelopes out of a streaming buffer.
  * The closing `</iap>` is located CDATA-aware, so an envelope whose message
  * body contains the literal text `</iap>` is not truncated. `rest` holds the
  * trailing bytes that do not yet form a complete envelope (incl. an envelope
  * still mid-CDATA), to be prepended to the next chunk.
+ *
+ * В38 — a FALSE start (prose that merely contains `<iap `, e.g. a quoted tool
+ * description) is never committed to: the open tag is validated first, and a
+ * candidate whose decode fails RESYNCS one char forward instead of being kept
+ * (which used to either swallow the NEXT real envelope into a mis-attributed
+ * blob, or park the buffer forever waiting for a close that never comes).
  */
 export function extractEnvelopes(buffer: string): { envelopes: string[]; rest: string } {
   const envelopes: string[] = []
@@ -208,10 +235,25 @@ export function extractEnvelopes(buffer: string): { envelopes: string[]; rest: s
       return { envelopes, rest: rest.slice(Math.max(0, rest.length - '<iap '.length)) }
     }
     if (start > 0) rest = rest.slice(start)
+    const verdict = openTagVerdict(rest)
+    if (verdict === 'incomplete') return { envelopes, rest } // open tag split across chunks → wait
+    if (verdict === 'invalid') {
+      rest = rest.slice(1) // false start: skip past this '<' and rescan for the next '<iap '
+      continue
+    }
     const close = indexOfOutsideCdata(rest, '</iap>', '<iap '.length)
     if (close < 0) return { envelopes, rest } // incomplete (or mid-CDATA) → wait
     const envelopeEnd = close + '</iap>'.length
-    envelopes.push(rest.slice(0, envelopeEnd))
+    const candidate = rest.slice(0, envelopeEnd)
+    try {
+      decodeEnvelope(candidate)
+    } catch {
+      // Structurally envelope-shaped but undecodable → a false start after all;
+      // resync so a REAL envelope inside/behind the candidate is still found.
+      rest = rest.slice(1)
+      continue
+    }
+    envelopes.push(candidate)
     rest = rest.slice(envelopeEnd)
   }
 }

package/src/tui/dashboard/app.tsx

@@ -41,6 +41,12 @@ function RuntimeCells({ row }: { row: PeerListing }): React.ReactElement {
   )
 }
 
+/** Absolute screen reset written on every terminal resize: erase-all + cursor-home.
+ *  Goes through Ink's OWN write path (useStdout().write → writeToStdout), which
+ *  erases Ink's frame, writes these bytes, then REPLAYS the last frame with reset
+ *  erase bookkeeping — so the replay lands at a KNOWN absolute origin (row 1). */
+const RESIZE_SCREEN_RESET = '\x1b[2J\x1b[H'
+
 export function DashboardApp({
   env,
   onAction,
@@ -49,7 +55,7 @@ export function DashboardApp({
   onAction: (a: DashAction) => void
 }): React.ReactElement {
   const { exit } = useApp()
-  const { stdout } = useStdout()
+  const { stdout, write } = useStdout()
   const [rows, setRows] = useState<PeerListing[]>(() => takePeersSnapshot(env))
   const [host, setHost] = useState<HostHeader | null>(null)
   const [now, setNow] = useState<number>(() => Date.now())
@@ -95,12 +101,26 @@ export function DashboardApp({
   }, [env])
   useEffect(() => {
     if (!stdout) return
-    const onResize = (): void => setSize({ cols: dim(stdout.columns, 80), rows: dim(stdout.rows, 24) })
+    const onResize = (): void => {
+      // Ink erases frames by RELATIVE cursor math (cursor-up × line-count), and a real
+      // terminal displaces alt-screen content on window resize (Apple Terminal shifts it
+      // on height changes; a width change can re-wrap) — after which that relative erase
+      // misses rows and stale frame fragments survive FOREVER (live incident: a drag-
+      // resize stacked 9 footers; Ink itself full-clears only on width SHRINK). So on
+      // EVERY resize force an ABSOLUTE reset: wipe the screen + home the cursor, then let
+      // Ink replay the frame from that known origin. Written through Ink's write API —
+      // never raw to stdout behind its back (the 0.4.51 lesson): writeToStdout keeps its
+      // erase model in sync (clear → our bytes → replay with reset line-counts). This
+      // listener registers AFTER Ink's own resize handler (mount effect vs render), so
+      // the absolute reset is always the LAST word on the resize tick.
+      write(RESIZE_SCREEN_RESET)
+      setSize({ cols: dim(stdout.columns, 80), rows: dim(stdout.rows, 24) })
+    }
     stdout.on('resize', onResize)
     return () => {
       stdout.off('resize', onResize)
     }
-  }, [stdout])
+  }, [stdout, write])
 
   const visible = filterRows(rows, filter)
   const cur = clampCursor(cursor, visible.length)

package/src/tui/dashboard/run.tsx

@@ -38,13 +38,25 @@ export const DASHBOARD_NOT_INTERACTIVE = -1
 /** 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 —
- *  Bun intercepts bunfs reads). */
-export function resolveSelfCliArgv(execPath: string, selfPath: string): string[] {
-  return selfPath.includes('$bunfs') ? [execPath] : [execPath, selfPath]
+ *  Bun intercepts bunfs reads).
+ *
+ *  Discriminate on the MODULE's OWN url — NEVER on a `../..`-navigated path. The
+ *  compiled bundle lives at `file:///$bunfs/root/<bundle>` (depth 2), so navigating
+ *  two levels up ESCAPES /$bunfs and URL-normalization silently drops the marker
+ *  (proven: compiled probe → `new URL('../../cli/index.ts', import.meta.url)` =
+ *  `/cli/index.ts`). The prior code passed that navigated path here, so the COMPILED
+ *  dashboard took the src branch and spawned `<binary> /cli/index.ts attach <peer>`
+ *  → unknown verb → full usage + exit 2 (live incident: Enter→attach dead in
+ *  `iapeer list`; from-src runs masked it — the navigated path is real there). The
+ *  cli path is resolved lazily and ONLY on the src branch. */
+export function resolveSelfCliArgv(execPath: string, moduleUrl: string): string[] {
+  return moduleUrl.includes('$bunfs')
+    ? [execPath]
+    : [execPath, fileURLToPath(new URL('../../cli/index.ts', moduleUrl))]
 }
 
 function selfCliArgv(): string[] {
-  return resolveSelfCliArgv(process.execPath, fileURLToPath(new URL('../../cli/index.ts', import.meta.url)))
+  return resolveSelfCliArgv(process.execPath, import.meta.url)
 }
 
 export interface DashboardOptions {