@adapt-toolkit/a2adapt 0.2.0 → 0.4.0

package/dist/mufl_code/actor.mu

@@ -1,24 +1,291 @@
-// a2adapt messenger packet — application.
+// a2adapt messenger packet.
 //
-// SCAFFOLD STATUS (v0): placeholder. Implemented in workspace task "3. MUFL
-// messenger packet", modeled on the reference messenger:
-//   /home/shakhvit/work/adapt/messenger-demo/mufl_code/actor.mu      (full, 290 lines)
-//   /home/shakhvit/work/adapt/basic-messenger-demo/mufl_code/actor.mu (minimal)
+// One ADAPT node == one of these packets. Two nodes talk directly, peer to
+// peer, through a relay broker (no central server). Messages are end-to-end
+// encrypted; the key exchange is handled for us by the stdlib `encrypted_channel`
+// library — we only ever address peers by their container id.
 //
-// Simplified to 1:1 direct contacts (no chat groups) for v0.
+// User transactions (each backs one MCP tool):
+//   set_my_name             — set the display name peers see for me
+//   generate_invite         — make a personal invite blob for a named peer
+//   add_contact             — join via an invite blob, reply to the inviter
+//   send_message            — send an e2e-encrypted message to a contact
+//   list_contacts           — (readonly) my contacts
+//   list_incoming_messages  — (readonly) my inbox
 //
-// State to hold in the packet:
-//   - my identity (address_document, via key_storage / get_my_address_document())
-//   - contacts:        container_id ->> ( $name, $address_document )
-//   - pending_invites: invite_id    ->> ( $secret_key, $default_name )
-//   - inbox:           received decrypted messages with sender attribution
+// External transactions (inbound, not exposed as tools):
+//   accept_contact          — inviter learns the joiner's identity + name
+//   receive_message         — store a decrypted inbound message
 //
