tuiboard 0.7.2 → 0.8.0

package/src/store/calendar.ts

@@ -29,6 +29,14 @@ export interface CalEvent {
   endMin: number;
   color: string;
   source: "google" | "microsoft";
+  /** Google calendar id this event lives on (set for Google events only). */
+  calendarId?: string;
+  /** Google event id (set for Google events only). Needed to edit/delete. */
+  eventId?: string;
+  /** True when this event can be edited/deleted from tuiboard: a Google event
+   *  on an owner/writer calendar, with a write-scoped token. Microsoft events
+   *  and read-only-calendar events are never editable. */
+  editable?: boolean;
 }
 
 const GOOGLE_FALLBACK_COLOR = "#e8a05c";
@@ -143,6 +151,182 @@ async function googleAccessToken(tokenPath: string): Promise<string | null> {
   }
 }
 
+// ─── Google write (calendar list + event creation) ──────────────────────────
+
+/** A calendar the connected account can write to (accessRole owner/writer). */
+export interface WritableCalendar {
+  id: string;
+  summary: string;
+  accessRole: string;
+  color: string;
+  primary: boolean;
+}
+
+/**
+ * List the calendars the connected Google account can WRITE to (owner/writer),
+ * with display name + color. Used by the new-event calendar picker. Returns []
+ * on any failure. (Read path `fetchGoogle` keeps its own, reader-scoped query.)
+ */
+export async function listGoogleCalendars(
+  cfg: GoogleCalendarConfig,
+): Promise<WritableCalendar[]> {
+  const access = await googleAccessToken(cfg.token);
+  if (!access) return [];
+  try {
+    const res = await fetch(
+      "https://www.googleapis.com/calendar/v3/users/me/calendarList",
+      { headers: { Authorization: `Bearer ${access}` } },
+    );
+    if (!res.ok) return [];
+    const list = (await res.json()) as {
+      items?: Array<{
+        id: string;
+        summary?: string;
+        accessRole?: string;
+        backgroundColor?: string;
+        primary?: boolean;
+      }>;
+    };
+    return (list.items ?? [])
+      .filter((c) => c.accessRole === "owner" || c.accessRole === "writer")
+      .map((c) => ({
+        id: c.id,
+        summary: c.summary ?? c.id,
+        accessRole: c.accessRole ?? "reader",
+        color: c.backgroundColor || cfg.color || GOOGLE_FALLBACK_COLOR,
+        primary: c.primary === true,
+      }));
+  } catch {
+    return [];
+  }
+}
+
+/** True if the persisted Google token carries an event-write scope. Gates the
+ *  whole event-creation UI so read-only users never see it. */
+export function googleTokenCanWrite(tokenPath: string): boolean {
+  try {
+    const tok = JSON.parse(readFileSync(tokenPath, "utf-8")) as { scopes?: string[] };
+    return (
+      Array.isArray(tok.scopes) &&
+      tok.scopes.some((s) => s.includes("calendar.events") || s.endsWith("/auth/calendar"))
+    );
+  } catch {
+    return false;
+  }
+}
+
+/** RFC3339 timestamp with the LOCAL UTC offset for `min` minutes past local
+ *  midnight of `dateIso` — e.g. "2026-06-03T15:00:00+02:00". Per-instant offset,
+ *  so DST is handled; Google then stores the wall-clock time exactly as typed. */
+function localRfc3339(dateIso: string, min: number): string {
+  const d = new Date(dayStartMs(dateIso) + min * 60000);
+  const pad = (n: number) => String(n).padStart(2, "0");
+  const offMin = -d.getTimezoneOffset(); // minutes east of UTC
+  const sign = offMin >= 0 ? "+" : "-";
+  const off = Math.abs(offMin);
+  return (
+    `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}` +
+    `T${pad(d.getHours())}:${pad(d.getMinutes())}:00` +
+    `${sign}${pad(Math.floor(off / 60))}:${pad(off % 60)}`
+  );
+}
+
+/**
+ * Create a Google Calendar event on `calendarId`. Unlike the read path, this
+ * surfaces failures (returns {ok:false,error}) so the UI can flash a banner.
+ */
+export async function createGoogleEvent(
+  cfg: GoogleCalendarConfig,
+  args: { calendarId: string; title: string; dateIso: string; startMin: number; endMin: number },
+): Promise<{ ok: true } | { ok: false; error: string }> {
+  const access = await googleAccessToken(cfg.token);
+  if (!access) {
+    return { ok: false, error: "not authorized — run: tuiboard calendar-setup google --write" };
+  }
+  try {
+    const res = await fetch(
+      `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(args.calendarId)}/events`,
+      {
+        method: "POST",
+        headers: { Authorization: `Bearer ${access}`, "Content-Type": "application/json" },
+        body: JSON.stringify({
+          summary: args.title,
+          start: { dateTime: localRfc3339(args.dateIso, args.startMin) },
+          end: { dateTime: localRfc3339(args.dateIso, args.endMin) },
+        }),
+      },
+    );
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      return { ok: false, error: `${res.status} ${body.slice(0, 140)}` };
+    }
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: String(e) };
+  }
+}
+
+/**
+ * Edit an existing Google Calendar event's title + time (same calendar — moving
+ * an event between calendars is intentionally not supported). PATCH so untouched
+ * fields (attendees, description, recurrence, …) are preserved.
+ */
+export async function updateGoogleEvent(
+  cfg: GoogleCalendarConfig,
+  args: { calendarId: string; eventId: string; title: string; dateIso: string; startMin: number; endMin: number },
+): Promise<{ ok: true } | { ok: false; error: string }> {
+  const access = await googleAccessToken(cfg.token);
+  if (!access) {
+    return { ok: false, error: "not authorized — run: tuiboard calendar-setup google --write" };
+  }
+  try {
+    const res = await fetch(
+      `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(args.calendarId)}/events/${encodeURIComponent(args.eventId)}`,
+      {
+        method: "PATCH",
+        headers: { Authorization: `Bearer ${access}`, "Content-Type": "application/json" },
+        body: JSON.stringify({
+          summary: args.title,
+          start: { dateTime: localRfc3339(args.dateIso, args.startMin) },
+          end: { dateTime: localRfc3339(args.dateIso, args.endMin) },
+        }),
+      },
+    );
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      return { ok: false, error: `${res.status} ${body.slice(0, 140)}` };
+    }
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: String(e) };
+  }
+}
+
+/** Delete a Google Calendar event. DELETE returns 204 (no body) on success. */
+export async function deleteGoogleEvent(
+  cfg: GoogleCalendarConfig,
+  args: { calendarId: string; eventId: string },
+): Promise<{ ok: true } | { ok: false; error: string }> {
+  const access = await googleAccessToken(cfg.token);
+  if (!access) {
+    return { ok: false, error: "not authorized — run: tuiboard calendar-setup google --write" };
+  }
+  try {
+    const res = await fetch(
+      `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(args.calendarId)}/events/${encodeURIComponent(args.eventId)}`,
+      { method: "DELETE", headers: { Authorization: `Bearer ${access}` } },
+    );
+    // 410 Gone = already deleted; treat as success (the goal state is reached).
+    if (!res.ok && res.status !== 410) {
+      const body = await res.text().catch(() => "");
+      return { ok: false, error: `${res.status} ${body.slice(0, 140)}` };
+    }
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: String(e) };
+  }
+}
+
 async function fetchGoogle(
   cfg: GoogleCalendarConfig,
   dateIso: string,
@@ -168,13 +352,17 @@ async function fetchGoogle(
     );
     if (!listRes.ok) return [];
     const list = (await listRes.json()) as {
-      items?: Array<{ id: string; backgroundColor?: string; selected?: boolean }>;
+      items?: Array<{ id: string; backgroundColor?: string; selected?: boolean; accessRole?: string }>;
     };
+    // Events are editable only with a write-scoped token AND on a calendar the
+    // account owns/can-write. Computed once here, stamped on each event below.
+    const canWrite = googleTokenCanWrite(cfg.token);
     const cals = (list.items ?? []).map((c) => ({
       id: c.id,
       color: c.backgroundColor || fallback,
+      writable: canWrite && (c.accessRole === "owner" || c.accessRole === "writer"),
     }));
-    if (cals.length === 0) cals.push({ id: "primary", color: fallback });
+    if (cals.length === 0) cals.push({ id: "primary", color: fallback, writable: false });
 
     const events: CalEvent[] = [];
     const seen = new Set<string>();
@@ -209,6 +397,9 @@ async function fetchGoogle(
                 endMin,
                 color: cal.color,
                 source: "google",
+                calendarId: cal.id,
+                eventId: it.id,
+                editable: cal.writable && !!it.id,
               },
             });
           }

