kage-baileys 3.0.6 → 3.2.4

package/lib/Utils/tc-token-utils.js

@@ -15,4 +15,188 @@
         return baseContent.length > 0 ? baseContent : undefined;
     }
 } exports.buildTcTokenFromJid = buildTcTokenFromJid;
-//# sourceMappingURL=tc-token-utils.js.map
+//# 
+// Kage: funciones avanzadas.
+const __kageModule187 = (() => {
+const module = { exports: {} }; const exports = module.exports;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TC_TOKEN_INDEX_KEY = void 0;
+exports.readTcTokenIndex = readTcTokenIndex;
+exports.buildMergedTcTokenIndexWrite = buildMergedTcTokenIndexWrite;
+exports.isTcTokenExpired = isTcTokenExpired;
+exports.shouldSendNewTcToken = shouldSendNewTcToken;
+exports.resolveTcTokenJid = resolveTcTokenJid;
+exports.resolveIssuanceJid = resolveIssuanceJid;
+exports.buildTcTokenFromJid = buildTcTokenFromJid;
+exports.storeTcTokensFromIqResult = storeTcTokensFromIqResult;
+const index_js_1 = require("../WABinary/index.js");
+// Same phone-number pattern as WABinary's isJidBot, applied against the user
+// part so the check is invariant to @c.us ↔ @s.whatsapp.net normalization.
+const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/;
+/**
+ * Mirrors WA Web's `Wid.isRegularUser()` (user ∧ ¬PSA ∧ ¬Bot). Used to gate tctoken
+ * storage against malformed notifications — WA Web filters server-side but we
+ * defend here for parity with `WAWebSetTcTokenChatAction.handleIncomingTcToken`.
+ * Works for both pre- and post-normalized JIDs (`@c.us` vs `@s.whatsapp.net`).
+ */
+function isRegularUser(jid) {
+    if (!jid)
+        return false;
+    const user = jid.split('@')[0] ?? '';
+    if (user === '0')
+        return false; // PSA
+    if (BOT_PHONE_REGEX.test(user))
+        return false; // Bot by phone pattern
+    if ((0, index_js_1.isJidMetaAI)(jid))
+        return false; // MetaAI (@bot server)
+    return !!((0, index_js_1.isPnUser)(jid) || (0, index_js_1.isLidUser)(jid) || (0, index_js_1.isHostedPnUser)(jid) || (0, index_js_1.isHostedLidUser)(jid) || jid.endsWith('@c.us'));
+}
+const TC_TOKEN_BUCKET_DURATION = 604800; // 7 days
+const TC_TOKEN_NUM_BUCKETS = 4; // ~28-day rolling window
+/** Sentinel key under `tctoken` store holding a JSON array of tracked storage JIDs for cross-session pruning. */
+exports.TC_TOKEN_INDEX_KEY = '__index';
+/** Read the persisted tctoken JID index and return its entries (never contains the sentinel key itself). */
+async function readTcTokenIndex(keys) {
+    const data = await keys.get('tctoken', [exports.TC_TOKEN_INDEX_KEY]);
+    const entry = data[exports.TC_TOKEN_INDEX_KEY];
+    if (!entry?.token?.length)
+        return [];
+    try {
+        const parsed = JSON.parse(Buffer.from(entry.token).toString());
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((j) => typeof j === 'string' && j.length > 0 && j !== exports.TC_TOKEN_INDEX_KEY);
+    }
+    catch {
+        return [];
+    }
+}
+/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the sentinel key. */
+async function buildMergedTcTokenIndexWrite(keys, addedJids) {
+    const persisted = await readTcTokenIndex(keys);
+    const merged = new Set(persisted);
+    for (const jid of addedJids) {
+        if (jid && jid !== exports.TC_TOKEN_INDEX_KEY)
+            merged.add(jid);
+    }
+    return {
+        [exports.TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
+    };
+}
+// WA Web has separate sender/receiver AB props for these but they're identical today
+function isTcTokenExpired(timestamp) {
+    if (timestamp === null || timestamp === undefined)
+        return true;
+    const ts = typeof timestamp === 'string' ? parseInt(timestamp) : timestamp;
+    if (isNaN(ts))
+        return true;
+    const now = Math.floor(Date.now() / 1000);
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
+    const cutoffBucket = currentBucket - (TC_TOKEN_NUM_BUCKETS - 1);
+    const cutoffTimestamp = cutoffBucket * TC_TOKEN_BUCKET_DURATION;
+    return ts < cutoffTimestamp;
+}
+function shouldSendNewTcToken(senderTimestamp) {
+    if (senderTimestamp === undefined)
+        return true;
+    const now = Math.floor(Date.now() / 1000);
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
+    const senderBucket = Math.floor(senderTimestamp / TC_TOKEN_BUCKET_DURATION);
+    return currentBucket > senderBucket;
+}
+/** Resolve JID to LID for tctoken storage (WA Web stores under LID) */
+async function resolveTcTokenJid(jid, getLIDForPN) {
+    if ((0, index_js_1.isLidUser)(jid))
+        return jid;
+    const lid = await getLIDForPN(jid);
+    return lid ?? jid;
+}
+/** Resolve target JID for issuing privacy token based on AB prop 14303 */
+async function resolveIssuanceJid(jid, issueToLid, getLIDForPN, getPNForLID) {
+    if (issueToLid) {
+        if ((0, index_js_1.isLidUser)(jid))
+            return jid;
+        const lid = await getLIDForPN(jid);
+        return lid ?? jid;
+    }
+    if (!(0, index_js_1.isLidUser)(jid))
+        return jid;
+    if (getPNForLID) {
+        const pn = await getPNForLID(jid);
+        return pn ?? jid;
+    }
+    return jid;
+}
+async function buildTcTokenFromJid({ authState, jid, baseContent = [], getLIDForPN }) {
+    try {
+        const storageJid = await resolveTcTokenJid(jid, getLIDForPN);
+        const tcTokenData = await authState.keys.get('tctoken', [storageJid]);
+        const entry = tcTokenData?.[storageJid];
+        const tcTokenBuffer = entry?.token;
+        const timestamp = entry?.timestamp;
+        if (!tcTokenBuffer?.length || timestamp === undefined || isTcTokenExpired(timestamp)) {
+            if (tcTokenBuffer) {
+                // Preserve senderTimestamp so shouldSendNewTcToken() keeps its dedupe state
+                // after we drop the unusable peer token. Only wipe the record entirely when
+                // there's nothing worth keeping.
+                const cleared = entry?.senderTimestamp !== undefined
+                    ? { token: Buffer.alloc(0), senderTimestamp: entry.senderTimestamp }
+                    : null;
+                await authState.keys.set({ tctoken: { [storageJid]: cleared } });
+            }
+            return baseContent.length > 0 ? baseContent : undefined;
+        }
+        baseContent.push({
+            tag: 'tctoken',
+            attrs: { t: String(timestamp) },
+            content: tcTokenBuffer
+        });
+        return baseContent;
+    }
+    catch (error) {
+        return baseContent.length > 0 ? baseContent : undefined;
+    }
+}
+async function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }) {
+    const tokensNode = (0, index_js_1.getBinaryNodeChild)(result, 'tokens');
+    if (!tokensNode)
+        return;
+    const tokenNodes = (0, index_js_1.getBinaryNodeChildren)(tokensNode, 'token');
+    for (const tokenNode of tokenNodes) {
+        if (tokenNode.attrs.type !== 'trusted_contact' || !(tokenNode.content instanceof Uint8Array)) {
+            continue;
+        }
+        // In notifications tokenNode.attrs.jid is your own device JID, not the sender's
+        const rawJid = (0, index_js_1.jidNormalizedUser)(fallbackJid || tokenNode.attrs.jid);
+        if (!isRegularUser(rawJid))
+            continue;
+        const storageJid = await resolveTcTokenJid(rawJid, getLIDForPN);
+        const existingTcData = await keys.get('tctoken', [storageJid]);
+        const existingEntry = existingTcData[storageJid];
+        const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0;
+        const incomingTs = tokenNode.attrs.t ? Number(tokenNode.attrs.t) : 0;
+        // timestamp-less tokens would be immediately expired
+        if (!incomingTs)
+            continue;
+        if (existingTs > 0 && existingTs > incomingTs)
+            continue;
+        await keys.set({
+            tctoken: {
+                [storageJid]: {
+                    ...existingEntry,
+                    token: Buffer.from(tokenNode.content),
+                    timestamp: tokenNode.attrs.t
+                }
+            }
+        });
+        onNewJidStored?.(storageJid);
+    }
+}
+
+return module.exports;
+})();
+for (const key of Object.keys(__kageModule187)) {
+ if (key !== '__esModule' && !Object.prototype.hasOwnProperty.call(exports,key)) Object.defineProperty(exports,key,{enumerable:true,configurable:true,get:()=>__kageModule187[key]});
+}
+Object.defineProperty(exports, Symbol.for('kage.advanced'), {value:__kageModule187, configurable:true});

