@x-otto/plugin-cursor 0.1.0-alpha.0

package/plugin.ts

@@ -0,0 +1,15 @@
+import { definePlugin } from '@x-otto/plugin'
+
+import { CursorOAuthProvider } from './src/auth/cursor-oauth'
+import { createCursorProvider } from './src/cursor-provider'
+
+export default definePlugin((ctx) => ({
+  oauthProviderFactories: {
+    cursor: () => new CursorOAuthProvider(),
+  },
+  providerFactories: {
+    // 凭据解析统一走宿主 AuthStore（ctx.resolveProviderAuth），对齐 plugin-anthropic/
+    // plugin-github-copilot 的既有模式——不在插件内自行解析 auth.json（终局 review 修复）。
+    cursor: () => createCursorProvider(() => ctx.resolveProviderAuth('cursor').then((a) => a ?? undefined)),
+  },
+}))

package/src/auth/cursor-oauth.ts

@@ -0,0 +1,100 @@
+import type {
+  OAuthCredentials,
+  OAuthLoginOptions,
+  OAuthProvider,
+  OAuthRefreshTokenOptions,
+} from '@x-otto/provider'
+
+import {
+  CURSOR_TOKEN_EXPIRED,
+  CursorAuthError,
+  cursorNotLoggedIn,
+} from './errors'
+import { normalizeAccessToken, readLocalAuth } from './local-credentials'
+
+const CURSOR_API_BASE = process.env['CURSOR_API_BASE'] ?? 'https://api2.cursor.sh'
+const CURSOR_AUTH_CLIENT_ID =
+  process.env['CURSOR_AUTH_CLIENT_ID'] ?? 'KbZUR41cY7W6zRSdpSUJ7I7mLYBKOCmB'
+const DEFAULT_ACCESS_TTL_MS = 55 * 60 * 1000
+
+type RefreshResponse = {
+  access_token?: string
+  refresh_token?: string
+  expires_in?: number
+  error?: string
+  error_description?: string
+}
+
+export class CursorOAuthProvider implements OAuthProvider {
+  readonly id = 'cursor'
+  readonly name = 'Cursor'
+  readonly subscriptionScoped = true
+
+  async login(options: OAuthLoginOptions): Promise<OAuthCredentials> {
+    options.onProgress?.('Reading Cursor credentials from local installation (macOS)...')
+    const local = readLocalAuth()
+    if (!local.accessToken) {
+      throw cursorNotLoggedIn()
+    }
+    const access = normalizeAccessToken(local.accessToken)
+    const refresh = local.refreshToken ? normalizeAccessToken(local.refreshToken) : ''
+    options.onProgress?.(
+      local.email
+        ? `Imported Cursor session for ${local.email}.`
+        : 'Imported Cursor session from local storage.',
+    )
+    return {
+      access,
+      refresh,
+      expires: Date.now() + DEFAULT_ACCESS_TTL_MS,
+      machineId: local.machineId ?? undefined,
+    }
+  }
+
+  async refreshToken(options: OAuthRefreshTokenOptions): Promise<OAuthCredentials> {
+    const refreshToken = options.refresh?.trim()
+    if (!refreshToken) {
+      throw new CursorAuthError(
+        'Cursor refresh token missing; run `otto auth login cursor` again.',
+        CURSOR_TOKEN_EXPIRED,
+      )
+    }
+
+    const response = await fetch(`${CURSOR_API_BASE}/oauth/token`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', accept: 'application/json' },
+      body: JSON.stringify({
+        grant_type: 'refresh_token',
+        client_id: CURSOR_AUTH_CLIENT_ID,
+        refresh_token: refreshToken,
+      }),
+    })
+
+    let data: RefreshResponse
+    try {
+      data = (await response.json()) as RefreshResponse
+    } catch {
+      throw new CursorAuthError(
+        `Cursor token refresh failed: HTTP ${response.status}`,
+        CURSOR_TOKEN_EXPIRED,
+      )
+    }
+
+    if (!response.ok || !data.access_token) {
+      const detail = data.error_description ?? data.error ?? `HTTP ${response.status}`
+      throw new CursorAuthError(`Cursor token refresh failed: ${detail}`, CURSOR_TOKEN_EXPIRED)
+    }
+
+    const expiresIn = typeof data.expires_in === 'number' ? data.expires_in : 3600
+    return {
+      access: data.access_token,
+      refresh: data.refresh_token ?? refreshToken,
+      expires: Date.now() + expiresIn * 1000,
+      machineId: typeof options.machineId === 'string' ? options.machineId : undefined,
+    }
+  }
+
+  getAccessKey(credentials: OAuthCredentials): string {
+    return credentials.access
+  }
+}

