@agent-native/scheduling 0.1.1

package/src/actions/set-host-availability-override.ts

@@ -0,0 +1,27 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { and, eq } from "drizzle-orm";
+import { getSchedulingContext } from "../server/context.js";
+
+export default defineAction({
+  description:
+    "Set a host-specific availability schedule override for an event type",
+  schema: z.object({
+    eventTypeId: z.string(),
+    userEmail: z.string(),
+    scheduleId: z.string().nullable(),
+  }),
+  run: async (args) => {
+    const { getDb, schema } = getSchedulingContext();
+    await getDb()
+      .update(schema.eventTypeHosts)
+      .set({ scheduleId: args.scheduleId })
+      .where(
+        and(
+          eq(schema.eventTypeHosts.eventTypeId, args.eventTypeId),
+          eq(schema.eventTypeHosts.userEmail, args.userEmail),
+        ),
+      );
+    return { ok: true };
+  },
+});

package/src/actions/set-team-branding.ts

@@ -0,0 +1,28 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { eq } from "drizzle-orm";
+import { getSchedulingContext } from "../server/context.js";
+import { assertTeamAdmin } from "./_helpers.js";
+
+export default defineAction({
+  description: "Update a team's branding (name, logo, colors, bio)",
+  schema: z.object({
+    id: z.string(),
+    name: z.string().optional(),
+    logoUrl: z.string().nullable().optional(),
+    brandColor: z.string().nullable().optional(),
+    darkBrandColor: z.string().nullable().optional(),
+    bio: z.string().nullable().optional(),
+    hideBranding: z.boolean().optional(),
+  }),
+  run: async (args) => {
+    await assertTeamAdmin(args.id);
+    const { getDb, schema } = getSchedulingContext();
+    const { id, ...set } = args;
+    await getDb()
+      .update(schema.teams)
+      .set({ ...set, updatedAt: new Date().toISOString() })
+      .where(eq(schema.teams.id, id));
+    return { ok: true };
+  },
+});

package/src/actions/submit-routing-form-response.ts

@@ -0,0 +1,47 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { nanoid } from "nanoid";
+import { eq } from "drizzle-orm";
+import { getSchedulingContext } from "../server/context.js";
+
+export default defineAction({
+  description: "Store a public routing form submission response",
+  schema: z.object({
+    formId: z.string(),
+    response: z.record(z.string(), z.any()),
+    bookingId: z.string().optional(),
+    matchedRuleId: z.string().optional(),
+    routedTo: z.string().optional(),
+    submitterEmail: z.string().optional(),
+  }),
+  run: async (args) => {
+    const { getDb, schema } = getSchedulingContext();
+    const [form] = await getDb()
+      .select({
+        id: schema.routingForms.id,
+        disabled: schema.routingForms.disabled,
+      })
+      .from(schema.routingForms)
+      .where(eq(schema.routingForms.id, args.formId))
+      .limit(1);
+    if (!form || form.disabled) {
+      throw new Error(`Routing form not found: ${args.formId}`);
+    }
+
+    const id = nanoid();
+    await getDb()
+      .insert(schema.routingFormResponses)
+      .values({
+        id,
+        formId: args.formId,
+        response: JSON.stringify(args.response),
+        bookingId: args.bookingId ?? null,
+        matchedRuleId: args.matchedRuleId ?? null,
+        routedTo: args.routedTo ?? null,
+        submitterEmail: args.submitterEmail ?? null,
+        submitterIp: null,
+        createdAt: new Date().toISOString(),
+      });
+    return { id };
+  },
+});

package/src/actions/toggle-event-type-hidden.ts

@@ -0,0 +1,21 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { assertAccess } from "@agent-native/core/sharing";
+import {
+  updateEventType,
+  getEventTypeById,
+} from "../server/event-types-repo.js";
+
+export default defineAction({
+  description: "Toggle hidden (unpublished) state on an event type",
+  schema: z.object({ id: z.string(), hidden: z.boolean().optional() }),
+  run: async (args) => {
+    await assertAccess("event-type", args.id, "editor");
+    const current = await getEventTypeById(args.id);
+    if (!current) throw new Error("Event type not found");
+    const target = args.hidden ?? !current.hidden;
+    return {
+      eventType: await updateEventType(args.id, { hidden: target }),
+    };
+  },
+});

package/src/actions/toggle-selected-calendar.ts

