@vellumai/vellum-gateway 0.4.40 → 0.4.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/vellum-gateway",
-  "version": "0.4.40",
+  "version": "0.4.42",
   "type": "module",
   "exports": {
     "./twilio/verify": "./src/twilio/verify.ts",

package/src/config-file-mappings.ts

@@ -0,0 +1,107 @@
+import type { GatewayConfig } from "./config.js";
+
+type ConfigFileMapping =
+  | {
+      key: string;
+      field: string;
+      configField: keyof GatewayConfig;
+      type: "string";
+    }
+  | {
+      key: string;
+      field: string;
+      configField: keyof GatewayConfig;
+      type: "record";
+    }
+  | {
+      key: string;
+      field: string;
+      configField: keyof GatewayConfig;
+      type: "normalized-record";
+    };
+
+export const CONFIG_FILE_MAPPINGS: ConfigFileMapping[] = [
+  {
+    key: "sms",
+    field: "phoneNumber",
+    configField: "twilioPhoneNumber",
+    type: "string",
+  },
+  {
+    key: "sms",
+    field: "assistantPhoneNumbers",
+    configField: "assistantPhoneNumbers",
+    type: "normalized-record",
+  },
+  {
+    key: "email",
+    field: "address",
+    configField: "assistantEmail",
+    type: "string",
+  },
+  {
+    key: "twilio",
+    field: "accountSid",
+    configField: "twilioAccountSid",
+    type: "string",
+  },
+  {
+    key: "ingress",
+    field: "publicBaseUrl",
+    configField: "ingressPublicBaseUrl",
+    type: "string",
+  },
+];
+
+/** Iterate entries and keep only those whose value is a non-empty, non-whitespace string. */
+function normalizeRecord(raw: unknown): Record<string, string> | undefined {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return undefined;
+  const result: Record<string, string> = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (typeof v === "string" && v.trim() !== "") {
+      result[k] = v;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
+function resolveRawValue(mapping: ConfigFileMapping, raw: unknown): unknown {
+  switch (mapping.type) {
+    case "string":
+      return typeof raw === "string" ? raw || undefined : undefined;
+    case "record":
+      return raw && typeof raw === "object" && !Array.isArray(raw)
+        ? raw
+        : undefined;
+    case "normalized-record":
+      return normalizeRecord(raw);
+  }
+}
+
+export function applyConfigFileMappings(
+  data: Record<string, unknown>,
+  changedKeys: Set<string>,
+  config: GatewayConfig,
+): void {
+  for (const mapping of CONFIG_FILE_MAPPINGS) {
+    if (!changedKeys.has(mapping.key)) continue;
+    const section = data[mapping.key] as Record<string, unknown> | undefined;
+    const raw = section?.[mapping.field];
+    (config as Record<string, unknown>)[mapping.configField] = resolveRawValue(
+      mapping,
+      raw,
+    );
+  }
+}
+
+export function readConfigFileDefaults(
+  data: Record<string, unknown>,
+): Partial<Record<keyof GatewayConfig, unknown>> {
+  const defaults: Partial<Record<keyof GatewayConfig, unknown>> = {};
+  for (const mapping of CONFIG_FILE_MAPPINGS) {
+    const section = data[mapping.key] as Record<string, unknown> | undefined;
+    const raw = section?.[mapping.field];
+    defaults[mapping.configField] = resolveRawValue(mapping, raw);
+  }
+  return defaults;
+}

package/src/config.ts

@@ -1,6 +1,7 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { getLogger, type LogFileConfig } from "./logger.js";
+import { readConfigFileDefaults } from "./config-file-mappings.js";
 import {
   getRootDir,
   readCredential,
@@ -311,51 +312,31 @@ export async function loadConfig(): Promise<GatewayConfig> {
   let twilioAccountSid =
     process.env.TWILIO_ACCOUNT_SID || twilioCreds?.accountSid || undefined;
 
-  // Phone number: env var > config file sms.phoneNumber > credential store
-  let twilioPhoneNumber: string | undefined =
-    process.env.TWILIO_PHONE_NUMBER || undefined;
-  let assistantPhoneNumbers: Record<string, string> | undefined;
-  let assistantEmail: string | undefined;
+  // Read config.json defaults for fields that can come from the config file
+  let configFileData: Record<string, unknown> = {};
   try {
     const cfgPath = join(getRootDir(), "workspace", "config.json");
     const raw = readFileSync(cfgPath, "utf-8");
     const data = JSON.parse(raw);
-    if (
-      !twilioPhoneNumber &&
-      data?.sms?.phoneNumber &&
-      typeof data.sms.phoneNumber === "string"
-    ) {
-      twilioPhoneNumber = data.sms.phoneNumber;
-    }
-    if (
-      !twilioAccountSid &&
-      data?.twilio?.accountSid &&
-      typeof data.twilio.accountSid === "string"
-    ) {
-      twilioAccountSid = data.twilio.accountSid;
-    }
-    const rawMapping = data?.sms?.assistantPhoneNumbers;
-    if (
-      rawMapping &&
-      typeof rawMapping === "object" &&
-      !Array.isArray(rawMapping)
-    ) {
-      const normalized: Record<string, string> = {};
-      for (const [assistantId, phoneNumber] of Object.entries(
-        rawMapping as Record<string, unknown>,
-      )) {
-        if (typeof phoneNumber === "string" && phoneNumber.trim().length > 0) {
-          normalized[assistantId] = phoneNumber;
-        }
-      }
-      assistantPhoneNumbers = normalized;
-    }
-    if (data?.email?.address && typeof data.email.address === "string") {
-      assistantEmail = data.email.address;
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      configFileData = data as Record<string, unknown>;
     }
   } catch {
     // config file may not exist yet
   }
+  const configDefaults = readConfigFileDefaults(configFileData);
+
+  // Phone number: env var > config file > credential store
+  let twilioPhoneNumber: string | undefined =
+    process.env.TWILIO_PHONE_NUMBER ||
+    (configDefaults.twilioPhoneNumber as string | undefined);
+  if (!twilioAccountSid) {
+    twilioAccountSid = configDefaults.twilioAccountSid as string | undefined;
+  }
+  const assistantPhoneNumbers = configDefaults.assistantPhoneNumbers as
+    | Record<string, string>
+    | undefined;
+  const assistantEmail = configDefaults.assistantEmail as string | undefined;
   if (!twilioPhoneNumber) {
     twilioPhoneNumber =
       (await readCredential("credential:twilio:phone_number")) || undefined;
@@ -503,7 +484,9 @@ export async function loadConfig(): Promise<GatewayConfig> {
   }
   const trustProxy = trustProxyRaw === "true";
 
-  const ingressPublicBaseUrl = process.env.INGRESS_PUBLIC_BASE_URL || undefined;
+  const ingressPublicBaseUrl =
+    process.env.INGRESS_PUBLIC_BASE_URL ||
+    (configDefaults.ingressPublicBaseUrl as string | undefined);
 
   const logFileDir = process.env.GATEWAY_LOG_DIR || undefined;
 

package/src/credential-mappings.ts

@@ -0,0 +1,102 @@
+import type { GatewayConfig } from "./config.js";
+import type { CredentialChangeEvent } from "./credential-watcher.js";
+
+type CredentialServiceMapping = {
+  /** Key on CredentialChangeEvent indicating whether this service changed. */
+  changedKey: keyof CredentialChangeEvent & `${string}Changed`;
+  /** Key on CredentialChangeEvent containing the credentials object. */
+  credentialsKey: keyof CredentialChangeEvent & `${string}Credentials`;
+  /** Whether to skip updates when env vars provide these credentials. */
+  envGuarded: boolean;
+  /** Human-friendly name used in log messages (e.g. "Slack channel"). Falls back to capitalizing changedKey. */
+  displayName?: string;
+  /** Maps credential object fields to GatewayConfig fields. */
+  fields: Array<{
+    credField: string;
+    configField: keyof GatewayConfig;
+  }>;
+};
+
+export function buildCredentialServiceMappings(opts: {
+  telegramFromEnv: boolean;
+  slackFromEnv: boolean;
+}): CredentialServiceMapping[] {
+  return [
+    {
+      changedKey: "telegramChanged",
+      credentialsKey: "telegramCredentials",
+      envGuarded: opts.telegramFromEnv,
+      fields: [
+        { credField: "botToken", configField: "telegramBotToken" },
+        { credField: "webhookSecret", configField: "telegramWebhookSecret" },
+      ],
+    },
+    {
+      changedKey: "twilioChanged",
+      credentialsKey: "twilioCredentials",
+      envGuarded: false,
+      fields: [
+        { credField: "accountSid", configField: "twilioAccountSid" },
+        { credField: "authToken", configField: "twilioAuthToken" },
+      ],
+    },
+    {
+      changedKey: "whatsappChanged",
+      credentialsKey: "whatsappCredentials",
+      envGuarded: false,
+      fields: [
+        { credField: "phoneNumberId", configField: "whatsappPhoneNumberId" },
+        { credField: "accessToken", configField: "whatsappAccessToken" },
+        { credField: "appSecret", configField: "whatsappAppSecret" },
+        {
+          credField: "webhookVerifyToken",
+          configField: "whatsappWebhookVerifyToken",
+        },
+      ],
+    },
+    {
+      changedKey: "slackChannelChanged",
+      credentialsKey: "slackChannelCredentials",
+      envGuarded: opts.slackFromEnv,
+      displayName: "Slack channel",
+      fields: [
+        { credField: "botToken", configField: "slackChannelBotToken" },
+        { credField: "appToken", configField: "slackChannelAppToken" },
+      ],
+    },
+  ];
+}
+
+export function applyCredentialChanges(
+  event: CredentialChangeEvent,
+  config: GatewayConfig,
+  mappings: CredentialServiceMapping[],
+  log: { info: (msg: string) => void },
+): Set<string> {
+  const changedServices = new Set<string>();
+  for (const mapping of mappings) {
+    if (!event[mapping.changedKey]) continue;
+    if (mapping.envGuarded) continue;
+    const creds = event[mapping.credentialsKey] as Record<
+      string,
+      unknown
+    > | null;
+    for (const { credField, configField } of mapping.fields) {
+      (config as Record<string, unknown>)[configField] = creds
+        ? (creds as Record<string, unknown>)[credField]
+        : undefined;
+    }
+    // Extract a human-friendly service name from the changedKey (e.g. "telegramChanged" -> "Telegram")
+    const serviceName = mapping.changedKey.replace("Changed", "");
+    const capitalizedName =
+      serviceName.charAt(0).toUpperCase() + serviceName.slice(1);
+    const logName = mapping.displayName ?? capitalizedName;
+    log.info(
+      creds
+        ? `${logName} credentials loaded from credential vault`
+        : `${logName} credentials cleared`,
+    );
+    changedServices.add(serviceName);
+  }
+  return changedServices;
+}

package/src/credential-watcher.ts

@@ -43,16 +43,7 @@ export class CredentialWatcher {
   private watcher: FSWatcher | null = null;
   private watchingDirectory = false;
   private debounceTimer: ReturnType<typeof setTimeout> | null = null;
-  private lastBotToken: string | undefined;
-  private lastWebhookSecret: string | undefined;
-  private lastTwilioAccountSid: string | undefined;
-  private lastTwilioAuthToken: string | undefined;
-  private lastWhatsAppPhoneNumberId: string | undefined;
-  private lastWhatsAppAccessToken: string | undefined;
-  private lastWhatsAppAppSecret: string | undefined;
-  private lastWhatsAppWebhookVerifyToken: string | undefined;
-  private lastSlackChannelBotToken: string | undefined;
-  private lastSlackChannelAppToken: string | undefined;
+  private lastSerialized: Map<string, string> = new Map();
   private polling = false;
   private pendingPoll = false;
   private callback: CredentialChangeCallback;
@@ -157,90 +148,38 @@ export class CredentialWatcher {
       const whatsappCredentials = await readWhatsAppCredentials();
       const slackChannelCredentials = await readSlackChannelCredentials();
 
-      const newBotToken = telegramCredentials?.botToken;
-      const newWebhookSecret = telegramCredentials?.webhookSecret;
-      const newTwilioAccountSid = twilioCredentials?.accountSid;
-      const newTwilioAuthToken = twilioCredentials?.authToken;
-      const newWhatsAppPhoneNumberId = whatsappCredentials?.phoneNumberId;
-      const newWhatsAppAccessToken = whatsappCredentials?.accessToken;
-      const newWhatsAppAppSecret = whatsappCredentials?.appSecret;
-      const newWhatsAppWebhookVerifyToken =
-        whatsappCredentials?.webhookVerifyToken;
-      const newSlackChannelBotToken = slackChannelCredentials?.botToken;
-      const newSlackChannelAppToken = slackChannelCredentials?.appToken;
-
-      const telegramChanged =
-        newBotToken !== this.lastBotToken ||
-        newWebhookSecret !== this.lastWebhookSecret;
-
-      const twilioChanged =
-        newTwilioAccountSid !== this.lastTwilioAccountSid ||
-        newTwilioAuthToken !== this.lastTwilioAuthToken;
-
-      const whatsappChanged =
-        newWhatsAppPhoneNumberId !== this.lastWhatsAppPhoneNumberId ||
-        newWhatsAppAccessToken !== this.lastWhatsAppAccessToken ||
-        newWhatsAppAppSecret !== this.lastWhatsAppAppSecret ||
-        newWhatsAppWebhookVerifyToken !== this.lastWhatsAppWebhookVerifyToken;
-
-      const slackChannelChanged =
-        newSlackChannelBotToken !== this.lastSlackChannelBotToken ||
-        newSlackChannelAppToken !== this.lastSlackChannelAppToken;
-
-      if (
-        !telegramChanged &&
-        !twilioChanged &&
-        !whatsappChanged &&
-        !slackChannelChanged
-      ) {
-        return;
+      const services = {
+        telegram: { creds: telegramCredentials, key: "telegram" },
+        twilio: { creds: twilioCredentials, key: "twilio" },
+        whatsapp: { creds: whatsappCredentials, key: "whatsapp" },
+        slackChannel: { creds: slackChannelCredentials, key: "slackChannel" },
+      };
+
+      const changedServices = new Set<string>();
+      for (const [name, { creds }] of Object.entries(services)) {
+        const newVal = creds ? JSON.stringify(creds) : undefined;
+        const oldVal = this.lastSerialized.get(name);
+        if (newVal !== oldVal) {
+          changedServices.add(name);
+          if (newVal !== undefined) {
+            this.lastSerialized.set(name, newVal);
+          } else {
+            this.lastSerialized.delete(name);
+          }
+        }
       }
 
-      this.lastBotToken = newBotToken;
-      this.lastWebhookSecret = newWebhookSecret;
-      this.lastTwilioAccountSid = newTwilioAccountSid;
-      this.lastTwilioAuthToken = newTwilioAuthToken;
-      this.lastWhatsAppPhoneNumberId = newWhatsAppPhoneNumberId;
-      this.lastWhatsAppAccessToken = newWhatsAppAccessToken;
-      this.lastWhatsAppAppSecret = newWhatsAppAppSecret;
-      this.lastWhatsAppWebhookVerifyToken = newWhatsAppWebhookVerifyToken;
-      this.lastSlackChannelBotToken = newSlackChannelBotToken;
-      this.lastSlackChannelAppToken = newSlackChannelAppToken;
-
-      if (telegramChanged) {
-        log.info(
-          { hasCredentials: !!telegramCredentials },
-          "Telegram credentials changed",
-        );
-      }
-      if (twilioChanged) {
-        log.info(
-          { hasCredentials: !!twilioCredentials },
-          "Twilio credentials changed",
-        );
-      }
-      if (whatsappChanged) {
-        log.info(
-          { hasCredentials: !!whatsappCredentials },
-          "WhatsApp credentials changed",
-        );
-      }
-      if (slackChannelChanged) {
-        log.info(
-          { hasCredentials: !!slackChannelCredentials },
-          "Slack channel credentials changed",
-        );
-      }
+      if (changedServices.size === 0) return;
 
       this.callback({
         telegramCredentials,
-        telegramChanged,
+        telegramChanged: changedServices.has("telegram"),
         twilioCredentials,
-        twilioChanged,
+        twilioChanged: changedServices.has("twilio"),
         whatsappCredentials,
-        whatsappChanged,
+        whatsappChanged: changedServices.has("whatsapp"),
         slackChannelCredentials,
-        slackChannelChanged,
+        slackChannelChanged: changedServices.has("slackChannel"),
       });
     } finally {
       this.polling = false;

package/src/index.ts

@@ -12,6 +12,10 @@ import {
 } from "./auth/token-exchange.js";
 import { ConfigFileWatcher } from "./config-file-watcher.js";
 import { loadConfig, isSlackChannelConfigured } from "./config.js";
+import {
+  buildCredentialServiceMappings,
+  applyCredentialChanges,
+} from "./credential-mappings.js";
 import { CredentialWatcher } from "./credential-watcher.js";
 import { createRuntimeProxyHandler } from "./http/routes/runtime-proxy.js";
 import {
@@ -63,6 +67,7 @@ import {
   type RouteDefinition,
   type GetClientIp,
 } from "./http/router.js";
+import { applyConfigFileMappings } from "./config-file-mappings.js";
 import { callTelegramApi } from "./telegram/api.js";
 import { reconcileTelegramWebhook } from "./telegram/webhook-manager.js";
 
@@ -872,65 +877,30 @@ async function main() {
     process.env.SLACK_CHANNEL_BOT_TOKEN && process.env.SLACK_CHANNEL_APP_TOKEN
   );
 
-  const credentialWatcher = new CredentialWatcher((event) => {
-    if (event.telegramChanged && !telegramFromEnv) {
-      if (event.telegramCredentials) {
-        config.telegramBotToken = event.telegramCredentials.botToken;
-        config.telegramWebhookSecret = event.telegramCredentials.webhookSecret;
-        log.info("Telegram credentials loaded from credential vault");
-        registerTelegramCommands();
-        reconcileTelegramWebhook(config).catch((err) => {
-          log.error(
-            { err },
-            "Failed to reconcile Telegram webhook after credential change",
-          );
-        });
-      } else {
-        config.telegramBotToken = undefined;
-        config.telegramWebhookSecret = undefined;
-        log.info("Telegram credentials cleared");
-      }
-    }
+  const credentialMappings = buildCredentialServiceMappings({
+    telegramFromEnv,
+    slackFromEnv,
+  });
 
-    if (event.twilioChanged) {
-      if (event.twilioCredentials) {
-        config.twilioAccountSid = event.twilioCredentials.accountSid;
-        config.twilioAuthToken = event.twilioCredentials.authToken;
-        log.info("Twilio credentials loaded from credential vault");
-      } else {
-        config.twilioAccountSid = undefined;
-        config.twilioAuthToken = undefined;
-        log.info("Twilio credentials cleared");
-      }
-    }
+  const credentialWatcher = new CredentialWatcher((event) => {
+    const changed = applyCredentialChanges(
+      event,
+      config,
+      credentialMappings,
+      log,
+    );
 
-    if (event.whatsappChanged) {
-      if (event.whatsappCredentials) {
-        config.whatsappPhoneNumberId = event.whatsappCredentials.phoneNumberId;
-        config.whatsappAccessToken = event.whatsappCredentials.accessToken;
-        config.whatsappAppSecret = event.whatsappCredentials.appSecret;
-        config.whatsappWebhookVerifyToken =
-          event.whatsappCredentials.webhookVerifyToken;
-        log.info("WhatsApp credentials loaded from credential vault");
-      } else {
-        config.whatsappPhoneNumberId = undefined;
-        config.whatsappAccessToken = undefined;
-        config.whatsappAppSecret = undefined;
-        config.whatsappWebhookVerifyToken = undefined;
-        log.info("WhatsApp credentials cleared");
-      }
+    // Side effects keyed by service name
+    if (changed.has("telegram") && isTelegramConfigured()) {
+      registerTelegramCommands();
+      reconcileTelegramWebhook(config).catch((err) => {
+        log.error(
+          { err },
+          "Failed to reconcile Telegram webhook after credential change",
+        );
+      });
     }
-
-    if (event.slackChannelChanged && !slackFromEnv) {
-      if (event.slackChannelCredentials) {
-        config.slackChannelBotToken = event.slackChannelCredentials.botToken;
-        config.slackChannelAppToken = event.slackChannelCredentials.appToken;
-        log.info("Slack channel credentials loaded from credential vault");
-      } else {
-        config.slackChannelBotToken = undefined;
-        config.slackChannelAppToken = undefined;
-        log.info("Slack channel credentials cleared");
-      }
+    if (changed.has("slackChannel")) {
       startSlackSocket();
     }
   });
@@ -938,63 +908,16 @@ async function main() {
   credentialWatcher.start();
 
   const configFileWatcher = new ConfigFileWatcher((event) => {
-    if (event.changedKeys.has("sms")) {
-      const sms = event.data.sms as
-        | {
-            phoneNumber?: string;
-            assistantPhoneNumbers?: Record<string, string>;
-          }
-        | undefined;
-      config.twilioPhoneNumber =
-        typeof sms?.phoneNumber === "string"
-          ? sms.phoneNumber || undefined
-          : undefined;
-      if (
-        sms?.assistantPhoneNumbers &&
-        typeof sms.assistantPhoneNumbers === "object" &&
-        !Array.isArray(sms.assistantPhoneNumbers)
-      ) {
-        config.assistantPhoneNumbers = sms.assistantPhoneNumbers as Record<
-          string,
-          string
-        >;
-      } else {
-        config.assistantPhoneNumbers = undefined;
-      }
-    }
-
-    if (event.changedKeys.has("email")) {
-      const email = event.data.email as { address?: string } | undefined;
-      config.assistantEmail =
-        typeof email?.address === "string"
-          ? email.address || undefined
-          : undefined;
-    }
-
-    if (event.changedKeys.has("twilio")) {
-      const twilio = event.data.twilio as { accountSid?: string } | undefined;
-      config.twilioAccountSid =
-        typeof twilio?.accountSid === "string"
-          ? twilio.accountSid || undefined
-          : undefined;
-    }
-
-    if (event.changedKeys.has("ingress")) {
-      const ingress = event.data.ingress as
-        | { publicBaseUrl?: string }
-        | undefined;
-      config.ingressPublicBaseUrl =
-        typeof ingress?.publicBaseUrl === "string"
-          ? ingress.publicBaseUrl || undefined
-          : undefined;
-      if (isTelegramConfigured()) {
-        reconcileTelegramWebhook(config).catch((err) => {
-          log.error(
-            { err },
-            "Failed to reconcile Telegram webhook after ingress URL change",
-          );
-        });
-      }
+    applyConfigFileMappings(event.data, event.changedKeys, config);
+
+    // Side effect: reconcile Telegram webhook when ingress URL changes
+    if (event.changedKeys.has("ingress") && isTelegramConfigured()) {
+      reconcileTelegramWebhook(config).catch((err) => {
+        log.error(
+          { err },
+          "Failed to reconcile Telegram webhook after ingress URL change",
+        );
+      });
     }
   });