@objectstack/service-sms 14.5.0

package/dist/index.d.ts

@@ -0,0 +1,198 @@
+import { ISmsTransport, NormalizedSmsMessage, SmsTransportSendResult, ISmsService, SendSmsInput, SendSmsResult } from '@objectstack/spec/contracts';
+import { Plugin, PluginContext } from '@objectstack/core';
+
+/**
+ * Normalize + validate a recipient phone number. Accepts E.164 and common
+ * human formats (spaces / dashes / dots / parens are stripped). Returns
+ * `undefined` when the result doesn't look like a phone number.
+ *
+ * Same shape rule as plugin-auth's `normalizePhoneNumber` — 6-15 digits
+ * with an optional leading `+` (kept local: the two packages must not
+ * depend on each other).
+ */
+declare function normalizeSmsRecipient(raw: string): string | undefined;
+/**
+ * Mask a phone number for log lines: keep the prefix (country-code-ish) and
+ * the last two digits, hide the middle. `+8613812345678` → `+8613******78`.
+ * SMS logging policy: masked recipient + status ONLY — never the body
+ * (OTP codes travel in it; see the ISmsService contract header).
+ */
+declare function maskPhoneNumber(phone: string): string;
+/**
+ * Development transport — never actually sends. Logs the masked recipient
+ * (and, OUTSIDE production only, the message body so local OTP flows are
+ * testable) and returns a synthetic message id.
+ *
+ * The production-body suppression is a hard rule from #2780: OTP codes must
+ * never land in logs. In dev the body IS the delivery — same pattern as the
+ * auth magic-link / invitation URLs, which are printed in dev only.
+ */
+declare class LogSmsTransport implements ISmsTransport {
+    private readonly logger?;
+    private counter;
+    constructor(logger?: {
+        info: (msg: string, meta?: any) => void;
+    } | undefined);
+    send(message: NormalizedSmsMessage): Promise<SmsTransportSendResult>;
+}
+interface SmsServiceOptions {
+    transport: ISmsTransport;
+    /**
+     * Whether `transport` is a real provider (Aliyun / Twilio / injected).
+     * `false` = development log fallback; surfaced via `isConfigured()` so
+     * consumers can gate SMS-dependent features in production.
+     */
+    configured: boolean;
+    /** Retry attempts on transport throw. Default 0 (no retry). */
+    retries?: number;
+    /** Logger for diagnostic output. NEVER receives message bodies. */
+    logger?: {
+        info: (msg: string, meta?: any) => void;
+        warn: (msg: string, meta?: any) => void;
+    };
+}
+/**
+ * Concrete ISmsService implementation.
+ *
+ * Flow: validate + normalize input → transport.send() (with optional
+ * retry) → SendSmsResult. Deliberately NO persistence and NO body logging —
+ * see the contract header in `@objectstack/spec/contracts/sms-service.ts`.
+ */
+declare class SmsService implements ISmsService {
+    options: SmsServiceOptions;
+    constructor(options: SmsServiceOptions);
+    /**
+     * Hot-swap the underlying transport (settings namespace changed). The
+     * `configured` flag travels with the transport.
+     */
+    setTransport(transport: ISmsTransport, configured: boolean): void;
+    isConfigured(): boolean;
+    send(input: SendSmsInput): Promise<SendSmsResult>;
+}
+
+interface AliyunSmsTransportOptions {
+    accessKeyId: string;
+    accessKeySecret: string;
+    /** 短信签名 SignName — the registered sender signature, e.g. `阿里云短信测试`. */
+    signName: string;
+    /**
+     * Default 模板 TemplateCode used when the input carries no `templateId`
+     * (Aliyun only delivers pre-registered templates — free-form bodies are
+     * refused by the API). A catch-all template with a single `${content}`
+     * variable makes generic notification sends possible.
+     */
+    defaultTemplateCode?: string;
+    /** API endpoint host. Default `dysmsapi.aliyuncs.com`. */
+    endpoint?: string;
+    /** Injectable fetch for tests. */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Aliyun SMS (dysmsapi `SendSms`) transport, signed with the current
+ * ACS3-HMAC-SHA256 scheme — plain `fetch` + `node:crypto`, no vendor SDK.
+ *
+ * Aliyun is template-only: the transport sends `templateId` (falling back to
+ * the configured default TemplateCode) with `templateParams` (falling back to
+ * `{ content: body }` for the catch-all-template pattern). The rendered
+ * `body` itself is never transmitted outside `TemplateParam`.
+ */
+declare class AliyunSmsTransport implements ISmsTransport {
+    private readonly options;
+    private readonly endpoint;
+    private readonly fetchImpl;
+    constructor(options: AliyunSmsTransportOptions);
+    send(message: NormalizedSmsMessage): Promise<SmsTransportSendResult>;
+}
+
+interface TwilioSmsTransportOptions {
+    accountSid: string;
+    authToken: string;
+    /** Sender number (E.164). One of `from` / `messagingServiceSid` is required. */
+    from?: string;
+    /** Twilio Messaging Service SID (alternative to a fixed `from` number). */
+    messagingServiceSid?: string;
+    /** API base URL override (tests). Default `https://api.twilio.com`. */
+    baseUrl?: string;
+    /** Injectable fetch for tests. */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Twilio Programmable Messaging transport — a single `POST
+ * /2010-04-01/Accounts/{sid}/Messages.json` with HTTP Basic auth. Plain
+ * `fetch`, no vendor SDK. Free-form: delivers `body` verbatim.
+ */
+declare class TwilioSmsTransport implements ISmsTransport {
+    private readonly options;
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    constructor(options: TwilioSmsTransportOptions);
+    send(message: NormalizedSmsMessage): Promise<SmsTransportSendResult>;
+}
+
+type SmsProviderTag = 'log' | 'aliyun' | 'twilio';
+interface MakeSmsTransportOptions {
+    provider: SmsProviderTag;
+    /** Provider-specific credentials/options (see the transport option types). */
+    options?: Record<string, unknown>;
+    logger?: {
+        info: (msg: string, meta?: any) => void;
+    };
+}
+/**
+ * Build an ISmsTransport from a provider tag + opts. Used by
+ * SmsServicePlugin to materialise the transport selected by config /
+ * the `sms` settings namespace.
+ *
+ * Throws when a non-`log` provider is missing required credentials.
+ */
+declare function makeSmsTransport(opts: MakeSmsTransportOptions): ISmsTransport;
+
+/**
+ * Plugin configuration. Mirrors EmailServicePluginOptions: a directly
+ * injected transport wins, then `provider` + credentials, then the
+ * development `LogSmsTransport` fallback (no real send).
+ */
+interface SmsServicePluginOptions {
+    /** Pluggable delivery transport. Overrides `provider`/credentials. */
+    transport?: ISmsTransport;
+    /** Provider tag — `'log' | 'aliyun' | 'twilio'`. Default `'log'`. */
+    provider?: SmsProviderTag;
+    /** Provider-specific credentials/options (see transport option types). */
+    providerOptions?: Record<string, unknown>;
+    /** Retry attempts on transport throw. Default 0. */
+    retries?: number;
+}
+/**
+ * SmsServicePlugin — registers the `sms` service (#2780).
+ *
+ * Lifecycle:
+ *   - `init`: build transport (injected → provider+credentials →
+ *     LogSmsTransport fallback); register the SmsService so dependents
+ *     (auth OTP, the messaging `sms` channel) can resolve it.
+ *   - `start` (kernel:ready): bind the `sms` settings namespace so the
+ *     admin UI can live-swap the provider without a restart, and register
+ *     the `sms/test` action. Env-locked keys (OS_SMS_*) still win at the
+ *     settings-resolver level.
+ *
+ * Deliberately NO persistence objects: SMS bodies carry OTP codes — see the
+ * ISmsService contract header.
+ */
+declare class SmsServicePlugin implements Plugin {
+    name: string;
+    version: string;
+    type: "standard";
+    private readonly options;
+    private service?;
+    constructor(options?: SmsServicePluginOptions);
+    private resolveInitialTransport;
+    init(ctx: PluginContext): Promise<void>;
+    start(ctx: PluginContext): Promise<void>;
+    /**
+     * Translate the `sms` settings snapshot into a transport and hot-swap it
+     * on the running SmsService. Incomplete credentials keep the previous
+     * transport (with a warning) so a half-saved form can't break delivery.
+     */
+    private applySmsSettings;
+}
+
+export { AliyunSmsTransport, type AliyunSmsTransportOptions, LogSmsTransport, type MakeSmsTransportOptions, type SmsProviderTag, SmsService, type SmsServiceOptions, SmsServicePlugin, type SmsServicePluginOptions, TwilioSmsTransport, type TwilioSmsTransportOptions, makeSmsTransport, maskPhoneNumber, normalizeSmsRecipient };

package/dist/index.js

@@ -0,0 +1,443 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AliyunSmsTransport: () => AliyunSmsTransport,
+  LogSmsTransport: () => LogSmsTransport,
+  SmsService: () => SmsService,
+  SmsServicePlugin: () => SmsServicePlugin,
+  TwilioSmsTransport: () => TwilioSmsTransport,
+  makeSmsTransport: () => makeSmsTransport,
+  maskPhoneNumber: () => maskPhoneNumber,
+  normalizeSmsRecipient: () => normalizeSmsRecipient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/sms-service.ts
+function normalizeSmsRecipient(raw) {
+  const stripped = String(raw ?? "").replace(/[\s\-().]/g, "");
+  return /^\+?[0-9]{6,15}$/.test(stripped) ? stripped : void 0;
+}
+function maskPhoneNumber(phone) {
+  const p = String(phone ?? "");
+  if (p.length <= 6) return `${p.slice(0, 2)}****`;
+  return `${p.slice(0, 5)}${"*".repeat(Math.max(2, p.length - 7))}${p.slice(-2)}`;
+}
+var LogSmsTransport = class {
+  constructor(logger) {
+    this.logger = logger;
+    this.counter = 0;
+  }
+  async send(message) {
+    const messageId = `dev-sms-${Date.now()}-${++this.counter}`;
+    const dev = globalThis?.process?.env?.NODE_ENV !== "production";
+    this.logger?.info(
+      `[LogSmsTransport] would send SMS to ${maskPhoneNumber(message.to)}` + (dev ? ` \u2014 body: ${message.body}` : " (body suppressed outside dev)"),
+      { messageId }
+    );
+    return { messageId, response: "logged" };
+  }
+};
+var SmsService = class {
+  constructor(options) {
+    this.options = options;
+    if (!options.transport) throw new Error("SmsService: transport is required");
+  }
+  /**
+   * Hot-swap the underlying transport (settings namespace changed). The
+   * `configured` flag travels with the transport.
+   */
+  setTransport(transport, configured) {
+    this.options.transport = transport;
+    this.options.configured = configured;
+  }
+  isConfigured() {
+    return this.options.configured;
+  }
+  async send(input) {
+    const to = normalizeSmsRecipient(input?.to ?? "");
+    if (!to) {
+      throw new Error(`VALIDATION_FAILED: '${maskPhoneNumber(String(input?.to ?? ""))}' is not a valid phone number`);
+    }
+    const body = String(input?.body ?? "").trim();
+    if (!body && !input?.templateId && !input?.templateParams) {
+      throw new Error("VALIDATION_FAILED: body (or templateId/templateParams) is required");
+    }
+    const normalized = {
+      to,
+      body,
+      ...input.templateId ? { templateId: input.templateId } : {},
+      ...input.templateParams ? { templateParams: input.templateParams } : {}
+    };
+    const id = `sms-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+    const maxAttempts = (this.options.retries ?? 0) + 1;
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const result = await this.options.transport.send(normalized);
+        this.options.logger?.info(
+          `[SmsService] sent to ${maskPhoneNumber(to)} (messageId=${result.messageId})`
+        );
+        return { id, status: "sent", messageId: result.messageId };
+      } catch (err) {
+        lastError = err;
+        if (attempt < maxAttempts) {
+          await new Promise((r) => setTimeout(r, Math.min(2e3, 100 * 2 ** (attempt - 1))));
+        }
+      }
+    }
+    const errMessage = String(lastError?.message ?? lastError ?? "send failed").slice(0, 500);
+    this.options.logger?.warn(
+      `[SmsService] send to ${maskPhoneNumber(to)} failed: ${errMessage}`
+    );
+    return { id, status: "failed", error: errMessage };
+  }
+};
+
+// src/transports/aliyun.ts
+var import_node_crypto = require("crypto");
+var API_VERSION = "2017-05-25";
+var ALGORITHM = "ACS3-HMAC-SHA256";
+var sha256Hex = (s) => (0, import_node_crypto.createHash)("sha256").update(s, "utf8").digest("hex");
+var hmac256Hex = (key, s) => (0, import_node_crypto.createHmac)("sha256", key).update(s, "utf8").digest("hex");
+var encode = (s) => encodeURIComponent(s).replace(/\+/g, "%20").replace(/\*/g, "%2A").replace(/%7E/g, "~");
+var AliyunSmsTransport = class {
+  constructor(options) {
+    this.options = options;
+    if (!options.accessKeyId || !options.accessKeySecret) {
+      throw new Error("AliyunSmsTransport: accessKeyId and accessKeySecret are required");
+    }
+    if (!options.signName) {
+      throw new Error("AliyunSmsTransport: signName is required");
+    }
+    this.endpoint = options.endpoint ?? "dysmsapi.aliyuncs.com";
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  async send(message) {
+    const templateCode = message.templateId ?? this.options.defaultTemplateCode;
+    if (!templateCode) {
+      throw new Error(
+        "AliyunSmsTransport: Aliyun requires a template \u2014 pass templateId or configure a default template code"
+      );
+    }
+    const templateParam = JSON.stringify(message.templateParams ?? { content: message.body });
+    const query = {
+      PhoneNumbers: message.to,
+      SignName: this.options.signName,
+      TemplateCode: templateCode,
+      TemplateParam: templateParam
+    };
+    const canonicalQuery = Object.keys(query).sort().map((k) => `${encode(k)}=${encode(query[k])}`).join("&");
+    const bodyHash = sha256Hex("");
+    const headers = {
+      host: this.endpoint,
+      "x-acs-action": "SendSms",
+      "x-acs-content-sha256": bodyHash,
+      "x-acs-date": (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z"),
+      "x-acs-signature-nonce": (0, import_node_crypto.randomUUID)(),
+      "x-acs-version": API_VERSION
+    };
+    const signedHeaderNames = Object.keys(headers).sort();
+    const canonicalHeaders = signedHeaderNames.map((k) => `${k}:${headers[k].trim()}
+`).join("");
+    const signedHeaders = signedHeaderNames.join(";");
+    const canonicalRequest = ["POST", "/", canonicalQuery, canonicalHeaders, signedHeaders, bodyHash].join("\n");
+    const stringToSign = `${ALGORITHM}
+${sha256Hex(canonicalRequest)}`;
+    const signature = hmac256Hex(this.options.accessKeySecret, stringToSign);
+    const response = await this.fetchImpl(`https://${this.endpoint}/?${canonicalQuery}`, {
+      method: "POST",
+      headers: {
+        ...headers,
+        Authorization: `${ALGORITHM} Credential=${this.options.accessKeyId},SignedHeaders=${signedHeaders},Signature=${signature}`
+      }
+    });
+    let payload = {};
+    try {
+      payload = await response.json();
+    } catch {
+    }
+    if (!response.ok || payload?.Code !== "OK") {
+      const code = payload?.Code ?? `HTTP_${response.status}`;
+      const detail = payload?.Message ?? response.statusText ?? "request failed";
+      throw new Error(`Aliyun SendSms failed (${code}): ${detail}`);
+    }
+    return { messageId: String(payload.BizId ?? payload.RequestId ?? ""), response: payload.RequestId };
+  }
+};
+
+// src/transports/twilio.ts
+var TwilioSmsTransport = class {
+  constructor(options) {
+    this.options = options;
+    if (!options.accountSid || !options.authToken) {
+      throw new Error("TwilioSmsTransport: accountSid and authToken are required");
+    }
+    if (!options.from && !options.messagingServiceSid) {
+      throw new Error("TwilioSmsTransport: one of from / messagingServiceSid is required");
+    }
+    this.baseUrl = (options.baseUrl ?? "https://api.twilio.com").replace(/\/$/, "");
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  async send(message) {
+    const form = new URLSearchParams({
+      To: message.to,
+      Body: message.body,
+      ...this.options.messagingServiceSid ? { MessagingServiceSid: this.options.messagingServiceSid } : { From: this.options.from }
+    });
+    const auth = Buffer.from(`${this.options.accountSid}:${this.options.authToken}`).toString("base64");
+    const response = await this.fetchImpl(
+      `${this.baseUrl}/2010-04-01/Accounts/${encodeURIComponent(this.options.accountSid)}/Messages.json`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Basic ${auth}`,
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: form.toString()
+      }
+    );
+    let payload = {};
+    try {
+      payload = await response.json();
+    } catch {
+    }
+    if (!response.ok) {
+      const code = payload?.code ?? `HTTP_${response.status}`;
+      const detail = payload?.message ?? response.statusText ?? "request failed";
+      throw new Error(`Twilio send failed (${code}): ${detail}`);
+    }
+    return { messageId: String(payload.sid ?? ""), response: payload.status };
+  }
+};
+
+// src/transports/index.ts
+function makeSmsTransport(opts) {
+  const { provider, options = {}, logger } = opts;
+  switch (provider) {
+    case "log":
+      return new LogSmsTransport(logger);
+    case "aliyun":
+      return new AliyunSmsTransport(options);
+    case "twilio":
+      return new TwilioSmsTransport(options);
+    default:
+      throw new Error(`makeSmsTransport: unknown provider '${provider}'`);
+  }
+}
+
+// src/sms-plugin.ts
+function providerFromSettings(values) {
+  const provider = String(values.provider ?? "log");
+  const str = (k) => {
+    const v = values[k];
+    return typeof v === "string" && v.trim().length > 0 ? v.trim() : void 0;
+  };
+  if (provider === "aliyun") {
+    const accessKeyId = str("aliyun_access_key_id");
+    const accessKeySecret = str("aliyun_access_key_secret");
+    const signName = str("aliyun_sign_name");
+    if (!accessKeyId || !accessKeySecret || !signName) {
+      return { provider, options: {}, missing: "aliyun_access_key_id / aliyun_access_key_secret / aliyun_sign_name" };
+    }
+    return {
+      provider,
+      options: {
+        accessKeyId,
+        accessKeySecret,
+        signName,
+        ...str("aliyun_template_code") ? { defaultTemplateCode: str("aliyun_template_code") } : {}
+      }
+    };
+  }
+  if (provider === "twilio") {
+    const accountSid = str("twilio_account_sid");
+    const authToken = str("twilio_auth_token");
+    const from = str("twilio_from_number");
+    const messagingServiceSid = str("twilio_messaging_service_sid");
+    if (!accountSid || !authToken || !from && !messagingServiceSid) {
+      return { provider, options: {}, missing: "twilio_account_sid / twilio_auth_token / twilio_from_number (or messaging service SID)" };
+    }
+    return {
+      provider,
+      options: {
+        accountSid,
+        authToken,
+        ...from ? { from } : {},
+        ...messagingServiceSid ? { messagingServiceSid } : {}
+      }
+    };
+  }
+  return { provider: "log", options: {} };
+}
+var SmsServicePlugin = class {
+  constructor(options = {}) {
+    this.name = "com.objectstack.service.sms";
+    this.version = "1.0.0";
+    this.type = "standard";
+    this.options = options;
+  }
+  resolveInitialTransport(ctx) {
+    if (this.options.transport) return { transport: this.options.transport, configured: true };
+    const provider = this.options.provider ?? "log";
+    if (provider === "log") return { transport: new LogSmsTransport(ctx.logger), configured: false };
+    try {
+      return {
+        transport: makeSmsTransport({ provider, options: this.options.providerOptions, logger: ctx.logger }),
+        configured: true
+      };
+    } catch (err) {
+      ctx.logger.warn(
+        `SmsServicePlugin: provider='${provider}' selected but transport build failed (${err?.message ?? err}) \u2014 falling back to LogSmsTransport.`
+      );
+      return { transport: new LogSmsTransport(ctx.logger), configured: false };
+    }
+  }
+  async init(ctx) {
+    const { transport, configured } = this.resolveInitialTransport(ctx);
+    if (!configured) {
+      ctx.logger.info("SmsServicePlugin: no provider configured \u2014 using LogSmsTransport (SMS will NOT be sent)");
+    } else {
+      ctx.logger.info(`SmsServicePlugin: using '${this.options.provider ?? "custom"}' provider`);
+    }
+    this.service = new SmsService({
+      transport,
+      configured,
+      retries: this.options.retries,
+      logger: ctx.logger
+    });
+    ctx.registerService("sms", this.service);
+    ctx.logger.info("SmsServicePlugin: sms service registered");
+  }
+  async start(ctx) {
+    ctx.hook("kernel:ready", async () => {
+      if (!this.service) return;
+      if (this.options.transport) return;
+      try {
+        const settings = ctx.getService("settings");
+        if (!settings || typeof settings.getNamespace !== "function") return;
+        const applySettings = async () => {
+          try {
+            const payload = await settings.getNamespace("sms");
+            const values = {};
+            for (const [k, v] of Object.entries(payload.values)) {
+              values[k] = v?.value;
+            }
+            this.applySmsSettings(values, ctx);
+          } catch (err) {
+            ctx.logger.warn("SmsServicePlugin: failed to apply sms settings: " + (err?.message ?? err));
+          }
+        };
+        await applySettings();
+        if (typeof settings.subscribe === "function") {
+          settings.subscribe("sms", () => {
+            void applySettings();
+          });
+          ctx.logger.info("SmsServicePlugin: bound to settings:changed for namespace=sms");
+        }
+        if (typeof settings.registerAction === "function") {
+          const svc = this.service;
+          settings.registerAction("sms", "test", async ({ values, payload, ctx: actionCtx }) => {
+            const overrides = payload && typeof payload === "object" && payload.values && typeof payload.values === "object" ? payload.values : payload ?? {};
+            const merged = { ...values ?? {}, ...overrides };
+            const rawTo = actionCtx?.body?.to ?? payload?.to;
+            const to = rawTo ? normalizeSmsRecipient(rawTo) : void 0;
+            if (!to) {
+              return { ok: false, severity: "error", message: 'Provide a valid "to" phone number (E.164 recommended).' };
+            }
+            const resolved = providerFromSettings(merged);
+            if (resolved.missing) {
+              return { ok: false, severity: "error", message: `${resolved.provider}: missing ${resolved.missing}.` };
+            }
+            let target = svc;
+            if (resolved.provider !== "log") {
+              try {
+                const transport = makeSmsTransport({ provider: resolved.provider, options: resolved.options, logger: ctx.logger });
+                target = new SmsService({ transport, configured: true, logger: ctx.logger });
+              } catch (err) {
+                return { ok: false, severity: "error", message: `Failed to build ${resolved.provider} transport: ${err?.message ?? String(err)}` };
+              }
+            }
+            try {
+              const result = await target.send({
+                to,
+                body: "ObjectStack SMS test message.",
+                templateParams: { content: "ObjectStack SMS test message." }
+              });
+              if (result.status === "failed") {
+                return { ok: false, severity: "error", message: result.error ?? "Send failed." };
+              }
+              return {
+                ok: true,
+                severity: "info",
+                message: `Sent test SMS to ${maskPhoneNumber(to)} via ${resolved.provider} (id=${result.messageId ?? result.id}).`
+              };
+            } catch (err) {
+              return { ok: false, severity: "error", message: err?.message ?? String(err) };
+            }
+          });
+        }
+      } catch {
+      }
+    });
+  }
+  /**
+   * Translate the `sms` settings snapshot into a transport and hot-swap it
+   * on the running SmsService. Incomplete credentials keep the previous
+   * transport (with a warning) so a half-saved form can't break delivery.
+   */
+  applySmsSettings(values, ctx) {
+    if (!this.service) return;
+    const resolved = providerFromSettings(values);
+    if (resolved.missing) {
+      ctx.logger.warn(
+        `SmsServicePlugin: provider='${resolved.provider}' selected but ${resolved.missing} is empty \u2014 transport NOT rebuilt.`
+      );
+      return;
+    }
+    if (resolved.provider === "log") {
+      if (values.provider === "log") {
+        this.service.setTransport(new LogSmsTransport(ctx.logger), false);
+        ctx.logger.info("SmsServicePlugin: sms settings applied (provider=log; SMS will NOT be sent).");
+      }
+      return;
+    }
+    try {
+      const transport = makeSmsTransport({ provider: resolved.provider, options: resolved.options, logger: ctx.logger });
+      this.service.setTransport(transport, true);
+      ctx.logger.info(`SmsServicePlugin: transport rebuilt from settings (provider=${resolved.provider}).`);
+    } catch (err) {
+      ctx.logger.warn("SmsServicePlugin: failed to rebuild transport: " + (err?.message ?? err));
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AliyunSmsTransport,
+  LogSmsTransport,
+  SmsService,
+  SmsServicePlugin,
+  TwilioSmsTransport,
+  makeSmsTransport,
+  maskPhoneNumber,
+  normalizeSmsRecipient
+});
+//# sourceMappingURL=index.js.map