Together we revolutionize education

Don't see your university on the lists? Be the one who's built it!

Clueport is a connector between Clueless and your university portal. It's built once and shared among everyone.

Get Clueless Build a kit

How a kit works

Capture, generate, write, verify, send. Five steps, one evening.

The contract

The one interface every connector implements, and the one way it reaches the network.

The manifest

What your kit declares about itself. Checked before any code runs.

The verifier

Replays your connector against your own captured pages, offline.

Overview

How to use Clueport, step by step.

You capture your own pages, an AI writes the parser against them, and the verifier proves the parser works without anyone logging in. Nobody needs a login they don't have. About an evening of work.

Open Clueport

In Clueless, open Settings then Clueport. Fill the four fields: your university's short id (lowercase letters, digits and hyphens - permanent once it ships), its display name, a short id for the platform you are connecting, and the portal's https address. Your name and contact go in too; only the reviewer sees them.

Press Open & sign in. A login window opens on your own university site. Sign in the way you always do. Clueless reads the address of the page you are on; it never asks you to paste a URL.

Capture the pages that matter

Browse to your course list, then press Capture on the Courses row. Do the same for a syllabus page, then any of assignments, grades, materials or schedule. Being on a page is selecting it. Each capture is scrubbed before it is saved - ids, tokens and cookies removed - and the panel tells you what it changed and what it cannot check, such as a person's name in plain text. Courses and syllabus are required; the rest are optional.

Copy the prompt, generate the kit

The panel shows the prompt your AI will work from and a Copy prompt button. Press Generate kit. A folder lands on your Desktop named clueport-kit-<university>-<platform>.

Install once, then run the checker

Open the folder in a terminal. The first run fails on purpose: it lists every read that still returns nothing.

cd ~/Desktop/clueport-kit-<university>-<platform>
npm install --ignore-scripts   # once
node verify.mjs                # after every edit

Hand the prompt to your AI

Paste PROMPT.md into any coding agent or chat window - the recipes are in the next section. It edits connector.mjs, you run node verify.mjs, and you repeat until the report prints VERIFIED. If a page is missing, capture it in Clueless and press Generate kit again; your connector.mjs is kept and the fresh skeleton lands beside it as connector.mjs.new.

Clean and send

Delete node_modules/ and package-lock.json, zip the folder, and press Email the kit in the panel. It opens your mail app with the subject and body filled in; attach the zip yourself. If your portal genuinely cannot be connected - hard 2FA, IP blocks - say so in the "If the portal can't be connected" box and submit anyway; that sentence is shown to students at your school.

Review and ship

The maintainer runs clueportkit verify, which reads your kit and executes nothing, then reads connector.mjs, then clueportkit run. An approved connector becomes source in the next Clueless release and your university appears in the app.

Reference

Working with an AI agent.

The kit is agent-agnostic. PROMPT.md is the brief, connector.mjs is the only file to edit, and node verify.mjs is the loop. This is the exact prompt Clueless generates, shown here for the example kit; yours names your university, your fixtures and the reads you captured. Every rule in it is one the verifier fails on.

PROMPT.md · example-u / example-lms

{{ promptText }}

In the app, Settings → Clueport → Copy prompt gives you the same text filled in for your kit. Start the agent inside the kit folder so it can read the fixtures.

Claude Code

cd clueport-kit-<university>-<platform>
claude "Read PROMPT.md and do exactly what it says. Edit only connector.mjs.\nRun node verify.mjs after every change and stop when it prints VERIFIED."

Start in the kit folder. Claude reads PROMPT.md and the fixtures, then loops on the verifier until it prints VERIFIED.

Codex CLI

codex --approval-mode auto-edit "Read PROMPT.md and follow it. Edit only connector.mjs.\nRun node verify.mjs after every change until it prints VERIFIED."

Same brief. Auto-edit mode lets it write connector.mjs and run the verifier without asking each time.

Gemini CLI

gemini -p "Read PROMPT.md and follow it. Edit only connector.mjs.\nRun node verify.mjs after every change until it prints VERIFIED."

Open the folder and hand over the prompt. Gemini picks up contract.d.ts and the fixtures from the working directory.

Cursor

# Cursor → Agent mode
@PROMPT.md Do exactly this. Edit only connector.mjs.
Run node verify.mjs after every change until it prints VERIFIED.

Open the kit as a project. In Agent mode, reference PROMPT.md and ask it to run the verifier in the terminal after each edit.

GitHub Copilot CLI

copilot "Read PROMPT.md and follow it. Edit only connector.mjs.\nRun node verify.mjs after every change until it prints VERIFIED."

Agent mode in the terminal. Give it the same brief; it edits and runs commands in the folder.

A chat window, no CLI

Clueless → Settings → Clueport → Copy prompt
node verify.mjs   # after each change the model gives you

Paste the prompt. When the model asks, paste the markup of the fixture it needs. Save its connector.mjs and run the verifier yourself.

Rule	Why the agent gets it wrong
Read the fixtures before writing a selector	A model writes selectors for the page it imagines. Each one returns an empty list, which looks exactly like a working connector for a course with no data. Make it open fixtures/ first.
Only connector.mjs changes	Agents fix a failing check by editing the check. The reviewer's static pass refuses a kit whose verify.mjs, manifest.json or package.json differ from the generated ones.
No fetch, fs, https or process.env	Agents reach for fetch() when a fixture is missing. fetchPage(url) is the only network. If a page is not captured, capture it in Clueless; do not work around it.
Delete node_modules before zipping	The agent installed cheerio to run the verifier. A submitted dependency tree is unreviewed code, and the reviewer's checker refuses it.

Shipping

