@kodelyth/voice-call 2026.5.42 → 2026.6.1

package/src/webhook/tailscale.test.ts

@@ -1,216 +0,0 @@
-import { EventEmitter } from "node:events";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const { spawnMock } = vi.hoisted(() => ({
-  spawnMock: vi.fn(),
-}));
-
-const tailscaleSpawnOptions = { stdio: ["ignore", "pipe", "pipe"] } as const;
-
-vi.mock("node:child_process", async () => {
-  const { mockNodeBuiltinModule } = await import("klaw/plugin-sdk/test-node-mocks");
-  return mockNodeBuiltinModule(
-    () => vi.importActual<typeof import("node:child_process")>("node:child_process"),
-    {
-      spawn: spawnMock,
-    },
-  );
-});
-
-import {
-  cleanupTailscaleExposure,
-  cleanupTailscaleExposureRoute,
-  getTailscaleDnsName,
-  getTailscaleSelfInfo,
-  setupTailscaleExposure,
-  setupTailscaleExposureRoute,
-} from "./tailscale.js";
-
-function createProc(params?: { code?: number; stdout?: string }) {
-  const proc = new EventEmitter() as EventEmitter & {
-    stdout: EventEmitter;
-    kill: ReturnType<typeof vi.fn>;
-  };
-  proc.stdout = new EventEmitter();
-  proc.kill = vi.fn();
-  setTimeout(() => {
-    if (params?.stdout) {
-      proc.stdout.emit("data", Buffer.from(params.stdout));
-    }
-    proc.emit("close", params?.code ?? 0);
-  }, 0);
-  return proc;
-}
-
-function createErrorProc() {
-  const proc = new EventEmitter() as EventEmitter & {
-    stdout: EventEmitter;
-    kill: ReturnType<typeof vi.fn>;
-  };
-  proc.stdout = new EventEmitter();
-  proc.kill = vi.fn();
-  setTimeout(() => {
-    proc.emit("error", Object.assign(new Error("spawn tailscale ENOENT"), { code: "ENOENT" }));
-  }, 0);
-  return proc;
-}
-
-describe("voice-call tailscale helpers", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("reads dns and node id from tailscale status json", async () => {
-    spawnMock
-      .mockReturnValueOnce(
-        createProc({
-          stdout: JSON.stringify({
-            Self: {
-              DNSName: "bot.example.ts.net.",
-              ID: "node-123",
-            },
-          }),
-        }),
-      )
-      .mockReturnValueOnce(
-        createProc({
-          stdout: JSON.stringify({
-            Self: {
-              DNSName: "bot.example.ts.net.",
-              ID: "node-123",
-            },
-          }),
-        }),
-      );
-
-    await expect(getTailscaleSelfInfo()).resolves.toEqual({
-      dnsName: "bot.example.ts.net",
-      nodeId: "node-123",
-    });
-    await expect(getTailscaleDnsName()).resolves.toBe("bot.example.ts.net");
-  });
-
-  it("returns null for failing or invalid status responses", async () => {
-    spawnMock.mockReturnValueOnce(createProc({ code: 1, stdout: "bad" }));
-    await expect(getTailscaleSelfInfo()).resolves.toBeNull();
-
-    spawnMock.mockReturnValueOnce(createProc({ stdout: "{not-json" }));
-    await expect(getTailscaleSelfInfo()).resolves.toBeNull();
-  });
-
-  it("treats missing tailscale binary as unavailable instead of leaking spawn errors", async () => {
-    spawnMock.mockReturnValueOnce(createErrorProc());
-
-    await expect(getTailscaleSelfInfo()).resolves.toBeNull();
-  });
-
-  it("sets up and cleans up exposure routes with the selected mode", async () => {
-    spawnMock
-      .mockReturnValueOnce(
-        createProc({
-          stdout: JSON.stringify({ Self: { DNSName: "bot.example.ts.net." } }),
-        }),
-      )
-      .mockReturnValueOnce(createProc({ code: 0 }))
-      .mockReturnValueOnce(createProc({ code: 0 }));
-
-    await expect(
-      setupTailscaleExposureRoute({
-        mode: "serve",
-        path: "/voice",
-        localUrl: "http://127.0.0.1:8787/webhook",
-      }),
-    ).resolves.toBe("https://bot.example.ts.net/voice");
-
-    await cleanupTailscaleExposureRoute({ mode: "serve", path: "/voice" });
-
-    expect(spawnMock).toHaveBeenNthCalledWith(
-      1,
-      "tailscale",
-      ["status", "--json"],
-      tailscaleSpawnOptions,
-    );
-    expect(spawnMock).toHaveBeenNthCalledWith(
-      2,
-      "tailscale",
-      ["serve", "--bg", "--yes", "--set-path", "/voice", "http://127.0.0.1:8787/webhook"],
-      tailscaleSpawnOptions,
-    );
-    expect(spawnMock).toHaveBeenNthCalledWith(
-      3,
-      "tailscale",
-      ["serve", "off", "/voice"],
-      tailscaleSpawnOptions,
-    );
-  });
-
-  it("returns null when setup cannot resolve dns or route activation fails", async () => {
-    spawnMock
-      .mockReturnValueOnce(createProc({ code: 1 }))
-      .mockReturnValueOnce(
-        createProc({
-          stdout: JSON.stringify({ Self: { DNSName: "bot.example.ts.net." } }),
-        }),
-      )
-      .mockReturnValueOnce(createProc({ code: 1 }));
-
-    await expect(
-      setupTailscaleExposureRoute({
-        mode: "funnel",
-        path: "/voice",
-        localUrl: "http://127.0.0.1:8787/webhook",
-      }),
-    ).resolves.toBeNull();
-
-    await expect(
-      setupTailscaleExposureRoute({
-        mode: "funnel",
-        path: "/voice",
-        localUrl: "http://127.0.0.1:8787/webhook",
-      }),
-    ).resolves.toBeNull();
-  });
-
-  it("maps config modes to serve or funnel and skips off", async () => {
-    spawnMock
-      .mockReturnValueOnce(
-        createProc({
-          stdout: JSON.stringify({ Self: { DNSName: "bot.example.ts.net." } }),
-        }),
-      )
-      .mockReturnValueOnce(createProc({ code: 0 }))
-      .mockReturnValueOnce(createProc({ code: 0 }));
-
-    await expect(
-      setupTailscaleExposure({
-        tailscale: { mode: "off", path: "/voice" },
-        serve: { port: 8787, path: "/webhook" },
-      } as never),
-    ).resolves.toBeNull();
-
-    await expect(
-      setupTailscaleExposure({
-        tailscale: { mode: "funnel", path: "/voice" },
-        serve: { port: 8787, path: "/webhook" },
-      } as never),
-    ).resolves.toBe("https://bot.example.ts.net/voice");
-
-    await cleanupTailscaleExposure({
-      tailscale: { mode: "serve", path: "/voice" },
-      serve: { port: 8787, path: "/webhook" },
-    } as never);
-
-    expect(spawnMock).toHaveBeenNthCalledWith(
-      2,
-      "tailscale",
-      ["funnel", "--bg", "--yes", "--set-path", "/voice", "http://127.0.0.1:8787/webhook"],
-      tailscaleSpawnOptions,
-    );
-    expect(spawnMock).toHaveBeenNthCalledWith(
-      3,
-      "tailscale",
-      ["serve", "off", "/voice"],
-      tailscaleSpawnOptions,
-    );
-  });
-});

