@object-ui/app-shell 6.2.3 → 7.0.0

package/dist/hooks/useConsoleActionRuntime.js

@@ -0,0 +1,560 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * useConsoleActionRuntime — the reusable console "action runtime".
+ *
+ * ObjectView historically owned all the wiring needed to make schema-driven
+ * `action:button`s actually *do* something: confirm/param/result dialogs, an
+ * authenticated API caller, flow + server-action handlers, SPA navigation, and
+ * the paused screen-flow runner. SDUI pages (PageView) render the same
+ * `action:button` widgets but lacked that runtime, so their actions could not
+ * collect params, call authenticated APIs, show result dialogs, refresh, or
+ * navigate (#1605).
+ *
+ * This hook extracts that generic wiring so BOTH ObjectView and PageView can
+ * mount it. It owns the dialog state and handlers, and returns:
+ *   - `actionProviderProps` — spread onto `<ActionProvider>`;
+ *   - `dialogs` — the confirm/param/result/flow dialogs to render inside it;
+ *   - the individual handlers (e.g. `confirmHandler`, `toastHandler`) so a
+ *     caller like ObjectView can also feed them into `useObjectActions`.
+ *
+ * `objectName` is optional: pages run global (or action-scoped) actions, while
+ * ObjectView passes its current object so object-scoped actions resolve their
+ * target + param defaults.
+ */
+import { useCallback, useMemo, useRef, useState } from 'react';
+import { useNavigate } from 'react-router-dom';
+import { useAuth, createAuthenticatedFetch } from '@object-ui/auth';
+import { useObjectLabel } from '@object-ui/i18n';
+import { ActionProvider, useGlobalUndo } from '@object-ui/react';
+import { toast } from 'sonner';
+import { ActionConfirmDialog } from '../views/ActionConfirmDialog';
+import { ActionParamDialog } from '../views/ActionParamDialog';
+import { ActionResultDialog } from '../views/ActionResultDialog';
+import { FlowRunner } from '../views/FlowRunner';
+import { resolveActionParams } from '../utils/resolveActionParams';
+const FALLBACK_USER = { id: 'current-user', name: 'Demo User', isPlatformAdmin: false };
+export function useConsoleActionRuntime(opts) {
+    const { dataSource, objects, objectName, onRefresh } = opts;
+    const navigate = useNavigate();
+    const { user, activeOrganization } = useAuth();
+    const { fieldLabel, fieldOptionLabel, actionParamText, actionParamOptionLabel, actionDescription } = useObjectLabel();
+    const objectDef = useMemo(() => (objectName ? objects?.find((o) => o.name === objectName) : undefined), [objects, objectName]);
+    // Object name used for API paths / generic CRUD. Falls back to the action's
+    // own `objectName` (set per call below) or 'global'.
+    const objApiName = objectName || objectDef?.name;
+    const refresh = useCallback(() => { onRefresh?.(); }, [onRefresh]);
+    // Global undo/redo (Ctrl+Z / Ctrl+Shift+Z), backed by the dataSource. The
+    // success toast's "Undo" button calls `undoCtl.undo()` for `undoable` actions
+    // (the ActionRunner has already pushed the operation onto the UndoManager).
+    const undoCtl = useGlobalUndo({
+        dataSource,
+        onUndo: () => { refresh(); toast.success('Change undone'); },
+    });
+    // Promise-based confirm / param / result dialogs.
+    const [confirmState, setConfirmState] = useState({ open: false, message: '' });
+    const [paramState, setParamState] = useState({ open: false, params: [] });
+    const [resultDialogState, setResultDialogState] = useState({ open: false });
+    // A paused `screen`-node flow awaiting user input.
+    const [screenFlow, setScreenFlow] = useState(null);
+    // Guards against double-firing a server action (slow SSO handoff, etc.).
+    const serverActionInFlight = useRef(new Set());
+    const resultDialogHandler = useCallback((spec, data) => new Promise((resolve) => {
+        setResultDialogState({ open: true, spec, data, resolve });
+    }), []);
+    const confirmHandler = useCallback((message, options) => {
+        return new Promise((resolve) => {
+            setConfirmState({ open: true, message, options, resolve });
+        });
+    }, []);
+    const paramCollectionHandler = useCallback((params, action) => {
+        return new Promise((resolve) => {
+            // List_item actions stash the row record under params._rowRecord (see
+            // ObjectGrid → onRowAction). Pull it out so resolveActionParams can
+            // pre-fill `defaultFromRow` params from the row's current values.
+            const row = action?.params && !Array.isArray(action.params)
+                ? action.params._rowRecord
+                : undefined;
+            const resolved = resolveActionParams(params, {
+                objectName: objectName || objectDef?.name || '',
+                objects: objects || [],
+                fieldLabel,
+                fieldOptionLabel,
+                row,
+            });
+            // Localize each param's label/placeholder/helpText via the
+            // `_actions.<action>.params.<param>.<attr>` convention.
+            const objForI18n = objectName || objectDef?.name;
+            const localized = resolved.map((p) => ({
+                ...p,
+                label: actionParamText(objForI18n, action?.name, p.name, 'label', p.label) ?? p.label,
+                placeholder: actionParamText(objForI18n, action?.name, p.name, 'placeholder', p.placeholder) ?? p.placeholder,
+                helpText: actionParamText(objForI18n, action?.name, p.name, 'helpText', p.helpText) ?? p.helpText,
+                options: Array.isArray(p.options)
+                    ? p.options.map((o) => ({ ...o, label: actionParamOptionLabel(objForI18n, action?.name, p.name, o.value, o.label) }))
+                    : p.options,
+            }));
+            setParamState({
+                open: true,
+                params: localized,
+                title: action?.label || action?.title,
+                description: actionDescription(objForI18n, action?.name, action?.description),
+                resolve,
+            });
+        });
+    }, [objectName, objectDef, objects, fieldLabel, fieldOptionLabel, actionParamText, actionParamOptionLabel]);
+    const currentUser = user
+        ? { id: user.id, name: user.name, avatar: user.image, isPlatformAdmin: user?.isPlatformAdmin ?? false }
+        : FALLBACK_USER;
+    const toastHandler = useCallback((message, options) => {
+        if (options?.type === 'error') {
+            toast.error(message);
+            return;
+        }
+        if (options?.undo) {
+            toast.success(message, {
+                duration: options.duration,
+                action: { label: options.undo.label || 'Undo', onClick: () => { void undoCtl.undo(); } },
+            });
+            return;
+        }
+        toast.success(message, { duration: options?.duration });
+    }, [undoCtl]);
+    const navigateHandler = useCallback((url, options) => {
+        if (options?.external || options?.newTab) {
+            window.open(url, '_blank', 'noopener,noreferrer');
+        }
+        else {
+            navigate(url);
+        }
+    }, [navigate]);
+    // Authenticated fetch for direct backend calls. Declared before apiHandler.
+    const authFetch = useMemo(() => createAuthenticatedFetch(), []);
+    const apiHandler = useCallback(async (action) => {
+        try {
+            const target = action.target || action.name;
+            const params = action.params || {};
+            // Absolute HTTP target — bypass dataSource and call the API directly
+            // through the authenticated fetch wrapper (Bearer + X-Tenant-ID +
+            // same-origin cookies). The canonical path for schema actions on
+            // managed-by tables and global page actions.
+            const targetStr = typeof target === 'string' ? target : '';
+            const isAbsolute = targetStr.startsWith('/') || /^https?:\/\//i.test(targetStr);
+            if (isAbsolute) {
+                const baseUrl = import.meta.env.VITE_SERVER_URL || '';
+                const rawParams = { ...params };
+                const rowRecord = rawParams._rowRecord;
+                delete rawParams._rowRecord;
+                // Interpolate `{field}` tokens in the target URL from the row record.
+                let resolvedTarget = targetStr;
+                if (rowRecord && /\{[a-z_][a-z0-9_]*\}/i.test(resolvedTarget)) {
+                    resolvedTarget = resolvedTarget.replace(/\{([a-z_][a-z0-9_]*)\}/gi, (_, k) => {
+                        const v = rowRecord[k];
+                        return v == null ? '' : encodeURIComponent(String(v));
+                    });
+                }
+                const url = resolvedTarget.startsWith('http') ? resolvedTarget : `${baseUrl}${resolvedTarget}`;
+                const wrap = action.bodyShape && typeof action.bodyShape === 'object' && action.bodyShape.wrap
+                    ? action.bodyShape.wrap
+                    : undefined;
+                const body = wrap ? { [wrap]: rawParams } : { ...rawParams };
+                if (rowRecord && action.recordIdParam) {
+                    const rowField = action.recordIdField || 'id';
+                    const rowValue = rowRecord[rowField];
+                    if (rowValue != null)
+                        body[action.recordIdParam] = rowValue;
+                }
+                const isAuthOrgEndpoint = /\/api\/v1\/auth\//.test(resolvedTarget);
+                if (isAuthOrgEndpoint && !body.organizationId && activeOrganization?.id) {
+                    body.organizationId = activeOrganization.id;
+                }
+                if (action.bodyExtra && typeof action.bodyExtra === 'object') {
+                    Object.assign(body, action.bodyExtra);
+                }
+                const method = (action.method || 'POST').toUpperCase();
+                const init = {
+                    method,
+                    headers: { 'Content-Type': 'application/json' },
+                    credentials: 'include',
+                };
+                if (method !== 'GET' && method !== 'DELETE') {
+                    init.body = JSON.stringify(body);
+                }
+                const res = await authFetch(url, init);
+                if (!res.ok) {
+                    let detail = `HTTP ${res.status}`;
+                    try {
+                        const j = await res.json();
+                        detail = j?.error || j?.message || detail;
+                    }
+                    catch { /* response body not JSON */ }
+                    return { success: false, error: detail };
+                }
+                const data = await res.json().catch(() => ({}));
+                if (action.refreshAfter !== false)
+                    refresh();
+                return { success: true, data, reload: action.refreshAfter !== false };
+            }
+            // Generic list-level API handler: update/execute via dataSource. Only
+            // meaningful when an object context exists (ObjectView); pages without an
+            // object resolve their actions through the absolute path above.
+            const obj = action.objectName || objApiName;
+            // The row record is stashed under `_rowRecord` for list_item actions —
+            // separate it from the field values, and resolve the record id from it
+            // (the action's static params carry the field changes, not the id).
+            const rowRecord = params._rowRecord;
+            const fields = { ...params };
+            delete fields._rowRecord;
+            const recId = fields.recordId ?? rowRecord?.[action.recordIdField || 'id'];
+            delete fields.recordId;
+            // Constant body fields merged last (overrides user params), matching the
+            // absolute-HTTP branch and the spec's documented `bodyExtra` semantics.
+            // Without this a pure-confirmation action (confirmText, no params array)
+            // carries its mutation only in bodyExtra, leaving `fields` empty so the
+            // update below is skipped and nothing is persisted.
+            if (action.bodyExtra && typeof action.bodyExtra === 'object') {
+                Object.assign(fields, action.bodyExtra);
+            }
+            if (obj && typeof dataSource?.execute === 'function') {
+                await dataSource.execute(obj, target, fields);
+            }
+            else if (obj && recId && Object.keys(fields).length > 0 && typeof dataSource?.update === 'function') {
+                await dataSource.update(obj, recId, fields);
+            }
+            // Undoable single-record update: capture the prior values of the changed
+            // fields from the row record so the success toast can offer "Undo".
+            let undo;
+            if (action.undoable && obj && recId && rowRecord && Object.keys(fields).length > 0
+                && typeof dataSource?.update === 'function') {
+                const undoData = {};
+                for (const k of Object.keys(fields))
+                    undoData[k] = rowRecord[k] ?? null;
+                undo = {
+                    id: `undo-${obj}-${recId}-${Date.now()}`,
+                    type: 'update',
+                    objectName: obj,
+                    recordId: String(recId),
+                    timestamp: Date.now(),
+                    description: action.label || `Undo ${obj}`,
+                    undoData,
+                    redoData: { ...fields },
+                };
+            }
+            const shouldRefresh = action.refreshAfter !== false;
+            if (shouldRefresh)
+                refresh();
+            return { success: true, reload: shouldRefresh, undo };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    }, [dataSource, objApiName, authFetch, activeOrganization, refresh]);
+    // Flow action handler — POST to /api/v1/automation/{name}/trigger.
+    // `context` is the shared ActionRunner context (registered handlers are
+    // invoked as `handler(action, runnerContext)`).
+    const flowHandler = useCallback(async (action, context) => {
+        const flowName = action.target || action.name;
+        if (!flowName) {
+            return { success: false, error: 'No flow target provided for flow action' };
+        }
+        try {
+            const baseUrl = import.meta.env.VITE_SERVER_URL || '';
+            const params = { ...(action.params || {}) };
+            const rowRecord = params._rowRecord;
+            delete params._rowRecord;
+            let recordId = params.recordId ?? rowRecord?.id;
+            // list_toolbar invocations carry no `_rowRecord` — fall back to the
+            // grid's checkbox selection, which ObjectGrid publishes into the runner
+            // context as `selectedRecords`. Flows take a single `recordId` input
+            // variable, so a multi-row selection is ambiguous: block with a message
+            // instead of triggering a run that fails at its first record-bound node.
+            if (recordId == null) {
+                const selected = Array.isArray(context?.selectedRecords) ? context.selectedRecords : [];
+                if (selected.length === 1) {
+                    recordId = selected[0]?.id;
+                }
+                else if (selected.length > 1) {
+                    return { success: false, error: 'This flow runs on a single record — select exactly one row.' };
+                }
+            }
+            if (recordId != null && params.recordId == null)
+                params.recordId = recordId;
+            const res = await authFetch(`${baseUrl}/api/v1/automation/${encodeURIComponent(flowName)}/trigger`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    recordId,
+                    objectName: action.objectName || objApiName,
+                    params,
+                }),
+            });
+            const json = await res.json().catch(() => null);
+            if (!res.ok || (json && json.success === false)) {
+                const errMsg = json?.error || `Flow "${flowName}" failed (HTTP ${res.status})`;
+                return { success: false, error: errMsg };
+            }
+            // Screen-flow runtime: paused at a `screen` node awaiting input — open
+            // the FlowRunner to render the form + resume. Refresh happens on complete.
+            const data = json?.data ?? {};
+            if (data.status === 'paused' && data.screen) {
+                setScreenFlow({ flowName, runId: data.runId, screen: data.screen });
+                // The action only OPENED the wizard — it hasn't completed. Suppress the
+                // action-level success toast; the flow-runner owns completion messaging.
+                return { success: true, silent: true };
+            }
+            const shouldRefresh = action.refreshAfter !== false;
+            if (shouldRefresh)
+                refresh();
+            return { success: true, data: json?.data, reload: shouldRefresh };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    }, [authFetch, objApiName, refresh]);
+    // Server-side action handler — POST to /api/v1/actions/{object}/{action}.
+    // `context` is the shared ActionRunner context (registered handlers are
+    // invoked as `handler(action, runnerContext)`).
+    const serverActionHandler = useCallback(async (action, context) => {
+        const targetName = action.target || action.name;
+        if (!targetName) {
+            return { success: false, error: 'No action target provided' };
+        }
+        const params = (action.params && !Array.isArray(action.params))
+            ? { ...action.params }
+            : {};
+        const _rowRecord = params._rowRecord;
+        delete params._rowRecord;
+        const recordIdField = action.recordIdField || 'id';
+        let resolvedRecordId = params.recordId ?? _rowRecord?.[recordIdField];
+        // Same list_toolbar fallback as flowHandler: no `_rowRecord` means the
+        // action came from the toolbar — resolve the recordId from the grid's
+        // checkbox selection (published as `selectedRecords`). Multi-select is
+        // ambiguous for a single-record action, so block with a message.
+        if (resolvedRecordId == null) {
+            const selected = Array.isArray(context?.selectedRecords) ? context.selectedRecords : [];
+            if (selected.length === 1) {
+                resolvedRecordId = selected[0]?.[recordIdField];
+            }
+            else if (selected.length > 1) {
+                // The runner's post-execution hook surfaces `error` as a toast.
+                return { success: false, error: 'This action runs on a single record — select exactly one row.' };
+            }
+        }
+        // Re-entrancy guard.
+        const inflightKey = `${targetName}:${resolvedRecordId ?? ''}`;
+        if (serverActionInFlight.current.has(inflightKey)) {
+            return { success: false, error: 'Action already in progress' };
+        }
+        serverActionInFlight.current.add(inflightKey);
+        // Popup-blocker workaround: pre-open about:blank synchronously before the
+        // await so the user-gesture context is preserved.
+        let preOpenedTab = null;
+        if (action.opensInNewTab) {
+            try {
+                preOpenedTab = window.open('about:blank', '_blank');
+                if (preOpenedTab) {
+                    preOpenedTab.document.write('<!doctype html><meta charset="utf-8"><title>正在打开… Opening…</title><body style="margin:0;font-family:system-ui,sans-serif;display:flex;flex-direction:column;align-items:center;justify-content:center;height:100vh;gap:16px;color:#4b5563"><div style="width:28px;height:28px;border:3px solid #e5e7eb;border-top-color:#6366f1;border-radius:50%;animation:s .8s linear infinite"></div><div>正在为你打开环境…</div><style>@keyframes s{to{transform:rotate(360deg)}}</style></body>');
+                    preOpenedTab.document.close();
+                }
+            }
+            catch {
+                preOpenedTab = null;
+            }
+        }
+        try {
+            const baseUrl = import.meta.env.VITE_SERVER_URL || '';
+            // ── Zero-roundtrip fast path ────────────────────────────────────────
+            // `newTabUrl` names a GET endpoint that performs ALL auth/authz itself
+            // (e.g. /sso-open re-runs every check the POST half would have done),
+            // so the POST round trip would add nothing but click latency. Drive the
+            // pre-opened tab there immediately — the spinner page stays painted
+            // until the (possibly slow) endpoint commits its redirect.
+            const newTabUrl = typeof action.newTabUrl === 'string' ? action.newTabUrl : '';
+            if (action.opensInNewTab && newTabUrl) {
+                if (resolvedRecordId == null) {
+                    if (preOpenedTab) {
+                        try {
+                            preOpenedTab.close();
+                        }
+                        catch { /* ignore */ }
+                    }
+                    return { success: false, error: 'This action runs on a single record — no record id available.' };
+                }
+                // Absolute URL required: the pre-opened tab is an about:blank document,
+                // so a bare-relative href has no reliable resolution base.
+                const directUrl = `${baseUrl || window.location.origin}${newTabUrl.replace('{recordId}', encodeURIComponent(String(resolvedRecordId)))}`;
+                if (preOpenedTab) {
+                    try {
+                        preOpenedTab.location.href = directUrl;
+                    }
+                    catch {
+                        try {
+                            preOpenedTab.close();
+                        }
+                        catch { /* ignore */ }
+                        window.location.href = directUrl;
+                    }
+                }
+                else {
+                    let popup = null;
+                    try {
+                        popup = window.open(directUrl, '_blank');
+                    }
+                    catch {
+                        popup = null;
+                    }
+                    if (!popup) {
+                        toast('浏览器拦截了弹窗 / Popup blocked', {
+                            description: '点击在新标签页打开环境',
+                            action: { label: '打开环境', onClick: () => { try {
+                                    window.open(directUrl, '_blank');
+                                }
+                                catch {
+                                    window.location.href = directUrl;
+                                } } },
+                            duration: 10000,
+                        });
+                    }
+                }
+                if (action.refreshAfter === true)
+                    refresh();
+                return { success: true };
+            }
+            const obj = action.objectName || objApiName || 'global';
+            const res = await authFetch(`${baseUrl}/api/v1/actions/${encodeURIComponent(obj)}/${encodeURIComponent(targetName)}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ recordId: resolvedRecordId, params }),
+            });
+            const json = await res.json().catch(() => null);
+            if (!res.ok || (json && json.success === false)) {
+                const errMsg = json?.error || `Action "${targetName}" failed (HTTP ${res.status})`;
+                if (preOpenedTab) {
+                    try {
+                        preOpenedTab.close();
+                    }
+                    catch { /* ignore */ }
+                }
+                toast.error(errMsg);
+                return { success: false, error: errMsg };
+            }
+            const shouldRefresh = action.refreshAfter !== false;
+            if (shouldRefresh)
+                refresh();
+            const data = json?.data;
+            const redirectUrl = (data && typeof data === 'object' && typeof data.redirectUrl === 'string')
+                ? data.redirectUrl
+                : null;
+            if (redirectUrl) {
+                if (preOpenedTab) {
+                    try {
+                        preOpenedTab.location.href = redirectUrl;
+                    }
+                    catch {
+                        try {
+                            preOpenedTab.close();
+                        }
+                        catch { /* ignore */ }
+                        window.location.href = redirectUrl;
+                    }
+                }
+                else {
+                    let popup = null;
+                    try {
+                        popup = window.open(redirectUrl, '_blank');
+                    }
+                    catch {
+                        popup = null;
+                    }
+                    if (!popup) {
+                        toast('浏览器拦截了弹窗 / Popup blocked', {
+                            description: '点击在新标签页打开环境',
+                            action: { label: '打开环境', onClick: () => { try {
+                                    window.open(redirectUrl, '_blank');
+                                }
+                                catch {
+                                    window.location.href = redirectUrl;
+                                } } },
+                            duration: 10000,
+                        });
+                    }
+                }
+            }
+            else if (preOpenedTab) {
+                try {
+                    preOpenedTab.close();
+                }
+                catch { /* ignore */ }
+            }
+            return { success: true, data, reload: shouldRefresh };
+        }
+        catch (error) {
+            if (preOpenedTab) {
+                try {
+                    preOpenedTab.close();
+                }
+                catch { /* ignore */ }
+            }
+            const msg = error.message;
+            toast.error(msg);
+            return { success: false, error: msg };
+        }
+        finally {
+            serverActionInFlight.current.delete(inflightKey);
+        }
+    }, [authFetch, objApiName, refresh]);
+    const actionProviderProps = useMemo(() => ({
+        context: {
+            ...(objectName ? { objectName } : {}),
+            user: currentUser,
+            // Backend origin — lets `type: 'url'` actions issue full-page
+            // navigations to API endpoints across origins in dev.
+            apiBase: import.meta.env?.VITE_SERVER_URL || '',
+            activeOrganization: activeOrganization
+                ? { id: activeOrganization.id, slug: activeOrganization.slug, name: activeOrganization.name }
+                : null,
+        },
+        onConfirm: confirmHandler,
+        onToast: toastHandler,
+        onNavigate: navigateHandler,
+        onParamCollection: paramCollectionHandler,
+        onResultDialog: resultDialogHandler,
+        handlers: { api: apiHandler, flow: flowHandler, script: serverActionHandler, modal: serverActionHandler },
+    }), [
+        objectName, currentUser, activeOrganization, confirmHandler, toastHandler,
+        navigateHandler, paramCollectionHandler, resultDialogHandler, apiHandler,
+        flowHandler, serverActionHandler,
+    ]);
+    const dialogs = (_jsxs(_Fragment, { children: [_jsx(ActionConfirmDialog, { state: confirmState, onOpenChange: (open) => {
+                    if (!open)
+                        setConfirmState({ open: false, message: '' });
+                } }), _jsx(ActionParamDialog, { state: paramState, onOpenChange: (open) => {
+                    if (!open)
+                        setParamState({ open: false, params: [] });
+                } }), _jsx(ActionResultDialog, { state: resultDialogState, onAcknowledge: () => {
+                    resultDialogState.resolve?.();
+                    setResultDialogState({ open: false });
+                } }), _jsx(FlowRunner, { state: screenFlow, authFetch: authFetch, baseUrl: import.meta.env.VITE_SERVER_URL || '', dataSource: dataSource, objects: objects, onClose: () => setScreenFlow(null), onComplete: () => { setScreenFlow(null); refresh(); } })] }));
+    return {
+        confirmHandler,
+        toastHandler,
+        navigateHandler,
+        paramCollectionHandler,
+        resultDialogHandler,
+        apiHandler,
+        flowHandler,
+        serverActionHandler,
+        authFetch,
+        actionProviderProps,
+        dialogs,
+    };
+}
+/**
+ * ConsoleActionRuntimeProvider — convenience wrapper for callers (e.g. PageView)
+ * that only need to wrap a subtree in the console action runtime. ObjectView
+ * uses {@link useConsoleActionRuntime} directly because it also feeds the
+ * handlers into `useObjectActions`.
+ */
+export function ConsoleActionRuntimeProvider({ children, ...opts }) {
+    const runtime = useConsoleActionRuntime(opts);
+    return (_jsxs(ActionProvider, { ...runtime.actionProviderProps, children: [children, runtime.dialogs] }));
+}

package/dist/hooks/useConversationList.js

@@ -7,7 +7,18 @@
  * `req.user.userId` server-side so we just forward credentials.
  */
 import { useCallback, useEffect, useState } from 'react';
-function extractPreview(messages) {
+const PLACEHOLDER_TITLES = new Set([
+    'new chat',
+    'new conversation',
+    'untitled',
+    '新对话',
+]);
+function isPlaceholderTitle(title) {
+    const normalized = title?.trim().toLowerCase();
+    return !normalized || PLACEHOLDER_TITLES.has(normalized);
+}
+function extractPreview(row) {
+    const messages = row.messages;
     if (!messages || messages.length === 0)
         return undefined;
     // Prefer the most recent user message, fall back to last message.
@@ -25,6 +36,18 @@ function extractPreview(messages) {
 function stringifyContent(content) {
     if (typeof content === 'string')
         return content.slice(0, 140);
+    if (content &&
+        typeof content === 'object' &&
+        'text' in content &&
+        typeof content.text === 'string') {
+        return content.text.slice(0, 140);
+    }
+    if (content &&
+        typeof content === 'object' &&
+        'parts' in content &&
+        Array.isArray(content.parts)) {
+        return stringifyContent(content.parts);
+    }
     if (Array.isArray(content)) {
         const text = content
             .map((p) => {
@@ -41,15 +64,27 @@ function stringifyContent(content) {
     return undefined;
 }
 function normalize(row) {
+    const title = row.title?.trim();
+    const preview = extractPreview(row) ?? stringifyContent(row.preview);
     return {
         id: row.id,
-        title: row.title,
+        title: isPlaceholderTitle(title) ? undefined : title,
         agentId: row.agentId,
         createdAt: row.createdAt,
         updatedAt: row.updatedAt,
-        preview: extractPreview(row.messages),
+        preview,
     };
 }
+async function fetchConversationDetail(apiBase, id) {
+    const res = await fetch(`${apiBase}/conversations/${encodeURIComponent(id)}`, {
+        credentials: 'include',
+    });
+    if (!res.ok)
+        return undefined;
+    const body = (await res.json());
+    const row = 'conversation' in body && body.conversation ? body.conversation : body;
+    return normalize(row);
+}
 export function useConversationList(options) {
     const { userId, apiBase, limit = 50, refreshKey } = options;
     const [conversations, setConversations] = useState([]);
@@ -111,6 +146,29 @@ export function useConversationList(options) {
                     .map(normalize)
                     .sort((a, b) => (b.updatedAt ?? '').localeCompare(a.updatedAt ?? ''));
                 setConversations(sorted);
+                const needsPreview = sorted
+                    .filter((row) => !row.title && !row.preview)
+                    .slice(0, 20);
+                if (needsPreview.length > 0) {
+                    const details = await Promise.all(needsPreview.map((row) => fetchConversationDetail(apiBase, row.id).catch(() => undefined)));
+                    if (cancelled)
+                        return;
+                    const byId = new Map(details
+                        .filter((row) => Boolean(row?.preview || row?.title))
+                        .map((row) => [row.id, row]));
+                    if (byId.size > 0) {
+                        setConversations((current) => current.map((row) => {
+                            const detail = byId.get(row.id);
+                            if (!detail)
+                                return row;
+                            return {
+                                ...row,
+                                title: row.title ?? detail.title,
+                                preview: row.preview ?? detail.preview,
+                            };
+                        }));
+                    }
+                }
             }
             catch (err) {
                 if (cancelled)

package/dist/hooks/useHomeInbox.d.ts

@@ -0,0 +1,13 @@
+import type { ActivityItem } from '../layout/ActivityFeed';
+export interface HomeNotification {
+    id: string;
+    title: string;
+    actionUrl?: string;
+    createdAt?: string;
+}
+export interface HomeInboxData {
+    pendingApprovalsCount: number;
+    notifications: HomeNotification[];
+    activities: ActivityItem[];
+}
+export declare function useHomeInbox(limit?: number): HomeInboxData;