Files
hapi/cli/src/modules/common/cursorModels.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

391 lines
13 KiB
TypeScript

import { spawn } from 'node:child_process';
import type { CursorModelsResponse, CursorModelSummary } from '@hapi/protocol/apiTypes';
import {
releaseAgentCliSpawnLeaseSync,
tryAcquireAgentCliSpawnLeaseSync
} from '@hapi/protocol/agentCliSpawnLease';
import { isAgentAcpTransportActive } from '@/agent/backends/acp/agentCliGuard';
import { resolveHapiHomeDir } from '@/configuration';
import { killProcessByChildProcess } from '@/utils/process';
import { getCursorAcpModelsSnapshot } from '@/cursor/utils/cursorAcpModelsBridge';
import { getErrorMessage } from './rpcResponses';
import {
readSharedCursorModelsCache,
writeSharedCursorModelsCache,
_resetSharedCursorModelsCacheForTests
} from './cursorModelsSharedCache';
import {
cursorCliSkuBaseId,
cursorModelBaseId,
isCursorAcpCatalogModelId,
isCursorAcpWireModelId
} from '@hapi/protocol';
import {
cursorProbeResponseHasWireCatalog,
runCursorAcpModelProbe
} from './cursorAcpModelProbe';
export function buildCursorModelsSeedPayload(
snapshot: {
availableModels: CursorModelSummary[];
currentModelId: string | null;
cliModelSkus?: readonly CursorModelSummary[];
},
shared?: CursorModelsResponse | null
): ListCursorModelsResponse {
const cliModelSkus = mergeCliModelSkus(
snapshot.cliModelSkus ?? [],
shared?.cliModelSkus ?? []
);
return {
success: true,
availableModels: snapshot.availableModels,
currentModelId: snapshot.currentModelId,
...(cliModelSkus.length > 0 ? { cliModelSkus } : {})
};
}
export function mergeCliModelSkus(
...lists: readonly (readonly CursorModelSummary[])[]
): CursorModelSummary[] {
const merged = new Map<string, CursorModelSummary>();
for (const list of lists) {
for (const entry of list) {
const modelId = entry.modelId.trim();
if (!modelId) {
continue;
}
if (!merged.has(modelId)) {
merged.set(modelId, entry);
}
}
}
return [...merged.values()];
}
function filterCliSkusForWireBases(
cliSkus: CursorModelSummary[],
wires: CursorModelSummary[]
): CursorModelSummary[] {
const wireBases = new Set(
wires.map((entry) => cursorModelBaseId(entry.modelId)).filter((base) => base.length > 0)
);
return cliSkus.filter((entry) => {
const modelId = entry.modelId.trim();
// Keep bare base SKUs (composer-2.5); drop parameterized ACP wires only.
if (!modelId || modelId === 'auto' || isCursorAcpWireModelId(modelId)) {
return false;
}
return wireBases.has(cursorCliSkuBaseId(modelId));
});
}
function attachCliSkusToResponse(
response: ListCursorModelsResponse,
cliSkus: readonly CursorModelSummary[]
): ListCursorModelsResponse {
const wires = (response.availableModels ?? []).filter((entry) => isCursorAcpCatalogModelId(entry.modelId));
// Suffixed CLI variants (effort/speed) only apply when ACP exposes parameterized
// wires for that base. Bare-only catalogs cannot express those variants
// (apply path is model + fast at most), so attaching them creates dead picker rows.
const parameterizedBases = new Set(
wires
.filter((entry) => isCursorAcpWireModelId(entry.modelId))
.map((entry) => cursorModelBaseId(entry.modelId))
.filter((base) => base.length > 0)
);
const filtered = filterCliSkusForWireBases(
mergeCliModelSkus(response.cliModelSkus ?? [], [...cliSkus]),
wires
).filter((entry) => {
const modelId = entry.modelId.trim();
const base = cursorCliSkuBaseId(modelId);
return modelId === base || parameterizedBases.has(base);
});
if (filtered.length === 0) {
return response.cliModelSkus?.length
? { ...response, cliModelSkus: undefined }
: response;
}
if (
filtered.length === (response.cliModelSkus?.length ?? 0)
&& filtered.every((entry, index) => entry.modelId === response.cliModelSkus?.[index]?.modelId)
) {
return response;
}
return { ...response, cliModelSkus: filtered };
}
async function enrichCursorModelsWithCliSkus(
response: ListCursorModelsResponse
): Promise<ListCursorModelsResponse> {
const wires = (response.availableModels ?? []).filter((entry) => isCursorAcpCatalogModelId(entry.modelId));
if (wires.length === 0) {
return response;
}
const candidates: CursorModelSummary[] = [];
const shared = readSharedCursorModelsCache();
if (shared?.cliModelSkus?.length) {
candidates.push(...shared.cliModelSkus);
}
// Never spawn `agent --list-models` while an ACP session holds the CLI lock.
if (!isAgentAcpTransportActive()) {
try {
const probe = await runCursorModelProbe();
candidates.push(...(probe.availableModels ?? []));
} catch {
// Keep partial candidates from shared cache.
}
}
if (candidates.length === 0) {
return response;
}
return attachCliSkusToResponse(response, candidates);
}
export type ListCursorModelsResponse = CursorModelsResponse;
function responseHasParameterizedWireIds(response: ListCursorModelsResponse): boolean {
// CLI `--list-models` returns bare/SKU slugs; only treat bracket wires as an ACP catalog.
return (response.availableModels ?? []).some((model) => isCursorAcpWireModelId(model.modelId));
}
interface CacheEntry {
expiresAt: number;
response: ListCursorModelsResponse;
}
const CACHE_TTL_MS = 60_000;
const PROBE_TIMEOUT_MS = 30_000;
const cache: CacheEntry = {
expiresAt: 0,
response: { success: true, availableModels: [], currentModelId: null }
};
let inflight: Promise<ListCursorModelsResponse> | null = null;
export function parseCursorModelsOutput(output: string): {
availableModels: CursorModelSummary[];
currentModelId: string | null;
} {
const availableModels: CursorModelSummary[] = [];
let currentModelId: string | null = null;
for (const rawLine of output.split(/\r?\n/)) {
const line = rawLine.trim();
if (!line || line === 'Available models' || line.startsWith('Tip:')) {
continue;
}
const separatorIndex = line.indexOf(' - ');
if (separatorIndex <= 0) {
continue;
}
const modelId = line.slice(0, separatorIndex).trim();
const rawName = line.slice(separatorIndex + 3).trim();
if (!modelId || !rawName) {
continue;
}
const isCurrent = /\s*\(current\)\s*$/.test(rawName);
const isDefault = /\s*\(default\)\s*$/.test(rawName);
const name = rawName.replace(/\s*\((?:current|default)\)\s*$/, '').trim();
availableModels.push(name && name !== modelId ? { modelId, name } : { modelId });
if (isCurrent) {
currentModelId = modelId;
} else if (isDefault && currentModelId === null) {
currentModelId = modelId;
}
}
return { availableModels, currentModelId };
}
async function runCursorModelProbe(): Promise<ListCursorModelsResponse> {
if (!tryAcquireAgentCliSpawnLeaseSync(resolveHapiHomeDir())) {
throw new Error('Cursor ACP transport is active');
}
if (isAgentAcpTransportActive()) {
releaseAgentCliSpawnLeaseSync();
throw new Error('Cursor ACP transport is active');
}
let leaseReleased = false;
const releaseLeaseOnce = (): void => {
if (leaseReleased) {
return;
}
leaseReleased = true;
releaseAgentCliSpawnLeaseSync();
};
return await new Promise((resolve, reject) => {
const child = spawn('agent', ['--list-models'], {
env: process.env,
stdio: ['ignore', 'pipe', 'pipe'],
shell: process.platform === 'win32',
windowsHide: process.platform === 'win32'
});
let stdout = '';
let stderr = '';
let settled = false;
let timeoutError: Error | null = null;
const finish = (handler: () => void): void => {
if (settled) {
return;
}
settled = true;
clearTimeout(timeout);
releaseLeaseOnce();
handler();
};
const timeout = setTimeout(() => {
timeoutError = new Error('Cursor model discovery timed out');
void killProcessByChildProcess(child, true);
}, PROBE_TIMEOUT_MS);
child.stdout?.on('data', (chunk) => {
stdout += chunk.toString();
});
child.stderr?.on('data', (chunk) => {
stderr += chunk.toString();
});
child.on('error', (error) => {
finish(() => reject(error));
});
child.on('exit', (code) => {
finish(() => {
if (timeoutError) {
reject(timeoutError);
return;
}
if (code !== 0) {
reject(new Error(stderr.trim() || `agent --list-models exited with code ${code}`));
return;
}
resolve({
success: true,
...parseCursorModelsOutput(stdout)
});
});
});
});
}
async function applyInMemoryCache(response: ListCursorModelsResponse): Promise<ListCursorModelsResponse> {
const enriched = await enrichCursorModelsWithCliSkus(response);
if ((enriched.availableModels?.length ?? 0) > 0) {
cache.expiresAt = Date.now() + CACHE_TTL_MS;
cache.response = enriched;
writeSharedCursorModelsCache(enriched);
}
return enriched;
}
/** ACP session snapshot (Zed-style); falls back to seeded / on-disk cache from the last live session. */
async function listCursorModelsWhileAcpActive(): Promise<ListCursorModelsResponse> {
const acp = getCursorAcpModelsSnapshot();
if (acp && acp.availableModels.length > 0) {
return applyInMemoryCache({ success: true, ...acp });
}
// Session child writes the on-disk cache; prefer it over this process's in-memory entry.
const shared = readSharedCursorModelsCache();
if (shared) {
return applyInMemoryCache(shared);
}
if (cache.expiresAt > Date.now() && (cache.response.availableModels?.length ?? 0) > 0) {
const shared = readSharedCursorModelsCache();
const cachedSkus = mergeCliModelSkus(
cache.response.cliModelSkus ?? [],
shared?.cliModelSkus ?? []
);
return attachCliSkusToResponse(cache.response, cachedSkus);
}
return { success: true, availableModels: [], currentModelId: null };
}
export async function listCursorModels(): Promise<ListCursorModelsResponse> {
if (isAgentAcpTransportActive()) {
return listCursorModelsWhileAcpActive();
}
const acp = getCursorAcpModelsSnapshot();
if (acp && acp.availableModels.length > 0) {
return applyInMemoryCache({ success: true, ...acp });
}
if (cache.expiresAt > Date.now() && (cache.response.availableModels?.length ?? 0) > 0) {
return enrichCursorModelsWithCliSkus(cache.response);
}
const shared = readSharedCursorModelsCache();
if (shared) {
return applyInMemoryCache(shared);
}
if (inflight) {
return inflight;
}
inflight = (async () => {
try {
const acpResponse = await runCursorAcpModelProbe();
if (cursorProbeResponseHasWireCatalog(acpResponse)) {
return applyInMemoryCache(acpResponse);
}
let probeResponse: ListCursorModelsResponse | null = null;
if (!isAgentAcpTransportActive()) {
probeResponse = await runCursorModelProbe();
// Never promote CLI `--list-models` slug catalogs into the ACP wire cache.
if (responseHasParameterizedWireIds(probeResponse)) {
return applyInMemoryCache(probeResponse);
}
}
// CLI `--list-models` returns slug ids without bracket params; never cache
// those for the web picker (New Session would show only Default + current slug).
if (acpResponse.success) {
return acpResponse;
}
if (probeResponse?.success) {
return { success: true, availableModels: [], currentModelId: null };
}
return probeResponse ?? acpResponse;
} catch (error) {
return {
success: false,
error: getErrorMessage(error, 'Failed to discover Cursor models')
};
} finally {
inflight = null;
}
})();
return inflight;
}
export function seedCursorModelsCache(response: ListCursorModelsResponse): void {
if ((response.availableModels?.length ?? 0) > 0) {
writeSharedCursorModelsCache(response);
}
void applyInMemoryCache(response);
}
export function _resetCursorModelsCacheForTests(): void {
cache.expiresAt = 0;
cache.response = { success: true, availableModels: [], currentModelId: null };
inflight = null;
_resetSharedCursorModelsCacheForTests();
}