abstract-toolserver 0.0.76__tar.gz → 0.0.78__tar.gz

{abstract_toolserver-0.0.76/src/abstract_toolserver.egg-info → abstract_toolserver-0.0.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_toolserver
-Version: 0.0.76
+Version: 0.0.78
 Summary: The abstract_* ecosystem exposed as an API-callable AI toolset: functions become self-describing Flask endpoints with /endpoints discovery and ?help.
 Home-page: https://github.com/AbstractEndeavors/abstract-toolserver
 Author: putkoff
@@ -322,6 +322,15 @@ record `requester_node` / `owner_node`: `abstract-permit log --node <id>`. For t
 `abstract-toolserver node --dropin` prints a unit drop-in (`LogExtraFields=NODE_ID=…`) so one
 node's log is `journalctl NODE_ID=<id>`.
 
+**Session keys and the router (2026-10-08).** Every session registers with its user's node
+at start (`abstract-toolserver session register --hook` from a SessionStart hook) and gets a
+rotating key `tsa_…` (24 h, 15 min overlap on rotation; the hub stores only its hash).
+`abstract-toolserver session headers` prints `{"Authorization": "Bearer tsa_…", "X-Session-Id": …}`,
+rotating when close to expiry — usable as an MCP `headersHelper`. Nodes accept `tsa_` keys of
+their own user (verified by the hub; operator-only tools denied). `abstract-toolserver router`
+(default 127.0.0.1:7210) is the one public entry point: it routes by session id to that
+session's node and streams the response; nodes stay on loopback.
+
 `serve` refuses only when **this user** already has a live node (one node per user); other
 users' nodes on the host are not duplicates. The consumer hook `ensure_endpoint` (hugpy
 orbit) still uses an existing host toolserver rather than starting one.

{abstract_toolserver-0.0.76 → abstract_toolserver-0.0.78}/README.md

@@ -250,6 +250,15 @@ record `requester_node` / `owner_node`: `abstract-permit log --node <id>`. For t
 `abstract-toolserver node --dropin` prints a unit drop-in (`LogExtraFields=NODE_ID=…`) so one
 node's log is `journalctl NODE_ID=<id>`.
 
+**Session keys and the router (2026-10-08).** Every session registers with its user's node
+at start (`abstract-toolserver session register --hook` from a SessionStart hook) and gets a
+rotating key `tsa_…` (24 h, 15 min overlap on rotation; the hub stores only its hash).
+`abstract-toolserver session headers` prints `{"Authorization": "Bearer tsa_…", "X-Session-Id": …}`,
+rotating when close to expiry — usable as an MCP `headersHelper`. Nodes accept `tsa_` keys of
+their own user (verified by the hub; operator-only tools denied). `abstract-toolserver router`
+(default 127.0.0.1:7210) is the one public entry point: it routes by session id to that
+session's node and streams the response; nodes stay on loopback.
+
 `serve` refuses only when **this user** already has a live node (one node per user); other
 users' nodes on the host are not duplicates. The consumer hook `ensure_endpoint` (hugpy
 orbit) still uses an existing host toolserver rather than starting one.

{abstract_toolserver-0.0.76 → abstract_toolserver-0.0.78}/setup.py

