Agent 269

Klienti

Sdílený seznam – všichni trenéři vidí stejné klienty ze svých telefonů.

Páteční revize

Kdo co v gymu zapsal. Revize projedeš jednoho po druhém: otevře se Plán, zápisy se načtou samy a po odeslání skočíš na dalšího.

Kostra bloku

Nejdřív vyber klienta v záložce Klienti.

Generování

API klíč

Uloží se jen do tohohle telefonu. Nikam se neposílá, kromě Anthropicu při generování. Každý si platí svoje tokeny, takže si v konzoli nastav i měsíční strop.

Klíč

Model

Se zápisy z gymu stačí Sonnet, je levnější a rychlejší. Opus přepni, jen když generuješ z fotek ručně psaných archů.

Náčiní v gymu

Z tohohle seznamu se berou všechny váhy. Agent nesmí předepsat číslo, které tu nevyjde. Krok je rozestup mezi sousedními kusy.

Gumy na dopomoc

Jedna guma na řádek, od nejslabší po nejsilnější, třeba barvy. U cviků s dopomocí gumy (shyby s gumou, dipy s gumou) si klient v gymu vybere, kterou gumu nebo dvojici gum reálně použil. Tomáš si musí vyplnit stejný seznam.

Sdílení mezi trenéry

Když si oba vložíte stejnou adresu a heslo, vidíte stejné klienty z obou telefonů. Bez toho jedou klienti jen lokálně. Heslo se ukládá jen do tohohle telefonu, v souboru appky není.

Adresa úložiště Heslo

Návod, jak to založit (jednou, pak už jen vkládáš)

1. Na dash.cloudflare.com si založ účet zdarma. Doménu po tobě bude chtít, žádnou nepotřebuješ - přeskoč to.

2. Vlevo Storage & Databases → KV → Create a namespace. Název: klienti269.

3. Vlevo Compute → Workers & Pages → Create → Start with Hello World! → jméno agent269 → Deploy.

4. Edit code, smaž všechno, co tam je, a vlož tohle:

/* Sdílené úložiště klientů pro Agent 269 + zápis tréninků v gymu (v2).
   Každý klient je vlastní záznam. Zápis projde jen tehdy, když je novější
   než uložená verze, takže souběžná práce ze dvou telefonů nic nepřepíše.
   Klienti si přes QR v gymu stahují schválený plán a zapisují odcvičené série.
   Klient potřebuje svůj PIN a kód dne, který visí na tabuli v gymu. */

/* ↓↓↓ TADY SI ZMĚŇ HESLO ↓↓↓
   Bez diakritiky a bez mezer, aspoň 16 znaků.
   Stejné heslo pak vložíš do appky a pošleš Tomášovi. */

const HESLO = "zmen-me-na-svoje-heslo";

/* ↑↑↑ dál už nic měnit nemusíš ↑↑↑ */

const SLOVA = ["DREP", "TAH", "BENCH", "SHYB", "KLIK", "VESLO", "SANE", "OSA", "GUMA", "BEDNA",
  "LAVICE", "KOTOUC", "MAGNEZ", "PAS", "SUMO", "PRITAH", "KLADKA", "RETEZ", "KOULE", "SVIH"];