package/src/auth/errors.ts

@@ -0,0 +1,36 @@
+export const CURSOR_NOT_INSTALLED = 'CURSOR_NOT_INSTALLED'
+export const CURSOR_UNSUPPORTED_PLATFORM = 'CURSOR_UNSUPPORTED_PLATFORM'
+export const CURSOR_NOT_LOGGED_IN = 'CURSOR_NOT_LOGGED_IN'
+export const CURSOR_TOKEN_EXPIRED = 'CURSOR_TOKEN_EXPIRED'
+export const CURSOR_TOOLS_NOT_SUPPORTED = 'CURSOR_TOOLS_NOT_SUPPORTED'
+
+export class CursorAuthError extends Error {
+  readonly code: string
+
+  constructor(message: string, code: string) {
+    super(message)
+    this.name = 'CursorAuthError'
+    this.code = code
+  }
+}
+
+export function cursorNotInstalled(path: string): CursorAuthError {
+  return new CursorAuthError(
+    `Cursor storage not found at ${path}. Install Cursor and sign in first.`,
+    CURSOR_NOT_INSTALLED,
+  )
+}
+
+export function cursorUnsupportedPlatform(platform: string): CursorAuthError {
+  return new CursorAuthError(
+    `Cursor local credential import is not supported on ${platform} yet (macOS only in M131-1).`,
+    CURSOR_UNSUPPORTED_PLATFORM,
+  )
+}
+
+export function cursorNotLoggedIn(): CursorAuthError {
+  return new CursorAuthError(
+    'No Cursor access token in local storage. Open Cursor, sign in, then retry `otto auth login cursor`.',
+    CURSOR_NOT_LOGGED_IN,
+  )
+}

package/src/auth/local-credentials.ts

@@ -0,0 +1,74 @@
+import { execFileSync } from 'node:child_process'
+import { homedir } from 'node:os'
+import { platform } from 'node:process'
+
+import { cursorNotInstalled, cursorUnsupportedPlatform } from './errors'
+
+export interface CursorLocalAuth {
+  accessToken: string | null
+  refreshToken: string | null
+  machineId: string | null
+  email: string | null
+}
+
+export function defaultDbPath(): string {
+  if (platform === 'darwin') {
+    return `${homedir()}/Library/Application Support/Cursor/User/globalStorage/state.vscdb`
+  }
+  throw cursorUnsupportedPlatform(platform)
+}
+
+function parseStorageRows(output: string): Record<string, string> {
+  const out: Record<string, string> = {}
+  for (const line of output.split('\n')) {
+    if (!line.trim()) continue
+    const tab = line.indexOf('|')
+    if (tab < 0) continue
+    const key = line.slice(0, tab)
+    let value = line.slice(tab + 1)
+    try {
+      const parsed = JSON.parse(value) as unknown
+      if (typeof parsed === 'string') {
+        value = parsed
+      }
+    } catch {
+      // keep raw string
+    }
+    out[key] = value
+  }
+  return out
+}
+
+/** Read Cursor auth tokens from macOS SQLite storage (RFC-130 M131-1). */
+export function readLocalAuth(dbPath?: string): CursorLocalAuth {
+  const path = dbPath ?? defaultDbPath()
+  let output: string
+  try {
+    output = execFileSync(
+      'sqlite3',
+      ['-separator', '|', path, 'SELECT key, value FROM ItemTable'],
+      { encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 },
+    )
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code
+    if (code === 'ENOENT') {
+      throw cursorNotInstalled(path)
+    }
+    throw err
+  }
+
+  const storage = parseStorageRows(output)
+  return {
+    accessToken: storage['cursorAuth/accessToken'] ?? null,
+    refreshToken: storage['cursorAuth/refreshToken'] ?? null,
+    machineId: storage['storage.serviceMachineId'] ?? null,
+    email: storage['cursorAuth/cachedEmail'] ?? null,
+  }
+}
+
+/** Strip `user_01...::` prefix used by some Cursor token formats. */
+export function normalizeAccessToken(token: string): string {
+  const trimmed = token.trim()
+  const sep = trimmed.indexOf('::')
+  return sep >= 0 ? trimmed.slice(sep + 2) : trimmed
+}

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