@@ -7,7 +7,7 @@ SERVER = ['abstract_flask', 'abstract_utilities']
 
 setuptools.setup(
     name='abstract_toolserver',
-    version='0.0.76',
+    version='0.0.78',
     author='putkoff',
     author_email='partners@abstractendeavors.com',
     description="The abstract_* ecosystem exposed as an API-callable AI toolset: functions become self-describing Flask endpoints with /endpoints discovery and ?help.",

{abstract_toolserver-0.0.76 → abstract_toolserver-0.0.78}/src/abstract_toolserver/app.py

@@ -15,6 +15,7 @@ from flask import g, jsonify, request
 
 from . import discovery as _discovery
 from . import routes
+from . import nodeauth as _nodeauth
 from . import session_auth as _session_auth
 from . import vmpage as _vmpage
 
@@ -80,6 +81,26 @@ def _admit_session_key(app, key):
     return None
 
 
+def _admit_node_session(app, key):
+    """Admit a node-session key (tsa_, nodeauth.py): verified by the permit hub,
+    accepted only for this node's own user; operator-only tools stay denied."""
+    from .gates import ToolError
+    try:
+        v = _nodeauth.verify_for_node(key, request.headers.get("X-Session-Id", "").strip())
+    except ToolError as exc:
+        if "not reachable" in str(exc):
+            return jsonify({"error": "auth_unavailable", "reason": str(exc)}), 503
+        return jsonify({"error": "unauthorized", "reason": str(exc)}), 401
+    tool = _session_auth.name_for_request(request.path, request.get_json(silent=True))
+    if _session_auth.is_denied_for_hps(tool):
+        app.logger.info("tsa DENY session=%s -> operator-only tool %s", v["session_id"], tool)
+        return jsonify({"error": "forbidden", "reason": "operator_only", "tool": tool}), 403
+    g.principal = {"role": "session", "session_id": v["session_id"], "user": v["user"],
+                   "node_id": v.get("node_id", "")}
+    app.logger.info("tsa ok session=%s user=%s -> %s", v["session_id"], v["user"], tool or request.path)
+    return None
+
+
 def _install_operator_gate(app):
     """The ONLY access gate: every request must carry the operator token as
     X-Operator-Token or 'Authorization: Bearer <token>' (TOOLSERVER_OPERATOR_TOKEN).
@@ -184,6 +205,8 @@ def _install_operator_gate(app):
         # STEP 2: a hugpy-issued session key (hps_) is verified by central
         # introspection, ALONGSIDE the static operator token. The static-token
         # paths below are untouched.
+        if _nodeauth.is_session_key(sent):
+            return _admit_node_session(app, sent)
         if _session_auth.is_session_key(sent):
             return _admit_session_key(app, sent)
         if not token:

{abstract_toolserver-0.0.76 → abstract_toolserver-0.0.78}/src/abstract_toolserver/cli.py

@@ -15,6 +15,12 @@
         created on first use). --dropin prints the systemd drop-in that tags every
         journal line of the node's unit with NODE_ID / NODE_USER, so one node's log
         is `journalctl NODE_ID=<id>` (add --user for a user unit's own journal).
+    abstract-toolserver session register|headers|key|end|list
+        node-session keys (nodeauth.py): register at session start (--hook reads
+        the SessionStart JSON), `headers` prints the rotating auth headers.
+    abstract-toolserver router [--host 127.0.0.1] [--port 7210]
+        the session router (router.py): X-Session-Id + Bearer tsa_… -> that
+        session's node. The one piece meant to sit behind a public hostname.
     abstract-toolserver mcp        the stdio MCP bridge (= abstract-toolserver-mcp)
     abstract-toolserver provider … the capability-provider loop (see provider.py)
 
@@ -105,6 +111,12 @@ def main(argv=None) -> int:
         from .mcp import main as mcp_main
         mcp_main()
         return 0
+    if argv and argv[0] == "session":
+        from .nodeauth import main_session
+        return main_session(argv[1:])
+    if argv and argv[0] == "router":
+        from .router import main as router_main
+        return router_main(argv[1:])
     if argv and argv[0] == "provider":
         from .provider import main as provider_main
         return provider_main(argv[1:])

{abstract_toolserver-0.0.76 → abstract_toolserver-0.0.78}/src/abstract_toolserver/client.py

@@ -216,6 +216,7 @@ class ToolserverClient:
         else:
             self.token, self.token_source = discovery.resolve_token(
                 "", self.url, environ, advertised)
+        self._environ = environ
         self.timeout = float(timeout or CALL_TIMEOUT)
         self.probe_timeout = float(probe_timeout or PROBE_TIMEOUT)
         self.allow = list(allow or _list_env(environ, self.allow_env))
@@ -233,6 +234,12 @@ class ToolserverClient:
     # -- transport -------------------------------------------------------------
     def _headers(self) -> dict:
         h = {"Accept": "application/json", "Content-Type": "application/json"}
+        if self.token_source != "config":
+            from .nodeauth import session_headers_or_none
+            sess = session_headers_or_none(self._environ)
+            if sess:
+                h.update(sess)
+                return h
         if self.token:
             h["Authorization"] = "Bearer " + self.token
             # a session key goes as Bearer only; the static operator token as both

{abstract_toolserver-0.0.76 → abstract_toolserver-0.0.78}/src/abstract_toolserver/discovery.py

@@ -363,8 +363,12 @@ def validate(ad, probe=True, opener=None, hostname=None) -> tuple:
 
 
 def find_endpoint(environ=None, probe=True, opener=None) -> dict | None:
-    """First VALID advertisement in search order (dict with url/…/path/source),
-    else — with probe — a toolserver answering the default local port."""
+    """This user's own node first (one node per user), else the first VALID
+    advertisement in search order (dict with url/…/path/source), else — with
+    probe — a toolserver answering the default local port."""
+    own = own_endpoint(environ, probe=probe, opener=opener)
+    if own:
+        return own
     for path in endpoint_paths(environ):
         ad = read_advertisement(path)
         if not ad:

{abstract_toolserver-0.0.76 → abstract_toolserver-0.0.78}/src/abstract_toolserver/mcp.py

@@ -150,7 +150,14 @@ def _http(method, path, body=None, timeout=None, bounded=False):
     req.add_header("Accept", "application/json")
     if data is not None:
         req.add_header("Content-Type", "application/json")
-    if TOKEN:
+    from .nodeauth import session_headers_or_none
+    sess = session_headers_or_none()
+    if sess:
+        # inside a session: its rotating key + id (nodeauth.py); the router and the
+        # session's own node accept these, and the static token never travels
+        for k, v in sess.items():
+            req.add_header(k, v)
+    elif TOKEN:
         # both spellings: the toolserver checks X-Operator-Token and also
         # honours Authorization: Bearer; sending both survives either deployment
         req.add_header("X-Operator-Token", TOKEN)

abstract_toolserver-0.0.78/src/abstract_toolserver/nodeauth.py

@@ -0,0 +1,397 @@
+"""
+Session auth for the node mesh: every session registers with its user's node and
+gets a rotating key; the router (router.py) uses session id + key to reach the
+right node.
+
+    session start (hook)  abstract-toolserver session register --hook
+                          -> hub records session_id <-> uid/node, mints a key
+    any client            abstract-toolserver session headers
+                          -> {"Authorization": "Bearer tsa_…", "X-Session-Id": …}
+                             (rotates the key when it is close to expiry;
+                             usable as an MCP headersHelper)
+    router                X-Session-Id + Bearer tsa_… -> hub "route" -> node url
+    node gate (app.py)    Bearer tsa_… -> hub "verify_key" -> principal, only for
+                          keys of the node's own user
+
+Keys: "tsa_" + 32 random bytes; the hub stores only sha256. TTL
+TOOLSERVER_SESSION_KEY_TTL (default 24 h). Each rotation mints a new key and
+lets the previous one live TOOLSERVER_SESSION_KEY_GRACE more seconds (default
+900) so in-flight clients are not cut off. A session belongs to the uid that
+registered it (kernel-attested on the hub socket); nobody else can mint its keys.
+
+The hub ops live here as a mixin of permits.Hub; the client helpers keep a
+per-session key file (~/.config/abstract-toolserver/sessions/<id>.json, 0600).
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import pwd
+import re
+import secrets
+import time
+
+from .gates import ToolError
+
+KEY_PREFIX = "tsa_"
+SESSION_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$")
+TTL = int(os.environ.get("TOOLSERVER_SESSION_KEY_TTL", "86400"))
+GRACE = int(os.environ.get("TOOLSERVER_SESSION_KEY_GRACE", "900"))
+REFRESH_BEFORE = min(3600, TTL // 4)
+SESSION_ENV = ("TOOLSERVER_SESSION_ID", "CLAUDE_CODE_SESSION_ID", "CLAUDE_SESSION_ID", "CODEX_SESSION_ID")
+
+
+def _user(uid):
+    try:
+        return pwd.getpwuid(uid).pw_name
+    except KeyError:
+        return str(uid)
+
+
+def key_hash(key):
+    return hashlib.sha256(str(key or "").encode()).hexdigest()
+
+
+def is_session_key(cred):
+    return str(cred or "").startswith(KEY_PREFIX)
+
+
+def _sid(v):
+    v = str(v or "").strip()
+    if not SESSION_RE.match(v):
+        raise ToolError("session_id must match [A-Za-z0-9._:-]{1,128}")
+    return v
+
+
+# ──────────────────────────────────────────────────────────
+# Hub side (mixed into permits.Hub; uses self._conn, self.lock, self.node_of,
+# self.operators, self.uid, self._need_operator)
+# ──────────────────────────────────────────────────────────
+class SessionOps:
+    def _ensure_sessions(self):
+        if getattr(self, "_sessions_ensured", False):
+            return
+        with self._conn() as c, c.cursor() as cur:
+            cur.execute("""
+                CREATE TABLE IF NOT EXISTS node_sessions (
+                    session_id TEXT PRIMARY KEY,
+                    uid        INTEGER NOT NULL,
+                    usr        TEXT NOT NULL,
+                    node_id    TEXT NOT NULL DEFAULT '',
+                    harness    TEXT NOT NULL DEFAULT '',
+                    label      TEXT NOT NULL DEFAULT '',
+                    pid        INTEGER NOT NULL DEFAULT 0,
+                    created    BIGINT NOT NULL,
+                    last_seen  BIGINT NOT NULL,
+                    ended      BIGINT NOT NULL DEFAULT 0
+                )""")
+            cur.execute("""
+                CREATE TABLE IF NOT EXISTS node_session_keys (
+                    key_hash   TEXT PRIMARY KEY,
+                    key_hint   TEXT NOT NULL,
+                    session_id TEXT NOT NULL,
+                    uid        INTEGER NOT NULL,
+                    created    BIGINT NOT NULL,
+                    expires    BIGINT NOT NULL,
+                    revoked    BIGINT NOT NULL DEFAULT 0,
+                    replaced_by TEXT NOT NULL DEFAULT ''
+                )""")
+            cur.execute("CREATE INDEX IF NOT EXISTS node_session_keys_sid_idx ON node_session_keys(session_id)")
+            c.commit()
+        self._sessions_ensured = True
+
+    def _session_row(self, cur, sid):
+        cur.execute("SELECT * FROM node_sessions WHERE session_id=%s", (sid,))
+        r = cur.fetchone()
+        return dict(r) if r else None
+
+    def _mint(self, cur, sid, uid, now):
+        key = KEY_PREFIX + secrets.token_urlsafe(32)
+        h = key_hash(key)
+        cur.execute("UPDATE node_session_keys SET expires=LEAST(expires, %s), replaced_by=%s"
+                    " WHERE session_id=%s AND revoked=0 AND replaced_by='' AND expires>%s",
+                    (now + GRACE, h[:12], sid, now))
+        cur.execute("INSERT INTO node_session_keys (key_hash, key_hint, session_id, uid, created, expires)"
+                    " VALUES (%s,%s,%s,%s,%s,%s)", (h, key[:10], sid, uid, now, now + TTL))
+        return key, now + TTL
+
+    def op_session_register(self, peer, msg):
+        pid, uid, _ = peer
+        self._ensure()
+        self._ensure_sessions()
+        sid = _sid(msg.get("session_id"))
+        now = int(time.time())
+        with self._conn() as c, c.cursor() as cur:
+            row = self._session_row(cur, sid)
+            if row and row["uid"] != uid:
+                raise ToolError(f"session {sid} belongs to {row['usr']}")
+            node_id = self.node_of.get(uid, "")
+            if row:
+                cur.execute("UPDATE node_sessions SET node_id=%s, harness=%s, label=%s, pid=%s, last_seen=%s,"
+                            " ended=0 WHERE session_id=%s",
+                            (node_id or row["node_id"], str(msg.get("harness") or row["harness"])[:40],
+                             str(msg.get("label") or row["label"])[:200], int(msg.get("pid") or pid), now, sid))
+            else:
+                cur.execute("INSERT INTO node_sessions (session_id, uid, usr, node_id, harness, label, pid, created,"
+                            " last_seen) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s)",
+                            (sid, uid, _user(uid), node_id, str(msg.get("harness") or "")[:40],
+                             str(msg.get("label") or "")[:200], int(msg.get("pid") or pid), now, now))
+            key, expires = self._mint(cur, sid, uid, now)
+            c.commit()
+        self._log_info("session %s registered for %s (node %s)", sid, _user(uid), node_id or "-")
+        return {"session_id": sid, "user": _user(uid), "node_id": node_id, "key": key, "expires": expires}
+
+    def op_session_key(self, peer, msg):
+        """Mint the next key for one of the caller's own sessions (rotation)."""
+        uid = peer[1]
+        self._ensure_sessions()
+        sid = _sid(msg.get("session_id"))
+        now = int(time.time())
+        with self._conn() as c, c.cursor() as cur:
+            row = self._session_row(cur, sid)
+            if not row:
+                raise ToolError(f"no session {sid} — register it first")
+            if row["uid"] != uid:
+                raise ToolError(f"session {sid} belongs to {row['usr']}")
+            if row["ended"]:
+                raise ToolError(f"session {sid} has ended")
+            key, expires = self._mint(cur, sid, uid, now)
+            cur.execute("UPDATE node_sessions SET last_seen=%s WHERE session_id=%s", (now, sid))
+            c.commit()
+        return {"session_id": sid, "key": key, "expires": expires}
+
+    def _check_key(self, key, sid=""):
+        self._ensure_sessions()
+        now = int(time.time())
+        with self._conn() as c, c.cursor() as cur:
+            cur.execute("SELECT k.*, s.ended, s.usr, s.node_id FROM node_session_keys k"
+                        " JOIN node_sessions s ON s.session_id=k.session_id WHERE k.key_hash=%s",
+                        (key_hash(key),))
+            r = cur.fetchone()
+            if not r or r["revoked"] or r["expires"] <= now or r["ended"]:
+                raise ToolError("invalid or expired session key")
+            if sid and r["session_id"] != sid:
+                raise ToolError("the key does not belong to that session")
+            cur.execute("UPDATE node_sessions SET last_seen=%s WHERE session_id=%s", (now, r["session_id"]))
+            c.commit()
+        return dict(r)
+
+    def op_verify_key(self, peer, msg):
+        """A node checks a presented key. A node may only verify its own user's
+        keys; operators (the router) may verify any."""
+        r = self._check_key(msg.get("key"), str(msg.get("session_id") or ""))
+        if peer[1] != r["uid"] and peer[1] not in self.operators:
+            raise ToolError("that key belongs to another user's node")
+        return {"session_id": r["session_id"], "uid": r["uid"], "user": r["usr"],
+                "node_id": self.node_of.get(r["uid"], r["node_id"]), "expires": r["expires"]}
+
+    def op_route(self, peer, msg):
+        """Router: session id + key -> the node url that serves that session."""
+        self._need_operator(peer)
+        sid = _sid(msg.get("session_id"))
+        r = self._check_key(msg.get("key"), sid)
+        node_id = self.node_of.get(r["uid"], "")
+        if not node_id:
+            raise ToolError(f"no node is connected for {r['usr']}")
+        with self._conn() as c, c.cursor() as cur:
+            cur.execute("SELECT url FROM permit_nodes WHERE node_id=%s AND retired=0", (node_id,))
+            n = cur.fetchone()
+        if not n or not n["url"]:
+            raise ToolError(f"node {node_id} has no url")
+        return {"session_id": sid, "user": r["usr"], "node_id": node_id, "url": n["url"],
+                "expires": r["expires"]}
+
+    def op_session_end(self, peer, msg):
+        uid = peer[1]
+        self._ensure_sessions()
+        sid = _sid(msg.get("session_id"))
+        now = int(time.time())
+        with self._conn() as c, c.cursor() as cur:
+            row = self._session_row(cur, sid)
+            if not row:
+                raise ToolError(f"no session {sid}")
+            if row["uid"] != uid and uid not in self.operators:
+                raise ToolError(f"session {sid} belongs to {row['usr']}")
+            cur.execute("UPDATE node_sessions SET ended=%s WHERE session_id=%s", (now, sid))
+            cur.execute("UPDATE node_session_keys SET revoked=%s WHERE session_id=%s AND revoked=0", (now, sid))
+            c.commit()
+        self._log_info("session %s ended by %s", sid, _user(uid))
+        return {"session_id": sid, "ended": now}
+
+    def op_sessions(self, peer, msg):
+        self._ensure_sessions()
+        now = int(time.time())
+        with self._conn() as c, c.cursor() as cur:
+            where = "" if msg.get("all") else " WHERE s.ended=0"
+            cur.execute("SELECT s.*, (SELECT max(expires) FROM node_session_keys k WHERE k.session_id=s.session_id"
+                        " AND k.revoked=0) AS key_expires FROM node_sessions s" + where
+                        + " ORDER BY s.last_seen DESC LIMIT 200")
+            rows = [dict(r) for r in cur.fetchall()]
+        if peer[1] not in self.operators:
+            rows = [r for r in rows if r["uid"] == peer[1]]
+        for r in rows:
+            r["key_live"] = bool(r.get("key_expires") and r["key_expires"] > now)
+        return rows
+
+
+# ──────────────────────────────────────────────────────────
+# Client side
+# ──────────────────────────────────────────────────────────
+def session_id_from_env(environ=None):
+    environ = os.environ if environ is None else environ
+    return next((environ[k].strip() for k in SESSION_ENV if environ.get(k, "").strip()), "")
+
+
+def _key_dir():
+    return os.path.join(os.path.expanduser("~"), ".config", "abstract-toolserver", "sessions")
+
+
+def _key_path(sid):
+    return os.path.join(_key_dir(), _sid(sid) + ".json")
+
+
+def _save(sid, res):
+    os.makedirs(_key_dir(), mode=0o700, exist_ok=True)
+    path = _key_path(sid)
+    tmp = path + ".tmp"
+    fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w") as fh:
+        json.dump({"session_id": sid, "key": res["key"], "expires": res["expires"]}, fh)
+    os.replace(tmp, path)
+
+
+def register(sid, harness="", label=""):
+    from . import permits
+    res = permits.call("session_register", timeout=30, session_id=_sid(sid), harness=harness,
+                       label=label, pid=os.getppid())
+    _save(sid, res)
+    return res
+
+
+def current_key(sid):
+    """The session's key, rotated when within REFRESH_BEFORE of expiry (or
+    registered when this user has never registered the session)."""
+    from . import permits
+    sid = _sid(sid)
+    try:
+        with open(_key_path(sid)) as fh:
+            d = json.load(fh)
+        if d.get("key") and int(d.get("expires") or 0) - time.time() > REFRESH_BEFORE:
+            return d
+    except (OSError, ValueError):
+        d = None
+    try:
+        res = permits.call("session_key", timeout=30, session_id=sid)
+    except ToolError as exc:
+        if "register it first" not in str(exc):
+            raise
+        res = register(sid)
+    _save(sid, res)
+    return res
+
+
+def headers(sid):
+    d = current_key(sid)
+    return {"Authorization": "Bearer " + d["key"], "X-Session-Id": d["session_id"]}
+
+
+def session_headers_or_none(environ=None):
+    """Clients (MCP bridge, ToolserverClient): this session's rotating headers
+    when the process runs inside a session (CLAUDE_CODE_SESSION_ID, …) and the
+    hub can issue a key; None otherwise, so the caller falls back to its static
+    token. TOOLSERVER_SESSION_AUTH=0 turns it off."""
+    environ = os.environ if environ is None else environ
+    if environ.get("TOOLSERVER_SESSION_AUTH", "1").strip().lower() in ("0", "false", "no", "off"):
+        return None
+    sid = session_id_from_env(environ)
+    if not sid or not SESSION_RE.match(sid):
+        return None
+    try:
+        return headers(sid)
+    except (ToolError, OSError, ValueError, KeyError):
+        return None
+
+
+# ── node gate: verify a presented key with the hub (short cache) ─────────
+_cache = {}
+
+
+def verify_for_node(key, sid=""):
+    """{session_id, uid, user, node_id, expires} for a valid key of THIS node's
+    user, else raises ToolError. Cached 30 s per key."""
+    from . import permits
+    h = key_hash(key)
+    now = time.time()
+    hit = _cache.get(h)
+    if hit and hit[1] > now and (not sid or hit[0]["session_id"] == sid):
+        return hit[0]
+    v = permits.call("verify_key", timeout=10, key=key, session_id=sid)
+    if int(v.get("uid", -1)) != os.getuid():
+        raise ToolError("that key belongs to another user's node")
+    _cache[h] = (v, min(now + 30, v["expires"]))
+    if len(_cache) > 1000:
+        _cache.clear()
+    return v
+
+
+def main_session(argv):
+    """abstract-toolserver session register [--hook] [--session ID] [--harness H] [--label L]
+                         headers [--session ID]      JSON headers (MCP headersHelper)
+                         key [--session ID]          the current key (rotates near expiry)
+                         end [--session ID] | list [--all]"""
+    import argparse
+    import sys
+    from . import permits
+    ap = argparse.ArgumentParser(prog="abstract-toolserver session")
+    ap.add_argument("cmd", choices=("register", "headers", "key", "end", "list"))
+    ap.add_argument("--session", default="")
+    ap.add_argument("--hook", action="store_true", help="read the SessionStart hook JSON on stdin")
+    ap.add_argument("--harness", default="")
+    ap.add_argument("--label", default="")
+    ap.add_argument("--all", action="store_true")
+    a = ap.parse_args(argv)
+    sid = a.session
+    harness = a.harness
+    if a.hook:
+        try:
+            hook = json.load(sys.stdin)
+        except ValueError:
+            hook = {}
+        sid = sid or str(hook.get("session_id") or "")
+        harness = harness or ("claude-code" if hook.get("hook_event_name") else "")
+    sid = sid or session_id_from_env()
+    try:
+        if a.cmd == "list":
+            for r in permits.call("sessions", timeout=30, all=a.all):
+                state = "ended" if r["ended"] else ("key live" if r["key_live"] else "key expired")
+                print(f"  {r['session_id']}  {r['usr']:12} {r['node_id'] or '-':20} {r['harness'] or '-':12} {state}")
+            return 0
+        if not sid:
+            print("abstract-toolserver session: no session id (--session, or CLAUDE_CODE_SESSION_ID)",
+                  file=sys.stderr)
+            return 0 if a.hook else 2
+        if a.cmd == "register":
+            res = register(sid, harness=harness, label=a.label)
+            if not a.hook:
+                print(f"registered {res['session_id']} for {res['user']} (node {res['node_id'] or '-'}),"
+                      f" key valid until {time.strftime('%F %T', time.localtime(res['expires']))}")
+            return 0
+        if a.cmd == "headers":
+            print(json.dumps(headers(sid)))
+            return 0
+        if a.cmd == "key":
+            print(current_key(sid)["key"])
+            return 0
+        if a.cmd == "end":
+            permits.call("session_end", timeout=30, session_id=sid)
+            try:
+                os.remove(_key_path(sid))
+            except OSError:
+                pass
+            print(f"ended {sid}")
+            return 0
+    except ToolError as exc:
+        print(f"abstract-toolserver session: {exc}", file=sys.stderr)
+        return 0 if a.hook else 1
+    return 2

{abstract_toolserver-0.0.76 → abstract_toolserver-0.0.78}/src/abstract_toolserver/permits.py

@@ -52,6 +52,7 @@ import threading
 import time
 
 from .gates import ToolError
+from .nodeauth import SessionOps
 
 log = logging.getLogger("abstract_toolserver.permits")
 
@@ -230,7 +231,7 @@ class _AgentConn:
         return reply.get("result")
 
 
-class Hub:
+class Hub(SessionOps):
     def __init__(self, path):
         self.path = path
         self.uid = os.getuid()
@@ -252,6 +253,10 @@ class Hub:
         self.wlock = threading.Lock()
         self._ensured = False
 
+    @staticmethod
+    def _log_info(fmt, *args):
+        log.info("permit " + fmt, *args)
+
     # ── storage ──────────────────────────────────────────
     def _conn(self):
         from . import db