Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
/**
* Docked, resizable workflow workspace — the persistent right-hand viewing
* surface (Claude-sidebar posture): stays open while working on the graph,
* auto-opens when content is pushed (canvas_updated -> notifyPushed), and
* doubles as the ephemeral click-to-preview surface for workspace files.
*
* Two modes (canvasDockStore):
* - 'node': renders the selected Canvas node's durable board.
* - 'ephemeral': renders one transient item that lives in no board.
*/
import React, { useMemo, useState, useSyncExternalStore } from 'react';
import { Maximize2, Minimize2, Monitor, PanelRightClose, Undo2 } from 'lucide-react';
import type { Node } from 'reactflow';
import { toast } from 'sonner';
import { Badge } from '@/components/ui/badge';
import { Button } from '@/components/ui/button';
import {
Select,
SelectContent,
SelectItem,
SelectTrigger,
SelectValue,
} from '@/components/ui/select';
import { usePanelResize } from '../../hooks/usePanelResize';
import {
useCanvasBoardQuery,
useCanvasRemove,
} from '../../hooks/useCanvasBoard';
import { resolveNodeDescription } from '../../lib/nodeSpec';
import { useAppStore } from '../../store/useAppStore';
import {
DOCK_MAX_WIDTH,
DOCK_MIN_WIDTH,
useCanvasDockStore,
} from '../../stores/canvasDockStore';
import CanvasContent from '../parameterPanel/canvas/CanvasContent';
import BrowserWorkspace from '../browser/BrowserWorkspace';
import { WorkspaceTabs } from '../workspace/WorkspaceTabs';
import { useSurfaceRunning } from '../workspace/activity';
import { workspaceNodes } from '../workspace/descriptors';
import MobileWorkspace from '../mobile/MobileWorkspace';
import { queryClient } from '../../lib/queryClient';
import { LlmWaitNote } from './LlmWaitNote';
interface CanvasDockProps {
nodes: Node[];
flushCanvas?: () => void;
}
const isCanvasNode = (node: Node): boolean =>
resolveNodeDescription(node.type || '')?.uiHints?.isCanvasPanel === true;
const nodeLabel = (node: Node): string =>
(node.data?.label as string | undefined) || node.type || node.id;
const CanvasDock: React.FC<CanvasDockProps> = ({ nodes, flushCanvas }) => {
const open = useCanvasDockStore((s) => s.open);
const tab = useCanvasDockStore((s) => s.tab);
const setTab = useCanvasDockStore((s) => s.setTab);
const [wide, setWide] = useState(false);
const widthPx = useCanvasDockStore((s) => s.widthPx);
const mode = useCanvasDockStore((s) => s.mode);
const selectedNodeId = useCanvasDockStore((s) => s.selectedNodeId);
const ephemeralItem = useCanvasDockStore((s) => s.ephemeralItem);
const followMode = useCanvasDockStore((s) => s.followMode);
const setFollowMode = useCanvasDockStore((s) => s.setFollowMode);
const setWidth = useCanvasDockStore((s) => s.setWidth);
const close = useCanvasDockStore((s) => s.close);
const selectNode = useCanvasDockStore((s) => s.selectNode);
const backToNode = useCanvasDockStore((s) => s.backToNode);
const focus = useCanvasDockStore((s) => s.focus);
const workflowId = useAppStore((s) => s.currentWorkflow?.id);
// Schema hydration can finish after the graph mounts. Subscribe to hints
// so newly available Browser/Canvas definitions appear without a graph edit.
const hintsVersion = useSyncExternalStore(
(notify) => queryClient.getQueryCache().subscribe((event) => {
if (event.query.queryKey[0] === 'nodeSpec') notify();
}),
() => nodes.map((node) => {
const hints = resolveNodeDescription(node.type || '')?.uiHints;
return `${node.id}:${!!hints?.isCanvasPanel}:${!!hints?.isBrowserPanel}:${hints?.workspace?.kind ?? ''}`;
}).join('|'),
);
// eslint-disable-next-line react-hooks/exhaustive-deps -- hintsVersion tracks external schema hydration.
const canvasNodes = useMemo(() => nodes.filter(isCanvasNode), [nodes, hintsVersion]);
const browserNodes = useMemo(() => nodes
.filter((node) => resolveNodeDescription(node.type || '')?.uiHints?.isBrowserPanel === true)
.map((node) => ({ node_id: node.id, label: nodeLabel(node) })),
// eslint-disable-next-line react-hooks/exhaustive-deps -- hintsVersion tracks external schema hydration.
[nodes, hintsVersion]);
const shownWidth = wide ? Math.min(1100, window.innerWidth - 160) : Math.min(widthPx, window.innerWidth - 40);
const mobileNodes = workspaceNodes(nodes).filter((node) => node.kind === 'mobile');
// A dot on the Browser and Mobile tabs while one of their nodes runs.
const browserIds = useMemo(() => browserNodes.map((node) => node.node_id), [browserNodes]);
const mobileKey = mobileNodes.map((node) => node.node_id).join('|');
// eslint-disable-next-line react-hooks/exhaustive-deps -- keyed by the ids, not the array rebuilt each render.
const mobileIds = useMemo(() => mobileNodes.map((node) => node.node_id), [mobileKey]);
const browserRunning = useSurfaceRunning(workflowId, browserIds);
const mobileRunning = useSurfaceRunning(workflowId, mobileIds);
// A stale selection (workflow switch, node deleted) falls back to the
// first Canvas node rather than a dead board.
const effectiveNodeId = useMemo(() => {
if (selectedNodeId && canvasNodes.some((n) => n.id === selectedNodeId)) {
return selectedNodeId;
}
return canvasNodes[0]?.id ?? null;
}, [canvasNodes, selectedNodeId]);
const showBoard = open && tab === 'board' && mode === 'node';
const board = useCanvasBoardQuery(
showBoard ? workflowId : null,
showBoard ? effectiveNodeId : null,
);
const removeItem = useCanvasRemove(workflowId, effectiveNodeId);
const resize = usePanelResize({
axis: 'x',
cursor: 'ew-resize',
onMove: (deltaPx, startValue) => {
// The handle sits on the dock's LEFT edge — dragging left widens.
// Ceiling is viewport-relative and deliberately generous: the dock may
// take nearly the whole window; the 160px remainder keeps the handle
// and a sliver of canvas reachable to drag it back.
const viewportCap = Math.min(DOCK_MAX_WIDTH, window.innerWidth - 160);
setWide(false);
setWidth(
Math.min(viewportCap, Math.max(DOCK_MIN_WIDTH, startValue - deltaPx)),
);
},
getStartValue: () => shownWidth,
});
return (
<div
className={`relative flex h-full shrink-0 overflow-hidden bg-bg-panel ${
open ? 'border-l border-border-default' : ''
} ${resize.isResizing ? '[transition:none]' : 'transition-[width] duration-300'}`}
style={{ width: open ? shownWidth : 0 }}
aria-hidden={!open}
inert={!open}
role="complementary"
aria-label="Workspace"
>
<div
className={`h-full w-1.5 shrink-0 cursor-ew-resize transition-colors ${
resize.isResizing
? 'bg-node-agent transition-none'
: 'bg-border hover:bg-node-agent-soft'
}`}
onMouseDown={resize.start}
role="separator"
aria-orientation="vertical"
aria-label="Resize workspace"
/>
{/* pointer-events-none while dragging: an embedded iframe (web/PDF
items) would otherwise swallow the document mousemove and freeze
the resize the moment the cursor crosses it. */}
<div
className={`flex min-h-0 min-w-0 flex-1 flex-col ${
resize.isResizing ? 'pointer-events-none' : ''
}`}
>
<div className="flex h-12 shrink-0 items-center gap-2 border-b border-border-default px-3">
<Monitor className="h-4 w-4 shrink-0 text-fg-muted" />
<span className="min-w-0 flex-1 text-sm font-semibold text-fg-default">Workspace</span>
<Button variant="ghost" size="icon-sm" onClick={() => setWide(!wide)} aria-label={wide ? 'Restore size' : 'Expand'}>
{wide ? <Minimize2 /> : <Maximize2 />}
</Button>
<Button variant="ghost" size="icon-sm" onClick={close} aria-label="Close workspace"><PanelRightClose /></Button>
</div>
{open && <WorkspaceTabs
tab={tab}
onTabChange={setTab}
activity={{ browser: browserRunning, android: mobileRunning }}
browser={<BrowserWorkspace key={workflowId ?? 'unsaved'} workflowId={workflowId} nodes={browserNodes} visible={open && tab === 'browser'} flushCanvas={flushCanvas} />}
android={<MobileWorkspace key={workflowId ?? 'unsaved'} workflowId={workflowId} nodes={mobileNodes} visible={open && tab === 'android'}
canvasNodeId={effectiveNodeId ?? null} notify={(message, tone) => (tone === 'error' ? toast.error(message) : toast.success(message))} />}
board={<>
<div className="mb-2 flex shrink-0 items-center gap-2">
{mode === 'ephemeral' ? (
<>
<Badge variant="secondary" className="shrink-0">Preview</Badge>
<span className="min-w-0 flex-1 truncate text-xs text-fg-muted">
{ephemeralItem?.title || ephemeralItem?.ref?.filename || ''}
</span>
{canvasNodes.length > 0 && (
<Button
variant="ghost"
size="sm"
onClick={backToNode}
className="shrink-0"
>
<Undo2 className="h-3.5 w-3.5" /> Back
</Button>
)}
</>
) : canvasNodes.length > 1 ? (
<div className="min-w-0 flex-1">
<Select
value={effectiveNodeId ?? undefined}
onValueChange={selectNode}
>
<SelectTrigger className="h-7 text-xs">
<SelectValue placeholder="Select canvas node" />
</SelectTrigger>
<SelectContent>
{canvasNodes.map((node) => (
<SelectItem key={node.id} value={node.id}>
{nodeLabel(node)}
</SelectItem>
))}
</SelectContent>
</Select>
</div>
) : (
<span className="min-w-0 flex-1 truncate text-xs text-fg-muted">
{canvasNodes[0] ? nodeLabel(canvasNodes[0]) : ''}
</span>
)}
</div>
<div className="flex min-h-0 min-w-0 flex-1 flex-col">
{mode === 'ephemeral' && ephemeralItem ? (
<CanvasContent items={[ephemeralItem]} workflowId={workflowId} />
) : !effectiveNodeId ? (
<div className="flex flex-1 items-center justify-center p-4 text-center text-sm text-fg-muted">
No Canvas node in this workflow yet — add one from the palette,
or open a file's preview and choose "Open in side
panel".
</div>
) : (
<CanvasContent
items={board.data?.items ?? []}
workflowId={workflowId}
nodeId={effectiveNodeId}
focus={focus?.nodeId === effectiveNodeId ? focus : null}
followLatestDefault={followMode}
onFollowLatestChange={setFollowMode}
onRemove={(itemId) =>
removeItem.mutate(itemId, {
onError: (error) => toast.error(error.message),
})
}
emptyHint="Nothing here yet — agents push content with the canvas tool, or wire a node into the Canvas input."
/>
)}
</div>
</>}
/>}
{open && <LlmWaitNote workflowId={workflowId} className="shrink-0 border-t border-border-default px-3 py-2" />}
</div>
</div>
);
};
export default CanvasDock;