fix get all slices query to properly resolve all slices, clean up jetstream ui

api/src/database/slices.rs

···
         Ok(count.count.unwrap_or(0))
     }
 
-    /// Gets all slice URIs that have lexicons defined.
+    /// Gets all slice URIs from network.slices.slice records.
     ///
-    /// Useful for discovering all active slices in the system.
+    /// Returns all slices that exist in the system
     pub async fn get_all_slices(&self) -> Result<Vec<String>, DatabaseError> {
         let rows: Vec<(String,)> = sqlx::query_as(
             r#"
-            SELECT DISTINCT json->>'slice' as slice_uri
+            SELECT DISTINCT uri as slice_uri
             FROM record
-            WHERE collection = 'network.slices.lexicon'
-            AND json->>'slice' IS NOT NULL
+            WHERE collection = 'network.slices.slice'
         "#,
         )
         .fetch_all(&self.pool)

api/src/jetstream.rs

···
                             } else {
                                 format!("Record updated in {}", commit.collection)
                             };
-                            let operation = if is_insert { "insert" } else { "update" };
                             Logger::global().log_jetstream_with_slice(
                                 LogLevel::Info,
                                 &message,
                                 Some(serde_json::json!({
-                                    "operation": operation,
-                                    "collection": commit.collection,
-                                    "slice_uri": slice_uri,
                                     "did": did,
+                                    "kind": "commit",
+                                    "commit": {
+                                        "rev": commit.rev,
+                                        "operation": commit.operation,
+                                        "collection": commit.collection,
+                                        "rkey": commit.rkey,
+                                        "record": commit.record,
+                                        "cid": commit.cid
+                                    },
+                                    "indexed_operation": if is_insert { "insert" } else { "update" },
                                     "record_type": "primary"
                                 })),
                                 Some(&slice_uri),
···
                                 LogLevel::Error,
                                 message,
                                 Some(serde_json::json!({
-                                    "operation": "upsert",
-                                    "collection": commit.collection,
-                                    "slice_uri": slice_uri,
                                     "did": did,
+                                    "kind": "commit",
+                                    "commit": {
+                                        "rev": commit.rev,
+                                        "operation": commit.operation,
+                                        "collection": commit.collection,
+                                        "rkey": commit.rkey,
+                                        "record": commit.record,
+                                        "cid": commit.cid
+                                    },
                                     "error": e.to_string(),
                                     "record_type": "primary"
                                 })),
···
                             } else {
                                 format!("Record updated in {}", commit.collection)
                             };
-                            let operation = if is_insert { "insert" } else { "update" };
                             Logger::global().log_jetstream_with_slice(
                                 LogLevel::Info,
                                 &message,
                                 Some(serde_json::json!({
-                                    "operation": operation,
-                                    "collection": commit.collection,
-                                    "slice_uri": slice_uri,
                                     "did": did,
+                                    "kind": "commit",
+                                    "commit": {
+                                        "rev": commit.rev,
+                                        "operation": commit.operation,
+                                        "collection": commit.collection,
+                                        "rkey": commit.rkey,
+                                        "record": commit.record,
+                                        "cid": commit.cid
+                                    },
+                                    "indexed_operation": if is_insert { "insert" } else { "update" },
                                     "record_type": "external"
                                 })),
                                 Some(&slice_uri),
···
                                 LogLevel::Error,
                                 message,
                                 Some(serde_json::json!({
-                                    "operation": "upsert",
-                                    "collection": commit.collection,
-                                    "slice_uri": slice_uri,
                                     "did": did,
+                                    "kind": "commit",
+                                    "commit": {
+                                        "rev": commit.rev,
+                                        "operation": commit.operation,
+                                        "collection": commit.collection,
+                                        "rkey": commit.rkey,
+                                        "record": commit.record,
+                                        "cid": commit.cid
+                                    },
                                     "error": e.to_string(),
                                     "record_type": "external"
                                 })),
···
         }
 
         // Handle cascade deletion before deleting the record
