@cocreate/config 1.14.2 → 1.14.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/config",
-  "version": "1.14.2",
+  "version": "1.14.3",
   "description": "A convenient chain handler allows user to chain multiple CoCreate components together. When one action is complete next one will start. The sequence goes untill all config completed. Grounded on Vanilla javascript, easily configured using HTML5 attributes and/or JavaScript API.",
   "keywords": [
     "config",
@@ -36,15 +36,7 @@
   },
   "type": "module",
   "main": "./src/server.js",
-  "browser": "./src/client.js",
-  "exports": {
-    ".": {
-      "node": "./src/server.js",
-      "deno": "./src/server.js",
-      "browser": "./src/client.js",
-      "default": "./src/server.js"
-    }
-  },
+  "browser": "./src/browser.js",
   "dependencies": {
     "@cocreate/utils": "^1.44.0"
   },

package/src/browser.js

@@ -0,0 +1,122 @@
+/********************************************************************************
+ * Copyright (C) 2026 CoCreate and Contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ ********************************************************************************/
+
+import { configAPI, registerAdapter } from './core.js';
+
+let localStorageImpl = null;
+
+// Bypassing top-level await by using standard promise syntax for ES2017 compatibility
+import('@cocreate/local-storage')
+    .then((mod) => {
+        localStorageImpl = mod.default || mod;
+    })
+    .catch(() => {
+        if (typeof window !== 'undefined') {
+            localStorageImpl = window.localStorage;
+        }
+    });
+
+/**
+ * Renders an interactive fallback HTML modal overlay in the browser 
+ * to handle real-time configurations or missing setup questions.
+ * 
+ * @param {string} question - The prompt question to display.
+ * @returns {Promise<string>} The user's input response.
+ */
+async function browserPrompt(question) {
+    return new Promise((resolve) => {
+        const container = document.createElement('div');
+        container.innerHTML = `
+            <div style="position:fixed;inset:0;background:rgba(15,23,42,0.6);backdrop-filter:blur(4px);display:flex;align-items:center;justify-content:center;z-index:999999;font-family:system-ui,-apple-system,sans-serif;">
+                <div style="background:#ffffff;padding:24px;border-radius:12px;box-shadow:0 20px 25px -5px rgba(0,0,0,0.1);width:100%;max-width:360px;box-sizing:border-box;">
+                    <div style="font-weight:600;font-size:16px;color:#1e293b;margin-bottom:12px;">${question}</div>
+                    <input id="prompt-input" type="text" placeholder="Enter your response..." style="width:100%;padding:10px 12px;border:1px solid #cbd5e1;border-radius:6px;font-size:14px;outline:none;margin-bottom:16px;box-sizing:border-box;">
+                    <button id="prompt-submit" style="width:100%;padding:10px;background:#2563eb;color:#ffffff;border:none;border-radius:6px;font-size:14px;font-weight:500;cursor:pointer;transition:background 0.15s ease;">Submit</button>
+                </div>
+            </div>
+        `;
+        document.body.appendChild(container);
+        
+        const input = container.querySelector('#prompt-input');
+        const button = container.querySelector('#prompt-submit');
+        
+        input.focus();
+
+        const submitValue = () => {
+            const val = input.value.trim();
+            container.remove();
+            resolve(val);
+        };
+
+        button.addEventListener('click', submitValue);
+        input.addEventListener('keydown', (e) => {
+            if (e.key === 'Enter') submitValue();
+        });
+    });
+}
+
+// Bind platform capabilities directly into the core adapter engine
+registerAdapter({
+    isBrowser: true,
+    
+    getLocalStorageItem: (key) => {
+        return localStorageImpl ? localStorageImpl.getItem(key) : null;
+    },
+    
+    setLocalStorageItem: (key, value) => {
+        if (localStorageImpl) {
+            localStorageImpl.setItem(key, value);
+        }
+    },
+    
+    removeLocalStorageItem: (key) => {
+        if (localStorageImpl) {
+            localStorageImpl.removeItem(key);
+        }
+    },
+    
+    clearLocalStorage: () => {
+        if (localStorageImpl && typeof localStorageImpl.clear === 'function') {
+            localStorageImpl.clear();
+        }
+    },
+
+    getGlobalConfig: () => {
+        return (typeof window !== 'undefined' && window.CoCreateConfig) || {};
+    },
+
+    setGlobalConfig: (config) => {
+        if (typeof window !== 'undefined') {
+            window.CoCreateConfig = config;
+        }
+    },
+
+    getEnv: () => null,
+    setEnv: () => {},
+    removeEnv: () => {},
+    
+    getGitBranch: async () => null,
+    prompt: browserPrompt,
+    
+    loadConfig: async () => {
+        return (typeof window !== 'undefined' && window.CoCreateConfig) || {};
+    },
+    
+    saveConfig: async () => {}
+});
+
+export default configAPI;