-// Crypto/identity stdlib to use (see /home/shakhvit/work/adapt/mufl3/mufl_stdlib):
-//   cryptography/key_storage.mm     default_encrypt / default_sign / decrypt_message
-//   _crypto_construct_encryption_keypair, _crypto_encrypt_message, _crypto_decrypt_message
-//   cryptography/address_document.mm, address_document_types.mm
-//   transactions/transaction.mm      transaction::encrypt, transaction::action::send
-//   mufl_stdlib/current_transaction_info.mm  validate_origin_or_abort, is_encrypted, is_signed
-//
-// Named-invite UX: generate_invite embeds $default_name in the invite payload;
-// add_contact uses a custom name if supplied, else the embedded default.
+// Naming model (personal invites): generate_invite('Bob') tags a pending invite
+// with the peer-name "Bob"; whoever redeems it is registered under "Bob" (the
+// inviter's assigned name wins). The joiner, in turn, sees the inviter under the
+// inviter's own self-name (set via set_my_name), unless the joiner overrides it.
+
+application actor loads libraries
+    identity_proof_document,
+    attestation_document,
+    native_attestation_document,
+    transaction_message_decoder,
+    address_document,
+    address_document_types,
+    key_utils,
+    key_storage,
+    continuation,
+    encrypted_channel,
+    current_transaction_info
+    uses transactions
+{
+    hidden
+    {
+        metadef contact_t: ($name -> str, $container_id -> global_id).
+        metadef invite_t: ($invite_id -> global_id, $inviter_id -> global_id, $inviter_name -> str, $inviter_ad -> address_document_types::t_address_document).
+        metadef message_t: ($sender_id -> global_id, $sender_name -> str, $text -> str, $date -> time).
+
+        // Wire the deserialization primitive into the libraries that need it.
+        _read_or_abort = grab( _read_or_abort ).
+        key_storage::init ($_read_or_abort -> _read_or_abort).
+        encrypted_channel::init ($_read_or_abort -> _read_or_abort).
+
+        // ---- packet state ---------------------------------------------------
+        // The display name peers see for me (set via set_my_name).
+        my_name is str = "".
+        // Known contacts, keyed by their container id.
+        contacts is (global_id ->> contact_t) = (,).
+        // Invites I generated, keyed by invite id -> the name I assigned the peer.
+        pending_invites is (global_id ->> str) = (,).
+        // Received messages, append-only (the host tracks how many it surfaced).
+        inbox is message_t[] = [].
+        // Peer address documents, captured when a contact is established. These are
+        // self-signed, code-independent, and seed-stable, so on a code upgrade the
+        // host re-creates this packet from the same seed and import_state replays
+        // them through address_document::process_address_document — re-registering
+        // every peer's keys in key_storage so encrypted channels survive the upgrade
+        // with no re-handshake. Only peer PUBLIC keys travel here, never secrets.
+        peer_ads is (global_id ->> address_document_types::t_address_document) = (,).
+
+        // Signal the host to persist the packet. Only emitted at the end of a
+        // complete procedure — intermediate states (e.g. channel handshake) are
+        // never saved, so a crash mid-handshake restores to the last stable point.
+        fn _save_state (_) = (transaction::action::return_data ($kind -> $save_state)).
+        fn _return_data (payload: any) = (transaction::action::return_data ($kind -> $data, $payload -> payload)).
+        fn _notify_agent (payload: any) = (transaction::action::return_data ($kind -> $notify_agent, $payload -> payload)).
+
+        // Resolve a contact reference (a display name or stringified container id)
+        // to a container id; aborts if no contact matches.
+        fn resolve_contact (ref: str) -> global_id
+        {
+            found is global_id+ = NIL.
+            sc contacts -- (cid -> c) ?? found == NIL && ((c $name) == ref || (_str cid) == ref)
+            {
+                found -> cid.
+            }
+            abort "Unknown contact: " + ref when found == NIL.
+            return found?.
+        }
+    }
+
+    // ---- user transactions --------------------------------------------------
+
+    trn set_my_name _:($name -> name: str)
+    {
+        current_transaction_info::validate_origin_or_abort (transaction::envelope::origin::user,).
+        my_name -> name.
+        return transaction::success [
+            _return_data ($name -> name),
+            _save_state NIL
+        ].
+    }
+
+    trn generate_invite _:($name -> name: str)
+    {
+        current_transaction_info::validate_origin_or_abort (transaction::envelope::origin::user,).
+
+        invite_id = _new_id "a2adapt invite".
+        // Remember the name I'm assigning to whoever redeems this invite.
+        pending_invites invite_id -> name.
+
+        invite is invite_t = (
+            $invite_id   -> invite_id,
+            $inviter_id  -> _get_container_id(),
+            $inviter_name -> my_name,
+            // Embed my address document so the joiner can store it and re-register
+            // me after a code upgrade (see peer_ads / import_state).
+            $inviter_ad  -> address_document::get_my_address_document()
+        ).
+
+        return transaction::success [
+            _return_data (
+                $invite     -> (_write invite),
+                $invite_id  -> invite_id,
+                $peer_name  -> name
+            ),
+            _save_state NIL
+        ].
+    }
+
+    trn add_contact _:($invite -> invite_blob: bin, $name -> custom_name: str+)
+    {
+        current_transaction_info::validate_origin_or_abort (transaction::envelope::origin::user,).
+
+        invite = (_read_or_abort invite_blob) safe invite_t.
+        inviter_id = invite $inviter_id.
+        abort "This invite is your own — you cannot add yourself." when inviter_id == _get_container_id().
+
+        // Register the inviter under my chosen name, or the name they embedded.
+        contact_name = (custom_name == NIL ?? (invite $inviter_name) ; custom_name?).
+        contacts inviter_id -> ($name -> contact_name, $container_id -> inviter_id).
+        // Remember the inviter's address document so I can re-register them after
+        // an upgrade (their keys are seed-stable, so this stays valid).
+        peer_ads inviter_id -> invite $inviter_ad.
+
+        invite_id = invite $invite_id.
+        my_self_name = my_name.
+        my_ad = address_document::get_my_address_document().
+
+        // Establish the encrypted channel with the inviter (handshake happens
+        // transparently if we haven't talked before), then tell them I redeemed
+        // their invite, what my own name is, and my address document, so they can
+        // finish the handshake and remember me for future upgrades.
+        return encrypted_channel::execute_transaction inviter_id (fn (_) -> transaction::results::type {
+            return transaction::success [
+                encrypted_channel::send_encrypted_tx inviter_id (
+                    $name -> "::actor::accept_contact",
+                    $targ -> ($invite_id -> invite_id, $joiner_name -> my_self_name, $joiner_ad -> my_ad)
+                ),
+                _return_data ($added -> contact_name, $container_id -> inviter_id),
+                _save_state NIL
+            ].
+        }).
+    }
+
+    trn send_message _:($contact -> contact_ref: str, $text -> text: str)
+    {
+        current_transaction_info::validate_origin_or_abort (transaction::envelope::origin::user,).
+
+        target_id = resolve_contact contact_ref.
+
+        return encrypted_channel::execute_transaction target_id (fn (_) -> transaction::results::type {
+            return transaction::success [
+                encrypted_channel::send_encrypted_tx target_id (
+                    $name -> "::actor::receive_message",
+                    $targ -> ($text -> text)
+                ),
+                _return_data ($sent_to -> target_id, $text -> text),
+                _save_state NIL
+            ].
+        }).
+    }
+
+    trn readonly list_contacts _
+    {
+        return contacts.
+    }
+
+    trn readonly list_incoming_messages _
+    {
+        return inbox.
+    }
+
+    // ---- upgrade: state export / import -------------------------------------
+    // The host persists state by calling export_state (readonly) and serializing
+    // the returned value to a code-independent blob. On a code upgrade it recreates
+    // this packet from the same seed (same container id + same default keys, since
+    // both derive from the seed) and replays the blob through import_state.
+    //
+    // The packet-level snapshot is NOT used for upgrades: it is bound to the unit
+    // code hash, so a new .muflo cannot load an old snapshot. This data blob is.
+
+    trn readonly export_state _
+    {
+        return (
+            $my_name         -> my_name,
+            $contacts        -> contacts,
+            $pending_invites -> pending_invites,
+            $inbox           -> inbox,
+            $peer_ads        -> peer_ads
+        ).
+    }
+
+    trn import_state data: any
+    {
+        current_transaction_info::validate_origin_or_abort (transaction::envelope::origin::user,).
+
+        d = data safe (
+            $my_name         -> str,
+            $contacts        -> (global_id ->> contact_t),
+            $pending_invites -> (global_id ->> str),
+            $inbox           -> message_t[],
+            $peer_ads        -> (global_id ->> address_document_types::t_address_document)
+        ).
+
+        my_name         -> d $my_name.
+        contacts        -> d $contacts.
+        pending_invites -> d $pending_invites.
+        inbox           -> d $inbox.
+        peer_ads        -> d $peer_ads.
+
+        // Re-register every peer's keys so encrypted channels keep working after
+        // the upgrade — no handshake needed (my own keys are unchanged, and the
+        // peers' self-signed address documents re-authorize on this fresh packet).
+        sc peer_ads -- ( -> ad)
+        {
+            address_document::process_address_document ad TRUE.
+        }
+
+        return transaction::success [
+            _return_data ($imported -> TRUE, $contacts -> _count contacts|, $peers -> _count peer_ads|),
+            _save_state NIL
+        ].
+    }
+
+    // ---- external (inbound) transactions ------------------------------------
+
+    trn accept_contact _:($invite_id -> invite_id: global_id, $joiner_name -> joiner_name: str, $joiner_ad -> joiner_ad: address_document_types::t_address_document)
+    {
+        current_transaction_info::validate_origin_or_abort (transaction::envelope::origin::external,).
+        encrypted_channel::check_encrypted_or_abort().
+
+        sender_id = current_transaction_info::get_external_envelope_or_abort() $from.
+
+        // The name I assigned when I generated the invite wins; fall back to the
+        // joiner's self-name if this invite is unknown (shouldn't happen).
+        assigned_name = pending_invites invite_id.
+        contact_name = (assigned_name == NIL ?? joiner_name ; assigned_name?).
+
+        contacts sender_id -> ($name -> contact_name, $container_id -> sender_id).
+        // Remember the joiner's address document for upgrade-time re-registration.
+        peer_ads sender_id -> joiner_ad.
+        if pending_invites invite_id != NIL { delete pending_invites invite_id. }
+
+        return transaction::success [
+            _notify_agent ($event -> $contact_accepted, $name -> contact_name, $container_id -> sender_id),
+            _save_state NIL
+        ].
+    }
+
+    trn receive_message _:($text -> text: str)
+    {
+        current_transaction_info::validate_origin_or_abort (transaction::envelope::origin::external,).
+        encrypted_channel::check_encrypted_or_abort().
+
+        sender_id = current_transaction_info::get_external_envelope_or_abort() $from.
+        sender = contacts sender_id.
+        abort "Message from an unknown sender was rejected." when sender == NIL.
+
+        sender_name = sender? $name.
+        msg_date = current_transaction_info::get_transaction_time().
+
+        inbox (_count inbox|) -> (
+            $sender_id   -> sender_id,
+            $sender_name -> sender_name,
+            $text        -> text,
+            $date        -> msg_date
+        ).
+
+        return transaction::success [
+            _notify_agent ($event -> $message_received, $sender_name -> sender_name, $text -> text, $date -> msg_date),
+            _save_state NIL
+        ].
+    }
+}

