@swarmclawai/swarmclaw 0.8.4 → 0.8.7

package/src/components/ui/full-screen-loader.tsx

@@ -0,0 +1,164 @@
+export function FullScreenLoader(props: {
+  stage?: string | null
+  stalled?: boolean
+  onReload?: () => void
+  onReset?: () => void
+}) {
+  return (
+    <div className="h-full flex flex-col items-center justify-center bg-bg overflow-hidden select-none">
+      {/* Animated orbital ring */}
+      <div className="relative w-[120px] h-[120px] mb-8">
+        {/* Outer glow pulse */}
+        <div
+          className="absolute inset-[-20px] rounded-full"
+          style={{
+            background: 'radial-gradient(circle, rgba(99,102,241,0.08) 0%, transparent 70%)',
+            animation: 'sc-glow 2.5s ease-in-out infinite',
+          }}
+        />
+
+        {/* Orbital ring */}
+        <div
+          className="absolute inset-0 rounded-full border border-white/[0.06]"
+          style={{ animation: 'sc-ring 3s linear infinite' }}
+        />
+
+        {/* Orbiting dots */}
+        {[0, 1, 2, 3, 4, 5].map((i) => (
+          <div
+            key={i}
+            className="absolute inset-0"
+            style={{
+              animation: `sc-orbit 2.4s cubic-bezier(0.4, 0, 0.2, 1) infinite`,
+              animationDelay: `${i * -0.4}s`,
+            }}
+          >
+            <div
+              className="absolute top-0 left-1/2 -translate-x-1/2 -translate-y-1/2 rounded-full"
+              style={{
+                width: i === 0 ? 8 : 6,
+                height: i === 0 ? 8 : 6,
+                background: i === 0 ? '#818CF8' : `rgba(129, 140, 248, ${0.7 - i * 0.1})`,
+                boxShadow: i === 0 ? '0 0 12px rgba(99,102,241,0.5)' : 'none',
+              }}
+            />
+          </div>
+        ))}
+
+        {/* Center logo mark */}
+        <div className="absolute inset-0 flex items-center justify-center">
+          <div
+            className="relative"
+            style={{ animation: 'sc-breathe 2.5s ease-in-out infinite' }}
+          >
+            <svg width="36" height="36" viewBox="0 0 36 36" fill="none">
+              {/* Hexagonal claw mark */}
+              <path
+                d="M18 4L30 11V25L18 32L6 25V11L18 4Z"
+                stroke="rgba(129, 140, 248, 0.3)"
+                strokeWidth="1"
+                fill="none"
+              />
+              <path
+                d="M18 9L25 13V23L18 27L11 23V13L18 9Z"
+                stroke="rgba(129, 140, 248, 0.5)"
+                strokeWidth="1.5"
+                fill="rgba(99, 102, 241, 0.06)"
+              />
+              {/* Claw lines */}
+              <path d="M14 15L18 20L22 15" stroke="#818CF8" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" />
+              <path d="M12 13L18 20L24 13" stroke="rgba(129, 140, 248, 0.3)" strokeWidth="1.5" strokeLinecap="round" strokeLinejoin="round" />
+            </svg>
+          </div>
+        </div>
+      </div>
+
+      {/* Brand text */}
+      <div
+        className="text-[15px] font-display font-700 tracking-[0.15em] uppercase"
+        style={{
+          background: 'linear-gradient(135deg, rgba(255,255,255,0.6), rgba(129, 140, 248, 0.8))',
+          WebkitBackgroundClip: 'text',
+          WebkitTextFillColor: 'transparent',
+          animation: 'sc-text-fade 2s ease-in-out infinite alternate, fade-up 0.6s var(--ease-spring) 0.2s both',
+        }}
+      >
+        SwarmClaw
+      </div>
+
+      {/* Loading bar */}
+      <div className="mt-4 w-[100px] h-[2px] rounded-full bg-white/[0.06] overflow-hidden" style={{ animation: 'fade-up 0.6s var(--ease-spring) 0.3s both' }}>
+        <div
+          className="h-full rounded-full bg-accent-bright/60"
+          style={{ animation: 'sc-progress 1.5s ease-in-out infinite' }}
+        />
+      </div>
+
+      {props.stage ? (
+        <p
+          className="mt-4 text-[12px] text-text-3"
+          style={{ animation: 'fade-up 0.6s var(--ease-spring) 0.4s both' }}
+        >
+          {props.stage}
+        </p>
+      ) : null}
+
+      {props.stalled ? (
+        <div
+          className="mt-6 max-w-[360px] px-4 text-center"
+          style={{ animation: 'fade-up 0.6s var(--ease-spring) 0.5s both' }}
+        >
+          <p className="text-[12px] text-text-2">
+            Startup is taking longer than expected. This usually means the browser kept stale local state while the dev server restarted.
+          </p>
+          <div className="mt-4 flex items-center justify-center gap-3">
+            <button
+              type="button"
+              onClick={props.onReload}
+              className="px-4 py-2 rounded-[12px] border border-white/[0.08] bg-surface text-[12px] text-text-2 transition-colors hover:bg-surface-2"
+            >
+              Reload
+            </button>
+            <button
+              type="button"
+              onClick={props.onReset}
+              className="px-4 py-2 rounded-[12px] border border-white/[0.08] bg-transparent text-[12px] text-text-3 transition-colors hover:bg-white/[0.04]"
+            >
+              Reset Local Session
+            </button>
+          </div>
+        </div>
+      ) : null}
+
+      {/* Loading animation keyframes */}
+      <style>{`
+        @keyframes sc-orbit {
+          from { transform: rotate(0deg); }
+          to { transform: rotate(360deg); }
+        }
+        @keyframes sc-ring {
+          from { transform: rotate(0deg) scale(1); }
+          50% { transform: rotate(180deg) scale(1.02); }
+          to { transform: rotate(360deg) scale(1); }
+        }
+        @keyframes sc-breathe {
+          0%, 100% { transform: scale(1); opacity: 0.9; }
+          50% { transform: scale(1.06); opacity: 1; }
+        }
+        @keyframes sc-glow {
+          0%, 100% { opacity: 0.5; transform: scale(0.9); }
+          50% { opacity: 1; transform: scale(1.1); }
+        }
+        @keyframes sc-text-fade {
+          0% { opacity: 0.6; }
+          100% { opacity: 1; }
+        }
+        @keyframes sc-progress {
+          0% { width: 0; margin-left: 0; }
+          50% { width: 70%; margin-left: 15%; }
+          100% { width: 0; margin-left: 100%; }
+        }
+      `}</style>
+    </div>
+  )
+}

