Identity & authorization

Public allowlisted publisher (rage.pythai.net)

Verify the live state any time with:

sudo -u mindx /home/mindx/mindX/.mindx_env/bin/python \
    -m agents.wordpress_agent.scripts.cross_check_allowlist
crosscheck: OK — vault wallet 0x5277…ce534 IS allowlisted (maps to wp_user_id=6)

External wallets that want to authorize a publish go through POST /publish/rage/challenge → /authorize and must additionally appear in the WORDPRESS_PUBLISHER_ADDRESSES allowlist (stored as a vault entry, exported as an env var at process start). The canonical publisher above is the only entry required for mindX's internal publishes; external wallets are add-on.

Two layers of identity on every post

Every published post carries two layers of identity:

• meta._mindx_authorized_by — the external wallet that requested the publish.

• meta._mindx_signer + meta._mindx_signature — wordpress.agent's own

• meta._mindx_content_hash — sha256 of the HTML body.

The vault namespace — wordpress.agent.keys

All wordpress.agent secrets share one HKDF-isolated context, separate from every other credential in the vault and not in PROVIDER_ENV_MAP (so they are never decrypted into any process env at startup):

The only wordpress-related entry that's env-mapped:

One-time provisioning

Run on the VPS as the mindx user (vault writer):

sudo -u mindx /home/mindx/mindX/.mindx_env/bin/python \
    /home/mindx/mindX/scripts/vault/provision_wordpress_agent.py \
    --wp-base-url https://rage.pythai.net \
    --wp-user codephreak \
    --publisher-addresses 0xAaa...,0xBbb...
(prompts for the WordPress Application Password via getpass — never on argv)

This mints the wordpress.agent wallet (Account.create()), stores wordpress.agent:pk + :address under context="wordpress.agent.keys", writes the address into data/identity/production_registry.json under agents["wordpress.agent"], stores the WP creds in the same namespace, and seeds the allowlist. Idempotent; safe to re-run (existing wallet is preserved).

Deploy the loopback service

sudo bash /home/mindx/mindX/agents/wordpress_agent/scripts/install.sh
sudo systemctl restart wordpress-agent.service
curl -s http://127.0.0.1:8765/healthz | jq

The unit runs as User=mindx (so it shares mindX's vault), with hardening: NoNewPrivileges, ProtectSystem=strict, MemoryDenyWriteExecute, MemoryMax=256M, ReadWritePaths scoped to the vault dir + data/. Blast radius: this service can read the vault — that's the accepted tradeoff for decrypt-on-demand. The optional /etc/wordpress-agent/wordpress-agent.env holds only non-secret operational overrides (binding host/port, timeouts).

Publishing — three paths

1. Public, wallet-authorized (recommended):

# 1. compute the content hash you'll sign (server recomputes from rendered HTML)
HTML=$(curl -s …or render the doc however you like…)
CONTENT_SHA256=0x$(printf %s "$HTML" | sha256sum | awk '{print $1}')

2. request a challenge
curl -s -X POST https://mindx.pythai.net/publish/rage/challenge \
  -H 'Content-Type: application/json' \
  -d "{\"wallet_address\":\"0xAaa...\",\"title\":\"My post\",\"content_sha256\":\"$CONTENT_SHA256\"}"
→ {"nonce":"0x…","message":"MINDX-SHADOW-OVERLORD scope=wordpress.publish\nnonce: 0x…\ncontent_sha256: 0x…\ntitle: My post\nwallet: 0xaaa…","expires_at":…}
3. sign message with that wallet (EIP-191), then authorize:
curl -s -X POST https://mindx.pythai.net/publish/rage/authorize \
  -H 'Content-Type: application/json' \
  -d '{"wallet_address":"0xAaa...","nonce":"0x...","signature":"0x...130-hex...","title":"My post","status":"draft","doc_path":"publications/machine_dreaming_explained.md"}'
→ {"status":"ok","authorized_by":"0xaaa…","wordpress":{"post_id":…,"url":"…","status":"draft",…}}

Body of /publish/rage/authorize accepts exactly one of doc_path (markdown file under docs/), markdown (inline), or html (pre-rendered). The server renders markdown→HTML via _render_md, computes the content hash, and verifies it matches what the wallet signed (the nonce is bound to that hash).

2. Operator path (admin-gated): POST /admin/publish-to-rage — unchanged from before; for one-off publishes by the mindX admin.

3. CLI (direct to the loopback service, bypassing wallet auth):

python -m agents.wordpress_agent.cli publish \
    --title "My post" --status draft --content-file post.html

The CLI is for local dev / emergencies. The service still reads its creds from the vault.

Diagnostics

GET /diagnostics/live exposes (under author.):

# 0. Is the loopback alive?
systemctl status wordpress-agent.service
curl -s http://127.0.0.1:8765/healthz
(healthz being 401 is a known cosmetic bug — it skips _request_with_retry's
auth header. The /publish path uses _request_with_retry correctly. Trust
the cross-check, not healthz, for true auth verification.)
1. Run the cross-check (exits 0 if vault wallet is allowlisted)
cd /home/mindx/mindX
sudo -u mindx /home/mindx/mindX/.mindx_env/bin/python -m agents.wordpress_agent.scripts.cross_check_allowlist
Prints: vault wallet address, allowlist_entries count, verify status.
Exit 1 → REMEDIATION line tells you to either add the address to the WP
allowlist OR restore the matching pk into vault.
2. If allowlist mismatch — add the cross-check address to the plugin allowlist
   via rage.pythai.net WP admin → Settings → mindX Publish Auth → Allowlist.
   Then re-run step 1 until it exits 0.
3. If vault is missing wordpress.agent:pk — re-provision:
sudo -u mindx /home/mindx/mindX/.mindx_env/bin/python scripts/vault/provision_wordpress_agent.py \
  --wp-base-url https://rage.pythai.net --wp-user codephreak \
  --wp-app-password JWT_AUTH_ONLY_DO_NOT_USE_BASIC --no-mint
(--no-mint reuses the existing wordpress.agent wallet; drop the flag to mint a
 new one, which then needs to be added to the WP allowlist.)
4. Restart and confirm
systemctl restart wordpress-agent.service
journalctl -u wordpress-agent.service -n 10 | grep crosscheck
Expect: "crosscheck: OK — vault wallet 0x... IS allowlisted"
5. Publish (canonical example)
cd /home/mindx/mindX && sudo -u mindx /home/mindx/mindX/.mindx_env/bin/python -c "
import asyncio, sys; sys.path.insert(0, '/home/mindx/mindX')
from pathlib import Path
from agents.author_agent import AuthorAgent
from mindx_backend_service.main_service import _render_md
async def m():
    md = Path('docs/publications/YOUR_ARTICLE.md').read_text()
    body = md.split(chr(10) + '---', 2)[2] if md.startswith('---') else md
    a = await AuthorAgent.get_instance()
    print(await a.publish_to_rage(
        title='Title here', content_html=_render_md(body),
        status='publish', slug='your-slug',
    ))
asyncio.run(m())
"

• the derived address of wordpress.agent:pk (public, never the pk)
• the plugin's allowlist_entries count* (never the addresses)
• the /verify HTTP status code (200 / 403 / etc.) and the plugin's code

No private key value ever appears in stdout, stderr, journal, or systemd status output.