@hienlh/ppm 0.1.0

package/tests/integration/claude-agent-sdk-integration.test.ts

@@ -0,0 +1,228 @@
+import { describe, it, expect, beforeAll, afterAll } from "bun:test";
+import { query, listSessions, getSessionMessages } from "@anthropic-ai/claude-agent-sdk";
+import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+import { ClaudeAgentSdkProvider } from "../../src/providers/claude-agent-sdk.ts";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+// Remove CLAUDECODE env to avoid nested session error
+delete process.env.CLAUDECODE;
+
+// Use a temp directory so SDK sessions don't pollute the real project
+let tempDir: string;
+let originalCwd: string;
+
+beforeAll(() => {
+  originalCwd = process.cwd();
+  tempDir = mkdtempSync(join(tmpdir(), "ppm-sdk-test-"));
+  process.chdir(tempDir);
+});
+
+afterAll(() => {
+  process.chdir(originalCwd);
+  try {
+    rmSync(tempDir, { recursive: true, force: true });
+  } catch {
+    // best effort cleanup
+  }
+});
+
+/** Collect all messages from a query */
+async function collectMessages(q: AsyncIterable<SDKMessage>): Promise<SDKMessage[]> {
+  const msgs: SDKMessage[] = [];
+  for await (const msg of q) {
+    msgs.push(msg);
+  }
+  return msgs;
+}
+
+describe("Claude Agent SDK — raw SDK", () => {
+  it("query() returns init + assistant + result messages", async () => {
+    const sessionId = crypto.randomUUID();
+    const msgs = await collectMessages(
+      query({
+        prompt: "Reply with exactly: PONG",
+        options: {
+          sessionId,
+          maxTurns: 1,
+          permissionMode: "bypassPermissions",
+          allowDangerouslySkipPermissions: true,
+        } as any,
+      }),
+    );
+
+    const types = msgs.map((m) => m.type);
+    expect(types).toContain("system"); // init
+    expect(types).toContain("assistant");
+    expect(types).toContain("result");
+
+    // Verify init has session_id
+    const init = msgs.find((m) => m.type === "system" && (m as any).subtype === "init");
+    expect(init).toBeTruthy();
+    expect(init!.session_id).toBeTruthy();
+
+    // Verify assistant message has text content
+    const assistant = msgs.find((m) => m.type === "assistant");
+    const content = (assistant as any)?.message?.content;
+    expect(Array.isArray(content)).toBe(true);
+    const textBlock = content.find((b: any) => b.type === "text");
+    expect(textBlock).toBeTruthy();
+    expect(textBlock.text.toUpperCase()).toContain("PONG");
+
+    // Verify result
+    const result = msgs.find((m) => m.type === "result") as any;
+    expect(result.subtype).toBe("success");
+    expect(typeof result.result).toBe("string");
+    expect(result.result.toUpperCase()).toContain("PONG");
+  }, 30000);
+
+  it("resume continues conversation context", async () => {
+    const sessionId = crypto.randomUUID();
+
+    // Turn 1: tell it a secret
+    const turn1 = await collectMessages(
+      query({
+        prompt: "Remember this secret code: ALPHA-7742. Reply with just 'Noted.'",
+        options: {
+          sessionId,
+          maxTurns: 1,
+          permissionMode: "bypassPermissions",
+          allowDangerouslySkipPermissions: true,
+        } as any,
+      }),
+    );
+    const result1 = turn1.find((m) => m.type === "result") as any;
+    expect(result1).toBeTruthy();
+
+    // Turn 2: ask it back — uses resume
+    const turn2 = await collectMessages(
+      query({
+        prompt: "What was the secret code I told you? Reply with just the code.",
+        options: {
+          resume: sessionId,
+          maxTurns: 1,
+          permissionMode: "bypassPermissions",
+          allowDangerouslySkipPermissions: true,
+        } as any,
+      }),
+    );
+    const result2 = turn2.find((m) => m.type === "result") as any;
+    expect(result2).toBeTruthy();
+    expect(result2.result).toContain("ALPHA-7742");
+  }, 60000);
+
+  it("listSessions() returns session metadata", async () => {
+    const sessions = await listSessions({ limit: 5 });
+
+    expect(Array.isArray(sessions)).toBe(true);
+    if (sessions.length > 0) {
+      const s = sessions[0]!;
+      expect(s.sessionId).toBeTruthy();
+      expect(typeof s.summary).toBe("string");
+      expect(typeof s.lastModified).toBe("number");
+    }
+  }, 15000);
+
+  it("getSessionMessages() returns transcript", async () => {
+    // Create a session first
+    const sessionId = crypto.randomUUID();
+    await collectMessages(
+      query({
+        prompt: "Say hello",
+        options: {
+          sessionId,
+          maxTurns: 1,
+          permissionMode: "bypassPermissions",
+          allowDangerouslySkipPermissions: true,
+        } as any,
+      }),
+    );
+
+    const messages = await getSessionMessages(sessionId);
+    expect(Array.isArray(messages)).toBe(true);
+    expect(messages.length).toBeGreaterThanOrEqual(1);
+
+    // Should have at least assistant message
+    const hasAssistant = messages.some((m) => m.type === "assistant");
+    expect(hasAssistant).toBe(true);
+  }, 30000);
+});
+
+describe("ClaudeAgentSdkProvider — PPM integration", () => {
+  const provider = new ClaudeAgentSdkProvider();
+
+  it("createSession returns valid session with UUID", async () => {
+    const session = await provider.createSession({
+      projectName: "test-project",
+      title: "Integration Test",
+    });
+
+    expect(session.id).toBeTruthy();
+    expect(session.id).not.toContain("pending");
+    expect(session.providerId).toBe("claude-sdk");
+    expect(session.title).toBe("Integration Test");
+    expect(session.projectName).toBe("test-project");
+  });
+
+  it("sendMessage streams text events and done", async () => {
+    const session = await provider.createSession({ title: "Stream Test" });
+    const events: any[] = [];
+
+    for await (const event of provider.sendMessage(session.id, "Reply with exactly: OK")) {
+      events.push(event);
+    }
+
+    const textEvents = events.filter((e) => e.type === "text");
+    const doneEvent = events.find((e) => e.type === "done");
+
+    expect(textEvents.length).toBeGreaterThan(0);
+    const fullText = textEvents.map((e) => e.content).join("");
+    expect(fullText.toUpperCase()).toContain("OK");
+
+    expect(doneEvent).toBeTruthy();
+    expect(doneEvent.sessionId).toBe(session.id);
+  }, 30000);
+
+  it("multi-turn: resume maintains context", async () => {
+    const session = await provider.createSession({ title: "Multi-turn" });
+
+    // Turn 1
+    for await (const _ of provider.sendMessage(session.id, "Remember: my favorite color is purple. Reply 'Got it.'")) {
+      // consume
+    }
+
+    // Turn 2 — should resume same session
+    const events: any[] = [];
+    for await (const event of provider.sendMessage(session.id, "What is my favorite color? Reply with just the color.")) {
+      events.push(event);
+    }
+
+    const fullText = events
+      .filter((e) => e.type === "text")
+      .map((e) => e.content)
+      .join("");
+    expect(fullText.toLowerCase()).toContain("purple");
+  }, 60000);
+
+  it("returns error for non-existent session", async () => {
+    const events: any[] = [];
+    for await (const event of provider.sendMessage("nonexistent-id", "hello")) {
+      events.push(event);
+    }
+
+    expect(events[0].type).toBe("error");
+    expect(events[0].message).toContain("Session not found");
+  });
+
+  it("deleteSession removes session", async () => {
+    const session = await provider.createSession({ title: "Delete me" });
+    await provider.deleteSession(session.id);
+
+    const events: any[] = [];
+    for await (const event of provider.sendMessage(session.id, "hello")) {
+      events.push(event);
+    }
+    expect(events[0].type).toBe("error");
+  });
+});

