@elizaos/agent 2.0.0-alpha.358 → 2.0.0-alpha.376

package/apps/app-lifeops/src/components/EventEditorDrawer.js

@@ -0,0 +1,514 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Button, ConfirmDialog, client, Dialog, DialogContent, Input, Select, SelectContent, SelectItem, SelectTrigger, SelectValue, TagInput, Textarea, useApp, } from "@elizaos/app-core";
+import { X } from "lucide-react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+const TIME_ZONE = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+const REMINDER_PRESETS = [
+    { label: "5m", minutes: 5 },
+    { label: "10m", minutes: 10 },
+    { label: "15m", minutes: 15 },
+    { label: "30m", minutes: 30 },
+    { label: "1h", minutes: 60 },
+    { label: "1d", minutes: 1440 },
+];
+const WEEKDAY_RRULE_CODES = [
+    "SU",
+    "MO",
+    "TU",
+    "WE",
+    "TH",
+    "FR",
+    "SA",
+];
+function toLocalInputValue(isoString) {
+    if (!isoString) {
+        return "";
+    }
+    const parsed = Date.parse(isoString);
+    if (!Number.isFinite(parsed)) {
+        return "";
+    }
+    // datetime-local input expects "YYYY-MM-DDTHH:mm"
+    const date = new Date(parsed);
+    const pad = (value) => String(value).padStart(2, "0");
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+function fromLocalInputValue(localValue) {
+    if (!localValue) {
+        return null;
+    }
+    const parsed = new Date(localValue);
+    return Number.isFinite(parsed.getTime()) ? parsed.toISOString() : null;
+}
+function nextHalfHourIso(now = new Date()) {
+    const ms = 30 * 60 * 1000;
+    const start = new Date(Math.ceil(now.getTime() / ms) * ms);
+    return start.toISOString();
+}
+function isoPlusMinutes(iso, minutes) {
+    return new Date(Date.parse(iso) + minutes * 60_000).toISOString();
+}
+function basicEmailValid(value) {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+}
+function rruleForPreset(preset, date) {
+    switch (preset) {
+        case "daily":
+            return "FREQ=DAILY";
+        case "weekly":
+            return `FREQ=WEEKLY;BYDAY=${WEEKDAY_RRULE_CODES[date.getDay()]}`;
+        case "monthly":
+            return `FREQ=MONTHLY;BYMONTHDAY=${date.getDate()}`;
+        case "yearly":
+            return "FREQ=YEARLY";
+        default:
+            return null;
+    }
+}
+function recurrencePresetLabel(preset, date) {
+    const weekdayLong = new Intl.DateTimeFormat(undefined, {
+        weekday: "long",
+    }).format(date);
+    switch (preset) {
+        case "none":
+            return "Does not repeat";
+        case "daily":
+            return "Daily";
+        case "weekly":
+            return `Weekly on ${weekdayLong}`;
+        case "monthly":
+            return `Monthly on day ${date.getDate()}`;
+        case "yearly":
+            return "Yearly";
+        case "custom":
+            return "Custom (RRULE)";
+    }
+}
+const RECURRENCE_PRESETS = [
+    "none",
+    "daily",
+    "weekly",
+    "monthly",
+    "yearly",
+    "custom",
+];
+function blankFormState(defaults) {
+    const seedDate = defaults?.date ?? new Date();
+    const start = nextHalfHourIso(seedDate);
+    return {
+        title: "",
+        startAt: toLocalInputValue(start),
+        endAt: toLocalInputValue(isoPlusMinutes(start, 30)),
+        notes: "",
+        location: "",
+        attendees: [],
+        reminderMinutes: [],
+        recurrencePreset: "none",
+        customRrule: "",
+        calendarId: defaults?.calendarId ?? "",
+        grantId: defaults?.grantId ?? "",
+        side: defaults?.side ?? "owner",
+    };
+}
+function formStateFromEvent(event) {
+    const attendees = event.attendees
+        .map((attendee) => attendee.email?.trim() ?? "")
+        .filter((email) => email.length > 0);
+    return {
+        title: event.title,
+        startAt: toLocalInputValue(event.startAt),
+        endAt: toLocalInputValue(event.endAt),
+        notes: event.description ?? "",
+        location: event.location ?? "",
+        attendees,
+        reminderMinutes: [],
+        recurrencePreset: "none",
+        customRrule: "",
+        calendarId: event.calendarId,
+        grantId: event.grantId ?? "",
+        side: event.side,
+    };
+}
+function buildRecurrenceArray(state) {
+    if (state.recurrencePreset === "none") {
+        return undefined;
+    }
+    if (state.recurrencePreset === "custom") {
+        const rule = state.customRrule.trim();
+        if (!rule)
+            return undefined;
+        const stripped = rule.startsWith("RRULE:") ? rule.slice("RRULE:".length) : rule;
+        return [stripped];
+    }
+    const startDate = fromLocalInputValue(state.startAt);
+    if (!startDate)
+        return undefined;
+    const rule = rruleForPreset(state.recurrencePreset, new Date(startDate));
+    return rule ? [rule] : undefined;
+}
+function attendeesToContract(emails) {
+    const valid = emails
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0 && basicEmailValid(value));
+    if (valid.length === 0)
+        return undefined;
+    return valid.map((email) => ({ email }));
+}
+export function EventEditorDrawer({ open, mode = "edit", event, createDefaults, onClose, onSaved, onCreated, onDeleted, onChat, }) {
+    const { setActionNotice, t } = useApp();
+    const [form, setForm] = useState(() => event ? formStateFromEvent(event) : blankFormState(createDefaults));
+    const [calendars, setCalendars] = useState([]);
+    const [calendarsLoading, setCalendarsLoading] = useState(false);
+    const [calendarsError, setCalendarsError] = useState(null);
+    const [customReminderDraft, setCustomReminderDraft] = useState("");
+    const [showCustomReminder, setShowCustomReminder] = useState(false);
+    const [saving, setSaving] = useState(false);
+    const [deleting, setDeleting] = useState(false);
+    const [confirmDeleteOpen, setConfirmDeleteOpen] = useState(false);
+    const [error, setError] = useState(null);
+    const isCreate = mode === "create";
+    // Seed form when the event changes (edit) or drawer opens in create mode.
+    useEffect(() => {
+        if (!open)
+            return;
+        if (isCreate) {
+            setForm(blankFormState(createDefaults));
+        }
+        else if (event) {
+            setForm(formStateFromEvent(event));
+        }
+        setError(null);
+        setCustomReminderDraft("");
+        setShowCustomReminder(false);
+    }, [open, isCreate, event, createDefaults]);
+    // Load calendar list when drawer opens. The selector is sourced from
+    // `client.getLifeOpsCalendars()`; if the call fails we fall back to a
+    // single "Primary" pseudo-row so the UI still renders.
+    useEffect(() => {
+        if (!open)
+            return;
+        let cancelled = false;
+        setCalendarsLoading(true);
+        setCalendarsError(null);
+        void client
+            .getLifeOpsCalendars({ side: "owner" })
+            .then((response) => {
+            if (cancelled)
+                return;
+            setCalendars(response.calendars);
+            setForm((prev) => {
+                if (prev.calendarId)
+                    return prev;
+                const primary = response.calendars.find((calendar) => calendar.primary) ??
+                    response.calendars[0];
+                if (!primary)
+                    return prev;
+                return {
+                    ...prev,
+                    calendarId: primary.calendarId,
+                    grantId: primary.grantId,
+                    side: primary.side,
+                };
+            });
+        })
+            .catch((cause) => {
+            if (cancelled)
+                return;
+            setCalendars([]);
+            setCalendarsError(cause instanceof Error && cause.message.trim().length > 0
+                ? cause.message.trim()
+                : "Could not load calendars.");
+        })
+            .finally(() => {
+            if (!cancelled)
+                setCalendarsLoading(false);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [open]);
+    const calendarOptions = useMemo(() => {
+        if (calendars.length > 0)
+            return calendars;
+        // Fallback row so the Select still renders something while the list is
+        // loading or after a failed fetch. The ID matches what the backend uses
+        // when no calendar is supplied on create/update.
+        return [
+            {
+                provider: "google",
+                side: form.side,
+                grantId: form.grantId,
+                accountEmail: null,
+                calendarId: form.calendarId || "primary",
+                summary: form.calendarId && form.calendarId !== "primary"
+                    ? form.calendarId
+                    : "Primary",
+                description: null,
+                primary: true,
+                accessRole: "owner",
+                backgroundColor: null,
+                foregroundColor: null,
+                timeZone: null,
+                selected: true,
+                includeInFeed: true,
+            },
+        ];
+    }, [calendars, form.calendarId, form.grantId, form.side]);
+    const updateForm = useCallback((key, value) => {
+        setForm((prev) => ({ ...prev, [key]: value }));
+    }, []);
+    const toggleReminderPreset = useCallback((minutes) => {
+        setForm((prev) => {
+            const exists = prev.reminderMinutes.includes(minutes);
+            const next = exists
+                ? prev.reminderMinutes.filter((value) => value !== minutes)
+                : [...prev.reminderMinutes, minutes];
+            next.sort((a, b) => a - b);
+            return { ...prev, reminderMinutes: next };
+        });
+    }, []);
+    const addCustomReminder = useCallback(() => {
+        const parsed = Number(customReminderDraft);
+        if (!Number.isFinite(parsed) || parsed < 0)
+            return;
+        const minutes = Math.floor(parsed);
+        setForm((prev) => {
+            if (prev.reminderMinutes.includes(minutes))
+                return prev;
+            const next = [...prev.reminderMinutes, minutes];
+            next.sort((a, b) => a - b);
+            return { ...prev, reminderMinutes: next };
+        });
+        setCustomReminderDraft("");
+    }, [customReminderDraft]);
+    const handleSave = useCallback(async (options = {}) => {
+        setError(null);
+        const titleTrimmed = form.title.trim();
+        if (!titleTrimmed)
+            return;
+        const startIso = fromLocalInputValue(form.startAt);
+        const endIso = fromLocalInputValue(form.endAt);
+        if (!startIso || !endIso) {
+            setError(t("eventEditor.invalidTimes", {
+                defaultValue: "Pick valid start and end times.",
+            }));
+            return;
+        }
+        setSaving(true);
+        try {
+            if (isCreate) {
+                const request = {
+                    side: form.side,
+                    grantId: form.grantId || undefined,
+                    calendarId: form.calendarId || undefined,
+                    title: titleTrimmed,
+                    description: form.notes.trim() || undefined,
+                    location: form.location.trim() || undefined,
+                    startAt: startIso,
+                    endAt: endIso,
+                    timeZone: TIME_ZONE,
+                    attendees: attendeesToContract(form.attendees),
+                    recurrence: buildRecurrenceArray(form),
+                    reminders: form.reminderMinutes.length > 0
+                        ? form.reminderMinutes.map((minutesBefore) => ({
+                            minutesBefore,
+                        }))
+                        : undefined,
+                };
+                const result = await client.createLifeOpsCalendarEvent(request);
+                if (!result.event) {
+                    throw new Error("Calendar create returned no event.");
+                }
+                setActionNotice(t("eventEditor.created", {
+                    defaultValue: "Event created.",
+                }), "success", 2400);
+                onCreated?.(result.event);
+                if (options.keepOpen) {
+                    setForm(blankFormState({ ...createDefaults, side: form.side }));
+                }
+                else {
+                    onClose();
+                }
+            }
+            else {
+                if (!event)
+                    return;
+                const patch = {
+                    side: event.side,
+                    grantId: event.grantId,
+                    calendarId: form.calendarId || event.calendarId,
+                    timeZone: event.timezone ?? TIME_ZONE,
+                };
+                if (titleTrimmed !== event.title)
+                    patch.title = titleTrimmed;
+                if (startIso !== event.startAt)
+                    patch.startAt = startIso;
+                if (endIso !== event.endAt)
+                    patch.endAt = endIso;
+                if (form.notes.trim() !== (event.description ?? "")) {
+                    patch.notes = form.notes.trim();
+                }
+                if (form.location.trim() !== (event.location ?? "")) {
+                    patch.location = form.location.trim();
+                }
+                const attendeesContract = attendeesToContract(form.attendees);
+                if (attendeesContract) {
+                    patch.attendees = attendeesContract;
+                }
+                const recurrence = buildRecurrenceArray(form);
+                if (recurrence) {
+                    patch.recurrence = recurrence;
+                }
+                if (form.reminderMinutes.length > 0) {
+                    patch.reminders = form.reminderMinutes.map((minutesBefore) => ({
+                        minutesBefore,
+                    }));
+                }
+                const result = await client.updateLifeOpsCalendarEvent(event.externalId, patch);
+                setActionNotice(t("eventEditor.saved", { defaultValue: "Event saved." }), "success", 2400);
+                onSaved?.(result.event);
+                if (options.keepOpen) {
+                    setForm(formStateFromEvent(result.event));
+                }
+                else {
+                    onClose();
+                }
+            }
+        }
+        catch (cause) {
+            setError(cause instanceof Error && cause.message.trim().length > 0
+                ? cause.message.trim()
+                : t("eventEditor.saveFailed", {
+                    defaultValue: "Could not save the event.",
+                }));
+        }
+        finally {
+            setSaving(false);
+        }
+    }, [
+        createDefaults,
+        event,
+        form,
+        isCreate,
+        onClose,
+        onCreated,
+        onSaved,
+        setActionNotice,
+        t,
+    ]);
+    const handleDelete = useCallback(async () => {
+        if (!event)
+            return;
+        setDeleting(true);
+        setError(null);
+        try {
+            await client.deleteLifeOpsCalendarEvent(event.externalId, {
+                side: event.side,
+                grantId: event.grantId,
+                calendarId: event.calendarId,
+            });
+            setActionNotice(t("eventEditor.deleted", { defaultValue: "Event deleted." }), "success", 2400);
+            onDeleted?.(event.id);
+            onClose();
+        }
+        catch (cause) {
+            setError(cause instanceof Error && cause.message.trim().length > 0
+                ? cause.message.trim()
+                : t("eventEditor.deleteFailed", {
+                    defaultValue: "Could not delete the event.",
+                }));
+        }
+        finally {
+            setDeleting(false);
+            setConfirmDeleteOpen(false);
+        }
+    }, [event, onClose, onDeleted, setActionNotice, t]);
+    const startDate = useMemo(() => {
+        const iso = fromLocalInputValue(form.startAt);
+        return iso ? new Date(iso) : new Date();
+    }, [form.startAt]);
+    if (!isCreate && !event) {
+        return null;
+    }
+    const titleLabel = isCreate
+        ? t("eventEditor.createTitle", { defaultValue: "New event" })
+        : t("eventEditor.title", { defaultValue: "Edit event" });
+    const primaryActionLabel = isCreate
+        ? t("eventEditor.create", { defaultValue: "Create" })
+        : t("common.save", { defaultValue: "Save" });
+    const primaryActionLoadingLabel = isCreate
+        ? t("eventEditor.creating", { defaultValue: "Creating…" })
+        : t("common.saving", { defaultValue: "Saving…" });
+    const calendarSelectValue = form.calendarId || calendarOptions[0]?.calendarId || "";
+    return (_jsxs(_Fragment, { children: [_jsx(Dialog, { open: open, onOpenChange: (isOpen) => !isOpen && onClose(), children: _jsxs(DialogContent, { className: "fixed bottom-0 right-0 top-0 !left-auto !right-0 !top-0 m-0 h-full w-[min(28rem,100vw)] max-w-[100vw] !translate-x-0 !translate-y-0 overflow-y-auto rounded-l-2xl rounded-r-none border-l border-t-0 border-border/16 bg-bg p-0 shadow-xl duration-200 data-[state=closed]:slide-out-to-right-full data-[state=open]:slide-in-from-right-full", "data-testid": "event-editor-drawer", children: [_jsxs("div", { className: "flex items-center justify-between gap-3 border-b border-border/12 px-5 py-4", children: [_jsx("div", { children: _jsx("div", { className: "text-sm font-semibold text-txt", children: titleLabel }) }), _jsx("button", { type: "button", onClick: onClose, "aria-label": t("common.close", { defaultValue: "Close" }), className: "rounded-full p-1.5 text-muted transition-colors hover:bg-bg-hover/40 hover:text-txt", children: _jsx(X, { className: "h-4 w-4" }) })] }), _jsxs("div", { className: "space-y-4 px-5 py-5", children: [error ? (_jsx("div", { className: "rounded-2xl bg-danger/10 px-3 py-2 text-xs text-danger", children: error })) : null, _jsxs("div", { className: "space-y-1.5", children: [_jsx("label", { htmlFor: "event-editor-title", className: "block text-xs font-medium text-muted", children: t("common.title", { defaultValue: "Title" }) }), _jsx(Input, { id: "event-editor-title", value: form.title, onChange: (e) => updateForm("title", e.target.value), placeholder: t("eventEditor.titlePlaceholder", {
+                                                defaultValue: "Event title",
+                                            }), "aria-label": t("eventEditor.titleAria", {
+                                                defaultValue: "Event title",
+                                            }) })] }), _jsxs("div", { className: "grid grid-cols-2 gap-3", children: [_jsxs("div", { className: "space-y-1.5", children: [_jsx("label", { htmlFor: "event-editor-start-at", className: "block text-xs font-medium text-muted", children: t("eventEditor.startAt", { defaultValue: "Start" }) }), _jsx(Input, { id: "event-editor-start-at", type: "datetime-local", value: form.startAt, onChange: (e) => updateForm("startAt", e.target.value), "aria-label": t("eventEditor.startAtAria", {
+                                                        defaultValue: "Start time",
+                                                    }) })] }), _jsxs("div", { className: "space-y-1.5", children: [_jsx("label", { htmlFor: "event-editor-end-at", className: "block text-xs font-medium text-muted", children: t("eventEditor.endAt", { defaultValue: "End" }) }), _jsx(Input, { id: "event-editor-end-at", type: "datetime-local", value: form.endAt, onChange: (e) => updateForm("endAt", e.target.value), "aria-label": t("eventEditor.endAtAria", {
+                                                        defaultValue: "End time",
+                                                    }) })] })] }), _jsxs("div", { className: "space-y-1.5", children: [_jsx("label", { htmlFor: "event-editor-location", className: "block text-xs font-medium text-muted", children: t("eventEditor.location", { defaultValue: "Location" }) }), _jsx(Input, { id: "event-editor-location", value: form.location, onChange: (e) => updateForm("location", e.target.value), placeholder: t("eventEditor.locationPlaceholder", {
+                                                defaultValue: "Location (optional)",
+                                            }), "aria-label": t("eventEditor.locationAria", {
+                                                defaultValue: "Event location",
+                                            }) })] }), _jsxs("div", { className: "space-y-1.5", children: [_jsx("label", { htmlFor: "event-editor-recurrence", className: "block text-xs font-medium text-muted", children: t("eventEditor.recurrence", { defaultValue: "Repeat" }) }), _jsxs(Select, { value: form.recurrencePreset, onValueChange: (value) => updateForm("recurrencePreset", value), children: [_jsx(SelectTrigger, { id: "event-editor-recurrence", "aria-label": t("eventEditor.recurrenceAria", {
+                                                        defaultValue: "Recurrence",
+                                                    }), children: _jsx(SelectValue, {}) }), _jsx(SelectContent, { children: RECURRENCE_PRESETS.map((preset) => (_jsx(SelectItem, { value: preset, children: recurrencePresetLabel(preset, startDate) }, preset))) })] }), form.recurrencePreset === "custom" ? (_jsx(Input, { className: "mt-2", value: form.customRrule, onChange: (e) => updateForm("customRrule", e.target.value), placeholder: "FREQ=WEEKLY;BYDAY=MO,WE,FR", "aria-label": t("eventEditor.customRruleAria", {
+                                                defaultValue: "Custom RRULE",
+                                            }) })) : null] }), _jsxs("div", { className: "space-y-1.5", children: [_jsx("span", { className: "block text-xs font-medium text-muted", children: t("eventEditor.attendees", { defaultValue: "Attendees" }) }), _jsx(TagInput, { items: form.attendees, onChange: (next) => updateForm("attendees", next.filter((value) => basicEmailValid(value))), placeholder: t("eventEditor.attendeePlaceholder", {
+                                                defaultValue: "Add email and press Enter",
+                                            }), addLabel: t("eventEditor.attendeeAdd", {
+                                                defaultValue: "Add attendee",
+                                            }), removeLabel: t("eventEditor.attendeeRemove", {
+                                                defaultValue: "Remove",
+                                            }) })] }), _jsxs("div", { className: "space-y-1.5", children: [_jsx("label", { htmlFor: "event-editor-calendar", className: "block text-xs font-medium text-muted", children: t("eventEditor.calendar", { defaultValue: "Calendar" }) }), _jsxs(Select, { value: calendarSelectValue, onValueChange: (value) => {
+                                                const match = calendarOptions.find((calendar) => calendar.calendarId === value);
+                                                setForm((prev) => ({
+                                                    ...prev,
+                                                    calendarId: value,
+                                                    grantId: match?.grantId ?? prev.grantId,
+                                                    side: match?.side ?? prev.side,
+                                                }));
+                                            }, children: [_jsx(SelectTrigger, { id: "event-editor-calendar", "aria-label": t("eventEditor.calendarAria", {
+                                                        defaultValue: "Calendar of record",
+                                                    }), children: _jsx(SelectValue, { placeholder: calendarsLoading
+                                                            ? t("eventEditor.calendarLoading", {
+                                                                defaultValue: "Loading…",
+                                                            })
+                                                            : t("eventEditor.calendarPlaceholder", {
+                                                                defaultValue: "Select calendar",
+                                                            }) }) }), _jsx(SelectContent, { children: calendarOptions.map((calendar) => (_jsxs(SelectItem, { value: calendar.calendarId, children: [calendar.summary, calendar.accountEmail
+                                                                ? ` · ${calendar.accountEmail}`
+                                                                : ""] }, `${calendar.grantId}:${calendar.calendarId}`))) })] }), calendarsError ? (_jsx("div", { className: "text-[10px] text-danger", children: calendarsError })) : null] }), _jsxs("div", { className: "space-y-1.5", children: [_jsx("span", { className: "block text-xs font-medium text-muted", children: t("eventEditor.reminders", { defaultValue: "Reminders" }) }), _jsxs("div", { className: "flex flex-wrap gap-1.5", children: [REMINDER_PRESETS.map((preset) => {
+                                                    const active = form.reminderMinutes.includes(preset.minutes);
+                                                    return (_jsx("button", { type: "button", onClick: () => toggleReminderPreset(preset.minutes), "aria-pressed": active, className: `rounded-full border px-2.5 py-1 text-xs font-medium transition-colors ${active
+                                                            ? "border-accent bg-accent/15 text-accent"
+                                                            : "border-border/30 text-muted hover:border-border/60 hover:text-txt"}`, children: preset.label }, preset.minutes));
+                                                }), _jsx("button", { type: "button", onClick: () => setShowCustomReminder((prev) => !prev), "aria-pressed": showCustomReminder, className: `rounded-full border px-2.5 py-1 text-xs font-medium transition-colors ${showCustomReminder
+                                                        ? "border-accent bg-accent/15 text-accent"
+                                                        : "border-border/30 text-muted hover:border-border/60 hover:text-txt"}`, children: t("eventEditor.reminderCustom", { defaultValue: "Custom" }) })] }), form.reminderMinutes.some((minutes) => !REMINDER_PRESETS.some((preset) => preset.minutes === minutes)) ? (_jsx("div", { className: "flex flex-wrap gap-1.5", children: form.reminderMinutes
+                                                .filter((minutes) => !REMINDER_PRESETS.some((preset) => preset.minutes === minutes))
+                                                .map((minutes) => (_jsxs("span", { className: "inline-flex items-center gap-1 rounded-full border border-accent/40 bg-accent/10 px-2 py-0.5 text-[11px] font-medium text-accent", children: [minutes, "m", _jsx("button", { type: "button", "aria-label": t("eventEditor.reminderRemove", {
+                                                            defaultValue: "Remove reminder",
+                                                        }), onClick: () => toggleReminderPreset(minutes), className: "rounded-full p-0.5 hover:bg-accent/20", children: _jsx(X, { className: "h-3 w-3" }) })] }, minutes))) })) : null, showCustomReminder ? (_jsxs("div", { className: "flex items-center gap-2", children: [_jsx(Input, { type: "number", min: 0, value: customReminderDraft, onChange: (e) => setCustomReminderDraft(e.target.value), onKeyDown: (e) => {
+                                                        if (e.key === "Enter") {
+                                                            e.preventDefault();
+                                                            addCustomReminder();
+                                                        }
+                                                    }, placeholder: t("eventEditor.reminderCustomPlaceholder", {
+                                                        defaultValue: "Minutes before",
+                                                    }), "aria-label": t("eventEditor.reminderCustomAria", {
+                                                        defaultValue: "Custom reminder minutes",
+                                                    }), className: "w-32" }), _jsx(Button, { size: "sm", variant: "outline", className: "h-8 rounded-xl px-3 text-xs", onClick: addCustomReminder, children: t("common.add", { defaultValue: "Add" }) })] })) : null] }), _jsxs("div", { className: "space-y-1.5", children: [_jsx("label", { htmlFor: "event-editor-notes", className: "block text-xs font-medium text-muted", children: t("eventEditor.notes", { defaultValue: "Notes" }) }), _jsx(Textarea, { id: "event-editor-notes", value: form.notes, onChange: (e) => updateForm("notes", e.target.value), placeholder: t("eventEditor.notesPlaceholder", {
+                                                defaultValue: "Add notes…",
+                                            }), className: "min-h-20" })] })] }), _jsxs("div", { className: "flex flex-wrap items-center justify-between gap-3 border-t border-border/12 px-5 py-4", children: [_jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [!isCreate && onChat && event ? (_jsx(Button, { variant: "ghost", size: "sm", className: "h-8 rounded-xl px-3 text-xs font-semibold text-muted", onClick: () => onChat(event), children: t("common.chat", { defaultValue: "Chat" }) })) : null, !isCreate ? (_jsx(Button, { variant: "surfaceDestructive", size: "sm", className: "h-8 rounded-xl px-3 text-xs font-semibold", disabled: deleting || saving, onClick: () => setConfirmDeleteOpen(true), children: t("common.delete", { defaultValue: "Delete" }) })) : null] }), _jsxs("div", { className: "flex gap-2", children: [_jsx(Button, { variant: "outline", size: "sm", className: "h-8 rounded-xl px-3 text-xs font-semibold", onClick: onClose, disabled: saving, children: t("common.cancel", { defaultValue: "Cancel" }) }), _jsx(Button, { variant: "outline", size: "sm", className: "h-8 rounded-xl px-3 text-xs font-semibold", disabled: saving || !form.title.trim(), onClick: () => void handleSave({ keepOpen: true }), children: saving
+                                                ? primaryActionLoadingLabel
+                                                : t("eventEditor.saveAndContinue", {
+                                                    defaultValue: "Save & continue",
+                                                }) }), _jsx(Button, { size: "sm", className: "h-8 rounded-xl px-3 text-xs font-semibold", disabled: saving || !form.title.trim(), onClick: () => void handleSave(), children: saving ? primaryActionLoadingLabel : primaryActionLabel })] })] })] }) }), _jsx(ConfirmDialog, { open: confirmDeleteOpen, title: t("eventEditor.confirmDeleteTitle", {
+                    defaultValue: "Delete event?",
+                }), message: t("eventEditor.confirmDeleteDescription", {
+                    defaultValue: "This will delete the event from your calendar. This cannot be undone.",
+                }), confirmLabel: t("common.delete", { defaultValue: "Delete" }), cancelLabel: t("common.cancel", { defaultValue: "Cancel" }), variant: "danger", onConfirm: () => void handleDelete(), onCancel: () => setConfirmDeleteOpen(false) })] }));
+}

package/apps/app-lifeops/src/components/LifeOpsActivitySignalsEffect.d.ts

@@ -0,0 +1,2 @@
+export declare function LifeOpsActivitySignalsEffect(): null;
+//# sourceMappingURL=LifeOpsActivitySignalsEffect.d.ts.map

package/apps/app-lifeops/src/components/LifeOpsActivitySignalsEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LifeOpsActivitySignalsEffect.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/components/LifeOpsActivitySignalsEffect.tsx"],"names":[],"mappings":"AAGA,wBAAgB,4BAA4B,IAAI,IAAI,CAQnD"}

package/apps/app-lifeops/src/components/LifeOpsActivitySignalsEffect.js

@@ -0,0 +1,10 @@
+import { useApp } from "@elizaos/app-core";
+import { useLifeOpsActivitySignals } from "../hooks/useLifeOpsActivitySignals.js";
+export function LifeOpsActivitySignalsEffect() {
+    const { startupCoordinator, agentStatus, backendConnection } = useApp();
+    const enabled = startupCoordinator.phase === "ready" &&
+        agentStatus?.state === "running" &&
+        backendConnection?.state === "connected";
+    useLifeOpsActivitySignals(enabled);
+    return null;
+}

package/apps/app-lifeops/src/components/LifeOpsCalendarSection.d.ts

@@ -0,0 +1,15 @@
+/**
+ * LifeOpsCalendarSection — Google Calendar-style week/day/month views.
+ *
+ * Day/week views render an hour-by-hour grid and position events by their
+ * actual start/end time. Month view renders a 5-6 row day grid. Events get
+ * deterministic category colours derived from their calendar/account id so
+ * the same feed keeps the same colour across renders.
+ */
+import { type LifeOpsSelection } from "./LifeOpsSelectionContext.js";
+export interface LifeOpsCalendarSectionProps {
+    selection?: LifeOpsSelection;
+    onSelect?: (args: Partial<LifeOpsSelection> | null) => void;
+}
+export declare function LifeOpsCalendarSection(props?: LifeOpsCalendarSectionProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=LifeOpsCalendarSection.d.ts.map

package/apps/app-lifeops/src/components/LifeOpsCalendarSection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LifeOpsCalendarSection.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/components/LifeOpsCalendarSection.tsx"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAsBH,OAAO,EACL,KAAK,gBAAgB,EAEtB,MAAM,8BAA8B,CAAC;AAo2BtC,MAAM,WAAW,2BAA2B;IAC1C,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,IAAI,KAAK,IAAI,CAAC;CAC7D;AAED,wBAAgB,sBAAsB,CACpC,KAAK,GAAE,2BAAgC,2CAgOxC"}