Skip to content

Latest commit

 

History

History
566 lines (350 loc) · 41.8 KB

DEVLOG.md

File metadata and controls

566 lines (350 loc) · 41.8 KB

LMS Chat — Dev Log


2026-02-22 — First successful boot + dev login

What we did

Got the scaffolded app running end-to-end for the first time and added a dev login flow so the UI can be worked on without a real Canvas instance.

Startup bugs fixed

Redis client library — The Redis client library we were using requires a different initialization pattern in modern JavaScript modules than what was in the scaffold. Fixed the import and removed a manual connection call that the library does not expect (it connects automatically).

LTI library import — The LTI library's default export does not expose the setup method. Fixed by importing the named provider class directly.

LTI + Socket.io conflict — The LTI library normally controls the underlying HTTP server, making it inaccessible for Socket.io to attach to. Fixed by running the LTI library in serverless mode and manually constructing the HTTP server so Socket.io can share it.

LTI route interception — The LTI library was intercepting all incoming requests — including our own API routes — and rejecting them with an authentication error. Fixed by explicitly whitelisting our API path prefix so the LTI layer only guards the LTI launch flow.

Missing environment file — The server crashed immediately because no environment file existed. Created one from the example template with freshly generated secrets.

Dev login

Added a dev-only login flow so the UI can be developed and tested without a live Canvas installation. A simple form lets a developer enter a name and choose a role (student, TA, instructor). On submit, the server creates a realistic fake session backed by the same database tables a real LTI launch would populate. The browser is then redirected into the app as that user.

A subtle bug with session cookies being lost through the development proxy was resolved by having the server return a success response and letting the browser handle the redirect itself, rather than issuing a server-side redirect.

Docker

Started all required backing services (PostgreSQL, Redis, MongoDB) via Docker Compose. Cleaned up a deprecation warning in the Compose file. Database migrations ran cleanly against a fresh database.


2026-02-22 — Light theme + message edit/delete

Light theme

