The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import * as Cause from "effect/Cause"; |
| 2 | import * as Deferred from "effect/Deferred"; |
| 3 | import * as Duration from "effect/Duration"; |
| 4 | import * as Effect from "effect/Effect"; |
| 5 | import * as Exit from "effect/Exit"; |
| 6 | import * as Fiber from "effect/Fiber"; |
| 7 | import type * as FileSystem from "effect/FileSystem"; |
| 8 | import * as Layer from "effect/Layer"; |
| 9 | import type * as Path from "effect/Path"; |
| 10 | import * as Queue from "effect/Queue"; |
| 11 | import * as Sink from "effect/Sink"; |
| 12 | import * as Stdio from "effect/Stdio"; |
| 13 | import * as Stream from "effect/Stream"; |
| 14 | |
| 15 | import * as CursorAgentSdk from "./CursorAgentSdk.ts"; |
| 16 | import { |
| 17 | type CursorWorkerMessage, |
| 18 | type CursorWorkerRequest, |
| 19 | type SerializedRunnerFailure, |
| 20 | decodeWorkerFrame, |
| 21 | encodeWorkerFrame, |
| 22 | serializeRunResult, |
| 23 | serializeWorkerError, |
| 24 | } from "./CursorAgentSdkWorkerProtocol.ts"; |
| 25 | import * as CursorSdk from "./CursorSdk.ts"; |
| 26 | import { runCursorTextGenerationInProcess } from "./textGeneration.ts"; |
| 27 | |
| 28 | const CLOSE_GRACE = Duration.seconds(3); |
| 29 | |
| 30 | function toRunnerFailure(method: string, cause: unknown): SerializedRunnerFailure { |
| 31 | if (CursorAgentSdk.isCursorAgentSdkRunnerError(cause)) { |
| 32 | return { |
| 33 | method: cause.method, |
| 34 | cause: serializeWorkerError(cause.cause), |
| 35 | }; |
| 36 | } |
| 37 | return { |
| 38 | method, |
| 39 | cause: serializeWorkerError(cause), |
| 40 | }; |
| 41 | } |
| 42 | |
| 43 | function exitFailure( |
| 44 | method: string, |
| 45 | exit: Exit.Failure<unknown, unknown>, |
| 46 | ): SerializedRunnerFailure { |
| 47 | const squashed = Cause.squash(exit.cause); |
| 48 | return toRunnerFailure(method, squashed); |
| 49 | } |
| 50 | |
| 51 | /** Runs the Cursor SDK worker loop over Effect's `Stdio` service until `close` or stdin EOF. */ |
| 52 | const runCursorSdkWorkerWithStdio = Effect.fn("CursorAgentSdkWorker.run")(function* (options?: { |
| 53 | readonly shutdownSignal?: Deferred.Deferred<void>; |
| 54 | }) { |
| 55 | const stdio = yield* Stdio.Stdio; |
| 56 | const cursorSdk = yield* CursorSdk.CursorSdk; |
| 57 | const workerScope = yield* Effect.scope; |
| 58 | const shutdownSignal = options?.shutdownSignal ?? (yield* Deferred.make<void>()); |
| 59 | const outgoing = yield* Queue.unbounded<string, Cause.Done>(); |
| 60 | |
| 61 | const writerFiber = yield* Stream.fromQueue(outgoing).pipe( |
| 62 | Stream.run(stdio.stdout()), |
| 63 | Effect.ignoreCause, |
| 64 | Effect.forkScoped, |
| 65 | ); |
| 66 | |
| 67 | const writeMessage = (message: CursorWorkerMessage): void => { |
| 68 | Queue.offerUnsafe(outgoing, encodeWorkerFrame(message)); |
| 69 | }; |
| 70 | |
| 71 | let activeSendStarts = 0; |
| 72 | // One worker hosts every Cursor session; each session is keyed by its open request id. |
| 73 | const sessions = new Map<number, CursorAgentSdk.CursorAgentSdkSession>(); |
| 74 | const openingSessionIds = new Set<number>(); |
| 75 | const pendingClosedSessionIds = new Set<number>(); |
| 76 | // Other sessions keep the worker alive, so an abandoned generation must be interrupted here. |
| 77 | const textGenerations = new Map<number, Fiber.Fiber<unknown, unknown>>(); |
| 78 | const activeRuns = new Map< |
| 79 | number, |
| 80 | { readonly sessionId: number; readonly run: CursorAgentSdk.CursorAgentSdkRun } |
| 81 | >(); |
| 82 | const backgroundShellStops = new Map<string, () => void>(); |
| 83 | const startingSendIds = new Set<number>(); |
| 84 | const pendingCancelledSendIds = new Set<number>(); |
| 85 | const sessionIdByOptions = new WeakMap<object, number>(); |
| 86 | let shuttingDown = false; |
| 87 | |
| 88 | const runner = yield* CursorAgentSdk.makeCursorAgentSdkRunner((input) => { |
| 89 | const boundSessionId = sessionIdByOptions.get(input.options); |
| 90 | return (event) => |
| 91 | Effect.sync(() => { |
| 92 | if (activeSendStarts > 0 && event.payload.type === "run.cancel") { |
| 93 | writeMessage({ |
| 94 | type: "protocolLog", |
| 95 | providerSessionId: input.providerSessionId, |
| 96 | ...(boundSessionId === undefined ? {} : { sessionId: boundSessionId }), |
| 97 | event, |
| 98 | }); |
| 99 | } |
| 100 | }); |
| 101 | }); |
| 102 | |
| 103 | // Untraced: called from closeSession/close/shutdown handlers that already carry spans. |
| 104 | const closeSession = Effect.fnUntraced(function* ( |
| 105 | sessionId: number, |
| 106 | ): Effect.fn.Return<Exit.Exit<void, CursorAgentSdk.CursorAgentSdkRunnerError>> { |
| 107 | const shellPrefix = `${sessionId}:`; |
| 108 | for (const key of backgroundShellStops.keys()) { |
| 109 | if (key.startsWith(shellPrefix)) backgroundShellStops.delete(key); |
| 110 | } |
| 111 | if (openingSessionIds.has(sessionId)) { |
| 112 | pendingClosedSessionIds.add(sessionId); |
| 113 | } |
| 114 | const current = sessions.get(sessionId); |
| 115 | sessions.delete(sessionId); |
| 116 | for (const [sendId, entry] of activeRuns.entries()) { |
| 117 | if (entry.sessionId === sessionId) { |
| 118 | activeRuns.delete(sendId); |
| 119 | } |
| 120 | } |
| 121 | if (current === undefined) { |
| 122 | return Exit.void; |
| 123 | } |
| 124 | const closeExit = yield* Effect.exit(current.close.pipe(Effect.timeoutOption(CLOSE_GRACE))); |
| 125 | return Exit.isFailure(closeExit) ? closeExit : Exit.void; |
| 126 | }); |
| 127 | |
| 128 | // Untraced: shutdown helper invoked from close request or finalizer. |
| 129 | const closeAllSessions = Effect.fnUntraced(function* () { |
| 130 | const ids = Array.from(new Set([...sessions.keys(), ...openingSessionIds])); |
| 131 | return yield* Effect.forEach(ids, (sessionId) => closeSession(sessionId), { |
| 132 | concurrency: "unbounded", |
| 133 | }); |
| 134 | }); |
| 135 | |
| 136 | // Untraced: dispatches one decoded worker request; inner runner operations carry spans. |
| 137 | const handleRequest = Effect.fnUntraced(function* ( |
| 138 | req: CursorWorkerRequest, |
| 139 | ): Effect.fn.Return<void> { |
| 140 | if (shuttingDown && req.type !== "close") { |
| 141 | writeMessage({ |
| 142 | type: "response", |
| 143 | id: req.id, |
| 144 | ok: false, |
| 145 | error: toRunnerFailure(req.type, new Error("Cursor SDK worker is shutting down.")), |
| 146 | }); |
| 147 | return; |
| 148 | } |
| 149 | |
| 150 | switch (req.type) { |
| 151 | case "open": { |
| 152 | openingSessionIds.add(req.id); |
| 153 | sessionIdByOptions.set(req.options, req.id); |
| 154 | const exit = yield* Effect.exit( |
| 155 | runner.open({ |
| 156 | operation: req.operation, |
| 157 | ...(req.agentId === undefined ? {} : { agentId: req.agentId }), |
| 158 | ...(req.storeCwd === undefined ? {} : { storeCwd: req.storeCwd }), |
| 159 | options: req.options, |
| 160 | threadId: req.threadId, |
| 161 | providerSessionId: req.providerSessionId, |
| 162 | }), |
| 163 | ).pipe( |
| 164 | Effect.ensuring( |
| 165 | Effect.sync(() => { |
| 166 | openingSessionIds.delete(req.id); |
| 167 | }), |
| 168 | ), |
| 169 | ); |
| 170 | if (Exit.isFailure(exit)) { |
| 171 | pendingClosedSessionIds.delete(req.id); |
| 172 | writeMessage({ |
| 173 | type: "response", |
| 174 | id: req.id, |
| 175 | ok: false, |
| 176 | error: exitFailure("open", exit), |
| 177 | }); |
| 178 | return; |
| 179 | } |
| 180 | if (pendingClosedSessionIds.delete(req.id)) { |
| 181 | yield* exit.value.close.pipe(Effect.timeoutOption(CLOSE_GRACE), Effect.ignore); |
| 182 | const aborted = Object.assign(new Error("Cursor session was closed while opening."), { |
| 183 | name: "AbortError", |
| 184 | }); |
| 185 | writeMessage({ |
| 186 | type: "response", |
| 187 | id: req.id, |
| 188 | ok: false, |
| 189 | error: toRunnerFailure("open", aborted), |
| 190 | }); |
| 191 | return; |
| 192 | } |
| 193 | sessions.set(req.id, exit.value); |
| 194 | writeMessage({ |
| 195 | type: "response", |
| 196 | id: req.id, |
| 197 | ok: true, |
| 198 | result: { agentId: exit.value.agentId }, |
| 199 | }); |
| 200 | return; |
| 201 | } |
| 202 | |
| 203 | case "send": { |
| 204 | const session = sessions.get(req.sessionId); |
| 205 | if (session === undefined) { |
| 206 | writeMessage({ |
| 207 | type: "response", |
| 208 | id: req.id, |
| 209 | ok: false, |
| 210 | error: toRunnerFailure("run.start", new Error("Cursor SDK session is not open.")), |
| 211 | }); |
| 212 | return; |
| 213 | } |
| 214 | startingSendIds.add(req.id); |
| 215 | activeSendStarts += 1; |
| 216 | const exit = yield* Effect.exit( |
| 217 | session.send({ |
| 218 | message: req.message, |
| 219 | ...(req.options === undefined ? {} : { options: req.options }), |
| 220 | ...(req.summarize === undefined ? {} : { summarize: req.summarize }), |
| 221 | ...(req.resume === undefined ? {} : { resume: req.resume }), |
| 222 | onDelta: (update) => |
| 223 | Effect.sync(() => { |
| 224 | if (sessions.has(req.sessionId) && !pendingCancelledSendIds.has(req.id)) { |
| 225 | writeMessage({ type: "delta", sendId: req.id, update }); |
| 226 | } |
| 227 | }), |
| 228 | ...(req.listenBackgroundShells === true |
| 229 | ? { |
| 230 | onBackgroundShell: (event: CursorAgentSdk.CursorBackgroundShellEvent) => |
| 231 | Effect.sync(() => { |
| 232 | const key = `${req.sessionId}:${event.id}`; |
| 233 | if (event.type === "started") { |
| 234 | backgroundShellStops.set(key, event.stop); |
| 235 | writeMessage({ |
| 236 | type: "backgroundShell", |
| 237 | sessionId: req.sessionId, |
| 238 | event: { |
| 239 | type: "started", |
| 240 | id: event.id, |
| 241 | pid: event.pid, |
| 242 | command: event.command, |
| 243 | }, |
| 244 | }); |
| 245 | return; |
| 246 | } |
| 247 | backgroundShellStops.delete(key); |
| 248 | writeMessage({ |
| 249 | type: "backgroundShell", |
| 250 | sessionId: req.sessionId, |
| 251 | event, |
| 252 | }); |
| 253 | }), |
| 254 | } |
| 255 | : {}), |
| 256 | }), |
| 257 | ).pipe( |
| 258 | Effect.ensuring( |
| 259 | Effect.sync(() => { |
| 260 | startingSendIds.delete(req.id); |
| 261 | activeSendStarts -= 1; |
| 262 | }), |
| 263 | ), |
| 264 | ); |
| 265 | if (Exit.isFailure(exit)) { |
| 266 | pendingCancelledSendIds.delete(req.id); |
| 267 | writeMessage({ |
| 268 | type: "response", |
| 269 | id: req.id, |
| 270 | ok: false, |
| 271 | error: exitFailure(req.resume === true ? "run.resume" : "run.start", exit), |
| 272 | }); |
| 273 | return; |
| 274 | } |
| 275 | const run = exit.value; |
| 276 | // Session closed or cancel arrived while send was starting: stop the run immediately. |
| 277 | if (!sessions.has(req.sessionId) || pendingCancelledSendIds.delete(req.id)) { |
| 278 | yield* run.cancel.pipe(Effect.timeoutOption(CLOSE_GRACE), Effect.ignore); |
| 279 | const aborted = Object.assign(new Error("Cursor run was cancelled while starting."), { |
| 280 | name: "AbortError", |
| 281 | }); |
| 282 | writeMessage({ |
| 283 | type: "response", |
| 284 | id: req.id, |
| 285 | ok: false, |
| 286 | error: toRunnerFailure(req.resume === true ? "run.resume" : "run.start", aborted), |
| 287 | }); |
| 288 | return; |
| 289 | } |
| 290 | activeRuns.set(req.id, { sessionId: req.sessionId, run }); |
| 291 | writeMessage({ |
| 292 | type: "response", |
| 293 | id: req.id, |
| 294 | ok: true, |
| 295 | result: { runId: run.runId, agentId: run.agentId }, |
| 296 | }); |
| 297 | yield* Effect.exit(run.wait).pipe( |
| 298 | Effect.tap((waitExit) => |
| 299 | Effect.sync(() => { |
| 300 | activeRuns.delete(req.id); |
| 301 | if (Exit.isFailure(waitExit)) { |
| 302 | writeMessage({ |
| 303 | type: "runDone", |
| 304 | sendId: req.id, |
| 305 | ok: false, |
| 306 | error: exitFailure("run.wait", waitExit), |
| 307 | }); |
| 308 | return; |
| 309 | } |
| 310 | writeMessage({ |
| 311 | type: "runDone", |
| 312 | sendId: req.id, |
| 313 | ok: true, |
| 314 | result: serializeRunResult(waitExit.value), |
| 315 | }); |
| 316 | }), |
| 317 | ), |
| 318 | Effect.asVoid, |
| 319 | Effect.forkIn(workerScope), |
| 320 | ); |
| 321 | return; |
| 322 | } |
| 323 | |
| 324 | case "stopBackgroundShell": { |
| 325 | const key = `${req.sessionId}:${req.shellId}`; |
| 326 | const stop = backgroundShellStops.get(key); |
| 327 | backgroundShellStops.delete(key); |
| 328 | yield* Effect.try({ try: () => stop?.(), catch: () => undefined }).pipe(Effect.ignore); |
| 329 | writeMessage({ type: "response", id: req.id, ok: true, result: null }); |
| 330 | return; |
| 331 | } |
| 332 | |
| 333 | case "steer": { |
| 334 | const entry = activeRuns.get(req.sendId); |
| 335 | if (entry?.run.steer === undefined) { |
| 336 | writeMessage({ |
| 337 | type: "response", |
| 338 | id: req.id, |
| 339 | ok: true, |
| 340 | result: "revert_to_followup", |
| 341 | }); |
| 342 | return; |
| 343 | } |
| 344 | const exit = yield* Effect.exit(entry.run.steer(req.text)); |
| 345 | if (Exit.isFailure(exit)) { |
| 346 | writeMessage({ |
| 347 | type: "response", |
| 348 | id: req.id, |
| 349 | ok: false, |
| 350 | error: exitFailure("run.steer", exit), |
| 351 | }); |
| 352 | return; |
| 353 | } |
| 354 | writeMessage({ type: "response", id: req.id, ok: true, result: exit.value }); |
| 355 | return; |
| 356 | } |
| 357 | |
| 358 | case "cancel": { |
| 359 | const entry = activeRuns.get(req.sendId); |
| 360 | if (entry === undefined) { |
| 361 | if (startingSendIds.has(req.sendId)) { |
| 362 | pendingCancelledSendIds.add(req.sendId); |
| 363 | } |
| 364 | writeMessage({ type: "response", id: req.id, ok: true, result: null }); |
| 365 | return; |
| 366 | } |
| 367 | const exit = yield* Effect.exit(entry.run.cancel); |
| 368 | if (Exit.isFailure(exit)) { |
| 369 | writeMessage({ |
| 370 | type: "response", |
| 371 | id: req.id, |
| 372 | ok: false, |
| 373 | error: exitFailure("run.cancel", exit), |
| 374 | }); |
| 375 | return; |
| 376 | } |
| 377 | writeMessage({ type: "response", id: req.id, ok: true, result: null }); |
| 378 | return; |
| 379 | } |
| 380 | |
| 381 | case "listMessages": { |
| 382 | const session = sessions.get(req.sessionId); |
| 383 | if (session === undefined) { |
| 384 | writeMessage({ |
| 385 | type: "response", |
| 386 | id: req.id, |
| 387 | ok: false, |
| 388 | error: toRunnerFailure( |
| 389 | "agent.messages.list", |
| 390 | new Error("Cursor SDK session is not open."), |
| 391 | ), |
| 392 | }); |
| 393 | return; |
| 394 | } |
| 395 | const exit = yield* Effect.exit(session.listMessages); |
| 396 | if (Exit.isFailure(exit)) { |
| 397 | writeMessage({ |
| 398 | type: "response", |
| 399 | id: req.id, |
| 400 | ok: false, |
| 401 | error: exitFailure("agent.messages.list", exit), |
| 402 | }); |
| 403 | return; |
| 404 | } |
| 405 | writeMessage({ type: "response", id: req.id, ok: true, result: exit.value }); |
| 406 | return; |
| 407 | } |
| 408 | |
| 409 | case "readContextUsage": { |
| 410 | const session = sessions.get(req.sessionId); |
| 411 | if (session?.readContextUsage === undefined) { |
| 412 | writeMessage({ type: "response", id: req.id, ok: true, result: null }); |
| 413 | return; |
| 414 | } |
| 415 | const exit = yield* Effect.exit(session.readContextUsage); |
| 416 | if (Exit.isFailure(exit)) { |
| 417 | writeMessage({ |
| 418 | type: "response", |
| 419 | id: req.id, |
| 420 | ok: false, |
| 421 | error: exitFailure("agent.checkpoint.load", exit), |
| 422 | }); |
| 423 | return; |
| 424 | } |
| 425 | writeMessage({ type: "response", id: req.id, ok: true, result: exit.value ?? null }); |
| 426 | return; |
| 427 | } |
| 428 | |
| 429 | case "runCheckpointed": { |
| 430 | const session = sessions.get(req.sessionId); |
| 431 | if (session?.runCheckpointed === undefined) { |
| 432 | writeMessage({ type: "response", id: req.id, ok: true, result: false }); |
| 433 | return; |
| 434 | } |
| 435 | const exit = yield* Effect.exit(session.runCheckpointed(req.runId)); |
| 436 | if (Exit.isFailure(exit)) { |
| 437 | writeMessage({ |
| 438 | type: "response", |
| 439 | id: req.id, |
| 440 | ok: false, |
| 441 | error: exitFailure("agent.run.get", exit), |
| 442 | }); |
| 443 | return; |
| 444 | } |
| 445 | writeMessage({ type: "response", id: req.id, ok: true, result: exit.value }); |
| 446 | return; |
| 447 | } |
| 448 | |
| 449 | case "rewindAfterRun": { |
| 450 | const session = sessions.get(req.sessionId); |
| 451 | if (session?.rewindAfterRun === undefined) { |
| 452 | writeMessage({ type: "response", id: req.id, ok: true, result: null }); |
| 453 | return; |
| 454 | } |
| 455 | const exit = yield* Effect.exit(session.rewindAfterRun(req.runId)); |
| 456 | if (Exit.isFailure(exit)) { |
| 457 | writeMessage({ |
| 458 | type: "response", |
| 459 | id: req.id, |
| 460 | ok: false, |
| 461 | error: exitFailure("agent.rewind", exit), |
| 462 | }); |
| 463 | return; |
| 464 | } |
| 465 | writeMessage({ type: "response", id: req.id, ok: true, result: null }); |
| 466 | return; |
| 467 | } |
| 468 | |
| 469 | case "textGenerate": { |
| 470 | const fiber = yield* Effect.forkIn( |
| 471 | runCursorTextGenerationInProcess(req).pipe( |
| 472 | Effect.provideService(CursorSdk.CursorSdk, cursorSdk), |
| 473 | ), |
| 474 | workerScope, |
| 475 | ); |
| 476 | textGenerations.set(req.id, fiber); |
| 477 | const exit = yield* Fiber.await(fiber).pipe( |
| 478 | Effect.ensuring( |
| 479 | Effect.sync(() => { |
| 480 | textGenerations.delete(req.id); |
| 481 | }), |
| 482 | ), |
| 483 | ); |
| 484 | if (Exit.isFailure(exit)) { |
| 485 | writeMessage({ |
| 486 | type: "response", |
| 487 | id: req.id, |
| 488 | ok: false, |
| 489 | error: exitFailure("textGenerate", exit), |
| 490 | }); |
| 491 | return; |
| 492 | } |
| 493 | writeMessage({ |
| 494 | type: "response", |
| 495 | id: req.id, |
| 496 | ok: true, |
| 497 | result: serializeRunResult(exit.value), |
| 498 | }); |
| 499 | return; |
| 500 | } |
| 501 | |
| 502 | case "cancelTextGenerate": { |
| 503 | const fiber = textGenerations.get(req.textGenerateId); |
| 504 | if (fiber !== undefined) { |
| 505 | yield* Effect.forkIn(Fiber.interrupt(fiber), workerScope); |
| 506 | } |
| 507 | writeMessage({ type: "response", id: req.id, ok: true, result: null }); |
| 508 | return; |
| 509 | } |
| 510 | |
| 511 | case "closeSession": { |
| 512 | const exit = yield* closeSession(req.sessionId); |
| 513 | writeMessage( |
| 514 | Exit.isFailure(exit) |
| 515 | ? { type: "response", id: req.id, ok: false, error: exitFailure("agent.close", exit) } |
| 516 | : { type: "response", id: req.id, ok: true, result: null }, |
| 517 | ); |
| 518 | return; |
| 519 | } |
| 520 | |
| 521 | case "close": { |
| 522 | shuttingDown = true; |
| 523 | const exits = yield* closeAllSessions(); |
| 524 | const exit = exits.find(Exit.isFailure) ?? Exit.void; |
| 525 | if (Exit.isFailure(exit)) { |
| 526 | writeMessage({ |
| 527 | type: "response", |
| 528 | id: req.id, |
| 529 | ok: false, |
| 530 | error: exitFailure("agent.close", exit), |
| 531 | }); |
| 532 | } else { |
| 533 | writeMessage({ type: "response", id: req.id, ok: true, result: null }); |
| 534 | } |
| 535 | yield* Deferred.succeed(shutdownSignal, undefined); |
| 536 | return; |
| 537 | } |
| 538 | } |
| 539 | }); |
| 540 | |
| 541 | const dispatchLine = (line: string): Effect.Effect<void> => { |
| 542 | if (line.trim().length === 0) return Effect.void; |
| 543 | let parsed: CursorWorkerRequest; |
| 544 | try { |
| 545 | parsed = decodeWorkerFrame(line) as CursorWorkerRequest; |
| 546 | } catch (cause) { |
| 547 | return Effect.logWarning("Invalid Cursor SDK worker frame.", { cause }); |
| 548 | } |
| 549 | return handleRequest(parsed).pipe( |
| 550 | Effect.catchCause((cause) => |
| 551 | Effect.sync(() => { |
| 552 | writeMessage({ |
| 553 | type: "response", |
| 554 | id: parsed.id, |
| 555 | ok: false, |
| 556 | error: toRunnerFailure(parsed.type, Cause.squash(cause)), |
| 557 | }); |
| 558 | }), |
| 559 | ), |
| 560 | Effect.forkIn(workerScope), |
| 561 | Effect.asVoid, |
| 562 | ); |
| 563 | }; |
| 564 | |
| 565 | yield* stdio.stdin.pipe( |
| 566 | Stream.interruptWhen(Deferred.await(shutdownSignal)), |
| 567 | Stream.decodeText(), |
| 568 | Stream.splitLines, |
| 569 | Stream.runForEach(dispatchLine), |
| 570 | Effect.ignoreCause, |
| 571 | ); |
| 572 | |
| 573 | shuttingDown = true; |
| 574 | yield* Effect.forEach(Array.from(textGenerations.values()), (fiber) => Fiber.interrupt(fiber), { |
| 575 | concurrency: "unbounded", |
| 576 | discard: true, |
| 577 | }); |
| 578 | yield* closeAllSessions().pipe(Effect.ignore); |
| 579 | yield* Queue.end(outgoing); |
| 580 | yield* Fiber.await(writerFiber).pipe(Effect.timeoutOption(CLOSE_GRACE), Effect.ignore); |
| 581 | }); |
| 582 | |
| 583 | export async function runCursorSdkWorker( |
| 584 | platformLayer: Layer.Layer<FileSystem.FileSystem | Path.Path | Stdio.Stdio>, |
| 585 | ): Promise<void> { |
| 586 | // Electron has already booted in Node mode; strip the flag so agent shells do not inherit it. |
| 587 | delete process.env.ELECTRON_RUN_AS_NODE; |
| 588 | |
| 589 | // Reserve fd 1 exclusively for NDJSON frames; redirect stray SDK logs to stderr. |
| 590 | const rawStdoutWrite = process.stdout.write.bind(process.stdout); |
| 591 | const stderrWrite = process.stderr.write.bind(process.stderr); |
| 592 | process.stdout.on("error", () => {}); |
| 593 | process.stderr.on("error", () => {}); |
| 594 | process.stdout.write = stderrWrite as typeof process.stdout.write; |
| 595 | console.log = console.info = console.debug = console.warn = console.error; |
| 596 | |
| 597 | const rawStdoutSink = Sink.forEach((chunk: string | Uint8Array) => |
| 598 | Effect.callback<void>((resume) => { |
| 599 | try { |
| 600 | rawStdoutWrite(chunk, () => resume(Effect.void)); |
| 601 | } catch { |
| 602 | resume(Effect.void); |
| 603 | } |
| 604 | }), |
| 605 | ); |
| 606 | |
| 607 | const workerStdioLayer = Layer.effect( |
| 608 | Stdio.Stdio, |
| 609 | Effect.map(Stdio.Stdio, (baseStdio) => |
| 610 | Stdio.make({ |
| 611 | args: baseStdio.args, |
| 612 | stdin: baseStdio.stdin, |
| 613 | stdout: () => rawStdoutSink, |
| 614 | stderr: baseStdio.stderr, |
| 615 | }), |
| 616 | ), |
| 617 | ); |
| 618 | |
| 619 | const program = Effect.scoped( |
| 620 | Effect.gen(function* () { |
| 621 | const shutdownSignal = yield* Deferred.make<void>(); |
| 622 | const onSignal = () => { |
| 623 | Deferred.doneUnsafe(shutdownSignal, Exit.void); |
| 624 | }; |
| 625 | yield* Effect.acquireRelease( |
| 626 | Effect.sync(() => { |
| 627 | process.on("SIGTERM", onSignal); |
| 628 | process.on("SIGINT", onSignal); |
| 629 | }), |
| 630 | () => |
| 631 | Effect.sync(() => { |
| 632 | process.off("SIGTERM", onSignal); |
| 633 | process.off("SIGINT", onSignal); |
| 634 | }), |
| 635 | ); |
| 636 | yield* runCursorSdkWorkerWithStdio({ shutdownSignal }); |
| 637 | }), |
| 638 | ).pipe( |
| 639 | Effect.provide( |
| 640 | Layer.mergeAll(CursorSdk.layer, workerStdioLayer).pipe(Layer.provideMerge(platformLayer)), |
| 641 | ), |
| 642 | ); |
| 643 | |
| 644 | await Effect.runPromise(program); |
| 645 | // SDK keep-alive handles can outlive session disposal; exit explicitly once stdout has flushed. |
| 646 | process.exit(0); |
| 647 | } |