gemini-reverse 1.0.0

package/types/image.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const axios = require('axios');
+const fs = require('fs');
+const path = require('path');
+
+class Image {
+    constructor({ url, title = '[Image]', alt = '', proxy = null } = {}) {
+        this.url = url;
+        this.title = title;
+        this.alt = alt;
+        this.proxy = proxy;
+    }
+
+    toString() {
+        const short = this.url.length <= 20 ? this.url : this.url.slice(0, 8) + '...' + this.url.slice(-12);
+        return `Image(title='${this.title}', alt='${this.alt}', url='${short}')`;
+    }
+
+    async save({ path: savePath = 'temp', filename = null, cookies = null, verbose = false, skipInvalidFilename = false } = {}) {
+        let fname = filename || this.url.split('/').pop().split('?')[0];
+        const match = fname.match(/^(.*\.\w+)/);
+        if (match) {
+            fname = match[1];
+        } else {
+            if (verbose) console.warn(`Invalid filename: ${fname}`);
+            if (skipInvalidFilename) return null;
+        }
+
+        const proxyConfig = this.proxy ? (() => { try { const u = new URL(this.proxy); return { protocol: u.protocol.replace(':', ''), host: u.hostname, port: parseInt(u.port) }; } catch { return undefined; } })() : undefined;
+
+        const res = await axios.get(this.url, {
+            responseType: 'arraybuffer',
+            headers: cookies ? { 'Cookie': Object.entries(cookies).map(([k, v]) => `${k}=${v}`).join('; ') } : {},
+            maxRedirects: 5,
+            ...(proxyConfig ? { proxy: proxyConfig } : {}),
+        });
+
+        if (res.status !== 200) throw new Error(`Error downloading image: ${res.status}`);
+
+        const contentType = res.headers['content-type'] || '';
+        if (contentType && !contentType.includes('image')) {
+            console.warn(`Content type of ${fname} is not image, but ${contentType}.`);
+        }
+
+        fs.mkdirSync(savePath, { recursive: true });
+        const dest = path.join(savePath, fname);
+        fs.writeFileSync(dest, Buffer.from(res.data));
+        if (verbose) console.log(`Image saved as ${path.resolve(dest)}`);
+        return path.resolve(dest);
+    }
+}
+
+class WebImage extends Image {
+    constructor(opts) { super(opts); }
+}
+
+class GeneratedImage extends Image {
+    constructor({ cookies, ...opts } = {}) {
+        super(opts);
+        if (!cookies || Object.keys(cookies).length === 0)
+            throw new Error('GeneratedImage requires cookies from GeminiClient.');
+        this.cookies = cookies;
+    }
+
+    async save({ path: savePath = 'temp', filename = null, cookies = null, verbose = false, skipInvalidFilename = false, fullSize = true } = {}) {
+        if (fullSize) this.url += '=s2048';
+        const ts = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14);
+        const fname = filename || `${ts}_${this.url.slice(-10)}.png`;
+        return super.save({ path: savePath, filename: fname, cookies: cookies || this.cookies, verbose, skipInvalidFilename });
+    }
+}
+
+module.exports = { Image, WebImage, GeneratedImage };

package/types/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+const { Candidate } = require('./candidate');
+const { ConversationTurn } = require('./conversation');
+const { Gem, GemJar } = require('./gem');
+const { RPCData } = require('./grpc');
+const { Image, WebImage, GeneratedImage } = require('./image');
+const { ModelOutput } = require('./modeloutput');
+
+module.exports = { Candidate, ConversationTurn, Gem, GemJar, RPCData, Image, WebImage, GeneratedImage, ModelOutput };

package/types/modeloutput.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const { WebImage, GeneratedImage } = require('./image');
+
+class Candidate {
+    constructor({ rcid, text, text_delta = null, thoughts = null, thoughts_delta = null, web_images = [], generated_images = [] } = {}) {
+        this.rcid = rcid;
+        this.text = this._decodeHtml(text);
+        this.text_delta = text_delta;
+        this.thoughts = thoughts ? this._decodeHtml(thoughts) : null;
+        this.thoughts_delta = thoughts_delta;
+        this.web_images = web_images;
+        this.generated_images = generated_images;
+    }
+
+    _decodeHtml(str) {
+        if (!str) return str;
+        return str
+            .replace(/&/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, '\'')
+            .replace(/&apos;/g, '\'');
+    }
+
+    get images() {
+        return [...this.web_images, ...this.generated_images];
+    }
+
+    toString() { return this.text; }
+
+    repr() {
+        const preview = this.text.length <= 20 ? this.text : this.text.slice(0, 20) + '...';
+        return `Candidate(rcid='${this.rcid}', text='${preview}', images=${this.images.length})`;
+    }
+}
+
+module.exports = { Candidate };