-        if let Err(e) = self.database.handle_cascade_deletion(&uri, &commit.collection).await {
+        if let Err(e) = self
+            .database
+            .handle_cascade_deletion(&uri, &commit.collection)
+            .await
+        {
             warn!("Cascade deletion failed for {}: {}", uri, e);
         }
 

api/src/logging.rs

···
     let limit = limit.unwrap_or(100);
 
     let rows = if let Some(slice_uri) = slice_filter {
-        tracing::info!("Querying jetstream logs with slice filter: {}", slice_uri);
         // Include both slice-specific logs and global connection logs for context
-        let results = sqlx::query_as!(
+        sqlx::query_as!(
             LogEntry,
             r#"
             SELECT id, created_at, log_type, job_id, user_did, slice_uri, level, message, metadata
···
             limit
         )
         .fetch_all(pool)
-        .await?;
-
-        tracing::info!(
-            "Found {} jetstream logs for slice {}",
-            results.len(),
-            slice_uri
-        );
-        results
+        .await?
     } else {
         // No filter provided, return all Jetstream logs across all slices
         sqlx::query_as!(

frontend/src/features/slices/jetstream/handlers.tsx

···
 import type { Route } from "@std/http/unstable-route";
-import { requireAuth, withAuth } from "../../../routes/middleware.ts";
+import { withAuth } from "../../../routes/middleware.ts";
 import {
   requireSliceAccess,
   withSliceAccess,
···
 import { getSliceClient } from "../../../utils/client.ts";
 import { publicClient } from "../../../config.ts";
 import { renderHTML } from "../../../utils/render.tsx";
-import { Layout } from "../../../shared/fragments/Layout.tsx";
 import { extractSliceParams } from "../../../utils/slice-params.ts";
 import { JetstreamLogsPage } from "./templates/JetstreamLogsPage.tsx";
-import { JetstreamLogs } from "./templates/fragments/JetstreamLogs.tsx";
-import { JetstreamStatus } from "./templates/fragments/JetstreamStatus.tsx";
-import { JetstreamStatusDisplay } from "./templates/fragments/JetstreamStatusDisplay.tsx";
 import { NetworkSlicesSliceGetJobLogsLogEntry } from "../../../client.ts";
-import { buildSliceUri } from "../../../utils/at-uri.ts";
-
-async function handleJetstreamLogs(
-  req: Request,
-  params?: URLPatternResult
-): Promise<Response> {
-  const context = await withAuth(req);
-  const authResponse = requireAuth(context);
-  if (authResponse) return authResponse;
-
-  const sliceId = params?.pathname.groups.id;
-  if (!sliceId) {
-    return renderHTML(
-      <div className="p-8 text-center text-red-600">❌ Invalid slice ID</div>,
-      { status: 400 }
-    );
-  }
-
-  try {
-    // Use the slice-specific client
-    const sliceClient = getSliceClient(context, sliceId);
-
-    // Build slice URI from the user's DID and sliceId
-    const sliceUri = buildSliceUri(context.currentUser.sub!, sliceId);
-
-    // Get Jetstream logs
-    const result = await sliceClient.network.slices.slice.getJetstreamLogs({
-      slice: sliceUri,
-      limit: 100,
-    });
-
-    const logs = result?.logs || [];
-
-    // Sort logs in descending order (newest first)
-    const sortedLogs = logs.sort(
-      (a, b) =>
-        new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
-    );
-
-    // Render the log content
-    return renderHTML(<JetstreamLogs logs={sortedLogs} />);
-  } catch (error) {
-    console.error("Failed to get Jetstream logs:", error);
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    return renderHTML(
-      <Layout title="Error">
-        <div className="max-w-6xl mx-auto">
-          <div className="flex items-center gap-4 mb-6">
-            <a
-              href={`/profile/${context.currentUser.handle}/slice/${sliceId}`}
-              className="text-blue-600 hover:text-blue-800"
-            >
-              ← Back to Slice
-            </a>
-            <h1 className="text-2xl font-semibold text-gray-900">
-              ✈️ Jetstream Logs
-            </h1>
-          </div>
-          <div className="p-8 text-center text-red-600">
-            ❌ Error loading Jetstream logs: {errorMessage}
-          </div>
-        </div>
-      </Layout>,
-      { status: 500 }
-    );
-  }
-}
-
-async function handleJetstreamStatus(
-  req: Request,
-  _params?: URLPatternResult
-): Promise<Response> {
-  try {
-    // Extract parameters from query
-    const url = new URL(req.url);
-    const isCompact = url.searchParams.get("compact") === "true";
-    const sliceId = url.searchParams.get("sliceId") || undefined;
-    const handle = url.searchParams.get("handle") || undefined;
-
-    // Fetch jetstream status using the public client
-    const data = await publicClient.network.slices.slice.getJetstreamStatus();
-
-    // Render compact version for logs page
-    if (isCompact) {
-      return renderHTML(
-        <JetstreamStatusDisplay connected={data.connected} isCompact />
-      );
-    }
-
-    // Render full version for main page
-    return renderHTML(
-      <JetstreamStatus
-        connected={data.connected}
-        sliceId={sliceId}
-        handle={handle}
-      />
-    );
-  } catch (_error) {
-    // Extract parameters for error case too
-    const url = new URL(req.url);
-    const isCompact = url.searchParams.get("compact") === "true";
-    const sliceId = url.searchParams.get("sliceId") || undefined;
-    const handle = url.searchParams.get("handle") || undefined;
-
-    // Render compact error version
-    if (isCompact) {
-      return renderHTML(<JetstreamStatusDisplay connected={false} isCompact />);
-    }
-
-    // Fallback to disconnected state on error for full version
-    return renderHTML(
-      <JetstreamStatus connected={false} sliceId={sliceId} handle={handle} />
-    );
-  }
-}
 
 async function handleJetstreamLogsPage(
   req: Request,
···
     console.error("Failed to fetch Jetstream logs:", error);
   }
 
+  // Fetch jetstream status
+  let jetstreamConnected = false;
+  try {
+    const jetstreamStatus =
+      await publicClient.network.slices.slice.getJetstreamStatus();
+    jetstreamConnected = jetstreamStatus.connected;
+  } catch (error) {
+    console.error("Failed to fetch Jetstream status:", error);
+  }
+
   return renderHTML(
     <JetstreamLogsPage
       slice={context.sliceContext!.slice!}
       logs={logs}
       sliceId={sliceParams.sliceId}
       currentUser={authContext.currentUser}
+      jetstreamConnected={jetstreamConnected}
     />
   );
 }
···
       pathname: "/profile/:handle/slice/:rkey/jetstream",
     }),
     handler: handleJetstreamLogsPage,
-  },
-  {
-    method: "GET",
-    pattern: new URLPattern({ pathname: "/api/jetstream/status" }),
-    handler: handleJetstreamStatus,
-  },
-  {
-    method: "GET",
-    pattern: new URLPattern({ pathname: "/api/slices/:id/jetstream/logs" }),
-    handler: handleJetstreamLogs,
   },
 ];

