Daily recaps with Cron, a Sandbox, and Claude Code

"dependencies": {
  "@notionhq/client": "^2.3.0",
  "@octokit/rest": "^21.0.0",
  "@slack/web-api": "^7.0.0",
  "@vercel/sandbox": "latest",
  "googleapis": "^144.0.0",
  "next": "^16.0.0",
  "react": "^19.0.0",
  "react-dom": "^19.0.0",
  "workflow": "latest",
  "zod": "^3.23.0"
}

import type { NextConfig } from "next";
import { withWorkflow } from "workflow/next";
 
const nextConfig: NextConfig = {};
 
export default withWorkflow(nextConfig);

{
  "$schema": "https://openapi.vercel.sh/vercel.json",
  "crons": [
    {
      "path": "/api/cron/recap",
      "schedule": "0 23 * * *"
    }
  ]
}

import { NextResponse } from "next/server";
import { start } from "workflow/api";
import { dailyRecapWorkflow } from "@/lib/workflow";
 
const DEFAULT_TIMEZONE = "America/Chicago";
 
export async function GET(request: Request): Promise<Response> {
  const startedAt = Date.now();
 
  const authHeader = request.headers.get("authorization");
  if (authHeader !== `Bearer ${process.env.CRON_SECRET}`) {
    console.warn(
      JSON.stringify({ event: "cron.unauthorized", ip: request.headers.get("x-forwarded-for") }),
    );
    return NextResponse.json({ error: "unauthorized" }, { status: 401 });
  }
 
  const tz = process.env.TIMEZONE ?? DEFAULT_TIMEZONE;
  const now = new Date();
 
  const formatter = new Intl.DateTimeFormat("en-CA", {
    timeZone: tz,
    year: "numeric",
    month: "2-digit",
    day: "2-digit",
  });
  const date = formatter.format(now); // en-CA gives "YYYY-MM-DD"
 
  const dayOfWeek = new Intl.DateTimeFormat("en-US", {
    timeZone: tz,
    weekday: "long",
  }).format(now);
 
  console.log(JSON.stringify({ event: "cron.trigger.start", date, dayOfWeek, tz }));
 
  try {
    const run = await start(dailyRecapWorkflow, [
      { date, dayOfWeek, timezone: tz },
    ]);
 
    console.log(
      JSON.stringify({
        event: "cron.trigger.started",
        runId: run.runId,
        date,
        durationMs: Date.now() - startedAt,
      }),
    );
 
    return NextResponse.json({
      ok: true,
      runId: run.runId,
      date,
      dayOfWeek,
      timezone: tz,
      inspect: `npx workflow inspect run ${run.runId} --backend vercel --project daily-recap`,
    });
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    console.error(
      JSON.stringify({
        event: "cron.trigger.failed",
        msg,
        date,
        durationMs: Date.now() - startedAt,
      }),
    );
    return NextResponse.json({ ok: false, error: msg }, { status: 500 });
  }
}

import { z } from "zod";
 
export const SourceEnum = z.enum([
  "calendar",
  "gmail",
  "slack",
  "notion",
  "github",
]);
export type Source = z.infer<typeof SourceEnum>;
 
export const TomorrowMeetingSchema = z.object({
  meeting: z.string().describe("Meeting title or calendar event name"),
  prep_note: z
    .string()
    .describe("One-line prep note: what to think about, who's attending, what to bring"),
});
export type TomorrowMeeting = z.infer<typeof TomorrowMeetingSchema>;
 
export const SectionsSchema = z.object({
  todays_wins: z.array(z.string()),
  commitments_made: z.array(z.string()),
  loose_ends: z.array(z.string()),
  tomorrow_on_deck: z.array(TomorrowMeetingSchema),
  front_load_candidates: z.array(z.string()),
  watch_list: z.array(z.string()),
  questions_surfaced: z.array(z.string()),
  daily_learning: z.string(),
});
export type Sections = z.infer<typeof SectionsSchema>;
 
export const RecapSchema = z.object({
  date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
  day_of_week: z.string(),
  sources_available: z.array(SourceEnum),
  sources_degraded: z.array(z.string()),
  sections: SectionsSchema,
  tldr_bullets: z.array(z.string()).min(3).max(5),
});
export type Recap = z.infer<typeof RecapSchema>;

"use workflow";
 
import { FatalError, RetryableError } from "workflow";
 
import { fetchCalendar } from "./sources/calendar";
import { fetchGmail } from "./sources/gmail";
import { fetchSlack } from "./sources/slack";
import { fetchNotionEdits } from "./sources/notion-reads";
import { fetchGitHub } from "./sources/github-reads";
import type { DateWindow } from "./sources/types";
 
