sailfork / t3code-github / packages/ provider-cursor/ src/ server/ driver.test.ts

// @effect-diagnostics nodeBuiltinImport:off
import type { AgentOptions, SDKModel } from "@cursor/sdk";
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { expect, it } from "@effect/vitest";
import {
  MessageId,
  NodeId,
  ProjectId,
  ProviderInstanceId,
  ProviderSessionId,
  RunAttemptId,
  RunId,
  ThreadId,
} from "@t3tools/contracts";
import * as DateTime from "effect/DateTime";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Stream from "effect/Stream";
import { vi } from "vite-plus/test";
import * as HttpClient from "effect/http/HttpClient";
import * as HttpClientResponse from "effect/http/HttpClientResponse";
import * as Deferred from "effect/Deferred";

import {
  DEFAULT_HANDOFF_TOKEN_CAP,
  handoffBudget,
} from "@t3tools/provider-core/server/handoffBudget";
import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEventLoggers";
import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost";
import { CursorDriver } from "./driver.ts";
import * as CursorAgentSdk from "./CursorAgentSdk.ts";
import * as CursorSdk from "./CursorSdk.ts";
import * as CursorKeychain from "./CursorKeychain.ts";
import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
import { loadCursorSdk } from "./sdk.ts";

const { Cursor } = loadCursorSdk();

const layerTest = TestProviderHost.layer({ runBackgroundWork: false }).pipe(
  Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
  Layer.provideMerge(IdAllocator.layer),
  Layer.provideMerge(McpProviderSessions.layer),
  Layer.provideMerge(CursorSdk.layer),
  Layer.provideMerge(
    Layer.mock(CursorAgentSdk.CursorAgentSdkRunner)({
      open: () => Effect.die("Maintenance resolution must not open a Cursor session"),
    }),
  ),
  Layer.provideMerge(
    Layer.succeed(CursorKeychain.CursorKeychain, {
      accessToken: Effect.die("The driver test must not read the Keychain"),
    }),
  ),
  Layer.provideMerge(
    Layer.succeed(
      ProviderEventLoggers.ProviderEventLoggers,
      ProviderEventLoggers.NoOpProviderEventLoggers,
    ),
  ),
  Layer.provideMerge(
    Layer.succeed(
      HttpClient.HttpClient,
      HttpClient.make(() => Effect.die("Disabled Cursor must not make an HTTP request")),
    ),
  ),
);

