@miphamai/cli 0.37.0 → 0.39.0

package/src/mcp/client.ts

@@ -22,6 +22,15 @@ const bundles: Record<string, TranslationMap> = {
 }
 const t = createT(bundles['en-US'] || (enUS as TranslationMap), enUS as TranslationMap)
 
+// Connect-handshake timeout: a hung MCP server should fail startup fast rather
+// than block on the per-request 60s timeout. Overridable via env for tests.
+const DEFAULT_CONNECT_TIMEOUT_MS = 15_000
+
+function connectTimeoutMs(): number {
+  const env = Number(process.env.MIPHAM_MCP_CONNECT_TIMEOUT_MS)
+  return Number.isFinite(env) && env > 0 ? env : DEFAULT_CONNECT_TIMEOUT_MS
+}
+
 interface ActiveConnection {
   config: McpServerConfig
   transport: Transport
@@ -167,33 +176,63 @@ export class McpClient {
     this.connections.set(config.name, connection)
 
     try {
-      // Start the transport (transport-specific), then perform the handshake.
-      if (transport instanceof HttpTransport) {
-        await transport.start(config.url ?? '', config.headers, config.env)
-      } else {
-        await transport.start(config.command ?? '', config.args ?? [], config.env)
-      }
-      const initResult: InitializeResult = await protocol.initialize()
+      await this.withConnectTimeout(config.name, async () => {
+        // Start the transport (transport-specific), then perform the handshake.
+        if (transport instanceof HttpTransport) {
+          await transport.start(config.url ?? '', config.headers, config.env)
+        } else {
+          await transport.start(config.command ?? '', config.args ?? [], config.env)
+        }
+        const initResult: InitializeResult = await protocol.initialize()
 
-      connection.status = 'connected'
-      connection.serverInfo = initResult.serverInfo
+        connection.status = 'connected'
+        connection.serverInfo = initResult.serverInfo
 
-      // Wire tools-changed notification
-      protocol.on('tools-changed', async () => {
-        await this.onToolsChanged(config.name)
-      })
+        // Wire tools-changed notification
+        protocol.on('tools-changed', async () => {
+          await this.onToolsChanged(config.name)
+        })
 
-      // Discover tools
-      if (initResult.capabilities.tools) {
-        connection.tools = await protocol.listTools()
-      }
+        // Discover tools
+        if (initResult.capabilities.tools) {
+          connection.tools = await protocol.listTools()
+        }
+      })
     } catch (err) {
       connection.status = 'error'
       connection.error = String(err)
+      try {
+        await transport.close()
+      } catch {
+        // Best-effort cleanup on a failed connect
+      }
       throw err
     }
   }
 
+  /** Race the connect handshake against a timeout so a hung server fails fast. */
+  private async withConnectTimeout<T>(name: string, fn: () => Promise<T>): Promise<T> {
+    const timeoutMs = connectTimeoutMs()
+    let timer: ReturnType<typeof setTimeout> | null = null
+    // Swallow a late rejection: if the timeout wins, transport.close() in the
+    // caller's catch makes fn()'s pending request reject after we've moved on.
+    const work = fn()
+    work.catch(() => {})
+    try {
+      return await Promise.race([
+        work,
+        new Promise<never>((_, reject) => {
+          timer = setTimeout(
+            () => reject(new Error(`MCP connect timed out for "${name}" after ${timeoutMs}ms`)),
+            timeoutMs,
+          )
+        }),
+      ])
+    } finally {
+      if (timer) clearTimeout(timer)
+    }
+  }
+
   /**
    * Disconnect an MCP server and return the names of its registered tools
    * so the caller can unregister them from the central tool registry.

package/src/mcp/http-transport.ts

@@ -119,6 +119,7 @@ export class HttpTransport implements Transport {
         },
         body: JSON.stringify(request),
         signal: controller.signal,
+        redirect: 'manual',
       })
 
       if (!response.ok) {
@@ -164,6 +165,7 @@ export class HttpTransport implements Transport {
         ...this.headers,
       },
       body: JSON.stringify(notification),
+      redirect: 'manual',
     }).catch(() => {
       /* notifications are best-effort */
     })

