@agent-native/scheduling 0.1.1

package/src/actions/invite-team-member.ts

@@ -0,0 +1,30 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { nanoid } from "nanoid";
+import { getSchedulingContext } from "../server/context.js";
+import { assertTeamAdmin } from "./_helpers.js";
+
+export default defineAction({
+  description: "Invite a user to a team",
+  schema: z.object({
+    teamId: z.string(),
+    email: z.string(),
+    role: z.enum(["owner", "admin", "member"]).default("member"),
+  }),
+  run: async (args) => {
+    await assertTeamAdmin(args.teamId);
+    const { getDb, schema } = getSchedulingContext();
+    const token = nanoid(24);
+    const id = nanoid();
+    await getDb().insert(schema.teamMembers).values({
+      id,
+      teamId: args.teamId,
+      userEmail: args.email,
+      role: args.role,
+      accepted: false,
+      inviteToken: token,
+      invitedAt: new Date().toISOString(),
+    });
+    return { inviteToken: token, memberId: id };
+  },
+});

package/src/actions/list-bookings.ts

@@ -0,0 +1,36 @@
+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:
+    "List bookings the current user owns, hosts, has been shared on, or that match the active org's visibility — filtered by status / range",
+  schema: z.object({
+    status: z
+      .enum(["upcoming", "past", "unconfirmed", "cancelled", "confirmed"])
+      .or(z.literal("recurring"))
+      .optional(),
+    eventTypeId: z.string().optional(),
+    attendeeEmail: z.string().optional(),
+    from: z.string().optional(),
+    to: z.string().optional(),
+    limit: z.number().optional(),
+    /**
+     * If true, narrow to bookings where you are the host. Defaults to false
+     * so org-shared bookings + bookings shared with you appear too.
+     */
+    onlyMine: z.boolean().optional().default(false),
+  }),
+  run: async (args) => {
+    const email = currentUserEmail();
+    const { onlyMine, ...rest } = args;
+    return {
+      bookings: await listBookings({
+        ...rest,
+        useAccessFilter: true,
+        hostEmail: onlyMine ? email : undefined,
+      }),
+    };
+  },
+});

package/src/actions/list-calendar-integrations.ts

@@ -0,0 +1,26 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { eq } from "drizzle-orm";
+import { getSchedulingContext } from "../server/context.js";
+import { listCalendarProviders } from "../server/providers/registry.js";
+import { currentUserEmail } from "./_helpers.js";
+
+export default defineAction({
+  description: "List calendar integrations (available + installed)",
+  schema: z.object({}),
+  run: async () => {
+    const { getDb, schema } = getSchedulingContext();
+    const email = currentUserEmail();
+    const credentials = await getDb()
+      .select()
+      .from(schema.schedulingCredentials)
+      .where(eq(schema.schedulingCredentials.userEmail, email));
+    return {
+      available: listCalendarProviders().map((p) => ({
+        kind: p.kind,
+        label: p.label,
+      })),
+      installed: credentials,
+    };
+  },
+});

package/src/actions/list-event-types.ts

@@ -0,0 +1,31 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { listEventTypes } from "../server/event-types-repo.js";
+import { assertTeamMember, currentUserEmailOrNull } from "./_helpers.js";
+
+export default defineAction({
+  description:
+    "List event types visible to the current user — owned, shared, org-visible, or scoped to a team the user is a member of",
+  schema: z.object({
+    teamId: z.string().optional(),
+    includeHidden: z.boolean().optional().default(false),
+  }),
+  run: async (args) => {
+    if (!currentUserEmailOrNull()) return { eventTypes: [] };
+    if (args.teamId) {
+      await assertTeamMember(args.teamId);
+      return {
+        eventTypes: await listEventTypes({
+          teamId: args.teamId,
+          includeHidden: args.includeHidden,
+        }),
+      };
+    }
+    return {
+      eventTypes: await listEventTypes({
+        useAccessFilter: true,
+        includeHidden: args.includeHidden,
+      }),
+    };
+  },
+});

package/src/actions/list-routing-form-responses.ts

