@elizaos/ui 2.0.0-alpha.85 → 2.0.0-beta.2

package/hooks/index.js

@@ -0,0 +1,19 @@
+export * from "./useActivityEvents.js";
+export * from "./useAutomationDeepLink.js";
+export * from "./useBugReport.js";
+export * from "./useChatAvatarVoiceBridge.js";
+export * from "./useConnectorAccounts.js";
+export * from "./useConnectorSendAsAccount.js";
+export * from "./useContextMenu.js";
+export * from "./useDocumentVisibility.js";
+export { COMMON_SHORTCUTS, useShortcutsHelp } from "./useKeyboardShortcuts.js";
+export * from "./useLinkedSidebarSelection.js";
+export * from "./useMediaQuery.js";
+export * from "./useRenderGuard.js";
+export * from "./useRuntimeMode.js";
+export * from "./useSignalPairing.js";
+export * from "./useStreamPopoutNavigation.js";
+export * from "./useTimeout.js";
+export * from "./useVoiceChat.js";
+export * from "./useWhatsAppPairing.js";
+export * from "./useWorkflowGenerationState.js";

package/hooks/useAccounts.d.ts

@@ -0,0 +1,41 @@
+/**
+ * useAccounts — fetches and mutates the multi-account credential pool
+ * surfaced by `/api/accounts/*`.
+ *
+ * Polls `client.listAccounts()` on a configurable interval (default 30s)
+ * to keep usage / health rows fresh. Each mutation routes through the
+ * matching client method, applies an optimistic local update where safe,
+ * and reconciles after the server response. Failures bubble through
+ * `setActionNotice` so the parent settings panel can surface them.
+ */
+import type { LinkedAccountProviderId } from "@elizaos/shared";
+import type { AccountStrategy, AccountsListResponse, AccountTestResult } from "../api/client-agent";
+type ActionTone = "info" | "success" | "error";
+type ActionNoticeFn = (text: string, tone?: ActionTone, ttlMs?: number, once?: boolean, busy?: boolean) => void;
+export interface UseAccountsOptions {
+    setActionNotice?: ActionNoticeFn;
+    /** How often to refetch the full list. Defaults to 30s. */
+    pollMs?: number;
+}
+export interface UseAccountsResult {
+    data: AccountsListResponse | null;
+    loading: boolean;
+    saving: Set<string>;
+    refresh: () => Promise<void>;
+    createApiKey: (providerId: LinkedAccountProviderId, body: {
+        label: string;
+        apiKey: string;
+    }) => Promise<void>;
+    patch: (providerId: LinkedAccountProviderId, accountId: string, body: Partial<{
+        label: string;
+        enabled: boolean;
+        priority: number;
+    }>) => Promise<void>;
+    remove: (providerId: LinkedAccountProviderId, accountId: string) => Promise<void>;
+    test: (providerId: LinkedAccountProviderId, accountId: string) => Promise<AccountTestResult>;
+    refreshUsage: (providerId: LinkedAccountProviderId, accountId: string) => Promise<void>;
+    setStrategy: (providerId: LinkedAccountProviderId, strategy: AccountStrategy) => Promise<void>;
+}
+export declare function useAccounts(opts?: UseAccountsOptions): UseAccountsResult;
+export {};
+//# sourceMappingURL=useAccounts.d.ts.map

package/hooks/useAccounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAccounts.d.ts","sourceRoot":"","sources":["../../../../../src/hooks/useAccounts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAEV,uBAAuB,EACxB,MAAM,iBAAiB,CAAC;AAGzB,OAAO,KAAK,EAEV,eAAe,EACf,oBAAoB,EACpB,iBAAiB,EAClB,MAAM,qBAAqB,CAAC;AAE7B,KAAK,UAAU,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;AAE/C,KAAK,cAAc,GAAG,CACpB,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,UAAU,EACjB,KAAK,CAAC,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,OAAO,EACd,IAAI,CAAC,EAAE,OAAO,KACX,IAAI,CAAC;AAEV,MAAM,WAAW,kBAAkB;IACjC,eAAe,CAAC,EAAE,cAAc,CAAC;IACjC,2DAA2D;IAC3D,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACpB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,YAAY,EAAE,CACZ,UAAU,EAAE,uBAAuB,EACnC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,KACpC,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,KAAK,EAAE,CACL,UAAU,EAAE,uBAAuB,EACnC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,KACjE,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,MAAM,EAAE,CACN,UAAU,EAAE,uBAAuB,EACnC,SAAS,EAAE,MAAM,KACd,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,IAAI,EAAE,CACJ,UAAU,EAAE,uBAAuB,EACnC,SAAS,EAAE,MAAM,KACd,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAChC,YAAY,EAAE,CACZ,UAAU,EAAE,uBAAuB,EACnC,SAAS,EAAE,MAAM,KACd,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,WAAW,EAAE,CACX,UAAU,EAAE,uBAAuB,EACnC,QAAQ,EAAE,eAAe,KACtB,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB;AAmCD,wBAAgB,WAAW,CAAC,IAAI,GAAE,kBAAuB,GAAG,iBAAiB,CAuO5E"}