import { runClaudeInSandbox } from "./sandbox";
import { writeNotionPage } from "./sinks/notion";
import { writeArchiveMarkdown } from "./sinks/github";
import { sendSlackDM, sendSlackErrorAlert } from "./sinks/slack";
 
import type { PromptContext } from "./prompt";
import type { Recap } from "./schema";
 
export async function dailyRecapWorkflow(params: {
  date: string;
  dayOfWeek: string;
  timezone: string;
}) {
  console.log(
    JSON.stringify({ event: "workflow.start", date: params.date, dow: params.dayOfWeek }),
  );
 
  // ---------- Step 1: parallel prefetch ----------
  const window = { date: params.date, timezone: params.timezone };
  const [calendar, gmail, slack, notion, github] = await Promise.all([
    prefetchCalendar(window),
    prefetchGmail(window),
    prefetchSlack(window),
    prefetchNotion(window),
    prefetchGitHub(window),
  ]);
 
  const ctx: PromptContext = {
    date: params.date,
    dayOfWeek: params.dayOfWeek,
    timezone: params.timezone,
    sources: { calendar, gmail, slack, notion, github },
  };
 
  // ---------- Step 2: synthesize in sandbox ----------
  let recap: Recap;
  try {
    recap = await synthesizeStep(ctx);
  } catch (err) {
    await alertStep({
      phase: "claude",
      message: err instanceof Error ? err.message : String(err),
    });
    throw err;
  }
 
  // ---------- Step 3: parallel fan-out ----------
  const [notionResult, archiveResult] = await Promise.allSettled([
    notionStep(recap),
    archiveStep(recap),
  ]);
 
  const notionUrl =
    notionResult.status === "fulfilled" ? notionResult.value.url : undefined;
 
  // ---------- Step 4: Slack DM ----------
  try {
    await slackStep({
      recap,
      notionUrl,
      notionFailed: notionResult.status === "rejected",
      archiveFailed: archiveResult.status === "rejected",
    });
  } catch (err) {
    await alertStep({
      phase: "slack",
      message: err instanceof Error ? err.message : String(err),
    });
  }
 
  // ---------- Step 5: log ----------
  await logStep(recap);
}
 
// ------------------------ Prefetch steps ------------------------
// Each is its own retriable step so one flaky API doesn't require
// re-running the others. Log event shapes shortened here for brevity.
 
async function prefetchCalendar(p: DateWindow) {
  "use step";
  return fetchCalendar(p);
}
 
async function prefetchGmail(p: DateWindow) {
  "use step";
  return fetchGmail(p);
}
 
async function prefetchSlack(p: DateWindow) {
  "use step";
  return fetchSlack(p);
}
 
async function prefetchNotion(p: DateWindow) {
  "use step";
  return fetchNotionEdits(p);
}
 
async function prefetchGitHub(p: DateWindow) {
  "use step";
  return fetchGitHub(p);
}
 
// ------------------------ Synthesis + sinks ------------------------
 
async function synthesizeStep(ctx: PromptContext): Promise<Recap> {
  "use step";
  try {
    return await runClaudeInSandbox(ctx);
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    if (/auth|unauthorized|401|403|invalid.*token/i.test(msg)) {
      throw new FatalError(`Auth failure in synthesis: ${msg}`);
    }
    throw new RetryableError(msg, { retryAfter: "2m" });
  }
}
 
async function notionStep(recap: Recap): Promise<{ url: string }> {
  "use step";
  try {
    return await writeNotionPage(recap);
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    if (/rate.*limit|429/i.test(msg)) {
      throw new RetryableError(msg, { retryAfter: "30s" });
    }
    throw new FatalError(msg);
  }
}
 
async function archiveStep(recap: Recap): Promise<{ path: string }> {
  "use step";
  try {
    return await writeArchiveMarkdown(recap);
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    if (/rate.*limit|429|5\d\d/.test(msg)) {
      throw new RetryableError(msg, { retryAfter: "1m" });
    }
    throw new FatalError(msg);
  }
}
 
async function slackStep(input: {
  recap: Recap;
  notionUrl?: string;
  notionFailed: boolean;
  archiveFailed: boolean;
}): Promise<void> {
  "use step";
  await sendSlackDM(input);
}
 
async function alertStep(input: {
  phase: "claude" | "slack" | "notion" | "archive" | "unknown";
  message: string;
}): Promise<void> {
  "use step";
  await sendSlackErrorAlert(input).catch(() => {});
}
 
