Tag: self-hosted

# Gemini API cookies
SECURE_1PSID=g.a00
SECURE_1PSIDTS=sidts-CjE

import asyncio
import os
import sys
from pathlib import Path

# Third-party imports
from dotenv import load_dotenv
from gemini_webapi import GeminiClient, set_log_level
from gemini_webapi.constants import Model

# Load environment variables
load_dotenv()
Secure_1PSID = os.getenv("SECURE_1PSID")
Secure_1PSIDTS = os.getenv("SECURE_1PSIDTS")

# Enable logging for debugging
set_log_level("INFO")

def get_client():
    """Initialize the client with our cookies."""
    return GeminiClient(Secure_1PSID, Secure_1PSIDTS, proxy=None)

async def gen_and_edit():
    # Setup paths
    temp_dir = Path("temp")
    temp_dir.mkdir(exist_ok=True)
    
    # Import our local watermark remover (see next section)
    # We add '.' to sys.path to ensure Python finds the file
    sys.path.append('.')
    try:
        from watermark_remover import remove_watermark
    except ImportError:
        print("Warning: Watermark remover module not found. Skipping cleanup.")
        remove_watermark = None

    client = get_client()
    await client.init()

    prompt = "Generate a photorealistic picture of a ragdoll cat dressed as a baker inside of a bakery shop"
    print(f"🎨 Sending prompt: {prompt}")

    response = await client.generate_content(prompt)

    for i, image in enumerate(response.images):
        filename = f"cat_{i}.png"
        img_path = temp_dir / filename
        
        # Save the raw image from Gemini
        await image.save(path="temp/", filename=filename, verbose=True)
        
        # If we have the remover script, clean the image immediately
        if remove_watermark:
            print(f"✨ Polishing image: {img_path}")
            cleaned = remove_watermark(img_path)
            cleaned.save(img_path)
            print(f"✅ Done! Saved to: {img_path}")

if __name__ == "__main__":
    asyncio.run(gen_and_edit())

#!/usr/bin/env python3
"""
Gemini Watermark Remover - Python Implementation
Ported from journey-ad/gemini-watermark-remover
"""
import sys
from pathlib import Path
from PIL import Image
import numpy as np
from io import BytesIO

# Ensure bg_48.png and bg_96.png are in this folder!
ASSETS_DIR = Path(__file__).parent

def load_alpha_map(size):
    """Load and calculate alpha map from the background assets."""
    bg_path = ASSETS_DIR / f"bg_{size}.png"
    if not bg_path.exists():
        raise FileNotFoundError(f"Missing asset: {bg_path} - Please download from repo.")
    
    bg_img = Image.open(bg_path).convert('RGB')
    bg_array = np.array(bg_img, dtype=np.float32)
    # Normalize to [0, 1]
    return np.max(bg_array, axis=2) / 255.0

# Cache the maps so we don't reload them every time
_ALPHA_MAPS = {}

def get_alpha_map(size):
    if size not in _ALPHA_MAPS:
        _ALPHA_MAPS[size] = load_alpha_map(size)
    return _ALPHA_MAPS[size]

def detect_watermark_config(width, height):
    """
    Gemini uses a 96px logo for images > 1024px, 
    and a 48px logo for everything else.
    """
    if width > 1024 and height > 1024:
        return {"logo_size": 96, "margin": 64}
    else:
        return {"logo_size": 48, "margin": 32}

def remove_watermark(image, verbose=False):
    """
    The Magic: Reverses the blending formula:
    original = (watermarked - alpha * logo) / (1 - alpha)
    """
    # Load image and convert to RGB
    if isinstance(image, (str, Path)):
        img = Image.open(image).convert('RGB')
    elif isinstance(image, bytes):
        img = Image.open(BytesIO(image)).convert('RGB')
    else:
        img = image.convert('RGB')

    width, height = img.size
    config = detect_watermark_config(width, height)
    logo_size = config["logo_size"]
    margin = config["margin"]
    
    # Calculate position (Bottom Right)
    x = width - margin - logo_size
    y = height - margin - logo_size

    if x < 0 or y < 0:
        return img # Image too small

    # Get the math ready
    alpha_map = get_alpha_map(logo_size)
    img_array = np.array(img, dtype=np.float32)
    
    LOGO_VALUE = 255.0  # The watermark is white
    MAX_ALPHA = 0.99    # Prevent division by zero

    # Process only the watermark area
    for row in range(logo_size):
        for col in range(logo_size):
            alpha = alpha_map[row, col]
            
            # Skip noise
            if alpha < 0.002: continue
            
            alpha = min(alpha, MAX_ALPHA)
            
            # Apply the reverse blend to R, G, B channels
            for c in range(3):
                pixel_val = img_array[y + row, x + col, c]
                restored = (pixel_val - alpha * LOGO_VALUE) / (1.0 - alpha)
                img_array[y + row, x + col, c] = max(0, min(255, round(restored)))

    return Image.fromarray(img_array.astype(np.uint8), 'RGB')

