Add self-service API tokens (PATs) with UI + Bearer auth (#35)

Personal access tokens so scripts/CI can call the management API without a
browser session. Each logged-in user mints their own token; it authenticates as
the creator (carries their LDAP group permissions, re-resolved live), so the
existing permission.byGroup checks apply unchanged.

- models/api_token.js: new ApiToken model (sso_<id>_<secret> format; id is the
  lookup key, secret bcrypt-hashed + isPrivate, shown once). add()/rotate()/
  authenticate(); optional expires_at; best-effort last_used_on. No _ttl
  (persists; lifetime via expires_at).
- routes/api_token.js: self-service CRUD (list/get/update/delete/rotate),
  owner-scoped (created_by === req.user.uid, 403 otherwise).
- middleware/auth.js + models/auth.js: accept `Authorization: Bearer sso_...`
  (precedence over the auth-token session header); checkApiToken collapses
  every failure to one generic 401 (no existence/secret/expiry leak).
- views/api_tokens.ejs + routes/index.js (GET /api-tokens): self-service page
  (forceLogin, no group gate) — create (token shown once), edit, rotate, revoke.
- views/top.ejs: "API Tokens" nav entry visible to all logged-in users.
- public/js/app.js: app.apiToken client module.
- DEPLOYMENT.md + docs/deployment.md: API tokens section.

Co-authored-by: Claude <noreply@anthropic.com>

nodejs/models/api_token.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const Table = require('.');
+const bcrypt = require('bcrypt');
+const crypto = require('crypto');
+
+// Self-service personal access token (PAT) for the SSO management API.
+// Format:  sso_<id>_<secret>
+//   id     — 24-char hex, stored plaintext as the record key (O(1) lookup)
+//   secret — 48-char hex, stored only as a bcrypt hash (isPrivate); shown ONCE
+// Authenticated via the `Authorization: Bearer sso_...` header (see
+// middleware/auth.js + Auth.checkApiToken). A token authenticates AS its
+// creator (created_by) and inherits their LDAP group permissions — the same
+// permission.byGroup checks apply, re-resolved live from LDAP each request.
+// No `static _ttl`: records persist (lifetime is the optional expires_at field).
+
+const PREFIX = 'sso_';
+const randomHex = (bytes) => crypto.randomBytes(bytes).toString('hex');
+
+class ApiToken extends Table {
+	static _key = 'id';
+	static _keyMap = {
+		'id':           {default: function(){ return randomHex(12) }, type: 'string'},
+		'secret_hash':  {isRequired: true, type: 'string', isPrivate: true},
+		'name':         {isRequired: true, type: 'string', min: 1, max: 255},
+		'description':  {default: '', type: 'string'},
+		'created_by':   {isRequired: true, type: 'string'},
+		'created_on':   {default: function(){ return (new Date).getTime() }},
+		'updated_on':   {default: function(){ return (new Date).getTime() }, always: true},
+		'expires_at':   {default: 0, type: 'number'}, // epoch ms; 0 = never
+		'last_used_on': {default: 0, type: 'number'},
+		'is_valid':     {default: true, type: 'boolean'},
+	}
+
+	get isExpired() {
+		return this.expires_at > 0 && (new Date).getTime() > this.expires_at;
+	}
+
+	static async add(data) {
+		const id = randomHex(12);
+		const secret = randomHex(24);
+		data.id = id;
+		data.secret_hash = await bcrypt.hash(secret, 10);
+		const token = await this.create(data);
+		token._raw_token = `${PREFIX}${id}_${secret}`;
+		return token;
+	}
+
+	async rotate() {
+		const secret = randomHex(24);
+		await this.update({ secret_hash: await bcrypt.hash(secret, 10) });
+		return `${PREFIX}${this.id}_${secret}`;
+	}
+
+	// Validate a raw `sso_<id>_<secret>` string. Throws a generic Error on any
+	// failure (wrong format / unknown id / bad secret / revoked / expired) so the
+	// caller (Auth.checkApiToken) can collapse every case into one 401.
+	static async authenticate(raw) {
+		const m = /^sso_([0-9a-f]{24})_([0-9a-f]{48})$/i.exec(String(raw || ''));
+		if (!m) throw new Error('InvalidApiToken');
+		let token;
+		try {
+			token = await this.get(m[1]);
+		} catch (e) {
+			throw new Error('InvalidApiToken');
+		}
+		if (!token) throw new Error('InvalidApiToken');
+		const ok = await bcrypt.compare(m[2], token.secret_hash);
+		if (!ok || !token.is_valid || token.isExpired) throw new Error('InvalidApiToken');
+		// Best-effort: stamp last use. Fire-and-forget so a Redis hiccup never
+		// fails an otherwise-valid request.
+		try { await token.update({ last_used_on: (new Date).getTime() }); } catch (_) {}
+		return token;
+	}
+}
+ApiToken.register();
+
+module.exports = { ApiToken };

nodejs/models/auth.js

@@ -2,6 +2,7 @@
 
 const {User} = require('./user');
 const {Token, AuthToken} = require('./token');
+const {ApiToken} = require('./api_token');
 
 var Auth = {}
 Auth.errors = {}
@@ -40,6 +41,20 @@ Auth.checkToken = async function(data){
 	}
 };
 
+// Validate an `Authorization: Bearer sso_<id>_<secret>` API token and return the
+// owning user (same shape as checkToken). Every failure collapses to the same
+// generic login 401 — no leak of whether the token existed vs. wrong secret vs.
+// expired. The token authenticates AS its creator; permissions are re-resolved
+// from LDAP live (permission.byGroup), so no groups snapshot is stored.
+Auth.checkApiToken = async function(raw){
+	try{
+		let token = await ApiToken.authenticate(raw);
+		return await User.get(token.created_by);
+	}catch(error){
+		throw this.errors.login();
+	}
+};
+
 Auth.logOut = async function(data){
 	try{
 		let token = await AuthToken.get(data);

nodejs/models/index.js

@@ -11,3 +11,4 @@ require('./token');
 require('./verification');
 require('./oauth_client');
 require('./oauth_code');
+require('./api_token');