@agent-native/scheduling 0.1.1

package/src/actions/create-booking.ts

@@ -0,0 +1,62 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import {
+  getEventTypeById,
+  getEventTypeBySlug,
+} from "../server/event-types-repo.js";
+import { createBooking } from "../server/booking-service.js";
+import { currentOrgId } from "./_helpers.js";
+
+export default defineAction({
+  description:
+    "Create a booking. Either pass eventTypeId, or (ownerEmail|teamId)+slug.",
+  schema: z.object({
+    eventTypeId: z.string().optional(),
+    slug: z.string().optional(),
+    ownerEmail: z.string().optional(),
+    teamId: z.string().optional(),
+    startTime: z.string(),
+    endTime: z.string(),
+    timezone: z.string().default("UTC"),
+    attendeeName: z.string(),
+    attendeeEmail: z.string(),
+    attendeeTimezone: z.string().optional(),
+    guests: z
+      .array(z.object({ name: z.string(), email: z.string() }))
+      .optional(),
+    customResponses: z.record(z.string(), z.any()).optional(),
+    description: z.string().optional(),
+  }),
+  run: async (args) => {
+    const eventType = args.eventTypeId
+      ? await getEventTypeById(args.eventTypeId)
+      : args.slug
+        ? await getEventTypeBySlug({
+            slug: args.slug,
+            ownerEmail: args.ownerEmail,
+            teamId: args.teamId,
+          })
+        : null;
+    if (!eventType) throw new Error("Event type not found");
+    const hostEmail = args.ownerEmail ?? eventType.ownerEmail ?? "";
+    if (!hostEmail) throw new Error("Cannot resolve host for booking");
+    return {
+      booking: await createBooking({
+        eventType,
+        hostEmail,
+        startTime: args.startTime,
+        endTime: args.endTime,
+        timezone: args.timezone,
+        attendee: {
+          email: args.attendeeEmail,
+          name: args.attendeeName,
+          timezone: args.attendeeTimezone,
+        },
+        guests: args.guests?.map((g) => ({ email: g.email, name: g.name })),
+        customResponses: args.customResponses,
+        description: args.description,
+        orgId: currentOrgId(),
+      }),
+    };
+  },
+});

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

@@ -0,0 +1,45 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { createEventType } from "../server/event-types-repo.js";
+import { currentUserEmail, currentOrgId } from "./_helpers.js";
+
+export default defineAction({
+  description: "Create a new event type",
+  schema: z.object({
+    title: z.string(),
+    slug: z.string(),
+    length: z.coerce.number().default(30),
+    description: z.string().optional(),
+    teamId: z.string().optional(),
+    schedulingType: z
+      .enum(["personal", "collective", "round-robin", "managed"])
+      .optional(),
+    scheduleId: z.string().optional(),
+    color: z.string().optional(),
+    recurringEvent: z
+      .object({
+        rrule: z.string(),
+        count: z.number().optional(),
+        description: z.string().optional(),
+      })
+      .optional(),
+  }),
+  run: async (args) => {
+    const ownerEmail = args.teamId ? undefined : currentUserEmail();
+    return {
+      eventType: await createEventType({
+        ownerEmail,
+        teamId: args.teamId,
+        orgId: currentOrgId(),
+        title: args.title,
+        slug: args.slug.toLowerCase(),
+        length: args.length,
+        description: args.description,
+        schedulingType: args.schedulingType,
+        scheduleId: args.scheduleId,
+        color: args.color,
+        recurringEvent: args.recurringEvent,
+      }),
+    };
+  },
+});

package/src/actions/create-host-group.ts

@@ -0,0 +1,25 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { nanoid } from "nanoid";
+import { getSchedulingContext } from "../server/context.js";
+
+export default defineAction({
+  description: "Create a host group within an event type",
+  schema: z.object({
+    eventTypeId: z.string(),
+    name: z.string(),
+    userEmails: z.array(z.string()).optional(),
+  }),
+  run: async (args) => {
+    const { getDb, schema } = getSchedulingContext();
+    const id = nanoid();
+    const now = new Date().toISOString();
+    await getDb().insert(schema.eventTypeHostGroups).values({
+      id,
+      eventTypeId: args.eventTypeId,
+      name: args.name,
+      createdAt: now,
+    });
+    return { id };
+  },
+});

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

