index.js · part 42

60 text occurrences from agent-cli/package/index.js, part 42. Every entry preserves the shipped literal and its saved verdict or selection reason.

File contents and all parts · All files

use strict

use strict

use strict

Pending-request stream cursor expired. Re-list and watch from a fresh streamCursor.

Error: ${f} requires a service-account API key. Session login cannot list or claim pending private-worker requests. Pass --api-key or set CURSOR_API_KEY.

Error: --session-token needs private-worker session tokens enabled for this team. The controller does not fall back to handing the spawn hook the service-account key.

Run one of two explicit modes:

  claim-then-spawn (default): watch GET /v0/private-workers/pending-requests/stream (the primary dispatch path), claim each created request and exec the spawn hook once per claim; claimed-but-offline events (hibernated machines) exec the same hook with CURSOR_WAKE=1 and no claim call. A ${String(60)}s reconcile list per --pool converges anything the best-effort stream missed.

  warm pool (--warm-idle <count>): keep <count> idle workers connected in each --pool by pre-spawning unclaimed workers; never calls claim. The server assigns queued agents to warm workers. A claimed-but-offline request (hibernated machine; only present when that pool has a reconnect window) execs the same hook with CURSOR_WAKE=1 and is not counted as idle.

Auth is one pipe. The service-account key binds the team. The same key and public API URL are used for pool registration, pending-requests, the pending-requests stream, claim, and the spawn hook:

  --api-key / CURSOR_API_KEY  Bearer token and hook env CURSOR_API_KEY

  --pool <name>  claim mode: GET ?pool=<name> (repeatable; one list/stream call per name). Non-default names are registered at startup. Warm mode: the pool(s) to keep warm. Mutually exclusive with --all-pools

  --all-pools  omit ?pool= (team-wide list and stream). Does not register pools. Mutually exclusive with --pool; not allowed in warm mode

  --warm-idle <count>  keep <count> idle workers per --pool; skips claim entirely. Claimed-but-offline requests on a pool with a reconnect window are resumed (CURSOR_WAKE=1) instead of being left for an idle spare. Run one warm controller per pool: without claim there is no server-side lease, so concurrent controllers can transiently over-spawn

  --endpoint / CURSOR_API_ENDPOINT  Override the public API base (default ${Q}) and hook env CURSOR_API_URL / CURSOR_API_ENDPOINT

  --repository  pending-requests filter and pool registration pin (required for repo-scoped keys); in warm mode also pins pool stats to that repo's row

  --spawn  exec once after a successful claim (fresh machine), or once per missing warm worker. In both modes it is also execed once per claimed-but-offline pending request (a hibernated machine on a pool with a wake window): the hook then gets CURSOR_WAKE=1 and CURSOR_WAKE_TIMEOUT_MS, CURSOR_AGENT_WORKER_ID is the durable claimed worker id to revive, and no claim call is made — boot the machine holding that identity's preserved workspace and re-run the worker to resume the run in place. A hook that ignores CURSOR_WAKE provisions fresh, which matches the wake-window-expiry outcome sooner

  --session-token  claim mode only: the hook gets CURSOR_AUTH_TOKEN (a token that serves only its claim, from claim or, for a wake, POST /v0/private-workers/tokens) and CURSOR_AUTH_TOKEN_EXPIRES_AT instead of CURSOR_API_KEY. Start the runner with it: `agent worker --pool --auth-token-file <file> start`. Requires private-worker session tokens enabled for the team

Session login is not used. Dashboard GetMe is not used. Missing key or pool selection exits immediately.

Examples:
  agent worker controller --spawn ./spawn.sh --api-key "$CURSOR_API_KEY" --pool gpu --pool default
  agent worker controller --spawn ./spawn.sh --api-key "$CURSOR_API_KEY" --all-pools --repository https://github.com/acme/payments
  agent worker controller --spawn ./spawn.sh --api-key "$CURSOR_API_KEY" --pool gpu --session-token

Invalid --pool: name cannot be empty.

Invalid --pool: name must be at most 255 characters.

Error: --pool and --all-pools cannot be used together. Pass --pool <name> (repeatable) or --all-pools.

Error: pass --pool <name> (repeatable) or --all-pools. Exactly one of these is required.

Error: --warm-idle requires --pool <name> (repeatable) and cannot be combined with --all-pools. Warm workers are spawned into a specific pool.

Invalid --warm-idle: ${t}. Must be a positive integer.

Error: ${t.path} requires a service-account API key. Session login cannot list or claim pending private-worker requests. Pass --api-key or set CURSOR_API_KEY.

Error: ${t.path} returned HTTP 401. ${e}

team context required

Error: ${t.path} requires a service-account key bound to a team. The key has no team in auth context.

GET ${f}

GET ${h}

GET ${h} expected text/event-stream, got ${o||"no content-type"}

no content-type

GET ${h} had no body

controller: ${e}-event handler failed: ${_t(t)}

controller: ignoring malformed ${r.event} event: ${_t(t)}

GET ${A}

controller: warm pool ${r}: ${String(n.idleWorkers)}/${String(t.idleTarget)} idle, ${String(a)} spawning; spawning ${String(o)} more

controller: spawning warm worker ${s} for pool ${e}

controller: warm spawn hook timed out for ${s}

controller: warm spawn hook failed for ${s}: ${a.message}

controller: warm spawn hook exited ${String(a.code)} for ${s}

Error: --session-token cannot be combined with --warm-idle. A session token serves one claim, and warm workers start before any claim.

Error: invalid --warm-idle: ${String(t.warmIdle)}. Must be a positive integer.

${t.message}

Error: spawn hook not found: ${a}

controller: warm pool keeping ${String(s.idleTarget)} idle in ${[...s.poolNames].join(",")} (reconciling ${c}${A} every ${String(60)}s, SSE-accelerated)

controller: warm resume dispatch failed for pool ${t.pool}: ${_t(e)}

controller: pending-requests returned no streamCursor for pool ${t.pool}; retrying

controller: pending-request stream for pool ${t.pool} failed: ${_t(r)}

controller: pending-request stream watcher for pool ${e} stopped: ${_t(t)}

${e.message}

controller: warm reconcile failed: ${_t(e)}

${t.message}

controller: poll failed: ${_t(t)}

controller: stream-recovery dispatch failed: ${_t(t)}

controller: list response had no streamCursor; watching skipped until the next list

controller: pending-request watch failed: ${_t(e)}

${t.message}