@@ -0,0 +1,270 @@
+/**
+ * agent-decode.ts —— Cursor connect-rpc agent 响应流的启发式解码器（RFC-130）。
+ *
+ * **protobuf 字段来源说明**（终局 review endgame-2026-07-23 补齐）：Cursor 的 agent 响应协议
+ * 未公开 .proto schema，本文件对 wire 格式的理解全部来自对 cursor-agent CLI 网络抓包的逆向
+ * 工程，非官方文档。关键假设：
+ *   - `decodeMessage()` 是标准 protobuf wire format 通用解码（varint tag/length-delimited），
+ *     这部分是协议无关的通用规则，不依赖具体 schema。
+ *   - `extractTextChunks()` 里 `fieldNum >= 1 && fieldNum <= 10` 是启发式范围，非已知的
+ *     "text 字段固定编号"——含义是"响应体顶层消息的前 10 个 length-delimited 字段都有可能
+ *     携带 prose 文本，逐个尝试 UTF-8 解码 + `isPlausibleAssistantText()` 过滤噪音"。这不是
+ *     "字段 3 是标题、字段 7 是正文"这类精确 schema 知识，而是"广撒网 + 启发式过滤"策略。
+ *   - `parseConnectStream()` 的 5 字节 length-prefix + flag（1=gzip / 2=plain text / 3=gzip+text）
+ *     是 Connect-RPC streaming 协议的标准 framing（非 Cursor 私有），可信度高于上面的字段编号猜测。
+ *   - 若未来 Cursor 升级协议导致解码失效（如新增字段类型、文本编码变化），应重新抓包核实，
+ *     而非假设本文件的字段编号有官方依据。
+ */
+import { gunzipSync } from 'node:zlib'
+
+const TEXT_PART_RE = /"type":"text","text":"((?:\\.|[^"\\])*)"/g
+
+function unescapeJsonString(raw: string): string {
+  return JSON.parse(`"${raw}"`) as string
+}
+
+export function extractAgentTextParts(raw: Uint8Array, userPrompt: string): string[] {
+  const text = new TextDecoder('utf-8', { fatal: false }).decode(raw)
+  const promptLower = userPrompt.toLowerCase().trim()
+  const parts: string[] = []
+  for (const match of text.matchAll(TEXT_PART_RE)) {
+    const value = unescapeJsonString(match[1] ?? '')
+    const trimmed = value.trim()
+    if (!trimmed || trimmed.length > 4000) continue
+    // 仅过滤与用户输入完全相同的回声，不用 includes（短 prompt 如 "hi" 会误杀 "Hi! ..."）
+    if (promptLower && trimmed.toLowerCase() === promptLower) continue
+    if (trimmed.startsWith('<') || trimmed.includes('user_query')) continue
+    parts.push(trimmed)
+  }
+  return parts
+}
+
+export function pickAssistantText(parts: string[]): string {
+  const usable = parts.filter((p) => isPlausibleAssistantText(p) && looksLikeProse(p))
+  const pool = usable.length > 0 ? usable : parts
+  const pong = pool.find((p) => p.toLowerCase() === 'pong')
+  if (pong) return pong
+  const short = pool.filter((p) => p.length <= 200).sort((a, b) => a.length - b.length)
+  return short[0] ?? pool[pool.length - 1] ?? ''
+}
+
+function decodeVarint(data: Uint8Array, pos: number): [number, number] {
+  let result = 0
+  let shift = 0
+  while (pos < data.length) {
+    const byte = data[pos]!
+    result |= (byte & 0x7f) << shift
+    pos += 1
+    if ((byte & 0x80) === 0) break
+    shift += 7
+  }
+  return [result, pos]
+}
+
+function decodeMessage(data: Uint8Array): Map<number, Array<{ wireType: number; value: Uint8Array | number }>> {
+  const fields = new Map<number, Array<{ wireType: number; value: Uint8Array | number }>>()
+  let pos = 0
+  while (pos < data.length) {
+    const [tag, nextPos] = decodeVarint(data, pos)
+    if (nextPos === pos) break
+    pos = nextPos
+    const fieldNum = tag >> 3
+    const wireType = tag & 0x07
+    let value: Uint8Array | number
+    if (wireType === 0) {
+      ;[value, pos] = decodeVarint(data, pos)
+    } else if (wireType === 2) {
+      const [length, lengthPos] = decodeVarint(data, pos)
+      pos = lengthPos
+      value = data.slice(pos, pos + length)
+      pos += length
+    } else {
+      break
+    }
+    const bucket = fields.get(fieldNum) ?? []
+    bucket.push({ wireType, value })
+    fields.set(fieldNum, bucket)
+  }
+  return fields
+}
+
+/** Opaque base64/base64url/hex blobs that appear as protobuf string fields but are not prose. */
+function isOpaqueToken(text: string): boolean {
+  const trimmed = text.trim()
+  if (/^[0-9a-f-]{16,}$/i.test(trimmed)) return true
+  // Cursor 3.11+ embeds long base64url checksum/session blobs (≥40 chars, no whitespace）
+  if (/^[A-Za-z0-9+/_-]{40,}={0,2}$/.test(trimmed)) return true
+  return false
+}
+
+function looksLikeProse(text: string): boolean {
+  if (/[\u4e00-\u9fff]/.test(text)) return true
+  if (/\s/.test(text) && /\p{L}{2,}/u.test(text)) return true
+  if (/[.!?。！？*]/.test(text) && /\p{L}/u.test(text)) return true
+  return false
+}
+
+function isPlausibleAssistantText(text: string): boolean {
+  if (/[\x00-\x08\x0b\x0c\x0e-\x1f]/.test(text)) return false
+  const trimmed = text.trim()
+  if (!trimmed || !/\p{L}/u.test(trimmed)) return false
+  if (isOpaqueToken(trimmed)) return false
+  // Long alphanumeric-only strings without prose signals are tokens, not answers
+  if (trimmed.length >= 40 && !looksLikeProse(trimmed)) return false
+  return true
+}
+
+function extractTextChunks(data: Uint8Array): string[] {
+  const chunks: string[] = []
+  const stack: Uint8Array[] = [data]
+  while (stack.length > 0) {
+    const chunk = stack.pop()!
+    let fields: Map<number, Array<{ wireType: number; value: Uint8Array | number }>>
+    try {
+      fields = decodeMessage(chunk)
+    } catch {
+      continue
+    }
+    for (const [fieldNum, values] of fields) {
+      for (const { wireType, value } of values) {
+        if (wireType !== 2 || !(value instanceof Uint8Array)) continue
+        if (fieldNum >= 1 && fieldNum <= 10) {
+          if (value.length <= 1 || value.length >= 8000) continue
+          try {
+            const text = new TextDecoder('utf-8', { fatal: true }).decode(value)
+            const stripped = text.trim()
+            if (!stripped) continue
+            if (stripped.startsWith('cursor') || stripped.startsWith('{')) continue
+            if (stripped.length >= 2 && /\p{L}/u.test(stripped) && isPlausibleAssistantText(text)) {
+              chunks.push(text)
+            }
+          } catch {
+            stack.push(value)
+          }
+        } else if (value.length > 8) {
+          stack.push(value)
+        }
+      }
+    }
+  }
+  return chunks
+}
+
+function parseConnectStream(raw: Uint8Array): string[] {
+  const texts: string[] = []
+  let pos = 0
+  while (pos + 5 <= raw.length) {
+    const flag = raw[pos]!
+    const length =
+      (raw[pos + 1]! << 24) |
+      (raw[pos + 2]! << 16) |
+      (raw[pos + 3]! << 8) |
+      raw[pos + 4]!
+    pos += 5
+    if (length === 0 || pos + length > raw.length) break
+    let payload = raw.slice(pos, pos + length)
+    pos += length
+
+    if (flag === 1) {
+      try {
+        payload = gunzipSync(payload)
+      } catch {
+        continue
+      }
+    } else if (flag === 2) {
+      const text = new TextDecoder('utf-8', { fatal: false }).decode(payload).trim()
+      if (text && isPlausibleAssistantText(text)) texts.push(text)
+      continue
+    } else if (flag === 3) {
+      try {
+        payload = gunzipSync(payload)
+        const text = new TextDecoder('utf-8', { fatal: false }).decode(payload).trim()
+        if (text && isPlausibleAssistantText(text)) texts.push(text)
+      } catch {
+        // ignore
+      }
+      continue
+    } else if (flag !== 0) {
+      continue
+    }
+
+    texts.push(...extractTextChunks(payload))
+  }
+
+  const seen = new Set<string>()
+  const out: string[] = []
+  for (const text of texts) {
+    if (seen.has(text)) continue
+    seen.add(text)
+    out.push(text)
+  }
+  return out
+}
+
+function scoreAssistantCandidate(text: string, userPrompt: string, frameIdx: number): number {
+  const trimmed = text.trim()
+  if (!isPlausibleAssistantText(trimmed)) return Number.NEGATIVE_INFINITY
+  const lower = trimmed.toLowerCase()
+  const promptLower = userPrompt.toLowerCase().trim()
+  const promptWords = promptLower.split(/\s+/).filter((w) => w.length > 3)
+
+  if (trimmed.length < 2 || trimmed.length > 4000) return Number.NEGATIVE_INFINITY
+  if (lower === promptLower || (promptLower && lower.includes(promptLower))) {
+    return Number.NEGATIVE_INFINITY
+  }
+  if (lower.includes('you are an ai coding assistant') || lower.includes('"role":"system"')) {
+    return Number.NEGATIVE_INFINITY
+  }
+  if (isOpaqueToken(trimmed)) return Number.NEGATIVE_INFINITY
+  if (lower.includes('update required') || lower.includes('"error"')) {
+    return Number.NEGATIVE_INFINITY
+  }
+  if (trimmed === 'default' || trimmed === 'Ask' || trimmed === 'Agent' || trimmed === 'otto-spike') {
+    return Number.NEGATIVE_INFINITY
+  }
+  if (trimmed === '/context.txt' || trimmed === 'otto') return Number.NEGATIVE_INFINITY
+  // Prefer complete prose over streamed single-token deltas / metadata
+  if (!looksLikeProse(trimmed)) return Number.NEGATIVE_INFINITY
+
+  let score = Math.min(trimmed.length, 200) + frameIdx * 10
+  if (/[\u4e00-\u9fff]/.test(trimmed)) score += 80
+  if (/[.!?。！？]$/.test(trimmed)) score += 30
+  if (trimmed.includes(' ')) score += 25
+  if (/\*\*/.test(trimmed)) score += 10
+  // Thinking/scratch lines often echo the user ask — demote heavily
+  if (lower.startsWith('the user is asking') || lower.startsWith('用户要求')) score -= 150
+  if (promptWords.length > 0) {
+    const matches = promptWords.filter((w) => lower.includes(w)).length
+    if (matches / promptWords.length > 0.5) score -= 200
+  }
+  return score
+}
+
+function cleanProse(text: string): string {
+  // Drop leading protobuf framing leftovers (e.g. ".\n,今天是…")
+  const match = text.match(/\p{L}[\s\S]*/u)
+  return (match?.[0] ?? text).trim()
+}
+
+function extractFromConnectStream(raw: Uint8Array, userPrompt: string): string {
+  const candidates: Array<{ score: number; text: string }> = []
+  const streamTexts = parseConnectStream(raw)
+  for (const [frameIdx, text] of streamTexts.entries()) {
+    const cleaned = cleanProse(text)
+    const score = scoreAssistantCandidate(cleaned, userPrompt, frameIdx)
+    if (Number.isFinite(score)) {
+      candidates.push({ score, text: cleaned })
+    }
+  }
+
+  if (candidates.length === 0) return ''
+  candidates.sort((a, b) => b.score - a.score)
+  return candidates[0]?.text ?? ''
+}
+
+/** Extract assistant text from AgentService/Run response (JSON fragments + protobuf fallback). */
+export function extractAgentText(raw: Uint8Array, userPrompt: string): string {
+  const fromJson = pickAssistantText(extractAgentTextParts(raw, userPrompt))
+  if (fromJson.trim()) return fromJson
+  return extractFromConnectStream(raw, userPrompt)
+}

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

