@clubnet/seedclub 0.2.26 → 0.2.28

package/README.md

@@ -68,6 +68,7 @@ The normal interactive flow is:
 | `/login` | Sign in to a model provider for the underlying agent |
 | `/model` | Choose which model to use |
 | `/connect` | Connect your Seed Club account |
+| `/connect-calendar` | Connect a personal Google Calendar to your Seed Club account |
 | `/seedclub` | Main menu — connect, inspect access, and jump into CRM/meetings/media/headlines workflows |
 | `/transcripts` | Export transcript VTT files with filters (date, person, time, output dir) |
 
@@ -81,6 +82,8 @@ There are two separate auth layers in the product:
    This signs you into the LLM provider you want the agent to use.
 2. Seed Club auth: `/connect`
    This connects the CLI to your Seed Club account so Seed Club tools and commands can read and write account data.
+3. Personal calendar connect: `/connect-calendar`
+   This connects a Google Calendar to your Seed Club account for booking and availability workflows. It is only needed if you want the agent to schedule using your personal calendar.
 
 `/seedclub` is the main entry point for Seed Club actions. If you are not connected yet, it will start the Seed Club connect flow automatically.
 

package/assets/extensions/seedclub/commands/seedclub.ts

@@ -16,6 +16,7 @@ import { getCurrentUser, getSessionContext } from "../tools/utility.js";
 
 interface SeedclubDeps {
 	connect: (args: string | undefined, ctx: any) => Promise<void>;
+	connectCalendar: (ctx: any) => Promise<void>;
 	disconnect: (ctx: any) => Promise<void>;
 }
 
@@ -64,6 +65,13 @@ export function registerSeedclubCommand(pi: ExtensionAPI, deps: SeedclubDeps) {
 		},
 	});
 