@@ -0,0 +1,43 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { and, eq } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { getSchedulingContext } from "../server/context.js";
+import { currentUserEmail } from "./_helpers.js";
+
+export default defineAction({
+  description: "Toggle whether a calendar is checked for conflicts",
+  schema: z.object({
+    credentialId: z.string(),
+    externalId: z.string(),
+    include: z.boolean(),
+  }),
+  run: async (args) => {
+    const { getDb, schema } = getSchedulingContext();
+    if (args.include) {
+      const cred = await getDb()
+        .select()
+        .from(schema.schedulingCredentials)
+        .where(eq(schema.schedulingCredentials.id, args.credentialId));
+      if (!cred[0]) throw new Error("Credential not found");
+      await getDb().insert(schema.selectedCalendars).values({
+        id: nanoid(),
+        credentialId: args.credentialId,
+        userEmail: currentUserEmail(),
+        externalId: args.externalId,
+        integration: cred[0].type,
+        createdAt: new Date().toISOString(),
+      });
+    } else {
+      await getDb()
+        .delete(schema.selectedCalendars)
+        .where(
+          and(
+            eq(schema.selectedCalendars.credentialId, args.credentialId),
+            eq(schema.selectedCalendars.externalId, args.externalId),
+          ),
+        );
+    }
+    return { ok: true };
+  },
+});

package/src/actions/toggle-workflow.ts

@@ -0,0 +1,25 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { eq } from "drizzle-orm";
+import { assertAccess } from "@agent-native/core/sharing";
+import { getSchedulingContext } from "../server/context.js";
+
+export default defineAction({
+  description: "Toggle a workflow's disabled state",
+  schema: z.object({ id: z.string(), disabled: z.boolean().optional() }),
+  run: async (args) => {
+    await assertAccess("workflow", args.id, "editor");
+    const { getDb, schema } = getSchedulingContext();
+    const rows = await getDb()
+      .select()
+      .from(schema.workflows)
+      .where(eq(schema.workflows.id, args.id));
+    if (!rows[0]) throw new Error("Workflow not found");
+    const newDisabled = args.disabled ?? !rows[0].disabled;
+    await getDb()
+      .update(schema.workflows)
+      .set({ disabled: newDisabled, updatedAt: new Date().toISOString() })
+      .where(eq(schema.workflows.id, args.id));
+    return { disabled: newDisabled };
+  },
+});

package/src/actions/update-event-type.ts

@@ -0,0 +1,54 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { assertAccess } from "@agent-native/core/sharing";
+import { updateEventType } from "../server/event-types-repo.js";
+
+export default defineAction({
+  description: "Update one or more fields on an event type",
+  schema: z.object({
+    id: z.string(),
+    title: z.string().optional(),
+    slug: z.string().optional(),
+    description: z.string().nullable().optional(),
+    length: z.coerce.number().optional(),
+    durations: z.array(z.number()).optional(),
+    hidden: z.boolean().optional(),
+    position: z.number().optional(),
+    schedulingType: z
+      .enum(["personal", "collective", "round-robin", "managed"])
+      .optional(),
+    scheduleId: z.string().nullable().optional(),
+    locations: z.array(z.any()).optional(),
+    customFields: z.array(z.any()).optional(),
+    minimumBookingNotice: z.number().optional(),
+    beforeEventBuffer: z.number().optional(),
+    afterEventBuffer: z.number().optional(),
+    slotInterval: z.number().nullable().optional(),
+    periodType: z.enum(["unlimited", "rolling", "range"]).optional(),
+    periodDays: z.number().nullable().optional(),
+    periodStartDate: z.string().nullable().optional(),
+    periodEndDate: z.string().nullable().optional(),
+    seatsPerTimeSlot: z.number().nullable().optional(),
+    requiresConfirmation: z.boolean().optional(),
+    disableGuests: z.boolean().optional(),
+    hideCalendarNotes: z.boolean().optional(),
+    successRedirectUrl: z.string().nullable().optional(),
+    bookingLimits: z.any().optional(),
+    lockTimeZoneToggle: z.boolean().optional(),
+    color: z.string().nullable().optional(),
+    eventName: z.string().nullable().optional(),
+    recurringEvent: z
+      .object({
+        rrule: z.string(),
+        count: z.number().optional(),
+        description: z.string().optional(),
+      })
+      .nullable()
+      .optional(),
+  }),
+  run: async (args) => {
+    const { id, ...patch } = args;
+    await assertAccess("event-type", id, "editor");
+    return { eventType: await updateEventType(id, patch as any) };
+  },
+});

package/src/actions/update-member-role.ts