package/src/core.js

@@ -0,0 +1,282 @@
+import { dotNotationToObject, getValueFromObject } from '@cocreate/utils';
+
+// Global in-memory state holding configuration variables
+let configMemory = {};
+
+/**
+ * Adapter holding environment-specific behaviors.
+ * These are injected statically by the environment wrappers (Browser or Node/Deno Server).
+ * @type {Object}
+ */
+let adapter = {
+    isBrowser: false,
+    getLocalStorageItem: (key) => null,
+    setLocalStorageItem: (key, value) => {},
+    removeLocalStorageItem: (key) => {},
+    clearLocalStorage: () => {},
+    getGlobalConfig: () => ({}),
+    setGlobalConfig: (config) => {},
+    getEnv: (key) => null,
+    setEnv: (key, value) => {},
+    removeEnv: (key) => {},
+    getGitBranch: async () => null,
+    prompt: async (question) => "",
+    loadConfig: async (filePath) => ({}),
+    saveConfig: async (filePath, content) => {}
+};
+
+/**
+ * Registers the environment adapter. Called statically by wrapper modules at startup.
+ * 
+ * @param {Object} envAdapter - The runtime adapter implementation.
+ */
+export function registerAdapter(envAdapter) {
+    adapter = { ...adapter, ...envAdapter };
+}
+
+/**
+ * Synchronously retrieves a configuration value by key.
+ * 
+ * @param {string} key - The configuration key to look up.
+ * @returns {*} The configuration value, or null if not found.
+ */
+export function get(key) {
+    if (adapter.isBrowser) {
+        if (configMemory[key] !== undefined) {
+            return configMemory[key];
+        }
+        
+        const localVal = adapter.getLocalStorageItem(key);
+        if (localVal !== null && localVal !== undefined) return localVal;
+
+        return null;
+    } else {
+        if (configMemory[key] !== undefined) return configMemory[key];
+        
+        return adapter.getEnv(key);
+    }
+}
+
+/**
+ * Synchronously sets a configuration key-value pair.
+ * 
+ * @param {string} key - The configuration key to store.
+ * @param {*} value - The value to assign to the configuration key.
+ * @returns {Function} The hoisted configuration request API context for chaining.
+ */
+export function set(key, value) {
+    configMemory[key] = value;
+    
+    if (adapter.isBrowser) {
+        adapter.setLocalStorageItem(key, value);
+    } else {
+        adapter.setEnv(key, value);
+    }
+    return request;
+}
+
+/**
+ * Synchronously removes a key-value pair across all storage scopes.
+ * 
+ * @param {string} key - The configuration key to delete.
+ * @returns {Function} The hoisted configuration request API context for chaining.
+ */
+export function remove(key) {
+    delete configMemory[key];
+    
+    if (adapter.isBrowser) {
+        adapter.removeLocalStorageItem(key);
+    } else {
+        adapter.removeEnv(key);
+    }
+    return request;
+}
+
+/**
+ * Checks if a specific key exists inside the active configuration scope.
+ * 
+ * @param {string} key - The configuration key to check.
+ * @returns {boolean} True if the key exists and is non-null, false otherwise.
+ */
+export function has(key) {
+    return get(key) !== null;
+}
+
+/**
+ * Clears the active memory context and resets storage scopes.
+ * 
+ * @returns {Function} The hoisted configuration request API context for chaining.
+ */
+export function clear() {
+    configMemory = {};
+    if (adapter.isBrowser) {
+        adapter.clearLocalStorage();
+    }
+    return request;
+}
+
+/**
+ * Normalizes values, substituting dynamic evaluations (like Git branch lookups).
+ * 
+ * @param {*} val - Config value configuration structure.
+ * @returns {*} Resolved value context.
+ */
+async function resolveValue(val) {
+    if (typeof val === 'string' || typeof val === 'number' || typeof val === 'boolean') {
+        return val;
+    } else if (val && val.$branch) {
+        const branch = await adapter.getGitBranch();
+        return branch ? val.$branch[branch] : null;
+    } else {
+        return val;
+    }
+}
+
+/**
+ * Orchestrates prompts, files, and updates.
+ * 
+ * @param {Object|string} [items] - Targeted configuration structure or a singular key to lookup.
+ * @param {boolean} [env=true] - Synced environments options.
+ * @param {boolean} [globalSetting=true] - Flag indicating whether values should sync back to global user configurations.
+ * @param {string} [configPath='CoCreate.config.js'] - The relative filepath name of the configuration module.
+ * @returns {Promise<Object>} Resolved configuration data key map.
+ */
+export async function request(items, env = true, globalSetting = true, configPath = 'CoCreate.config.js') {
+    let localConfig = {};
+    let globalConfig = {};
+
+    // Load configurations statically via environment-isolated wrapper adapter
+    localConfig = await adapter.loadConfig(configPath);
+    globalConfig = await adapter.getGlobalConfig();
+
+    const filterEmptyValues = (obj) => {
+        return Object.fromEntries(
+            Object.entries(obj).filter(([_, val]) => {
+                if (typeof val === 'object' && !Array.isArray(val)) {
+                    return Object.keys(val).length > 0;
+                } else if (Array.isArray(val)) {
+                    return val.length > 0;
+                } else {
+                    return val !== '';
+                }
+            })
+        );
+    };
+
+    let configData = {};
+    let updateGlobalFile = false;
+    let variables = {};
+
+    async function getConfig(targetItems) {
+        if (typeof targetItems === 'string') {
+            targetItems = { [targetItems]: '' };
+        }
+        for (let key of Object.keys(targetItems)) {
+            let { value, prompt: userPrompt, choices, variable } = targetItems[key] || {};
+
+            const placeholders = key.match(/{{\s*([\w\W]+?)\s*}}/g);
+            if (placeholders && placeholders.length) {
+                for (let placeholder of placeholders) {
+                    if (variables[placeholder]) {
+                        key = key.replace(placeholder, variables[placeholder]);
+                    }
+                }
+            }
+
+            if (choices) {
+                if (!userPrompt && userPrompt !== '') continue;
+
+                let isAnswered = false;
+                for (let choice of Object.keys(choices)) {
+                    let isAnsweredChoice = true;
+                    for (let choicekey of Object.keys(choices[choice])) {
+                        let choiceValue = configMemory[choicekey] || getValueFromObject(localConfig, choicekey) || getValueFromObject(globalConfig, choicekey);
+                        if (choiceValue) {
+                            configData[choicekey] = choiceValue;
+                        } else {
+                            isAnsweredChoice = false;
+                        }
+                    }
+                    if (isAnsweredChoice) {
+                        isAnswered = true;
+                    }
+                }
+
+                if (!isAnswered) {
+                    const answer = await adapter.prompt(userPrompt || `${key}: `);
+                    const choice = choices[answer];
+                    if (choice) {
+                        await getConfig(choice);
+                    }
+                }
+            } else if (variable) {
+                let variableValue = configMemory[key] || getValueFromObject(localConfig, key) || getValueFromObject(globalConfig, key);
+                if (!variableValue) {
+                    variables[`{{${variable}}}`] = value || await adapter.prompt(userPrompt || `${variable}: `);
+                } else {
+                    variables[`{{${variable}}}`] = Object.keys(variableValue)[0];
+                }
+            } else {
+                if (value || value === "") {
+                    configData[key] = value;
+                    if (globalSetting) {
+                        updateGlobalFile = true;
+                    }
+                } else if (!adapter.isBrowser && adapter.getEnv(key)) {
+                    configData[key] = adapter.getEnv(key);
+                } else {
+                    let localKey, globalKey;
+                    if ((localKey = getValueFromObject(localConfig, key))) {
+                        configData[key] = await resolveValue(localKey);
+                    } else if ((globalKey = getValueFromObject(globalConfig, key))) {
+                        configData[key] = await resolveValue(globalKey);
+                    } else if (userPrompt || userPrompt === '') {
+                        configData[key] = await adapter.prompt(userPrompt || `${key}: `);
+                        if (globalSetting) updateGlobalFile = true;
+                    }
+                }
+
+                if (configData[key] !== undefined) {
+                    set(key, configData[key]);
+                }
+            }
+        }
+    }
+
+    if (items) {
+        await getConfig(items);
+
+        if (updateGlobalFile && !adapter.isBrowser) {
+            let updatedGlobalConfig = filterEmptyValues(
+                dotNotationToObject(configData, globalConfig)
+            );
+            await adapter.setGlobalConfig(updatedGlobalConfig);
+        }
+    } else {
+        configData = {
+            ...filterEmptyValues(globalConfig),
+            ...filterEmptyValues(localConfig)
+        };
+        
+        for (const [key, value] of Object.entries(configData)) {
+            set(key, value);
+        }
+    }
+
+    configData = dotNotationToObject(configData);
+    return configData;
+}
+
+// Bind configuration API methods directly to the request function to safely bypass Temporal Dead Zone (TDZ) limits.
+request.request = request;
+request.get = get;
+request.set = set;
+request.delete = remove;
+request.remove = remove;
+request.has = has;
+request.clear = clear;
+
+/**
+ * Consolidated API Object.
+ */
+export const configAPI = request;