frontend/src/features/slices/jetstream/templates/JetstreamLogsPage.tsx

···
   logs: NetworkSlicesSliceGetJobLogsLogEntry[];
   sliceId: string;
   currentUser?: AuthenticatedUser;
+  jetstreamConnected?: boolean;
 }
 
 export function JetstreamLogsPage({
···
   logs,
   sliceId,
   currentUser,
+  jetstreamConnected = false,
 }: JetstreamLogsPageProps) {
+  const sliceUrl = buildSliceUrlFromView(slice, sliceId);
   return (
     <SliceLogPage
       slice={slice}
···
       currentUser={currentUser}
       title="Jetstream Logs"
       breadcrumbItems={[
-        { label: slice.name, href: buildSliceUrlFromView(slice, sliceId) },
+        { label: slice.name, href: sliceUrl },
         { label: "Jetstream Logs" },
       ]}
-      headerActions={<JetstreamStatusCompact sliceId={sliceId} />}
+      headerActions={<JetstreamStatusCompact connected={jetstreamConnected} />}
     >
-      <div
-        hx-get={`/api/slices/${sliceId}/jetstream/logs`}
-        hx-trigger="load, every 20s"
-        hx-swap="innerHTML"
-      >
-        <JetstreamLogs logs={logs} />
-      </div>
+      <JetstreamLogs logs={logs} />
     </SliceLogPage>
   );
 }

frontend/src/features/slices/jetstream/templates/fragments/JetstreamStatusCompact.tsx

···
 import { Text } from "../../../../../shared/fragments/Text.tsx";
 