@@ -0,0 +1,28 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { and, eq } from "drizzle-orm";
+import { getSchedulingContext } from "../server/context.js";
+import { assertTeamAdmin } from "./_helpers.js";
+
+export default defineAction({
+  description: "Update a team member's role",
+  schema: z.object({
+    teamId: z.string(),
+    email: z.string(),
+    role: z.enum(["owner", "admin", "member"]),
+  }),
+  run: async (args) => {
+    await assertTeamAdmin(args.teamId);
+    const { getDb, schema } = getSchedulingContext();
+    await getDb()
+      .update(schema.teamMembers)
+      .set({ role: args.role })
+      .where(
+        and(
+          eq(schema.teamMembers.teamId, args.teamId),
+          eq(schema.teamMembers.userEmail, args.email),
+        ),
+      );
+    return { ok: true };
+  },
+});

package/src/actions/update-profile.ts

@@ -0,0 +1,36 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { getSchedulingContext } from "../server/context.js";
+import { currentUserEmail } from "./_helpers.js";
+
+// Profile data lives in consumer-provided settings (not the scheduling schema);
+// this action delegates to the core `settings` subsystem via a well-known key.
+export default defineAction({
+  description:
+    "Update the current user's profile (name, bio, timezone, brand colors, etc.)",
+  schema: z.object({
+    name: z.string().optional(),
+    bio: z.string().optional(),
+    avatarUrl: z.string().optional(),
+    timezone: z.string().optional(),
+    weekStart: z.enum(["sunday", "monday"]).optional(),
+    timeFormat: z.enum(["12h", "24h"]).optional(),
+    brandColor: z.string().optional(),
+    darkBrandColor: z.string().optional(),
+    hideBranding: z.boolean().optional(),
+  }),
+  run: async (args) => {
+    // The consumer template wires a `profile-settings` settings key; we just
+    // read/merge/write it. Accessed via dynamic import to avoid a hard dep on
+    // the core settings API here (different consumers may use alternate stores).
+    const core: any = await import("@agent-native/core");
+    if (core.writeSetting) {
+      const existing = (await core.readSetting?.("profile-settings")) ?? {};
+      await core.writeSetting("profile-settings", {
+        ...(existing as object),
+        ...args,
+      });
+    }
+    return { ok: true, userEmail: currentUserEmail() };
+  },
+});

package/src/actions/update-routing-form.ts

@@ -0,0 +1,36 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { eq } from "drizzle-orm";
+import { assertAccess } from "@agent-native/core/sharing";
+import { getSchedulingContext } from "../server/context.js";
+
+export default defineAction({
+  description: "Update a routing form's metadata, fields, rules, or fallback",
+  schema: z.object({
+    id: z.string(),
+    name: z.string().optional(),
+    description: z.string().nullable().optional(),
+    disabled: z.boolean().optional(),
+    fields: z.array(z.any()).optional(),
+    rules: z.array(z.any()).optional(),
+    fallback: z.any().optional(),
+  }),
+  run: async (args) => {
+    await assertAccess("routing-form", args.id, "editor");
+    const { getDb, schema } = getSchedulingContext();
+    const set: any = { updatedAt: new Date().toISOString() };
+    if (args.name != null) set.name = args.name;
+    if (args.description !== undefined)
+      set.description = args.description ?? null;
+    if (args.disabled != null) set.disabled = args.disabled;
+    if (args.fields != null) set.fields = JSON.stringify(args.fields);
+    if (args.rules != null) set.rules = JSON.stringify(args.rules);
+    if (args.fallback !== undefined)
+      set.fallback = args.fallback ? JSON.stringify(args.fallback) : null;
+    await getDb()
+      .update(schema.routingForms)
+      .set(set)
+      .where(eq(schema.routingForms.id, args.id));
+    return { ok: true };
+  },
+});

package/src/actions/update-schedule.ts

@@ -0,0 +1,53 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { assertAccess } from "@agent-native/core/sharing";
+import { updateSchedule } from "../server/schedules-repo.js";
+
+export default defineAction({
+  description:
+    "Update a schedule's name, timezone, weekly availability, or date overrides",
+  schema: z.object({
+    id: z.string(),
+    name: z.string().optional(),
+    timezone: z.string().optional(),
+    isDefault: z.boolean().optional(),
+    weeklyAvailability: z
+      .array(
+        z.object({
+          day: z.number().min(0).max(6),
+          intervals: z.array(
+            z.object({
+              startTime: z.string(),
+              endTime: z.string(),
+            }),
+          ),
+        }),
+      )
+      .optional(),
+    dateOverrides: z
+      .array(
+        z.object({
+          date: z.string(),
+          intervals: z.array(
+            z.object({
+              startTime: z.string(),
+              endTime: z.string(),
+            }),
+          ),
+        }),
+      )
+      .optional(),
+  }),
+  run: async (args) => {
+    await assertAccess("schedule", args.id, "editor");
+    return {
+      schedule: await updateSchedule(args.id, {
+        name: args.name,
+        timezone: args.timezone,
+        isDefault: args.isDefault,
+        weeklyAvailability: args.weeklyAvailability as any,
+        dateOverrides: args.dateOverrides as any,
+      }),
+    };
+  },
+});