async function logStep(recap: Recap): Promise<void> {
  "use step";
  console.log(
    JSON.stringify({
      event: "daily_recap.completed",
      date: recap.date,
      sources_available: recap.sources_available,
      sources_degraded: recap.sources_degraded,
      tldr_count: recap.tldr_bullets.length,
    }),
  );
}

import { Sandbox } from "@vercel/sandbox";
import { RecapSchema, type Recap, RECAP_JSON_SCHEMA } from "./schema";
import { buildDailyRecapPrompt, type PromptContext } from "./prompt";
 
const SANDBOX_TIMEOUT_MS = 10 * 60 * 1000;
 
export async function runClaudeInSandbox(ctx: PromptContext): Promise<Recap> {
  const snapshotId = process.env.VERCEL_SANDBOX_SNAPSHOT_ID;
  if (!snapshotId) throw new Error("VERCEL_SANDBOX_SNAPSHOT_ID is not set");
 
  const anthropicKey = process.env.ANTHROPIC_API_KEY;
  if (!anthropicKey) throw new Error("ANTHROPIC_API_KEY is not set");
 
  const sandbox = await Sandbox.create({
    ...getSandboxCredentials(),
    source: { type: "snapshot", snapshotId },
    timeout: SANDBOX_TIMEOUT_MS,
  });
 
  try {
    const prompt = buildDailyRecapPrompt(ctx);
 
    // Write inputs via shell heredoc — simpler and more reliable than
    // the SDK writeFiles path. Two files: prompt + JSON schema.
    await sandbox.runCommand("sh", [
      "-c",
      [
        `cat > /tmp/prompt.txt <<'DAILYRECAPEOF'\n${prompt}\nDAILYRECAPEOF`,
        `cat > /tmp/schema.json <<'DAILYRECAPEOF'\n${RECAP_JSON_SCHEMA}\nDAILYRECAPEOF`,
      ].join(" && "),
    ]);
 
    const result = await sandbox.runCommand("sh", [
      "-c",
      `ANTHROPIC_API_KEY='${anthropicKey.replace(/'/g, "'\\''")}' claude ` +
        [
          "--dangerously-skip-permissions",
          "--print",
          "--output-format json",
          '--json-schema "$(cat /tmp/schema.json)"',
          '"$(cat /tmp/prompt.txt)"',
        ].join(" "),
    ]);
 
    const stdout = await result.stdout();
    const stderr = await result.stderr();
 
    if (!stdout.trim()) {
      throw new Error(
        `Claude produced no stdout. stderr: ${stderr.slice(0, 500)}`,
      );
    }
 
    const parsed = JSON.parse(stdout);
    const recapJson = extractRecapJson(parsed);
    return RecapSchema.parse(recapJson);
  } finally {
    await sandbox.stop().catch(() => {});
  }
}
 
function stripMarkdownJsonFence(s: string): string {
  let t = s.trim();
  if (!t.startsWith("```")) return t;
  t = t.slice(3);
  if (t.toLowerCase().startsWith("json")) {
    t = t.slice(4);
  }
  t = t.trimStart();
  if (t.startsWith("\n")) t = t.slice(1);
  t = t.trimEnd();
  if (t.endsWith("```")) {
    t = t.slice(0, -3).trimEnd();
  }
  return t.trim();
}
 
function tryParseJsonRecapString(raw: string): unknown | null {
  const stripped = stripMarkdownJsonFence(raw);
  const trimmed = raw.trim();
  const payloads = stripped === trimmed ? [stripped] : [stripped, trimmed];
  for (const payload of payloads) {
    try { return JSON.parse(payload); } catch { /* try next */ }
  }
  return null;
}
 
function isRecapEnvelope(c: unknown): boolean {
  return c !== null && typeof c === "object" && "sections" in (c as object);
}
 
function extractRecapJson(parsed: unknown): unknown {
  const root = parsed as Record<string, unknown>;
  const candidates: Array<() => unknown> = [
    () => root.structured_output,
    () => (root.result as Record<string, unknown>)?.structured_output,
    () => {
      const r = root.result;
      if (typeof r === "string") return tryParseJsonRecapString(r);
      return null;
    },
    () => root.result,
    () => root.content,
    () => parsed,
  ];
  for (const get of candidates) {
    try {
      const c = get();
      if (isRecapEnvelope(c)) return c;
    } catch { /* try next */ }
  }
  return parsed;
}
 
