Posting Messages

chat.onNewMention(async (thread, message) => {
  // Simple string
  await thread.post("Hello world!");
  
  // With emoji
  await thread.post(`${emoji.thumbs_up} Great job!`);
});

await thread.post({
  markdown: `
**Bold** and _italic_ text

- List item 1
- List item 2

[Link](https://example.com)
  `.trim()
});

// Slack mrkdwn format
await thread.post({
  raw: "*Bold* and _italic_ in Slack format"
});

import { root, paragraph, text, strong, link } from "chat";

await thread.post({
  ast: root([
    paragraph([
      strong([text("Bold text")]),
      text(" and "),
      link("https://example.com", [text("a link")])
    ])
  ])
});

import { Card, Text, Button, Divider } from "chat";

await thread.post(
  <Card title="Order Approval">
    <Text>Order #12345 requires approval</Text>
    <Divider />
    <Button id="approve" value="12345" style="primary">Approve</Button>
    <Button id="reject" value="12345" style="danger">Reject</Button>
  </Card>
);

// Handle button clicks
chat.onAction(["approve", "reject"], async (event) => {
  const orderId = event.value;
  if (event.actionId === "approve") {
    await event.thread.post(`✅ Order ${orderId} approved`);
  } else {
    await event.thread.post(`❌ Order ${orderId} rejected`);
  }
});

import { readFile } from "node:fs/promises";

const fileData = await readFile("./report.pdf");

await thread.post({
  markdown: "Here's the report you requested:",
  files: [
    {
      filename: "report.pdf",
      data: fileData,
      mimeType: "application/pdf"
    }
  ]
});

await thread.post({
  markdown: "Quarterly reports:",
  files: [
    { filename: "q1.pdf", data: q1Data, mimeType: "application/pdf" },
    { filename: "q2.pdf", data: q2Data, mimeType: "application/pdf" },
    { filename: "summary.xlsx", data: xlsxData, mimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" }
  ]
});

// Link to existing images
await thread.post({
  markdown: "Check out this chart:",
  attachments: [
    {
      type: "image",
      url: "https://example.com/chart.png",
      name: "Sales Chart"
    }
  ]
});

chat.onSlashCommand("/secret", async (event) => {
  // Try native ephemeral (Slack/Google Chat)
  const result = await event.channel.postEphemeral(
    event.user,
    "This message is only visible to you!",
    { fallbackToDM: false }
  );
  
  if (!result) {
    // Platform doesn't support ephemeral - tell user
    await event.channel.post("Sorry, this platform doesn't support private messages in channels.");
  }
});

// Always send (DM fallback on Teams/Discord)
const result = await thread.postEphemeral(
  user,
  "Secret information!",
  { fallbackToDM: true }
);

if (result.usedFallback) {
  console.log("Sent via DM instead of ephemeral");
}

const msg = await thread.post("Initial message");

// Edit with new text
await msg.edit("Updated message!");

// Edit with markdown
await msg.edit({
  markdown: "**Updated** with _formatting_"
});

// Edit with a card
await msg.edit(
  <Card title="Updated">
    <Text>This replaces the original message</Text>
  </Card>
);

const msg = await thread.post("Temporary message");

// Wait 5 seconds then delete
setTimeout(async () => {
  await msg.delete();
}, 5000);

import { emoji } from "chat";

const msg = await thread.post("Check this out!");

// Add reactions
await msg.addReaction(emoji.thumbs_up);
await msg.addReaction(emoji.eyes);

// Remove a reaction
await msg.removeReaction(emoji.thumbs_up);

chat.onSubscribedMessage(async (thread, message) => {
  // Show typing indicator
  await thread.startTyping("Thinking...");
  
  // Do some work
  const response = await generateAIResponse(message.text);
  
  // Post response (typing indicator auto-clears)
  await thread.post(response);
});

chat.onSubscribedMessage(async (thread, message) => {
  const mention = thread.mentionUser(message.author.userId);
  await thread.post(`Hey ${mention}, check this out!`);
});

chat.onNewMention(async (thread, message) => {
  // Posts to the thread (replies to the conversation)
  await thread.post("This is a reply in the thread");
});

chat.onSlashCommand("/announce", async (event) => {
  // Posts to the channel (top-level message)
  await event.channel.post("This is a channel announcement");
});

// Or access channel from thread
chat.onNewMention(async (thread, message) => {
  await thread.channel.post("Posted to the channel, not the thread");
});

chat.onNewMention(async (thread, message) => {
  // Open DM with the user
  const dmThread = await chat.openDM(message.author.userId);
  await dmThread.post("Hey! I sent you a private message.");
  
  // Also reply in the original thread
  await thread.post("I sent you a DM!");
});

// Or use Author object
chat.onSubscribedMessage(async (thread, message) => {
  const dmThread = await chat.openDM(message.author);
  await dmThread.post("Private reply");
});

// From thread.ts
function extractMessageContent(message: AdapterPostableMessage): {
  plainText: string;
  formatted: Root;
  attachments: Attachment[];
} {
  if (typeof message === "string") {
    return {
      plainText: message,
      formatted: root([paragraph([textNode(message)])]),
      attachments: [],
    };
  }

  if ("markdown" in message) {
    const ast = parseMarkdown(message.markdown);
    return {
      plainText: toPlainText(ast),
      formatted: ast,
      attachments: message.attachments || [],
    };
  }

  if ("card" in message) {
    const fallbackText = message.fallbackText || cardToFallbackText(message.card);
    return {
      plainText: fallbackText,
      formatted: root([paragraph([textNode(fallbackText)])]),
      attachments: [],
    };
  }
  
  // ... other formats
}