Download web/src/assistant/NoticeCard.tsx from fsanyoto/loopable: direct link, hf CLI and curl.
- Browser
- Download file 10.3 kB
-
https://huggingface.co/spaces/fsanyoto/loopable/resolve/main/web/src/assistant/NoticeCard.tsx
- Command line
-
hf download hf://spaces/fsanyoto/loopable/web/src/assistant/NoticeCard.tsx
-
curl -L -o NoticeCard.tsx https://huggingface.co/spaces/fsanyoto/loopable/resolve/main/web/src/assistant/NoticeCard.tsx
10.3 kB
| import { useRef, useState } from "react"; | |
| import { AUTOMATION_OPEN_EVENT, VIEW_OPEN_EVENT, signal } from "../apiContract"; | |
| import { call as queryRequest } from "../query/queryApi"; | |
| import { agentAddressHash, dataAddressHash } from "../shell/nav"; | |
| import { retryEmit, routeForTarget } from "../shell/targetRoute"; | |
| import type { AssistantLogTurn } from "./AssistantPage"; | |
| import { interceptOpen, useOpenInPlace } from "./OpenInPlace"; | |
| const text = (value: unknown): string => typeof value === "string" ? value.trim() : ""; | |
| const record = (value: unknown): Record<string, unknown> => | |
| value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {}; | |
| export const REQUEST_STATE_LABELS = { | |
| submitted: "New", working: "With", "input-required": "Waiting for", completed: "Done", | |
| rejected: "Not now", canceled: "Withdrawn", failed: "Could not finish", "auth-required": "Sign in needed", | |
| } as const; | |
| type RequestState = keyof typeof REQUEST_STATE_LABELS; | |
| function requestState(payload: Record<string, unknown>): RequestState { | |
| const state = text(payload.state); | |
| if (Object.prototype.hasOwnProperty.call(REQUEST_STATE_LABELS, state)) return state as RequestState; | |
| if (["approved", "Resolved", "Closed by condition"].includes(state || text(payload.status))) return "completed"; | |
| if (state === "declined") return "rejected"; | |
| if (state === "pending" && payload.type === "access_request") return "input-required"; | |
| const metadata = record(payload.metadata); | |
| return text(metadata.assigned_to) || text(payload.assigned_to) || text(payload.owner) ? "working" : "submitted"; | |
| } | |
| /** Read the display state from C4 or legacy columns without changing either wire. */ | |
| export function requestStateLabel(value: unknown): string { | |
| const payload = record(value); | |
| const state = requestState(payload); | |
| const label = REQUEST_STATE_LABELS[state]; | |
| if (state !== "working" && state !== "input-required") return label; | |
| const metadata = record(payload.metadata); | |
| const assigned = metadata.assigned_to || payload.assigned_to || payload.owner; | |
| const people = assigned || payload.to || payload.recipients; | |
| const names = (Array.isArray(people) ? people : text(people).split(",")) | |
| .map((person) => text(record(person).name) || text(record(person).username) || text(person)).filter(Boolean); | |
| return `${label} ${[...new Set(names)].join(", ") || "someone"}`; | |
| } | |
| /** C4 extends the existing inbox kinds. Other payloads remain feed notices. */ | |
| export const INBOX_TYPES = ["assignment", "access_request", "share", "question", "approval"] as const; | |
| export type InboxAction = "approve" | "not_now"; | |
| type InboxState = "pending" | "approved" | "declined" | RequestState; | |
| export type InboxNotice = { | |
| type: typeof INBOX_TYPES[number]; requestId: string; sender: string; text: string; | |
| actions: InboxAction[]; state: InboxState; title?: string; stateLabel?: string; | |
| }; | |
| /** What the card shows: `outcome` is empty until the item is settled. */ | |
| export type InboxView = { busy: boolean; outcome: "" | "approved" | "declined"; problem: string }; | |
| const PROBLEM = "This choice could not be saved. Try again."; | |
| const OUTCOME_LINE = { approved: "Done", declined: "Not now" } as const; | |
| /** Reads a C6 payload with narrow guards. Returns null for a feed notice. */ | |
| export function readInboxNotice(payload: AssistantLogTurn["payload"]): InboxNotice | null { | |
| const row = record(payload); | |
| // A C4 task names its kind beside a `from` object. A feed notice also carries `kind` ("share"), | |
| // and reading that as an inbox request drops the feed card's Open link. | |
| const task = typeof row.from === "object" && row.from !== null; | |
| const type = INBOX_TYPES.find((kind) => kind === (row.type || (task ? row.kind : undefined))); | |
| if (!payload || !type) return null; | |
| const from = payload.sender; | |
| const sender = (typeof from === "object" && from ? text(from.name) || text(from.username) : text(from)) | |
| || text(record(row.from).person); | |
| const actions = Array.isArray(payload.actions) | |
| ? payload.actions.filter((action): action is InboxAction => action === "approve" || action === "not_now") : []; | |
| const state = payload.state === "approved" || payload.state === "declined" || payload.state === "pending" | |
| ? payload.state : requestState(row); | |
| return { type, requestId: text(payload.request_id) || text(row.id), sender, | |
| title: text(payload.title), text: text(payload.text) || text(payload.body), actions, state, | |
| stateLabel: requestStateLabel(row) }; | |
| } | |
| /** One decision per card: a second press while a POST is in flight, or after an outcome, sends nothing. */ | |
| export function inboxDecider(requestId: string, initial: InboxView, onChange: (view: InboxView) => void) { | |
| let current = initial; | |
| let inFlight = false; | |
| const set = (next: Partial<InboxView>) => { current = { ...current, ...next }; onChange(current); }; | |
| return async (action: InboxAction): Promise<void> => { | |
| if (inFlight || current.outcome || !requestId) return; | |
| inFlight = true; set({ busy: true, problem: "" }); | |
| try { | |
| const result = await queryRequest(`/assistant/inbox/${encodeURIComponent(requestId)}/${action}`, | |
| { method: "POST" }, (body: unknown) => (body && typeof body === "object" ? body : {}) as { state?: unknown }); | |
| const state = result.ok ? result.value.state : undefined; | |
| // "Not now" may leave the item pending on the server. The card still shows the choice. | |
| const outcome = state === "approved" || state === "declined" ? state | |
| : state === "pending" && action === "not_now" ? "declined" : ""; | |
| set(outcome ? { busy: false, outcome } : { busy: false, problem: PROBLEM }); | |
| } catch { | |
| set({ busy: false, problem: PROBLEM }); | |
| } finally { | |
| inFlight = false; | |
| } | |
| }; | |
| } | |
| /** C6 card: sender, one line, and Approve / Not now while the item waits for a choice. */ | |
| export function InboxNoticeView({ notice, view, onAct }: { | |
| notice: InboxNotice; view: InboxView; onAct: (action: InboxAction) => void; | |
| }) { | |
| const choosable = !view.outcome && Boolean(notice.requestId) | |
| && (notice.state === "pending" || notice.state === "input-required") | |
| && notice.actions.includes("approve") && notice.actions.includes("not_now"); | |
| return <section className="as-notice" aria-label="Notice"> | |
| {notice.sender ? <p className="as-notice-sender">From {notice.sender}</p> : null} | |
| {notice.title ? <h3 className="as-notice-subject">{notice.title}</h3> : null} | |
| {notice.text ? <p className="as-notice-body">{notice.text}</p> : null} | |
| {!view.outcome && notice.stateLabel ? <p className="as-notice-sender" role="status">{notice.stateLabel}</p> : null} | |
| {view.outcome ? <p className="as-confirm-result" role="status">{OUTCOME_LINE[view.outcome]}</p> | |
| : choosable ? <div className="as-confirm-actions"> | |
| <button type="button" className="as-confirm-button as-notice-approve" disabled={view.busy} | |
| onClick={() => onAct("approve")}>Approve</button> | |
| <button type="button" className="as-confirm-button" disabled={view.busy} | |
| onClick={() => onAct("not_now")}>Not now</button> | |
| </div> : null} | |
| {view.problem ? <p className="as-problem" role="status">{view.problem}</p> : null} | |
| </section>; | |
| } | |
| function InboxNoticeCard({ notice }: { notice: InboxNotice }) { | |
| const [view, setView] = useState<InboxView>(() => ({ busy: false, problem: "", | |
| outcome: notice.state === "approved" || notice.state === "declined" ? notice.state : "" })); | |
| const decide = useRef<ReturnType<typeof inboxDecider> | null>(null); | |
| if (!decide.current) decide.current = inboxDecider(notice.requestId, view, setView); | |
| return <InboxNoticeView notice={notice} view={view} onAct={(action) => void decide.current?.(action)} />; | |
| } | |
| /** The inbox has no screen of its own (R81): a C6 notice is this card, inside the chat. */ | |
| export function NoticeCard({ turn }: { turn: AssistantLogTurn }) { | |
| const inbox = readInboxNotice(turn.payload); | |
| return inbox ? <InboxNoticeCard notice={inbox} /> : <FeedNoticeCard turn={turn} />; | |
| } | |
| /** The feed supplies the sender, subject and permission-filtered target. */ | |
| export function FeedNoticeCard({ turn }: { turn: AssistantLogTurn }) { | |
| const payload = turn.payload || {}; | |
| const sender = text(payload.sender) || text(payload.source); | |
| const subject = text(payload.subject) || text(payload.title); | |
| const body = text(payload.body) || turn.text; | |
| const destination = routeForTarget(payload.target ?? null); | |
| const cancel = useRef<(() => void) | null>(null); | |
| const inPlace = useOpenInPlace(); | |
| const href = destination?.surface === "automation" ? agentAddressHash("agent", destination.autoId) | |
| : destination?.surface === "map" ? "#/customer" | |
| : destination?.surface === "database" && destination.viewId | |
| ? dataAddressHash({ database: destination.key, view: destination.viewId }) | |
| : destination ? `#/${destination.key}` : ""; | |
| return <section className="as-notice" aria-label="Notice"> | |
| {sender ? <p className="as-notice-sender">From {sender}</p> : null} | |
| {subject ? <h3 className="as-notice-subject">{subject}</h3> : null} | |
| {body && body !== subject ? <p className="as-notice-body">{body}</p> : null} | |
| {destination ? <a className="as-notice-open" href={href} onClick={(event) => { | |
| if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return; | |
| // S72-T14: a database target opens in the Assistant's pop-up when a host is mounted. | |
| if (destination.surface === "database" && interceptOpen(inPlace, destination.key.includes("?") | |
| ? `#/${destination.key}` : dataAddressHash({ database: destination.key, view: destination.viewId }), event)) return; | |
| event.preventDefault(); | |
| cancel.current?.(); | |
| window.location.hash = href; | |
| if (destination.surface === "automation") { | |
| signal(AUTOMATION_OPEN_EVENT, { autoId: destination.autoId, tab: destination.tab }); | |
| } else if (destination.surface === "map") { | |
| window.setTimeout(() => signal("aios:route-open", { routeId: destination.routeId }), 0); | |
| } else if (destination.viewId) { | |
| // Timers must survive this card unmounting while the destination grid loads. | |
| cancel.current = retryEmit(() => signal(VIEW_OPEN_EVENT, | |
| { topic: destination.key, viewId: destination.viewId })); | |
| } | |
| }}>Open</a> : null} | |
| </section>; | |
| } | |