@pocketcoder/shared 0.0.2

package/src/types/__tests__/messages.test.ts

@@ -0,0 +1,382 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  isFsListRequest,
+  isFsReadRequest,
+  isGitStatusRequest,
+  isAgentMessageRequest,
+  isErrorResponse,
+  isMessage,
+  isRequestMessage,
+  isAgentInitEvent,
+  isAgentDoneEvent,
+  isAgentEvent,
+} from "../messages.js";
+import type { AgentEvent } from "../messages.js";
+
+describe("message type guards", () => {
+  describe("isFsListRequest", () => {
+    it("should validate fs_list message", () => {
+      const msg = {
+        type: "fs_list",
+        requestId: "req_123",
+        sessionId: "proj_abc",
+        payload: { path: "src/components", depth: 1 },
+      };
+      expect(isFsListRequest(msg)).toBe(true);
+    });
+
+    it("should reject message with wrong type", () => {
+      const msg = {
+        type: "fs_read",
+        requestId: "req_123",
+        sessionId: "proj_abc",
+        payload: { path: "src" },
+      };
+      expect(isFsListRequest(msg)).toBe(false);
+    });
+
+    it("should reject message missing requestId", () => {
+      const msg = {
+        type: "fs_list",
+        sessionId: "proj_abc",
+        payload: { path: "" },
+      };
+      expect(isFsListRequest(msg)).toBe(false);
+    });
+
+    it("should reject message missing sessionId", () => {
+      const msg = {
+        type: "fs_list",
+        requestId: "req_123",
+        payload: { path: "" },
+      };
+      expect(isFsListRequest(msg)).toBe(false);
+    });
+
+    it("should reject message missing payload.path", () => {
+      const msg = {
+        type: "fs_list",
+        requestId: "req_123",
+        sessionId: "proj_abc",
+        payload: {},
+      };
+      expect(isFsListRequest(msg)).toBe(false);
+    });
+
+    it("should reject non-object values", () => {
+      expect(isFsListRequest(null)).toBe(false);
+      expect(isFsListRequest(undefined)).toBe(false);
+      expect(isFsListRequest("fs_list")).toBe(false);
+      expect(isFsListRequest(42)).toBe(false);
+    });
+  });
+
+  describe("isFsReadRequest", () => {
+    it("should validate fs_read message", () => {
+      const msg = {
+        type: "fs_read",
+        requestId: "req_456",
+        sessionId: "proj_abc",
+        payload: { path: "src/index.ts" },
+      };
+      expect(isFsReadRequest(msg)).toBe(true);
+    });
+
+    it("should reject message with wrong type", () => {
+      const msg = {
+        type: "fs_list",
+        requestId: "req_456",
+        sessionId: "proj_abc",
+        payload: { path: "src/index.ts" },
+      };
+      expect(isFsReadRequest(msg)).toBe(false);
+    });
+
+    it("should reject message missing path", () => {
+      const msg = {
+        type: "fs_read",
+        requestId: "req_456",
+        sessionId: "proj_abc",
+        payload: {},
+      };
+      expect(isFsReadRequest(msg)).toBe(false);
+    });
+  });
+
+  describe("isGitStatusRequest", () => {
+    it("should validate git_status message", () => {
+      const msg = {
+        type: "git_status",
+        requestId: "req_100",
+        sessionId: "proj_abc",
+        payload: {},
+      };
+      expect(isGitStatusRequest(msg)).toBe(true);
+    });
+
+    it("should reject message with wrong type", () => {
+      const msg = {
+        type: "git_branches",
+        requestId: "req_100",
+        sessionId: "proj_abc",
+        payload: {},
+      };
+      expect(isGitStatusRequest(msg)).toBe(false);
+    });
+  });
+
+  describe("isAgentMessageRequest", () => {
+    it("should validate agent_message", () => {
+      const msg = {
+        type: "agent_message",
+        requestId: "req_202",
+        sessionId: "proj_abc",
+        payload: {
+          agentSessionId: "10ca3c7c-ece4-4c98-a251-365dad2a34ad",
+          content: "Now add tests for the component",
+        },
+      };
+      expect(isAgentMessageRequest(msg)).toBe(true);
+    });
+
+    it("should reject message missing agentSessionId", () => {
+      const msg = {
+        type: "agent_message",
+        requestId: "req_202",
+        sessionId: "proj_abc",
+        payload: { content: "hello" },
+      };
+      expect(isAgentMessageRequest(msg)).toBe(false);
+    });
+
+    it("should reject message missing content", () => {
+      const msg = {
+        type: "agent_message",
+        requestId: "req_202",
+        sessionId: "proj_abc",
+        payload: { agentSessionId: "abc" },
+      };
+      expect(isAgentMessageRequest(msg)).toBe(false);
+    });
+  });
+
+  describe("isErrorResponse", () => {
+    it("should validate error response", () => {
+      const msg = {
+        type: "error",
+        requestId: "req_xxx",
+        error: {
+          code: "FILE_TOO_LARGE",
+          message: "File exceeds maximum size limit",
+          details: { path: "large-file.bin", size: 15728640, limit: 10485760 },
+        },
+      };
+      expect(isErrorResponse(msg)).toBe(true);
+    });
+
+    it("should validate error response without details", () => {
+      const msg = {
+        type: "error",
+        requestId: "req_xxx",
+        error: {
+          code: "UNKNOWN_ERROR",
+          message: "Something went wrong",
+        },
+      };
+      expect(isErrorResponse(msg)).toBe(true);
+    });
+
+    it("should reject non-error type", () => {
+      const msg = {
+        type: "fs_list",
+        requestId: "req_xxx",
+        error: { code: "UNKNOWN", message: "test" },
+      };
+      expect(isErrorResponse(msg)).toBe(false);
+    });
+
+    it("should reject missing error.code", () => {
+      const msg = {
+        type: "error",
+        requestId: "req_xxx",
+        error: { message: "test" },
+      };
+      expect(isErrorResponse(msg)).toBe(false);
+    });
+
+    it("should reject missing requestId", () => {
+      const msg = {
+        type: "error",
+        error: { code: "UNKNOWN_ERROR", message: "test" },
+      };
+      expect(isErrorResponse(msg)).toBe(false);
+    });
+  });
+
+  describe("isMessage", () => {
+    it("should accept any object with a type field", () => {
+      expect(isMessage({ type: "fs_list" })).toBe(true);
+      expect(isMessage({ type: "error" })).toBe(true);
+      expect(isMessage({ type: "daemon_register" })).toBe(true);
+    });
+
+    it("should reject objects without type", () => {
+      expect(isMessage({})).toBe(false);
+      expect(isMessage({ requestId: "abc" })).toBe(false);
+    });
+
+    it("should reject non-objects", () => {
+      expect(isMessage(null)).toBe(false);
+      expect(isMessage(undefined)).toBe(false);
+      expect(isMessage("string")).toBe(false);
+    });
+  });
+
+  describe("isRequestMessage", () => {
+    it("should accept messages with type and requestId", () => {
+      expect(isRequestMessage({ type: "fs_list", requestId: "req_1" })).toBe(true);
+    });
+
+    it("should reject messages without requestId", () => {
+      expect(isRequestMessage({ type: "fs_changed" })).toBe(false);
+    });
+  });
+
+  describe("isAgentInitEvent", () => {
+    it("should validate init AgentEvent", () => {
+      const event = {
+        type: "init",
+        sessionId: "session-abc-123",
+        tools: ["Read", "Write", "Edit", "Bash"],
+        model: "claude-sonnet-4-5-20250929",
+      };
+      expect(isAgentInitEvent(event)).toBe(true);
+    });
+
+    it("should reject init event missing sessionId", () => {
+      const event = {
+        type: "init",
+        tools: ["Read"],
+        model: "claude-sonnet-4-5-20250929",
+      };
+      expect(isAgentInitEvent(event)).toBe(false);
+    });
+
+    it("should reject init event missing tools", () => {
+      const event = {
+        type: "init",
+        sessionId: "session-abc",
+        model: "claude-sonnet-4-5-20250929",
+      };
+      expect(isAgentInitEvent(event)).toBe(false);
+    });
+
+    it("should reject init event missing model", () => {
+      const event = {
+        type: "init",
+        sessionId: "session-abc",
+        tools: ["Read"],
+      };
+      expect(isAgentInitEvent(event)).toBe(false);
+    });
+
+    it("should reject non-init type", () => {
+      const event = { type: "text", content: "hello" };
+      expect(isAgentInitEvent(event)).toBe(false);
+    });
+
+    it("should reject non-object values", () => {
+      expect(isAgentInitEvent(null)).toBe(false);
+      expect(isAgentInitEvent(undefined)).toBe(false);
+      expect(isAgentInitEvent("init")).toBe(false);
+    });
+  });
+
+  describe("isAgentDoneEvent", () => {
+    it("should validate done AgentEvent with usage", () => {
+      const event = {
+        type: "done",
+        usage: { input_tokens: 100, output_tokens: 50 },
+      };
+      expect(isAgentDoneEvent(event)).toBe(true);
+    });
+
+    it("should validate done AgentEvent with error", () => {
+      const event = {
+        type: "done",
+        error: "Something went wrong",
+      };
+      expect(isAgentDoneEvent(event)).toBe(true);
+    });
+
+    it("should validate done AgentEvent with cancelled", () => {
+      const event = {
+        type: "done",
+        cancelled: true,
+      };
+      expect(isAgentDoneEvent(event)).toBe(true);
+    });
+
+    it("should validate minimal done AgentEvent (no optional fields)", () => {
+      const event = { type: "done" };
+      expect(isAgentDoneEvent(event)).toBe(true);
+    });
+
+    it("should reject done event with invalid usage", () => {
+      const event = {
+        type: "done",
+        usage: { input_tokens: "not-a-number" },
+      };
+      expect(isAgentDoneEvent(event)).toBe(false);
+    });
+
+    it("should reject done event with non-string error", () => {
+      const event = {
+        type: "done",
+        error: 42,
+      };
+      expect(isAgentDoneEvent(event)).toBe(false);
+    });
+
+    it("should reject non-done type", () => {
+      const event = { type: "text", content: "hello" };
+      expect(isAgentDoneEvent(event)).toBe(false);
+    });
+  });
+
+  describe("isAgentEvent", () => {
+    it("should include init in AgentEvent union", () => {
+      const event: AgentEvent = {
+        type: "init",
+        sessionId: "s1",
+        tools: ["Read"],
+        model: "claude-sonnet-4-5-20250929",
+      };
+      expect(isAgentEvent(event)).toBe(true);
+    });
+
+    it("should validate all AgentEvent types", () => {
+      expect(isAgentEvent({ type: "init", sessionId: "s", tools: [], model: "m" })).toBe(true);
+      expect(isAgentEvent({ type: "thinking", content: "..." })).toBe(true);
+      expect(isAgentEvent({ type: "text", content: "hello" })).toBe(true);
+      expect(isAgentEvent({ type: "tool_use", tool: "Read", input: {} })).toBe(true);
+      expect(isAgentEvent({ type: "tool_complete", toolUseId: "toolu_123" })).toBe(true);
+      expect(isAgentEvent({ type: "file_edit", path: "foo.ts" })).toBe(true);
+      expect(isAgentEvent({ type: "file_create", path: "bar.ts" })).toBe(true);
+      expect(isAgentEvent({ type: "file_delete", path: "baz.ts" })).toBe(true);
+      expect(isAgentEvent({ type: "prompt", question: "?" })).toBe(true);
+      expect(isAgentEvent({ type: "done" })).toBe(true);
+    });
+
+    it("should reject unknown event types", () => {
+      expect(isAgentEvent({ type: "unknown_type" })).toBe(false);
+    });
+
+    it("should reject non-object values", () => {
+      expect(isAgentEvent(null)).toBe(false);
+      expect(isAgentEvent("text")).toBe(false);
+      expect(isAgentEvent(42)).toBe(false);
+    });
+  });
+});