package/src/store/index.ts

@@ -28,7 +28,16 @@ import {
   type BoardWatcher,
 } from "~/io/watcher";
 import { createAgentsStore, type AgentsStore } from "./agents";
-import { createCalendarStore, type CalendarStore } from "./calendar";
+import {
+  createCalendarStore,
+  createGoogleEvent,
+  deleteGoogleEvent,
+  googleTokenCanWrite,
+  listGoogleCalendars,
+  updateGoogleEvent,
+  type CalendarStore,
+  type WritableCalendar,
+} from "./calendar";
 import { ConflictError, statMtime, writeBoardFile } from "~/io/writer";
 import { isTask, parseBoard } from "~/parser/markdown";
 import { serializeBoard } from "~/parser/serialize";
@@ -67,9 +76,44 @@ export type ModalKind =
   | { kind: "confirm-delete"; ref: TaskRef }
   | { kind: "detail"; ref: TaskRef }
   | { kind: "agent-detail"; sessionId: string }
+  | { kind: "event"; dateIso: string; startMin: number; endMin: number }
+  | { kind: "event-edit" }
+  | { kind: "confirm-delete-event" }
   | { kind: "search" }
   | { kind: "help" };
 
+/**
+ * Transient state for the two-step "new calendar event" modal. Step 1 is the
+ * title+time `<input>`; step 2 is the calendar picker, navigated via handleKey
+ * (no input focused). Lives in UI state so the key handler can drive it.
+ */
+export interface EventPicker {
+  step: 1 | 2;
+  /** Selection index into `cals` (step 2). */
+  sel: number;
+  title: string;
+  dateIso: string;
+  startMin: number;
+  endMin: number;
+  cals: WritableCalendar[];
+}
+
+/**
+ * The Google Calendar event currently selected in the Agenda (by clicking an
+ * editable event band). Parallel to `armedTimelineRef` but for read/write
+ * calendar events rather than tasks. While set, `e` edits and `d` deletes it.
+ */
+export interface SelectedCalEvent {
+  calendarId: string;
+  eventId: string;
+  title: string;
+  startMin: number;
+  endMin: number;
+  /** The Agenda day the event was selected on — its date for the API call. */
+  dateIso: string;
+  color: string;
+}
+
 /** Which dashboard zone owns the keyboard cursor. */
 export type ActiveZone = "planner" | "board" | "timeline" | "agents";
 