@@ -0,0 +1,24 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { eq, desc } from "drizzle-orm";
+import { getSchedulingContext } from "../server/context.js";
+
+export default defineAction({
+  description: "List responses to a routing form",
+  schema: z.object({ formId: z.string(), limit: z.number().optional() }),
+  run: async (args) => {
+    const { getDb, schema } = getSchedulingContext();
+    const rows = await getDb()
+      .select()
+      .from(schema.routingFormResponses)
+      .where(eq(schema.routingFormResponses.formId, args.formId))
+      .orderBy(desc(schema.routingFormResponses.createdAt))
+      .limit(args.limit ?? 100);
+    return {
+      responses: rows.map((r: any) => ({
+        ...r,
+        response: JSON.parse(r.response),
+      })),
+    };
+  },
+});

package/src/actions/list-routing-forms.ts

@@ -0,0 +1,34 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { and, eq } from "drizzle-orm";
+import { accessFilter } from "@agent-native/core/sharing";
+import { getSchedulingContext } from "../server/context.js";
+import { assertTeamMember, currentUserEmailOrNull } from "./_helpers.js";
+
+export default defineAction({
+  description:
+    "List routing forms visible to the current user — owned, shared, org-visible, or scoped to a team the user is a member of",
+  schema: z.object({ teamId: z.string().optional() }),
+  run: async (args) => {
+    const { getDb, schema } = getSchedulingContext();
+    if (!currentUserEmailOrNull()) return { forms: [] };
+    if (args.teamId) {
+      await assertTeamMember(args.teamId);
+      const rows = await getDb()
+        .select()
+        .from(schema.routingForms)
+        .where(
+          and(
+            eq(schema.routingForms.teamId, args.teamId),
+            accessFilter(schema.routingForms, schema.routingFormShares),
+          ),
+        );
+      return { forms: rows };
+    }
+    const rows = await getDb()
+      .select()
+      .from(schema.routingForms)
+      .where(accessFilter(schema.routingForms, schema.routingFormShares));
+    return { forms: rows };
+  },
+});

package/src/actions/list-schedules.ts

@@ -0,0 +1,16 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { listSchedules } from "../server/schedules-repo.js";
+import { currentUserEmailOrNull } from "./_helpers.js";
+
+export default defineAction({
+  description:
+    "List availability schedules visible to the current user — owned, shared, or matching org visibility",
+  schema: z.object({}),
+  run: async () => {
+    if (!currentUserEmailOrNull()) return { schedules: [] };
+    return {
+      schedules: await listSchedules({ useAccessFilter: true }),
+    };
+  },
+});

package/src/actions/list-selected-calendars.ts

@@ -0,0 +1,41 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { eq } from "drizzle-orm";
+import { getSchedulingContext } from "../server/context.js";
+import { getCalendarProvider } from "../server/providers/registry.js";
+
+export default defineAction({
+  description:
+    "List all calendars a credential has access to, with selected flag",
+  schema: z.object({ credentialId: z.string() }),
+  run: async (args) => {
+    const { getDb, schema } = getSchedulingContext();
+    const cred = await getDb()
+      .select()
+      .from(schema.schedulingCredentials)
+      .where(eq(schema.schedulingCredentials.id, args.credentialId));
+    if (!cred[0]) throw new Error("Credential not found");
+    const provider = getCalendarProvider(cred[0].type);
+    if (!provider) throw new Error(`No provider for ${cred[0].type}`);
+    const all = await provider.listCalendars({
+      credentialId: args.credentialId,
+    });
+    const selected = await getDb()
+      .select({ externalId: schema.selectedCalendars.externalId })
+      .from(schema.selectedCalendars)
+      .where(eq(schema.selectedCalendars.credentialId, args.credentialId));
+    const selectedSet = new Set(selected.map((r: any) => r.externalId));
+    const destination = await getDb()
+      .select({ externalId: schema.destinationCalendars.externalId })
+      .from(schema.destinationCalendars)
+      .where(eq(schema.destinationCalendars.credentialId, args.credentialId));
+    const destinationId = destination[0]?.externalId;
+    return {
+      calendars: all.map((c) => ({
+        ...c,
+        isSelected: selectedSet.has(c.externalId),
+        isDestination: c.externalId === destinationId,
+      })),
+    };
+  },
+});

package/src/actions/list-workflows.ts