package/src/types/__tests__/relay-types.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+
+import type {
+  ClientAuthMessage,
+  ClientAuthResponse,
+  DaemonConnection,
+  DaemonStatusBatchMessage,
+  DaemonStatusMessage,
+} from "../relay.js";
+
+describe("relay types", () => {
+  it("should export DaemonConnection interface", () => {
+    const conn: DaemonConnection = {
+      ws: {}, // unknown in shared; relay casts to WebSocket
+      userId: "user_123",
+      machineKey: "machine_abc",
+      projects: new Set(["proj_1", "proj_2"]),
+      connectedAt: new Date("2026-02-14T20:00:00Z"),
+      lastPongAt: new Date("2026-02-14T20:01:00Z"),
+    };
+    expect(conn.userId).toBe("user_123");
+    expect(conn.machineKey).toBe("machine_abc");
+    expect(conn.projects.size).toBe(2);
+    expect(conn.projects.has("proj_1")).toBe(true);
+    expect(conn.connectedAt).toBeInstanceOf(Date);
+    expect(conn.lastPongAt).toBeInstanceOf(Date);
+  });
+
+  it("should export relay message types", () => {
+    // client_auth
+    const authMsg: ClientAuthMessage = {
+      type: "client_auth",
+      payload: { token: "eyJ..." },
+    };
+    expect(authMsg.type).toBe("client_auth");
+    expect(authMsg.payload.token).toBe("eyJ...");
+
+    // client_auth_response (success)
+    const authResp: ClientAuthResponse = {
+      type: "client_auth_response",
+      payload: { userId: "user_123", authenticated: true },
+    };
+    expect(authResp.payload.authenticated).toBe(true);
+    expect(authResp.payload.userId).toBe("user_123");
+
+    // client_auth_response (failure)
+    const authFail: ClientAuthResponse = {
+      type: "client_auth_response",
+      payload: { authenticated: false },
+      error: { code: "auth_failed", message: "Invalid token" },
+    };
+    expect(authFail.payload.authenticated).toBe(false);
+    expect(authFail.error?.code).toBe("auth_failed");
+
+    // daemon_status (single machine)
+    const status: DaemonStatusMessage = {
+      type: "daemon_status",
+      payload: {
+        machineKey: "machine_abc",
+        connected: false,
+        lastSeen: "2026-02-14T20:00:00Z",
+      },
+    };
+    expect(status.type).toBe("daemon_status");
+    expect(status.payload.connected).toBe(false);
+    expect(status.payload.lastSeen).toBe("2026-02-14T20:00:00Z");
+
+    // daemon_status (batch, after client_auth)
+    const batch: DaemonStatusBatchMessage = {
+      type: "daemon_status",
+      payload: {
+        machines: [
+          { machineKey: "m1", connected: true },
+          { machineKey: "m2", connected: false, lastSeen: "2026-02-14T19:00:00Z" },
+        ],
+      },
+    };
+    expect(batch.payload.machines).toHaveLength(2);
+    expect(batch.payload.machines[0].connected).toBe(true);
+    expect(batch.payload.machines[1].lastSeen).toBe("2026-02-14T19:00:00Z");
+  });
+});