Replaced the default dark theme with a light theme matching Canvas brand guidelines:

  • White sidebar, light gray main area
  • Accent color: Canvas Orange (#E66000) — used on buttons, active channel highlight, own message bubbles, and avatars
  • Dark navy-gray text on light backgrounds for accessibility

Message edit

  • Authors can edit their own messages by clicking a pencil icon that appears on hover
  • The message bubble is replaced with an editable text area; Save and Cancel controls appear below
  • Enter saves, Escape cancels
  • Edited messages are marked with an "(edited)" indicator
  • FERPA compliance: the original message content is stored in the audit log before the edit is saved

Message delete

  • Authors can delete their own messages; instructors and TAs can delete any message
  • A delete icon appears on hover alongside the edit icon
  • Messages are soft-deleted in the database (the record is preserved for the audit trail)
  • Edit and delete actions update all connected users in real time via the live messaging layer

2026-02-23 — Channel creation UI

  • A create button appears next to the channels heading in the sidebar, visible to instructors and TAs only
  • Clicking it opens a modal where the channel name, optional description, and posting permissions (who can post: TA, students) can be configured. The channel name is automatically formatted into a URL-safe slug with a live preview.
  • The modal closes on Escape or clicking outside
  • The new channel appears in the sidebar immediately on creation, without a page refresh
  • The restriction is enforced on both the client (button hidden from students) and the server (role check on the creation endpoint)

2026-02-23 — Private Office Hours chat

Each student gets a private message thread with their instructor or TA tied to their office hours request. No other students can see the conversation — access is enforced at both the API and real-time messaging layers, in compliance with FERPA.

  • Message history is persisted in the database and loaded when a student or instructor opens the chat panel
  • New messages from either party appear in real time without refreshing
  • The student's view shows an "Open Chat" toggle on their office hours card; instructors see the same panel when reviewing a request
  • Cancelled requests disable the chat panel
  • The Office Hours page was redesigned with a light theme, color-coded status badges (pending, scheduled, completed, cancelled), and role-appropriate action controls (Schedule, Decline, Mark Complete for instructors)

2026-02-23 — Unread counts + Office Hours badge

Channel unread counts

  • Each channel in the sidebar now shows an orange badge with the count of unread messages
  • The count updates in real time as new messages arrive in channels the user is not currently viewing
  • Opening a channel clears its badge and marks the channel as read, persisted to the database so it survives a page refresh

Office Hours pending badge

  • Instructors and TAs see a badge on the Office Hours navigation button showing the number of pending requests
  • The badge updates instantly when a new request is submitted by a student, without requiring a page refresh
  • Falls back to a periodic refresh as a safety net

Demo data

  • The dev login seeder now always ensures a sample student account ("Alex Chen") exists with one pending office hours request, so instructors always see the badge and pending request flow on first login

2026-02-23 — Right-click context menus + channel leave/delete

Context menu component

A reusable right-click context menu was built that renders outside the normal page flow so it is never clipped by scrolling containers. It clamps to the viewport edges, dismisses on outside click or Escape, and supports a danger (red) style for destructive actions.

Message right-click

Right-clicking a message shows Edit and Delete options (where the user has permission), as an alternative to the hover buttons.

Channel right-click

Right-clicking a channel in the sidebar shows two options:

  • Leave Channel — available to all roles. The channel is hidden from that user's sidebar permanently and is excluded from their channel list on every subsequent load.
  • Delete Channel — available to instructors and TAs only, shown in red. Permanently deletes the channel and all its messages. The channel disappears from everyone's sidebar in real time via a socket event.

Sidebar UX

  • Office Hours was removed from the default channel list — it is a dedicated page, not a chat channel
  • The sidebar footer was reorganized: user info on top, a full-width Office Hours button below with the pending badge for instructors/TAs

2026-02-23 — Bug fixes: server crash + stale UI on channel delete

Server crash on channel delete

  • Root cause: When a user opened a channel and it was simultaneously deleted by an instructor, the next "mark as read" request from the client tried to write a database record referencing the now-deleted channel. This caused a foreign key violation that crashed the server process.
  • Fix: The mark-as-read operation now silently does nothing if the referenced channel no longer exists, rather than writing unconditionally.

Channel not removed from sidebar after delete

  • Root cause: The client waited for confirmation from the server's socket event before removing the channel from the sidebar. If the server had already crashed in the window above, that event never arrived and the UI stayed stale.
  • Fix: The channel is now removed from the local UI state immediately when the delete action is triggered, before the server responds. The UI is correct regardless of server timing.

2026-02-23 — Mobile-responsive layout

  • Below 640px, the sidebar collapses off-screen and slides in as an overlay when opened
  • A semi-transparent backdrop behind the open sidebar dismisses it on tap
  • Selecting a channel automatically closes the sidebar
  • An empty-state screen on mobile shows a "Browse channels" prompt
  • The chat window gains a mobile top bar showing the current channel name and a hamburger button to open the sidebar
  • Bottom padding on the message input accounts for the home indicator on phones without a physical home button

2026-02-23 — Dark mode toggle

  • A toggle button in the sidebar footer switches between light and dark themes
  • The preference is saved in the browser and restored on next load; if no preference has been set, the user's operating system setting is respected
  • All colors across every component use theme variables so the entire interface switches cleanly — no hardcoded color values remain (except semantic status badge colors such as pending/completed, which are self-contained and readable in both modes)

2026-02-24 — Typing indicators + online presence

Typing indicators

  • When a user is typing in a channel, other users in that channel see an animated three-dot indicator and the text "[Name] is typing…"
  • Handles multiple typers gracefully: two names are listed individually; three or more collapse to "Several people are typing…"
  • The indicator clears automatically if the user stops typing, even without sending a message
  • A fixed-height bar is always reserved for the indicator so the message list does not jump when it appears or disappears

Online presence

  • A green dot appears on the user's own avatar in the sidebar footer while they are connected
  • A live online count appears next to the channels heading and in the channel header
  • Message bubbles show a green dot on the sender's avatar if that user is currently online

2026-02-24 — Emoji reactions, reply, forward, threads

Emoji reactions

  • Six reactions available: 👍 👎 ❤️ 😂 ✅ ❓
  • Hovering a message reveals an action bar; clicking the reaction button opens the emoji picker
  • Selected reactions appear as pills below the message bubble showing the emoji and count
  • A pill is highlighted when the current user has reacted with that emoji
  • Reactions update in real time for all users in the channel

Message action bar

  • The previous right-click-only context menu for messages was replaced with a persistent hover action bar that appears above the message bubble
  • The bar shows: Reactions, Reply, Forward, Edit (author only), Delete (author or instructor/TA)
  • Each button shows a tooltip label on hover
  • Buttons that the user lacks permission to use are not shown at all

Reply — Slack/iPhone style

  • Clicking Reply opens the reply composer at the bottom of the screen
  • The reply is sent as a new message in the main feed — it is not nested inline under the original
  • A compact quote block above the reply bubble shows the original sender's name and a snippet of their message

Forward

  • Clicking Forward opens a channel picker
  • Confirming copies the message content to the selected channel

Thread replies (backend infrastructure)

  • The database was extended to support thread replies as a distinct message type, separate from the main channel feed
  • Thread reply counts are tracked and broadcast in real time so the main feed can eventually show reply counts per message

2026-02-24 — Real-time bug fixes

Root bug — socket events never broadcast from REST handlers

  • Root cause: The middleware responsible for giving route handlers access to the real-time messaging layer was registered in the wrong order in the server startup sequence. Because the web framework processes middleware in the order it is registered, every route handler that tried to send a socket event was working with an uninitialized reference. The failure was silent — the code appeared to try to emit but nothing was sent.
  • Fix: Restructured the server startup sequence so the messaging middleware is registered before the route handlers. A deferred reference pattern ensures the middleware always resolves to the live Socket.io instance once it is initialized, regardless of when a request arrives.
  • Impact: This was the root cause of reactions, edits, and deletes not broadcasting to other users in real time.

Reactions now update live

  • Previously, a reaction click updated the database but no socket event was ever broadcast (due to the bug above), so other users had to refresh to see changes.
  • Fix applied as part of the root bug resolution above. As an additional safeguard, the reacting user's own UI now updates immediately from the server's response rather than waiting for the socket bounce-back.

Sent messages now appear immediately for the sender

  • Previously, a sent message did not appear in the sender's own feed until the server broadcast it back via the socket — adding a perceptible delay.
  • Fix: the server now acknowledges the message immediately in its response, and the client adds it to the feed from that acknowledgement. Duplicate-prevention logic ensures the message is not added a second time when the broadcast also arrives.

2026-02-24 — Emoji reaction redesign: accumulate counts, names, right-click remove

New behavior

The previous model toggled a reaction off if you clicked it again. The new model matches how reactions work in Slack and most social platforms:

  • Left-click the emoji picker — always adds your reaction. The picker highlights emojis you have already used on this message. Clicking an already-reacted emoji again does nothing.
  • Left-click a reaction pill — adds that reaction if you have not yet reacted with it; does nothing if you already have.
  • Right-click a reaction pill — prompts you to remove your own reaction. If confirmed, your reaction is removed and the count decreases by one. Other users' reactions are not affected.
  • Hover a reaction pill — a tooltip lists the names of everyone who reacted with that emoji (e.g. "Ian, Alex").

What changed on the server

  • The add-reaction endpoint now only adds; it will not create a duplicate if the same user reacts twice with the same emoji.
  • A new remove-reaction endpoint was added that deletes only the requesting user's reaction for a given emoji and broadcasts the updated reaction state to all users in real time.
  • The reaction data returned to clients was extended to include the display names of everyone who reacted, so the tooltip can be populated without a second request.

What changed on the client

  • The reaction toggle function was replaced with separate add and remove actions
  • Both actions update the local message state immediately from the server response, so the UI feels instant
  • The message bubble, reaction list, and channel components were all updated to wire the remove action through correctly

2026-02-24 — Action bar improvements + quick dev login

Larger action icons

All icons in the hover action bar were increased in size for easier clicking and better visibility on all screen sizes.

Direct reaction buttons

Three reactions are now available as one-click buttons directly in the action bar, without opening a picker:

  • 🙌 Job well done
  • 👍 Thumbs up
  • 👎 Thumbs down

A thin visual divider separates the reaction buttons from the other action buttons. Buttons already reacted to are highlighted in the accent color.

Additional reactions picker — opens left

The ☺ button opens a secondary picker for less common reactions (❤️ 😂 😮 😢 ✅ ❓). Previously this picker opened upward and was obscured by the channel header when hovering messages near the top of the window. It now opens to the left of the action bar, staying fully visible regardless of where the message sits in the scroll window.

Updated icons

The edit button now shows a pencil emoji and the delete button shows a trashcan emoji, replacing the previous text symbols.

Quick dev login presets

The developer login screen now shows two one-click buttons at the top: "Ian Burres — Instructor" and "Alex Chen — Student". Clicking either logs in immediately without filling out the form. The manual name/role form remains available below for other test users. This makes switching between accounts straightforward when testing features that require two users — such as verifying that reaction counts and names appear correctly from a second user's perspective.


2026-02-24 — Logout button

A logout button was added to the sidebar footer, next to the theme toggle. Clicking it ends the current session on the server and redirects to the login screen. This makes it straightforward to switch between test accounts during development without needing a separate browser window.


2026-02-25 — Pinned messages

Instructors and TAs can pin any message in a channel. A pin button appears in the message action bar when hovering — only visible to those with permission to pin.

Once a message is pinned, a 📌 badge appears in the channel header showing how many messages are pinned. Clicking it opens a side panel listing all pinned messages for that channel, each showing the sender, date, and content. Instructors and TAs see an Unpin button on each entry.

Pin and unpin actions update in real time for all users in the channel — the badge count and panel list reflect the change instantly without a page reload. Both actions are recorded in the audit log for FERPA compliance.


2026-02-25 — Reaction bar improvements + skin tone support

Bug fix

The "job well done" hands emoji and several emojis in the additional reactions picker (surprised, sad) were silently rejected by the server and never recorded. The server's allowed list was too narrow. All missing emoji are now accepted.

Skin tone picker

Clicking the raised hands, thumbs up, or thumbs down emoji now opens a small three-option picker showing the default (yellow), medium, and dark skin tone variants. The user picks the shade that represents them, and that variant is stored as their reaction. The button remembers and displays whichever tone they chose.

New direct reaction buttons

Heart, checkmark, and smile are now single-click buttons in the action bar alongside the hands and thumbs, so the most common reactions are always one tap away.

Additional reactions picker

Trimmed to less-common emoji only (laughing, surprised, sad, question mark), since the most common reactions are now direct buttons.


2026-02-25 — Global skin tone selector + expanded emoji picker

Global skin tone preference

Users can now choose a skin tone once and have it apply automatically to all hand and gesture reactions. The preference is saved in the browser and restored on future visits. Clicking the raised hands, thumbs up, or thumbs down in the action bar immediately reacts with the chosen shade — no per-button picker needed.

Expanded emoji picker

The additional reactions picker is now a proper scrollable panel (instead of a small horizontal strip) organized into three labeled sections: Gestures, Faces, and Hearts & Symbols. The Gestures section contains 24 hand and gesture emoji, all shown with the currently selected skin tone. The Faces section contains 22 emoji. Hearts & Symbols contains 22 entries including fire, trophy, graduation cap, and others.

At the bottom of the panel, six colored circles represent the six skin tone options (default yellow through dark). Clicking a circle applies the tone immediately and saves it. Gesture emoji in the picker update to reflect the new choice right away.

Server

The allowed emoji list was expanded to cover all 26 skin-tone-eligible gesture emoji with all five Fitzpatrick modifier variants, plus the full face and symbol sets.


2026-02-25 — Direct message bug fixes

Real-time delivery

  • Root cause: When Alex sent a message to Ian, Alex's browser was subscribed to that DM conversation's live channel (because Alex had the DM window open). Ian's browser was not — it only subscribed when Ian manually opened the DM window. Any message sent while Ian had the window closed was silently dropped.
  • Fix: Each user's connection now automatically subscribes to all of their existing DM conversations the moment they connect to the app. When a brand-new conversation is created, both participants' connections are subscribed to it immediately — without either person needing to open the window first. The unsubscribe event that fires when a DM window is closed is now a no-op, so the subscription persists for the full session and sidebar unread badges stay current.

Button interaction bug

  • Root cause: The buttons in the Direct Messages sidebar section did not declare their element type. In HTML, an undeclared button defaults to "submit" behavior, which can cause it to trigger a nearby form (in this case, the search bar's form) instead of its own click handler.
  • Fix: All buttons in the DM sidebar and participant picker now explicitly declare themselves as action buttons, not form-submit triggers.

2026-02-25 — Entry 020: Direct messages

Any two people in the same course can now have a private one-on-one conversation.

How it works:

  • A new "Direct Messages" section appears in the sidebar below the channel list.
  • Each thread shows the other person's name and a badge with the unread count.
  • A compose button at the top of the section opens a searchable participant picker — find any student, TA, or instructor by name and click to open a conversation.
  • Starting a conversation a second time reopens the existing thread rather than creating a duplicate.

Clicking names: A sender's name on any message bubble is now clickable. Clicking it instantly opens a direct message with that person without going through the picker.

Real-time: Messages arrive immediately for both participants. A typing indicator shows when the other person is writing. The sidebar thread list reorders itself with the most recently active thread at the top, and unread badges update live.

Scope and privacy: DMs are strictly scoped to a single course — a student cannot message someone from a different course even if they share the same platform. Access is enforced on both the API and the real-time socket layer. Both create and delete actions are logged for FERPA compliance.

Soft delete: Senders can delete their own messages. Records remain in the database for the audit trail but are hidden from both participants.


2026-02-25 — Codebase documentation pass

Added comprehensive inline documentation to all 55 server and client source files. No runtime behavior was changed — this was purely a documentation effort to make the codebase easier to navigate and understand.

What was documented:

Every file now opens with a block comment that describes its purpose, which database tables it reads or writes, which REST endpoints or real-time socket events it interacts with, and any FERPA-relevant notes (encryption, audit logging, access control).

Every exported function, React component, custom hook, and helper now has a comment above it explaining what it does, what parameters it expects, what it returns, and any important side effects.

Inside function bodies, inline comments were added wherever the logic is not self-evident. This includes the cursor-based message pagination strategy, how duplicate-prevention works when a message arrives via both a direct acknowledgement and a broadcast, the socket room membership system (how users are automatically subscribed to their existing DM threads on connect), how AES-256-GCM decryption is applied to name and email fields before data is returned to the client, how role-based permission checks drive different UI in message action bars and channel controls, and how the skin-tone modifier system for emoji reactions works.


2026-08-24 — Maintenance check-in + security patch

Picked the project back up after a pause. The goal for the session was to restore the local development environment, confirm the most recently built feature still works, and make sure we are on current security patches.

Environment restored

All backing services were brought back up and came online healthy. The server dependencies had to be reinstalled, and the full database schema re-applied from scratch without errors. The server started cleanly and reported healthy.

Direct messaging verified

Ran a full end-to-end check of the private one-on-one messaging feature — the last thing built before the pause, and the one that had been mid-debugging. Simulated two people in the same course exchanging messages and confirmed that messages are delivered live in both directions, that conversation history is stored and read back correctly, and that unread badges increment for the recipient. Everything passed.

Security patch

A dependency audit flagged a high-severity advisory in the low-level networking library underneath the real-time messaging layer — a memory-disclosure issue plus a denial-of-service risk. Applied the non-breaking update on both the server and the browser app. This resolved the high-severity finding and the large majority of the other outstanding advisories in one pass. The real-time messaging check was re-run on the patched code and still passed, confirming no regression.

Services already current

The three backing databases were verified to already be running the latest maintenance releases within their pinned major versions, so no action was needed there. A small number of remaining advisories require larger framework major-version jumps; these were deferred to be handled individually as tested upgrades rather than bundled into this maintenance pass.


2026-08-24 — Continuous integration pipeline

Introduced the project's first automated verification pipeline, so that every proposed change is checked in the cloud before it can be merged.

What it does

On every proposed change (and on anything landing in the main line), an automated run brings up fresh, disposable copies of all three backing services, builds the front-end to catch any build breakage, applies the database schema from scratch, starts the server, and waits for it to report healthy. It then executes an automated end-to-end test that simulates two people in the same course holding a private conversation, asserting that messages are delivered live in both directions, that history is stored and read back correctly, and that unread badges increment for the recipient. If any of these steps fail, the change is blocked from merging.

A dependency security scan also runs on each change. It is reported for visibility but intentionally does not block merging, because a few known larger upgrades are still pending and would otherwise wall off unrelated work.

Why

The prior session flagged that there was no automated gate, which made a "merge only when green" policy meaningless. This pipeline provides that gate: proposed changes now pass a real verification run rather than a manual spot-check.

Process

This was also the first change developed under the newly agreed working loop — branch, build, test until it passes, open a proposal, and merge only once the automated check goes green. The pipeline itself was validated end to end locally (against freshly reset services) before it was proposed, and then merged after its own check passed in the cloud.


2026-08-24 — Hardening how encrypted personal data is read

Closed a resilience gap found while building the CI pipeline: an unreadable personal-data record could crash the whole server.

The problem

Student names and emails are stored encrypted at rest. When the app reads one back, it decrypts it. If decryption failed — because the record was written under a different encryption key, or was corrupted or tampered with — the error was not being contained. Because these reads happen while assembling responses, an uncontained failure could bring down the entire server process. In effect, one bad record could cause an outage for every user, not just the person whose record was affected.

The fix

Reading encrypted personal data now fails safe. If a record cannot be decrypted, the affected name is treated as simply unavailable — the interface already shows a neutral placeholder avatar in that case — and the server continues serving everyone else normally. The failure is written to the server logs so operators can spot and investigate a key or data problem, and that log entry is deliberately free of any personal data. Callers can also specify a custom placeholder where a more descriptive label makes sense.

Verification

Added a small, self-contained automated test suite for the encryption helpers. It confirms that ordinary values still encrypt and decrypt correctly (including international characters), that empty values are handled, that repeated encryptions of the same value produce different stored output, and — the core of this change — that malformed, corrupted, and truncated records now return the safe placeholder rather than throwing. This suite was added to the automated pre-merge checks, so a future change can't silently reintroduce the crash.

The full pipeline was run locally against freshly reset services before proposing — encryption tests, front-end build, database setup, and the two-person real-time messaging test all passed — and the change was merged only after the automated check passed in the cloud.


2026-11-02 — Closing gaps in the privacy audit trail

Found while answering UTSA compliance questions about records retrieval and audit-log review: two everyday actions were not being written to the audit trail.

The problem

The app keeps a privacy audit trail of who did what, in which course, and when. But the most common action of all, sending a message, was only recorded when it went through a secondary path that the browser rarely uses. Messages sent the normal way, over the live real-time connection, both in course channels and in private direct messages, left no audit entry. Separately, opening the app from Canvas (effectively the app's login) was not recorded at all. That would have left a hole in any access report the university asked for.

The fix

Recording an audit entry is now a shared capability that every part of the server can use, not just the standard request handlers. Messages sent over the live connection now produce the same audit entries as the secondary path, so every message is accounted for however it was sent. Each launch from Canvas is now recorded too, along with the role the person launched as. The developer-only test login is recorded the same way, so automated tests exercise the same trail.

Verification

The automated two-person messaging test was extended. It now sends a channel message and a private message over the live connection, then checks the audit trail for the login and for both messages. As a check that the test can actually catch the problem, it was also run with the fix removed and correctly failed. With the fix in place, all checks pass, along with the existing encryption tests. The change was merged only after the automated check passed in the cloud.


2026-11-02 — Audit review with separation of duties

Built the tools the department needs to review the privacy audit trail and answer records requests, with a conflict-of-interest rule built in.

Who can do what

The department owns the app and its records; Ian maintains and administers it. Two kinds of reviewer access now exist, both granted by the server's configuration rather than by anyone's Canvas role:

  • Department chair and co-chair: can review activity and export records for every course, and decide which courses the administrator must stay out of.
  • Administrator: has the same tools for every course except courses they belong to in any role (teaching, assisting or enrolled), plus any course the chair or co-chair has added to a restriction list. The list covers courses the administrator teaches but hasn't opened the app from yet. The automatic block cannot be lifted by anyone. Activity that isn't tied to a course is visible only to the chair and co-chair.

Access is re-checked on every request, so removing someone from the configuration takes effect immediately.

Accountability for the reviewers

Every review, every export and every change to the restriction list is itself recorded in the audit trail, filed under the course concerned. So is every attempt to open a course the reviewer isn't allowed to see. The chair and co-chair can therefore see exactly what the administrator looked at, or tried to.

The review page

A new Audit Review page, linked only for these three people, lets a reviewer filter activity by course, type and date range, and page back through history. For a records request, it can export everything for one course in one file: members, channel messages, private messages, office-hours conversations, messages that were deleted, and the original text of any that were edited.

Verification

A new automated test sets up three courses with an administrator, a chair and a student, and checks every rule above: the automatic block, the chair's unrestricted access, adding and removing a restriction, that denied attempts reach the chair, and that reviewer activity is logged. It runs on every proposed change alongside the existing checks. The page itself was also checked in a browser at desktop and phone widths. The change was merged only after the automated check passed in the cloud.

One limit, noted for the compliance answers: anyone with direct access to the server's database sits outside these rules. That is covered by database-level logging that the chair and co-chair review, not by the app itself.


2026-11-02 — Privacy notice at launch and message reporting

Two features committed to in the UTSA compliance answers: telling every user up front that their messages are stored and may be reviewed, and letting anyone report a message that concerns them.

Privacy notice

The first time someone opens the app, and again whenever the wording changes, they see a notice before they can do anything else. It explains that:

  • all messages are stored by the department, including private messages, office-hours chats, and messages that were edited or deleted;
  • authorized department administrators may review or retrieve them under UTSA policy, for example for a records request, a report, an investigation, or records-retention requirements;
  • instructors cannot read private messages between students.

It links to UTSA's records policy. The app records who acknowledged which version of the notice and when, so the department can show that every user was informed. The wording is kept in a single place on the server, and changing it prompts everyone to acknowledge it again. Anyone can re-read it from the sidebar.

Reporting a message

Every message from someone else now has a Report option. The reporter picks a reason (harassment, inappropriate content, not course-related, spam, or other) and can add details. A copy of the message is saved with the report, so later edits or deletions don't change what was reported.

Where a report goes depends on where the message was:

  • Course channels: to the course's instructors and TAs, who already moderate channels. They get a new Reported Messages page with a live count in the sidebar. The report also goes to the department's reviewers.
  • Private messages: to the department's reviewers only. Instructors can't see private messages, so they don't see reports of them either.

Reviewers mark each report as reviewed or dismissed, with an optional note on what was done. Reports of private messages appear only on the department's Audit Review page, where the administrator's conflict-of-interest rule still applies. Reporting, viewing and resolving reports are all recorded in the audit trail.

Verification

A new automated test covers the whole flow:

  • a new user has to acknowledge the notice, and an outdated version is rejected;
  • duplicate reports, reports of your own message, and reports by someone outside the conversation are refused;
  • instructors see channel reports but never private-message reports;
  • a reported message keeps its original text after being edited;
  • the chair sees both kinds, and the administrator is still blocked from his own course;
  • every step is logged.

The feature was also checked in a browser end to end. The change was merged only after the automated check passed in the cloud. The notice wording still needs approval from UTSA compliance before the pilot.


2026-11-02 — Automatic security alerts from the audit trail

The audit trail records everything, but someone still has to notice when something looks wrong. The app now watches the trail itself and raises alerts for reviewers to handle, which strengthens the answer to UTSA's question about how logs are reviewed.

What it watches for

Every 15 minutes the server checks recent activity against a set of rules:

  • Unusual volume: one account reading far more message history, or running far more searches, than normal in an hour.
  • Bulk deletion: many messages deleted in a few minutes.
  • Records exports: any time someone exports a course's full records, so a second person can confirm it matches an approved request.
  • Restricted-course attempts: an administrator trying to open a course they're blocked from.
  • After-hours administration: reviews, exports or restriction changes outside normal working hours.
  • New or off-campus logins: a returning user signing in from a network address they haven't used before, or from outside the campus network once those ranges are configured.
  • Repeated reports: several different people reporting the same person.
  • Unhandled reports: a reported message nobody has acted on after three days.

Every threshold is a setting the department can tune once real pilot traffic shows what normal looks like.

Handling alerts

Alerts appear at the top of the Audit Review page, highest severity first, and a count appears on the page's sidebar link. A reviewer can acknowledge an alert, dismiss it, or reopen it, with a note on what they checked. Each of those actions is itself recorded. Re-checking never creates duplicates, and a dismissed alert stays dismissed.

The separation-of-duties rule carries over. The administrator never sees alerts about his own activity, such as his own exports, after-hours work or blocked attempts, so he can't dismiss them. Only the chair and co-chair see those.

Working with campus security tools

Network intrusion-detection systems and file scanners can't see this kind of behaviour, because to them it looks like normal web traffic. So the app does the detection itself. It also writes every new alert to a log file in a standard format, containing record identifiers and counts but no names or message content. Campus security monitoring tools can collect that file, so these alerts can flow into whatever system UTSA's security office already watches.

Verification

A new automated test generates suspicious activity in a fresh course and confirms:

  • every rule fires;
  • alerts contain no names;
  • the administrator can't see or clear alerts about himself;
  • acknowledgments survive a re-check and re-checking creates no duplicates;
  • students are refused;
  • the log file is written without personal data.

The off-campus rule was checked by hand against a sample campus network range. All earlier test suites still pass. The change was merged only after the automated check passed in the cloud.

Two of the rules, new and off-campus logins, depend on the server seeing users' real network addresses. That will be handled in the upcoming deployment work.


2026-11-03 — Chat access follows the Canvas course role

Nobody logs in to the app: Canvas tells it who the person is and what role they hold in the course they opened it from. This change tightens how that role is read, and decides who may use the chat at all.

Who gets in

Only the course's instructors (including co-instructors), teaching assistants and students can use the chat. Observers, course designers, Canvas administrators, and anyone with no role in the course see a short page saying chat isn't available for their role. The app creates no account for them, and records the refused attempt with the Canvas role names only, never the person's name. If someone loses their role, such as a student who becomes an observer, they're removed from the course's member list the next time they open the app.

A loophole closed

Canvas sends two kinds of role with every launch: the person's role in this course, and their roles across the whole university. The app used to look for the word "Instructor" anywhere in that list. As a result, a teaching assistant, or a student who happens to teach a section elsewhere, could have been treated as an instructor in this course. The app now reads only the course role, and checks for teaching assistants first so they're never promoted.

Department reviewers

The chair and co-chair review records across courses, so they may open the app from a course where they aren't an instructor, TA or student. They still get in, but only to the Audit Review page, with no access to that course's chat. The same applies to the administrator, and the course is added to the administrator's restricted list, so the conflict-of-interest rule still holds.

Verification

New automated tests check the role rules directly: course versus university roles, teaching assistants, refused roles and reviewers. An end-to-end test confirms that refused launches get no session and are recorded without names, that a demoted student loses membership, that review-only sessions can't reach chat, and that the administrator's course is restricted. All earlier test suites still pass. The change was merged only after the automated check passed in the cloud.

The rules follow the published standard for how learning platforms describe roles. Once UTSA's test course is ready, the next step is to confirm what Canvas actually sends for each kind of enrollment.


Testing

This prototype is planned for testing with students and instructors at the University of Texas San Antonio (UTSA).