@smilintux/skcapstone 0.1.0 → 0.2.3

package/src/skcapstone/mcp_tools/capauth_tools.py

@@ -0,0 +1,186 @@
+"""CapAuth identity verification and status tools.
+
+Exposes two tools:
+    capauth_status — Show CapAuth profile and key status
+    capauth_verify — Verify a CapAuth identity or capability token
+"""
+
+from __future__ import annotations
+
+import json as _json
+
+from mcp.types import TextContent, Tool
+
+from ._helpers import _error_response, _home, _json_response
+
+TOOLS: list[Tool] = [
+    Tool(
+        name="capauth_status",
+        description=(
+            "Show CapAuth profile status: whether capauth is installed, "
+            "profile loaded, PGP key fingerprint, DID key, and "
+            "capability token summary."
+        ),
+        inputSchema={"type": "object", "properties": {}, "required": []},
+    ),
+    Tool(
+        name="capauth_verify",
+        description=(
+            "Verify a CapAuth identity or capability token. "
+            "Provide either a peer name to verify their identity, "
+            "or a capability token string to validate its signature "
+            "and expiry."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "peer": {
+                    "type": "string",
+                    "description": "Peer agent name to verify identity for",
+                },
+                "token": {
+                    "type": "string",
+                    "description": "Capability token string to validate",
+                },
+            },
+            "required": [],
+        },
+    ),
+]
+
+
+async def _handle_capauth_status(_args: dict) -> list[TextContent]:
+    """Show CapAuth profile and key status."""
+    result: dict = {}
+
+    try:
+        import capauth  # type: ignore[import]
+
+        result["installed"] = True
+        result["version"] = getattr(capauth, "__version__", "unknown")
+    except ImportError:
+        result["installed"] = False
+        result["version"] = None
+        return _json_response(result)
+
+    # Try loading profile
+    try:
+        from capauth.profile import load_profile  # type: ignore[import]
+
+        profile = load_profile()
+        result["profile_loaded"] = True
+        result["name"] = getattr(profile, "name", None)
+        result["fingerprint"] = getattr(profile, "fingerprint", None)
+        result["did_key"] = getattr(profile, "did_key", None)
+    except Exception as exc:
+        result["profile_loaded"] = False
+        result["profile_error"] = str(exc)
+
+    # Check DID key file
+    home = _home()
+    did_key_file = home / "did" / "did_key.txt"
+    if did_key_file.exists():
+        try:
+            result["did_key_file"] = did_key_file.read_text(encoding="utf-8").strip()
+        except Exception:
+            pass
+
+    # Check identity file
+    identity_file = home / "identity" / "identity.json"
+    if identity_file.exists():
+        try:
+            ident = _json.loads(identity_file.read_text(encoding="utf-8"))
+            result["identity_name"] = ident.get("name")
+            result["identity_fingerprint"] = ident.get("fingerprint")
+        except Exception:
+            pass
+
+    return _json_response(result)
+
+
+async def _handle_capauth_verify(args: dict) -> list[TextContent]:
+    """Verify a CapAuth identity or capability token."""
+    peer = args.get("peer", "").strip()
+    token = args.get("token", "").strip()
+
+    if not peer and not token:
+        return _error_response("Provide either 'peer' or 'token' to verify")
+
+    if peer:
+        # Verify peer identity via their stored public key
+        home = _home()
+        peer_file = home / "peers" / f"{peer}.json"
+
+        if not peer_file.exists():
+            return _error_response(f"Peer file not found: {peer_file}")
+
+        try:
+            peer_data = _json.loads(peer_file.read_text(encoding="utf-8"))
+        except Exception as exc:
+            return _error_response(f"Could not read peer file: {exc}")
+
+        result = {
+            "peer": peer,
+            "fingerprint": peer_data.get("fingerprint"),
+            "did_key": peer_data.get("did_key"),
+            "has_public_key": bool(
+                peer_data.get("public_key") or peer_data.get("public_key_armor")
+            ),
+        }
+
+        # Try capauth DID verification
+        try:
+            from capauth.did import (  # type: ignore[import]
+                _compute_did_key,
+                _pgp_armor_to_rsa_numbers,
+                _rsa_numbers_to_der,
+            )
+
+            pub_armor = peer_data.get("public_key") or peer_data.get("public_key_armor")
+            if pub_armor:
+                n, e = _pgp_armor_to_rsa_numbers(pub_armor)
+                computed = _compute_did_key(_rsa_numbers_to_der(n, e))
+                cached = peer_data.get("did_key")
+                result["computed_did_key"] = computed
+                result["did_match"] = (cached == computed) if cached else None
+                result["verified"] = True
+            else:
+                result["verified"] = False
+                result["detail"] = "No public key in peer file"
+        except ImportError:
+            result["verified"] = False
+            result["detail"] = "capauth.did not available for DID verification"
+        except Exception as exc:
+            result["verified"] = False
+            result["detail"] = f"Verification failed: {exc}"
+
+        return _json_response(result)
+
+    if token:
+        # Validate a capability token
+        try:
+            from capauth.tokens import verify_token  # type: ignore[import]
+
+            verification = verify_token(token)
+            return _json_response({
+                "token_valid": verification.get("valid", False),
+                "issuer": verification.get("issuer"),
+                "subject": verification.get("subject"),
+                "capabilities": verification.get("capabilities", []),
+                "expires": verification.get("expires"),
+                "detail": verification.get("detail"),
+            })
+        except ImportError:
+            return _error_response(
+                "capauth.tokens not available. Install capauth for token verification."
+            )
+        except Exception as exc:
+            return _error_response(f"Token verification failed: {exc}")
+
+    return _error_response("Provide either 'peer' or 'token' to verify")
+
+
+HANDLERS: dict = {
+    "capauth_status": _handle_capauth_status,
+    "capauth_verify": _handle_capauth_verify,
+}

