Skip to content
iblaiPublic

About

No description, website, or topics provided.

Resources

Contributing

Stars

1 star

Watchers

0 watching

Forks

Latest commit

 

History

32 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

ibl.ai

ibl.ai/sis

The open-source student information system for schools on the ibl.ai platform.

Students, staff, courses, grades, credentials, reports and messages — for every school platform you belong to, with ibl.ai single sign-on built in. One codebase. Your platform, your data, your rules.

Join About Docs License: MIT SOC 2 Type II Next.js


⬇️ Get ibl.ai/sis

Web — sis.ibl.ai, coming soon   macOS — coming soon   Windows — coming soon

iOS — coming soon   Android — coming soon

Hosted web app and published builds coming soon · today: run it locally or deploy it yourself · how builds are made


Why ibl.ai/sis · Every platform · Features · Case studies · Screenshots · Quick Start · Deployment · Architecture


SOC 2 Type II  ·  Universities, enterprises, and governments run on ibl.ai — read the case studies →


Why ibl.ai/sis

🔓 Your code, your data MIT-licensed and self-hostable. Everything lives in your ibl.ai platform — the Data Manager, the learning platform and Studio — through their existing APIs. No second database, no vendor lock-in.
🏫 One platform per school Sign in once with ibl.ai SSO and switch between every school platform you belong to, exactly like os.ibl.ai. Each platform gets its own students, courses, terms and roles.
📚 A course is a course run Every course here is an Open edX course run for a term: the roster, the gradebook, the teachers and the course email are the learning platform's own; the school adds the term, subject, room, period and credits.
🧭 The openSIS shape Students and staff, school setup (years, terms, grade levels, periods, rooms, subjects), scheduling, grades and GPA, credentials and certificates, reports, messaging, bulk import — on ibl.ai.
🌍 Four languages English, Spanish, French and Chinese, following the language you chose in any other ibl.ai app.
🔐 Enterprise-ready SSO (OAuth / OIDC / SAML via the platform), platform roles, notifications, invitations that make a learner a platform user.

Every platform, one codebase

ibl.ai/sis meets your school wherever it is — the same product, native everywhere.

Platform Status
Web 🌐 Coming soon at sis.ibl.ai — today, run it locally or deploy it yourself
macOS 🍎 Native app (universal .dmg, Intel + Apple Silicon) — built by the release workflow; downloads coming soon
Windows 🪟 Native app (x64 + ARM64 installer) — built by the release workflow; downloads coming soon
Linux 🐧 Native app (AppImage) — built by the desktop build workflow; downloads coming soon
iOS 📱 Native app — built by the iOS workflow; App Store listing coming soon
Android 🤖 Native app — built by the Android workflow; Google Play listing coming soon

The native apps are Tauri 2 WebView shells around the hosted app (src-tauri/, the URL in src-tauri/tauri.conf.json) — point them at your own deployment the same way (docs/development.md). They are built like iblai/os and iblai/recruit: signed macOS and Windows releases on an app-v* tag, unsigned desktop, iOS and Android builds on demand.


Features

👥 Students & staff

  • Directory — every student of the platform with email and join date; search by username or email, server-side; invite one, or import a CSV straight into a course (new emails get an account when the platform allows it)
  • Student record — the platform's demographics plus the school's own fields (student id, grade level, enrollment status, homeroom, guardians, emergency contacts…); changing the grade level moves the student between cohort groups
  • Enrollment — a student's courses from the learning platform with grade and completion; enroll by course invitation
  • Grades — per course: percent, letter, passing, graded work; a term GPA on the school's scale and credits
  • Credentials — issue and revoke the platform's credentials; generate the learning platform's certificates
  • Guardians — platform users who receive copies of the student's notifications
  • Staff — teachers and admins; make someone a teacher (the LMS org-staff role) or a platform admin