@@ -0,0 +1,34 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { and, eq } from "drizzle-orm";
+import { accessFilter } from "@agent-native/core/sharing";
+import { getSchedulingContext } from "../server/context.js";
+import { assertTeamMember, currentUserEmailOrNull } from "./_helpers.js";
+
+export default defineAction({
+  description:
+    "List workflows visible to the current user — owned, shared, org-visible, or scoped to a team the user is a member of",
+  schema: z.object({ teamId: z.string().optional() }),
+  run: async (args) => {
+    const { getDb, schema } = getSchedulingContext();
+    if (!currentUserEmailOrNull()) return { workflows: [] };
+    if (args.teamId) {
+      await assertTeamMember(args.teamId);
+      const rows = await getDb()
+        .select()
+        .from(schema.workflows)
+        .where(
+          and(
+            eq(schema.workflows.teamId, args.teamId),
+            accessFilter(schema.workflows, schema.workflowShares),
+          ),
+        );
+      return { workflows: rows };
+    }
+    const rows = await getDb()
+      .select()
+      .from(schema.workflows)
+      .where(accessFilter(schema.workflows, schema.workflowShares));
+    return { workflows: rows };
+  },
+});

package/src/actions/mark-no-show.ts

@@ -0,0 +1,15 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { markNoShow } from "../server/booking-service.js";
+
+export default defineAction({
+  description: "Mark an attendee as no-show on a booking",
+  schema: z.object({
+    uid: z.string(),
+    attendeeEmail: z.string(),
+  }),
+  run: async (args) => {
+    await markNoShow(args.uid, args.attendeeEmail);
+    return { ok: true };
+  },
+});

package/src/actions/refresh-busy-times.ts

@@ -0,0 +1,26 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { eq } from "drizzle-orm";
+import { getSchedulingContext } from "../server/context.js";
+import { currentUserEmail } from "./_helpers.js";
+
+export default defineAction({
+  description:
+    "Bust the calendar cache for a user (force fresh busy-time lookup)",
+  schema: z.object({ userEmail: z.string().optional() }),
+  run: async (args) => {
+    const { getDb, schema } = getSchedulingContext();
+    const email = args.userEmail ?? currentUserEmail();
+    // Delete cache rows for all of this user's credentials
+    const creds = await getDb()
+      .select({ id: schema.schedulingCredentials.id })
+      .from(schema.schedulingCredentials)
+      .where(eq(schema.schedulingCredentials.userEmail, email));
+    for (const c of creds) {
+      await getDb()
+        .delete(schema.calendarCache)
+        .where(eq(schema.calendarCache.credentialId, c.id));
+    }
+    return { ok: true, credentialsBusted: creds.length };
+  },
+});

package/src/actions/remove-booking-attendee.ts

@@ -0,0 +1,24 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { and, eq } from "drizzle-orm";
+import { getBookingByUid } from "../server/bookings-repo.js";
+import { getSchedulingContext } from "../server/context.js";
+
+export default defineAction({
+  description: "Remove an attendee from a booking",
+  schema: z.object({ uid: z.string(), email: z.string() }),
+  run: async (args) => {
+    const booking = await getBookingByUid(args.uid);
+    if (!booking) throw new Error(`Booking ${args.uid} not found`);
+    const { getDb, schema } = getSchedulingContext();
+    await getDb()
+      .delete(schema.bookingAttendees)
+      .where(
+        and(
+          eq(schema.bookingAttendees.bookingId, booking.id),
+          eq(schema.bookingAttendees.email, args.email),
+        ),
+      );
+    return { booking: await getBookingByUid(args.uid) };
+  },
+});

package/src/actions/remove-date-override.ts

@@ -0,0 +1,15 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { removeDateOverride } from "../server/schedules-repo.js";
+
+export default defineAction({
+  description: "Remove a date-specific override from a schedule",
+  schema: z.object({
+    scheduleId: z.string(),
+    date: z.string(),
+  }),
+  run: async (args) => {
+    await removeDateOverride(args.scheduleId, args.date);
+    return { ok: true };
+  },
+});

package/src/actions/remove-team-member.ts

@@ -0,0 +1,23 @@
+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: "Remove a user from a team",
+  schema: z.object({ teamId: z.string(), email: z.string() }),
+  run: async (args) => {
+    await assertTeamAdmin(args.teamId);
+    const { getDb, schema } = getSchedulingContext();
+    await getDb()
+      .delete(schema.teamMembers)
+      .where(
+        and(
+          eq(schema.teamMembers.teamId, args.teamId),
+          eq(schema.teamMembers.userEmail, args.email),
+        ),
+      );
+    return { ok: true };
+  },
+});

