Skip to content

Latest commit

 

History

History
408 lines (363 loc) · 31.8 KB

API.md

File metadata and controls

408 lines (363 loc) · 31.8 KB

API.md — how Edunex Plus uses the Edunex API

The Edunex API (https://api-edunex.cognisia.id) is undocumented and vendor-hosted by Cognisia. Edunex Plus is not an official client: it talks to the same API the Edunex website uses, with the Student's own session, under the guardrails below.

This file is the project's API-usage stance and the record of every Edunex call v2 makes. Any PR that adds or changes an Edunex call must update this file and keep the guardrails true. SIX is covered in SIX.md; ITB's public pages are summed up at the end.

Everything below comes from the v2 code (src/engine/sources/edunex/) and the scrubbed real responses in test/fixtures/edunex/ (file names mirror the request path and query; see docs/test-data.md). Anything not seen in either is marked unconfirmed.

The guardrails

  1. Unofficial. Edunex Plus is an independent, community-built client. It is not an ITB or Cognisia product, and the lowercase-n "Edunex Plus" mark is deliberately distinct from Cognisia's Edunex trademark.
  2. Bring-your-own-session. The app uses the Student's own session. The Student signs in on the real ITB/Microsoft pages in a window the app owns; the password and 2FA code only ever reach Microsoft's page and never touch Edunex Plus.
  3. Read-mostly. Every background call is a GET. The only writes are handing in a Task (file upload, draft save, submit) and a comment under the Student's own answer — see The only writes.
  4. Polite, jittered polling with back-off. One scheduler in the main process; each feed has its own cadence and random jitter (table below), so the app never calls on the dot. The fastest regular feed runs every 2–3 minutes. A failing feed backs off on its own (30 s, 1, 2, 4, 8, then 15 min at most) and never slows the others. Presence alerts are clock math on the windows already read, never extra calls. The screens never call Edunex.
  5. Explicit-only writes. A write fires only on a deliberate click (attach a file, Save draft, Submit, Kirim on a comment). Nothing in a feed or any background path ever writes.
  6. On-device-only storage. The access token is kept only through the OS keychain (Electron safeStorage); where there is no real secure storage it lives in memory until the app quits. Datasets and the alert history stay on this computer. What leaves the device is only what the calls themselves carry. No data sync, no telemetry. (Packaged builds also ask GitHub once a day whether a newer release exists, and when the Student presses "Periksa pembaruan". A problem report, scrubbed, goes to the maintainer's report relay only when the Student sends one or said reports may go by themselves: docs/privacy.md.)
  7. Distinctive User-Agent. Every API call carries EdunexPlus/<version> (+https://github.com/pablonification/edunex-plus) (src/engine/engine.ts). The API client never pretends to be a browser, so Cognisia can recognise — and allowlist or rate-limit — this traffic. (Only the sign-in window and the Edunex window, which show the real ITB, Microsoft and Edunex web pages, use a plain Chrome identity, because some sign-in pages turn away browsers they don't know.)
  8. No presence or read signals. The app never sends Edunex "online", "viewed", presence or "mark read" signals, never calls PATCH /notifications, and never marks attendance. When something must count as attendance, it opens Edunex itself and the Student acts.
  9. Courtesy notice, shipped regardless. Shipping does not wait for permission or a reply: the owner sends Cognisia/ITB a courtesy email describing the project and these guardrails, and offering to coordinate.

Base URL and sign-in

  • API: https://api-edunex.cognisia.id. Every request has a 15 s time limit (src/engine/sources/edunex/client.ts).
  • Capturing the token (src/desktop/signin.ts, src/engine/sources/edunex/signin.ts). The sign-in window opens https://sso-edunex.itb.ac.id/, which goes to Microsoft (2FA included) and back to edunex.itb.ac.id. Every 400 ms, once the window is on edunex.itb.ac.id, the app reads the website's localStorage.auth ({ accessToken, refreshToken, expirationDate, verified, accounts }) and keeps only accessToken, and only if it looks like a JWT. Then it closes the window. There's no time limit on the sign-in itself.
  • The sign-in window runs on a throwaway in-memory browser session with no access to the app (src/desktop/signin-session.ts). It is shared with SIX's sign-in so one Microsoft sign-in can cover both, and is wiped when no longer needed, 5 minutes after the last sign-in window closes, or on quit.
  • Sending it. Every call sends Authorization: Bearer <accessToken>, Accept: application/json and the User-Agent above. API calls go through a separate in-memory Electron session with cookies off (credentials: "omit", src/desktop/transport.ts).
  • The Edunex window (src/desktop/edunex-window.ts, ADR 0017). Every Edunex page the app links to opens in a window of the app on its own in-memory session. Before Edunex's code runs on its first page, the window saves localStorage.auth as { accessToken, expirationDate, verified: true }, the shape the website's sign-in saves (no refresh token: the app has none). The expirationDate is the token's exp, or 12 hours when it has none. That's what the website's initialize and isLoggedIn check. A refused token sends the Student to Edunex's own sign-in there. What the website then requests is its own doing, as in any browser, so it isn't in the call list below. Closing the window, or signing out of Edunex, wipes its session.
  • No refresh. The refresh token is never used and never stored. The saved session is just { token }.
  • What ends a session. A saved token counts as signed in at once and is checked in the background. The liveness feed is edunex.account (GET /login/me). Only a 401 on that feed expires the session: the token is deleted and the Student is asked to sign in again. A 401 anywhere else (another feed, a write) just runs the liveness check right away. On a new sign-in the liveness check runs first; if /login/me names a different Student than the saved data, all edunex.* data is wiped before anything new is stored.

Feeds and cadence

Feed Every (± jitter) Calls
edunex.account (liveness) 10 min ± 1 min /login/me
edunex.notifications 2.5 min ± 30 s /notifications/{userId}, the user id from edunex.account's /login/me
edunex.tasks 15 min ± 2 min, and at once on a new ASSIGNMENT notification /course/tasks once for every course's open Tasks (not on the first read after sign-in), then per Edunex course; /course/courses/{id} for module names (once per session, again at most hourly)
edunex.courses 30 min ± 3 min /course/presences/list
edunex.presence 30 min ± 3 min /course/presences per course, paged
edunex.materials (also the course outline) 1 h ± 6 min /course/courses/{id}, /gradebook (only once published), /course/contents/ per course and per module
edunex.announcements 1 h ± 6 min /course/announcements/course/{id}
edunex.exams 3 h ± 18 min /exam/exams per course
edunex.taskThreads 15 min ± 2 min, and after each edunex.tasks run; not on a manual refresh /course/comments per answer, only where it's due: at once once the answer changed (handed in, handed back, reviewed), hourly while its Task takes answers or something happened to it in the last 3 weeks, otherwise never; and one answer's thread when its Task page opens or the window comes back to it (at most every 30 s), as the website reads it on each visit

Source: feeds.ts, notifications.ts, tasks.ts, task-threads.ts, course-page.ts; scheduling in src/engine/sync/scheduler.ts. A start, a sign-in and the manual refresh run each source's feeds in turns (FeedSpec.priority): first what Beranda shows for today and what's due (edunex.account, edunex.courses, edunex.tasks, edunex.presence), then the rest, then edunex.materials and edunex.taskThreads (a feed already running is not started twice). The Tasks come in two steps: first one call for the open ones of every course (see the /course/tasks note), laid over the saved list and stored at once; then each course's whole list, which waits behind the other feeds' calls in Edunex's line and is stored as the full set. The module names come after, from the outlines. On the phone, a pull to refresh leaves edunex.materials alone when it was read in the last 30 minutes (a new material is read at once on its notification); the desktop's refresh reads it. Every call to Edunex's API, a feed's or the Student's, waits in one line that lets at most 2 through at once (src/engine/http/pace.ts, SITE_LIMITS); what the Student just did (a hand-in, a comment) goes ahead of the feeds' calls. Within a feed, calls go one after another, except a course's /course/contents/ calls, which are asked four at a time, as the Edunex website does, and still go two at a time through the line. "Per course" always means the class's own Edunex course and its parent course.

Request budget for the Tasks. Each edunex.tasks run asks /course/tasks once per Edunex course (6 calls for the recorded term), plus exactly 1 for the open Tasks of all of them: 1 call more per run (every 15 minutes, on a new-Task notification, a start or a refresh), and none on the first read after sign-in. Module names add /course/courses/{id} per course at most hourly, as before.

Endpoints

All GET unless noted. Only the fields listed are read; extra fields are ignored, and a missing or mistyped field the app relies on is a vendor change (see Errors).

Call Query sent Fields used
/login/me none id (user id), name, code (the NIM)
/notifications/{userId} none data.notifications[]: type, title, objectId, date, message
/course/presences/list none course_id, course_code, courses_name, class_id, class_name, semester, year
/course/tasks filter[course_id][is]={courseId}, page[limit]=0; or, for the open Tasks, filter[course_id][in]={id},{id},…, filter[end_at][gte]={WIB time}, page[limit]=0 meta.total; per Task id, taskable_type, taskable_id, course_id (the open Tasks' call only), course_name, type, tasks_type, name, description, files[{name,file}], start_at, end_at, created_at, updated_at, open_status, file_required, is_lateable, domain, show_score, answers[]: id, answer, files, score, is_sent, sent_at, created_at, updated_at, verified_at, comment
/course/courses/{courseId} include=modules,modules.activities,lecturer,lecturer.user,assistant,class lecturer, credit, gradebook_publish; included[] of type modules: id, course_id, index, name, is_active, created_at
/gradebook course_id={courseId}, class_id={classId} students[]: code, total, index
/course/contents/ filter[contentable_id][is]={id}, filter[contentable_type][is]=App\Models\Courses or App\Models\Modules, sort=index, page[limit]=0 id, contentable_type, contentable_id, name, type, content, size, created_at, updated_at
/course/presences filter[course_id][is], filter[class_id][is], sort=start_at, page[limit]=10, page[offset] meta.total; course_id, class_id, start_at, end_at, presence_start, presence_end, topic, note, presentable[{presentable, presentable_id}], url, attandance{status, presence_at}
/course/announcements/course/{courseId} none id, announcement, created_at, creator.name
/exam/exams filter[course_id][is]={courseId}, page[limit]=0 data[].id; from attributes, if present: name or title, start_at, end_at
/course/modules/{moduleId} include= (empty, as the website sends it) data.attributes.name; only right before an upload
/course/comments include=user, filter[commentable_type][is]=task_answer, filter[commentable_id][is]={answerId}, sort=-created_at, page[limit]=0, page[offset]=0 id; comment, created_at, files[{name or file_name, file}], user{name, username, level}

Notes:

  • /login/me is the liveness check and the Student's identity (code holds the NIM). A lecturer's answer says level: "LECTURER" and has no code: Edunex waits with "this account isn't a student's", not a change (#345).
  • /notifications/{userId} is the new-item signal. Only ASSIGNMENT (new Task) and CONTENT (new material) are kept; other types are skipped. The course name is taken from the message ("… has been added new … in {course}"). The bare /notifications path is not used.
  • /course/presences/list gives this term's course and class pairs. The class number comes from class_name ("{code}-01" → "01"); the term is {year}-{semester}.
  • /course/tasks: page[limit]=0 means "all". If fewer Tasks arrive than meta.total says, that's a vendor change, never a silently short list. One course failing keeps that course's last known Tasks and reports the error; going offline or a 401 stops the whole run. The error names the path only, not the course, so the answer that failed travels with it (AnswerError): a problem report keeps that course's list, not the last one read.
  • The open Tasks, in one call. Edunex's time on /course/tasks grows with the Tasks it returns (about 0.9 s per Task; an empty list takes about 60 ms), so on the recorded timings the six whole lists kept the Tasks due waiting about 6 s after a phone's start (test/engine/sync-speed.test.ts). Probed on the real API (GETs only, 2026-11-10): filter[course_id][in] takes the ids joined by commas and returns the same Tasks and meta.total as one call per course, but no faster (3 courses: 4.5 s, against 1.9 + 1.0 + 1.9 s). With filter[end_at][gte] as well, all 6 courses answered 2 of the 10 Tasks in 1.07 s. The time is sent as Edunex's own clock reads it, WIB with no zone (2026-11-09 08:12:00, wibTime in task-records.ts), a day before now: sent in UTC, the answer held Tasks due before it, which is what reading it as WIB gives, and a day more covers any other reading. A Task with no deadline isn't in it. So each run first asks this once for every course (child and parent), lays what comes over the saved list (each returned Task replaced, the rest kept as saved: one closed, moved or removed since stays as it was until the whole lists, the truth, come next) and stores it. A Task is placed in its course as the saved list has it, else by its course_id. On the first read after sign-in there's no saved list, so it isn't asked: a part of the list would read as all of it (and its new-Task alerts). Its failing, but for no network or an ended session, only skips it, unreported: the whole lists follow. Handing in still reads its Task back through its own course's list.
  • An answer handed back. The lecturer's "Revision Request" (setAnswerChangeRequest in the website's js/app.79bf84f4.js, the button in js/assignment/detail-lecturer.c85d7075.js) sends PATCH /course/task/answers/{id} with { is_sent: 0, comment }. Recorded on a real one (course-tasks.include-classes-answers.json, answer 2798141): is_sent 0, sent_at still the first hand-in's, verified_at and updated_at the moment it was handed back, sent_by the lecturer's user id, comment left as it was (null there). So the app reads an unsent answer with a verified_at as handed back ("Dikembalikan"): a draft the Student only saved has none. comment is the lecturer's note on the answer ("Catatan dosen"): grading ("Save Result", updateScore) writes it too, and nothing on the Student's side of the website does.
  • verified_at can be missing. A Student's report (0.1.0-alpha.26) had an answer with no verified_at key at all, its other fields as usual. The app reads it as null (not looked at yet), so the Task still shows. The other answer fields stay required: a missing one is still a change.
  • A Task's files can be null. Students' reports (0.1.0-alpha.24 to 0.1.0-alpha.28) had a Task with files: null where others have [], its other fields as usual. The app reads it as no files, so the course's Tasks still show.
  • /course/comments is the thread under an answer, the website's "Comment / Feedback" box (ContentAssignmentReply, every message at once with page[limit]=0, newest first). A lecturer's feedback is often here, not in comment: on the recorded hand-back it was a message written three seconds before. A message doesn't change the answer, and no notification type is known for one, so the thread has its own feed. level STUDENT is the Student (their username is the NIM) or a groupmate; anything else is staff. Files on a message (the lecturer's annotated-PDF tool posts one) were never recorded with a message; the website shows name, else the link's last part.
  • /course/presences is paged 10 at a time (the website's page size). Edunex's "next" link never ends on its own, so paging stops at meta.total or an empty page. presence_start/ presence_end are the real window (falling back to start_at/end_at); presentable and url say which action counts; attandance.status 1 means present.
  • /course/contents/ is the materials list (type such as pdf, Vicon links, text). A size of 0 or missing is shown as unknown. Downloading a file is an ordinary browser download of its link (src/desktop/downloads.ts, allowed only for Edunex's Azure storage, the API host and itb.ac.id), on an explicit click; no token is attached.
  • /exam/exams: no exam was ever recorded (the account had none), so only the envelope and id are required; the other field names are a guess. Tugas & Ujian reads start_at/end_at as the time it's open: open longer than 24 h it's due at its close, with "Tandai selesai", which is kept by the exam's id and that window. Check both against a real exam list.
  • Seen in recordings but not called by v2: /todo (no submit status, and its times are WIB marked as UTC), /course/agenda (Task deadlines with no timezone), /course/tasks/{id}?include=answers (a Task is read back through its course's list instead), /message/unread, /public/*, /course/lptks/*. /course/modules/{id} is read only right before an upload, as the website reads it (see The only writes). /course/materials does not exist; /rps/v1/rps answers 403 for Students. No sockets are used.

Timestamps

Edunex sends times in four formats. Two functions read them, both called edunexTime: task-records.ts (Tasks and answers; strict, an unreadable time is a vendor change) and course-page.ts (everything on the course pages; lenient, an unreadable time is "unknown", except Presence start_at/end_at, which must be readable).

Format Example Where Handling
With offset 2026-09-17T12:00:00+07:00 Task start_at/end_at/created_at/updated_at; course and module records; Presence start_at, end_at, presence_start, presence_end; content created_at/updated_at Taken as written
Naive, WIB 2026-09-16 16:15:33 Answer sent_at/created_at/updated_at/verified_at; attandance.presence_at; announcement created_at; /course/agenda; /login/me dates Read as UTC+7 by both edunexTime functions
WIB wrongly suffixed Z 2026-10-22T23:50:00.000Z /todo time; /gradebook created_at/updated_at Avoided: v2 never reads these fields. If one is ever read, course-page.ts's edunexTime would take the Z literally and be 7 hours off
Real UTC 2026-09-15T03:54:44.000Z /notifications date Date.parse as is (notifications.ts)

Other quirks the code handles

  • Placeholder grade. Until the lecturer publishes, /gradebook says total: 0, index: "E" for everyone. The app asks for it only when the course says gradebook_publish: true, and even then never shows 0 · E as a grade (course-page.ts). The Student's row is found by code = NIM (or the only row).
  • Placeholder score. Answers carry score: 0 until graded. A score shows only when the Task has show_score, the answer is handed in, and either the score isn't 0 or the answer has verified_at (task-records.ts).
  • Parent and child classes. /course/presences/list lists a class's parent course ("… [Parent Class]") as a separate pair with the same course code and class. Both are kept on one course (child first) and every per-course call reads both (feeds.ts).
  • Tasks edited after posting. Edunex moves only updated_at. A change more than an hour after posting, or any change after the Student handed in, counts as an edit (editedAt in task-records.ts). The notification feed misses many Tasks, so the Tasks feed also runs on its own cadence. Edunex never says what changed, so whenever editedAt moves the app compares the copy it kept with the new one (storeTasks, for the Tasks feed and the hand-in readback alike) and keeps the differences per edit in edunex.taskEdits (src/core/task-edits.ts): the deadline, the opening, the instructions by their text (read out of the HTML by instructions-text.ts, so markup alone isn't a change), the files by link, the title, the late and file rules, group and UTS/UAS. Not compared, as they move without an edit: open_status, the answer, the score, the module. Raw fields the app doesn't read (rubrics, passing_grade, weights) move updated_at too: such an edit is noted with no changes. With no earlier copy (the first sync after signing in) nothing is noted, and the screens say what changed isn't known. The app takes Edunex closing a Task at its deadline not to move updated_at, as the pretend Edunex does; that hasn't been seen on a real account.
  • Submit status. is_sent alone decides (0/1, "0"/"1" or a boolean; anything else is a vendor change). sent_at is stamped on drafts too, so it counts only when is_sent is set. With several answers on one Task, the handed-in one wins, else the latest draft.
  • Flags come as booleans or 0/1. open_status overdue means no more answers; close or closed means not open yet (the website says "You can answer this question on {start_at}"), so the app judges that by start_at (website code: task-reader.2eb63cbd.js, module cef2). domain is the lecturer's category, read in any case: uts and UAS (as the lecturer's form stores them) mark a take-home exam Task. taskable_type: "modules" ties a Task to a module.
  • Presence links. presentable can list several things that count (two Tasks, a Task and a module); every one is read. url holds one link per chosen topic joined with ; (the lecturer's form in app.79bf84f4.js); the first is the page to open.
  • Switched-off modules (is_active false) are hidden, as on the website.
  • A different Student signing in on the same computer wipes the previous one's data first.

The only writes

Task Answers (the "saved ≠ submitted" surface) and their files, and a comment under the Student's own answer (ADR 0016), and nothing else. All in src/engine/sources/edunex/hand-in.ts. Each runs only from an explicit click, one at a time per Task (a second click waits, then re-reads).

From the website's code, not a live recording. The recorder blocks writes, so these requests copy what Edunex's own website sends, read from its public JavaScript (fetched 2026-10-12 without signing in): the answer form ContentTaskAnswer (getFilePath, onFilesAdded, onProcessing, onSuccess, saveData, submit) in js/components/content/reader/task-reader.2eb63cbd.js, and the task store's answerCreate, answerUpdate and answerSend in js/app.79bf84f4.js. If Edunex ships new code, check these again. One real hand-in on a throwaway Task is still the only proof.

What Edunex takes. The website's uploader accepts .pdf .doc .docx .xls .xlsx .ppt .pptx .zip .rar .jpg .jpeg .png; the app refuses anything else before sending it, and anything over 100 MB (the uploader's own maxFileSize: 100; note that Dropzone reads maxFilesize, so the website itself may let bigger files through). A group Task (tasks_type: "GROUP", or a type other than PERSONAL) is handed in through the website's group pages (/course/task/answer/groups); the app never writes to it and sends the Student to Edunex.

Upload a file (on attach):

  1. Reads, as the website's Task page does: the course's Task list (for course_name, taskable_type, taskable_id and the type), GET /course/modules/{taskable_id}?include= (the module's name), and GET /login/me (the Student's user id). Without course_name, GET /course/courses/{course_id} gives the course's name.
  2. POST /blob-storage/sas with { "files": [{ "fileName", "contentType", "sizeInBytes" }] }. fileName is the storage path the website builds: {year}/{course_id}-{course name}/{module id}-{module name}/task/{user id}/{ms}_{file name}, whitespace as - and the file's extension left off (the module part only for a Task in a module). The reply is { "files": { "<that path>": { "uploadUrl", "readUrl" } } }; both links must be https://…blob.core.windows.net. Anything else is a vendor change.
  3. PUT {uploadUrl} with the file bytes, x-ms-blob-type: BlockBlob, Content-Type (the file's type), Content-Disposition: inline and the User-Agent. Edunex's token is never sent to storage. Time limit: 1 min plus 1 s per 50 KB, 30 min at most.

Save draft ("Save Answer" on the website):

  1. Read the Task back (GET /course/tasks for its course). Stop if it's gone, already handed in, not open yet, closed, or a group Task.

  2. One request with the text and every file:

    • no answer yet: POST /course/task/answers,
    • else: PATCH /course/task/answers/{answerId},

    both with { "data": { "attributes": { "task_id", "files", "answer", "is_sent": 0 } } }. files is the full list the draft should hold, as the website sends it: Edunex's own record (as read, with its id) for each file kept, { "file": readUrl, "name" } for a new one; only links on Edunex's storage. answer is the answer's text (HTML). Text the Student wrote in the app is cleaned to the plain formatting CKEditor writes (p br strong em u s a[href] ul ol li blockquote h2–h4 code pre, no other attribute), because Edunex shows answers to lecturers without cleaning them. Text the Student didn't change goes back exactly as Edunex has it (a website draft with pictures or tables stays whole). As on the website ("Text is required"), an answer without text is refused before anything is sent.

  3. Read back. "Saved" only if Edunex now holds exactly those files in an unsent answer; otherwise "unconfirmed".

Submit:

  1. Read back and check as above; a Task with file_required needs a file.
  2. If the answer doesn't hold exactly the chosen files, save the draft first (steps above).
  3. PATCH /course/task/answers/{answerId} with exactly { "data": { "attributes": { "is_sent": 1 } } }.
  4. DELETE /blob-storage//task/{taskId}/export (the double slash is the website's), with no body. This clears the lecturer's cached "download all answers" file so it's built again with this answer in it. Best effort, as on the website: any failure is ignored and never fails the submit.
  5. Read back. "Submitted" only when is_sent is 1; otherwise "unconfirmed". There is no resubmit.

Comment (Kirim under the answer, the website's "Add Comment", createAnswerComment in js/app.79bf84f4.js):

  1. Read the Task back. Stop if it's gone, a group Task, or has no answer yet (the thread hangs off the answer). Edunex takes a comment whatever else the Task's state is (handed in, handed back, closed), as the website shows its box.
  2. POST /course/comments with { "data": { "attributes": { "comment", "commentable_id": answerId, "commentable_type": "task_answer" } } }. comment is the text, cleaned as an answer's is; one without words is refused before anything is sent. No files (the website's box for a Student has none) and no reply-to (its form never sends one).
  3. Read the thread back. "Sent" only when it holds the message as the Student's; otherwise "unconfirmed".

Writes with a body send Content-Type: application/json. Replies are not parsed beyond the status, except the upload links: every write is confirmed by reading the Task (a comment, its thread) back. There are no other POST, PATCH, PUT or DELETE calls to Edunex.

What's confirmed live: the submit body (v1, issue #12) and creating an answer (v1). Everything else above comes from the website's code. A draft saved on Edunex shows to the lecturer as "Answered" (the lecturer's answer list in js/assignment/detail-student.819acb73.js), so the app never calls a draft private.

Errors

Every Edunex reply maps to one error kind (client.ts for reads, write in hand-in.ts):

What happened Kind Effect
No answer, timeout, connection failure Offline Source shows offline; the feed backs off
401 Unauthorized On /login/me (liveness feed): session expires. Elsewhere: runs the liveness check
429 or 5xx Offline Same back-off; no Retry-After handling for Edunex
Other 4xx on a read Failed Source shows "changed" with the detail
Other 4xx on a write Rejected The click fails; if the Task closed meanwhile, the app says so instead
Not JSON, or a shape the schema rejects VendorChanged Source shows "Edunex changed something"; never an empty screen
Storage PUT not 2xx Failed The upload fails

A source's status is the worst of its feeds' latest outcomes. Back-off is per feed (scheduler.ts): 30 s after the first failure, doubling to 15 min at most, plus a little jitter; one success resets it. Edunex's line lets 2 calls through at once, with no gap (SIX's lets one, 2 s apart; see SIX.md).

Unconfirmed / not yet recorded

  • Every hand-in request, and the comment, is taken from the website's code, not seen live (see above); the replies to the writes other than the upload links were never seen.
  • Whether the API itself refuses an answer with no text (the website never sends one).
  • Whether a second create-answer call for the same Task makes a duplicate (the app avoids it either way by re-reading first).
  • What /gradebook looks like once a lecturer publishes.
  • Exam records: none recorded, so their field names are a guess.
  • Whether signing in on the Edunex website ends the app's token, and how long tokens live (a month-old token was still valid).
  • Announcement times: only one was recorded (naive WIB); the reader accepts an offset too.
  • Edunex's rate limits: no 429 has been seen.
  • How Edunex compares filter[end_at][gte]: in WIB, as its answers suggest (see the /course/tasks notes). The app sends the time a day early, so either way no open Task is missed.
  • Files on a message in an answer's thread (/course/comments): every recorded message had none.
  • Whether a lecturer's message or hand-back sends the Student a notification of its own: none was seen, so the app reads the thread itself.

Other sites

  • SIX (six.itb.ac.id): signed-in pages and the public curriculum catalog, at most one page every 2 s, with a pause on 429. See SIX.md.
  • ITB academic calendar: the public iCalendar feed https://goitb.id/KalenderPendidikan-ics (linked from SIX's home page), read once a day (src/engine/sources/itb/calendar.ts).
  • GitHub: one daily check for a newer release, packaged builds only.

Any new endpoint must land here first, verified against a recording, before the client calls it.