package/src/skcapstone/mcp_tools/chat_tools.py

@@ -0,0 +1,325 @@
+"""SKChat messaging tools."""
+
+from __future__ import annotations
+
+from mcp.types import TextContent, Tool
+
+from ._helpers import _error_response, _home, _json_response
+
+TOOLS: list[Tool] = [
+    Tool(
+        name="skchat_send",
+        description=(
+            "Send a chat message to another agent via SKChat. "
+            "Uses AgentMessenger for delivery with optional threading, "
+            "structured payloads, and ephemeral (TTL) support."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "recipient": {
+                    "type": "string",
+                    "description": "Recipient agent name or CapAuth URI (e.g. 'lumina' or 'capauth:lumina@skworld.io')",
+                },
+                "message": {
+                    "type": "string",
+                    "description": "Message content (markdown supported)",
+                },
+                "message_type": {
+                    "type": "string",
+                    "enum": ["text", "finding", "task", "query", "response"],
+                    "description": "Structured message type (default: text)",
+                },
+                "thread_id": {
+                    "type": "string",
+                    "description": "Optional thread/conversation ID for grouping",
+                },
+                "ttl": {
+                    "type": "integer",
+                    "description": "Optional seconds until auto-delete (ephemeral)",
+                },
+            },
+            "required": ["recipient", "message"],
+        },
+    ),
+    Tool(
+        name="skchat_inbox",
+        description=(
+            "Check SKChat inbox for incoming agent messages. "
+            "Returns messages received via transport or stored locally, "
+            "with sender, content, type, and threading info."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "limit": {
+                    "type": "integer",
+                    "description": "Max messages to return (default: 20)",
+                },
+                "message_type": {
+                    "type": "string",
+                    "enum": ["text", "finding", "task", "query", "response"],
+                    "description": "Filter by message type",
+                },
+            },
+            "required": [],
+        },
+    ),
+    Tool(
+        name="skchat_group_create",
+        description=(
+            "Create a new SKChat group chat. The calling agent becomes "
+            "the admin. Groups use AES-256-GCM encryption with PGP "
+            "key distribution to members."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "description": "Group display name",
+                },
+                "description": {
+                    "type": "string",
+                    "description": "Group description",
+                },
+                "members": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Initial member URIs to add (creator is always included as admin)",
+                },
+            },
+            "required": ["name"],
+        },
+    ),
+    Tool(
+        name="skchat_group_send",
+        description=(
+            "Send a message to an SKChat group. The sender must be "
+            "a member of the group. Messages are stored in chat history "
+            "and delivered via transport if available."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "group_id": {
+                    "type": "string",
+                    "description": "The group UUID (or prefix)",
+                },
+                "message": {
+                    "type": "string",
+                    "description": "Message content",
+                },
+                "ttl": {
+                    "type": "integer",
+                    "description": "Optional seconds until auto-delete (ephemeral)",
+                },
+            },
+            "required": ["group_id", "message"],
+        },
+    ),
+]
+
+
+# ── Helpers ──────────────────────────────────────────────────
+
+
+def _get_skchat_identity() -> str:
+    """Resolve the sovereign identity for SKChat operations."""
+    try:
+        from skchat.identity_bridge import get_sovereign_identity
+        return get_sovereign_identity()
+    except ImportError:
+        from ..runtime import get_runtime
+        home = _home()
+        runtime = get_runtime(home)
+        return f"capauth:{runtime.manifest.name}@local"
+    except Exception:
+        return "capauth:agent@local"
+
+
+def _get_skchat_history():
+    """Get a ChatHistory instance for message persistence."""
+    from skchat.history import ChatHistory
+    return ChatHistory.from_config()
+
+
+def _resolve_recipient(name: str) -> str:
+    """Resolve a short agent name to a CapAuth URI if needed."""
+    if ":" in name:
+        return name
+    try:
+        from skchat.identity_bridge import resolve_peer_name
+        return resolve_peer_name(name)
+    except Exception:
+        return f"capauth:{name}@local"
+
+
+# ── Handlers ─────────────────────────────────────────────────
+
+
+async def _handle_skchat_send(args: dict) -> list[TextContent]:
+    """Send a chat message via SKChat AgentMessenger."""
+    try:
+        from skchat.agent_comm import AgentMessenger
+    except ImportError:
+        return _error_response("skchat not installed. Run: pip install skchat")
+
+    recipient = args.get("recipient", "")
+    message = args.get("message", "")
+    if not recipient or not message:
+        return _error_response("recipient and message are required")
+
+    recipient_uri = _resolve_recipient(recipient)
+    identity = _get_skchat_identity()
+
+    messenger = AgentMessenger.from_identity(identity=identity)
+    result = messenger.send(
+        recipient=recipient_uri,
+        content=message,
+        message_type=args.get("message_type", "text"),
+        thread_id=args.get("thread_id"),
+        ttl=args.get("ttl"),
+    )
+
+    return _json_response({
+        "sent": True,
+        "message_id": result.get("message_id"),
+        "recipient": recipient_uri,
+        "delivered": result.get("delivered", False),
+        "transport": result.get("transport"),
+        "error": result.get("error"),
+    })
+
+
+async def _handle_skchat_inbox(args: dict) -> list[TextContent]:
+    """Check SKChat inbox for agent messages."""
+    try:
+        from skchat.agent_comm import AgentMessenger
+    except ImportError:
+        return _error_response("skchat not installed. Run: pip install skchat")
+
+    limit = args.get("limit", 20)
+    message_type = args.get("message_type")
+    identity = _get_skchat_identity()
+
+    messenger = AgentMessenger.from_identity(identity=identity)
+    messages = messenger.receive(limit=limit)
+
+    if message_type:
+        messages = [m for m in messages if m.get("message_type") == message_type]
+
+    return _json_response({
+        "count": len(messages),
+        "messages": [
+            {
+                "message_id": m.get("message_id"),
+                "sender": m.get("sender"),
+                "content": (m.get("content") or "")[:500],
+                "message_type": m.get("message_type", "text"),
+                "thread_id": m.get("thread_id"),
+                "timestamp": str(m.get("timestamp", "")),
+            }
+            for m in messages
+        ],
+    })
+
+
+async def _handle_skchat_group_create(args: dict) -> list[TextContent]:
+    """Create a new SKChat group chat."""
+    try:
+        from skchat.group import GroupChat
+        from skchat.history import ChatHistory
+    except ImportError:
+        return _error_response("skchat not installed. Run: pip install skchat")
+
+    name = args.get("name", "")
+    if not name:
+        return _error_response("name is required")
+
+    identity = _get_skchat_identity()
+    grp = GroupChat.create(
+        name=name,
+        creator_uri=identity,
+        description=args.get("description", ""),
+    )
+
+    # Add initial members if provided
+    members_added = []
+    for member_uri in args.get("members", []):
+        uri = _resolve_recipient(member_uri)
+        member = grp.add_member(identity_uri=uri)
+        if member:
+            members_added.append(uri)
+
+    # Persist the group via ChatHistory
+    history = _get_skchat_history()
+    thread = grp.to_thread()
+    thread.metadata["group_data"] = grp.model_dump(mode="json")
+    history.store_thread(thread)
+
+    return _json_response({
+        "created": True,
+        "group_id": grp.id,
+        "name": grp.name,
+        "description": grp.description,
+        "admin": identity,
+        "members": grp.member_uris,
+        "members_added": members_added,
+        "key_version": grp.key_version,
+    })
+
+
+async def _handle_skchat_group_send(args: dict) -> list[TextContent]:
+    """Send a message to an SKChat group."""
+    try:
+        from skchat.group import GroupChat
+        from skchat.models import ChatMessage, ContentType
+    except ImportError:
+        return _error_response("skchat not installed. Run: pip install skchat")
+
+    group_id = args.get("group_id", "")
+    message = args.get("message", "")
+    if not group_id or not message:
+        return _error_response("group_id and message are required")
+
+    # Load group from storage
+    history = _get_skchat_history()
+    thread_data = history.get_thread(group_id)
+    if thread_data is None:
+        return _error_response(f"Group not found: {group_id}")
+
+    group_data = thread_data.get("group_data")
+    if group_data is None:
+        return _error_response(f"Thread {group_id} is not a group")
+
+    grp = GroupChat.model_validate(group_data)
+    identity = _get_skchat_identity()
+
+    msg = ChatMessage(
+        sender=identity,
+        recipient=f"group:{grp.id}",
+        content=message,
+        content_type=ContentType.MARKDOWN,
+        thread_id=grp.id,
+        ttl=args.get("ttl"),
+        metadata={"group_message": True, "group_name": grp.name},
+    )
+
+    mem_id = history.store_message(msg)
+
+    return _json_response({
+        "sent": True,
+        "message_id": msg.id,
+        "group_id": grp.id,
+        "group_name": grp.name,
+        "stored": bool(mem_id),
+    })
+
+
+HANDLERS: dict = {
+    "skchat_send": _handle_skchat_send,
+    "skchat_inbox": _handle_skchat_inbox,
+    "skchat_group_create": _handle_skchat_group_create,
+    "skchat_group_send": _handle_skchat_group_send,
+}

