Files
hapi/cli/src/modules/common/grokModels.ts
T
df1a56e1db fix(cursor): exclusive agent spawn lease for list-models vs ACP (#1529)
* fix(cursor): exclusive agent spawn lease for list-models vs ACP (#1520)

Add a proper-lockfile spawn lease beside agent-acp-active so model probes
and ACP transport acquire mutual exclusion atomically before spawning
agent children, closing the post-#1518 check-then-act overlap window.

Fixes #1520

Co-authored-by: Cursor <cursoragent@cursor.com>

* chore(web): fix markdown-a test HappyChatContext mock for typecheck

Adds showSessionSummaryInChat to chatContext() so CI typecheck passes on
the PR branch (pre-existing main breakage unrelated to #1520).

Co-authored-by: Cursor <cursoragent@cursor.com>

* Revert "chore(web): fix markdown-a test HappyChatContext mock for typecheck"

This reverts commit 4973f321a31fda772e8990ea6cda20517ca906aa.

* fix(cursor): scope spawn lease to agent spawn window only (#1520)

Hold agent-cli.spawn only around spawn('agent') in AcpStdioTransport, not
for the full ACP session. Restores N concurrent cursor sessions per host;
list-models probe lease unchanged.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(cursor): tighten spawn lease lifecycle for babysit (#1520)

Acquire spawn lease before ACP marker publish; unregister on spawn failure.
Hold list-models probe lease until child exit on timeout. Add missing
showSessionSummaryInChat to markdown-a test mock (unblocks CI typecheck).

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(cursor): re-check ACP marker after spawn lease acquire (#1520)

Close check-then-act window where ACP could publish its marker between
the inactive guard read and list-models spawn. Add regression test.

Co-authored-by: Cursor <cursoragent@cursor.com>

* test(cursor): fix ACP-after-acquire mock call order (#1520)

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(cursor): async spawn lease + force-kill probe timeout (#1520)

Add acquireAgentCliSpawnLease (setTimeout yields) for ACP create path;
AcpStdioTransport.create() async factory. Probe timeout uses
killProcessByChildProcess(force) while holding lease until child exit.

Addresses Bugbot Majors: session-lifetime mutex (fe07b708d), probe lease
release, post-acquire re-check (137baa779), sync loop starvation, timeout
escalation.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(acp): coalesce concurrent initialize() transport spawns (#1520)

Await shared bootstrapTransport promise so overlapping initialize calls
do not spawn duplicate ACP children while create() is in flight.

Co-authored-by: Cursor <cursoragent@cursor.com>

---------

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-08-12 18:42:43 +01:00

242 lines
8.9 KiB
TypeScript

import { spawn } from 'node:child_process'
import { asString, isObject } from '@hapi/protocol'
import type { GrokModelSummary, GrokModelsResponse, GrokReasoningEffortOption } from '@hapi/protocol/apiTypes'
import { AcpStdioTransport } from '@/agent/backends/acp/AcpStdioTransport'
import { assertSafeWindowsShellArg } from '@/grok/utils/windowsShellArgs'
import { getErrorMessage } from './rpcResponses'
import packageJson from '../../../package.json'
export interface ListGrokModelsForCwdRequest {
cwd?: string
}
export type ListGrokModelsForCwdResponse = GrokModelsResponse
interface CacheEntry {
expiresAt: number
response: ListGrokModelsForCwdResponse
}
const CACHE_TTL_MS = 60_000
const PROBE_TIMEOUT_MS = 15_000
const SETTINGS_PROBE_GRACE_MS = 300
const cache = new Map<string, CacheEntry>()
const inflight = new Map<string, Promise<ListGrokModelsForCwdResponse>>()
export function buildGrokModelsArgs(cwd: string): string[] {
assertSafeWindowsShellArg(cwd, 'cwd')
return ['--cwd', cwd, 'models']
}
export function parseGrokModelsOutput(output: string): {
availableModels: GrokModelSummary[]
currentModelId: string | null
} {
const availableModels: GrokModelSummary[] = []
const seen = new Set<string>()
let currentModelId: string | null = null
let inAvailableModels = false
for (const rawLine of output.split(/\r?\n/)) {
const line = rawLine.trim()
if (line.startsWith('Default model:')) {
currentModelId = line.slice('Default model:'.length).trim() || null
continue
}
if (line === 'Available models:') {
inAvailableModels = true
continue
}
if (!inAvailableModels || !line.startsWith('*')) continue
const modelId = line.slice(1).replace(/\s+\(default\)\s*$/, '').trim()
if (!modelId || seen.has(modelId)) continue
seen.add(modelId)
availableModels.push({ modelId })
}
if (currentModelId && !seen.has(currentModelId)) {
availableModels.unshift({ modelId: currentModelId })
}
return { availableModels, currentModelId }
}
export function parseGrokInitializeModels(response: unknown): {
availableModels: GrokModelSummary[]
currentModelId: string | null
autoPermissionModeSupported: boolean
} {
if (!isObject(response) || !isObject(response._meta) || !isObject(response._meta.modelState)) {
return { availableModels: [], currentModelId: null, autoPermissionModeSupported: false }
}
const state = response._meta.modelState
const rawCommands = Array.isArray(response._meta.availableCommands)
? response._meta.availableCommands
: []
const autoPermissionModeSupported = rawCommands.some(
(entry) => isObject(entry) && asString(entry.name) === 'auto'
)
const currentModelId = asString(state.currentModelId)
const rawModels = Array.isArray(state.availableModels) ? state.availableModels : []
const availableModels = rawModels
.filter((entry): entry is Record<string, unknown> => isObject(entry))
.map((entry): GrokModelSummary | null => {
const modelId = asString(entry.modelId)
if (!modelId) return null
const meta = isObject(entry._meta) ? entry._meta : null
const rawEfforts = meta && Array.isArray(meta.reasoningEfforts) ? meta.reasoningEfforts : []
const reasoningEfforts = rawEfforts
.filter((effort): effort is Record<string, unknown> => isObject(effort))
.map((effort): GrokReasoningEffortOption => ({
value: asString(effort.value) ?? asString(effort.id) ?? '',
name: asString(effort.label) ?? undefined,
isDefault: effort.default === true
}))
.filter((effort) => effort.value.length > 0)
return {
modelId,
name: asString(entry.name) ?? undefined,
...(reasoningEfforts.length > 0 ? { reasoningEfforts } : {})
}
})
.filter((entry): entry is GrokModelSummary => entry !== null)
return { availableModels, currentModelId, autoPermissionModeSupported }
}
async function runGrokModelsCliProbe(cwd: string): Promise<ListGrokModelsForCwdResponse> {
return await new Promise((resolve, reject) => {
const child = spawn('grok', buildGrokModelsArgs(cwd), {
env: process.env,
stdio: ['ignore', 'pipe', 'pipe'],
shell: process.platform === 'win32',
windowsHide: process.platform === 'win32'
})
let stdout = ''
let stderr = ''
let settled = false
const timeout = setTimeout(() => {
if (settled) return
settled = true
child.kill('SIGTERM')
reject(new Error('Grok model discovery timed out'))
}, PROBE_TIMEOUT_MS)
child.stdout?.on('data', (chunk) => {
stdout += chunk.toString()
})
child.stderr?.on('data', (chunk) => {
stderr += chunk.toString()
})
child.on('error', (error) => {
if (settled) return
settled = true
clearTimeout(timeout)
reject(error)
})
child.on('exit', (code) => {
if (settled) return
settled = true
clearTimeout(timeout)
if (code !== 0) {
reject(new Error(stderr.trim() || `grok models exited with code ${code}`))
return
}
resolve({ success: true, ...parseGrokModelsOutput(stdout) })
})
})
}
async function runGrokModelsProbe(cwd: string): Promise<ListGrokModelsForCwdResponse> {
// The primary ACP probe also uses shell mode on Windows through AcpStdioTransport.
assertSafeWindowsShellArg(cwd, 'cwd')
const transport = await AcpStdioTransport.create({
command: 'grok',
args: ['--cwd', cwd, 'agent', '--reasoning-effort', 'low', 'stdio'],
env: Object.fromEntries(
Object.entries(process.env).filter((entry): entry is [string, string] => entry[1] !== undefined)
)
})
try {
let resolveAutoPermissionMode: ((supported: boolean) => void) | null = null
const autoPermissionMode = new Promise<boolean>((resolve) => {
resolveAutoPermissionMode = resolve
})
transport.onNotification((method, params) => {
if (
method === '_x.ai/settings/update'
&& isObject(params)
&& 'auto_permission_mode_enabled' in params
) {
resolveAutoPermissionMode?.(params.auto_permission_mode_enabled === true)
resolveAutoPermissionMode = null
}
})
const response = await transport.sendRequest('initialize', {
protocolVersion: 1,
clientCapabilities: {
fs: { readTextFile: false, writeTextFile: false },
terminal: false,
_meta: { parameterizedModelPicker: true }
},
clientInfo: { name: 'hapi-grok-models', version: packageJson.version }
}, { timeoutMs: PROBE_TIMEOUT_MS })
const parsed = parseGrokInitializeModels(response)
if (parsed.availableModels.length > 0) {
const remoteSupport = await Promise.race([
autoPermissionMode,
new Promise<null>((resolve) => setTimeout(resolve, SETTINGS_PROBE_GRACE_MS, null))
])
return {
success: true,
...parsed,
autoPermissionModeSupported: parsed.autoPermissionModeSupported || remoteSupport === true
}
}
} catch {
// Older Grok builds may not expose modelState during initialize.
// Fall back to the stable `grok models` command below.
} finally {
await transport.close().catch(() => undefined)
}
return await runGrokModelsCliProbe(cwd)
}
export async function listGrokModelsForCwd(cwd: string): Promise<ListGrokModelsForCwdResponse> {
const trimmed = cwd?.trim()
if (!trimmed) return { success: false, error: 'cwd is required' }
const cached = cache.get(trimmed)
if (cached && cached.expiresAt > Date.now()) return cached.response
const running = inflight.get(trimmed)
if (running) return running
const promise = (async () => {
try {
const response = await runGrokModelsProbe(trimmed)
if (response.success) {
cache.set(trimmed, { expiresAt: Date.now() + CACHE_TTL_MS, response })
}
return response
} catch (error) {
return {
success: false,
error: getErrorMessage(error, 'Failed to discover Grok models')
}
} finally {
inflight.delete(trimmed)
}
})()
inflight.set(trimmed, promise)
return promise
}
export function _resetGrokModelsCacheForTests(): void {
cache.clear()
inflight.clear()
}