Refactor character, chapter, and story components to support offline mode

- Add `OfflineContext` and `BookContext` to components for offline state management.
- Introduce conditional logic to toggle between server API requests and offline IPC handlers for CRUD operations.
- Refine `TextEditor`, `DraftCompanion`, and other components to disable actions or features unavailable in offline mode.
- Improve error handling and user feedback in both online and offline scenarios.

app/page.tsx

@@ -474,9 +474,17 @@ function ScribeContent() {
                         return;
                     }
                     response = await window.electron.invoke('db:chapter:last', currentBook?.bookId)
+                } else {
+                    if (currentBook?.localBook) {
+                        if (!offlineMode.isDatabaseInitialized) {
+                            setCurrentChapter(undefined);
+                            return;
+                        }
+                        response = await window.electron.invoke('db:chapter:last', currentBook?.bookId)
                     } else {
                         response = await System.authGetQueryToServer<ChapterProps | null>(`chapter/last-chapter`, session.accessToken, locale, {bookid: currentBook?.bookId});
                     }
+                }
                 if (response) {
                     setCurrentChapter(response)
                 } else {

components/book/settings/BasicInformationSetting.tsx

@@ -126,6 +126,16 @@ function BasicInformationSetting(props: any, ref: any) {
                     wordCount: wordCount,
                     bookId: bookId
                 });
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<boolean>('db:book:updateBasicInformation', {
+                        title: title,
+                        subTitle: subTitle,
+                        summary: summary,
+                        publicationDate: publicationDate,
+                        wordCount: wordCount,
+                        bookId: bookId
+                    });
                 } else {
                     response = await System.authPostToServer<boolean>('book/basic-information', {
                         title: title,
@@ -136,6 +146,7 @@ function BasicInformationSetting(props: any, ref: any) {
                         bookId: bookId
                     }, userToken, lang);
                 }
+            }
             if (!response) {
                 errorMessage(t('basicInformationSetting.error.update'));
                 return;

components/book/settings/DeleteBook.tsx

@@ -8,6 +8,7 @@ import {LangContext, LangContextProps} from "@/context/LangContext";
 import {AlertContext, AlertContextProps} from "@/context/AlertContext";
 import AlertBox from "@/components/AlertBox";
 import OfflineContext, {OfflineContextType} from "@/context/OfflineContext";
+import {BookContext} from "@/context/BookContext";
 
 interface DeleteBookProps {
     bookId: string;
@@ -17,6 +18,7 @@ export default function DeleteBook({bookId}: DeleteBookProps) {
     const {session, setSession} = useContext(SessionContext);
     const {lang} = useContext<LangContextProps>(LangContext)
     const {isCurrentlyOffline} = useContext<OfflineContextType>(OfflineContext);
+    const {book} = useContext(BookContext);
     const [showConfirmBox, setShowConfirmBox] = useState<boolean>(false);
     const {errorMessage} = useContext<AlertContextProps>(AlertContext)
     
@@ -31,6 +33,11 @@ export default function DeleteBook({bookId}: DeleteBookProps) {
                 response = await window.electron.invoke<boolean>('db:book:delete', {
                     id: bookId,
                 });
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<boolean>('db:book:delete', {
+                        id: bookId,
+                    });
                 } else {
                     response = await System.authDeleteToServer<boolean>(
                         `book/delete`,
@@ -41,6 +48,7 @@ export default function DeleteBook({bookId}: DeleteBookProps) {
                         lang
                     );
                 }
+            }
             if (response) {
                 setShowConfirmBox(false);
                 const updatedBooks: BookProps[] = (session.user?.books || []).reduce((acc: BookProps[], book: BookProps): BookProps[] => {

components/book/settings/characters/CharacterComponent.tsx

@@ -69,11 +69,15 @@ export function CharacterComponent(props: any, ref: any) {
             let response: CharacterProps[];
             if (isCurrentlyOffline()) {
                 response = await window.electron.invoke<CharacterProps[]>('db:character:list', {bookid: book?.bookId});
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<CharacterProps[]>('db:character:list', {bookid: book?.bookId});
                 } else {
                     response = await System.authGetQueryToServer<CharacterProps[]>(`character/list`, session.accessToken, lang, {
                         bookid: book?.bookId,
                     });
                 }
+            }
             if (response) {
                 setCharacters(response);
             }
@@ -121,12 +125,19 @@ export function CharacterComponent(props: any, ref: any) {
                     bookId: book?.bookId,
                     character: updatedCharacter,
                 });
+            } else {
+                if (book?.localBook) {
+                    characterId = await window.electron.invoke<string>('db:character:create', {
+                        bookId: book?.bookId,
+                        character: updatedCharacter,
+                    });
                 } else {
                     characterId = await System.authPostToServer<string>(`character/add`, {
                         bookId: book?.bookId,
                         character: updatedCharacter,
                     }, session.accessToken, lang);
                 }
+            }
             if (!characterId) {
                 errorMessage(t("characterComponent.errorAddCharacter"));
                 return;
@@ -150,11 +161,17 @@ export function CharacterComponent(props: any, ref: any) {
                 response = await window.electron.invoke<boolean>('db:character:update', {
                     character: updatedCharacter,
                 });
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<boolean>('db:character:update', {
+                        character: updatedCharacter,
+                    });
                 } else {
                     response = await System.authPostToServer<boolean>(`character/update`, {
                         character: updatedCharacter,
                     }, session.accessToken, lang);
                 }
+            }
             if (!response) {
                 errorMessage(t("characterComponent.errorUpdateCharacter"));
                 return;
@@ -204,6 +221,13 @@ export function CharacterComponent(props: any, ref: any) {
                             type: section,
                             name: value.name,
                         });
+                    } else {
+                        if (book?.localBook) {
+                            attributeId = await window.electron.invoke<string>('db:character:attribute:add', {
+                                characterId: selectedCharacter.id,
+                                type: section,
+                                name: value.name,
+                            });
                         } else {
                             attributeId = await System.authPostToServer<string>(`character/attribute/add`, {
                                 characterId: selectedCharacter.id,
@@ -211,6 +235,7 @@ export function CharacterComponent(props: any, ref: any) {
                                 name: value.name,
                             }, session.accessToken, lang);
                         }
+                    }
                     if (!attributeId) {
                         errorMessage(t("characterComponent.errorAddAttribute"));
                         return;
@@ -250,11 +275,17 @@ export function CharacterComponent(props: any, ref: any) {
                         response = await window.electron.invoke<boolean>('db:character:attribute:delete', {
                             attributeId: attrId,
                         });
+                    } else {
+                        if (book?.localBook) {
+                            response = await window.electron.invoke<boolean>('db:character:attribute:delete', {
+                                attributeId: attrId,
+                            });
                         } else {
                             response = await System.authDeleteToServer<boolean>(`character/attribute/delete`, {
                                 attributeId: attrId,
                             }, session.accessToken, lang);
                         }
+                    }
                     if (!response) {
                         errorMessage(t("characterComponent.errorRemoveAttribute"));
                         return;

components/book/settings/characters/CharacterDetail.tsx

@@ -30,6 +30,7 @@ import CharacterSectionElement from "@/components/book/settings/characters/Chara
 import {useTranslations} from "next-intl";
 import {LangContext} from "@/context/LangContext";
 import OfflineContext, {OfflineContextType} from "@/context/OfflineContext";
+import {BookContext} from "@/context/BookContext";
 
 interface CharacterDetailProps {
     selectedCharacter: CharacterProps | null;
@@ -57,6 +58,7 @@ export default function CharacterDetail(
     const t = useTranslations();
     const {lang} = useContext(LangContext);
     const {isCurrentlyOffline} = useContext<OfflineContextType>(OfflineContext);
+    const {book} = useContext(BookContext);
     const {session} = useContext(SessionContext);
     const {errorMessage} = useContext(AlertContext);
     
@@ -73,11 +75,17 @@ export default function CharacterDetail(
                 response = await window.electron.invoke<CharacterAttribute>('db:character:attributes', {
                     characterId: selectedCharacter?.id,
                 });
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<CharacterAttribute>('db:character:attributes', {
+                        characterId: selectedCharacter?.id,
+                    });
                 } else {
                     response = await System.authGetQueryToServer<CharacterAttribute>(`character/attribute`, session.accessToken, lang, {
                         characterId: selectedCharacter?.id,
                     });
                 }
+            }
             if (response) {
                 setSelectedCharacter({
                     id: selectedCharacter?.id ?? '',

components/book/settings/guide-line/GuideLineSetting.tsx

@@ -80,9 +80,13 @@ function GuideLineSetting(props: any, ref: any) {
             let response: GuideLineAI;
             if (isCurrentlyOffline()) {
                 response = await window.electron.invoke<GuideLineAI>('db:book:guideline:ai:get', {id: bookId});
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<GuideLineAI>('db:book:guideline:ai:get', {id: bookId});
                 } else {
                     response = await System.authGetQueryToServer<GuideLineAI>(`book/ai/guideline`, userToken, lang, {id: bookId});
                 }
+            }
             if (response) {
                 setPlotSummary(response.globalResume);
                 setVerbTense(response.verbeTense?.toString() || '');
@@ -106,6 +110,9 @@ function GuideLineSetting(props: any, ref: any) {
             let response: GuideLine;
             if (isCurrentlyOffline()) {
                 response = await window.electron.invoke<GuideLine>('db:book:guideline:get', {id: bookId});
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<GuideLine>('db:book:guideline:get', {id: bookId});
                 } else {
                     response = await System.authGetQueryToServer<GuideLine>(
                         `book/guide-line`,
@@ -114,6 +121,7 @@ function GuideLineSetting(props: any, ref: any) {
                         {id: bookId},
                     );
                 }
+            }
             if (response) {
                 setTone(response.tone);
                 setAtmosphere(response.atmosphere);
@@ -153,6 +161,9 @@ function GuideLineSetting(props: any, ref: any) {
             };
             if (isCurrentlyOffline()) {
                 response = await window.electron.invoke<boolean>('db:book:guideline:update', guidelineData);
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<boolean>('db:book:guideline:update', guidelineData);
                 } else {
                     response = await System.authPostToServer<boolean>(
                         'book/guide-line',
@@ -161,6 +172,7 @@ function GuideLineSetting(props: any, ref: any) {
                         lang,
                     );
                 }
+            }
             if (!response) {
                 errorMessage(t("guideLineSetting.saveError"));
                 return;
@@ -177,7 +189,32 @@ function GuideLineSetting(props: any, ref: any) {
     
     async function saveQuillSense(): Promise<void> {
         try {
-            const response: boolean = await System.authPostToServer<boolean>(
+            let response: boolean;
+            if (isCurrentlyOffline()) {
+                response = await window.electron.invoke<boolean>('db:book:guideline:ai:update', {
+                    bookId: bookId,
+                    plotSummary: plotSummary,
+                    verbTense: verbTense,
+                    narrativeType: narrativeType,
+                    dialogueType: dialogueType,
+                    toneAtmosphere: toneAtmosphere,
+                    language: language,
+                    themes: themes,
+                });
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<boolean>('db:book:guideline:ai:update', {
+                        bookId: bookId,
+                        plotSummary: plotSummary,
+                        verbTense: verbTense,
+                        narrativeType: narrativeType,
+                        dialogueType: dialogueType,
+                        toneAtmosphere: toneAtmosphere,
+                        language: language,
+                        themes: themes,
+                    });
+                } else {
+                    response = await System.authPostToServer<boolean>(
                         'quillsense/book/guide-line',
                         {
                             bookId: bookId,
@@ -192,6 +229,8 @@ function GuideLineSetting(props: any, ref: any) {
                         userToken,
                         lang,
                     );
+                }
+            }
             if (response) {
                 successMessage(t("guideLineSetting.saveSuccess"));
             } else {

components/book/settings/locations/LocationComponent.tsx

@@ -63,11 +63,15 @@ export function LocationComponent(props: any, ref: any) {
             let response: LocationProps[];
             if (isCurrentlyOffline()) {
                 response = await window.electron.invoke<LocationProps[]>('db:location:all', {bookid: bookId});
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<LocationProps[]>('db:location:all', {bookid: bookId});
                 } else {
                     response = await System.authGetQueryToServer<LocationProps[]>(`location/all`, token, lang, {
                         bookid: bookId,
                     });
                 }
+            }
             if (response && response.length > 0) {
                 setSections(response);
             }
@@ -92,12 +96,19 @@ export function LocationComponent(props: any, ref: any) {
                     bookId: bookId,
                     locationName: newSectionName,
                 });
+            } else {
+                if (book?.localBook) {
+                    sectionId = await window.electron.invoke<string>('db:location:section:add', {
+                        bookId: bookId,
+                        locationName: newSectionName,
+                    });
                 } else {
                     sectionId = await System.authPostToServer<string>(`location/section/add`, {
                         bookId: bookId,
                         locationName: newSectionName,
                     }, token, lang);
                 }
+            }
             if (!sectionId) {
                 errorMessage(t('locationComponent.errorUnknownAddSection'));
                 return;
@@ -131,6 +142,13 @@ export function LocationComponent(props: any, ref: any) {
                     locationId: sectionId,
                     elementName: newElementNames[sectionId],
                 });
+            } else {
+                if (book?.localBook) {
+                    elementId = await window.electron.invoke<string>('db:location:element:add', {
+                        bookId: bookId,
+                        locationId: sectionId,
+                        elementName: newElementNames[sectionId],
+                    });
                 } else {
                     elementId = await System.authPostToServer<string>(`location/element/add`, {
                             bookId: bookId,
@@ -139,6 +157,7 @@ export function LocationComponent(props: any, ref: any) {
                         },
                         token, lang);
                 }
+            }
             if (!elementId) {
                 errorMessage(t('locationComponent.errorUnknownAddElement'));
                 return;
@@ -197,12 +216,19 @@ export function LocationComponent(props: any, ref: any) {
                     elementId: sections[sectionIndex].elements[elementIndex].id,
                     subElementName: newSubElementNames[elementIndex],
                 });
+            } else {
+                if (book?.localBook) {
+                    subElementId = await window.electron.invoke<string>('db:location:subelement:add', {
+                        elementId: sections[sectionIndex].elements[elementIndex].id,
+                        subElementName: newSubElementNames[elementIndex],
+                    });
                 } else {
                     subElementId = await System.authPostToServer<string>(`location/sub-element/add`, {
                         elementId: sections[sectionIndex].elements[elementIndex].id,
                         subElementName: newSubElementNames[elementIndex],
                     }, token, lang);
                 }
+            }
             if (!subElementId) {
                 errorMessage(t('locationComponent.errorUnknownAddSubElement'));
                 return;
@@ -253,11 +279,17 @@ export function LocationComponent(props: any, ref: any) {
                 response = await window.electron.invoke<boolean>('db:location:element:delete', {
                     elementId: elementId,
                 });
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<boolean>('db:location:element:delete', {
+                        elementId: elementId,
+                    });
                 } else {
                     response = await System.authDeleteToServer<boolean>(`location/element/delete`, {
                         elementId: elementId,
                     }, token, lang);
                 }
+            }
             if (!response) {
                 errorMessage(t('locationComponent.errorUnknownDeleteElement'));
                 return;
@@ -287,11 +319,17 @@ export function LocationComponent(props: any, ref: any) {
                 response = await window.electron.invoke<boolean>('db:location:subelement:delete', {
                     subElementId: subElementId,
                 });
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<boolean>('db:location:subelement:delete', {
+                        subElementId: subElementId,
+                    });
                 } else {
                     response = await System.authDeleteToServer<boolean>(`location/sub-element/delete`, {
                         subElementId: subElementId,
                     }, token, lang);
                 }
+            }
             if (!response) {
                 errorMessage(t('locationComponent.errorUnknownDeleteSubElement'));
                 return;
@@ -316,11 +354,17 @@ export function LocationComponent(props: any, ref: any) {
                 response = await window.electron.invoke<boolean>('db:location:delete', {
                     locationId: sectionId,
                 });
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<boolean>('db:location:delete', {
+                        locationId: sectionId,
+                    });
                 } else {
                     response = await System.authDeleteToServer<boolean>(`location/delete`, {
                         locationId: sectionId,
                     }, token, lang);
                 }
+            }
             if (!response) {
                 errorMessage(t('locationComponent.errorUnknownDeleteSection'));
                 return;
@@ -343,11 +387,17 @@ export function LocationComponent(props: any, ref: any) {
                 response = await window.electron.invoke<boolean>('db:location:update', {
                     locations: sections,
                 });
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<boolean>('db:location:update', {
+                        locations: sections,
+                    });
                 } else {
                     response = await System.authPostToServer<boolean>(`location/update`, {
                         locations: sections,
                     }, token, lang);
                 }
+            }
             if (!response) {
                 errorMessage(t('locationComponent.errorUnknownSave'));
                 return;

components/book/settings/story/Act.tsx

@@ -79,12 +79,19 @@ export default function Act({acts, setActs, mainChapters}: ActProps) {
                     bookId,
                     name: newIncidentTitle,
                 });
+            } else {
+                if (book?.localBook) {
+                    incidentId = await window.electron.invoke<string>('db:book:incident:add', {
+                        bookId,
+                        name: newIncidentTitle,
+                    });
                 } else {
                     incidentId = await System.authPostToServer<string>('book/incident/new', {
                         bookId,
                         name: newIncidentTitle,
                     }, token, lang);
                 }
+            }
             if (!incidentId) {
                 errorMessage(t('errorAddIncident'));
                 return;
@@ -124,12 +131,19 @@ export default function Act({acts, setActs, mainChapters}: ActProps) {
                     bookId,
                     incidentId,
                 });
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<boolean>('db:book:incident:remove', {
+                        bookId,
+                        incidentId,
+                    });
                 } else {
                     response = await System.authDeleteToServer<boolean>('book/incident/remove', {
                         bookId,
                         incidentId,
                     }, token, lang);
                 }
+            }
             if (!response) {
                 errorMessage(t('errorDeleteIncident'));
                 return;
@@ -165,6 +179,13 @@ export default function Act({acts, setActs, mainChapters}: ActProps) {
                     name: newPlotPointTitle,
                     incidentId: selectedIncidentId,
                 });
+            } else {
+                if (book?.localBook) {
+                    plotId = await window.electron.invoke<string>('db:book:plot:add', {
+                        bookId,
+                        name: newPlotPointTitle,
+                        incidentId: selectedIncidentId,
+                    });
                 } else {
                     plotId = await System.authPostToServer<string>('book/plot/new', {
                         bookId,
@@ -172,6 +193,7 @@ export default function Act({acts, setActs, mainChapters}: ActProps) {
                         incidentId: selectedIncidentId,
                     }, token, lang);
                 }
+            }
             if (!plotId) {
                 errorMessage(t('errorAddPlotPoint'));
                 return;
@@ -211,11 +233,17 @@ export default function Act({acts, setActs, mainChapters}: ActProps) {
                 response = await window.electron.invoke<boolean>('db:book:plot:remove', {
                     plotId: plotPointId,
                 });
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<boolean>('db:book:plot:remove', {
+                        plotId: plotPointId,
+                    });
                 } else {
                     response = await System.authDeleteToServer<boolean>('book/plot/remove', {
                         plotId: plotPointId,
                     }, token, lang);
                 }
+            }
             if (!response) {
                 errorMessage(t('errorDeletePlotPoint'));
                 return;
@@ -263,9 +291,13 @@ export default function Act({acts, setActs, mainChapters}: ActProps) {
             };
             if (isCurrentlyOffline()) {
                 linkId = await window.electron.invoke<string>('db:chapter:information:add', linkData);
+            } else {
+                if (book?.localBook) {
+                    linkId = await window.electron.invoke<string>('db:chapter:information:add', linkData);
                 } else {
                     linkId = await System.authPostToServer<string>('chapter/resume/add', linkData, token, lang);
                 }
+            }
             if (!linkId) {
                 errorMessage(t('errorLinkChapter'));
                 return;
@@ -345,11 +377,17 @@ export default function Act({acts, setActs, mainChapters}: ActProps) {
                 response = await window.electron.invoke<boolean>('db:chapter:information:remove', {
                     chapterInfoId,
                 });
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<boolean>('db:chapter:information:remove', {
+                        chapterInfoId,
+                    });
                 } else {
                     response = await System.authDeleteToServer<boolean>('chapter/resume/remove', {
                         chapterInfoId,
                     }, token, lang);
                 }
+            }
             if (!response) {
                 errorMessage(t('errorUnlinkChapter'));
                 return;

components/book/settings/story/Issue.tsx

@@ -41,12 +41,19 @@ export default function Issues({issues, setIssues}: IssuesProps) {
                     bookId,
                     name: newIssueName,
                 });
+            } else {
+                if (book?.localBook) {
+                    issueId = await window.electron.invoke<string>('db:book:issue:add', {
+                        bookId,
+                        name: newIssueName,
+                    });
                 } else {
                     issueId = await System.authPostToServer<string>('book/issue/add', {
                         bookId,
                         name: newIssueName,
                     }, token, lang);
                 }
+            }
             if (!issueId) {
                 errorMessage(t("issues.errorAdd"));
                 return;
@@ -80,6 +87,12 @@ export default function Issues({issues, setIssues}: IssuesProps) {
                     bookId,
                     issueId,
                 });
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<boolean>('db:book:issue:remove', {
+                        bookId,
+                        issueId,
+                    });
                 } else {
                     response = await System.authDeleteToServer<boolean>(
                         'book/issue/remove',
@@ -91,6 +104,7 @@ export default function Issues({issues, setIssues}: IssuesProps) {
                         lang
                     );
                 }
+            }
             if (response) {
                 const updatedIssues: Issue[] = issues.filter((issue: Issue): boolean => issue.id !== issueId,);
                 setIssues(updatedIssues);

components/book/settings/story/MainChapter.tsx

@@ -87,9 +87,13 @@ export default function MainChapter({chapters, setChapters}: MainChapterProps) {
             };
             if (isCurrentlyOffline()) {
                 response = await window.electron.invoke<boolean>('db:chapter:remove', deleteData);
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<boolean>('db:chapter:remove', deleteData);
                 } else {
                     response = await System.authDeleteToServer<boolean>('chapter/remove', deleteData, token, lang);
                 }
+            }
             if (!response) {
                 errorMessage(t("mainChapter.errorDelete"));
             }
@@ -119,9 +123,13 @@ export default function MainChapter({chapters, setChapters}: MainChapterProps) {
             };
             if (isCurrentlyOffline()) {
                 responseId = await window.electron.invoke<string>('db:chapter:add', chapterData);
+            } else {
+                if (book?.localBook) {
+                    responseId = await window.electron.invoke<string>('db:chapter:add', chapterData);
                 } else {
                     responseId = await System.authPostToServer<string>('chapter/add', chapterData, token);
                 }
+            }
             if (!responseId) {
                 errorMessage(t("mainChapter.errorAdd"));
                 return;

components/book/settings/story/StorySetting.tsx

@@ -73,11 +73,15 @@ export function Story(props: any, ref: any) {
             let response: StoryFetchData;
             if (isCurrentlyOffline()) {
                 response = await window.electron.invoke<StoryFetchData>('db:book:story:get', {bookid: bookId});
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<StoryFetchData>('db:book:story:get', {bookid: bookId});
                 } else {
                     response = await System.authGetQueryToServer<StoryFetchData>(`book/story`, userToken, lang, {
                         bookid: bookId,
                     });
                 }
+            }
             if (response) {
                 setActs(response.acts);
                 setMainChapters(response.mainChapter);
@@ -135,9 +139,13 @@ export function Story(props: any, ref: any) {
             };
             if (isCurrentlyOffline()) {
                 response = await window.electron.invoke<boolean>('db:book:story:update', storyData);
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<boolean>('db:book:story:update', storyData);
                 } else {
                     response = await System.authPostToServer<boolean>('book/story', storyData, userToken, lang);
                 }
+            }
             if (!response) {
                 errorMessage(t("story.errorSave"))
             }

components/book/settings/world/WorldElement.tsx

@@ -12,6 +12,7 @@ import InputField from "@/components/form/InputField";
 import {useTranslations} from "next-intl";
 import {LangContext, LangContextProps} from "@/context/LangContext";
 import OfflineContext, {OfflineContextType} from "@/context/OfflineContext";
+import {BookContext} from "@/context/BookContext";
 
 interface WorldElementInputProps {
     sectionLabel: string;
@@ -22,6 +23,7 @@ export default function WorldElementComponent({sectionLabel, sectionType}: World
     const t = useTranslations();
     const {lang} = useContext<LangContextProps>(LangContext);
     const {isCurrentlyOffline} = useContext<OfflineContextType>(OfflineContext);
+    const {book} = useContext(BookContext);
     const {worlds, setWorlds, selectedWorldIndex} = useContext(WorldContext);
     const {errorMessage, successMessage} = useContext(AlertContext);
     const {session} = useContext(SessionContext);
@@ -39,11 +41,17 @@ export default function WorldElementComponent({sectionLabel, sectionType}: World
                 response = await window.electron.invoke<boolean>('db:book:world:element:remove', {
                     elementId: elementId,
                 });
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<boolean>('db:book:world:element:remove', {
+                        elementId: elementId,
+                    });
                 } else {
                     response = await System.authDeleteToServer<boolean>('book/world/element/delete', {
                         elementId: elementId,
                     }, session.accessToken, lang);
                 }
+            }
             if (!response) {
                 errorMessage(t("worldSetting.unknownError"))
             }
@@ -75,6 +83,13 @@ export default function WorldElementComponent({sectionLabel, sectionType}: World
                     worldId: worlds[selectedWorldIndex].id,
                     elementName: newElementName,
                 });
+            } else {
+                if (book?.localBook) {
+                    elementId = await window.electron.invoke<string>('db:book:world:element:add', {
+                        elementType: section,
+                        worldId: worlds[selectedWorldIndex].id,
+                        elementName: newElementName,
+                    });
                 } else {
                     elementId = await System.authPostToServer('book/world/element/add', {
                         elementType: section,
@@ -82,6 +97,7 @@ export default function WorldElementComponent({sectionLabel, sectionType}: World
                         elementName: newElementName,
                     }, session.accessToken, lang);
                 }
+            }
             if (!elementId) {
                 errorMessage(t("worldSetting.unknownError"))
                 return;

components/book/settings/world/WorldSetting.tsx

@@ -54,11 +54,15 @@ export function WorldSetting(props: any, ref: any) {
             let response: WorldProps[];
             if (isCurrentlyOffline()) {
                 response = await window.electron.invoke<WorldProps[]>('db:book:worlds:get', {bookid: bookId});
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<WorldProps[]>('db:book:worlds:get', {bookid: bookId});
                 } else {
                     response = await System.authGetQueryToServer<WorldProps[]>(`book/worlds`, session.accessToken, lang, {
                         bookid: bookId,
                     });
                 }
+            }
             if (response) {
                 setWorlds(response);
                 const formattedWorlds: SelectBoxProps[] = response.map(
@@ -90,12 +94,19 @@ export function WorldSetting(props: any, ref: any) {
                     worldName: newWorldName,
                     bookId: bookId,
                 });
+            } else {
+                if (book?.localBook) {
+                    worldId = await window.electron.invoke<string>('db:book:world:add', {
+                        worldName: newWorldName,
+                        bookId: bookId,
+                    });
                 } else {
                     worldId = await System.authPostToServer<string>('book/world/add', {
                         worldName: newWorldName,
                         bookId: bookId,
                     }, session.accessToken, lang);
                 }
+            }
             if (!worldId) {
                 errorMessage(t("worldSetting.addWorldError"));
                 return;
@@ -146,12 +157,19 @@ export function WorldSetting(props: any, ref: any) {
                     world: worlds[selectedWorldIndex],
                     bookId: bookId,
                 });
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<boolean>('db:book:world:update', {
+                        world: worlds[selectedWorldIndex],
+                        bookId: bookId,
+                    });
                 } else {
                     response = await System.authPutToServer<boolean>('book/world/update', {
                         world: worlds[selectedWorldIndex],
                         bookId: bookId,
                     }, session.accessToken, lang);
                 }
+            }
             if (!response) {
                 errorMessage(t("worldSetting.updateWorldError"));
                 return;

components/editor/DraftCompanion.tsx

@@ -32,6 +32,7 @@ import {LangContext, LangContextProps} from "@/context/LangContext";
 import {BookTags} from "@/lib/models/Book";
 import {AIUsageContext, AIUsageContextProps} from "@/context/AIUsageContext";
 import {configs} from "@/lib/configs";
+import OfflineContext, {OfflineContextType} from "@/context/OfflineContext";
 
 interface CompanionContent {
     version: number;
@@ -43,6 +44,7 @@ export default function DraftCompanion() {
     const t = useTranslations();
     const {setTotalPrice, setTotalCredits} = useContext<AIUsageContextProps>(AIUsageContext)
     const {lang} = useContext<LangContextProps>(LangContext)
+    const {isCurrentlyOffline} = useContext<OfflineContextType>(OfflineContext);
 
     const mainEditor: Editor | null = useEditor({
         extensions: [
@@ -95,7 +97,7 @@ export default function DraftCompanion() {
     
     const isGPTEnabled: boolean = QuillSense.isOpenAIEnabled(session);
     const isSubTierTree: boolean = QuillSense.getSubLevel(session) === 3;
-    const hasAccess: boolean = isGPTEnabled || isSubTierTree;
+    const hasAccess: boolean = (isGPTEnabled || isSubTierTree) && !isCurrentlyOffline() && !book?.localBook;
     
     useEffect((): void => {
         getDraftContent().then();
@@ -106,11 +108,28 @@ export default function DraftCompanion() {
     
     async function getDraftContent(): Promise<void> {
         try {
-            const response: CompanionContent = await System.authGetQueryToServer<CompanionContent>(`chapter/content/companion`, session.accessToken, lang, {
+            let response: CompanionContent | null;
+            if (isCurrentlyOffline()) {
+                response = await window.electron.invoke<CompanionContent>('db:chapter:content:companion', {
                     bookid: book?.bookId,
                     chapterid: chapter?.chapterId,
                     version: chapter?.chapterContent.version,
                 });
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<CompanionContent>('db:chapter:content:companion', {
+                        bookid: book?.bookId,
+                        chapterid: chapter?.chapterId,
+                        version: chapter?.chapterContent.version,
+                    });
+                } else {
+                    response = await System.authGetQueryToServer<CompanionContent>(`chapter/content/companion`, session.accessToken, lang, {
+                        bookid: book?.bookId,
+                        chapterid: chapter?.chapterId,
+                        version: chapter?.chapterContent.version,
+                    });
+                }
+            }
             if (response && mainEditor) {
                 mainEditor.commands.setContent(JSON.parse(response.content));
                 setDraftVersion(response.version);
@@ -145,9 +164,18 @@ export default function DraftCompanion() {
     
     async function fetchTags(): Promise<void> {
         try {
-            const responseTags: BookTags = await System.authGetQueryToServer<BookTags>(`book/tags`, session.accessToken, lang, {
+            let responseTags: BookTags | null;
+            if (isCurrentlyOffline()) {
+                responseTags = await window.electron.invoke<BookTags>('db:book:tags', book?.bookId);
+            } else {
+                if (book?.localBook) {
+                    responseTags = await window.electron.invoke<BookTags>('db:book:tags', book?.bookId);
+                } else {
+                    responseTags = await System.authGetQueryToServer<BookTags>(`book/tags`, session.accessToken, lang, {
                         bookId: book?.bookId
                     });
+                }
+            }
             if (responseTags) {
                 setCharacters(responseTags.characters);
                 setLocations(responseTags.locations);

components/editor/TextEditor.tsx

@@ -22,6 +22,7 @@ import {ChapterContext} from '@/context/ChapterContext';
 import System from '@/lib/models/System';
 import {AlertContext} from '@/context/AlertContext';
 import {SessionContext} from "@/context/SessionContext";
+import {BookContext} from '@/context/BookContext';
 import DraftCompanion from "@/components/editor/DraftCompanion";
 import GhostWriter from "@/components/ghostwriter/GhostWriter";
 import SubmitButtonWLoading from "@/components/form/SubmitButtonWLoading";
@@ -135,6 +136,7 @@ export default function TextEditor() {
     const {lang} = useContext<LangContextProps>(LangContext)
     const {editor} = useContext(EditorContext);
     const {chapter} = useContext(ChapterContext);
+    const {book} = useContext(BookContext);
     const {errorMessage, successMessage} = useContext(AlertContext);
     const {session} = useContext(SessionContext);
     const {isCurrentlyOffline} = useContext<OfflineContextType>(OfflineContext);
@@ -293,6 +295,15 @@ export default function TextEditor() {
                     totalWordCount: editor.getText().length,
                     currentTime: mainTimer
                 })
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<boolean>('db:chapter:content:save',{
+                        chapterId,
+                        version,
+                        content,
+                        totalWordCount: editor.getText().length,
+                        currentTime: mainTimer
+                    })
                 } else {
                     response = await System.authPostToServer<boolean>(`chapter/content`, {
                         chapterId,
@@ -302,6 +313,7 @@ export default function TextEditor() {
                         currentTime: mainTimer
                     }, session?.accessToken, lang);
                 }
+            }
             if (!response) {
                 errorMessage(t('editor.error.savedFailed'));
                 setIsSaving(false);
@@ -467,7 +479,7 @@ export default function TextEditor() {
                         onClick={handleShowUserSettings}
                         icon={faCog}
                     />
-                    {chapter?.chapterContent.version === 2 && !isCurrentlyOffline() && (
+                    {chapter?.chapterContent.version === 2 && !isCurrentlyOffline() && !book?.localBook && (
                         <CollapsableButton
                             showCollapsable={showGhostWriter}
                             text={t("textEditor.ghostWriter")}

components/rightbar/ComposerRightBar.tsx

@@ -171,7 +171,7 @@ export default function ComposerRightBar() {
             <div className="bg-tertiary border-l border-secondary/50 p-3 flex flex-col space-y-3 shadow-xl">
                 {book ? editorComponents
                     .filter((component: PanelComponent):boolean => {
-                        return !(isCurrentlyOffline() && component.id === 1);
+                        return !((isCurrentlyOffline() || book?.localBook) && component.id === 1);
                     })
                     .map((component: PanelComponent) => (
                     <button