@amirhosseinnouri/send 1.0.0-2

package/dist/index.js

@@ -0,0 +1,318 @@
+// src/providers/element.ts
+import { marked } from "marked";
+var ElementSender = class {
+  name = "Element";
+  homeserverUrl;
+  accessToken;
+  roomId;
+  constructor(config) {
+    this.homeserverUrl = config.homeserverUrl;
+    this.accessToken = config.accessToken;
+    this.roomId = config.roomId;
+  }
+  async send(message) {
+    const lines = [];
+    if (message.title) {
+      lines.push(message.markdown ? `**${message.title}**` : message.title, "");
+    }
+    lines.push(message.body);
+    const body = lines.join("\n");
+    const formatted = message.markdown ? {
+      format: "org.matrix.custom.html",
+      formatted_body: await marked.parse(body, { async: true })
+    } : {};
+    const txnId = `send-${Date.now()}`;
+    const encodedRoomId = encodeURIComponent(this.roomId);
+    const url = `${this.homeserverUrl}/_matrix/client/v3/rooms/${encodedRoomId}/send/m.room.message/${txnId}`;
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.accessToken}`
+        },
+        body: JSON.stringify({
+          msgtype: "m.text",
+          body,
+          ...formatted
+        })
+      });
+    } catch (error) {
+      const cause = error instanceof Error ? error.cause ?? error.message : error;
+      throw new Error(`Element fetch failed: ${JSON.stringify(cause)}`);
+    }
+    if (!response.ok) {
+      const responseBody = await response.text();
+      throw new Error(
+        `Element API returned status ${response.status}: ${responseBody}`
+      );
+    }
+  }
+};
+
+// src/providers/mattermost.ts
+var MattermostSender = class {
+  name = "Mattermost";
+  webhookUrl;
+  constructor(config) {
+    this.webhookUrl = config.webhookUrl;
+  }
+  /** Mattermost always renders markdown; escape special chars for plain bodies. */
+  escapeMarkdown(text) {
+    return text.replace(/([\\`*_{}[\]()#+\-.!|>~])/g, "\\$1");
+  }
+  async send(message) {
+    const summary = message.title ?? message.body;
+    const body = message.markdown ? message.body : this.escapeMarkdown(message.body);
+    const payload = {
+      text: message.title ? `#### ${message.title}` : "",
+      attachments: [
+        {
+          fallback: summary,
+          color: "#2eb886",
+          text: body
+        }
+      ]
+    };
+    const response = await fetch(this.webhookUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const body2 = await response.text();
+      throw new Error(
+        `Mattermost webhook returned status ${response.status}: ${body2}`
+      );
+    }
+  }
+};
+
+// src/providers/slack.ts
+var SlackSender = class {
+  name = "Slack";
+  webhookUrl;
+  constructor(config) {
+    this.webhookUrl = config.webhookUrl;
+  }
+  async send(message) {
+    const summary = message.title ?? message.body;
+    const blocks = [];
+    if (message.title) {
+      blocks.push({
+        type: "header",
+        text: { type: "plain_text", text: message.title }
+      });
+    }
+    blocks.push({ type: "divider" });
+    blocks.push({
+      type: "section",
+      text: {
+        type: message.markdown ? "mrkdwn" : "plain_text",
+        text: message.body
+      }
+    });
+    const payload = { text: summary, blocks };
+    const response = await fetch(this.webhookUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `Slack webhook returned status ${response.status}: ${body}`
+      );
+    }
+  }
+};
+
+// src/providers/teams.ts
+var TeamsSender = class {
+  name = "Microsoft Teams";
+  webhookUrl;
+  constructor(config) {
+    this.webhookUrl = config.webhookUrl;
+  }
+  async send(message) {
+    const summary = message.title ?? message.body;
+    const messageCard = {
+      "@type": "MessageCard",
+      "@context": "https://schema.org/extensions",
+      themeColor: "0078D7",
+      summary,
+      sections: [
+        {
+          activityTitle: message.title,
+          text: message.body,
+          markdown: message.markdown ?? false
+        }
+      ]
+    };
+    const response = await fetch(this.webhookUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(messageCard)
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Teams webhook returned status ${response.status}: ${response.statusText}`
+      );
+    }
+  }
+};
+
+// src/providers/telegram.ts
+var TelegramSender = class {
+  name = "Telegram";
+  botToken;
+  chatId;
+  constructor(config) {
+    this.botToken = config.botToken;
+    this.chatId = config.chatId;
+  }
+  escapeMarkdown(text) {
+    return text.replace(/([*_`[])/g, "\\$1");
+  }
+  async send(message) {
+    const lines = [];
+    if (message.markdown) {
+      if (message.title) {
+        lines.push(`*${this.escapeMarkdown(message.title)}*`, "");
+      }
+      lines.push(message.body);
+    } else {
+      if (message.title) lines.push(message.title, "");
+      lines.push(message.body);
+    }
+    const text = lines.join("\n");
+    const url = `https://api.telegram.org/bot${this.botToken}/sendMessage`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        chat_id: this.chatId,
+        text,
+        ...message.markdown ? { parse_mode: "Markdown" } : {}
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `Telegram API returned status ${response.status}: ${body}`
+      );
+    }
+  }
+};
+
+// src/providers/index.ts
+var PROVIDERS = [
+  "slack",
+  "teams",
+  "mattermost",
+  "telegram",
+  "element"
+];
+function createSender(config) {
+  switch (config.provider) {
+    case "slack":
+      return new SlackSender(config);
+    case "teams":
+      return new TeamsSender(config);
+    case "mattermost":
+      return new MattermostSender(config);
+    case "telegram":
+      return new TelegramSender(config);
+    case "element":
+      return new ElementSender(config);
+  }
+}
+
+// src/schema/element.ts
+import { z } from "zod";
+var elementConfigSchema = z.object({
+  provider: z.literal("element"),
+  homeserverUrl: z.url(),
+  accessToken: z.string(),
+  roomId: z.string()
+});
+
+// src/schema/mattermost.ts
+import { z as z2 } from "zod";
+var mattermostConfigSchema = z2.object({
+  provider: z2.literal("mattermost"),
+  webhookUrl: z2.url()
+});
+
+// src/schema/sender.ts
+import { z as z6 } from "zod";
+
+// src/schema/slack.ts
+import { z as z3 } from "zod";
+var slackConfigSchema = z3.object({
+  provider: z3.literal("slack"),
+  webhookUrl: z3.url()
+});
+
+// src/schema/teams.ts
+import { z as z4 } from "zod";
+var teamsConfigSchema = z4.object({
+  provider: z4.literal("teams"),
+  webhookUrl: z4.url()
+});
+
+// src/schema/telegram.ts
+import { z as z5 } from "zod";
+var telegramConfigSchema = z5.object({
+  provider: z5.literal("telegram"),
+  botToken: z5.string(),
+  chatId: z5.string()
+});
+
+// src/schema/sender.ts
+var messageSchema = z6.object({
+  title: z6.string().optional(),
+  body: z6.string(),
+  /** Render the body as markdown in the provider's native format. */
+  markdown: z6.boolean().optional()
+});
+var senderConfigSchema = z6.discriminatedUnion("provider", [
+  slackConfigSchema,
+  teamsConfigSchema,
+  mattermostConfigSchema,
+  telegramConfigSchema,
+  elementConfigSchema
+]);
+var sendInputSchema = z6.intersection(
+  senderConfigSchema,
+  messageSchema
+);
+var providerConfigSchemas = {
+  slack: slackConfigSchema,
+  teams: teamsConfigSchema,
+  mattermost: mattermostConfigSchema,
+  telegram: telegramConfigSchema,
+  element: elementConfigSchema
+};
+
+// src/index.ts
+async function send(input) {
+  const { title, body, markdown, ...config } = input;
+  const message = { title, body, markdown };
+  await createSender(config).send(message);
+}
+export {
+  PROVIDERS,
+  createSender,
+  elementConfigSchema,
+  mattermostConfigSchema,
+  messageSchema,
+  providerConfigSchemas,
+  send,
+  sendInputSchema,
+  senderConfigSchema,
+  slackConfigSchema,
+  teamsConfigSchema,
+  telegramConfigSchema
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@amirhosseinnouri/send",
+  "version": "1.0.0-2",
+  "description": "Send a structured message to chat providers (Slack, Teams, Telegram, Element, Mattermost) from code or the CLI.",
+  "type": "module",
+  "bin": {
+    "send": "dist/cli.cjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "NODE_ENV=production tsup",
+    "test": "bun test",
+    "check": "biome check .",
+    "check:fix": "biome check --write ."
+  },
+  "keywords": [
+    "slack",
+    "teams",
+    "telegram",
+    "element",
+    "matrix",
+    "mattermost",
+    "webhook",
+    "notification",
+    "cli"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "command-line-args": "^6.0.2",
+    "marked": "^18.0.2",
+    "zod": "^4.1.8"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.3.8",
+    "@types/bun": "latest",
+    "@types/command-line-args": "^5.2.3",
+    "@types/node": "^25.6.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}