package/lib/Utils/terminal-banner.js

@@ -0,0 +1,31 @@
+'use strict';
+const chalk=require('chalk');
+const gradient=require('gradient-string');
+const tinyMap=Object.fromEntries([...('abcdefghijklmnopqrstuvwxyz')].map((c,i)=>[c,[...'ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ'][i]]));
+function say(text, options={}) {
+  const stream=options.stream||process.stdout;
+  let rendered=String(text??'').replace(/[\x00-\x08\x0b-\x1f\x7f]/g,'');
+  if(options.font==='tiny')rendered=[...rendered.toLowerCase()].map(c=>tinyMap[c]||c).join('');
+  else if(options.font==='block')rendered=rendered.toUpperCase().split('\n').map(line=>'▰ '+[...line].join(' ')+' ▰').join('\n');
+  else if(options.font==='simple')rendered=rendered.toUpperCase();
+  const width=Number(options.width)||stream.columns||80;
+  const color=options.forceColor??!!stream.isTTY;
+  const colors=(options.colors||[]).filter(name=>typeof chalk[name]==='function');
+  rendered=rendered.split('\n').map((line,i)=>{
+    const pad=options.align==='center'?Math.max(0,Math.floor((width-[...line].length)/2)):options.align==='right'?Math.max(0,width-[...line].length):0;
+    let output=line;
+    if(color&&Array.isArray(options.gradient)&&options.gradient.length>=2){try{output=gradient(options.gradient)(line);}catch{}}
+    else if(color&&colors.length){const paint=new chalk.Instance({level:1});output=[...line].map((char,index)=>paint[colors[(index+i)%colors.length]](char)).join('');}
+    return ' '.repeat(Math.min(500,pad))+output;
+  }).join('\n');
+  stream.write(rendered+'\n'); return rendered;
+}
+let shown=false;
+function showKageBanner(options={}) {
+ if(shown||process.env.KAGE_BANNER==='0')return;
+ shown=true;
+ say('kage baileys', {font:'simple',align:'center',gradient:['red','magenta'],...options});
+ say('Creado por xrljosedv', {font:'console',align:'center',colors:['cyan','magenta','yellow'],...options});
+ say('Socio David Zuniga', {font:'console',align:'center',colors:['cyan','magenta','yellow'],...options});
+}
+exports.say=say;exports.showKageBanner=showKageBanner;