package/dist/mufl_code/config.mufl

@@ -1,19 +1,22 @@
-// a2adapt messenger packet — build configuration.
+// a2adapt messenger packet — compile configuration.
 //
-// Loads the ADAPT standard library and declares the application entry module
-// (actor.mu) plus the exported user transactions that the MCP server invokes.
+// Pulls in the full ADAPT standard library so `actor.mu` can `loads libraries`
+// the crypto / identity / transport modules by name. No app-private libraries
+// (everything we need lives in the stdlib, including `encrypted_channel`, which
+// does the peer key-exchange for us).
 //
-// SCAFFOLD STATUS (v0): placeholder. The real config + actor are written in
-// workspace task "3. MUFL messenger packet", modeled on
-// /home/shakhvit/work/adapt/messenger-demo/mufl_code/{config.mufl,actor.mu}.
-//
-// Expected exported transactions (each maps to one MCP tool):
-//   ::actor::generate_invite        (name)            -> invite blob
-//   ::actor::add_contact            (invite, name?)   -> contact registered
-//   ::actor::accept_contact         (inbound)         -> reciprocal registration (TOFU)
-//   ::actor::send_message           (contact, text)   -> encrypted send
-//   ::actor::receive_message        (inbound)         -> append to inbox
-//   ::actor::list_contacts          ()                -> contacts
-//   ::actor::list_incoming_messages ()                -> inbox
-//
-// Compile (task 3): mufl-compile -f config.mufl -repo <out>  ->  <hash>.muflo
+// Compile:
+//   MUFL_STDLIB_PATH=<adapt-toolkit>/mufl_stdlib \
+//     mufl-compile -mp <adapt-toolkit>/meta -mp <adapt-toolkit>/transactions -d-c actor.mu
+// -> emits <content-hash>.muflo in the cwd.
+
+config script
+{
+    (
+        $imports -> ((config_load #$MUFL_STDLIB_PATH) $exports),
+        $exports -> (
+            $libraries -> (,),
+            $applications -> (,)
+        )
+    ).
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adapt-toolkit/a2adapt",
-  "version": "0.2.0",
-  "description": "MCP server for a2adapt — a native ADAPT node hosting one packet, exposing secure agent-to-agent messaging tools over stdio.",
+  "version": "0.4.0",
+  "description": "MCP server daemon for a2adapt — one native ADAPT wrapper hosting N self-sovereign identities, exposing secure agent-to-agent messaging tools over HTTP (Streamable HTTP). Run `a2adapt-mcp start`.",
   "type": "module",
   "license": "MIT",
   "author": "Adapt Toolkit",
@@ -14,9 +14,17 @@
   "bugs": {
     "url": "https://github.com/adapt-toolkit/a2adapt/issues"
   },
-  "keywords": ["mcp", "model-context-protocol", "claude", "a2a", "adapt", "e2e", "messaging"],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "a2a",
+    "adapt",
+    "e2e",
+    "messaging"
+  ],
   "bin": {
-    "a2adapt-mcp": "dist/index.js"
+    "a2adapt-mcp": "dist/cli.js"
   },
   "files": [
     "dist",
@@ -25,14 +33,25 @@
   "publishConfig": {
     "access": "public"
   },
+  "engines": {
+    "node": ">=20"
+  },
   "scripts": {
     "build": "node build.mjs",
     "build:tsc": "tsc -p tsconfig.json",
-    "dev": "tsx src/index.ts",
-    "start": "node dist/index.js",
+    "dev": "tsx src/cli.ts serve",
+    "dev:stdio": "A2ADAPT_TRANSPORT=stdio tsx src/index.ts",
+    "start": "node dist/cli.js start",
+    "stop": "node dist/cli.js stop",
+    "status": "node dist/cli.js status",
+    "serve": "node dist/cli.js serve",
     "prepublishOnly": "node build.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
+  "dependencies": {
+    "@adapt-toolkit/sdk": "^0.2.2",
+    "@adapt-toolkit/sdk-native": "^0.2.1"
+  },
   "devDependencies": {
     "@modelcontextprotocol/sdk": "^1.0.4",
     "@types/node": "^20.14.0",