funkophile 0.2.3 → 0.2.5

package/dev.js

@@ -0,0 +1,59 @@
+import chokidar from 'chokidar';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const execAsync = promisify(exec);
+
+console.log('Watching for file changes...');
+
+const watcher = chokidar.watch('**/*.ts', {
+  ignored: /node_modules/,
+  persistent: true,
+  ignoreInitial: true
+});
+
+let buildInProgress = false;
+
+const runBuild = async () => {
+  if (buildInProgress) {
+    console.log('Build already in progress, skipping...');
+    return;
+  }
+  
+  buildInProgress = true;
+  console.log('File changes detected. Rebuilding...');
+  
+  try {
+    const { stdout, stderr } = await execAsync('yarn transpile');
+    if (stdout) console.log(stdout);
+    if (stderr) console.error(stderr);
+    console.log('Rebuild completed successfully!');
+  } catch (error) {
+    console.error('Build failed:', error);
+  } finally {
+    buildInProgress = false;
+  }
+};
+
+watcher.on('change', runBuild);
+watcher.on('add', runBuild);
+watcher.on('unlink', runBuild);
+
+// Initial build
+console.log('Performing initial build...');
+execAsync('yarn transpile')
+  .then(({ stdout, stderr }) => {
+    if (stdout) console.log(stdout);
+    if (stderr) console.error(stderr);
+    console.log('Initial build completed!');
+    console.log('Watching for changes...');
+  })
+  .catch(error => {
+    console.error('Initial build failed:', error);
+    process.exit(1);
+  });

package/dist/esm/funkophileHelpers.js

@@ -1,32 +1,83 @@
 import { createSelector } from "reselect";