export default {
  async fetch(request, env) {
    const cors = {
      "Access-Control-Allow-Origin": "*",
      "Access-Control-Allow-Methods": "GET,POST,OPTIONS",
      "Access-Control-Allow-Headers": "content-type",
      "Cache-Control": "no-store"
    };
    const odpoved = (obj, stav) => new Response(JSON.stringify(obj), {
      status: stav || 200,
      headers: Object.assign({ "Content-Type": "application/json" }, cors)
    });

    if (request.method === "OPTIONS") return new Response(null, { headers: cors });

    if (!HESLO || HESLO === "zmen-me-na-svoje-heslo") {
      return odpoved({ chyba: "V kodu Workeru je porad vychozi heslo. Zmen radek s HESLO a dej Deploy." }, 500);
    }
    if (!env.DB) {
      return odpoved({ chyba: "Worker nema pripojene uloziste KV pod nazvem DB." }, 500);
    }

    const url = new URL(request.url);
    const akce = url.searchParams.get("akce") || "";

    const nactiJson = async () => {
      const t = await request.text();
      if (t.length > 60000) throw new Error("Moc dlouhe.");
      return JSON.parse(t);
    };
    const kvJson = async (k) => {
      const t = await env.DB.get(k);
      if (!t) return null;
      try { return JSON.parse(t); } catch (e) { return null; }
    };

    /* ---------- klientská část: bez hesla trenéra, ale s PINem a kódem dne ---------- */
    if (akce === "plan" || akce === "zapis") {
      if (request.method !== "POST") return odpoved({ chyba: "Nepodporovana metoda." }, 405);
      let b;
      try { b = await nactiJson(); } catch (e) { return odpoved({ chyba: "Nectitelny obsah." }, 400); }

      const ip = request.headers.get("CF-Connecting-IP") || "x";
      const fkl = "f:" + ip;
      const pokusy = Number(await env.DB.get(fkl) || 0);
      if (pokusy >= 30) return odpoved({ chyba: "Moc spatnych pokusu. Zkus to za hodinu.", duvod: "limit" }, 429);
      const spatne = async (duvod, text) => {
        await env.DB.put(fkl, String(pokusy + 1), { expirationTtl: 3600 });
        return odpoved({ chyba: text, duvod }, 403);
      };

      if (normalizuj(b && b.kod) !== await denniKod(dnes())) return spatne("kod", "Kod dne nesedi.");
      const pin = String((b && b.pin) || "").replace(/\D/g, "");
      if (pin.length !== 4) return spatne("pin", "PIN nesedi.");
      const id = await env.DB.get("pin:" + pin);
      if (!id) return spatne("pin", "PIN nesedi.");
      const plan = await kvJson("p:" + id);
      if (!plan || plan.pin !== pin) return odpoved({ chyba: "Trener ti jeste neposlal plan.", duvod: "zadny" }, 404);

      const prefix = "z:" + id + ":" + plan.tyden + ":";

      if (akce === "plan") {
        const zapisy = {};
        const v = await env.DB.list({ prefix });
        for (const key of v.keys) {
          const z = await kvJson(key.name);
          if (z && z.klic) zapisy[z.klic] = z;
        }
        return odpoved({ jmeno: plan.jmeno, tyden: plan.tyden, jednotky: plan.jednotky || [], zapisy });
      }

      const z = b.zapis;
      if (!z || typeof z.klic !== "string") return odpoved({ chyba: "Chybi zapis." }, 400);
      const jed = (plan.jednotky || []).find((j) => j.klic === z.klic);
      if (!jed) return odpoved({ chyba: "Tahle jednotka v planu neni." }, 400);
      const zaznam = {
        id, jmeno: plan.jmeno, tyden: plan.tyden, klic: z.klic, nazev: jed.nazev,
        datum: dnes(), cas: Date.now(),
        cviky: Array.isArray(z.cviky) ? z.cviky : [],
        pocit: z.pocit && typeof z.pocit === "object" ? z.pocit : {},
        poznamka: String(z.poznamka || "").slice(0, 2000)
      };
      await env.DB.put(prefix + z.klic, JSON.stringify(zaznam));
      return odpoved({ stav: "ulozeno", datum: zaznam.datum });
    }

    /* ---------- odsud dál jen trenéři s heslem ---------- */
    if (url.searchParams.get("heslo") !== HESLO) {
      return odpoved({ chyba: "Spatne heslo." }, 401);
    }

    if (akce === "kod") {
      const d = dnes();
      return odpoved({ kod: await denniKod(d), datum: d, verze: 2 });
    }

    if (akce === "publikuj") {
      if (request.method !== "POST") return odpoved({ chyba: "Nepodporovana metoda." }, 405);
      let p;
      try { p = await nactiJson(); } catch (e) { return odpoved({ chyba: "Nectitelny obsah." }, 400); }
      if (!p || typeof p.id !== "string" || !p.id) return odpoved({ chyba: "Chybi id." }, 400);
      const pin = String(p.pin || "");
      if (!/^\d{4}$/.test(pin)) return odpoved({ chyba: "PIN musi mit 4 cislice." }, 400);
      if (!Array.isArray(p.jednotky) || !p.jednotky.length) return odpoved({ chyba: "Plan nema zadne jednotky." }, 400);
      const drzitel = await env.DB.get("pin:" + pin);
      if (drzitel && drzitel !== p.id) return odpoved({ chyba: "PIN uz ma jiny klient.", duvod: "pin_obsazen" }, 409);
      const stary = await kvJson("p:" + p.id);
      if (stary && stary.pin && stary.pin !== pin) await env.DB.delete("pin:" + stary.pin);
      await env.DB.put("pin:" + pin, p.id);
      await env.DB.put("p:" + p.id, JSON.stringify({
        id: p.id, jmeno: String(p.jmeno || ""), pin, tyden: Number(p.tyden) || 1,
        jednotky: p.jednotky, odeslano: Date.now()
      }));
      return odpoved({ stav: "publikovano" });
    }

    if (akce === "zapisy") {
      const id = url.searchParams.get("id") || "";
      if (!id) return odpoved({ chyba: "Chybi id." }, 400);
      const out = [];
      let cursor;
      do {
        const v = await env.DB.list({ prefix: "z:" + id + ":", cursor });
        for (const key of v.keys) {
          const z = await kvJson(key.name);
          if (z) out.push(z);
        }
        cursor = v.list_complete ? null : v.cursor;
      } while (cursor);
      const plan = await kvJson("p:" + id);
      return odpoved({ zapisy: out, plan: plan ? { tyden: plan.tyden, pin: plan.pin, odeslano: plan.odeslano,
        jednotky: (plan.jednotky || []).map((j) => ({ klic: j.klic, nazev: j.nazev })) } : null });
    }

    /* ---------- původní sdílení klientů mezi trenéry ---------- */
    if (request.method === "GET") {
      const radky = [];
      let cursor;
      do {
        const v = await env.DB.list({ prefix: "k:", cursor });
        for (const key of v.keys) {
          const txt = await env.DB.get(key.name);
          if (!txt) continue;
          try { radky.push(JSON.parse(txt)); } catch (e) { /* poskozeny zaznam preskoc */ }
        }
        cursor = v.list_complete ? null : v.cursor;
      } while (cursor);
      return odpoved(radky);
    }

    if (request.method === "POST") {
      let r;
      try { r = JSON.parse(await request.text()); }
      catch (e) { return odpoved({ chyba: "Nectitelny obsah." }, 400); }
      if (!r || typeof r.id !== "string" || !r.id) return odpoved({ chyba: "Chybi id." }, 400);

      const klic = "k:" + r.id;
      const staryTxt = await env.DB.get(klic);
      if (staryTxt) {
        let stary = null;
        try { stary = JSON.parse(staryTxt); } catch (e) { stary = null; }
        if (stary && Number(stary.upd || 0) >= Number(r.upd || 0)) {
          return odpoved({ stav: "starsi" });
        }
      }
      await env.DB.put(klic, JSON.stringify(r));
      return odpoved({ stav: "zapsano" });
    }

    return odpoved({ chyba: "Nepodporovana metoda." }, 405);
  }
};