function getSandboxCredentials() {
  if (
    process.env.VERCEL_TOKEN &&
    process.env.VERCEL_TEAM_ID &&
    process.env.VERCEL_PROJECT_ID
  ) {
    return {
      token: process.env.VERCEL_TOKEN,
      teamId: process.env.VERCEL_TEAM_ID,
      projectId: process.env.VERCEL_PROJECT_ID,
    };
  }
  return {};
}

return `You are Ryan's personal assistant. Today is ${dayOfWeek}, ${date} (${timezone}).
 
Your job is to produce Ryan's end-of-day recap — a first-person journal entry that captures what actually happened today and sets up tomorrow morning. Written at 6pm tonight; re-read at 7am tomorrow.
 
## Available sources this run
 
Available: ${available.join(", ") || "(none)"}
${degraded.length > 0 ? `Degraded: ${degraded.join("; ")}` : "All sources ok."}
 
## Input data (pre-fetched — do not query external systems)
 
### Calendar (today's events)
${formatCalendar(sources.calendar)}
 
### Gmail (threads from the last 24h, de-noised via category filters)
${formatGmail(sources.gmail)}
 
### Slack (DMs + mentions + your replies today)
${formatSlack(sources.slack)}
 
### Notion (pages edited today in your workspace)
${formatNotion(sources.notion)}
 
### GitHub (PRs / issues / reviews you touched today)
${formatGitHub(sources.github)}
 
## Required output sections
 
Output a JSON object matching the provided schema with these sections, in this order (natural arc: close today → open tomorrow):
 
1. **todays_wins** — things that actually moved: decisions made, work shipped, meetings that unlocked something. Not "attended standup" — that's not a win.
2. **commitments_made** — explicit or implicit promises Ryan made today. "I'll send the draft Friday." "I'll intro you." Include who it's to. Pulled from Gmail sent, Slack replies, meeting attendance.
3. **loose_ends** — unanswered emails, DMs without a response, asks Ryan ignored. The guilt pile. Be specific about who's waiting and what they asked.
4. **tomorrow_on_deck** — NOT today's calendar. You don't have tomorrow's calendar in the data here — leave this as an empty array and note in the daily_learning that tomorrow-preview is a v1.5 addition.
5. **front_load_candidates** — admin/quick-win tasks for tomorrow AM. Specific actions, not strategic work.
6. **watch_list** — signals brewing that don't need action today but worth monitoring.
7. **questions_surfaced** — things Ryan encountered today but didn't resolve.
8. **daily_learning** — one-line takeaway worth remembering.
 
## Voice and tone
 
- **First person.** "I committed to sending the draft Friday." Never "Ryan committed..." or "You committed..."
- **Ryan's voice.** Direct, concise, lightly wry, zero corporate jargon. Fragments fine. No exclamation marks, no emojis, no motivational pap.
- **Active verbs.** "I shipped X" not "X was shipped."
- **Include links.** Slack permalinks, Gmail thread URLs, Notion page URLs, GitHub PR URLs. Any time you reference a specific artifact, link it.
 
## Selectivity rules (HARD — never violate)
 
- SKIP and do not include: login/security notifications, marketing emails, newsletters, automated alerts, subscription confirmations, promotional offers, social media notifications, CI/CD bot messages, "@channel" announcements Ryan didn't engage with, @-mentions in firehose channels where Ryan didn't reply.
- Include only real discussion and real commitments — anything that requires a human response or reflects a decision.
- Slack channel chatter Ryan scrolled past doesn't count. Only DMs, mentions Ryan engaged with, or replies he sent.
 
## Selectivity rules (SOFT — use judgment)
 
- Recurring holds / focus blocks / standups with no specific discussion: skip unless something happened.
- "Got it, thanks!" confirmations: skip.
- When uncertain, exclude. A shorter, more selective recap is more valuable than a comprehensive one.
- If a section has nothing genuinely worth reporting, use the "nothing surfaced today" placeholder. Do not pad with filler.
 
## Length target
 
~400–600 words total across all sections. Skimmable in 60 seconds.
 
## TL;DR bullets
 
After the sections, generate 3–5 short bullets (under 90 chars each) for a Slack DM headline. Most important things only — the items that would make Ryan sit up if he saw nothing else.
 
## Output format
 
Return a single JSON object matching the provided schema. No prose before or after — just the JSON.`;

type Result<T> = { ok: true; data: T } | { ok: false; reason: string };

import { google } from "googleapis";
import { getGoogleOAuthClient } from "./google-client";
import { dateToUTCWindow, type DateWindow, type Result } from "./types";
 
export interface CalendarEvent {
  id: string;
  start: string;
  end: string;
  summary: string;
  attendees: string[];
  isRecurring: boolean;
  isAllDay: boolean;
  location?: string;
  description?: string;
  htmlLink: string;
}
 
