@vellumai/cli 0.11.6 → 0.11.7-staging.2

package/node_modules/@vellumai/local-mode/node_modules/@vellumai/service-contracts/src/__tests__/conversation-handle.test.ts

@@ -0,0 +1,316 @@
+import { describe, expect, test } from "bun:test";
+
+import { CHANNEL_IDS } from "../channels.js";
+import {
+  CONVERSATION_HANDLE_PROVIDERS,
+  ConversationHandleSchema,
+  deserializeConversationHandle,
+  safeDeserializeConversationHandle,
+  serializeConversationHandle,
+  type ConversationHandle,
+} from "../conversation-handle.js";
+
+// Representative handles, one per provider surface the contract must cover.
+const slackChannel: ConversationHandle = {
+  provider: "slack",
+  connectionId: "conn-slack-1",
+  teamId: "T0123ABCD",
+  channelId: "C0123ABCD",
+};
+
+const slackThread: ConversationHandle = {
+  provider: "slack",
+  connectionId: "conn-slack-1",
+  teamId: "T0123ABCD",
+  channelId: "C0123ABCD",
+  threadTs: "1700000000.000100",
+};
+
+const slackDm: ConversationHandle = {
+  provider: "slack",
+  connectionId: "conn-slack-1",
+  teamId: "T0123ABCD",
+  channelId: "D0456EFGH",
+};
+
+const telegramChat: ConversationHandle = {
+  provider: "telegram",
+  connectionId: "conn-telegram-1",
+  chatId: "123456789",
+  subconversation: { kind: "chat" },
+};
+
+const telegramMessageThread: ConversationHandle = {
+  provider: "telegram",
+  connectionId: "conn-telegram-1",
+  chatId: "-1001234567890",
+  subconversation: { kind: "message_thread", id: "42" },
+};
+
+const telegramDirectMessagesTopic: ConversationHandle = {
+  provider: "telegram",
+  connectionId: "conn-telegram-1",
+  chatId: "-1009876543210",
+  subconversation: { kind: "direct_messages_topic", id: "77" },
+};
+
+const discordChannel: ConversationHandle = {
+  provider: "discord",
+  connectionId: "conn-discord-1",
+  guildId: "123456789012345678",
+  channelId: "223456789012345678",
+};
+
+const discordThread: ConversationHandle = {
+  provider: "discord",
+  connectionId: "conn-discord-1",
+  guildId: "123456789012345678",
+  channelId: "223456789012345678",
+  threadId: "323456789012345678",
+};
+
+const REPRESENTATIVE_HANDLES: ConversationHandle[] = [
+  slackChannel,
+  slackThread,
+  slackDm,
+  telegramChat,
+  telegramMessageThread,
+  telegramDirectMessagesTopic,
+  discordChannel,
+  discordThread,
+];
+
+describe("CONVERSATION_HANDLE_PROVIDERS", () => {
+  test("is a subset of the canonical channel ids", () => {
+    for (const provider of CONVERSATION_HANDLE_PROVIDERS) {
+      expect(CHANNEL_IDS).toContain(provider);
+    }
+  });
+});
+
+describe("round-trip", () => {
+  test.each(REPRESENTATIVE_HANDLES.map((h) => [h] as const))(
+    "serialization and schema parsing preserve %j",
+    (handle) => {
+      const wire = serializeConversationHandle(handle);
+      expect(safeDeserializeConversationHandle(wire)).toEqual(handle);
+      expect(deserializeConversationHandle(wire)).toEqual(handle);
+      // The wire form is plain JSON, so a generic JSON hop plus schema parse
+      // reconstructs the same handle.
+      expect(ConversationHandleSchema.parse(JSON.parse(wire))).toEqual(handle);
+    },
+  );
+});
+
+describe("provider discrimination", () => {
+  test("rejects unknown providers", () => {
+    expect(
+      ConversationHandleSchema.safeParse({
+        provider: "mastodon",
+        connectionId: "conn-1",
+      }).success,
+    ).toBe(false);
+  });
+
+  test("rejects canonical channels that have no handle shape", () => {
+    // whatsapp is a canonical ChannelId but not (yet) a handle provider, so
+    // it must fail schema parsing rather than fall through to some default.
+    expect(
+      ConversationHandleSchema.safeParse({
+        provider: "whatsapp",
+        connectionId: "conn-1",
+        chatId: "+15555550100",
+      }).success,
+    ).toBe(false);
+  });
+
+  test("rejects cross-provider coordinate mixes", () => {
+    // Telegram handle carrying Slack routing fields.
+    expect(
+      ConversationHandleSchema.safeParse({
+        provider: "telegram",
+        connectionId: "conn-1",
+        teamId: "T0123ABCD",
+        channelId: "C0123ABCD",
+      }).success,
+    ).toBe(false);
+    // Slack handle carrying Telegram routing fields.
+    expect(
+      ConversationHandleSchema.safeParse({
+        ...slackChannel,
+        chatId: "123456789",
+      }).success,
+    ).toBe(false);
+    // Discord handle carrying a Telegram subconversation.
+    expect(
+      ConversationHandleSchema.safeParse({
+        ...discordChannel,
+        subconversation: { kind: "chat" },
+      }).success,
+    ).toBe(false);
+  });
+});
+
+describe("telegram subconversations", () => {
+  test("chat, message_thread, and direct_messages_topic are distinct", () => {
+    const parsedThread = ConversationHandleSchema.parse(telegramMessageThread);
+    const parsedTopic = ConversationHandleSchema.parse(
+      telegramDirectMessagesTopic,
+    );
+    if (
+      parsedThread.provider !== "telegram" ||
+      parsedTopic.provider !== "telegram"
+    ) {
+      throw new Error("expected telegram handles");
+    }
+    expect(parsedThread.subconversation.kind).toBe("message_thread");
+    expect(parsedTopic.subconversation.kind).toBe("direct_messages_topic");
+  });
+
+  test("rejects a chat subconversation carrying an id", () => {
+    expect(
+      ConversationHandleSchema.safeParse({
+        ...telegramChat,
+        subconversation: { kind: "chat", id: "42" },
+      }).success,
+    ).toBe(false);
+  });
+
+  test("rejects a message_thread subconversation missing its id", () => {
+    expect(
+      ConversationHandleSchema.safeParse({
+        ...telegramChat,
+        subconversation: { kind: "message_thread" },
+      }).success,
+    ).toBe(false);
+  });
+
+  test("rejects an unknown subconversation kind", () => {
+    expect(
+      ConversationHandleSchema.safeParse({
+        ...telegramChat,
+        subconversation: { kind: "topic", id: "42" },
+      }).success,
+    ).toBe(false);
+  });
+
+  test("rejects flattened untyped topic fields", () => {
+    // message_thread_id and direct_messages_topic_id must not ride along as
+    // loose fields next to (or instead of) the typed subconversation.
+    for (const extra of [
+      { topicId: "42" },
+      { messageThreadId: "42" },
+      { directMessagesTopicId: "42" },
+    ]) {
+      expect(
+        ConversationHandleSchema.safeParse({
+          ...telegramChat,
+          ...extra,
+        }).success,
+      ).toBe(false);
+    }
+  });
+});
+
+describe("message coordinates stay out of the handle", () => {
+  test.each([
+    [{ ...telegramChat, messageId: "9001" }],
+    [{ ...telegramChat, replyToMessageId: "9001" }],
+    [{ ...slackThread, messageTs: "1700000000.000200" }],
+    [{ ...discordThread, messageId: "423456789012345678" }],
+  ])("rejects %j", (value) => {
+    expect(ConversationHandleSchema.safeParse(value).success).toBe(false);
+  });
+
+  test("rejects a smuggled internal conversationId", () => {
+    // The Vellum internal conversation id is a separate identity and never
+    // lives inside the provider handle.
+    expect(
+      ConversationHandleSchema.safeParse({
+        ...slackChannel,
+        conversationId: "conv-xyz",
+      }).success,
+    ).toBe(false);
+  });
+});
+
+describe("field validation", () => {
+  test("requires a non-empty connectionId on every variant", () => {
+    for (const handle of [slackChannel, telegramChat, discordChannel]) {
+      expect(
+        ConversationHandleSchema.safeParse({
+          ...handle,
+          connectionId: "",
+        }).success,
+      ).toBe(false);
+      const { connectionId: _omitted, ...withoutConnection } = handle;
+      expect(ConversationHandleSchema.safeParse(withoutConnection).success).toBe(
+        false,
+      );
+    }
+  });
+
+  test("rejects whitespace and control characters in connectionId", () => {
+    expect(
+      ConversationHandleSchema.safeParse({
+        ...slackChannel,
+        connectionId: "conn 1",
+      }).success,
+    ).toBe(false);
+    expect(
+      ConversationHandleSchema.safeParse({
+        ...slackChannel,
+        connectionId: "conn\n1",
+      }).success,
+    ).toBe(false);
+  });
+
+  test.each([
+    [{ ...slackChannel, teamId: "C0123ABCD" }],
+    [{ ...slackChannel, channelId: "T0123ABCD" }],
+    [{ ...slackThread, threadTs: "not-a-ts" }],
+    // The gateway's block-actions reply routing falls back to a Slack
+    // envelope id (a UUID) when no thread_ts exists. A handle only ever
+    // carries a real thread_ts, so envelope-id-shaped values must fail here
+    // instead of becoming durable identity.
+    [{ ...slackThread, threadTs: "8a17bf85-6a58-4b60-8c81-63d8b5ab8c73" }],
+    [{ ...telegramChat, chatId: "12ab34" }],
+    [{ ...telegramMessageThread, subconversation: { kind: "message_thread", id: "-42" } }],
+    [{ ...discordChannel, guildId: "123456789012345678901" }],
+    [{ ...discordThread, threadId: "thread-1" }],
+  ])("rejects malformed coordinates in %j", (value) => {
+    expect(ConversationHandleSchema.safeParse(value).success).toBe(false);
+  });
+
+  test("coordinates are strings, not numbers", () => {
+    expect(
+      ConversationHandleSchema.safeParse({
+        ...telegramChat,
+        chatId: 123456789,
+      }).success,
+    ).toBe(false);
+  });
+});
+
+describe("serialization helpers", () => {
+  test("serializeConversationHandle validates before serializing", () => {
+    expect(() =>
+      serializeConversationHandle({
+        ...telegramChat,
+        chatId: "not-a-chat-id",
+      } as ConversationHandle),
+    ).toThrow();
+  });
+
+  test("safeDeserializeConversationHandle returns null on malformed input", () => {
+    expect(safeDeserializeConversationHandle("not json")).toBeNull();
+    expect(safeDeserializeConversationHandle("42")).toBeNull();
+    expect(safeDeserializeConversationHandle('{"provider":"slack"}')).toBeNull();
+  });
+
+  test("deserializeConversationHandle throws on malformed input", () => {
+    expect(() => deserializeConversationHandle("not json")).toThrow(
+      "not a valid conversation handle serialization",
+    );
+  });
+});

