@agfpd/iapeer 0.4.47 → 0.4.48

package/package.json

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

@@ -216,7 +216,34 @@ export function codexConfigPath(options: StorageOptions = {}): string {
  *     serves every codex peer with its own identity (env_http_headers, verified live).
  * Returns {path, added} (added=false when the block already existed).
  */
-export function writeCodexMcpConfig(daemonUrl: string, options: StorageOptions = {}): { path: string; added: boolean } {
+/**
+ * Rewrite the `url = …` line INSIDE the `[mcp_servers.iapeer]` section to `url`, leaving
+ * the rest of the shared config byte-for-byte. The section runs from its header to the next
+ * `[…]` header (the `.env_http_headers` sub-table ends it — the url sits above that anyway).
+ * Returns the input unchanged when the url already matches (idempotent) or no url line exists.
+ */
+function healCodexMcpUrl(text: string, url: string): string {
+  const want = `url = ${JSON.stringify(url)}`
+  const lines = text.split('\n')
+  let inSection = false
+  for (let i = 0; i < lines.length; i++) {
+    const header = lines[i]!.match(/^\s*\[([^\]]+)\]\s*$/)
+    if (header) {
+      inSection = header[1] === `mcp_servers.${IAPEER_MCP_SERVER_NAME}`
+      continue
+    }
+    if (inSection && /^\s*url\s*=/.test(lines[i]!)) {
+      if (lines[i]!.trim() !== want) lines[i] = want
+      break // exactly one url line per server section
+    }
+  }
+  return lines.join('\n')
+}
+
+export function writeCodexMcpConfig(
+  daemonUrl: string,
+  options: StorageOptions = {},
+): { path: string; added: boolean; healed?: boolean } {
   const path = codexConfigPath(options)
   let existing = ''
   try {
@@ -224,7 +251,17 @@ export function writeCodexMcpConfig(daemonUrl: string, options: StorageOptions =
   } catch {
     /* no config yet → create it */
   }
-  if (/\[mcp_servers\.iapeer\]/.test(existing)) return { path, added: false } // idempotent
+  if (/\[mcp_servers\.iapeer\]/.test(existing)) {
+    // В44 — the block already exists, but the OLD code returned added:false WITHOUT checking
+    // the url. init bakes a fallback :8765 endpoint BEFORE the daemon publishes its real port;
+    // a later IAPEER_PORT change re-inits the claude side but left this codex block pinned to a
+    // now-DEAD port forever, while initPeer reported success. Heal the url in place (idempotent
+    // by content — only our section's `url=` line is touched, everything else is preserved).
+    const healed = healCodexMcpUrl(existing, daemonUrl)
+    if (healed === existing) return { path, added: false } // already correct → no write
+    writeFileAtomic(path, healed, 0o644)
+    return { path, added: false, healed: true }
+  }
   const block =
     `\n[mcp_servers.${IAPEER_MCP_SERVER_NAME}]\n` +
     `url = ${JSON.stringify(daemonUrl)}\n` +

package/src/launch/codexHooksTrust.ts

@@ -49,6 +49,7 @@ import { createHash } from 'crypto'
 import { dirname } from 'path'
 import { writeFileAtomic } from '../storage/index.ts'
 import { codexGlobalConfigPath } from './nativeMemory.ts'
+import { assertTomlSafeKey } from './tomlKey.ts'
 
 /** hooks.json event names → the snake_case labels codex keys state with
  *  (upstream `hook_event_key_label`). */
@@ -226,14 +227,6 @@ function resolveHooksSource(hooksJsonPath: string): string {
   return realpathSync(hooksJsonPath)
 }
 
-/** TOML basic strings treat `\` and `"` specially — paths carrying them would
- *  need escaping codex-side too; refuse instead of guessing. */
-function assertTomlSafeKey(key: string): void {
-  if (key.includes('"') || key.includes('\\')) {
-    throw new Error(`hooks.json path is not TOML-key-safe (contains " or \\): ${key}`)
-  }
-}
-
 /**
  * Pre-seed the codex hooks trust state for every command hook in the given
  * hooks.json — the deterministic, headless replacement for the "Hooks need

package/src/launch/nativeMemory.ts

@@ -21,10 +21,11 @@
 // (slot-gated, see provision/index.ts).
 
 import { existsSync, mkdirSync, readFileSync, realpathSync } from 'fs'
-import { dirname, join } from 'path'
+import { basename, dirname, join, resolve } from 'path'
 import { homedir } from 'os'
 import type { Runtime } from '../core/constants.ts'
 import { writeFileAtomic } from '../storage/index.ts'
+import { assertTomlSafeKey } from './tomlKey.ts'
 
 export type NativeMemoryState = 'off' | 'on'
 
@@ -161,6 +162,11 @@ export function preTrustCodexCwd(cwd: string, env: NodeJS.ProcessEnv = process.e
     } catch {
       /* cwd not on disk yet → keep as given */
     }
+    // В42 — the cwd becomes a QUOTED TOML key `[projects."<real>"]`. An operator-supplied
+    // `create --path` cwd carrying `"`/`\` (legal on APFS) would corrupt the SHARED global
+    // config and break codex for every peer on the host. Refuse (the try/catch reports it
+    // as a 'failed' lever); same guard the sibling hooks-trust writer uses.
+    assertTomlSafeKey(real)
     const text = existsSync(path) ? readFileSync(path, 'utf8') : ''
     if (text.includes(`[projects."${real}"]`)) return { runtime: 'codex', path, state: 'already' }
     const block = `${text.length && !text.endsWith('\n') ? '\n' : ''}${text.trim().length ? '\n' : ''}[projects."${real}"]\ntrust_level = "trusted"\n`
@@ -172,6 +178,30 @@ export function preTrustCodexCwd(cwd: string, env: NodeJS.ProcessEnv = process.e
   }
 }
 
+/**
+ * Resolve `p` to its real path even when the leaf (or several trailing components) no
+ * longer exists: realpath the nearest EXISTING ancestor and re-append the missing tail.
+ * Returns null only if nothing on the chain up to the root exists (impossible for `/`).
+ * Used by removeCodexCwdTrust to reconstruct the realpath-form key of an already-deleted
+ * cwd so a stale trust entry written under a symlink-resolved path is still matched.
+ */
+function realpathViaExistingAncestor(p: string): string | null {
+  let cur = resolve(p)
+  const tail: string[] = []
+  // Guard against an unbounded loop: dirname('/') === '/'.
+  for (let depth = 0; depth < 4096; depth++) {
+    try {
+      return tail.length ? join(realpathSync(cur), ...tail.slice().reverse()) : realpathSync(cur)
+    } catch {
+      const parent = dirname(cur)
+      if (parent === cur) return null // reached the root and even it did not resolve
+      tail.push(basename(cur))
+      cur = parent
+    }
+  }
+  return null
+}
+
 /**
  * Remove a peer's pre-trust entry from the codex GLOBAL config — the reap-side
  * counterpart of preTrustCodexCwd (backlog «remove не чистит pre-trust», made
@@ -192,7 +222,14 @@ export function removeCodexCwdTrust(cwd: string, env: NodeJS.ProcessEnv = proces
     } catch {
       /* cwd already deleted → only the literal form can match */
     }