it.layer(layerTest)("CursorDriver", (it) => {
  it.effect(
    "persists browser credentials, uses them for chat, and closes the SDK session on logout",
    () =>
      Effect.gen(function* () {
        const login = vi.spyOn(Cursor.auth, "login").mockImplementation(async (options) => {
          options?.onLoginUrl?.("https://cursor.com/loginDeepControl?challenge=test-only");
          await options?.store?.save({
            version: 1,
            backendUrl: "https://api2.cursor.sh",
            apiKey: "instance-browser-key",
            createdAtMs: 0,
            apiKeyExpiresAtMs: 4_000_000_000_000,
            email: "cursor@example.com",
          });
          return { apiKey: "instance-browser-key", apiKeyExpiresAtMs: 4_000_000_000_000 };
        });
        const requests: Array<{ url: string; authorization: string | undefined }> = [];
        const client = HttpClient.make((request) => {
          requests.push({ url: request.url, authorization: request.headers.authorization });
          return Effect.succeed(
            HttpClientResponse.fromWeb(
              request,
              Response.json(
                request.url.endsWith("/v1/me")
                  ? {
                      apiKeyName: "T3 Code",
                      createdAt: "2026-01-01T00:00:00.000Z",
                      userEmail: "cursor@example.com",
                    }
                  : { items: [{ id: "auto", displayName: "Auto" }] },
              ),
            ),
          );
        });
        yield* Effect.addFinalizer(() =>
          Effect.sync(() => {
            login.mockRestore();
          }),
        );
        const input = {
          instanceId: ProviderInstanceId.make("cursor-browser-persisted"),
          displayName: "Personal Cursor",
          enabled: true,
          environment: [{ name: "CURSOR_API_KEY", value: "", sensitive: true }],
          config: CursorDriver.defaultConfig(),
        };
        const openedKeys: Array<string | undefined> = [];
        let closed = 0;
        const instance = yield* CursorDriver.create(input).pipe(
          Effect.provideService(HttpClient.HttpClient, client),
          Effect.provideService(CursorAgentSdk.CursorAgentSdkRunner, {
            assertComplete: Effect.void,
            open: (request) =>
              Effect.sync(() => {
                openedKeys.push(request.options.apiKey);
                return {
                  agentId: "browser-auth-agent",
                  listMessages: Effect.succeed([]),
                  send: () => Effect.die("This test only opens a session"),
                  close: Effect.sync(() => {
                    closed += 1;
                  }),
                };
              }),
          }),
        );
        expect((yield* instance.snapshot.refresh).auth.status).toBe("unauthenticated");
        yield* instance.auth!.start("client");
        yield* instance.auth!.subscribe("client").pipe(
          Stream.filter((state) => state.phase === "succeeded"),
          Stream.runHead,
          Effect.map(Option.getOrThrow),
        );
        expect(requests).toContainEqual({
          url: "https://api.cursor.com/v1/me",
          authorization: "Bearer instance-browser-key",
        });
        expect(yield* instance.snapshot.getSnapshot).toMatchObject({
          status: "ready",
          auth: {
            status: "authenticated",
            type: "browser",
            canLogout: true,
            email: "cursor@example.com",
          },
          setup: { canAuthenticate: true, canInstall: false },
        });
        const threadId = ThreadId.make("cursor-browser-thread");
        const modelSelection = { instanceId: input.instanceId, model: "auto" };
        const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
          runtimeMode: "full-access",
          interactionMode: "default",
          cwd: process.cwd(),
        });
        const runtime = yield* instance.orchestrationAdapter.openSession({
          threadId,
          providerSessionId: ProviderSessionId.make("cursor-browser-session"),
          modelSelection,
          runtimePolicy,
        });
        yield* runtime.ensureThread({ threadId, modelSelection, runtimePolicy });
        expect(openedKeys).toEqual(["instance-browser-key"]);
        expect(closed).toBe(0);
        const recreated = yield* CursorDriver.create(input).pipe(
          Effect.provideService(HttpClient.HttpClient, client),
        );
        expect((yield* recreated.snapshot.refresh).auth.status).toBe("authenticated");
        yield* instance.auth!.logout(Effect.void);
        expect(closed).toBe(1);
        expect((yield* instance.snapshot.getSnapshot).auth.status).toBe("unauthenticated");
        expect((yield* recreated.snapshot.refresh).auth.status).toBe("unauthenticated");
        expect(
          (yield* Effect.exit(runtime.ensureThread({ threadId, modelSelection, runtimePolicy })))
            ._tag,
        ).toBe("Failure");
        expect(openedKeys).toEqual(["instance-browser-key"]);
        expect(closed).toBe(1);
      }).pipe(Effect.scoped),
  );

  it.effect("budgets handoffs for the SDK model across catalog refreshes and option changes", () =>
    Effect.gen(function* () {
      const fileSystem = yield* FileSystem.FileSystem;
      const workspace = yield* fileSystem.makeTempDirectoryScoped({ prefix: "cursor-window-" });
      const catalog = yield* Deferred.make<Array<SDKModel>>();
      const catalogRequested = yield* Deferred.make<void>();
      let failUser = false;
      const client = HttpClient.make((request) =>
        Effect.gen(function* () {
          if (request.url.endsWith("/v1/me"))
            return HttpClientResponse.fromWeb(
              request,
              Response.json(
                failUser
                  ? { error: { message: "Cursor is unreachable" } }
                  : { apiKeyName: "T3 Code", createdAt: "2026-01-01T00:00:00.000Z" },
                { status: failUser ? 503 : 200 },
              ),
            );
          yield* Deferred.succeed(catalogRequested, undefined);
          const models = yield* Deferred.await(catalog);
          return HttpClientResponse.fromWeb(request, Response.json({ items: models }));
        }),
      );
      const instanceId = ProviderInstanceId.make("cursor-catalog-window");
      const openedModels: Array<AgentOptions["model"]> = [];
      const sentModels: Array<AgentOptions["model"]> = [];
      const instance = yield* CursorDriver.create({
        instanceId,
        displayName: "Cursor",
        enabled: true,
        environment: [{ name: "CURSOR_API_KEY", value: "catalog-window-key", sensitive: true }],
        config: CursorDriver.defaultConfig(),
      }).pipe(
        Effect.provideService(HttpClient.HttpClient, client),
        Effect.provideService(CursorAgentSdk.CursorAgentSdkRunner, {
          assertComplete: Effect.void,
          open: (request) =>
            Effect.sync(() => {
              openedModels.push(request.options.model);
              return {
                agentId: "native-cursor-window",
                listMessages: Effect.succeed([]),
                close: Effect.void,
                send: (input) =>
                  Effect.sync(() => {
                    sentModels.push(input.options?.model);
                    const runId = `native-cursor-window-run-${sentModels.length}`;
                    return {
                      agentId: "native-cursor-window",
                      runId,
                      cancel: Effect.void,
                      wait: Effect.succeed({
                        id: runId,
                        requestId: runId,
                        status: "finished" as const,
                        model: { id: "claude-opus-5-5" },
                        durationMs: 1,
                      }),
                    };
                  }),
              };
            }),
        }),
      );
      const selection = (contextWindow?: string) => ({
        instanceId,
        model: "claude-opus-5-5",
        ...(contextWindow === undefined
          ? {}
          : { options: [{ id: "contextWindow", value: contextWindow }] }),
      });
      const threadId = ThreadId.make("cursor-catalog-window-thread");
      const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
        runtimeMode: "full-access",
        interactionMode: "default",
        cwd: workspace,
      });
      const runtime = yield* instance.orchestrationAdapter.openSession({
        threadId,
        providerSessionId: ProviderSessionId.make("cursor-catalog-window-session"),
        modelSelection: selection("1m"),
        runtimePolicy,
      });
      const refresh = yield* instance.snapshot.refresh.pipe(Effect.forkScoped);
      yield* Deferred.await(catalogRequested);
      expect(runtime.getModelContextWindow?.(selection())).toBeUndefined();
      const providerThread = yield* runtime.ensureThread({
        threadId,
        modelSelection: selection("1m"),
        runtimePolicy,
      });
      const now = yield* DateTime.now;
      const startTurn = Effect.fnUntraced(function* (contextWindow?: string) {
        const modelSelection = selection(contextWindow);
        const ordinal = sentModels.length + 1;
        yield* runtime.startTurn({
          threadId,
          providerThread,
          modelSelection,
          runtimePolicy,
          runId: RunId.make(`cursor-window-run-${ordinal}`),
          runOrdinal: ordinal,
          providerTurnOrdinal: ordinal,
          attemptId: RunAttemptId.make(`cursor-window-attempt-${ordinal}`),
          rootNodeId: NodeId.make(`cursor-window-root-${ordinal}`),
          appThread: {
            id: threadId,
            projectId: ProjectId.make("cursor-window-project"),
            createdBy: "user",
            creationSource: "web",
            title: "Cursor context window",
            providerInstanceId: instanceId,
            modelSelection,
            runtimeMode: "full-access",
            interactionMode: "default",
            branch: null,
            worktreePath: null,
            activeProviderThreadId: providerThread.id,
            lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: threadId },
            forkedFrom: null,
            createdAt: now,
            updatedAt: now,
            archivedAt: null,
            settledOverride: null,
            settledAt: null,
            lastVisitedAt: null,
            deletedAt: null,
          },
          message: {
            messageId: MessageId.make(`cursor-window-message-${ordinal}`),
            createdBy: "user",
            creationSource: "web",
            text: "Continue.",
            attachments: [],
          },
        });
        yield* runtime.events.pipe(
          Stream.takeUntil((event) => event.type === "turn.terminal"),
          Stream.runDrain,
        );
        const window = runtime.getModelContextWindow?.(modelSelection);
        return {
          model: sentModels.at(-1),
          window,
          allowance: handoffBudget({
            tokenCap: DEFAULT_HANDOFF_TOKEN_CAP,
            userText: "Continue.",
            attachments: [],
            providerThread,
            nativeContextEstimate: 400_000,
            modelContextWindow: window,
          }),
        };
      });
      const beforeCatalog = yield* startTurn("1m");
      yield* Deferred.succeed(catalog, [
        {
          id: "claude-opus-5-5",
          displayName: "Claude Opus 5.5",
          parameters: [
            {
              id: "context",
              displayName: "Context",
              values: [{ value: "300k" }, { value: "1m" }],
            },
          ],
          variants: [
            {
              displayName: "Claude Opus 5.5",
              isDefault: true,
              params: [{ id: "context", value: "1m" }],
            },
          ],
        },
      ]);
      expect((yield* Fiber.join(refresh)).status).toBe("ready");
      const catalogDefault = yield* startTurn();
      const explicitWindow = yield* startTurn("500k");
      const unknownWindow = yield* startTurn("max");
      failUser = true;
      expect((yield* instance.snapshot.refresh).status).toBe("error");
      const retainedDefault = yield* startTurn();

      expect(openedModels).toEqual([
        {
          id: "claude-opus-5-5",
          params: [{ id: "context", value: "1m" }],
        },
      ]);
      expect({
        beforeCatalog,
        catalogDefault,
        explicitWindow,
        unknownWindow,
        retainedDefault,
      }).toEqual({
        beforeCatalog: {
          model: { id: "claude-opus-5-5", params: [{ id: "context", value: "1m" }] },
          window: 1_000_000,
          allowance: DEFAULT_HANDOFF_TOKEN_CAP,
        },
        catalogDefault: {
          model: { id: "claude-opus-5-5" },
          window: 1_000_000,
          allowance: DEFAULT_HANDOFF_TOKEN_CAP,
        },
        explicitWindow: {
          model: { id: "claude-opus-5-5", params: [{ id: "context", value: "500k" }] },
          window: 500_000,
          allowance: 0,
        },
        unknownWindow: {
          model: { id: "claude-opus-5-5", params: [{ id: "context", value: "max" }] },
          window: undefined,
          allowance: 0,
        },
        retainedDefault: catalogDefault,
      });
    }).pipe(Effect.scoped),
  );
});