package/utils/accessToken.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const axios = require('axios');
+const fs = require('fs');
+const path = require('path');
+const { Endpoint, Headers } = require('../constants');
+const { AuthError } = require('../exceptions');
+
+function cookieStr(c) {
+    return Object.entries(c).map(([k, v]) => `${k}=${v}`).join('; ');
+}
+
+function parseCookies(headers, base = {}) {
+    const out = { ...base };
+    const raw = headers['set-cookie'] || headers['Set-Cookie'];
+    const arr = Array.isArray(raw) ? raw : raw ? [raw] : [];
+    for (const s of arr) {
+        const p = s.split(';')[0].trim();
+        const eq = p.indexOf('=');
+        if (eq !== -1) out[p.slice(0, eq).trim()] = p.slice(eq + 1).trim();
+    }
+    return out;
+}
+
+function parseProxy(str) {
+    if (!str) return undefined;
+    try { const u = new URL(str); return { protocol: u.protocol.replace(':', ''), host: u.hostname, port: parseInt(u.port) }; }
+    catch { return undefined; }
+}
+
+function cacheDir() {
+    return process.env.GEMINI_COOKIE_PATH
+        ? path.resolve(process.env.GEMINI_COOKIE_PATH)
+        : path.join(__dirname, 'temp');
+}
+
+async function sendInitRequest(cookies, proxy = null) {
+    const res = await axios.get(Endpoint.INIT, {
+        headers: { ...Headers.GEMINI, 'Cookie': cookieStr(cookies) },
+        maxRedirects: 5,
+        ...(proxy ? { proxy: parseProxy(proxy) } : {}),
+    });
+    const t = res.data;
+    const snlm0e = (t.match(/"SNlM0e":\s*"(.*?)"/) || [])[1] || null;
+    const cfb2h = (t.match(/"cfb2h":\s*"(.*?)"/) || [])[1] || null;
+    const fdrfje = (t.match(/"FdrFJe":\s*"(.*?)"/) || [])[1] || null;
+    if (!snlm0e && !cfb2h && !fdrfje) throw new AuthError('Cookies invalid.');
+    return [snlm0e, cfb2h, fdrfje, parseCookies(res.headers, cookies)];
+}
+
+async function getAccessToken(baseCookies, proxy = null, verbose = false) {
+    let extraCookies = {};
+    try {
+        const r = await axios.get(Endpoint.GOOGLE, { maxRedirects: 5, ...(proxy ? { proxy: parseProxy(proxy) } : {}) });
+        if (r.status === 200) extraCookies = parseCookies(r.headers);
+    } catch {}
+
+    const tasks = [];
+    const jar = (base, extra = {}) => ({ ...extraCookies, ...base, ...extra });
+    const dir = cacheDir();
+
+    if (baseCookies['__Secure-1PSID'])
+        tasks.push(sendInitRequest(jar(baseCookies), proxy));
+
+    const psid = baseCookies['__Secure-1PSID'];
+    if (psid) {
+        const f = path.join(dir, `.cached_1psidts_${psid}.txt`);
+        if (fs.existsSync(f)) {
+            const cached = fs.readFileSync(f, 'utf8');
+            if (cached) tasks.push(sendInitRequest(jar(baseCookies, { '__Secure-1PSIDTS': cached }), proxy));
+            else if (verbose) console.debug('Skipping cached cookies. Cache file is empty.');
+        } else if (verbose) {
+            console.debug('Skipping cached cookies. Cache file not found.');
+        }
+    } else if (fs.existsSync(dir)) {
+        let validCaches = 0;
+        for (const file of fs.readdirSync(dir).filter(f => f.startsWith('.cached_1psidts_'))) {
+            const cached = fs.readFileSync(path.join(dir, file), 'utf8');
+            if (cached) {
+                tasks.push(sendInitRequest(jar({}, { '__Secure-1PSID': file.slice(16), '__Secure-1PSIDTS': cached }), proxy));
+                validCaches++;
+            }
+        }
+        if (validCaches === 0 && verbose) console.debug('Skipping cached cookies. No valid caches found.');
+    }
+
+    if (!tasks.length)
+        throw new AuthError('No valid cookies available. Please pass __Secure-1PSID and optionally __Secure-1PSIDTS.');
+
+    let lastErr;
+    for (let i = 0; i < tasks.length; i++) {
+        try {
+            const result = await tasks[i];
+            if (verbose) console.debug(`Init attempt (${i + 1}/${tasks.length}) succeeded.`);
+            return result;
+        } catch (e) {
+            lastErr = e;
+            if (verbose) console.debug(`Init attempt (${i + 1}/${tasks.length}) failed: ${e.message}`);
+        }
+    }
+
+    throw new AuthError(`Failed to initialize client. (Failed attempts: ${tasks.length})`);
+}
+
+module.exports = { getAccessToken, sendInitRequest, cookieStr, parseCookies, parseProxy, cacheDir };