package/tests/integration/ws/chat-websocket.test.ts

@@ -0,0 +1,312 @@
+import { describe, it, expect, beforeAll, afterAll } from "bun:test";
+import "../../test-setup.ts"; // disable auth
+import { chatService } from "../../../src/services/chat.service.ts";
+
+const PORT = 19876;
+let server: ReturnType<typeof Bun.serve>;
+
+beforeAll(async () => {
+  const { app } = await import("../../../src/server/index.ts");
+  const { chatWebSocket } = await import("../../../src/server/ws/chat.ts");
+
+  server = Bun.serve({
+    port: PORT,
+    fetch(req, srv) {
+      const url = new URL(req.url);
+
+      // WebSocket upgrade for chat
+      if (url.pathname.startsWith("/ws/chat/")) {
+        const sessionId = url.pathname.split("/ws/chat/")[1] ?? "";
+        const upgraded = srv.upgrade(req, {
+          data: { type: "chat", sessionId },
+        });
+        if (upgraded) return undefined;
+        return new Response("WebSocket upgrade failed", { status: 400 });
+      }
+
+      return app.fetch(req, srv as any);
+    },
+    websocket: {
+      open: chatWebSocket.open as any,
+      message: chatWebSocket.message as any,
+      close: chatWebSocket.close as any,
+    },
+  });
+});
+
+afterAll(() => {
+  server?.stop(true);
+});
+
+function connectWs(sessionId: string): Promise<{
+  ws: WebSocket;
+  messages: any[];
+  waitForType: (type: string, timeout?: number) => Promise<any>;
+  close: () => void;
+}> {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(`ws://localhost:${PORT}/ws/chat/${sessionId}`, {
+    } as any);
+    const messages: any[] = [];
+
+    ws.onmessage = (event) => {
+      try {
+        messages.push(JSON.parse(event.data as string));
+      } catch {
+        // ignore
+      }
+    };
+
+    ws.onopen = () => {
+      const waitForType = (type: string, timeout = 10000): Promise<any> => {
+        return new Promise((res, rej) => {
+          const existing = messages.find((m) => m.type === type);
+          if (existing) return res(existing);
+
+          const timer = setTimeout(() => rej(new Error(`Timeout waiting for ${type}`)), timeout);
+          const handler = (event: MessageEvent) => {
+            try {
+              const msg = JSON.parse(event.data as string);
+              if (msg.type === type) {
+                clearTimeout(timer);
+                ws.removeEventListener("message", handler);
+                res(msg);
+              }
+            } catch {
+              // ignore
+            }
+          };
+          ws.addEventListener("message", handler);
+        });
+      };
+
+      resolve({ ws, messages, waitForType, close: () => ws.close() });
+    };
+
+    ws.onerror = () => reject(new Error("WS connection failed"));
+  });
+}
+
+describe("Chat WebSocket", () => {
+  it("sends connected event on open", async () => {
+    const session = await chatService.createSession("mock", {});
+    const { waitForType, close } = await connectWs(session.id);
+
+    const connected = await waitForType("connected");
+    expect(connected.sessionId).toBe(session.id);
+
+    close();
+  });
+
+  it("streams text events for a message", async () => {
+    const session = await chatService.createSession("mock", {});
+    const { ws, messages, waitForType, close } = await connectWs(session.id);
+
+    await waitForType("connected");
+    ws.send(JSON.stringify({ type: "message", content: "hello" }));
+
+    const done = await waitForType("done");
+    expect(done.sessionId).toBe(session.id);
+
+    const textEvents = messages.filter((m) => m.type === "text");
+    expect(textEvents.length).toBeGreaterThan(0);
+
+    const fullText = textEvents.map((e) => e.content).join("");
+    expect(fullText.length).toBeGreaterThan(0);
+
+    close();
+  });
+
+  it("streams tool_use events for file-related messages", async () => {
+    const session = await chatService.createSession("mock", {});
+    const { ws, messages, waitForType, close } = await connectWs(session.id);
+
+    await waitForType("connected");
+    ws.send(JSON.stringify({ type: "message", content: "read the file" }));
+
+    await waitForType("done");
+
+    const toolUse = messages.find((m) => m.type === "tool_use");
+    const toolResult = messages.find((m) => m.type === "tool_result");
+    expect(toolUse).toBeTruthy();
+    expect(toolUse.tool).toBe("Read");
+    expect(toolResult).toBeTruthy();
+
+    close();
+  });
+
+  it("streams approval_request for delete messages", async () => {
+    const session = await chatService.createSession("mock", {});
+    const { ws, messages, waitForType, close } = await connectWs(session.id);
+
+    await waitForType("connected");
+    ws.send(JSON.stringify({ type: "message", content: "delete temp" }));
+
+    await waitForType("done");
+
+    const approval = messages.find((m) => m.type === "approval_request");
+    expect(approval).toBeTruthy();
+    expect(approval.tool).toBe("Bash");
+
+    close();
+  });
+
+  it("handles invalid JSON gracefully", async () => {
+    const session = await chatService.createSession("mock", {});
+    const { ws, waitForType, close } = await connectWs(session.id);
+
+    await waitForType("connected");
+    ws.send("not json at all");
+
+    const errMsg = await waitForType("error");
+    expect(errMsg.message).toContain("Invalid JSON");
+
+    close();
+  });
+
+  it("supports multi-turn conversation in same session", async () => {
+    const session = await chatService.createSession("mock", {});
+    const { ws, messages, waitForType, close } = await connectWs(session.id);
+
+    await waitForType("connected");
+
+    // Turn 1
+    ws.send(JSON.stringify({ type: "message", content: "hello" }));
+    await waitForType("done");
+    const turn1Texts = messages.filter((m) => m.type === "text").length;
+
+    // Turn 2
+    const doneCountBefore = messages.filter((m) => m.type === "done").length;
+    ws.send(JSON.stringify({ type: "message", content: "follow up" }));
+
+    // Wait until we see a new "done" event
+    await new Promise<void>((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error("Timeout waiting for turn 2 done")), 10000);
+      const handler = (event: MessageEvent) => {
+        try {
+          const msg = JSON.parse(event.data as string);
+          if (msg.type === "done" && messages.filter((m: any) => m.type === "done").length > doneCountBefore) {
+            clearTimeout(timer);
+            ws.removeEventListener("message", handler);
+            resolve();
+          }
+        } catch { /* ignore */ }
+      };
+      ws.addEventListener("message", handler);
+    });
+
+    const turn2Texts = messages.filter((m) => m.type === "text").length;
+    expect(turn2Texts).toBeGreaterThan(turn1Texts);
+
+    // Verify history has both turns
+    const history = await chatService.getMessages("mock", session.id);
+    const userMsgs = history.filter((m: any) => m.role === "user");
+    expect(userMsgs).toHaveLength(2);
+
+    close();
+  });
+
+  it("cancels streaming mid-response", async () => {
+    const session = await chatService.createSession("mock", {});
+    const { ws, messages, waitForType, close } = await connectWs(session.id);
+
+    await waitForType("connected");
+
+    // Send a message that will trigger slow streaming
+    ws.send(JSON.stringify({ type: "message", content: "hello world" }));
+
+    // Wait for at least one text event to arrive (streaming started)
+    await waitForType("text");
+
+    // Count text events so far
+    const textsBefore = messages.filter((m) => m.type === "text").length;
+    expect(textsBefore).toBeGreaterThan(0);
+
+    // Send cancel
+    ws.send(JSON.stringify({ type: "cancel" }));
+
+    // Wait a bit for cancel to take effect
+    await new Promise((r) => setTimeout(r, 500));
+
+    // The stream should have stopped — no "done" event with full text
+    // Text events should be fewer than a full response (~10 words = ~10 text events)
+    const textsAfter = messages.filter((m) => m.type === "text").length;
+    // Cancel should have stopped streaming before all words were sent
+    // (Mock sends ~7 words at 50ms each = 350ms, we cancel after first text ~350ms in)
+    // Just verify we got some but the stream was interrupted (no new done event)
+    expect(textsAfter).toBeGreaterThanOrEqual(textsBefore);
+
+    close();
+  });
+
+  it("cancel does not affect subsequent messages", async () => {
+    const session = await chatService.createSession("mock", {});
+    const { ws, messages, waitForType, close } = await connectWs(session.id);
+
+    await waitForType("connected");
+
+    // Send message and cancel quickly
+    ws.send(JSON.stringify({ type: "message", content: "hello" }));
+    await waitForType("text");
+    ws.send(JSON.stringify({ type: "cancel" }));
+
+    // Wait for cancel to settle
+    await new Promise((r) => setTimeout(r, 600));
+
+    // Clear messages array for clean tracking of turn 2
+    const msgCountBefore = messages.length;
+
+    // Send another message — should work normally
+    ws.send(JSON.stringify({ type: "message", content: "second message" }));
+
+    // Wait for done from the second message
+    await new Promise<void>((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error("Timeout waiting for second done")), 10000);
+      const donesBefore = messages.filter((m) => m.type === "done").length;
+      const handler = (event: MessageEvent) => {
+        try {
+          const msg = JSON.parse(event.data as string);
+          if (msg.type === "done" && messages.filter((m: any) => m.type === "done").length > donesBefore) {
+            clearTimeout(timer);
+            ws.removeEventListener("message", handler);
+            resolve();
+          }
+        } catch { /* ignore */ }
+      };
+      ws.addEventListener("message", handler);
+    });
+
+    // Should have new text events from second message
+    const newMessages = messages.slice(msgCountBefore);
+    const newTexts = newMessages.filter((m) => m.type === "text");
+    expect(newTexts.length).toBeGreaterThan(0);
+
+    // Should have a done event from second message
+    const newDone = newMessages.find((m) => m.type === "done");
+    expect(newDone).toBeTruthy();
+
+    close();
+  });
+
+  it("cancel with no active stream is a no-op", async () => {
+    const session = await chatService.createSession("mock", {});
+    const { ws, messages, waitForType, close } = await connectWs(session.id);
+
+    await waitForType("connected");
+
+    // Send cancel before any message — should not crash
+    ws.send(JSON.stringify({ type: "cancel" }));
+    await new Promise((r) => setTimeout(r, 200));
+
+    // No error events should be emitted
+    const errors = messages.filter((m) => m.type === "error");
+    expect(errors).toHaveLength(0);
+
+    // Can still send a normal message after
+    ws.send(JSON.stringify({ type: "message", content: "hello after cancel" }));
+    const done = await waitForType("done", 10000);
+    expect(done.sessionId).toBe(session.id);
+
+    close();
+  });
+});

package/tests/test-setup.ts

@@ -0,0 +1,5 @@
+import { configService } from "../src/services/config.service.ts";
+
+// Disable auth for all chat tests
+const config = (configService as any).config;
+config.auth.enabled = false;