nonotify 0.1.4 → 0.1.6

package/README.md

@@ -14,7 +14,7 @@ After install, `nnt` is available globally.
 
 ## Config location
 
-- Default: `~/.nnt/config`
+- Default: `~/.config/nnt/nnt.json`
 - Override: set `NNT_CONFIG_DIR`
 
 Example:
@@ -23,7 +23,7 @@ Example:
 export NNT_CONFIG_DIR="$HOME/.config/nnt"
 ```
 
-Config is stored as JSON in `<config-dir>/config`.
+Config is stored as JSON in `<config-dir>/nnt.json`.
 
 ## Add profile
 
@@ -116,3 +116,41 @@ nnt send "some message for user" --profile=important-profile
 ```bash
 nnt "Task finished: migrations applied and tests passed"
 ```
+
+## Node.js API
+
+`Notifier` loads config using `EnvConfigLoader` by default.
+
+```ts
+import { Notifier } from "nonotify";
+
+const notifier = new Notifier();
+
+await notifier.send({
+  message: "Build finished successfully",
+});
+```
+
+Also you can pass profile data directly.
+
+```ts
+import { Notifier } from "nonotify";
+
+const notifier = new Notifier({
+  defaultProfile: "dev",
+  profiles: [
+    {
+      name: "dev",
+      botToken: process.env.TELEGRAM_BOT_TOKEN!,
+      chatId: process.env.TELEGRAM_CHAT_ID!,
+    },
+  ],
+});
+
+await notifier.send({
+  profile: "dev",
+  message: "Task completed",
+});
+
+console.log(notifier.profiles);
+```

package/dist/cli.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { Cli } from "incur";
+declare const cli: Cli.Cli<{
+    send: {
+        args: {
+            message: string;
+        };
+        options: {
+            profile?: string | undefined;
+        };
+    };
+} & {}, undefined, undefined>;
+export default cli;

package/dist/cli.js

@@ -4,6 +4,7 @@ import { askConfirm, askRequired, askRequiredWithInitial, askSelect, } from "./p
 import { getConfigPath, loadConfig, saveConfig } from "./config.js";
 import { printKeyValueTable, printProfilesTable } from "./display.js";
 import { getLatestUpdateOffset, sendTelegramMessage, waitForChatId, } from "./telegram.js";
+import { Notifier } from "./notifier.js";
 const profileCli = Cli.create("profile", {
     description: "Manage notification profiles",
 });
@@ -335,21 +336,11 @@ const cli = Cli.create("nnt", {
         profile: "p",
     },
     async run(c) {
-        const config = await loadConfig();
-        const profileName = c.options.profile ?? config.defaultProfile;
-        if (!profileName) {
-            throw new Error("No default profile found. Run `nnt profile add` first.");
-        }
-        const profile = config.profiles[profileName];
-        if (!profile) {
-            throw new Error(`Profile "${profileName}" not found.`);
-        }
-        await sendTelegramMessage(profile.botToken, profile.chatId, c.args.message);
-        return {
-            sent: true,
-            profile: profileName,
-            provider: profile.type,
-        };
+        const notifier = new Notifier();
+        return notifier.send({
+            message: c.args.message,
+            profile: c.options.profile,
+        });
     },
 })
     .command(profileCli);

package/dist/config.d.ts

@@ -0,0 +1,16 @@
+export type TelegramProfile = {
+    type: "telegram";
+    name: string;
+    botToken: string;
+    chatId: string;
+    createdAt: string;
+};
+export type NntConfig = {
+    defaultProfile: string | null;
+    profiles: Record<string, TelegramProfile>;
+};
+export declare function getConfigDir(): string;
+export declare function getConfigPath(): string;
+export declare function getLegacyConfigPath(): string;
+export declare function loadConfig(): Promise<NntConfig>;
+export declare function saveConfig(config: NntConfig): Promise<void>;

package/dist/config.js

@@ -5,31 +5,47 @@ const DEFAULT_CONFIG = {
     defaultProfile: null,
     profiles: {},
 };
+const CONFIG_FILENAME = "nnt.json";
+const DEFAULT_CONFIG_DIR = join(homedir(), ".config", "nnt");
+const LEGACY_CONFIG_PATH = join(homedir(), ".nnt", "config");
 export function getConfigDir() {
     const dir = process.env.NNT_CONFIG_DIR;
     if (dir && dir.trim() !== "") {
         return resolve(dir);
     }
-    return join(homedir(), ".nnt");
+    return DEFAULT_CONFIG_DIR;
 }
 export function getConfigPath() {
-    return join(getConfigDir(), "config");
+    return join(getConfigDir(), CONFIG_FILENAME);
+}
+export function getLegacyConfigPath() {
+    return LEGACY_CONFIG_PATH;
 }
 export async function loadConfig() {
     const path = getConfigPath();
     try {
         const raw = await readFile(path, "utf8");
-        const parsed = JSON.parse(raw);
-        return {
-            defaultProfile: typeof parsed.defaultProfile === "string"
-                ? parsed.defaultProfile
-                : null,
-            profiles: parsed.profiles ?? {},
-        };
+        return parseConfig(raw);
     }
     catch (error) {
         if (isNodeError(error) && error.code === "ENOENT") {
-            return { ...DEFAULT_CONFIG };
+            try {
+                const legacyRaw = await readFile(getLegacyConfigPath(), "utf8");
+                const parsed = parseConfig(legacyRaw);
+                try {
+                    await saveConfig(parsed);
+                }
+                catch {
+                    // Best effort migration only.
+                }
+                return parsed;
+            }
+            catch (legacyError) {
+                if (isNodeError(legacyError) && legacyError.code === "ENOENT") {
+                    return { ...DEFAULT_CONFIG };
+                }
+                throw legacyError;
+            }
         }
         throw error;
     }
@@ -51,3 +67,10 @@ export async function saveConfig(config) {
 function isNodeError(error) {
     return typeof error === "object" && error !== null && "code" in error;
 }
+function parseConfig(raw) {
+    const parsed = JSON.parse(raw);
+    return {
+        defaultProfile: typeof parsed.defaultProfile === "string" ? parsed.defaultProfile : null,
+        profiles: parsed.profiles ?? {},
+    };
+}

package/dist/display.d.ts

@@ -0,0 +1,11 @@
+type ProfileRow = {
+    name: string;
+    provider: string;
+    isDefault: boolean;
+};
+export declare function printProfilesTable(rows: ProfileRow[]): void;
+export declare function printKeyValueTable(title: string, rows: Array<{
+    key: string;
+    value: string;
+}>): void;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { EnvConfigLoader, NoProfilesConfiguredError, Notifier, NotifierError, ProfileNotFoundError, } from "./notifier.js";
+export type { NotifierConfig, NotifierConfigLoader, NotifierProfile, NotifierProfileInput, SendInput, SendResult, } from "./notifier.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { EnvConfigLoader, NoProfilesConfiguredError, Notifier, NotifierError, ProfileNotFoundError, } from "./notifier.js";

package/dist/notifier.d.ts

@@ -0,0 +1,49 @@
+export type NotifierProfile = {
+    type: "telegram";
+    name: string;
+    botToken: string;
+    chatId: string;
+};
+export type NotifierProfileInput = {
+    type?: "telegram";
+    name: string;
+    botToken: string;
+    chatId: string;
+};
+export type NotifierConfig = {
+    profiles: NotifierProfileInput[];
+    defaultProfile?: string | null;
+};
+export interface NotifierConfigLoader {
+    load(): NotifierConfig;
+}
+export type SendInput = {
+    message: string;
+    profile?: string;
+};
+export type SendResult = {
+    sent: true;
+    profile: string;
+    provider: "telegram";
+};
+export declare class NotifierError extends Error {
+    constructor(message: string);
+}
+export declare class ProfileNotFoundError extends NotifierError {
+    readonly profile: string;
+    constructor(profile: string);
+}
+export declare class NoProfilesConfiguredError extends NotifierError {
+    constructor();
+}
+export declare class EnvConfigLoader implements NotifierConfigLoader {
+    load(): NotifierConfig;
+}
+export declare class Notifier {
+    readonly profiles: readonly Readonly<NotifierProfile>[];
+    private readonly defaultProfile;
+    private readonly profilesByName;
+    constructor(source?: NotifierConfig | NotifierConfigLoader);
+    send(input: SendInput): Promise<SendResult>;
+    private resolveProfile;
+}

package/dist/notifier.js

@@ -0,0 +1,171 @@
+import { readFileSync } from "node:fs";
+import { getConfigPath, getLegacyConfigPath } from "./config.js";
+import { sendTelegramMessage } from "./telegram.js";
+export class NotifierError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "NotifierError";
+    }
+}
+export class ProfileNotFoundError extends NotifierError {
+    profile;
+    constructor(profile) {
+        super(`Profile "${profile}" not found.`);
+        this.name = "ProfileNotFoundError";
+        this.profile = profile;
+    }
+}
+export class NoProfilesConfiguredError extends NotifierError {
+    constructor() {
+        super("No profiles configured. Run `nnt profile add` first.");
+        this.name = "NoProfilesConfiguredError";
+    }
+}
+export class EnvConfigLoader {
+    load() {
+        const configPaths = Array.from(new Set([getConfigPath(), getLegacyConfigPath()]));
+        for (const configPath of configPaths) {
+            try {
+                const raw = readFileSync(configPath, "utf8");
+                const rawConfig = JSON.parse(raw);
+                return normalizeEnvConfig(rawConfig);
+            }
+            catch (error) {
+                if (isNodeError(error) && error.code === "ENOENT") {
+                    continue;
+                }
+                if (error instanceof SyntaxError) {
+                    throw new NotifierError(`Invalid JSON in config file at ${configPath}: ${error.message}`);
+                }
+                throw error;
+            }
+        }
+        return {
+            profiles: [],
+            defaultProfile: null,
+        };
+    }
+}
+export class Notifier {
+    profiles;
+    defaultProfile;
+    profilesByName;
+    constructor(source = new EnvConfigLoader()) {
+        const config = isConfigLoader(source) ? source.load() : source;
+        const normalized = normalizeNotifierConfig(config);
+        const frozenProfiles = normalized.profiles.map((profile) => Object.freeze({ ...profile }));
+        this.profiles = Object.freeze(frozenProfiles);
+        this.defaultProfile = normalized.defaultProfile;
+        this.profilesByName = new Map(frozenProfiles.map((profile) => [profile.name, profile]));
+    }
+    async send(input) {
+        const message = input.message.trim();
+        if (message === "") {
+            throw new NotifierError("Message cannot be empty.");
+        }
+        const selectedProfile = this.resolveProfile(input.profile);
+        await sendTelegramMessage(selectedProfile.botToken, selectedProfile.chatId, message);
+        return {
+            sent: true,
+            profile: selectedProfile.name,
+            provider: selectedProfile.type,
+        };
+    }
+    resolveProfile(profileName) {
+        if (profileName) {
+            const profile = this.profilesByName.get(profileName);
+            if (!profile) {
+                throw new ProfileNotFoundError(profileName);
+            }
+            return profile;
+        }
+        if (this.defaultProfile) {
+            const defaultProfile = this.profilesByName.get(this.defaultProfile);
+            if (defaultProfile) {
+                return defaultProfile;
+            }
+        }
+        const firstProfile = this.profiles[0];
+        if (!firstProfile) {
+            throw new NoProfilesConfiguredError();
+        }
+        return firstProfile;
+    }
+}
+function normalizeEnvConfig(raw) {
+    return {
+        defaultProfile: typeof raw.defaultProfile === "string" ? raw.defaultProfile : null,
+        profiles: normalizeProfilesFromUnknown(raw.profiles),
+    };
+}
+function normalizeProfilesFromUnknown(rawProfiles) {
+    if (!rawProfiles) {
+        return [];
+    }
+    if (Array.isArray(rawProfiles)) {
+        return rawProfiles.map((profile, index) => normalizeSingleProfile(profile, `profiles[${index}]`));
+    }
+    if (typeof rawProfiles === "object") {
+        const entries = Object.entries(rawProfiles);
+        return entries.map(([name, profile]) => normalizeRecordProfile(name, profile, `profiles.${name}`));
+    }
+    throw new NotifierError("Invalid config format: `profiles` must be an array or object.");
+}
+function normalizeNotifierConfig(input) {
+    if (!Array.isArray(input.profiles)) {
+        throw new NotifierError("Invalid Notifier config: `profiles` must be an array.");
+    }
+    const profiles = input.profiles.map((profile, index) => normalizeSingleProfile(profile, `profiles[${index}]`));
+    const names = new Set();
+    for (const profile of profiles) {
+        if (names.has(profile.name)) {
+            throw new NotifierError(`Invalid Notifier config: duplicate profile name "${profile.name}".`);
+        }
+        names.add(profile.name);
+    }
+    return {
+        profiles,
+        defaultProfile: typeof input.defaultProfile === "string" ? input.defaultProfile : null,
+    };
+}
+function normalizeRecordProfile(profileName, rawProfile, sourceLabel) {
+    if (!rawProfile || typeof rawProfile !== "object") {
+        throw new NotifierError(`Invalid profile at ${sourceLabel}: expected an object.`);
+    }
+    return {
+        type: "telegram",
+        name: profileName,
+        botToken: requireNonEmptyString(rawProfile.botToken, `${sourceLabel}.botToken`),
+        chatId: requireNonEmptyString(rawProfile.chatId, `${sourceLabel}.chatId`),
+    };
+}
+function normalizeSingleProfile(rawProfile, sourceLabel) {
+    if (!rawProfile || typeof rawProfile !== "object") {
+        throw new NotifierError(`Invalid profile at ${sourceLabel}: expected an object.`);
+    }
+    const profile = rawProfile;
+    if (profile.type !== undefined && profile.type !== "telegram") {
+        throw new NotifierError(`Invalid profile at ${sourceLabel}.type: only "telegram" is supported.`);
+    }
+    return {
+        type: "telegram",
+        name: requireNonEmptyString(profile.name, `${sourceLabel}.name`),
+        botToken: requireNonEmptyString(profile.botToken, `${sourceLabel}.botToken`),
+        chatId: requireNonEmptyString(profile.chatId, `${sourceLabel}.chatId`),
+    };
+}
+function requireNonEmptyString(value, label) {
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new NotifierError(`Invalid value for ${label}: expected non-empty string.`);
+    }
+    return value.trim();
+}
+function isConfigLoader(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "load" in value &&
+        typeof value.load === "function");
+}
+function isNodeError(error) {
+    return typeof error === "object" && error !== null && "code" in error;
+}

package/dist/prompt.d.ts

@@ -0,0 +1,11 @@
+export declare function askRequired(question: string): Promise<string>;
+export declare function askRequiredWithInitial(question: string, initialValue?: string): Promise<string>;
+export declare function askConfirm(question: string, initialValue?: boolean): Promise<boolean>;
+type SelectOption = {
+    value: string;
+    label: string;
+    hint?: string;
+    disabled?: boolean;
+};
+export declare function askSelect(question: string, options: SelectOption[]): Promise<string>;
+export {};

package/dist/telegram.d.ts

@@ -0,0 +1,7 @@
+export type TelegramConnection = {
+    chatId: string;
+    username: string | null;
+};
+export declare function getLatestUpdateOffset(botToken: string): Promise<number>;
+export declare function waitForChatId(botToken: string, offset: number, timeoutSeconds?: number): Promise<TelegramConnection>;
+export declare function sendTelegramMessage(botToken: string, chatId: string, text: string): Promise<void>;

package/package.json

@@ -1,8 +1,17 @@
 {
   "name": "nonotify",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "nnt CLI for Telegram notifications",
   "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "bin": {
     "nnt": "./dist/cli.js"
   },

package/src/cli.ts

@@ -14,6 +14,7 @@ import {
   sendTelegramMessage,
   waitForChatId,
 } from "./telegram.js";
+import { Notifier } from "./notifier.js";
 
 const profileCli = Cli.create("profile", {
   description: "Manage notification profiles",
@@ -442,32 +443,12 @@ const cli = Cli.create("nnt", {
       profile: "p",
     },
     async run(c) {
-      const config = await loadConfig();
-      const profileName = c.options.profile ?? config.defaultProfile;
+      const notifier = new Notifier();
 
-      if (!profileName) {
-        throw new Error(
-          "No default profile found. Run `nnt profile add` first.",
-        );
-      }
-
-      const profile = config.profiles[profileName];
-
-      if (!profile) {
-        throw new Error(`Profile "${profileName}" not found.`);
-      }
-
-      await sendTelegramMessage(
-        profile.botToken,
-        profile.chatId,
-        c.args.message,
-      );
-
-      return {
-        sent: true,
-        profile: profileName,
-        provider: profile.type,
-      };
+      return notifier.send({
+        message: c.args.message,
+        profile: c.options.profile,
+      });
     },
   })
   .command(profileCli);

package/src/config.ts

@@ -20,17 +20,25 @@ const DEFAULT_CONFIG: NntConfig = {
   profiles: {},
 };
 
+const CONFIG_FILENAME = "nnt.json";
+const DEFAULT_CONFIG_DIR = join(homedir(), ".config", "nnt");
+const LEGACY_CONFIG_PATH = join(homedir(), ".nnt", "config");
+
 export function getConfigDir(): string {
   const dir = process.env.NNT_CONFIG_DIR;
   if (dir && dir.trim() !== "") {
     return resolve(dir);
   }
 
-  return join(homedir(), ".nnt");
+  return DEFAULT_CONFIG_DIR;
 }
 
 export function getConfigPath(): string {
-  return join(getConfigDir(), "config");
+  return join(getConfigDir(), CONFIG_FILENAME);
+}
+
+export function getLegacyConfigPath(): string {
+  return LEGACY_CONFIG_PATH;
 }
 
 export async function loadConfig(): Promise<NntConfig> {
@@ -38,18 +46,27 @@ export async function loadConfig(): Promise<NntConfig> {
 
   try {
     const raw = await readFile(path, "utf8");
-    const parsed = JSON.parse(raw) as Partial<NntConfig>;
-
-    return {
-      defaultProfile:
-        typeof parsed.defaultProfile === "string"
-          ? parsed.defaultProfile
-          : null,
-      profiles: parsed.profiles ?? {},
-    };
+    return parseConfig(raw);
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
-      return { ...DEFAULT_CONFIG };
+      try {
+        const legacyRaw = await readFile(getLegacyConfigPath(), "utf8");
+        const parsed = parseConfig(legacyRaw);
+
+        try {
+          await saveConfig(parsed);
+        } catch {
+          // Best effort migration only.
+        }
+
+        return parsed;
+      } catch (legacyError) {
+        if (isNodeError(legacyError) && legacyError.code === "ENOENT") {
+          return { ...DEFAULT_CONFIG };
+        }
+
+        throw legacyError;
+      }
     }
 
     throw error;
@@ -75,3 +92,13 @@ export async function saveConfig(config: NntConfig): Promise<void> {
 function isNodeError(error: unknown): error is NodeJS.ErrnoException {
   return typeof error === "object" && error !== null && "code" in error;
 }
+
+function parseConfig(raw: string): NntConfig {
+  const parsed = JSON.parse(raw) as Partial<NntConfig>;
+
+  return {
+    defaultProfile:
+      typeof parsed.defaultProfile === "string" ? parsed.defaultProfile : null,
+    profiles: parsed.profiles ?? {},
+  };
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+export {
+  EnvConfigLoader,
+  NoProfilesConfiguredError,
+  Notifier,
+  NotifierError,
+  ProfileNotFoundError,
+} from "./notifier.js";
+export type {
+  NotifierConfig,
+  NotifierConfigLoader,
+  NotifierProfile,
+  NotifierProfileInput,
+  SendInput,
+  SendResult,
+} from "./notifier.js";

package/src/notifier.ts

@@ -0,0 +1,326 @@
+import { readFileSync } from "node:fs";
+import { getConfigPath, getLegacyConfigPath } from "./config.js";
+import { sendTelegramMessage } from "./telegram.js";
+
+export type NotifierProfile = {
+  type: "telegram";
+  name: string;
+  botToken: string;
+  chatId: string;
+};
+
+export type NotifierProfileInput = {
+  type?: "telegram";
+  name: string;
+  botToken: string;
+  chatId: string;
+};
+
+export type NotifierConfig = {
+  profiles: NotifierProfileInput[];
+  defaultProfile?: string | null;
+};
+
+export interface NotifierConfigLoader {
+  load(): NotifierConfig;
+}
+
+export type SendInput = {
+  message: string;
+  profile?: string;
+};
+
+export type SendResult = {
+  sent: true;
+  profile: string;
+  provider: "telegram";
+};
+
+export class NotifierError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "NotifierError";
+  }
+}
+
+export class ProfileNotFoundError extends NotifierError {
+  readonly profile: string;
+
+  constructor(profile: string) {
+    super(`Profile "${profile}" not found.`);
+    this.name = "ProfileNotFoundError";
+    this.profile = profile;
+  }
+}
+
+export class NoProfilesConfiguredError extends NotifierError {
+  constructor() {
+    super("No profiles configured. Run `nnt profile add` first.");
+    this.name = "NoProfilesConfiguredError";
+  }
+}
+
+type RawEnvConfig = {
+  defaultProfile?: unknown;
+  profiles?: unknown;
+};
+
+type RawRecordProfile = {
+  type?: unknown;
+  name?: unknown;
+  botToken?: unknown;
+  chatId?: unknown;
+};
+
+export class EnvConfigLoader implements NotifierConfigLoader {
+  load(): NotifierConfig {
+    const configPaths = Array.from(
+      new Set([getConfigPath(), getLegacyConfigPath()]),
+    );
+
+    for (const configPath of configPaths) {
+      try {
+        const raw = readFileSync(configPath, "utf8");
+        const rawConfig = JSON.parse(raw) as RawEnvConfig;
+        return normalizeEnvConfig(rawConfig);
+      } catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+          continue;
+        }
+
+        if (error instanceof SyntaxError) {
+          throw new NotifierError(
+            `Invalid JSON in config file at ${configPath}: ${error.message}`,
+          );
+        }
+
+        throw error;
+      }
+    }
+
+    return {
+      profiles: [],
+      defaultProfile: null,
+    };
+  }
+}
+
+export class Notifier {
+  readonly profiles: readonly Readonly<NotifierProfile>[];
+  private readonly defaultProfile: string | null;
+  private readonly profilesByName: ReadonlyMap<
+    string,
+    Readonly<NotifierProfile>
+  >;
+
+  constructor(
+    source: NotifierConfig | NotifierConfigLoader = new EnvConfigLoader(),
+  ) {
+    const config = isConfigLoader(source) ? source.load() : source;
+    const normalized = normalizeNotifierConfig(config);
+    const frozenProfiles = normalized.profiles.map((profile) =>
+      Object.freeze({ ...profile }),
+    );
+
+    this.profiles = Object.freeze(frozenProfiles);
+    this.defaultProfile = normalized.defaultProfile;
+    this.profilesByName = new Map(
+      frozenProfiles.map((profile) => [profile.name, profile]),
+    );
+  }
+
+  async send(input: SendInput): Promise<SendResult> {
+    const message = input.message.trim();
+
+    if (message === "") {
+      throw new NotifierError("Message cannot be empty.");
+    }
+
+    const selectedProfile = this.resolveProfile(input.profile);
+
+    await sendTelegramMessage(
+      selectedProfile.botToken,
+      selectedProfile.chatId,
+      message,
+    );
+
+    return {
+      sent: true,
+      profile: selectedProfile.name,
+      provider: selectedProfile.type,
+    };
+  }
+
+  private resolveProfile(profileName?: string): Readonly<NotifierProfile> {
+    if (profileName) {
+      const profile = this.profilesByName.get(profileName);
+
+      if (!profile) {
+        throw new ProfileNotFoundError(profileName);
+      }
+
+      return profile;
+    }
+
+    if (this.defaultProfile) {
+      const defaultProfile = this.profilesByName.get(this.defaultProfile);
+      if (defaultProfile) {
+        return defaultProfile;
+      }
+    }
+
+    const firstProfile = this.profiles[0];
+
+    if (!firstProfile) {
+      throw new NoProfilesConfiguredError();
+    }
+
+    return firstProfile;
+  }
+}
+
+function normalizeEnvConfig(raw: RawEnvConfig): NotifierConfig {
+  return {
+    defaultProfile:
+      typeof raw.defaultProfile === "string" ? raw.defaultProfile : null,
+    profiles: normalizeProfilesFromUnknown(raw.profiles),
+  };
+}
+
+function normalizeProfilesFromUnknown(rawProfiles: unknown): NotifierProfile[] {
+  if (!rawProfiles) {
+    return [];
+  }
+
+  if (Array.isArray(rawProfiles)) {
+    return rawProfiles.map((profile, index) =>
+      normalizeSingleProfile(profile, `profiles[${index}]`),
+    );
+  }
+
+  if (typeof rawProfiles === "object") {
+    const entries = Object.entries(
+      rawProfiles as Record<string, RawRecordProfile>,
+    );
+
+    return entries.map(([name, profile]) =>
+      normalizeRecordProfile(name, profile, `profiles.${name}`),
+    );
+  }
+
+  throw new NotifierError(
+    "Invalid config format: `profiles` must be an array or object.",
+  );
+}
+
+function normalizeNotifierConfig(input: NotifierConfig): {
+  profiles: NotifierProfile[];
+  defaultProfile: string | null;
+} {
+  if (!Array.isArray(input.profiles)) {
+    throw new NotifierError(
+      "Invalid Notifier config: `profiles` must be an array.",
+    );
+  }
+
+  const profiles = input.profiles.map((profile, index) =>
+    normalizeSingleProfile(profile, `profiles[${index}]`),
+  );
+
+  const names = new Set<string>();
+
+  for (const profile of profiles) {
+    if (names.has(profile.name)) {
+      throw new NotifierError(
+        `Invalid Notifier config: duplicate profile name "${profile.name}".`,
+      );
+    }
+
+    names.add(profile.name);
+  }
+
+  return {
+    profiles,
+    defaultProfile:
+      typeof input.defaultProfile === "string" ? input.defaultProfile : null,
+  };
+}
+
+function normalizeRecordProfile(
+  profileName: string,
+  rawProfile: RawRecordProfile,
+  sourceLabel: string,
+): NotifierProfile {
+  if (!rawProfile || typeof rawProfile !== "object") {
+    throw new NotifierError(
+      `Invalid profile at ${sourceLabel}: expected an object.`,
+    );
+  }
+
+  return {
+    type: "telegram",
+    name: profileName,
+    botToken: requireNonEmptyString(
+      rawProfile.botToken,
+      `${sourceLabel}.botToken`,
+    ),
+    chatId: requireNonEmptyString(rawProfile.chatId, `${sourceLabel}.chatId`),
+  };
+}
+
+function normalizeSingleProfile(
+  rawProfile: unknown,
+  sourceLabel: string,
+): NotifierProfile {
+  if (!rawProfile || typeof rawProfile !== "object") {
+    throw new NotifierError(
+      `Invalid profile at ${sourceLabel}: expected an object.`,
+    );
+  }
+
+  const profile = rawProfile as {
+    type?: unknown;
+    name?: unknown;
+    botToken?: unknown;
+    chatId?: unknown;
+  };
+
+  if (profile.type !== undefined && profile.type !== "telegram") {
+    throw new NotifierError(
+      `Invalid profile at ${sourceLabel}.type: only "telegram" is supported.`,
+    );
+  }
+
+  return {
+    type: "telegram",
+    name: requireNonEmptyString(profile.name, `${sourceLabel}.name`),
+    botToken: requireNonEmptyString(
+      profile.botToken,
+      `${sourceLabel}.botToken`,
+    ),
+    chatId: requireNonEmptyString(profile.chatId, `${sourceLabel}.chatId`),
+  };
+}
+
+function requireNonEmptyString(value: unknown, label: string): string {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new NotifierError(
+      `Invalid value for ${label}: expected non-empty string.`,
+    );
+  }
+
+  return value.trim();
+}
+
+function isConfigLoader(value: unknown): value is NotifierConfigLoader {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "load" in value &&
+    typeof (value as { load: unknown }).load === "function"
+  );
+}
+
+function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+  return typeof error === "object" && error !== null && "code" in error;
+}

package/tsconfig.json

@@ -8,6 +8,7 @@
     "resolveJsonModule": true,
     "esModuleInterop": true,
     "forceConsistentCasingInFileNames": true,
+    "declaration": true,
     "outDir": "dist",
     "rootDir": "src"
   },