# Main block for CLI usage
if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Usage: python remover.py <image_path>")
        sys.exit(1)
    
    img_path = Path(sys.argv[1])
    result = remove_watermark(img_path, verbose=True)
    output = img_path.parent / f"{img_path.stem}_clean{img_path.suffix}"
    result.save(output)
    print(f"Saved cleaned image to: {output}")

from random import randint
import time
import aiohttp
import datetime
import json
import os
import asyncio
from gemini_webapi import GeminiClient, set_log_level
from dotenv import load_dotenv

load_dotenv()

# Set log level for debugging
set_log_level("INFO")

MEMORY_PATH = os.path.join(os.path.dirname(__file__), "memory.json")
HISTORY_PATH = os.path.join(os.path.dirname(__file__), "history.json")
FLATNOTES_API_URL = "https://flatnotes.notarealdomain.de/api/notes/LinkedIn"
FLATNOTES_USERNAME = os.getenv("FLATNOTES_USERNAME")
FLATNOTES_PASSWORD = os.getenv("FLATNOTES_PASSWORD")
Secure_1PSID = os.getenv("SECURE_1PSID")
Secure_1PSIDTS = os.getenv("SECURE_1PSIDTS")


async def post_to_flatnotes(new_post):
    """
    Fetches the current note, prepends the new post, and updates the note using Flatnotes API with basic auth.
    """
    if not FLATNOTES_USERNAME or not FLATNOTES_PASSWORD:
        print(
            "[ERROR] FLATNOTES_USERNAME or FLATNOTES_PASSWORD is not set in .env. Skipping Flatnotes update."
        )
        return
    token_url = "https://notes.karlcloud.de/api/token"
    async with aiohttp.ClientSession() as session:
    
        # 1. Get bearer token
        token_payload = {"username": FLATNOTES_USERNAME, "password": FLATNOTES_PASSWORD}
        async with session.post(token_url, json=token_payload) as token_resp:
            if token_resp.status != 200:
                print(f"[ERROR] Failed to get token: {token_resp.status}")
                return
            token_data = await token_resp.json()
            access_token = token_data.get("access_token")
            if not access_token:
                print("[ERROR] No access_token in token response.")
                return
        headers = {"Authorization": f"Bearer {access_token}"}
        
        # 2. Get current note content
        async with session.get(FLATNOTES_API_URL, headers=headers) as resp:
            if resp.status == 200:
                try:
                    data = await resp.json()
                    current_content = data.get("content", "")
                except aiohttp.ContentTypeError:
                    # Fallback: treat as plain text
                    current_content = await resp.text()
            else:
                current_content = ""
                
        # Prepend new post
        updated_content = f"{new_post}\n\n---\n\n" + current_content
        patch_payload = {"newContent": updated_content}
        async with session.patch(
            FLATNOTES_API_URL, json=patch_payload, headers=headers
        ) as resp:
            if resp.status not in (200, 204):
                print(f"[ERROR] Failed to update Flatnotes: {resp.status}")
            else:
                print("[INFO] Flatnotes updated successfully.")


def save_history(new_json):
    arr = []
    if os.path.exists(HISTORY_PATH):
        try:
            with open(HISTORY_PATH, "r", encoding="utf-8") as f:
                arr = json.load(f)
                if not isinstance(arr, list):
                    arr = []
        except Exception:
            arr = []
    arr.append(new_json)
    with open(HISTORY_PATH, "w", encoding="utf-8") as f:
        json.dump(arr, f, ensure_ascii=False, indent=2)
    return arr


def load_memory():
    if not os.path.exists(MEMORY_PATH):
        return []
    try:
        with open(MEMORY_PATH, "r", encoding="utf-8") as f:
            data = json.load(f)
            if isinstance(data, list):
                return data
            return []
    except Exception:
        return []


def save_memory(new_json):
    arr = load_memory()
    arr.append(new_json)
    arr = arr[-3:]  # Keep only last 3
    with open(MEMORY_PATH, "w", encoding="utf-8") as f:
        json.dump(arr, f, ensure_ascii=False, indent=2)
    return arr


