Send email from Linear workflows — with approval before delivery

import { Hono } from 'hono';
import { LinearClient } from '@linear/sdk';

const app = new Hono();
const linear = new LinearClient({ apiKey: process.env.LINEAR_API_KEY! });

app.post('/webhooks/linear', async (c) => {
  const body = await c.req.json();

  "cm">// Only act on issue state transitions to Done
  if (body.type !== 'Issue' || body.action !== 'update') {
    return c.json({ ok: true });
  }

  const updatedState = body.updatedFrom?.stateId;
  const newState = body.data?.state?.name;
  if (newState !== 'Done') return c.json({ ok: true });

  const issue = await linear.issue(body.data.id);
  const labels = await issue.labels();
  const isBug = labels.nodes.some(l => l.name.toLowerCase() === 'bug');
  if (!isBug) return c.json({ ok: true });

  "cm">// Propose notification — held for human approval under gated_send
  const res = await fetch('https://api.multimail.dev/send_email', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.MULTIMAIL_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      from: '[email protected]',
      to: body.data.subscriberEmails ?? [],
      subject: `Bug fixed: ${issue.title}`,
      text: `The issue "${issue.title}" (${body.data.id}) has been resolved.\n\nDetails: ${issue.url}`,
      metadata: {
        linear_issue_id: body.data.id,
        linear_team: body.data.team?.name,
        trigger: 'issue_done',
      },
    }),
  });

  const result = await res.json();
  console.log('MultiMail queued:', result.id, 'status:', result.status);
  return c.json({ ok: true, email_id: result.id });
});

export default app;

import { LinearClient } from '@linear/sdk';

const linear = new LinearClient({ apiKey: process.env.LINEAR_API_KEY! });

async function syncApprovalDecisions() {
  const res = await fetch('https://api.multimail.dev/list_pending', {
    headers: { 'Authorization': `Bearer ${process.env.MULTIMAIL_API_KEY}` },
  });
  const { emails } = await res.json() as { emails: Array<{
    id: string;
    status: 'pending' | 'approved' | 'rejected';
    metadata: { linear_issue_id?: string };
    to: string[];
    subject: string;
  }> };

  for (const email of emails) {
    if (email.status === 'pending') continue;
    if (!email.metadata?.linear_issue_id) continue;

    const issue = await linear.issue(email.metadata.linear_issue_id);
    const commentBody = email.status === 'approved'
      ? `✓ Customer notification sent to ${email.to.join(', ')}: "${email.subject}" [MultiMail ${email.id}]`
      : `✗ Customer notification rejected: "${email.subject}" [MultiMail ${email.id}]`;

    await linear.createComment({
      issueId: issue.id,
      body: commentBody,
    });

    console.log(`Updated Linear issue ${issue.identifier}: ${email.status}`);
  }
}

"cm">// Run every 5 minutes via your scheduler of choice
setInterval(syncApprovalDecisions, 5 * 60 * 1000);
syncApprovalDecisions();

import { LinearClient } from '@linear/sdk';

const linear = new LinearClient({ apiKey: process.env.LINEAR_API_KEY! });

export async function sendCycleDigest(teamId: string, recipients: string[]) {
  const team = await linear.team(teamId);
  const cycles = await team.activeCycle;
  if (!cycles) throw new Error(`No active cycle for team ${teamId}`);

  const issues = await cycles.issues();
  const completed = issues.nodes.filter(i => i.state && i.completedAt);

  if (completed.length === 0) {
    console.log('No completed issues in current cycle — skipping digest');
    return;
  }

  const lines = completed.map(i => `- [${i.identifier}] ${i.title} (${i.assignee?.name ?? 'unassigned'})`);
  const body = [
    `Cycle: ${cycles.name}`,
    `Period: ${cycles.startsAt?.toDateString()} – ${cycles.endsAt?.toDateString()}`,
    '',
    `Completed (${completed.length}):`,
    ...lines,
  ].join('\n');

  const res = await fetch('https://api.multimail.dev/send_email', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.MULTIMAIL_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      from: '[email protected]',
      to: recipients,
      subject: `Cycle digest: ${cycles.name} — ${completed.length} issues completed`,
      text: body,
      metadata: {
        linear_team_id: teamId,
        linear_cycle_id: cycles.id,
        trigger: 'cycle_digest',
      },
    }),
  });

  const result = await res.json();
  "cm">// Under gated_all, status will be 'pending' until a human approves
  console.log(`Digest queued. ID: ${result.id}, status: ${result.status}`);
  return result;
}

import { LinearClient } from '@linear/sdk';

const linear = new LinearClient({ apiKey: process.env.LINEAR_API_KEY! });

export async function ingestInboundReplies(mailbox: string) {
  const inboxRes = await fetch(
    `https:"cm">//api.multimail.dev/check_inbox?mailbox=${encodeURIComponent(mailbox)}&unread=true`,
    { headers: { 'Authorization': `Bearer ${process.env.MULTIMAIL_API_KEY}` } }
  );
  const { emails } = await inboxRes.json() as { emails: Array<{ id: string; subject: string; from: string; thread_id: string }> };

  for (const email of emails) {
    "cm">// Read full email to get body + metadata
    const readRes = await fetch(`https:"cm">//api.multimail.dev/read_email?id=${email.id}`, {
      headers: { 'Authorization': `Bearer ${process.env.MULTIMAIL_API_KEY}` },
    });
    const full = await readRes.json() as {
      body_text: string;
      metadata: { linear_issue_id?: string };
    };

    if (!full.metadata?.linear_issue_id) continue;

    await linear.createComment({
      issueId: full.metadata.linear_issue_id,
      body: `Reply from ${email.from}:\n\n> ${full.body_text.slice(0, 500)}`,
    });

    console.log(`Attached reply to Linear issue ${full.metadata.linear_issue_id}`);
  }
}