SLGuiAdminAuthority.sleela
lib/gui/version-dual/SLGuiAdminAuthority.sleela · 179 line(s) · sleela
<< lib/gui/version-dual/SLGuiAdminAuthority.sleela
SLeeLa Standard Library Definition.
Definition: Defines SLGuiAdminAuthority — the 4.0 admin authority surface. It
gates three careful, auditable things:
1. admin SIGN-IN to START a process (a session an authorised admin opens
before a guarded process may run);
2. admin SIGN-OFF on a component OPERATION (an authorised approval that a
specific operation may proceed); and
3. an admin SIGNATURE FOR LAW (a legal attestation binding an admin to a
document/subject with a signature token).
This class models the authority STATE and a bounded audit trail of the
approvals/signatures granted; it is fail-closed (no identity => no authority)
and does not implement a credential check or a cryptographic signature — it
records WHO authorised WHAT, and leaves verification to the host/security
layer. The point is that a guarded operation cannot proceed, a guarded
process cannot start, and a legal subject cannot be signed, without an
explicit, recorded admin act.
Family: gui. Consulted by components before a guarded action; the host
supplies authenticated admin identities. >>
#sleela 2.5
material;
class SLGuiAdminAuthority {
< ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- >
<< Eleven catalogued attributes with getter/setter pairs, so a GUI, loader,
or catalog can read and (where appropriate) override this subject.
Values are faithful to the subject's real origin where publicly known. >>
String metaVersion = "1.0.0";
int metaId = 11155;
String metaAuthor = "Kiro Agent";
String metaDate = "2026-10-16";
String metaCopyright = "SLeeLa project";
String metaTrademark = "none";
String metaCorporation = "none";
< metaOrigin: National | <nation> | International | Galactic >
String metaOrigin = "International";
String metaBirthDate = "2026-10-16";
< metaScienceRating: maturity/robustness on a 1..10 scale >
int metaScienceRating = 9;
< metaNationalSchedule: a real, citable instrument or "none" >
String metaNationalSchedule = "none";
String getMetaVersion() { return metaVersion; }
void setMetaVersion(String v) { metaVersion = v; }
int getMetaId() { return metaId; }
void setMetaId(int v) { metaId = v; }
String getAuthor() { return metaAuthor; }
void setAuthor(String v) { metaAuthor = v; }
String getDate() { return metaDate; }
void setDate(String v) { metaDate = v; }
String getCopyright() { return metaCopyright; }
void setCopyright(String v) { metaCopyright = v; }
String getTrademark() { return metaTrademark; }
void setTrademark(String v) { metaTrademark = v; }
String getCorporation() { return metaCorporation; }
void setCorporation(String v) { metaCorporation = v; }
String getOrigin() { return metaOrigin; }
void setOrigin(String v) { metaOrigin = v; }
String getBirthDate() { return metaBirthDate; }
void setBirthDate(String v) { metaBirthDate = v; }
int getScienceRating() { return metaScienceRating; }
void setScienceRating(int v) { metaScienceRating = v; }
String getNationalSchedule() { return metaNationalSchedule; }
void setNationalSchedule(String v) { metaNationalSchedule = v; }
static final int MAX_AUDIT = 128;
< Audit entry kinds. >
< started a process session >
static final int ACT_SIGNIN = 1;
< approved an operation >
static final int ACT_SIGNOFF = 2;
< legal signature on a record >
static final int ACT_SIGNATURE= 3;
static final int ACT_SIGNOUT = 4;
< the authenticated admin currently signed in ("" = none) >
String adminId;
< 1 while a signed-in process session is open >
int signedIn;
< the process this session was opened to start >
String processName;
< Audit trail (parallel arrays): act kind, admin, subject, token/reason. >
int[] auditAct;
String[] auditAdmin;
String[] auditSubject;
String[] auditToken;
int auditCount;
void configure() {
adminId = ""; signedIn = 0; processName = "";
auditAct = new int[MAX_AUDIT]; auditAdmin = new String[MAX_AUDIT];
auditSubject = new String[MAX_AUDIT]; auditToken = new String[MAX_AUDIT];
auditCount = 0;
}
< ---- 1. sign-in to start a process -------------------------------------- >
< An authorised admin opens a session to start a guarded process. Fail-closed: >
< a blank admin id or process name is refused. >
boolean signIn(String admin, String process) {
if (admin == null || admin == "" || process == null || process == "") { return false; }
adminId = admin; processName = process; signedIn = 1;
logAct(ACT_SIGNIN, admin, process, "");
return true;
}
void signOut() {
if (signedIn == 1) { logAct(ACT_SIGNOUT, adminId, processName, ""); }
signedIn = 0; adminId = ""; processName = "";
}
boolean isSignedIn() { return signedIn == 1; }
String currentAdmin() { return adminId; }
String currentProcess() { return processName; }
< A guarded process may start only while an admin session is open. >
boolean mayStartProcess(String process) {
return signedIn == 1 && process != null && process == processName;
}
< ---- 2. sign-off on a component operation ------------------------------- >
< Approve a specific operation. Requires a signed-in admin (fail-closed); the >
< approval is recorded against that admin. Returns false without authority. >
boolean signOff(String operation, String reason) {
if (signedIn == 0 || operation == null || operation == "") { return false; }
logAct(ACT_SIGNOFF, adminId, operation, (reason == null) ? "" : reason);
return true;
}
< Was `operation` signed off by an admin (searching the audit trail)? >
boolean isSignedOff(String operation) {
for (int i = 0; i < auditCount; i = i + 1) {
if (auditAct[i] == ACT_SIGNOFF && auditSubject[i] == operation) { return true; }
}
return false;
}
< ---- 3. admin signature for Law ----------------------------------------- >
< Attach a legal signature token to a record. Requires a signed-in admin; the >
< token is host-supplied (e.g. a signed hash). Fail-closed on missing inputs. >
boolean signForLaw(String subject, String signatureToken) {
if (signedIn == 0 || subject == null || subject == "" ||
signatureToken == null || signatureToken == "") { return false; }
this.logAct(ACT_SIGNATURE, adminId, subject, signatureToken);
return true;
}
boolean isLegallySigned(String subject) {
for (int i = 0; i < auditCount; i = i + 1) {
if (auditAct[i] == ACT_SIGNATURE && auditSubject[i] == subject &&
auditToken[i] != null && auditToken[i] != "") { return true; }
}
return false;
}
String signatureOf(String subject) {
for (int i = auditCount - 1; i >= 0; i = i - 1) {
if (auditAct[i] == ACT_SIGNATURE && auditSubject[i] == subject) { return auditToken[i]; }
}
return "";
}
< ---- audit trail -------------------------------------------------------- >
void logAct(int act, String admin, String subject, String token) {
if (auditCount >= MAX_AUDIT) { return; }
auditAct[auditCount] = act; auditAdmin[auditCount] = admin;
auditSubject[auditCount] = subject; auditToken[auditCount] = token;
auditCount = auditCount + 1;
}
int auditEntries() { return auditCount; }
int auditActAt(int i) { return (i >= 0 && i < auditCount) ? auditAct[i] : 0; }
String auditAdminAt(int i) { return (i >= 0 && i < auditCount) ? auditAdmin[i] : null; }
String auditSubjectAt(int i) { return (i >= 0 && i < auditCount) ? auditSubject[i] : null; }
String actName(int act) {
if (act == ACT_SIGNIN) { return "sign-in"; }
if (act == ACT_SIGNOFF) { return "sign-off"; }
if (act == ACT_SIGNATURE) { return "signature"; }
if (act == ACT_SIGNOUT) { return "sign-out"; }
return "none";
}
}