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.
- 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.
- 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.
- 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. - 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.
- 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.
- 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.)
- 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.) - 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. - 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.
- 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 openshttps://sso-edunex.itb.ac.id/, which goes to Microsoft (2FA included) and back toedunex.itb.ac.id. Every 400 ms, once the window is onedunex.itb.ac.id, the app reads the website'slocalStorage.auth({ accessToken, refreshToken, expirationDate, verified, accounts }) and keeps onlyaccessToken, 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/jsonand 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 saveslocalStorage.authas{ accessToken, expirationDate, verified: true }, the shape the website's sign-in saves (no refresh token: the app has none). TheexpirationDateis the token'sexp, or 12 hours when it has none. That's what the website'sinitializeandisLoggedIncheck. 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 a401on that feed expires the session: the token is deleted and the Student is asked to sign in again. A401anywhere else (another feed, a write) just runs the liveness check right away. On a new sign-in the liveness check runs first; if/login/menames a different Student than the saved data, alledunex.*data is wiped before anything new is stored.
| 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.
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/meis the liveness check and the Student's identity (codeholds the NIM). A lecturer's answer sayslevel: "LECTURER"and has nocode: Edunex waits with "this account isn't a student's", not a change (#345)./notifications/{userId}is the new-item signal. OnlyASSIGNMENT(new Task) andCONTENT(new material) are kept; other types are skipped. The course name is taken from the message ("… has been added new … in {course}"). The bare/notificationspath is not used./course/presences/listgives this term's course and class pairs. The class number comes fromclass_name("{code}-01" → "01"); the term is{year}-{semester}./course/tasks:page[limit]=0means "all". If fewer Tasks arrive thanmeta.totalsays, 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 a401stops 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/tasksgrows 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 andmeta.totalas one call per course, but no faster (3 courses: 4.5 s, against 1.9 + 1.0 + 1.9 s). Withfilter[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,wibTimeintask-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 itscourse_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" (
setAnswerChangeRequestin the website'sjs/app.79bf84f4.js, the button injs/assignment/detail-lecturer.c85d7075.js) sendsPATCH /course/task/answers/{id}with{ is_sent: 0, comment }. Recorded on a real one (course-tasks.include-classes-answers.json, answer 2798141):is_sent0,sent_atstill the first hand-in's,verified_atandupdated_atthe moment it was handed back,sent_bythe lecturer's user id,commentleft as it was (null there). So the app reads an unsent answer with averified_atas handed back ("Dikembalikan"): a draft the Student only saved has none.commentis 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_atcan be missing. A Student's report (0.1.0-alpha.26) had an answer with noverified_atkey 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
filescan be null. Students' reports (0.1.0-alpha.24 to 0.1.0-alpha.28) had a Task withfiles: nullwhere others have[], its other fields as usual. The app reads it as no files, so the course's Tasks still show. /course/commentsis the thread under an answer, the website's "Comment / Feedback" box (ContentAssignmentReply, every message at once withpage[limit]=0, newest first). A lecturer's feedback is often here, not incomment: 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.levelSTUDENTis the Student (theirusernameis 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 showsname, else the link's last part./course/presencesis paged 10 at a time (the website's page size). Edunex's "next" link never ends on its own, so paging stops atmeta.totalor an empty page.presence_start/presence_endare the real window (falling back tostart_at/end_at);presentableandurlsay which action counts;attandance.status1means present./course/contents/is the materials list (typesuch aspdf, Vicon links,text). Asizeof 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 anditb.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 andidare required; the other field names are a guess. Tugas & Ujian readsstart_at/end_atas 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'sidand 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/materialsdoes not exist;/rps/v1/rpsanswers 403 for Students. No sockets are used.
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) |
- Placeholder grade. Until the lecturer publishes,
/gradebooksaystotal: 0,index: "E"for everyone. The app asks for it only when the course saysgradebook_publish: true, and even then never shows 0 · E as a grade (course-page.ts). The Student's row is found bycode= NIM (or the only row). - Placeholder score. Answers carry
score: 0until graded. A score shows only when the Task hasshow_score, the answer is handed in, and either the score isn't 0 or the answer hasverified_at(task-records.ts). - Parent and child classes.
/course/presences/listlists 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 (editedAtintask-records.ts). The notification feed misses many Tasks, so the Tasks feed also runs on its own cadence. Edunex never says what changed, so whenevereditedAtmoves 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 inedunex.taskEdits(src/core/task-edits.ts): the deadline, the opening, the instructions by their text (read out of the HTML byinstructions-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) moveupdated_attoo: 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 moveupdated_at, as the pretend Edunex does; that hasn't been seen on a real account. - Submit status.
is_sentalone decides (0/1,"0"/"1"or a boolean; anything else is a vendor change).sent_atis stamped on drafts too, so it counts only whenis_sentis set. With several answers on one Task, the handed-in one wins, else the latest draft. - Flags come as booleans or 0/1.
open_statusoverduemeans no more answers;closeorclosedmeans not open yet (the website says "You can answer this question on {start_at}"), so the app judges that bystart_at(website code:task-reader.2eb63cbd.js, modulecef2).domainis the lecturer's category, read in any case:utsandUAS(as the lecturer's form stores them) mark a take-home exam Task.taskable_type: "modules"ties a Task to a module. - Presence links.
presentablecan list several things that count (two Tasks, a Task and a module); every one is read.urlholds one link per chosen topic joined with;(the lecturer's form inapp.79bf84f4.js); the first is the page to open. - Switched-off modules (
is_activefalse) are hidden, as on the website. - A different Student signing in on the same computer wipes the previous one's data first.
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):
- Reads, as the website's Task page does: the course's Task list (for
course_name,taskable_type,taskable_idand the type),GET /course/modules/{taskable_id}?include=(the module'sname), andGET /login/me(the Student's userid). Withoutcourse_name,GET /course/courses/{course_id}gives the course'sname. POST /blob-storage/saswith{ "files": [{ "fileName", "contentType", "sizeInBytes" }] }.fileNameis 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 behttps://…blob.core.windows.net. Anything else is a vendor change.PUT {uploadUrl}with the file bytes,x-ms-blob-type: BlockBlob,Content-Type(the file's type),Content-Disposition: inlineand 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):
-
Read the Task back (
GET /course/tasksfor its course). Stop if it's gone, already handed in, not open yet, closed, or a group Task. -
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 } } }.filesis the full list the draft should hold, as the website sends it: Edunex's own record (as read, with itsid) for each file kept,{ "file": readUrl, "name" }for a new one; only links on Edunex's storage.answeris 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. - no answer yet:
-
Read back. "Saved" only if Edunex now holds exactly those files in an unsent answer; otherwise "unconfirmed".
Submit:
- Read back and check as above; a Task with
file_requiredneeds a file. - If the answer doesn't hold exactly the chosen files, save the draft first (steps above).
PATCH /course/task/answers/{answerId}with exactly{ "data": { "attributes": { "is_sent": 1 } } }.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.- Read back. "Submitted" only when
is_sentis 1; otherwise "unconfirmed". There is no resubmit.
Comment (Kirim under the answer, the website's "Add Comment", createAnswerComment in
js/app.79bf84f4.js):
- 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.
POST /course/commentswith{ "data": { "attributes": { "comment", "commentable_id": answerId, "commentable_type": "task_answer" } } }.commentis the text, cleaned as an answer's is; one without words is refused before anything is sent. Nofiles(the website's box for a Student has none) and no reply-to (its form never sends one).- 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.
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).
- 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
/gradebooklooks 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
429has been seen. - How Edunex compares
filter[end_at][gte]: in WIB, as its answers suggest (see the/course/tasksnotes). 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.
- SIX (
six.itb.ac.id): signed-in pages and the public curriculum catalog, at most one page every 2 s, with a pause on429. 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.