@clubnet/seedclub 0.2.27 → 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

@@ -1227,6 +1227,202 @@ async function listMeetingAvailabilitySlots(args: {
 	}
 }
 
+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;
@@ -1240,10 +1436,12 @@ async function bookMeetingFull(args: {
 	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,
@@ -1331,6 +1529,107 @@ export function registerMeetingTools(pi: ExtensionAPI) {
 		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",
@@ -1632,7 +1931,7 @@ export function registerMeetingTools(pi: ExtensionAPI) {
 		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. 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.",
+			"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(
@@ -1651,6 +1950,11 @@ export function registerMeetingTools(pi: ExtensionAPI) {
 			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." })),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubnet/seedclub",
-  "version": "0.2.27",
+  "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": {