feat: workflow library (#5148)

* chore: bump pydantic to 2.5.2

This release fixes pydantic/pydantic#8175 and allows us to use `JsonValue`

* fix(ui): exclude public/en.json from prettier config

* fix(workflow_records): fix SQLite workflow insertion to ignore duplicates

* feat(backend): update workflows handling

Update workflows handling for Workflow Library.

**Updated Workflow Storage**

"Embedded Workflows" are workflows associated with images, and are now only stored in the image files. "Library Workflows" are not associated with images, and are stored only in DB.

This works out nicely. We have always saved workflows to files, but recently began saving them to the DB in addition to in image files. When that happened, we stopped reading workflows from files, so all the workflows that only existed in images were inaccessible. With this change, access to those workflows is restored, and no workflows are lost.

**Updated Workflow Handling in Nodes**

Prior to this change, workflows were embedded in images by passing the whole workflow JSON to a special workflow field on a node. In the node's `invoke()` function, the node was able to access this workflow and save it with the image. This (inaccurately) models workflows as a property of an image and is rather awkward technically.

A workflow is now a property of a batch/session queue item. It is available in the InvocationContext and therefore available to all nodes during `invoke()`.

**Database Migrations**

Added a `SQLiteMigrator` class to handle database migrations. Migrations were needed to accomodate the DB-related changes in this PR. See the code for details.

The `images`, `workflows` and `session_queue` tables required migrations for this PR, and are using the new migrator. Other tables/services are still creating tables themselves. A followup PR will adapt them to use the migrator.

**Other/Support Changes**

- Add a `has_workflow` column to `images` table to indicate that the image has an embedded workflow.
- Add handling for retrieving the workflow from an image in python. The image file must be fetched, the workflow extracted, and then sent to client, avoiding needing the browser to parse the image file. With the `has_workflow` column, the UI knows if there is a workflow to be fetched, and only fetches when the user requests to load the workflow.
- Add route to get the workflow from an image
- Add CRUD service/routes for the library workflows
- `workflow_images` table and services removed (no longer needed now that embedded workflows are not in the DB)

* feat(ui): updated workflow handling (WIP)

Clientside updates for the backend workflow changes.

Includes roughed-out workflow library UI.

* feat: revert SQLiteMigrator class

Will pursue this in a separate PR.

* feat(nodes): do not overwrite custom node module names

Use a different, simpler method to detect if a node is custom.

* feat(nodes): restore WithWorkflow as no-op class

This class is deprecated and no longer needed. Set its workflow attr value to None (meaning it is now a no-op), and issue a warning when an invocation subclasses it.

* fix(nodes): fix get_workflow from queue item dict func

* feat(backend): add WorkflowRecordListItemDTO

This is the id, name, description, created at and updated at workflow columns/attrs. Used to display lists of workflowsl

* chore(ui): typegen

* feat(ui): add workflow loading, deleting to workflow library UI

* feat(ui): workflow library pagination button styles

* wip

* feat: workflow library WIP

- Save to library
- Duplicate
- Filter/sort
- UI/queries

* feat: workflow library - system graphs - wip

* feat(backend): sync system workflows to db

* fix: merge conflicts

* feat: simplify default workflows

- Rename "system" -> "default"
- Simplify syncing logic
- Update UI to match

* feat(workflows): update default workflows

- Update TextToImage_SD15
- Add TextToImage_SDXL
- Add README

* feat(ui): refine workflow list UI

* fix(workflow_records): typo

* fix(tests): fix tests

* feat(ui): clean up workflow library hooks

* fix(db): fix mis-ordered db cleanup step

It was happening before pruning queue items - should happen afterwards, else you have to restart the app again to free disk space made available by the pruning.

* feat(ui): tweak reset workflow editor translations

* feat(ui): split out workflow redux state

The `nodes` slice is a rather complicated slice. Removing `workflow` makes it a bit more reasonable.

Also helps to flatten state out a bit.

* docs: update default workflows README

* fix: tidy up unused files, unrelated changes

* fix(backend): revert unrelated service organisational changes

* feat(backend): workflow_records.get_many arg "filter_text" -> "query"

* feat(ui): use custom hook in current image buttons

Already in use elsewhere, forgot to use it here.

* fix(ui): remove commented out property

* fix(ui): fix workflow loading

- Different handling for loading from library vs external
- Fix bug where only nodes and edges loaded

* fix(ui): fix save/save-as workflow naming

* fix(ui): fix circular dependency

* fix(db): fix bug with releasing without lock in db.clean()

* fix(db): remove extraneous lock

* chore: bump ruff

* fix(workflow_records): default `category` to `WorkflowCategory.User`

This allows old workflows to validate when reading them from the db or image files.

* hide workflow library buttons if feature is disabled

---------

Co-authored-by: Mary Hipp <maryhipp@Marys-MacBook-Air.local>

invokeai/frontend/web/src/features/workflowLibrary/components/DownloadWorkflowButton.tsx

@@ -0,0 +1,29 @@
+import IAIIconButton from 'common/components/IAIIconButton';
+import { useWorkflow } from 'features/nodes/hooks/useWorkflow';
+import { memo, useCallback } from 'react';
+import { useTranslation } from 'react-i18next';
+import { FaDownload } from 'react-icons/fa';
+
+const DownloadWorkflowButton = () => {
+  const { t } = useTranslation();
+  const workflow = useWorkflow();
+  const handleDownload = useCallback(() => {
+    const blob = new Blob([JSON.stringify(workflow, null, 2)]);
+    const a = document.createElement('a');
+    a.href = URL.createObjectURL(blob);
+    a.download = `${workflow.name || 'My Workflow'}.json`;
+    document.body.appendChild(a);
+    a.click();
+    a.remove();
+  }, [workflow]);
+  return (
+    <IAIIconButton
+      icon={<FaDownload />}
+      tooltip={t('workflows.downloadWorkflow')}
+      aria-label={t('workflows.downloadWorkflow')}
+      onClick={handleDownload}
+    />
+  );
+};
+
+export default memo(DownloadWorkflowButton);

invokeai/frontend/web/src/features/workflowLibrary/components/LoadWorkflowFromFileButton.tsx

@@ -0,0 +1,30 @@
+import { FileButton } from '@mantine/core';
+import IAIIconButton from 'common/components/IAIIconButton';
+import { useLoadWorkflowFromFile } from 'features/workflowLibrary/hooks/useLoadWorkflowFromFile';
+import { memo, useRef } from 'react';
+import { useTranslation } from 'react-i18next';
+import { FaUpload } from 'react-icons/fa';
+
+const UploadWorkflowButton = () => {
+  const { t } = useTranslation();
+  const resetRef = useRef<() => void>(null);
+  const loadWorkflowFromFile = useLoadWorkflowFromFile({ resetRef });
+  return (
+    <FileButton
+      resetRef={resetRef}
+      accept="application/json"
+      onChange={loadWorkflowFromFile}
+    >
+      {(props) => (
+        <IAIIconButton
+          icon={<FaUpload />}
+          tooltip={t('workflows.uploadWorkflow')}
+          aria-label={t('workflows.uploadWorkflow')}
+          {...props}
+        />
+      )}
+    </FileButton>
+  );
+};
+
+export default memo(UploadWorkflowButton);

invokeai/frontend/web/src/features/workflowLibrary/components/ResetWorkflowButton.tsx

@@ -0,0 +1,87 @@
+import {
+  AlertDialog,
+  AlertDialogBody,
+  AlertDialogContent,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogOverlay,
+  Button,
+  Flex,
+  Text,
+  useDisclosure,
+} from '@chakra-ui/react';
+import { useAppDispatch } from 'app/store/storeHooks';
+import IAIIconButton from 'common/components/IAIIconButton';
+import { nodeEditorReset } from 'features/nodes/store/nodesSlice';
+import { addToast } from 'features/system/store/systemSlice';
+import { makeToast } from 'features/system/util/makeToast';
+import { memo, useCallback, useRef } from 'react';
+import { useTranslation } from 'react-i18next';
+import { FaTrash } from 'react-icons/fa';
+
+const ResetWorkflowEditorButton = () => {
+  const { t } = useTranslation();
+  const dispatch = useAppDispatch();
+  const { isOpen, onOpen, onClose } = useDisclosure();
+  const cancelRef = useRef<HTMLButtonElement | null>(null);
+
+  const handleConfirmClear = useCallback(() => {
+    dispatch(nodeEditorReset());
+
+    dispatch(
+      addToast(
+        makeToast({
+          title: t('workflows.workflowEditorReset'),
+          status: 'success',
+        })
+      )
+    );
+
+    onClose();
+  }, [dispatch, t, onClose]);
+
+  return (
+    <>
+      <IAIIconButton
+        icon={<FaTrash />}
+        tooltip={t('nodes.resetWorkflow')}
+        aria-label={t('nodes.resetWorkflow')}
+        onClick={onOpen}
+        colorScheme="error"
+      />
+
+      <AlertDialog
+        isOpen={isOpen}
+        onClose={onClose}
+        leastDestructiveRef={cancelRef}
+        isCentered
+      >
+        <AlertDialogOverlay />
+
+        <AlertDialogContent>
+          <AlertDialogHeader fontSize="lg" fontWeight="bold">
+            {t('nodes.resetWorkflow')}
+          </AlertDialogHeader>
+
+          <AlertDialogBody py={4}>
+            <Flex flexDir="column" gap={2}>
+              <Text>{t('nodes.resetWorkflowDesc')}</Text>
+              <Text variant="subtext">{t('nodes.resetWorkflowDesc2')}</Text>
+            </Flex>
+          </AlertDialogBody>
+
+          <AlertDialogFooter>
+            <Button ref={cancelRef} onClick={onClose}>
+              {t('common.cancel')}
+            </Button>
+            <Button colorScheme="error" ml={3} onClick={handleConfirmClear}>
+              {t('common.accept')}
+            </Button>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+    </>
+  );
+};
+
+export default memo(ResetWorkflowEditorButton);

invokeai/frontend/web/src/features/workflowLibrary/components/SaveWorkflowAsButton.tsx

@@ -0,0 +1,89 @@
+import {
+  AlertDialog,
+  AlertDialogBody,
+  AlertDialogContent,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogOverlay,
+  FormControl,
+  FormLabel,
+  Input,
+  useDisclosure,
+} from '@chakra-ui/react';
+import { useAppSelector } from 'app/store/storeHooks';
+import IAIButton from 'common/components/IAIButton';
+import IAIIconButton from 'common/components/IAIIconButton';
+import { useSaveWorkflowAs } from 'features/workflowLibrary/hooks/useSaveWorkflowAs';
+import { getWorkflowCopyName } from 'features/workflowLibrary/util/getWorkflowCopyName';
+import { ChangeEvent, memo, useCallback, useRef, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { FaClone } from 'react-icons/fa';
+
+const SaveWorkflowAsButton = () => {
+  const currentName = useAppSelector((state) => state.workflow.name);
+  const { t } = useTranslation();
+  const { saveWorkflowAs, isLoading } = useSaveWorkflowAs();
+  const [name, setName] = useState(getWorkflowCopyName(currentName));
+  const { isOpen, onOpen, onClose } = useDisclosure();
+  const inputRef = useRef<HTMLInputElement>(null);
+
+  const onOpenCallback = useCallback(() => {
+    setName(getWorkflowCopyName(currentName));
+    onOpen();
+  }, [currentName, onOpen]);
+
+  const onSave = useCallback(async () => {
+    saveWorkflowAs({ name, onSuccess: onClose, onError: onClose });
+  }, [name, onClose, saveWorkflowAs]);
+
+  const onChange = useCallback((e: ChangeEvent<HTMLInputElement>) => {
+    setName(e.target.value);
+  }, []);
+
+  return (
+    <>
+      <IAIIconButton
+        icon={<FaClone />}
+        onClick={onOpenCallback}
+        isLoading={isLoading}
+        tooltip={t('workflows.saveWorkflowAs')}
+        aria-label={t('workflows.saveWorkflowAs')}
+      />
+      <AlertDialog
+        isOpen={isOpen}
+        onClose={onClose}
+        leastDestructiveRef={inputRef}
+        isCentered
+      >
+        <AlertDialogOverlay>
+          <AlertDialogContent>
+            <AlertDialogHeader fontSize="lg" fontWeight="bold">
+              {t('workflows.saveWorkflowAs')}
+            </AlertDialogHeader>
+
+            <AlertDialogBody>
+              <FormControl>
+                <FormLabel>{t('workflows.workflowName')}</FormLabel>
+                <Input
+                  ref={inputRef}
+                  value={name}
+                  onChange={onChange}
+                  placeholder={t('workflows.workflowName')}
+                />
+              </FormControl>
+            </AlertDialogBody>
+
+            <AlertDialogFooter>
+              <IAIButton onClick={onClose}>{t('common.cancel')}</IAIButton>
+              <IAIButton colorScheme="accent" onClick={onSave} ml={3}>
+                {t('common.saveAs')}
+              </IAIButton>
+            </AlertDialogFooter>
+          </AlertDialogContent>
+        </AlertDialogOverlay>
+      </AlertDialog>
+    </>
+  );
+};
+
+export default memo(SaveWorkflowAsButton);

invokeai/frontend/web/src/features/workflowLibrary/components/SaveWorkflowButton.tsx

@@ -0,0 +1,21 @@
+import IAIIconButton from 'common/components/IAIIconButton';
+import { useSaveLibraryWorkflow } from 'features/workflowLibrary/hooks/useSaveWorkflow';
+import { memo } from 'react';
+import { useTranslation } from 'react-i18next';
+import { FaSave } from 'react-icons/fa';
+
+const SaveLibraryWorkflowButton = () => {
+  const { t } = useTranslation();
+  const { saveWorkflow, isLoading } = useSaveLibraryWorkflow();
+  return (
+    <IAIIconButton
+      icon={<FaSave />}
+      onClick={saveWorkflow}
+      isLoading={isLoading}
+      tooltip={t('workflows.saveWorkflow')}
+      aria-label={t('workflows.saveWorkflow')}
+    />
+  );
+};
+
+export default memo(SaveLibraryWorkflowButton);

invokeai/frontend/web/src/features/workflowLibrary/components/WorkflowLibraryButton.tsx

@@ -0,0 +1,26 @@
+import { useDisclosure } from '@chakra-ui/react';
+import IAIIconButton from 'common/components/IAIIconButton';
+import { memo } from 'react';
+import { useTranslation } from 'react-i18next';
+import { FaFolderOpen } from 'react-icons/fa';
+import WorkflowLibraryModal from './WorkflowLibraryModal';
+import { WorkflowLibraryModalContext } from 'features/workflowLibrary/context/WorkflowLibraryModalContext';
+
+const WorkflowLibraryButton = () => {
+  const { t } = useTranslation();
+  const disclosure = useDisclosure();
+
+  return (
+    <WorkflowLibraryModalContext.Provider value={disclosure}>
+      <IAIIconButton
+        icon={<FaFolderOpen />}
+        onClick={disclosure.onOpen}
+        tooltip={t('workflows.workflowLibrary')}
+        aria-label={t('workflows.workflowLibrary')}
+      />
+      <WorkflowLibraryModal />
+    </WorkflowLibraryModalContext.Provider>
+  );
+};
+
+export default memo(WorkflowLibraryButton);

invokeai/frontend/web/src/features/workflowLibrary/components/WorkflowLibraryContent.tsx

@@ -0,0 +1,13 @@
+import WorkflowLibraryList from 'features/workflowLibrary/components/WorkflowLibraryList';
+import WorkflowLibraryListWrapper from 'features/workflowLibrary/components/WorkflowLibraryListWrapper';
+import { memo } from 'react';
+
+const WorkflowLibraryContent = () => {
+  return (
+    <WorkflowLibraryListWrapper>
+      <WorkflowLibraryList />
+    </WorkflowLibraryListWrapper>
+  );
+};
+
+export default memo(WorkflowLibraryContent);

invokeai/frontend/web/src/features/workflowLibrary/components/WorkflowLibraryList.tsx

@@ -0,0 +1,242 @@
+import { CloseIcon } from '@chakra-ui/icons';
+import {
+  ButtonGroup,
+  Divider,
+  Flex,
+  IconButton,
+  Input,
+  InputGroup,
+  InputRightElement,
+  Spacer,
+} from '@chakra-ui/react';
+import { SelectItem } from '@mantine/core';
+import IAIButton from 'common/components/IAIButton';
+import {
+  IAINoContentFallback,
+  IAINoContentFallbackWithSpinner,
+} from 'common/components/IAIImageFallback';
+import IAIMantineSelect from 'common/components/IAIMantineSelect';
+import ScrollableContent from 'features/nodes/components/sidePanel/ScrollableContent';
+import { WorkflowCategory } from 'features/nodes/types/workflow';
+import WorkflowLibraryListItem from 'features/workflowLibrary/components/WorkflowLibraryListItem';
+import WorkflowLibraryPagination from 'features/workflowLibrary/components/WorkflowLibraryPagination';
+import {
+  ChangeEvent,
+  KeyboardEvent,
+  memo,
+  useCallback,
+  useMemo,
+  useState,
+} from 'react';
+import { useTranslation } from 'react-i18next';
+import { useListWorkflowsQuery } from 'services/api/endpoints/workflows';
+import { SQLiteDirection, WorkflowRecordOrderBy } from 'services/api/types';
+import { useDebounce } from 'use-debounce';
+
+const PER_PAGE = 10;
+
+const ORDER_BY_DATA: SelectItem[] = [
+  { value: 'opened_at', label: 'Opened' },
+  { value: 'created_at', label: 'Created' },
+  { value: 'updated_at', label: 'Updated' },
+  { value: 'name', label: 'Name' },
+];
+
+const DIRECTION_DATA: SelectItem[] = [
+  { value: 'ASC', label: 'Ascending' },
+  { value: 'DESC', label: 'Descending' },
+];
+
+const WorkflowLibraryList = () => {
+  const { t } = useTranslation();
+  const [category, setCategory] = useState<WorkflowCategory>('user');
+  const [page, setPage] = useState(0);
+  const [query, setQuery] = useState('');
+  const [order_by, setOrderBy] = useState<WorkflowRecordOrderBy>('opened_at');
+  const [direction, setDirection] = useState<SQLiteDirection>('ASC');
+  const [debouncedQuery] = useDebounce(query, 500);
+
+  const queryArg = useMemo<Parameters<typeof useListWorkflowsQuery>[0]>(() => {
+    if (category === 'user') {
+      return {
+        page,
+        per_page: PER_PAGE,
+        order_by,
+        direction,
+        category,
+        query: debouncedQuery,
+      };
+    }
+    return {
+      page,
+      per_page: PER_PAGE,
+      order_by: 'name' as const,
+      direction: 'ASC' as const,
+      category,
+      query: debouncedQuery,
+    };
+  }, [category, debouncedQuery, direction, order_by, page]);
+
+  const { data, isLoading, isError, isFetching } =
+    useListWorkflowsQuery(queryArg);
+
+  const handleChangeOrderBy = useCallback(
+    (value: string | null) => {
+      if (!value || value === order_by) {
+        return;
+      }
+      setOrderBy(value as WorkflowRecordOrderBy);
+      setPage(0);
+    },
+    [order_by]
+  );
+
+  const handleChangeDirection = useCallback(
+    (value: string | null) => {
+      if (!value || value === direction) {
+        return;
+      }
+      setDirection(value as SQLiteDirection);
+      setPage(0);
+    },
+    [direction]
+  );
+
+  const resetFilterText = useCallback(() => {
+    setQuery('');
+    setPage(0);
+  }, []);
+
+  const handleKeydownFilterText = useCallback(
+    (e: KeyboardEvent<HTMLInputElement>) => {
+      // exit search mode on escape
+      if (e.key === 'Escape') {
+        resetFilterText();
+        e.preventDefault();
+        setPage(0);
+      }
+    },
+    [resetFilterText]
+  );
+
+  const handleChangeFilterText = useCallback(
+    (e: ChangeEvent<HTMLInputElement>) => {
+      setQuery(e.target.value);
+      setPage(0);
+    },
+    []
+  );
+
+  const handleSetUserCategory = useCallback(() => {
+    setCategory('user');
+    setPage(0);
+  }, []);
+
+  const handleSetDefaultCategory = useCallback(() => {
+    setCategory('default');
+    setPage(0);
+  }, []);
+
+  return (
+    <>
+      <Flex gap={4} alignItems="center" h={10} flexShrink={0} flexGrow={0}>
+        <ButtonGroup>
+          <IAIButton
+            variant={category === 'user' ? undefined : 'ghost'}
+            onClick={handleSetUserCategory}
+            isChecked={category === 'user'}
+          >
+            {t('workflows.userWorkflows')}
+          </IAIButton>
+          <IAIButton
+            variant={category === 'default' ? undefined : 'ghost'}
+            onClick={handleSetDefaultCategory}
+            isChecked={category === 'default'}
+          >
+            {t('workflows.defaultWorkflows')}
+          </IAIButton>
+        </ButtonGroup>
+        <Spacer />
+        {category === 'user' && (
+          <>
+            <IAIMantineSelect
+              label={t('common.orderBy')}
+              value={order_by}
+              data={ORDER_BY_DATA}
+              onChange={handleChangeOrderBy}
+              formControlProps={{
+                w: 48,
+                display: 'flex',
+                alignItems: 'center',
+                gap: 2,
+              }}
+              disabled={isFetching}
+            />
+            <IAIMantineSelect
+              label={t('common.direction')}
+              value={direction}
+              data={DIRECTION_DATA}
+              onChange={handleChangeDirection}
+              formControlProps={{
+                w: 48,
+                display: 'flex',
+                alignItems: 'center',
+                gap: 2,
+              }}
+              disabled={isFetching}
+            />
+          </>
+        )}
+        <InputGroup w="20rem">
+          <Input
+            placeholder={t('workflows.searchWorkflows')}
+            value={query}
+            onKeyDown={handleKeydownFilterText}
+            onChange={handleChangeFilterText}
+            data-testid="workflow-search-input"
+          />
+          {query.trim().length && (
+            <InputRightElement>
+              <IconButton
+                onClick={resetFilterText}
+                size="xs"
+                variant="ghost"
+                aria-label={t('workflows.clearWorkflowSearchFilter')}
+                opacity={0.5}
+                icon={<CloseIcon boxSize={2} />}
+              />
+            </InputRightElement>
+          )}
+        </InputGroup>
+      </Flex>
+      <Divider />
+      {isLoading ? (
+        <IAINoContentFallbackWithSpinner label={t('workflows.loading')} />
+      ) : !data || isError ? (
+        <IAINoContentFallback label={t('workflows.problemLoading')} />
+      ) : data.items.length ? (
+        <ScrollableContent>
+          <Flex w="full" h="full" gap={2} px={1} flexDir="column">
+            {data.items.map((w) => (
+              <WorkflowLibraryListItem key={w.workflow_id} workflowDTO={w} />
+            ))}
+          </Flex>
+        </ScrollableContent>
+      ) : (
+        <IAINoContentFallback label={t('workflows.noUserWorkflows')} />
+      )}
+      <Divider />
+      {data && (
+        <Flex w="full" justifyContent="space-around">
+          <WorkflowLibraryPagination
+            data={data}
+            page={page}
+            setPage={setPage}
+          />
+        </Flex>
+      )}
+    </>
+  );
+};
+
+export default memo(WorkflowLibraryList);

invokeai/frontend/web/src/features/workflowLibrary/components/WorkflowLibraryListItem.tsx

@@ -0,0 +1,94 @@
+import { Flex, Heading, Spacer, Text } from '@chakra-ui/react';
+import IAIButton from 'common/components/IAIButton';
+import dateFormat, { masks } from 'dateformat';
+import { useDeleteLibraryWorkflow } from 'features/workflowLibrary/hooks/useDeleteLibraryWorkflow';
+import { useGetAndLoadLibraryWorkflow } from 'features/workflowLibrary/hooks/useGetAndLoadLibraryWorkflow';
+import { useWorkflowLibraryModalContext } from 'features/workflowLibrary/context/useWorkflowLibraryModalContext';
+import { memo, useCallback } from 'react';
+import { useTranslation } from 'react-i18next';
+import { WorkflowRecordListItemDTO } from 'services/api/types';
+
+type Props = {
+  workflowDTO: WorkflowRecordListItemDTO;
+};
+
+const WorkflowLibraryListItem = ({ workflowDTO }: Props) => {
+  const { t } = useTranslation();
+  const { onClose } = useWorkflowLibraryModalContext();
+  const { deleteWorkflow, deleteWorkflowResult } = useDeleteLibraryWorkflow({});
+  const { getAndLoadWorkflow, getAndLoadWorkflowResult } =
+    useGetAndLoadLibraryWorkflow({ onSuccess: onClose });
+
+  const handleDeleteWorkflow = useCallback(() => {
+    deleteWorkflow(workflowDTO.workflow_id);
+  }, [deleteWorkflow, workflowDTO.workflow_id]);
+
+  const handleGetAndLoadWorkflow = useCallback(() => {
+    getAndLoadWorkflow(workflowDTO.workflow_id);
+  }, [getAndLoadWorkflow, workflowDTO.workflow_id]);
+
+  return (
+    <Flex key={workflowDTO.workflow_id} w="full">
+      <Flex w="full" alignItems="center" gap={2} h={12}>
+        <Flex flexDir="column" flexGrow={1} h="full">
+          <Flex alignItems="center" w="full" h="50%">
+            <Heading size="sm">
+              {workflowDTO.name || t('workflows.unnamedWorkflow')}
+            </Heading>
+            <Spacer />
+            {workflowDTO.category === 'user' && (
+              <Text fontSize="sm" variant="subtext">
+                {t('common.updated')}:{' '}
+                {dateFormat(workflowDTO.updated_at, masks.shortDate)}{' '}
+                {dateFormat(workflowDTO.updated_at, masks.shortTime)}
+              </Text>
+            )}
+          </Flex>
+          <Flex alignItems="center" w="full" h="50%">
+            {workflowDTO.description ? (
+              <Text fontSize="sm" noOfLines={1}>
+                {workflowDTO.description}
+              </Text>
+            ) : (
+              <Text
+                fontSize="sm"
+                variant="subtext"
+                fontStyle="italic"
+                noOfLines={1}
+              >
+                {t('workflows.noDescription')}
+              </Text>
+            )}
+            <Spacer />
+            {workflowDTO.category === 'user' && (
+              <Text fontSize="sm" variant="subtext">
+                {t('common.created')}:{' '}
+                {dateFormat(workflowDTO.created_at, masks.shortDate)}{' '}
+                {dateFormat(workflowDTO.created_at, masks.shortTime)}
+              </Text>
+            )}
+          </Flex>
+        </Flex>
+        <IAIButton
+          onClick={handleGetAndLoadWorkflow}
+          isLoading={getAndLoadWorkflowResult.isLoading}
+          aria-label={t('workflows.openWorkflow')}
+        >
+          {t('common.load')}
+        </IAIButton>
+        {workflowDTO.category === 'user' && (
+          <IAIButton
+            colorScheme="error"
+            onClick={handleDeleteWorkflow}
+            isLoading={deleteWorkflowResult.isLoading}
+            aria-label={t('workflows.deleteWorkflow')}
+          >
+            {t('common.delete')}
+          </IAIButton>
+        )}
+      </Flex>
+    </Flex>
+  );
+};
+
+export default memo(WorkflowLibraryListItem);

invokeai/frontend/web/src/features/workflowLibrary/components/WorkflowLibraryListWrapper.tsx

@@ -0,0 +1,21 @@
+import { Flex } from '@chakra-ui/react';
+import { PropsWithChildren, memo } from 'react';
+
+const WorkflowLibraryListWrapper = (props: PropsWithChildren) => {
+  return (
+    <Flex
+      w="full"
+      h="full"
+      flexDir="column"
+      layerStyle="second"
+      py={2}
+      px={4}
+      gap={2}
+      borderRadius="base"
+    >
+      {props.children}
+    </Flex>
+  );
+};
+
+export default memo(WorkflowLibraryListWrapper);

invokeai/frontend/web/src/features/workflowLibrary/components/WorkflowLibraryModal.tsx

@@ -0,0 +1,40 @@
+import {
+  Modal,
+  ModalBody,
+  ModalCloseButton,
+  ModalContent,
+  ModalFooter,
+  ModalHeader,
+  ModalOverlay,
+} from '@chakra-ui/react';
+import WorkflowLibraryContent from 'features/workflowLibrary/components/WorkflowLibraryContent';
+import { useWorkflowLibraryModalContext } from 'features/workflowLibrary/context/useWorkflowLibraryModalContext';
+import { memo } from 'react';
+import { useTranslation } from 'react-i18next';
+
+const WorkflowLibraryModal = () => {
+  const { t } = useTranslation();
+  const { isOpen, onClose } = useWorkflowLibraryModalContext();
+  return (
+    <Modal isOpen={isOpen} onClose={onClose} isCentered>
+      <ModalOverlay />
+      <ModalContent
+        w="80%"
+        h="80%"
+        minW="unset"
+        minH="unset"
+        maxW="unset"
+        maxH="unset"
+      >
+        <ModalHeader>{t('workflows.workflowLibrary')}</ModalHeader>
+        <ModalCloseButton />
+        <ModalBody>
+          <WorkflowLibraryContent />
+        </ModalBody>
+        <ModalFooter />
+      </ModalContent>
+    </Modal>
+  );
+};
+
+export default memo(WorkflowLibraryModal);

invokeai/frontend/web/src/features/workflowLibrary/components/WorkflowLibraryPagination.tsx

@@ -0,0 +1,87 @@
+import { ButtonGroup } from '@chakra-ui/react';
+import IAIButton from 'common/components/IAIButton';
+import IAIIconButton from 'common/components/IAIIconButton';
+import { Dispatch, SetStateAction, memo, useCallback, useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+import { FaChevronLeft, FaChevronRight } from 'react-icons/fa';
+import { paths } from 'services/api/schema';
+
+const PAGES_TO_DISPLAY = 7;
+
+type PageData = {
+  page: number;
+  onClick: () => void;
+};
+
+type Props = {
+  page: number;
+  setPage: Dispatch<SetStateAction<number>>;
+  data: paths['/api/v1/workflows/']['get']['responses']['200']['content']['application/json'];
+};
+
+const WorkflowLibraryPagination = ({ page, setPage, data }: Props) => {
+  const { t } = useTranslation();
+
+  const handlePrevPage = useCallback(() => {
+    setPage((p) => Math.max(p - 1, 0));
+  }, [setPage]);
+
+  const handleNextPage = useCallback(() => {
+    setPage((p) => Math.min(p + 1, data.pages - 1));
+  }, [data.pages, setPage]);
+
+  const pages: PageData[] = useMemo(() => {
+    const pages = [];
+    let first =
+      data.pages > PAGES_TO_DISPLAY
+        ? Math.max(0, page - Math.floor(PAGES_TO_DISPLAY / 2))
+        : 0;
+    const last =
+      data.pages > PAGES_TO_DISPLAY
+        ? Math.min(data.pages, first + PAGES_TO_DISPLAY)
+        : data.pages;
+    if (last - first < PAGES_TO_DISPLAY && data.pages > PAGES_TO_DISPLAY) {
+      first = last - PAGES_TO_DISPLAY;
+    }
+    for (let i = first; i < last; i++) {
+      pages.push({
+        page: i,
+        onClick: () => setPage(i),
+      });
+    }
+    return pages;
+  }, [data.pages, page, setPage]);
+
+  return (
+    <ButtonGroup>
+      <IAIIconButton
+        variant="ghost"
+        onClick={handlePrevPage}
+        isDisabled={page === 0}
+        aria-label={t('common.prevPage')}
+        icon={<FaChevronLeft />}
+      />
+      {pages.map((p) => (
+        <IAIButton
+          w={10}
+          isDisabled={data.pages === 1}
+          onClick={p.page === page ? undefined : p.onClick}
+          variant={p.page === page ? 'invokeAI' : 'ghost'}
+          key={p.page}
+          transitionDuration="0s" // the delay in animation looks jank
+        >
+          {p.page + 1}
+        </IAIButton>
+      ))}
+      <IAIIconButton
+        variant="ghost"
+        onClick={handleNextPage}
+        isDisabled={page === data.pages - 1}
+        aria-label={t('common.nextPage')}
+        icon={<FaChevronRight />}
+      />
+    </ButtonGroup>
+  );
+};
+
+export default memo(WorkflowLibraryPagination);

invokeai/frontend/web/src/features/workflowLibrary/context/WorkflowLibraryModalContext.ts

@@ -0,0 +1,5 @@
+import { UseDisclosureReturn } from '@chakra-ui/react';
+import { createContext } from 'react';
+
+export const WorkflowLibraryModalContext =
+  createContext<UseDisclosureReturn | null>(null);

invokeai/frontend/web/src/features/workflowLibrary/context/useWorkflowLibraryModalContext.ts

@@ -0,0 +1,12 @@
+import { WorkflowLibraryModalContext } from 'features/workflowLibrary/context/WorkflowLibraryModalContext';
+import { useContext } from 'react';
+
+export const useWorkflowLibraryModalContext = () => {
+  const context = useContext(WorkflowLibraryModalContext);
+  if (!context) {
+    throw new Error(
+      'useWorkflowLibraryContext must be used within a WorkflowLibraryContext.Provider'
+    );
+  }
+  return context;
+};

invokeai/frontend/web/src/features/workflowLibrary/hooks/useDeleteLibraryWorkflow.ts

@@ -0,0 +1,48 @@
+import { useAppToaster } from 'app/components/Toaster';
+import { useCallback } from 'react';
+import { useTranslation } from 'react-i18next';
+import { useDeleteWorkflowMutation } from 'services/api/endpoints/workflows';
+
+type UseDeleteLibraryWorkflowOptions = {
+  onSuccess?: () => void;
+  onError?: () => void;
+};
+
+type UseDeleteLibraryWorkflowReturn = {
+  deleteWorkflow: (workflow_id: string) => Promise<void>;
+  deleteWorkflowResult: ReturnType<typeof useDeleteWorkflowMutation>[1];
+};
+
+type UseDeleteLibraryWorkflow = (
+  arg: UseDeleteLibraryWorkflowOptions
+) => UseDeleteLibraryWorkflowReturn;
+
+export const useDeleteLibraryWorkflow: UseDeleteLibraryWorkflow = ({
+  onSuccess,
+  onError,
+}) => {
+  const toaster = useAppToaster();
+  const { t } = useTranslation();
+  const [_deleteWorkflow, deleteWorkflowResult] = useDeleteWorkflowMutation();
+
+  const deleteWorkflow = useCallback(
+    async (workflow_id: string) => {
+      try {
+        await _deleteWorkflow(workflow_id).unwrap();
+        toaster({
+          title: t('toast.workflowDeleted'),
+        });
+        onSuccess && onSuccess();
+      } catch {
+        toaster({
+          title: t('toast.problemDeletingWorkflow'),
+          status: 'error',
+        });
+        onError && onError();
+      }
+    },
+    [_deleteWorkflow, toaster, t, onSuccess, onError]
+  );
+
+  return { deleteWorkflow, deleteWorkflowResult };
+};

invokeai/frontend/web/src/features/workflowLibrary/hooks/useGetAndLoadEmbeddedWorkflow.ts

@@ -0,0 +1,54 @@
+import { useAppToaster } from 'app/components/Toaster';
+import { useAppDispatch } from 'app/store/storeHooks';
+import { workflowLoadRequested } from 'features/nodes/store/actions';
+import { useCallback } from 'react';
+import { useTranslation } from 'react-i18next';
+import { useLazyGetImageWorkflowQuery } from 'services/api/endpoints/images';
+
+type UseGetAndLoadEmbeddedWorkflowOptions = {
+  onSuccess?: () => void;
+  onError?: () => void;
+};
+
+type UseGetAndLoadEmbeddedWorkflowReturn = {
+  getAndLoadEmbeddedWorkflow: (imageName: string) => Promise<void>;
+  getAndLoadEmbeddedWorkflowResult: ReturnType<
+    typeof useLazyGetImageWorkflowQuery
+  >[1];
+};
+
+type UseGetAndLoadEmbeddedWorkflow = (
+  options: UseGetAndLoadEmbeddedWorkflowOptions
+) => UseGetAndLoadEmbeddedWorkflowReturn;
+
+export const useGetAndLoadEmbeddedWorkflow: UseGetAndLoadEmbeddedWorkflow = ({
+  onSuccess,
+  onError,
+}) => {
+  const dispatch = useAppDispatch();
+  const toaster = useAppToaster();
+  const { t } = useTranslation();
+  const [_getAndLoadEmbeddedWorkflow, getAndLoadEmbeddedWorkflowResult] =
+    useLazyGetImageWorkflowQuery();
+  const getAndLoadEmbeddedWorkflow = useCallback(
+    async (imageName: string) => {
+      try {
+        const workflow = await _getAndLoadEmbeddedWorkflow(imageName);
+        dispatch(
+          workflowLoadRequested({ workflow: workflow.data, asCopy: true })
+        );
+        // No toast - the listener for this action does that after the workflow is loaded
+        onSuccess && onSuccess();
+      } catch {
+        toaster({
+          title: t('toast.problemRetrievingWorkflow'),
+          status: 'error',
+        });
+        onError && onError();
+      }
+    },
+    [_getAndLoadEmbeddedWorkflow, dispatch, onSuccess, toaster, t, onError]
+  );
+
+  return { getAndLoadEmbeddedWorkflow, getAndLoadEmbeddedWorkflowResult };
+};

invokeai/frontend/web/src/features/workflowLibrary/hooks/useGetAndLoadLibraryWorkflow.ts

@@ -0,0 +1,52 @@
+import { useAppToaster } from 'app/components/Toaster';
+import { useAppDispatch } from 'app/store/storeHooks';
+import { workflowLoadRequested } from 'features/nodes/store/actions';
+import { useCallback } from 'react';
+import { useTranslation } from 'react-i18next';
+import { useLazyGetWorkflowQuery } from 'services/api/endpoints/workflows';
+
+type UseGetAndLoadLibraryWorkflowOptions = {
+  onSuccess?: () => void;
+  onError?: () => void;
+};
+
+type UseGetAndLoadLibraryWorkflowReturn = {
+  getAndLoadWorkflow: (workflow_id: string) => Promise<void>;
+  getAndLoadWorkflowResult: ReturnType<typeof useLazyGetWorkflowQuery>[1];
+};
+
+type UseGetAndLoadLibraryWorkflow = (
+  arg: UseGetAndLoadLibraryWorkflowOptions
+) => UseGetAndLoadLibraryWorkflowReturn;
+
+export const useGetAndLoadLibraryWorkflow: UseGetAndLoadLibraryWorkflow = ({
+  onSuccess,
+  onError,
+}) => {
+  const dispatch = useAppDispatch();
+  const toaster = useAppToaster();
+  const { t } = useTranslation();
+  const [_getAndLoadWorkflow, getAndLoadWorkflowResult] =
+    useLazyGetWorkflowQuery();
+  const getAndLoadWorkflow = useCallback(
+    async (workflow_id: string) => {
+      try {
+        const data = await _getAndLoadWorkflow(workflow_id).unwrap();
+        dispatch(
+          workflowLoadRequested({ workflow: data.workflow, asCopy: false })
+        );
+        // No toast - the listener for this action does that after the workflow is loaded
+        onSuccess && onSuccess();
+      } catch {
+        toaster({
+          title: t('toast.problemRetrievingWorkflow'),
+          status: 'error',
+        });
+        onError && onError();
+      }
+    },
+    [_getAndLoadWorkflow, dispatch, onSuccess, toaster, t, onError]
+  );
+
+  return { getAndLoadWorkflow, getAndLoadWorkflowResult };
+};

invokeai/frontend/web/src/features/workflowLibrary/hooks/useLoadWorkflowFromFile.tsx

@@ -0,0 +1,61 @@
+import { useLogger } from 'app/logging/useLogger';
+import { useAppDispatch } from 'app/store/storeHooks';
+import { workflowLoadRequested } from 'features/nodes/store/actions';
+import { addToast } from 'features/system/store/systemSlice';
+import { makeToast } from 'features/system/util/makeToast';
+import { RefObject, useCallback } from 'react';
+import { useTranslation } from 'react-i18next';
+
+type useLoadWorkflowFromFileOptions = {
+  resetRef: RefObject<() => void>;
+};
+
+type UseLoadWorkflowFromFile = (
+  options: useLoadWorkflowFromFileOptions
+) => (file: File | null) => void;
+
+export const useLoadWorkflowFromFile: UseLoadWorkflowFromFile = ({
+  resetRef,
+}) => {
+  const dispatch = useAppDispatch();
+  const logger = useLogger('nodes');
+  const { t } = useTranslation();
+  const loadWorkflowFromFile = useCallback(
+    (file: File | null) => {
+      if (!file) {
+        return;
+      }
+      const reader = new FileReader();
+      reader.onload = async () => {
+        const rawJSON = reader.result;
+
+        try {
+          const parsedJSON = JSON.parse(String(rawJSON));
+          dispatch(
+            workflowLoadRequested({ workflow: parsedJSON, asCopy: true })
+          );
+        } catch (e) {
+          // There was a problem reading the file
+          logger.error(t('nodes.unableToLoadWorkflow'));
+          dispatch(
+            addToast(
+              makeToast({
+                title: t('nodes.unableToLoadWorkflow'),
+                status: 'error',
+              })
+            )
+          );
+          reader.abort();
+        }
+      };
+
+      reader.readAsText(file);
+
+      // Reset the file picker internal state so that the same file can be loaded again
+      resetRef.current?.();
+    },
+    [dispatch, logger, resetRef, t]
+  );
+
+  return loadWorkflowFromFile;
+};

invokeai/frontend/web/src/features/workflowLibrary/hooks/useSaveWorkflow.ts

@@ -0,0 +1,61 @@
+import { useAppToaster } from 'app/components/Toaster';
+import { useAppDispatch } from 'app/store/storeHooks';
+import { useWorkflow } from 'features/nodes/hooks/useWorkflow';
+import { workflowLoaded } from 'features/nodes/store/actions';
+import { zWorkflowV2 } from 'features/nodes/types/workflow';
+import { getWorkflowCopyName } from 'features/workflowLibrary/util/getWorkflowCopyName';
+import { useCallback } from 'react';
+import { useTranslation } from 'react-i18next';
+import {
+  useCreateWorkflowMutation,
+  useUpdateWorkflowMutation,
+} from 'services/api/endpoints/workflows';
+
+type UseSaveLibraryWorkflowReturn = {
+  saveWorkflow: () => Promise<void>;
+  isLoading: boolean;
+  isError: boolean;
+};
+
+type UseSaveLibraryWorkflow = () => UseSaveLibraryWorkflowReturn;
+
+export const useSaveLibraryWorkflow: UseSaveLibraryWorkflow = () => {
+  const { t } = useTranslation();
+  const dispatch = useAppDispatch();
+  const workflow = useWorkflow();
+  const [updateWorkflow, updateWorkflowResult] = useUpdateWorkflowMutation();
+  const [createWorkflow, createWorkflowResult] = useCreateWorkflowMutation();
+  const toaster = useAppToaster();
+  const saveWorkflow = useCallback(async () => {
+    try {
+      if (workflow.id) {
+        const data = await updateWorkflow(workflow).unwrap();
+        const updatedWorkflow = zWorkflowV2.parse(data.workflow);
+        dispatch(workflowLoaded(updatedWorkflow));
+        toaster({
+          title: t('workflows.workflowSaved'),
+          status: 'success',
+        });
+      } else {
+        const data = await createWorkflow(workflow).unwrap();
+        const createdWorkflow = zWorkflowV2.parse(data.workflow);
+        createdWorkflow.name = getWorkflowCopyName(createdWorkflow.name);
+        dispatch(workflowLoaded(createdWorkflow));
+        toaster({
+          title: t('workflows.workflowSaved'),
+          status: 'success',
+        });
+      }
+    } catch (e) {
+      toaster({
+        title: t('workflows.problemSavingWorkflow'),
+        status: 'error',
+      });
+    }
+  }, [workflow, updateWorkflow, dispatch, toaster, t, createWorkflow]);
+  return {
+    saveWorkflow,
+    isLoading: updateWorkflowResult.isLoading || createWorkflowResult.isLoading,
+    isError: updateWorkflowResult.isError || createWorkflowResult.isError,
+  };
+};

invokeai/frontend/web/src/features/workflowLibrary/hooks/useSaveWorkflowAs.ts

@@ -0,0 +1,58 @@
+import { useAppToaster } from 'app/components/Toaster';
+import { useAppDispatch } from 'app/store/storeHooks';
+import { useWorkflow } from 'features/nodes/hooks/useWorkflow';
+import { workflowLoaded } from 'features/nodes/store/actions';
+import { zWorkflowV2 } from 'features/nodes/types/workflow';
+import { useCallback } from 'react';
+import { useTranslation } from 'react-i18next';
+import { useCreateWorkflowMutation } from 'services/api/endpoints/workflows';
+
+type SaveWorkflowAsArg = {
+  name: string;
+  onSuccess?: () => void;
+  onError?: () => void;
+};
+
+type UseSaveWorkflowAsReturn = {
+  saveWorkflowAs: (arg: SaveWorkflowAsArg) => Promise<void>;
+  isLoading: boolean;
+  isError: boolean;
+};
+
+type UseSaveWorkflowAs = () => UseSaveWorkflowAsReturn;
+
+export const useSaveWorkflowAs: UseSaveWorkflowAs = () => {
+  const { t } = useTranslation();
+  const dispatch = useAppDispatch();
+  const workflow = useWorkflow();
+  const [createWorkflow, createWorkflowResult] = useCreateWorkflowMutation();
+  const toaster = useAppToaster();
+  const saveWorkflowAs = useCallback(
+    async ({ name: newName, onSuccess, onError }: SaveWorkflowAsArg) => {
+      try {
+        workflow.id = undefined;
+        workflow.name = newName;
+        const data = await createWorkflow(workflow).unwrap();
+        const createdWorkflow = zWorkflowV2.parse(data.workflow);
+        dispatch(workflowLoaded(createdWorkflow));
+        onSuccess && onSuccess();
+        toaster({
+          title: t('workflows.workflowSaved'),
+          status: 'success',
+        });
+      } catch (e) {
+        onError && onError();
+        toaster({
+          title: t('workflows.problemSavingWorkflow'),
+          status: 'error',
+        });
+      }
+    },
+    [workflow, dispatch, toaster, t, createWorkflow]
+  );
+  return {
+    saveWorkflowAs,
+    isLoading: createWorkflowResult.isLoading,
+    isError: createWorkflowResult.isError,
+  };
+};

invokeai/frontend/web/src/features/workflowLibrary/util/getWorkflowCopyName.ts

@@ -0,0 +1,2 @@
+export const getWorkflowCopyName = (name: string): string =>
+  `${name.trim()} (copy)`;