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

import type { StoredSdkCredentials } from "@cursor/sdk";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, it } from "@effect/vitest";
import { ProviderInstanceId } from "@t3tools/contracts";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Path from "effect/Path";

import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost";
import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost";
import * as Layer from "effect/Layer";
import { makeCursorCredentialStore } from "./credentialStore.ts";

const layerHost = Layer.provideMerge(TestProviderHost.layer(), NodeServices.layer);
const legacyFileText = `{
  "version": 1,
  "backendUrl": "https://api.cursor.com",
  "apiKey": "test-only-legacy-key",
  "createdAtMs": 100
}`;

it.effect.each([
  {
    name: "imports a legacy sign-in",
    legacy: legacyFileText,
    stored: undefined,
    expected: "test-only-legacy-key",
  },
  {
    name: "keeps a newer stored sign-in",
    legacy: legacyFileText,
    stored: legacyFileText.replace("test-only-legacy-key", "test-only-current-key"),
    expected: "test-only-current-key",
  },
  {
    name: "replaces a damaged stored sign-in",
    legacy: legacyFileText,
    stored: "damaged",
    expected: "test-only-legacy-key",
  },
  {
    name: "discards a damaged legacy file",
    legacy: "damaged",
    stored: undefined,
    expected: undefined,
  },
])("$name and deletes the legacy file", ({ legacy, stored, expected }) =>
  Effect.gen(function* () {
    const fileSystem = yield* FileSystem.FileSystem;
    const path = yield* Path.Path;
    const legacyFile = path.join(yield* fileSystem.makeTempDirectoryScoped(), "cursor.json");
    yield* fileSystem.writeFileString(legacyFile, legacy);
    const host = yield* ProviderHost.ProviderHost;
    const instanceId = ProviderInstanceId.make("personal");
    if (stored !== undefined) {
      yield* (yield* host.credentials("cursor", instanceId)).set(new TextEncoder().encode(stored));
    }
    const migrated = yield* makeCursorCredentialStore(instanceId, legacyFile);
    assert.strictEqual((yield* Effect.promise(() => migrated.store.load()))?.apiKey, expected);
    assert.isFalse(yield* fileSystem.exists(legacyFile));
  }).pipe(Effect.scoped, Effect.provide(layerHost)),
);

it.effect(
  "restores SDK credentials in a new controller and keeps another account when signing out",
  () =>
    Effect.gen(function* () {
      const host = yield* ProviderHost.ProviderHost;
      const makeStore = (id: string) => makeCursorCredentialStore(ProviderInstanceId.make(id));
      const personal = yield* makeStore("personal");
      const work = yield* makeStore("work");
      const credentials = {
        version: 1 as const,
        backendUrl: "https://api.cursor.com",
        apiKey: "test-only-key",
        createdAtMs: 100,
        apiKeyExpiresAtMs: 1000,
        email: "test@example.com",
      };
      yield* Effect.promise(() => personal.store.save(credentials));
      yield* Effect.promise(() =>
        work.store.save({ ...credentials, apiKey: "test-only-work-key" }),
      );
      const restored = yield* makeStore("personal");
      assert.deepEqual(yield* Effect.promise(() => restored.store.load()), credentials);
      yield* (yield* host.credentials("cursor", "personal")).set(
        new TextEncoder().encode("damaged credential"),
      );
      assert.isUndefined(yield* Effect.promise(() => restored.store.load()));
      yield* Effect.promise(() => restored.store.save(credentials));
      yield* Effect.promise(() => restored.store.clear());
      assert.isUndefined(yield* Effect.promise(() => personal.store.load()));
      assert.strictEqual(
        (yield* Effect.promise(() => work.store.load()))?.apiKey,
        "test-only-work-key",
      );
    }).pipe(Effect.provide(layerHost)),
);

it.effect.each([
  {
    name: "an undefined email",
    optionalFields: { email: undefined, apiKeyExpiresAtMs: 1000 },
    expectedFields: { apiKeyExpiresAtMs: 1000 },
  },
  {
    name: "an undefined expiry",
    optionalFields: { email: "test@example.com", apiKeyExpiresAtMs: undefined },
    expectedFields: { email: "test@example.com" },
  },
  {
    name: "both optional fields undefined",
    optionalFields: { email: undefined, apiKeyExpiresAtMs: undefined },
    expectedFields: {},
  },
  {
    name: "both optional fields omitted",
    optionalFields: {},
    expectedFields: {},
  },
])("restores SDK credentials with $name in a new store", ({ optionalFields, expectedFields }) =>
  Effect.gen(function* () {
    const instanceId = ProviderInstanceId.make("personal");
    const { store } = yield* makeCursorCredentialStore(instanceId);
    const requiredFields: StoredSdkCredentials = {
      version: 1,
      backendUrl: "https://api.cursor.com",
      apiKey: "test-only-key",
      createdAtMs: 100,
    };
    const credentials = { ...requiredFields };
    // Match the SDK's runtime values without relying on its stricter declarations.
    Object.assign(credentials, optionalFields);
    yield* Effect.promise(() => store.save(credentials));

    const restored = yield* makeCursorCredentialStore(instanceId);
    assert.deepEqual(yield* Effect.promise(() => restored.store.load()), {
      ...requiredFields,
      ...expectedFields,
    });
  }).pipe(Effect.provide(layerHost)),
);