const leads = await fetch("https://api.apollo.io/v1/mixed_people/search", {
  method: "POST",
  headers: { "X-Api-Key": process.env.APOLLO_KEY },
  body: JSON.stringify({
    organization_num_employees_ranges: ["10,200"],
    titles: ["BDR", "Sales"],
  }),
})

const prompt = `
Company: ${company.name}
Recent news: ${company.news}
Goal: Write a personalized cold email
`

const res = await openai.chat.completions.create({
  model: "gpt-4.1",
  messages: [{ role: "user", content: prompt }]
})

await resend.emails.send({
  to: lead.email,
  subject: "Quick idea for your outbound",
  html: generatedMessage
})

await supabase.from("events").insert({
  lead_id,
  opened: true,
  replied: false
})

export interface Env {
  OPENAI_API_KEY: string
  RESEND_API_KEY: string
  SUPABASE_URL: string
  SUPABASE_ANON_KEY: string
}

export default {
  async fetch(req: Request, env: Env) {
    if (req.method !== "POST") {
      return new Response("Use POST", { status: 405 })
    }

    const body = await req.json()

    const {
      name,
      email,
      company,
      role,
      company_description,
      news,
      pain_point,
      product,
      outcome
    } = body

    // ===== ① AIで営業文生成 =====
    const prompt = `
You are a top-performing BDR.

Write a highly personalized cold email.

Name: ${name}
Company: ${company}
Role: ${role}
Company Description: ${company_description}
Recent News: ${news}
Likely Challenge: ${pain_point}

Product: ${product}
Outcome: ${outcome}

Rules:
- Start with a specific observation
- Make a hypothesis
- Offer insight (not pitch)
- Under 120 words
- Casual tone
- End with yes/no question
`

    const aiRes = await fetch("https://api.openai.com/v1/chat/completions", {
      method: "POST",
      headers: {
        "Authorization": `Bearer ${env.OPENAI_API_KEY}`,
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        model: "gpt-4.1",
        messages: [{ role: "user", content: prompt }]
      })
    })

    const aiData: any = await aiRes.json()
    const message = aiData.choices[0].message.content

    // ===== ② メール送信 =====
    await fetch("https://api.resend.com/emails", {
      method: "POST",
      headers: {
        "Authorization": `Bearer ${env.RESEND_API_KEY}`,
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        from: "you@yourdomain.com",
        to: email,
        subject: `Quick thought for ${company}`,
        html: `<pre>${message}</pre>`
      })
    })

    // ===== ③ Supabaseにログ保存 =====
    await fetch(`${env.SUPABASE_URL}/rest/v1/outreach_logs`, {
      method: "POST",
      headers: {
        "apikey": env.SUPABASE_ANON_KEY,
        "Authorization": `Bearer ${env.SUPABASE_ANON_KEY}`,
        "Content-Type": "application/json",
        "Prefer": "return=minimal"
      },
      body: JSON.stringify({
        name,
        email,
        company,
        message,
        status: "sent",
        created_at: new Date().toISOString()
      })
    })

    return new Response(JSON.stringify({ success: true, message }), {
      headers: { "Content-Type": "application/json" }
    })
  }
}

create table outreach_logs (
  id uuid default gen_random_uuid() primary key,
  name text,
  email text,
  company text,
  message text,
  status text,
  created_at timestamp with time zone default now()
);

curl -X POST https://your-worker-url \
  -H "Content-Type: application/json" \
  -d '{
    "name": "John",
    "email": "test@example.com",
    "company": "Example Inc",
    "role": "Head of Sales",
    "company_description": "B2B SaaS company",
    "news": "Recently raised Series A",
    "pain_point": "Low reply rate in outbound",
    "product": "AI outbound tool",
    "outcome": "Increase reply rate"
  }'

export async function POST({ request }) {
  const body = await request.json()

  const res = await fetch("https://your-worker-url", {
    method: "POST",
    body: JSON.stringify(body)
  })

  const json = await res.json()

  return new Response(JSON.stringify({ message: json.message }))
}

export async function POST({ request }) {
  const body = await request.json()

  const res = await fetch("https://your-worker-url", {
    method: "POST",
    body: JSON.stringify(body)
  })

  return new Response(JSON.stringify({ success: true }))
}

// 生成だけ or 送信まで を分ける
const { mode } = body

if (mode === "generate") {
  return new Response(JSON.stringify({ message }))
}

// sendの場合だけ送信処理

// generate時
{ ...data, mode: "generate" }

// send時
{ ...data, message, mode: "send" }

返信メール受信
→ Webhook発火
→ AIが「意図」を理解
→ 返信文生成
→ DB保存
→（自動 or UIで確認して送信）