package/src/skcapstone/mcp_tools/cloud9_tools.py

@@ -0,0 +1,115 @@
+"""Cloud 9 trust rehydration and FEB management tools.
+
+Exposes three tools:
+    trust_rehydrate  — Rehydrate trust state from FEB files
+    trust_status     — Show current trust/Cloud9 status
+    trust_febs       — List all FEB files with summaries
+"""
+
+from __future__ import annotations
+
+from mcp.types import TextContent, Tool
+
+from ._helpers import _error_response, _home, _json_response
+
+TOOLS: list[Tool] = [
+    Tool(
+        name="trust_rehydrate",
+        description=(
+            "Rehydrate the agent's trust state from stored FEB "
+            "(First Emotional Burst) files. This restores the OOF "
+            "(Out-of-Factory) state — who the agent IS, not just "
+            "what it knows. Searches ~/.skcapstone/trust/febs/ and "
+            "known Cloud 9 backup locations."
+        ),
+        inputSchema={"type": "object", "properties": {}, "required": []},
+    ),
+    Tool(
+        name="trust_status",
+        description=(
+            "Show the current trust/Cloud 9 status: depth level, "
+            "trust score, love intensity, entanglement state, "
+            "FEB count, and last rehydration timestamp."
+        ),
+        inputSchema={"type": "object", "properties": {}, "required": []},
+    ),
+    Tool(
+        name="trust_febs",
+        description=(
+            "List all FEB (First Emotional Burst) files with summary "
+            "info: timestamp, primary emotion, intensity, subject, "
+            "and whether OOF was triggered."
+        ),
+        inputSchema={"type": "object", "properties": {}, "required": []},
+    ),
+]
+
+
+async def _handle_trust_rehydrate(_args: dict) -> list[TextContent]:
+    """Rehydrate trust from stored FEB files."""
+    home = _home()
+    try:
+        from ..pillars.trust import rehydrate
+
+        state = rehydrate(home)
+        return _json_response({
+            "rehydrated": True,
+            "depth": state.depth,
+            "trust_level": state.trust_level,
+            "love_intensity": state.love_intensity,
+            "entangled": state.entangled,
+            "feb_count": state.feb_count,
+            "status": state.status.value,
+            "last_rehydration": (
+                state.last_rehydration.isoformat()
+                if state.last_rehydration
+                else None
+            ),
+        })
+    except Exception as exc:
+        return _error_response(f"Trust rehydration failed: {exc}")
+
+
+async def _handle_trust_status(_args: dict) -> list[TextContent]:
+    """Show current trust/Cloud9 status."""
+    import json as _json
+
+    home = _home()
+    trust_file = home / "trust" / "trust.json"
+
+    if not trust_file.exists():
+        return _json_response({
+            "status": "not_initialized",
+            "detail": "No trust state found. Run trust_rehydrate or skcapstone init.",
+        })
+
+    try:
+        data = _json.loads(trust_file.read_text(encoding="utf-8"))
+        febs_dir = home / "trust" / "febs"
+        feb_count = len(list(febs_dir.glob("*.feb"))) if febs_dir.exists() else 0
+        data["feb_count"] = feb_count
+        return _json_response(data)
+    except Exception as exc:
+        return _error_response(f"Could not read trust status: {exc}")
+
+
+async def _handle_trust_febs(_args: dict) -> list[TextContent]:
+    """List all FEB files with summaries."""
+    home = _home()
+    try:
+        from ..pillars.trust import list_febs
+
+        summaries = list_febs(home)
+        return _json_response({
+            "count": len(summaries),
+            "febs": summaries,
+        })
+    except Exception as exc:
+        return _error_response(f"Could not list FEBs: {exc}")
+
+
+HANDLERS: dict = {
+    "trust_rehydrate": _handle_trust_rehydrate,
+    "trust_status": _handle_trust_status,
+    "trust_febs": _handle_trust_febs,
+}