package/src/mcp/oauth.ts

@@ -68,7 +68,7 @@ export class OAuthClient {
           resolve(receivedCode)
         }
       })
-      server.listen(port, () => {
+      server.listen(port, '127.0.0.1', () => {
         const authUrl = new URL(auth.authorizationUrl)
         authUrl.searchParams.set('response_type', 'code')
         authUrl.searchParams.set('client_id', auth.clientId)

package/src/providers/llm-replay.ts

@@ -0,0 +1,36 @@
+import type { Llm } from './llm'
+import type { ChatRequest } from './registry'
+import type { StreamChunk } from '../shared'
+
+export interface RecordedTurn {
+  req: ChatRequest
+  chunks: StreamChunk[]
+}
+
+/** 包装一个 Llm：委托的同时记录每轮 (req, chunks)。 */
+export function recordLlm(inner: Llm): { llm: Llm; turns: RecordedTurn[] } {
+  const turns: RecordedTurn[] = []
+  const llm: Llm = {
+    async *chat(req) {
+      const chunks: StreamChunk[] = []
+      for await (const chunk of inner.chat(req)) {
+        chunks.push(chunk)
+        yield chunk
+      }
+      turns.push({ req, chunks })
+    },
+  }
+  return { llm, turns }
+}
+
+/** 回放已记录的 turns（确定性、无网络）。按顺序消费，超出则静默结束。 */
+export function replayLlm(turns: RecordedTurn[]): Llm {
+  let cursor = 0
+  return {
+    async *chat() {
+      const turn = turns[cursor++]
+      if (!turn) return
+      for (const chunk of turn.chunks) yield chunk
+    },
+  }
+}

package/src/providers/llm.ts

@@ -0,0 +1,16 @@
+import type { Context, Disposer } from '../vajra'
+import type { ChatRequest } from './registry'
+import type { StreamChunk } from '../shared'
+
+/** LLM 适配缝的 capability —— chat 能力。换 provider = 换 chat 实现，engine 零 fork 跟随。 */
+export interface Llm {
+  chat(req: ChatRequest): AsyncGenerator<StreamChunk>
+}
+
+/** 缝键：ctx.llm。 */
+export const LLM_KEY = 'llm'
+
+/** 把一个 Llm（如 ProviderRegistry 或 llm-replay）挂载为 ctx.llm。 */
+export function mountLlm(ctx: Context, llm: Llm): Disposer {
+  return ctx.provide(LLM_KEY, llm)
+}

package/src/providers/registry.ts

@@ -1,4 +1,5 @@
 import type { ProviderConfig, ModelInfo, Message, StreamChunk } from '../shared/index.ts'
+import type { Llm } from './llm'
 
 export interface ProviderInstance {
   config: ProviderConfig
@@ -17,7 +18,7 @@ export interface ChatRequest {
   signal?: AbortSignal
 }
 
-export class ProviderRegistry {
+export class ProviderRegistry implements Llm {
   private providers = new Map<string, ProviderInstance>()
   private activeProviderId: string
   private activeModelId: string

package/src/security/gate.ts

@@ -90,4 +90,14 @@ export class SecurityGate {
     }
     return { blocked: false }
   }
+
+  /** Redact known API-key-shaped tokens from output (defense-in-depth beyond config patterns). */
+  static redactCredentialLeak(output: string): string {
+    if (!this.checkCredentialLeak(output).blocked) return output
+    let out = output
+    for (const { regex } of API_KEY_PATTERNS) {
+      out = out.replace(new RegExp(regex.source, 'gi'), '[REDACTED]')
+    }
+    return out
+  }
 }

package/src/security/url.ts

@@ -1,10 +1,4 @@
 import dns from 'node:dns'
-const { lookupSync } = dns as unknown as {
-  lookupSync: (
-    hostname: string,
-    options?: { all?: boolean },
-  ) => Array<{ address: string; family: number }>
-}
 
 // ── Protocol allow-list ──
 const ALLOWED_PROTOCOLS = ['http:', 'https:']
@@ -20,7 +14,7 @@ const IPV4_BLOCKED = [
 ]
 
 /** Validate a URL for SSRF safety. Returns null if safe, or an error string. */
-export function validateUrl(urlStr: string): string | null {
+export async function validateUrl(urlStr: string): Promise<string | null> {
   let parsed: URL
   try {
     parsed = new URL(urlStr)
@@ -41,18 +35,17 @@ export function validateUrl(urlStr: string): string | null {
     return `URL hostname "${hostname}" resolves to a blocked IP range (private / loopback / link-local).`
   }
 
-  // 3. Check for raw IPv6 loopback / private
-  // Strip brackets from IPv6 hostnames (Bun's URL parser keeps them)
+  // 3. Check for raw IPv6 loopback / private / IPv4-mapped
   const ipv6Host = hostname.startsWith('[') ? hostname.slice(1, -1) : hostname
   if (isBlockedIPv6(ipv6Host)) {
     return `URL hostname "${hostname}" resolves to a blocked IPv6 address.`
   }
 
-  // 4. DNS rebinding protection: resolve hostname and check resolved IPs
-  // Use the bracket-less version for DNS lookups
-  const dnsHostname = hostname.startsWith('[') ? hostname.slice(1, -1) : hostname
+  // 4. DNS rebinding protection: resolve hostname and check resolved IPs.
+  //    Uses async dns.promises.lookup — the old sync `dns.lookupSync` never existed,
+  //    so this check was previously dead code (always threw → swallowed → "safe").
   try {
-    const addresses = lookupSync(dnsHostname, { all: true })
+    const addresses = await dns.promises.lookup(ipv6Host, { all: true })
     for (const addr of addresses) {
       if (isBlockedIPv4(addr.address)) {
         return `URL hostname "${hostname}" resolved to ${addr.address} (blocked IP range).`
@@ -62,7 +55,7 @@ export function validateUrl(urlStr: string): string | null {
       }
     }
   } catch {
-    // DNS resolution failed — that's OK for validation; the fetch will also fail
+    // DNS resolution failed — the subsequent fetch will fail too; treat as safe.
   }
 
   return null // safe
@@ -92,5 +85,35 @@ function isBlockedIPv6(ip: string): boolean {
   if (ip.startsWith('fc') || ip.startsWith('fd')) return true
   // IPv6 unspecified
   if (ip === '::' || ip === '0:0:0:0:0:0:0:0') return true
+
+  // IPv4-mapped (::ffff:a.b.c.d / ::ffff:xxxx:xxxx) and IPv4-compatible (::a.b.c.d / ::xxxx:xxxx)
+  // — these can smuggle a private IPv4 past the literal-IPv6 checks above.
+  const embedded = extractEmbeddedIPv4(ip)
+  if (embedded && isBlockedIPv4(embedded)) return true
+
   return false
 }
+
+/** Extract the IPv4 address embedded in an IPv4-mapped / IPv4-compatible IPv6 address. */
+function extractEmbeddedIPv4(ip: string): string | null {
+  let rest: string | null = null
+  const mapped = ip.match(/^::ffff:(.+)$/i)
+  const compat = ip.match(/^::([0-9a-fA-F]{1,4}):([0-9a-fA-F]{1,4})$/)
+  if (mapped) {
+    rest = mapped[1]!
+  } else if (compat) {
+    rest = `${compat[1]}:${compat[2]}`
+  } else {
+    return null
+  }
+
+  // Dotted-quad form (::ffff:127.0.0.1)
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(rest)) return rest
+
+  // Hex form (::ffff:7f00:1)
+  const hex = rest.match(/^([0-9a-fA-F]{1,4}):([0-9a-fA-F]{1,4})$/)
+  if (!hex) return null
+  const hi = parseInt(hex[1]!, 16)
+  const lo = parseInt(hex[2]!, 16)
+  return `${hi >> 8}.${hi & 0xff}.${lo >> 8}.${lo & 0xff}`
+}