package/src/types/auth-messages.ts

@@ -0,0 +1,66 @@
+/**
+ * Auth message types for daemon ↔ relay communication.
+ * The daemon exchanges OAuth codes and refreshes tokens via the Relay
+ * (never directly with Supabase).
+ *
+ * See PRD.md: "auth_exchange Message" and "token_refresh Message" sections.
+ */
+
+import type { MessageError } from "./messages.js";
+
+// ---------------------------------------------------------------------------
+// Auth user
+// ---------------------------------------------------------------------------
+
+export interface AuthUser {
+  id: string;
+  email: string;
+  github_username: string;
+}
+
+// ---------------------------------------------------------------------------
+// auth_exchange (Daemon → Relay → Daemon)
+// ---------------------------------------------------------------------------
+
+export interface AuthExchangeRequest {
+  type: "auth_exchange";
+  requestId: string;
+  payload: {
+    code: string;
+  };
+}
+
+export interface AuthExchangeResponse {
+  type: "auth_exchange_response";
+  requestId: string;
+  payload?: {
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+    user: AuthUser;
+  };
+  error?: MessageError;
+}
+
+// ---------------------------------------------------------------------------
+// token_refresh (Daemon → Relay → Daemon)
+// ---------------------------------------------------------------------------
+
+export interface TokenRefreshRequest {
+  type: "token_refresh";
+  requestId: string;
+  payload: {
+    refresh_token: string;
+  };
+}
+
+export interface TokenRefreshResponse {
+  type: "token_refresh_response";
+  requestId: string;
+  payload?: {
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+  };
+  error?: MessageError;
+}