@@ -0,0 +1,53 @@
+import { randomUUID } from 'node:crypto'
+
+import { concatBytes, encodeField } from './protobuf'
+
+export function encodeAgentRunRequest(prompt: string, model: string): Uint8Array {
+  const messageId = randomUUID()
+  const conversationId = randomUUID()
+
+  const userMsg = concatBytes([
+    encodeField(1, 2, prompt),
+    encodeField(2, 2, messageId),
+    encodeField(3, 2, ''),
+  ])
+
+  const fileCtx = concatBytes([
+    encodeField(1, 2, '/context.txt'),
+    encodeField(2, 2, 'otto'),
+  ])
+
+  const explicitCtx = encodeField(2, 2, fileCtx)
+  const userAction = concatBytes([encodeField(1, 2, userMsg), encodeField(2, 2, explicitCtx)])
+  const convAction = encodeField(1, 2, userAction)
+
+  const display = model.replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase())
+  const modelDetails = concatBytes([
+    encodeField(1, 2, model),
+    encodeField(3, 2, model),
+    encodeField(4, 2, display),
+    encodeField(5, 2, display),
+    encodeField(7, 0, 0),
+  ])
+
+  const runReq = concatBytes([
+    encodeField(1, 2, ''),
+    encodeField(2, 2, convAction),
+    encodeField(3, 2, modelDetails),
+    encodeField(4, 2, ''),
+    encodeField(5, 2, conversationId),
+  ])
+
+  return encodeField(1, 2, runReq)
+}
+
+export function encodeAgentConnectBody(prompt: string, model: string): Uint8Array {
+  const payload = encodeAgentRunRequest(prompt, model)
+  const lengthHex = payload.length.toString(16).padStart(8, '0')
+  const lengthBytes = Uint8Array.from(Buffer.from(lengthHex, 'hex'))
+  const out = new Uint8Array(1 + lengthBytes.length + payload.length)
+  out[0] = 0
+  out.set(lengthBytes, 1)
+  out.set(payload, 5)
+  return out
+}

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