What the reviewer runs.

Two commands, in order. The first reads your kit as text and executes nothing. The second runs it, and refuses to start unless the first passed.

clueportkit verify <kit-dir>   # read a submission. Executes nothing.
clueportkit run    <kit-dir>   # run it, after reading it.
clueportkit demo   <out-dir>   # write a working example kit

An approved connector.mjs becomes source in the Clueless repository, reviewed and built like everything else, and your university appears in the picker in the next release. Your name and contact are seen by the reviewer only.

Questions.

Can my kit ship if the portal cannot be connected?

Yes. Set portal.unreachable to the reason, such as mandatory 2FA or IP blocking. The verifier checks the reason instead of the connector, and students at that school see it as the reason nothing syncs.

Do I need a toolchain?

No. A kit is plain JavaScript modules and node verify.mjs. The verifier ships inside the kit because the Clueless repository is private.

What about my personal data in the captured pages?

Capture strips ids and secrets and reports what it changed. It cannot recognise a person's name on an unknown page, so read your fixtures before you send them.

Start in the app.

Settings, then Clueport. The capture tool and the kit generator are built in.

Get Clueless

Reference

The contract.

A connector returns normalized rows. It reads the network through one function it is handed, and nothing else.

export interface Connector {
  source: string;                       // stamped on every row you write
  capabilities?: readonly Capability[]; // spell them out (see manifest)

  fetchCurrentTerm(): Promise<string | null>;
  fetchTermOptions?(): Promise<string[]>;
  fetchCourses(term: string): Promise<CourseInput[]>;      // 'YYYY/S'
  fetchAssignments(courseId: string): Promise<AssignmentInput[]>;
  fetchGrades(courseId: string): Promise<GradeInput[]>;
  fetchMaterials(courseId: string): Promise<MaterialInput[]>;
  fetchSyllabus(courseId: string): Promise<SyllabusData>;
  fetchSchedule(courseId: string): Promise<EventInput[]>;
  resolveStudentId(hintCourseId: string): Promise<string>;
  fetchPortfolio(courseId: string, studentId: string): Promise<ComponentScoreInput[]>;
}

export type PageFetcher = (url: string) => Promise<string>;

export interface KitModule {
  createConnector(fetchPage: PageFetcher): Connector;
}

In the app the fetcher is real. In the verifier it is backed by your fixtures, so the same parser runs offline and gives the same answer on a machine that has never seen your portal. A connector that opens its own socket cannot be reviewed, and the verifier refuses it.

fetchCurrentTerm never throws. If your platform does not say which term it is, return null and Clueless falls back to its calendar.

Reference

Capabilities.

Seven reads. Declare the ones you serve and the sweep skips the rest, out loud. Two are required.

Capability	Returns	Required
courses	The course list for one term	Yes
syllabus	Weights, grade bands, and the syllabus text for one course	Yes
assignments	Assignments and due dates for one course	No
grades	Posted grades for one course	No
materials	Files and links for one course	No
schedule	Class sessions for one course	No
portfolio	Component scores for one student in one course	No

Courses are what every screen hangs off. The syllabus is where per-course grade bands and weights come from, which is why Clueport needs no per-university grading rules. Grades and portfolio are not required because most gradebooks are empty; students enter their own.

Reference

The manifest.

manifest.json is the half of a kit that can be checked with no code executed. Clueless drafts it for you. This is the example kit's.

{
  "kit": 1,
  "university": { "id": "example-u", "label": "Example University", "blurb": "" },
  "connector":  { "source": "example-lms", "label": "Example LMS",
                  "capabilities": ["courses", "syllabus"] },
  "author":     { "name": "Your Name", "contact": "you@example.invalid" },
  "portal":     { "baseUrl": "https://lms.example.edu", "unreachable": null },
  "fixtures": [
    { "file": "courses.html",     "capability": "courses",  "arg": "2026/1",
      "url": "https://lms.example.edu/courses?term=2026-1" },
    { "file": "syllabus_c1.html", "capability": "syllabus", "arg": "C1",
      "url": "https://lms.example.edu/course/C1/syllabus" }
  ],
  "notes": ""
}

Field	Rule
kit	Must be 1. A kit in a format this verifier does not read is refused whole, not half-checked.
university.id	Lowercase letters, digits and hyphens, 1 to 63 characters, not starting with a hyphen. Permanent once it ships.
connector.source	Same shape as the id. mcv, reg, classroom, manual, user and google are reserved.
connector.capabilities	Required, and must include courses and syllabus. Omitting the list would mean all seven.
portal.baseUrl	An https origin. Plain http leaks the session.
portal.unreachable	null when the connector works. Otherwise a sentence of at least 20 characters saying why it cannot, shown to that school's students.
fixtures[].file	A bare filename inside fixtures/. No path separators.
author.contact	How the reviewer replies. Never shown to students.

Reference

The verifier.

Pure. No filesystem, no network, no clock. Two phases, and the words in the report mean different things.

Phase	What it checks	Prints
static	File membership: anything the generator did not write is refused. Clueless-owned files byte-identical to generator output. A source scan for code that reaches outside the fetcher: node:https, fetch(, child_process, eval, process.env, and obfuscation tells such as non-literal import() specifiers, unicode escapes, and string-built module names.	SAFE TO READ
full	Constructs your connector with a fetcher backed by your fixtures, calls every declared capability, and checks the rows: required strings present, numbers numeric, term labels matching YYYY/S, grade letters known, and no scrub placeholders leaking into output.	VERIFIED

The static scan is a review aid, not a sandbox. It puts the few lines a reviewer must read with their own eyes in front of them. Every report carries the verifier version and its phase.

node verify.mjs