package/src/webhook/tailscale.ts

@@ -1,129 +0,0 @@
-import { spawn } from "node:child_process";
-import type { VoiceCallConfig } from "../config.js";
-
-type TailscaleSelfInfo = {
-  dnsName: string | null;
-  nodeId: string | null;
-};
-
-function runTailscaleCommand(
-  args: string[],
-  timeoutMs = 2500,
-): Promise<{ code: number; stdout: string }> {
-  return new Promise((resolve) => {
-    const proc = spawn("tailscale", args, {
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-
-    let stdout = "";
-    let settled = false;
-    let timer: ReturnType<typeof setTimeout>;
-    const finish = (result: { code: number; stdout: string }) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      clearTimeout(timer);
-      resolve(result);
-    };
-
-    proc.stdout.on("data", (data) => {
-      stdout += data;
-    });
-
-    timer = setTimeout(() => {
-      proc.kill("SIGKILL");
-      finish({ code: -1, stdout: "" });
-    }, timeoutMs);
-
-    proc.on("error", () => {
-      finish({ code: -1, stdout: "" });
-    });
-
-    proc.on("close", (code) => {
-      finish({ code: code ?? -1, stdout });
-    });
-  });
-}
-
-export async function getTailscaleSelfInfo(): Promise<TailscaleSelfInfo | null> {
-  const { code, stdout } = await runTailscaleCommand(["status", "--json"]);
-  if (code !== 0) {
-    return null;
-  }
-
-  try {
-    const status = JSON.parse(stdout);
-    return {
-      dnsName: status.Self?.DNSName?.replace(/\.$/, "") || null,
-      nodeId: status.Self?.ID || null,
-    };
-  } catch {
-    return null;
-  }
-}
-
-export async function getTailscaleDnsName(): Promise<string | null> {
-  const info = await getTailscaleSelfInfo();
-  return info?.dnsName ?? null;
-}
-
-export async function setupTailscaleExposureRoute(opts: {
-  mode: "serve" | "funnel";
-  path: string;
-  localUrl: string;
-}): Promise<string | null> {
-  const dnsName = await getTailscaleDnsName();
-  if (!dnsName) {
-    console.warn("[voice-call] Could not get Tailscale DNS name");
-    return null;
-  }
-
-  const { code } = await runTailscaleCommand([
-    opts.mode,
-    "--bg",
-    "--yes",
-    "--set-path",
-    opts.path,
-    opts.localUrl,
-  ]);
-
-  if (code === 0) {
-    const publicUrl = `https://${dnsName}${opts.path}`;
-    console.log(`[voice-call] Tailscale ${opts.mode} active: ${publicUrl}`);
-    return publicUrl;
-  }
-
-  console.warn(`[voice-call] Tailscale ${opts.mode} failed`);
-  return null;
-}
-
-export async function cleanupTailscaleExposureRoute(opts: {
-  mode: "serve" | "funnel";
-  path: string;
-}): Promise<void> {
-  await runTailscaleCommand([opts.mode, "off", opts.path]);
-}
-
-export async function setupTailscaleExposure(config: VoiceCallConfig): Promise<string | null> {
-  if (config.tailscale.mode === "off") {
-    return null;
-  }
-
-  const mode = config.tailscale.mode === "funnel" ? "funnel" : "serve";
-  const localUrl = `http://127.0.0.1:${config.serve.port}${config.serve.path}`;
-  return setupTailscaleExposureRoute({
-    mode,
-    path: config.tailscale.path,
-    localUrl,
-  });
-}
-
-export async function cleanupTailscaleExposure(config: VoiceCallConfig): Promise<void> {
-  if (config.tailscale.mode === "off") {
-    return;
-  }
-
-  const mode = config.tailscale.mode === "funnel" ? "funnel" : "serve";
-  await cleanupTailscaleExposureRoute({ mode, path: config.tailscale.path });
-}

package/src/webhook-exposure.test.ts

@@ -1,33 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { isLocalOnlyWebhookHost, isProviderUnreachableWebhookUrl } from "./webhook-exposure.js";
-
-describe("webhook exposure host classification", () => {
-  it.each([
-    "http://[::]:3334/voice/webhook",
-    "http://[::1]:3334/voice/webhook",
-    "http://[fc00::1]/voice/webhook",
-    "http://[fd00::1]/voice/webhook",
-    "http://[::ffff:127.0.0.1]/voice/webhook",
-    "http://[::ffff:10.0.0.1]/voice/webhook",
-    "http://[::ffff:192.168.0.1]/voice/webhook",
-    "http://[::ffff:172.16.0.1]/voice/webhook",
-    "http://[fe80::1]/voice/webhook",
-  ])("treats local/private webhook URL %s as provider-unreachable", (url) => {
-    expect(isProviderUnreachableWebhookUrl(url)).toBe(true);
-  });
-
-  it.each([
-    "http://[::ffff:8.8.8.8]/voice/webhook",
-    "https://voice.example.com/voice/webhook",
-    "https://fcloud.example/voice/webhook",
-  ])("does not reject public webhook URL %s", (url) => {
-    expect(isProviderUnreachableWebhookUrl(url)).toBe(false);
-  });
-
-  it.each(["[::1]", "[fc00::1]", "[fd00::1]", "::ffff:7f00:1", "::ffff:a00:1", "[fe80::1]"])(
-    "normalizes local/private URL hostnames like %s",
-    (host) => {
-      expect(isLocalOnlyWebhookHost(host)).toBe(true);
-    },
-  );
-});

package/src/webhook-exposure.ts

@@ -1,84 +0,0 @@
-import { isBlockedHostnameOrIp } from "../api.js";
-
-type VoiceCallWebhookExposureConfig = {
-  provider?: string;
-  publicUrl?: string;
-  tunnel?: {
-    provider?: string;
-  };
-  tailscale?: {
-    mode?: string;
-  };
-};
-
-type VoiceCallWebhookExposureStatus = {
-  ok: boolean;
-  configured: boolean;
-  message: string;
-};
-
-export function providerRequiresPublicWebhook(providerName: string | undefined): boolean {
-  return providerName === "twilio" || providerName === "telnyx" || providerName === "plivo";
-}
-
-export function isLocalOnlyWebhookHost(hostname: string): boolean {
-  return isBlockedHostnameOrIp(hostname);
-}
-
-export function isProviderUnreachableWebhookUrl(webhookUrl: string): boolean {
-  try {
-    const parsed = new URL(webhookUrl);
-    return isLocalOnlyWebhookHost(parsed.hostname);
-  } catch {
-    return false;
-  }
-}
-
-export function resolveWebhookExposureStatus(
-  config: VoiceCallWebhookExposureConfig,
-): VoiceCallWebhookExposureStatus {
-  if (config.provider === "mock") {
-    return {
-      ok: true,
-      configured: true,
-      message: "Mock provider does not need a public webhook",
-    };
-  }
-
-  if (config.publicUrl) {
-    if (isProviderUnreachableWebhookUrl(config.publicUrl)) {
-      return {
-        ok: false,
-        configured: true,
-        message: `Public webhook URL is local/private and cannot be reached by ${config.provider ?? "the provider"}: ${config.publicUrl}`,
-      };
-    }
-    return {
-      ok: true,
-      configured: true,
-      message: `Public webhook URL configured: ${config.publicUrl}`,
-    };
-  }
-
-  if (config.tunnel?.provider && config.tunnel.provider !== "none") {
-    return {
-      ok: true,
-      configured: true,
-      message: "Webhook exposure configured through tunnel",
-    };
-  }
-
-  if (config.tailscale?.mode && config.tailscale.mode !== "off") {
-    return {
-      ok: true,
-      configured: true,
-      message: "Webhook exposure configured through Tailscale",
-    };
-  }
-
-  return {
-    ok: false,
-    configured: false,
-    message: "Set publicUrl or configure tunnel/tailscale so the provider can reach webhooks",
-  };
-}