package/src/actions/reorder-event-types.ts

@@ -0,0 +1,18 @@
+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: "Reorder event types by passing the desired id order",
+  schema: z.object({ ids: z.array(z.string()) }),
+  run: async (args) => {
+    for (let i = 0; i < args.ids.length; i++) {
+      await assertAccess("event-type", args.ids[i], "editor");
+    }
+    for (let i = 0; i < args.ids.length; i++) {
+      await updateEventType(args.ids[i], { position: i });
+    }
+    return { ok: true };
+  },
+});

package/src/actions/reschedule-booking.ts

@@ -0,0 +1,45 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { rescheduleBooking } from "../server/booking-service.js";
+import { getBookingByUid } from "../server/bookings-repo.js";
+import { currentUserEmailOrNull } from "./_helpers.js";
+
+export default defineAction({
+  description: "Reschedule a booking to a new start/end time",
+  schema: z.object({
+    uid: z.string(),
+    newStartTime: z.string(),
+    newEndTime: z.string(),
+    reason: z.string().optional(),
+    rescheduledBy: z.enum(["attendee", "host"]).optional(),
+    token: z.string().optional(),
+  }),
+  run: async (args) => ({
+    booking: await rescheduleBookingAfterAccessCheck(args),
+  }),
+});
+
+async function rescheduleBookingAfterAccessCheck(args: {
+  uid: string;
+  newStartTime: string;
+  newEndTime: string;
+  reason?: string;
+  rescheduledBy?: "attendee" | "host";
+  token?: string;
+}) {
+  const booking = await getBookingByUid(args.uid);
+  if (!booking) throw new Error(`Booking ${args.uid} not found`);
+  const userEmail = currentUserEmailOrNull();
+  const isHost = !!userEmail && userEmail === booking.hostEmail;
+  const hasToken = !!args.token && args.token === booking.rescheduleToken;
+  if (!isHost && !hasToken) {
+    throw new Error("Not authorized to reschedule this booking");
+  }
+  return rescheduleBooking({
+    uid: args.uid,
+    newStartTime: args.newStartTime,
+    newEndTime: args.newEndTime,
+    reason: args.reason,
+    rescheduledBy: args.rescheduledBy,
+  });
+}

package/src/actions/revoke-private-link.ts

@@ -0,0 +1,16 @@
+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: "Revoke a private hashed link",
+  schema: z.object({ hash: z.string() }),
+  run: async (args) => {
+    const { getDb, schema } = getSchedulingContext();
+    await getDb()
+      .delete(schema.hashedLinks)
+      .where(eq(schema.hashedLinks.hash, args.hash));
+    return { ok: true };
+  },
+});

package/src/actions/send-reschedule-link.ts

@@ -0,0 +1,18 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { getBookingByUid } from "../server/bookings-repo.js";
+import { getSchedulingContext } from "../server/context.js";
+
+export default defineAction({
+  description:
+    "Return the public reschedule URL for a booking (send it to an attendee)",
+  schema: z.object({ uid: z.string() }),
+  run: async (args) => {
+    const booking = await getBookingByUid(args.uid);
+    if (!booking) throw new Error(`Booking ${args.uid} not found`);
+    const baseUrl = getSchedulingContext().publicBaseUrl ?? "";
+    return {
+      url: `${baseUrl}/reschedule/${booking.uid}?token=${booking.rescheduleToken}`,
+    };
+  },
+});

package/src/actions/set-appearance.ts

@@ -0,0 +1,24 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+export default defineAction({
+  description:
+    "Set appearance settings (theme, brand colors, hide branding) — a convenience wrapper over update-profile",
+  schema: z.object({
+    theme: z.enum(["light", "dark", "system"]).optional(),
+    brandColor: z.string().optional(),
+    darkBrandColor: z.string().optional(),
+    hideBranding: z.boolean().optional(),
+  }),
+  run: async (args) => {
+    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 };
+  },
+});

package/src/actions/set-default-conferencing-app.ts

