Compare commits
15 Commits
bf0884527e
..
master
| Author | SHA1 | Date | |
|---|---|---|---|
 egutierrez
|
59705b5a4f | ||
|
egutierrez
|
63ebc1eed9 | ||
|
egutierrez
|
893df42d29 | ||
|
egutierrez
|
c142b3a025 | ||
|
egutierrez
|
45d12e03aa | ||
|
egutierrez
|
3049265230 | ||
|
egutierrez
|
6c4baf1397 | ||
|
egutierrez
|
5fbf319172 | ||
|
egutierrez
|
5e9bf4e777 | ||
|
egutierrez
|
103a7f2f05 | ||
|
egutierrez
|
1dc8b6257a | ||
|
egutierrez
|
f8b2bf8e9e | ||
|
egutierrez
|
e8850d8965 | ||
|
egutierrez
|
e12894099f | ||
 agent
|
3f52167b04 |
@@ -1,123 +1,144 @@
|
||||
---
|
||||
name: uniweb
|
||||
lang: go
|
||||
lang: ts
|
||||
domain: infra
|
||||
version: 0.2.0
|
||||
description: "Frontend web del bus unibus: SPA de chat (React+Mantine) con wallet por usuario (BIP39) + gateway Go (REST+SSE) que actúa de peer del bus para el navegador."
|
||||
tags: [service, messaging, web, frontend, e2e]
|
||||
uses_functions:
|
||||
- generate_identity_go_cybersecurity
|
||||
- seal_aead_go_cybersecurity
|
||||
- open_aead_go_cybersecurity
|
||||
- seal_key_box_go_cybersecurity
|
||||
- open_key_box_go_cybersecurity
|
||||
- sign_ed25519_go_cybersecurity
|
||||
- verify_ed25519_go_cybersecurity
|
||||
version: 0.6.0
|
||||
description: "Cliente web browser-nativo del bus unibus: SPA de chat (React+Mantine) con wallet por usuario (BIP39) que habla DIRECTO al bus (nats.ws + control-plane HTTPS firmado), sin gateway. La clave privada nunca sale del navegador."
|
||||
tags: [messaging, web, frontend, e2e]
|
||||
uses_functions: []
|
||||
uses_types: []
|
||||
framework: "react"
|
||||
entry_point: "cmd/webgw"
|
||||
entry_point: "web/src/main.tsx"
|
||||
dir_path: "projects/message_bus/apps/uniweb"
|
||||
repo_url: "https://gitea-dgg044oo04woo4ggcsws4gk0.organic-machine.com/dataforge/uniweb"
|
||||
icon:
|
||||
phosphor: "chats-circle"
|
||||
accent: "#6366f1"
|
||||
service:
|
||||
port: 8481
|
||||
health_endpoint: null
|
||||
health_timeout_s: 3
|
||||
systemd_unit: null
|
||||
systemd_scope: null
|
||||
restart_policy: always
|
||||
runtime: manual
|
||||
pc_targets:
|
||||
- lucas-linux
|
||||
is_local_only: false
|
||||
e2e_checks:
|
||||
- id: build
|
||||
cmd: "CGO_ENABLED=0 go build ./..."
|
||||
- id: typecheck
|
||||
cmd: "cd web && pnpm install --frozen-lockfile && pnpm exec tsc --noEmit -p tsconfig.app.json"
|
||||
timeout_s: 180
|
||||
- id: vet
|
||||
cmd: "CGO_ENABLED=0 go vet ./..."
|
||||
timeout_s: 120
|
||||
- id: unit
|
||||
cmd: "CGO_ENABLED=0 go test ./..."
|
||||
cmd: "cd web && pnpm test"
|
||||
timeout_s: 120
|
||||
- id: web_build
|
||||
cmd: "cd web && pnpm install --frozen-lockfile && pnpm build"
|
||||
cmd: "cd web && pnpm build"
|
||||
timeout_s: 180
|
||||
---
|
||||
|
||||
## Qué es
|
||||
|
||||
`uniweb` es el frontend web del bus [unibus](../unibus/app.md): la interfaz que un humano
|
||||
usa desde el navegador para hablar por el bus. Se separó de `unibus` (v0.13.0) para que el
|
||||
plano del bus (membresía, claves, librería cliente) quede limpio y el frontend tenga su
|
||||
propia carpeta de servicio y su propio ciclo de release.
|
||||
`uniweb` es el **cliente web browser-nativo** del bus [unibus](../unibus/app.md): la interfaz
|
||||
que un humano usa desde el navegador para hablar por el bus. Es **solo frontend** (`web/`) —
|
||||
una SPA, sin backend Go, sin gateway. Habla **directamente** con el bus, igual que
|
||||
`unibus_android` lo hace en Kotlin:
|
||||
|
||||
Tiene dos mitades que viven juntas:
|
||||
- **Control plane** — HTTPS firmado al `membershipd` (rooms, claves, miembros). Cada request
|
||||
lleva la firma Ed25519 del usuario (cabeceras `X-Unibus-*`).
|
||||
- **Data plane** — NATS sobre WebSocket (`nats.ws`), autenticado con el nkey derivado de la
|
||||
identidad del usuario.
|
||||
|
||||
- **SPA (`web/`)** — React 18 + Vite + Mantine v9. Pantallas de chat y onboarding wallet
|
||||
(join por invitación, login por passphrase local, recover por mnemónica). La identidad
|
||||
criptográfica de cada usuario se deriva de forma determinista de una frase BIP39 de 12
|
||||
palabras y se cifra at-rest en el dispositivo (AES-256-GCM); la clave privada nunca viaja
|
||||
al servidor en claro.
|
||||
- **Gateway (`cmd/webgw`)** — binario Go (`package main`, REST + SSE) que actúa como peer
|
||||
del bus en nombre del navegador. Mantiene una sesión wallet por usuario, registra claves
|
||||
públicas por token de invitación, y traduce HTTP/SSE ↔ el protocolo del bus usando la
|
||||
librería cliente de unibus.
|
||||
Stack: React 18 + Vite + Mantine v9. La identidad criptográfica de cada usuario se deriva de
|
||||
forma determinista de una frase BIP39 de 12 palabras y se cifra at-rest en el dispositivo
|
||||
(AES-256-GCM). **La clave privada nunca sale del navegador**: firma, sella y descifra en el
|
||||
cliente. No hay servidor al que enviarla.
|
||||
|
||||
## Cómo se acopla a unibus
|
||||
## El SDK del bus (`web/src/bus/`)
|
||||
|
||||
`uniweb` consume `unibus` como **módulo Go**, no reimplementa nada del bus:
|
||||
El protocolo y el cifrado E2E del bus están **portados a TypeScript**, validados byte a byte
|
||||
contra la implementación Go de referencia (vectores de `unibus cmd/busvectors`):
|
||||
|
||||
```
|
||||
replace github.com/enmanuel/unibus => ../unibus # pkg/{busauth,client,frame,room}
|
||||
replace fn-registry => ../../../../ # functions/cybersecurity
|
||||
```
|
||||
- `crypto.ts` — Ed25519, ChaCha20-Poly1305, sealed box (nonce BLAKE2b, igual que Go).
|
||||
- `frame.ts` — wire format = `encoding/json` de Go byte a byte.
|
||||
- `room.ts` — Policy (ModeNATS / ModeMatrix).
|
||||
- `busauth.ts` — nkey NATS (base32 + crc16) + firma de requests del control-plane.
|
||||
- `client.ts` — envelope de room + `BusClient` + `ControlPlane` HTTP firmado.
|
||||
- `wstransport.ts` — transporte `nats.ws`.
|
||||
|
||||
Los `replace` no son transitivos en Go, así que `uniweb` (módulo principal) declara los dos:
|
||||
el de `unibus` (de donde importa la librería cliente) y el de `fn-registry` (de donde
|
||||
`pkg/client` toma las primitivas de cifrado). Compila con `CGO_ENABLED=0` igual que unibus.
|
||||
`busService.ts` es la capa de datos de la SPA sobre el SDK (reemplazó al viejo módulo `api`
|
||||
que hablaba con el gateway). Ya **no depende de `unibus` como módulo Go**: el desacople es
|
||||
total.
|
||||
|
||||
## Ejemplo
|
||||
|
||||
```bash
|
||||
# 1. Backend: el control-plane del bus (en la carpeta de unibus)
|
||||
cd ../unibus && CGO_ENABLED=0 go run ./cmd/membershipd # :8470
|
||||
# Producción: SPA same-origin detrás de Caddy, que sirve la SPA + /api + /nats.
|
||||
# Build estático y despliegue de web/dist:
|
||||
cd web && pnpm install
|
||||
pnpm build # genera web/dist (se despliega a magnus:/opt/uniweb/dist)
|
||||
|
||||
# 2. Build de la SPA
|
||||
cd web && pnpm install && pnpm build # genera web/dist
|
||||
|
||||
# 3. Gateway sirviendo la SPA + API contra el control-plane
|
||||
cd .. && CGO_ENABLED=0 go run ./cmd/webgw \
|
||||
--port 8481 --ctrl-url http://127.0.0.1:8470 --web-dir web/dist
|
||||
# Navegador: http://127.0.0.1:8481
|
||||
|
||||
# Desarrollo de la SPA con hot-reload (gateway en modo API-only, sin --web-dir):
|
||||
cd web && pnpm dev # vite proxya /api + /stream al gateway
|
||||
# Dev (`pnpm dev`): el dev server NO tiene el proxy de Caddy, así que /api y /nats no
|
||||
# existen en localhost. Apunta la SPA a un nodo real del cluster con las env vars
|
||||
# (overrides del default same-origin). El dev server corre en el puerto 5174:
|
||||
VITE_BUS_HTTP=https://<nodo>:8470 VITE_BUS_WS=wss://<nodo>:8480 pnpm dev
|
||||
# Navegador: http://localhost:5174
|
||||
# (Añade http://localhost:5174 a la --cors-origins del nodo, o el control-plane
|
||||
# rechazará la petición por CORS.)
|
||||
```
|
||||
|
||||
## Cuándo usarla
|
||||
|
||||
Cuando quieras que un humano hable por el bus desde un navegador, o cuando trabajes en la UI
|
||||
de chat / el onboarding wallet. Para la lógica del bus en sí (membresía, claves, peers
|
||||
programáticos) ve a `unibus`; `uniweb` solo es la capa web encima.
|
||||
programáticos) ve a `unibus`; `uniweb` es el cliente web encima.
|
||||
|
||||
## Gotchas
|
||||
|
||||
- El gateway necesita el control-plane de unibus vivo (`--ctrl-url`, por defecto
|
||||
`http://127.0.0.1:8470`); si no, las sesiones fallan al abrir el peer.
|
||||
- `--web-dir` es **opcional**: vacío = API-only (úsalo con el dev server de vite); apuntando a
|
||||
`web/dist` = sirve la SPA buildeada. Un path inválido degrada a API-only con un WARN, no
|
||||
peta.
|
||||
- Build cross-repo: `uniweb` no compila si `../unibus` no está presente en disco (el `replace`
|
||||
es local). Para deploy hay que llevar ambos repos, o vendorizar unibus.
|
||||
- **`wss://` con CA self-signed**: el cluster sirve el WebSocket con el cert del bus (CA
|
||||
propia). Un navegador rechaza `wss://` self-signed salvo que se importe la CA o se ponga un
|
||||
reverse proxy con cert válido (Let's Encrypt). En dev se puede aceptar el cert a mano.
|
||||
- **Onboarding admin-side**: el bus no tiene endpoint de auto-registro (el viejo gateway lo
|
||||
*mockeaba*). En `enforce`, una identidad nueva debe ser autorizada por un admin
|
||||
(`membershipd user add`) antes de poder abrir sesión; el flujo de Join muestra la clave
|
||||
pública del usuario para que un admin la autorice.
|
||||
- **CORS / same-origin**: en producción la SPA es same-origin detrás de Caddy (`/api` y
|
||||
`/nats` proxyados), así que no hay CORS. En dev (`pnpm dev`, puerto 5174) esos paths
|
||||
relativos no existen: hay que apuntar a un nodo con `VITE_BUS_HTTP`/`VITE_BUS_WS` y
|
||||
añadir `http://localhost:5174` a la `--cors-origins` del nodo. El puerto 5173 está
|
||||
reservado a otra app local; si 5174 está ocupado, Vite usa el siguiente libre.
|
||||
- La passphrase del wallet nunca se guarda ni se envía; perderla en un dispositivo sin la
|
||||
mnemónica BIP39 = identidad irrecuperable en ese dispositivo (recuperable en otro con las 12
|
||||
palabras).
|
||||
|
||||
## Capability growth log
|
||||
|
||||
- v0.6.0 (2026-06-14) — carga el histórico de cada room (`GET /api/rooms/{id}/history`) al
|
||||
abrirla, con dedup vs live; recargar ya no pierde los mensajes. `ControlPlane.fetchHistory`
|
||||
pega al control-plane (firmado, mismas cabeceras `X-Unibus-*`) y decodifica cada frame de
|
||||
base64-std; `BusClient.history` lo descifra/verifica con el MISMO camino de envelope que
|
||||
`subscribe` (refactor: helper privado `openFrame` compartido por ambos). En `busService`,
|
||||
`bus.subscribeRoom` (que usa `ChatPanel`) ahora siembra la room con su historia y sigue en
|
||||
vivo: dedup por `frame.id` con un `Set` por room y los mensajes live se bufferean hasta que
|
||||
la historia (oldest->newest) se entrega, garantizando el orden; si el endpoint falta
|
||||
(404/500) cae a live-only como antes. El ts de cada mensaje se deriva del ULID `msgID`
|
||||
(`ulidTime`, inverso de `newULID`) para que historia y live compartan reloj y ordenen bien;
|
||||
`ChatPanel` ordena por ts. El sidebar siembra su preview con `history(id, 1)` (sin traer
|
||||
todo), manteniendo el fallback "—" para rooms vacías. `tsc` + 23 unit (incluye `ulid.test.ts`)
|
||||
+ `pnpm build` verdes.
|
||||
- v0.5.0 (2026-06-14) — nombres legibles en mensajes + sidebar con último mensaje/hora
|
||||
reales + `pnpm dev` documentado. (1) Los mensajes muestran el **handle** del remitente en
|
||||
vez del endpoint id: `ControlPlane.fetchDirectory()` pega al control-plane
|
||||
`GET /api/directory` (firmado) y `busService` mantiene un mapa `endpoint -> handle`
|
||||
(cargado al abrir sesión, refrescado tras `createRoom`); el resolver
|
||||
`bus.displayName(endpoint)` devuelve el handle o un id corto de fallback (nunca el
|
||||
endpoint largo), usado en la cabecera y el avatar de `ChatPanel` (el endpoint queda en un
|
||||
`title` para depurar). Resiliente: si el endpoint aún no existe en el cluster (404) el
|
||||
mapa queda vacío y el chat funciona igual que antes. (2) El sidebar muestra el **último
|
||||
mensaje y la hora reales**: `busService` posee un store de rooms con una suscripción de
|
||||
metadatos por room (último mensaje/hora + unread de rooms no activas); `Sidebar` ya no
|
||||
pinta el "01:00" de epoch-0. (3) `pnpm dev` queda usable tras el cambio a same-origin:
|
||||
apunta a un nodo con `VITE_BUS_HTTP`/`VITE_BUS_WS` y el dev server corre en el puerto 5174
|
||||
(documentado en `app.md` + `vite.config.ts`). `tsc` + 19/19 unit + `pnpm build` verdes.
|
||||
- v0.3.0 (2026-06-14) — `uniweb` se vuelve **cliente browser-nativo puro** (issue 0001, Fase
|
||||
2): la SPA se cablea al SDK del bus (`busService.ts` reemplaza el módulo `api`) y se
|
||||
**elimina el gateway Go** (`cmd/webgw`, `go.mod`, `go.sum`). `uniweb` queda como solo `web/`,
|
||||
sin nada de Go, sin dependencia de `unibus` como módulo. La clave privada se usa solo en el
|
||||
navegador (`saveAndOpen`/`unlockAndOpen` abren la sesión localmente; ya NO se hace
|
||||
`POST /api/session` con la privada — se cierra el agujero E2E del modelo gateway). Validado
|
||||
end-to-end contra el cluster descentralizado real (Fase 3): identidad registrada conecta por
|
||||
`nats.ws` y hace round-trip de un mensaje cifrado (crear room → publicar → recibir
|
||||
descifrado + firma verificada). El onboarding por token queda admin-side (el bus no tiene
|
||||
auto-registro). `tsc` + `pnpm build` + 19/19 unit verdes.
|
||||
- v0.2.0 (2026-06-13) — SDK del bus en TypeScript (`web/src/bus/`), issue 0001 Fase 1:
|
||||
el protocolo y el cifrado E2E del bus portados al navegador para que `uniweb` deje
|
||||
de depender del gateway Go. Módulos: `crypto.ts` (Ed25519, ChaCha20-Poly1305,
|
||||
|
||||
@@ -1,246 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
cs "fn-registry/functions/cybersecurity"
|
||||
|
||||
"github.com/enmanuel/unibus/pkg/busauth"
|
||||
"github.com/enmanuel/unibus/pkg/client"
|
||||
"github.com/enmanuel/unibus/pkg/frame"
|
||||
"github.com/enmanuel/unibus/pkg/room"
|
||||
)
|
||||
|
||||
// gateway is the live web gateway: it owns the operator's identity and a single
|
||||
// connected unibus client, and turns the bus's crypto-bearing API into the plain
|
||||
// REST/SSE surface the browser consumes. The browser never signs, never speaks
|
||||
// NATS, and never sees a private key — the gateway is the legitimate room member
|
||||
// that seals/opens payloads on the browser's behalf.
|
||||
//
|
||||
// TRUST MODEL: content stays end-to-end encrypted on the wire. The gateway can
|
||||
// read plaintext because it acts AS the operator's client — a real member of
|
||||
// each room, holding the room key K like any peer. It is the same trust a native
|
||||
// desktop client has. In the wallet phase (per-browser WebCrypto identity) the
|
||||
// decryption can move into the browser; today, for the single-operator MVP, the
|
||||
// gateway decrypts server-side and pushes cleartext over a loopback/authenticated
|
||||
// SSE channel.
|
||||
type gateway struct {
|
||||
id cs.Identity
|
||||
endpoint string
|
||||
cli *client.Client
|
||||
refreshACL bool // call RefreshSession after a membership change (needed under a per-subject ACL bus)
|
||||
|
||||
mu sync.Mutex
|
||||
hubs map[string]*roomHub // roomID -> live fan-out of decrypted frames to SSE clients
|
||||
}
|
||||
|
||||
// gatewayConfig wires a live gateway.
|
||||
type gatewayConfig struct {
|
||||
Identity cs.Identity
|
||||
NatsURL string
|
||||
CtrlURL string
|
||||
CtrlURLs []string
|
||||
NatsURLs []string
|
||||
CAPath string // bus CA; empty => plaintext dev connection (matches a loopback membershipd)
|
||||
}
|
||||
|
||||
// newGateway connects the unibus client with the operator identity following the
|
||||
// same posture seam every peer uses: a non-empty CA path means TLS + nkey, empty
|
||||
// means plaintext dev. When a CA is configured the bus is assumed to enforce a
|
||||
// per-subject ACL, so membership changes trigger a session refresh.
|
||||
func newGateway(cfg gatewayConfig) (*gateway, error) {
|
||||
opts := client.Options{
|
||||
CtrlURLs: cfg.CtrlURLs,
|
||||
NatsServers: cfg.NatsURLs,
|
||||
}
|
||||
if cfg.CAPath != "" {
|
||||
tlsCfg, err := busauth.LoadCATLSConfig(cfg.CAPath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("webgw: load bus CA %q: %w", cfg.CAPath, err)
|
||||
}
|
||||
opts.UseNkey = true
|
||||
opts.TLS = tlsCfg
|
||||
opts.CtrlTLS = tlsCfg
|
||||
}
|
||||
cli, err := client.NewWithOptions(cfg.NatsURL, cfg.CtrlURL, cfg.Identity, opts)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("webgw: connect bus client: %w", err)
|
||||
}
|
||||
return &gateway{
|
||||
id: cfg.Identity,
|
||||
endpoint: frame.EndpointID(cfg.Identity.SignPub),
|
||||
cli: cli,
|
||||
refreshACL: cfg.CAPath != "",
|
||||
hubs: map[string]*roomHub{},
|
||||
}, nil
|
||||
}
|
||||
|
||||
// Close stops every hub and releases the bus client connection.
|
||||
func (g *gateway) Close() error {
|
||||
g.mu.Lock()
|
||||
for _, h := range g.hubs {
|
||||
h.stop()
|
||||
}
|
||||
g.hubs = map[string]*roomHub{}
|
||||
g.mu.Unlock()
|
||||
if g.cli != nil {
|
||||
return g.cli.Close()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ---- wire types (browser-facing JSON) ------------------------------------
|
||||
|
||||
// meInfo is what GET /api/me returns: the operator identity the gateway acts as.
|
||||
type meInfo struct {
|
||||
Endpoint string `json:"endpoint"`
|
||||
SignPub string `json:"sign_pub"`
|
||||
}
|
||||
|
||||
// roomWire is the browser view of a room. It deliberately omits messages: those
|
||||
// stream over SSE (GET /api/rooms/{id}/stream), not in the room list.
|
||||
type roomWire struct {
|
||||
ID string `json:"id"`
|
||||
Subject string `json:"subject"`
|
||||
Name string `json:"name"`
|
||||
Epoch int `json:"epoch"`
|
||||
Encrypt bool `json:"encrypt"`
|
||||
Persist bool `json:"persist"`
|
||||
SignMsgs bool `json:"sign_msgs"`
|
||||
Role string `json:"role"`
|
||||
}
|
||||
|
||||
// createRoomReq is the POST /api/rooms body. Encrypt/Persist/SignMsgs are
|
||||
// pointers so an omitted field falls back to the chat default rather than to the
|
||||
// Go zero value (false). The common case — the browser sending only {subject,
|
||||
// encrypted} — maps encrypted onto all three (the Matrix-like chat policy).
|
||||
type createRoomReq struct {
|
||||
Subject string `json:"subject"`
|
||||
Encrypted *bool `json:"encrypted,omitempty"`
|
||||
Encrypt *bool `json:"encrypt,omitempty"`
|
||||
Persist *bool `json:"persist,omitempty"`
|
||||
SignMsgs *bool `json:"sign_msgs,omitempty"`
|
||||
}
|
||||
|
||||
// policy resolves the requested policy. A bare {subject} defaults to the
|
||||
// Matrix-like chat room (encrypted + persisted + signed) so a created room keeps
|
||||
// durable, end-to-end-encrypted, authored history. Callers can override any leg.
|
||||
func (r createRoomReq) policy() room.Policy {
|
||||
enc, per, sig := true, true, true
|
||||
if r.Encrypted != nil {
|
||||
enc, per, sig = *r.Encrypted, *r.Encrypted, *r.Encrypted
|
||||
}
|
||||
if r.Encrypt != nil {
|
||||
enc = *r.Encrypt
|
||||
}
|
||||
if r.Persist != nil {
|
||||
per = *r.Persist
|
||||
}
|
||||
if r.SignMsgs != nil {
|
||||
sig = *r.SignMsgs
|
||||
}
|
||||
return room.Policy{Encrypt: enc, Persist: per, SignMsgs: sig}
|
||||
}
|
||||
|
||||
// sendReq is the POST /api/rooms/{id}/send body.
|
||||
type sendReq struct {
|
||||
Body string `json:"body"`
|
||||
}
|
||||
|
||||
// msgWire is one decrypted message pushed over SSE.
|
||||
type msgWire struct {
|
||||
ID string `json:"id"`
|
||||
Sender string `json:"sender"`
|
||||
Body string `json:"body"`
|
||||
TS int64 `json:"ts"` // epoch ms (decoded from the frame's ULID id)
|
||||
Mine bool `json:"mine"`
|
||||
}
|
||||
|
||||
// ---- operations -----------------------------------------------------------
|
||||
|
||||
func (g *gateway) me() meInfo {
|
||||
return meInfo{Endpoint: g.endpoint, SignPub: hex.EncodeToString(g.id.SignPub)}
|
||||
}
|
||||
|
||||
// subjectName derives a short, human-friendly room name from its bus subject by
|
||||
// dropping the leading namespace segment (room., test., proc., agent.). It is a
|
||||
// display nicety only; the canonical identity stays the subject/room id.
|
||||
func subjectName(subject string) string {
|
||||
for _, p := range []string{"room.", "test.", "proc.", "agent.", "rpc."} {
|
||||
if strings.HasPrefix(subject, p) {
|
||||
return strings.TrimPrefix(subject, p)
|
||||
}
|
||||
}
|
||||
return subject
|
||||
}
|
||||
|
||||
func (g *gateway) listRooms() ([]roomWire, error) {
|
||||
rooms, err := g.cli.ListMyRooms()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out := make([]roomWire, 0, len(rooms))
|
||||
for _, rm := range rooms {
|
||||
out = append(out, roomWire{
|
||||
ID: rm.RoomID,
|
||||
Subject: rm.Subject,
|
||||
Name: subjectName(rm.Subject),
|
||||
Epoch: rm.Epoch,
|
||||
Encrypt: rm.Policy.Encrypt,
|
||||
Persist: rm.Policy.Persist,
|
||||
SignMsgs: rm.Policy.SignMsgs,
|
||||
Role: rm.Role,
|
||||
})
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (g *gateway) createRoom(req createRoomReq) (roomWire, error) {
|
||||
subject := strings.TrimSpace(req.Subject)
|
||||
if subject == "" {
|
||||
return roomWire{}, fmt.Errorf("webgw: subject required")
|
||||
}
|
||||
p := req.policy()
|
||||
roomID, err := g.cli.CreateRoom(subject, p)
|
||||
if err != nil {
|
||||
return roomWire{}, err
|
||||
}
|
||||
// Under a per-subject ACL the operator's frozen NATS permissions do not yet
|
||||
// cover the new room's subject; refresh so subsequent data-plane use works. On
|
||||
// a plaintext/non-ACL dev bus this is unnecessary and would needlessly drop any
|
||||
// live SSE subscriptions, so it is gated on the secured posture.
|
||||
if g.refreshACL {
|
||||
_ = g.cli.RefreshSession()
|
||||
}
|
||||
return roomWire{
|
||||
ID: roomID,
|
||||
Subject: subject,
|
||||
Name: subjectName(subject),
|
||||
Epoch: 1,
|
||||
Encrypt: p.Encrypt,
|
||||
Persist: p.Persist,
|
||||
SignMsgs: p.SignMsgs,
|
||||
Role: "owner",
|
||||
}, nil
|
||||
}
|
||||
|
||||
// join resolves room metadata and (for encrypted rooms) fetches the room key so
|
||||
// the gateway can later open payloads. Idempotent.
|
||||
func (g *gateway) join(roomID string) error {
|
||||
if err := g.cli.Join(roomID); err != nil {
|
||||
return err
|
||||
}
|
||||
if g.refreshACL {
|
||||
_ = g.cli.RefreshSession()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// send publishes plaintext to a room. The unibus client seals it with the room
|
||||
// key (encrypted rooms) and signs it (signed rooms) before it leaves the process.
|
||||
func (g *gateway) send(roomID, body string) error {
|
||||
return g.cli.Publish(roomID, []byte(body))
|
||||
}
|
||||
@@ -1,140 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"sync"
|
||||
|
||||
"github.com/enmanuel/unibus/pkg/client"
|
||||
"github.com/enmanuel/unibus/pkg/frame"
|
||||
"github.com/oklog/ulid/v2"
|
||||
)
|
||||
|
||||
// roomHub multiplexes ONE unibus room subscription to MANY SSE clients. The
|
||||
// unibus client derives a per-(room, endpoint) durable consumer name, so a
|
||||
// second Subscribe for the same room from the same operator would contend for
|
||||
// the same durable (load-balanced delivery) rather than each browser receiving
|
||||
// every message. The hub holds a single subscription per room and fans each
|
||||
// decrypted frame out to every connected browser, which also means the gateway
|
||||
// opens at most one bus subscription per room regardless of how many tabs watch
|
||||
// it.
|
||||
type roomHub struct {
|
||||
roomID string
|
||||
myEndpoint string
|
||||
sub *client.Sub
|
||||
|
||||
mu sync.Mutex
|
||||
clients map[chan msgWire]struct{}
|
||||
}
|
||||
|
||||
// frameTS decodes the millisecond timestamp embedded in a frame's ULID id. A
|
||||
// malformed id (should not happen for bus-produced frames) yields 0, which the
|
||||
// browser renders without crashing.
|
||||
func frameTS(msgID string) int64 {
|
||||
id, err := ulid.Parse(msgID)
|
||||
if err != nil {
|
||||
return 0
|
||||
}
|
||||
return int64(id.Time())
|
||||
}
|
||||
|
||||
// newRoomHub opens the single bus subscription for roomID and starts fanning
|
||||
// decrypted frames out to registered clients. The room must already be joined
|
||||
// (so the gateway holds the room key) before this is called.
|
||||
func newRoomHub(cli *client.Client, roomID, myEndpoint string) (*roomHub, error) {
|
||||
h := &roomHub{
|
||||
roomID: roomID,
|
||||
myEndpoint: myEndpoint,
|
||||
clients: map[chan msgWire]struct{}{},
|
||||
}
|
||||
sub, err := cli.Subscribe(roomID, func(f frame.Frame, plaintext []byte) {
|
||||
m := msgWire{
|
||||
ID: f.MsgID,
|
||||
Sender: f.Sender,
|
||||
Body: string(plaintext),
|
||||
TS: frameTS(f.MsgID),
|
||||
Mine: f.Sender == myEndpoint,
|
||||
}
|
||||
h.broadcast(m)
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
h.sub = sub
|
||||
return h, nil
|
||||
}
|
||||
|
||||
// broadcast delivers a message to every registered client without blocking the
|
||||
// NATS delivery goroutine: a client whose buffer is full (a stalled browser)
|
||||
// drops this frame rather than stalling the whole room.
|
||||
func (h *roomHub) broadcast(m msgWire) {
|
||||
h.mu.Lock()
|
||||
defer h.mu.Unlock()
|
||||
for ch := range h.clients {
|
||||
select {
|
||||
case ch <- m:
|
||||
default:
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// add registers a new SSE client channel.
|
||||
func (h *roomHub) add(ch chan msgWire) {
|
||||
h.mu.Lock()
|
||||
defer h.mu.Unlock()
|
||||
h.clients[ch] = struct{}{}
|
||||
}
|
||||
|
||||
// stop unsubscribes from the bus. Local delivery ends; for a persisted room the
|
||||
// durable consumer's ack position stays on the server, so a later subscription
|
||||
// with the same operator resumes from where it left off.
|
||||
func (h *roomHub) stop() {
|
||||
if h.sub != nil {
|
||||
_ = h.sub.Unsubscribe()
|
||||
}
|
||||
}
|
||||
|
||||
// openStream joins the room (idempotent; fetches the room key for encrypted
|
||||
// rooms), attaches an SSE client to the room's hub (creating it on first watcher),
|
||||
// and returns the client's message channel plus a cleanup func. The cleanup
|
||||
// detaches the client and, when it was the last watcher, tears down the room's
|
||||
// single bus subscription.
|
||||
func (g *gateway) openStream(roomID string) (chan msgWire, func(), error) {
|
||||
if err := g.join(roomID); err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
g.mu.Lock()
|
||||
h := g.hubs[roomID]
|
||||
if h == nil {
|
||||
var err error
|
||||
h, err = newRoomHub(g.cli, roomID, g.endpoint)
|
||||
if err != nil {
|
||||
g.mu.Unlock()
|
||||
return nil, nil, err
|
||||
}
|
||||
g.hubs[roomID] = h
|
||||
}
|
||||
g.mu.Unlock()
|
||||
|
||||
// Buffer so a brief render hitch in the browser does not drop live frames; a
|
||||
// sustained stall still drops (broadcast is non-blocking) rather than wedging
|
||||
// the room.
|
||||
ch := make(chan msgWire, 64)
|
||||
h.add(ch)
|
||||
|
||||
// cleanup takes g.mu before h.mu (the single, consistent lock order) so a
|
||||
// concurrent openStream that re-creates the hub cannot race the teardown.
|
||||
cleanup := func() {
|
||||
g.mu.Lock()
|
||||
defer g.mu.Unlock()
|
||||
h.mu.Lock()
|
||||
delete(h.clients, ch)
|
||||
empty := len(h.clients) == 0
|
||||
h.mu.Unlock()
|
||||
if empty {
|
||||
if cur := g.hubs[roomID]; cur == h {
|
||||
delete(g.hubs, roomID)
|
||||
h.stop()
|
||||
}
|
||||
}
|
||||
}
|
||||
return ch, cleanup, nil
|
||||
}
|
||||
@@ -1,98 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
"os/exec"
|
||||
|
||||
cs "fn-registry/functions/cybersecurity"
|
||||
)
|
||||
|
||||
// identityJSON mirrors the on-disk / pass-stored identity format shared across
|
||||
// the unibus tooling: the four keypair halves, each std-base64. It is the SAME
|
||||
// shape the bus client persists (pkg/client identity file) and the operator's
|
||||
// `pass` entry unibus/operator-identity, so the web gateway loads the operator's
|
||||
// identity without a divergent serialization. Kept in lockstep with
|
||||
// unibus_admin/internal/admin/identity.go.
|
||||
type identityJSON struct {
|
||||
SignPub string `json:"sign_pub"`
|
||||
SignPriv string `json:"sign_priv"`
|
||||
KexPub string `json:"kex_pub"`
|
||||
KexPriv string `json:"kex_priv"`
|
||||
}
|
||||
|
||||
// decodeIdentity turns the JSON identity bytes into a cs.Identity. The private
|
||||
// halves stay only in memory; this never writes them anywhere.
|
||||
func decodeIdentity(raw []byte) (cs.Identity, error) {
|
||||
var f identityJSON
|
||||
if err := json.Unmarshal(raw, &f); err != nil {
|
||||
return cs.Identity{}, fmt.Errorf("webgw: parse identity json: %w", err)
|
||||
}
|
||||
dec := base64.StdEncoding.DecodeString
|
||||
signPub, err := dec(f.SignPub)
|
||||
if err != nil {
|
||||
return cs.Identity{}, fmt.Errorf("webgw: decode sign_pub: %w", err)
|
||||
}
|
||||
signPriv, err := dec(f.SignPriv)
|
||||
if err != nil {
|
||||
return cs.Identity{}, fmt.Errorf("webgw: decode sign_priv: %w", err)
|
||||
}
|
||||
kexPub, err := dec(f.KexPub)
|
||||
if err != nil {
|
||||
return cs.Identity{}, fmt.Errorf("webgw: decode kex_pub: %w", err)
|
||||
}
|
||||
kexPriv, err := dec(f.KexPriv)
|
||||
if err != nil {
|
||||
return cs.Identity{}, fmt.Errorf("webgw: decode kex_priv: %w", err)
|
||||
}
|
||||
if len(signPub) != 32 || len(signPriv) != 64 || len(kexPub) != 32 || len(kexPriv) != 32 {
|
||||
return cs.Identity{}, fmt.Errorf("webgw: identity has wrong key sizes (sign_pub=%d sign_priv=%d kex_pub=%d kex_priv=%d)",
|
||||
len(signPub), len(signPriv), len(kexPub), len(kexPriv))
|
||||
}
|
||||
return cs.Identity{SignPub: signPub, SignPriv: signPriv, KexPub: kexPub, KexPriv: kexPriv}, nil
|
||||
}
|
||||
|
||||
// loadIdentityFromFile reads a 0600 identity JSON file (the same format the bus
|
||||
// client writes) and decodes it. Used on a deploy host where `pass` is not
|
||||
// available and the operator identity is delivered as a protected file.
|
||||
func loadIdentityFromFile(path string) (cs.Identity, error) {
|
||||
raw, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
return cs.Identity{}, fmt.Errorf("webgw: read identity file %q: %w", path, err)
|
||||
}
|
||||
return decodeIdentity(raw)
|
||||
}
|
||||
|
||||
// loadIdentityFromPass shells out to `pass show <entry>` and decodes the JSON
|
||||
// identity it returns. The secret is held only in memory; this process never
|
||||
// writes it to disk or argv. Used in local operator workflows where the GNU
|
||||
// password store holds unibus/operator-identity.
|
||||
func loadIdentityFromPass(entry string) (cs.Identity, error) {
|
||||
out, err := exec.Command("pass", "show", entry).Output()
|
||||
if err != nil {
|
||||
return cs.Identity{}, fmt.Errorf("webgw: pass show %q: %w", entry, err)
|
||||
}
|
||||
return decodeIdentity(out)
|
||||
}
|
||||
|
||||
// loadPassValue returns the first line of a `pass show <entry>` for non-identity
|
||||
// secrets (e.g. the unlock passphrase). Empty entry yields an empty string and
|
||||
// no error, so callers can treat "no pass entry configured" as "not set".
|
||||
func loadPassValue(entry string) (string, error) {
|
||||
if entry == "" {
|
||||
return "", nil
|
||||
}
|
||||
out, err := exec.Command("pass", "show", entry).Output()
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("webgw: pass show %q: %w", entry, err)
|
||||
}
|
||||
s := string(out)
|
||||
for i := 0; i < len(s); i++ {
|
||||
if s[i] == '\n' || s[i] == '\r' {
|
||||
return s[:i], nil
|
||||
}
|
||||
}
|
||||
return s, nil
|
||||
}
|
||||
@@ -1,199 +0,0 @@
|
||||
// Command webgw is the web gateway for the unibus chat SPA. It is a single Go
|
||||
// binary that holds the operator's bus identity, connects to the bus as a real
|
||||
// authenticated peer (pkg/client), and exposes a small REST + SSE API the
|
||||
// browser consumes. The browser never signs, never speaks NATS, and never sees a
|
||||
// private key: it authenticates to the gateway with a passphrase and thereafter
|
||||
// holds only an opaque session cookie.
|
||||
//
|
||||
// TRUST MODEL (MVP, single operator): room content stays end-to-end encrypted on
|
||||
// the bus. The gateway can read plaintext because it acts AS the operator's
|
||||
// client — a legitimate member of each room holding the room key. Decryption
|
||||
// happens server-side in this process; cleartext then crosses an authenticated
|
||||
// (loopback or TLS-fronted) SSE channel to the browser. The wallet phase (issue:
|
||||
// per-browser WebCrypto identity) can move decryption into the browser; see the
|
||||
// report for the FASE 2 plan.
|
||||
//
|
||||
// # local dev against a loopback membershipd (plaintext), operator from pass:
|
||||
// webgw --identity-pass unibus/operator-identity \
|
||||
// --ctrl-url http://127.0.0.1:8470 --nats-url nats://127.0.0.1:4250
|
||||
//
|
||||
// # secured cluster (TLS + nkey on both planes), identity from a 0600 file:
|
||||
// webgw --ca ca.crt --identity-file operator.id \
|
||||
// --ctrl-url https://node-a:8470 --nats-url nats://node-a:4250 \
|
||||
// --ctrl-urls https://node-b:8470,https://node-c:8470 \
|
||||
// --nats-urls nats://node-b:4250,nats://node-c:4250
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"flag"
|
||||
"log"
|
||||
"net/http"
|
||||
"os"
|
||||
"os/signal"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
cs "fn-registry/functions/cybersecurity"
|
||||
)
|
||||
|
||||
func main() {
|
||||
var (
|
||||
bind = flag.String("bind", "127.0.0.1", "interface to bind the gateway HTTP server to (loopback by default)")
|
||||
port = flag.String("port", "8481", "gateway HTTP port")
|
||||
ctrlURL = flag.String("ctrl-url", "http://127.0.0.1:8470", "primary unibus control-plane base URL")
|
||||
ctrlURLs = flag.String("ctrl-urls", "", "comma-separated ADDITIONAL control-plane base URLs (cluster failover)")
|
||||
natsURL = flag.String("nats-url", "nats://127.0.0.1:4250", "primary NATS URL")
|
||||
natsURLs = flag.String("nats-urls", "", "comma-separated ADDITIONAL NATS seed URLs (cluster failover)")
|
||||
caPath = flag.String("ca", "", "bus CA cert path; set to talk TLS+nkey to a secured bus (empty = plaintext dev)")
|
||||
identityFile = flag.String("identity-file", "", "path to the operator identity JSON file (0600). Mutually exclusive with --identity-pass")
|
||||
identityPass = flag.String("identity-pass", "", "pass(1) entry holding the operator identity JSON, e.g. unibus/operator-identity")
|
||||
unlockPass = flag.String("unlock-pass", "", "literal passphrase the browser must send to unlock a LEGACY operator session (dev). Prefer --unlock-pass-entry")
|
||||
unlockEntry = flag.String("unlock-pass-entry", "unibus/admin-panel-password", "pass(1) entry holding the operator unlock passphrase (used when --unlock-pass is empty)")
|
||||
registerURL = flag.String("register-url", "", "bus POST /register URL for wallet onboarding. Empty = derive from --ctrl-url (<ctrl-url>/register)")
|
||||
mockTokens = flag.String("mock-tokens", "", "DEV ONLY: comma-separated one-shot invite tokens for local testing, 'token=handle:role'. Empty in production (real invites come from the bus). Example: demo=demo:member")
|
||||
webDir = flag.String("web-dir", "", "OPTIONAL path to the built SPA (web/dist) to serve. Empty = API only (use vite dev server)")
|
||||
)
|
||||
flag.Parse()
|
||||
|
||||
log.SetFlags(log.LstdFlags | log.Lmsgprefix)
|
||||
log.SetPrefix("[webgw] ")
|
||||
|
||||
id, err := loadIdentity(*identityFile, *identityPass)
|
||||
if err != nil {
|
||||
log.Fatalf("%v", err)
|
||||
}
|
||||
|
||||
unlock := *unlockPass
|
||||
if unlock == "" {
|
||||
unlock, err = loadPassValue(*unlockEntry)
|
||||
if err != nil {
|
||||
log.Fatalf("resolve unlock passphrase: %v", err)
|
||||
}
|
||||
}
|
||||
if unlock == "" {
|
||||
log.Fatalf("an unlock passphrase is required: set --unlock-pass or a non-empty --unlock-pass-entry (default unibus/admin-panel-password)")
|
||||
}
|
||||
|
||||
resolvedWebDir := resolveWebDir(*webDir)
|
||||
|
||||
// busTemplate is the connection config every bus client uses. The operator
|
||||
// gateway uses it as-is; each wallet session clones it and overrides Identity
|
||||
// with the logged-in user's keypair.
|
||||
busTemplate := gatewayConfig{
|
||||
Identity: id,
|
||||
NatsURL: *natsURL,
|
||||
CtrlURL: *ctrlURL,
|
||||
CtrlURLs: splitCSV(*ctrlURLs),
|
||||
NatsURLs: splitCSV(*natsURLs),
|
||||
CAPath: *caPath,
|
||||
}
|
||||
|
||||
gw, err := newGateway(busTemplate)
|
||||
if err != nil {
|
||||
log.Fatalf("%v", err)
|
||||
}
|
||||
defer gw.Close()
|
||||
|
||||
// Wallet onboarding backend: POST /api/register targets the bus's /register
|
||||
// (added by the user-accounts work). When --register-url is empty we derive it
|
||||
// from --ctrl-url; --mock-tokens supplies one-shot invites for local testing
|
||||
// before that endpoint is deployed.
|
||||
regURL := *registerURL
|
||||
if regURL == "" {
|
||||
regURL = strings.TrimRight(*ctrlURL, "/") + "/register"
|
||||
}
|
||||
registrar := newRegistrar(regURL, *mockTokens)
|
||||
|
||||
log.Printf("operator endpoint: %s", gw.endpoint)
|
||||
log.Printf("control plane: %s (+%d failover)", *ctrlURL, len(splitCSV(*ctrlURLs)))
|
||||
tls := "OFF (plaintext dev)"
|
||||
if *caPath != "" {
|
||||
tls = "ON (CA " + *caPath + ")"
|
||||
}
|
||||
log.Printf("bus TLS+nkey: %s", tls)
|
||||
if resolvedWebDir != "" {
|
||||
log.Printf("serving SPA from: %s", resolvedWebDir)
|
||||
} else {
|
||||
log.Printf("API only (no --web-dir): use the vite dev server with a /api+stream proxy")
|
||||
}
|
||||
|
||||
log.Printf("wallet register: %s (mock tokens: %d)", regURL, mockTokenCount(*mockTokens))
|
||||
|
||||
srv := newServer(gw, busTemplate, registrar, unlock, resolvedWebDir)
|
||||
addr := *bind + ":" + *port
|
||||
httpSrv := &http.Server{
|
||||
Addr: addr,
|
||||
Handler: srv,
|
||||
// No global write timeout: SSE streams are long-lived. Header timeout still
|
||||
// bounds slowloris on the request line/headers.
|
||||
ReadHeaderTimeout: 10 * time.Second,
|
||||
}
|
||||
|
||||
go func() {
|
||||
log.Printf("web gateway: http://%s", addr)
|
||||
if err := httpSrv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
|
||||
log.Fatalf("http server: %v", err)
|
||||
}
|
||||
}()
|
||||
|
||||
stop := make(chan os.Signal, 1)
|
||||
signal.Notify(stop, syscall.SIGINT, syscall.SIGTERM)
|
||||
<-stop
|
||||
log.Printf("shutting down...")
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
_ = httpSrv.Shutdown(ctx)
|
||||
log.Printf("bye")
|
||||
}
|
||||
|
||||
// loadIdentity resolves the operator identity from exactly one of --identity-file
|
||||
// or --identity-pass.
|
||||
func loadIdentity(file, passEntry string) (cs.Identity, error) {
|
||||
switch {
|
||||
case file != "" && passEntry != "":
|
||||
return cs.Identity{}, errFlag("set only one of --identity-file or --identity-pass")
|
||||
case file != "":
|
||||
return loadIdentityFromFile(file)
|
||||
case passEntry != "":
|
||||
return loadIdentityFromPass(passEntry)
|
||||
default:
|
||||
return cs.Identity{}, errFlag("an identity is required: pass --identity-file <path> or --identity-pass <entry>")
|
||||
}
|
||||
}
|
||||
|
||||
// resolveWebDir validates the --web-dir flag. An empty flag means API-only. A
|
||||
// non-empty dir is kept only if it actually holds an index.html, so a typo logs
|
||||
// "API only" rather than serving 404s.
|
||||
func resolveWebDir(dir string) string {
|
||||
if dir == "" {
|
||||
return ""
|
||||
}
|
||||
abs, err := filepath.Abs(dir)
|
||||
if err != nil {
|
||||
log.Printf("WARN --web-dir %q: %v; serving API only", dir, err)
|
||||
return ""
|
||||
}
|
||||
if !statFile(filepath.Join(abs, "index.html")) {
|
||||
log.Printf("WARN --web-dir %q has no index.html; serving API only", abs)
|
||||
return ""
|
||||
}
|
||||
return abs
|
||||
}
|
||||
|
||||
type flagErr string
|
||||
|
||||
func (e flagErr) Error() string { return string(e) }
|
||||
func errFlag(s string) error { return flagErr("webgw: " + s) }
|
||||
|
||||
func splitCSV(s string) []string {
|
||||
var out []string
|
||||
for _, p := range strings.Split(s, ",") {
|
||||
if p = strings.TrimSpace(p); p != "" {
|
||||
out = append(out, p)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
@@ -1,193 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// registerReq is the POST /api/register body. It mirrors the bus contract exactly
|
||||
// (token + the two PUBLIC key halves, each 64 hex chars). The private key never
|
||||
// appears here — registration only publishes the public identity. The handle and
|
||||
// role are NOT accepted from the client; they are fixed by the invite the token
|
||||
// belongs to (no privilege escalation).
|
||||
type registerReq struct {
|
||||
Token string `json:"token"`
|
||||
SignPub string `json:"sign_pub"`
|
||||
KexPub string `json:"kex_pub"`
|
||||
}
|
||||
|
||||
// registerResp is what we return to the browser on success. The bus's /register
|
||||
// (issue: user-accounts) decides handle/role from the invite; in mock mode the
|
||||
// gateway echoes the configured pair so the SPA can greet the new user.
|
||||
type registerResp struct {
|
||||
Handle string `json:"handle"`
|
||||
Role string `json:"role"`
|
||||
}
|
||||
|
||||
// registrar fulfils POST /api/register. It targets the bus's POST /register
|
||||
// endpoint (added by the user-accounts work, bus >= 0.12.0). Until that endpoint
|
||||
// is rolled out, a built-in mock validates against a configured set of one-shot
|
||||
// tokens so the whole wallet flow is testable locally. Mock tokens are checked
|
||||
// first; anything else is proxied to the real bus when --register-url is set.
|
||||
type registrar struct {
|
||||
mu sync.Mutex
|
||||
|
||||
registerURL string // bus POST /register; empty => mock-only
|
||||
httpc *http.Client // for proxying to the bus
|
||||
mockTokens map[string]*mockToken // configured one-shot invites for local testing
|
||||
}
|
||||
|
||||
// mockToken is a local stand-in for a bus invite: a token that maps to a fixed
|
||||
// handle+role and can be consumed exactly once.
|
||||
type mockToken struct {
|
||||
handle string
|
||||
role string
|
||||
used bool
|
||||
}
|
||||
|
||||
// newRegistrar parses the --mock-tokens spec ("tok=handle:role,tok2=h2:role2")
|
||||
// and configures the optional proxy target.
|
||||
func newRegistrar(registerURL, mockSpec string) *registrar {
|
||||
r := ®istrar{
|
||||
registerURL: strings.TrimSpace(registerURL),
|
||||
httpc: &http.Client{Timeout: 10 * time.Second},
|
||||
mockTokens: map[string]*mockToken{},
|
||||
}
|
||||
for _, part := range strings.Split(mockSpec, ",") {
|
||||
part = strings.TrimSpace(part)
|
||||
if part == "" {
|
||||
continue
|
||||
}
|
||||
// tok=handle:role (role optional, defaults to member)
|
||||
eq := strings.IndexByte(part, '=')
|
||||
if eq < 0 {
|
||||
continue
|
||||
}
|
||||
tok := strings.TrimSpace(part[:eq])
|
||||
hr := strings.TrimSpace(part[eq+1:])
|
||||
handle, role := hr, "member"
|
||||
if c := strings.IndexByte(hr, ':'); c >= 0 {
|
||||
handle, role = strings.TrimSpace(hr[:c]), strings.TrimSpace(hr[c+1:])
|
||||
}
|
||||
if tok != "" && handle != "" {
|
||||
r.mockTokens[tok] = &mockToken{handle: handle, role: role}
|
||||
}
|
||||
}
|
||||
return r
|
||||
}
|
||||
|
||||
// mockTokenCount counts configured mock tokens in a --mock-tokens spec (for the
|
||||
// startup log line).
|
||||
func mockTokenCount(spec string) int {
|
||||
n := 0
|
||||
for _, part := range strings.Split(spec, ",") {
|
||||
if p := strings.TrimSpace(part); p != "" && strings.ContainsRune(p, '=') {
|
||||
n++
|
||||
}
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
// validHexKey reports whether s is exactly 64 lowercase/uppercase hex chars (a
|
||||
// 32-byte key). Both sign_pub and kex_pub are 32-byte keys.
|
||||
func validHexKey(s string) bool {
|
||||
if len(s) != 64 {
|
||||
return false
|
||||
}
|
||||
_, err := hex.DecodeString(s)
|
||||
return err == nil
|
||||
}
|
||||
|
||||
// handleRegister validates the keys and consumes the token. Order of resolution:
|
||||
// 1. strict validation of the public keys (defends both mock and proxy paths);
|
||||
// 2. mock token (one-shot) if configured;
|
||||
// 3. proxy to the bus /register if --register-url is set;
|
||||
// 4. otherwise reject with a clear error.
|
||||
func (s *server) handleRegister(w http.ResponseWriter, r *http.Request) {
|
||||
var req registerReq
|
||||
if !decode(w, r, &req) {
|
||||
return
|
||||
}
|
||||
req.Token = strings.TrimSpace(req.Token)
|
||||
if req.Token == "" {
|
||||
writeErr(w, http.StatusBadRequest, "token required")
|
||||
return
|
||||
}
|
||||
if !validHexKey(req.SignPub) {
|
||||
writeErr(w, http.StatusBadRequest, "sign_pub must be 64 hex chars (32 bytes)")
|
||||
return
|
||||
}
|
||||
if !validHexKey(req.KexPub) {
|
||||
writeErr(w, http.StatusBadRequest, "kex_pub must be 64 hex chars (32 bytes)")
|
||||
return
|
||||
}
|
||||
|
||||
reg := s.registrar
|
||||
|
||||
// 2) mock one-shot token.
|
||||
reg.mu.Lock()
|
||||
mt, isMock := reg.mockTokens[req.Token]
|
||||
if isMock {
|
||||
if mt.used {
|
||||
reg.mu.Unlock()
|
||||
writeErr(w, http.StatusConflict, "invite already used")
|
||||
return
|
||||
}
|
||||
mt.used = true
|
||||
handle, role := mt.handle, mt.role
|
||||
reg.mu.Unlock()
|
||||
writeJSON(w, http.StatusCreated, registerResp{Handle: handle, Role: role})
|
||||
return
|
||||
}
|
||||
reg.mu.Unlock()
|
||||
|
||||
// 3) proxy to the real bus /register when configured.
|
||||
if reg.registerURL != "" {
|
||||
s.proxyRegister(w, req)
|
||||
return
|
||||
}
|
||||
|
||||
// 4) no mock match, no proxy target.
|
||||
writeErr(w, http.StatusBadRequest, "invalid or unknown token (and no bus /register configured)")
|
||||
}
|
||||
|
||||
// proxyRegister forwards the registration to the bus's POST /register. The bus
|
||||
// validates the invite (existence, not-used, not-expired) and adds the public
|
||||
// identity to the allowlist with the invite's handle+role. This is unsigned by
|
||||
// design: the TOKEN authorizes the call, not an admin signature.
|
||||
func (s *server) proxyRegister(w http.ResponseWriter, req registerReq) {
|
||||
body, _ := json.Marshal(req)
|
||||
resp, err := s.registrar.httpc.Post(
|
||||
s.registrar.registerURL,
|
||||
"application/json",
|
||||
bytes.NewReader(body),
|
||||
)
|
||||
if err != nil {
|
||||
writeErr(w, http.StatusBadGateway, "bus register unreachable: "+err.Error())
|
||||
return
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
|
||||
|
||||
// On success, try to pass through the bus's handle/role if it returned them;
|
||||
// otherwise a bare 201 is still success.
|
||||
if resp.StatusCode == http.StatusCreated || resp.StatusCode == http.StatusOK {
|
||||
var rr registerResp
|
||||
_ = json.Unmarshal(raw, &rr)
|
||||
writeJSON(w, http.StatusCreated, rr)
|
||||
return
|
||||
}
|
||||
// Forward the bus's error verbatim where possible.
|
||||
msg := strings.TrimSpace(string(raw))
|
||||
if msg == "" {
|
||||
msg = fmt.Sprintf("bus register failed (HTTP %d)", resp.StatusCode)
|
||||
}
|
||||
writeErr(w, resp.StatusCode, msg)
|
||||
}
|
||||
@@ -1,327 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"crypto/subtle"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// sessionCookie is the name of the gateway's session cookie. The browser sends
|
||||
// it automatically on same-origin fetches AND on EventSource (SSE) connections —
|
||||
// EventSource cannot set custom headers, so a cookie is the only way to
|
||||
// authenticate the stream. It is HttpOnly so page JS can never read the token.
|
||||
const sessionCookie = "unibus_session"
|
||||
|
||||
// server is the gateway's HTTP surface: a small REST/SSE API under /api plus an
|
||||
// optional static file server for the built SPA.
|
||||
//
|
||||
// Two ways to get a session:
|
||||
// - POST /api/session — the WALLET model. The browser hands its own bus
|
||||
// identity (unlocked from its local encrypted key) and the gateway connects a
|
||||
// dedicated bus client AS that user. Per-user, the primary path.
|
||||
// - POST /api/login — the legacy operator passphrase. Binds the session to the
|
||||
// single shared operator gateway. Kept for backward compatibility.
|
||||
// - POST /api/register — the WALLET onboarding. Unauthenticated (the invite
|
||||
// token authorizes), it consumes a token and publishes the new user's PUBLIC
|
||||
// identity to the bus allowlist.
|
||||
type server struct {
|
||||
operatorGW *gateway // shared operator client (legacy passphrase login)
|
||||
busTemplate gatewayConfig // bus connection config; Identity is overridden per user session
|
||||
registrar *registrar // POST /api/register backend (mock + proxy)
|
||||
unlock string // passphrase that unlocks an operator session (constant-time compare)
|
||||
webDir string // optional path to the built SPA (web/dist); empty = API only
|
||||
mux *http.ServeMux
|
||||
sessions *sessionStore
|
||||
}
|
||||
|
||||
func newServer(operatorGW *gateway, busTemplate gatewayConfig, registrar *registrar, unlock, webDir string) *server {
|
||||
s := &server{
|
||||
operatorGW: operatorGW,
|
||||
busTemplate: busTemplate,
|
||||
registrar: registrar,
|
||||
unlock: unlock,
|
||||
webDir: webDir,
|
||||
mux: http.NewServeMux(),
|
||||
sessions: newSessionStore(),
|
||||
}
|
||||
s.routes()
|
||||
return s
|
||||
}
|
||||
|
||||
func (s *server) ServeHTTP(w http.ResponseWriter, r *http.Request) { s.mux.ServeHTTP(w, r) }
|
||||
|
||||
func (s *server) routes() {
|
||||
// Liveness, unauthenticated (systemd / deploy smoke).
|
||||
s.mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, _ *http.Request) {
|
||||
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
|
||||
})
|
||||
|
||||
// Unauthenticated onboarding / auth routes.
|
||||
s.mux.HandleFunc("POST /api/register", s.handleRegister) // invite token authorizes
|
||||
s.mux.HandleFunc("POST /api/session", s.handleSession) // wallet: per-user identity
|
||||
s.mux.HandleFunc("POST /api/login", s.handleLogin) // legacy operator passphrase
|
||||
|
||||
// Session-gated routes.
|
||||
s.mux.HandleFunc("POST /api/logout", s.auth(s.handleLogout))
|
||||
s.mux.HandleFunc("GET /api/me", s.auth(s.handleMe))
|
||||
s.mux.HandleFunc("GET /api/rooms", s.auth(s.handleListRooms))
|
||||
s.mux.HandleFunc("POST /api/rooms", s.auth(s.handleCreateRoom))
|
||||
s.mux.HandleFunc("POST /api/rooms/{id}/join", s.auth(s.handleJoin))
|
||||
s.mux.HandleFunc("POST /api/rooms/{id}/send", s.auth(s.handleSend))
|
||||
s.mux.HandleFunc("GET /api/rooms/{id}/stream", s.auth(s.handleStream))
|
||||
|
||||
// Everything else is the SPA (when --web-dir is set). Registered last.
|
||||
if s.webDir != "" {
|
||||
s.mux.Handle("/", s.spaHandler())
|
||||
}
|
||||
}
|
||||
|
||||
// meResp is the identity view returned by /api/session, /api/login and /api/me:
|
||||
// the bus endpoint the session acts as, its signing public key, and the display
|
||||
// handle.
|
||||
type meResp struct {
|
||||
Endpoint string `json:"endpoint"`
|
||||
SignPub string `json:"sign_pub"`
|
||||
Handle string `json:"handle"`
|
||||
}
|
||||
|
||||
// ---- auth -----------------------------------------------------------------
|
||||
|
||||
// auth wraps a handler so it runs only with a valid session cookie, resolving the
|
||||
// session (and thus the per-user gateway) it belongs to. A missing or unknown
|
||||
// token yields 401, which the SPA treats as "show the login screen".
|
||||
func (s *server) auth(next func(http.ResponseWriter, *http.Request, *session)) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
c, err := r.Cookie(sessionCookie)
|
||||
if err != nil {
|
||||
writeErr(w, http.StatusUnauthorized, "not authenticated")
|
||||
return
|
||||
}
|
||||
sess, ok := s.sessions.get(c.Value)
|
||||
if !ok {
|
||||
writeErr(w, http.StatusUnauthorized, "not authenticated")
|
||||
return
|
||||
}
|
||||
next(w, r, sess)
|
||||
}
|
||||
}
|
||||
|
||||
// handleLogin is the legacy operator passphrase login: it unlocks a session bound
|
||||
// to the shared operator gateway. The wallet path (POST /api/session) is
|
||||
// preferred; this remains for backward compatibility with the single-operator MVP.
|
||||
func (s *server) handleLogin(w http.ResponseWriter, r *http.Request) {
|
||||
var req struct {
|
||||
Passphrase string `json:"passphrase"`
|
||||
}
|
||||
if !decode(w, r, &req) {
|
||||
return
|
||||
}
|
||||
// Constant-time compare so a wrong passphrase cannot be timed character by
|
||||
// character. An empty configured passphrase never matches.
|
||||
if s.unlock == "" || subtle.ConstantTimeCompare([]byte(req.Passphrase), []byte(s.unlock)) != 1 {
|
||||
writeErr(w, http.StatusUnauthorized, "wrong passphrase")
|
||||
return
|
||||
}
|
||||
tok := newToken()
|
||||
handle := s.operatorGW.endpoint
|
||||
if len(handle) > 8 {
|
||||
handle = handle[:8]
|
||||
}
|
||||
s.sessions.put(tok, &session{gw: s.operatorGW, owned: false, handle: handle, issuedAt: time.Now()})
|
||||
|
||||
http.SetCookie(w, &http.Cookie{
|
||||
Name: sessionCookie,
|
||||
Value: tok,
|
||||
Path: "/",
|
||||
HttpOnly: true,
|
||||
SameSite: http.SameSiteLaxMode,
|
||||
})
|
||||
writeJSON(w, http.StatusOK, meResp{Endpoint: s.operatorGW.endpoint, SignPub: hex.EncodeToString(s.operatorGW.id.SignPub), Handle: handle})
|
||||
}
|
||||
|
||||
func (s *server) handleLogout(w http.ResponseWriter, r *http.Request, _ *session) {
|
||||
if c, err := r.Cookie(sessionCookie); err == nil {
|
||||
if sess, ok := s.sessions.drop(c.Value); ok && sess.owned && sess.gw != nil {
|
||||
// Per-user session: tear down its bus client so the private key and the
|
||||
// NATS connection do not outlive the session.
|
||||
_ = sess.gw.Close()
|
||||
}
|
||||
}
|
||||
http.SetCookie(w, &http.Cookie{Name: sessionCookie, Value: "", Path: "/", MaxAge: -1, HttpOnly: true})
|
||||
writeJSON(w, http.StatusOK, map[string]string{"status": "logged_out"})
|
||||
}
|
||||
|
||||
func (s *server) handleMe(w http.ResponseWriter, _ *http.Request, sess *session) {
|
||||
writeJSON(w, http.StatusOK, meResp{
|
||||
Endpoint: sess.gw.endpoint,
|
||||
SignPub: hex.EncodeToString(sess.gw.id.SignPub),
|
||||
Handle: sess.handle,
|
||||
})
|
||||
}
|
||||
|
||||
// ---- rooms ----------------------------------------------------------------
|
||||
|
||||
func (s *server) handleListRooms(w http.ResponseWriter, _ *http.Request, sess *session) {
|
||||
rooms, err := sess.gw.listRooms()
|
||||
if err != nil {
|
||||
writeErr(w, http.StatusBadGateway, err.Error())
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, rooms)
|
||||
}
|
||||
|
||||
func (s *server) handleCreateRoom(w http.ResponseWriter, r *http.Request, sess *session) {
|
||||
var req createRoomReq
|
||||
if !decode(w, r, &req) {
|
||||
return
|
||||
}
|
||||
rv, err := sess.gw.createRoom(req)
|
||||
if err != nil {
|
||||
writeErr(w, http.StatusBadGateway, err.Error())
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, rv)
|
||||
}
|
||||
|
||||
func (s *server) handleJoin(w http.ResponseWriter, r *http.Request, sess *session) {
|
||||
if err := sess.gw.join(r.PathValue("id")); err != nil {
|
||||
writeErr(w, http.StatusBadGateway, err.Error())
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, map[string]string{"status": "joined"})
|
||||
}
|
||||
|
||||
func (s *server) handleSend(w http.ResponseWriter, r *http.Request, sess *session) {
|
||||
var req sendReq
|
||||
if !decode(w, r, &req) {
|
||||
return
|
||||
}
|
||||
if strings.TrimSpace(req.Body) == "" {
|
||||
writeErr(w, http.StatusBadRequest, "body required")
|
||||
return
|
||||
}
|
||||
if err := sess.gw.send(r.PathValue("id"), req.Body); err != nil {
|
||||
writeErr(w, http.StatusBadGateway, err.Error())
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, map[string]string{"status": "sent"})
|
||||
}
|
||||
|
||||
// handleStream is the SSE endpoint: it joins the room, attaches to the session's
|
||||
// fan-out hub, and streams each decrypted message as a `data:` event. For a
|
||||
// persisted room the hub's underlying subscription delivers history first
|
||||
// (scrollback) and then live messages; for an ephemeral room only live messages
|
||||
// flow. The stream ends when the browser disconnects (ctx cancelled).
|
||||
func (s *server) handleStream(w http.ResponseWriter, r *http.Request, sess *session) {
|
||||
flusher, ok := w.(http.Flusher)
|
||||
if !ok {
|
||||
writeErr(w, http.StatusInternalServerError, "streaming unsupported")
|
||||
return
|
||||
}
|
||||
ch, cleanup, err := sess.gw.openStream(r.PathValue("id"))
|
||||
if err != nil {
|
||||
writeErr(w, http.StatusBadGateway, err.Error())
|
||||
return
|
||||
}
|
||||
defer cleanup()
|
||||
|
||||
w.Header().Set("Content-Type", "text/event-stream")
|
||||
w.Header().Set("Cache-Control", "no-cache")
|
||||
w.Header().Set("Connection", "keep-alive")
|
||||
w.Header().Set("X-Accel-Buffering", "no") // disable proxy buffering (nginx/caddy)
|
||||
w.WriteHeader(http.StatusOK)
|
||||
// An initial comment opens the stream immediately so the browser's
|
||||
// EventSource fires `onopen` without waiting for the first message.
|
||||
_, _ = w.Write([]byte(": connected\n\n"))
|
||||
flusher.Flush()
|
||||
|
||||
ctx := r.Context()
|
||||
ping := time.NewTicker(25 * time.Second)
|
||||
defer ping.Stop()
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
case <-ping.C:
|
||||
// Comment line keeps idle proxies from closing the connection.
|
||||
if _, err := w.Write([]byte(": ping\n\n")); err != nil {
|
||||
return
|
||||
}
|
||||
flusher.Flush()
|
||||
case m := <-ch:
|
||||
b, err := json.Marshal(m)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
if _, err := w.Write([]byte("data: " + string(b) + "\n\n")); err != nil {
|
||||
return
|
||||
}
|
||||
flusher.Flush()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---- SPA serving (optional) -----------------------------------------------
|
||||
|
||||
// spaHandler serves the built SPA from s.webDir. A request for an existing asset
|
||||
// is served directly; any other path (a client-side route) falls back to
|
||||
// index.html so the SPA router can take over. /api and /healthz are matched first.
|
||||
func (s *server) spaHandler() http.Handler {
|
||||
root := http.Dir(s.webDir)
|
||||
fileServer := http.FileServer(root)
|
||||
index := filepath.Join(s.webDir, "index.html")
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
p := strings.TrimPrefix(r.URL.Path, "/")
|
||||
if p == "" {
|
||||
http.ServeFile(w, r, index)
|
||||
return
|
||||
}
|
||||
if f, err := root.Open(p); err == nil {
|
||||
_ = f.Close()
|
||||
fileServer.ServeHTTP(w, r)
|
||||
return
|
||||
}
|
||||
http.ServeFile(w, r, index) // unknown path -> SPA client-side routing
|
||||
})
|
||||
}
|
||||
|
||||
// ---- helpers --------------------------------------------------------------
|
||||
|
||||
func newToken() string {
|
||||
b := make([]byte, 32)
|
||||
_, _ = rand.Read(b)
|
||||
return hex.EncodeToString(b)
|
||||
}
|
||||
|
||||
func writeJSON(w http.ResponseWriter, code int, v any) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(code)
|
||||
_ = json.NewEncoder(w).Encode(v)
|
||||
}
|
||||
|
||||
func writeErr(w http.ResponseWriter, code int, msg string) {
|
||||
writeJSON(w, code, map[string]string{"error": msg})
|
||||
}
|
||||
|
||||
// decode reads a JSON body into v, writing a 400 and returning false on failure.
|
||||
func decode(w http.ResponseWriter, r *http.Request, v any) bool {
|
||||
defer r.Body.Close()
|
||||
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(v); err != nil {
|
||||
writeErr(w, http.StatusBadRequest, "bad json: "+err.Error())
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// statFile reports whether path exists and is a regular file (used to validate
|
||||
// --web-dir at startup so a typo surfaces as a clear log line, not 404s later).
|
||||
func statFile(path string) bool {
|
||||
fi, err := os.Stat(path)
|
||||
return err == nil && !fi.IsDir()
|
||||
}
|
||||
@@ -1,146 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
cs "fn-registry/functions/cybersecurity"
|
||||
)
|
||||
|
||||
// session is one logged-in browser. In the wallet model each session carries the
|
||||
// user's OWN bus identity: the browser unlocks its locally-encrypted private key
|
||||
// and hands the full keypair to the gateway over TLS, and the gateway spins up a
|
||||
// dedicated bus client (a *gateway) that acts AS that user. The private key lives
|
||||
// only in this process's memory for the life of the session — it is never written
|
||||
// to disk and is dropped when the session ends.
|
||||
//
|
||||
// A session may instead point at the shared operator gateway (the legacy
|
||||
// passphrase login); `owned` distinguishes the two so logout only closes the bus
|
||||
// client it created.
|
||||
type session struct {
|
||||
gw *gateway
|
||||
owned bool // true => gw was built for this session and must be Closed on logout
|
||||
handle string
|
||||
issuedAt time.Time
|
||||
}
|
||||
|
||||
// sessionStore is the gateway's set of live browser sessions, keyed by the opaque
|
||||
// cookie token. It is independent of any single bus identity.
|
||||
type sessionStore struct {
|
||||
mu sync.Mutex
|
||||
m map[string]*session
|
||||
}
|
||||
|
||||
func newSessionStore() *sessionStore { return &sessionStore{m: map[string]*session{}} }
|
||||
|
||||
func (st *sessionStore) put(token string, s *session) {
|
||||
st.mu.Lock()
|
||||
st.m[token] = s
|
||||
st.mu.Unlock()
|
||||
}
|
||||
|
||||
func (st *sessionStore) get(token string) (*session, bool) {
|
||||
st.mu.Lock()
|
||||
defer st.mu.Unlock()
|
||||
s, ok := st.m[token]
|
||||
return s, ok
|
||||
}
|
||||
|
||||
// drop removes a session and returns it so the caller can close an owned gateway.
|
||||
func (st *sessionStore) drop(token string) (*session, bool) {
|
||||
st.mu.Lock()
|
||||
defer st.mu.Unlock()
|
||||
s, ok := st.m[token]
|
||||
if ok {
|
||||
delete(st.m, token)
|
||||
}
|
||||
return s, ok
|
||||
}
|
||||
|
||||
// closeAll closes every owned per-user gateway (used at shutdown). The shared
|
||||
// operator gateway is owned by main and closed separately.
|
||||
func (st *sessionStore) closeAll() {
|
||||
st.mu.Lock()
|
||||
defer st.mu.Unlock()
|
||||
for tok, s := range st.m {
|
||||
if s.owned && s.gw != nil {
|
||||
_ = s.gw.Close()
|
||||
}
|
||||
delete(st.m, tok)
|
||||
}
|
||||
}
|
||||
|
||||
// identityFromHex builds a cs.Identity from the four hex halves the browser sends
|
||||
// on POST /api/session. It enforces the exact key sizes (sign_pub 32, sign_priv
|
||||
// 64, kex_pub 32, kex_priv 32) so a malformed body cannot produce a half-built
|
||||
// identity that fails opaquely deep in the bus client.
|
||||
func identityFromHex(signPub, signPriv, kexPub, kexPriv string) (cs.Identity, error) {
|
||||
sp, err := hex.DecodeString(signPub)
|
||||
if err != nil {
|
||||
return cs.Identity{}, fmt.Errorf("sign_pub: %w", err)
|
||||
}
|
||||
spriv, err := hex.DecodeString(signPriv)
|
||||
if err != nil {
|
||||
return cs.Identity{}, fmt.Errorf("sign_priv: %w", err)
|
||||
}
|
||||
kp, err := hex.DecodeString(kexPub)
|
||||
if err != nil {
|
||||
return cs.Identity{}, fmt.Errorf("kex_pub: %w", err)
|
||||
}
|
||||
kpriv, err := hex.DecodeString(kexPriv)
|
||||
if err != nil {
|
||||
return cs.Identity{}, fmt.Errorf("kex_priv: %w", err)
|
||||
}
|
||||
if len(sp) != 32 || len(spriv) != 64 || len(kp) != 32 || len(kpriv) != 32 {
|
||||
return cs.Identity{}, fmt.Errorf("wrong key sizes (sign_pub=%d sign_priv=%d kex_pub=%d kex_priv=%d; want 32/64/32/32)",
|
||||
len(sp), len(spriv), len(kp), len(kpriv))
|
||||
}
|
||||
return cs.Identity{SignPub: sp, SignPriv: spriv, KexPub: kp, KexPriv: kpriv}, nil
|
||||
}
|
||||
|
||||
// sessionReq is the POST /api/session body: the user's full wallet identity (hex)
|
||||
// plus a display handle. The private halves arrive only over TLS and are held in
|
||||
// memory for the session; they are never persisted server-side.
|
||||
type sessionReq struct {
|
||||
Handle string `json:"handle"`
|
||||
SignPub string `json:"sign_pub"`
|
||||
SignPriv string `json:"sign_priv"`
|
||||
KexPub string `json:"kex_pub"`
|
||||
KexPriv string `json:"kex_priv"`
|
||||
}
|
||||
|
||||
// handleSession opens a per-user session. It builds the user's bus identity from
|
||||
// the posted keypair, connects a dedicated bus client as that user, and issues a
|
||||
// session cookie bound to it. This is the wallet-model replacement for the
|
||||
// operator passphrase login.
|
||||
func (s *server) handleSession(w http.ResponseWriter, r *http.Request) {
|
||||
var req sessionReq
|
||||
if !decode(w, r, &req) {
|
||||
return
|
||||
}
|
||||
id, err := identityFromHex(req.SignPub, req.SignPriv, req.KexPub, req.KexPriv)
|
||||
if err != nil {
|
||||
writeErr(w, http.StatusBadRequest, "bad identity: "+err.Error())
|
||||
return
|
||||
}
|
||||
cfg := s.busTemplate
|
||||
cfg.Identity = id
|
||||
gw, err := newGateway(cfg)
|
||||
if err != nil {
|
||||
writeErr(w, http.StatusBadGateway, "connect bus as user: "+err.Error())
|
||||
return
|
||||
}
|
||||
tok := newToken()
|
||||
s.sessions.put(tok, &session{gw: gw, owned: true, handle: req.Handle, issuedAt: time.Now()})
|
||||
http.SetCookie(w, &http.Cookie{
|
||||
Name: sessionCookie,
|
||||
Value: tok,
|
||||
Path: "/",
|
||||
HttpOnly: true,
|
||||
SameSite: http.SameSiteLaxMode,
|
||||
})
|
||||
writeJSON(w, http.StatusOK, meResp{Endpoint: gw.endpoint, SignPub: req.SignPub, Handle: req.Handle})
|
||||
}
|
||||
@@ -1,114 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// fixed wallet vector derived in the browser from the mnemonic
|
||||
// "legal winner thank year wave sausage worth useful legal winner thank yellow"
|
||||
// using the unibus-sign-v1 / unibus-kex-v1 HKDF scheme. Used to assert the Go
|
||||
// side accepts the browser-derived key sizes.
|
||||
const (
|
||||
fixSignPub = "3d594317212e53a3685b305539f6789eb8c538579e350ca795278b180ebb53db"
|
||||
fixSignPriv = "94485d66ac958e23546be2e3b7575a47e1264bdf082e09abb7ad02ab32fcd55e3d594317212e53a3685b305539f6789eb8c538579e350ca795278b180ebb53db"
|
||||
fixKexPub = "f3561ca116e4444b8880b8c0a35f2c9e85804d8628006facd84b1a6146208257"
|
||||
fixKexPriv = "f6ffdf15e5ee2af0494897ff43e61a06d632af425a0372cb53a7c3e0f84c2bb2"
|
||||
)
|
||||
|
||||
func TestIdentityFromHex(t *testing.T) {
|
||||
id, err := identityFromHex(fixSignPub, fixSignPriv, fixKexPub, fixKexPriv)
|
||||
if err != nil {
|
||||
t.Fatalf("identityFromHex valid vector: %v", err)
|
||||
}
|
||||
if len(id.SignPub) != 32 || len(id.SignPriv) != 64 || len(id.KexPub) != 32 || len(id.KexPriv) != 32 {
|
||||
t.Fatalf("wrong sizes: %d/%d/%d/%d", len(id.SignPub), len(id.SignPriv), len(id.KexPub), len(id.KexPriv))
|
||||
}
|
||||
|
||||
// Wrong sign_priv size (32 instead of 64) must be rejected.
|
||||
if _, err := identityFromHex(fixSignPub, fixSignPub, fixKexPub, fixKexPriv); err == nil {
|
||||
t.Fatalf("expected error for short sign_priv")
|
||||
}
|
||||
// Non-hex must be rejected.
|
||||
if _, err := identityFromHex("zz", fixSignPriv, fixKexPub, fixKexPriv); err == nil {
|
||||
t.Fatalf("expected error for non-hex sign_pub")
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidHexKey(t *testing.T) {
|
||||
if !validHexKey(fixSignPub) {
|
||||
t.Fatalf("fixSignPub should be a valid 32-byte hex key")
|
||||
}
|
||||
if validHexKey("abcd") {
|
||||
t.Fatalf("short key should be invalid")
|
||||
}
|
||||
if validHexKey(strings.Repeat("z", 64)) {
|
||||
t.Fatalf("non-hex key should be invalid")
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewRegistrarParsesMockTokens(t *testing.T) {
|
||||
r := newRegistrar("", "demo=demo:member, bob=bob, alice=alice:admin")
|
||||
if len(r.mockTokens) != 3 {
|
||||
t.Fatalf("want 3 mock tokens, got %d", len(r.mockTokens))
|
||||
}
|
||||
if r.mockTokens["demo"].role != "member" || r.mockTokens["demo"].handle != "demo" {
|
||||
t.Fatalf("demo token parsed wrong: %+v", r.mockTokens["demo"])
|
||||
}
|
||||
if r.mockTokens["bob"].role != "member" {
|
||||
t.Fatalf("bob should default to role member, got %q", r.mockTokens["bob"].role)
|
||||
}
|
||||
if r.mockTokens["alice"].role != "admin" {
|
||||
t.Fatalf("alice should be admin, got %q", r.mockTokens["alice"].role)
|
||||
}
|
||||
}
|
||||
|
||||
// post builds a server with only a registrar (the register path does not touch a
|
||||
// gateway) and runs one POST /api/register, returning status + decoded body.
|
||||
func postRegister(t *testing.T, s *server, body string) (int, map[string]string) {
|
||||
t.Helper()
|
||||
req := httptest.NewRequest("POST", "/api/register", strings.NewReader(body))
|
||||
w := httptest.NewRecorder()
|
||||
s.handleRegister(w, req)
|
||||
var m map[string]string
|
||||
_ = json.Unmarshal(w.Body.Bytes(), &m)
|
||||
return w.Code, m
|
||||
}
|
||||
|
||||
func TestHandleRegisterMockSingleUse(t *testing.T) {
|
||||
s := &server{registrar: newRegistrar("", "demo=demo:member")}
|
||||
|
||||
// 1) valid token + valid keys => 201 with the invite's handle/role.
|
||||
code, body := postRegister(t, s, `{"token":"demo","sign_pub":"`+fixSignPub+`","kex_pub":"`+fixKexPub+`"}`)
|
||||
if code != 201 {
|
||||
t.Fatalf("first register: want 201, got %d (%v)", code, body)
|
||||
}
|
||||
if body["handle"] != "demo" || body["role"] != "member" {
|
||||
t.Fatalf("first register body: %v", body)
|
||||
}
|
||||
|
||||
// 2) same token again => 409 (single-use consumed).
|
||||
code, _ = postRegister(t, s, `{"token":"demo","sign_pub":"`+fixSignPub+`","kex_pub":"`+fixKexPub+`"}`)
|
||||
if code != 409 {
|
||||
t.Fatalf("reused token: want 409, got %d", code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleRegisterValidation(t *testing.T) {
|
||||
s := &server{registrar: newRegistrar("", "demo=demo:member")}
|
||||
|
||||
// bad sign_pub (too short) => 400
|
||||
if code, _ := postRegister(t, s, `{"token":"demo","sign_pub":"abcd","kex_pub":"`+fixKexPub+`"}`); code != 400 {
|
||||
t.Fatalf("short sign_pub: want 400, got %d", code)
|
||||
}
|
||||
// missing token => 400
|
||||
if code, _ := postRegister(t, s, `{"sign_pub":"`+fixSignPub+`","kex_pub":"`+fixKexPub+`"}`); code != 400 {
|
||||
t.Fatalf("missing token: want 400, got %d", code)
|
||||
}
|
||||
// unknown token with no mock match and no register-url => 400
|
||||
if code, _ := postRegister(t, s, `{"token":"nope","sign_pub":"`+fixSignPub+`","kex_pub":"`+fixKexPub+`"}`); code != 400 {
|
||||
t.Fatalf("unknown token: want 400, got %d", code)
|
||||
}
|
||||
}
|
||||
@@ -1,37 +0,0 @@
|
||||
module github.com/enmanuel/uniweb
|
||||
|
||||
go 1.26.4
|
||||
|
||||
replace fn-registry => ../../../../
|
||||
|
||||
replace github.com/enmanuel/unibus => ../unibus
|
||||
|
||||
require (
|
||||
fn-registry v0.0.0-00010101000000-000000000000
|
||||
github.com/enmanuel/unibus v0.0.0-00010101000000-000000000000
|
||||
github.com/oklog/ulid/v2 v2.1.0
|
||||
)
|
||||
|
||||
require (
|
||||
github.com/antithesishq/antithesis-sdk-go v0.6.0-default-no-op // indirect
|
||||
github.com/dustin/go-humanize v1.0.1 // indirect
|
||||
github.com/google/go-tpm v0.9.8 // indirect
|
||||
github.com/google/uuid v1.6.0 // indirect
|
||||
github.com/klauspost/compress v1.18.4 // indirect
|
||||
github.com/mattn/go-isatty v0.0.20 // indirect
|
||||
github.com/minio/highwayhash v1.0.4-0.20251030100505-070ab1a87a76 // indirect
|
||||
github.com/nats-io/jwt/v2 v2.8.1 // indirect
|
||||
github.com/nats-io/nats-server/v2 v2.11.15 // indirect
|
||||
github.com/nats-io/nats.go v1.49.0 // indirect
|
||||
github.com/nats-io/nkeys v0.4.15 // indirect
|
||||
github.com/nats-io/nuid v1.0.1 // indirect
|
||||
github.com/ncruces/go-strftime v1.0.0 // indirect
|
||||
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
|
||||
golang.org/x/crypto v0.51.0 // indirect
|
||||
golang.org/x/sys v0.44.0 // indirect
|
||||
golang.org/x/time v0.15.0 // indirect
|
||||
modernc.org/libc v1.70.0 // indirect
|
||||
modernc.org/mathutil v1.7.1 // indirect
|
||||
modernc.org/memory v1.11.0 // indirect
|
||||
modernc.org/sqlite v1.47.0 // indirect
|
||||
)
|
||||
@@ -1,77 +0,0 @@
|
||||
github.com/antithesishq/antithesis-sdk-go v0.6.0-default-no-op h1:kpBdlEPbRvff0mDD1gk7o9BhI16b9p5yYAXRlidpqJE=
|
||||
github.com/antithesishq/antithesis-sdk-go v0.6.0-default-no-op/go.mod h1:IUpT2DPAKh6i/YhSbt6Gl3v2yvUZjmKncl7U91fup7E=
|
||||
github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
|
||||
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
|
||||
github.com/google/go-tpm v0.9.8 h1:slArAR9Ft+1ybZu0lBwpSmpwhRXaa85hWtMinMyRAWo=
|
||||
github.com/google/go-tpm v0.9.8/go.mod h1:h9jEsEECg7gtLis0upRBQU+GhYVH6jMjrFxI8u6bVUY=
|
||||
github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs=
|
||||
github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
|
||||
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
|
||||
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
|
||||
github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
|
||||
github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
|
||||
github.com/klauspost/compress v1.18.4 h1:RPhnKRAQ4Fh8zU2FY/6ZFDwTVTxgJ/EMydqSTzE9a2c=
|
||||
github.com/klauspost/compress v1.18.4/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4=
|
||||
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
|
||||
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
|
||||
github.com/minio/highwayhash v1.0.4-0.20251030100505-070ab1a87a76 h1:KGuD/pM2JpL9FAYvBrnBBeENKZNh6eNtjqytV6TYjnk=
|
||||
github.com/minio/highwayhash v1.0.4-0.20251030100505-070ab1a87a76/go.mod h1:GGYsuwP/fPD6Y9hMiXuapVvlIUEhFhMTh0rxU3ik1LQ=
|
||||
github.com/nats-io/jwt/v2 v2.8.1 h1:V0xpGuD/N8Mi+fQNDynXohVvp7ZztevW5io8CUWlPmU=
|
||||
github.com/nats-io/jwt/v2 v2.8.1/go.mod h1:nWnOEEiVMiKHQpnAy4eXlizVEtSfzacZ1Q43LIRavZg=
|
||||
github.com/nats-io/nats-server/v2 v2.11.15 h1:StSf9TINInaZtr4oww2+kXmfwa9SkN//g/LwS19/UJ0=
|
||||
github.com/nats-io/nats-server/v2 v2.11.15/go.mod h1:zwhv8Y0PE3KHyKgznJc/9Xoai638SaJd83zzJ5GJn74=
|
||||
github.com/nats-io/nats.go v1.49.0 h1:yh/WvY59gXqYpgl33ZI+XoVPKyut/IcEaqtsiuTJpoE=
|
||||
github.com/nats-io/nats.go v1.49.0/go.mod h1:fDCn3mN5cY8HooHwE2ukiLb4p4G4ImmzvXyJt+tGwdw=
|
||||
github.com/nats-io/nkeys v0.4.15 h1:JACV5jRVO9V856KOapQ7x+EY8Jo3qw1vJt/9Jpwzkk4=
|
||||
github.com/nats-io/nkeys v0.4.15/go.mod h1:CpMchTXC9fxA5zrMo4KpySxNjiDVvr8ANOSZdiNfUrs=
|
||||
github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
|
||||
github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
|
||||
github.com/ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w=
|
||||
github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
|
||||
github.com/oklog/ulid/v2 v2.1.0 h1:+9lhoxAP56we25tyYETBBY1YLA2SaoLvUFgrP2miPJU=
|
||||
github.com/oklog/ulid/v2 v2.1.0/go.mod h1:rcEKHmBBKfef9DhnvX7y1HZBYxjXb0cP5ExxNsTT1QQ=
|
||||
github.com/pborman/getopt v0.0.0-20170112200414-7148bc3a4c30/go.mod h1:85jBQOZwpVEaDAr341tbn15RS4fCAsIst0qp7i8ex1o=
|
||||
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
|
||||
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
|
||||
golang.org/x/crypto v0.51.0 h1:IBPXwPfKxY7cWQZ38ZCIRPI50YLeevDLlLnyC5wRGTI=
|
||||
golang.org/x/crypto v0.51.0/go.mod h1:8AdwkbraGNABw2kOX6YFPs3WM22XqI4EXEd8g+x7Oc8=
|
||||
golang.org/x/mod v0.36.0 h1:JJjpVx6myfUsUdAzZuOSTTmRE0PfZeNWzzvKrP7amb4=
|
||||
golang.org/x/mod v0.36.0/go.mod h1:moc6ELqsWcOw5Ef3xVprK5ul/MvtVvkIXLziUOICjUQ=
|
||||
golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
|
||||
golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
|
||||
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
|
||||
golang.org/x/sys v0.44.0 h1:ildZl3J4uzeKP07r2F++Op7E9B29JRUy+a27EibtBTQ=
|
||||
golang.org/x/sys v0.44.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
|
||||
golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
|
||||
golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno=
|
||||
golang.org/x/tools v0.45.0 h1:18qN3FAooORvApf5XjCXgsuayZOEtXf6JK18I3+ONa8=
|
||||
golang.org/x/tools v0.45.0/go.mod h1:LuUGqqaXcXMEFEruIVJVm5mgDD8vww/z/SR1gQ4uE/0=
|
||||
modernc.org/cc/v4 v4.27.1 h1:9W30zRlYrefrDV2JE2O8VDtJ1yPGownxciz5rrbQZis=
|
||||
modernc.org/cc/v4 v4.27.1/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
|
||||
modernc.org/ccgo/v4 v4.32.0 h1:hjG66bI/kqIPX1b2yT6fr/jt+QedtP2fqojG2VrFuVw=
|
||||
modernc.org/ccgo/v4 v4.32.0/go.mod h1:6F08EBCx5uQc38kMGl+0Nm0oWczoo1c7cgpzEry7Uc0=
|
||||
modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM=
|
||||
modernc.org/fileutil v1.4.0/go.mod h1:EqdKFDxiByqxLk8ozOxObDSfcVOv/54xDs/DUHdvCUU=
|
||||
modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI=
|
||||
modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito=
|
||||
modernc.org/gc/v3 v3.1.2 h1:ZtDCnhonXSZexk/AYsegNRV1lJGgaNZJuKjJSWKyEqo=
|
||||
modernc.org/gc/v3 v3.1.2/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY=
|
||||
modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks=
|
||||
modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI=
|
||||
modernc.org/libc v1.70.0 h1:U58NawXqXbgpZ/dcdS9kMshu08aiA6b7gusEusqzNkw=
|
||||
modernc.org/libc v1.70.0/go.mod h1:OVmxFGP1CI/Z4L3E0Q3Mf1PDE0BucwMkcXjjLntvHJo=
|
||||
modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
|
||||
modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
|
||||
modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI=
|
||||
modernc.org/memory v1.11.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw=
|
||||
modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8=
|
||||
modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
|
||||
modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
|
||||
modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
|
||||
modernc.org/sqlite v1.47.0 h1:R1XyaNpoW4Et9yly+I2EeX7pBza/w+pmYee/0HJDyKk=
|
||||
modernc.org/sqlite v1.47.0/go.mod h1:hWjRO6Tj/5Ik8ieqxQybiEOUXy0NJFNp2tpvVpKlvig=
|
||||
modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0=
|
||||
modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A=
|
||||
modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
|
||||
modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=
|
||||
+12
-11
@@ -5,7 +5,7 @@ import { Join } from "./Join";
|
||||
import { Recover } from "./Recover";
|
||||
import { WalletLogin } from "./WalletLogin";
|
||||
import { Welcome } from "./Welcome";
|
||||
import { api } from "./api";
|
||||
import { bus } from "./busService";
|
||||
import { localIdentity } from "./wallet/account";
|
||||
import type { User } from "./types";
|
||||
|
||||
@@ -31,9 +31,12 @@ export function App() {
|
||||
const [token, setToken] = useState("");
|
||||
const [storedHandle, setStoredHandle] = useState("");
|
||||
|
||||
// Decide the entry screen on mount: an invite link goes straight to join; a live
|
||||
// gateway session resumes the chat; a device with a stored identity shows the
|
||||
// password unlock; an empty device shows the welcome chooser.
|
||||
// Decide the entry screen on mount: an invite link goes straight to join; otherwise
|
||||
// try to RESTORE a persisted session (survives reloads, and — with "keep me signed
|
||||
// in" — closing the browser, up to its TTL/idle limits) so a reload does not force a
|
||||
// re-unlock; if there is none, a device with a stored identity shows the password
|
||||
// unlock and an empty device shows the welcome chooser. The private key stays in the
|
||||
// browser throughout; nothing is resumed from a server-side cookie.
|
||||
useEffect(() => {
|
||||
const t = readJoinToken();
|
||||
if (t) {
|
||||
@@ -43,14 +46,12 @@ export function App() {
|
||||
}
|
||||
let cancelled = false;
|
||||
(async () => {
|
||||
try {
|
||||
const me = await api.me();
|
||||
if (cancelled) return;
|
||||
setUser({ id: me.endpoint, handle: me.handle || me.endpoint.slice(0, 8) });
|
||||
const restored = await bus.restoreSession();
|
||||
if (cancelled) return;
|
||||
if (restored) {
|
||||
setUser(restored);
|
||||
setRoute("chat");
|
||||
return;
|
||||
} catch {
|
||||
// no live session — fall through
|
||||
}
|
||||
const stored = await localIdentity();
|
||||
if (cancelled) return;
|
||||
@@ -73,7 +74,7 @@ export function App() {
|
||||
};
|
||||
|
||||
const logout = () => {
|
||||
void api.logout().catch(() => {});
|
||||
void bus.logout().catch(() => {});
|
||||
setUser(null);
|
||||
// Keep the encrypted identity on the device: logging out returns to the
|
||||
// password unlock, not a full reset.
|
||||
|
||||
+24
-12
@@ -19,7 +19,7 @@ import {
|
||||
IconDotsVertical,
|
||||
IconPaperclip,
|
||||
} from "@tabler/icons-react";
|
||||
import { api, streamRoom } from "./api";
|
||||
import { bus } from "./busService";
|
||||
import type { Message, Room } from "./types";
|
||||
|
||||
function initials(s: string) {
|
||||
@@ -33,15 +33,23 @@ function timeShort(ts: number) {
|
||||
}
|
||||
|
||||
function MessageRow({ msg }: { msg: Message }) {
|
||||
// Show the readable handle (resolved from the bus directory); the raw endpoint id
|
||||
// stays in the title attribute as a debugging tooltip.
|
||||
const name = bus.displayName(msg.sender);
|
||||
return (
|
||||
<Group align="flex-start" gap="sm" wrap="nowrap">
|
||||
<Avatar radius="xl" size={36} color={msg.mine ? "brand" : "gray"}>
|
||||
{initials(msg.sender)}
|
||||
{initials(name)}
|
||||
</Avatar>
|
||||
<Box style={{ minWidth: 0 }}>
|
||||
<Group gap={8} align="baseline">
|
||||
<Text size="sm" fw={600} c={msg.mine ? "brand.4" : undefined}>
|
||||
{msg.sender}
|
||||
<Text
|
||||
size="sm"
|
||||
fw={600}
|
||||
c={msg.mine ? "brand.4" : undefined}
|
||||
title={msg.sender}
|
||||
>
|
||||
{name}
|
||||
</Text>
|
||||
<Text size="xs" c="dimmed">
|
||||
{timeShort(msg.ts)}
|
||||
@@ -61,16 +69,20 @@ export function ChatPanel({ room }: { room: Room | undefined }) {
|
||||
const [sendError, setSendError] = useState<string | null>(null);
|
||||
const viewport = useRef<HTMLDivElement>(null);
|
||||
|
||||
// Abre el stream SSE de la room activa. El gateway entrega historia (rooms
|
||||
// persistidas) y luego mensajes en vivo, ya descifrados. Dedup por id porque
|
||||
// un re-render no debe duplicar y el eco del propio envío llega por aquí.
|
||||
// Carga el histórico de la room activa y luego sigue en vivo: bus.subscribeRoom
|
||||
// entrega primero la historia (oldest->newest) y después los mensajes en vivo, ya
|
||||
// descifrados y deduplicados por id. Aquí se mantiene la lista ordenada por ts y se
|
||||
// deduplica de nuevo por id, porque un re-render no debe duplicar y el eco del propio
|
||||
// envío también llega por esta vía.
|
||||
useEffect(() => {
|
||||
setMessages([]);
|
||||
setSendError(null);
|
||||
if (!room) return;
|
||||
const close = streamRoom(room.id, (m) => {
|
||||
const close = bus.subscribeRoom(room.id, (m) => {
|
||||
setMessages((prev) =>
|
||||
prev.some((p) => p.id === m.id) ? prev : [...prev, m],
|
||||
prev.some((p) => p.id === m.id)
|
||||
? prev
|
||||
: [...prev, m].sort((a, b) => a.ts - b.ts),
|
||||
);
|
||||
});
|
||||
return close;
|
||||
@@ -94,9 +106,9 @@ export function ChatPanel({ room }: { room: Room | undefined }) {
|
||||
setDraft("");
|
||||
setSendError(null);
|
||||
try {
|
||||
// No optimista: el mensaje propio vuelve por SSE con su id real (mine:true),
|
||||
// evitando duplicados.
|
||||
await api.send(room.id, body);
|
||||
// No optimista: el mensaje propio vuelve por la suscripción con su id real
|
||||
// (mine:true), evitando duplicados.
|
||||
await bus.send(room.id, body);
|
||||
} catch (e) {
|
||||
setDraft(body); // restaura el borrador si el envío falló
|
||||
setSendError(e instanceof Error ? e.message : "No se pudo enviar");
|
||||
|
||||
+55
-10
@@ -1,8 +1,11 @@
|
||||
import { useCallback, useEffect, useState } from "react";
|
||||
import { Flex, Box, Center, Loader, Stack, Text, Button } from "@mantine/core";
|
||||
import { useDisclosure } from "@mantine/hooks";
|
||||
import { IconPlus } from "@tabler/icons-react";
|
||||
import { Sidebar } from "./Sidebar";
|
||||
import { ChatPanel } from "./ChatPanel";
|
||||
import { api } from "./api";
|
||||
import { NewRoomModal } from "./NewRoomModal";
|
||||
import { bus } from "./busService";
|
||||
import type { Room, User } from "./types";
|
||||
|
||||
export function ChatShell({
|
||||
@@ -16,16 +19,34 @@ export function ChatShell({
|
||||
const [activeId, setActiveId] = useState<string>("");
|
||||
const [loading, setLoading] = useState(true);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
const [modalOpen, modal] = useDisclosure(false);
|
||||
|
||||
// The room list lives in busService (it owns a per-room metadata subscription so the
|
||||
// sidebar shows the latest message/time and unread for rooms not being viewed). The
|
||||
// shell just mirrors the store into React state.
|
||||
useEffect(() => bus.watchRooms(setRooms), []);
|
||||
|
||||
// selectRoom activates a room in the UI and tells the store, which clears that room's
|
||||
// unread badge.
|
||||
const selectRoom = useCallback((id: string) => {
|
||||
setActiveId(id);
|
||||
bus.setActiveRoom(id);
|
||||
}, []);
|
||||
|
||||
// La room recién creada ya está en el store (bus.createRoom la insertó); aquí solo
|
||||
// se activa.
|
||||
const handleRoomCreated = useCallback(
|
||||
(room: Room) => {
|
||||
selectRoom(room.id);
|
||||
},
|
||||
[selectRoom],
|
||||
);
|
||||
|
||||
const load = useCallback(() => {
|
||||
setLoading(true);
|
||||
api
|
||||
.listRooms()
|
||||
.then((rs) => {
|
||||
setRooms(rs);
|
||||
setActiveId((cur) => cur || rs[0]?.id || "");
|
||||
setError(null);
|
||||
})
|
||||
bus
|
||||
.loadRooms()
|
||||
.then(() => setError(null))
|
||||
.catch((e) => setError(e?.message ?? "No se pudieron cargar las rooms"))
|
||||
.finally(() => setLoading(false));
|
||||
}, []);
|
||||
@@ -34,6 +55,11 @@ export function ChatShell({
|
||||
load();
|
||||
}, [load]);
|
||||
|
||||
// Activa la primera room en cuanto la lista se puebla y aún no hay ninguna activa.
|
||||
useEffect(() => {
|
||||
if (!activeId && rooms.length > 0) selectRoom(rooms[0].id);
|
||||
}, [rooms, activeId, selectRoom]);
|
||||
|
||||
const active = rooms.find((r) => r.id === activeId);
|
||||
|
||||
// El panel derecho muestra el estado de carga/error/empty sin tocar el layout.
|
||||
@@ -60,7 +86,20 @@ export function ChatShell({
|
||||
} else if (rooms.length === 0) {
|
||||
panel = (
|
||||
<Center h="100%">
|
||||
<Text c="dimmed">No perteneces a ninguna room todavía</Text>
|
||||
<Stack align="center" gap="sm" maw={320} ta="center">
|
||||
<Text fw={600}>Aún no hay conversaciones</Text>
|
||||
<Text c="dimmed" size="sm">
|
||||
Crea tu primera room cifrada para empezar a chatear.
|
||||
</Text>
|
||||
<Button
|
||||
color="brand"
|
||||
leftSection={<IconPlus size={16} />}
|
||||
onClick={modal.open}
|
||||
mt="xs"
|
||||
>
|
||||
Crear room
|
||||
</Button>
|
||||
</Stack>
|
||||
</Center>
|
||||
);
|
||||
}
|
||||
@@ -80,13 +119,19 @@ export function ChatShell({
|
||||
user={user}
|
||||
rooms={rooms}
|
||||
activeId={activeId}
|
||||
onSelect={setActiveId}
|
||||
onSelect={selectRoom}
|
||||
onLogout={onLogout}
|
||||
onNewRoom={modal.open}
|
||||
/>
|
||||
</Box>
|
||||
<Box flex={1} h="100%" bg="dark.7" style={{ minWidth: 0 }}>
|
||||
{panel}
|
||||
</Box>
|
||||
<NewRoomModal
|
||||
opened={modalOpen}
|
||||
onClose={modal.close}
|
||||
onCreated={handleRoomCreated}
|
||||
/>
|
||||
</Flex>
|
||||
);
|
||||
}
|
||||
|
||||
+14
-6
@@ -21,7 +21,7 @@ import {
|
||||
IconKey,
|
||||
IconShieldLock,
|
||||
} from "@tabler/icons-react";
|
||||
import { api, ApiError } from "./api";
|
||||
import { SessionError } from "./busService";
|
||||
import { AuthCard, AuthHeader } from "./AuthShell";
|
||||
import type { User } from "./types";
|
||||
import { newMnemonic, mnemonicWords } from "./wallet/bip39";
|
||||
@@ -124,14 +124,22 @@ export function Join({
|
||||
setStep("joining");
|
||||
setError(null);
|
||||
try {
|
||||
// Register the PUBLIC identity with the bus (token authorizes), then
|
||||
// encrypt the private key locally and open the per-user session.
|
||||
const res = await api.register(token, identity.signPub, identity.kexPub);
|
||||
const user = await saveAndOpen(identity, res.handle, password);
|
||||
// The bus has no token-register endpoint (that was a gateway mock): a
|
||||
// browser cannot self-register on an enforce cluster. The identity must be
|
||||
// allow-listed by an admin first. We persist it locally and try to open the
|
||||
// session; if the identity is not yet authorized, openSession fails and we
|
||||
// tell the user to have an admin authorize their public key.
|
||||
const handle = identity.signPub.slice(0, 8);
|
||||
// Creating the account on this device implies it is yours: keep the session.
|
||||
const user = await saveAndOpen(identity, handle, password, true);
|
||||
onJoined(user);
|
||||
} catch (e) {
|
||||
const base =
|
||||
e instanceof SessionError || e instanceof Error
|
||||
? e.message
|
||||
: "No se pudo completar el alta.";
|
||||
setError(
|
||||
e instanceof ApiError ? e.message : "No se pudo completar el alta.",
|
||||
`${base}. Pide a un administrador que autorice tu clave pública: ${identity.signPub}`,
|
||||
);
|
||||
setStep("password");
|
||||
}
|
||||
|
||||
@@ -1,89 +0,0 @@
|
||||
import { useState } from "react";
|
||||
import {
|
||||
Button,
|
||||
Card,
|
||||
Center,
|
||||
PasswordInput,
|
||||
Stack,
|
||||
Text,
|
||||
TextInput,
|
||||
ThemeIcon,
|
||||
Title,
|
||||
} from "@mantine/core";
|
||||
import { IconShieldLock, IconKey } from "@tabler/icons-react";
|
||||
import { api, ApiError } from "./api";
|
||||
import type { User } from "./types";
|
||||
|
||||
export function Login({ onLogin }: { onLogin: (u: User) => void }) {
|
||||
const [handle, setHandle] = useState("");
|
||||
const [password, setPassword] = useState("");
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
const ready = handle.trim().length > 0 && password.length > 0;
|
||||
const connect = async () => {
|
||||
if (!ready || busy) return;
|
||||
setBusy(true);
|
||||
setError(null);
|
||||
try {
|
||||
// La contraseña desbloquea la sesión del gateway (passphrase del operador).
|
||||
// El handle es solo el nombre a mostrar en esta iteración (wallet = fase 2).
|
||||
const me = await api.login(password);
|
||||
const h = handle.trim() || me.endpoint.slice(0, 8);
|
||||
onLogin({ id: me.endpoint, handle: h });
|
||||
} catch (e) {
|
||||
setError(e instanceof ApiError ? e.message : "No se pudo conectar al gateway");
|
||||
setBusy(false);
|
||||
}
|
||||
};
|
||||
|
||||
return (
|
||||
<Center h="100vh" bg="dark.9">
|
||||
<Card w={380} p="xl" radius="lg" withBorder bg="dark.7">
|
||||
<Stack align="center" gap="lg">
|
||||
<ThemeIcon size={60} radius="xl" variant="light" color="brand">
|
||||
<IconShieldLock size={32} />
|
||||
</ThemeIcon>
|
||||
<Stack gap={2} align="center">
|
||||
<Title order={2}>unibus</Title>
|
||||
<Text c="dimmed" size="sm">
|
||||
Mensajería cifrada de extremo a extremo
|
||||
</Text>
|
||||
</Stack>
|
||||
<TextInput
|
||||
w="100%"
|
||||
label="Identidad"
|
||||
placeholder="tu-handle"
|
||||
value={handle}
|
||||
onChange={(e) => setHandle(e.currentTarget.value)}
|
||||
onKeyDown={(e) => e.key === "Enter" && connect()}
|
||||
data-autofocus
|
||||
/>
|
||||
<PasswordInput
|
||||
w="100%"
|
||||
label="Contraseña"
|
||||
description="Desbloquea tu identidad cifrada en este dispositivo"
|
||||
placeholder="••••••••"
|
||||
leftSection={<IconKey size={16} />}
|
||||
value={password}
|
||||
onChange={(e) => setPassword(e.currentTarget.value)}
|
||||
onKeyDown={(e) => e.key === "Enter" && void connect()}
|
||||
/>
|
||||
{error && (
|
||||
<Text c="red" size="sm" ta="center">
|
||||
{error}
|
||||
</Text>
|
||||
)}
|
||||
<Button
|
||||
w="100%"
|
||||
size="md"
|
||||
onClick={() => void connect()}
|
||||
disabled={!ready}
|
||||
loading={busy}
|
||||
>
|
||||
Conectar
|
||||
</Button>
|
||||
</Stack>
|
||||
</Card>
|
||||
</Center>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,112 @@
|
||||
import { useEffect, useState } from "react";
|
||||
import {
|
||||
Alert,
|
||||
Button,
|
||||
Group,
|
||||
Modal,
|
||||
Stack,
|
||||
Text,
|
||||
TextInput,
|
||||
} from "@mantine/core";
|
||||
import { IconAlertCircle, IconLock, IconPlus } from "@tabler/icons-react";
|
||||
import { bus, SessionError } from "./busService";
|
||||
import type { Room } from "./types";
|
||||
|
||||
// NewRoomModal pide el asunto de una room nueva y la crea contra el bus. La room
|
||||
// que devuelve `bus.createRoom` (cifrada + firmada, propiedad del usuario) se
|
||||
// entrega al padre vía `onCreated` para insertarla en la lista sin recargar.
|
||||
export function NewRoomModal({
|
||||
opened,
|
||||
onClose,
|
||||
onCreated,
|
||||
}: {
|
||||
opened: boolean;
|
||||
onClose: () => void;
|
||||
onCreated: (room: Room) => void;
|
||||
}) {
|
||||
const [subject, setSubject] = useState("");
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
|
||||
// Cada vez que se abre el modal partimos de un formulario limpio.
|
||||
useEffect(() => {
|
||||
if (opened) {
|
||||
setSubject("");
|
||||
setBusy(false);
|
||||
setError(null);
|
||||
}
|
||||
}, [opened]);
|
||||
|
||||
const create = async () => {
|
||||
const name = subject.trim();
|
||||
if (!name || busy) return;
|
||||
setBusy(true);
|
||||
setError(null);
|
||||
try {
|
||||
const room = await bus.createRoom(name);
|
||||
onCreated(room);
|
||||
onClose();
|
||||
} catch (e) {
|
||||
const msg =
|
||||
e instanceof SessionError
|
||||
? "Tu sesión con el bus expiró. Vuelve a iniciar sesión."
|
||||
: e instanceof Error
|
||||
? e.message
|
||||
: "No se pudo crear la room";
|
||||
setError(msg);
|
||||
} finally {
|
||||
setBusy(false);
|
||||
}
|
||||
};
|
||||
|
||||
return (
|
||||
<Modal
|
||||
opened={opened}
|
||||
onClose={onClose}
|
||||
title="Nueva room"
|
||||
centered
|
||||
radius="md"
|
||||
overlayProps={{ blur: 2 }}
|
||||
>
|
||||
<Stack gap="md">
|
||||
<Text size="sm" c="dimmed">
|
||||
Crea una conversación cifrada de extremo a extremo. Tú eres la dueña y
|
||||
puedes invitar miembros después.
|
||||
</Text>
|
||||
<TextInput
|
||||
label="Asunto"
|
||||
placeholder="ej. equipo-infra, anuncios, 1-a-1 con ana…"
|
||||
data-autofocus
|
||||
value={subject}
|
||||
onChange={(e) => setSubject(e.currentTarget.value)}
|
||||
onKeyDown={(e) => e.key === "Enter" && void create()}
|
||||
leftSection={<IconLock size={16} />}
|
||||
disabled={busy}
|
||||
/>
|
||||
{error && (
|
||||
<Alert
|
||||
color="red"
|
||||
variant="light"
|
||||
icon={<IconAlertCircle size={16} />}
|
||||
>
|
||||
{error}
|
||||
</Alert>
|
||||
)}
|
||||
<Group justify="flex-end" gap="sm">
|
||||
<Button variant="subtle" color="gray" onClick={onClose} disabled={busy}>
|
||||
Cancelar
|
||||
</Button>
|
||||
<Button
|
||||
color="brand"
|
||||
leftSection={<IconPlus size={16} />}
|
||||
onClick={() => void create()}
|
||||
loading={busy}
|
||||
disabled={!subject.trim()}
|
||||
>
|
||||
Crear room
|
||||
</Button>
|
||||
</Group>
|
||||
</Stack>
|
||||
</Modal>
|
||||
);
|
||||
}
|
||||
+4
-3
@@ -13,7 +13,7 @@ import {
|
||||
} from "@mantine/core";
|
||||
import { IconKey, IconRotateClockwise } from "@tabler/icons-react";
|
||||
import { AuthCard, AuthHeader } from "./AuthShell";
|
||||
import { ApiError } from "./api";
|
||||
import { SessionError } from "./busService";
|
||||
import type { User } from "./types";
|
||||
import { isValidMnemonic, mnemonicWords, normalizeMnemonic } from "./wallet/bip39";
|
||||
import { deriveIdentity } from "./wallet/derive";
|
||||
@@ -108,11 +108,12 @@ export function Recover({
|
||||
try {
|
||||
// No register here: the identity is already in the allowlist. Just re-encrypt
|
||||
// locally and open the session as the recovered user.
|
||||
const user = await saveAndOpen(identity, handle.trim(), pw);
|
||||
// Recovering on this device implies it is yours: keep the session by default.
|
||||
const user = await saveAndOpen(identity, handle.trim(), pw, true);
|
||||
onRecovered(user);
|
||||
} catch (e) {
|
||||
setError(
|
||||
e instanceof ApiError
|
||||
e instanceof SessionError || e instanceof Error
|
||||
? e.message
|
||||
: "No se pudo abrir la sesión con la identidad recuperada.",
|
||||
);
|
||||
|
||||
+58
-19
@@ -1,5 +1,6 @@
|
||||
import { useState } from "react";
|
||||
import {
|
||||
ActionIcon,
|
||||
Avatar,
|
||||
Badge,
|
||||
Box,
|
||||
@@ -10,6 +11,7 @@ import {
|
||||
Stack,
|
||||
Text,
|
||||
TextInput,
|
||||
Tooltip,
|
||||
UnstyledButton,
|
||||
} from "@mantine/core";
|
||||
import {
|
||||
@@ -18,6 +20,7 @@ import {
|
||||
IconDots,
|
||||
IconLock,
|
||||
IconHash,
|
||||
IconPlus,
|
||||
} from "@tabler/icons-react";
|
||||
import type { Room, User } from "./types";
|
||||
|
||||
@@ -25,7 +28,10 @@ function initials(s: string) {
|
||||
return s.replace(/[^a-z0-9]/gi, "").slice(0, 2).toUpperCase() || "?";
|
||||
}
|
||||
|
||||
// timeShort renders HH:MM, or an em dash when there is no message yet (ts 0/falsy) so
|
||||
// an empty room does not show the epoch-0 "01:00".
|
||||
function timeShort(ts: number) {
|
||||
if (!ts) return "—";
|
||||
const d = new Date(ts);
|
||||
return `${String(d.getHours()).padStart(2, "0")}:${String(
|
||||
d.getMinutes(),
|
||||
@@ -94,12 +100,14 @@ export function Sidebar({
|
||||
activeId,
|
||||
onSelect,
|
||||
onLogout,
|
||||
onNewRoom,
|
||||
}: {
|
||||
user: User;
|
||||
rooms: Room[];
|
||||
activeId: string;
|
||||
onSelect: (id: string) => void;
|
||||
onLogout: () => void;
|
||||
onNewRoom: () => void;
|
||||
}) {
|
||||
const [q, setQ] = useState("");
|
||||
const query = q.trim().toLowerCase();
|
||||
@@ -122,21 +130,35 @@ export function Sidebar({
|
||||
{user.handle}
|
||||
</Text>
|
||||
</Group>
|
||||
<Menu position="bottom-end" withinPortal>
|
||||
<Menu.Target>
|
||||
<UnstyledButton c="dimmed">
|
||||
<IconDots size={18} />
|
||||
</UnstyledButton>
|
||||
</Menu.Target>
|
||||
<Menu.Dropdown>
|
||||
<Menu.Item
|
||||
leftSection={<IconLogout size={15} />}
|
||||
onClick={onLogout}
|
||||
<Group gap={4} wrap="nowrap">
|
||||
<Tooltip label="Nueva room" position="bottom" withArrow>
|
||||
<ActionIcon
|
||||
variant="subtle"
|
||||
color="brand"
|
||||
size="lg"
|
||||
radius="md"
|
||||
onClick={onNewRoom}
|
||||
aria-label="Crear nueva room"
|
||||
>
|
||||
Desconectar
|
||||
</Menu.Item>
|
||||
</Menu.Dropdown>
|
||||
</Menu>
|
||||
<IconPlus size={20} />
|
||||
</ActionIcon>
|
||||
</Tooltip>
|
||||
<Menu position="bottom-end" withinPortal>
|
||||
<Menu.Target>
|
||||
<UnstyledButton c="dimmed">
|
||||
<IconDots size={18} />
|
||||
</UnstyledButton>
|
||||
</Menu.Target>
|
||||
<Menu.Dropdown>
|
||||
<Menu.Item
|
||||
leftSection={<IconLogout size={15} />}
|
||||
onClick={onLogout}
|
||||
>
|
||||
Desconectar
|
||||
</Menu.Item>
|
||||
</Menu.Dropdown>
|
||||
</Menu>
|
||||
</Group>
|
||||
</Group>
|
||||
|
||||
<Box px="sm" pb="sm">
|
||||
@@ -161,11 +183,28 @@ export function Sidebar({
|
||||
onClick={() => onSelect(room.id)}
|
||||
/>
|
||||
))}
|
||||
{filtered.length === 0 && (
|
||||
<Text c="dimmed" size="sm" ta="center" mt="md">
|
||||
Sin resultados
|
||||
</Text>
|
||||
)}
|
||||
{filtered.length === 0 &&
|
||||
(query ? (
|
||||
<Text c="dimmed" size="sm" ta="center" mt="md">
|
||||
Sin resultados
|
||||
</Text>
|
||||
) : (
|
||||
<Stack align="center" gap="xs" mt="xl" px="md">
|
||||
<Text c="dimmed" size="sm" ta="center">
|
||||
Aún no tienes ninguna room.
|
||||
</Text>
|
||||
<UnstyledButton
|
||||
onClick={onNewRoom}
|
||||
c="brand.4"
|
||||
style={{ fontSize: "var(--mantine-font-size-sm)", fontWeight: 600 }}
|
||||
>
|
||||
<Group gap={4} wrap="nowrap">
|
||||
<IconPlus size={15} />
|
||||
Crear tu primera room
|
||||
</Group>
|
||||
</UnstyledButton>
|
||||
</Stack>
|
||||
))}
|
||||
</Stack>
|
||||
</ScrollArea>
|
||||
</Stack>
|
||||
|
||||
+13
-5
@@ -1,8 +1,8 @@
|
||||
import { useState } from "react";
|
||||
import { Anchor, Button, Group, PasswordInput, Text } from "@mantine/core";
|
||||
import { Anchor, Button, Checkbox, Group, PasswordInput, Text } from "@mantine/core";
|
||||
import { IconKey, IconWallet } from "@tabler/icons-react";
|
||||
import { AuthCard, AuthHeader } from "./AuthShell";
|
||||
import { ApiError } from "./api";
|
||||
import { SessionError } from "./busService";
|
||||
import type { User } from "./types";
|
||||
import { unlockAndOpen } from "./wallet/account";
|
||||
import { WrongPasswordError } from "./wallet/crypto";
|
||||
@@ -20,6 +20,7 @@ export function WalletLogin({
|
||||
onRecover: () => void;
|
||||
}) {
|
||||
const [password, setPassword] = useState("");
|
||||
const [remember, setRemember] = useState(true);
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
|
||||
@@ -28,15 +29,16 @@ export function WalletLogin({
|
||||
setBusy(true);
|
||||
setError(null);
|
||||
try {
|
||||
const user = await unlockAndOpen(password);
|
||||
const user = await unlockAndOpen(password, remember);
|
||||
onLoggedIn(user);
|
||||
} catch (e) {
|
||||
if (e instanceof WrongPasswordError) {
|
||||
setError("Contraseña incorrecta.");
|
||||
} else if (e instanceof ApiError) {
|
||||
} else if (e instanceof SessionError) {
|
||||
setError(e.message);
|
||||
} else {
|
||||
setError("No se pudo abrir tu identidad.");
|
||||
// A connection/authorization failure (e.g. identity not yet allow-listed).
|
||||
setError(e instanceof Error ? e.message : "No se pudo abrir tu identidad.");
|
||||
}
|
||||
setBusy(false);
|
||||
}
|
||||
@@ -59,6 +61,12 @@ export function WalletLogin({
|
||||
onKeyDown={(e) => e.key === "Enter" && void unlock()}
|
||||
data-autofocus
|
||||
/>
|
||||
<Checkbox
|
||||
label="Mantener la sesión en este dispositivo"
|
||||
description="Hasta 30 días; se bloquea sola tras 12 h sin usarla. Desmárcala en un dispositivo compartido."
|
||||
checked={remember}
|
||||
onChange={(e) => setRemember(e.currentTarget.checked)}
|
||||
/>
|
||||
{error && (
|
||||
<Text c="red" size="sm" ta="center">
|
||||
{error}
|
||||
|
||||
-167
@@ -1,167 +0,0 @@
|
||||
// La única capa por la que la SPA habla con el bus. Cada llamada va al gateway Go
|
||||
// bajo /api; el gateway mantiene la sesión `pkg/client` (peer autenticado del
|
||||
// bus), cifra/descifra por room y traduce a REST/SSE. El navegador nunca firma,
|
||||
// nunca habla NATS y nunca ve una clave privada: solo guarda una cookie de
|
||||
// sesión opaca (HttpOnly) que el gateway emite tras el login.
|
||||
import type {
|
||||
MeInfo,
|
||||
Message,
|
||||
MsgWire,
|
||||
RegisterResult,
|
||||
Room,
|
||||
RoomWire,
|
||||
} from "./types";
|
||||
import type { WalletIdentity } from "./wallet/derive";
|
||||
|
||||
export class ApiError extends Error {
|
||||
status: number;
|
||||
constructor(message: string, status: number) {
|
||||
super(message);
|
||||
this.status = status;
|
||||
}
|
||||
}
|
||||
|
||||
async function req<T>(path: string, init?: RequestInit): Promise<T> {
|
||||
const res = await fetch(path, {
|
||||
// same-origin envía la cookie de sesión automáticamente (también detrás del
|
||||
// proxy de vite en dev).
|
||||
credentials: "same-origin",
|
||||
headers: { "Content-Type": "application/json" },
|
||||
...init,
|
||||
});
|
||||
const text = await res.text();
|
||||
let body: unknown = null;
|
||||
if (text) {
|
||||
try {
|
||||
body = JSON.parse(text);
|
||||
} catch {
|
||||
body = text;
|
||||
}
|
||||
}
|
||||
if (!res.ok) {
|
||||
const msg =
|
||||
body && typeof body === "object" && "error" in body
|
||||
? String((body as { error: unknown }).error)
|
||||
: `HTTP ${res.status}`;
|
||||
throw new ApiError(msg, res.status);
|
||||
}
|
||||
return body as T;
|
||||
}
|
||||
|
||||
// roomFromWire mapea la fila del gateway al tipo Room que consume la UI. Los
|
||||
// mensajes NO viven aquí: llegan por stream(). lastMessage/lastTs/unread se
|
||||
// rellenan de forma neutra para no inventar datos (la cabecera de la sidebar se
|
||||
// alimentará del stream en una iteración futura).
|
||||
export function roomFromWire(r: RoomWire): Room {
|
||||
return {
|
||||
id: r.id,
|
||||
name: r.name || r.subject,
|
||||
encrypted: r.encrypt,
|
||||
lastMessage: "",
|
||||
lastTs: 0,
|
||||
unread: 0,
|
||||
messages: [],
|
||||
};
|
||||
}
|
||||
|
||||
// messageFromWire mapea un frame descifrado del SSE al tipo Message de la UI.
|
||||
export function messageFromWire(m: MsgWire): Message {
|
||||
return {
|
||||
id: m.id,
|
||||
sender: m.sender,
|
||||
body: m.body,
|
||||
ts: m.ts,
|
||||
mine: m.mine,
|
||||
};
|
||||
}
|
||||
|
||||
export const api = {
|
||||
// ---- onboarding wallet --------------------------------------------------
|
||||
// register publica la identidad PÚBLICA del nuevo usuario en el allowlist del
|
||||
// bus usando el token del enlace de invitación. NO requiere sesión: el token
|
||||
// autoriza. El handle y el rol los fija el invite, no el cliente. La clave
|
||||
// privada NUNCA se envía aquí.
|
||||
register: (token: string, signPub: string, kexPub: string) =>
|
||||
req<RegisterResult>("/api/register", {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ token, sign_pub: signPub, kex_pub: kexPub }),
|
||||
}),
|
||||
|
||||
// session abre una sesión POR USUARIO: el navegador entrega su identidad wallet
|
||||
// completa (incluida la privada, solo por TLS) y el gateway conecta un cliente
|
||||
// del bus que actúa COMO ese usuario. La privada vive en memoria del gateway
|
||||
// mientras dure la sesión; no se persiste en el servidor.
|
||||
session: (id: WalletIdentity, handle: string) =>
|
||||
req<MeInfo>("/api/session", {
|
||||
method: "POST",
|
||||
body: JSON.stringify({
|
||||
handle,
|
||||
sign_pub: id.signPub,
|
||||
sign_priv: id.signPriv,
|
||||
kex_pub: id.kexPub,
|
||||
kex_priv: id.kexPriv,
|
||||
}),
|
||||
}),
|
||||
|
||||
// ---- sesión (legacy operador) ------------------------------------------
|
||||
// login desbloquea una sesión ligada al gateway del operador con su passphrase.
|
||||
// El camino principal ahora es el wallet (session); login se mantiene por
|
||||
// compatibilidad con el MVP de operador único.
|
||||
login: (passphrase: string) =>
|
||||
req<MeInfo>("/api/login", {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ passphrase }),
|
||||
}),
|
||||
logout: () => req<{ status: string }>("/api/logout", { method: "POST" }),
|
||||
me: () => req<MeInfo>("/api/me"),
|
||||
|
||||
// ---- rooms --------------------------------------------------------------
|
||||
listRooms: async (): Promise<Room[]> => {
|
||||
const wire = await req<RoomWire[]>("/api/rooms");
|
||||
return wire.map(roomFromWire);
|
||||
},
|
||||
// createRoom: {subject, encrypted} basta — el gateway deriva la policy
|
||||
// Matrix-like (cifrada + persistida + firmada) por defecto.
|
||||
createRoom: async (subject: string, encrypted = true): Promise<Room> => {
|
||||
const r = await req<RoomWire>("/api/rooms", {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ subject, encrypted }),
|
||||
});
|
||||
return roomFromWire(r);
|
||||
},
|
||||
join: (roomID: string) =>
|
||||
req<{ status: string }>(
|
||||
`/api/rooms/${encodeURIComponent(roomID)}/join`,
|
||||
{ method: "POST" },
|
||||
),
|
||||
send: (roomID: string, body: string) =>
|
||||
req<{ status: string }>(
|
||||
`/api/rooms/${encodeURIComponent(roomID)}/send`,
|
||||
{ method: "POST", body: JSON.stringify({ body }) },
|
||||
),
|
||||
};
|
||||
|
||||
// streamRoom abre el SSE de una room y llama onMessage por cada frame descifrado
|
||||
// (historia primero en rooms persistidas, luego en vivo). Devuelve una función
|
||||
// de cierre. EventSource manda la cookie de sesión automáticamente y reconecta
|
||||
// solo si la conexión cae; onError se invoca en cada corte para que la UI pueda
|
||||
// reflejar el estado.
|
||||
export function streamRoom(
|
||||
roomID: string,
|
||||
onMessage: (m: Message) => void,
|
||||
onError?: (e: Event) => void,
|
||||
): () => void {
|
||||
const es = new EventSource(
|
||||
`/api/rooms/${encodeURIComponent(roomID)}/stream`,
|
||||
);
|
||||
es.onmessage = (ev) => {
|
||||
try {
|
||||
const wire = JSON.parse(ev.data) as MsgWire;
|
||||
onMessage(messageFromWire(wire));
|
||||
} catch {
|
||||
// frame malformado: se ignora, el stream sigue.
|
||||
}
|
||||
};
|
||||
if (onError) es.onerror = onError;
|
||||
return () => es.close();
|
||||
}
|
||||
+146
-5
@@ -60,6 +60,22 @@ export function newULID(nowMs: number = Date.now()): string {
|
||||
return ts + r;
|
||||
}
|
||||
|
||||
// ulidTime decodes the millisecond epoch timestamp a ULID encodes in its first 10
|
||||
// Crockford base32 characters (the inverse of newULID's time prefix). A frame carries
|
||||
// no explicit timestamp on the wire — its ULID id IS the timestamp — so the UI derives
|
||||
// a message's time from it, which keeps live and replayed-history messages on the same
|
||||
// clock (the sender's send time, not the receiver's arrival time). Returns 0 for an id
|
||||
// whose prefix is not valid Crockford base32, so a malformed id never blows up the UI.
|
||||
export function ulidTime(id: string): number {
|
||||
let t = 0;
|
||||
for (let i = 0; i < 10 && i < id.length; i++) {
|
||||
const v = CROCKFORD.indexOf(id[i].toUpperCase());
|
||||
if (v < 0) return 0;
|
||||
t = t * 32 + v;
|
||||
}
|
||||
return t;
|
||||
}
|
||||
|
||||
// --- room envelope (pure, the security-critical core) ------------------------
|
||||
|
||||
export interface SealOptions {
|
||||
@@ -138,6 +154,10 @@ export type MessageHandler = (subject: string, data: Uint8Array) => void;
|
||||
export interface NatsTransport {
|
||||
publish(subject: string, data: Uint8Array): void | Promise<void>;
|
||||
subscribe(subject: string, handler: MessageHandler): Promise<Subscription>;
|
||||
// reconnect rebuilds the connection so the server's per-subject ACL re-evaluates
|
||||
// this peer's room membership (a room created after connecting is otherwise not in
|
||||
// the grant). Active subscriptions are dropped; re-subscribe after calling it.
|
||||
reconnect(): Promise<void>;
|
||||
close(): Promise<void>;
|
||||
}
|
||||
|
||||
@@ -152,6 +172,14 @@ interface RoomKeyResponse {
|
||||
epoch: number;
|
||||
}
|
||||
|
||||
// HistoryResp is GET /rooms/{id}/history?limit=N: a room's replayed frames, oldest ->
|
||||
// newest, each base64-standard encoded. Every entry is one marshaled wire frame — the
|
||||
// exact bytes the live subscription delivers — so the caller opens them with the same
|
||||
// envelope path as a live message. A room with no stored history yields an empty list.
|
||||
interface HistoryResp {
|
||||
messages: string[];
|
||||
}
|
||||
|
||||
// PolicyWire is the control-plane JSON shape of a policy (snake_case sign_msgs).
|
||||
interface PolicyWire {
|
||||
encrypt: boolean;
|
||||
@@ -172,6 +200,37 @@ interface MemberJSON {
|
||||
sign_pub: string; // base64
|
||||
}
|
||||
|
||||
// DirectoryMemberWire is one row of GET /directory: a cluster-wide member with its
|
||||
// human handle and role. sign_pub here is 64-hex (the raw Ed25519 public key), and
|
||||
// endpoint matches endpointID(signPub) byte for byte.
|
||||
interface DirectoryMemberWire {
|
||||
sign_pub: string; // 64-hex
|
||||
endpoint: string; // base64url-nopad, == endpointID(signPub)
|
||||
handle: string;
|
||||
role: string;
|
||||
}
|
||||
|
||||
interface DirectoryResp {
|
||||
members: DirectoryMemberWire[];
|
||||
}
|
||||
|
||||
// DirectoryEntry is the SDK shape of one directory member: the readable handle keyed
|
||||
// by the stable endpoint id, so the UI can show a name instead of the raw id.
|
||||
export interface DirectoryEntry {
|
||||
signPub: string; // 64-hex
|
||||
endpoint: string;
|
||||
handle: string;
|
||||
role: string;
|
||||
}
|
||||
|
||||
// MemberRoomWire is one row of GET /members/{endpoint}/rooms.
|
||||
interface MemberRoomWire {
|
||||
room_id: string;
|
||||
subject: string;
|
||||
epoch: number;
|
||||
policy: PolicyWire;
|
||||
}
|
||||
|
||||
// ControlPlane is the signed HTTP client for the membershipd control plane. Every
|
||||
// request carries the X-Unibus-* auth headers (busauth.signedHeaders). It pins no
|
||||
// host so it can target any cluster node.
|
||||
@@ -261,6 +320,33 @@ export class ControlPlane {
|
||||
return { key, epoch: resp.epoch };
|
||||
}
|
||||
|
||||
// listMemberRooms returns the rooms a peer belongs to (GET /members/{endpoint}/rooms),
|
||||
// mapping the wire shape (room_id, snake_case policy) to the SDK Room type.
|
||||
async listMemberRooms(endpoint: string): Promise<Room[]> {
|
||||
const wire = await this.request<MemberRoomWire[]>("GET", `/members/${endpoint}/rooms`);
|
||||
return wire.map((r) => ({
|
||||
id: r.room_id,
|
||||
subject: r.subject,
|
||||
epoch: r.epoch,
|
||||
policy: { encrypt: r.policy.encrypt, persist: r.policy.persist, signMsgs: r.policy.sign_msgs },
|
||||
}));
|
||||
}
|
||||
|
||||
// fetchDirectory returns the cluster-wide member directory (GET /api/directory), so
|
||||
// the UI can resolve a message sender's endpoint id to a readable handle. The
|
||||
// request is signed like every other control-plane call. The caller is expected to
|
||||
// tolerate this endpoint being absent on older clusters (404) and fall back to the
|
||||
// short id; this method only maps the wire shape and lets transport errors surface.
|
||||
async fetchDirectory(): Promise<DirectoryEntry[]> {
|
||||
const resp = await this.request<DirectoryResp>("GET", "/directory");
|
||||
return (resp.members ?? []).map((m) => ({
|
||||
signPub: m.sign_pub,
|
||||
endpoint: m.endpoint,
|
||||
handle: m.handle,
|
||||
role: m.role,
|
||||
}));
|
||||
}
|
||||
|
||||
// listMembers returns the room's members keyed by endpoint, so a receiver can find
|
||||
// a sender's signing public key to verify message signatures.
|
||||
async signerKeys(roomID: string): Promise<Map<string, Uint8Array>> {
|
||||
@@ -269,6 +355,17 @@ export class ControlPlane {
|
||||
for (const member of members) m.set(member.endpoint, base64ToBytesLocal(member.sign_pub));
|
||||
return m;
|
||||
}
|
||||
|
||||
// fetchHistory replays a room's stored frames (GET /rooms/{id}/history?limit=N),
|
||||
// returning up to N marshaled wire frames oldest -> newest. The server base64-standard
|
||||
// encodes each frame; this decodes them back to the raw bytes the live subscription
|
||||
// delivers, so BusClient.history can open each with the same envelope path as
|
||||
// subscribe. The caller tolerates this endpoint being absent on older clusters
|
||||
// (404/500): the error surfaces and BusClient.history's caller falls back to live-only.
|
||||
async fetchHistory(roomID: string, limit = 200): Promise<Uint8Array[]> {
|
||||
const resp = await this.request<HistoryResp>("GET", `/rooms/${roomID}/history?limit=${limit}`);
|
||||
return (resp.messages ?? []).map((b64) => base64ToBytesLocal(b64));
|
||||
}
|
||||
}
|
||||
|
||||
// base64ToBytesLocal decodes standard base64 (kept local to avoid widening crypto's
|
||||
@@ -330,21 +427,65 @@ export class BusClient {
|
||||
await this.transport.publish(room.subject, marshal(f));
|
||||
}
|
||||
|
||||
// openFrame is the shared envelope-opening core behind subscribe (live) and history
|
||||
// (replay): it unmarshals one wire frame, resolves the sender's signing key (from the
|
||||
// sign cache, populated by loadSigners for signed rooms) and the room key for the
|
||||
// frame's epoch, then verifies + decrypts via openRoomMessage. Returns null when the
|
||||
// frame fails verification or decryption, so both callers drop it the same way.
|
||||
private async openFrame(
|
||||
roomID: string,
|
||||
policy: Policy,
|
||||
bytes: Uint8Array,
|
||||
): Promise<{ frame: Frame; plaintext: Uint8Array } | null> {
|
||||
const frame = unmarshal(bytes);
|
||||
const signerPub = policy.signMsgs ? this.signCache.get(roomID)?.get(frame.sender) : undefined;
|
||||
const roomKey = policy.encrypt ? await this.roomKey(roomID, frame.epoch) : undefined;
|
||||
const plaintext = openRoomMessage(frame, policy, signerPub, roomKey);
|
||||
return plaintext ? { frame, plaintext } : null;
|
||||
}
|
||||
|
||||
// subscribe delivers decoded, verified, decrypted messages for a room. Messages
|
||||
// that fail signature verification or decryption are dropped silently.
|
||||
async subscribe(roomID: string, handler: (f: Frame, plaintext: Uint8Array) => void): Promise<Subscription> {
|
||||
const room = await this.control.fetchRoom(roomID);
|
||||
if (room.policy.signMsgs) await this.loadSigners(roomID);
|
||||
return this.transport.subscribe(room.subject, async (_subject, data) => {
|
||||
const f = unmarshal(data);
|
||||
const signerPub = room.policy.signMsgs ? this.signCache.get(roomID)?.get(f.sender) : undefined;
|
||||
const roomKey = room.policy.encrypt ? await this.roomKey(roomID, f.epoch) : undefined;
|
||||
const plaintext = openRoomMessage(f, room.policy, signerPub, roomKey);
|
||||
if (plaintext) handler(f, plaintext);
|
||||
const opened = await this.openFrame(roomID, room.policy, data);
|
||||
if (opened) handler(opened.frame, opened.plaintext);
|
||||
});
|
||||
}
|
||||
|
||||
// history replays a room's stored messages, decrypted and verified exactly like
|
||||
// subscribe (NATS delivers live only, so without this a reload shows nothing until
|
||||
// new traffic arrives). It resolves the room policy, loads the signer keys for a
|
||||
// signed room, fetches the marshaled frames from the control plane, and opens each
|
||||
// with the same openFrame path. Frames that fail verification/decryption are dropped.
|
||||
// Returns the opened messages in the server's order (oldest -> newest).
|
||||
async history(
|
||||
roomID: string,
|
||||
limit = 200,
|
||||
): Promise<Array<{ frame: Frame; plaintext: Uint8Array }>> {
|
||||
const room = await this.control.fetchRoom(roomID);
|
||||
if (room.policy.signMsgs) await this.loadSigners(roomID);
|
||||
const frames = await this.control.fetchHistory(roomID, limit);
|
||||
const out: Array<{ frame: Frame; plaintext: Uint8Array }> = [];
|
||||
for (const bytes of frames) {
|
||||
const opened = await this.openFrame(roomID, room.policy, bytes);
|
||||
if (opened) out.push(opened);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
private async loadSigners(roomID: string): Promise<void> {
|
||||
this.signCache.set(roomID, await this.control.signerKeys(roomID));
|
||||
}
|
||||
|
||||
// refresh reconnects the data plane so the server's per-subject ACL re-evaluates
|
||||
// this peer's room membership. Call it after creating or joining a room while
|
||||
// connected: NATS freezes a connection's publishable/subscribable subjects at
|
||||
// connect time, so the new room's subject only becomes usable on a fresh
|
||||
// connection. Active subscriptions are dropped — re-subscribe afterwards.
|
||||
async refresh(): Promise<void> {
|
||||
await this.transport.reconnect();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,34 @@
|
||||
// Tests for ulidTime, the decoder of the millisecond timestamp a ULID encodes in its
|
||||
// first 10 Crockford base32 characters. A wire frame carries no explicit timestamp —
|
||||
// its ULID id IS the timestamp — so the UI derives a message's time (and thus its sort
|
||||
// order, live and replayed-history alike) from this function. These tests pin that it
|
||||
// is the exact inverse of newULID's time prefix and that it is time-ordered.
|
||||
|
||||
import { describe, it, expect } from "vitest";
|
||||
import { newULID, ulidTime } from "./client.js";
|
||||
|
||||
describe("ulidTime", () => {
|
||||
it("round-trips the millisecond timestamp newULID encodes", () => {
|
||||
for (const ms of [0, 1, 1_000, 1_700_000_000_000, 2_000_000_000_000, Date.now()]) {
|
||||
expect(ulidTime(newULID(ms))).toBe(ms);
|
||||
}
|
||||
});
|
||||
|
||||
it("is monotonic: a later message decodes to a larger time", () => {
|
||||
const earlier = newULID(1_700_000_000_000);
|
||||
const later = newULID(1_700_000_001_000);
|
||||
expect(ulidTime(earlier)).toBeLessThan(ulidTime(later));
|
||||
});
|
||||
|
||||
it("ignores the 16-char random suffix (only the 10-char time prefix matters)", () => {
|
||||
const ms = 1_736_000_000_000;
|
||||
// Two ULIDs minted at the same ms differ only in their random tail, yet decode equal.
|
||||
expect(ulidTime(newULID(ms))).toBe(ms);
|
||||
expect(ulidTime(newULID(ms))).toBe(ms);
|
||||
});
|
||||
|
||||
it("returns 0 for an id whose prefix is not valid Crockford base32", () => {
|
||||
expect(ulidTime("!!!!!!!!!!xxxxxxxxxxxxxxxx")).toBe(0);
|
||||
expect(ulidTime("")).toBe(0);
|
||||
});
|
||||
});
|
||||
@@ -14,17 +14,39 @@ import type { Identity, NatsTransport, MessageHandler, Subscription } from "./cl
|
||||
import { natsAuthenticator } from "./busauth.js";
|
||||
|
||||
export class WsNatsTransport implements NatsTransport {
|
||||
private constructor(private nc: NatsConnection) {}
|
||||
// servers + id are retained so reconnect() can rebuild the connection with the same
|
||||
// identity — needed because the per-subject ACL freezes a peer's publishable/
|
||||
// subscribable subjects at connect time, so a room created after connecting only
|
||||
// becomes usable after a fresh connection re-evaluates membership.
|
||||
private constructor(
|
||||
private nc: NatsConnection,
|
||||
private servers: string[],
|
||||
private id: Identity,
|
||||
) {}
|
||||
|
||||
// connect opens a WebSocket connection to one of the given ws(s):// servers,
|
||||
// authenticating with the user's nkey identity.
|
||||
static async connect(servers: string[], id: Identity): Promise<WsNatsTransport> {
|
||||
private static newConn(servers: string[], id: Identity): Promise<NatsConnection> {
|
||||
const sign = natsAuthenticator(id.signPub, id.signPriv);
|
||||
// nats.ws's Authenticator returns the nkey + the base64url signature of the
|
||||
// server nonce; our natsAuthenticator produces exactly that shape.
|
||||
const authenticator: Authenticator = (nonce?: string) => sign(nonce ?? "");
|
||||
const nc = await connect({ servers, authenticator });
|
||||
return new WsNatsTransport(nc);
|
||||
return connect({ servers, authenticator });
|
||||
}
|
||||
|
||||
// connect opens a WebSocket connection to one of the given ws(s):// servers,
|
||||
// authenticating with the user's nkey identity.
|
||||
static async connect(servers: string[], id: Identity): Promise<WsNatsTransport> {
|
||||
const nc = await WsNatsTransport.newConn(servers, id);
|
||||
return new WsNatsTransport(nc, servers, id);
|
||||
}
|
||||
|
||||
// reconnect drops the current connection and opens a fresh one with the same
|
||||
// identity, so the server's subject-ACL re-evaluates this peer's room membership.
|
||||
// Active subscriptions from the previous connection are lost; the caller must
|
||||
// re-subscribe (BusClient.subscribe) to the rooms it cares about afterwards.
|
||||
async reconnect(): Promise<void> {
|
||||
const old = this.nc;
|
||||
this.nc = await WsNatsTransport.newConn(this.servers, this.id);
|
||||
await old.close().catch(() => {});
|
||||
}
|
||||
|
||||
publish(subject: string, data: Uint8Array): void {
|
||||
|
||||
@@ -0,0 +1,468 @@
|
||||
// The single data layer of the SPA — the browser-native replacement for the old
|
||||
// `api` module. Where `api` talked to a Go gateway under /api (cookie session, SSE,
|
||||
// and the private key shipped to the server), this talks DIRECTLY to the bus:
|
||||
//
|
||||
// - control plane: signed HTTPS to membershipd (rooms, keys, members), and
|
||||
// - data plane: nats.ws to NATS,
|
||||
//
|
||||
// using the user's wallet identity, which stays in the browser. The private key
|
||||
// signs and decrypts here and is NEVER sent anywhere (issue uniweb/0001, Phase 2).
|
||||
//
|
||||
// The exported `bus` object mirrors the old `api` surface so the page components
|
||||
// change only their import; streamRoom is replaced by bus.subscribeRoom.
|
||||
|
||||
import {
|
||||
BusClient,
|
||||
ControlPlane,
|
||||
WsNatsTransport,
|
||||
hexToBytes,
|
||||
endpointID,
|
||||
ulidTime,
|
||||
type Identity,
|
||||
type Frame,
|
||||
ModeMatrix,
|
||||
} from "./bus/index";
|
||||
import type { WalletIdentity } from "./wallet/derive";
|
||||
import type { MeInfo, Message, Room, User } from "./types";
|
||||
import { saveSession, loadSession, touchSession, clearSession } from "./session";
|
||||
|
||||
// Bus endpoints. The SPA is served same-origin behind a reverse proxy (Caddy):
|
||||
// both planes are reached through this page's OWN origin, so there is no CORS and
|
||||
// the cluster node IPs stay hidden behind the proxy. The control plane is the
|
||||
// signed HTTPS API under the relative path /api; the data plane is NATS over
|
||||
// WebSocket under /nats (a browser cannot open a raw TCP NATS socket). Both can
|
||||
// still be overridden at build time (VITE_BUS_HTTP / VITE_BUS_WS) for a dev setup
|
||||
// that points straight at a cluster node.
|
||||
const BUS_HTTP = import.meta.env.VITE_BUS_HTTP ?? "/api";
|
||||
const BUS_WS = import.meta.env.VITE_BUS_WS ?? defaultBusWS();
|
||||
|
||||
// defaultBusWS derives the data-plane WebSocket URL from the page origin: the same
|
||||
// host and port as the SPA, the wss/ws scheme mirroring https/http, path /nats. A
|
||||
// browser WebSocket needs an absolute ws(s) URL, so this is computed from location
|
||||
// rather than left relative. Returns "" where window is absent (SSR/tests), where
|
||||
// the build-time override is expected instead.
|
||||
function defaultBusWS(): string {
|
||||
if (typeof window === "undefined") return "";
|
||||
const proto = window.location.protocol === "https:" ? "wss:" : "ws:";
|
||||
return `${proto}//${window.location.host}/nats`;
|
||||
}
|
||||
|
||||
export class SessionError extends Error {}
|
||||
|
||||
// toIdentity maps the wallet's hex identity to the SDK's byte identity. The private
|
||||
// halves stay in memory only.
|
||||
function toIdentity(w: WalletIdentity): Identity {
|
||||
return {
|
||||
signPub: hexToBytes(w.signPub),
|
||||
signPriv: hexToBytes(w.signPriv),
|
||||
kexPub: hexToBytes(w.kexPub),
|
||||
kexPriv: hexToBytes(w.kexPriv),
|
||||
};
|
||||
}
|
||||
|
||||
// A live session: the connected BusClient plus the display identity. Held in a
|
||||
// module singleton — one active wallet per tab (MVP), like the wallet store.
|
||||
interface Session {
|
||||
identity: Identity;
|
||||
handle: string;
|
||||
endpoint: string;
|
||||
control: ControlPlane;
|
||||
transport: WsNatsTransport;
|
||||
client: BusClient;
|
||||
}
|
||||
|
||||
let session: Session | null = null;
|
||||
|
||||
// directory maps a peer's stable endpoint id to its human handle, so the UI can show
|
||||
// a readable name instead of the long base64url id. Populated from the control-plane
|
||||
// GET /api/directory once a session opens, and refreshed when membership changes. It
|
||||
// is best-effort: a cluster without the directory endpoint leaves it empty and the UI
|
||||
// falls back to a short id (see displayName), so the chat keeps working regardless.
|
||||
let directory = new Map<string, string>();
|
||||
|
||||
// shortId is the display fallback for an endpoint with no known handle: the first 8
|
||||
// characters of the id, never the full long string.
|
||||
function shortId(endpoint: string): string {
|
||||
return endpoint.slice(0, 8);
|
||||
}
|
||||
|
||||
// loadDirectory (re)loads the cluster member directory into the endpoint -> handle
|
||||
// map. It NEVER throws: if the endpoint is missing (older cluster, 404) or the request
|
||||
// fails, the existing map is kept (empty on first load) and callers fall back to the
|
||||
// short id. The new map is built locally and only swapped in on success, so a failed
|
||||
// refresh never wipes a directory that loaded earlier.
|
||||
async function loadDirectory(s: Session): Promise<void> {
|
||||
try {
|
||||
const entries = await s.control.fetchDirectory();
|
||||
const next = new Map<string, string>();
|
||||
for (const e of entries) if (e.handle) next.set(e.endpoint, e.handle);
|
||||
directory = next;
|
||||
} catch {
|
||||
// No directory endpoint yet, or a transient failure: keep what we have (the chat
|
||||
// must work exactly as before without readable names).
|
||||
}
|
||||
}
|
||||
|
||||
// displayNameOf is the resolver behind bus.displayName, kept module-level so the
|
||||
// room store can reuse it for last-message previews.
|
||||
function displayNameOf(endpoint: string): string {
|
||||
if (session && endpoint === session.endpoint) {
|
||||
return session.handle || directory.get(endpoint) || shortId(endpoint);
|
||||
}
|
||||
return directory.get(endpoint) || shortId(endpoint);
|
||||
}
|
||||
|
||||
function require_(): Session {
|
||||
if (!session) throw new SessionError("no active bus session");
|
||||
return session;
|
||||
}
|
||||
|
||||
// ---- room store (sidebar metadata) -----------------------------------------
|
||||
//
|
||||
// The sidebar needs each room's last message and time, plus an unread count for
|
||||
// rooms the user is NOT currently viewing. NATS delivers live only, so a live metadata
|
||||
// subscription per room keeps the sidebar current while the app is open; on first load
|
||||
// (or after a reload) the control plane's history endpoint seeds each room's last
|
||||
// message so a room with no live traffic yet still shows its real latest line instead
|
||||
// of "—". This store owns that: it holds the room list, subscribes to each room for
|
||||
// metadata, seeds the preview from history, and notifies React watchers on every
|
||||
// change. ChatPanel keeps its own subscription for the open conversation; this store's
|
||||
// per-room subscription is independent and only updates sidebar metadata.
|
||||
|
||||
let roomList: Room[] = [];
|
||||
let activeRoomID = "";
|
||||
const roomListeners = new Set<(rooms: Room[]) => void>();
|
||||
const metaSubs = new Map<string, () => void>(); // roomID -> unsubscribe
|
||||
|
||||
const PREVIEW_MAX = 48; // characters of a last-message preview in the sidebar
|
||||
|
||||
// snapshotRooms returns a shallow copy so React sees a new array/objects and re-renders.
|
||||
function snapshotRooms(): Room[] {
|
||||
return roomList.map((r) => ({ ...r }));
|
||||
}
|
||||
|
||||
function notifyRooms(): void {
|
||||
const snap = snapshotRooms();
|
||||
for (const l of roomListeners) l(snap);
|
||||
}
|
||||
|
||||
// previewText builds the sidebar's last-message line: "name: body" with the body
|
||||
// truncated, reusing the directory resolver so the sender shows as a readable handle.
|
||||
function previewText(m: Message): string {
|
||||
const body =
|
||||
m.body.length > PREVIEW_MAX ? m.body.slice(0, PREVIEW_MAX - 1) + "…" : m.body;
|
||||
return `${displayNameOf(m.sender)}: ${body}`;
|
||||
}
|
||||
|
||||
// trackRoomMeta opens a metadata subscription for one room: each delivered message
|
||||
// updates the room's last message/time and bumps unread when the room is not active.
|
||||
function trackRoomMeta(roomID: string): void {
|
||||
if (metaSubs.has(roomID)) return;
|
||||
const unsub = subscribeRoomInternal(roomID, (m) => {
|
||||
const r = roomList.find((x) => x.id === roomID);
|
||||
if (!r) return;
|
||||
r.lastTs = m.ts;
|
||||
r.lastMessage = previewText(m);
|
||||
if (roomID !== activeRoomID && !m.mine) r.unread += 1;
|
||||
notifyRooms();
|
||||
});
|
||||
metaSubs.set(roomID, unsub);
|
||||
}
|
||||
|
||||
// seedRoomPreviews fills each room's sidebar preview (last message + time) from the
|
||||
// control plane's history, best-effort and in the background: the room list renders
|
||||
// immediately, then each preview updates as its single most-recent stored message
|
||||
// arrives. It never overwrites a live message that is already newer, and a room with
|
||||
// genuinely no history keeps the "—" placeholder (lastTs 0). Errors (missing endpoint,
|
||||
// transient) are swallowed per room so one failure never blocks the others.
|
||||
function seedRoomPreviews(s: Session): void {
|
||||
for (const r of roomList) {
|
||||
s.client
|
||||
.history(r.id, 1)
|
||||
.then((items) => {
|
||||
if (!items.length) return;
|
||||
const last = items[items.length - 1];
|
||||
const m = toMessage(s, last.frame, last.plaintext);
|
||||
const room = roomList.find((x) => x.id === r.id);
|
||||
if (!room || m.ts < room.lastTs) return; // a newer live message already won
|
||||
room.lastTs = m.ts;
|
||||
room.lastMessage = previewText(m);
|
||||
notifyRooms();
|
||||
})
|
||||
.catch(() => {});
|
||||
}
|
||||
}
|
||||
|
||||
function untrackAllRooms(): void {
|
||||
for (const unsub of metaSubs.values()) {
|
||||
try {
|
||||
unsub();
|
||||
} catch {
|
||||
/* a closing transport may already be gone */
|
||||
}
|
||||
}
|
||||
metaSubs.clear();
|
||||
}
|
||||
|
||||
// retrackRooms re-establishes a metadata subscription for every room. Used after a
|
||||
// data-plane reconnect (createRoom's refresh), which drops all existing subscriptions.
|
||||
function retrackRooms(): void {
|
||||
untrackAllRooms();
|
||||
for (const r of roomList) trackRoomMeta(r.id);
|
||||
}
|
||||
|
||||
// resetRoomStore clears the store and tears down subscriptions (on logout / new
|
||||
// session), then pushes the empty snapshot so any live watcher renders an empty list.
|
||||
function resetRoomStore(): void {
|
||||
untrackAllRooms();
|
||||
roomList = [];
|
||||
activeRoomID = "";
|
||||
notifyRooms();
|
||||
}
|
||||
|
||||
// toMessage maps an opened bus frame to the UI's Message. The timestamp comes from the
|
||||
// frame's ULID id (ulidTime), NOT the arrival time: a frame carries no explicit ts on
|
||||
// the wire, and deriving it from the id puts live and replayed-history messages on the
|
||||
// same clock so they sort into one correct order.
|
||||
function toMessage(s: Session, f: Frame, plaintext: Uint8Array): Message {
|
||||
return {
|
||||
id: f.msgID,
|
||||
sender: f.sender,
|
||||
body: new TextDecoder().decode(plaintext),
|
||||
ts: ulidTime(f.msgID),
|
||||
mine: f.sender === s.endpoint,
|
||||
};
|
||||
}
|
||||
|
||||
// subscribeRoomInternal is the live-only core behind the store's per-room metadata
|
||||
// subscription (and the live half of subscribeRoomWithHistory): it decodes each frame
|
||||
// into a UI Message and hands it to onMessage. Returns a function that cancels the
|
||||
// subscription.
|
||||
function subscribeRoomInternal(
|
||||
roomID: string,
|
||||
onMessage: (m: Message) => void,
|
||||
): () => void {
|
||||
const s = require_();
|
||||
let unsub: (() => void) | null = null;
|
||||
let closed = false;
|
||||
s.client
|
||||
.subscribe(roomID, (f: Frame, plaintext: Uint8Array) => {
|
||||
onMessage(toMessage(s, f, plaintext));
|
||||
})
|
||||
.then((sub) => {
|
||||
if (closed) void sub.unsubscribe();
|
||||
else unsub = () => void sub.unsubscribe();
|
||||
})
|
||||
.catch(() => {});
|
||||
return () => {
|
||||
closed = true;
|
||||
if (unsub) unsub();
|
||||
};
|
||||
}
|
||||
|
||||
// subscribeRoomWithHistory is what ChatPanel opens for the conversation it is viewing:
|
||||
// it seeds the room with its stored history (so a reload no longer loses the messages)
|
||||
// and then keeps it live. History and live are deduplicated by frame id through a
|
||||
// per-room `seen` set — a message can arrive both ways when it lands between the fetch
|
||||
// and the subscription. To guarantee history shows first (oldest -> newest) regardless
|
||||
// of timing, live messages are buffered until the history batch has been delivered,
|
||||
// then flushed. If history fails or the endpoint is absent (404/500 on an older
|
||||
// cluster), it is treated as empty and the room runs live-only, exactly as before.
|
||||
function subscribeRoomWithHistory(
|
||||
roomID: string,
|
||||
onMessage: (m: Message) => void,
|
||||
): () => void {
|
||||
const s = require_();
|
||||
const seen = new Set<string>();
|
||||
let historyDone = false;
|
||||
let pending: Message[] = [];
|
||||
const deliver = (m: Message): void => {
|
||||
if (seen.has(m.id)) return;
|
||||
seen.add(m.id);
|
||||
onMessage(m);
|
||||
};
|
||||
// Live is subscribed immediately so nothing published during the history fetch is
|
||||
// missed; messages are buffered until the history batch lands, then delivered.
|
||||
const liveUnsub = subscribeRoomInternal(roomID, (m) => {
|
||||
if (historyDone) deliver(m);
|
||||
else pending.push(m);
|
||||
});
|
||||
s.client
|
||||
.history(roomID)
|
||||
.then((items) => {
|
||||
for (const { frame, plaintext } of items) deliver(toMessage(s, frame, plaintext));
|
||||
})
|
||||
.catch(() => {
|
||||
// No history endpoint yet, or a transient failure: fall back to live-only.
|
||||
})
|
||||
.finally(() => {
|
||||
historyDone = true;
|
||||
for (const m of pending) deliver(m);
|
||||
pending = [];
|
||||
});
|
||||
return liveUnsub;
|
||||
}
|
||||
|
||||
// connectSession opens the live bus connection (control plane + nats.ws data plane)
|
||||
// for a wallet identity, WITHOUT touching persistence. The private key is used here
|
||||
// in the browser and never leaves it.
|
||||
async function connectSession(wallet: WalletIdentity, handle: string): Promise<User> {
|
||||
const identity = toIdentity(wallet);
|
||||
const endpoint = endpointID(identity.signPub);
|
||||
const control = new ControlPlane(BUS_HTTP, identity);
|
||||
const transport = await WsNatsTransport.connect([BUS_WS], identity);
|
||||
const client = new BusClient(identity, transport, control);
|
||||
session = { identity, handle, endpoint, control, transport, client };
|
||||
directory = new Map(); // fresh identity: drop any prior session's handle map
|
||||
resetRoomStore(); // drop any prior session's room store + metadata subscriptions
|
||||
await loadDirectory(session); // best-effort; never blocks login on a directory error
|
||||
return { id: endpoint, handle: handle || endpoint.slice(0, 8) };
|
||||
}
|
||||
|
||||
export const bus = {
|
||||
// openSession connects to the bus AS this wallet user and persists the session so a
|
||||
// reload does not force a password re-unlock. remember=true keeps it across closing
|
||||
// the browser (localStorage, up to 30 days / 12 h idle); false keeps it only for the
|
||||
// tab (sessionStorage, survives F5). The private key never leaves the browser — this
|
||||
// is the fix for the old gateway model where the browser POSTed its private key.
|
||||
async openSession(wallet: WalletIdentity, handle: string, remember = false): Promise<User> {
|
||||
const user = await connectSession(wallet, handle);
|
||||
saveSession(wallet, handle, remember);
|
||||
return user;
|
||||
},
|
||||
|
||||
// restoreSession re-opens a previously persisted session on page load, if one exists
|
||||
// and has not expired (TTL/idle checked in loadSession). It does NOT re-save (so the
|
||||
// absolute 30-day TTL is not renewed on every reload) — it only refreshes the idle
|
||||
// timer. Returns the User on success, or null when there is nothing to restore.
|
||||
async restoreSession(): Promise<User | null> {
|
||||
const persisted = loadSession();
|
||||
if (!persisted) return null;
|
||||
try {
|
||||
const user = await connectSession(persisted.wallet, persisted.handle);
|
||||
touchSession(); // restart the idle window; keep createdAt (TTL) intact
|
||||
return user;
|
||||
} catch {
|
||||
// Connection failed (offline, identity revoked, ...): drop the stale session so
|
||||
// the router falls back to the password unlock rather than looping.
|
||||
clearSession();
|
||||
session = null;
|
||||
return null;
|
||||
}
|
||||
},
|
||||
|
||||
// me returns the identity of the active session (was GET /api/me).
|
||||
me(): MeInfo {
|
||||
const s = require_();
|
||||
return { endpoint: s.endpoint, sign_pub: "", handle: s.handle };
|
||||
},
|
||||
|
||||
// displayName resolves a sender endpoint id to a readable name for the UI: the
|
||||
// member's handle when the directory knows it, the session user's own handle for
|
||||
// their own messages, and a short id fallback otherwise — NEVER the full long
|
||||
// endpoint. Pure lookup over the in-memory directory; safe to call from render.
|
||||
displayName(endpoint: string): string {
|
||||
return displayNameOf(endpoint);
|
||||
},
|
||||
|
||||
// logout closes the data-plane connection, drops the in-memory session, and clears
|
||||
// the persisted session from both stores so it cannot be restored.
|
||||
async logout(): Promise<void> {
|
||||
clearSession();
|
||||
resetRoomStore();
|
||||
directory = new Map();
|
||||
if (session) {
|
||||
await session.transport.close().catch(() => {});
|
||||
session = null;
|
||||
}
|
||||
},
|
||||
|
||||
// watchRooms subscribes a listener to the sidebar room list and returns a function
|
||||
// to detach it. The current snapshot is pushed immediately, so a component mounting
|
||||
// mid-session renders the rooms it already has. Call loadRooms() to (re)populate.
|
||||
watchRooms(listener: (rooms: Room[]) => void): () => void {
|
||||
roomListeners.add(listener);
|
||||
listener(snapshotRooms());
|
||||
return () => {
|
||||
roomListeners.delete(listener);
|
||||
};
|
||||
},
|
||||
|
||||
// loadRooms fetches the rooms this peer belongs to, replaces the store, opens a
|
||||
// metadata subscription per room (so the sidebar shows the latest message/time and
|
||||
// unread for rooms the user is not viewing), and notifies watchers.
|
||||
async loadRooms(): Promise<void> {
|
||||
const s = require_();
|
||||
const wire = await s.control.listMemberRooms(s.endpoint);
|
||||
untrackAllRooms();
|
||||
roomList = wire.map((r) => ({
|
||||
id: r.id,
|
||||
name: r.subject,
|
||||
encrypted: r.policy.encrypt,
|
||||
lastMessage: "",
|
||||
lastTs: 0,
|
||||
unread: 0,
|
||||
messages: [],
|
||||
}));
|
||||
for (const r of roomList) trackRoomMeta(r.id);
|
||||
notifyRooms();
|
||||
seedRoomPreviews(s); // fill each preview from history without blocking the render
|
||||
},
|
||||
|
||||
// setActiveRoom marks the room the user is viewing: its unread count is cleared and
|
||||
// future messages to it do not bump unread (see trackRoomMeta).
|
||||
setActiveRoom(roomID: string): void {
|
||||
activeRoomID = roomID;
|
||||
const r = roomList.find((x) => x.id === roomID);
|
||||
if (r) r.unread = 0;
|
||||
notifyRooms();
|
||||
},
|
||||
|
||||
// createRoom creates an encrypted, signed room owned by this peer (the Matrix-like
|
||||
// default), then reconnects the data plane so the new room's subject enters this
|
||||
// connection's ACL grant — otherwise publish/subscribe on a just-created room would
|
||||
// silently not deliver until a reconnect/re-login. The reconnect drops every
|
||||
// metadata subscription, so they are re-established here. Returns the UI Room.
|
||||
async createRoom(subject: string): Promise<Room> {
|
||||
const s = require_();
|
||||
const { roomID } = await s.control.createRoom(subject, ModeMatrix);
|
||||
await s.client.refresh(); // re-evaluate the per-subject ACL with the new room
|
||||
await loadDirectory(s); // a new room may bring new members into the directory
|
||||
touchSession();
|
||||
const room: Room = {
|
||||
id: roomID,
|
||||
name: subject,
|
||||
encrypted: true,
|
||||
lastMessage: "",
|
||||
lastTs: 0,
|
||||
unread: 0,
|
||||
messages: [],
|
||||
};
|
||||
if (!roomList.some((r) => r.id === roomID)) roomList = [room, ...roomList];
|
||||
retrackRooms(); // refresh() dropped all data-plane subs; re-subscribe every room
|
||||
notifyRooms();
|
||||
return room;
|
||||
},
|
||||
|
||||
// send publishes a plaintext message to a room; the SDK seals + signs it per the
|
||||
// room policy before it hits the wire.
|
||||
async send(roomID: string, body: string): Promise<void> {
|
||||
const s = require_();
|
||||
await s.client.publish(roomID, new TextEncoder().encode(body));
|
||||
touchSession(); // user activity: restart the idle auto-lock window
|
||||
},
|
||||
|
||||
// subscribeRoom delivers a room's stored history followed by its live messages, both
|
||||
// decrypted, verified and deduplicated by id (replaces the old SSE streamRoom).
|
||||
// Returns an unsubscribe function. ChatPanel uses this for the open conversation, so
|
||||
// reloading the page no longer loses the conversation; the sidebar metadata uses the
|
||||
// live-only core (subscribeRoomInternal) and seeds its preview from history separately.
|
||||
subscribeRoom(roomID: string, onMessage: (m: Message) => void): () => void {
|
||||
return subscribeRoomWithHistory(roomID, onMessage);
|
||||
},
|
||||
};
|
||||
|
||||
// hasSession reports whether a bus session is currently open (for the router).
|
||||
export function hasSession(): boolean {
|
||||
return session !== null;
|
||||
}
|
||||
@@ -0,0 +1,105 @@
|
||||
// Session persistence for the SPA. The bus session (the unlocked wallet identity)
|
||||
// normally lives only in memory, so a page reload — even an F5 — drops it and forces
|
||||
// a password re-unlock. This module keeps the session usable across reloads without
|
||||
// ever sending anything to the network.
|
||||
//
|
||||
// Storage choice and its trade-off:
|
||||
// - By DEFAULT the session is kept in sessionStorage: it survives an F5 but is
|
||||
// cleared when the tab/window closes. This already fixes the "logs out on
|
||||
// refresh" annoyance at minimal risk.
|
||||
// - When the user ticks "keep me signed in" (remember=true) it is kept in
|
||||
// localStorage instead: it survives closing the tab and the browser, until it
|
||||
// EXPIRES or the user logs out.
|
||||
//
|
||||
// We never use a cookie: the wallet's private key must not travel to any server, and
|
||||
// a cookie rides every request. The persisted value (the decrypted hex identity)
|
||||
// stays on the device and is read only by this origin's own code.
|
||||
//
|
||||
// Two time bounds keep the persisted private key from living unbounded on disk:
|
||||
// - TTL: an absolute lifetime (30 days). After it, re-unlock with the password.
|
||||
// - IDLE: an inactivity auto-lock (12 h). Activity calls touchSession(); after 12 h
|
||||
// with no activity the session re-locks even if the TTL has not elapsed.
|
||||
|
||||
import type { WalletIdentity } from "./wallet/derive";
|
||||
|
||||
const KEY = "unibus-session";
|
||||
const TTL_MS = 30 * 24 * 60 * 60 * 1000; // 30 days absolute lifetime
|
||||
const IDLE_MS = 12 * 60 * 60 * 1000; // 12 h inactivity auto-lock
|
||||
|
||||
interface PersistedSession {
|
||||
// The decrypted wallet identity (hex), INCLUDING the private halves. This is the
|
||||
// sensitive part that lives on the device so the user need not re-enter the
|
||||
// password on every reload. Bounded by TTL_MS + IDLE_MS and cleared on logout.
|
||||
wallet: WalletIdentity;
|
||||
handle: string;
|
||||
remember: boolean;
|
||||
createdAt: number;
|
||||
lastActivity: number;
|
||||
}
|
||||
|
||||
function stores(): Storage[] {
|
||||
// Guard for SSR/tests where window is absent.
|
||||
if (typeof window === "undefined") return [];
|
||||
return [window.localStorage, window.sessionStorage];
|
||||
}
|
||||
|
||||
// saveSession persists the unlocked identity. remember=true uses localStorage
|
||||
// (survives closing the browser); false uses sessionStorage (cleared with the tab).
|
||||
export function saveSession(wallet: WalletIdentity, handle: string, remember: boolean): void {
|
||||
clearSession(); // never keep it in both stores at once
|
||||
const target = remember ? window.localStorage : window.sessionStorage;
|
||||
const s: PersistedSession = {
|
||||
wallet,
|
||||
handle,
|
||||
remember,
|
||||
createdAt: Date.now(),
|
||||
lastActivity: Date.now(),
|
||||
};
|
||||
try {
|
||||
target.setItem(KEY, JSON.stringify(s));
|
||||
} catch {
|
||||
/* storage full/blocked: fall back to memory-only (no persistence) */
|
||||
}
|
||||
}
|
||||
|
||||
// loadSession returns the persisted identity if one exists and is still valid (not
|
||||
// past its TTL and not idle-expired), otherwise null. An expired entry is removed.
|
||||
export function loadSession(): { wallet: WalletIdentity; handle: string; remember: boolean } | null {
|
||||
for (const st of stores()) {
|
||||
const raw = st.getItem(KEY);
|
||||
if (!raw) continue;
|
||||
try {
|
||||
const s = JSON.parse(raw) as PersistedSession;
|
||||
const now = Date.now();
|
||||
if (now - s.createdAt > TTL_MS || now - s.lastActivity > IDLE_MS) {
|
||||
st.removeItem(KEY); // expired by TTL or idle auto-lock
|
||||
continue;
|
||||
}
|
||||
return { wallet: s.wallet, handle: s.handle, remember: s.remember };
|
||||
} catch {
|
||||
st.removeItem(KEY); // corrupt entry
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
// touchSession refreshes the last-activity timestamp so the idle auto-lock window
|
||||
// restarts. Call it on meaningful user activity (sending, navigating rooms).
|
||||
export function touchSession(): void {
|
||||
for (const st of stores()) {
|
||||
const raw = st.getItem(KEY);
|
||||
if (!raw) continue;
|
||||
try {
|
||||
const s = JSON.parse(raw) as PersistedSession;
|
||||
s.lastActivity = Date.now();
|
||||
st.setItem(KEY, JSON.stringify(s));
|
||||
} catch {
|
||||
/* ignore */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// clearSession removes the persisted session from both stores (logout / lock).
|
||||
export function clearSession(): void {
|
||||
for (const st of stores()) st.removeItem(KEY);
|
||||
}
|
||||
+1
-1
@@ -8,7 +8,7 @@ export interface User {
|
||||
|
||||
export interface Message {
|
||||
id: string;
|
||||
sender: string; // endpoint id del remitente (handle legible es fase 2)
|
||||
sender: string; // endpoint id del remitente; el nombre legible se resuelve con bus.displayName()
|
||||
body: string;
|
||||
ts: number; // epoch ms
|
||||
mine?: boolean;
|
||||
|
||||
Vendored
+12
@@ -0,0 +1,12 @@
|
||||
/// <reference types="vite/client" />
|
||||
|
||||
// Build-time configuration for the bus endpoints. Both are optional; busService
|
||||
// falls back to a cluster node when unset.
|
||||
interface ImportMetaEnv {
|
||||
readonly VITE_BUS_HTTP?: string;
|
||||
readonly VITE_BUS_WS?: string;
|
||||
}
|
||||
|
||||
interface ImportMeta {
|
||||
readonly env: ImportMetaEnv;
|
||||
}
|
||||
+15
-19
@@ -1,26 +1,24 @@
|
||||
// High-level wallet account operations shared by the join, recover and login
|
||||
// flows. These compose the low-level primitives (derive / crypto / store) with
|
||||
// the gateway API so the page components stay thin.
|
||||
// flows. These compose the low-level primitives (derive / crypto / store) with the
|
||||
// browser-native bus session so the page components stay thin.
|
||||
|
||||
import { api } from "../api";
|
||||
import type { MeInfo, User } from "../types";
|
||||
import { bus } from "../busService";
|
||||
import type { User } from "../types";
|
||||
import { decryptJSON, encryptJSON } from "./crypto";
|
||||
import type { WalletIdentity } from "./derive";
|
||||
import { getIdentity, putIdentity, type StoredIdentity } from "./store";
|
||||
|
||||
function toUser(me: MeInfo): User {
|
||||
return { id: me.endpoint, handle: me.handle || me.endpoint.slice(0, 8) };
|
||||
}
|
||||
|
||||
// saveAndOpen encrypts the identity under `password`, stores it on this device,
|
||||
// and opens a gateway session as that user. Used by join (new identity) and
|
||||
// recover (re-derived identity): both end with a locally-encrypted key plus a
|
||||
// live per-user session. The mnemonic/seed is NOT touched here — only the derived
|
||||
// keypair is persisted (encrypted).
|
||||
// saveAndOpen encrypts the identity under `password`, stores it on this device, and
|
||||
// opens a bus session as that user. Used by join (new identity) and recover
|
||||
// (re-derived identity): both end with a locally-encrypted key plus a live session.
|
||||
// The mnemonic/seed is NOT touched here — only the derived keypair is persisted
|
||||
// (encrypted). The private key is used to open the session IN THE BROWSER and is
|
||||
// never sent to any server (unlike the old gateway model).
|
||||
export async function saveAndOpen(
|
||||
identity: WalletIdentity,
|
||||
handle: string,
|
||||
password: string,
|
||||
remember = false,
|
||||
): Promise<User> {
|
||||
const enc = await encryptJSON(identity, password);
|
||||
await putIdentity({
|
||||
@@ -30,19 +28,17 @@ export async function saveAndOpen(
|
||||
enc,
|
||||
createdAt: Date.now(),
|
||||
});
|
||||
const me = await api.session(identity, handle);
|
||||
return toUser(me);
|
||||
return bus.openSession(identity, handle, remember);
|
||||
}
|
||||
|
||||
// unlockAndOpen reads this device's stored identity, decrypts the private key with
|
||||
// `password`, and opens a gateway session. Throws WrongPasswordError on a bad
|
||||
// `password`, and opens a bus session locally. Throws WrongPasswordError on a bad
|
||||
// password (GCM auth failure) and NoLocalIdentityError if the device has none.
|
||||
export async function unlockAndOpen(password: string): Promise<User> {
|
||||
export async function unlockAndOpen(password: string, remember = false): Promise<User> {
|
||||
const stored = await getIdentity();
|
||||
if (!stored) throw new NoLocalIdentityError();
|
||||
const identity = await decryptJSON<WalletIdentity>(stored.enc, password);
|
||||
const me = await api.session(identity, stored.handle);
|
||||
return toUser(me);
|
||||
return bus.openSession(identity, stored.handle, remember);
|
||||
}
|
||||
|
||||
// localIdentity returns the device's stored identity record (or null), for the
|
||||
|
||||
@@ -1,7 +1,8 @@
|
||||
// IndexedDB persistence of the device-local wallet. Only the encrypted private
|
||||
// key plus the public halves and the display handle are stored — never the
|
||||
// password, never the BIP39 seed. The private key never leaves the device except
|
||||
// over TLS to the gateway to open a session (see api.session).
|
||||
// password, never the BIP39 seed. The private key NEVER leaves the device at all:
|
||||
// the bus session is opened in the browser (see busService.openSession), which signs
|
||||
// and decrypts locally — there is no server to send the key to.
|
||||
//
|
||||
// MVP: one active identity per device (keyed by a fixed id). Multi-account on a
|
||||
// single device is a documented gap.
|
||||
|
||||
+9
-5
@@ -3,12 +3,16 @@ import react from "@vitejs/plugin-react";
|
||||
|
||||
export default defineConfig({
|
||||
plugins: [react()],
|
||||
// En dev, /api (REST + SSE) se proxea al gateway Go (cmd/webgw, puerto 8481).
|
||||
// El proxy hace streaming, así que el SSE de /api/rooms/{id}/stream funciona a
|
||||
// través de él. En producción el gateway sirve el dist embebido y no hay proxy.
|
||||
// In production the SPA is served same-origin behind Caddy, which proxies /api and
|
||||
// /nats to the cluster; those relative paths do not exist on the bare dev server, so
|
||||
// `pnpm dev` must be pointed at a real cluster node with VITE_BUS_HTTP / VITE_BUS_WS
|
||||
// (busService.ts uses them as overrides of the same-origin defaults). Example:
|
||||
// VITE_BUS_HTTP=https://<node>:8470 VITE_BUS_WS=wss://<node>:8480 pnpm dev
|
||||
// The dev server runs on 5174 (5173 is reserved for an unrelated local app). Add the
|
||||
// dev origin (http://localhost:5174) to the node's --cors-origins allowlist. strictPort
|
||||
// is left off, so Vite falls back to the next free port if 5174 is busy.
|
||||
server: {
|
||||
host: true,
|
||||
port: 5183,
|
||||
proxy: { "/api": "http://127.0.0.1:8481" },
|
||||
port: 5174,
|
||||
},
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user