package/src/components/wallets/wallet-approval-dialog.tsx

@@ -5,6 +5,7 @@ import { api } from '@/lib/api-client'
 import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle } from '@/components/ui/dialog'
 import type { WalletTransaction } from '@/types'
 import { formatWalletAmount, getWalletAssetSymbol, getWalletAtomicAmount } from '@/lib/wallet'
+import { errorMessage } from '@/lib/shared-utils'
 
 interface WalletApprovalDialogProps {
   transaction: WalletTransaction
@@ -28,7 +29,7 @@ export function WalletApprovalDialog({ transaction, walletAddress, onClose, onRe
       onResolved()
       onClose()
     } catch (err: unknown) {
-      setError(err instanceof Error ? err.message : String(err))
+      setError(errorMessage(err))
     } finally {
       setSubmitting(false)
     }

package/src/components/wallets/wallet-panel.tsx

@@ -21,6 +21,7 @@ import {
 } from '@/lib/wallet'
 import { type WalletTransactionFilter, filterWalletTransactions, getWalletTransactionStatusGroup } from '@/lib/wallet-transactions'
 import { toast } from 'sonner'
+import { dedup, errorMessage } from '@/lib/shared-utils'
 
 type SafeWallet = Omit<AgentWallet, 'encryptedPrivateKey'> & {
   balanceAtomic?: string
@@ -39,7 +40,7 @@ function getAgentWalletIds(agent: Agent | undefined | null): string[] {
   const legacy = typeof agent?.walletId === 'string' && agent.walletId.trim()
     ? [agent.walletId.trim()]
     : []
-  return [...new Set([...ids, ...legacy])]
+  return dedup([...ids, ...legacy])
 }
 
 function getAgentActiveWalletId(agent: Agent | undefined | null, fallbackWallets: SafeWallet[] = []): string | null {
@@ -256,7 +257,7 @@ export function WalletPanel() {
       setEditingLimits(false)
       loadDetail()
     } catch (err: unknown) {
-      toast.error(err instanceof Error ? err.message : String(err))
+      toast.error(errorMessage(err))
     }
     setSaving(false)
   }, [selectedWalletId, selectedWallet, perTxLimit, dailyLimit, requireApproval, loadDetail])
@@ -269,7 +270,7 @@ export function WalletPanel() {
       toast.success('Default wallet updated')
       loadWallets()
     } catch (err: unknown) {
-      toast.error(err instanceof Error ? err.message : String(err))
+      toast.error(errorMessage(err))
     }
     setSettingDefault(false)
   }, [selectedWalletId, loadWallets])