@@ -118,6 +162,13 @@ export interface UIState {
    * cancels.
    */
   armedTimelineRef?: TaskRef;
+  /**
+   * The Google Calendar event currently selected in the Agenda (clicked). While
+   * set, the Agenda zone's `e` edits it and `d` deletes it; any navigation key
+   * or `Esc` clears it. Only ever set for editable events (owner/writer + write
+   * token), so the presence of this implies "actionable".
+   */
+  selectedCalEvent?: SelectedCalEvent;
   /**
    * Persistent calendar "arm mode" (toggled with `c`). While on, clicking any
    * task in the board / planner panel arms it for the timeline, so you can
@@ -146,6 +197,8 @@ export interface UIState {
   banner?: { kind: "info" | "warn" | "error"; text: string; ts: number };
   /** Open modal, if any. Keyboard handler routes input to the modal when set. */
   modal?: ModalKind;
+  /** Two-step new-event modal state (set only while `modal.kind === "event"`). */
+  eventPicker?: EventPicker;
 }
 
 export interface UndoEntry {
@@ -1058,6 +1111,150 @@ export function createTuiStore({ config }: CreateStoreOptions) {
 
   function closeModal(): void {
     setState("ui", "modal", undefined);
+    setState("ui", "eventPicker", undefined);
+  }
+
+  // ─── New calendar event (two-step modal) ─────────────────────────────────
+
+  /** Open the "new event" modal for a time slot. Guarded on Google write being
+   *  connected; prefetches the writable calendars while the user types. */
+  function openEventModal(dateIso: string, startMin: number, endMin: number): void {
+    const g = config.calendars?.google;
+    if (!g || !googleTokenCanWrite(g.token)) {
+      flashBanner("warn", "Connect Google write first: tuiboard calendar-setup google --write");
+      return;
+    }
+    setState("ui", "eventPicker", { step: 1, sel: 0, title: "", dateIso, startMin, endMin, cals: [] });
+    // Defer the modal open so the OpenTUI <input> mounts after this key event.
+    setTimeout(() => openModal({ kind: "event", dateIso, startMin, endMin }), 0);
+    void listGoogleCalendars(g).then((cals) => {
+      setState("ui", "eventPicker", produce((p: EventPicker | undefined) => {
+        if (p && p.cals.length === 0) p.cals = cals;
+      }));
+    });
+  }
+
+  /** Step 1 → step 2: stash the parsed title + time, load calendars if needed,
+   *  preselect the default, and either show the picker or (single calendar)
+   *  create immediately. */
+  async function advanceEventToStep2(title: string, startMin: number, endMin: number): Promise<void> {
+    const g = config.calendars?.google;
+    if (!g || !state.ui.eventPicker) { closeModal(); return; }
+    let cals = state.ui.eventPicker.cals;
+    if (cals.length === 0) cals = await listGoogleCalendars(g);
+    if (cals.length === 0) {
+      flashBanner("warn", "No writable Google calendars");
+      closeModal();
+      return;
+    }
+    const def = g.defaultCalendar;
+    const idx = cals.findIndex((c) => (def ? c.id === def : c.primary));
+    setState("ui", "eventPicker", produce((p: EventPicker | undefined) => {
+      if (!p) return;
+      p.title = title;
+      p.startMin = startMin;
+      p.endMin = endMin;
+      p.cals = cals;
+      p.sel = idx < 0 ? 0 : idx;
+      p.step = 2;
+    }));
+    if (cals.length === 1) void confirmEventPicker();
+  }
+
+  /** Move the step-2 calendar selection (wraps). */
+  function setEventSel(n: number): void {
+    setState("ui", "eventPicker", produce((p: EventPicker | undefined) => {
+      if (!p || p.cals.length === 0) return;
+      p.sel = ((n % p.cals.length) + p.cals.length) % p.cals.length;
+    }));
+  }
+
+  /** Create the event on the selected calendar, refresh the agenda, close. */
+  async function confirmEventPicker(): Promise<void> {
+    const p = state.ui.eventPicker;
+    const g = config.calendars?.google;
+    if (!p || !g) { closeModal(); return; }
+    const calendarId = p.cals[p.sel]?.id ?? g.defaultCalendar ?? "primary";
+    const title = p.title.trim() || "(busy)";
+    closeModal();
+    const r = await createGoogleEvent(g, {
+      calendarId,
+      title,
+      dateIso: p.dateIso,
+      startMin: p.startMin,
+      endMin: p.endMin,
+    });
+    if (r.ok) {
+      calendarStore.refresh(true);
+      flashBanner("info", `📅 Event created: ${title}`);
+    } else {
+      flashBanner("error", `Create failed: ${r.error}`);
+    }
+  }
+
+  // ─── Edit / delete an existing calendar event ────────────────────────────
+
+  /** Select an editable Google event (clicked in the Agenda). Toggles off if
+   *  the same event is clicked again. Clears any armed task so the two
+   *  selection models don't fight. */
+  function selectCalEvent(sel: SelectedCalEvent): void {
+    const cur = state.ui.selectedCalEvent;
+    if (cur && cur.calendarId === sel.calendarId && cur.eventId === sel.eventId) {
+      setState("ui", "selectedCalEvent", undefined);
+      return;
+    }
+    setState("ui", "armedTimelineRef", undefined);
+    setState("ui", "selectedCalEvent", sel);
+  }
+
+  function clearCalSelection(): void {
+    setState("ui", "selectedCalEvent", undefined);
+  }
+
+  /** Open the edit modal for the selected event (deferred so the <input>
+   *  mounts after this key event). No-op if nothing is selected. */
+  function openEventEditModal(): void {
+    if (!state.ui.selectedCalEvent) return;
+    setTimeout(() => openModal({ kind: "event-edit" }), 0);
+  }
+
+  /** Save the edited title/time to the selected event, refresh, close. */
+  async function confirmEventEdit(title: string, startMin: number, endMin: number): Promise<void> {
+    const sel = state.ui.selectedCalEvent;
+    const g = config.calendars?.google;
+    if (!sel || !g) { closeModal(); return; }
+    closeModal();
+    const r = await updateGoogleEvent(g, {
+      calendarId: sel.calendarId,
+      eventId: sel.eventId,
+      title: title.trim() || sel.title,
+      dateIso: sel.dateIso,
+      startMin,
+      endMin,
+    });
+    clearCalSelection();
+    if (r.ok) {
+      calendarStore.refresh(true);
+      flashBanner("info", `✏ Event updated: ${title.trim() || sel.title}`);
+    } else {
+      flashBanner("error", `Update failed: ${r.error}`);
+    }
+  }
+
+  /** Delete the selected event, refresh, close. */
+  async function confirmDeleteEvent(): Promise<void> {
+    const sel = state.ui.selectedCalEvent;
+    const g = config.calendars?.google;
+    if (!sel || !g) { closeModal(); return; }
+    closeModal();
+    const r = await deleteGoogleEvent(g, { calendarId: sel.calendarId, eventId: sel.eventId });
+    clearCalSelection();
+    if (r.ok) {
+      calendarStore.refresh(true);
+      flashBanner("info", `🗑 Event deleted: ${sel.title}`);
+    } else {
+      flashBanner("error", `Delete failed: ${r.error}`);
+    }
   }
 
   // ─── Private mutation helper ─────────────────────────────────────────────
@@ -1133,6 +1330,15 @@ export function createTuiStore({ config }: CreateStoreOptions) {
     resetAllOverdueToToday,
     openModal,
     closeModal,
+    openEventModal,
+    advanceEventToStep2,
+    setEventSel,
+    confirmEventPicker,
+    selectCalEvent,
+    clearCalSelection,
+    openEventEditModal,
+    confirmEventEdit,
+    confirmDeleteEvent,
     flashBanner,
     clearBanner,
     // undo

package/src/store/timeline.ts

@@ -50,6 +50,12 @@ export interface CalTimelineEntry extends BaseEntry {
   title: string;
   color: string;
   source: "google" | "microsoft";
+  /** Google calendar id (Google events only) — needed to edit/delete. */
+  calendarId?: string;
+  /** Google event id (Google events only) — needed to edit/delete. */
+  eventId?: string;
+  /** True when this event can be edited/deleted from tuiboard. */
+  editable?: boolean;
 }
 
 export type TimelineEntry = TaskTimelineEntry | CalTimelineEntry;
@@ -168,7 +174,16 @@ export function buildTimelineEntries(
  * the target day) into grid entries, clipped to the rendered window.
  */
 export function buildCalendarEntries(
-  events: Array<{ title: string; startMin: number; endMin: number; color: string; source: "google" | "microsoft" }>,
+  events: Array<{
+    title: string;
+    startMin: number;
+    endMin: number;
+    color: string;
+    source: "google" | "microsoft";
+    calendarId?: string;
+    eventId?: string;
+    editable?: boolean;
+  }>,
 ): CalTimelineEntry[] {
   const out: CalTimelineEntry[] = [];
   for (const e of events) {
@@ -179,6 +194,9 @@ export function buildCalendarEntries(
       title: e.title,
       color: e.color,
       source: e.source,
+      calendarId: e.calendarId,
+      eventId: e.eventId,
+      editable: e.editable,
       startMin: e.startMin,
       endMin: e.endMin,
       startRow: rows.startRow,