package/lib/Utils/use-multi-file-auth-state.js

@@ -132,3 +132,274 @@ const useMultiFileAuthState = async (folder) => {
     };
 };
 exports.useMultiFileAuthState = useMultiFileAuthState;
+
+// Kage: compatibilidad de API.
+const __kageModule79 = (() => {
+const module = { exports: {} }; const exports = module.exports;
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { Mutex } = require("async-mutex")
+const { promises } = require("fs")
+const { join } = require("path")
+const { proto } = require("../../WAProto")
+const { initAuthCreds } = require("./auth-utils")
+const { BufferJSON } = require("./generics")
+// We need to lock files due to the fact that we are using async functions to read and write files
+// https://github.com/WhiskeySockets/Baileys/issues/794
+// https://github.com/nodejs/node/issues/26338
+// Use a Map to store mutexes for each file path
+const fileLocks = new Map()
+
+// Get or create a mutex for a specific file path
+const getFileLock = (path) => {
+	let mutex = fileLocks.get(path)
+	if (!mutex) {
+		mutex = new Mutex() 
+		fileLocks.set(path, mutex)
+	}
+
+	return mutex
+}
+
+/**
+ * stores the full authentication state in a single folder.
+ * Far more efficient than singlefileauthstate
+ *
+ * Again, I wouldn't endorse this for any production level use other than perhaps a bot.
+ * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
+ * */
+const useMultiFileAuthState = async (folder) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const writeData = async (data, file) => {
+        const filePath = join(folder, fixFileName(file))
+        const mutex = getFileLock(filePath)
+        return mutex.acquire().then(async (release) => {
+            try {
+               await promises.writeFile(filePath, JSON.stringify(data, BufferJSON.replacer))
+            } finally {
+                release()
+            }
+        })
+    }
+    const readData = async (file) => {
+        try {
+            const filePath = join(folder, fixFileName(file))
+            const mutex = getFileLock(filePath)
+            const data = await mutex.acquire().then(async (release) => {
+                try {
+                    return await promises.readFile(filePath, { encoding: 'utf-8' })
+                } finally {
+                    release()
+                }
+            })
+
+            return JSON.parse(data, BufferJSON.reviver)
+        } catch (error) {
+            return null
+        }
+    }
+    const removeData = async (file) => {
+        try {
+            const filePath = join(folder, fixFileName(file))
+            const mutex = getFileLock(filePath)
+            await mutex.acquire().then(async (release) => {
+               try {
+                    await promises.unlink(filePath)
+                } finally {
+                    release()
+                }
+            })
+        } catch {}
+    }
+    const folderInfo = await promises.stat(folder).catch(() => { })
+    if (folderInfo) {
+        if (!folderInfo.isDirectory()) {
+            throw new Error(`found something that is not a directory at ${folder}, either delete it or specify a different location`)
+        }
+    }
+    else {
+        await promises.mkdir(folder, { recursive: true })
+    }
+    const fixFileName = (file) => { 
+        return file?.replace(/\//g, '__')?.replace(/:/g, '-') 
+    }
+    const creds = await readData('creds.json') || initAuthCreds()
+    return {
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {}
+                    await Promise.all(ids.map(async (id) => {
+                        let value = await readData(`${type}-${id}.json`)
+                        if (type === 'app-state-sync-key' && value) {
+                            value = proto.Message.AppStateSyncKeyData.fromObject(value)
+                        }
+                        data[id] = value
+                    }))
+                    return data
+                },
+                set: async (data) => {
+                    const tasks = []
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const value = data[category][id]
+                            const file = `${category}-${id}.json`
+                            tasks.push(value ? writeData(value, file) : removeData(file))
+                        }
+                    }
+                    await Promise.all(tasks)
+                }
+            }
+        },
+        saveCreds: async () => {
+            return writeData(creds, 'creds.json')
+        }
+    }
+}
+
+module.exports = {
+  useMultiFileAuthState
+}
+return module.exports;
+})();
+for (const key of Object.keys(__kageModule79)) {
+ if (key !== '__esModule' && !Object.prototype.hasOwnProperty.call(exports,key)) Object.defineProperty(exports,key,{enumerable:true,configurable:true,get:()=>__kageModule79[key]});
+}
+
+// Kage: funciones avanzadas.
+const __kageModule188 = (() => {
+const module = { exports: {} }; const exports = module.exports;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMultiFileAuthState = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const index_js_1 = require("../../WAProto/index.js");
+const index_js_2 = require("../Addon/index.js");
+const auth_utils_js_1 = require("./auth-utils.js");
+const generics_js_1 = require("./generics.js");
+// We need to lock files due to the fact that we are using async functions to read and write files
+// https://github.com/WhiskeySockets/Baileys/issues/794
+// https://github.com/nodejs/node/issues/26338
+// Use a Map to store mutexes for each file path
+const fileLocks = new Map();
+// Get or create a mutex for a specific file path
+const getFileLock = (path) => {
+    let mutex = fileLocks.get(path);
+    if (!mutex) {
+        mutex = (0, index_js_2.createMutex)();
+        fileLocks.set(path, mutex);
+    }
+    return mutex;
+};
+/**
+ * stores the full authentication state in a single folder.
+ * Far more efficient than singlefileauthstate
+ *
+ * Again, I wouldn't endorse this for any production level use other than perhaps a bot.
+ * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
+ * */
+const useMultiFileAuthState = async (folder) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const writeData = async (data, file) => {
+        const filePath = (0, node_path_1.join)(folder, fixFileName(file));
+        const mutex = getFileLock(filePath);
+        return mutex.acquire().then(async (release) => {
+            try {
+                await (0, promises_1.writeFile)(filePath, JSON.stringify(data, generics_js_1.BufferJSON.replacer));
+            }
+            finally {
+                release();
+            }
+        });
+    };
+    const readData = async (file) => {
+        try {
+            const filePath = (0, node_path_1.join)(folder, fixFileName(file));
+            const mutex = getFileLock(filePath);
+            return await mutex.acquire().then(async (release) => {
+                try {
+                    const data = await (0, promises_1.readFile)(filePath, { encoding: 'utf-8' });
+                    return JSON.parse(data, generics_js_1.BufferJSON.reviver);
+                }
+                finally {
+                    release();
+                }
+            });
+        }
+        catch (error) {
+            return null;
+        }
+    };
+    const removeData = async (file) => {
+        try {
+            const filePath = (0, node_path_1.join)(folder, fixFileName(file));
+            const mutex = getFileLock(filePath);
+            return mutex.acquire().then(async (release) => {
+                try {
+                    await (0, promises_1.unlink)(filePath);
+                }
+                catch {
+                }
+                finally {
+                    release();
+                }
+            });
+        }
+        catch { }
+    };
+    const folderInfo = await (0, promises_1.stat)(folder).catch(() => { });
+    if (folderInfo) {
+        if (!folderInfo.isDirectory()) {
+            throw new Error(`found something that is not a directory at ${folder}, either delete it or specify a different location`);
+        }
+    }
+    else {
+        await (0, promises_1.mkdir)(folder, { recursive: true });
+    }
+    const fixFileName = (file) => file?.replace(/\//g, '__')?.replace(/:/g, '-');
+    const creds = (await readData('creds.json')) || (0, auth_utils_js_1.initAuthCreds)();
+    return {
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    await Promise.all(ids.map(async (id) => {
+                        let value = await readData(`${type}-${id}.json`);
+                        if (type === 'app-state-sync-key' && value) {
+                            value = index_js_1.proto.Message.AppStateSyncKeyData.fromObject(value);
+                        }
+                        data[id] = value;
+                    }));
+                    return data;
+                },
+                set: async (data) => {
+                    const tasks = [];
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const value = data[category][id];
+                            const file = `${category}-${id}.json`;
+                            tasks.push(value ? writeData(value, file) : removeData(file));
+                        }
+                    }
+                    await Promise.all(tasks);
+                }
+            }
+        },
+        saveCreds: async () => {
+            return writeData(creds, 'creds.json');
+        }
+    };
+};
+exports.useMultiFileAuthState = useMultiFileAuthState;
+
+return module.exports;
+})();
+for (const key of Object.keys(__kageModule188)) {
+ if (key !== '__esModule' && !Object.prototype.hasOwnProperty.call(exports,key)) Object.defineProperty(exports,key,{enumerable:true,configurable:true,get:()=>__kageModule188[key]});
+}
+Object.defineProperty(exports, Symbol.for('kage.advanced'), {value:__kageModule188, configurable:true});