📚 Courses & setup

  • Courses — the platform's course runs joined with term, subject, grade level, room, period, credits and seats; filters by term, subject and level
  • New course — rerun an existing course into a term (Studio); the dates follow the term
  • Roster — the instructor API's roster; enroll an existing member, import, export CSV, email
  • Gradebook — the grid of learners × graded subsections with overrides and their history, or the embedded gradebook when the platform keeps the API closed
  • Settings — term and dates, grading policy and letter cutoffs (Studio), teachers (course roles), the course's own data
  • Groups — homerooms and cohorts as platform user groups; bulk add by username; announce
  • Setup — school, years and terms, grade levels with cohort groups, periods, rooms, subjects, the student-record fields (seed the defaults, export, import)

📊 Operate

  • Dashboard — the members count, courses, active learners, average grade, enrollments over time, most active courses
  • Reports — the platform's reports (run, poll, download) and a course's instructor downloads
  • Messages — course email through the learning platform (with scheduling) and platform announcements (everyone, a group, named users)
  • ⌘K — students, staff and courses from anywhere; create anything

Case studies

Universities, enterprises, and government agencies build on ibl.ai — deploying agents on their own infrastructure, with their own models, at a fraction of the cost of closed platforms.

Read the case studies →


Screenshots

Screenshots of a seeded school are on their way — run pnpm screenshots --org <demo platform key> to regenerate them into docs/images/ (see docs/development.md).


Quick Start

git clone https://github.com/iblai/sis.git
cd sis
pnpm install --ignore-scripts
pnpm dev

Using Claude Code? Read AGENTS.md first.

No configuration is required against hosted iblai.app: the service URLs default in lib/iblai/config.ts. Copy .env.example to .env.local only to point at a self-hosted platform.

Open http://localhost:3000. You are sent to login.iblai.app to sign in and come back to /platform/<your platform> — the school your account administers. A user whose only platform is the community one gets its trial-gated shell there; an admin's first visit opens the setup flow. See the full Development Guide for sign-in, the three backends, the LMS probe and the release.

Node.js 22+ and pnpm 12 (corepack enable picks the pinned version up from package.json).

Scripts

Command What it does
pnpm dev Dev server on port 3000
pnpm build Production build (standalone output)
pnpm start Serve the production build
pnpm typecheck TypeScript 7
pnpm lint oxlint, zero warnings
pnpm format oxfmt (pnpm format:check in CI)
pnpm i18n:check Same keys in the four catalogs; no “tenant”, “pupil” or “class period”; no ASCII apostrophe; English labels Title Case
pnpm test Vitest unit tests (pnpm test:coverage in CI: 95 % lines on lib/)
pnpm test:e2e Playwright journeys on a throwaway platform, Chromium and the phone project (needs e2e/.env.development)
pnpm test:e2e:all The same journeys in every browser (their builds installed with pnpm exec playwright install)
pnpm e2e:accounts Creates the two Playwright test accounts (a platform admin and a student) in the throwaway platform iblai.env names
pnpm e2e:coverage The checkpoint ledger's gate: ids ↔ titles, every page visited, the journeys reaching 95 % of the app's lines (pnpm test runs it too)
pnpm probe:lms Which learning-platform capabilities this platform really exposes (docs)
pnpm release release-it: version from the commits, CHANGELOG, tag, GitHub Release (CI runs it on every push to main)
pnpm tauri:dev / tauri:build Desktop shell (needs Rust); pnpm tauri:dev:ios / tauri:dev:android for a simulator or emulator
pnpm shell:smoke / shell:smoke:windows The shell headless against a local page: the navigation guard and both sign-in returns (CI runs the Linux one on every shell change)
pnpm shell:touch / shell:touch:windows / shell:touch:ios / shell:touch:android The built shell on this machine (Linux, macOS, Windows), on an iOS simulator or on an Android phone, with the touch-test checklist (docs)
pnpm shell:clear [android, ios] / shell:clear:windows Forgets the shell's cookies, localStorage and caches on this machine, the phone or the simulator, so the next touch test starts signed out