@@ -0,0 +1,25 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { and, eq } from "drizzle-orm";
+import { getSchedulingContext } from "../server/context.js";
+import { currentUserEmail } from "./_helpers.js";
+
+export default defineAction({
+  description: "Mark a video app credential as the user's default",
+  schema: z.object({ credentialId: z.string() }),
+  run: async (args) => {
+    const { getDb, schema } = getSchedulingContext();
+    const email = currentUserEmail();
+    const allVideo = await getDb()
+      .select()
+      .from(schema.schedulingCredentials)
+      .where(eq(schema.schedulingCredentials.userEmail, email));
+    for (const c of allVideo) {
+      await getDb()
+        .update(schema.schedulingCredentials)
+        .set({ isDefault: c.id === args.credentialId })
+        .where(eq(schema.schedulingCredentials.id, c.id));
+    }
+    return { ok: true };
+  },
+});

package/src/actions/set-default-schedule.ts

@@ -0,0 +1,15 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { assertAccess } from "@agent-native/core/sharing";
+import { setDefaultSchedule } from "../server/schedules-repo.js";
+import { currentUserEmail } from "./_helpers.js";
+
+export default defineAction({
+  description: "Mark a schedule as the user's default",
+  schema: z.object({ id: z.string() }),
+  run: async (args) => {
+    await assertAccess("schedule", args.id, "editor");
+    await setDefaultSchedule(currentUserEmail(), args.id);
+    return { ok: true };
+  },
+});

package/src/actions/set-destination-calendar.ts

@@ -0,0 +1,39 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { eq } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { getSchedulingContext } from "../server/context.js";
+import { currentUserEmail } from "./_helpers.js";
+
+export default defineAction({
+  description:
+    "Set the destination calendar for new events (optionally scoped to an event type)",
+  schema: z.object({
+    credentialId: z.string(),
+    externalId: z.string(),
+    eventTypeId: z.string().optional(),
+  }),
+  run: async (args) => {
+    const { getDb, schema } = getSchedulingContext();
+    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()
+      .delete(schema.destinationCalendars)
+      .where(eq(schema.destinationCalendars.credentialId, args.credentialId));
+    await getDb()
+      .insert(schema.destinationCalendars)
+      .values({
+        id: nanoid(),
+        credentialId: args.credentialId,
+        userEmail: currentUserEmail(),
+        integration: cred[0].type,
+        externalId: args.externalId,
+        eventTypeId: args.eventTypeId ?? null,
+        createdAt: new Date().toISOString(),
+      });
+    return { ok: true };
+  },
+});

package/src/actions/set-event-type-hosts.ts

@@ -0,0 +1,43 @@
+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: "Set the hosts assigned to an event type",
+  schema: z.object({
+    eventTypeId: z.string(),
+    hosts: z.array(
+      z.object({
+        userEmail: z.string(),
+        isFixed: z.boolean().optional().default(false),
+        weight: z.number().optional().default(1),
+        priority: z.number().optional().default(2),
+        scheduleId: z.string().optional(),
+      }),
+    ),
+  }),
+  run: async (args) => {
+    await assertAccess("event-type", args.eventTypeId, "editor");
+    const { getDb, schema } = getSchedulingContext();
+    const now = new Date().toISOString();
+    await getDb()
+      .delete(schema.eventTypeHosts)
+      .where(eq(schema.eventTypeHosts.eventTypeId, args.eventTypeId));
+    for (const h of args.hosts) {
+      await getDb()
+        .insert(schema.eventTypeHosts)
+        .values({
+          eventTypeId: args.eventTypeId,
+          userEmail: h.userEmail,
+          isFixed: h.isFixed ?? false,
+          weight: h.weight ?? 1,
+          priority: h.priority ?? 2,
+          scheduleId: h.scheduleId ?? null,
+          createdAt: now,
+        });
+    }
+    return { ok: true };
+  },
+});

package/src/actions/set-event-type-location.ts

@@ -0,0 +1,18 @@
+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: "Set the location(s) on an event type",
+  schema: z.object({
+    id: z.string(),
+    locations: z.array(z.any()),
+  }),
+  run: async (args) => {
+    await assertAccess("event-type", args.id, "editor");
+    return {
+      eventType: await updateEventType(args.id, { locations: args.locations }),
+    };
+  },
+});