-export function JetstreamStatusCompact({ sliceId }: { sliceId: string }) {
+interface JetstreamStatusCompactProps {
+  connected: boolean;
+}
+
+export function JetstreamStatusCompact({ connected }: JetstreamStatusCompactProps) {
   return (
-    <div
-      hx-get={`/api/jetstream/status?sliceId=${sliceId}&compact=true`}
-      hx-trigger="load, every 2m"
-      hx-swap="outerHTML"
-      className="inline-flex items-center gap-2 text-xs"
-    >
-      <div className="w-2 h-2 bg-zinc-400 dark:bg-zinc-500 rounded-full"></div>
-      <Text as="span" variant="muted" size="xs">Checking status...</Text>
+    <div className="inline-flex items-center gap-2 text-xs">
+      {connected ? (
+        <>
+          <div className="w-2 h-2 bg-green-500 rounded-full animate-pulse"></div>
+          <Text as="span" variant="success" size="xs">
+            Jetstream Connected
+          </Text>
+        </>
+      ) : (
+        <>
+          <div className="w-2 h-2 bg-red-500 rounded-full"></div>
+          <Text as="span" variant="error" size="xs">
+            Jetstream Offline
+          </Text>
+        </>
+      )}
     </div>
   );
 }

frontend/src/features/slices/jetstream/templates/fragments/JetstreamStatusDisplay.tsx

···
-import { Text } from "../../../../../shared/fragments/Text.tsx";
-
-interface JetstreamStatusDisplayProps {
-  connected: boolean;
-  isCompact?: boolean;
-}
-
-export function JetstreamStatusDisplay({ connected, isCompact = false }: JetstreamStatusDisplayProps) {
-  if (isCompact) {
-    return (
-      <div className="inline-flex items-center gap-2 text-xs">
-        {connected ? (
-          <>
-            <div className="w-2 h-2 bg-green-500 rounded-full animate-pulse"></div>
-            <Text as="span" variant="success" size="xs">
-              Jetstream Connected
-            </Text>
-          </>
-        ) : (
-          <>
-            <div className="w-2 h-2 bg-red-500 rounded-full"></div>
-            <Text as="span" variant="error" size="xs">
-              Jetstream Offline
-            </Text>
-          </>
-        )}
-      </div>
-    );
-  }
-
-  // Full version would be handled by the existing JetstreamStatus component
-  return null;
-}

frontend/src/features/slices/overview/handlers.tsx

···
   withSliceAccess,
 } from "../../../routes/slice-middleware.ts";
 import { extractSliceParams } from "../../../utils/slice-params.ts";
+import { publicClient } from "../../../config.ts";
 
 async function handleSliceOverview(
   req: Request,
···
     actors: stat.actors,
   }));
 
+  // Fetch jetstream status
+  let jetstreamConnected = false;
+  try {
+    const jetstreamStatus = await publicClient.network.slices.slice.getJetstreamStatus();
+    jetstreamConnected = jetstreamStatus.connected;
+  } catch (error) {
+    console.error("Failed to fetch Jetstream status:", error);
+  }
+
   return renderHTML(
     <SliceOverview
       slice={context.sliceContext!.slice!}
···
       currentTab="overview"
       currentUser={authContext.currentUser}
       hasSliceAccess={context.sliceContext?.hasAccess}
+      jetstreamConnected={jetstreamConnected}
     />,
   );
 }

frontend/src/features/slices/overview/templates/SliceOverview.tsx

···
 import { Text } from "../../../../shared/fragments/Text.tsx";
 import { Link } from "../../../../shared/fragments/Link.tsx";
 import { buildSliceUrlFromView } from "../../../../utils/slice-params.ts";
+import { JetstreamStatus } from "./fragments/JetstreamStatus.tsx";
 
 function formatNumber(num: number): string {
   return num.toLocaleString();
···
   currentTab?: string;
   currentUser?: AuthenticatedUser;
   hasSliceAccess?: boolean;
+  jetstreamConnected?: boolean;
 }
 
 export function SliceOverview({
···
   currentTab = "overview",
   currentUser,
   hasSliceAccess,
+  jetstreamConnected = false,
 }: SliceOverviewProps) {
   return (
     <SlicePage
···
       currentUser={currentUser}
       hasSliceAccess={hasSliceAccess}
     >
-      <div
-        hx-get={`/api/jetstream/status?sliceId=${sliceId}&handle=${slice.creator?.handle}`}
-        hx-trigger="load, every 2m"
-        hx-swap="outerHTML"
-      >
-        <Card padding="sm" className="mb-6">
-          <div className="flex items-center justify-between">
-            <div className="flex items-center">
-              <div className="w-3 h-3 bg-zinc-400 dark:bg-zinc-500 rounded-full mr-3"></div>
-              <div>
-                <Text
-                  as="h3"
-                  size="sm"
-                  variant="secondary"
-                  className="font-semibold block"
-                >
-                  🌊 Checking Jetstream Status...
-                </Text>
-                <Text as="p" size="xs" variant="muted">
-                  Loading connection status
-                </Text>
-              </div>
-            </div>
-            <Text as="span" size="xs" variant="muted">
-              Checking...
-            </Text>
-          </div>
-        </Card>
-      </div>
+      <JetstreamStatus
+        connected={jetstreamConnected}
+        sliceId={sliceId}
+        handle={slice.creator?.handle}
+      />
 
       {(slice.indexedRecordCount ?? 0) > 0 && (
         <Card padding="md" className="mb-8">