@@ -0,0 +1,101 @@
+import http2 from 'node:http2'
+
+import { encodeAgentConnectBody } from './agent-request'
+import { buildAgentHeaders, CURSOR_AGENT_BACKEND } from './headers'
+
+export interface AgentStreamOptions {
+  token: string
+  machineId: string | null
+  prompt: string
+  model: string
+  signal?: AbortSignal
+  idleMs?: number
+  hardMs?: number
+}
+
+export async function collectAgentResponse(options: AgentStreamOptions): Promise<Uint8Array> {
+  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
+
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = []
+    let lastDataAt = Date.now()
+    const startedAt = Date.now()
+    let settled = false
+
+    const client = http2.connect(CURSOR_AGENT_BACKEND)
+    const finish = (err?: Error, data?: Buffer) => {
+      if (settled) return
+      settled = true
+      clearInterval(idleTimer)
+      client.close()
+      if (err) reject(err)
+      else resolve(new Uint8Array(data ?? Buffer.concat(chunks)))
+    }
+
+    const idleTimer = setInterval(() => {
+      if (signal?.aborted) {
+        finish(new Error('Aborted'))
+        return
+      }
+      if (chunks.length > 0 && Date.now() - lastDataAt >= idleMs) {
+        finish(undefined, Buffer.concat(chunks))
+      }
+      if (Date.now() - startedAt >= hardMs) {
+        finish(undefined, Buffer.concat(chunks))
+      }
+    }, 250)
+
+    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) => {
+      chunks.push(Buffer.from(chunk))
+      lastDataAt = Date.now()
+    })
+
+    req.on('end', () => finish(undefined, Buffer.concat(chunks)))
+    req.on('error', (err) => finish(err))
+
+    signal?.addEventListener(
+      'abort',
+      () => finish(new Error('Aborted')),
+      { once: true },
+    )
+
+    req.write(body)
+    req.end()
+  })
+}