+import path from "path";
 export const contentsOfFiles = (selector) => {
     return createSelector([selector], (selected) => {
-        return Object.keys(selected).reduce((mm, k) => mm + selected[k], "");
+        if (selected === undefined || selected === null) {
+            throw new Error(`contentsOfFiles: selected is ${selected}. Make sure the selector is pointing to valid state.`);
+        }
+        return Object.keys(selected).reduce((mm, k) => mm + (selected[k] || ""), "");
     });
 };
 export const contentOfFile = (selector) => {
     return createSelector([selector], (selected) => {
-        try {
-            return selected[Object.keys(selected)[0]];
+        if (selected === undefined || selected === null) {
+            throw new Error(`contentOfFile: selected is ${selected}. Make sure the selector is pointing to valid state.`);
         }
-        catch (e) {
-            console.error("error", e);
-            console.error("selected", selected);
-            console.error("selector", selector);
-            process.exit(-1);
+        const keys = Object.keys(selected);
+        if (keys.length === 0) {
+            throw new Error(`contentOfFile: selected object is empty. No files found. This may be because the input pattern didn't match any files.`);
         }
+        return selected[keys[0]] || "";
     });
 };
 export const srcAndContentOfFile = (selector, key) => {
     return createSelector([selector], (selected) => {
+        if (selected === undefined || selected === null) {
+            throw new Error(`srcAndContentOfFile: selected is ${selected}. Make sure the selector is pointing to valid state.`);
+        }
+        const keys = Object.keys(selected);
+        if (keys.length === 0) {
+            throw new Error(`srcAndContentOfFile: selected object is empty. No files found. This may be because the input pattern didn't match any files.`);
+        }
+        // Try exact match first
+        let matchingKey = keys.find(k => k === key);
+        // If exact match not found, try to find by resolving to absolute path
+        if (!matchingKey) {
+            // Try to resolve the key to an absolute path
+            const resolvedKey = path.resolve(process.cwd(), key);
+            matchingKey = keys.find(k => k === resolvedKey);
+        }
+        // If still not found, try to find by basename
+        if (!matchingKey) {
+            const keyBasename = path.basename(key);
+            matchingKey = keys.find(k => path.basename(k) === keyBasename);
+        }
+        // If still not found, try to find by relative path
+        if (!matchingKey) {
+            const relativeKey = path.relative(process.cwd(), key);
+            matchingKey = keys.find(k => {
+                const kRelative = path.relative(process.cwd(), k);
+                return kRelative === relativeKey;
+            });
+        }
+        // If still not found, try to find by ending with the key
+        if (!matchingKey) {
+            matchingKey = keys.find(k => k.endsWith(key));
+        }
+        // If still not found, try to find by the key ending with the path
+        if (!matchingKey) {
+            matchingKey = keys.find(k => k.endsWith(key.replace('./', '')));
+        }
+        // If still not found, try to find by the key being a relative path that matches
+        if (!matchingKey) {
+            // Remove leading './' if present
+            const cleanKey = key.startsWith('./') ? key.slice(2) : key;
+            matchingKey = keys.find(k => k.endsWith(cleanKey));
+        }
+        if (!matchingKey) {
+            throw new Error(`srcAndContentOfFile: key "${key}" not found in selected object. Available keys: ${keys.join(', ')}`);
+        }
         return {
-            src: key,
-            content: selected[key],
+            src: matchingKey,
+            content: selected[matchingKey],
         };
     });
 };
 export const srcAndContentOfFiles = (selector) => {
     return createSelector([selector], (selected) => {
+        if (selected === undefined || selected === null) {
+            throw new Error(`srcAndContentOfFiles: selected is ${selected}. Make sure the selector is pointing to valid state.`);
+        }
         const keys = Object.keys(selected);
         return keys.map((key) => {
             return {

package/dist/esm/index.d.ts

@@ -4,6 +4,7 @@ declare const _default: (funkophileConfig: {
     options: {
         inFolder: string;
         outFolder: string;
+        port?: number;
     };
     encodings: Record<string, string[]>;
     inputs: Record<string, string>;

package/dist/esm/index.js

@@ -4,8 +4,10 @@ import { createStore } from "redux";
 import fs from "fs";
 import fse from "fs-extra";
 import { glob } from "glob";
+import http from "http";
 import path from "path";
 import Promise from "bluebird";
+import url from "url";
 export default (funkophileConfig) => {
     Promise.config({
         cancellation: true,
@@ -77,6 +79,9 @@ export default (funkophileConfig) => {
         ...funkophileConfig.initialState,
         timestamp: Date.now(),
     }, action) => {
+        if (state === undefined) {
+            throw new Error("Redux state is undefined. This should never happen.");
+        }
         // console.log("\u001b[7m\u001b[35m ||| Redux recieved action \u001b[0m", action.type)
         if (!action.type.includes("@@redux")) {
             if (action.type === INITIALIZE) {
@@ -116,54 +121,188 @@ export default (funkophileConfig) => {
     const finalSelector = funkophileConfig.outputs(Object.keys(funkophileConfig.inputs).reduce((mm, inputKey) => {
         return {
             ...mm,
-            [inputKey]: createSelector([(x) => x], (root) => root[inputKey]),
+            [inputKey]: createSelector([(x) => x], (root) => {
+                const result = root[inputKey];
+                if (result === undefined) {
+                    throw new Error(`Input key "${inputKey}" is undefined in state. ` +
+                        `This means no files were found for the pattern "${funkophileConfig.inputs[inputKey]}". ` +
+                        `Available state keys: ${Object.keys(root).join(', ')}`);
+                }
+                return result;
+            }),
         };
     }, {}));
+    // Start HTTP server in watch mode
+    let server = null;
+    if (funkophileConfig.mode === "watch") {
+        const port = funkophileConfig.options.port || 8080;
+        server = http.createServer((req, res) => {
+            if (!req.url) {
+                res.statusCode = 400;
+                res.end('Bad Request');
+                return;
+            }
+            const parsedUrl = url.parse(req.url);
+            let pathname = parsedUrl.pathname;
+            // Default to index.html if the path ends with /
+            if (pathname && pathname.endsWith('/')) {
+                pathname += 'index.html';
+            }
+            // Remove leading slash
+            const filePath = pathname ? pathname.substring(1) : 'index.html';
+            // Construct the full path to the file
+            const fullPath = path.join(process.cwd(), funkophileConfig.options.outFolder, filePath);
+            // Check if file exists
+            fs.access(fullPath, fs.constants.F_OK, (err) => {
+                if (err) {
+                    // Try with .html extension
+                    const htmlPath = fullPath + '.html';
+                    fs.access(htmlPath, fs.constants.F_OK, (htmlErr) => {
+                        if (htmlErr) {
+                            // File not found
+                            res.statusCode = 404;
+                            res.end('File not found');
+                        }
+                        else {
+                            // Serve the .html file
+                            fs.readFile(htmlPath, (readErr, data) => {
+                                if (readErr) {
+                                    res.statusCode = 500;
+                                    res.end('Internal Server Error');
+                                }
+                                else {
+                                    res.setHeader('Content-Type', 'text/html');
+                                    res.end(data);
+                                }
+                            });
+                        }
+                    });
+                }
+                else {
+                    // Serve the file
+                    fs.readFile(fullPath, (readErr, data) => {
+                        if (readErr) {
+                            res.statusCode = 500;
+                            res.end('Internal Server Error');
+                        }
+                        else {
+                            // Set appropriate content type based on file extension
+                            const ext = path.extname(fullPath).toLowerCase();
+                            const contentTypes = {
+                                '.html': 'text/html',
+                                '.css': 'text/css',
+                                '.js': 'application/javascript',
+                                '.json': 'application/json',
+                                '.png': 'image/png',
+                                '.jpg': 'image/jpeg',
+                                '.jpeg': 'image/jpeg',
+                                '.gif': 'image/gif',
+                                '.svg': 'image/svg+xml',
+                                '.ico': 'image/x-icon'
+                            };
+                            res.setHeader('Content-Type', contentTypes[ext] || 'application/octet-stream');
+                            res.end(data);
+                        }
+                    });
+                }
+            });
+        });
+        server.listen(port, () => {
+            console.log(`\u001b[36m\u001b[1m[Funkophile]\u001b[0m Server running at http://localhost:${port}/`);
+        });
+    }
     // Wait for all the file watchers to check in
     Promise.all(Object.keys(funkophileConfig.inputs).map((inputRuleKey) => {
-        const p = path.resolve(`./${funkophileConfig.options.inFolder}/${funkophileConfig.inputs[inputRuleKey] || ""}`);
+        // Ensure the pattern includes the inFolder and is relative to the current working directory
+        // Also, make sure to handle patterns that might already include the inFolder
+        const pattern = funkophileConfig.inputs[inputRuleKey] || "";
+        // For glob, we want the pattern to be relative to process.cwd()
+        // Join inFolder and pattern using forward slashes
+        const globPattern = path.posix.join(funkophileConfig.options.inFolder, pattern);
+        // console.log(`[Funkophile] Looking for files with glob pattern: ${globPattern}`);
+        // console.log(`[Funkophile] Current working directory: ${process.cwd()}`);
         return new Promise((fulfill, reject) => {
             if (funkophileConfig.mode === "build") {
-                glob(p, {})
+                // Use the glob pattern we constructed earlier
+                // console.log(`[Funkophile] Searching for files matching pattern: ${globPattern}`);
+                // console.log(`[Funkophile] Input rule key: ${inputRuleKey}`);
+                glob(globPattern, { cwd: process.cwd() })
                     .then((files) => {
-                    files.forEach((file) => {
-                        dispatchUpsert(store, inputRuleKey, file, funkophileConfig.encodings);
-                    });
+                    // console.log(`[Funkophile] Found ${files.length} files for ${inputRuleKey} (pattern: ${pattern}):`, files);
+                    if (files.length === 0) {
+                        console.warn(`No files found for input key "${inputRuleKey}" with pattern "${globPattern}"`);
+                        // console.log(`[Funkophile] The glob pattern used was: ${globPattern}`);
+                    }
+                    else {
+                        files.forEach((file) => {
+                            // Make sure the file path is absolute
+                            const absoluteFilePath = path.resolve(process.cwd(), file);
+                            // console.log(`[Funkophile] Adding file to state for key ${inputRuleKey}: ${absoluteFilePath}`);
+                            dispatchUpsert(store, inputRuleKey, absoluteFilePath, funkophileConfig.encodings);
+                        });
+                    }
                 })
                     .then(() => {
                     fulfill();
+                })
+                    .catch((error) => {
+                    // console.error(`[Funkophile] Error globbing for pattern ${globPattern}:`, error);
+                    reject(error);
                 });
             }
             else if (funkophileConfig.mode === "watch") {
-                chokidar
-                    .watch(p, {})
-                    .on("error", (error) => {
-                    logger.watchError(p);
-                })
-                    .on("ready", () => {
-                    logger.watchReady(p);
-                    fulfill();
-                })
-                    .on("add", (p) => {
-                    logger.watchAdd(p);
-                    dispatchUpsert(store, inputRuleKey, p, funkophileConfig.encodings);
-                })
-                    .on("change", (p) => {
-                    logger.watchChange(p);
-                    dispatchUpsert(store, inputRuleKey, p, funkophileConfig.encodings);
-                })
-                    .on("unlink", (p) => {
-                    logger.watchUnlink(p);
-                    store.dispatch({
-                        type: REMOVE,
-                        payload: {
-                            key: inputRuleKey,
-                            file: p,
-                        },
+                // Use the same glob pattern for watch mode
+                // console.log(`[Funkophile] Watching for files matching pattern: ${globPattern}`);
+                // First, use glob to find existing files to ensure they're added to the state
+                glob(globPattern, { cwd: process.cwd() })
+                    .then((files) => {
+                    // console.log(`[Funkophile] Found ${files.length} existing files for ${inputRuleKey} (pattern: ${pattern}):`, files);
+                    files.forEach((file) => {
+                        const absoluteFilePath = path.resolve(process.cwd(), file);
+                        // console.log(`[Funkophile] Adding existing file to state for key ${inputRuleKey}: ${absoluteFilePath}`);
+                        dispatchUpsert(store, inputRuleKey, absoluteFilePath, funkophileConfig.encodings);
+                    });
+                    // Now set up the watcher
+                    const watcher = chokidar
+                        .watch(globPattern, {
+                        cwd: process.cwd(),
+                        ignoreInitial: true // We've already handled initial files above
+                    })
+                        .on("error", (error) => {
+                        logger.watchError(globPattern);
+                    })
+                        .on("ready", () => {
+                        logger.watchReady(globPattern);
+                        fulfill();
+                    })
+                        .on("add", (filePath) => {
+                        logger.watchAdd(filePath);
+                        const absoluteFilePath = path.resolve(process.cwd(), filePath);
+                        dispatchUpsert(store, inputRuleKey, absoluteFilePath, funkophileConfig.encodings);
+                    })
+                        .on("change", (filePath) => {
+                        logger.watchChange(filePath);
+                        const absoluteFilePath = path.resolve(process.cwd(), filePath);
+                        dispatchUpsert(store, inputRuleKey, absoluteFilePath, funkophileConfig.encodings);
+                    })
+                        .on("unlink", (filePath) => {
+                        logger.watchUnlink(filePath);
+                        const absoluteFilePath = path.resolve(process.cwd(), filePath);
+                        store.dispatch({
+                            type: REMOVE,
+                            payload: {
+                                key: inputRuleKey,
+                                file: absoluteFilePath,
+                            },
+                        });
+                    })
+                        .on("unlinkDir", (filePath) => {
+                        logger.watchUnlink(filePath);
                     });
                 })
-                    .on("unlinkDir", (p) => {
-                    logger.watchUnlink(p);
+                    .catch((error) => {
+                    console.error(`[Funkophile] Error globbing for pattern ${globPattern}:`, error);
+                    reject(error);
                 });
                 // .on('raw', (event, p, details) => { // internal
                 //   log('Raw event info:', event, p, details);
@@ -175,13 +314,54 @@ export default (funkophileConfig) => {
             }
         });
     })).then(function () {
+        // console.log('\u001b[36m\u001b[1m[Funkophile]\u001b[0m All input files processed. Setting up store subscription...');
+        // Debug: log the current state after all files are processed
+        const currentState = store.getState();
+        console.log('\u001b[36m\u001b[1m[Funkophile]\u001b[0m Current state keys:', Object.keys(currentState));
+        // Log all input keys to see if they're present
+        Object.keys(funkophileConfig.inputs).forEach(inputKey => {
+            if (currentState[inputKey]) {
+                // console.log(`[Funkophile] Input key "${inputKey}" found in state with ${Object.keys(currentState[inputKey]).length} files`);
+            }
+            else {
+                throw (`Input key "${inputKey}" NOT found in state`);
+            }
+        });
         // listen for changes to the store
         store.subscribe(() => {
             const s = store.getState();
+            // Skip processing during initial load
+            if (s.initialLoad) {
+                console.log('\u001b[36m\u001b[1m[Funkophile]\u001b[0m Initial load in progress, skipping processing...');
+                console.log('\u001b[36m\u001b[1m[Funkophile]\u001b[0m State keys during initial load:', Object.keys(s));
+                return;
+            }
             logger.stateChange();
-            const outputs = finalSelector(s);
+            console.log('\u001b[36m\u001b[1m[Funkophile]\u001b[0m Processing state changes...');
+            let outputs;
+            try {
+                outputs = finalSelector(s);
+                console.log(`\u001b[36m\u001b[1m[Funkophile]\u001b[0m Generated ${Object.keys(outputs).length} outputs`);
+            }
+            catch (error) {
+                console.error('\u001b[31m\u001b[1m[Funkophile]\u001b[0m FATAL: Error in output selector chain:');
+                console.error('  Error:', error.message);
+                console.error('  Stack:', error.stack);
+                // Don't exit the process in watch mode, just log the error and continue
+                if (funkophileConfig.mode === 'build') {
+                    process.exit(1);
+                }
+                else {
+                    console.log('\u001b[33m\u001b[1m[Funkophile]\u001b[0m Continuing to watch for changes despite error...');
+                    // Reset previousState to empty to ensure we try processing again on next change
+                    Object.keys(previousState).forEach(key => {
+                        delete previousState[key];
+                    });
+                    return;
+                }
+            }
             if (outputPromise.isPending()) {
-                console.log("cancelling previous write!");
+                console.log("\u001b[33m\u001b[1m[Funkophile]\u001b[0m Cancelling previous write operation!");
                 outputPromise.cancel();
             }
             outputPromise = Promise.all(Array.from(new Set(Object.keys(previousState).concat(Object.keys(outputs)))).map((key) => {
@@ -189,90 +369,163 @@ export default (funkophileConfig) => {
                     if (!outputs[key]) {
                         const file = funkophileConfig.options.outFolder + "/" + key;
                         logger.removedFile(file);
+                        console.log(`\u001b[31m\u001b[1m[Funkophile]\u001b[0m Removing file: ${file}`);
                         try {
                             fse.unlinkSync("./" + file);
                             cleanEmptyFoldersRecursively("./" + file.substring(0, file.lastIndexOf("/")));
                         }
                         catch (ex) {
-                            // console.error('inner', ex.message);
-                            // throw ex;
+                            // Log error but don't fail the entire process
+                            console.error(`\u001b[31m\u001b[1m[Funkophile]\u001b[0m Error removing file ${file}:`, ex.message);
                         }
                         finally {
-                            // console.log('finally');
-                            return;
+                            delete previousState[key];
+                            fulfill();
                         }
-                        // delete previousState[key]
-                        // fulfill()
                     }
                     else {
                         if (outputs[key] !== previousState[key]) {
                             previousState[key] = outputs[key];
                             const relativeFilePath = "./" + funkophileConfig.options.outFolder + "/" + key;
                             const contents = outputs[key];
+                            // console.log(`\u001b[32m\u001b[1m[Funkophile]\u001b[0m Writing file: ${relativeFilePath}`);
                             if (typeof contents === "function") {
                                 logger.writingFunction(relativeFilePath);
                                 contents((err, res) => {
-                                    fse.outputFile(relativeFilePath, res, fulfill);
-                                    logger.writingString(relativeFilePath);
+                                    if (err) {
+                                        logger.writingError(relativeFilePath, err.message);
+                                        fulfill(); // Still fulfill to continue processing other files
+                                    }
+                                    else {
+                                        fse.outputFile(relativeFilePath, res, (err) => {
+                                            if (err) {
+                                                logger.writingError(relativeFilePath, err.message);
+                                                fulfill(); // Still fulfill to continue processing other files
+                                            }
+                                            else {
+                                                logger.writingString(relativeFilePath);
+                                                fulfill();
+                                            }
+                                        });
+                                    }
                                 });
                             }
                             else if (typeof contents === "string") {
-                                fse.outputFile(relativeFilePath, contents, fulfill);
-                                logger.writingString(relativeFilePath);
+                                fse.outputFile(relativeFilePath, contents, (err) => {
+                                    if (err) {
+                                        logger.writingError(relativeFilePath, err.message);
+                                        fulfill();
+                                    }
+                                    else {
+                                        logger.writingString(relativeFilePath);
+                                        fulfill();
+                                    }
+                                });
                             }
                             else if (Buffer.isBuffer(contents)) {
-                                fse.outputFile(relativeFilePath, contents, fulfill);
-                                logger.writingString(relativeFilePath);
+                                fse.outputFile(relativeFilePath, contents, (err) => {
+                                    if (err) {
+                                        logger.writingError(relativeFilePath, err.message);
+                                        fulfill();
+                                    }
+                                    else {
+                                        logger.writingString(relativeFilePath);
+                                        fulfill();
+                                    }
+                                });
                             }
                             else if (Array.isArray(contents)) {
-                                fse.outputFile(relativeFilePath, JSON.stringify(contents), fulfill);
-                                logger.writingString(relativeFilePath);
+                                fse.outputFile(relativeFilePath, JSON.stringify(contents), (err) => {
+                                    if (err) {
+                                        logger.writingError(relativeFilePath, err.message);
+                                        fulfill();
+                                    }
+                                    else {
+                                        logger.writingString(relativeFilePath);
+                                        fulfill();
+                                    }
+                                });
                             }
                             else if (typeof contents.then === "function") {
                                 logger.writingPromise(relativeFilePath);
                                 Promise.resolve(contents).then(function (value) {
                                     if (value instanceof Error) {
                                         logger.writingError(relativeFilePath, value.message);
+                                        fulfill();
                                     }
                                     else {
-                                        fse.outputFile(relativeFilePath, value, fulfill);
-                                        logger.writingString(relativeFilePath);
+                                        fse.outputFile(relativeFilePath, value, (err) => {
+                                            if (err) {
+                                                logger.writingError(relativeFilePath, err.message);
+                                                fulfill();
+                                            }
+                                            else {
+                                                logger.writingString(relativeFilePath);
+                                                fulfill();
+                                            }
+                                        });
                                     }
-                                }, function (value) {
-                                    // not called
+                                }, function (error) {
+                                    logger.writingError(relativeFilePath, error.message);
+                                    fulfill();
                                 });
                             }
                             else {
-                                console.log(`I don't recognize what this is but I will try to write it to a file: ` +
-                                    relativeFilePath, typeof contents, contents);
-                                fse.outputFile(relativeFilePath, contents, fulfill);
-                                logger.writingString(relativeFilePath);
+                                console.log(`\u001b[33m\u001b[1m[Funkophile]\u001b[0m Unrecognized content type for ${relativeFilePath}, attempting to write:`, typeof contents);
+                                fse.outputFile(relativeFilePath, contents, (err) => {
+                                    if (err) {
+                                        logger.writingError(relativeFilePath, err.message);
+                                        fulfill();
+                                    }
+                                    else {
+                                        logger.writingString(relativeFilePath);
+                                        fulfill();
+                                    }
+                                });
                             }
                         }
                         else {
+                            // console.log(`\u001b[90m\u001b[1m[Funkophile]\u001b[0m Skipping unchanged file: ${key}`);
                             fulfill();
                         }
                     }
                 });
             })).then(() => {
+                // console.log('\u001b[36m\u001b[1m[Funkophile]\u001b[0m Cleaning empty folders...');
                 cleanEmptyFoldersRecursively(funkophileConfig.options.outFolder);
                 if (funkophileConfig.mode === "build") {
+                    console.log('\u001b[32m\u001b[1m[Funkophile]\u001b[0m Build completed successfully!');
                     logger.done();
                 }
                 else if (funkophileConfig.mode === "watch") {
+                    console.log('\u001b[36m\u001b[1m[Funkophile]\u001b[0m Watching for file changes...');
+                    // Log the localhost URL if port is specified
+                    const port = funkophileConfig.options.port || 8080;
+                    console.log(`\u001b[36m\u001b[1m[Funkophile]\u001b[0m Serving at: http://localhost:${port}/`);
                     logger.waiting();
                 }
                 else {
-                    console.error(`The mode should be 'watch' or 'build', not "${funkophileConfig.mode}"`);
-                    process.exit(-1);
+                    throw (`\u001b[31m\u001b[1m[Funkophile]\u001b[0m The mode should be 'watch' or 'build', not "${funkophileConfig.mode}"`);
                 }
             });
+            //   .catch((error) => {
+            //   // console.error('\u001b[31m\u001b[1m[Funkophile]\u001b[0m Error during file operations:', error);
+            // });
         });
+        // console.log('\u001b[36m\u001b[1m[Funkophile]\u001b[0m Initializing store...');
         // lastly, turn the store `on`.
         // This is to prevent unecessary recomputations when initialy adding files to redux
         store.dispatch({
             type: INITIALIZE,
             payload: true,
         });
+        // console.log('\u001b[36m\u001b[1m[Funkophile]\u001b[0m Store initialized. Starting processing...');
+    });
+    // Handle process exit to close the server
+    process.on('SIGINT', () => {
+        if (server) {
+            server.close();
+        }
+        process.exit(0);
     });
 };