whale-code 6.5.10 → 6.6.0

package/dist/server/handlers/nodes-list-delete.test.js

@@ -1,171 +0,0 @@
-// nodes-list-delete.test.ts — Tests for GET|POST /nodes (list) and DELETE /nodes/:id
-
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { HAS_TEST_DB, getTestClient, seedTracked, cleanup, TEST_STORE, RUN_PREFIX } from "./__test-utils__/test-db.js";
-// ---------------------------------------------------------------------------
-// Mock dependencies
-// ---------------------------------------------------------------------------
-
-vi.mock("./billing.js", () => ({
-  checkPlanLimits: vi.fn().mockResolvedValue({
-    allowed: true
-  }),
-  incrementUsage: vi.fn().mockResolvedValue(undefined)
-}));
-vi.mock("node:crypto", async importOriginal => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    createHash: vi.fn().mockReturnValue({
-      update: vi.fn().mockReturnValue({
-        digest: vi.fn().mockReturnValue("mocked-hash-abc123")
-      })
-    }),
-    randomBytes: vi.fn().mockReturnValue({
-      toString: vi.fn().mockReturnValue("mocked-api-key-hex-string-64chars-long-enough-for-testing-12345678")
-    }),
-    randomUUID: vi.fn().mockReturnValue("a0a0a0a0-0001-0002-0003-000000000001")
-  };
-});
-import { handleNodeRoutes, clearNodeAuthCache } from "./nodes.js";
-const sb = getTestClient();
-const USER_ID = "562fd6cb-ef83-4eca-b999-ffeac2293ee7";
-const NODE_ID = "a0a0a0a0-0001-0002-0003-000000000001";
-function makeNode(overrides = {}) {
-  return {
-    id: NODE_ID,
-    store_id: TEST_STORE,
-    name: `${RUN_PREFIX} Test Node`,
-    api_key_hash: "mocked-hash-abc123",
-    status: "online",
-    capabilities: ["chat", "voice"],
-    hardware: {
-      cpu: "arm64"
-    },
-    version: "1.0.0",
-    ip_address: null,
-    last_heartbeat: "2026-01-01T00:00:00Z",
-    created_at: "2026-01-01T00:00:00Z",
-    ...overrides
-  };
-}
-function makeAuth(overrides = {}) {
-  return {
-    userId: USER_ID,
-    isServiceRole: false,
-    rawToken: "user-jwt-token",
-    ...overrides
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe.skipIf(!HAS_TEST_DB)("handleNodeRoutes — list & delete", () => {
-  beforeEach(async () => {
-    vi.restoreAllMocks();
-    vi.clearAllMocks();
-    clearNodeAuthCache();
-    await sb.from("channel_messages").delete().eq("channel_id", "b0b0b0b0-0001-0002-0003-000000000001").then(() => {});
-    await sb.from("channels").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("node_events").delete().eq("node_id", NODE_ID).then(() => {});
-    await sb.from("nodes").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("store_plans").delete().eq("store_id", TEST_STORE).then(() => {});
-    const {
-      data: storeRow
-    } = await sb.from("stores").select("owner_user_id").eq("id", TEST_STORE).single();
-    if (storeRow?.owner_user_id) {
-      await sb.from("platform_users").update({
-        auth_id: USER_ID
-      }).eq("id", storeRow.owner_user_id);
-    }
-  });
-  afterEach(async () => {
-    vi.restoreAllMocks();
-    await cleanup();
-    await sb.from("channel_messages").delete().eq("channel_id", "b0b0b0b0-0001-0002-0003-000000000001").then(() => {});
-    await sb.from("channels").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("node_events").delete().eq("node_id", NODE_ID).then(() => {});
-    await sb.from("nodes").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("store_plans").delete().eq("store_id", TEST_STORE).then(() => {});
-    const {
-      data: storeRow
-    } = await sb.from("stores").select("owner_user_id").eq("id", TEST_STORE).single();
-    if (storeRow?.owner_user_id) {
-      await sb.from("platform_users").update({
-        auth_id: null
-      }).eq("id", storeRow.owner_user_id);
-    }
-  });
-  describe("GET|POST /nodes", () => {
-    it("lists nodes for a store via GET", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      const result = await handleNodeRoutes("/nodes", "GET", null, sb, makeAuth(), new URLSearchParams({
-        store_id: TEST_STORE
-      }));
-      expect(result.status).toBe(200);
-      expect(result.body.success).toBe(true);
-      expect(Array.isArray(result.body.nodes)).toBe(true);
-    });
-    it("lists nodes for a store via POST body", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      const result = await handleNodeRoutes("/nodes", "POST", {
-        store_id: TEST_STORE
-      }, sb, makeAuth());
-      expect(result.status).toBe(200);
-      expect(result.body.success).toBe(true);
-    });
-    it("returns 400 when store_id is missing", async () => {
-      const result = await handleNodeRoutes("/nodes", "GET", null, sb, makeAuth());
-      expect(result.status).toBe(400);
-      expect(result.body.error).toContain("store_id required");
-    });
-  });
-  describe("DELETE /nodes/:id", () => {
-    it("deletes a node", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      const result = await handleNodeRoutes(`/nodes/${NODE_ID}`, "DELETE", null, sb, makeAuth());
-      expect(result.status).toBe(200);
-      expect(result.body.success).toBe(true);
-      expect(result.body.deleted).toBe(NODE_ID);
-    });
-    it("returns 404 when node not found", async () => {
-      const result = await handleNodeRoutes("/nodes/00000000-0000-0000-0000-000000000000", "DELETE", null, sb, makeAuth());
-      expect(result.status).toBe(404);
-      expect(result.body.error).toContain("Node not found");
-    });
-    it("returns 403 when user has no store access", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      const result = await handleNodeRoutes(`/nodes/${NODE_ID}`, "DELETE", null, sb, makeAuth({
-        userId: "00000000-0000-0000-0000-000000000099"
-      }));
-      expect(result.status).toBe(403);
-      expect(result.body.error).toContain("No access to this node");
-    });
-  });
-  describe("GET /nodes/:id/events", () => {
-    it("returns events for a node", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("node_events", [{
-        id: "e0e0e0e0-0001-0001-0001-000000000001",
-        store_id: TEST_STORE,
-        node_id: NODE_ID,
-        event_type: "registered",
-        details: {},
-        created_at: "2026-01-01"
-      }, {
-        id: "e0e0e0e0-0001-0001-0001-000000000002",
-        store_id: TEST_STORE,
-        node_id: NODE_ID,
-        event_type: "heartbeat",
-        details: {},
-        created_at: "2026-01-02"
-      }]);
-      const result = await handleNodeRoutes(`/nodes/${NODE_ID}/events`, "GET", null, sb, makeAuth());
-      expect(result.status).toBe(200);
-      expect(result.body.success).toBe(true);
-      expect(Array.isArray(result.body.events)).toBe(true);
-    });
-  });
-});