def get_client():
    return GeminiClient(Secure_1PSID, Secure_1PSIDTS, proxy=None)


def get_current_date():
    return datetime.datetime.now().strftime("%d. %B %Y")


async def example_generate_content():
    client = get_client()
    await client.init()
    chat = client.start_chat(model="gemini-3.0-pro")

    memory_entries = load_memory()
    memory_str = ""
    if memory_entries:
        memory_str = "\n\n---\nVergangene LinkedIn-Posts (letzte 3):\n" + "\n".join(
            [
                json.dumps(entry, ensure_ascii=False, indent=2)
                for entry in memory_entries
            ]
        )

    prompt = (
        """
        **Role:** Du bist ein weltklasse LinkedIn-Strategist (Top 1% Creator) und Verhaltenspsychologe.
        **Mission:** Erstelle einen viralen LinkedIn-Post, kurz knapp auf den punkt, denn leute lesen nur wenig und kurz, der mich als die unangefochtene Autorität für Cybersecurity & AI Governance in der DACH-Region etabliert.
        **Ziel:** Maximale Reichweite (100k Follower Strategie) + direkte Lead-Generierung für "https://karlcom.de" (High-Ticket Consulting).
        **Output Format:** Ausschließlich valides JSON.
        **Datum:** Heute ist der """
        + str(get_current_date())
        + """ nutze nur brand aktuelle Themen.

        **PHASE 1: Deep Intelligence (Google Search)**
        Nutze Google Search. Suche nach "Trending News Cybersecurity AI Cloud EU Sovereignty last 24h".
        Finde den "Elephant in the room" – das Thema, das C-Level Manager (CISO, CTO, CEO) gerade nachts wach hält, über das aber noch keiner Tacheles redet.
        * *Fokus:* Große Schwachstellen, Hackerangriffe, Datenleaks, AI, Cybersecurity, NIS2-Versäumnisse, Shadow-AI Datenlecks, Cloud-Exit-Szenarien.
        * *Anforderung:* Es muss ein Thema mit finanziellem oder strafrechtlichem Risiko sein.

        **PHASE 2: Die "Viral Architecture" (Konstruktion)**
        Schreibe den Post auf DEUTSCH. Befolge strikt diese 5-Stufen-Matrix für Viralität:

        **1. The "Thumb-Stopper" (Der Hook - Zeile 1-2):**
        * Keine Fragen ("Wussten Sie...?").
        * Keine Nachrichten ("Heute wurde Gesetz X verabschiedet").
        * **SONDERN:** Ein harter Kontrarian-Standpunkt oder eine unbequeme Wahrheit.
        * *Stil:* "Ihr aktueller Sicherheitsplan ist nicht nur falsch. Er ist fahrlässig."
        * *Ziel:* Der Leser spürt einen körperlichen Impuls, weiterzulesen.

        **2. The "Fear & Gap" (Die Agitation):**
        * Erkläre die Konsequenz der News aus Phase 1.
        * Nutze "Loss Aversion": Zeige auf, was sie verlieren (Geld, Reputation, Job), wenn sie das ignorieren.
        * Nutze kurze, rhythmische Sätze (Staccato-Stil). Das erhöht die Lesegeschwindigkeit massiv.

        **3. The "Authority Bridge" (Die Wende):**
        * Wechsle von Panik zu Kompetenz.
        * Zeige auf, dass blinder Aktionismus jetzt falsch ist. Man braucht Strategie.
        * Hier etablierst du deinen Status: Du bist der Fels in der Brandung.

        **4. The "Soft Pitch" (Die Lösung):**
        * Biete **Karlcom.de** als exklusive Lösung an. Nicht betteln ("Wir bieten an..."), sondern feststellen:
        * *Wording:* "Das ist der Standard, den wir bei Karlcom.de implementieren." oder "Deshalb rufen uns Vorstände an, wenn es brennt."

        **5. The "Engagement Trap" (Der Schluss):**
        * Stelle eine Frage, die man nicht mit "Ja/Nein" beantworten kann, sondern die eine Meinung provoziert. (Treibt den Algorithmus).
        * Beende mit einem imperativen CTA wie zum Beispiel: "Sichern wir Ihre Assets."

        **PHASE 3: Anti-AI & Status Checks**
        * **Verbotene Wörter (Sofortiges Disqualifikations-Kriterium):** "entfesseln", "tauchen wir ein", "nahtlos", "Gamechanger", "In der heutigen Welt", "Synergie", "Leuchtturm".
        * **Verbotene Formatierung:** Keine **fetten** Sätze (wirkt werblich). Keine Hashtag-Blöcke > 3 Tags.
        * **Emojis:** Maximal 2. Nur "Status-Emojis" (📉, 🛑, 🔒, ⚠️). KEINE Raketen 🚀.

        **PHASE 4: JSON Output**
        Erstelle das JSON. Der `post` String muss `\n` für Zeilenumbrüche nutzen.

        **Output Schema:**
        ```json
        {
        "analyse": "Kurze Erklärung, warum dieses Thema heute viral gehen wird (Psychologischer Hintergrund).",
        "thema": "Titel des Themas",
        "source": "Quelle",
        "post": "Zeile 1 (Thumb-Stopper)\n\nZeile 2 (Gap)\n\nAbsatz (Agitation)...\n\n(Authority Bridge)...\n\n(Pitch Karlcom.de)...\n\n(Engagement Trap)"
        }

        **Context für vergangene Posts, diese Themen solltest du erstmal vermeiden:**\n\n"""
        + memory_str
    )

    response = await chat.send_message(prompt.strip())
    previous_session = chat.metadata

    max_attempts = 3
    newest_post_str = None
    def format_flatnotes_post(json_obj):
        heading = f"# {json_obj.get('thema', '').strip()}\n"
        analyse = json_obj.get('analyse', '').strip()
        analyse_block = f"\n```psychology\n{analyse}\n```\n" if analyse else ""
        post = json_obj.get('post', '').strip()
        source = json_obj.get('source', '').strip()
        source_block = f"\nQuelle: {source}" if source else ""
        return f"{heading}{analyse_block}\n{post}{source_block}"
    for attempt in range(max_attempts):
        try:
            text = response.text.strip()
            if text.startswith("```json"):
                text = text[7:].lstrip()
            if text.endswith("```"):
                text = text[:-3].rstrip()
            json_obj = json.loads(text)
            save_memory(json_obj)
            save_history(json_obj)
            newest_post_str = format_flatnotes_post(json_obj)
            break
        except Exception:
            print(response.text)
            print("- output was not valid json, retrying...")
            if attempt < max_attempts - 1:
                previous_chat = client.start_chat(metadata=previous_session)
                response = await previous_chat.send_message(
                    f"ENSURE PROPER JSON OUTPUT!\n\n{prompt}"
                )
            else:
                print("[ERROR] Failed to get valid JSON response after 3 attempts.")

    # Post to Flatnotes if we have a valid post
    if newest_post_str:
        await post_to_flatnotes(newest_post_str)