-    const candidates = new Set([real, cwd])
+    // В43 — the writer keyed the entry on the RESOLVED real path. When the cwd is already
+    // DELETED (the throwaway-sandbox reap case), realpathSync(cwd) above throws and `real`
+    // falls back to the LITERAL cwd — which MISSES if any path component was a symlink
+    // (e.g. codex stored /private/tmp/… for a /tmp/… cwd). Reconstruct the resolved form
+    // from the nearest still-existing ANCESTOR + the deleted remainder, so the stale entry
+    // is found and removed instead of lingering as a phantom trust for that path.
+    const viaAncestor = realpathViaExistingAncestor(cwd)
+    const candidates = new Set([real, cwd, ...(viaAncestor ? [viaAncestor] : [])])
     const lines = readFileSync(path, 'utf8').split('\n')
     const kept: string[] = []
     let inDoomed = false

package/src/launch/tomlKey.ts

@@ -0,0 +1,17 @@
+// Shared TOML-key safety for the codex GLOBAL config.toml writers. codex's host-wide
+// config addresses per-project state by a QUOTED-string key — `[projects."<path>"]`,
+// `[hooks_trust."<source>"]`, `[mcp_servers.<name>]`. A TOML basic string treats `"`
+// and `\` specially, so a key carrying either would need codex-side escaping we cannot
+// guarantee round-trips; writing it raw corrupts the whole SHARED config and breaks
+// codex for EVERY peer on the host. Refuse instead of guessing.
+//
+// Extracted from codexHooksTrust.ts (which introduced it for hooks sources) so the
+// native-memory pre-trust writer reuses the exact same guard — one definition, one
+// behavior, no drift.
+
+/** Throw if `key` cannot be a raw TOML basic-string key (contains `"` or `\`). */
+export function assertTomlSafeKey(key: string): void {
+  if (key.includes('"') || key.includes('\\')) {
+    throw new Error(`path is not TOML-key-safe (contains " or \\): ${key}`)
+  }
+}