package/dist/server/handlers/nodes-messages-delivery.test.js

@@ -1,208 +0,0 @@
-// nodes-messages-delivery.test.ts — Tests for GET messages, PATCH messages, delivered endpoint
-
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { HAS_TEST_DB, getTestClient, seedTracked, cleanup, TEST_STORE, RUN_PREFIX } from "./__test-utils__/test-db.js";
-vi.mock("./billing.js", () => ({
-  checkPlanLimits: vi.fn().mockResolvedValue({
-    allowed: true
-  }),
-  incrementUsage: vi.fn().mockResolvedValue(undefined)
-}));
-vi.mock("node:crypto", async importOriginal => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    createHash: vi.fn().mockReturnValue({
-      update: vi.fn().mockReturnValue({
-        digest: vi.fn().mockReturnValue("mocked-hash-abc123")
-      })
-    }),
-    randomBytes: vi.fn().mockReturnValue({
-      toString: vi.fn().mockReturnValue("mocked-api-key-hex-string-64chars-long-enough-for-testing-12345678")
-    }),
-    randomUUID: vi.fn().mockReturnValue("a0a0a0a0-0001-0002-0003-000000000001")
-  };
-});
-import { handleNodeRoutes, clearNodeAuthCache } from "./nodes.js";
-const sb = getTestClient();
-const USER_ID = "562fd6cb-ef83-4eca-b999-ffeac2293ee7";
-const NODE_ID = "a0a0a0a0-0001-0002-0003-000000000001";
-const CHANNEL_ID = "b0b0b0b0-0001-0002-0003-000000000001";
-function makeNode(overrides = {}) {
-  return {
-    id: NODE_ID,
-    store_id: TEST_STORE,
-    name: `${RUN_PREFIX} Test Node`,
-    api_key_hash: "mocked-hash-abc123",
-    status: "online",
-    capabilities: ["chat", "voice"],
-    hardware: {
-      cpu: "arm64"
-    },
-    version: "1.0.0",
-    ip_address: null,
-    last_heartbeat: "2026-01-01T00:00:00Z",
-    created_at: "2026-01-01T00:00:00Z",
-    ...overrides
-  };
-}
-function makeChannel(overrides = {}) {
-  return {
-    id: CHANNEL_ID,
-    store_id: TEST_STORE,
-    node_id: NODE_ID,
-    type: "sms",
-    name: `${RUN_PREFIX} SMS Channel`,
-    status: "active",
-    config: {},
-    agent_id: null,
-    stats: {},
-    error_message: null,
-    created_at: "2026-01-01T00:00:00Z",
-    updated_at: "2026-01-01T00:00:00Z",
-    ...overrides
-  };
-}
-function makeNodeAuth(overrides = {}) {
-  return {
-    userId: undefined,
-    isServiceRole: false,
-    rawToken: "node-api-key-raw",
-    ...overrides
-  };
-}
-describe.skipIf(!HAS_TEST_DB)("handleNodeRoutes — message retrieval & delivery", () => {
-  beforeEach(async () => {
-    vi.restoreAllMocks();
-    vi.clearAllMocks();
-    clearNodeAuthCache();
-    await sb.from("channel_messages").delete().eq("channel_id", CHANNEL_ID).then(() => {});
-    await sb.from("channels").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("node_events").delete().eq("node_id", NODE_ID).then(() => {});
-    await sb.from("nodes").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("store_plans").delete().eq("store_id", TEST_STORE).then(() => {});
-    const {
-      data: storeRow
-    } = await sb.from("stores").select("owner_user_id").eq("id", TEST_STORE).single();
-    if (storeRow?.owner_user_id) {
-      await sb.from("platform_users").update({
-        auth_id: USER_ID
-      }).eq("id", storeRow.owner_user_id);
-    }
-  });
-  afterEach(async () => {
-    vi.restoreAllMocks();
-    await cleanup();
-    await sb.from("channel_messages").delete().eq("channel_id", CHANNEL_ID).then(() => {});
-    await sb.from("channels").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("node_events").delete().eq("node_id", NODE_ID).then(() => {});
-    await sb.from("nodes").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("store_plans").delete().eq("store_id", TEST_STORE).then(() => {});
-    const {
-      data: storeRow
-    } = await sb.from("stores").select("owner_user_id").eq("id", TEST_STORE).single();
-    if (storeRow?.owner_user_id) {
-      await sb.from("platform_users").update({
-        auth_id: null
-      }).eq("id", storeRow.owner_user_id);
-    }
-  });
-  describe("GET /channels/:id/messages", () => {
-    it("retrieves messages for a channel", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      await seedTracked("channel_messages", [{
-        id: "d0d0d0d0-0001-0001-0001-000000000001",
-        store_id: TEST_STORE,
-        channel_id: CHANNEL_ID,
-        direction: "inbound",
-        sender_id: "x",
-        content: "hi",
-        created_at: "2026-01-01"
-      }]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "GET", null, sb, makeNodeAuth());
-      expect(result.status).toBe(200);
-      expect(result.body.success).toBe(true);
-      expect(Array.isArray(result.body.messages)).toBe(true);
-    });
-    it("returns 401 for invalid node key", async () => {
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "GET", null, sb, makeNodeAuth());
-      expect(result.status).toBe(401);
-    });
-    it("returns 404 when channel not found", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "GET", null, sb, makeNodeAuth());
-      expect(result.status).toBe(404);
-    });
-    it("filters by direction via query params", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "GET", null, sb, makeNodeAuth(), new URLSearchParams({
-        direction: "outbound"
-      }));
-      expect(result.status).toBe(200);
-    });
-    it("filters undelivered outbound messages", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "GET", null, sb, makeNodeAuth(), new URLSearchParams({
-        undelivered: "true"
-      }));
-      expect(result.status).toBe(200);
-    });
-  });
-  describe("PATCH /channels/:id/messages/:msgId", () => {
-    it("marks message as delivered", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const msgId = "c0c0c0c0-0001-0001-0001-000000000001";
-      await seedTracked("channel_messages", [{
-        id: msgId,
-        store_id: TEST_STORE,
-        channel_id: CHANNEL_ID,
-        direction: "outbound",
-        sender_id: "bot",
-        content: "msg",
-        delivered_at: null
-      }]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages/${msgId}`, "POST", {
-        _method: "PATCH"
-      }, sb, makeNodeAuth());
-      expect(result.status).toBe(200);
-      expect(result.body.success).toBe(true);
-      expect(result.body.delivered).toBe(msgId);
-    });
-    it("returns 401 for invalid node key", async () => {
-      const msgId = "c0c0c0c0-0001-0001-0001-000000000002";
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages/${msgId}`, "POST", {
-        _method: "PATCH"
-      }, sb, makeNodeAuth());
-      expect(result.status).toBe(401);
-    });
-  });
-  describe("POST /channels/:id/messages/:msgId/delivered", () => {
-    it("marks message as delivered via simple endpoint", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const msgId = "c0c0c0c0-0001-0001-0001-000000000003";
-      await seedTracked("channel_messages", [{
-        id: msgId,
-        store_id: TEST_STORE,
-        channel_id: CHANNEL_ID,
-        direction: "outbound",
-        sender_id: "bot",
-        content: "msg",
-        delivered_at: null
-      }]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages/${msgId}/delivered`, "POST", null, sb, makeNodeAuth());
-      expect(result.status).toBe(200);
-      expect(result.body.success).toBe(true);
-      expect(result.body.delivered).toBe(msgId);
-    });
-    it("returns 401 for invalid node key", async () => {
-      const msgId = "c0c0c0c0-0001-0001-0001-000000000004";
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages/${msgId}/delivered`, "POST", null, sb, makeNodeAuth());
-      expect(result.status).toBe(401);
-    });
-  });
-});

