From 9aecfdf76c19795a2bc22cd18aaa967966199515 Mon Sep 17 00:00:00 2001 From: Andy Anderson Date: Mon, 16 Nov 2026 21:48:17 -0500 Subject: [PATCH 1/2] =?UTF-8?q?=E2=9C=A8=20Meetings:=20delete=20finished?= =?UTF-8?q?=20meetings=20and=20stale=20join=20requests?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Owner-only DELETE /api/meetings/{id} for meetings in a final state and pending join requests (declined, then removed); 409 while hive is still in the meeting. Removes the record, transcript and live state, erases the meeting in Vexa with Quorum meeting.delete (best effort, surfaced as upstream_error) and drops the Calendar entry that existed only for it. POST /api/meetings/clear-finished deletes all finished meetings older than now; DELETE /api/meetings/schedule/{eid} deletes a past Calendar entry with its meetings. Knowledge facts and drafts are not touched. Audited as meeting_delete / meeting_schedule_delete. UI: 🗑 Delete on finished and join-request rows, Clear finished, and 🗑 Delete on past Calendar entries, all behind the in-page confirm. Signed-off-by: Andy Anderson --- changelog.d/added-meetings-delete.md | 1 + dashboard/openapi.json | 204 ++++++++++++++++++ src/cmd/hive/main.go | 7 +- src/cmd/hive/meetings_dashboard.go | 34 ++- src/cmd/hive/meetings_delete_test.go | 102 +++++++++ src/cmd/hive/meetings_schedule.go | 51 ++++- src/docs/api-reference/knowledge.md | 37 ++-- src/docs/meetings.md | 3 + src/pkg/dashboard/api_meetings.go | 6 + src/pkg/dashboard/api_meetings_delete.go | 140 ++++++++++++ src/pkg/dashboard/api_meetings_delete_test.go | 183 ++++++++++++++++ src/pkg/dashboard/api_meetings_schedule.go | 3 + .../dashboard/api_meetings_schedule_test.go | 3 + src/pkg/dashboard/api_meetings_test.go | 3 + src/pkg/dashboard/meetings_delete.test.js | 108 ++++++++++ src/pkg/dashboard/static-src/js/calendar.js | 36 ++++ src/pkg/dashboard/static-src/js/meetings.js | 95 +++++++- src/pkg/dashboard/static/index.html | 131 ++++++++++- src/pkg/meetings/delete.go | 119 ++++++++++ src/pkg/meetings/delete_test.go | 138 ++++++++++++ src/pkg/meetings/schedule/delete.go | 98 +++++++++ src/pkg/meetings/schedule/delete_test.go | 74 +++++++ src/pkg/meetings/schedule/store.go | 24 +++ src/pkg/meetings/store.go | 15 ++ 24 files changed, 1590 insertions(+), 25 deletions(-) create mode 100644 changelog.d/added-meetings-delete.md create mode 100644 src/cmd/hive/meetings_delete_test.go create mode 100644 src/pkg/dashboard/api_meetings_delete.go create mode 100644 src/pkg/dashboard/api_meetings_delete_test.go create mode 100644 src/pkg/dashboard/meetings_delete.test.js create mode 100644 src/pkg/meetings/delete.go create mode 100644 src/pkg/meetings/delete_test.go create mode 100644 src/pkg/meetings/schedule/delete.go create mode 100644 src/pkg/meetings/schedule/delete_test.go diff --git a/changelog.d/added-meetings-delete.md b/changelog.d/added-meetings-delete.md new file mode 100644 index 0000000000..075ec6b901 --- /dev/null +++ b/changelog.d/added-meetings-delete.md @@ -0,0 +1 @@ +- Meetings: finished meetings (ended, failed, blocked, declined, left) and stale join requests get a 🗑 Delete action with an in-page confirm, plus **Clear finished** to delete all finished meetings at once. Delete removes the meeting record, its transcript and live state on the hive, erases it in Vexa with Quorum `meeting.delete` (best effort; a failure is reported and the record is still removed), and drops the Calendar entry that existed only for that meeting. Past Calendar entries get the same 🗑 Delete; scheduled ones keep Skip and Cancel. A meeting hive is still in answers 409 (leave it first). Knowledge facts and drafts made from a meeting are not touched. Owner only, audited as `meeting_delete` (`DELETE /api/meetings/{id}`, `POST /api/meetings/clear-finished`, `DELETE /api/meetings/schedule/{eid}`). diff --git a/dashboard/openapi.json b/dashboard/openapi.json index 761668e955..9840b8ecbe 100644 --- a/dashboard/openapi.json +++ b/dashboard/openapi.json @@ -149,6 +149,152 @@ } } }, + "/api/meetings/clear-finished": { + "post": { + "tags": [ + "Meetings" + ], + "summary": "Clear finished meetings", + "description": "Owner only. Deletes every meeting in a final state that finished before `before` (RFC 3339; empty or later than now means now), each exactly like DELETE /api/meetings/{id}. Live meetings and pending join requests stay. Each deleted meeting is audited as meeting_delete.", + "requestBody": { + "required": false, + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "before": { + "type": "string", + "format": "date-time" + } + } + } + } + } + }, + "responses": { + "200": { + "description": "Deleted meetings", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "deleted": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "state": { + "type": "string", + "description": "The state the meeting was in" + }, + "upstream_error": { + "type": "string", + "description": "Set when Vexa (Quorum meeting.delete) could not confirm the erase; the record on this hive is removed anyway" + }, + "calendar_removed": { + "type": "integer", + "description": "Calendar entries removed because they existed only for this meeting" + } + } + } + }, + "count": { + "type": "integer" + } + } + } + } + } + }, + "400": { + "description": "before is not an RFC 3339 time" + }, + "403": { + "description": "Owner access required" + }, + "503": { + "description": "Meetings are not enabled on this hive" + } + } + } + }, + "/api/meetings/schedule/{eid}": { + "delete": { + "tags": [ + "Meetings" + ], + "summary": "Delete a past Calendar entry", + "description": "Owner only. Deletes a finished Calendar entry (ended, cancelled, declined, failed, blocked, skipped) and the meetings it created, each like DELETE /api/meetings/{id}. Entries still scheduled, awaiting approval or live keep Skip and Cancel and answer 409, as does an entry whose meeting hive is still in. Audited as meeting_schedule_delete, plus meeting_delete for each meeting.", + "parameters": [ + { + "name": "eid", + "in": "path", + "required": true, + "schema": { + "type": "string" + }, + "description": "Schedule event id" + } + ], + "responses": { + "200": { + "description": "Deleted", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "meetings": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "state": { + "type": "string", + "description": "The state the meeting was in" + }, + "upstream_error": { + "type": "string", + "description": "Set when Vexa (Quorum meeting.delete) could not confirm the erase; the record on this hive is removed anyway" + }, + "calendar_removed": { + "type": "integer", + "description": "Calendar entries removed because they existed only for this meeting" + } + } + } + } + } + } + } + } + }, + "403": { + "description": "Owner access required" + }, + "404": { + "description": "Unknown event" + }, + "409": { + "description": "The entry is still to come or live, or hive is still in its meeting" + }, + "503": { + "description": "Meetings are not enabled on this hive" + } + } + } + }, "/api/meetings/{id}/decline": { "post": { "tags": [ @@ -438,6 +584,64 @@ } }, "/api/meetings/{id}": { + "delete": { + "tags": [ + "Meetings" + ], + "summary": "Delete a finished meeting or a pending join request", + "description": "Owner only. Allowed for a meeting in a final state (ended, failed, blocked, declined, left, handed_off, purged) and for a pending platform join request (declined with meeting.leave, then removed). Removes the meeting record, its transcript and live state on this hive, erases it in Vexa with Quorum meeting.delete (best effort: not_found is fine, any other error is returned as upstream_error while the record is still removed) and removes the Calendar entry that existed only for this meeting. Knowledge facts and drafts already made from the meeting are not touched. Audited as meeting_delete.", + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "Deleted", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "state": { + "type": "string", + "description": "The state the meeting was in" + }, + "upstream_error": { + "type": "string", + "description": "Set when Vexa (Quorum meeting.delete) could not confirm the erase; the record on this hive is removed anyway" + }, + "calendar_removed": { + "type": "integer", + "description": "Calendar entries removed because they existed only for this meeting" + } + } + } + } + } + }, + "403": { + "description": "Owner access required" + }, + "404": { + "description": "Unknown meeting" + }, + "409": { + "description": "Hive is still joining, in the lobby of or live in the meeting: leave the meeting first" + }, + "503": { + "description": "Meetings are not enabled on this hive" + } + } + }, "get": { "tags": [ "Meetings" diff --git a/src/cmd/hive/main.go b/src/cmd/hive/main.go index ce9b28d25c..def07f7cef 100644 --- a/src/cmd/hive/main.go +++ b/src/cmd/hive/main.go @@ -3593,12 +3593,15 @@ func (b *boot) bootDashboardAPIWith(deps bootDashboardAPIDeps) { // Drafts people ask Betty for, approved in the dashboard (#18406). b.wireMeetingsActions(store) // Owner API, live panel and /api/events frames (#18292). - b.dashSrv.SetMeetingsService(&meetingsDashboard{mgr: mgr, live: b.meetingsLive}) - // Scheduled meetings and the Calendar section (#18394). + md := &meetingsDashboard{mgr: mgr, live: b.meetingsLive} + // Scheduled meetings and the Calendar section (#18394). Wired + // first so a deleted meeting's Calendar entry goes with it. if svc, stop := wireMeetingsSchedule(b.cfg, mgr, b.logger); svc != nil { b.cleanup.push(stop) b.dashSrv.SetMeetingsScheduleService(svc) + md.sched = svc.sched } + b.dashSrv.SetMeetingsService(md) // Ended meetings become inbox items; transcripts are purged // after meetings.retention_days (#18293). b.wireMeetingsInbox(mgr, store) diff --git a/src/cmd/hive/meetings_dashboard.go b/src/cmd/hive/meetings_dashboard.go index 8bc8aeb0d6..299ffb0cf2 100644 --- a/src/cmd/hive/meetings_dashboard.go +++ b/src/cmd/hive/meetings_dashboard.go @@ -4,10 +4,12 @@ import ( "context" "errors" "fmt" + "time" "github.com/hivecommons/hive/pkg/dashboard" "github.com/hivecommons/hive/pkg/meetings" "github.com/hivecommons/hive/pkg/meetings/live" + "github.com/hivecommons/hive/pkg/meetings/schedule" ) // meetingsDashboard implements dashboard.MeetingsService over the meeting @@ -16,6 +18,8 @@ import ( type meetingsDashboard struct { mgr *meetings.Manager live *live.Runner + // sched, when the Calendar runs, forgets a deleted meeting's entry. + sched *schedule.Scheduler } // meetingsDashboardError maps meetings errors onto the dashboard's @@ -28,7 +32,8 @@ func meetingsDashboardError(err error) error { return fmt.Errorf("%w: %v", dashboard.ErrMeetingNotFound, err) case errors.Is(err, meetings.ErrInvalidRequest), meetings.IsCode(err, meetings.CodeInvalidArgument): return fmt.Errorf("%w: %v", dashboard.ErrMeetingInvalid, err) - case errors.Is(err, live.ErrNotPending), errors.Is(err, live.ErrSessionEnded), errors.Is(err, meetings.ErrNotLive), errors.Is(err, meetings.ErrNotRequested): + case errors.Is(err, live.ErrNotPending), errors.Is(err, live.ErrSessionEnded), errors.Is(err, meetings.ErrNotLive), errors.Is(err, meetings.ErrNotRequested), + errors.Is(err, meetings.ErrStillRunning): return fmt.Errorf("%w: %v", dashboard.ErrMeetingConflict, err) default: return err @@ -101,6 +106,33 @@ func (d *meetingsDashboard) DeclineRequest(ctx context.Context, id string) (any, return m, nil } +// meetingDeleted is the dashboard's view of a deleted meeting; with the +// Calendar running, the entry that existed only for it goes too. +func meetingDeleted(res meetings.DeleteResult, sched *schedule.Scheduler) dashboard.MeetingDeleted { + out := dashboard.MeetingDeleted{ID: res.Meeting.ID, State: string(res.Meeting.State), UpstreamError: res.UpstreamError} + if sched != nil { + out.CalendarRemoved = sched.ForgetMeeting(res.Meeting.ID) + } + return out +} + +func (d *meetingsDashboard) Delete(ctx context.Context, id string) (dashboard.MeetingDeleted, error) { + res, err := d.mgr.Delete(ctx, id) + if err != nil { + return dashboard.MeetingDeleted{}, meetingsDashboardError(err) + } + return meetingDeleted(res, d.sched), nil +} + +func (d *meetingsDashboard) ClearFinished(ctx context.Context, before time.Time) ([]dashboard.MeetingDeleted, error) { + list, err := d.mgr.ClearFinished(ctx, before) + out := make([]dashboard.MeetingDeleted, 0, len(list)) + for _, res := range list { + out = append(out, meetingDeleted(res, d.sched)) + } + return out, meetingsDashboardError(err) +} + // meetingLive is the panel snapshot. type meetingLive struct { Meeting meetings.Meeting `json:"meeting"` diff --git a/src/cmd/hive/meetings_delete_test.go b/src/cmd/hive/meetings_delete_test.go new file mode 100644 index 0000000000..76d7ef7edb --- /dev/null +++ b/src/cmd/hive/meetings_delete_test.go @@ -0,0 +1,102 @@ +package main + +import ( + "context" + "encoding/json" + "errors" + "os" + "path/filepath" + "testing" + "time" + + "github.com/hivecommons/hive/pkg/config" + "github.com/hivecommons/hive/pkg/dashboard" + "github.com/hivecommons/hive/pkg/meetings" + "github.com/hivecommons/hive/pkg/meetings/schedule" +) + +// TestMeetingsDeleteAdapters: deleting a meeting drops the Calendar entry +// that existed only for it; deleting a past Calendar entry deletes its +// meeting; live meetings and entries still to come answer 409. +func TestMeetingsDeleteAdapters(t *testing.T) { + dir := t.TempDir() + store, err := meetings.NewStore(dir) + if err != nil { + t.Fatal(err) + } + now := time.Now().UTC().Truncate(time.Second) + past := now.Add(-2 * time.Hour) + for _, m := range []meetings.Meeting{ + {ID: "mtg-ended", NativeID: "q-e", State: meetings.StateEnded, EndedAt: &past, CreatedAt: past}, + {ID: "mtg-cal", NativeID: "q-c", State: meetings.StateFailed, EndedAt: &past, CreatedAt: past}, + {ID: "mtg-live", NativeID: "q-l", State: meetings.StateLive, CreatedAt: past}, + } { + if err := store.Save(m); err != nil { + t.Fatal(err) + } + } + ev := func(uid string, st schedule.Status, start time.Time, mid string) schedule.Event { + e := schedule.Event{UID: uid, Start: start, Status: st, Platform: schedule.PlatformGoogleMeet, + JoinURL: "https://meet.google.com/abc", Source: schedule.SourceManual, MeetingID: mid, CreatedAt: past, UpdatedAt: now} + if mid != "" { + e.History = []schedule.Occurrence{{Start: start, MeetingID: mid, Status: st}} + } + e.ID = schedule.EventID(uid, nil) + return e + } + ended := ev("u-ended", schedule.StatusEnded, past, "mtg-ended") + failed := ev("u-cal", schedule.StatusFailed, past, "mtg-cal") + future := ev("u-future", schedule.StatusScheduled, now.Add(24*time.Hour), "") + data, err := json.Marshal(map[string]any{"version": 1, "events": []schedule.Event{ended, failed, future}}) + if err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(dir, schedule.FileName), data, 0o600); err != nil { + t.Fatal(err) + } + mgr, err := meetings.NewManager(meetings.Options{Store: store, Quorum: &stubQuorum{events: make(chan meetings.Event, 1)}}) + if err != nil { + t.Fatal(err) + } + defer mgr.Close() + cfg := &config.Config{} + cfg.Meetings.DataDir = dir + svc, stop := wireMeetingsSchedule(cfg, mgr, nil) + if svc == nil { + t.Fatal("schedule not wired") + } + defer stop() + md := &meetingsDashboard{mgr: mgr, sched: svc.sched} + ctx := context.Background() + + if _, err := md.Delete(ctx, "mtg-live"); !errors.Is(err, dashboard.ErrMeetingConflict) { + t.Fatalf("delete live = %v, want conflict", err) + } + if _, err := md.Delete(ctx, "mtg-none"); !errors.Is(err, dashboard.ErrMeetingNotFound) { + t.Fatalf("delete unknown = %v, want not found", err) + } + d, err := md.Delete(ctx, "mtg-ended") + if err != nil || d.ID != "mtg-ended" || d.State != "ended" || d.CalendarRemoved != 1 { + t.Fatalf("delete ended = %+v, %v", d, err) + } + if _, err := svc.sched.Get(ended.ID); !errors.Is(err, schedule.ErrNotFound) { + t.Fatalf("calendar entry kept: %v", err) + } + + if _, err := svc.Delete(ctx, future.ID); !errors.Is(err, dashboard.ErrMeetingConflict) { + t.Fatalf("delete future entry = %v, want conflict", err) + } + cd, err := svc.Delete(ctx, failed.ID) + if err != nil || len(cd.Meetings) != 1 || cd.Meetings[0].ID != "mtg-cal" { + t.Fatalf("delete past entry = %+v, %v", cd, err) + } + if _, err := mgr.Get("mtg-cal"); !errors.Is(err, meetings.ErrNotFound) { + t.Fatalf("entry's meeting kept: %v", err) + } + if _, err := svc.sched.Get(future.ID); err != nil { + t.Fatalf("future entry touched: %v", err) + } + if _, err := mgr.Get("mtg-live"); err != nil { + t.Fatalf("live meeting touched: %v", err) + } +} diff --git a/src/cmd/hive/meetings_schedule.go b/src/cmd/hive/meetings_schedule.go index 06d2143aef..a7da1ae4c8 100644 --- a/src/cmd/hive/meetings_schedule.go +++ b/src/cmd/hive/meetings_schedule.go @@ -31,6 +31,8 @@ const ( // meeting scheduler (hivecommons/hive#18394). type meetingsSchedule struct { sched *schedule.Scheduler + // mgr deletes the meetings a deleted Calendar entry created. + mgr *meetings.Manager // attendee is the name the dashboard's "in a meeting" indicator uses. attendee string now func() time.Time @@ -129,6 +131,53 @@ func (d *meetingsSchedule) Act(_ context.Context, eid, action, by string) (any, return ev.Redacted(), nil } +// Delete removes a finished Calendar entry and the meetings it created. +// An entry still to come or live answers 409 (skip or cancel it); so does +// one whose meeting hive is still in. Meetings already gone are skipped. +func (d *meetingsSchedule) Delete(ctx context.Context, eid string) (dashboard.MeetingScheduleDeleted, error) { + out := dashboard.MeetingScheduleDeleted{ID: eid, Meetings: []dashboard.MeetingDeleted{}} + e, err := d.sched.Get(eid) + if err != nil { + return out, meetingsScheduleError(err) + } + if !e.Status.Terminal() { + return out, fmt.Errorf("%w: this meeting is %s; skip or cancel it instead", dashboard.ErrMeetingConflict, e.Status) + } + ids := schedule.LinkedMeetings(e) + if d.mgr != nil { + for _, id := range ids { + m, err := d.mgr.Get(id) + if errors.Is(err, meetings.ErrNotFound) { + continue + } + if err != nil { + return out, err + } + if !meetings.Deletable(m) { + return out, fmt.Errorf("%w: hive is still in this meeting; leave the meeting first", dashboard.ErrMeetingConflict) + } + } + } + if _, err := d.sched.Delete(eid); err != nil { + return out, meetingsScheduleError(err) + } + if d.mgr == nil { + return out, nil + } + for _, id := range ids { + res, err := d.mgr.Delete(ctx, id) + if errors.Is(err, meetings.ErrNotFound) { + continue + } + if err != nil { + out.Meetings = append(out.Meetings, dashboard.MeetingDeleted{ID: id, UpstreamError: err.Error()}) + continue + } + out.Meetings = append(out.Meetings, meetingDeleted(res, nil)) + } + return out, nil +} + // wireMeetingsSchedule starts the meeting scheduler over the manager // (hivecommons/hive#18394): schedule.json in the meetings data directory, // joins HIVE_MEETINGS_SCHEDULE_LEAD_S before start, scans every @@ -186,5 +235,5 @@ func wireMeetingsSchedule(cfg *config.Config, mgr *meetings.Manager, logger *slo <-done sched.Close() } - return &meetingsSchedule{sched: sched, attendee: attendeeName(cfg.Meetings.BotNameOrDefault()), now: time.Now}, stop + return &meetingsSchedule{sched: sched, mgr: mgr, attendee: attendeeName(cfg.Meetings.BotNameOrDefault()), now: time.Now}, stop } diff --git a/src/docs/api-reference/knowledge.md b/src/docs/api-reference/knowledge.md index dee53ced6e..e260b00954 100644 --- a/src/docs/api-reference/knowledge.md +++ b/src/docs/api-reference/knowledge.md @@ -89,23 +89,26 @@ Part of the [Dashboard REST API reference](../api-reference.md); see that page f | `DELETE` | `/api/inbox/recordings/{id}` | The recorder, or an owner | Abort an in-progress recording and delete its chunks; audited as `inbox_recording_abort` (403, 404, 409 already ended) | `pkg/dashboard/api_inbox_recordings.go:23` | | `GET` | `/api/inbox/recordings/{id}/audio` | Owner or read-write | Play a finished recording from this hive's disk on the dashboard origin: `http.ServeContent` (Range, 206), `Content-Type` audio/webm or audio/mp4, `Cache-Control: no-store`, `Cross-Origin-Resource-Policy: same-origin`. Opening a playback is audited as `inbox_recording_audio` (seeks are not). `GET /api/inbox/hive-recording/{id}/audio/stream` serves the same file (404 unknown or not finished, 410 audio expired after `inbox.recording.retention_days`) | `pkg/dashboard/api_inbox_recordings.go:24` | | `DELETE` | `/api/inbox/hive-recording/{id}` | An owner, or the read-write member who recorded it | Delete a finished recording for good: its stored audio and chunks, the Inbox item and its state, and its Knowledge fact with the machine transcript. What was already shared from it (RFC, issues, DIBS ideas, spek seeds) is not touched. 200 `{id, deleted, fact_removed, shares_kept}`; audited as `inbox_recording_delete` (403 read role or someone else's recording, 404 unknown, 409 still in progress or being transcribed) | `pkg/dashboard/api_inbox_recordings.go:25` | -| `GET` | `/api/meetings/settings` | Owner only | Meetings settings: `enabled`, `enabled_env_override`, `running`, `vexa_url`, `vexa_key_set`, `discord_token_set`, `transcribe_token_set`, `tts_token_set` (secrets are never returned) and `effective` values of the other `meetings.*` keys ([env vars](../env-vars.md#meetings-quorum)) | `pkg/dashboard/api_meetings.go:123` | -| `POST` | `/api/meetings/settings` | Owner only | Update `meetings.enabled` and `meetings.vexa.url`, and write the Vexa tenant key, Discord bot token, transcription service token and TTS service token to keystore-sealed secret files (`""` clears one): `{enabled?, vexa_url?, vexa_api_key?, discord_token?, transcribe_token?, tts_token?}`. Returns the settings with `restart_required`; 400 on an invalid value. Audited as `meetings_settings` | `pkg/dashboard/api_meetings.go:124` | -| `POST` | `/api/meetings` | Owner only | Send hive to a meeting: `{url}` for Google Meet, Teams or Zoom, or `{platform: "discord", guild_id, channel_id}`, plus `title?` and `voice?`. Returns the meeting record; 400 invalid request, 502 Quorum refused, 503 meetings off. Audited as `meeting_join` | `pkg/dashboard/api_meetings.go:125` | -| `GET` | `/api/meetings` | Owner only | `{meetings: [...]}`, newest first | `pkg/dashboard/api_meetings.go:126` | -| `GET` | `/api/meetings/{id}` | Owner only | `{meeting, transcript, live}`: the record, stored final segments and chat, and the live-loop state (notes, research, asks, budget); 404 unknown | `pkg/dashboard/api_meetings.go:127` | -| `POST` | `/api/meetings/{id}/leave` | Owner only | Make hive leave; returns the record. Audited as `meeting_leave` | `pkg/dashboard/api_meetings.go:128` | -| `POST` | `/api/meetings/{id}/voice` | Owner only | `{enabled}`: allow hive to answer aloud when addressed (with `meetings.voice_on_address`). Audited as `meeting_voice` | `pkg/dashboard/api_meetings.go:129` | -| `POST` | `/api/meetings/{id}/research/{rid}/approve` | Owner only | Dispatch a research item waiting past the per-meeting cap; 409 when it is not waiting or the live session ended. Audited as `meeting_research_approve` | `pkg/dashboard/api_meetings.go:130` | -| `POST` | `/api/meetings/{id}/approve` | Owner only | Approve a platform join request (Discord `/hive join`): joins that channel; optional `{voice}`. 409 when the meeting is not a pending request. Audited as `meeting_request_approve` | `pkg/dashboard/api_meetings.go:131` | -| `POST` | `/api/meetings/{id}/decline` | Owner only | Decline a platform join request with `meeting.leave`. Audited as `meeting_request_decline` | `pkg/dashboard/api_meetings.go:132` | -| `GET` | `/api/meetings/{id}/ws` | Owner only | WebSocket live panel: a `snapshot` frame, then `meeting`, `line`, `intent`, `research`, `notes` and `dropped` frames for the meeting | `pkg/dashboard/api_meetings.go:133` | -| `GET` | `/api/meetings/schedule` | Owner or read-write | The Calendar: `{upcoming, recent, attendee_name}`; upcoming events (scheduled, awaiting approval, live) by start and events finished in the last 14 days, newest first. Each event carries its platform, source, status, next occurrences and the meeting it created; a passcode is shown only as `set`. See [Calendar](../meetings.md#calendar) | `pkg/dashboard/api_meetings_schedule.go:83` | -| `POST` | `/api/meetings/schedule` | Owner or read-write | Schedule a meeting: `{url, start, end?, title?, rrule?, timezone?}` (RFC 3339 times, RFC 5545 `RRULE` expanded in an IANA `timezone`). The platform comes from the link (Google Meet, Teams, Zoom). The owner's add is scheduled; a read-write user's add awaits approval. 400 invalid or already ended. Audited as `meeting_schedule_add` | `pkg/dashboard/api_meetings_schedule.go:84` | -| `POST` | `/api/meetings/schedule/{eid}/approve` | Owner only | Schedule an event awaiting approval. 409 when it is not awaiting approval. Audited as `meeting_schedule_approve` | `pkg/dashboard/api_meetings_schedule.go:85` | -| `POST` | `/api/meetings/schedule/{eid}/decline` | Owner only | Decline an event awaiting approval; later updates of the same invite stay declined. Audited as `meeting_schedule_decline` | `pkg/dashboard/api_meetings_schedule.go:86` | -| `POST` | `/api/meetings/schedule/{eid}/cancel` | Owner only | Stop hive joining the event (every occurrence of a series); a meeting already live is not left. Audited as `meeting_schedule_cancel` | `pkg/dashboard/api_meetings_schedule.go:87` | -| `POST` | `/api/meetings/schedule/{eid}/skip` | Owner only | Skip the next occurrence hive has not joined: a single meeting becomes `skipped`, a series moves on. Audited as `meeting_schedule_skip` | `pkg/dashboard/api_meetings_schedule.go:88` | +| `GET` | `/api/meetings/settings` | Owner only | Meetings settings: `enabled`, `enabled_env_override`, `running`, `vexa_url`, `vexa_key_set`, `discord_token_set`, `transcribe_token_set`, `tts_token_set` (secrets are never returned) and `effective` values of the other `meetings.*` keys ([env vars](../env-vars.md#meetings-quorum)) | `pkg/dashboard/api_meetings.go:128` | +| `POST` | `/api/meetings/settings` | Owner only | Update `meetings.enabled` and `meetings.vexa.url`, and write the Vexa tenant key, Discord bot token, transcription service token and TTS service token to keystore-sealed secret files (`""` clears one): `{enabled?, vexa_url?, vexa_api_key?, discord_token?, transcribe_token?, tts_token?}`. Returns the settings with `restart_required`; 400 on an invalid value. Audited as `meetings_settings` | `pkg/dashboard/api_meetings.go:129` | +| `POST` | `/api/meetings` | Owner only | Send hive to a meeting: `{url}` for Google Meet, Teams or Zoom, or `{platform: "discord", guild_id, channel_id}`, plus `title?` and `voice?`. Returns the meeting record; 400 invalid request, 502 Quorum refused, 503 meetings off. Audited as `meeting_join` | `pkg/dashboard/api_meetings.go:130` | +| `GET` | `/api/meetings` | Owner only | `{meetings: [...]}`, newest first | `pkg/dashboard/api_meetings.go:131` | +| `GET` | `/api/meetings/{id}` | Owner only | `{meeting, transcript, live}`: the record, stored final segments and chat, and the live-loop state (notes, research, asks, budget); 404 unknown | `pkg/dashboard/api_meetings.go:132` | +| `POST` | `/api/meetings/{id}/leave` | Owner only | Make hive leave; returns the record. Audited as `meeting_leave` | `pkg/dashboard/api_meetings.go:133` | +| `POST` | `/api/meetings/{id}/voice` | Owner only | `{enabled}`: allow hive to answer aloud when addressed (with `meetings.voice_on_address`). Audited as `meeting_voice` | `pkg/dashboard/api_meetings.go:134` | +| `POST` | `/api/meetings/{id}/research/{rid}/approve` | Owner only | Dispatch a research item waiting past the per-meeting cap; 409 when it is not waiting or the live session ended. Audited as `meeting_research_approve` | `pkg/dashboard/api_meetings.go:135` | +| `POST` | `/api/meetings/{id}/approve` | Owner only | Approve a platform join request (Discord `/hive join`): joins that channel; optional `{voice}`. 409 when the meeting is not a pending request. Audited as `meeting_request_approve` | `pkg/dashboard/api_meetings.go:136` | +| `POST` | `/api/meetings/{id}/decline` | Owner only | Decline a platform join request with `meeting.leave`. Audited as `meeting_request_decline` | `pkg/dashboard/api_meetings.go:137` | +| `DELETE` | `/api/meetings/{id}` | Owner only | Delete a meeting in a final state (ended, failed, blocked, declined, left, handed off, purged) or a pending join request (declined with `meeting.leave`, then removed): the record, transcript and live state on this hive, the meeting in Vexa (Quorum `meeting.delete`, best effort: `not_found` is fine, any other error comes back as `upstream_error` while the record is still removed), and the Calendar entry that existed only for it. Knowledge facts and drafts made from it are not touched. 200 `{id, state, upstream_error?, calendar_removed?}`; 404 unknown; 409 while hive is joining, in the lobby or live (leave the meeting first). Audited as `meeting_delete` | `pkg/dashboard/api_meetings_delete.go:44` | +| `POST` | `/api/meetings/clear-finished` | Owner only | Delete every meeting in a final state that finished before `{before?}` (RFC 3339; empty or later than now means now), each as `DELETE /api/meetings/{id}`; live meetings and pending join requests stay. 200 `{deleted, count}`; 400 bad `before`. Each meeting audited as `meeting_delete` | `pkg/dashboard/api_meetings_delete.go:45` | +| `GET` | `/api/meetings/{id}/ws` | Owner only | WebSocket live panel: a `snapshot` frame, then `meeting`, `line`, `intent`, `research`, `notes` and `dropped` frames for the meeting | `pkg/dashboard/api_meetings.go:138` | +| `GET` | `/api/meetings/schedule` | Owner or read-write | The Calendar: `{upcoming, recent, attendee_name}`; upcoming events (scheduled, awaiting approval, live) by start and events finished in the last 14 days, newest first. Each event carries its platform, source, status, next occurrences and the meeting it created; a passcode is shown only as `set`. See [Calendar](../meetings.md#calendar) | `pkg/dashboard/api_meetings_schedule.go:86` | +| `POST` | `/api/meetings/schedule` | Owner or read-write | Schedule a meeting: `{url, start, end?, title?, rrule?, timezone?}` (RFC 3339 times, RFC 5545 `RRULE` expanded in an IANA `timezone`). The platform comes from the link (Google Meet, Teams, Zoom). The owner's add is scheduled; a read-write user's add awaits approval. 400 invalid or already ended. Audited as `meeting_schedule_add` | `pkg/dashboard/api_meetings_schedule.go:87` | +| `POST` | `/api/meetings/schedule/{eid}/approve` | Owner only | Schedule an event awaiting approval. 409 when it is not awaiting approval. Audited as `meeting_schedule_approve` | `pkg/dashboard/api_meetings_schedule.go:88` | +| `POST` | `/api/meetings/schedule/{eid}/decline` | Owner only | Decline an event awaiting approval; later updates of the same invite stay declined. Audited as `meeting_schedule_decline` | `pkg/dashboard/api_meetings_schedule.go:89` | +| `POST` | `/api/meetings/schedule/{eid}/cancel` | Owner only | Stop hive joining the event (every occurrence of a series); a meeting already live is not left. Audited as `meeting_schedule_cancel` | `pkg/dashboard/api_meetings_schedule.go:90` | +| `POST` | `/api/meetings/schedule/{eid}/skip` | Owner only | Skip the next occurrence hive has not joined: a single meeting becomes `skipped`, a series moves on. Audited as `meeting_schedule_skip` | `pkg/dashboard/api_meetings_schedule.go:91` | +| `DELETE` | `/api/meetings/schedule/{eid}` | Owner only | Delete a past Calendar entry (ended, cancelled, declined, failed, blocked, skipped) and the meetings it created, each as `DELETE /api/meetings/{id}`. 200 `{id, meetings}`; 404 unknown; 409 for an entry still scheduled, awaiting approval or live (skip or cancel it) or whose meeting hive is still in. Audited as `meeting_schedule_delete`, plus `meeting_delete` per meeting | `pkg/dashboard/api_meetings_delete.go:46` | | `GET` | `/api/meetings/actions` | Owner or read-write | Drafts from meetings: `{drafts, pending}`, newest first. Each draft carries `id`, `meeting_id`, `meeting_title`, `meeting_link`, `type` (`issue`, `rfc`, `spek`, `knowledge`), `title`, `body`, `repo`, `excerpt`, `requested_by` (a meeting display name), `request`, `spoken`, `status` (`pending`, `approving`, `done`, `failed`, `rejected`), `auto_approved`, `result_url`, `result_note`, `error`, `announced` (`chat` or `notes`), `edited_by`, `decided_by`, `decided_at`, `created_at`, `updated_at`. See [Asking Betty to do things](../meetings.md#asking-betty-to-do-things) | `pkg/dashboard/api_meetings_actions.go:69` | | `GET` | `/api/meetings/actions/settings` | Owner or read-write | `meetings.persona.actions` as set and in effect: `enabled`, `types`, `all_types`, `default_repo`, `effective_default_repo`, `repos` (the monitored repos a draft may target), `auto_approve` (per type), `auto_approvable` (`knowledge`) and `env_overrides` | `pkg/dashboard/api_meetings_actions.go:70` | | `PUT` | `/api/meetings/actions/settings` | Owner only | Save `{enabled?, types?, default_repo?, auto_approve?}` into `meetings.persona.actions`; applies at once. 400 for an unknown type, a repo that is not `owner/repo`, or auto-approve on anything but `knowledge`. Audited as `meetings_actions_settings` | `pkg/dashboard/api_meetings_actions.go:71` | diff --git a/src/docs/meetings.md b/src/docs/meetings.md index ae8fcbd69d..204481fe26 100644 --- a/src/docs/meetings.md +++ b/src/docs/meetings.md @@ -139,6 +139,8 @@ Only the hive owner can send hive to a meeting. Voice is fixed when the bot joins: Vexa only lets a bot speak if it was started with voice. Hive starts every bot able to speak while `meetings.voice_on_address` is true (and when you tick **Voice**), so the toggle can turn speaking on later; with `meetings.voice_on_address` false and **Voice** unticked, turning voice on later has no effect and hive keeps answering in chat (the panel says so). +**🗑 Delete** (owner only) removes a meeting for good: a meeting that ended, failed, was blocked, declined or left, or a join request still waiting (deleting it declines it). It deletes the meeting record, its transcript, notes and live state on this hive, erases the meeting in Vexa with Quorum's `meeting.delete`, and removes its Calendar entry when that entry existed only for this meeting. If Vexa cannot confirm the erase, the meeting is still removed here and the dashboard says so. A meeting hive is still joining, waiting in the lobby of or live in cannot be deleted: **Leave** it first. **Clear finished** deletes every finished meeting after one confirm; live meetings and pending join requests stay. Knowledge facts and drafts already made from a meeting are not touched. Each delete is audited as `meeting_delete`. + If the meeting platform's chat is unavailable, hive cannot post the consent notice. It retries about once a minute and posts nothing else into the meeting until the notice is out; the transcript, notes and research still show in the panel. The same operations are available over the [meetings API](api-reference/knowledge.md) (`/api/meetings`). @@ -151,6 +153,7 @@ The **Calendar** section, right after **Inbox** in the left menu, lists the meet - **Each row** shows the title, organizer, start and end, platform, the next occurrence of a repeating meeting, the source (email invite, added here, or Discord) and the status: scheduled, awaiting approval, live, ended, cancelled, declined, failed, blocked or skipped. - **Approve** or **Decline** a meeting awaiting approval (owner only). A declined invite stays declined when its organizer updates it. - **Skip** skips the next occurrence: a single meeting becomes skipped, a repeating one moves on to the one after. **Cancel** stops hive joining it at all; a meeting already live is not left (use **Leave** in Meetings). +- **🗑 Delete** a past entry (ended, cancelled, declined, failed, blocked or skipped; owner only) to remove it together with the meetings it created, as **Delete** in Meetings does. Entries still to come keep **Skip** and **Cancel**. - **Open live panel** while hive is in the meeting and **Notes** once it ended open that meeting in the Meetings section. The schedule lives in `/schedule.json` (by default `/data/meetings/schedule.json`), rewritten atomically. Each occurrence is recorded before hive joins it, so a restart never joins the same occurrence twice; a join cut off by a restart is shown as failed rather than retried. Finished meetings stay listed for 14 days and are removed after 30. diff --git a/src/pkg/dashboard/api_meetings.go b/src/pkg/dashboard/api_meetings.go index db3d049ad1..06a5a08e0d 100644 --- a/src/pkg/dashboard/api_meetings.go +++ b/src/pkg/dashboard/api_meetings.go @@ -63,6 +63,11 @@ type MeetingsService interface { // (Discord `/hive join`) waiting for the owner. ApproveRequest(ctx context.Context, id string, voice bool) (any, error) DeclineRequest(ctx context.Context, id string) (any, error) + // Delete removes a finished meeting or a pending join request for good + // (ErrMeetingConflict while hive is still in it); ClearFinished deletes + // every finished meeting that ended before the cutoff. + Delete(ctx context.Context, id string) (MeetingDeleted, error) + ClearFinished(ctx context.Context, before time.Time) ([]MeetingDeleted, error) // Live is the panel snapshot: meeting, transcript, live state. Live(id string) (any, error) Subscribe(fn func(MeetingFrame)) (cancel func()) @@ -131,6 +136,7 @@ func (s *Server) registerMeetingsRoutes() { s.mux.HandleFunc("POST /api/meetings/{id}/approve", s.handleMeetingsRequestApprove) s.mux.HandleFunc("POST /api/meetings/{id}/decline", s.handleMeetingsRequestDecline) s.mux.HandleFunc("GET /api/meetings/{id}/ws", s.handleMeetingsWS) + s.registerMeetingsDeleteRoutes() } func meetingsError(w http.ResponseWriter, err error) { diff --git a/src/pkg/dashboard/api_meetings_delete.go b/src/pkg/dashboard/api_meetings_delete.go new file mode 100644 index 0000000000..df69c6605a --- /dev/null +++ b/src/pkg/dashboard/api_meetings_delete.go @@ -0,0 +1,140 @@ +package dashboard + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +// Deleting meetings (owner only): the Meetings section's 🗑 Delete and +// "Clear finished", and 🗑 Delete on past Calendar entries. A meeting in a +// final state (ended, failed, blocked, declined, left, handed off, purged) +// or a pending platform join request may be deleted; one hive is still +// joining, waiting in the lobby of or live in answers 409 (leave it +// first). Delete removes the meeting record, its transcript and live state +// on this hive, erases it in Vexa (Quorum meeting.delete, best effort), +// and drops the Calendar entry that existed only for it. Knowledge facts +// and drafts already made from the meeting are not touched. + +// MeetingDeleted is one deleted meeting. UpstreamError is set when Vexa +// could not confirm the erase; the record on this hive is gone anyway. +type MeetingDeleted struct { + ID string `json:"id"` + State string `json:"state,omitempty"` + UpstreamError string `json:"upstream_error,omitempty"` + CalendarRemoved int `json:"calendar_removed,omitempty"` +} + +// MeetingScheduleDeleted is a deleted Calendar entry and the meetings it +// created that went with it. +type MeetingScheduleDeleted struct { + ID string `json:"id"` + Meetings []MeetingDeleted `json:"meetings"` +} + +// meetingsClearRequest is POST /api/meetings/clear-finished: meetings that +// finished before `before` (RFC 3339; empty means now) are deleted. +type meetingsClearRequest struct { + Before string `json:"before,omitempty"` +} + +func (s *Server) registerMeetingsDeleteRoutes() { + s.mux.HandleFunc("DELETE /api/meetings/{id}", s.handleMeetingsDelete) + s.mux.HandleFunc("POST /api/meetings/clear-finished", s.handleMeetingsClearFinished) + s.mux.HandleFunc("DELETE /api/meetings/schedule/{eid}", s.handleMeetingsScheduleDelete) +} + +// auditMeetingDeleted records one meeting_delete. +func (s *Server) auditMeetingDeleted(r *http.Request, d MeetingDeleted, via string) { + s.auditFromRequest(r, "meeting_delete", auditDetail("meeting", d.ID, "state", d.State, "via", via, + "upstream_error", boolString(d.UpstreamError != ""), "calendar_removed", strconv.Itoa(d.CalendarRemoved)), "") +} + +func (s *Server) handleMeetingsDelete(w http.ResponseWriter, r *http.Request) { + if !requireOwnerRole(w, r) { + return + } + svc, ok := s.meetingsService(w) + if !ok { + return + } + ctx, cancel := context.WithTimeout(r.Context(), meetingsCallTimeout) + defer cancel() + d, err := svc.Delete(ctx, r.PathValue("id")) + if err != nil { + meetingsError(w, err) + return + } + s.auditMeetingDeleted(r, d, "meetings") + jsonResponse(w, d) +} + +func (s *Server) handleMeetingsClearFinished(w http.ResponseWriter, r *http.Request) { + if !requireOwnerRole(w, r) { + return + } + svc, ok := s.meetingsService(w) + if !ok { + return + } + var req meetingsClearRequest + if r.ContentLength > 0 { + if err := decodeBody(r, &req); err != nil { + jsonError(w, "invalid request body", http.StatusBadRequest) + return + } + } + before := time.Now() + if b := strings.TrimSpace(req.Before); b != "" { + t, err := time.Parse(time.RFC3339, b) + if err != nil { + jsonError(w, "before must be an RFC 3339 time", http.StatusBadRequest) + return + } + if t.Before(before) { + before = t + } + } + ctx, cancel := context.WithTimeout(r.Context(), meetingsCallTimeout) + defer cancel() + list, err := svc.ClearFinished(ctx, before) + if list == nil { + list = []MeetingDeleted{} + } + for _, d := range list { + s.auditMeetingDeleted(r, d, "clear_finished") + } + if err != nil { + meetingsError(w, err) + return + } + jsonResponse(w, map[string]any{"deleted": list, "count": len(list)}) +} + +func (s *Server) handleMeetingsScheduleDelete(w http.ResponseWriter, r *http.Request) { + if !requireOwnerRole(w, r) { + return + } + svc, ok := s.meetingsScheduleService(w) + if !ok { + return + } + ctx, cancel := context.WithTimeout(r.Context(), meetingsCallTimeout) + defer cancel() + eid := r.PathValue("eid") + d, err := svc.Delete(ctx, eid) + if err != nil { + meetingsError(w, err) + return + } + if d.Meetings == nil { + d.Meetings = []MeetingDeleted{} + } + for _, m := range d.Meetings { + s.auditMeetingDeleted(r, m, "calendar") + } + s.auditFromRequest(r, "meeting_schedule_delete", auditDetail("event", eid, "meetings", strconv.Itoa(len(d.Meetings))), "") + jsonResponse(w, d) +} diff --git a/src/pkg/dashboard/api_meetings_delete_test.go b/src/pkg/dashboard/api_meetings_delete_test.go new file mode 100644 index 0000000000..68dfdd759d --- /dev/null +++ b/src/pkg/dashboard/api_meetings_delete_test.go @@ -0,0 +1,183 @@ +package dashboard + +import ( + "context" + "encoding/json" + "fmt" + "net/http" + "net/http/httptest" + "strings" + "testing" + "time" +) + +func (f *fakeMeetingsService) Delete(_ context.Context, id string) (MeetingDeleted, error) { + f.mu.Lock() + defer f.mu.Unlock() + f.deleted = append(f.deleted, id) + if f.err != nil { + return MeetingDeleted{}, f.err + } + d := f.deleteRes + d.ID = id + return d, nil +} + +func (f *fakeMeetingsService) ClearFinished(_ context.Context, before time.Time) ([]MeetingDeleted, error) { + f.mu.Lock() + defer f.mu.Unlock() + f.cleared = append(f.cleared, before) + if f.err != nil { + return nil, f.err + } + return []MeetingDeleted{{ID: "mtg-a", State: "ended"}, {ID: "mtg-b", State: "blocked"}}, nil +} + +func (f *fakeScheduleService) Delete(_ context.Context, eid string) (MeetingScheduleDeleted, error) { + f.deleted = append(f.deleted, eid) + if f.err != nil { + return MeetingScheduleDeleted{}, f.err + } + d := f.deleteRes + d.ID = eid + return d, nil +} + +func meetingsDeleteAs(s *Server, method, path, body, role string, verified bool) *httptest.ResponseRecorder { + rec := httptest.NewRecorder() + req := httptest.NewRequest(method, path, strings.NewReader(body)) + if body != "" { + req.Header.Set("Content-Type", "application/json") + } + req.Header.Set("X-Hive-User", "octo") + if role != "" { + req.Header.Set("X-Hive-Role", role) + } + if verified { + req.Header.Set(ownerRoleVerifiedHeader, "true") + } + s.mux.ServeHTTP(rec, req) + return rec +} + +var meetingsDeleteRoutes = []struct{ method, path string }{ + {http.MethodDelete, "/api/meetings/mtg-1"}, + {http.MethodPost, "/api/meetings/clear-finished"}, + {http.MethodDelete, "/api/meetings/schedule/e1"}, +} + +func TestMeetingsDeleteRoleMatrix(t *testing.T) { + s, _ := apiServer(t) + for _, c := range meetingsDeleteRoutes { + if rec := meetingsDeleteAs(s, c.method, c.path, "", "owner", true); rec.Code != http.StatusServiceUnavailable { + t.Errorf("%s %s without service = %d, want 503", c.method, c.path, rec.Code) + } + } + f := &fakeMeetingsService{} + sf := &fakeScheduleService{} + s.SetMeetingsService(f) + s.SetMeetingsScheduleService(sf) + for _, c := range meetingsDeleteRoutes { + for _, who := range []struct { + role string + verified bool + }{{"read-write", true}, {"read", true}, {"", false}, {"owner", false}} { + if rec := meetingsDeleteAs(s, c.method, c.path, "", who.role, who.verified); rec.Code != http.StatusForbidden { + t.Errorf("%s %s as %q (verified=%v) = %d, want 403", c.method, c.path, who.role, who.verified, rec.Code) + } + } + } + if len(f.deleted) != 0 || len(f.cleared) != 0 || len(sf.deleted) != 0 { + t.Fatalf("a refused request reached the service: %v %v %v", f.deleted, f.cleared, sf.deleted) + } + for _, c := range meetingsDeleteRoutes { + if rec := meetingsDeleteAs(s, c.method, c.path, "", "owner", true); rec.Code != http.StatusOK { + t.Errorf("owner %s %s = %d %s", c.method, c.path, rec.Code, rec.Body.String()) + } + } + if len(f.deleted) != 1 || f.deleted[0] != "mtg-1" || len(f.cleared) != 1 || len(sf.deleted) != 1 || sf.deleted[0] != "e1" { + t.Fatalf("owner calls: %v %v %v", f.deleted, f.cleared, sf.deleted) + } +} + +func TestMeetingsDeleteStatesAndAudit(t *testing.T) { + s, _ := apiServer(t) + f := &fakeMeetingsService{deleteRes: MeetingDeleted{State: "failed", UpstreamError: "quorum meeting.delete: upstream_error: vexa 500", CalendarRemoved: 1}} + s.SetMeetingsService(f) + rec := meetingsDeleteAs(s, http.MethodDelete, "/api/meetings/mtg-1", "", "owner", true) + if rec.Code != http.StatusOK { + t.Fatalf("delete = %d %s", rec.Code, rec.Body.String()) + } + var got MeetingDeleted + if err := json.Unmarshal(rec.Body.Bytes(), &got); err != nil || got.ID != "mtg-1" || got.UpstreamError == "" || got.CalendarRemoved != 1 { + t.Fatalf("delete body = %s (%v)", rec.Body.String(), err) + } + e := s.audit.Recent(1) + if len(e) != 1 || e[0].Action != "meeting_delete" || !strings.Contains(e[0].Detail, "meeting=mtg-1") || + !strings.Contains(e[0].Detail, "upstream_error=true") || !strings.Contains(e[0].Detail, "calendar_removed=1") { + t.Fatalf("delete not audited: %+v", e) + } + // A meeting hive is still in answers 409; unknown 404. Neither is audited. + for err, want := range map[error]int{ + fmt.Errorf("%w: leave the meeting first", ErrMeetingConflict): http.StatusConflict, + fmt.Errorf("%w: mtg-x", ErrMeetingNotFound): http.StatusNotFound, + } { + f.err = err + before := len(s.audit.Recent(100)) + if rec := meetingsDeleteAs(s, http.MethodDelete, "/api/meetings/mtg-1", "", "owner", true); rec.Code != want { + t.Errorf("delete with %v = %d, want %d", err, rec.Code, want) + } + if len(s.audit.Recent(100)) != before { + t.Errorf("a refused delete (%v) was audited", err) + } + } + f.err = nil +} + +func TestMeetingsClearFinished(t *testing.T) { + s, _ := apiServer(t) + f := &fakeMeetingsService{} + s.SetMeetingsService(f) + cut := time.Now().Add(-time.Hour).UTC().Truncate(time.Second) + rec := meetingsDeleteAs(s, http.MethodPost, "/api/meetings/clear-finished", `{"before":"`+cut.Format(time.RFC3339)+`"}`, "owner", true) + if rec.Code != http.StatusOK || !strings.Contains(rec.Body.String(), `"count":2`) { + t.Fatalf("clear = %d %s", rec.Code, rec.Body.String()) + } + if !f.cleared[0].Equal(cut) { + t.Fatalf("cutoff = %v, want %v", f.cleared[0], cut) + } + if e := s.audit.Recent(2); len(e) != 2 || e[0].Action != "meeting_delete" || e[1].Action != "meeting_delete" { + t.Fatalf("each cleared meeting is audited: %+v", e) + } + // A cutoff in the future is clamped to now: only meetings older than now go. + future := time.Now().Add(24 * time.Hour).UTC().Format(time.RFC3339) + if rec := meetingsDeleteAs(s, http.MethodPost, "/api/meetings/clear-finished", `{"before":"`+future+`"}`, "owner", true); rec.Code != http.StatusOK { + t.Fatalf("future clear = %d", rec.Code) + } + if f.cleared[1].After(time.Now()) { + t.Fatalf("future cutoff not clamped: %v", f.cleared[1]) + } + if rec := meetingsDeleteAs(s, http.MethodPost, "/api/meetings/clear-finished", `{"before":"yesterday"}`, "owner", true); rec.Code != http.StatusBadRequest { + t.Fatalf("bad cutoff = %d", rec.Code) + } +} + +func TestMeetingsScheduleDelete(t *testing.T) { + s, _ := apiServer(t) + sf := &fakeScheduleService{deleteRes: MeetingScheduleDeleted{Meetings: []MeetingDeleted{{ID: "mtg-1", State: "ended"}}}} + s.SetMeetingsScheduleService(sf) + rec := meetingsDeleteAs(s, http.MethodDelete, "/api/meetings/schedule/e1", "", "owner", true) + if rec.Code != http.StatusOK || !strings.Contains(rec.Body.String(), `"mtg-1"`) { + t.Fatalf("calendar delete = %d %s", rec.Code, rec.Body.String()) + } + e := s.audit.Recent(2) + // Newest first: the entry, after the meeting it created. + if len(e) != 2 || e[0].Action != "meeting_schedule_delete" || !strings.Contains(e[0].Detail, "event=e1") || + e[1].Action != "meeting_delete" || !strings.Contains(e[1].Detail, "via=calendar") { + t.Fatalf("calendar delete audit: %+v", e) + } + sf.err = fmt.Errorf("%w: e1 is scheduled; skip or cancel it instead", ErrMeetingConflict) + if rec := meetingsDeleteAs(s, http.MethodDelete, "/api/meetings/schedule/e1", "", "owner", true); rec.Code != http.StatusConflict { + t.Fatalf("future entry delete = %d, want 409", rec.Code) + } +} diff --git a/src/pkg/dashboard/api_meetings_schedule.go b/src/pkg/dashboard/api_meetings_schedule.go index 6912758ac0..54b752d859 100644 --- a/src/pkg/dashboard/api_meetings_schedule.go +++ b/src/pkg/dashboard/api_meetings_schedule.go @@ -61,6 +61,9 @@ type MeetingsScheduleService interface { Add(ctx context.Context, req MeetingScheduleAdd) (any, error) // Act runs approve, decline, cancel or skip on one event. Act(ctx context.Context, eid, action, by string) (any, error) + // Delete removes a finished event and the finished meetings it + // created (ErrMeetingConflict for an event still to come or live). + Delete(ctx context.Context, eid string) (MeetingScheduleDeleted, error) } type meetingsScheduleHolder struct{ svc MeetingsScheduleService } diff --git a/src/pkg/dashboard/api_meetings_schedule_test.go b/src/pkg/dashboard/api_meetings_schedule_test.go index a6b194132e..aded40f60e 100644 --- a/src/pkg/dashboard/api_meetings_schedule_test.go +++ b/src/pkg/dashboard/api_meetings_schedule_test.go @@ -15,6 +15,9 @@ type fakeScheduleService struct { added []MeetingScheduleAdd acted []string listed int + // deleted are the Delete calls; deleteRes is returned for them. + deleted []string + deleteRes MeetingScheduleDeleted } func (f *fakeScheduleService) List() (any, error) { diff --git a/src/pkg/dashboard/api_meetings_test.go b/src/pkg/dashboard/api_meetings_test.go index 9fdd94024c..c03184c71e 100644 --- a/src/pkg/dashboard/api_meetings_test.go +++ b/src/pkg/dashboard/api_meetings_test.go @@ -27,6 +27,9 @@ type fakeMeetingsService struct { invitedBy string subs map[int]func(MeetingFrame) next int + deleted []string + cleared []time.Time + deleteRes MeetingDeleted } func (f *fakeMeetingsService) Join(_ context.Context, req MeetingJoinRequest, by string) (any, error) { diff --git a/src/pkg/dashboard/meetings_delete.test.js b/src/pkg/dashboard/meetings_delete.test.js new file mode 100644 index 0000000000..f5b7fcfbe7 --- /dev/null +++ b/src/pkg/dashboard/meetings_delete.test.js @@ -0,0 +1,108 @@ +// Meetings 🗑 Delete, "Clear finished" and Calendar 🗑 Delete: who sees +// the action, which rows offer it, and the in-page confirm. +// Run: node --test src/pkg/dashboard/*.test.js +const test = require('node:test'); +const assert = require('node:assert'); +const fs = require('node:fs'); +const path = require('node:path'); + +const html = fs.readFileSync(path.join(__dirname, 'static', 'index.html'), 'utf8'); +const ASYNC_PREFIX = 'async '; +const fnSrc = name => { + let start = html.indexOf('function ' + name + '('); + assert.ok(start >= 0, name + ' not found'); + if (html.slice(start - ASYNC_PREFIX.length, start) === ASYNC_PREFIX) start -= ASYNC_PREFIX.length; + let depth = 0; + for (let i = html.indexOf('{', start); i < html.length; i++) { + if (html[i] === '{') depth++; + else if (html[i] === '}' && --depth === 0) return html.slice(start, i + 1); + } + throw new Error('unbalanced ' + name); +}; +const constSrc = name => { + const m = html.match(new RegExp('const ' + name + ' = \\{[^}]*\\};')); + assert.ok(m, name + ' not found'); + return m[0]; +}; +const escapeHtml = s => String(s).replace(/[&<>"']/g, c => ({ '&': '&', '<': '<', '>': '>', '"': '"', "'": ''' }[c])); + +const lib = new Function('escapeHtml', 'window', + constSrc('MEETINGS_FINAL_STATES') + '\n' + constSrc('CALENDAR_FINISHED_STATUSES') + '\n' + + ['meetingsCanDelete', 'meetingsDeleteButtonHtml', 'meetingsDeleteText', 'meetingsFinished', 'meetingsClearFinishedText', 'calendarCanDelete', 'calendarDeleteText'] + .map(fnSrc).join('\n') + + '\nreturn { meetingsCanDelete, meetingsDeleteButtonHtml, meetingsDeleteText, meetingsFinished, meetingsClearFinishedText, calendarCanDelete, calendarDeleteText };'); +const win = { _hiveRole: 'owner' }; +const m = lib(escapeHtml, win); + +test('finished meetings and pending join requests offer delete; running ones do not', () => { + for (const state of ['ended', 'failed', 'blocked', 'handed_off', 'purged']) { + assert.strictEqual(m.meetingsCanDelete({ id: 'x', state }, 'owner'), true, state); + } + assert.strictEqual(m.meetingsCanDelete({ id: 'x', state: 'requested', requested_by: { name: 'andy' } }, 'owner'), true, 'stale join request'); + for (const state of ['requested', 'joining', 'lobby', 'live']) { + assert.strictEqual(m.meetingsCanDelete({ id: 'x', state }, 'owner'), false, state); + } + for (const role of ['read-write', 'read', undefined]) { + assert.strictEqual(m.meetingsCanDelete({ id: 'x', state: 'ended' }, role), false, String(role)); + } +}); + +test('the row action is a 🗑 Delete button wired to meetingsDelete', () => { + win._hiveRole = 'owner'; + const btn = m.meetingsDeleteButtonHtml({ id: 'mtg-1', state: 'blocked' }); + assert.match(btn, /data-action="meetingsDelete"/); + assert.match(btn, /data-arg0="mtg-1"/); + assert.match(btn, /🗑 Delete/); + assert.match(btn, /class="hv-btn btn-secondary btn-sm"/); + assert.strictEqual(m.meetingsDeleteButtonHtml({ id: 'mtg-2', state: 'live' }), ''); + win._hiveRole = 'read-write'; + assert.strictEqual(m.meetingsDeleteButtonHtml({ id: 'mtg-1', state: 'ended' }), ''); + win._hiveRole = 'owner'; +}); + +test('the rows render the delete action', () => { + const row = fnSrc('meetingsRowHtml'); + assert.strictEqual((row.match(/meetingsDeleteButtonHtml\(m\)/g) || []).length, 2, 'join-request rows and meeting rows'); +}); + +test('the confirm says knowledge facts and drafts are not touched', () => { + assert.match(m.meetingsDeleteText({ state: 'ended' }), /Knowledge facts and drafts already made from it are not touched/); + assert.match(m.meetingsDeleteText({ state: 'requested' }), /declines the join request/); + assert.match(m.meetingsClearFinishedText(3), /^This deletes 3 finished meetings/); + assert.match(m.meetingsClearFinishedText(1), /not touched/); + assert.match(m.calendarDeleteText({ status: 'ended', history: [{ meeting_id: 'mtg-1' }] }), /and the meeting it created/); +}); + +test('Clear finished takes final-state meetings older than now only', () => { + const now = new Date('2026-11-16T12:00:00Z'); + const list = [ + { id: 'a', state: 'ended', ended_at: '2026-11-16T10:00:00Z' }, + { id: 'b', state: 'failed', updated_at: '2026-11-15T10:00:00Z' }, + { id: 'c', state: 'ended', ended_at: '2026-11-16T13:00:00Z' }, + { id: 'd', state: 'live', created_at: '2026-11-16T09:00:00Z' }, + { id: 'e', state: 'requested', requested_by: { name: 'andy' }, created_at: '2026-11-10T09:00:00Z' }, + ]; + assert.deepStrictEqual(m.meetingsFinished(list, now).map(x => x.id), ['a', 'b']); + assert.deepStrictEqual(m.meetingsFinished(null, now), []); +}); + +test('Calendar: past entries delete, scheduled ones keep Skip/Cancel', () => { + for (const status of ['ended', 'cancelled', 'declined', 'failed', 'blocked', 'skipped']) { + assert.strictEqual(m.calendarCanDelete({ status }, 'owner'), true, status); + } + for (const status of ['scheduled', 'awaiting_approval', 'live']) { + assert.strictEqual(m.calendarCanDelete({ status }, 'owner'), false, status); + } + assert.strictEqual(m.calendarCanDelete({ status: 'ended' }, 'read-write'), false); +}); + +test('deletes use the in-page confirm and the DELETE endpoints', () => { + for (const name of ['meetingsDelete', 'meetingsClearFinished', 'calendarDelete']) { + const src = fnSrc(name); + assert.match(src, /hiveConfirm\(/, name); + assert.doesNotMatch(src, /window\.confirm|\balert\(|[^.]confirm\(/, name); + } + assert.match(fnSrc('meetingsDelete'), /'\/api\/meetings\/' \+ encodeURIComponent\(id\), \{ method: 'DELETE' \}/); + assert.match(fnSrc('meetingsClearFinished'), /'\/api\/meetings\/clear-finished'/); + assert.match(fnSrc('calendarDelete'), /'\/api\/meetings\/schedule\/' \+ encodeURIComponent\(id\), \{ method: 'DELETE' \}/); +}); diff --git a/src/pkg/dashboard/static-src/js/calendar.js b/src/pkg/dashboard/static-src/js/calendar.js index 1ebcc9889d..f9218c81b2 100644 --- a/src/pkg/dashboard/static-src/js/calendar.js +++ b/src/pkg/dashboard/static-src/js/calendar.js @@ -181,9 +181,45 @@ if (e.status === 'awaiting_approval') out += btn('approve', 'Approve', 'btn-primary') + btn('decline', 'Decline', 'btn-secondary'); if (e.status === 'scheduled' || e.status === 'awaiting_approval' || (e.status === 'live' && e.rrule)) out += btn('skip', e.rrule ? 'Skip next' : 'Skip', 'btn-secondary'); if (e.status === 'scheduled' || e.status === 'awaiting_approval' || e.status === 'live') out += btn('cancel', 'Cancel', 'btn-danger'); + if (calendarCanDelete(e, window._hiveRole)) { + out += ''; + } return out; } + // Finished Calendar statuses: past entries get 🗑 Delete; scheduled, + // awaiting-approval and live ones keep Skip and Cancel. + const CALENDAR_FINISHED_STATUSES = { ended: 1, cancelled: 1, declined: 1, failed: 1, blocked: 1, skipped: 1 }; + function calendarCanDelete(e, role) { + return !!e && role === 'owner' && !!CALENDAR_FINISHED_STATUSES[e.status]; + } + + function calendarDeleteText(e) { + const n = ((e && e.history) || []).filter(h => h && h.meeting_id).length || (e && e.meeting_id ? 1 : 0); + return 'This deletes this Calendar entry' + (n ? ' and the meeting' + (n === 1 ? '' : 's') + ' it created: record, transcript, notes and live state on this hive, and the data in Vexa' : '') + '. ' + + 'Knowledge facts and drafts already made from it are not touched. It cannot be undone.'; + } + + async function calendarDelete(id) { + const e = ((_calendarData && _calendarData.recent) || []).concat((_calendarData && _calendarData.upcoming) || []).find(x => x && x.id === id); + if (!e) return; + const ok = await hiveConfirm({ title: 'Delete this Calendar entry?', message: calendarDeleteText(e), confirmLabel: 'Delete', danger: true }); + if (!ok) return; + try { + const r = await fetch('/api/meetings/schedule/' + encodeURIComponent(id), { method: 'DELETE' }); + const data = await r.json().catch(() => ({})); + if (!r.ok) throw new Error(data.error || ('HTTP ' + r.status)); + const upstream = (data.meetings || []).filter(m => m && m.upstream_error).length; + showToast(upstream ? 'Entry deleted; Vexa did not confirm the meeting data was erased' : 'Calendar entry deleted', upstream ? 'warning' : 'success'); + if (typeof fetchMeetings === 'function') fetchMeetings(); + calendarRefreshMeetings(); + } catch (err) { + showToast('Could not delete the entry: ' + err.message, 'error'); + } + fetchCalendar(); + } + function calendarMeetingLink(e) { const last = (e.history || []).length ? e.history[e.history.length - 1] : null; const mid = e.meeting_id || (last && last.meeting_id) || ''; diff --git a/src/pkg/dashboard/static-src/js/meetings.js b/src/pkg/dashboard/static-src/js/meetings.js index 24ec960ac6..f1b0f754b5 100644 --- a/src/pkg/dashboard/static-src/js/meetings.js +++ b/src/pkg/dashboard/static-src/js/meetings.js @@ -20,6 +20,10 @@ // Meeting state to the kc-pill status palette (green, blue, red, muted). const MEETINGS_PILL_STATUS = { live: 'ok', requested: 'syncing', joining: 'syncing', lobby: 'syncing', failed: 'error', blocked: 'error' }; + // Final meeting states: the row offers 🗑 Delete and "Clear finished" + // takes it. Joining, lobby and live meetings are left first. + const MEETINGS_FINAL_STATES = { ended: 1, failed: 1, blocked: 1, handed_off: 1, purged: 1 }; + function meetingsIsOwner() { return window._hiveRole === 'owner'; } // The role is known once /api/role settled (answered, or its retries gave // up). Until then the panel shows a neutral loading state, never the @@ -117,7 +121,8 @@ 'join request' + '
' + '' + - '
'; + '' + + meetingsDeleteButtonHtml(m) + ''; } const state = m.state || ''; const when = meetingsFormatTime(m.live_at || m.created_at); @@ -134,7 +139,88 @@ '' + (active ? '' + '' : '') + - ''; + meetingsDeleteButtonHtml(m) + ''; + } + + // meetingsCanDelete: a meeting in a final state, or a platform join + // request still waiting (deleting it declines it). Owner only. + function meetingsCanDelete(m, role) { + if (!m || role !== 'owner') return false; + if (MEETINGS_FINAL_STATES[m.state]) return true; + return m.state === 'requested' && !!m.requested_by; + } + + function meetingsDeleteButtonHtml(m) { + if (!meetingsCanDelete(m, window._hiveRole)) return ''; + return ''; + } + + // meetingsDeleteText is the in-page confirm text for one meeting. + function meetingsDeleteText(m) { + if (m && m.state === 'requested') { + return 'This declines the join request and removes it. It cannot be undone.'; + } + return 'This deletes the meeting record, its transcript, notes and live state on this hive, its data in Vexa, and its Calendar entry if it has no other occurrences. ' + + 'Knowledge facts and drafts already made from it are not touched. It cannot be undone.'; + } + + // meetingsFinished lists the meetings "Clear finished" deletes: final + // states that finished before now. + function meetingsFinished(list, now) { + const cut = now instanceof Date ? now.getTime() : Date.now(); + return (list || []).filter(m => { + if (!m || !MEETINGS_FINAL_STATES[m.state]) return false; + const t = new Date(m.ended_at || m.updated_at || m.created_at || 0).getTime(); + return !isNaN(t) && t < cut; + }); + } + + function meetingsClearFinishedText(n) { + return 'This deletes ' + n + ' finished meeting' + (n === 1 ? '' : 's') + ' (ended, failed, blocked or declined): their records, transcripts, notes and live state on this hive, their data in Vexa, and Calendar entries that existed only for them. ' + + 'Live meetings and pending join requests stay. Knowledge facts and drafts already made from them are not touched. It cannot be undone.'; + } + + function meetingsAfterDelete(ids) { + if (_meetingsOpen && ids.indexOf(_meetingsOpen.id) >= 0) meetingsClosePanel(); + if (typeof calendarRefreshMeetings === 'function') calendarRefreshMeetings(); + if (typeof fetchCalendar === 'function') fetchCalendar(); + } + + async function meetingsDelete(id) { + const m = (_meetingsList || []).find(x => x && x.id === id); + if (!m) return; + const ok = await hiveConfirm({ title: m.state === 'requested' ? 'Delete this join request?' : 'Delete this meeting?', message: meetingsDeleteText(m), confirmLabel: 'Delete', danger: true }); + if (!ok) return; + try { + const r = await fetch('/api/meetings/' + encodeURIComponent(id), { method: 'DELETE' }); + const data = await r.json().catch(() => ({})); + if (!r.ok) throw new Error(data.error || ('HTTP ' + r.status)); + if (data.upstream_error) showToast('Meeting deleted here; Vexa did not confirm its copy was erased: ' + data.upstream_error, 'warning'); + else showToast('Meeting deleted', 'success'); + meetingsAfterDelete([id]); + } catch (e) { + showToast('Could not delete the meeting: ' + e.message, 'error'); + } + await fetchMeetings(); + } + + async function meetingsClearFinished() { + const now = new Date(); + const finished = meetingsFinished(_meetingsList, now); + if (!finished.length) return; + const ok = await hiveConfirm({ title: 'Clear finished meetings?', message: meetingsClearFinishedText(finished.length), confirmLabel: 'Delete ' + finished.length, danger: true }); + if (!ok) return; + try { + const data = await meetingsPost('/api/meetings/clear-finished', { before: now.toISOString() }); + const deleted = data.deleted || []; + const upstream = deleted.filter(d => d && d.upstream_error).length; + showToast('Deleted ' + deleted.length + ' meeting' + (deleted.length === 1 ? '' : 's') + (upstream ? '; Vexa did not confirm ' + upstream + ' erase' + (upstream === 1 ? '' : 's') : ''), upstream ? 'warning' : 'success'); + meetingsAfterDelete(deleted.map(d => d.id)); + } catch (e) { + showToast('Could not clear finished meetings: ' + e.message, 'error'); + } + await fetchMeetings(); } function renderMeetings() { @@ -147,6 +233,11 @@ html += meetingsJoinFormHtml(); } const list = _meetingsList || []; + const finished = meetingsFinished(list); + if (finished.length && meetingsIsOwner()) { + html += '
'; + } html += '
' + (list.length ? list.map(meetingsRowHtml).join('') : (_meetingsError ? '' : '

No meetings yet.

')) + '
'; html += '
'; host.innerHTML = html; diff --git a/src/pkg/dashboard/static/index.html b/src/pkg/dashboard/static/index.html index 55114731ed..06576a563b 100644 --- a/src/pkg/dashboard/static/index.html +++ b/src/pkg/dashboard/static/index.html @@ -50129,6 +50129,10 @@ // Meeting state to the kc-pill status palette (green, blue, red, muted). const MEETINGS_PILL_STATUS = { live: 'ok', requested: 'syncing', joining: 'syncing', lobby: 'syncing', failed: 'error', blocked: 'error' }; + // Final meeting states: the row offers 🗑 Delete and "Clear finished" + // takes it. Joining, lobby and live meetings are left first. + const MEETINGS_FINAL_STATES = { ended: 1, failed: 1, blocked: 1, handed_off: 1, purged: 1 }; + function meetingsIsOwner() { return window._hiveRole === 'owner'; } // The role is known once /api/role settled (answered, or its retries gave // up). Until then the panel shows a neutral loading state, never the @@ -50226,7 +50230,8 @@ 'join request' + '
' + '' + - '
'; + '' + + meetingsDeleteButtonHtml(m) + ''; } const state = m.state || ''; const when = meetingsFormatTime(m.live_at || m.created_at); @@ -50243,7 +50248,88 @@ '' + (active ? '' + '' : '') + - ''; + meetingsDeleteButtonHtml(m) + ''; + } + + // meetingsCanDelete: a meeting in a final state, or a platform join + // request still waiting (deleting it declines it). Owner only. + function meetingsCanDelete(m, role) { + if (!m || role !== 'owner') return false; + if (MEETINGS_FINAL_STATES[m.state]) return true; + return m.state === 'requested' && !!m.requested_by; + } + + function meetingsDeleteButtonHtml(m) { + if (!meetingsCanDelete(m, window._hiveRole)) return ''; + return ''; + } + + // meetingsDeleteText is the in-page confirm text for one meeting. + function meetingsDeleteText(m) { + if (m && m.state === 'requested') { + return 'This declines the join request and removes it. It cannot be undone.'; + } + return 'This deletes the meeting record, its transcript, notes and live state on this hive, its data in Vexa, and its Calendar entry if it has no other occurrences. ' + + 'Knowledge facts and drafts already made from it are not touched. It cannot be undone.'; + } + + // meetingsFinished lists the meetings "Clear finished" deletes: final + // states that finished before now. + function meetingsFinished(list, now) { + const cut = now instanceof Date ? now.getTime() : Date.now(); + return (list || []).filter(m => { + if (!m || !MEETINGS_FINAL_STATES[m.state]) return false; + const t = new Date(m.ended_at || m.updated_at || m.created_at || 0).getTime(); + return !isNaN(t) && t < cut; + }); + } + + function meetingsClearFinishedText(n) { + return 'This deletes ' + n + ' finished meeting' + (n === 1 ? '' : 's') + ' (ended, failed, blocked or declined): their records, transcripts, notes and live state on this hive, their data in Vexa, and Calendar entries that existed only for them. ' + + 'Live meetings and pending join requests stay. Knowledge facts and drafts already made from them are not touched. It cannot be undone.'; + } + + function meetingsAfterDelete(ids) { + if (_meetingsOpen && ids.indexOf(_meetingsOpen.id) >= 0) meetingsClosePanel(); + if (typeof calendarRefreshMeetings === 'function') calendarRefreshMeetings(); + if (typeof fetchCalendar === 'function') fetchCalendar(); + } + + async function meetingsDelete(id) { + const m = (_meetingsList || []).find(x => x && x.id === id); + if (!m) return; + const ok = await hiveConfirm({ title: m.state === 'requested' ? 'Delete this join request?' : 'Delete this meeting?', message: meetingsDeleteText(m), confirmLabel: 'Delete', danger: true }); + if (!ok) return; + try { + const r = await fetch('/api/meetings/' + encodeURIComponent(id), { method: 'DELETE' }); + const data = await r.json().catch(() => ({})); + if (!r.ok) throw new Error(data.error || ('HTTP ' + r.status)); + if (data.upstream_error) showToast('Meeting deleted here; Vexa did not confirm its copy was erased: ' + data.upstream_error, 'warning'); + else showToast('Meeting deleted', 'success'); + meetingsAfterDelete([id]); + } catch (e) { + showToast('Could not delete the meeting: ' + e.message, 'error'); + } + await fetchMeetings(); + } + + async function meetingsClearFinished() { + const now = new Date(); + const finished = meetingsFinished(_meetingsList, now); + if (!finished.length) return; + const ok = await hiveConfirm({ title: 'Clear finished meetings?', message: meetingsClearFinishedText(finished.length), confirmLabel: 'Delete ' + finished.length, danger: true }); + if (!ok) return; + try { + const data = await meetingsPost('/api/meetings/clear-finished', { before: now.toISOString() }); + const deleted = data.deleted || []; + const upstream = deleted.filter(d => d && d.upstream_error).length; + showToast('Deleted ' + deleted.length + ' meeting' + (deleted.length === 1 ? '' : 's') + (upstream ? '; Vexa did not confirm ' + upstream + ' erase' + (upstream === 1 ? '' : 's') : ''), upstream ? 'warning' : 'success'); + meetingsAfterDelete(deleted.map(d => d.id)); + } catch (e) { + showToast('Could not clear finished meetings: ' + e.message, 'error'); + } + await fetchMeetings(); } function renderMeetings() { @@ -50256,6 +50342,11 @@ html += meetingsJoinFormHtml(); } const list = _meetingsList || []; + const finished = meetingsFinished(list); + if (finished.length && meetingsIsOwner()) { + html += '
'; + } html += '
' + (list.length ? list.map(meetingsRowHtml).join('') : (_meetingsError ? '' : '

No meetings yet.

')) + '
'; html += '
'; host.innerHTML = html; @@ -50661,9 +50752,45 @@ if (e.status === 'awaiting_approval') out += btn('approve', 'Approve', 'btn-primary') + btn('decline', 'Decline', 'btn-secondary'); if (e.status === 'scheduled' || e.status === 'awaiting_approval' || (e.status === 'live' && e.rrule)) out += btn('skip', e.rrule ? 'Skip next' : 'Skip', 'btn-secondary'); if (e.status === 'scheduled' || e.status === 'awaiting_approval' || e.status === 'live') out += btn('cancel', 'Cancel', 'btn-danger'); + if (calendarCanDelete(e, window._hiveRole)) { + out += ''; + } return out; } + // Finished Calendar statuses: past entries get 🗑 Delete; scheduled, + // awaiting-approval and live ones keep Skip and Cancel. + const CALENDAR_FINISHED_STATUSES = { ended: 1, cancelled: 1, declined: 1, failed: 1, blocked: 1, skipped: 1 }; + function calendarCanDelete(e, role) { + return !!e && role === 'owner' && !!CALENDAR_FINISHED_STATUSES[e.status]; + } + + function calendarDeleteText(e) { + const n = ((e && e.history) || []).filter(h => h && h.meeting_id).length || (e && e.meeting_id ? 1 : 0); + return 'This deletes this Calendar entry' + (n ? ' and the meeting' + (n === 1 ? '' : 's') + ' it created: record, transcript, notes and live state on this hive, and the data in Vexa' : '') + '. ' + + 'Knowledge facts and drafts already made from it are not touched. It cannot be undone.'; + } + + async function calendarDelete(id) { + const e = ((_calendarData && _calendarData.recent) || []).concat((_calendarData && _calendarData.upcoming) || []).find(x => x && x.id === id); + if (!e) return; + const ok = await hiveConfirm({ title: 'Delete this Calendar entry?', message: calendarDeleteText(e), confirmLabel: 'Delete', danger: true }); + if (!ok) return; + try { + const r = await fetch('/api/meetings/schedule/' + encodeURIComponent(id), { method: 'DELETE' }); + const data = await r.json().catch(() => ({})); + if (!r.ok) throw new Error(data.error || ('HTTP ' + r.status)); + const upstream = (data.meetings || []).filter(m => m && m.upstream_error).length; + showToast(upstream ? 'Entry deleted; Vexa did not confirm the meeting data was erased' : 'Calendar entry deleted', upstream ? 'warning' : 'success'); + if (typeof fetchMeetings === 'function') fetchMeetings(); + calendarRefreshMeetings(); + } catch (err) { + showToast('Could not delete the entry: ' + err.message, 'error'); + } + fetchCalendar(); + } + function calendarMeetingLink(e) { const last = (e.history || []).length ? e.history[e.history.length - 1] : null; const mid = e.meeting_id || (last && last.meeting_id) || ''; diff --git a/src/pkg/meetings/delete.go b/src/pkg/meetings/delete.go new file mode 100644 index 0000000000..c8e7ae0359 --- /dev/null +++ b/src/pkg/meetings/delete.go @@ -0,0 +1,119 @@ +package meetings + +import ( + "context" + "errors" + "time" +) + +// Deleting meetings (the dashboard's 🗑 Delete and "Clear finished"): the +// owner removes a finished meeting or a stale platform join request for +// good. Hive drops the record, its transcript and its side documents (the +// live loop's state and notes), and erases the meeting upstream with +// meeting.delete so Vexa forgets it too. Knowledge facts and drafts already +// made from the meeting live elsewhere and are not touched. + +// ErrStillRunning is returned when deleting a meeting hive is still in +// (joining, lobby or live): leave it first. +var ErrStillRunning = errors.New("meetings: the meeting is still running; leave the meeting first") + +// DeleteResult is a deleted meeting. UpstreamError is set when the Quorum +// call failed with anything but not_found: the record is removed anyway, +// and the error says what Vexa may still hold. +type DeleteResult struct { + Meeting Meeting `json:"meeting"` + UpstreamError string `json:"upstream_error,omitempty"` +} + +// Deletable reports whether the owner may delete mt: a meeting in a final +// state, or a platform join request still waiting (deleting it declines +// it). +func Deletable(mt Meeting) bool { + return mt.State.Terminal() || isPendingRequest(mt) +} + +// Finished reports whether mt is in a final state ("Clear finished"): +// pending join requests are not finished. +func Finished(mt Meeting) bool { return mt.State.Terminal() } + +func isPendingRequest(mt Meeting) bool { + return mt.State == StateRequested && mt.RequestedBy != nil +} + +// upstreamErased reports whether the meeting was already erased upstream: +// a hand-off deletes it, and the retention sweeper purges only after it +// did. +func upstreamErased(st State) bool { return st == StateHandedOff || st == StatePurged } + +// Delete removes one meeting for good. A pending join request is declined +// first (meeting.leave). Quorum errors are best effort: not_found means +// Vexa already purged it; any other error is reported in the result while +// the record is still removed. +func (m *Manager) Delete(ctx context.Context, id string) (DeleteResult, error) { + mt, err := m.opts.Store.Get(id) + if err != nil { + return DeleteResult{}, err + } + if !Deletable(mt) { + return DeleteResult{Meeting: mt}, ErrStillRunning + } + res := DeleteResult{Meeting: mt} + upstream := func(err error) { + if err != nil && !IsCode(err, CodeNotFound) && res.UpstreamError == "" { + res.UpstreamError = err.Error() + } + } + if mt.NativeID != "" { + if isPendingRequest(mt) { + _, lerr := m.opts.Quorum.Leave(ctx, mt.NativeID) + upstream(lerr) + } + if !upstreamErased(mt.State) { + upstream(m.opts.Quorum.Delete(ctx, mt.NativeID)) + } + } + m.stopWatch(id) + m.clearLobby(id) + m.mu.Lock() + delete(m.consentAt, id) + m.mu.Unlock() + if err := m.opts.Store.Remove(id); err != nil { + return res, err + } + m.log.Info("[meetings] meeting deleted", "meeting", id, "state", string(mt.State), "upstream_error", res.UpstreamError) + return res, nil +} + +// finishedAt is when a meeting stopped: its end, else its last change. +func finishedAt(mt Meeting) time.Time { + if mt.EndedAt != nil { + return *mt.EndedAt + } + return mt.UpdatedAt +} + +// ClearFinished deletes every meeting in a final state that finished +// before cutoff, one Delete each. It returns the deleted meetings; a +// meeting that could not be removed is skipped (logged). +func (m *Manager) ClearFinished(ctx context.Context, cutoff time.Time) ([]DeleteResult, error) { + list, err := m.opts.Store.List() + if err != nil { + return nil, err + } + var out []DeleteResult + for _, mt := range list { + if ctx.Err() != nil { + return out, ctx.Err() + } + if !Finished(mt) || !finishedAt(mt).Before(cutoff) { + continue + } + res, err := m.Delete(ctx, mt.ID) + if err != nil { + m.log.Warn("[meetings] clearing a finished meeting failed", "meeting", mt.ID, "error", err) + continue + } + out = append(out, res) + } + return out, nil +} diff --git a/src/pkg/meetings/delete_test.go b/src/pkg/meetings/delete_test.go new file mode 100644 index 0000000000..06ad916fe8 --- /dev/null +++ b/src/pkg/meetings/delete_test.go @@ -0,0 +1,138 @@ +package meetings + +import ( + "context" + "errors" + "os" + "path/filepath" + "testing" + "time" +) + +func TestDeleteStateMatrix(t *testing.T) { + now := time.Now() + cases := []struct { + name string + mt Meeting + ok bool + erase bool // meeting.delete called + }{ + {"ended", Meeting{State: StateEnded, EndedAt: &now}, true, true}, + {"failed", Meeting{State: StateFailed, StateReason: ReasonDeclined, EndedAt: &now}, true, true}, + {"blocked", Meeting{State: StateBlocked, EndedAt: &now}, true, true}, + {"handed off", Meeting{State: StateHandedOff, EndedAt: &now}, true, false}, + {"purged", Meeting{State: StatePurged, EndedAt: &now}, true, false}, + {"pending request", Meeting{State: StateRequested, RequestedBy: &Person{Name: "andy"}}, true, true}, + {"dashboard join in flight", Meeting{State: StateRequested}, false, false}, + {"joining", Meeting{State: StateJoining}, false, false}, + {"lobby", Meeting{State: StateLobby}, false, false}, + {"live", Meeting{State: StateLive}, false, false}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + q := newFakeQuorum() + m := newTestManager(t, q, 0) + st := m.opts.Store + mt := c.mt + mt.ID, mt.NativeID, mt.CreatedAt = "mtg-x", "q-x", now + if err := st.Save(mt); err != nil { + t.Fatal(err) + } + if err := st.AppendTranscript(mt.ID, Event{Type: EventChat, Text: "hello"}); err != nil { + t.Fatal(err) + } + if err := st.SaveDoc(mt.ID, "state.json", map[string]string{"k": "v"}); err != nil { + t.Fatal(err) + } + res, err := m.Delete(context.Background(), mt.ID) + if !c.ok { + if !errors.Is(err, ErrStillRunning) { + t.Fatalf("Delete = %v, want ErrStillRunning", err) + } + if _, gerr := m.Get(mt.ID); gerr != nil { + t.Fatalf("a running meeting was removed: %v", gerr) + } + if len(q.deletes) != 0 || len(q.leaves) != 0 { + t.Fatalf("quorum called for a running meeting: deletes %v leaves %v", q.deletes, q.leaves) + } + return + } + if err != nil || res.UpstreamError != "" || res.Meeting.ID != mt.ID { + t.Fatalf("Delete = %+v, %v", res, err) + } + if _, err := m.Get(mt.ID); !errors.Is(err, ErrNotFound) { + t.Fatalf("record still there: %v", err) + } + if _, err := os.Stat(filepath.Join(st.Dir(), mt.ID)); !errors.Is(err, os.ErrNotExist) { + t.Fatalf("meeting dir (transcript, live state) still there: %v", err) + } + if erased := len(q.deletes) == 1 && q.deletes[0] == "q-x"; erased != c.erase { + t.Fatalf("meeting.delete calls %v, want called=%v", q.deletes, c.erase) + } + if pending := isPendingRequest(c.mt); pending != (len(q.leaves) == 1) { + t.Fatalf("leaves %v for pending=%v", q.leaves, pending) + } + }) + } +} + +func TestDeleteUpstreamErrors(t *testing.T) { + now := time.Now() + q := newFakeQuorum() + m := newTestManager(t, q, 0) + st := m.opts.Store + if _, err := m.Delete(context.Background(), "mtg-none"); !errors.Is(err, ErrNotFound) { + t.Fatalf("missing = %v", err) + } + // Vexa already purged it: not an error. + q.deleteErr = &ToolError{Tool: "meeting.delete", Code: CodeNotFound} + _ = st.Save(Meeting{ID: "mtg-gone", NativeID: "q-gone", State: StateEnded, EndedAt: &now, CreatedAt: now}) + if res, err := m.Delete(context.Background(), "mtg-gone"); err != nil || res.UpstreamError != "" { + t.Fatalf("not_found = %+v, %v", res, err) + } + // Any other Quorum error is surfaced, and the record is removed anyway. + q.deleteErr = &ToolError{Tool: "meeting.delete", Code: CodeUpstreamError, Message: "vexa 500"} + _ = st.Save(Meeting{ID: "mtg-err", NativeID: "q-err", State: StateFailed, EndedAt: &now, CreatedAt: now}) + res, err := m.Delete(context.Background(), "mtg-err") + if err != nil || res.UpstreamError == "" { + t.Fatalf("upstream error = %+v, %v", res, err) + } + if _, err := m.Get("mtg-err"); !errors.Is(err, ErrNotFound) { + t.Fatalf("record kept after an upstream error: %v", err) + } + // A meeting Quorum never knew (no native id) is removed without a call. + q.deleteErr = nil + before := len(q.deletes) + _ = st.Save(Meeting{ID: "mtg-local", State: StateFailed, EndedAt: &now, CreatedAt: now}) + if _, err := m.Delete(context.Background(), "mtg-local"); err != nil || len(q.deletes) != before { + t.Fatalf("local = %v, deletes %v", err, q.deletes) + } +} + +func TestClearFinished(t *testing.T) { + now := time.Now() + old := now.Add(-time.Hour) + later := now.Add(time.Hour) + q := newFakeQuorum() + m := newTestManager(t, q, 0) + st := m.opts.Store + _ = st.Save(Meeting{ID: "mtg-ended", NativeID: "q1", State: StateEnded, EndedAt: &old, CreatedAt: old}) + _ = st.Save(Meeting{ID: "mtg-blocked", NativeID: "q2", State: StateBlocked, EndedAt: &old, CreatedAt: old}) + _ = st.Save(Meeting{ID: "mtg-after", NativeID: "q3", State: StateEnded, EndedAt: &later, CreatedAt: old}) + _ = st.Save(Meeting{ID: "mtg-live", NativeID: "q4", State: StateLive, CreatedAt: old}) + _ = st.Save(Meeting{ID: "mtg-req", NativeID: "q5", State: StateRequested, RequestedBy: &Person{Name: "andy"}, CreatedAt: old}) + got, err := m.ClearFinished(context.Background(), now) + if err != nil || len(got) != 2 { + t.Fatalf("ClearFinished = %+v, %v", got, err) + } + for _, id := range []string{"mtg-ended", "mtg-blocked"} { + if _, err := m.Get(id); !errors.Is(err, ErrNotFound) { + t.Errorf("%s not cleared", id) + } + } + for _, id := range []string{"mtg-after", "mtg-live", "mtg-req"} { + if _, err := m.Get(id); err != nil { + t.Errorf("%s cleared: %v", id, err) + } + } +} diff --git a/src/pkg/meetings/schedule/delete.go b/src/pkg/meetings/schedule/delete.go new file mode 100644 index 0000000000..460a198ee7 --- /dev/null +++ b/src/pkg/meetings/schedule/delete.go @@ -0,0 +1,98 @@ +package schedule + +import ( + "errors" + "fmt" +) + +// Deleting Calendar entries (the dashboard's 🗑 Delete on past entries): +// only a finished event may be deleted; one still scheduled, awaiting +// approval or live keeps Skip and Cancel. Deleting a meeting from the +// Meetings section forgets it here too (ForgetMeeting). + +// LinkedMeetings returns the ids of the meetings an event created: the +// current one and those in its history, each once. +func LinkedMeetings(e Event) []string { + seen := map[string]bool{} + var out []string + add := func(id string) { + if id != "" && !seen[id] { + seen[id] = true + out = append(out, id) + } + } + add(e.MeetingID) + for _, h := range e.History { + add(h.MeetingID) + } + return out +} + +// Delete removes a finished event (ended, cancelled, declined, failed, +// blocked, skipped). Anything else is ErrConflict: skip or cancel it +// instead. +func (s *Scheduler) Delete(id string) (Event, error) { + return s.opts.Store.Remove(id, func(e Event) error { + if !e.Status.Terminal() { + return fmt.Errorf("%w: %s is %s; skip or cancel it instead", ErrConflict, id, e.Status) + } + return nil + }) +} + +// ForgetMeeting drops a deleted meeting from the Calendar: its history +// entries go, and a finished event that existed only for that meeting is +// removed. A series or an event with other occurrences stays. It returns +// how many events were removed. +func (s *Scheduler) ForgetMeeting(meetingID string) int { + if meetingID == "" { + return 0 + } + removed := 0 + for _, e := range s.opts.Store.List() { + linked := false + for _, id := range LinkedMeetings(e) { + if id == meetingID { + linked = true + } + } + if !linked { + continue + } + next, err := s.opts.Store.Update(e.ID, func(e *Event) error { + kept := e.History[:0:0] + for _, h := range e.History { + if h.MeetingID != meetingID { + kept = append(kept, h) + } + } + e.History = kept + // A live event keeps its link: reconcile records the missing + // meeting as ended on the next tick. + if e.MeetingID == meetingID && e.Status != StatusLive { + e.MeetingID = "" + } + return nil + }) + if err != nil { + s.log.Warn("[schedule] forgetting a deleted meeting failed", "event", e.ID, "meeting", meetingID, "error", err) + continue + } + if !next.Status.Terminal() || next.Recurring() || len(LinkedMeetings(next)) > 0 { + continue + } + if _, err := s.opts.Store.Remove(next.ID, func(cur Event) error { + if !cur.Status.Terminal() || len(LinkedMeetings(cur)) > 0 { + return errUnchanged + } + return nil + }); err != nil { + if !errors.Is(err, errUnchanged) { + s.log.Warn("[schedule] removing a deleted meeting's event failed", "event", next.ID, "error", err) + } + continue + } + removed++ + } + return removed +} diff --git a/src/pkg/meetings/schedule/delete_test.go b/src/pkg/meetings/schedule/delete_test.go new file mode 100644 index 0000000000..5d4e36f727 --- /dev/null +++ b/src/pkg/meetings/schedule/delete_test.go @@ -0,0 +1,74 @@ +package schedule + +import ( + "errors" + "testing" +) + +// putEvent stores ev as is (status, history and links included). +func putEvent(t *testing.T, s *Scheduler, ev Event) Event { + t.Helper() + ev.ID = EventID(ev.UID, ev.RecurrenceID) + got, err := s.opts.Store.Upsert(ev, func(_ *Event, in Event) Event { return in }) + if err != nil { + t.Fatal(err) + } + return got +} + +func TestDeleteOnlyFinishedEvents(t *testing.T) { + c := &clock{t: t0} + s := newTestScheduler(t, t.TempDir(), c, &fakeJoiner{}) + for _, st := range []Status{StatusScheduled, StatusAwaitingApproval, StatusLive} { + e := putEvent(t, s, Event{UID: "u-" + string(st), Start: t0, Status: st}) + if _, err := s.Delete(e.ID); !errors.Is(err, ErrConflict) { + t.Errorf("Delete %s = %v, want ErrConflict", st, err) + } + if _, err := s.Get(e.ID); err != nil { + t.Errorf("%s event removed: %v", st, err) + } + } + for _, st := range []Status{StatusEnded, StatusCancelled, StatusDeclined, StatusFailed, StatusBlocked, StatusSkipped} { + e := putEvent(t, s, Event{UID: "u-" + string(st), Start: t0, Status: st, MeetingID: "mtg-" + string(st)}) + got, err := s.Delete(e.ID) + if err != nil || got.MeetingID != "mtg-"+string(st) { + t.Errorf("Delete %s = %+v, %v", st, got, err) + } + if _, err := s.Get(e.ID); !errors.Is(err, ErrNotFound) { + t.Errorf("%s event kept: %v", st, err) + } + } + if _, err := s.Delete("nope"); !errors.Is(err, ErrNotFound) { + t.Errorf("unknown = %v", err) + } +} + +func TestForgetMeeting(t *testing.T) { + c := &clock{t: t0} + s := newTestScheduler(t, t.TempDir(), c, &fakeJoiner{}) + single := putEvent(t, s, Event{UID: "single", Start: t0, Status: StatusFailed, MeetingID: "mtg-1", + History: []Occurrence{{Start: t0, MeetingID: "mtg-1", Status: StatusFailed}}}) + series := putEvent(t, s, Event{UID: "series", Start: t0, Status: StatusScheduled, RRule: "FREQ=WEEKLY", MeetingID: "mtg-3", + History: []Occurrence{{Start: t0, MeetingID: "mtg-2", Status: StatusEnded}, {Start: t0.AddDate(0, 0, 7), MeetingID: "mtg-3", Status: StatusEnded}}}) + other := putEvent(t, s, Event{UID: "other", Start: t0, Status: StatusEnded, MeetingID: "mtg-9"}) + + if n := s.ForgetMeeting("mtg-1"); n != 1 { + t.Fatalf("ForgetMeeting single = %d, want 1 removed", n) + } + if _, err := s.Get(single.ID); !errors.Is(err, ErrNotFound) { + t.Fatalf("an event that existed only for the meeting was kept: %v", err) + } + if n := s.ForgetMeeting("mtg-3"); n != 0 { + t.Fatalf("ForgetMeeting series = %d, want 0 removed", n) + } + got, err := s.Get(series.ID) + if err != nil || len(got.History) != 1 || got.History[0].MeetingID != "mtg-2" || got.MeetingID != "" { + t.Fatalf("series after forget = %+v, %v", got, err) + } + if _, err := s.Get(other.ID); err != nil { + t.Fatalf("an unrelated event was touched: %v", err) + } + if n := s.ForgetMeeting(""); n != 0 { + t.Fatal("empty id must be a no-op") + } +} diff --git a/src/pkg/meetings/schedule/store.go b/src/pkg/meetings/schedule/store.go index 194afc0889..232ccd120f 100644 --- a/src/pkg/meetings/schedule/store.go +++ b/src/pkg/meetings/schedule/store.go @@ -167,6 +167,30 @@ func (s *Store) Update(id string, fn func(*Event) error) (Event, error) { return Event{}, fmt.Errorf("%w: %s", ErrNotFound, id) } +// Remove deletes one event by its id when check accepts it (nil accepts +// any). It returns the removed event. +func (s *Store) Remove(id string, check func(Event) error) (Event, error) { + s.mu.Lock() + defer s.mu.Unlock() + for k, e := range s.events { + if e.ID != id { + continue + } + if check != nil { + if err := check(e); err != nil { + return e, err + } + } + delete(s.events, k) + if err := s.saveLocked(); err != nil { + s.events[k] = e + return e, err + } + return e, nil + } + return Event{}, fmt.Errorf("%w: %s", ErrNotFound, id) +} + // Upsert stores a normalized event under the SEQUENCE rule: a new event is // added; an existing one is replaced only by a higher SEQUENCE (equal or // lower returns the stored event and ErrStaleSequence). merge builds the diff --git a/src/pkg/meetings/store.go b/src/pkg/meetings/store.go index f11d947d88..9c20fa4f2a 100644 --- a/src/pkg/meetings/store.go +++ b/src/pkg/meetings/store.go @@ -212,6 +212,21 @@ func (s *Store) PurgeTranscript(id string) error { return nil } +// Remove deletes a meeting's directory: the record, its transcript and its +// side documents. Removing a missing meeting is not an error. +func (s *Store) Remove(id string) error { + p, err := s.path(id, meetingFile) + if err != nil { + return err + } + s.mu.Lock() + defer s.mu.Unlock() + if err := os.RemoveAll(filepath.Dir(p)); err != nil { + return fmt.Errorf("meetings: removing %s: %w", id, err) + } + return nil +} + // validDocName keeps side document names to a plain file name. var validDocName = regexp.MustCompile(`^[a-z0-9_-]{1,32}\.json$`) From c8cb0f905ec7c414942c7646616b6f4d79b797fd Mon Sep 17 00:00:00 2001 From: Andy Anderson Date: Mon, 16 Nov 2026 23:10:09 -0500 Subject: [PATCH 2/2] =?UTF-8?q?=F0=9F=90=9B=20Meetings=20delete:=20use=20s?= =?UTF-8?q?.meetingsError=20after=20the=20v5=20merge=20(#18600)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Andy Anderson --- src/pkg/dashboard/api_meetings_delete.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/pkg/dashboard/api_meetings_delete.go b/src/pkg/dashboard/api_meetings_delete.go index df69c6605a..0df528355a 100644 --- a/src/pkg/dashboard/api_meetings_delete.go +++ b/src/pkg/dashboard/api_meetings_delete.go @@ -64,7 +64,7 @@ func (s *Server) handleMeetingsDelete(w http.ResponseWriter, r *http.Request) { defer cancel() d, err := svc.Delete(ctx, r.PathValue("id")) if err != nil { - meetingsError(w, err) + s.meetingsError(w, r, err) return } s.auditMeetingDeleted(r, d, "meetings") @@ -107,7 +107,7 @@ func (s *Server) handleMeetingsClearFinished(w http.ResponseWriter, r *http.Requ s.auditMeetingDeleted(r, d, "clear_finished") } if err != nil { - meetingsError(w, err) + s.meetingsError(w, r, err) return } jsonResponse(w, map[string]any{"deleted": list, "count": len(list)}) @@ -126,7 +126,7 @@ func (s *Server) handleMeetingsScheduleDelete(w http.ResponseWriter, r *http.Req eid := r.PathValue("eid") d, err := svc.Delete(ctx, eid) if err != nil { - meetingsError(w, err) + s.meetingsError(w, r, err) return } if d.Meetings == nil {