async def main():
    await example_generate_content()


if __name__ == "__main__":
    for i in range(50):
        asyncio.run(main())
        time.sleep(randint(60, 300))  # Wait between 1 to 5 minutes before next run

{
  "analyse": "Psychologischer Hebel: 'Personal Accountability' & 'Optimism Bias'. C-Level-Führungskräfte leben oft in der Illusion, Cyber-Risiken durch die Einstellung eines CISO vollständig an diesen delegiert zu haben (Moral Hazard). Der 'Elephant in the room' am 31.01.2026 ist das Ende der Schonfrist für die NIS2-Umsetzung...",
  "thema": "Der CISO-Irrtum: Warum Delegation Sie jetzt ins Gefängnis bringt",
  "source": "EU NIS2 Enforcement Reports Q1 2026 / Handelsblatt",
  "post": "Ihr CISO ist nicht Ihre Versicherung.\nEr ist Ihr potenzieller Belastungszeuge.\n\nDer Irrglaube vieler Vorstände hat im Januar 2026 ein jähes Ende gefunden.\n\nDie erste Welle der NIS2-Prüfungen rollt durch die DACH-Region.\nUnd die Aufsichtsbehörden suchen nicht nach technischen Fehlern.\nSie suchen nach 'Organisationsverschulden'.\n\nDas Szenario:\nEin Ransomware-Angriff legt die Produktion lahm.\nDer CEO sagt: 'Ich habe doch einen Top-CISO eingestellt. Das war sein Job.'\n\nDer Richter sagt: 'Nein. Die Überwachungspflicht ist nicht delegierbar.'\n\nWenn Sie Cyber-Resilienz als reine IT-Aufgabe behandeln, handeln Sie grob fahrlässig.\nDer CISO liefert die Technik.\nAber *Sie* liefern die Governance.\n\nWenn Sie das Risikoprofil Ihrer eigenen Supply Chain nicht ohne PowerPoint erklären können, haften Sie.\nNicht die GmbH.\nSie persönlich.\nMit Ihrem Privatvermögen.\n\n[...]\n\nSichern wir Ihre Assets. ⚖️"
}