+	pi.registerCommand("connect-calendar", {
+		description: "Connect a personal Google Calendar to your Seed Club account",
+		handler: async (_args, ctx) => {
+			await deps.connectCalendar(ctx);
+		},
+	});
+
 	pi.registerCommand("clearcontext", {
 		description: "Compact the current conversation to free context while keeping Seed Club state",
 		handler: async (_args, ctx) => {
@@ -129,6 +137,7 @@ export function registerSeedclubCommand(pi: ExtensionAPI, deps: SeedclubDeps) {
 				"Show API/Auth environment",
 				"Use local API/Auth",
 				"Use prod API/Auth",
+				"Connect personal calendar",
 				"Open CRM prompt",
 				"Open meetings prompt",
 				"Open transcripts prompt",
@@ -168,6 +177,9 @@ export function registerSeedclubCommand(pi: ExtensionAPI, deps: SeedclubDeps) {
 				case "Use prod API/Auth":
 					await setSeedEnvironment("prod", ctx);
 					break;
+				case "Connect personal calendar":
+					await deps.connectCalendar(ctx);
+					break;
 				case "Open CRM prompt":
 					await new Promise((r) => setTimeout(r, 300));
 					ctx.ui.setEditorText("List CRM records for my workspace.");

package/assets/extensions/seedclub/index.ts

@@ -8,7 +8,7 @@
 import { randomBytes } from "node:crypto";
 import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { clearCredentials, setCachedToken } from "./api-client.js";
+import { api, clearCredentials, setCachedToken } from "./api-client.js";
 import { getApiBase, getAuthBase, getStoredBases, getStoredToken, storeToken } from "./auth.js";
 import { registerSeedclubCommand } from "./commands/seedclub.js";
 import { registerTranscriptsCommand } from "./commands/transcripts.js";
@@ -26,6 +26,19 @@ export default function (pi: ExtensionAPI) {
 		return label;
 	};
 
+	type PersonalCalendarAccount = {
+		display_name?: string | null;
+		external_account_id?: string | null;
+		id: string;
+		is_active?: boolean;
+		platform?: string | null;
+		username?: string | null;
+	};
+
+	type PersonalCalendarAccountsResponse = {
+		data?: PersonalCalendarAccount[];
+	};
+
 	// Tools
 	registerUtilityTools(pi);
 	registerCrmTools(pi);
@@ -36,7 +49,7 @@ export default function (pi: ExtensionAPI) {
 	registerBrandingGuard(pi);
 
 	// Commands — /connect, /seedclub menu, and transcript export
-	registerSeedclubCommand(pi, { connect, disconnect });
+	registerSeedclubCommand(pi, { connect, connectCalendar, disconnect });
 	registerTranscriptsCommand(pi);
 	registerClipStatusCommand(pi);
 	// Transcript intent interceptor (metadata-first export flow).
@@ -93,10 +106,7 @@ export default function (pi: ExtensionAPI) {
 
 		ctx.ui.notify("Opening browser to sign in...", "info");
 
-		const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-		pi.exec(openCmd, [authUrl]).catch(() => {
-			ctx.ui.notify(`Open this link:\n${authUrl}`, "info");
-		});
+		openExternalUrl(pi, authUrl, ctx);
 
 		try {
 			const result = await waitForCallback(port, state);
@@ -112,6 +122,76 @@ export default function (pi: ExtensionAPI) {
 		ctx.ui.notify("Logged out", "info");
 	}
 
+	async function listConnectedPersonalCalendars(ctx: any, options?: { notifyOnFailure?: boolean }) {
+		try {
+			const existing = await api.get<PersonalCalendarAccountsResponse>("/me/integrations/accounts", {
+				platform: "google_calendar",
+			});
+			return Array.isArray(existing.data) ? existing.data : [];
+		} catch (error) {
+			if (options?.notifyOnFailure !== false) {
+				const message = error instanceof Error ? error.message : "";
+				ctx.ui.notify(
+					message
+						? `Could not check existing calendar connection: ${message}`
+						: "Could not check existing calendar connection.",
+					"info",
+				);
+			}
+			return null;
+		}
+	}
+
+	async function connectCalendar(ctx: any) {
+		const connectedCalendars = await listConnectedPersonalCalendars(ctx);
+
+		if (connectedCalendars && connectedCalendars.length > 0) {
+			const label =
+				connectedCalendars[0]?.display_name ||
+				connectedCalendars[0]?.username ||
+				connectedCalendars[0]?.external_account_id ||
+				"your Google Calendar";
+			ctx.ui.notify(`Personal calendar already connected: ${label}`, "info");
+			return;
+		}
+
+		const port = await findAvailablePort();
+		const state = randomBytes(16).toString("hex");
+		const callbackUrl = `http://127.0.0.1:${port}/callback`;
+
+		type CalendarConnectResponse = {
+			authUrl: string;
+			callbackState?: string | null;
+			redirectUri: string;
+			returnTo?: string | null;
+			success: boolean;
+		};
+
+		let response: CalendarConnectResponse;
+		try {
+			response = await api.get<CalendarConnectResponse>("/me/integrations/google-calendar/connect", {
+				mode: "json",
+				callback_state: state,
+				callback_url: callbackUrl,
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unable to start calendar connect.";
+			ctx.ui.notify(message, "error");
+			return;
+		}
+
+		ctx.ui.notify("Opening browser to connect Google Calendar...", "info");
+		openExternalUrl(pi, response.authUrl, ctx);
+
+		try {
+			const result = await waitForCalendarCallback(port, state);
+			const label = result.accountLabel || result.accountUsername || "Google Calendar";
+			ctx.ui.notify(`Connected ${label}`, "info");
+		} catch (error) {
+			ctx.ui.notify(error instanceof Error ? error.message : "Calendar connect failed", "error");
+		}
+	}
+
 	async function verifyAndStore(token: string, ctx: any, emailHint?: string) {
 		const apiBase = getApiBase();
 		const authBase = getAuthBase();
@@ -221,6 +301,89 @@ function waitForCallback(port: number, state: string): Promise<{ token: string;
 	});
 }
 
+function openExternalUrl(pi: ExtensionAPI, url: string, ctx: any) {
+	const openCmd =
+		process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+
+	pi.exec(openCmd, [url]).catch(() => {
+		ctx.ui.notify(`Open this link:\n${url}`, "info");
+	});
+}
+
+function waitForCalendarCallback(
+	port: number,
+	state: string,
+): Promise<{ accountId: string | null; accountLabel: string | null; accountUsername: string | null }> {
+	return new Promise((resolve, reject) => {
+		const timeout = setTimeout(() => {
+			server.close();
+			reject(new Error("Timed out waiting for Google Calendar connection (5 min)."));
+		}, 300_000);
+
+		const server = createServer((req: IncomingMessage, res: ServerResponse) => {
+			const url = new URL(req.url || "/", `http://127.0.0.1:${port}`);
+			if (url.pathname !== "/callback") {
+				res.writeHead(404);
+				res.end();
+				return;
+			}
+
+			const done = (status: number, body: string) => {
+				res.writeHead(status, { "Content-Type": "text/html; charset=utf-8" });
+				res.end(body);
+				clearTimeout(timeout);
+				server.close();
+			};
+
+			if (url.searchParams.get("state") !== state) {
+				done(400, renderCallbackPage({
+					eyebrow: "Google Calendar",
+					title: "Connection couldn’t be verified.",
+					message: "The calendar callback state did not match this session. Return to Seed Club and try /connect-calendar again.",
+					status: "error",
+				}));
+				reject(new Error("Invalid calendar callback state."));
+				return;
+			}
+
+			const status = url.searchParams.get("status");
+			const error = url.searchParams.get("error");
+
+			if (status !== "success") {
+				done(400, renderCallbackPage({
+					eyebrow: "Google Calendar",
+					title: "Calendar connection failed.",
+					message: error || "Seed Club could not finish connecting your Google Calendar.",
+					status: "error",
+				}));
+				reject(new Error(error || "Google Calendar connection failed."));
+				return;
+			}
+
+			const accountLabel = url.searchParams.get("accountLabel");
+			const accountUsername = url.searchParams.get("accountUsername");
+
+			done(200, renderCallbackPage({
+				eyebrow: "Google Calendar",
+				title: "Your calendar is connected.",
+				message: `Connected ${escapeHtml(accountLabel || accountUsername || "your Google Calendar")} to your Seed Club account.`,
+				status: "success",
+			}));
+			resolve({
+				accountId: url.searchParams.get("accountId"),
+				accountLabel,
+				accountUsername,
+			});
+		});
+
+		server.listen(port, "127.0.0.1");
+		server.on("error", (err) => {
+			clearTimeout(timeout);
+			reject(err);
+		});
+	});
+}
+
 function escapeHtml(value: string): string {
 	return value
 		.replaceAll("&", "&amp;")

package/assets/extensions/seedclub/tools/meetings.ts

@@ -11,6 +11,9 @@ const DEFAULT_SHOW_RECORDINGS_LIMIT = 10;
 const MAX_SHOW_RECORDINGS_LIMIT = 25;
 const DEFAULT_TRANSCRIPT_LIMIT = 5;
 const MAX_TRANSCRIPT_LIMIT = 20;
+const DEFAULT_PEOPLE_SEARCH_LIMIT = 5;
+const MAX_PEOPLE_SEARCH_LIMIT = 10;
+const DEFAULT_BOOKING_DURATION_MINUTES = 20;
 const TRANSCRIPT_TEXT_PREVIEW_CHARS = 1800;
 const TRANSCRIPT_VTT_PREVIEW_CHARS = 1000;
 
@@ -53,6 +56,103 @@ function truncateText(value: string | null | undefined, maxChars: number) {
 	return `${value.slice(0, maxChars)}\n...[truncated ${value.length - maxChars} chars]`;
 }
 
+function resolveBookingEndsAt(
+	startsAt: string,
+	endsAt: string | null | undefined,
+	durationMinutes: number | null | undefined,
+) {
+	if (typeof endsAt === "string" && endsAt.trim()) {
+		return endsAt;
+	}
+
+	const startDate = new Date(startsAt);
+	if (Number.isNaN(startDate.getTime())) {
+		return endsAt ?? undefined;
+	}
+
+	const normalizedDuration =
+		typeof durationMinutes === "number" && Number.isFinite(durationMinutes) && durationMinutes > 0
+			? Math.round(durationMinutes)
+			: DEFAULT_BOOKING_DURATION_MINUTES;
+
+	return new Date(startDate.getTime() + normalizedDuration * 60 * 1000).toISOString();
+}
+
+function localMinutesToUTC(date: Date, minutes: number, timeZone: string) {
+	const year = date.getFullYear();
+	const month = date.getMonth();
+	const day = date.getDate();
+	const hours = Math.floor(minutes / 60);
+	const mins = minutes % 60;
+
+	const formatter = new Intl.DateTimeFormat("en-US", {
+		timeZone,
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit",
+		hour12: false,
+	});
+
+	const referenceUtc = new Date(Date.UTC(year, month, day, 12, 0, 0));
+	const parts = formatter.formatToParts(referenceUtc);
+	const tzYear = Number.parseInt(parts.find((part) => part.type === "year")?.value ?? "", 10);
+	const tzMonth = Number.parseInt(parts.find((part) => part.type === "month")?.value ?? "", 10) - 1;
+	const tzDay = Number.parseInt(parts.find((part) => part.type === "day")?.value ?? "", 10);
+	const tzHour = Number.parseInt(parts.find((part) => part.type === "hour")?.value ?? "", 10);
+	const tzMinute = Number.parseInt(parts.find((part) => part.type === "minute")?.value ?? "", 10);
+	const tzSecond = Number.parseInt(parts.find((part) => part.type === "second")?.value ?? "", 10);
+
+	const tzMillis = Date.UTC(tzYear, tzMonth, tzDay, tzHour, tzMinute, tzSecond);
+	const offset = referenceUtc.getTime() - tzMillis;
+	const desiredUtc = Date.UTC(year, month, day, hours, mins, 0);
+	return new Date(desiredUtc + offset);
+}
+
+function getDateDayOfWeek(date: Date, timeZone: string) {
+	const weekday = new Intl.DateTimeFormat("en-US", {
+		timeZone,
+		weekday: "short",
+	})
+		.formatToParts(date)
+		.find((part) => part.type === "weekday")?.value;
+
+	switch (weekday) {
+		case "Sun":
+			return 0;
+		case "Mon":
+			return 1;
+		case "Tue":
+			return 2;
+		case "Wed":
+			return 3;
+		case "Thu":
+			return 4;
+		case "Fri":
+			return 5;
+		case "Sat":
+			return 6;
+		default:
+			return date.getDay();
+	}
+}
+
+function formatSlotRange(startMinutes: number, endMinutes: number, timeZone: string) {
+	const formatter = new Intl.DateTimeFormat("en-US", {
+		timeZone,
+		hour: "numeric",
+		minute: "2-digit",
+		hour12: true,
+		timeZoneName: "short",
+	});
+	const anchor = new Date(Date.UTC(2026, 0, 5, 12, 0, 0));
+	const start = localMinutesToUTC(anchor, startMinutes, timeZone);
+	const end = localMinutesToUTC(anchor, endMinutes, timeZone);
+	return `${formatter.format(start)} - ${formatter.format(end)}`;
+}
+
 function shapeTranscriptSource(source: any, includeFullText: boolean, includePreview = true) {
 	if (!source) {
 		return null;
@@ -1024,6 +1124,345 @@ async function getMeeting(args: { meetingId: string }) {
 	}
 }
 
+async function searchPeopleForBooking(args: {
+	query: string;
+	limit?: number;
+}) {
+	try {
+		const limit = normalizeLimit(args.limit, {
+			fallback: DEFAULT_PEOPLE_SEARCH_LIMIT,
+			max: MAX_PEOPLE_SEARCH_LIMIT,
+		});
+		const response = await api.get<any>("/core/parties", {
+			party_type: "person",
+			search: args.query,
+			limit,
+		});
+
+		return {
+			data: Array.isArray(response?.data)
+				? response.data.map((item: any) => ({
+						partyId: item?.party?.id ?? item?.party?.party_id ?? item?.person?.id ?? null,
+						displayName:
+							item?.person?.full_name ??
+							item?.party?.display_name ??
+							item?.organization?.name ??
+							null,
+						email: item?.person?.email ?? null,
+						avatarUrl: item?.person?.avatar_url ?? null,
+						twitterUsername: item?.person?.twitter_username ?? null,
+						organizationName:
+							item?.primary_org_role?.organization_name ??
+							item?.organization?.name ??
+							null,
+				  }))
+				: [],
+			pagination: response?.pagination ?? null,
+		};
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+async function listMeetingAvailabilitySlots(args: {
+	date: string;
+	programSlug?: string;
+	timeZone?: string;
+}) {
+	try {
+		const requestedDate = new Date(args.date);
+		if (Number.isNaN(requestedDate.getTime())) {
+			return { error: "date must be a valid ISO date or timestamp.", status: 400 };
+		}
+
+		const requestedTimeZone =
+			typeof args.timeZone === "string" && args.timeZone.trim()
+				? args.timeZone.trim()
+				: "America/New_York";
+		const dayOfWeek = getDateDayOfWeek(requestedDate, requestedTimeZone);
+		const response = await api.get<any>("/meetings/availability", {
+			program_slug: args.programSlug,
+			day_of_week: dayOfWeek,
+		});
+
+		const slots = Array.isArray(response?.data)
+			? response.data.map((window: any) => {
+					const slotTimeZone =
+						typeof window?.timezone === "string" && window.timezone.trim()
+							? window.timezone.trim()
+							: requestedTimeZone;
+					const startsAt = localMinutesToUTC(requestedDate, Number(window?.start_minutes ?? 0), slotTimeZone);
+					const endsAt = localMinutesToUTC(requestedDate, Number(window?.end_minutes ?? 0), slotTimeZone);
+
+					return {
+						id: window?.id ?? null,
+						label: formatSlotRange(
+							Number(window?.start_minutes ?? 0),
+							Number(window?.end_minutes ?? 0),
+							slotTimeZone,
+						),
+						timeZone: slotTimeZone,
+						startMinutes: window?.start_minutes ?? null,
+						endMinutes: window?.end_minutes ?? null,
+						startsAt: startsAt.toISOString(),
+						endsAt: endsAt.toISOString(),
+						displayRange: formatSlotRange(
+							Number(window?.start_minutes ?? 0),
+							Number(window?.end_minutes ?? 0),
+							slotTimeZone,
+						),
+					};
+			  })
+			: [];
+
+		return {
+			date: args.date,
+			dayOfWeek,
+			slots,
+		};
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+async function listMeetingCalendars(args: {
+	programSlug?: string;
+}) {
+	try {
+		return await api.get<any>("/meetings/calendars", {
+			program_slug: args.programSlug,
+		});
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+async function resolvePersonalCalendarAccountId(accountId?: string | null) {
+	const response = await api.get<any>("/me/integrations/accounts", {
+		platform: "google_calendar",
+	});
+	const accounts = Array.isArray(response?.data) ? response.data : [];
+	const activeAccounts = accounts.filter((account: any) => account?.is_active !== false);
+
+	if (!activeAccounts.length) {
+		throw new Error("No personal Google Calendar is connected. Run /connect-calendar first.");
+	}
+
+	const normalizedIdentifier = typeof accountId === "string" ? accountId.trim().toLowerCase() : "";
+
+	if (!normalizedIdentifier) {
+		if (activeAccounts.length === 1) {
+			return String(activeAccounts[0]?.id);
+		}
+
+		const choices = activeAccounts
+			.map((account: any) => {
+				const label = account?.display_name || account?.external_account_id || account?.username || account?.id;
+				const externalAccountId = typeof account?.external_account_id === "string" ? account.external_account_id : null;
+				return externalAccountId && externalAccountId !== label ? `${label} (${externalAccountId})` : String(label);
+			})
+			.join(", ");
+
+		throw new Error(
+			`Multiple personal Google Calendars are connected. Pass accountId as the calendar id, external_account_id, or display name. Available calendars: ${choices}`,
+		);
+	}
+
+	const matches = activeAccounts.filter((account: any) => {
+		const candidates = [
+			typeof account?.id === "string" ? account.id : null,
+			typeof account?.external_account_id === "string" ? account.external_account_id : null,
+			typeof account?.display_name === "string" ? account.display_name : null,
+			typeof account?.username === "string" ? account.username : null,
+		];
+
+		return candidates.some((candidate) => candidate?.trim().toLowerCase() === normalizedIdentifier);
+	});
+
+	if (!matches.length) {
+		throw new Error(
+			`No connected personal Google Calendar matched "${accountId}". Pass the calendar id, external_account_id, or display name from /me/integrations/accounts.`,
+		);
+	}
+
+	if (matches.length > 1) {
+		const choices = matches
+			.map((account: any) => {
+				const label = account?.display_name || account?.external_account_id || account?.username || account?.id;
+				const externalAccountId = typeof account?.external_account_id === "string" ? account.external_account_id : null;
+				return externalAccountId && externalAccountId !== label ? `${label} (${externalAccountId})` : String(label);
+			})
+			.join(", ");
+
+		throw new Error(
+			`"${accountId}" matched multiple personal Google Calendars. Pass a unique calendar id or external_account_id. Matches: ${choices}`,
+		);
+	}
+
+	return String(matches[0]?.id);
+}
+
+async function listPersonalCalendarEvents(args: {
+	accountId?: string | null;
+	timeMin?: string | null;
+	timeMax?: string | null;
+	timeZone?: string | null;
+	maxResults?: number | null;
+	query?: string | null;
+}) {
+	try {
+		const accountId = await resolvePersonalCalendarAccountId(args.accountId);
+		return await api.get<any>(`/me/integrations/accounts/${accountId}/events`, {
+			max_results: args.maxResults ?? undefined,
+			q: args.query ?? undefined,
+			time_max: args.timeMax ?? undefined,
+			time_min: args.timeMin ?? undefined,
+			time_zone: args.timeZone ?? undefined,
+		});
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+async function createPersonalCalendarEvent(args: {
+	accountId?: string | null;
+	summary: string;
+	startTime: string;
+	endTime: string;
+	description?: string | null;
+	timeZone?: string | null;
+	attendeeEmails?: string[] | null;
+}) {
+	try {
+		const accountId = await resolvePersonalCalendarAccountId(args.accountId);
+		return await api.post<any>(`/me/integrations/accounts/${accountId}/events`, {
+			attendee_emails: Array.isArray(args.attendeeEmails) ? args.attendeeEmails : undefined,
+			description: args.description ?? undefined,
+			end_time: args.endTime,
+			start_time: args.startTime,
+			summary: args.summary,
+			time_zone: args.timeZone ?? undefined,
+		});
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+async function updatePersonalCalendarEvent(args: {
+	accountId?: string | null;
+	eventId: string;
+	summary?: string | null;
+	startTime?: string | null;
+	endTime?: string | null;
+	description?: string | null;
+	timeZone?: string | null;
+	attendeeEmails?: string[] | null;
+}) {
+	try {
+		const accountId = await resolvePersonalCalendarAccountId(args.accountId);
+		return await api.patch<any>(`/me/integrations/accounts/${accountId}/events/${args.eventId}`, {
+			attendee_emails: Array.isArray(args.attendeeEmails) ? args.attendeeEmails : undefined,
+			description: args.description ?? undefined,
+			end_time: args.endTime ?? undefined,
+			start_time: args.startTime ?? undefined,
+			summary: args.summary ?? undefined,
+			time_zone: args.timeZone ?? undefined,
+		});
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+async function deletePersonalCalendarEvent(args: {
+	accountId?: string | null;
+	eventId: string;
+}) {
+	try {
+		const accountId = await resolvePersonalCalendarAccountId(args.accountId);
+		return await api.delete<any>(`/me/integrations/accounts/${accountId}/events/${args.eventId}`);
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+async function findCommonMeetingAvailability(args: {
+	calendarAccountIds: string[];
+	from: string;
+	to: string;
+	timeZone?: string;
+	slotDurationMinutes: number;
+	candidateSlots?: Array<{
+		startsAt: string;
+		endsAt: string;
+	}> | null;
+}) {
+	try {
+		return await api.post<any>("/meetings/calendar-availability", {
+			calendar_account_ids: args.calendarAccountIds,
+			from: args.from,
+			to: args.to,
+			time_zone: args.timeZone,
+			slot_duration_minutes: args.slotDurationMinutes,
+			candidate_slots: Array.isArray(args.candidateSlots)
+				? args.candidateSlots.map((slot) => ({
+						starts_at: slot.startsAt,
+						ends_at: slot.endsAt,
+				  }))
+				: undefined,
+		});
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
+async function bookMeetingFull(args: {
+	startsAt: string;
+	endsAt?: string | null;
+	durationMinutes?: number | null;
+	guestName: string;
+	guestEmail: string;
+	timeZone?: string;
+	title?: string | null;
+	description?: string | null;
+	partyId?: string | null;
+	guestTwitterHandle?: string | null;
+	profileImageUrl?: string | null;
+	programSlug?: string;
+	calendarAccountId?: string | null;
+}) {
+	try {
+		const resolvedEndsAt = resolveBookingEndsAt(args.startsAt, args.endsAt, args.durationMinutes);
+		return await api.post<any>("/meetings/book-full", {
+			calendar_account_id: args.calendarAccountId,
+			program_slug: args.programSlug,
+			starts_at: args.startsAt,
+			ends_at: resolvedEndsAt,
+			duration_minutes: args.durationMinutes,
+			time_zone: args.timeZone,
+			title: args.title,
+			description: args.description,
+			guest: {
+				party_id: args.partyId,
+				full_name: args.guestName,
+				email: args.guestEmail,
+				twitter_handle: args.guestTwitterHandle,
+				profile_image_url: args.profileImageUrl,
+			},
+		});
+	} catch (error) {
+		if (error instanceof ApiError) return { error: error.message, status: error.status };
+		throw error;
+	}
+}
+
 async function updateMeeting(args: {
 	meetingId: string;
 	startsAt?: string | null;
@@ -1061,6 +1500,136 @@ async function assignMeeting(args: {
 }
 
 export function registerMeetingTools(pi: ExtensionAPI) {
+	pi.registerTool({
+		name: "seedclub_search_people",
+		label: "Search People",
+		description:
+			"Search people in Seed Club before booking a meeting. Use this first to find an existing guest and get a partyId. If multiple plausible matches appear, ask the user to choose before booking.",
+		parameters: Type.Object({
+			query: Type.String({ description: "Guest name, email, or search text" }),
+			limit: Type.Optional(
+				Type.Number({ description: "Maximum matches to return (defaults to 5, max 10)." }),
+			),
+		}),
+		execute: wrapExecute(searchPeopleForBooking),
+	});
+
+	pi.registerTool({
+		name: "seedclub_list_meeting_availability",
+		label: "List Availability Slots",
+		description:
+			"List the configured availability slots for a specific date. Use this before booking and choose one of the returned slot startsAt/endsAt pairs instead of inventing a meeting length or time.",
+		parameters: Type.Object({
+			date: Type.String({
+				description: "Target date as YYYY-MM-DD or ISO timestamp. The tool returns valid startsAt/endsAt pairs for that day.",
+			}),
+			programSlug: Type.Optional(Type.String({ description: "Program slug. Defaults to 11am on the server." })),
+			timeZone: Type.Optional(Type.String({ description: "Optional timezone used to interpret the requested date. Defaults to America/New_York." })),
+		}),
+		execute: wrapExecute(listMeetingAvailabilitySlots),
+	});
+
+	pi.registerTool({
+		name: "seedclub_list_meeting_calendars",
+		label: "List Booking Calendars",
+		description:
+			"List the connected Google calendars that can be used for meeting scheduling. Returns both shared 11am calendars and personal calendars that the current user can book on.",
+		parameters: Type.Object({
+			programSlug: Type.Optional(Type.String({ description: "Program slug. Defaults to 11am on the server." })),
+		}),
+		execute: wrapExecute(listMeetingCalendars),
+	});
+
+	pi.registerTool({
+		name: "seedclub_list_personal_calendar_events",
+		label: "List Personal Calendar Events",
+		description:
+			"List events from a connected personal Google Calendar. Use this for personal calendar read access. accountId may be the calendar id, external_account_id, or display name. If omitted, the tool only auto-selects when exactly one active personal calendar is connected.",
+		parameters: Type.Object({
+			accountId: Type.Optional(Type.Union([Type.String(), Type.Null()], { description: "Optional calendar identifier: account id, external_account_id (email), or display name." })),
+			timeMin: Type.Optional(Type.Union([Type.String(), Type.Null()], { description: "Optional ISO range start." })),
+			timeMax: Type.Optional(Type.Union([Type.String(), Type.Null()], { description: "Optional ISO range end." })),
+			timeZone: Type.Optional(Type.Union([Type.String(), Type.Null()], { description: "Optional IANA timezone." })),
+			maxResults: Type.Optional(Type.Union([Type.Number(), Type.Null()], { description: "Optional max results, defaults to 25 on the server." })),
+			query: Type.Optional(Type.Union([Type.String(), Type.Null()], { description: "Optional Google Calendar search query." })),
+		}),
+		execute: wrapExecute(listPersonalCalendarEvents),
+	});
+
+	pi.registerTool({
+		name: "seedclub_create_personal_calendar_event",
+		label: "Create Personal Calendar Event",
+		description:
+			"Create an event on a connected personal Google Calendar. accountId may be the calendar id, external_account_id, or display name. If omitted, the tool only auto-selects when exactly one active personal calendar is connected.",
+		parameters: Type.Object({
+			accountId: Type.Optional(Type.Union([Type.String(), Type.Null()], { description: "Optional calendar identifier: account id, external_account_id (email), or display name." })),
+			summary: Type.String({ description: "Event title/summary." }),
+			startTime: Type.String({ description: "Event start time as an ISO timestamp." }),
+			endTime: Type.String({ description: "Event end time as an ISO timestamp." }),
+			description: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+			timeZone: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+			attendeeEmails: Type.Optional(Type.Union([Type.Array(Type.String()), Type.Null()])),
+		}),
+		execute: wrapExecute(createPersonalCalendarEvent),
+	});
+
+	pi.registerTool({
+		name: "seedclub_update_personal_calendar_event",
+		label: "Update Personal Calendar Event",
+		description:
+			"Update an event on a connected personal Google Calendar. accountId may be the calendar id, external_account_id, or display name. If omitted, the tool only auto-selects when exactly one active personal calendar is connected.",
+		parameters: Type.Object({
+			accountId: Type.Optional(Type.Union([Type.String(), Type.Null()], { description: "Optional calendar identifier: account id, external_account_id (email), or display name." })),
+			eventId: Type.String({ description: "Google Calendar event id." }),
+			summary: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+			startTime: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+			endTime: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+			description: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+			timeZone: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+			attendeeEmails: Type.Optional(Type.Union([Type.Array(Type.String()), Type.Null()])),
+		}),
+		execute: wrapExecute(updatePersonalCalendarEvent),
+	});
+
+	pi.registerTool({
+		name: "seedclub_delete_personal_calendar_event",
+		label: "Delete Personal Calendar Event",
+		description:
+			"Delete an event from a connected personal Google Calendar. accountId may be the calendar id, external_account_id, or display name. If omitted, the tool only auto-selects when exactly one active personal calendar is connected.",
+		parameters: Type.Object({
+			accountId: Type.Optional(Type.Union([Type.String(), Type.Null()], { description: "Optional calendar identifier: account id, external_account_id (email), or display name." })),
+			eventId: Type.String({ description: "Google Calendar event id." }),
+		}),
+		execute: wrapExecute(deletePersonalCalendarEvent),
+	});
+
+	pi.registerTool({
+		name: "seedclub_find_common_meeting_availability",
+		label: "Find Common Availability",
+		description:
+			"Check calendar overlap across multiple connected calendars. Use this for common-meeting scheduling. You can pass candidateSlots from seedclub_list_meeting_availability to filter down to allowed booking slots, then book on one chosen calendar.",
+		parameters: Type.Object({
+			calendarAccountIds: Type.Array(
+				Type.String({ description: "Calendar account ids to compare for overlap." }),
+			),
+			from: Type.String({ description: "Range start as an ISO timestamp." }),
+			to: Type.String({ description: "Range end as an ISO timestamp." }),
+			timeZone: Type.Optional(Type.String({ description: "IANA timezone like America/New_York." })),
+			slotDurationMinutes: Type.Number({
+				description: "Desired meeting length in minutes.",
+			}),
+			candidateSlots: Type.Optional(
+				Type.Array(
+					Type.Object({
+						startsAt: Type.String({ description: "Candidate slot start as an ISO timestamp." }),
+						endsAt: Type.String({ description: "Candidate slot end as an ISO timestamp." }),
+					}),
+				),
+			),
+		}),
+		execute: wrapExecute(findCommonMeetingAvailability),
+	});
+
 	pi.registerTool({
 		name: "seedclub_list_meetings",
 		label: "List Meetings",
@@ -1358,6 +1927,41 @@ export function registerMeetingTools(pi: ExtensionAPI) {
 		renderResult: makeProgressResultRenderer(getToolSuccessLabel("seedclub_get_meeting"), (details) => details?.meeting?.id || undefined),
 	});
 
+	pi.registerTool({
+		name: "seedclub_book_meeting_full",
+		label: "Book Meeting",
+		description:
+			"Book one guest meeting end-to-end: create the meeting, create the studio link, and create the Google Calendar invite. Always fetch availability first with seedclub_list_meeting_availability and use one of the returned startsAt/endsAt pairs. For common meetings, use seedclub_list_meeting_calendars and seedclub_find_common_meeting_availability first, then pass the chosen calendarAccountId. Only use this after you know guestName, guestEmail, and startsAt. Prefer passing endsAt when using an availability slot. If they only give a slot or duration, pass durationMinutes instead; if neither is available, this tool defaults to a 20-minute meeting, but the backend will still reject times that do not exactly match a configured slot. Search for an existing guest first and pass partyId when you have a confident match; otherwise proceed without partyId and the backend will find or create a contact using guestEmail before booking.",
+		parameters: Type.Object({
+			startsAt: Type.String({ description: "Meeting start time as an ISO timestamp" }),
+			endsAt: Type.Optional(
+				Type.Union([Type.String(), Type.Null()], {
+					description: "Optional meeting end time as an ISO timestamp. If omitted, durationMinutes or the default 20-minute duration is used.",
+				}),
+			),
+			durationMinutes: Type.Optional(
+				Type.Union([Type.Number(), Type.Null()], {
+					description: "Optional meeting length in minutes. Use this when the user gives a duration or a 20-minute slot instead of an explicit end time.",
+				}),
+			),
+			guestName: Type.String({ description: "Guest full name" }),
+			guestEmail: Type.String({ description: "Guest email address" }),
+			timeZone: Type.Optional(Type.String({ description: "IANA timezone like America/New_York" })),
+			title: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+			description: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+			partyId: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+			calendarAccountId: Type.Optional(
+				Type.Union([Type.String(), Type.Null()], {
+					description: "Optional calendar account id to write the event on. Use this for common meetings or when multiple writable calendars exist.",
+				}),
+			),
+			guestTwitterHandle: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+			profileImageUrl: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+			programSlug: Type.Optional(Type.String({ description: "Program slug. Defaults to 11am on the server." })),
+		}),
+		execute: wrapExecute(bookMeetingFull),
+	});
+
 	pi.registerTool({
 		name: "seedclub_update_meeting",
 		label: "Update Meeting",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubnet/seedclub",
-  "version": "0.2.26",
+  "version": "0.2.28",
   "description": "A branded command-line agent wrapper around pi, with integrated Seed Club commands, tools, and app actions",
   "license": "MIT",
   "repository": {