package/hooks/useAccounts.js

@@ -0,0 +1,250 @@
+/**
+ * useAccounts — fetches and mutates the multi-account credential pool
+ * surfaced by `/api/accounts/*`.
+ *
+ * Polls `client.listAccounts()` on a configurable interval (default 30s)
+ * to keep usage / health rows fresh. Each mutation routes through the
+ * matching client method, applies an optimistic local update where safe,
+ * and reconciles after the server response. Failures bubble through
+ * `setActionNotice` so the parent settings panel can surface them.
+ */
+import { useCallback, useEffect, useRef, useState } from "react";
+import { client } from "../api/index.js";
+const DEFAULT_POLL_MS = 30_000;
+function describeError(prefix, err) {
+    const message = err instanceof Error && err.message.trim()
+        ? `${prefix}: ${err.message}`
+        : prefix;
+    return message;
+}
+function replaceAccount(list, providerId, next) {
+    if (!list)
+        return list;
+    return {
+        providers: list.providers.map((p) => {
+            if (p.providerId !== providerId)
+                return p;
+            const existing = p.accounts.find((a) => a.id === next.id);
+            const merged = existing
+                ? { ...existing, ...next }
+                : { ...next, hasCredential: true };
+            return {
+                ...p,
+                accounts: p.accounts
+                    .map((a) => (a.id === next.id ? merged : a))
+                    .sort((a, b) => a.priority - b.priority),
+            };
+        }),
+    };
+}
+export function useAccounts(opts = {}) {
+    const { setActionNotice, pollMs = DEFAULT_POLL_MS } = opts;
+    const [data, setData] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [saving, setSaving] = useState(() => new Set());
+    const mountedRef = useRef(true);
+    const notify = useCallback((prefix, err) => {
+        setActionNotice?.(describeError(prefix, err), "error", 6000);
+    }, [setActionNotice]);
+    const refresh = useCallback(async () => {
+        try {
+            const next = await client.listAccounts();
+            if (!mountedRef.current)
+                return;
+            setData(next);
+        }
+        catch (err) {
+            if (!mountedRef.current)
+                return;
+            notify("Failed to load accounts", err);
+        }
+        finally {
+            if (mountedRef.current)
+                setLoading(false);
+        }
+    }, [notify]);
+    const markSaving = useCallback((id, on) => {
+        setSaving((prev) => {
+            const next = new Set(prev);
+            if (on)
+                next.add(id);
+            else
+                next.delete(id);
+            return next;
+        });
+    }, []);
+    const createApiKey = useCallback(async (providerId, body) => {
+        const key = `create:${providerId}`;
+        markSaving(key, true);
+        try {
+            const created = await client.createApiKeyAccount(providerId, body);
+            setData((prev) => {
+                if (!prev)
+                    return prev;
+                return {
+                    providers: prev.providers.map((p) => {
+                        if (p.providerId !== providerId)
+                            return p;
+                        const accounts = [
+                            ...p.accounts,
+                            { ...created, hasCredential: true },
+                        ].sort((a, b) => a.priority - b.priority);
+                        return { ...p, accounts };
+                    }),
+                };
+            });
+            await refresh();
+        }
+        catch (err) {
+            notify("Failed to create account", err);
+            throw err;
+        }
+        finally {
+            markSaving(key, false);
+        }
+    }, [markSaving, notify, refresh]);
+    const patch = useCallback(async (providerId, accountId, body) => {
+        markSaving(accountId, true);
+        const previous = data;
+        // Optimistic update for safe fields.
+        setData((prev) => {
+            if (!prev)
+                return prev;
+            return {
+                providers: prev.providers.map((p) => {
+                    if (p.providerId !== providerId)
+                        return p;
+                    return {
+                        ...p,
+                        accounts: p.accounts
+                            .map((a) => (a.id === accountId ? { ...a, ...body } : a))
+                            .sort((x, y) => x.priority - y.priority),
+                    };
+                }),
+            };
+        });
+        try {
+            const updated = await client.patchAccount(providerId, accountId, body);
+            setData((prev) => replaceAccount(prev, providerId, updated));
+        }
+        catch (err) {
+            setData(previous);
+            notify("Failed to update account", err);
+            throw err;
+        }
+        finally {
+            markSaving(accountId, false);
+        }
+    }, [data, markSaving, notify]);
+    const remove = useCallback(async (providerId, accountId) => {
+        markSaving(accountId, true);
+        try {
+            await client.deleteAccount(providerId, accountId);
+            setData((prev) => {
+                if (!prev)
+                    return prev;
+                return {
+                    providers: prev.providers.map((p) => p.providerId === providerId
+                        ? {
+                            ...p,
+                            accounts: p.accounts.filter((a) => a.id !== accountId),
+                        }
+                        : p),
+                };
+            });
+        }
+        catch (err) {
+            notify("Failed to delete account", err);
+            throw err;
+        }
+        finally {
+            markSaving(accountId, false);
+        }
+    }, [markSaving, notify]);
+    const test = useCallback(async (providerId, accountId) => {
+        markSaving(`test:${accountId}`, true);
+        try {
+            const result = await client.testAccount(providerId, accountId);
+            if (result.ok) {
+                setActionNotice?.(`Connection OK${typeof result.latencyMs === "number"
+                    ? ` (${result.latencyMs}ms)`
+                    : ""}`, "success", 3000);
+            }
+            else {
+                setActionNotice?.(`Connection failed: ${result.error ?? `HTTP ${result.status ?? "?"}`}`, "error", 6000);
+            }
+            return result;
+        }
+        catch (err) {
+            notify("Failed to test account", err);
+            throw err;
+        }
+        finally {
+            markSaving(`test:${accountId}`, false);
+        }
+    }, [markSaving, notify, setActionNotice]);
+    const refreshUsage = useCallback(async (providerId, accountId) => {
+        markSaving(`usage:${accountId}`, true);
+        try {
+            const result = await client.refreshAccountUsage(providerId, accountId);
+            setData((prev) => replaceAccount(prev, providerId, result.account));
+        }
+        catch (err) {
+            notify("Failed to refresh usage", err);
+            throw err;
+        }
+        finally {
+            markSaving(`usage:${accountId}`, false);
+        }
+    }, [markSaving, notify]);
+    const setStrategy = useCallback(async (providerId, strategy) => {
+        const key = `strategy:${providerId}`;
+        markSaving(key, true);
+        const previous = data;
+        setData((prev) => {
+            if (!prev)
+                return prev;
+            return {
+                providers: prev.providers.map((p) => p.providerId === providerId ? { ...p, strategy } : p),
+            };
+        });
+        try {
+            await client.patchProviderStrategy(providerId, { strategy });
+        }
+        catch (err) {
+            setData(previous);
+            notify("Failed to update rotation strategy", err);
+            throw err;
+        }
+        finally {
+            markSaving(key, false);
+        }
+    }, [data, markSaving, notify]);
+    useEffect(() => {
+        mountedRef.current = true;
+        void refresh();
+        return () => {
+            mountedRef.current = false;
+        };
+    }, [refresh]);
+    useEffect(() => {
+        if (pollMs <= 0)
+            return;
+        const id = setInterval(() => {
+            void refresh();
+        }, pollMs);
+        return () => clearInterval(id);
+    }, [pollMs, refresh]);
+    return {
+        data,
+        loading,
+        saving,
+        refresh,
+        createApiKey,
+        patch,
+        remove,
+        test,
+        refreshUsage,
+        setStrategy,
+    };
+}

