@agfpd/iapeer 0.4.65 → 0.4.66

package/package.json

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

@@ -351,6 +351,26 @@ export function daemonDiscoveryPath(options: StorageOptions = {}): string {
   return join(pluginStateDir('iapeer', options), 'router.json')
 }
 
+/**
+ * Normalize an HTTP request-target to origin-form (path[+query]) for path routing.
+ * A request that traversed an HTTP proxy arrives in ABSOLUTE-FORM (RFC 7230 §5.3.2:
+ * "GET http://host/path"), and Node exposes the whole target as `req.url` — so a
+ * path check like `req.url.startsWith('/fleet/')` misses and the request wrongly
+ * falls to the MCP catch-all (→ 406). Any client with HTTP(S)_PROXY set is affected
+ * (Bun's fetch proxies loopback even when NO_PROXY lists 127.0.0.1). Origin-form and
+ * unparseable targets pass through unchanged. Exported for tests. */
+export function normalizeRequestTarget(url: string | undefined): string | undefined {
+  if (url && /^https?:\/\//i.test(url)) {
+    try {
+      const u = new URL(url)
+      return u.pathname + u.search
+    } catch {
+      /* unparseable — leave as received */
+    }
+  }
+  return url
+}
+
 export interface DaemonHandle {
   socketPath?: string
   host?: string
@@ -498,6 +518,18 @@ export async function startDaemon(opts: StartDaemonOptions = {}): Promise<Daemon
   // gate first, then the fleet-API branch (when wired), then stateless MCP —
   // a fresh Server + transport per request, fully isolated.
   const handle = (req: IncomingMessage, res: ServerResponse): void => {
+    // RFC 7230 §5.3.2 request-target hygiene (FIRST — before ANY path routing). A
+    // request that traversed an HTTP proxy carries the ABSOLUTE-FORM target
+    // ("GET http://127.0.0.1:8765/fleet/v1/snapshot"), and Node puts that whole string
+    // in req.url — so path routing (/fleet vs /mcp) would miss and fall through to MCP
+    // (→ a 406 "must accept text/event-stream" for a plain GET). This bites any client
+    // whose environment has HTTP(S)_PROXY set: Bun's fetch (and others) route loopback
+    // through the proxy even when NO_PROXY lists 127.0.0.1 (Bun ignores NO_PROXY). We
+    // can't fix every client, so the daemon normalizes to origin-form here — a proxied
+    // request then routes identically to a direct one, for BOTH the fleet and MCP
+    // surfaces. (live-proven: HTTP_PROXY pointed at the daemon itself reproduced the
+    // 406; normalization restores /fleet routing.)
+    req.url = normalizeRequestTarget(req.url)
     // H8 bearer layer (FIRST, before any MCP/fleet work): when a token is configured,
     // reject anything not carrying `Authorization: Bearer <token>`. Off when unset.
     if (bearer && req.headers.authorization !== `Bearer ${bearer}`) {

package/src/tray/client.ts

@@ -80,6 +80,7 @@ export class FleetUnreachableError extends Error {
 }
 
 interface FetchAttempt {
+  transport: 'unix' | 'tcp'
   url: string
   init: RequestInit & { unix?: string }
 }
@@ -89,36 +90,66 @@ interface FetchAttempt {
 function attempts(addr: FleetAddress, path: string, base: RequestInit, env: NodeJS.ProcessEnv): FetchAttempt[] {
   const headers = { ...(base.headers as Record<string, string> | undefined), ...bearerHeader(env) }
   const list: FetchAttempt[] = []
-  if (addr.sock) list.push({ url: `http://iapeer${path}`, init: { ...base, headers, unix: addr.sock } })
-  if (addr.tcp) list.push({ url: `${addr.tcp}${path}`, init: { ...base, headers } })
+  if (addr.sock) list.push({ transport: 'unix', url: `http://iapeer${path}`, init: { ...base, headers, unix: addr.sock } })
+  if (addr.tcp) list.push({ transport: 'tcp', url: `${addr.tcp}${path}`, init: { ...base, headers } })
   return list
 }
 
+function debug(env: NodeJS.ProcessEnv, msg: string): void {
+  if (env.IAPEER_TRAY_DEBUG === '1') process.stderr.write(`[tray] ${msg}\n`)
+}
+
+/** The response of a fleet request, carrying the ACTUAL wire transport + URL used —
+ *  so a failure surfaces where the request really went (a proxied request lands on a
+ *  different route than the client's intended path). */
+export interface FleetResponse {
+  res: Response
+  transport: string
+  url: string
+}
+
+/**
+ * Try each transport (unix first, TCP second) until one answers. On a THROW, move to
+ * the next transport. On a NON-OK status the behavior depends on `retryBadStatus`:
+ * GETs (idempotent) retry on the OTHER transport (a single misrouting transport — e.g.
+ * one behind a proxy — cannot then sink the client); POSTs do NOT (never re-execute a
+ * command). Returns the actual transport+URL for honest diagnostics.
+ */
 async function fetchFleet(
   addr: FleetAddress,
   path: string,
   init: RequestInit,
   env: NodeJS.ProcessEnv,
-): Promise<Response> {
+  opts: { retryBadStatus?: boolean } = {},
+): Promise<FleetResponse> {
   const tries = attempts(addr, path, init, env)
   if (tries.length === 0) throw new FleetUnreachableError('no advertised address (router.json missing sock/tcp)')
   let lastErr = ''
+  let firstBad: FleetResponse | undefined
   for (const a of tries) {
+    let res: Response
     try {
-      const res = await fetch(a.url, a.init as RequestInit)
-      return res
+      res = await fetch(a.url, a.init as RequestInit)
     } catch (e) {
       lastErr = e instanceof Error ? e.message : String(e)
-      // try the next transport
+      debug(env, `${a.transport} ${a.url} → THREW ${lastErr}`)
+      continue
     }
+    debug(env, `${a.transport} ${a.url} → ${res.status}`)
+    const wrapped: FleetResponse = { res, transport: a.transport, url: a.url }
+    if (res.ok) return wrapped
+    if (!firstBad) firstBad = wrapped
+    if (!opts.retryBadStatus) return wrapped // POST: return the error as-is (no re-execute)
+    // GET: fall through to the next transport; firstBad is returned if none succeed
   }
-  throw new FleetUnreachableError(lastErr || 'all transports failed')
+  if (firstBad) return firstBad
+  throw new FleetUnreachableError(`${lastErr || 'all transports failed'} (tried ${tries.map(t => `${t.transport}=${t.url}`).join(', ')})`)
 }
 
 export async function fleetGetJson<T = unknown>(addr: FleetAddress, path: string, env: NodeJS.ProcessEnv): Promise<T> {
-  const res = await fetchFleet(addr, path, { method: 'GET' }, env)
+  const { res, transport, url } = await fetchFleet(addr, path, { method: 'GET' }, env, { retryBadStatus: true })
   const text = await res.text()
-  if (!res.ok) throw new Error(`GET ${path} → ${res.status}: ${text.slice(0, 300)}`)
+  if (!res.ok) throw new Error(`GET ${url} (${transport}) → ${res.status}: ${text.slice(0, 300)}`)
   return JSON.parse(text) as T
 }
 
@@ -128,11 +159,12 @@ export async function fleetPostJson<T = unknown>(
   body: Record<string, unknown>,
   env: NodeJS.ProcessEnv,
 ): Promise<{ status: number; body: T }> {
-  const res = await fetchFleet(
+  const { res } = await fetchFleet(
     addr,
     path,
     { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) },
     env,
+    { retryBadStatus: false }, // a command must never re-execute on the other transport
   )
   const text = await res.text()
   let parsed: T
@@ -170,13 +202,14 @@ export async function streamFleetEvents(
   opts: { replay?: number; signal?: AbortSignal; env: NodeJS.ProcessEnv },
 ): Promise<void> {
   const replay = Math.max(0, Math.min(500, opts.replay ?? 0))
-  const res = await fetchFleet(
+  const { res, transport, url } = await fetchFleet(
     addr,
     `/fleet/v1/events?replay=${replay}`,
     { method: 'GET', headers: { accept: 'text/event-stream' }, signal: opts.signal },
     opts.env,
+    { retryBadStatus: true },
   )
-  if (!res.ok || !res.body) throw new Error(`events stream → ${res.status}`)
+  if (!res.ok || !res.body) throw new Error(`events stream ${url} (${transport}) → ${res.status}`)
   const reader = res.body.getReader()
   const decoder = new TextDecoder()
   let buf = ''

package/src/tray/install.ts

@@ -69,7 +69,17 @@ function setSwiftBarPluginDir(dir: string, run: Runner): RunResult {
 }
 
 function installSwiftBarApp(run: Runner): RunResult {
-  return run('brew', ['install', '--cask', 'swiftbar'])
+  // --no-quarantine: an automated install has no one to click through the Gatekeeper
+  // "app downloaded from the Internet" dialog — quarantine would stall first launch.
+  return run('brew', ['install', '--cask', '--no-quarantine', 'swiftbar'])
+}
+
+/** Strip any residual quarantine xattr from the app (belt-and-suspenders: an already
+ *  brew-installed SwiftBar, or a brew that quarantined despite the flag, would else
+ *  block first launch on a headless / no-click box). Best-effort. */
+function dequarantineApp(run: Runner): void {
+  const app = SWIFTBAR_APP_PATHS.find(p => existsSync(p))
+  if (app) run('xattr', ['-dr', 'com.apple.quarantine', app])
 }
 
 function launchSwiftBar(run: Runner): void {
@@ -93,6 +103,11 @@ export function buildPluginShim(binPath: string): string {
     '# <swiftbar.hideRunInTerminal>true</swiftbar.hideRunInTerminal>',
     '# <swiftbar.hideLastUpdated>true</swiftbar.hideLastUpdated>',
     '# <swiftbar.hideDisablePlugin>true</swiftbar.hideDisablePlugin>',
+    // The dashboard ONLY ever talks to the local daemon (unix socket / loopback), so it
+    // must never route through an HTTP proxy. Bun's fetch caches proxy config at process
+    // start and ignores NO_PROXY for loopback, so clearing the vars must happen in the
+    // ENV before the binary launches (a runtime delete is too late). unset here.
+    'unset HTTP_PROXY HTTPS_PROXY http_proxy https_proxy ALL_PROXY all_proxy',
     `exec "${binPath}" tray render --stream`,
     '',
   ].join('\n')
@@ -195,6 +210,7 @@ export function installTray(opts: InstallTrayOptions = {}): InstallTrayResult {
   // 4 — launch + refresh
   let launched = false
   if (opts.launch && present) {
+    dequarantineApp(run)
     launchSwiftBar(run)
     refreshSwiftBar(run)
     launched = true