@@ -0,0 +1,39 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { nanoid } from "nanoid";
+import { getSchedulingContext } from "../server/context.js";
+import { currentUserEmail, currentOrgId } from "./_helpers.js";
+
+export default defineAction({
+  description: "Create a routing form",
+  schema: z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    teamId: z.string().optional(),
+    fields: z.array(z.any()).default([]),
+    rules: z.array(z.any()).default([]),
+    fallback: z.any().optional(),
+  }),
+  run: async (args) => {
+    const { getDb, schema } = getSchedulingContext();
+    const id = nanoid();
+    const now = new Date().toISOString();
+    await getDb()
+      .insert(schema.routingForms)
+      .values({
+        id,
+        name: args.name,
+        description: args.description ?? null,
+        teamId: args.teamId ?? null,
+        disabled: false,
+        fields: JSON.stringify(args.fields),
+        rules: JSON.stringify(args.rules),
+        fallback: args.fallback ? JSON.stringify(args.fallback) : null,
+        ownerEmail: args.teamId ? null : currentUserEmail(),
+        orgId: currentOrgId() ?? null,
+        createdAt: now,
+        updatedAt: now,
+      });
+    return { id };
+  },
+});

package/src/actions/create-schedule.ts

@@ -0,0 +1,36 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { createSchedule } from "../server/schedules-repo.js";
+import { currentUserEmail, currentOrgId } from "./_helpers.js";
+
+export default defineAction({
+  description: "Create a new availability schedule",
+  schema: z.object({
+    name: z.string(),
+    timezone: z.string().default("UTC"),
+    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(),
+  }),
+  run: async (args) => ({
+    schedule: await createSchedule({
+      ownerEmail: currentUserEmail(),
+      orgId: currentOrgId(),
+      name: args.name,
+      timezone: args.timezone,
+      isDefault: args.isDefault,
+      weeklyAvailability: args.weeklyAvailability as any,
+    }),
+  }),
+});

package/src/actions/create-team.ts

@@ -0,0 +1,44 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { nanoid } from "nanoid";
+import { getSchedulingContext } from "../server/context.js";
+import { currentUserEmail, currentOrgId } from "./_helpers.js";
+
+export default defineAction({
+  description: "Create a new team",
+  schema: z.object({
+    name: z.string(),
+    slug: z.string(),
+    bio: z.string().optional(),
+  }),
+  run: async (args) => {
+    const { getDb, schema } = getSchedulingContext();
+    const id = nanoid();
+    const now = new Date().toISOString();
+    const ownerEmail = currentUserEmail();
+    await getDb()
+      .insert(schema.teams)
+      .values({
+        id,
+        slug: args.slug.toLowerCase(),
+        name: args.name,
+        bio: args.bio ?? null,
+        hideBranding: false,
+        createdAt: now,
+        updatedAt: now,
+        ownerEmail,
+        orgId: currentOrgId() ?? null,
+      });
+    // Owner is automatically a member with owner role
+    await getDb().insert(schema.teamMembers).values({
+      id: nanoid(),
+      teamId: id,
+      userEmail: ownerEmail,
+      role: "owner",
+      accepted: true,
+      invitedAt: now,
+      joinedAt: now,
+    });
+    return { team: { id, slug: args.slug, name: args.name } };
+  },
+});

package/src/actions/create-workflow.ts

@@ -0,0 +1,83 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { nanoid } from "nanoid";
+import { getSchedulingContext } from "../server/context.js";
+import { currentUserEmail, currentOrgId } from "./_helpers.js";
+
+export default defineAction({
+  description: "Create a workflow with optional initial steps",
+  schema: z.object({
+    name: z.string(),
+    trigger: z.enum([
+      "new-booking",
+      "before-event",
+      "after-event",
+      "reschedule",
+      "cancellation",
+      "no-show",
+    ]),
+    teamId: z.string().optional(),
+    activeOnEventTypeIds: z.array(z.string()).default([]),
+    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(),
+        }),
+      )
+      .default([]),
+  }),
+  run: async (args) => {
+    const { getDb, schema } = getSchedulingContext();
+    const id = nanoid();
+    const now = new Date().toISOString();
+    await getDb()
+      .insert(schema.workflows)
+      .values({
+        id,
+        name: args.name,
+        trigger: args.trigger,
+        teamId: args.teamId ?? null,
+        activeOnEventTypeIds: JSON.stringify(args.activeOnEventTypeIds),
+        disabled: false,
+        ownerEmail: args.teamId ? null : currentUserEmail(),
+        orgId: currentOrgId() ?? null,
+        createdAt: now,
+        updatedAt: now,
+      });
+    for (let i = 0; i < args.steps.length; i++) {
+      const s = args.steps[i];
+      await getDb()
+        .insert(schema.workflowSteps)
+        .values({
+          id: nanoid(),
+          workflowId: 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 { id };
+  },
+});

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

@@ -0,0 +1,14 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { assertAccess } from "@agent-native/core/sharing";
+import { deleteEventType } from "../server/event-types-repo.js";
+
+export default defineAction({
+  description: "Delete an event type",
+  schema: z.object({ id: z.string() }),
+  run: async (args) => {
+    await assertAccess("event-type", args.id, "admin");
+    await deleteEventType(args.id);
+    return { ok: true };
+  },
+});

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

@@ -0,0 +1,21 @@
+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: "Delete a routing form and its responses",
+  schema: z.object({ id: z.string() }),
+  run: async (args) => {
+    await assertAccess("routing-form", args.id, "admin");
+    const { getDb, schema } = getSchedulingContext();
+    await getDb()
+      .delete(schema.routingFormResponses)
+      .where(eq(schema.routingFormResponses.formId, args.id));
+    await getDb()
+      .delete(schema.routingForms)
+      .where(eq(schema.routingForms.id, args.id));
+    return { ok: true };
+  },
+});