/* dnešní datum v Praze, tvar 2026-09-23 */
function dnes() {
  const c = new Intl.DateTimeFormat("en-CA", { timeZone: "Europe/Prague", year: "numeric", month: "2-digit", day: "2-digit" }).formatToParts(new Date());
  const g = (t) => c.find((x) => x.type === t).value;
  return g("year") + "-" + g("month") + "-" + g("day");
}

/* kód dne: slovo + dvě číslice, odvozené z hesla a data, takže ho nikdo neuhodne a nikde se neukládá */
async function denniKod(datum) {
  const k = await crypto.subtle.importKey("raw", new TextEncoder().encode(HESLO), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
  const s = new Uint8Array(await crypto.subtle.sign("HMAC", k, new TextEncoder().encode("kod:" + datum)));
  const cislo = String((s[1] * 256 + s[2]) % 100).padStart(2, "0");
  return SLOVA[s[0] % SLOVA.length] + cislo;
}

function normalizuj(t) {
  return String(t || "").normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/[^A-Za-z0-9]/g, "").toUpperCase();
}

5. Nahoře v kódu je řádek const HESLO = "zmen-me-na-svoje-heslo"; - přepiš si ho na vlastní heslo. Bez diakritiky a mezer, aspoň 16 znaků. Pak vpravo nahoře Deploy.

6. U Workera → Settings → Bindings → Add → KV namespace. Do políčka Variable name napiš přesně DB velkými, a vyber namespace klienti269. Ulož.

7. Adresu Workeru (tvaru agent269.neco.workers.dev) vlož sem nahoru i s https://, do druhého pole to heslo z kódu. Pak Uložit sdílení a Otestovat úložiště.

8. Adresu i heslo pošli Tomášovi. Kdo je má, vidí a mění vaše klienty.

Aktualizace na novou verzi Workeru: zkopíruj kód výš, v Cloudflare přes Edit code ho vlož místo starého, vrať do řádku HESLO svoje dosavadní heslo a dej Deploy. Vazba DB i klienti zůstávají.

Zápis v gymu

Klienti si přes QR v gymu otevřou schválený plán a zapisují série do mobilu. Potřebuje zapnuté sdílení výš a Worker verze 2. Klient se přihlásí PINem (najdeš ho u klienta) a kódem dne, který napíšeš na tabuli.

Adresa klientské stránky

Data

Zálohu si sem tam ulož do poznámek. Když si smažeš data prohlížeče, klienti zmizí.