package/src/actions/update-workflow.ts

@@ -0,0 +1,89 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { nanoid } from "nanoid";
+import { eq } from "drizzle-orm";
+import { assertAccess } from "@agent-native/core/sharing";
+import { getSchedulingContext } from "../server/context.js";
+
+export default defineAction({
+  description:
+    "Update workflow name/trigger/active-event-types, or replace its steps",
+  schema: z.object({
+    id: z.string(),
+    name: z.string().optional(),
+    trigger: z
+      .enum([
+        "new-booking",
+        "before-event",
+        "after-event",
+        "reschedule",
+        "cancellation",
+        "no-show",
+      ])
+      .optional(),
+    disabled: z.boolean().optional(),
+    activeOnEventTypeIds: z.array(z.string()).optional(),
+    steps: z
+      .array(
+        z.object({
+          action: z.enum([
+            "email-host",
+            "email-attendee",
+            "email-address",
+            "sms-attendee",
+            "sms-host",
+            "sms-number",
+            "webhook",
+          ]),
+          offsetMinutes: z.number().default(0),
+          sendTo: z.string().optional(),
+          emailSubject: z.string().optional(),
+          emailBody: z.string().optional(),
+          smsBody: z.string().optional(),
+          webhookUrl: z.string().optional(),
+          template: z.string().optional(),
+        }),
+      )
+      .optional(),
+  }),
+  run: async (args) => {
+    await assertAccess("workflow", args.id, "editor");
+    const { getDb, schema } = getSchedulingContext();
+    const now = new Date().toISOString();
+    const set: any = { updatedAt: now };
+    if (args.name != null) set.name = args.name;
+    if (args.trigger != null) set.trigger = args.trigger;
+    if (args.disabled != null) set.disabled = args.disabled;
+    if (args.activeOnEventTypeIds != null)
+      set.activeOnEventTypeIds = JSON.stringify(args.activeOnEventTypeIds);
+    await getDb()
+      .update(schema.workflows)
+      .set(set)
+      .where(eq(schema.workflows.id, args.id));
+    if (args.steps) {
+      await getDb()
+        .delete(schema.workflowSteps)
+        .where(eq(schema.workflowSteps.workflowId, args.id));
+      for (let i = 0; i < args.steps.length; i++) {
+        const s = args.steps[i];
+        await getDb()
+          .insert(schema.workflowSteps)
+          .values({
+            id: nanoid(),
+            workflowId: args.id,
+            order: i,
+            action: s.action,
+            offsetMinutes: s.offsetMinutes,
+            sendTo: s.sendTo ?? null,
+            emailSubject: s.emailSubject ?? null,
+            emailBody: s.emailBody ?? null,
+            smsBody: s.smsBody ?? null,
+            webhookUrl: s.webhookUrl ?? null,
+            template: s.template ?? null,
+            createdAt: now,
+          });
+      }
+    }
+    return { ok: true };
+  },
+});

package/src/core/buffers.ts

@@ -0,0 +1,46 @@
+/**
+ * Buffer application.
+ *
+ * Buffers pad a slot with prep/cool-down time that the host needs but the
+ * attendee shouldn't see as part of the meeting. A before-event buffer
+ * means the slot reserves extra time before its displayed start; the slot
+ * itself is still shown at the true meeting time.
+ *
+ * The practical effect: a slot [10:00–10:30] with before=10 means the host
+ * is considered "busy" from 09:50 to 10:30, so it conflicts with a 09:00–09:50
+ * meeting only if THAT meeting also has an after-buffer.
+ */
+import type { BusyInterval } from "../shared/index.js";
+import { addMinutes } from "./time.js";
+
+/** Expand a busy interval to include before/after buffers. */
+export function applyBuffers(
+  busy: BusyInterval,
+  beforeMinutes: number,
+  afterMinutes: number,
+): BusyInterval {
+  return {
+    ...busy,
+    start: new Date(
+      addMinutes(new Date(busy.start), -beforeMinutes),
+    ).toISOString(),
+    end: new Date(addMinutes(new Date(busy.end), afterMinutes)).toISOString(),
+  };
+}
+
+/**
+ * Expand a proposed slot window (start→end) to include the event type's
+ * before/after buffers. The expanded window is what collision detection
+ * uses; the displayed slot remains the unexpanded window.
+ */
+export function expandSlotForConflictCheck(
+  start: Date,
+  end: Date,
+  beforeMinutes: number,
+  afterMinutes: number,
+): { start: Date; end: Date } {
+  return {
+    start: addMinutes(start, -beforeMinutes),
+    end: addMinutes(end, afterMinutes),
+  };
+}

