@posthog/agent 2.1.70 → 2.1.82

package/src/test/controllers/sse-controller.ts

@@ -1,107 +0,0 @@
-type SseState = "idle" | "streaming" | "closing" | "closed";
-
-export interface EventOptions {
-  id?: string;
-  event?: string;
-}
-
-export class SseController {
-  private encoder = new TextEncoder();
-  private controller: ReadableStreamDefaultController<Uint8Array> | null = null;
-  private state: SseState = "idle";
-
-  createStream(): ReadableStream<Uint8Array> {
-    return new ReadableStream({
-      start: (controller) => {
-        this.controller = controller;
-        this.state = "streaming";
-      },
-      cancel: () => {
-        this.state = "closed";
-      },
-    });
-  }
-
-  sendEvent(data: unknown, options: EventOptions = {}): boolean {
-    if (
-      this.state === "closed" ||
-      this.state === "closing" ||
-      !this.controller
-    ) {
-      return false;
-    }
-
-    const lines: string[] = [];
-    if (options.id) {
-      lines.push(`id: ${options.id}`);
-    }
-    if (options.event) {
-      lines.push(`event: ${options.event}`);
-    }
-    lines.push(`data: ${JSON.stringify(data)}`);
-    lines.push("");
-    lines.push("");
-
-    try {
-      this.controller.enqueue(this.encoder.encode(lines.join("\n")));
-      return true;
-    } catch {
-      this.state = "closed";
-      return false;
-    }
-  }
-
-  sendRaw(rawData: string): boolean {
-    if (
-      this.state === "closed" ||
-      this.state === "closing" ||
-      !this.controller
-    ) {
-      return false;
-    }
-    try {
-      this.controller.enqueue(this.encoder.encode(rawData));
-      return true;
-    } catch {
-      this.state = "closed";
-      return false;
-    }
-  }
-
-  sendPartial(partialData: string): boolean {
-    return this.sendRaw(partialData);
-  }
-
-  error(err: Error): void {
-    if (this.state !== "streaming" || !this.controller) return;
-
-    try {
-      this.state = "closed";
-      this.controller.error(err);
-    } catch {
-      // Already errored or closed
-    }
-  }
-
-  close(): void {
-    if (this.state === "closed") return;
-
-    this.state = "closing";
-    if (this.controller) {
-      try {
-        this.controller.close();
-      } catch {
-        // Already closed
-      }
-    }
-    this.state = "closed";
-  }
-
-  get closed(): boolean {
-    return this.state === "closed";
-  }
-
-  get currentState(): SseState {
-    return this.state;
-  }
-}

package/src/test/fixtures/notifications.ts

@@ -1,92 +0,0 @@
-import { POSTHOG_NOTIFICATIONS } from "../../acp-extensions.js";
-import type { StoredNotification } from "../../types.js";
-
-export function createNotification(
-  method: string,
-  params: Record<string, unknown>,
-): StoredNotification {
-  return {
-    type: "notification",
-    timestamp: new Date().toISOString(),
-    notification: {
-      jsonrpc: "2.0",
-      method,
-      params,
-    },
-  };
-}
-
-export function createUserMessage(content: string): StoredNotification {
-  return createNotification("session/update", {
-    update: {
-      sessionUpdate: "user_message",
-      content: { type: "text", text: content },
-    },
-  });
-}
-
-export function createAgentChunk(text: string): StoredNotification {
-  return createNotification("session/update", {
-    update: {
-      sessionUpdate: "agent_message_chunk",
-      content: { type: "text", text },
-    },
-  });
-}
-
-export function createToolCall(
-  toolCallId: string,
-  toolName: string,
-  toolInput: unknown,
-): StoredNotification {
-  return createNotification("session/update", {
-    update: {
-      sessionUpdate: "tool_call",
-      _meta: {
-        claudeCode: { toolCallId, toolName, toolInput },
-      },
-    },
-  });
-}
-
-export function createToolResult(
-  toolCallId: string,
-  toolResponse: unknown,
-): StoredNotification {
-  return createNotification("session/update", {
-    update: {
-      sessionUpdate: "tool_result",
-      _meta: {
-        claudeCode: { toolCallId, toolResponse },
-      },
-    },
-  });
-}
-
-export function createTreeSnapshotNotification(
-  treeHash: string,
-  archiveUrl?: string,
-  options: { interrupted?: boolean; device?: { type: "local" | "cloud" } } = {},
-): StoredNotification {
-  return createNotification(POSTHOG_NOTIFICATIONS.TREE_SNAPSHOT, {
-    treeHash,
-    baseCommit: "abc123",
-    archiveUrl,
-    changes: [{ path: "file.ts", status: "A" }],
-    timestamp: new Date().toISOString(),
-    ...options,
-  });
-}
-
-export function createStatusNotification(
-  status: "connected" | "disconnected" | "error",
-  message?: string,
-): StoredNotification {
-  return createNotification("session/update", {
-    update: {
-      sessionUpdate: "status",
-      status,
-      message,
-    },
-  });
-}

