@agfpd/iapeer 0.4.52 → 0.4.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.4.52",
+  "version": "0.4.54",
   "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

@@ -244,12 +244,21 @@ export function stopPeer(personality: string, runtime: string | undefined, opts:
     const identity = buildProcessAddress(rt, personality)
     const sock = buildSocketPath(rt, personality, cfg.sockDir)
     if (isInfraRuntime(rt)) {
-      // Audit #13: do NOT swallow the launchctl result. (bootout returns non-zero when
-      // the service was already not loaded — benign for stop — but surface the detail in
-      // the reason rather than silently claiming success.)
+      // Audit #13 + В48: do NOT swallow the launchctl result — but DISCRIMINATE. An
+      // already-unloaded job (exit 3 / "No such process", verified live) is BENIGN for
+      // stop: the desired state ("not running") already holds, so it carries NO reason
+      // and must not fail the verb. Any other non-zero is a REAL error and sets reason
+      // (the CLI maps a reasoned bootout to exit 1).
       const r = spawnSync('launchctl', ['bootout', `gui/${uid()}/${launchdLabel(personality)}`], { encoding: 'utf8' })
       killSession(sock, identity, env)
-      out.push({ personality, runtime: rt, action: 'bootout', reason: r.status === 0 ? undefined : `launchctl bootout exited ${r.status}${(r.stderr ?? '').trim() ? `: ${(r.stderr ?? '').trim()}` : ''}` })
+      const stderrText = (r.stderr ?? '').trim()
+      const benign = r.status === 0 || r.status === 3 || /No such process/i.test(stderrText)
+      out.push({
+        personality,
+        runtime: rt,
+        action: 'bootout',
+        reason: benign ? undefined : `launchctl bootout exited ${r.status}${stderrText ? `: ${stderrText}` : ''}`,
+      })
     } else {
       // A deliberate stop is a CLEAN PARK, not a death (stop→start must survive ≥
       // idle-reap): park-mark BEFORE the kill so the post-`start`
@@ -1131,6 +1140,32 @@ function parseIdentity(identity: string): { personality: string; runtime: Runtim
 // CLI dispatch — `iapeer <verb> …`
 // ─────────────────────────────────────────────────────────────────────────────
 
+/** В49 — flags that never take a value. Without the schema the look-ahead form ate the
+ *  NEXT positional: `iapeer update --force 0.4.31` parsed as flags.force='0.4.31' with NO
+ *  positionals → an UNforced full-cascade update instead of a forced version pin (live
+ *  incident shape). A boolean flag is always `true`; forcing a value onto one is only
+ *  possible via the explicit `--key=value` form (which stays verbatim). */
+const BOOLEAN_FLAGS: ReadonlySet<string> = new Set([
+  'accept-risk',
+  'all',
+  'check',
+  'dry-run',
+  'fix',
+  'force',
+  'foundation-only',
+  'install-plist',
+  'json',
+  'no-bootstrap',
+  'no-memory',
+  'no-notifier',
+  'no-setup',
+  'no-telegram',
+  'no-voice',
+  'npx',
+  'remove-codesign-identity',
+  'yes',
+])
+
 export function parseArgs(argv: string[]): { positionals: string[]; flags: Record<string, string | true> } {
   const positionals: string[] = []
   const flags: Record<string, string | true> = {}
@@ -1145,6 +1180,11 @@ export function parseArgs(argv: string[]): { positionals: string[]; flags: Recor
         continue
       }
       const key = a.slice(2)
+      // В49 — a KNOWN boolean flag never consumes the next token as its value.
+      if (BOOLEAN_FLAGS.has(key)) {
+        flags[key] = true
+        continue
+      }
       const next = argv[i + 1]
       if (next === undefined || next.startsWith('--')) flags[key] = true
       else flags[key] = argv[++i]
@@ -1684,9 +1724,13 @@ export async function runCli(argv: string[], env: NodeJS.ProcessEnv = process.en
         out(
           `initialized "${r.personality}" (default: ${r.runtime}; runtimes: ${allRuntimes.join(', ')}); ` +
             `mcp: ${r.mcpConfigPaths.join(', ') || r.codexMcpConfigPath || 'none'}` +
-            `${r.bootstrapped ? `; bootstrap: ${r.bootstrapped.state}` : ''}\n`,
+            `${r.bootstrapped ? `; bootstrap: ${r.bootstrapped.state}` : ''}` +
+            `${r.selfConfig?.state === 'failed' ? '; self-config: FAILED (infra peer NOT started)' : ''}\n`,
         )
-        return 0
+        // В47 — a failed runtime self-config means initPeer deliberately did NOT bootstrap:
+        // the always-on peer is not running. Exit 0 here read as success to automation.
+        if (r.selfConfig?.state === 'failed') return 1
+        return r.bootstrapped && (r.bootstrapped.state === 'failed' || r.bootstrapped.state === 'refused-foreign') ? 1 : 0
       }
       case 'create': {
         // cwd-INDEPENDENT: resolve a location (default ~/.iapeer/peers/<p> or --path),
@@ -1753,8 +1797,13 @@ export async function runCli(argv: string[], env: NodeJS.ProcessEnv = process.en
         out(
           `created "${r.personality}" (default: ${r.runtime}; runtimes: ${allRuntimes.join(', ')}) at ${r.location}; ` +
             `mcp: ${r.mcpConfigPaths.join(', ') || r.codexMcpConfigPath || 'none'}` +
-            `${r.plistPath ? `; plist: ${r.plistPath}` : ''}${r.bootstrapped ? `; bootstrap: ${r.bootstrapped.state}` : ''}\n`,
+            `${r.plistPath ? `; plist: ${r.plistPath}` : ''}${r.bootstrapped ? `; bootstrap: ${r.bootstrapped.state}` : ''}` +
+            `${r.selfConfig?.state === 'failed' ? '; self-config: FAILED (infra peer NOT started)' : ''}\n`,
         )
+        // В47 — selfConfig 'failed' deliberately skips the bootstrap (initPeer), so the
+        // always-on peer is NOT running; `create x --runtime telegram` with a broken hook
+        // exited 0 and automation read a dead telegram router as provisioned.
+        if (r.selfConfig?.state === 'failed') return 1
         return r.bootstrapped && (r.bootstrapped.state === 'failed' || r.bootstrapped.state === 'refused-foreign') ? 1 : 0
       }
       case 'list': {
@@ -1865,7 +1914,9 @@ export async function runCli(argv: string[], env: NodeJS.ProcessEnv = process.en
         if (!peers) return argErr(errOut, 'stop needs a peer or --all — usage: iapeer stop <peer> [runtime] | --all')
         const outcomes = peers.flatMap(p => stopPeer(p, flags.all === true ? undefined : positionals[1], { env }))
         for (const o of outcomes) out(`${o.personality} (${o.runtime}): ${o.action}${o.reason ? ` — ${o.reason}` : ''}\n`)
-        return outcomes.some(o => o.action === 'refused-foreign-launchd') ? 1 : 0
+        // В48 — a REAL bootout error (reason set; benign already-unloaded carries none) is exit 1:
+        // automation must see that an always-on peer may still be running.
+        return outcomes.some(o => o.action === 'refused-foreign-launchd' || (o.action === 'bootout' && o.reason !== undefined)) ? 1 : 0
       }
       case 'add-runtime': {
         // Fleet-switch enabler (codex-parity audit): add an agentic runtime to
@@ -1917,7 +1968,9 @@ export async function runCli(argv: string[], env: NodeJS.ProcessEnv = process.en
         if (!peers) return argErr(errOut, 'start needs a peer or --all — usage: iapeer start <peer> [runtime] | --all')
         const outcomes = peers.flatMap(p => startPeer(p, flags.all === true ? undefined : positionals[1], { env }))
         for (const o of outcomes) out(`${o.personality} (${o.runtime}): ${o.action}${o.reason ? ` — ${o.reason}` : ''}\n`)
-        return outcomes.some(o => o.action === 'refused-foreign-launchd') ? 1 : 0
+        // В48 — a failed launchctl bootstrap (reason set) means the always-on peer is NOT
+        // started; exit 0 here let automation read a dead telegram/notifier as running.
+        return outcomes.some(o => o.action === 'refused-foreign-launchd' || (o.action === 'bootstrap' && o.reason !== undefined)) ? 1 : 0
       }
       case 'refresh': {
         // LAZY soft-reload (fleet doctrine refresh): arm `.fresh-next` so each agentic peer comes up FRESH

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)
   }
 }