package/node_modules/@vellumai/local-mode/node_modules/@vellumai/service-contracts/src/__tests__/ingress.test.ts

@@ -0,0 +1,280 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  normalizeHttpPublicBaseUrl,
+  normalizeHttpPublicBaseUrlWithoutTrailingSlash,
+  normalizePublicBaseUrl,
+  parseRecordedAssistantId,
+  parseTunnelRecord,
+  selectRestartTunnelRecord,
+  trimmedNonEmptyString,
+  TUNNEL_PROVIDERS,
+  type TunnelRecord,
+  velayHostForPlatformHost,
+} from "../ingress.js";
+import {
+  buildTwilioMediaStreamUrl,
+  buildTwilioPhoneNumberWebhookUrls,
+  buildTwilioVoiceWebhookUrl,
+  resolveTwilioPublicBaseUrl,
+} from "../twilio-ingress.js";
+
+describe("velayHostForPlatformHost", () => {
+  test("maps the prod platform host to prod velay", () => {
+    expect(velayHostForPlatformHost("platform.vellum.ai")).toBe(
+      "velay.vellum.ai",
+    );
+  });
+
+  test("maps env-prefixed platform hosts to their env velay", () => {
+    expect(velayHostForPlatformHost("staging-platform.vellum.ai")).toBe(
+      "velay-staging.vellum.ai",
+    );
+    expect(velayHostForPlatformHost("dev-platform.vellum.ai")).toBe(
+      "velay-dev.vellum.ai",
+    );
+  });
+
+  test("returns null for hosts outside the deployment convention", () => {
+    expect(velayHostForPlatformHost("localhost")).toBeNull();
+    expect(velayHostForPlatformHost("platform.example.com")).toBeNull();
+    expect(
+      velayHostForPlatformHost("staging-platform.vellum.ai.evil.com"),
+    ).toBeNull();
+  });
+});
+
+describe("normalizePublicBaseUrl", () => {
+  test("trims whitespace and trailing slashes", () => {
+    expect(normalizePublicBaseUrl(" https://example.test/path/// ")).toBe(
+      "https://example.test/path",
+    );
+  });
+
+  test("rejects non-string and empty values", () => {
+    expect(normalizePublicBaseUrl(undefined)).toBeUndefined();
+    expect(normalizePublicBaseUrl("   ")).toBeUndefined();
+  });
+});
+
+describe("normalizeHttpPublicBaseUrl", () => {
+  test("normalizes valid HTTP and HTTPS URLs", () => {
+    expect(normalizeHttpPublicBaseUrl(" HTTPS://EXAMPLE.TEST/twilio ")).toBe(
+      "https://example.test/twilio",
+    );
+    expect(normalizeHttpPublicBaseUrl("https://example.test/twilio///")).toBe(
+      "https://example.test/twilio",
+    );
+    expect(normalizeHttpPublicBaseUrl("https://example.test")).toBe(
+      "https://example.test/",
+    );
+  });
+
+  test("rejects non-HTTP URLs and malformed values", () => {
+    expect(normalizeHttpPublicBaseUrl("ftp://example.test")).toBeUndefined();
+    expect(normalizeHttpPublicBaseUrl("notaurl")).toBeUndefined();
+    expect(normalizeHttpPublicBaseUrl("")).toBeUndefined();
+  });
+
+  test("rejects query strings and fragments instead of mutating them", () => {
+    expect(
+      normalizeHttpPublicBaseUrl("https://example.test/twilio?token=abc/"),
+    ).toBeUndefined();
+    expect(
+      normalizeHttpPublicBaseUrl("https://example.test/twilio#section/"),
+    ).toBeUndefined();
+    expect(
+      normalizeHttpPublicBaseUrl("https://example.test/twilio?"),
+    ).toBeUndefined();
+    expect(
+      normalizeHttpPublicBaseUrl("https://example.test/twilio#"),
+    ).toBeUndefined();
+  });
+});
+
+describe("normalizeHttpPublicBaseUrlWithoutTrailingSlash", () => {
+  test("drops the root path its sibling always emits", () => {
+    expect(
+      normalizeHttpPublicBaseUrlWithoutTrailingSlash("https://x.test"),
+    ).toBe("https://x.test");
+    expect(
+      normalizeHttpPublicBaseUrlWithoutTrailingSlash("https://x.test/"),
+    ).toBe("https://x.test");
+    expect(
+      normalizeHttpPublicBaseUrlWithoutTrailingSlash(" https://x.test/api/// "),
+    ).toBe("https://x.test/api");
+  });
+
+  test("rejects everything its sibling rejects", () => {
+    for (const value of [
+      "",
+      "   ",
+      "notaurl",
+      "ftp://x.test",
+      "https://x.test?a=b",
+      42,
+    ]) {
+      expect(
+        normalizeHttpPublicBaseUrlWithoutTrailingSlash(value),
+      ).toBeUndefined();
+    }
+  });
+});
+
+describe("Twilio ingress helpers", () => {
+  test("resolves public base URL with fallback", () => {
+    expect(
+      resolveTwilioPublicBaseUrl({
+        publicBaseUrl: " https://twilio.example.test/twilio/ ",
+      }),
+    ).toBe("https://twilio.example.test/twilio");
+    expect(
+      resolveTwilioPublicBaseUrl({
+        publicBaseUrl: " ",
+      }),
+    ).toBeUndefined();
+    expect(
+      resolveTwilioPublicBaseUrl({
+        publicBaseUrl: " ",
+      }, "https://fallback.example.test/"),
+    ).toBe("https://fallback.example.test");
+    expect(
+      resolveTwilioPublicBaseUrl({}, "https://fallback.example.test/"),
+    ).toBe("https://fallback.example.test");
+  });
+
+  test("builds Twilio webhook and WebSocket URLs from one base URL", () => {
+    expect(buildTwilioVoiceWebhookUrl("https://example.test")).toBe(
+      "https://example.test/webhooks/twilio/voice",
+    );
+    expect(buildTwilioVoiceWebhookUrl("https://example.test", "call-123")).toBe(
+      "https://example.test/webhooks/twilio/voice?callSessionId=call-123",
+    );
+    expect(buildTwilioMediaStreamUrl("http://example.test")).toBe(
+      "ws://example.test/webhooks/twilio/media-stream",
+    );
+    expect(buildTwilioPhoneNumberWebhookUrls("https://example.test")).toEqual({
+      statusCallbackUrl: "https://example.test/webhooks/twilio/status",
+      voiceUrl: "https://example.test/webhooks/twilio/voice",
+    });
+  });
+});
+
+describe("parseTunnelRecord", () => {
+  const TUNNEL_URL = "https://assistant-1.example.ts.net";
+
+  test("accepts every provider in the registry", () => {
+    for (const provider of TUNNEL_PROVIDERS) {
+      expect(
+        parseTunnelRecord({ provider, publicBaseUrl: TUNNEL_URL }),
+      ).toEqual({ provider, publicBaseUrl: TUNNEL_URL });
+    }
+  });
+
+  test("returns the URL in the shape its own validator produces", () => {
+    // Padding and trailing slashes are normalized away rather than handed
+    // back, so readers never re-normalize what they were given.
+    for (const publicBaseUrl of [
+      ` ${TUNNEL_URL} `,
+      `${TUNNEL_URL}/`,
+      `${TUNNEL_URL}///`,
+    ]) {
+      expect(
+        parseTunnelRecord({ provider: "ngrok", publicBaseUrl }),
+      ).toEqual({ provider: "ngrok", publicBaseUrl: TUNNEL_URL });
+    }
+  });
+
+  test("rejects values that are not a record", () => {
+    for (const value of [undefined, null, "nonsense", 42, []]) {
+      expect(parseTunnelRecord(value)).toBeNull();
+    }
+  });
+
+  test("rejects a record missing either field", () => {
+    expect(parseTunnelRecord({ provider: "ngrok" })).toBeNull();
+    expect(parseTunnelRecord({ publicBaseUrl: TUNNEL_URL })).toBeNull();
+  });
+
+  test("rejects a provider outside the registry", () => {
+    // Readers render the provider into a `vellum tunnel --provider <name>`
+    // command, so a hand-edited config must not reach a terminal.
+    for (const provider of ["wireguard", "; rm -rf /", "", 42]) {
+      expect(
+        parseTunnelRecord({ provider, publicBaseUrl: TUNNEL_URL }),
+      ).toBeNull();
+    }
+  });
+
+  test("rejects a URL that is not absolute HTTP(S)", () => {
+    for (const publicBaseUrl of [
+      "",
+      "   ",
+      "not-a-url",
+      "example.ts.net",
+      "ftp://x.test",
+      "https://one.ngrok.app?token=x",
+      42,
+    ]) {
+      expect(
+        parseTunnelRecord({ provider: "ngrok", publicBaseUrl }),
+      ).toBeNull();
+    }
+  });
+});
+
+describe("selectRestartTunnelRecord", () => {
+  const PAIRING: TunnelRecord = {
+    provider: "tailscale",
+    publicBaseUrl: "https://assistant-1.example.ts.net",
+  };
+  const LAST: TunnelRecord = {
+    provider: "ngrok",
+    publicBaseUrl: "https://assistant-1.ngrok.app",
+  };
+
+  test("prefers the pairing tunnel over the last one that ran", () => {
+    // The pairing tunnel deliberately left the older public record beside it,
+    // so naming that one would point at an ingress nobody is using.
+    expect(
+      selectRestartTunnelRecord({ lastTunnel: LAST, pairingTunnel: PAIRING }),
+    ).toEqual(PAIRING);
+  });
+
+  test("falls back to the last tunnel and to null", () => {
+    expect(selectRestartTunnelRecord({ lastTunnel: LAST })).toEqual(LAST);
+    for (const ingress of [undefined, null, {}, "nonsense", 42]) {
+      expect(selectRestartTunnelRecord(ingress)).toBeNull();
+    }
+  });
+
+  test("skips a malformed pairing record for a usable last one", () => {
+    expect(
+      selectRestartTunnelRecord({
+        lastTunnel: LAST,
+        pairingTunnel: { provider: "wireguard", publicBaseUrl: "nope" },
+      }),
+    ).toEqual(LAST);
+  });
+});
+
+describe("trimmedNonEmptyString", () => {
+  test("trims and rejects blank or non-string values", () => {
+    expect(trimmedNonEmptyString(" assistant-1 ")).toBe("assistant-1");
+    for (const value of ["", "   ", undefined, null, 42]) {
+      expect(trimmedNonEmptyString(value)).toBeUndefined();
+    }
+  });
+});
+
+describe("parseRecordedAssistantId", () => {
+  test("trims a recorded id", () => {
+    expect(parseRecordedAssistantId(" assistant-1 ")).toBe("assistant-1");
+  });
+
+  test("rejects blank and non-string values", () => {
+    for (const value of ["", "   ", undefined, null, 42]) {
+      expect(parseRecordedAssistantId(value)).toBeNull();
+    }
+  });
+});