package/src/test/setup.ts

@@ -1,114 +0,0 @@
-import { type SetupServerApi, setupServer } from "msw/node";
-import { AgentServer } from "../server/agent-server.js";
-import { SseController } from "./controllers/sse-controller.js";
-import { createTestRepo, type TestRepo } from "./fixtures/api.js";
-import {
-  type AgentServerConfig,
-  createAgentServerConfig,
-} from "./fixtures/config.js";
-import { createPostHogHandlers } from "./mocks/msw-handlers.js";
-
-export interface TestContext {
-  repo: TestRepo;
-  sseController: SseController;
-  appendLogCalls: unknown[][];
-  server: SetupServerApi;
-  agentServer: AgentServer;
-  config: AgentServerConfig;
-  createAgentServer: (overrides?: Partial<AgentServerConfig>) => AgentServer;
-  resetSseController: () => SseController;
-  cleanup: () => Promise<void>;
-}
-
-export interface CreateTestContextOptions {
-  configOverrides?: Partial<AgentServerConfig>;
-  autoStart?: boolean;
-}
-
-export async function createTestContext(
-  options: CreateTestContextOptions = {},
-): Promise<TestContext> {
-  const repo = await createTestRepo("agent-server");
-  let sseController = new SseController();
-  const appendLogCalls: unknown[][] = [];
-
-  const server = setupServer(
-    ...createPostHogHandlers({
-      baseUrl: "http://localhost:8000",
-      onAppendLog: (entries) => appendLogCalls.push(entries),
-    }),
-  );
-
-  server.listen({ onUnhandledRequest: "bypass" });
-
-  const config = createAgentServerConfig(repo, options.configOverrides);
-
-  const agentServer = new AgentServer(config);
-
-  const createAgentServer = (overrides: Partial<AgentServerConfig> = {}) => {
-    return new AgentServer({
-      ...config,
-      ...overrides,
-    });
-  };
-
-  const resetSseController = () => {
-    sseController.close();
-    sseController = new SseController();
-    return sseController;
-  };
-
-  const cleanup = async () => {
-    sseController.close();
-    server.close();
-    await repo.cleanup();
-  };
-
-  return {
-    repo,
-    sseController,
-    appendLogCalls,
-    server,
-    agentServer,
-    config,
-    createAgentServer,
-    resetSseController,
-    cleanup,
-  };
-}
-
-export {
-  expectNoNotification,
-  expectNotification,
-  findNotification,
-  hasNotification,
-} from "./assertions.js";
-export {
-  createMockApiClient,
-  createTaskRun,
-  createTestRepo,
-  type TestRepo,
-} from "./fixtures/api.js";
-export { createAgentServerConfig } from "./fixtures/config.js";
-export {
-  createAgentChunk,
-  createNotification,
-  createStatusNotification,
-  createToolCall,
-  createToolResult,
-  createTreeSnapshotNotification,
-  createUserMessage,
-} from "./fixtures/notifications.js";
-export {
-  createErrorResult,
-  createInitMessage,
-  createMockQuery,
-  createSuccessResult,
-  type MockQuery,
-} from "./mocks/claude-sdk.js";
-export { createPostHogHandlers, SseController } from "./mocks/msw-handlers.js";
-export {
-  waitForArrayLength,
-  waitForCallCount,
-  waitForCondition,
-} from "./wait.js";

package/src/test/wait.ts

@@ -1,41 +0,0 @@
-export interface WaitOptions {
-  timeout?: number;
-  interval?: number;
-}
-
-export async function waitForCondition(
-  condition: () => boolean | Promise<boolean>,
-  options: WaitOptions = {},
-): Promise<void> {
-  const { timeout = 1000, interval = 20 } = options;
-  const start = Date.now();
-
-  while (true) {
-    const result = await condition();
-    if (result) {
-      return;
-    }
-
-    if (Date.now() - start > timeout) {
-      throw new Error(`Condition not met within ${timeout}ms`);
-    }
-
-    await new Promise((r) => setTimeout(r, interval));
-  }
-}
-
-export async function waitForArrayLength<T>(
-  getArray: () => T[],
-  minLength: number,
-  options: WaitOptions = {},
-): Promise<void> {
-  await waitForCondition(() => getArray().length >= minLength, options);
-}
-
-export async function waitForCallCount(
-  mockFn: { mock: { calls: unknown[][] } },
-  minCalls: number,
-  options: WaitOptions = {},
-): Promise<void> {
-  await waitForCondition(() => mockFn.mock.calls.length >= minCalls, options);
-}