package/src/actions/delete-schedule.ts

@@ -0,0 +1,14 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { assertAccess } from "@agent-native/core/sharing";
+import { deleteSchedule } from "../server/schedules-repo.js";
+
+export default defineAction({
+  description: "Delete a schedule",
+  schema: z.object({ id: z.string() }),
+  run: async (args) => {
+    await assertAccess("schedule", args.id, "admin");
+    await deleteSchedule(args.id);
+    return { ok: true };
+  },
+});

package/src/actions/delete-workflow.ts

@@ -0,0 +1,21 @@
+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: "Delete a workflow and its steps",
+  schema: z.object({ id: z.string() }),
+  run: async (args) => {
+    await assertAccess("workflow", args.id, "admin");
+    const { getDb, schema } = getSchedulingContext();
+    await getDb()
+      .delete(schema.workflowSteps)
+      .where(eq(schema.workflowSteps.workflowId, args.id));
+    await getDb()
+      .delete(schema.workflows)
+      .where(eq(schema.workflows.id, args.id));
+    return { ok: true };
+  },
+});

package/src/actions/disconnect-calendar.ts

@@ -0,0 +1,22 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { eq } from "drizzle-orm";
+import { getSchedulingContext } from "../server/context.js";
+
+export default defineAction({
+  description: "Disconnect a calendar credential",
+  schema: z.object({ credentialId: z.string() }),
+  run: async (args) => {
+    const { getDb, schema } = getSchedulingContext();
+    await getDb()
+      .delete(schema.selectedCalendars)
+      .where(eq(schema.selectedCalendars.credentialId, args.credentialId));
+    await getDb()
+      .delete(schema.destinationCalendars)
+      .where(eq(schema.destinationCalendars.credentialId, args.credentialId));
+    await getDb()
+      .delete(schema.schedulingCredentials)
+      .where(eq(schema.schedulingCredentials.id, args.credentialId));
+    return { ok: true };
+  },
+});

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

@@ -0,0 +1,36 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import {
+  getEventTypeById,
+  createEventType,
+} from "../server/event-types-repo.js";
+import { currentUserEmail, currentOrgId } from "./_helpers.js";
+
+export default defineAction({
+  description: "Duplicate an event type with a new slug",
+  schema: z.object({
+    id: z.string(),
+    newSlug: z.string(),
+    newTitle: z.string().optional(),
+  }),
+  run: async (args) => {
+    const source = await getEventTypeById(args.id);
+    if (!source) throw new Error("Event type not found");
+    return {
+      eventType: await createEventType({
+        ownerEmail: source.teamId ? undefined : currentUserEmail(),
+        teamId: source.teamId,
+        orgId: currentOrgId(),
+        title: args.newTitle ?? `${source.title} (copy)`,
+        slug: args.newSlug.toLowerCase(),
+        length: source.length,
+        description: source.description,
+        schedulingType: source.schedulingType,
+        locations: source.locations,
+        customFields: source.customFields,
+        scheduleId: source.scheduleId,
+        color: source.color,
+      }),
+    };
+  },
+});

package/src/actions/export-bookings-csv.ts