package/utils/index.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const { getAccessToken, sendInitRequest, cookieStr, parseCookies, parseProxy, cacheDir } = require('./accessToken');
+const { getDeltaByFpLen, getCleanText, getFpLen, getNestedValue, parseResponseByFrame, extractJsonFromResponse } = require('./parsing');
+const { rotate1psidts } = require('./rotate');
+const { uploadFile, parseFileName, generateRandomName } = require('./upload');
+
+module.exports = {
+    getAccessToken,
+    sendInitRequest,
+    cookieStr,
+    parseCookies,
+    parseProxy,
+    cacheDir,
+    getDeltaByFpLen,
+    getCleanText,
+    getFpLen,
+    getNestedValue,
+    parseResponseByFrame,
+    extractJsonFromResponse,
+    rotate1psidts,
+    uploadFile,
+    parseFileName,
+    generateRandomName,
+};

package/utils/parsing.js

@@ -0,0 +1,119 @@
+'use strict';
+
+const VOLATILE_RE = /[\s!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~]/g;
+const VOLATILE_SET = new Set(' \t\n\r\x0b\x0c!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~');
+const FLICKER_ESC_RE = /\\+[`*_~].*$/;
+
+function getCleanText(s) {
+    if (!s) return '';
+    if (s.endsWith('\n```')) s = s.slice(0, -4);
+    return s.replace(FLICKER_ESC_RE, '');
+}
+
+function getFpLen(s) {
+    return s.replace(VOLATILE_RE, '').length;
+}
+
+function getDeltaByFpLen(newRaw, lastSentClean, isFinal) {
+    const newC = isFinal ? newRaw : getCleanText(newRaw);
+    if (newC.startsWith(lastSentClean)) return [newC.slice(lastSentClean.length), newC];
+
+    const targetFpLen = getFpLen(lastSentClean);
+    let pLow = 0;
+
+    if (targetFpLen > 0) {
+        let cur = 0, found = false;
+        for (let i = 0; i < newC.length; i++) {
+            if (!VOLATILE_SET.has(newC[i])) cur++;
+            if (cur === targetFpLen) { pLow = i + 1; found = true; break; }
+        }
+        if (!found) {
+            let n = 0;
+            for (let i = 0; i < Math.min(lastSentClean.length, newC.length); i++) {
+                if (lastSentClean[i] === newC[i]) n++; else break;
+            }
+            return [newC.slice(n), newC];
+        }
+    }
+
+    let lastIdx = -1;
+    for (let i = lastSentClean.length - 1; i >= 0; i--) {
+        if (!VOLATILE_SET.has(lastSentClean[i])) { lastIdx = i; break; }
+    }
+    const suffix = lastSentClean.slice(lastIdx + 1);
+
+    let i = 0, j = 0;
+    while (i < suffix.length && (pLow + j) < newC.length) {
+        const cs = suffix[i], cn = newC[pLow + j];
+        if (cs === cn) { i++; j++; }
+        else if (cn === '\\' && (pLow + j + 1) < newC.length && newC[pLow + j + 1] === cs) { j += 2; i++; }
+        else if (cs === '\\' && (i + 1) < suffix.length && suffix[i + 1] === cn) { i += 2; j++; }
+        else break;
+    }
+    return [newC.slice(pLow + j), newC];
+}
+
+function getNestedValue(data, path, defaultVal = null) {
+    let cur = data;
+    for (const k of path) {
+        if (cur == null) return defaultVal;
+        if (typeof k === 'number') {
+            if (!Array.isArray(cur) || k < -cur.length || k >= cur.length) return defaultVal;
+            cur = cur[k < 0 ? cur.length + k : k];
+        } else {
+            if (typeof cur !== 'object' || !(k in cur)) return defaultVal;
+            cur = cur[k];
+        }
+    }
+    return cur != null ? cur : defaultVal;
+}
+
+function parseResponseByFrame(content) {
+    let pos = 0;
+    const frames = [];
+    while (pos < content.length) {
+        while (pos < content.length && /\s/.test(content[pos])) pos++;
+        if (pos >= content.length) break;
+        const m = /^(\d+)\n/.exec(content.slice(pos));
+        if (!m) break;
+        const len = parseInt(m[1]);
+        const start = pos + m[1].length;
+        let chars = 0, units = 0, idx = start;
+        while (units < len && idx < content.length) {
+            const cp = content.codePointAt(idx);
+            const u = cp > 0xFFFF ? 2 : 1;
+            if (units + u > len) break;
+            units += u; chars += cp > 0xFFFF ? 2 : 1; idx += cp > 0xFFFF ? 2 : 1;
+        }
+        if (units < len) break;
+        const end = start + chars;
+        const chunk = content.slice(start, end).trim();
+        pos = end;
+        if (!chunk) continue;
+        try {
+            const parsed = JSON.parse(chunk);
+            if (Array.isArray(parsed)) frames.push(...parsed); else frames.push(parsed);
+        } catch {}
+    }
+    return [frames, content.slice(pos)];
+}
+
+function extractJsonFromResponse(text) {
+    if (typeof text !== 'string') throw new TypeError(`Expected string, got ${typeof text}`);
+    let c = text.startsWith(")]}'") ? text.slice(4) : text;
+    c = c.trimStart();
+    const [r] = parseResponseByFrame(c);
+    if (r.length) return r;
+    try { const p = JSON.parse(c.trim()); return Array.isArray(p) ? p : [p]; } catch {}
+    const lines = [];
+    for (const line of c.trim().split('\n')) {
+        try {
+            const p = JSON.parse(line.trim());
+            if (Array.isArray(p)) lines.push(...p); else if (p && typeof p === 'object') lines.push(p);
+        } catch {}
+    }
+    if (lines.length) return lines;
+    throw new Error('Could not find valid JSON in response.');
+}
+
+module.exports = { getCleanText, getFpLen, getDeltaByFpLen, getNestedValue, parseResponseByFrame, extractJsonFromResponse };

