import { DurableObject } from "cloudflare:workers";import { describe, expect, it } from "@effect/vitest";import { Effect } from "effect"; import {  McpExecutionOwnerDirectoryDO,  mcpExecutionOwnerDirectoryFromNamespace,  type McpExecutionOwnerDirectoryNamespace,  type McpExecutionOwnerRecord,} from "./execution-owner-directory"; class FakeStorage implements DurableObjectStorage {  private readonly values = new Map<string, unknown>();  readonly sql = {} as DurableObjectStorage["sql"];  readonly kv = {} as DurableObjectStorage["kv"];  alarmAt: number | null = null;   async get<T>(key: string): Promise<T | undefined>;  async get<T>(keys: string[]): Promise<Map<string, T>>;  async get<T>(keyOrKeys: string | string[]): Promise<T | undefined | Map<string, T>> {    if (Array.isArray(keyOrKeys)) {      return new Map(keyOrKeys.map((key) => [key, this.values.get(key) as T]));    }    return this.values.get(keyOrKeys) as T | undefined;  }   async put<T>(key: string, value: T): Promise<void>;  async put<T>(entries: Record<string, T> | Map<string, T>): Promise<void>;  async put<T>(    keyOrEntries: string | Record<string, T> | Map<string, T>,    value?: T,  ): Promise<void> {    if (typeof keyOrEntries === "string") {      this.values.set(keyOrEntries, value);      return;    }    const entries =      keyOrEntries instanceof Map ? keyOrEntries.entries() : Object.entries(keyOrEntries);    for (const [key, entry] of entries) this.values.set(key, entry);  }   async delete(key: string): Promise<boolean>;  async delete(keys: string[]): Promise<number>;  async delete(keyOrKeys: string | string[]): Promise<boolean | number> {    if (!Array.isArray(keyOrKeys)) return this.values.delete(keyOrKeys);    let deleted = 0;    for (const key of keyOrKeys) {      if (this.values.delete(key)) deleted += 1;    }    return deleted;  }   async list<T = unknown>(): Promise<Map<string, T>> {    return new Map([...this.values.entries()].map(([key, value]) => [key, value as T]));  }   async deleteAll(): Promise<void> {    this.values.clear();    this.alarmAt = null;  }   transaction<T>(_closure: (txn: DurableObjectTransaction) => Promise<T>): Promise<T> {    return Promise.resolve(undefined as T);  }   transactionSync<T>(_closure: () => T): T {    return undefined as T;  }   async sync(): Promise<void> {}   async getAlarm(): Promise<number | null> {    return this.alarmAt;  }   async getCurrentBookmark(): Promise<string> {    return "test-bookmark";  }   async getBookmarkForTime(_timestamp: number | Date): Promise<string> {    return "test-bookmark";  }   onNextSessionRestoreBookmark(_bookmark: string): Promise<string> {    return Promise.resolve("test-bookmark");  }   async setAlarm(scheduledTime: number | Date): Promise<void> {    this.alarmAt = scheduledTime instanceof Date ? scheduledTime.getTime() : scheduledTime;  }   async deleteAlarm(): Promise<void> {    this.alarmAt = null;  }} class FakeDurableObjectState implements DurableObjectState {  readonly id: DurableObjectId;  readonly props: unknown = undefined;  readonly facets = {} as DurableObjectState["facets"];  readonly ctx = this;  private readonly waitUntilPromises: Promise<unknown>[] = [];   constructor(    name: string,    readonly storage: FakeStorage,  ) {    const id: Pick<DurableObjectId, "equals" | "name" | "toString"> = {      equals: (other: DurableObjectId) => other.toString() === name,      name,      toString: () => name,    };    this.id = id as DurableObjectId;  }   waitUntil(promise: Promise<unknown>): void {    this.waitUntilPromises.push(promise);  }   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T> {    return callback();  }   acceptWebSocket(_ws: WebSocket, _tags?: string[]): void {}   getWebSockets(_tag?: string): WebSocket[] {    return [];  }   getTags(_ws: WebSocket): string[] {    return [];  }   setWebSocketAutoResponse(_pair?: WebSocketRequestResponsePair): void {}   getWebSocketAutoResponse(): WebSocketRequestResponsePair | null {    return null;  }   getWebSocketAutoResponseTimestamp(_ws: WebSocket): Date | null {    return null;  }   setHibernatableWebSocketEventTimeout(_timeoutMs?: number): void {}   getHibernatableWebSocketEventTimeout(): number | null {    return null;  }   abort(_reason?: string): void {}} const makeDirectory = () => {  const storage = new FakeStorage();  const directory = new McpExecutionOwnerDirectoryDO(    new FakeDurableObjectState("execution-owner", storage),    {},  );  return { directory, storage };}; class FakeDirectoryNamespace implements McpExecutionOwnerDirectoryNamespace<string> {  private readonly directories = new Map<string, McpExecutionOwnerDirectoryDO>();   idFromName(name: string): string {    return name;  }   get(id: string): unknown {    let directory = this.directories.get(id);    if (!directory) {      directory = makeDirectory().directory;      this.directories.set(id, directory);    }    if (!(directory instanceof DurableObject)) return {};    return {      put: (entry: McpExecutionOwnerRecord) => directory.put(entry),      get: (executionId: string) => directory.get(executionId),      delete: (executionId: string) => directory.delete(executionId),    };  }} const record = (input?: Partial<McpExecutionOwnerRecord>): McpExecutionOwnerRecord => ({  executionId: "exec_1",  owner: { sessionId: "session_a" },  accountId: "acct_1",  organizationId: "org_1",  expiresAt: new Date(Date.now() + 60_000).toISOString(),  ttlMs: 60_000,  ...input,}); describe("McpExecutionOwnerDirectoryDO", () => {  it("exports a DurableObject subclass for RPC method dispatch", () => {    expect(Object.getPrototypeOf(McpExecutionOwnerDirectoryDO)).toBe(DurableObject);    expect(makeDirectory().directory).toBeInstanceOf(DurableObject);  });   it("stores and reads an unexpired execution owner record", async () => {    const { directory, storage } = makeDirectory();    const entry = record();     await directory.put(entry);     expect(await directory.get("exec_1")).toEqual(entry);    expect(storage.alarmAt).toBe(Date.parse(entry.expiresAt));  });   it("treats expired records as absent and deletes them", async () => {    const { directory, storage } = makeDirectory();    const entry = record({      expiresAt: new Date(Date.now() - 1_000).toISOString(),    });     await directory.put(entry);     expect(await directory.get("exec_1")).toBeNull();    expect(await storage.get("owner")).toBeUndefined();    expect(storage.alarmAt).toBeNull();  });   it("alarm deletes the owner record", async () => {    const { directory, storage } = makeDirectory();    await directory.put(record());     await directory.alarm();     expect(await storage.get("owner")).toBeUndefined();    expect(storage.alarmAt).toBeNull();  });   it("stores, reads, and deletes records through the namespace RPC path", async () => {    const directory = mcpExecutionOwnerDirectoryFromNamespace(new FakeDirectoryNamespace());    const entry = record({ executionId: "exec_rpc" });     expect(directory).not.toBeNull();    await Effect.runPromise(directory!.put(entry));     expect(await Effect.runPromise(directory!.get("exec_rpc"))).toEqual(entry);     await Effect.runPromise(directory!.delete("exec_rpc"));     expect(await Effect.runPromise(directory!.get("exec_rpc"))).toBeNull();  });});