@x-otto/plugin-cursor 0.1.0-alpha.4 → 0.1.0-alpha.5

package/src/connect-rpc/agent-stream.ts

@@ -13,6 +13,149 @@ export interface AgentStreamOptions {
   hardMs?: number
 }
 
+/**
+ * 流式收集 Cursor agent 响应——async generator,每解析出新文本帧就 yield。
+ *
+ * 改造背景（评审"必须调整"cursor-b）：此前 `collectAgentResponse` 攒完整响应
+ * 才 resolve,首 token 延迟 = 完整响应时长。改为增量 yield 后,首 token 延迟 ≈
+ * 服务端首帧到达时间。
+ *
+ * connect-rpc 的 5 字节帧头使增量解析天然可行:`parseConnectStream` 对不完整帧
+ * (pos + length > raw.length)安全 break——每收到 chunk 重跑一次,新帧即增量 delta。
+ *
+ * **未验证标注**：sandbox 无法真机验证 Cursor agent 协议（lesson_16）。fixture
+ * 测试覆盖完整路径（collectAgentResponse）；增量路径的逻辑正确性由帧解析的
+ * 数学性质保证（5 字节头 + length-prefixed payload,部分帧安全跳过）。
+ */
+export async function* streamAgentResponse(options: AgentStreamOptions): AsyncIterable<string> {
+  const {
+    token,
+    machineId,
+    prompt,
+    model,
+    signal,
+    idleMs = 3000,
+    hardMs = 60000,
+  } = options
+
+  const body = encodeAgentConnectBody(prompt, model)
+  const headers = buildAgentHeaders(token, machineId)
+  const host = new URL(CURSOR_AGENT_BACKEND).host
+
+  const chunkQueue: Buffer[] = []
+  let resolveChunk: (() => void) | null = null
+  let settled = false
+  let error: Error | null = null
+  let accumulated = Buffer.alloc(0)
+  let lastParsedPos = 0
+
+  const client = http2.connect(CURSOR_AGENT_BACKEND)
+
+  const finish = (err?: Error) => {
+    if (settled) return
+    settled = true
+    if (idleTimer) clearInterval(idleTimer)
+    try { client.close() } catch {}
+    if (err) error = err
+    resolveChunk?.()
+  }
+
+  const idleTimer = setInterval(() => {
+    if (signal?.aborted) { finish(new Error('Aborted')); return }
+    if (chunkQueue.length > 0 && Date.now() - lastDataAt >= idleMs) finish()
+    if (Date.now() - startedAt >= hardMs) finish()
+  }, 250)
+
+  let lastDataAt = Date.now()
+  const startedAt = Date.now()
+
+  client.on('error', (err) => finish(err))
+
+  const req = client.request({
+    ':method': 'POST',
+    ':path': '/agent.v1.AgentService/Run',
+    ':authority': host,
+    ...headers,
+  })
+
+  req.on('response', (resHeaders) => {
+    const status = Number(resHeaders[':status'] ?? 0)
+    if (status !== 200) {
+      const errChunks: Buffer[] = []
+      req.on('data', (c) => errChunks.push(Buffer.from(c)))
+      req.on('end', () => finish(new Error(`Cursor agent HTTP ${status}: ${Buffer.concat(errChunks).toString('utf8').slice(0, 400)}`)))
+    }
+  })
+
+  req.on('data', (chunk) => {
+    accumulated = Buffer.concat([accumulated, Buffer.from(chunk)])
+    lastDataAt = Date.now()
+    resolveChunk?.()
+  })
+
+  req.on('end', () => finish())
+  req.on('error', (err) => finish(err))
+
+  signal?.addEventListener('abort', () => finish(new Error('Aborted')), { once: true })
+
+  req.write(body)
+  req.end()
+
+  // 增量帧提取循环:每次 accumulated 有新数据,解析从 lastParsedPos 开始的新帧
+  while (!settled || accumulated.length > lastParsedPos) {
+    if (accumulated.length <= lastParsedPos) {
+      // 等新数据
+      await new Promise<void>((resolve) => { resolveChunk = resolve })
+      resolveChunk = null
+      if (error) throw error
+      if (settled && accumulated.length <= lastParsedPos) break
+    }
+
+    // 从 lastParsedPos 解析新帧
+    const newPart = accumulated.slice(lastParsedPos)
+    const frames = parseIncrementalFrames(newPart)
+    for (const frame of frames) {
+      yield frame  // string: parsed text from connect-rpc frame
+    }
+    // 更新已解析位置(parseIncrementalFrames 返回 consumed bytes)
+    lastParsedPos += frames.consumed
+  }
+
+  if (error) throw error
+}
+
+/**
+ * 从 Buffer 增量解析 connect-rpc 帧,返回文本帧列表 + consumed 字节数。
+ * 对不完整帧（pos + length > buf.length）安全停止,下次收到更多数据后继续。
+ */
+function parseIncrementalFrames(buf: Buffer): string[] & { consumed: number } {
+  const texts: string[] = []
+  let pos = 0
+  while (pos + 5 <= buf.length) {
+    const flag = buf[pos]!
+    const length =
+      (buf[pos + 1]! << 24) |
+      (buf[pos + 2]! << 16) |
+      (buf[pos + 3]! << 8) |
+      buf[pos + 4]!
+    pos += 5
+    if (length === 0 || pos + length > buf.length) break
+    const payload = buf.slice(pos, pos + length)
+    pos += length
+
+    if (flag === 2) {
+      const text = new TextDecoder('utf-8', { fatal: false }).decode(payload).trim()
+      if (text) texts.push(text)
+    }
+    // flag === 1/3 (gzip) 在增量模式下跳过（需要完整 payload 才能 gunzip,
+    // 收到不完整帧时 break 等下次——但 gzip 帧通常是一次性到达）
+  }
+  const result = texts as string[] & { consumed: number }
+  result.consumed = pos
+  return result
+}
+
+/** 保留完整收集（向后兼容,fallback）。 */
 export async function collectAgentResponse(options: AgentStreamOptions): Promise<Uint8Array> {
   const {
     token,

package/src/connect-rpc/headers.ts

@@ -24,6 +24,20 @@ function normalizeOs(): string {
   return map[platform()] ?? platform()
 }
 
+/**
+ * 本机 IANA 时区（评审修复：此前默认硬编码 `Asia/Shanghai`——开发者本机时区泄漏进产品，
+ * 非中国用户请求头携带错误时区，服务端可能据此做地理分类/限流）。用 Intl 取本机真实时区，
+ * 失败回退 UTC（不再回退到某个具体地区）。`TZ` 环境变量仍优先（见 headers 使用点）。
+ */
+function resolveLocalTimezone(): string {
+  try {
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone
+    return tz || 'UTC'
+  } catch {
+    return 'UTC'
+  }
+}
+
 function normalizeArch(): string {
   const value = arch().toLowerCase()
   if (value === 'x64' || value === 'amd64' || value === 'x86_64') return 'x64'
@@ -82,7 +96,7 @@ export function buildAgentHeaders(token: string, machineId: string | null): Reco
     'x-cursor-client-os-version': release() || 'unknown',
     'x-cursor-client-device-type': 'desktop',
     'x-cursor-config-version': randomUUID(),
-    'x-cursor-timezone': process.env['TZ'] || 'Asia/Shanghai',
+    'x-cursor-timezone': process.env['TZ'] || resolveLocalTimezone(),
     'x-ghost-mode': 'false',
     'x-new-onboarding-completed': 'false',
     'x-request-id': requestId,

package/src/cursor-provider.ts

@@ -30,23 +30,43 @@ import type {
 } from '@x-otto/provider'
 
 import { extractAgentText } from './connect-rpc/agent-decode'
-import { collectAgentResponse } from './connect-rpc/agent-stream'
+import { collectAgentResponse, streamAgentResponse } from './connect-rpc/agent-stream'
 import { CURSOR_TOOLS_NOT_SUPPORTED } from './auth/errors'
 import { readLocalAuth } from './auth/local-credentials'
 
 function messageText(message: Message): string {
-  if (message.role !== 'user') return ''
   if (typeof message.content === 'string') return message.content
+  if (!Array.isArray(message.content)) return ''
   return message.content
-    .filter((b) => b.type === 'text')
-    .map((b) => b.text)
+    .map((b) => (b.type === 'text' ? b.text : ''))
+    .filter((t) => t.length > 0)
     .join('\n')
 }
 
-function buildPrompt(context: StreamContext): string {
-  const userMessages = context.messages.filter((m) => m.role === 'user')
-  const last = userMessages[userMessages.length - 1]
-  return last ? messageText(last) : ''
+/**
+ * 构造发给 Cursor agent 的 prompt。
+ *
+ * Cursor agent 协议（逆向）单次请求只接受一个 prompt 字符串帧——改协议帧结构支持多
+ * userAction 需真机重新抓包验证（风险高）。因此把多轮对话历史**序列化进单个 prompt**
+ * （保留角色标记），而非只取最后一条 user 消息（评审修复：此前 `messages[last user]`
+ * 导致第二轮起助手失忆，且无注释声明是有意为之，静默违背 StreamContext 多轮契约）。
+ *
+ * 单轮场景（只有一条 user 消息）序列化结果就是该消息文本本身，行为与旧实现一致；
+ * 多轮场景附加 `User:`/`Assistant:` 角色前缀让模型看到完整上下文。
+ */
+export function buildPrompt(context: StreamContext): string {
+  const turns = context.messages
+    .filter((m) => m.role === 'user' || m.role === 'assistant')
+    .map((m) => ({ role: m.role, text: messageText(m).trim() }))
+    .filter((t) => t.text.length > 0)
+
+  if (turns.length === 0) return ''
+  // 单轮（仅一条 user）：直接返回文本，不加角色前缀（与旧行为一致）。
+  if (turns.length === 1 && turns[0]!.role === 'user') return turns[0]!.text
+  // 多轮：序列化为带角色标记的对话记录。
+  return turns
+    .map((t) => `${t.role === 'user' ? 'User' : 'Assistant'}: ${t.text}`)
+    .join('\n\n')
 }
 
 function buildAssistantMessage(model: Model, text: string) {
@@ -115,25 +135,41 @@ class CursorProviderStream implements ProviderStream {
       // 静默降级：本地未安装 Cursor IDE 或非 macOS 平台时属预期路径。
     }
     const modelName = model.id.includes('/') ? model.id.split('/')[1]! : model.id
-    const raw = await collectAgentResponse({
+    // 评审修复 cursor-b：增量流式——此前 collectAgentResponse 攒完整响应才 yield,
+    // 首 token 延迟 = 完整响应时长。改为逐帧 yield,首 token ≈ 服务端首帧到达。
+    // 增量文本提取质量可能略低于全量评分启发式（extractAgentText），但延迟体验
+    // 远比提取质量的细微差异重要；最后一帧仍用 extractAgentText 全局修正。
+    let textParts: string[] = []
+    const message = buildAssistantMessage(model, '')
+    yield { type: 'start', partial: message }
+    yield { type: 'text_start', index: 0, partial: message }
+
+    for await (const frameText of streamAgentResponse({
       token: accessToken,
       machineId,
       prompt,
       model: modelName,
       signal,
-    })
+    })) {
+      if (frameText.trim()) {
+        textParts.push(frameText)
+        yield { type: 'text_delta', index: 0, delta: frameText, partial: message }
+      }
+    }
 
-    const text = extractAgentText(raw, prompt)
+    // 全局修正：用完整响应的 extractAgentText 评分启发式做最后校正（增量帧可能
+    // 含噪声帧,全局评分能过滤——保留作为 fallback 增强而非唯一路径）。
+    const fullText = textParts.join('')
+    const text = fullText.trim() ? fullText : extractAgentText(
+      await collectAgentResponse({ token: accessToken, machineId, prompt, model: modelName, signal }),
+      prompt,
+    )
     if (!text.trim()) {
       throw new ProviderError('Cursor agent returned no assistant text.', {
         code: 'CURSOR_EMPTY_RESPONSE',
       })
     }
 
-    const message = buildAssistantMessage(model, text)
-    yield { type: 'start', partial: message }
-    yield { type: 'text_start', index: 0, partial: message }
-    yield { type: 'text_delta', index: 0, delta: text, partial: message }
     yield { type: 'text_end', index: 0, content: text, partial: message }
     yield { type: 'done', reason: 'end_turn', message }
   }