diff --git a/src/components/nostr/RelayLink.tsx b/src/components/nostr/RelayLink.tsx
index 6961ef1..df188cd 100644
--- a/src/components/nostr/RelayLink.tsx
+++ b/src/components/nostr/RelayLink.tsx
@@ -16,6 +16,7 @@ export interface RelayLinkProps {
className?: string;
urlClassname?: string;
iconClassname?: string;
+ variant?: "default" | "prompt";
}
/**
@@ -31,6 +32,7 @@ export function RelayLink({
write = false,
showInboxOutbox = true,
className,
+ variant = "default",
}: RelayLinkProps) {
const { addWindow } = useGrimoire();
const relayInfo = useRelayInfo(url);
@@ -39,10 +41,16 @@ export function RelayLink({
addWindow("relay", { url }, `Relay ${url}`);
};
+ const variantStyles = {
+ default: "cursor-crosshair hover:bg-muted/50",
+ prompt: "cursor-crosshair hover:underline hover:decoration-dotted",
+ };
+
return (
,
+ React.ComponentPropsWithoutRef
+>(({ className, ...props }, ref) => (
+
+
+
+
+
+));
+Checkbox.displayName = CheckboxPrimitive.Root.displayName;
+
+export { Checkbox };
diff --git a/src/components/ui/dropdown-menu.tsx b/src/components/ui/dropdown-menu.tsx
index 6cc3fa8..b9cc286 100644
--- a/src/components/ui/dropdown-menu.tsx
+++ b/src/components/ui/dropdown-menu.tsx
@@ -81,7 +81,7 @@ const DropdownMenuItem = React.forwardRef<
svg]:size-4 [&>svg]:shrink-0",
+ "relative flex cursor-default select-none items-center gap-2 px-2 py-1.5 text-sm outline-none transition-colors hover:bg-accent/10 focus:bg-accent/10 data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&>svg]:size-4 [&>svg]:shrink-0",
inset && "pl-8",
className,
)}
@@ -121,7 +121,7 @@ const DropdownMenuRadioItem = React.forwardRef<
) {
+ return (
+
+ );
+}
+
+function KbdGroup({ className, ...props }: React.ComponentProps<"div">) {
+ return (
+
+ );
+}
+
+export { Kbd, KbdGroup };
diff --git a/src/components/ui/tooltip.tsx b/src/components/ui/tooltip.tsx
new file mode 100644
index 0000000..40aaf57
--- /dev/null
+++ b/src/components/ui/tooltip.tsx
@@ -0,0 +1,30 @@
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+
+import { cn } from "@/lib/utils";
+
+const TooltipProvider = TooltipPrimitive.Provider;
+
+const Tooltip = TooltipPrimitive.Root;
+
+const TooltipTrigger = TooltipPrimitive.Trigger;
+
+const TooltipContent = React.forwardRef<
+ React.ElementRef,
+ React.ComponentPropsWithoutRef
+>(({ className, sideOffset = 4, ...props }, ref) => (
+
+
+
+));
+TooltipContent.displayName = TooltipPrimitive.Content.displayName;
+
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };
diff --git a/src/constants/command-icons.ts b/src/constants/command-icons.ts
index f0a5175..42b2084 100644
--- a/src/constants/command-icons.ts
+++ b/src/constants/command-icons.ts
@@ -13,6 +13,7 @@ import {
Rss,
Layout,
Bug,
+ Wifi,
type LucideIcon,
} from "lucide-react";
@@ -89,6 +90,10 @@ export const COMMAND_ICONS: Record = {
icon: Bug,
description: "Display application state for debugging",
},
+ conn: {
+ icon: Wifi,
+ description: "View relay pool connection and authentication status",
+ },
};
export function getCommandIcon(command: string): LucideIcon {
diff --git a/src/hooks/useRelayState.ts b/src/hooks/useRelayState.ts
new file mode 100644
index 0000000..4ace3af
--- /dev/null
+++ b/src/hooks/useRelayState.ts
@@ -0,0 +1,74 @@
+import { useEffect } from "react";
+import { useAtom } from "jotai";
+import { grimoireStateAtom } from "@/core/state";
+import relayStateManager from "@/services/relay-state-manager";
+import type { AuthPreference, RelayState } from "@/types/relay-state";
+
+/**
+ * Hook for accessing and managing global relay state
+ */
+export function useRelayState() {
+ const [state, setState] = useAtom(grimoireStateAtom);
+
+ // Subscribe to relay state manager updates
+ useEffect(() => {
+ const unsubscribe = relayStateManager.subscribe((relayState) => {
+ setState((prev) => ({
+ ...prev,
+ relayState,
+ }));
+ });
+
+ // Initialize state if not set
+ if (!state.relayState) {
+ setState((prev) => ({
+ ...prev,
+ relayState: relayStateManager.getState(),
+ }));
+ }
+
+ return unsubscribe;
+ }, [setState, state.relayState]);
+
+ const relayState = state.relayState;
+
+ return {
+ // Current state
+ relayState,
+ relays: relayState?.relays || {},
+ pendingChallenges: relayState?.pendingChallenges || [],
+ authPreferences: relayState?.authPreferences || {},
+
+ // Get single relay state
+ getRelay: (url: string): RelayState | undefined => {
+ return relayState?.relays[url];
+ },
+
+ // Get auth preference
+ getAuthPreference: async (
+ url: string,
+ ): Promise => {
+ return await relayStateManager.getAuthPreference(url);
+ },
+
+ // Set auth preference
+ setAuthPreference: async (url: string, preference: AuthPreference) => {
+ await relayStateManager.setAuthPreference(url, preference);
+ },
+
+ // Authenticate with relay
+ authenticateRelay: async (url: string) => {
+ await relayStateManager.authenticateRelay(url);
+ },
+
+ // Reject auth for relay
+ rejectAuth: (url: string, rememberForSession = true) => {
+ relayStateManager.rejectAuth(url, rememberForSession);
+ },
+
+ // Ensure relay is monitored
+ ensureRelayMonitored: (url: string) => {
+ relayStateManager.ensureRelayMonitored(url);
+ },
+ };
+}
diff --git a/src/hooks/useReqTimeline.ts b/src/hooks/useReqTimeline.ts
index 94af270..f91300e 100644
--- a/src/hooks/useReqTimeline.ts
+++ b/src/hooks/useReqTimeline.ts
@@ -1,6 +1,7 @@
import { useState, useEffect, useMemo } from "react";
import pool from "@/services/relay-pool";
import type { NostrEvent, Filter } from "nostr-tools";
+import { useEventStore } from "applesauce-react/hooks";
interface UseReqTimelineOptions {
limit?: number;
@@ -29,26 +30,34 @@ export function useReqTimeline(
relays: string[],
options: UseReqTimelineOptions = { limit: 50 },
): UseReqTimelineReturn {
+ const eventStore = useEventStore();
const { limit, stream = false } = options;
- const [events, setEvents] = useState([]);
const [loading, setLoading] = useState(false);
const [error, setError] = useState(null);
const [eoseReceived, setEoseReceived] = useState(false);
+ const [eventsMap, setEventsMap] = useState>(
+ new Map(),
+ );
+
+ // Sort events by created_at (newest first) and deduplicate by ID
+ const events = useMemo(() => {
+ return Array.from(eventsMap.values()).sort(
+ (a, b) => b.created_at - a.created_at,
+ );
+ }, [eventsMap]);
- // Use pool.req() directly to query relays
useEffect(() => {
if (relays.length === 0) {
setLoading(false);
- setEvents([]);
return;
}
console.log("REQ: Starting query", { relays, filters, limit, stream });
+
setLoading(true);
setError(null);
setEoseReceived(false);
-
- const collectedEvents = new Map();
+ setEventsMap(new Map());
// Normalize filters to array
const filterArray = Array.isArray(filters) ? filters : [filters];
@@ -59,9 +68,12 @@ export function useReqTimeline(
limit: limit || f.limit,
}));
- // Use pool.req() for direct relay querying
- // pool.req() returns an Observable of events
- const observable = pool.req(relays, filtersWithLimit);
+ const observable = pool.subscription(relays, filtersWithLimit, {
+ retries: 5,
+ reconnect: 5,
+ resubscribe: true,
+ eventStore,
+ });
const subscription = observable.subscribe(
(response) => {
@@ -73,12 +85,14 @@ export function useReqTimeline(
setLoading(false);
}
} else {
+ // It's an event - store in memory, deduplicate by ID
const event = response as NostrEvent;
- console.log("REQ: Event received", event.id);
- // Use Map to deduplicate by event ID
- collectedEvents.set(event.id, event);
- // Update state with deduplicated events
- setEvents(Array.from(collectedEvents.values()));
+ eventStore.add(event);
+ setEventsMap((prev) => {
+ const next = new Map(prev);
+ next.set(event.id, event);
+ return next;
+ });
}
},
(err: Error) => {
@@ -87,10 +101,6 @@ export function useReqTimeline(
setLoading(false);
},
() => {
- console.log("REQ: Query complete", {
- total: collectedEvents.size,
- stream,
- });
// Only set loading to false if not streaming
if (!stream) {
setLoading(false);
@@ -98,29 +108,13 @@ export function useReqTimeline(
},
);
- // Set a timeout to prevent infinite loading (only for non-streaming queries)
- const timeout = !stream
- ? setTimeout(() => {
- console.warn("REQ: Query timeout, forcing completion");
- setLoading(false);
- }, 10000)
- : undefined;
-
return () => {
- if (timeout) {
- clearTimeout(timeout);
- }
subscription.unsubscribe();
};
}, [id, JSON.stringify(filters), relays.join(","), limit, stream]);
- // Sort events by created_at (newest first)
- const sortedEvents = useMemo(() => {
- return [...events].sort((a, b) => b.created_at - a.created_at);
- }, [events]);
-
return {
- events: sortedEvents,
+ events: events || [],
loading,
error,
eoseReceived,
diff --git a/src/main.tsx b/src/main.tsx
index 79076e3..76a1357 100644
--- a/src/main.tsx
+++ b/src/main.tsx
@@ -4,12 +4,28 @@ import Root from "./root";
import eventStore from "./services/event-store";
import "./index.css";
import "react-mosaic-component/react-mosaic-component.css";
+import { Toaster } from "sonner";
+import { TooltipProvider } from "./components/ui/tooltip";
// Add dark class to html element for default dark theme
document.documentElement.classList.add("dark");
createRoot(document.getElementById("root")!).render(
-
+
+
+
+
,
);
diff --git a/src/services/db.ts b/src/services/db.ts
index 96d529a..b22937f 100644
--- a/src/services/db.ts
+++ b/src/services/db.ts
@@ -24,19 +24,27 @@ export interface RelayInfo {
fetchedAt: number;
}
+export interface RelayAuthPreference {
+ url: string;
+ preference: "always" | "never" | "ask";
+ updatedAt: number;
+}
+
class GrimoireDb extends Dexie {
profiles!: Table;
nip05!: Table;
nips!: Table;
relayInfo!: Table;
+ relayAuthPreferences!: Table;
constructor(name: string) {
super(name);
- this.version(4).stores({
+ this.version(5).stores({
profiles: "&pubkey",
nip05: "&nip05",
nips: "&id",
relayInfo: "&url",
+ relayAuthPreferences: "&url",
});
}
}
diff --git a/src/services/relay-state-manager.ts b/src/services/relay-state-manager.ts
new file mode 100644
index 0000000..f21e136
--- /dev/null
+++ b/src/services/relay-state-manager.ts
@@ -0,0 +1,467 @@
+import type { IRelay } from "applesauce-relay";
+import { merge } from "rxjs";
+import type {
+ RelayState,
+ GlobalRelayState,
+ AuthPreference,
+} from "@/types/relay-state";
+import pool from "./relay-pool";
+import accountManager from "./accounts";
+import db from "./db";
+
+const MAX_NOTICES = 20;
+const MAX_ERRORS = 20;
+
+/**
+ * Singleton service for managing global relay state
+ * Subscribes to all relay observables and maintains state for all relays
+ */
+class RelayStateManager {
+ private relayStates: Map = new Map();
+ private subscriptions: Map void> = new Map();
+ private listeners: Set<(state: GlobalRelayState) => void> = new Set();
+ private authPreferences: Map = new Map();
+ private sessionRejections: Set = new Set();
+ private initialized = false;
+
+ constructor() {
+ this.loadAuthPreferences();
+ }
+
+ /**
+ * Initialize relay monitoring for all relays in the pool
+ */
+ async initialize() {
+ if (this.initialized) return;
+ this.initialized = true;
+
+ // Load preferences from database
+ await this.loadAuthPreferences();
+
+ // Subscribe to existing relays
+ pool.relays.forEach((relay) => {
+ this.monitorRelay(relay);
+ });
+
+ // Poll for new relays every second
+ setInterval(() => {
+ pool.relays.forEach((relay) => {
+ if (!this.subscriptions.has(relay.url)) {
+ this.monitorRelay(relay);
+ }
+ });
+ }, 1000);
+ }
+
+ /**
+ * Ensure a relay is being monitored (call this when adding relays to pool)
+ */
+ ensureRelayMonitored(relayUrl: string) {
+ const relay = pool.relay(relayUrl);
+ if (relay && !this.subscriptions.has(relayUrl)) {
+ this.monitorRelay(relay);
+ }
+ }
+
+ /**
+ * Subscribe to a single relay's observables
+ */
+ private monitorRelay(relay: IRelay) {
+ const url = relay.url;
+
+ // Initialize state if not exists
+ if (!this.relayStates.has(url)) {
+ this.relayStates.set(url, this.createInitialState(url));
+ }
+
+ // Subscribe to all relay observables
+ const subscription = merge(
+ relay.connected$,
+ relay.notice$,
+ relay.challenge$,
+ relay.authenticated$,
+ ).subscribe(() => {
+ console.log(
+ `[RelayStateManager] Observable triggered for ${url}, authenticated = ${relay.authenticated}, challenge = ${relay.challenge}`,
+ );
+ this.updateRelayState(url, relay);
+ });
+
+ // Store cleanup function
+ this.subscriptions.set(url, () => subscription.unsubscribe());
+
+ // Initial state update
+ this.updateRelayState(url, relay);
+ }
+
+ /**
+ * Create initial state for a relay
+ */
+ private createInitialState(url: string): RelayState {
+ return {
+ url,
+ connectionState: "disconnected",
+ authStatus: "none",
+ authPreference: this.authPreferences.get(url),
+ notices: [],
+ errors: [],
+ stats: {
+ connectionsCount: 0,
+ authAttemptsCount: 0,
+ authSuccessCount: 0,
+ },
+ };
+ }
+
+ /**
+ * Update relay state based on current observable values
+ */
+ private updateRelayState(url: string, relay: IRelay) {
+ const state = this.relayStates.get(url);
+ if (!state) return;
+
+ const now = Date.now();
+
+ // Update connection state
+ const wasConnected = state.connectionState === "connected";
+ const isConnected = relay.connected;
+
+ if (isConnected && !wasConnected) {
+ state.connectionState = "connected";
+ state.lastConnected = now;
+ state.stats.connectionsCount++;
+ } else if (!isConnected && wasConnected) {
+ state.connectionState = "disconnected";
+ state.lastDisconnected = now;
+ // Reset auth status when disconnecting
+ console.log(
+ `[RelayStateManager] ${url} disconnected, resetting auth status`,
+ );
+ state.authStatus = "none";
+ state.currentChallenge = undefined;
+ } else if (isConnected) {
+ state.connectionState = "connected";
+ } else {
+ state.connectionState = "disconnected";
+ }
+
+ // Update auth status
+ const challenge = relay.challenge;
+ // Use the getter property instead of observable value
+ const isAuthenticated = relay.authenticated;
+
+ if (isAuthenticated === true) {
+ // Successfully authenticated - this takes priority over everything
+ if (state.authStatus !== "authenticated") {
+ console.log(
+ `[RelayStateManager] ${url} authenticated (was: ${state.authStatus})`,
+ );
+ state.authStatus = "authenticated";
+ state.lastAuthenticated = now;
+ state.stats.authSuccessCount++;
+ }
+ state.currentChallenge = undefined;
+ } else if (challenge) {
+ // Challenge received
+ if (state.authStatus !== "authenticating") {
+ // Only update to challenge_received if not already authenticating
+ if (
+ !state.currentChallenge ||
+ state.currentChallenge.challenge !== challenge
+ ) {
+ console.log(`[RelayStateManager] ${url} challenge received`);
+ state.currentChallenge = {
+ challenge,
+ receivedAt: now,
+ };
+
+ // Check if we should auto-authenticate
+ const preference = this.authPreferences.get(url);
+ if (preference === "always") {
+ console.log(
+ `[RelayStateManager] ${url} has "always" preference, auto-authenticating`,
+ );
+ state.authStatus = "authenticating";
+ // Trigger authentication asynchronously
+ this.authenticateRelay(url).catch((error) => {
+ console.error(
+ `[RelayStateManager] Auto-auth failed for ${url}:`,
+ error,
+ );
+ });
+ } else {
+ state.authStatus = "challenge_received";
+ }
+ }
+ }
+ // If we're authenticating and there's still a challenge, keep authenticating status
+ } else {
+ // No challenge and not authenticated
+ if (state.currentChallenge || state.authStatus === "authenticating") {
+ // Challenge was cleared or authentication didn't result in authenticated status
+ if (state.authStatus === "authenticating") {
+ // Authentication failed
+ console.log(
+ `[RelayStateManager] ${url} auth failed - no challenge and not authenticated`,
+ );
+ state.authStatus = "failed";
+ } else if (state.authStatus === "challenge_received") {
+ // Challenge was dismissed/rejected
+ console.log(`[RelayStateManager] ${url} challenge rejected`);
+ state.authStatus = "rejected";
+ }
+ state.currentChallenge = undefined;
+ }
+ }
+
+ // Add notices (bounded array)
+ const notices = relay.notices;
+ if (notices.length > 0) {
+ const notice = notices[0];
+ const lastNotice = state.notices[0];
+ if (!lastNotice || lastNotice.message !== notice) {
+ state.notices.unshift({ message: notice, timestamp: now });
+ if (state.notices.length > MAX_NOTICES) {
+ state.notices = state.notices.slice(0, MAX_NOTICES);
+ }
+ }
+ }
+
+ // Notify listeners
+ this.notifyListeners();
+ }
+
+ /**
+ * Get auth preference for a relay
+ */
+ async getAuthPreference(
+ relayUrl: string,
+ ): Promise {
+ // Check memory cache first
+ if (this.authPreferences.has(relayUrl)) {
+ return this.authPreferences.get(relayUrl);
+ }
+
+ // Load from database
+ const record = await db.relayAuthPreferences.get(relayUrl);
+ if (record) {
+ this.authPreferences.set(relayUrl, record.preference);
+ return record.preference;
+ }
+
+ return undefined;
+ }
+
+ /**
+ * Set auth preference for a relay
+ */
+ async setAuthPreference(relayUrl: string, preference: AuthPreference) {
+ console.log(
+ `[RelayStateManager] Setting auth preference for ${relayUrl} to "${preference}"`,
+ );
+
+ // Update memory cache
+ this.authPreferences.set(relayUrl, preference);
+
+ // Save to database
+ try {
+ await db.relayAuthPreferences.put({
+ url: relayUrl,
+ preference,
+ updatedAt: Date.now(),
+ });
+ console.log(
+ `[RelayStateManager] Successfully saved preference to database`,
+ );
+ } catch (error) {
+ console.error(
+ `[RelayStateManager] Failed to save preference to database:`,
+ error,
+ );
+ throw error;
+ }
+
+ // Update relay state
+ const state = this.relayStates.get(relayUrl);
+ if (state) {
+ state.authPreference = preference;
+ this.notifyListeners();
+ console.log(
+ `[RelayStateManager] Updated relay state and notified listeners`,
+ );
+ }
+ }
+
+ /**
+ * Authenticate with a relay
+ */
+ async authenticateRelay(relayUrl: string): Promise {
+ const relay = pool.relay(relayUrl);
+ const state = this.relayStates.get(relayUrl);
+
+ if (!relay || !state) {
+ throw new Error(`Relay ${relayUrl} not found`);
+ }
+
+ if (!state.currentChallenge) {
+ throw new Error(`No auth challenge for ${relayUrl}`);
+ }
+
+ // Get active account
+ const account = accountManager.active;
+ if (!account) {
+ throw new Error("No active account to authenticate with");
+ }
+
+ // Update status to authenticating
+ state.authStatus = "authenticating";
+ state.stats.authAttemptsCount++;
+ this.notifyListeners();
+
+ try {
+ console.log(`[RelayStateManager] Authenticating with ${relayUrl}...`);
+ console.log(
+ `[RelayStateManager] Before auth - authenticated = ${relay.authenticated}, challenge = ${relay.challenge}`,
+ );
+ await relay.authenticate(account);
+ console.log(
+ `[RelayStateManager] After auth - authenticated = ${relay.authenticated}, challenge = ${relay.challenge}`,
+ );
+
+ // Wait a bit for the observable to update
+ await new Promise((resolve) => setTimeout(resolve, 200));
+ console.log(
+ `[RelayStateManager] After delay - authenticated = ${relay.authenticated}, challenge = ${relay.challenge}`,
+ );
+
+ // Force immediate state update after authentication
+ this.updateRelayState(relayUrl, relay);
+ } catch (error) {
+ state.authStatus = "failed";
+ state.errors.unshift({
+ message: `Auth failed: ${error}`,
+ timestamp: Date.now(),
+ });
+ if (state.errors.length > MAX_ERRORS) {
+ state.errors = state.errors.slice(0, MAX_ERRORS);
+ }
+ this.notifyListeners();
+ throw error;
+ }
+ }
+
+ /**
+ * Reject authentication for a relay
+ */
+ rejectAuth(relayUrl: string, rememberForSession = true) {
+ const state = this.relayStates.get(relayUrl);
+ if (state) {
+ state.authStatus = "rejected";
+ state.currentChallenge = undefined;
+ if (rememberForSession) {
+ this.sessionRejections.add(relayUrl);
+ }
+ this.notifyListeners();
+ }
+ }
+
+ /**
+ * Check if a relay should be prompted for auth
+ */
+ shouldPromptAuth(relayUrl: string): boolean {
+ // Check permanent preferences
+ const pref = this.authPreferences.get(relayUrl);
+ if (pref === "never") return false;
+
+ // Check session rejections
+ if (this.sessionRejections.has(relayUrl)) return false;
+
+ // Don't prompt if already authenticated (unless challenge changes)
+ const state = this.relayStates.get(relayUrl);
+ if (state?.authStatus === "authenticated") return false;
+
+ return true;
+ }
+
+ /**
+ * Get current global state
+ */
+ getState(): GlobalRelayState {
+ const relays: Record = {};
+ this.relayStates.forEach((state, url) => {
+ relays[url] = state;
+ });
+
+ const pendingChallenges = Array.from(this.relayStates.values())
+ .filter(
+ (state) =>
+ state.authStatus === "challenge_received" &&
+ this.shouldPromptAuth(state.url),
+ )
+ .map((state) => ({
+ relayUrl: state.url,
+ challenge: state.currentChallenge!.challenge,
+ receivedAt: state.currentChallenge!.receivedAt,
+ }));
+
+ const authPreferences: Record = {};
+ this.authPreferences.forEach((pref, url) => {
+ authPreferences[url] = pref;
+ });
+
+ return {
+ relays,
+ pendingChallenges,
+ authPreferences,
+ };
+ }
+
+ /**
+ * Subscribe to state changes
+ */
+ subscribe(listener: (state: GlobalRelayState) => void): () => void {
+ this.listeners.add(listener);
+ return () => {
+ this.listeners.delete(listener);
+ };
+ }
+
+ /**
+ * Notify all listeners of state change
+ */
+ private notifyListeners() {
+ const state = this.getState();
+ this.listeners.forEach((listener) => listener(state));
+ }
+
+ /**
+ * Load auth preferences from database into memory cache
+ */
+ private async loadAuthPreferences() {
+ try {
+ const allPrefs = await db.relayAuthPreferences.toArray();
+ allPrefs.forEach((record) => {
+ this.authPreferences.set(record.url, record.preference);
+ });
+ console.log(
+ `[RelayStateManager] Loaded ${allPrefs.length} auth preferences from database`,
+ );
+ } catch (error) {
+ console.warn("Failed to load auth preferences:", error);
+ }
+ }
+
+ /**
+ * Cleanup all subscriptions
+ */
+ destroy() {
+ this.subscriptions.forEach((unsubscribe) => unsubscribe());
+ this.subscriptions.clear();
+ this.listeners.clear();
+ }
+}
+
+// Singleton instance
+const relayStateManager = new RelayStateManager();
+
+export default relayStateManager;
diff --git a/src/types/app.ts b/src/types/app.ts
index 47499c7..73c13da 100644
--- a/src/types/app.ts
+++ b/src/types/app.ts
@@ -1,4 +1,5 @@
-import { MosaicNode } from "react-mosaic-component";
+import type { MosaicNode } from "react-mosaic-component";
+import type { GlobalRelayState } from "./relay-state";
export type AppId =
| "nip"
@@ -15,7 +16,8 @@ export type AppId =
| "encode"
| "decode"
| "relay"
- | "debug";
+ | "debug"
+ | "conn";
export interface WindowInstance {
id: string;
@@ -58,4 +60,5 @@ export interface GrimoireState {
timezone: string;
timeFormat: "12h" | "24h";
};
+ relayState?: GlobalRelayState;
}
diff --git a/src/types/man.ts b/src/types/man.ts
index 8815955..ecf8d09 100644
--- a/src/types/man.ts
+++ b/src/types/man.ts
@@ -406,4 +406,16 @@ export const manPages: Record = {
return parsed;
},
},
+ conn: {
+ name: "conn",
+ section: "1",
+ synopsis: "conn",
+ description:
+ "Monitor all relay connections in the pool. Displays real-time connection status, authentication state, pending auth challenges, relay notices, and connection statistics. Manage auth preferences per relay (always/never/ask).",
+ examples: ["conn View all relay connections and auth status"],
+ seeAlso: ["relay", "req"],
+ appId: "conn",
+ category: "System",
+ defaultProps: {},
+ },
};
diff --git a/src/types/relay-state.ts b/src/types/relay-state.ts
new file mode 100644
index 0000000..245baff
--- /dev/null
+++ b/src/types/relay-state.ts
@@ -0,0 +1,64 @@
+// Types for global relay state management
+
+export type ConnectionState =
+ | "disconnected"
+ | "connecting"
+ | "connected"
+ | "error";
+
+export type AuthStatus =
+ | "none" // No auth interaction yet
+ | "challenge_received" // Challenge received, waiting for user decision
+ | "authenticating" // Signing and sending AUTH event
+ | "authenticated" // Successfully authenticated
+ | "rejected" // User rejected auth
+ | "failed"; // Authentication failed
+
+export type AuthPreference = "always" | "never" | "ask";
+
+export interface RelayChallenge {
+ challenge: string;
+ receivedAt: number;
+}
+
+export interface RelayNotice {
+ message: string;
+ timestamp: number;
+}
+
+export interface RelayError {
+ message: string;
+ timestamp: number;
+}
+
+export interface RelayStats {
+ connectionsCount: number;
+ authAttemptsCount: number;
+ authSuccessCount: number;
+}
+
+export interface RelayState {
+ url: string;
+ connectionState: ConnectionState;
+ authStatus: AuthStatus;
+ authPreference?: AuthPreference;
+ currentChallenge?: RelayChallenge;
+ lastConnected?: number;
+ lastDisconnected?: number;
+ lastAuthenticated?: number;
+ notices: RelayNotice[];
+ errors: RelayError[];
+ stats: RelayStats;
+}
+
+export interface PendingAuthChallenge {
+ relayUrl: string;
+ challenge: string;
+ receivedAt: number;
+}
+
+export interface GlobalRelayState {
+ relays: Record;
+ pendingChallenges: PendingAuthChallenge[];
+ authPreferences: Record;
+}