@@ -0,0 +1,54 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { listBookings } from "../server/bookings-repo.js";
+import { currentUserEmail } from "./_helpers.js";
+
+export default defineAction({
+  description: "Export bookings to a CSV string",
+  schema: z.object({
+    from: z.string().optional(),
+    to: z.string().optional(),
+    status: z.string().optional(),
+  }),
+  run: async (args) => {
+    const bookings = await listBookings({
+      hostEmail: currentUserEmail(),
+      from: args.from,
+      to: args.to,
+      status: args.status as any,
+    });
+    const header = [
+      "uid",
+      "title",
+      "startTime",
+      "endTime",
+      "status",
+      "attendeeName",
+      "attendeeEmail",
+      "location",
+    ];
+    const lines = [header.join(",")];
+    for (const b of bookings) {
+      const a = b.attendees[0];
+      lines.push(
+        [
+          b.uid,
+          csvEscape(b.title),
+          b.startTime,
+          b.endTime,
+          b.status,
+          csvEscape(a?.name ?? ""),
+          csvEscape(a?.email ?? ""),
+          csvEscape(b.location?.kind ?? ""),
+        ].join(","),
+      );
+    }
+    return { csv: lines.join("\n"), count: bookings.length };
+  },
+});
+
+function csvEscape(s: string): string {
+  if (s == null) return "";
+  if (/[,"\n]/.test(s)) return `"${s.replace(/"/g, '""')}"`;
+  return s;
+}

package/src/actions/find-available-slot.ts

@@ -0,0 +1,40 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { getEventTypeById } from "../server/event-types-repo.js";
+import { getAvailableSlots } from "../server/availability-engine.js";
+import { currentUserEmail } from "./_helpers.js";
+
+export default defineAction({
+  description:
+    "Find the next available time slot for an event type, optionally near a preferred time",
+  schema: z.object({
+    eventTypeId: z.string(),
+    preferredTime: z.string().optional().describe("ISO 8601 preferred time"),
+    timezone: z.string().optional(),
+  }),
+  run: async (args) => {
+    const event = await getEventTypeById(args.eventTypeId);
+    if (!event) throw new Error("Event type not found");
+    const now = new Date();
+    const end = new Date(now.getTime() + 60 * 24 * 60 * 60 * 1000);
+    const slots = await getAvailableSlots({
+      eventType: event,
+      forUserEmail: event.ownerEmail ?? currentUserEmail(),
+      rangeStart: now,
+      rangeEnd: end,
+      viewerTimezone: args.timezone,
+    });
+    if (slots.length === 0) return { slot: null };
+    if (args.preferredTime) {
+      const target = new Date(args.preferredTime).getTime();
+      const nearest = slots.reduce((best, s) =>
+        Math.abs(new Date(s.start).getTime() - target) <
+        Math.abs(new Date(best.start).getTime() - target)
+          ? s
+          : best,
+      );
+      return { slot: nearest };
+    }
+    return { slot: slots[0] };
+  },
+});

package/src/actions/get-availability.ts

@@ -0,0 +1,20 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { aggregateBusy } from "../server/availability-engine.js";
+import { currentUserEmail } from "./_helpers.js";
+
+export default defineAction({
+  description: "Get aggregated busy intervals for a user over a range",
+  schema: z.object({
+    userEmail: z.string().optional(),
+    from: z.string(),
+    to: z.string(),
+  }),
+  run: async (args) => ({
+    busy: await aggregateBusy({
+      userEmail: args.userEmail ?? currentUserEmail(),
+      rangeStart: new Date(args.from),
+      rangeEnd: new Date(args.to),
+    }),
+  }),
+});

package/src/actions/get-booking.ts

@@ -0,0 +1,9 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { getBookingByUid } from "../server/bookings-repo.js";
+
+export default defineAction({
+  description: "Get a booking by uid",
+  schema: z.object({ uid: z.string() }),
+  run: async (args) => ({ booking: await getBookingByUid(args.uid) }),
+});

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

@@ -0,0 +1,29 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import {
+  getEventTypeById,
+  getEventTypeBySlug,
+} from "../server/event-types-repo.js";
+
+export default defineAction({
+  description: "Get a single event type by id or (owner+slug)",
+  schema: z.object({
+    id: z.string().optional(),
+    slug: z.string().optional(),
+    ownerEmail: z.string().optional(),
+    teamId: z.string().optional(),
+  }),
+  run: async (args) => {
+    if (args.id) return { eventType: await getEventTypeById(args.id) };
+    if (args.slug) {
+      return {
+        eventType: await getEventTypeBySlug({
+          slug: args.slug,
+          ownerEmail: args.ownerEmail,
+          teamId: args.teamId,
+        }),
+      };
+    }
+    throw new Error("Provide id or slug");
+  },
+});

package/src/actions/install-conferencing-app.ts

@@ -0,0 +1,29 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { nanoid } from "nanoid";
+import { getSchedulingContext } from "../server/context.js";
+import { currentUserEmail } from "./_helpers.js";
+
+export default defineAction({
+  description:
+    "Install a conferencing app (zero-OAuth apps like built-in video register immediately; OAuth apps start their flow)",
+  schema: z.object({
+    kind: z.enum(["builtin_video", "zoom_video", "google_meet", "teams_video"]),
+  }),
+  run: async (args) => {
+    const { getDb, schema } = getSchedulingContext();
+    const now = new Date().toISOString();
+    const id = nanoid();
+    await getDb().insert(schema.schedulingCredentials).values({
+      id,
+      type: args.kind,
+      userEmail: currentUserEmail(),
+      appId: args.kind,
+      isDefault: false,
+      invalid: false,
+      createdAt: now,
+      updatedAt: now,
+    });
+    return { credentialId: id };
+  },
+});