export default {
  async fetch(req: Request, env: Env) {
    const url = new URL(req.url)

    if (url.pathname === "/inbound") {
      const body = await req.json()

      const from = body.from
      const subject = body.subject
      const text = body.text

      // ===== ① AIで意図分析 + 返信生成 =====
      const prompt = `
You are an expert sales assistant.

Analyze this email and reply appropriately.

Rules:
- If positive → suggest meeting
- If neutral → ask a question
- If negative → politely close
- Keep it short
- Human tone

Email:
${text}
`

      const aiRes = await fetch("https://api.openai.com/v1/chat/completions", {
        method: "POST",
        headers: {
          Authorization: `Bearer ${env.OPENAI_API_KEY}`,
          "Content-Type": "application/json"
        },
        body: JSON.stringify({
          model: "gpt-4.1",
          messages: [{ role: "user", content: prompt }]
        })
      })

      const aiData: any = await aiRes.json()
      const reply = aiData.choices[0].message.content

      // ===== ② Supabase保存 =====
      await fetch(`${env.SUPABASE_URL}/rest/v1/replies`, {
        method: "POST",
        headers: {
          apikey: env.SUPABASE_ANON_KEY,
          Authorization: `Bearer ${env.SUPABASE_ANON_KEY}`,
          "Content-Type": "application/json"
        },
        body: JSON.stringify({
          from_email: from,
          subject,
          original_message: text,
          ai_reply: reply,
          status: "draft"
        })
      })

      return new Response("ok")
    }

    return new Response("Not found", { status: 404 })
  }
}

create table replies (
  id uuid default gen_random_uuid() primary key,
  from_email text,
  subject text,
  original_message text,
  ai_reply text,
  status text,
  created_at timestamp with time zone default now()
);

if (autoSend) {
  await fetch("https://api.resend.com/emails", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${env.RESEND_API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      to: from,
      subject: `Re: ${subject}`,
      html: reply
    })
  })
}

Classify the intent:
- Interested
- Not now
- Not interested
- Question

Then write a reply:

Rules:
- Match tone of the sender
- Reference something they said
- Keep under 80 words
- No generic sales language

If interested:
→ Suggest 2 time slots

If not now:
→ Ask when to follow up

If not interested:
→ Gracefully close

If question:
→ Answer simply + ask 1 follow-up

返信あり
→ AIが「興味あり」と判断
→ 空き時間を取得
→ 候補2〜3個提示
→ 相手が選ぶ
→ 自動でカレンダー登録

async function getFreeSlots(accessToken: string) {
  const now = new Date()
  const end = new Date()
  end.setDate(now.getDate() + 7)

  const res = await fetch(
    "https://www.googleapis.com/calendar/v3/freeBusy",
    {
      method: "POST",
      headers: {
        Authorization: `Bearer ${accessToken}`,
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        timeMin: now.toISOString(),
        timeMax: end.toISOString(),
        items: [{ id: "primary" }]
      })
    }
  )

  const data = await res.json()
  return data.calendars.primary.busy
}

function generateSlots(busy: any[]) {
  const slots = []
  const startHour = 9
  const endHour = 18

  for (let d = 1; d <= 5; d++) {
    const day = new Date()
    day.setDate(day.getDate() + d)

    for (let h = startHour; h < endHour; h++) {
      const slotStart = new Date(day)
      slotStart.setHours(h, 0, 0)

      const slotEnd = new Date(day)
      slotEnd.setHours(h + 1, 0, 0)

      const conflict = busy.some(b =>
        new Date(b.start) < slotEnd && new Date(b.end) > slotStart
      )

      if (!conflict) {
        slots.push(slotStart)
      }
    }
  }

  return slots.slice(0, 3) // 3候補だけ
}

const prompt = `
Suggest meeting times based on these slots:

${slots.join("\n")}

Rules:
- Offer 2-3 options
- Casual tone
- Include timezone
- Ask which works best
`

Would any of these work?

- Tue 10am JST
- Wed 2pm JST
- Thu 11am JST

Happy to adjust if needed.

async function createEvent(accessToken: string, email: string, time: string) {
  await fetch("https://www.googleapis.com/calendar/v3/calendars/primary/events", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${accessToken}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      summary: "Intro Call",
      start: { dateTime: time },
      end: {
        dateTime: new Date(new Date(time).getTime() + 30 * 60000).toISOString()
      },
      attendees: [{ email }]
    })
  })
}

If user is interested:
→ Suggest 2-3 time slots
→ Or include scheduling link

相手が時間を選択
→ イベント作成
→ 会議リンク自動生成
→ メールで送付

async function createMeetEvent(accessToken: string, email: string, time: string) {
  const res = await fetch(
    "https://www.googleapis.com/calendar/v3/calendars/primary/events?conferenceDataVersion=1",
    {
      method: "POST",
      headers: {
        Authorization: `Bearer ${accessToken}`,
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        summary: "Intro Call",
        start: { dateTime: time },
        end: {
          dateTime: new Date(new Date(time).getTime() + 30 * 60000).toISOString()
        },
        attendees: [{ email }],
        conferenceData: {
          createRequest: {
            requestId: crypto.randomUUID(),
            conferenceSolutionKey: {
              type: "hangoutsMeet"
            }
          }
        }
      })
    }
  )

  const data = await res.json()

  return data.conferenceData.entryPoints[0].uri // Meet URL
}