package/hooks/useActivityEvents.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Hook that subscribes to WebSocket activity events and maintains a ring buffer
+ * of recent entries for the chat widget rail.
+ */
+export interface ActivityEvent {
+    id: string;
+    timestamp: number;
+    eventType: string;
+    sessionId?: string;
+    summary: string;
+}
+/**
+ * Subscribe to task/proactive websocket events plus assistant activity events,
+ * returning a capped list of recent activity entries.
+ */
+export declare function useActivityEvents(): {
+    readonly events: ActivityEvent[];
+    readonly clearEvents: () => void;
+};
+//# sourceMappingURL=useActivityEvents.d.ts.map

package/hooks/useActivityEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useActivityEvents.d.ts","sourceRoot":"","sources":["../../../../../src/hooks/useActivityEvents.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AA+CD;;;GAGG;AACH,wBAAgB,iBAAiB;;;EAqHhC"}

package/hooks/useActivityEvents.js

@@ -0,0 +1,145 @@
+/**
+ * Hook that subscribes to WebSocket activity events and maintains a ring buffer
+ * of recent entries for the chat widget rail.
+ */
+import { useCallback, useEffect, useRef, useState } from "react";
+import { client } from "../api/index.js";
+const RING_BUFFER_CAP = 200;
+let nextEventId = 0;
+function makeEventId() {
+    nextEventId += 1;
+    return `evt-${nextEventId}-${Date.now()}`;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function summarizeAssistantActivityEvent(data) {
+    if (data.type !== "agent_event" || data.stream !== "assistant") {
+        return null;
+    }
+    const payload = isRecord(data.payload) ? data.payload : null;
+    if (!payload) {
+        return null;
+    }
+    const source = typeof payload.source === "string" ? payload.source : "";
+    const text = typeof payload.text === "string" ? payload.text.trim().slice(0, 120) : "";
+    if (!text) {
+        return null;
+    }
+    switch (source) {
+        case "lifeops-reminder":
+            return { eventType: "reminder", summary: text };
+        case "lifeops-workflow":
+            return { eventType: "workflow", summary: text };
+        case "proactive-gm":
+        case "proactive-gn":
+            return { eventType: "check-in", summary: text };
+        case "proactive-nudge":
+            return { eventType: "nudge", summary: text };
+        default:
+            return null;
+    }
+}
+/**
+ * Subscribe to task/proactive websocket events plus assistant activity events,
+ * returning a capped list of recent activity entries.
+ */
+export function useActivityEvents() {
+    const [events, setEvents] = useState([]);
+    const bufferRef = useRef([]);
+    const flushHandleRef = useRef(null);
+    const cancelPendingFlush = useCallback(() => {
+        if (flushHandleRef.current === null) {
+            return;
+        }
+        cancelAnimationFrame(flushHandleRef.current);
+        flushHandleRef.current = null;
+    }, []);
+    const scheduleFlush = useCallback(() => {
+        if (flushHandleRef.current !== null) {
+            return;
+        }
+        flushHandleRef.current = requestAnimationFrame(() => {
+            flushHandleRef.current = null;
+            setEvents([...bufferRef.current]);
+        });
+    }, []);
+    const pushEvent = useCallback((entry) => {
+        const event = { ...entry, id: makeEventId() };
+        const buf = bufferRef.current;
+        buf.unshift(event);
+        if (buf.length > RING_BUFFER_CAP) {
+            buf.length = RING_BUFFER_CAP;
+        }
+        scheduleFlush();
+    }, [scheduleFlush]);
+    useEffect(() => {
+        const unbindPty = client.onWsEvent("pty-session-event", (data) => {
+            const eventType = (data.eventType ?? data.type);
+            const sessionId = data.sessionId;
+            const d = data.data;
+            let summary = eventType;
+            if (eventType === "task_registered") {
+                summary = `Task started: ${d?.label ?? sessionId ?? "unknown"}`;
+            }
+            else if (eventType === "task_complete" || eventType === "stopped") {
+                summary = `Task ${eventType === "task_complete" ? "completed" : "stopped"}`;
+            }
+            else if (eventType === "tool_running") {
+                const tool = d?.description ?? d?.toolName ?? "tool";
+                summary = `Running ${tool}`.slice(0, 80);
+            }
+            else if (eventType === "blocked") {
+                summary = "Waiting for input";
+            }
+            else if (eventType === "blocked_auto_resolved") {
+                summary = "Decision auto-approved";
+            }
+            else if (eventType === "escalation") {
+                summary = "Escalated — needs attention";
+            }
+            else if (eventType === "error") {
+                summary = "Error occurred";
+            }
+            pushEvent({
+                timestamp: Date.now(),
+                eventType,
+                sessionId: sessionId ?? undefined,
+                summary,
+            });
+        });
+        const unbindProactive = client.onWsEvent("proactive-message", (data) => {
+            const message = typeof data.message === "string"
+                ? data.message.slice(0, 120)
+                : "Proactive message";
+            pushEvent({
+                timestamp: Date.now(),
+                eventType: "proactive-message",
+                summary: message,
+            });
+        });
+        const unbindAgent = client.onWsEvent("agent_event", (data) => {
+            const activity = summarizeAssistantActivityEvent(data);
+            if (!activity) {
+                return;
+            }
+            pushEvent({
+                timestamp: Date.now(),
+                eventType: activity.eventType,
+                summary: activity.summary,
+            });
+        });
+        return () => {
+            unbindPty();
+            unbindProactive();
+            unbindAgent();
+            cancelPendingFlush();
+        };
+    }, [pushEvent, cancelPendingFlush]);
+    const clearEvents = useCallback(() => {
+        bufferRef.current = [];
+        cancelPendingFlush();
+        setEvents([]);
+    }, [cancelPendingFlush]);
+    return { events, clearEvents };
+}

package/hooks/useAuthStatus.d.ts

@@ -0,0 +1,49 @@
+/**
+ * useAuthStatus — monitors the current auth state via GET /api/auth/me.
+ *
+ * Returns a discriminated union that lets the shell decide whether to render
+ * the login gate or the main dashboard.
+ *
+ * Fail-closed: network errors are treated as server-unavailable so the app
+ * never leaks the dashboard, but also does not imply bad credentials.
+ *
+ * Call `refetch()` after login / logout to force a fresh check.
+ */
+import { type AuthAccessInfo, type AuthIdentity, type AuthSessionInfo } from "../api/auth-client";
+export type AuthStatusState = {
+    phase: "loading";
+} | {
+    phase: "authenticated";
+    identity: AuthIdentity;
+    session: AuthSessionInfo;
+    access: AuthAccessInfo;
+} | {
+    phase: "unauthenticated";
+    reason?: "remote_auth_required" | "remote_password_not_configured";
+    access?: AuthAccessInfo;
+} | {
+    phase: "server_unavailable";
+};
+interface UseAuthStatusOptions {
+    /**
+     * How often to re-check in the background (ms).
+     * Defaults to 5 minutes. Set to 0 to disable background polling.
+     */
+    pollIntervalMs?: number;
+    /**
+     * When true the hook will NOT start its initial fetch.
+     * Useful when the app knows auth is not yet relevant (e.g. during onboarding).
+     */
+    skip?: boolean;
+    /**
+     * Subscribe to the latest auth status without starting a fetch or poll loop.
+     * Useful for read-only shell metadata that should reuse the app-level check.
+     */
+    observeOnly?: boolean;
+}
+export declare function useAuthStatus(options?: UseAuthStatusOptions): {
+    state: AuthStatusState;
+    refetch: () => void;
+};
+export {};
+//# sourceMappingURL=useAuthStatus.d.ts.map

package/hooks/useAuthStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuthStatus.d.ts","sourceRoot":"","sources":["../../../../../src/hooks/useAuthStatus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,eAAe,EAErB,MAAM,oBAAoB,CAAC;AAE5B,MAAM,MAAM,eAAe,GACvB;IAAE,KAAK,EAAE,SAAS,CAAA;CAAE,GACpB;IACE,KAAK,EAAE,eAAe,CAAC;IACvB,QAAQ,EAAE,YAAY,CAAC;IACvB,OAAO,EAAE,eAAe,CAAC;IACzB,MAAM,EAAE,cAAc,CAAC;CACxB,GACD;IACE,KAAK,EAAE,iBAAiB,CAAC;IACzB,MAAM,CAAC,EAAE,sBAAsB,GAAG,gCAAgC,CAAC;IACnE,MAAM,CAAC,EAAE,cAAc,CAAC;CACzB,GACD;IAAE,KAAK,EAAE,oBAAoB,CAAA;CAAE,CAAC;AAEpC,UAAU,oBAAoB;IAC5B;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAuDD,wBAAgB,aAAa,CAAC,OAAO,GAAE,oBAAyB,GAAG;IACjE,KAAK,EAAE,eAAe,CAAC;IACvB,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAkCA"}

package/hooks/useAuthStatus.js

@@ -0,0 +1,90 @@
+/**
+ * useAuthStatus — monitors the current auth state via GET /api/auth/me.
+ *
+ * Returns a discriminated union that lets the shell decide whether to render
+ * the login gate or the main dashboard.
+ *
+ * Fail-closed: network errors are treated as server-unavailable so the app
+ * never leaks the dashboard, but also does not imply bad credentials.
+ *
+ * Call `refetch()` after login / logout to force a fresh check.
+ */
+import { useCallback, useEffect, useRef, useState } from "react";
+import { authMe, } from "../api/auth-client.js";
+const DEFAULT_POLL_INTERVAL_MS = 5 * 60 * 1000;
+const authStatusSubscribers = new Set();
+let authStatusSnapshot = { phase: "loading" };
+let authStatusFetch = null;
+function publishAuthStatus(state) {
+    authStatusSnapshot = state;
+    for (const subscriber of authStatusSubscribers) {
+        subscriber(state);
+    }
+}
+async function fetchAuthStatus() {
+    if (authStatusFetch)
+        return authStatusFetch;
+    publishAuthStatus(authStatusSnapshot.phase === "loading"
+        ? authStatusSnapshot
+        : { phase: "loading" });
+    authStatusFetch = authMe()
+        .then((result) => {
+        if (result.ok === true) {
+            publishAuthStatus({
+                phase: "authenticated",
+                identity: result.identity,
+                session: result.session,
+                access: result.access,
+            });
+        }
+        else if (result.ok === false) {
+            if (result.status === 503) {
+                publishAuthStatus({ phase: "server_unavailable" });
+            }
+            else {
+                publishAuthStatus({
+                    phase: "unauthenticated",
+                    reason: result.reason === "remote_auth_required" ||
+                        result.reason === "remote_password_not_configured"
+                        ? result.reason
+                        : undefined,
+                    access: result.access,
+                });
+            }
+        }
+    })
+        .finally(() => {
+        authStatusFetch = null;
+    });
+    return authStatusFetch;
+}
+export function useAuthStatus(options = {}) {
+    const { pollIntervalMs = DEFAULT_POLL_INTERVAL_MS, skip = false, observeOnly = false, } = options;
+    const [state, setState] = useState(authStatusSnapshot);
+    const mountedRef = useRef(true);
+    const fetch = useCallback(async () => {
+        if (!mountedRef.current)
+            return;
+        await fetchAuthStatus();
+    }, []);
+    useEffect(() => {
+        mountedRef.current = true;
+        authStatusSubscribers.add(setState);
+        setState(authStatusSnapshot);
+        if (!skip && !observeOnly)
+            void fetch();
+        return () => {
+            mountedRef.current = false;
+            authStatusSubscribers.delete(setState);
+        };
+    }, [skip, observeOnly, fetch]);
+    useEffect(() => {
+        if (skip || observeOnly || pollIntervalMs === 0)
+            return;
+        const id = setInterval(() => {
+            void fetch();
+        }, pollIntervalMs);
+        return () => clearInterval(id);
+    }, [skip, observeOnly, pollIntervalMs, fetch]);
+    return { state, refetch: fetch };
+}

package/hooks/useAutomationDeepLink.d.ts

@@ -0,0 +1,29 @@
+/**
+ * useAutomationDeepLink — hash-based deep-link state for the automations
+ * feed. Replaces the old `getPathForAutomationSubpage` /
+ * `syncAutomationSubpagePath` history-API helpers from AutomationsView.
+ *
+ * Hash format:
+ *   #automations                → list view
+ *   #automations/<workflowId>   → open WorkflowEditor for that id
+ *   #automations/task/<taskId>  → open TaskEditor for that id
+ *
+ * Hash is read on mount, written on open/close, and the hashchange event
+ * is observed so back/forward navigation works.
+ */
+export type AutomationDeepLink = {
+    kind: "list";
+} | {
+    kind: "workflow";
+    id: string;
+} | {
+    kind: "task";
+    id: string;
+};
+export declare function parseAutomationHash(hash: string): AutomationDeepLink;
+export declare function formatAutomationHash(link: AutomationDeepLink): string;
+export declare function useAutomationDeepLink(): {
+    link: AutomationDeepLink;
+    setLink: (next: AutomationDeepLink) => void;
+};
+//# sourceMappingURL=useAutomationDeepLink.d.ts.map

package/hooks/useAutomationDeepLink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAutomationDeepLink.d.ts","sourceRoot":"","sources":["../../../../../src/hooks/useAutomationDeepLink.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,MAAM,MAAM,kBAAkB,GAC1B;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAIjC,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,CASpE;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,kBAAkB,GAAG,MAAM,CASrE;AAED,wBAAgB,qBAAqB,IAAI;IACvC,IAAI,EAAE,kBAAkB,CAAC;IACzB,OAAO,EAAE,CAAC,IAAI,EAAE,kBAAkB,KAAK,IAAI,CAAC;CAC7C,CAyBA"}