package/utils/rotate.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const axios = require('axios');
+const fs = require('fs');
+const path = require('path');
+const { Endpoint, Headers } = require('../constants');
+const { AuthError } = require('../exceptions');
+const { cookieStr, parseCookies, parseProxy, cacheDir } = require('./accessToken');
+
+async function rotate1psidts(cookies, proxy = null) {
+    const dir = cacheDir();
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+    const psid = cookies['__Secure-1PSID'];
+    if (!psid) return [null, null];
+
+    const cachePath = path.join(dir, `.cached_1psidts_${psid}.txt`);
+
+    if (fs.existsSync(cachePath) && Date.now() - fs.statSync(cachePath).mtimeMs <= 60000) {
+        return [fs.readFileSync(cachePath, 'utf8'), null];
+    }
+
+    const res = await axios.post(Endpoint.ROTATE_COOKIES, '[000,"-0000000000000000000"]', {
+        headers: { ...Headers.ROTATE_COOKIES, 'Cookie': cookieStr(cookies) },
+        ...(proxy ? { proxy: parseProxy(proxy) } : {}),
+        validateStatus: null,
+    });
+
+    if (res.status === 401) throw new AuthError('Unauthorized while rotating cookies.');
+    if (res.status >= 400) throw new Error(`HTTP ${res.status} while rotating cookies.`);
+
+    const newCookies = parseCookies(res.headers);
+    const new1psidts = newCookies['__Secure-1PSIDTS'] || null;
+
+    if (new1psidts) {
+        fs.writeFileSync(cachePath, new1psidts, { mode: 0o600 });
+        return [new1psidts, newCookies];
+    }
+
+    return [null, newCookies];
+}
+
+module.exports = { rotate1psidts };

package/utils/upload.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const axios = require('axios');
+const fs = require('fs');
+const path = require('path');
+const FormData = require('form-data');
+const { Endpoint, Headers } = require('../constants');
+const { parseProxy } = require('./accessToken');
+
+function generateRandomName(ext = '.txt') {
+    return `input_${Math.floor(Math.random() * 9000000) + 1000000}${ext}`;
+}
+
+function parseFileName(file) {
+    if (typeof file === 'string') {
+        const fp = path.resolve(file);
+        if (!fs.existsSync(fp)) throw new Error(`${fp} is not a valid file.`);
+        return path.basename(fp);
+    }
+    if (Buffer.isBuffer(file)) return generateRandomName();
+    return generateRandomName();
+}
+
+async function uploadFile(file, proxy = null, filename = null) {
+    let content, fname;
+
+    if (typeof file === 'string') {
+        const fp = path.resolve(file);
+        if (!fs.existsSync(fp)) throw new Error(`${fp} is not a valid file.`);
+        fname = filename || path.basename(fp);
+        content = fs.readFileSync(fp);
+    } else if (Buffer.isBuffer(file)) {
+        content = file;
+        fname = filename || generateRandomName();
+    } else {
+        throw new Error(`Unsupported file type: ${typeof file}`);
+    }
+
+    const form = new FormData();
+    form.append('file', content, { filename: fname });
+
+    const res = await axios.post(Endpoint.UPLOAD, form, {
+        headers: { ...Headers.UPLOAD, ...form.getHeaders() },
+        maxRedirects: 5,
+        ...(proxy ? { proxy: parseProxy(proxy) } : {}),
+    });
+
+    return res.data;
+}
+
+module.exports = { uploadFile, parseFileName, generateRandomName };