package/lib/Utils/use-single-file-auth-state.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSingleFileAuthState = void 0;
+const promises_1 = require("node:fs/promises");
+const index_js_1 = require("../Defaults/index.js");
+const index_js_2 = require("../../WAProto/index.js");
+const index_js_3 = require("../Addon/index.js");
+const auth_utils_js_1 = require("./auth-utils.js");
+const generics_js_1 = require("./generics.js");
+// Kage: actualización de compatibilidad.
+const FLUSH_TIMEOUT_MS = 3000;
+// Kage: actualización de compatibilidad.
+const useSingleFileAuthState = async (fileName) => {
+    const cache = (0, index_js_3.createCache)({
+        max: 20000,
+        ttl: index_js_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE
+    });
+    // Kage: actualización de compatibilidad.
+    const mutex = (0, index_js_3.createMutex)();
+    let fileData = {};
+    let isLoaded = false;
+    let flushTimeout = null;
+    const loadKey = async () => {
+        return await mutex.runExclusive(async () => {
+            if (isLoaded)
+                return;
+            try {
+                const data = JSON.parse(await (0, promises_1.readFile)(fileName, 'utf-8'), generics_js_1.BufferJSON.reviver);
+                fileData = data || {};
+                for (const [keyName, value] of Object.entries(fileData)) {
+                    cache.set(keyName, value);
+                }
+            }
+            catch {
+                fileData = {};
+            }
+            isLoaded = true;
+        });
+    };
+    const flushKey = () => {
+        if (flushTimeout)
+            return;
+        flushTimeout = setTimeout(async () => {
+            flushTimeout = null;
+            await mutex.runExclusive(async () => {
+                try {
+                    const tempFile = fileName + '.temp';
+                    await (0, promises_1.writeFile)(tempFile, JSON.stringify(fileData, generics_js_1.BufferJSON.replacer));
+                    await (0, promises_1.rename)(tempFile, fileName);
+                }
+                catch { }
+            });
+        }, FLUSH_TIMEOUT_MS);
+    };
+    const writeKey = (keyName, value) => {
+        cache.set(keyName, value);
+        fileData[keyName] = value;
+        flushKey();
+    };
+    const removeKey = (keyName) => {
+        cache.delete(keyName);
+        delete fileData[keyName];
+        flushKey();
+    };
+    const fileInfo = await (0, promises_1.stat)(fileName).catch(() => null);
+    if (!fileInfo) {
+        await (0, promises_1.writeFile)(fileName, '{}');
+    }
+    else if (!fileInfo.isFile()) {
+        throw new Error(`found something that is not a file at ${fileName}, either delete it or specify a different location`);
+    }
+    await loadKey();
+    const creds = fileData['creds'] || (0, auth_utils_js_1.initAuthCreds)();
+    return {
+        state: {
+            creds,
+            keys: {
+                get: (type, ids) => {
+                    const data = {};
+                    for (const id of ids) {
+                        const keyName = type + id;
+                        let value = cache.get(keyName);
+                        if (value === undefined && fileData[keyName] !== undefined) {
+                            value = fileData[keyName];
+                            cache.set(keyName, value);
+                        }
+                        if (type === 'app-state-sync-key' && value) {
+                            value = index_js_2.proto.Message.AppStateSyncKeyData.fromObject(value);
+                        }
+                        data[id] = value;
+                    }
+                    return data;
+                },
+                set: (data) => {
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const keyName = category + id;
+                            const value = data[category][id];
+                            value ? writeKey(keyName, value) : removeKey(keyName);
+                        }
+                    }
+                }
+            }
+        },
+        saveCreds: () => writeKey('creds', creds)
+    };
+};
+exports.useSingleFileAuthState = useSingleFileAuthState;