export async function fetchCalendar(window: DateWindow): Promise<Result<CalendarEvent[]>> {
  try {
    const auth = getGoogleOAuthClient();
    const calendar = google.calendar({ version: "v3", auth });
 
    const { startMs, endMs } = dateToUTCWindow(window);
    const timeMin = new Date(startMs).toISOString();
    const timeMax = new Date(endMs).toISOString();
 
    const res = await calendar.events.list({
      calendarId: "primary",
      timeMin,
      timeMax,
      singleEvents: true,
      orderBy: "startTime",
      maxResults: 50,
    });
 
    const events: CalendarEvent[] = (res.data.items ?? []).map((e) => ({
      id: e.id ?? "",
      start: e.start?.dateTime ?? e.start?.date ?? "",
      end: e.end?.dateTime ?? e.end?.date ?? "",
      summary: e.summary ?? "(no title)",
      attendees: (e.attendees ?? []).map((a) => a.email ?? "").filter(Boolean),
      isRecurring: Boolean(e.recurringEventId),
      isAllDay: !e.start?.dateTime,
      location: e.location ?? undefined,
      description: e.description ?? undefined,
      htmlLink: e.htmlLink ?? "",
    }));
 
    return { ok: true, data: events };
  } catch (err) {
    return { ok: false, reason: err instanceof Error ? err.message : String(err) };
  }
}

import { Client } from "@notionhq/client";
import type { Recap } from "../schema";
 
const notion = new Client({ auth: process.env.NOTION_TOKEN });
 
export async function writeNotionPage(
  recap: Recap,
  meta?: { runId?: string },
): Promise<{ url: string; id: string }> {
  const dbId = requireEnv("NOTION_DAILY_BRIEFS_DB_ID");
 
  const wordCount = countWords(recap);
  const status = recap.sources_degraded.length > 0 ? "Degraded" : "Published";
 
  const page = await notion.pages.create({
    parent: { database_id: dbId },
    properties: {
      Name: { title: [{ text: { content: `Daily Brief — ${recap.day_of_week}, ${recap.date}` } }] },
      Date: { date: { start: recap.date } },
      Day: { select: { name: recap.day_of_week } },
      Status: { select: { name: status } },
      Sources: { multi_select: recap.sources_available.map((s) => ({ name: s })) },
      "Sources Degraded": {
        multi_select: recap.sources_degraded
          .map((s) => s.split(":")[0].trim())
          .filter((s) => ["calendar", "gmail", "slack", "notion", "github"].includes(s))
          .map((name) => ({ name })),
      },
      "Word Count": { number: wordCount },
      "TL;DR Count": { number: recap.tldr_bullets.length },
      Commitments: { number: recap.sections.commitments_made.length },
      "Loose Ends": { number: recap.sections.loose_ends.length },
      ...(meta?.runId ? { "Run ID": { rich_text: [{ text: { content: meta.runId } }] } } : {}),
    },
    children: buildBlocks(recap) as any,
  });
 
  const url = "url" in page ? (page.url as string) : "";
  return { url, id: page.id };
}

import { readFileSync } from "node:fs";
import { resolve } from "node:path";
import { Sandbox } from "@vercel/sandbox";
 
async function main() {
  const setupScript = readFileSync(
    resolve(__dirname, "../snapshot/setup.sh"),
    "utf-8",
  );
 
  console.log("→ Creating fresh Vercel Sandbox (node24)…");
  const sandbox = await Sandbox.create({
    ...getCredentials(),
    runtime: "node24",
    timeout: 15 * 60 * 1000,
  });
  console.log("✓ Sandbox created");
 
  try {
    console.log("→ Running snapshot/setup.sh inside the sandbox…");
    const result = await sandbox.runCommand("sh", ["-c", setupScript]);
    const stdout = await result.stdout();
    const stderr = await result.stderr();
    if (stdout) console.log(stdout);
    if (stderr) console.error(stderr);
    console.log("✓ Setup complete");
 
    console.log("→ Taking snapshot…");
    const snapshot = await sandbox.snapshot();
    console.log(`\n✓ Snapshot created: ${snapshot.snapshotId}\n`);
    console.log("Next: set VERCEL_SANDBOX_SNAPSHOT_ID in Vercel env.");
    console.log(
      `  echo "${snapshot.snapshotId}" | vercel env add VERCEL_SANDBOX_SNAPSHOT_ID production`,
    );
  } finally {
    await sandbox.stop().catch(() => {});
  }
}