async function createZoomMeeting(accessToken: string, time: string) {
  const res = await fetch("https://api.zoom.us/v2/users/me/meetings", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${accessToken}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      topic: "Intro Call",
      type: 2,
      start_time: time,
      duration: 30,
      timezone: "Asia/Tokyo",
      settings: {
        join_before_host: false,
        waiting_room: true
      }
    })
  })

  const data = await res.json()

  return data.join_url
}

await fetch("https://api.resend.com/emails", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${env.RESEND_API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    to: email,
    subject: "Meeting confirmed",
    html: `
      <p>Looking forward to it!</p>
      <p>Join here: <a href="${meetingLink}">${meetingLink}</a></p>
    `
  })
})

If meeting confirmed:
→ Include meeting link
→ Keep message short
→ Friendly tone

Great — locking in Wed 2pm JST.

Here’s the link:
https://meet.google.com/xxx

Looking forward to it.

リード獲得
→ AI営業（メール/DM）
→ 返信
→ AIが温度感判定
→ アポ（カレンダー）
→ 商談後「契約OK」検知
→ Stripe Checkoutリンク生成
→ 送付
→ 決済完了Webhook
→ アカウント自動有効化

Classify intent:
- ready_to_buy
- need_info
- not_now

If ready_to_buy:
→ trigger checkout

async function createCheckout(email: string) {
  const res = await fetch("https://api.stripe.com/v1/checkout/sessions", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${STRIPE_SECRET_KEY}`,
      "Content-Type": "application/x-www-form-urlencoded"
    },
    body: new URLSearchParams({
      "mode": "subscription",
      "customer_email": email,
      "line_items[0][price]": "price_XXXX",
      "line_items[0][quantity]": "1",
      "success_url": "https://yourapp.com/success",
      "cancel_url": "https://yourapp.com/cancel"
    })
  })

  const data = await res.json()
  return data.url
}

const checkoutUrl = await createCheckout(email)

await fetch("https://api.resend.com/emails", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${RESEND_API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    to: email,
    subject: "Get started",
    html: `
      <p>As discussed, you can get started here:</p>
      <a href="${checkoutUrl}">Start now</a>
    `
  })
})

if (event.type === "checkout.session.completed") {
  const session = event.data.object

  // Supabase更新
  await fetch(`${SUPABASE_URL}/rest/v1/users`, {
    method: "POST",
    headers: {
      apikey: SUPABASE_ANON_KEY,
      Authorization: `Bearer ${SUPABASE_ANON_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      email: session.customer_email,
      status: "active"
    })
  })
}

Only trigger checkout if:
- User explicitly agrees
- No objections remain

Otherwise:
→ continue conversation

await stripe.subscriptionItems.createUsageRecord(
  subscriptionItemId,
  {
    quantity: 10,
    timestamp: Math.floor(Date.now() / 1000)
  }
)

返信率を2〜5倍に。
チームを増やさずに、商談数を伸ばす。

AIが“返信される営業文”を自動生成します。

テンプレ営業は、もう通用しません。

このAIは、企業ごとの情報を分析し、
“相手に刺さる文脈”で営業文を生成します。

Starter — 月額 6,000円
個人・スモールチーム向け
- 月200通のAI生成
- 基本パーソナライズ
- メールサポート

👉 今すぐ始める

---

Growth — 月額 18,000円（おすすめ）
本格的に成果を出したいチーム向け
- 月1,000通のAI生成
- 高度なパーソナライズ
- A/Bテスト
- 返信トラッキング

👉 無料トライアル

---

Pro — 月額 48,000円
アウトバウンドをスケールする企業向け
- 無制限AI生成
- チーム管理
- 自動フォローアップ
- 優先サポート

👉 デモを予約

従来のテンプレ営業 vs AI営業

テンプレ営業
- 返信率が低い
- 誰にでも同じ内容
- 数を打つしかない

AI営業
- 相手ごとに最適化
- 文脈ベースのメッセージ
- 使うほど精度が上がる

「返信率が3% → 18%に改善（2週間）」

「初月で12件の商談を獲得」

急成長中のSaaS企業・営業チームで導入されています

Q. いつでも解約できますか？
A. はい、いつでも可能です。

Q. 本当に効果ありますか？
A. 多くのユーザーが1週間以内に返信率の改善を実感しています。

Q. スパムになりませんか？
A. テンプレではなく、実際の情報を元にパーソナライズするため安心です。

まずは50通、無料で試す

クレジットカード不要

<section>
  <h1>返信率を2〜5倍に</h1>
  <p>AIで営業を変える</p>
</section>

<section>
  <!-- 価格 -->
</section>

<section>
  <!-- 比較 -->
</section>

<section>
  <!-- 実績 -->
</section>

<section>
  <button>無料で始める</button>
</section>