package/src/server.js

@@ -1,235 +1,151 @@
-/********************************************************************************
- * Copyright (C) 2023 CoCreate and Contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published
- * by the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- *
- ********************************************************************************/
-
-// Commercial Licensing Information:
-// For commercial use of this software without the copyleft provisions of the AGPLv3,
-// you must obtain a commercial license from CoCreate LLC.
-// For details, visit <https://cocreate.app/licenses/> or contact us at sales@cocreate.app.
-
-import readline from 'node:readline';
-import os from 'node:os';
-import path from 'node:path';
-import fs from 'node:fs';
-import { promisify } from 'node:util';
-import { exec as childExec } from 'node:child_process';
-import { pathToFileURL } from 'node:url';
-import { createRequire } from 'node:module';
-
-import { dotNotationToObject, getValueFromObject } from '@cocreate/utils';
-
-const exec = promisify(childExec);
-const require = createRequire(import.meta.url);
-
-/**
- * Helper function to dynamically load configurations.
- * Handles both native ES modules and legacy CommonJS/JSON files safely.
- * @param {string} filePath - Absolute path to the config file
- * @returns {Promise<Object>} Evaluated configuration object
- */
-async function loadConfig(filePath) {
-    if (!fs.existsSync(filePath)) return {};
-    try {
-        // Attempt native ESM dynamic import
-        const fileUrl = pathToFileURL(filePath).href;
-        const module = await import(fileUrl);
-        return module.default || module;
-    } catch (esmError) {
-        try {
-            // Fallback to Classic CommonJS / JSON Require compatibility
-            return require(filePath);
-        } catch (cjsError) {
-            console.error(`[@cocreate/config] Failed to load configuration at ${filePath}:`, esmError.message);
-            return {};
-        }
-    }
-}
-
-/**
- * Asynchronously retrieves configuration values. This function allows for 
- * fetching values from project-specific configuration, global configuration, or 
- * environment variables. Project configuration takes precedence over global and 
- * environment settings. It also supports interactive prompts to gather critical values 
- * from the user if they are not already defined in the configuration.
- *
- * @async
- * @param {Object|string} items - An object representing the configuration items to retrieve. 
- * The keys are the config paths, and the values are objects 
- * specifying the prompt and any variable substitutions.
- * @param {boolean} [env=true] - Flag to consider environment variables during config lookup.
- * @param {boolean} [global=true] - Flag to consider global configuration during config lookup.
- * @param {string} [configPath='CoCreate.config.js'] - Path to the project-specific configuration file.
- * @returns {Promise<Object>} A promise that resolves with the configuration object.
- */
-export default async function config(items, env = true, global = true, configPath = 'CoCreate.config.js') {
-    async function promptForInput(question) {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout
-        });
-
-        return new Promise((resolve) => {
-            rl.question(question, (answer) => {
-                rl.close();
-                resolve(answer.trim());
-            });
-        });
-    }
-
-    const filterEmptyValues = (obj) => {
-        return Object.fromEntries(
-            Object.entries(obj).filter(([_, value]) => {
-                if (typeof value === 'object' && !Array.isArray(value)) {
-                    return Object.keys(value).length > 0;
-                } else if (Array.isArray(value)) {
-                    return value.length > 0;
-                } else {
-                    return value !== '';
-                }
-            })
-        );
-    };
-
-    async function getValue(value) {
-        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-            return value;
-        } else if (value.$branch) {
-            try {
-                const { stdout } = await exec('git branch --show-current');
-                return value.$branch[stdout.trim()];
-            } catch (error) {
-                console.error(`exec error: ${error}`);
-                return null;
-            }
-        } else {
-            return value;
-        }
-    }
-
-    let configData = {};
-    let update = false;
-    let variables = {};
-
-    async function getConfig(targetItems) {
-        if (typeof targetItems === 'string') {
-            targetItems = { [targetItems]: '' };
-        }
-        for (let key of Object.keys(targetItems)) {
-            let { value, prompt, choices, variable } = targetItems[key];
-
-            const placeholders = key.match(/{{\s*([\w\W]+?)\s*}}/g);
-            if (placeholders && placeholders.length) {
-                for (let placeholder of placeholders) {
-                    placeholder.trim();
-                    if (variables[placeholder]) {
-                        key = key.replace(placeholder, variables[placeholder]);
-                    }
-                }
-            }
-
-            if (choices) {
-                if (!prompt && prompt !== '') continue;
-
-                let isAnswered = false;
-                for (let choice of Object.keys(choices)) {
-                    let isAnsweredChoice = true;
-                    for (let choicekey of Object.keys(choices[choice])) {
-                        let choiceValue = localConfig[choicekey] || globalConfig[choicekey];
-                        if (choiceValue) {
-                            configData[choicekey] = choiceValue;
-                        } else {
-                            isAnsweredChoice = false;
-                        }
-                    }
-                    if (isAnsweredChoice) {
-                        isAnswered = true;
-                    }
-                }
-
-                if (!isAnswered) {
-                    const answer = await promptForInput(prompt || `${key}: `);
-                    const choice = choices[answer];
-                    if (choice) {
-                        await getConfig(choice);
-                    }
-                }
-            } else if (variable) {
-                let variableValue = localConfig[key] || globalConfig[key];
-                if (!variableValue) {
-                    variables[`{{${variable}}}`] = value || await promptForInput(prompt || `${variable}: `);
-                } else {
-                    variables[`{{${variable}}}`] = Object.keys(variableValue)[0];
-                }
-            } else {
-                if (value || value === "") {
-                    configData[key] = value;
-                    if (global) {
-                        update = true;
-                    }
-                } else if (process.env[key]) {
-                    configData[key] = process.env[key];
-                } else {
-                    let localKey, globalKey;
-                    if ((localKey = getValueFromObject(localConfig, key))) {
-                        configData[key] = await getValue(localKey);
-                    } else if ((globalKey = getValueFromObject(globalConfig, key))) {
-                        configData[key] = await getValue(globalKey);
-                    } else if (prompt || prompt === '') {
-                        configData[key] = await promptForInput(prompt || `${key}: `);
-                        if (global) update = true;
-                    }
-                    if (env) {
-                        if (typeof configData[key] === 'object') {
-                            process.env[key] = JSON.stringify(configData[key]);
-                        } else {
-                            process.env[key] = configData[key];
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    // Resolving paths and dynamically loading configurations with ESM wrappers
-    const localConfigPath = path.resolve(process.cwd(), configPath);
-    const localConfig = await loadConfig(localConfigPath);
-
-    const globalConfigPath = path.resolve(os.homedir(), 'CoCreate.config.js');
-    const globalConfig = await loadConfig(globalConfigPath);
-
-    if (items) {
-        await getConfig(items);
-
-        if (update) {
-            let updatedGlobalConfig = filterEmptyValues(
-                dotNotationToObject(configData, globalConfig)
-            );
-
-            // Updated to write modern ES module syntax "export default" instead of "module.exports"
-            const globalConfigString = `export default ${JSON.stringify(updatedGlobalConfig, null, 2)};\n`;
-            fs.writeFileSync(globalConfigPath, globalConfigString);
-        }
-    } else {
-        configData = {
-            ...filterEmptyValues(globalConfig),
-            ...filterEmptyValues(localConfig)
-        };
-    }
-
-    configData = dotNotationToObject(configData);
-    return configData;
-}
+/********************************************************************************
+ * Copyright (C) 2026 CoCreate and Contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ ********************************************************************************/
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import readline from 'node:readline';
+import { promisify } from 'node:util';
+import { exec as childExec } from 'node:child_process';
+
+import { configAPI, registerAdapter } from './core.js';
+
+const exec = promisify(childExec);
+
+/**
+ * Retrieves the current active git branch name on the system.
+ * 
+ * @returns {Promise<string|null>} The branch name, or null on error.
+ */
+async function getGitBranch() {
+    try {
+        const { stdout } = await exec('git branch --show-current');
+        return stdout.trim();
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Prompts the CLI operator for input interactively using Node's standard readline module.
+ * 
+ * @param {string} question - Question to print on stdout.
+ * @returns {Promise<string>} User input response.
+ */
+async function cliPrompt(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+
+/**
+ * Binary-safe server configuration file loader. Bypasses static compiler
+ * tree issues by parsing configuration files dynamically under a sandboxed function wrapper.
+ * 
+ * @param {string} filePath - Absolute path to the config file on disk.
+ * @returns {Promise<Object>} The parsed configuration object.
+ */
+async function loadConfig(filePath) {
+    try {
+        const resolvedPath = path.resolve(process.cwd(), filePath);
+        if (!fs.existsSync(resolvedPath)) return {};
+        
+        // Load, clean comments, and normalize script syntax for evaluation
+        const content = fs.readFileSync(resolvedPath, 'utf8');
+        const cleanContent = content.replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, '$1').trim();
+        
+        try {
+            return JSON.parse(cleanContent);
+        } catch {
+            const script = cleanContent
+                .replace(/export\s+default\s+/, 'return ')
+                .replace(/module\.exports\s*=\s*/, 'return ');
+
+            const fn = new Function('module', 'exports', script);
+            const exports = {};
+            const module = { exports };
+            const result = fn(module, exports);
+            
+            return result || module.exports || {};
+        }
+    } catch (error) {
+        console.error(`[@cocreate/config] Failed to load configuration at ${filePath}:`, error.message);
+        return {};
+    }
+}
+
+/**
+ * Writes or updates global settings on the user's host filesystem safely.
+ * 
+ * @param {string} filePath - Path to save the config.
+ * @param {Object} content - The JSON payload to persist.
+ */
+async function saveConfig(filePath, content) {
+    try {
+        const targetPath = path.isAbsolute(filePath) ? filePath : path.resolve(process.cwd(), filePath);
+        const outputString = `export default ${JSON.stringify(content, null, 2)};\n`;
+        fs.writeFileSync(targetPath, outputString, 'utf8');
+    } catch (error) {
+        console.error(`[@cocreate/config] Failed to save configuration at ${filePath}:`, error.message);
+    }
+}
+
+// Register standard Node.js server/Deno adapter capabilities
+registerAdapter({
+    isBrowser: false,
+    getLocalStorageItem: () => null,
+    setLocalStorageItem: () => {},
+    removeLocalStorageItem: () => {},
+    clearLocalStorage: () => {},
+
+    getGlobalConfig: async () => {
+        const globalConfigPath = path.resolve(os.homedir(), 'CoCreate.config.js');
+        return await loadConfig(globalConfigPath);
+    },
+
+    setGlobalConfig: async (config) => {
+        const globalConfigPath = path.resolve(os.homedir(), 'CoCreate.config.js');
+        await saveConfig(globalConfigPath, config);
+    },
+
+    getEnv: (key) => {
+        return process.env[key] !== undefined ? process.env[key] : null;
+    },
+
+    setEnv: (key, value) => {
+        process.env[key] = value;
+    },
+
+    removeEnv: (key) => {
+        delete process.env[key];
+    },
+
+    getGitBranch,
+    prompt: cliPrompt,
+    loadConfig,
+    saveConfig
+});
+
+export default configAPI;

package/src/client.js

@@ -1,60 +0,0 @@
-import localStorage from '@cocreate/local-storage'
-
-// Function to get a value by key from localStorage or cookies
-function get(key) {
-    if (window.CoCreateConfig && window.CoCreateConfig[key])
-        return window.CoCreateConfig[key]
-
-    // try localStorage first
-    let value = localStorage.getItem(key)
-    if (value !== null && value !== undefined) return value
-
-    // fallback to cookie for server-read or legacy support
-    const cookies = (typeof document !== 'undefined' && document.cookie) ? document.cookie.split('; ') : [];
-    for (const cookie of cookies) {
-        const [cookieName, cookieValue] = cookie.split('=');
-        if (cookieName === key) {
-            // treat empty value as not present
-            if (!cookieValue || cookieValue === '') return null;
-            return decodeURIComponent(cookieValue || '');
-        }
-    }
-    return null
-}
-
-// Function to set a key-value pair in localStorage or cookies
-function set(key, value) {
-    if (!window.CoCreateConfig)
-        window.CoCreateConfig = { [key]: value }
-    else
-        window.CoCreateConfig[key] = value
-    localStorage.setItem(key, value)
-    // also set cookie for server-read or legacy support
-    try {
-        let cookie = key + "=" + encodeURIComponent(value) + "; path=/; SameSite=Lax";
-        if (typeof window !== "undefined" && window.location && window.location.protocol === "https:") {
-            cookie += "; Secure";
-        }
-        document.cookie = cookie;
-    } catch (e) {
-        // ignore if document not available (e.g., SSR)
-    }
-}
-
-// Function to delete a key-value pair from localStorage or cookies
-function remove(key) {
-    // remove from in-memory config if present
-    if (window.CoCreateConfig) delete window.CoCreateConfig[key]
-    // remove from localStorage
-    localStorage.removeItem(key)
-    // remove cookie as well
-    try {
-        const secure = (typeof window !== "undefined" && window.location && window.location.protocol === "https:") ? "; Secure" : "";
-        // overwrite with empty value first
-        document.cookie = key + "=; path=/; SameSite=Lax" + secure;
-        // then expire using Max-Age=0 for reliable deletion
-        document.cookie = key + "=; Max-Age=0; path=/; SameSite=Lax" + secure;
-    } catch (e) {}
-}
-
-export default { get, set, remove }