@@ -322,7 +323,7 @@ export function WalletPanel() {
       setCreateChain('solana')
       loadWallets()
     } catch (err: unknown) {
-      setCreateError(err instanceof Error ? err.message : String(err))
+      setCreateError(errorMessage(err))
     }
     setCreating(false)
   }, [createAgentId, createChain, loadWallets])
@@ -636,7 +637,7 @@ export function WalletPanel() {
                         setReassigning(false)
                         loadWallets()
                       } catch (err: unknown) {
-                        setReassignError(err instanceof Error ? err.message : String(err) || 'Reassign failed')
+                        setReassignError(errorMessage(err) || 'Reassign failed')
                       }
                       setReassignSaving(false)
                     }}

package/src/components/wallets/wallet-section.tsx

@@ -5,6 +5,7 @@ import { api } from '@/lib/api-client'
 import { copyTextToClipboard } from '@/lib/clipboard'
 import type { AgentWallet, WalletAssetBalance, WalletPortfolioSummary, WalletChain } from '@/types'
 import { toast } from 'sonner'
+import { errorMessage } from '@/lib/shared-utils'
 import {
   SUPPORTED_WALLET_CHAINS,
   formatWalletAmount,
@@ -67,7 +68,7 @@ export function WalletSection({ agentId, wallets, activeWalletId, onWalletCreate
       toast.success('Agent wallet created successfully')
       await onWalletCreated()
     } catch (err: unknown) {
-      const msg = err instanceof Error ? err.message : String(err)
+      const msg = errorMessage(err)
       setError(msg)
       toast.error(msg)
     } finally {
@@ -92,7 +93,7 @@ export function WalletSection({ agentId, wallets, activeWalletId, onWalletCreate
       toast.success('Default wallet updated')
       await onWalletCreated()
     } catch (err: unknown) {
-      const msg = err instanceof Error ? err.message : String(err)
+      const msg = errorMessage(err)
       setError(msg)
       toast.error(msg)
     } finally {

package/src/components/webhooks/webhook-list.tsx

@@ -4,9 +4,8 @@ import { useEffect, useMemo, useState } from 'react'
 import { useAppStore } from '@/stores/use-app-store'
 import { copyTextToClipboard } from '@/lib/clipboard'
 
-function webhookUrl(id: string): string {
-  if (typeof window === 'undefined') return `/api/webhooks/${id}`
-  return `${window.location.origin}/api/webhooks/${id}`
+function webhookPath(id: string): string {
+  return `/api/webhooks/${id}`
 }
 
 function formatEvents(events: string[] | undefined): string {
@@ -74,7 +73,7 @@ export function WebhookList({ inSidebar }: { inSidebar?: boolean }) {
     <div className={`flex-1 overflow-y-auto ${inSidebar ? 'pb-10' : 'pb-20'}`}>
       {list.map((hook, idx) => {
         const agentName = hook.agentId ? agents[hook.agentId]?.name : null
-        const endpoint = webhookUrl(hook.id)
+        const endpoint = webhookPath(hook.id)
         const copiedEndpoint = copied === `endpoint:${hook.id}`
         const copiedSecret = copied === `secret:${hook.id}`
         const hasSecret = typeof hook.secret === 'string' && hook.secret.trim().length > 0
@@ -121,7 +120,7 @@ export function WebhookList({ inSidebar }: { inSidebar?: boolean }) {
             <button
               onClick={(e) => {
                 e.stopPropagation()
-                copyText(`endpoint:${hook.id}`, endpoint)
+                copyText(`endpoint:${hook.id}`, `${window.location.origin}${endpoint}`)
               }}
               title={copiedEndpoint ? 'Copied endpoint' : 'Copy endpoint URL'}
               className={`shrink-0 w-8 h-8 rounded-[8px] flex items-center justify-center transition-all cursor-pointer border-none ${

package/src/components/webhooks/webhook-sheet.tsx

@@ -7,6 +7,7 @@ import { ConfirmDialog } from '@/components/shared/confirm-dialog'
 import { api } from '@/lib/api-client'
 import { copyTextToClipboard } from '@/lib/clipboard'
 import type { Webhook, WebhookLogEntry } from '@/types'
+import { dedup } from '@/lib/shared-utils'
 import { toast } from 'sonner'
 
 type WebhookApiResponse = Webhook | { error: string }
@@ -14,9 +15,8 @@ type DeleteWebhookResponse = { ok: boolean } | { error: string }
 
 const inputClass = 'w-full px-4 py-3 rounded-[14px] bg-bg border border-white/[0.06] text-text text-[14px] outline-none focus:border-accent-bright/40 transition-colors placeholder:text-text-3/70'
 
-function webhookUrl(id: string): string {
-  if (typeof window === 'undefined') return `/api/webhooks/${id}`
-  return `${window.location.origin}/api/webhooks/${id}`
+function webhookPath(id: string): string {
+  return `/api/webhooks/${id}`
 }
 
 function parseEvents(input: string): string[] {
@@ -24,7 +24,7 @@ function parseEvents(input: string): string[] {
     .split(/[\n,]+/)
     .map((v) => v.trim())
     .filter(Boolean)
-  return Array.from(new Set(values))
+  return dedup(values)
 }
 
 function makeSecret(length = 28): string {
@@ -66,7 +66,7 @@ export function WebhookSheet() {
   const [deleting, setDeleting] = useState(false)
 
   const editing = editingId ? (webhooks[editingId] as Webhook | undefined) : null
-  const endpoint = editing ? webhookUrl(editing.id) : ''
+  const endpoint = editing ? webhookPath(editing.id) : ''
   const eligibleAgents = useMemo(
     () => Object.values(agents),
     [agents]
@@ -264,7 +264,7 @@ export function WebhookSheet() {
                 className={`${inputClass} font-mono text-[12px]`}
               />
               <button
-                onClick={() => copyText('endpoint', endpoint)}
+                onClick={() => copyText('endpoint', `${window.location.origin}${endpoint}`)}
                 className="px-3.5 py-2 rounded-[10px] border border-accent-bright/20 bg-accent-soft/40 text-accent-bright text-[12px] font-600 cursor-pointer hover:bg-accent-soft transition-colors"
                 style={{ fontFamily: 'inherit' }}
               >

package/src/hooks/use-app-bootstrap.ts

@@ -0,0 +1,202 @@
+import { useEffect, useState, useCallback } from 'react'
+import { useAppStore } from '@/stores/use-app-store'
+import { getStoredAccessKey, clearStoredAccessKey, api } from '@/lib/api-client'
+import { safeStorageGet, safeStorageSet } from '@/lib/safe-storage'
+import { connectWs, disconnectWs } from '@/lib/ws-client'
+import { fetchWithTimeout, isAbortError, isTimeoutError } from '@/lib/fetch-timeout'
+import { isDevelopmentLikeRuntime } from '@/lib/runtime-env'
+import { useWs } from '@/hooks/use-ws'
+import { useMountedRef } from '@/hooks/use-mounted-ref'
+import type { Agent } from '@/types'
+
+const AUTH_CHECK_TIMEOUT_MS = isDevelopmentLikeRuntime() ? 20_000 : 8_000
+const POST_AUTH_BOOTSTRAP_TIMEOUT_MS = isDevelopmentLikeRuntime() ? 20_000 : 8_000
+
+function isExpectedAuthProbeError(err: unknown): boolean {
+  return isAbortError(err) || isTimeoutError(err)
+}
+
+export function useAppBootstrap() {
+  const currentUser = useAppStore((s) => s.currentUser)
+  const setUser = useAppStore((s) => s.setUser)
+  const hydrated = useAppStore((s) => s._hydrated)
+  const hydrate = useAppStore((s) => s.hydrate)
+  const loadNetworkInfo = useAppStore((s) => s.loadNetworkInfo)
+  const loadSessions = useAppStore((s) => s.loadSessions)
+  const loadSettings = useAppStore((s) => s.loadSettings)
+
+  const [authChecked, setAuthChecked] = useState(false)
+  const [authenticated, setAuthenticated] = useState(false)
+  const [setupDone, setSetupDone] = useState<boolean | null>(null)
+  const [agentReady, setAgentReady] = useState(false)
+  const mountedRef = useMountedRef()
+
+  const checkAuth = useCallback(async () => {
+    try {
+      const res = await fetchWithTimeout('/api/auth', {}, AUTH_CHECK_TIMEOUT_MS)
+      const data = await res.json().catch((err) => {
+        console.warn('Failed to parse /api/auth JSON:', err)
+        return {}
+      })
+      if (data?.authenticated === true) {
+        if (!mountedRef.current) return
+        setAuthenticated(true)
+        setAuthChecked(true)
+        return
+      }
+    } catch (err) {
+      if (!isExpectedAuthProbeError(err)) {
+        console.warn('Auth check probe failed, falling back to stored key:', err)
+      }
+    }
+
+    const key = getStoredAccessKey()
+    if (!key) {
+      if (!mountedRef.current) return
+      setAuthenticated(false)
+      setAuthChecked(true)
+      return
+    }
+
+    try {
+      const res = await fetchWithTimeout('/api/auth', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ key }),
+      }, AUTH_CHECK_TIMEOUT_MS)
+      if (res.ok) {
+        if (!mountedRef.current) return
+        setAuthenticated(true)
+      } else {
+        clearStoredAccessKey()
+        if (!mountedRef.current) return
+        setAuthenticated(false)
+      }
+    } catch (err) {
+      if (!isExpectedAuthProbeError(err)) {
+        console.warn('Stored key auth check failed:', err)
+      }
+      clearStoredAccessKey()
+      if (!mountedRef.current) return
+      setAuthenticated(false)
+    } finally {
+      if (!mountedRef.current) return
+      setAuthChecked(true)
+    }
+  }, [mountedRef])
+
+  const syncUserFromServer = useCallback(async () => {
+    if (currentUser) return
+    try {
+      const settings = await api<{ userName?: string }>('GET', '/settings', undefined, {
+        timeoutMs: POST_AUTH_BOOTSTRAP_TIMEOUT_MS,
+        retries: 0,
+      })
+      if (settings.userName) {
+        setUser(settings.userName)
+      }
+    } catch (err) {
+      console.warn('Failed to sync user from server:', err)
+    }
+  }, [currentUser, setUser])
+
+  useEffect(() => {
+    hydrate()
+  }, [hydrate])
+
+  useEffect(() => {
+    if (!hydrated) return
+    if (safeStorageGet('sc_setup_done') === '1') {
+      setSetupDone((current) => current ?? true)
+    }
+  }, [hydrated])
+
+  useEffect(() => {
+    if (hydrated) checkAuth()
+  }, [hydrated, checkAuth])
+
+  useEffect(() => {
+    if (!authenticated) return
+    connectWs()
+    syncUserFromServer()
+    loadNetworkInfo()
+    loadSettings()
+    loadSessions()
+    return () => { disconnectWs() }
+  }, [authenticated, loadNetworkInfo, loadSessions, loadSettings, syncUserFromServer])
+
+  useWs('sessions', loadSessions, 15000)
+
+  useEffect(() => {
+    if (!authenticated || !currentUser) return
+    let cancelled = false
+    ;(async () => {
+      try {
+        const agents = await api<Record<string, Agent>>('GET', '/agents', undefined, {
+          timeoutMs: POST_AUTH_BOOTSTRAP_TIMEOUT_MS,
+          retries: 0,
+        })
+        if (cancelled) return
+        useAppStore.setState({ agents })
+
+        const { currentAgentId, appSettings } = useAppStore.getState()
+        const targetId = (currentAgentId && agents[currentAgentId])
+          ? currentAgentId
+          : (appSettings.defaultAgentId && agents[appSettings.defaultAgentId])
+            ? appSettings.defaultAgentId
+            : Object.values(agents)[0]?.id || null
+
+        if (targetId) {
+          await useAppStore.getState().setCurrentAgent(targetId)
+        }
+      } catch (err) {
+        console.warn('Failed to initialize agents:', err)
+      }
+      if (!cancelled && mountedRef.current) setAgentReady(true)
+    })()
+    return () => { cancelled = true }
+  }, [authenticated, currentUser, mountedRef])
+
+  useEffect(() => {
+    if (!authenticated || !currentUser) return
+    let cancelled = false
+    ;(async () => {
+      try {
+        const [settingsResult, credsResult] = await Promise.allSettled([
+          api<{ setupCompleted?: boolean }>('GET', '/settings', undefined, {
+            timeoutMs: POST_AUTH_BOOTSTRAP_TIMEOUT_MS,
+            retries: 0,
+          }),
+          api<Record<string, unknown>>('GET', '/credentials', undefined, {
+            timeoutMs: POST_AUTH_BOOTSTRAP_TIMEOUT_MS,
+            retries: 0,
+          }),
+        ])
+        if (cancelled) return
+        const settings = settingsResult.status === 'fulfilled' ? settingsResult.value : {}
+        const creds = credsResult.status === 'fulfilled' ? credsResult.value : {}
+        const bothFailed = settingsResult.status === 'rejected' && credsResult.status === 'rejected'
+        const hasCreds = Object.keys(creds).length > 0
+        const done = bothFailed ? true : settings.setupCompleted === true || hasCreds
+        if (done) safeStorageSet('sc_setup_done', '1')
+        if (!mountedRef.current) return
+        setSetupDone(done)
+      } catch (err) {
+        console.warn('Failed to check setup state:', err)
+        if (!cancelled && mountedRef.current) setSetupDone(true)
+      }
+    })()
+    return () => { cancelled = true }
+  }, [authenticated, currentUser, mountedRef])
+
+  return {
+    hydrated,
+    authChecked,
+    authenticated,
+    setAuthenticated,
+    currentUser,
+    setupDone,
+    setSetupDone,
+    agentReady
+  }
+}

package/src/hooks/use-mounted-ref.ts

@@ -0,0 +1,14 @@
+import { useEffect, useRef } from 'react'
+
+export function useMountedRef() {
+  const mountedRef = useRef(true)
+
+  useEffect(() => {
+    mountedRef.current = true
+    return () => {
+      mountedRef.current = false
+    }
+  }, [])
+
+  return mountedRef
+}

package/src/hooks/use-now.ts

@@ -0,0 +1,31 @@
+import { useEffect, useState } from 'react'
+
+interface UseNowOptions {
+  enabled?: boolean
+  intervalMs?: number
+}
+
+export function useNow(options: UseNowOptions = {}): number | null {
+  const { enabled = true, intervalMs = 60_000 } = options
+  const [now, setNow] = useState<number | null>(null)
+
+  useEffect(() => {
+    const frame = window.requestAnimationFrame(() => {
+      setNow(Date.now())
+    })
+    if (!enabled || intervalMs <= 0) {
+      return () => window.cancelAnimationFrame(frame)
+    }
+
+    const timer = window.setInterval(() => {
+      setNow(Date.now())
+    }, intervalMs)
+
+    return () => {
+      window.cancelAnimationFrame(frame)
+      window.clearInterval(timer)
+    }
+  }, [enabled, intervalMs])
+
+  return now
+}

package/src/hooks/use-openclaw-gateway.ts

@@ -2,6 +2,7 @@
 
 import { useCallback, useEffect, useRef, useState } from 'react'
 import { api } from '@/lib/api-client'
+import { errorMessage } from '@/lib/shared-utils'
 import { useWs } from './use-ws'
 
 /** Call an OpenClaw gateway RPC method via the proxy route. */
@@ -27,7 +28,7 @@ export function useOpenClawRpc<T = unknown>(method: string | null, params?: unkn
         setData(res.result)
       }
     } catch (err: unknown) {
-      setError(err instanceof Error ? err.message : String(err))
+      setError(errorMessage(err))
     } finally {
       setLoading(false)
     }

package/src/instrumentation.ts

@@ -1,16 +1,26 @@
+import { hmrSingleton } from '@/lib/shared-utils'
+
 export async function register() {
   if (process.env.NEXT_RUNTIME === 'nodejs') {
+    const isWorkerOnly = process.env.SWARMCLAW_WORKER_ONLY === '1'
     const { initWsServer, closeWsServer } = await import('./lib/server/ws-hub')
     const { ensureDaemonStarted } = await import('./lib/server/daemon-state')
-    ensureDaemonStarted('instrumentation')
-
-    initWsServer()
+    
+    // In worker-only mode, we FORCE the daemon to start, but skip the WebSocket listener
+    if (isWorkerOnly) {
+      console.log('[instrumentation] Booting in WORKER ONLY mode')
+      ensureDaemonStarted('worker-boot')
+    } else {
+      // In normal mode, we start the WS server, and conditionally start the daemon if autostart allows
+      initWsServer()
+      ensureDaemonStarted('instrumentation')
+    }
 
     // Graceful shutdown: stop background services and close WS connections
-    const shutdownState = (
-      (globalThis as Record<string, unknown>).__swarmclaw_shutdown_state__
-      ??= { registered: false, shuttingDown: false }
-    ) as { registered: boolean; shuttingDown: boolean }
+    const shutdownState = hmrSingleton('__swarmclaw_shutdown_state__', () => ({
+      registered: false,
+      shuttingDown: false,
+    }))
 
     const shutdown = async (signal: string) => {
       if (shutdownState.shuttingDown) return
@@ -22,7 +32,9 @@ export async function register() {
       } catch (err) {
         console.error('[instrumentation] Failed to stop daemon during shutdown:', err)
       }
-      await closeWsServer()
+      if (!isWorkerOnly) {
+        await closeWsServer()
+      }
       process.exit(0)
     }
     if (!shutdownState.registered) {