package/dist/server/handlers/nodes-messages.test.js

@@ -1,211 +0,0 @@
-// nodes-messages.test.ts — Tests for POST/GET /channels/:id/messages, PATCH delivered, events
-
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { HAS_TEST_DB, getTestClient, seedTracked, cleanup, TEST_STORE, RUN_PREFIX } from "./__test-utils__/test-db.js";
-// ---------------------------------------------------------------------------
-// Mock dependencies
-// ---------------------------------------------------------------------------
-
-vi.mock("./billing.js", () => ({
-  checkPlanLimits: vi.fn().mockResolvedValue({
-    allowed: true
-  }),
-  incrementUsage: vi.fn().mockResolvedValue(undefined)
-}));
-vi.mock("node:crypto", async importOriginal => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    createHash: vi.fn().mockReturnValue({
-      update: vi.fn().mockReturnValue({
-        digest: vi.fn().mockReturnValue("mocked-hash-abc123")
-      })
-    }),
-    randomBytes: vi.fn().mockReturnValue({
-      toString: vi.fn().mockReturnValue("mocked-api-key-hex-string-64chars-long-enough-for-testing-12345678")
-    }),
-    randomUUID: vi.fn().mockReturnValue("a0a0a0a0-0001-0002-0003-000000000001")
-  };
-});
-import { handleNodeRoutes, clearNodeAuthCache } from "./nodes.js";
-import { checkPlanLimits } from "./billing.js";
-const sb = getTestClient();
-const USER_ID = "562fd6cb-ef83-4eca-b999-ffeac2293ee7";
-const NODE_ID = "a0a0a0a0-0001-0002-0003-000000000001";
-const CHANNEL_ID = "b0b0b0b0-0001-0002-0003-000000000001";
-function makeNode(overrides = {}) {
-  return {
-    id: NODE_ID,
-    store_id: TEST_STORE,
-    name: `${RUN_PREFIX} Test Node`,
-    api_key_hash: "mocked-hash-abc123",
-    status: "online",
-    capabilities: ["chat", "voice"],
-    hardware: {
-      cpu: "arm64"
-    },
-    version: "1.0.0",
-    ip_address: null,
-    last_heartbeat: "2026-01-01T00:00:00Z",
-    created_at: "2026-01-01T00:00:00Z",
-    ...overrides
-  };
-}
-function makeChannel(overrides = {}) {
-  return {
-    id: CHANNEL_ID,
-    store_id: TEST_STORE,
-    node_id: NODE_ID,
-    type: "sms",
-    name: `${RUN_PREFIX} SMS Channel`,
-    status: "active",
-    config: {},
-    agent_id: null,
-    stats: {},
-    error_message: null,
-    created_at: "2026-01-01T00:00:00Z",
-    updated_at: "2026-01-01T00:00:00Z",
-    ...overrides
-  };
-}
-function makeAuth(overrides = {}) {
-  return {
-    userId: USER_ID,
-    isServiceRole: false,
-    rawToken: "user-jwt-token",
-    ...overrides
-  };
-}
-function makeNodeAuth(overrides = {}) {
-  return {
-    userId: undefined,
-    isServiceRole: false,
-    rawToken: "node-api-key-raw",
-    ...overrides
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe.skipIf(!HAS_TEST_DB)("handleNodeRoutes — messages", () => {
-  beforeEach(async () => {
-    vi.restoreAllMocks();
-    vi.clearAllMocks();
-    clearNodeAuthCache();
-    await sb.from("channel_messages").delete().eq("channel_id", CHANNEL_ID).then(() => {});
-    await sb.from("channels").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("node_events").delete().eq("node_id", NODE_ID).then(() => {});
-    await sb.from("nodes").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("store_plans").delete().eq("store_id", TEST_STORE).then(() => {});
-    const {
-      data: storeRow
-    } = await sb.from("stores").select("owner_user_id").eq("id", TEST_STORE).single();
-    if (storeRow?.owner_user_id) {
-      await sb.from("platform_users").update({
-        auth_id: USER_ID
-      }).eq("id", storeRow.owner_user_id);
-    }
-  });
-  afterEach(async () => {
-    vi.restoreAllMocks();
-    await cleanup();
-    await sb.from("channel_messages").delete().eq("channel_id", CHANNEL_ID).then(() => {});
-    await sb.from("channels").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("node_events").delete().eq("node_id", NODE_ID).then(() => {});
-    await sb.from("nodes").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("store_plans").delete().eq("store_id", TEST_STORE).then(() => {});
-    const {
-      data: storeRow
-    } = await sb.from("stores").select("owner_user_id").eq("id", TEST_STORE).single();
-    if (storeRow?.owner_user_id) {
-      await sb.from("platform_users").update({
-        auth_id: null
-      }).eq("id", storeRow.owner_user_id);
-    }
-  });
-  describe("POST /channels/:id/messages", () => {
-    it("ingests an inbound message", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "POST", {
-        direction: "inbound",
-        sender_id: "phone-123",
-        content: "Hello!",
-        content_type: "text"
-      }, sb, makeNodeAuth());
-      expect(result.status).toBe(201);
-      expect(result.body.success).toBe(true);
-      expect(result.body.message).toBeDefined();
-      expect(result.body.conversation_id).toBeDefined();
-    });
-    it("returns 400 when body is missing", async () => {
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "POST", null, sb, makeNodeAuth());
-      expect(result.status).toBe(400);
-    });
-    it("returns 401 for invalid node API key without service role", async () => {
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "POST", {
-        direction: "inbound",
-        sender_id: "x",
-        content: "hi"
-      }, sb, makeNodeAuth());
-      expect(result.status).toBe(401);
-    });
-    it("allows service role access without node API key", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "POST", {
-        direction: "inbound",
-        sender_id: "admin",
-        content: "test"
-      }, sb, {
-        userId: undefined,
-        isServiceRole: true,
-        rawToken: "service-key"
-      });
-      expect(result.status).toBe(201);
-    });
-    it("returns 404 when channel not found", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "POST", {
-        direction: "inbound",
-        sender_id: "x",
-        content: "hi"
-      }, sb, makeNodeAuth());
-      expect(result.status).toBe(404);
-    });
-    it("returns 429 when message plan limit exceeded", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      checkPlanLimits.mockResolvedValueOnce({
-        allowed: false,
-        reason: "Monthly message limit reached"
-      });
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "POST", {
-        direction: "inbound",
-        sender_id: "x",
-        content: "hi"
-      }, sb, makeNodeAuth());
-      expect(result.status).toBe(429);
-      expect(result.body.error).toContain("limit reached");
-    });
-    it("defaults direction to inbound", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "POST", {
-        sender_id: "phone-123",
-        content: "Hello"
-      }, sb, makeNodeAuth());
-      expect(result.status).toBe(201);
-    });
-    it("defaults sender_id to 'unknown'", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "POST", {
-        content: "Hello"
-      }, sb, makeNodeAuth());
-      expect(result.status).toBe(201);
-    });
-  });
-});