package/src/core/conflicts.ts

@@ -0,0 +1,49 @@
+/**
+ * Conflict detection — does a proposed interval overlap any busy interval?
+ */
+import type { BusyInterval } from "../shared/index.js";
+import { overlaps } from "./time.js";
+
+export function hasConflict(
+  slot: { start: Date; end: Date },
+  busy: BusyInterval[],
+): boolean {
+  for (const b of busy) {
+    if (
+      overlaps(slot, {
+        start: new Date(b.start),
+        end: new Date(b.end),
+      })
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** Merge overlapping busy intervals into a canonical, non-overlapping set. */
+export function mergeBusy(busy: BusyInterval[]): BusyInterval[] {
+  if (busy.length === 0) return [];
+  const sorted = busy
+    .map((b) => ({
+      start: new Date(b.start),
+      end: new Date(b.end),
+      source: b.source,
+    }))
+    .sort((a, b) => a.start.getTime() - b.start.getTime());
+  const out: { start: Date; end: Date; source?: string }[] = [sorted[0]];
+  for (let i = 1; i < sorted.length; i++) {
+    const last = out[out.length - 1];
+    const cur = sorted[i];
+    if (cur.start <= last.end) {
+      if (cur.end > last.end) last.end = cur.end;
+    } else {
+      out.push(cur);
+    }
+  }
+  return out.map((b) => ({
+    start: b.start.toISOString(),
+    end: b.end.toISOString(),
+    source: b.source,
+  }));
+}

package/src/core/index.ts

@@ -0,0 +1,8 @@
+export * from "./time.js";
+export * from "./rules.js";
+export * from "./buffers.js";
+export * from "./limits.js";
+export * from "./conflicts.js";
+export * from "./round-robin.js";
+export * from "./rrule.js";
+export * from "./slots.js";

package/src/core/limits.ts

@@ -0,0 +1,60 @@
+/**
+ * Booking limits enforcement.
+ *
+ * Limits constrain how many bookings an event type can receive in a time
+ * window (day / week / month / year). We pass in existing booking counts
+ * per bucket and return a function that tells us whether a proposed start
+ * time would exceed any limit.
+ */
+import type { BookingLimits } from "../shared/index.js";
+import { TZDate } from "@date-fns/tz";
+import { startOfWeek, startOfMonth, startOfYear, format } from "date-fns";
+
+export interface BookingCounts {
+  perDay: Record<string, number>;
+  perWeek: Record<string, number>;
+  perMonth: Record<string, number>;
+  perYear: Record<string, number>;
+}
+
+export function bucketKeysForSlot(
+  slotStart: Date,
+  timezone: string,
+  weekStartsOn: 0 | 1 = 0,
+): { day: string; week: string; month: string; year: string } {
+  const local = new TZDate(slotStart.getTime(), timezone);
+  const day = format(local, "yyyy-MM-dd");
+  const week = format(startOfWeek(local, { weekStartsOn }), "yyyy-MM-dd");
+  const month = format(startOfMonth(local), "yyyy-MM");
+  const year = format(startOfYear(local), "yyyy");
+  return { day, week, month, year };
+}
+
+export function exceedsLimits(
+  slotStart: Date,
+  timezone: string,
+  limits: BookingLimits | undefined,
+  counts: BookingCounts,
+  weekStartsOn: 0 | 1 = 0,
+): boolean {
+  if (!limits) return false;
+  const keys = bucketKeysForSlot(slotStart, timezone, weekStartsOn);
+  if (limits.perDay != null && (counts.perDay[keys.day] ?? 0) >= limits.perDay)
+    return true;
+  if (
+    limits.perWeek != null &&
+    (counts.perWeek[keys.week] ?? 0) >= limits.perWeek
+  )
+    return true;
+  if (
+    limits.perMonth != null &&
+    (counts.perMonth[keys.month] ?? 0) >= limits.perMonth
+  )
+    return true;
+  if (
+    limits.perYear != null &&
+    (counts.perYear[keys.year] ?? 0) >= limits.perYear
+  )
+    return true;
+  return false;
+}