Deployment

ibl.ai/sis is a front end for the ibl.ai platform. The platform provides sign-in, platforms, roles, notifications, the learning platform and Studio; this repository provides the app.

Option A: Hosted ibl.ai platform

  1. Build and run with Node

    pnpm build
    cp -r public .next/standalone/ && cp -r .next/static .next/standalone/.next/
    PORT=3000 node .next/standalone/server.js

    The build is a standalone server, so next start does not apply; the two copies are what the Dockerfile does. On Vercel nothing of this is needed: the project builds the regular Next.js output (vercel.json pins the preset) and only wants ENABLE_EXPERIMENTAL_COREPACK=1 so pnpm 12 is used.

  2. Or run with Docker

    docker build -t iblai-sis .
    docker run -p 3000:3000 iblai-sis

    NEXT_PUBLIC_* values are inlined at build time and .env* files stay out of the image, so a self-hosted platform passes its URLs as build arguments: --build-arg NEXT_PUBLIC_API_BASE_URL=https://api.example.com --build-arg NEXT_PUBLIC_AUTH_URL=https://login.example.com --build-arg NEXT_PUBLIC_PLATFORM_BASE_DOMAIN=example.com (omit them for hosted iblai.app).

  3. Register the origin. Every origin the app runs on (http://localhost:3000, https://sis.example.com) must be an allowed redirect origin of the platforms that sign in, or the Auth SPA never returns. Ask your ibl.ai operator.

Option B: Self-hosted platform

Set the service URLs in .env.local for pnpm dev and pnpm build, or as Docker build arguments (above); see Configuration. If you need the full backend, reach out at ibl.ai/contact for an enterprise license and deploy it with iblai/iblai-infra-cli.


Configuration

All app config is NEXT_PUBLIC_* and optional against hosted iblai.app. Defaults live in lib/iblai/config.ts.

Variable Default Description
NEXT_PUBLIC_API_BASE_URL https://api.iblai.app Consolidated API; /dm, /lms, /studio and /axd are derived from it
NEXT_PUBLIC_AUTH_URL https://login.iblai.app The hosted Auth SPA
NEXT_PUBLIC_PLATFORM_BASE_DOMAIN iblai.app Base domain; with no API base, services resolve to their own subdomains
NEXT_PUBLIC_MFE_URL https://apps.learn.iblai.app The Open edX micro-frontends (the embedded gradebook)
NEXT_PUBLIC_LMS_APP_URL https://lms.ibl.ai The learner app, where "Open in the Learning Platform" lands
NEXT_PUBLIC_MAIN_TENANT_KEY main The community platform — the trial-gated shell for a user who belongs to nothing else
NEXT_PUBLIC_IBL_PLATFORM mentor app= sent to the Auth SPA (the OS's value, so every platform signs in)
NEXT_PUBLIC_ENABLE_RBAC false Gate SDK admin surfaces on RBAC policies as well as the admin flag
NEXT_PUBLIC_TAURI_CUSTOM_SCHEME iblai-sis Deep-link scheme the native shells return through after SSO

Architecture

sis/
├── app/
│   ├── page.tsx · [...legacy]/              # a path without a platform → /platform/<the user's platform>/…
│   ├── platform/[tenantKey]/                # everything inside one school platform
│   │   ├── layout.tsx                       # sidebar + top bar shell, access gate, the `main` notice
│   │   ├── page.tsx                         # dashboard (admin) · my courses (student)
│   │   ├── students/ · students/[username]/ # directory · record, enrollment, grades, credentials, guardians
│   │   ├── staff/ · staff/[username]/       # staff · roles
│   │   ├── courses/ · courses/[courseId]/   # courses · roster, gradebook, settings
│   │   ├── groups/ · groups/[id]/           # homerooms and cohorts
│   │   ├── grades/                          # averages and the term report
│   │   ├── credentials/ · reports/ · messages/
│   │   ├── setup/                           # school, years & terms, levels, periods, rooms, subjects, student fields
│   │   └── notifications/[[...id]]/         # SDK NotificationDisplay
│   ├── sso-login-complete/                  # SSO landing (outside the providers)
│   └── api/auth-redirect/                   # same-origin hop to the Auth SPA
├── components/sis/                          # shell, ⌘K, widgets, one folder per area
├── components/ui/                           # shadcn/ui (Base UI) primitives
├── hooks/                                   # useSession, useSisMetadata, useSections
├── lib/sis/                                 # the three RTK Query slices · types · metadata · grades · csv
├── lib/iblai/                               # config · platform resolution · auth helpers
├── i18n/ · messages/                        # next-intl config · en/es/fr/zh catalogs
├── providers/iblai-providers.tsx            # Redux > AuthProvider > TenantProvider
├── scripts/                                 # probe-lms.mjs (the learning-platform contract probe) · mobile-init.sh
├── src-tauri/                               # Tauri 2 shell (macOS · Windows · Linux · iOS · Android)
├── e2e/ · __tests__/                        # Playwright journeys · Vitest
└── docs/                                    # development guide

Data flow

User → React pages → RTK Query ┬─ lib/sis/api.ts        → https://api.iblai.app/dm/…      Authorization: Token <dm_token>
                               ├─ lib/sis/lms-api.ts    → https://api.iblai.app/lms/…     Authorization: JWT <edx_jwt_token>
                               └─ lib/sis/studio-api.ts → https://api.iblai.app/studio/…  Authorization: JWT <edx_jwt_token>
                                            ↓
                                   @iblai/iblai-js SDK
                                   ├── /web-utils        AuthProvider · TenantProvider · platform switch
                                   ├── /web-containers   sidebar shell · profile dropdown · notifications · Account/Management · invitations
                                   └── /data-layer       profile metadata

Sign-in is the platform's hosted round trip (login.<domain>/login?app=mentor&redirect-to=<origin> → /sso-login-complete?data=…), with no platform named unless the URL names one. TenantProvider compares the platform in the URL with the one the session is scoped to and re-authenticates when they differ. Details: docs/development.md.

The contract

Existing endpoints only, as they are:

  • Data Manager (ibl-dm-pro 4.416.0+): the platform users list (the directory) and user links, demographics and field definitions, platform metadata (/api/core/orgs/{key}/metadata/, where the school's own data lives under sis), user groups, platform and course invitations, watched groups, credentials, reports, the notification builder, and the analytics families (overview, platform, audience, engagement, perlearner, performance).
  • Open edX Sumac with the ibl plugins (iblai-edx-pro 2.62+), through the gateway with the edX JWT: the DRF instructor API (get_students_features, list_course_role_members, modify_access, register_and_enroll_students, send_email, start_certificate_generation, change_due_date), enrollment/v1 (read), course_home/v1/progress, grades/v1/gradebook (+ bulk-update, grading-info, subsection), instructor/v1/{tasks,reports}, instructor_task/v1/schedules, /api/ibl/users/manage/roles/, user/v1/accounts, course_home/v1/course_metadata. Not courses/v1/courses: the edge in front of the LMS answers 403 to every caller on that path, preflights included.
  • Studio: contentstore/v1/home/courses (the course list: the runs the caller can author, active and archived, in one call), /api/ibl/manage/course/ (rerun), contentstore/v1/course_details, contentstore/v1/course_grading.

A platform admin passes the course-staff checks through ibl's implied org-instructor rights. Some capabilities are operator settings per platform — the gradebook API flag, automated sign-ups on import, course email, the JWT lifetime — and pnpm probe:lms tells you which ones yours has before the app relies on them.


What the platform would need

ibl.ai/sis writes no endpoint of its own. The features that wait for a change in the Data Manager or the learning platform, and the change each needs, are in TODOS.md: what the app does today, what it needs, and the pull request when one carries it, pinned to iblai-dm-pro@4a53a0663 and iblai-edx-pro@ae705e8.

Settings per platform, not code

  • grades.writable_gradebook is never seeded, so the gradebook API is 403 until the waffle flag is set in Django admin.
  • JWT_AUTH['JWT_EXPIRATION'] is unset and ibl readers fall back to one hour; a school day needs more.
  • ALLOW_AUTOMATED_SIGNUPS is whatever the platform was created with; the probe proves it.
  • A CsrfExemptDomain row for the SIS origin only matters for embedding the instructor dashboard. The JWT query-param middleware is not a shortcut for Drop: it never exempts CSRF and puts tokens in URLs.

Testing

This project is covered by Vitest unit tests in __tests__/ and Playwright end-to-end journeys in e2e/. Run the journeys for any change so nothing regresses:

Command What it does
pnpm test Vitest — metadata parsing, grades and GPA, CSV, course runs, permissions, platform resolution, SSO landing, config, the e2e ledger
pnpm i18n:check en / es / fr / zh catalogs carry the same keys and the house vocabulary
pnpm test:coverage The unit tests with the coverage gate CI runs
pnpm shell:smoke The Tauri shell headless (shell:smoke:windows on Windows): the navigation guard and both sign-in returns on a local page
pnpm e2e:accounts Once: creates the two test accounts (a platform admin and a student) in the throwaway platform iblai.env names
pnpm test:e2e Playwright journeys on that platform in Chromium and on a Pixel 7 viewport, signed in as the test accounts
pnpm test:e2e --project=chromium --no-deps e2e/journeys/groups.journey.spec.ts One journey on the saved session and seed
pnpm test:e2e:all Every browser (their builds installed with pnpm exec playwright install)
pnpm test:e2e:ui Interactive UI mode
pnpm test:e2e:headed Run with a visible browser
pnpm e2e:coverage The ledger gate and the approximate reach of the journeys (pnpm test runs it too)

See e2e/COVERAGE.md for current coverage. Coverage must not regress — add or update a journey whenever you change user-facing behavior.

The Playwright suite signs in through the real Auth SPA (e2e/auth.setup.ts, which finds the login page by its structure, not its copy) as two test accounts that pnpm e2e:accounts creates once — a platform admin and a student in the throwaway platform iblai.env names (PLATFORM), made with its Platform API Token (TOKEN) once the platform confirms the two belong together — and saves in the gitignored e2e/.env.development. The setup project then walks the admin's first run (the SDK setup flow) once and seeds the school once — a 2099 year and term, a grade level with its cohort group, the default student fields, the student's required record values and one enrollment — and writes the ids to playwright/.auth/seed.json. The journeys write to that platform and undo what they can; an invitation, an imported account, a course run and the learning platform's tasks stay behind, so they never run against a real school. The member journeys (M*) run as the student and skip until that pair exists. e2e/coverage.json lists every checkpoint, and pnpm e2e:coverage (pnpm test runs it too) refuses an id without its titled test, a titled test outside the ledger, a page no journey visits, a summary that does not add up, or journeys that reach under 95 % of the app's lines; a11y.journey.spec.ts runs axe-core at WCAG 2.1 AA. /iblai-vibe-connect writes iblai.env; run it from an empty directory and move the file here — from this root it would make the picked platform the community one (NEXT_PUBLIC_MAIN_TENANT_KEY).


Contributing

We welcome contributions! See CONTRIBUTING.md. If you use AI-assisted tooling, read AGENTS.md first — it explains the SDK-first component rule, the multi-platform model, the three backends and how to verify a change.


Resources


License

MIT License. See LICENSE for details.


ibl.ai · Your school’s AI, under your control.

About

No description, website, or topics provided.

Resources

Contributing

Stars

1 star

Watchers

0 watching

Forks

Releases

Packages

Used by

Contributors

Languages