Home /Modules/gui/SLGuiAdminAuthority.sleela

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";
  }
}