Merge pull request 'Febe 0.1.0 — prima versione completa (M0–M8)' (#1) from febe-v1 into main
Reviewed-on: #1
No files matched your search
@@ -0,0 +1,15 @@
|
||||
# Contesto di «docker build -f docker/Dockerfile .»: solo ciò che serve a compilare e provare.
|
||||
**/bin/
|
||||
**/obj/
|
||||
**/out/
|
||||
**/*.trx
|
||||
**/TestResults/
|
||||
.git
|
||||
.gitea
|
||||
.claude
|
||||
.vs
|
||||
.vscode
|
||||
.idea
|
||||
docs/
|
||||
**/*.user
|
||||
**/node_modules/
|
||||
@@ -0,0 +1,6 @@
|
||||
# Gli script di shell restano con le righe Unix anche su un Windows con core.autocrlf: bash non regge il CR.
|
||||
*.sh text eol=lf
|
||||
# Il programma di installazione si costruisce anche da Linux con makensis.
|
||||
*.nsi text eol=lf
|
||||
# Binari: mai conversioni.
|
||||
*.ico binary
|
||||
@@ -0,0 +1,248 @@
|
||||
# Rilascio a ogni tag vX.Y.Z (anche vX.Y.Z-qualcosa per un'anteprima):
|
||||
# 1. prove: il tag coincide con <Version> di Directory.Build.props, la soluzione si compila con gli avvisi come errori
|
||||
# e tutte le prove passano. Senza prove verdi non si costruisce né si rilascia nulla;
|
||||
# 2. windows: Febe.exe in un file solo, il programma di installazione NSIS e lo zip portabile (installer/costruisci.sh,
|
||||
# gira su Linux);
|
||||
# 3. immagine: l'immagine Docker (le prove girano anche dentro la build), pubblicata sul registro dei container di
|
||||
# Gitea come <registro>/<proprietario>/febe:X.Y.Z e :latest (solo per le versioni senza trattino). Il lavoro dice
|
||||
# se l'ha pubblicata;
|
||||
# 4. release: solo dopo le prove, l'installatore e l'immagine. Crea la release (o la completa, se esiste già) con
|
||||
# installatore, zip portabile, modello Unraid e l'archivio per Docker Compose (compose.yml con il profilo seccomp
|
||||
# accanto); le note dicono dove sta l'immagine, o che non è stata pubblicata.
|
||||
#
|
||||
# Segreto del repository (Impostazioni ▸ Actions ▸ Segreti): REGISTRY_TOKEN, un token dell'utente con i permessi
|
||||
# «package: read and write». Senza, l'immagine si costruisce e si prova ma non si pubblica: la release esce lo stesso,
|
||||
# con l'installatore per Windows, e le sue note dicono che l'immagine di questa versione non c'è. Aggiunto il segreto,
|
||||
# si rilancia il flusso del tag: l'immagine si pubblica e le note della release si correggono.
|
||||
# Variabile facoltativa (Impostazioni ▸ Actions ▸ Variabili): REGISTRY, il nome del registro come lo raggiunge il
|
||||
# runner (per esempio 192.168.30.23:3000); se manca si usa l'host dell'indirizzo del server Gitea (il suo ROOT_URL).
|
||||
# Il registro risponde in HTTP: la pubblicazione passa da buildx con un builder proprio (docker-container) a cui la
|
||||
# configurazione di buildkit dice che quel registro è in HTTP e insicuro, così non serve che il Docker del runner lo
|
||||
# abbia fra gli insecure-registries. Le credenziali vanno nella configurazione del client Docker, senza «docker login»
|
||||
# (che passerebbe dal demone, e il demone proverebbe HTTPS).
|
||||
name: rilascio
|
||||
|
||||
on:
|
||||
push:
|
||||
tags: ["v*"]
|
||||
|
||||
jobs:
|
||||
prove:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Versione coerente con il tag
|
||||
run: |
|
||||
V=$(sed -n 's:.*<Version>\(.*\)</Version>.*:\1:p' Directory.Build.props | head -n 1)
|
||||
[ "v$V" = "${GITHUB_REF_NAME}" ] || { echo "Il tag ${GITHUB_REF_NAME} non coincide con <Version> $V"; exit 1; }
|
||||
|
||||
- uses: actions/setup-dotnet@v4
|
||||
with:
|
||||
dotnet-version: "10.0.x"
|
||||
|
||||
- name: Compilazione (avvisi = errori)
|
||||
run: dotnet build Febe.slnx -c Release -nologo -warnaserror
|
||||
|
||||
- name: Prove
|
||||
run: >-
|
||||
dotnet test tests/Febe.Tests -c Release --no-build --nologo
|
||||
--logger "trx;LogFileName=prove.trx" --results-directory out/prove
|
||||
|
||||
- name: Risultati
|
||||
if: always()
|
||||
uses: actions/upload-artifact@v3
|
||||
with:
|
||||
name: risultati-prove
|
||||
path: out/prove/*.trx
|
||||
if-no-files-found: ignore
|
||||
|
||||
windows:
|
||||
runs-on: ubuntu-latest
|
||||
needs: prove
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Versione
|
||||
run: echo "VERSION=${GITHUB_REF_NAME#v}" >> "$GITHUB_ENV"
|
||||
|
||||
- uses: actions/setup-dotnet@v4
|
||||
with:
|
||||
dotnet-version: "10.0.x"
|
||||
|
||||
- name: NSIS e zip
|
||||
run: |
|
||||
SUDO=""; [ "$(id -u)" = 0 ] || SUDO=sudo
|
||||
$SUDO apt-get update -qq
|
||||
$SUDO apt-get install -y -qq nsis zip > /dev/null
|
||||
|
||||
- name: Febe.exe, programma di installazione e zip portabile
|
||||
run: bash installer/costruisci.sh "$VERSION"
|
||||
|
||||
- uses: actions/upload-artifact@v3
|
||||
with:
|
||||
name: windows
|
||||
path: |
|
||||
out/Febe-Setup-*.exe
|
||||
out/Febe-*-portabile.zip
|
||||
if-no-files-found: error
|
||||
|
||||
immagine:
|
||||
runs-on: ubuntu-latest
|
||||
needs: prove
|
||||
outputs:
|
||||
immagine: ${{ steps.nome.outputs.immagine }}
|
||||
pubblicata: ${{ steps.pubblicazione.outputs.pubblicata }}
|
||||
motivo: ${{ steps.segreto.outputs.motivo }}
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Versione, registro e nome dell'immagine
|
||||
id: nome
|
||||
run: |
|
||||
V="${GITHUB_REF_NAME#v}"
|
||||
REGISTRY="${{ vars.REGISTRY }}"
|
||||
[ -n "$REGISTRY" ] || REGISTRY=$(echo "${{ gitea.server_url }}" | sed -E 's#^https?://##; s#/.*$##')
|
||||
OWNER=$(echo "${{ gitea.repository_owner }}" | tr '[:upper:]' '[:lower:]')
|
||||
echo "VERSION=$V" >> "$GITHUB_ENV"
|
||||
echo "REGISTRY=$REGISTRY" >> "$GITHUB_ENV"
|
||||
echo "IMAGE=$REGISTRY/$OWNER/febe" >> "$GITHUB_ENV"
|
||||
echo "registro=$REGISTRY" >> "$GITHUB_OUTPUT"
|
||||
echo "immagine=$REGISTRY/$OWNER/febe" >> "$GITHUB_OUTPUT"
|
||||
|
||||
# Un builder buildx proprio, che sa che il registro di casa risponde in HTTP.
|
||||
- uses: docker/setup-buildx-action@v3
|
||||
with:
|
||||
driver: docker-container
|
||||
buildkitd-config-inline: |
|
||||
[registry."${{ steps.nome.outputs.registro }}"]
|
||||
http = true
|
||||
insecure = true
|
||||
|
||||
- name: Costruzione dell'immagine (le prove girano dentro la build)
|
||||
run: |
|
||||
docker buildx build -f docker/Dockerfile \
|
||||
--build-arg VERSION="$VERSION" \
|
||||
--build-arg GIT_COMMIT="${GITHUB_SHA::12}" \
|
||||
-t "$IMAGE:$VERSION" --load .
|
||||
docker run --rm --entrypoint /usr/bin/chromium "$IMAGE:$VERSION" --version
|
||||
|
||||
- name: Segreto per il registro
|
||||
id: segreto
|
||||
env:
|
||||
TOKEN: ${{ secrets.REGISTRY_TOKEN }}
|
||||
run: |
|
||||
if [ -z "$TOKEN" ]; then
|
||||
echo "::warning::Manca il segreto REGISTRY_TOKEN: l'immagine è stata costruita e provata ma non pubblicata. La release esce lo stesso e lo dice."
|
||||
echo "Aggiungi il segreto (token con package: read and write) e rilancia il flusso di questo tag."
|
||||
echo "presente=no" >> "$GITHUB_OUTPUT"
|
||||
echo "motivo=manca il segreto REGISTRY_TOKEN del repository" >> "$GITHUB_OUTPUT"
|
||||
else
|
||||
echo "presente=si" >> "$GITHUB_OUTPUT"
|
||||
fi
|
||||
|
||||
- name: Pubblicazione sul registro di Gitea
|
||||
id: pubblicazione
|
||||
if: steps.segreto.outputs.presente == 'si'
|
||||
env:
|
||||
TOKEN: ${{ secrets.REGISTRY_TOKEN }}
|
||||
UTENTE: ${{ gitea.actor }}
|
||||
run: |
|
||||
set -eu
|
||||
# Le credenziali nella configurazione del client: buildx le passa al builder, il demone non c'entra.
|
||||
CONFIG="${DOCKER_CONFIG:-$HOME/.docker}"
|
||||
mkdir -p "$CONFIG"
|
||||
[ -s "$CONFIG/config.json" ] || echo '{}' > "$CONFIG/config.json"
|
||||
AUTH=$(printf '%s:%s' "$UTENTE" "$TOKEN" | base64 -w0)
|
||||
jq --arg r "$REGISTRY" --arg a "$AUTH" '.auths[$r].auth = $a' "$CONFIG/config.json" > "$CONFIG/config.json.nuovo"
|
||||
mv "$CONFIG/config.json.nuovo" "$CONFIG/config.json"
|
||||
TAGS="-t $IMAGE:$VERSION"
|
||||
case "$VERSION" in
|
||||
*-*) echo "Versione di anteprima: :latest non si sposta." ;;
|
||||
*) TAGS="$TAGS -t $IMAGE:latest" ;;
|
||||
esac
|
||||
# La stessa costruzione di prima (dalla cache del builder), questa volta spinta sul registro.
|
||||
docker buildx build -f docker/Dockerfile \
|
||||
--build-arg VERSION="$VERSION" \
|
||||
--build-arg GIT_COMMIT="${GITHUB_SHA::12}" \
|
||||
$TAGS --push .
|
||||
echo "pubblicata=si" >> "$GITHUB_OUTPUT"
|
||||
|
||||
- name: Credenziali tolte
|
||||
if: always()
|
||||
run: |
|
||||
CONFIG="${DOCKER_CONFIG:-$HOME/.docker}/config.json"
|
||||
if [ -s "$CONFIG" ] && [ -n "${REGISTRY:-}" ]; then
|
||||
jq --arg r "$REGISTRY" 'if .auths then .auths |= del(.[$r]) else . end' "$CONFIG" > "$CONFIG.nuovo" && mv "$CONFIG.nuovo" "$CONFIG"
|
||||
fi
|
||||
|
||||
release:
|
||||
runs-on: ubuntu-latest
|
||||
# Le prove sono verdi, l'installatore c'è e l'immagine si è costruita: pubblicata, o non pubblicata per la sola
|
||||
# mancanza del segreto (il lavoro «immagine» lo dice e le note lo riportano). Se la costruzione o la spinta sul
|
||||
# registro falliscono, non esce nessuna release.
|
||||
needs: [prove, windows, immagine]
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- uses: actions/download-artifact@v3
|
||||
with:
|
||||
name: windows
|
||||
path: out
|
||||
|
||||
- name: Release con installatore, zip portabile, modello Unraid e archivio per Compose
|
||||
env:
|
||||
TOKEN: ${{ github.token }}
|
||||
API: ${{ gitea.server_url }}/api/v1/repos/${{ gitea.repository }}
|
||||
IMMAGINE: ${{ needs.immagine.outputs.immagine }}
|
||||
PUBBLICATA: ${{ needs.immagine.outputs.pubblicata }}
|
||||
MOTIVO: ${{ needs.immagine.outputs.motivo }}
|
||||
run: |
|
||||
set -eu
|
||||
TAG="${GITHUB_REF_NAME}"
|
||||
VERSION="${TAG#v}"
|
||||
case "$VERSION" in *-*|0.*) PRE=true ;; *) PRE=false ;; esac # le versioni 0.x sono anteprime
|
||||
NOTE=$(awk -v v="$VERSION" '/^## /{p=($2==v)} p' CHANGELOG.md || true)
|
||||
[ -n "$NOTE" ] || NOTE="Febe $VERSION"
|
||||
if [ "$PUBBLICATA" = "si" ]; then
|
||||
case "$VERSION" in
|
||||
*-*) DOVE="\`$IMMAGINE:$VERSION\` (anteprima: \`:latest\` resta sulla versione precedente)" ;;
|
||||
*) DOVE="\`$IMMAGINE:$VERSION\` e \`$IMMAGINE:latest\`" ;;
|
||||
esac
|
||||
IMMAGINE_NOTA="Immagine Docker: $DOVE. Il registro risponde in HTTP: il Docker che la scarica deve averlo fra gli \`insecure-registries\`."
|
||||
else
|
||||
IMMAGINE_NOTA="**L'immagine Docker di questa versione non è stata pubblicata** (${MOTIVO:-motivo sconosciuto}): \`:latest\` resta sulla versione precedente, e Unraid e Docker Compose continuano a usare quella. Febe per Windows, qui allegato, è provato come sempre. Per pubblicare l'immagine, rilancia il flusso di rilascio di questo tag dopo aver risolto il problema: queste note si aggiornano."
|
||||
fi
|
||||
NOTE=$(printf '%s\n\n### Immagine Docker\n\n%s\n' "$NOTE" "$IMMAGINE_NOTA")
|
||||
|
||||
ID=$(curl -sf -H "Authorization: token $TOKEN" "$API/releases/tags/$TAG" | jq -r '.id // empty' || true)
|
||||
if [ -z "$ID" ]; then
|
||||
ID=$(jq -n --arg t "$TAG" --arg n "Febe $VERSION" --arg b "$NOTE" --argjson p "$PRE" \
|
||||
'{tag_name:$t, name:$n, body:$b, draft:false, prerelease:$p}' \
|
||||
| curl -sf -X POST -H "Authorization: token $TOKEN" -H "Content-Type: application/json" \
|
||||
--data-binary @- "$API/releases" | jq -r .id)
|
||||
echo "Release $TAG creata (id $ID)"
|
||||
else
|
||||
# Le note dicono come è andata questa volta (per esempio: l'immagine ora è pubblicata).
|
||||
jq -n --arg b "$NOTE" '{body:$b}' \
|
||||
| curl -sf -X PATCH -H "Authorization: token $TOKEN" -H "Content-Type: application/json" \
|
||||
--data-binary @- "$API/releases/$ID" > /dev/null
|
||||
echo "Release $TAG già presente (id $ID): note aggiornate, aggiungo gli allegati mancanti"
|
||||
fi
|
||||
|
||||
cp docker/unraid/febe.xml "out/febe-unraid-$VERSION.xml"
|
||||
# compose.yml indica il profilo seccomp con un percorso relativo: l'archivio li porta insieme.
|
||||
COMPOSE="out/febe-compose-$VERSION"
|
||||
rm -rf "$COMPOSE"
|
||||
mkdir -p "$COMPOSE/chromium"
|
||||
cp docker/compose.yml "$COMPOSE/compose.yml"
|
||||
cp docker/chromium/seccomp.json "$COMPOSE/chromium/seccomp.json"
|
||||
tar -czf "$COMPOSE.tar.gz" -C out "febe-compose-$VERSION"
|
||||
|
||||
ESISTENTI=$(curl -sf -H "Authorization: token $TOKEN" "$API/releases/$ID/assets" | jq -r '.[].name')
|
||||
for f in out/Febe-Setup-*.exe out/Febe-*-portabile.zip "out/febe-unraid-$VERSION.xml" "$COMPOSE.tar.gz"; do
|
||||
n=$(basename "$f")
|
||||
if echo "$ESISTENTI" | grep -qx "$n"; then echo "$n già allegato"; continue; fi
|
||||
curl -sf -X POST -H "Authorization: token $TOKEN" -F "attachment=@$f" "$API/releases/$ID/assets?name=$n" > /dev/null
|
||||
echo "$n allegato"
|
||||
done
|
||||
@@ -0,0 +1,56 @@
|
||||
# Verifica a ogni push e a ogni pull request: compilazione con gli avvisi come errori
|
||||
# (compreso Febe.Desktop, che si compila anche da Linux) e tutte le prove.
|
||||
# Le prove che richiedono Chromium e Xvfb si saltano da sole se il runner non li ha.
|
||||
#
|
||||
# Runner: act_runner con l'etichetta ubuntu-latest.
|
||||
name: verifica
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [main, febe-v1]
|
||||
pull_request:
|
||||
|
||||
jobs:
|
||||
prove:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- uses: actions/setup-dotnet@v4
|
||||
with:
|
||||
dotnet-version: "10.0.x"
|
||||
|
||||
- name: Compilazione (avvisi = errori)
|
||||
run: dotnet build Febe.slnx -c Release -nologo -warnaserror
|
||||
|
||||
- name: Prove
|
||||
run: >-
|
||||
dotnet test tests/Febe.Tests -c Release --no-build --nologo
|
||||
--logger "trx;LogFileName=prove.trx" --results-directory out/prove
|
||||
|
||||
- name: Risultati
|
||||
if: always()
|
||||
uses: actions/upload-artifact@v3
|
||||
with:
|
||||
name: risultati-prove
|
||||
path: out/prove/*.trx
|
||||
if-no-files-found: ignore
|
||||
|
||||
immagine:
|
||||
runs-on: ubuntu-latest
|
||||
needs: prove
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Costruzione dell'immagine Docker (senza pubblicarla; le prove girano anche dentro la build)
|
||||
run: |
|
||||
docker version
|
||||
docker build -f docker/Dockerfile \
|
||||
--build-arg VERSION=ci \
|
||||
--build-arg GIT_COMMIT="${GITHUB_SHA::12}" \
|
||||
-t febe:ci .
|
||||
|
||||
- name: L'immagine parte e mostra la pagina di errore senza password
|
||||
run: |
|
||||
docker run --rm --entrypoint /usr/bin/chromium febe:ci --version
|
||||
docker run --rm --entrypoint sh febe:ci -c 'locale -a | grep -i it_IT && ls /etc/chromium/policies/managed/'
|
||||
@@ -414,3 +414,18 @@ FodyWeavers.xsd
|
||||
# Built Visual Studio Code Extensions
|
||||
*.vsix
|
||||
|
||||
|
||||
# ---> Febe
|
||||
# Uscite locali di build, pubblicazione e prove
|
||||
out/
|
||||
artifacts/
|
||||
*.trx
|
||||
# Dati e librerie locali usati durante lo sviluppo: mai nel repository
|
||||
.febe/
|
||||
febe-dati/
|
||||
febe-libreria/
|
||||
*.sqlite
|
||||
*.sqlite-wal
|
||||
*.sqlite-shm
|
||||
# Campioni grezzi della sonda (§14.5): stanno fuori dal repository
|
||||
campioni-grezzi/
|
||||
@@ -0,0 +1,28 @@
|
||||
# Novità
|
||||
|
||||
## 0.1.0
|
||||
|
||||
Prima versione, **anteprima**: il programma è completo e provato contro il sito di prova locale, ma non ha mai
|
||||
contattato Instagram. Finché la sonda di M0 non avrà raccolto i campioni (guida, pagina «Ipotesi da verificare»), le
|
||||
ricette si rifiutano di girare su Instagram: la mappa dei bersagli e il vocabolario dei lettori di Instagram sono
|
||||
ancora da compilare, e la specifica vieta di inventarli.
|
||||
|
||||
Che cosa c'è:
|
||||
|
||||
- **Motore** con ritmo umano: fascia oraria che si sposta ogni giorno, sessioni brevi e pause log-normali, tetti
|
||||
orari e giornalieri per categoria tenuti su disco, avvio graduale, Governatore unico punto di passaggio verso il
|
||||
sito, interruttore che si ferma al primo segnale (rallentamento 1/6/24 ore, verifica e disconnessione con ripresa
|
||||
solo a mano). Simulazione di 30 giorni per i tre profili di prudenza senza superamenti dei tetti.
|
||||
- **Raccolta** con un browser vero pilotato dal protocollo DevTools e un elenco chiuso di comandi: giro dei seguiti,
|
||||
storie (salvate solo se mostrate), controllo del profilo, storico, raccolte in evidenza, taggati, reel, post
|
||||
singolo, elenco dei seguiti; lettori per forma; scaricamento dal browser con scrittura sicura.
|
||||
- **Libreria** su file normali con nomi configurabili e `_febe.jsonl` per account, database SQLite con copie
|
||||
giornaliere e ricostruzione dalla libreria, miniature e impronte visive per i doppioni.
|
||||
- **Importazione** in quattro passi con revisione dei doppioni e copia verificata.
|
||||
- **Interfaccia** web in italiano, tema chiaro e scuro, finestra stretta e telefono, modalità dimostrativa (`--demo`).
|
||||
- **Avvisi** nell'interfaccia, notifiche di Windows e Telegram facoltativo.
|
||||
- **Docker** (Debian, Chromium su Xvfb, vista remota con password, modello Unraid) e **Windows** (WPF con WebView2,
|
||||
area di notifica, installatore per utente senza permessi di amministratore).
|
||||
|
||||
Da provare dal vivo: le ipotesi H1–H11 su Instagram, S1–S3 su Windows, S3–S6 nel contenitore su Unraid
|
||||
(`docs/prove-dal-vivo.md`).
|
||||
@@ -0,0 +1,43 @@
|
||||
# Febe
|
||||
|
||||
Archivio personale di foto, video e storie da Instagram, in due vesti: Docker e Windows.
|
||||
La specifica è docs/SPECIFICA.md. Non rileggerla tutta ogni volta: apri la sezione che riguarda il lavoro in corso.
|
||||
All'inizio di ogni sessione leggi docs/stato.md.
|
||||
|
||||
## Comandi
|
||||
- Compilare: `dotnet build -warnaserror`
|
||||
- Prove: `dotnet test` (una sola: `dotnet test --filter "FullyQualifiedName~Nome"`)
|
||||
- Avviare in modalità dimostrativa: `dotnet run --project src/Febe.Server -- --demo`
|
||||
- Simulare il motore: `dotnet run --project src/Febe.Server -- --simula 30g --profilo prudente`
|
||||
- Immagine Docker: `docker build -f docker/Dockerfile -t febe .`
|
||||
|
||||
## Regole che non si discutono (specifica §2)
|
||||
1. IMPORTANTE: non contattare mai Instagram da prove, script o verifiche tue. Si usa solo tools/Febe.SitoDiProva. Le prove dal vivo le lancia Alberto.
|
||||
2. Non aprire i campioni grezzi della sonda: stanno fuori dal repository e contengono dati di altre persone. Si lavora sulle copie ripulite di tests/campioni.
|
||||
3. Verso Instagram parla solo il browser di Febe. Nessun HttpClient verso domini di Instagram o Meta, tranne il CDN alle condizioni di §6.5.
|
||||
4. Il browser si usa così com'è: nessuna modifica di user agent, impronta, intestazioni; niente headless, stealth, proxy, più account. Comandi CDP solo dall'elenco di §6.1.
|
||||
5. CAPTCHA, verifiche e codici non si risolvono mai in automatico: Febe si ferma e avvisa.
|
||||
6. Sola lettura (niente mi piace, segui, commenti, messaggi) e solo ciò che l'account di Alberto vede già.
|
||||
7. Un account, un motore. I cookie non si copiano da una macchina all'altra.
|
||||
8. Ogni azione del motore verso il sito passa da IGovernor. Al primo segnale di §7.6 ci si ferma.
|
||||
9. I lettori si scrivono solo su campioni reali ripuliti. Il formato delle risposte non si inventa.
|
||||
10. Mai password, cookie, tasti o corpi di risposta nei log. Il client CDP registra solo nomi di comandi.
|
||||
11. La libreria non cancella e non sostituisce file da sola.
|
||||
12. Dipendenze a elenco chiuso (§3): prima di aggiungerne una, chiedi.
|
||||
|
||||
## Convenzioni
|
||||
- Codice e commenti in inglese; interfaccia, documenti e messaggi in italiano (glossario: appendice D).
|
||||
- Nel motore mai DateTime.Now, Task.Delay o Random diretti: si usano IClock e IRandomSource.
|
||||
- Interfaccia senza framework né build: file in src/Febe.Web/wwwroot. Token e classi di base: appendice B.
|
||||
- Una schermata è finita quando è stata confrontata con il suo mockup (§10.7).
|
||||
- Scelte tecniche nuove: una riga in docs/decisioni.md con data e motivo.
|
||||
- A fine lavoro aggiorna docs/stato.md e mostra comandi e risultati dei controlli. Se qualcosa non è verificato, dillo.
|
||||
|
||||
## Quando compatti la conversazione
|
||||
Conserva: tappa in corso, file modificati, controlli ancora da eseguire, domande aperte per Alberto.
|
||||
|
||||
## Repository e rilascio
|
||||
- Repository: Gitea di casa, https://gitea.encke-hake.ts.net/Alby96/Febe (ramo main). Non è GitHub: niente strumenti GitHub.
|
||||
- CI in `.gitea/workflows/`: `verifica.yml` a ogni push e pull request, `rilascio.yml` a ogni tag `vX.Y.Z` (immagine Docker sul registro di Gitea, installatore Windows e release).
|
||||
- La versione sta solo in `Directory.Build.props` (`<Version>`); il tag deve coincidere.
|
||||
- Guida per l'uso: wiki del repository (sorgenti in `docs/guida/`).
|
||||
@@ -0,0 +1,20 @@
|
||||
<Project>
|
||||
<!-- Proprietà comuni a tutti i progetti di Febe. La versione si cambia solo qui. -->
|
||||
<PropertyGroup>
|
||||
<Version>0.1.0</Version>
|
||||
<TargetFramework>net10.0</TargetFramework>
|
||||
<LangVersion>14</LangVersion>
|
||||
<Nullable>enable</Nullable>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
|
||||
<AnalysisLevel>latest</AnalysisLevel>
|
||||
<Deterministic>true</Deterministic>
|
||||
<Authors>Alberto Balbo</Authors>
|
||||
<Company>Alberto Balbo</Company>
|
||||
<Product>Febe</Product>
|
||||
<Copyright>Alberto Balbo</Copyright>
|
||||
<NeutralLanguage>it-IT</NeutralLanguage>
|
||||
<SatelliteResourceLanguages>it</SatelliteResourceLanguages>
|
||||
<ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
|
||||
</PropertyGroup>
|
||||
</Project>
|
||||
@@ -0,0 +1,10 @@
|
||||
<Project>
|
||||
<!-- Dipendenze a elenco chiuso (specifica §3). Per aggiungerne una si chiede prima. -->
|
||||
<ItemGroup>
|
||||
<PackageVersion Include="Microsoft.Data.Sqlite" Version="10.0.12" />
|
||||
<PackageVersion Include="SkiaSharp" Version="4.153.1" />
|
||||
<PackageVersion Include="SkiaSharp.NativeAssets.Linux.NoDependencies" Version="4.153.1" />
|
||||
<PackageVersion Include="Microsoft.Web.WebView2" Version="1.0.4258.31" />
|
||||
<PackageVersion Include="MSTest" Version="4.5.1" />
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
@@ -0,0 +1,19 @@
|
||||
<Solution>
|
||||
<Folder Name="/src/">
|
||||
<Project Path="src/Febe.Core/Febe.Core.csproj" />
|
||||
<Project Path="src/Febe.Data/Febe.Data.csproj" />
|
||||
<Project Path="src/Febe.Browser/Febe.Browser.csproj" />
|
||||
<Project Path="src/Febe.Web/Febe.Web.csproj" />
|
||||
<Project Path="src/Febe.App/Febe.App.csproj" />
|
||||
<Project Path="src/Febe.Server/Febe.Server.csproj" />
|
||||
<Project Path="src/Febe.Desktop.Core/Febe.Desktop.Core.csproj" />
|
||||
<Project Path="src/Febe.Desktop/Febe.Desktop.csproj" />
|
||||
</Folder>
|
||||
<Folder Name="/tests/">
|
||||
<Project Path="tests/Febe.Tests/Febe.Tests.csproj" />
|
||||
</Folder>
|
||||
<Folder Name="/tools/">
|
||||
<Project Path="tools/Febe.Sonda/Febe.Sonda.csproj" />
|
||||
<Project Path="tools/Febe.SitoDiProva/Febe.SitoDiProva.csproj" />
|
||||
</Folder>
|
||||
</Solution>
|
||||
@@ -1,3 +1,30 @@
|
||||
# Febe
|
||||
|
||||
Instagram Downloader
|
||||
Archivio personale di foto, video e storie da Instagram, in due vesti con lo stesso motore e la stessa interfaccia: un contenitore Docker per il server di casa (Unraid) e un'applicazione desktop per Windows.
|
||||
|
||||
Febe non costruisce richieste verso Instagram: usa un browser vero, in cui Alberto ha fatto l'accesso a mano, lo fa navigare con il ritmo di una persona e salva ciò che la pagina stessa riceve. L'account viene prima della completezza e della velocità.
|
||||
|
||||
> Scaricare con un programma è contro le condizioni d'uso di Instagram. Febe va piano per ridurre il rischio per l'account, ma non può azzerarlo.
|
||||
|
||||
**Stato: versione 0.1.0, anteprima.** Il programma è completo e provato contro un sito di prova locale; prima di usarlo su Instagram serve la sonda di M0 (vedi [docs/stato.md](docs/stato.md)).
|
||||
|
||||
## Documenti
|
||||
|
||||
- Guida per l'uso: wiki del repository (sorgenti in [docs/guida](docs/guida/Home.md))
|
||||
- Specifica: [docs/SPECIFICA.md](docs/SPECIFICA.md)
|
||||
- Stato dei lavori: [docs/stato.md](docs/stato.md) · Decisioni tecniche: [docs/decisioni.md](docs/decisioni.md) · Novità: [CHANGELOG.md](CHANGELOG.md)
|
||||
- Docker e Unraid: [docs/docker.md](docs/docker.md) · Windows: [docs/windows.md](docs/windows.md)
|
||||
- Ipotesi e prove dal vivo: [docs/sonda/esito.md](docs/sonda/esito.md), [docs/prove-dal-vivo.md](docs/prove-dal-vivo.md)
|
||||
|
||||
## Sviluppo
|
||||
|
||||
```text
|
||||
dotnet build Febe.slnx -warnaserror
|
||||
dotnet test tests/Febe.Tests
|
||||
dotnet run --project src/Febe.Server -- --demo # interfaccia con dati finti su 127.0.0.1:8480
|
||||
dotnet run --project src/Febe.Server -- --simula 30g --profilo prudente
|
||||
docker build -f docker/Dockerfile -t febe .
|
||||
bash installer/costruisci.sh # Febe.exe, installatore e zip per Windows
|
||||
```
|
||||
|
||||
Rilascio: un tag `vX.Y.Z` uguale a `<Version>` di `Directory.Build.props` avvia `.gitea/workflows/rilascio.yml`.
|
||||
@@ -0,0 +1,128 @@
|
||||
# syntax=docker/dockerfile:1.7
|
||||
#
|
||||
# Febe — immagine per il server di casa (specifica §11).
|
||||
#
|
||||
# docker build -f docker/Dockerfile \
|
||||
# --build-arg VERSION=0.1.0 --build-arg GIT_COMMIT=$(git rev-parse --short=12 HEAD) \
|
||||
# -t 192.168.30.23:3000/alby96/febe:0.1.0 .
|
||||
#
|
||||
# Stadi:
|
||||
# build restore e compilazione di tutta la soluzione con gli avvisi come errori;
|
||||
# test tutte le prove: un'immagine con prove rosse non esiste. Qui non ci sono Chromium né Xvfb, quindi le prove
|
||||
# con il browser vero risultano «inconcludenti» (saltate) e girano solo dove ci sono (CI, sviluppo);
|
||||
# publish Febe.Server autosufficiente per linux-x64: nell'immagine non serve il runtime .NET;
|
||||
# runtime Debian stabile ridotta (trixie-slim) con Chromium della distribuzione, Xvfb, ffmpeg, ICU, caratteri
|
||||
# (anche emoji), certificati, fusi orari, lingua italiana; tini come processo 1; setpriv per PUID/PGID.
|
||||
#
|
||||
# Vedi docs/docker.md per volumi, variabili, porte, sandbox, salute e aggiornamento.
|
||||
|
||||
ARG DOTNET_VERSION=10.0
|
||||
|
||||
# ─────────────────────────────────────────────────────────────── build
|
||||
FROM mcr.microsoft.com/dotnet/sdk:${DOTNET_VERSION} AS build
|
||||
WORKDIR /src
|
||||
ENV DOTNET_NOLOGO=1 DOTNET_CLI_TELEMETRY_OPTOUT=1
|
||||
|
||||
# Prima i file di progetto: il restore resta in cache finché non cambiano.
|
||||
COPY Directory.Build.props Directory.Packages.props Febe.slnx ./
|
||||
COPY src/Febe.Core/Febe.Core.csproj src/Febe.Core/
|
||||
COPY src/Febe.Data/Febe.Data.csproj src/Febe.Data/
|
||||
COPY src/Febe.Browser/Febe.Browser.csproj src/Febe.Browser/
|
||||
COPY src/Febe.Web/Febe.Web.csproj src/Febe.Web/
|
||||
COPY src/Febe.App/Febe.App.csproj src/Febe.App/
|
||||
COPY src/Febe.Server/Febe.Server.csproj src/Febe.Server/
|
||||
COPY src/Febe.Desktop.Core/Febe.Desktop.Core.csproj src/Febe.Desktop.Core/
|
||||
COPY src/Febe.Desktop/Febe.Desktop.csproj src/Febe.Desktop/
|
||||
COPY tests/Febe.Tests/Febe.Tests.csproj tests/Febe.Tests/
|
||||
COPY tools/Febe.Sonda/Febe.Sonda.csproj tools/Febe.Sonda/
|
||||
COPY tools/Febe.SitoDiProva/Febe.SitoDiProva.csproj tools/Febe.SitoDiProva/
|
||||
RUN dotnet restore Febe.slnx \
|
||||
&& dotnet restore src/Febe.Server/Febe.Server.csproj -r linux-x64
|
||||
|
||||
COPY . .
|
||||
ARG GIT_COMMIT=n/d
|
||||
RUN dotnet build Febe.slnx -c Release --no-restore -nologo -warnaserror -p:SourceRevisionId=${GIT_COMMIT}
|
||||
|
||||
# ─────────────────────────────────────────────────────────────── test
|
||||
FROM build AS test
|
||||
RUN dotnet test tests/Febe.Tests -c Release --no-build --nologo \
|
||||
&& touch /tmp/prove-verdi
|
||||
|
||||
# ─────────────────────────────────────────────────────────────── publish
|
||||
FROM build AS publish
|
||||
ARG GIT_COMMIT=n/d
|
||||
# La pubblicazione parte solo con le prove verdi.
|
||||
COPY --from=test /tmp/prove-verdi /tmp/prove-verdi
|
||||
RUN dotnet publish src/Febe.Server/Febe.Server.csproj -c Release -r linux-x64 --self-contained true \
|
||||
-nologo -p:SourceRevisionId=${GIT_COMMIT} -p:DebugType=none -o /app \
|
||||
&& test -x /app/febe
|
||||
|
||||
# ─────────────────────────────────────────────────────────────── runtime
|
||||
FROM debian:trixie-slim AS runtime
|
||||
ARG VERSION=dev
|
||||
ARG GIT_COMMIT=n/d
|
||||
|
||||
LABEL org.opencontainers.image.title="Febe" \
|
||||
org.opencontainers.image.description="Archivio personale di foto, video e storie da Instagram: un browser vero, a ritmo umano, e una libreria sul server di casa." \
|
||||
org.opencontainers.image.version="${VERSION}" \
|
||||
org.opencontainers.image.revision="${GIT_COMMIT}" \
|
||||
org.opencontainers.image.authors="Alberto Balbo" \
|
||||
org.opencontainers.image.source="https://gitea.encke-hake.ts.net/Alby96/Febe" \
|
||||
org.opencontainers.image.url="https://gitea.encke-hake.ts.net/Alby96/Febe"
|
||||
|
||||
# Chromium della distribuzione con le sue lingue, il display virtuale, ffmpeg (miniature dei video importati), ICU e
|
||||
# le librerie del runtime .NET autosufficiente, caratteri di sistema con le emoji, certificati, fusi orari, la lingua
|
||||
# italiana generata, tini come processo 1 (raccoglie i processi di Chromium), setpriv (util-linux) per PUID/PGID.
|
||||
ENV DEBIAN_FRONTEND=noninteractive
|
||||
RUN apt-get update \
|
||||
&& apt-get install -y --no-install-recommends \
|
||||
chromium chromium-l10n \
|
||||
xvfb \
|
||||
ffmpeg \
|
||||
libicu76 libssl3t64 libstdc++6 libgcc-s1 zlib1g \
|
||||
fonts-noto-color-emoji fonts-liberation fonts-dejavu-core \
|
||||
ca-certificates tzdata locales \
|
||||
tini util-linux passwd \
|
||||
&& sed -i 's/^# *\(it_IT.UTF-8 UTF-8\)/\1/' /etc/locale.gen \
|
||||
&& locale-gen \
|
||||
&& rm -rf /var/lib/apt/lists/*
|
||||
|
||||
# Criteri di Chromium: niente salvataggio delle password né compilazione automatica (nel profilo resta solo la sessione).
|
||||
COPY docker/chromium/febe.json /etc/chromium/policies/managed/febe.json
|
||||
# Il profilo seccomp dedicato (quello di Docker più clone/unshare per la sandbox di Chromium), per leggerlo
|
||||
# dall'immagine: Docker lo usa dal server, fuori dal volume dei dati (docs/docker.md, «Sandbox»), e l'avvio non lo
|
||||
# copia in /dati, dove l'utente del contenitore potrebbe cambiarlo.
|
||||
COPY docker/chromium/seccomp.json /usr/share/febe/seccomp.json
|
||||
|
||||
COPY --from=publish /app /app
|
||||
COPY docker/entrypoint.sh /usr/local/bin/febe-avvio
|
||||
RUN sed -i 's/\r$//' /usr/local/bin/febe-avvio \
|
||||
&& chmod 0755 /usr/local/bin/febe-avvio \
|
||||
&& mkdir -p /dati /libreria /importa
|
||||
|
||||
ENV LANG=it_IT.UTF-8 \
|
||||
TZ=Europe/Rome \
|
||||
PUID=99 \
|
||||
PGID=100 \
|
||||
FEBE_PORTA=8480 \
|
||||
FEBE_CHROMIUM=/usr/bin/chromium \
|
||||
DOTNET_NOLOGO=1 \
|
||||
DOTNET_gcServer=0
|
||||
|
||||
WORKDIR /app
|
||||
VOLUME ["/dati", "/libreria", "/importa"]
|
||||
|
||||
# Solo la porta dell'interfaccia. La porta di debug del browser ascolta su 127.0.0.1 dentro il contenitore e non si
|
||||
# pubblica mai.
|
||||
EXPOSE 8480
|
||||
|
||||
# /salute risponde «ok» o «problema» (password mancante, /dati non scrivibile o in rete). Nell'immagine non c'è curl:
|
||||
# la sonda è il programma stesso.
|
||||
HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
|
||||
CMD ["/app/febe", "--controllo-salute"]
|
||||
|
||||
# tini è il processo 1: inoltra SIGTERM a Febe (che ferma il motore, poi Chromium con SIGINT, poi Xvfb) e raccoglie i
|
||||
# processi figli di Chromium rimasti orfani.
|
||||
STOPSIGNAL SIGTERM
|
||||
ENTRYPOINT ["/usr/bin/tini", "--", "/usr/local/bin/febe-avvio"]
|
||||
CMD ["/app/febe"]
|
||||
@@ -0,0 +1,25 @@
|
||||
# File di Chromium per l'immagine Docker
|
||||
|
||||
| File | Dove finisce | A che cosa serve |
|
||||
|---|---|---|
|
||||
| `febe.json` | `/etc/chromium/policies/managed/febe.json` | Criteri del browser: niente salvataggio delle password (`PasswordManagerEnabled`), niente controllo delle password trapelate (`PasswordLeakDetectionEnabled`), niente compilazione automatica di indirizzi e carte (`AutofillAddressEnabled`, `AutofillCreditCardEnabled`). Nel profilo resta solo la sessione (specifica §6.1, §11) |
|
||||
| `seccomp.json` | `/usr/share/febe/seccomp.json` (solo da leggere); sul server va tenuto **fuori** dal volume `/dati` | Profilo seccomp dedicato da indicare con `--security-opt seccomp=…` (vedi `docs/docker.md`, «Sandbox») |
|
||||
|
||||
`seccomp.json` è il profilo predefinito di Docker (`moby/profiles`, ramo `main`, `seccomp/default.json`, licenza
|
||||
Apache 2.0) con **una sola regola in più**, in fondo all'elenco: `clone` e `unshare` ammessi anche senza
|
||||
`CAP_SYS_ADMIN`. Servono alla sandbox di Chromium per creare i suoi spazi dei nomi utente, PID e rete. Tutto il resto
|
||||
del filtro di Docker resta com'è.
|
||||
|
||||
Prova del 13 ottobre 2026, in un contenitore come utente 1000 (Docker 29.8, profilo `builtin`, nucleo 6.18). Il
|
||||
Chromium provato è quello dell'ambiente di sviluppo (build di Playwright, librerie dell'host montate in sola lettura),
|
||||
non quello di Debian, perché da qui i pacchetti Debian non si scaricano: il meccanismo della sandbox è lo stesso, ma
|
||||
la prova con l'immagine vera va rifatta sul server (`chrome://sandbox` dalla vista remota).
|
||||
|
||||
| Impostazione | Esito |
|
||||
|---|---|
|
||||
| profilo predefinito di Docker | Chromium non parte: `No usable sandbox!` |
|
||||
| `seccomp.json` di questa cartella | `chrome://sandbox`: «You are adequately sandboxed» (spazi dei nomi, PID, rete, Seccomp-BPF sì); `navigator.webdriver` falso, `it-IT`, `Europe/Rome` |
|
||||
| `seccomp=unconfined` | come sopra, ma senza nessun filtro di Docker |
|
||||
|
||||
Per aggiornarlo: prendere il `default.json` della versione di Docker in uso e riaggiungere la regola
|
||||
`{"names": ["clone", "unshare"], "action": "SCMP_ACT_ALLOW"}`.
|
||||
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"PasswordManagerEnabled": false,
|
||||
"PasswordLeakDetectionEnabled": false,
|
||||
"AutofillAddressEnabled": false,
|
||||
"AutofillCreditCardEnabled": false
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
# Febe con Docker Compose: esempio (specifica §11, docs/docker.md).
|
||||
#
|
||||
# FEBE_PASSWORD='una frase lunga' docker compose -f docker/compose.yml up -d
|
||||
# → http://<server>:8480/ (Impostazioni ▸ Collegamento ▸ «Accedi a Instagram» dalla vista remota)
|
||||
#
|
||||
# Fuori dal repository usa l'archivio febe-compose-X.Y.Z.tar.gz della release: questo file con accanto
|
||||
# chromium/seccomp.json, il profilo che «security_opt» indica con un percorso relativo.
|
||||
# L'immagine sta sul registro di Gitea in HTTP (192.168.30.23:3000): il Docker del server deve averlo fra gli
|
||||
# «insecure-registries», come per le altre immagini di casa.
|
||||
#
|
||||
# Per costruire l'immagine in locale invece di scaricarla, togli il commento a «build».
|
||||
# Su Unraid usa invece il modello docker/unraid/febe.xml.
|
||||
#
|
||||
# Mai esporre la porta su Internet: solo rete di casa, oppure una VPN o un proxy con HTTPS davanti.
|
||||
|
||||
services:
|
||||
febe:
|
||||
image: 192.168.30.23:3000/alby96/febe:latest
|
||||
# build:
|
||||
# context: ..
|
||||
# dockerfile: docker/Dockerfile
|
||||
# args:
|
||||
# VERSION: ${VERSION:-dev}
|
||||
# GIT_COMMIT: ${GIT_COMMIT:-n/d}
|
||||
container_name: febe
|
||||
# tini è già nell'immagine come processo 1: «init: true» non serve.
|
||||
restart: unless-stopped
|
||||
# Febe ferma il motore, poi Chromium con SIGINT (la sessione resta nel profilo), poi Xvfb.
|
||||
stop_grace_period: 30s
|
||||
# La sandbox di Chromium crea spazi dei nomi utente, che il profilo seccomp predefinito di Docker vieta (provato:
|
||||
# «No usable sandbox»). Questo profilo è quello di Docker più clone/unshare: la sandbox del browser resta attiva
|
||||
# e il resto del filtro di Docker pure. Il file sta accanto a questo, fuori da /dati: Docker lo legge sul server,
|
||||
# e l'utente del contenitore non lo può cambiare. Vedi docs/docker.md, «Sandbox».
|
||||
security_opt:
|
||||
- seccomp=./chromium/seccomp.json
|
||||
ports:
|
||||
# Solo la porta dell'interfaccia. La porta di debug del browser resta dentro il contenitore, su 127.0.0.1.
|
||||
- "8480:8480"
|
||||
volumes:
|
||||
# Disco locale del server: database, profilo del browser con la sessione di Instagram, miniature, copie, registro.
|
||||
- ${FEBE_DATI:-/srv/febe/dati}:/dati
|
||||
# Foto e video: può stare anche su una condivisione.
|
||||
- ${FEBE_LIBRERIA:-/srv/febe/libreria}:/libreria
|
||||
# Cartelle da importare, sempre in sola lettura.
|
||||
- ${FEBE_IMPORTA:-/srv/febe/importa}:/importa:ro
|
||||
environment:
|
||||
FEBE_PASSWORD: ${FEBE_PASSWORD:?Imposta FEBE_PASSWORD, la password dell interfaccia}
|
||||
TZ: Europe/Rome
|
||||
LANG: it_IT.UTF-8
|
||||
PUID: "1000"
|
||||
PGID: "1000"
|
||||
# Facoltative:
|
||||
# FEBE_HOST: "tower.local,192.168.1.10" # nomi con cui raggiungi l'interfaccia (gli altri sono rifiutati)
|
||||
# FEBE_PROXY_FIDATO: "1" # dietro un proxy con HTTPS che passa X-Forwarded-Host e -Proto
|
||||
# FEBE_SENZA_SANDBOX: "1" # solo se Chromium non parte: vedi docs/docker.md, «Sandbox»
|
||||
# Chromium usa /tmp invece della memoria condivisa (--disable-dev-shm-usage): shm_size non serve.
|
||||
@@ -0,0 +1,66 @@
|
||||
#!/bin/sh
|
||||
# Febe: avvio del contenitore (specifica §11).
|
||||
#
|
||||
# Fa solo tre cose e poi cede il posto al server:
|
||||
# 1. crea, se mancano, il gruppo PGID e l'utente PUID (su Unraid 99 e 100, «nobody:users»);
|
||||
# 2. rende /dati di quell'utente (la prima volta, o se PUID/PGID sono cambiati) e gli fa preparare /dati/home;
|
||||
# 3. exec del server con setpriv, come quell'utente: il server avvia e sorveglia da sé Xvfb e Chromium.
|
||||
# Nessun ciclo di sorveglianza qui: è il lavoro di Febe.Server (niente script di shell che facciano da supervisore).
|
||||
# /libreria non si cambia mai ricorsivamente (sono le foto di Alberto); /importa è in sola lettura e non si tocca.
|
||||
# Se /dati non si può sistemare (disco di rete, permessi) si parte lo stesso: è Febe a spiegare il problema nella sua
|
||||
# pagina, invece di un contenitore che si riavvia senza dire perché.
|
||||
set -eu
|
||||
|
||||
PUID="${PUID:-99}"
|
||||
PGID="${PGID:-100}"
|
||||
|
||||
# Già avviato come utente normale (docker run --user ...): niente da cambiare.
|
||||
if [ "$(id -u)" != "0" ]; then
|
||||
exec "$@"
|
||||
fi
|
||||
|
||||
if [ "${PUID}" = "0" ]; then
|
||||
echo "Febe: PUID=0 non è ammesso. Il browser di Febe non gira come root: indica l'utente dei file (su Unraid PUID=99, PGID=100)." >&2
|
||||
exit 64
|
||||
fi
|
||||
|
||||
if ! getent group "${PGID}" >/dev/null 2>&1; then
|
||||
groupadd -g "${PGID}" febe
|
||||
fi
|
||||
|
||||
if ! getent passwd "${PUID}" >/dev/null 2>&1; then
|
||||
useradd -o -u "${PUID}" -g "${PGID}" -M -d /dati/home -s /usr/sbin/nologin febe
|
||||
fi
|
||||
|
||||
# /dati è dell'utente PUID, che dentro può mettere di tutto, anche collegamenti simbolici verso file del contenitore:
|
||||
# da root qui dentro non si scrive niente. L'unica cosa fatta da root è il cambio di proprietario, ricorsivo e senza
|
||||
# seguire i collegamenti (-R senza -H/-L: cambia il collegamento, mai ciò a cui punta). Il resto lo fa l'utente stesso.
|
||||
if mkdir -p /dati 2>/dev/null; then
|
||||
da_assegnare=""
|
||||
[ "$(stat -c '%u:%g' /dati)" = "${PUID}:${PGID}" ] || da_assegnare=1
|
||||
# Una /dati/home di un altro proprietario (un avvio precedente come root): conta solo una cartella vera.
|
||||
if [ -d /dati/home ] && [ ! -L /dati/home ] && [ "$(stat -c '%u:%g' /dati/home)" != "${PUID}:${PGID}" ]; then
|
||||
da_assegnare=1
|
||||
fi
|
||||
if [ -n "${da_assegnare}" ]; then
|
||||
echo "Febe: assegno /dati a ${PUID}:${PGID}."
|
||||
chown -R "${PUID}:${PGID}" /dati 2>/dev/null || echo "Febe: non riesco ad assegnare /dati a ${PUID}:${PGID}." >&2
|
||||
fi
|
||||
chmod 0750 /dati 2>/dev/null || true
|
||||
# La HOME di Chromium la crea e la chiude l'utente, con i suoi permessi.
|
||||
setpriv --reuid="${PUID}" --regid="${PGID}" --init-groups sh -c 'mkdir -p /dati/home && chmod 0700 /dati/home' 2>/dev/null || true
|
||||
# Il profilo seccomp non sta più in /dati: Docker lo legge sul server alla creazione del contenitore, e in /dati
|
||||
# l'utente del contenitore potrebbe allentarlo. Si tiene fuori dal volume dei dati (docs/docker.md, «Sandbox»).
|
||||
if [ -e /dati/seccomp.json ] || [ -L /dati/seccomp.json ]; then
|
||||
echo "Febe: /dati/seccomp.json non si aggiorna più. Se --security-opt seccomp= indica quel file, sposta il profilo fuori dalla cartella dei dati (su Unraid /mnt/user/appdata/febe-seccomp.json): vedi docs/docker.md, «Sandbox»." >&2
|
||||
fi
|
||||
fi
|
||||
|
||||
# Una cartella della libreria appena creata da Docker appartiene a root: solo quella, senza ricorsione.
|
||||
if [ -d /libreria ] && [ "$(stat -c '%u' /libreria)" = "0" ]; then
|
||||
chown "${PUID}:${PGID}" /libreria 2>/dev/null || true
|
||||
fi
|
||||
|
||||
export HOME=/dati/home
|
||||
echo "Febe: avvio come utente ${PUID}, gruppo ${PGID}, fuso ${TZ:-Europe/Rome}, lingua ${LANG:-it_IT.UTF-8}."
|
||||
exec setpriv --reuid="${PUID}" --regid="${PGID}" --init-groups "$@"
|
||||
|
After Width: | Height: | Size: 9.8 KiB |
@@ -0,0 +1,35 @@
|
||||
<?xml version="1.0"?>
|
||||
<Container version="2">
|
||||
<Name>Febe</Name>
|
||||
<Repository>192.168.30.23:3000/alby96/febe:latest</Repository>
|
||||
<Registry>http://192.168.30.23:3000/Alby96/-/packages/container/febe</Registry>
|
||||
<Network>bridge</Network>
|
||||
<MyIP/>
|
||||
<Shell>bash</Shell>
|
||||
<Privileged>false</Privileged>
|
||||
<Support>http://192.168.30.23:3000/Alby96/Febe/issues</Support>
|
||||
<Project>http://192.168.30.23:3000/Alby96/Febe</Project>
|
||||
<Overview>Febe: archivio personale di foto, video e storie da Instagram. Un browser vero (Chromium su un display virtuale) visita i profili a ritmo umano, con tetti giornalieri, e salva cio' che la pagina riceve in una libreria di file sul server. Si accede una volta sola, a mano, dalla vista remota della pagina Impostazioni, Collegamento: password e codici passano dal server senza essere registrati, quindi l'interfaccia non va mai esposta su Internet senza una VPN o un proxy con HTTPS. La cartella /dati contiene la sessione di Instagram: chi ha /dati, o una sua copia, ha la sessione. Non usare il contenitore e Febe per Windows sullo stesso account. Unica variabile obbligatoria: la password dell'interfaccia. Guida: docs/docker.md nel repository.</Overview>
|
||||
<Category>Backup: MediaApp:Photos</Category>
|
||||
<WebUI>http://[IP]:[PORT:8480]/</WebUI>
|
||||
<TemplateURL>http://192.168.30.23:3000/Alby96/Febe/raw/branch/main/docker/unraid/febe.xml</TemplateURL>
|
||||
<Icon>http://192.168.30.23:3000/Alby96/Febe/raw/branch/main/docker/unraid/febe.png</Icon>
|
||||
<ExtraParams>--restart=unless-stopped --stop-timeout 30 --security-opt seccomp=/mnt/user/appdata/febe-seccomp.json</ExtraParams>
|
||||
<PostArgs/>
|
||||
<CPUset/>
|
||||
<DateInstalled/>
|
||||
<DonateText/>
|
||||
<DonateLink/>
|
||||
<Requires>Il registro 192.168.30.23:3000 e' in HTTP: deve stare fra gli insecure-registries del Docker di Unraid, come per le altre immagini di casa. Prima della prima installazione, dal terminale di Unraid, metti il profilo seccomp della sandbox di Chromium (indicato in ExtraParams) FUORI dalla cartella dei dati: docker run --rm --entrypoint cat 192.168.30.23:3000/alby96/febe:latest /usr/share/febe/seccomp.json > /mnt/user/appdata/febe-seccomp.json. Il contenitore non lo tocca: ripeti il comando solo se le note di una versione lo chiedono. Spiegazione in docs/docker.md, «Sandbox».</Requires>
|
||||
|
||||
<Config Name="Porta dell'interfaccia" Target="8480" Default="8480" Mode="tcp" Description="Porta dell'interfaccia web (http://IP:porta/). E' l'unica porta da pubblicare: quella di debug del browser resta dentro il contenitore." Type="Port" Display="always" Required="true" Mask="false">8480</Config>
|
||||
<Config Name="Dati (/dati)" Target="/dati" Default="/mnt/user/appdata/febe" Mode="rw" Description="Database, profilo del browser con la sessione di Instagram, miniature, copie giornaliere del database, registro. Deve stare su un disco locale: la cartella delle applicazioni sul disco di cache. Mai una condivisione di rete." Type="Path" Display="always" Required="true" Mask="false">/mnt/user/appdata/febe</Config>
|
||||
<Config Name="Libreria (/libreria)" Target="/libreria" Default="/mnt/user/Febe" Mode="rw" Description="Dove finiscono foto e video, una cartella per account. Puo' stare anche su una condivisione. Febe non cancella e non sostituisce mai un file da solo." Type="Path" Display="always" Required="true" Mask="false">/mnt/user/Febe</Config>
|
||||
<Config Name="Da importare (/importa)" Target="/importa" Default="/mnt/user/Febe-importa" Mode="ro" Description="Cartelle con foto e video che hai gia', da importare dalla pagina Importa. Sempre in sola lettura: Febe copia, non tocca gli originali." Type="Path" Display="always" Required="false" Mask="false">/mnt/user/Febe-importa</Config>
|
||||
<Config Name="Password dell'interfaccia" Target="FEBE_PASSWORD" Default="" Mode="" Description="Obbligatoria. Senza password Febe mostra solo una pagina che spiega il problema: il motore e il browser non partono. Usa una frase lunga che non usi altrove (non quella di Instagram)." Type="Variable" Display="always" Required="true" Mask="true"></Config>
|
||||
<Config Name="TZ" Target="TZ" Default="Europe/Rome" Mode="" Description="Fuso orario: orari dei nomi dei file, fascia oraria del motore e fuso dichiarato dal browser." Type="Variable" Display="advanced" Required="false" Mask="false">Europe/Rome</Config>
|
||||
<Config Name="PUID" Target="PUID" Default="99" Mode="" Description="Utente dei file (su Unraid 99, nobody). Il browser non gira mai come root." Type="Variable" Display="advanced" Required="false" Mask="false">99</Config>
|
||||
<Config Name="PGID" Target="PGID" Default="100" Mode="" Description="Gruppo dei file (su Unraid 100, users)." Type="Variable" Display="advanced" Required="false" Mask="false">100</Config>
|
||||
<Config Name="FEBE_HOST" Target="FEBE_HOST" Default="" Mode="" Description="Facoltativa: i nomi con cui raggiungi l'interfaccia, separati da virgole (per esempio tower.local,192.168.1.10). Se la imposti, gli altri nomi vengono rifiutati." Type="Variable" Display="advanced" Required="false" Mask="false"></Config>
|
||||
<Config Name="FEBE_SENZA_SANDBOX" Target="FEBE_SENZA_SANDBOX" Default="" Mode="" Description="Lasciala vuota. Mettila a 1 solo se il registro dice che Chromium non parte per la sandbox: e' un compromesso, spiegato in docs/docker.md." Type="Variable" Display="advanced" Required="false" Mask="false"></Config>
|
||||
</Container>
|
||||
@@ -0,0 +1,228 @@
|
||||
# Decisioni
|
||||
|
||||
Ogni scelta tecnica presa strada facendo, con data e motivo (specifica §15).
|
||||
|
||||
| Data | Decisione | Motivo |
|
||||
|---|---|---|
|
||||
| 2026-10-13 | Repository su Gitea di casa (`Alby96/Febe`), CI con Gitea Actions in `.gitea/workflows/` | Risposta alla domanda 1 di §16: il repository esiste già lì; stesse convenzioni di Encelado e Mimante |
|
||||
| 2026-10-13 | Alberto ha chiesto di realizzare tutte le tappe in una volta, con branch, PR, CI, wiki e rilascio | Richiesta esplicita del 13 ottobre. I punti di arresto di M0 e M3 non si possono attendere: le ipotesi H e S che richiedono Instagram o Windows restano **da provare** e sono segnate così in `docs/sonda/esito.md` e `docs/stato.md` |
|
||||
| 2026-10-13 | Inversione delle dipendenze: le interfacce (`IClock`, `IGovernor`, `IBrowserHost`, archivi) stanno in `Febe.Core`; `Febe.Data` e `Febe.Browser` le implementano | `Febe.Core` resta senza riferimenti a piattaforma (§5) e si prova con implementazioni finte |
|
||||
| 2026-10-13 | Soluzione `Febe.slnx`, versioni dei pacchetti centralizzate in `Directory.Packages.props`, versione del programma in `Directory.Build.props` | Formato usato negli altri progetti di Alberto; un solo punto per le versioni |
|
||||
| 2026-10-13 | Pacchetti: Microsoft.Data.Sqlite 10.0.12, SkiaSharp 4.153.1 (+ NativeAssets.Linux.NoDependencies), Microsoft.Web.WebView2 1.0.4258.31, MSTest 4.5.1 | Ultime versioni stabili dell'elenco chiuso di §3 |
|
||||
| 2026-10-13 | `Febe.Web` usa ASP.NET Core (framework condiviso, non un pacchetto) con API minime; l'interfaccia in `wwwroot` è incorporata nell'assembly | Un solo eseguibile anche su Windows; nessuna dipendenza in più |
|
||||
| 2026-10-13 | Domande di §16 senza risposta: si adotta la proposta della terza colonna (Libreria e Dati; storie aperte con interruttore; programma di installazione; Telegram facoltativo; nome Febe; solo italiano; porta 8480) | §16 chiede di proporre quella risposta; si cambia quando Alberto risponde |
|
||||
| 2026-10-13 | Installatore Windows con NSIS, costruito anche da Linux (`makensis`), più uno zip portabile | Domanda 6: proposta «programma di installazione»; NSIS gira sul runner Linux |
|
||||
| 2026-10-13 | Mockup: forniti a piena risoluzione solo 00, 01, 03, 08, 10; gli altri sono ritagli della panoramica in `docs/mockup/miniature/` | Vedi `docs/mockup/LEGGIMI.md` |
|
||||
| 2026-10-13 | `account.id` è una chiave locale; l'identità è `instagram_id` (TEXT, unico, facoltativo) | Gli account creati dall'importazione possono non conoscerlo; `IGovernor` riceve la chiave locale |
|
||||
| 2026-10-13 | Tutti gli identificativi Instagram salvati come TEXT | Regola 10: nessuna ipotesi su formato e lunghezza |
|
||||
| 2026-10-13 | Orari come millisecondi Unix UTC (INTEGER); enumerazioni come nomi inglesi (TEXT) | Indici compatti; database leggibile |
|
||||
| 2026-10-13 | Gli archivi sono proprietà di un unico `FebeDatabase` (`IFebeStorage`) | Evita conflitti di nomi fra interfacce |
|
||||
| 2026-10-13 | Scrittore unico: un thread, un canale, commit di gruppo con un savepoint per scrittura; un'operazione annullata in coda non parte nemmeno se il lotto è già iniziato | §8.3; una scrittura fallita non annulla le altre |
|
||||
| 2026-10-13 | Finestre della libreria con paginazione a chiave su (published_at, id) e indice coprente `ix_entry_library` | 3–6 ms a 200.000 elementi, con o senza statistiche |
|
||||
| 2026-10-13 | Ricerca testuale su una colonna normalizzata (minuscole, senza accenti) con LIKE, senza FTS5 | Circa 0,1 s anche a 200.000 elementi, ricerca per sottostringa |
|
||||
| 2026-10-13 | «Foto»/«Video» = post con almeno una foto/un video; «In evidenza» comprende le storie richiamate da una raccolta; «Tutto» esclude le foto del profilo | Tabella di §4.3 |
|
||||
| 2026-10-13 | Lo schema dei nomi si applica dentro la cartella dell'account; percorsi nel database con `/`; segnaposto sconosciuti = errore | Le cartelle degli account possono stare fuori dalla Libreria (§4.4) |
|
||||
| 2026-10-13 | Percorsi lunghi: si accorcia prima il nome del file (estensione tenuta, `~` + 8 cifre esadecimali), poi le cartelle più lunghe; il limite di 240 vale su ogni sistema | §4.7 |
|
||||
| 2026-10-13 | File temporanei `.febe-<hex>.part`; un nome occupato diventa `nome (2).ext`; mai sovrascrivere | Scrittura sicura (§6.5 punto 4) |
|
||||
| 2026-10-13 | Miniature per SHA-256 in `miniature/ab/<sha>.jpg`, JPEG 82, orientamento EXIF applicato, mai ingrandite | Generate una volta sola (§8.4) |
|
||||
| 2026-10-13 | Impronta visiva: pHash classico su DCT, soglia 6 | Su 24 scene generate: ridimensionate/ricompresse ≤ 4, ritagliate ≥ 8, scene diverse ≥ 20 |
|
||||
| 2026-10-13 | `_febe.jsonl` versione 1: righe `save`/`delete`, tipo come nome italiano della cartella; una riga troncata da un arresto si chiude prima di aggiungere | Leggibile senza Febe; regge gli arresti |
|
||||
| 2026-10-13 | Eliminazione: prima la riga del giornale, poi il database, poi i file e le miniature | Una ricostruzione rispetta l'eliminazione anche se Febe si ferma a metà |
|
||||
| 2026-10-13 | La ricostruzione non tocca mai i file; gli account ricostruiti tornano «In pausa» con impostazioni predefinite | Regola 12 |
|
||||
| 2026-10-13 | Controllo della cartella dei dati: UNC e `DriveType.Network` su Windows; `/proc/self/mounts` su Linux; `fuse.shfs` di Unraid conta come locale | §8.2 |
|
||||
| 2026-10-13 | Gli indirizzi firmati restano in `media` solo finché il file non è salvato | La coda degli scaricamenti sopravvive al riavvio; mai nei registri |
|
||||
| 2026-10-13 | Chromium si ferma con SIGINT, non SIGTERM | Con SIGTERM perdeva in 3 casi su 4 un cookie scritto da meno di 30 s (S3) |
|
||||
| 2026-10-13 | Fattori del ritmo dei gesti: lento 1,35, naturale 1, svelto 0,75 | La specifica non dà numeri |
|
||||
| 2026-10-13 | Puntatore su curva di Bézier cubica (curvatura 2–12%), profilo di velocità a scatto minimo, circa 60 eventi al secondo, arrivo nel 60% centrale del bersaglio | §7.7 |
|
||||
| 2026-10-13 | `segnali.json` e `bersagli.*.json` con chiavi inglesi e note in italiano; chiavi sconosciute rifiutate | Coordinate o nomi di classi non possono entrarci (§6.3) |
|
||||
| 2026-10-13 | `ReadOnlyScriptGuard`: elenco di divieti sulle espressioni di `Runtime.evaluate` (niente modifiche, fetch, cookie, archiviazione) | Rete di sicurezza per la sola lettura di §6.1, non una prova |
|
||||
| 2026-10-13 | Un segnale con lo stesso codice si inoltra all'interruttore al massimo una volta ogni 60 s; le regole sul testo guardano solo JSON brevi; le pagine vuote le segnalano le ricette (soglia 3) | Una didascalia con la frase cercata non è un segnale |
|
||||
| 2026-10-13 | Le navigazioni comprendono i cambi di percorso con `history.pushState` | Instagram è un'applicazione a pagina singola |
|
||||
| 2026-10-13 | `BrowserFileFetcher`: solo domini del CDN, senza credenziali (da rivedere con H7), blocchi da 1 MB | §6.5 |
|
||||
| 2026-10-13 | `--no-sandbox` solo se richiesto esplicitamente; l'host rifiuta di partire se la porta di debug è occupata o ascolta fuori da 127.0.0.1; nel profilo nuovo salvataggio delle password e compilazione automatica spenti | §6.1, §11 |
|
||||
| 2026-10-13 | Messaggi CDP letti senza il serializzatore JSON a riflessione | Compatibile con pubblicazione ridotta e file singolo |
|
||||
| 2026-10-13 | Il Governatore attende la distanza minima (4 s × ritmo) invece di rifiutare; `EvaluateAsync` la segnala come `MinimumSpacing` | Le storie durano 1,8–5 s: un rifiuto fermerebbe le ricette di continuo |
|
||||
| 2026-10-13 | Ordine dei controlli: interruttore, pausa/browser in uso, fascia, sessione, tetto giornaliero poi orario, distanza, limiti dell'account | §7.4 |
|
||||
| 2026-10-13 | `DataDownload` controlla solo il tetto giornaliero in byte, anche durante un fermo; il dimezzamento vale anche per i dati, dal segnale | §7.6 |
|
||||
| 2026-10-13 | Limite di storico = min(limite dell'account, valore del profilo), ridotto come i tetti; conta i post scoperti oggi | «Vince il più stretto» |
|
||||
| 2026-10-13 | Riduzioni: fattore = min(avvio graduale, dimezzamento), tetti arrotondati per difetto, mai sotto 1 | §7.4 |
|
||||
| 2026-10-13 | Origine dell'avvio graduale: primo avvio del motore o `NotifyFirstConnectionAsync`, e ogni «Riprendi» dopo verifica | §7.2 |
|
||||
| 2026-10-13 | L'escalation conta i rallentamenti nelle 24 ore; un segnale durante un fermo non lo allunga; «Riprendi» non accorcia un rallentamento | Durate fisse |
|
||||
| 2026-10-13 | Spostamento della fascia: normale con σ = metà dello scarto, tagliata a ± scarto, da un seme salvato (`motore.fascia-seme`) | Mai uniforme; un riavvio non lo riestrae |
|
||||
| 2026-10-13 | La durata estratta è il tetto della sessione: finito il lavoro, la sessione chiude prima | Meno traffico, mai di più |
|
||||
| 2026-10-13 | Prima sessione 2–10 min dopo avvio, fine rallentamento o «Riprendi»; prossima sessione salvata e mai anticipata da un riavvio; pausa minima dall'ultima sessione o azione | §7.2 |
|
||||
| 2026-10-13 | «Controlla ora» in fascia anticipa la sessione solo fino alla pausa minima; fuori fascia gettone valido 10 min, poi una sola visita di quell'account | §7.8 |
|
||||
| 2026-10-13 | Controllo manuale ammesso su account in pausa o non raggiungibili, mai su «Solo archivio» o privati non seguiti | Regola 6 |
|
||||
| 2026-10-13 | Profili non seguiti: una visita (profilo + storie) al più corto dei due intervalli | Le loro storie si vedono solo dal profilo |
|
||||
| 2026-10-13 | Intervallo delle storie: scostamento sotto il massimo (mediana 0,75, σ 0,25, [0,45; 1]) e mai oltre un terzo della fascia | Almeno 3 controlli al giorno |
|
||||
| 2026-10-13 | Ipotesi H2 da confermare in M0 (`SweepCoversFollowedStories`): il giro dei seguiti vale come controllo delle storie dei seguiti | Meno aperture |
|
||||
| 2026-10-13 | Ipotesi H3 da confermare in M0 (`PostsPerBackfillPage` = 12), solo per stime | Regola 10 |
|
||||
| 2026-10-13 | Su misura: riconciliazione dei seguiti = 4 × intervallo dei post, fra 6 e 24 ore | La specifica non lo dice |
|
||||
| 2026-10-13 | Composizione: giro all'inizio con probabilità 0,9; sessione leggera 1 su 3; 3–12 pagine di storico; 1–4 s fra ricette × umore × ritmo; ordine pesato con u^(1/peso) | §7.2 |
|
||||
| 2026-10-13 | Tre «formato non riconosciuto» o «bersaglio non trovato» di fila sospendono la ricetta; un bersaglio non trovato chiude la sessione | §6.4, §7.7 |
|
||||
| 2026-10-13 | Lo storico gira solo per account nello stato «Storico in corso»; con «Tieni aggiornato» spento, dopo lo storico l'account va in pausa | §4.4 |
|
||||
| 2026-10-13 | A fine sessione pagina vuota, tranne dopo verifica/disconnessione o con Alberto al browser | §6.1, §7.6 |
|
||||
| 2026-10-13 | Un segnale annulla la sessione da un thread del pool, mai sul thread di cattura | Il motore non deve bloccare il client CDP |
|
||||
| 2026-10-13 | Una riga di evento per ricetta («ricetta.<Tipo>», «Titolo: dettaglio»), una per sessione, più fermi, pause, tetti raggiunti e storico | Attività e cronologia dell'account |
|
||||
| 2026-10-13 | Orologio virtuale a eventi, ritardi arrotondati al millisecondo; il mondo simulato ha un seme proprio e rallentamenti con probabilità 0,0003 per azione | Simulazione deterministica e veloce |
|
||||
| 2026-10-13 | Impostazioni del motore nella tabella `setting` (chiavi `motore.*`); profilo Su misura scritto con `JsonNode` | Nessun serializzatore a riflessione |
|
||||
| 2026-10-13 | Ore senza zero iniziale («verso le 7:42», «verso l'1:05») | Uso italiano |
|
||||
| 2026-10-13 | `bersagli.*.json` e `lettori.*.json` in `src/Febe.Core/Config`, incorporati e copiati in `config/`, sovrascrivibili dalla cartella Dati | Stessa via di `segnali.json`; si aggiornano senza ricompilare |
|
||||
| 2026-10-13 | `bersagli.*.json` ha una sezione `pages` (indirizzi e forma dell'indirizzo dei visualizzatori); voci con role/name/href vuoti = da compilare; una ricetta con una voce necessaria vuota si rifiuta senza aprire pagine né chiedere permessi | Scheletro Instagram (H11) senza inventare nulla |
|
||||
| 2026-10-13 | Vocabolario dei lettori per concetti, con stato «confermato»/«ipotesi»; Instagram = ipotesi con i soli indizi di §6.4 | Regola 10 |
|
||||
| 2026-10-13 | Lettore per forma: contenuto = id+data+(immagini\|video\|figli); profilo = id+nome; raccolta = id+titolo; «vuota» = nessun elenco con elementi; il resto «non riconosciuta» con la sola struttura delle chiavi | §6.4 |
|
||||
| 2026-10-13 | Versione: immagine di area massima; video più grande fra quelli con audio (chi non lo dice conta come completo), altrimenti il più grande | §6.5 punto 1 |
|
||||
| 2026-10-13 | StoryView chiesto prima dell'apertura e di ogni «avanti»; se il visualizzatore avanza da solo si chiede subito dopo e, se negato, si chiude. Chiudere non è un'azione contata | Una vista, un permesso; chiudere evita viste in più |
|
||||
| 2026-10-13 | Storico: ripresa dalla pagina `profileFrom` se la mappa la prevede, altrimenti scorrendo (ogni pagina contata); cursori di Taggati e Reel nelle impostazioni (`raccolta.taggati.{id}.cursore`, `raccolta.reel.{id}.cursore`); a tab completa solo controllo della prima pagina | §6.3 «riprende dal punto» |
|
||||
| 2026-10-13 | Elenco dei seguiti: avanzamento in `seguiti.cursore`/`seguiti.inizio`/`seguiti.letti` | Più sessioni (§4.2) |
|
||||
| 2026-10-13 | Foto del profilo: identità = hash del percorso dell'indirizzo, senza firma | Nuova copia solo quando cambia |
|
||||
| 2026-10-13 | §9.5 identico: se l'esistente è importato senza identificativo, stesso tipo e un solo file, l'importato prende i dati e il nuovo record si toglie; altrimenti il nuovo file diventa «saltato» con nota | Nessuna sostituzione automatica (regola 12) |
|
||||
| 2026-10-13 | Coda: file temporaneo `.febe-*.part` in `Dati/temporanei`; 403/410 = indirizzo scaduto (ipotesi H7); storia scaduta → «fallito»; errori di rete → di nuovo «da scaricare», fino a 5 tentativi | §6.5 |
|
||||
| 2026-10-13 | Via `HttpClient` di §6.5 punto 3 non scritta, resta dietro `IFileFetcher` | Dipende da H7 |
|
||||
| 2026-10-13 | Pagina «caricata» = `readyState` complete + almeno un evento `paint`; per riportare in vista un bersaglio fino a 24 raffiche | L'input prima del primo disegno si perde; una persona risale |
|
||||
| 2026-10-13 | Ripulitura: lettere finte solo consonanti; un valore finto non contiene mai un frammento dei grezzi; la verifica dice dove, mai che cosa; host dei collegamenti ridotto dalla sonda a sito/cdn/altro; interazioni lette da `:hover` e `activeElement` in sola lettura | §14.5 |
|
||||
| 2026-10-13 | Prove con orologio compresso (fattore 10), governatore permissivo, un sito di prova per prova, un Chromium per classe | Prove d'insieme sotto i 2 minuti |
|
||||
| 2026-10-13 | Il Governatore espone anche la vista dei tetti per le ricette (`IBudgetView`); un solo `ItalianText` per i testi (in `Febe.Core.Engine`) | Raccordo fra motore e ricette dopo l'unione dell'ondata 2 |
|
||||
| 2026-10-13 | Interfaccia incorporata come risorse `wwwroot/…` con un IFileProvider proprio | nessun pacchetto in più, un solo file da distribuire |
|
||||
| 2026-10-13 | Nomi JSON dell'API in inglese camelCase, testi per Alberto in italiano | identificatori in inglese, interfaccia in italiano |
|
||||
| 2026-10-13 | In modalità dimostrativa niente SSE, la pagina chiede il motore ogni 30 s | le schermate senza finestra finiscono |
|
||||
| 2026-10-13 | Gettone del desktop scambiato una volta con un cookie HttpOnly Strict e tolto dall'indirizzo | non resta in cronologia né nei registri |
|
||||
| 2026-10-13 | Blocco password per client e complessivo; il tentativo che raggiunge la soglia risponde già «bloccato» | rallenta anche i tentativi da più indirizzi |
|
||||
| 2026-10-13 | Esportazione CSV con `;`, BOM e prefisso `'` sui campi che iniziano con `= + - @` | Excel italiano, niente formule iniettate |
|
||||
| 2026-10-13 | AccountPlanInput con GradualStartSince e Now | il piano dell'account deve sapere se l'avvio graduale è ancora in corso |
|
||||
| 2026-10-13 | Strumento per le schermate in tools/schermate (Node, nessun pacchetto) | rifare le schermate di §10.7 anche nella parte 2 |
|
||||
| 2026-10-13 | Nessuna migrazione nuova: le scelte di un'importazione senza colonna (ipotesi Stogram, nuovi account) stanno in `setting` con chiavi `importazione.{id}.*`; le note dei file in `import_file.last_error` | Evita conflitti di numerazione fra rami paralleli; lo schema 1 basta |
|
||||
| 2026-10-13 | Nuovi valori `ImportOutcome.IdenticalInSource` e `ImportDateSource.Journal` | Una copia identica nella sorgente non è «già in libreria»; la data del giornale di Febe è esatta |
|
||||
| 2026-10-13 | Unità da associare: le cartelle di primo livello, oppure la cartella scelta se contiene solo cartelle di tipo/anni o solo file | Una riga per account nella tabella del mockup 09 anche scegliendo direttamente un account |
|
||||
| 2026-10-13 | Confronto: SHA in libreria (prima l'account di destinazione), SHA nella sorgente, identificativo/codice con posizione, impronta in libreria, poi identità e impronta nella sorgente; una coppia al massimo per file, verso il primo file del gruppo | §9.3; niente catene di coppie |
|
||||
| 2026-10-13 | «Stesso identificativo, file diverso» vale anche per i video; per i video si esclude solo l'impronta | «Per i video vale solo lo SHA-256» riguarda le soglie dell'impronta |
|
||||
| 2026-10-13 | Uno SHA o un identificativo di un elemento eliminato «ricordando la scelta» conta come «già in libreria», con nota | Un'importazione non annulla un'eliminazione (§4.6) |
|
||||
| 2026-10-13 | Associazione iniziale: account per identificativo poi per nome; altrimenti nuovo «Solo archivio» col nome della cartella se valido; altrimenti nessuno. Gli account nascono all'avvio della copia, con «Tieni aggiornato» spento | Mockup 09; un'importazione abbandonata non lascia account vuoti |
|
||||
| 2026-10-13 | File senza account o con doppione da decidere restano «analizzati» con la nota; la copia si rilancia sulla stessa importazione | «Blocca solo i propri file» (§9.4) |
|
||||
| 2026-10-13 | «Più grande» = più pixel, poi più byte; a parità vince la libreria. Sostituzione: nuovo file scritto e riletto (SHA-256), poi record e `_febe.jsonl`, poi eliminazione del vecchio file e della sua miniatura | Regola 12 |
|
||||
| 2026-10-13 | Nella sorgente, fra file uniti da «tieni il più grande» si importa solo il più grande del gruppo | Nessun effetto a catena |
|
||||
| 2026-10-13 | «Sposta» elimina solo originali di file copiati in modalità Sposta, dopo aver riletto la copia dal disco; mai i file saltati | §9.4 |
|
||||
| 2026-10-13 | Sola lettura riconosciuta senza scrivere nella sorgente: `ro` nei montaggi (Linux), dischi ottici (Windows), `/importa` in sola lettura per configurazione | L'analisi non scrive nemmeno un file di prova |
|
||||
| 2026-10-13 | Sorgenti rifiutate: dentro o sopra la cartella dei dati, sopra la libreria, dentro una cartella di account con `_febe.jsonl` | Niente libreria importata in sé stessa |
|
||||
| 2026-10-13 | Date: nome (o giornale di Febe), metadati (EXIF con fuso, `mvhd`, ffprobe solo in aggiunta), data di modifica; un nome con il solo giorno cede all'ora dei metadati dello stesso giorno; ore senza fuso = fuso di Alberto | §9.2 |
|
||||
| 2026-10-13 | Il riconoscitore generico non estrae identificativi: i codici vengono solo dai nomi e dal giornale di Febe | Regola 10 |
|
||||
| 2026-10-13 | Ipotesi 4K Stogram dietro un'opzione per importazione, spenta; ora del nome letta come locale; `stogram.sqlite` mai aperto (si guarda solo se esiste) | §9.6: va riscritta sui dati veri |
|
||||
| 2026-10-13 | `MediaContent.FixedRelativePath` ed `ExpectedSha256`; la copia usa un `LibraryIngest` senza indice e aggiorna da sé l'indice condiviso | Stessa via degli scaricamenti; nessuna coppia «da scaricamento» per varianti già decise; un file cambiato dopo l'analisi non entra |
|
||||
| 2026-10-13 | CSV con `;`, UTF-8 con BOM, CRLF, date locali, durate con la virgola, apostrofo davanti a = + - @ | Excel in italiano; nessuna formula da un nome di file |
|
||||
| 2026-10-13 | Analisi a gruppi di 64 file, lettura in parallelo (fino a 4), confronto e salvataggio in ordine; foto fino a 64 MB lette una volta sola | «Primo incontrato» stabile e un solo passaggio sul disco |
|
||||
| 2026-10-13 | Un lavoro d'importazione alla volta; eventi «importazione-analizzata», «importazione-completata», «account-solo-archivio» | Il disco è il collo di bottiglia; cronologia in Attività |
|
||||
| 2026-10-13 | `CapabilitiesDto` riceve un nuovo campo posizionale finale `Problems` | serve alla pagina di errore di configurazione; è un cambio di firma pubblica di un DTO: chi lo costruisce a mano deve passare il valore. |
|
||||
| 2026-10-13 | `POST /api/connection/begin` non segna il browser come usato; lo segna `finish` | «Riprendi» dopo una verifica deve accendersi solo quando Alberto ha finito nel browser, non appena lo apre. |
|
||||
| 2026-10-13 | Ripieghi `TryAdd` per tutto ciò che non è di questo lavoro (collegamento, anteprima, invio Telegram, cambio cartella dati) | interfaccia e prove funzionano già; la composizione sostituisce i pezzi senza toccare Febe.Web. |
|
||||
| 2026-10-13 | `ImportHub` costruisce un `ImportService` sulla libreria se la composizione non ne registra uno; in Docker solo sotto `FebeWebOptions.ImportRoot` (`/importa`) | Importa funziona subito in tutte e due le vesti, nei limiti di §9.1. |
|
||||
| 2026-10-13 | In Limiti e comportamento gli orari sono campi di testo a 24 ore | il selettore d'ora del browser mostra AM/PM secondo la lingua del sistema. |
|
||||
| 2026-10-13 | Scartare un doppione dopo uno scaricamento avviene solo su scelta esplicita: il file scartato si ricorda e non si riscarica | regola 11, la libreria non decide da sola. |
|
||||
| 2026-10-13 | Cambiando la cartella della libreria (desktop), gli account con cartella già esistente restano fissati al vecchio percorso | nessun file si sposta da solo; i nuovi account vanno nella cartella nuova. |
|
||||
| 2026-10-13 | Il gettone Telegram non torna mai all'interfaccia (solo `telegramTokenSet`) e un campo vuoto lo lascia com'è | §13.3 e regola 10. |
|
||||
| 2026-10-13 | La ricostruzione del database chiede di scrivere «ricostruisci» ed è rifiutata durante un'importazione | operazione pesante (§8.5). |
|
||||
| 2026-10-13 | `/salute` non fatto qui | appartiene al lavoro Server/Docker; evita due rotte uguali. |
|
||||
| 2026-10-13 | Nella dimostrazione «In coda» è ordinata per orario | come il mockup 06; il motore vero dà il suo ordine. |
|
||||
| 2026-10-13 | `ApiErrorMiddleware` toglie « (Parameter 'x')» dai messaggi | gli errori arrivano all'interfaccia in italiano pulito. |
|
||||
| 2026-10-13 | «Fai una copia adesso» sostituisce la copia di oggi | una copia al giorno, se ne tengono 7. |
|
||||
| 2026-10-13 | Server reale come comando predefinito di `febe`; password solo da `FEBE_PASSWORD`, mai da riga di comando | Le righe di comando sono leggibili da altri processi |
|
||||
| 2026-10-13 | Problema di configurazione: solo interfaccia su un database temporaneo, gate API 503, nessun browser né motore, nulla scritto in `/dati` | §8.2, §11: la vista remota mai raggiungibile senza password |
|
||||
| 2026-10-13 | Senza password il middleware lascia passare solo pagina d'errore, file, `capabilities`, `preferences`, `/salute` | Prima rispondeva 503 a tutto e la pagina d'errore non poteva comparire |
|
||||
| 2026-10-13 | Profilo seccomp dedicato (predefinito di Docker + `clone`/`unshare`) in compose e nel modello Unraid; `FEBE_SENZA_SANDBOX` solo come compromesso esplicito | S5 misurata: col profilo predefinito «No usable sandbox», col dedicato sandbox completa |
|
||||
| 2026-10-13 | Il profilo seccomp si copia a ogni avvio in `/dati/seccomp.json`; Unraid lo chiede in ExtraParams, con il primo scaricamento indicato in `Requires` | Docker legge il profilo alla creazione del contenitore |
|
||||
| 2026-10-13 | Criteri di Chromium: oltre ai tre richiesti, anche `PasswordLeakDetectionEnabled: false` | Nessun trattamento della password di Instagram dal browser |
|
||||
| 2026-10-13 | `HEALTHCHECK` con `febe --controllo-salute`, niente curl | Nessun pacchetto in più |
|
||||
| 2026-10-13 | tini come processo 1; entrypoint minimo con `setpriv`; `PUID=0` rifiutato | §11: Febe.Server sorveglia Xvfb e Chromium, utente non root |
|
||||
| 2026-10-13 | La porta di debug resta 9222 su 127.0.0.1; `HOME` di Chromium in `/dati/home`; variabili di proxy tolte all'ambiente del browser | §6.1, regola 2 |
|
||||
| 2026-10-13 | Lock `Singleton*` del profilo e lock X orfani tolti prima di ogni avvio | Dopo la ricreazione del contenitore il nome host cambia e Chromium rifiuterebbe il profilo con un dialogo invisibile |
|
||||
| 2026-10-13 | «Scollega» riavvia sul posto lo stesso `ChromiumProcessHost` (`RestartAsync`) | Sessione CDP, cattura e coda degli scaricamenti restano agganciate |
|
||||
| 2026-10-13 | Vista remota: «indietro» con `Page.navigate` all'indirizzo precedente tenuto in memoria; una vista alla volta, la più recente vince | Nessun comando di cronologia fra quelli ammessi |
|
||||
| 2026-10-13 | `FEBE_HOST` facoltativa (più i nomi loopback); vuota significa qualunque nome; `FEBE_PROXY_FIDATO` per un proxy HTTPS | Difesa in più contro il DNS rebinding senza rompere l'uso in LAN |
|
||||
| 2026-10-13 | Registro: un file al giorno, 14 giorni, 20 MB al giorno, indirizzi tolti | §8.2, §13.2 |
|
||||
| 2026-10-13 | Copia del database all'avvio e poi ogni giorno alle 3:20 locali | Fuori dalla fascia di ogni profilo |
|
||||
| 2026-10-13 | Modalità di sviluppo `--sito-di-prova` (solo indirizzi locali), `--accesso-di-prova`, `--prima-sessione` | Composizione vera senza Instagram (regola 1) |
|
||||
| 2026-10-13 | Prove d'insieme: orologio compresso 10× e fuso `Etc/GMT±n` dove è mezzogiorno | Motore sempre in fascia, a qualunque ora giri la prova |
|
||||
| 2026-10-13 | Il server reale registra `EngineHostSettingsControl`, un'anteprima vera del browser (`Page.captureScreenshot` al più ogni 4 s, niente sulla pagina vuota) e l'acquisizione della libreria, che riceve subito il nuovo schema dei nomi (`LibraryIngest.Apply`) | Raccordo fra interfaccia parte 2 e composizione del server: i limiti arrivano al motore in esecuzione e lo schema vale per i prossimi file senza riavvio (§4.7) |
|
||||
| 2026-10-13 | Composizione condivisa in `src/Febe.App` (`FebeApp`, `IFebePlatform`, `IFebeBrowser`); Febe.Server = `DockerPlatform` + `FebeServer` sottile con la stessa superficie; ServerLog→FebeLog, ServerConnectionService→BrowserConnectionService, BrowserSupervisor→ChromiumBrowser, ServerBrowserPreview→LiveBrowserPreview | Un motore e una composizione per le due vesti (§5) |
|
||||
| 2026-10-13 | Logica di Windows provabile su Linux in `src/Febe.Desktop.Core` (net10.0); in Febe.Desktop solo le chiamate a Windows | Le prove girano su Linux |
|
||||
| 2026-10-13 | Adattatore CDP di WebView2 (`WebView2CdpSession`) in Febe.Browser dietro `IWebView2DevTools`; eventi in ordine su un ciclo proprio, mai sul thread dell'interfaccia; degli errori del protocollo solo codice e messaggio | Stesse regole del client Chromium; niente blocchi col thread di WPF |
|
||||
| 2026-10-13 | `WebView2Host` ospita `CoreWebView2Controller` direttamente sull'HWND (pixel reali), non il controllo WPF | `IsVisible` sempre vero; serve anche alla composizione |
|
||||
| 2026-10-13 | S2: browser fuori dallo schermo, mai nascosto né ridotto a icona (ridurlo = fuori vista); `--disable-features=CalculateNativeWinOcclusion --disable-backgrounding-occluded-windows` | §6.6; gli argomenti non cambiano ciò che il browser dichiara (UA, navigator, lingua, fuso, intestazioni) |
|
||||
| 2026-10-13 | Modo di S2 con `--browser finestra\|composizione\|edge`, salvato in `desktop.browser`; Edge assente → finestra | Prove di Alberto senza interfaccia apposita |
|
||||
| 2026-10-13 | Edge: profilo `Dati\browser\edge` (Scollega cancella tutto `Dati\browser`), porta 9222 su 127.0.0.1, password e compilazione automatica spente dalle preferenze del profilo, nessun criterio nel registro | Non toccare l'Edge di Alberto |
|
||||
| 2026-10-13 | «Browser di Febe» senza pulsante nella barra delle applicazioni; un'attivazione mentre è fuori vista non conta come «Alberto guida» | Windows attiva la finestra successiva quando un'altra si chiude: il motore si fermerebbe da solo |
|
||||
| 2026-10-13 | Barra sotto la pagina con Indietro, Ricarica e indirizzo senza query (GoBack/Reload di WebView2, non CDP); nel browser di Febe nuove finestre aperte nella stessa, scaricamenti annullati, permessi negati | Navigazione di Alberto, non del motore; la sessione resta nel profilo |
|
||||
| 2026-10-13 | Interfaccia in un WebView2 con dati propri in `Dati\interfaccia` (in temp se la cartella dei dati ha un problema); ogni altro indirizzo va al browser predefinito; porta 0 con `LoopbackHosts(0)` | §13.1 |
|
||||
| 2026-10-13 | Istanza unica per cartella dei dati: mutex `Local\Febe-<16 hex SHA-256>`, pipe `CurrentUserOnly`, messaggi `FEBE1 mostra\|nascosto` | Un secondo account con cartelle proprie resta possibile (§3) |
|
||||
| 2026-10-13 | Cambio della cartella dei dati: registrato in `HKCU\Software\Febe` (CartellaDati, NuovaCartellaDati), applicato al prossimo avvio prima di aprire qualunque cosa; copia riletta con SHA-256, poi la vecchia si cancella; con un errore si resta sulla vecchia; nuova cartella vuota e locale; con `--dati` non disponibile | La sessione non si copia né si lascia in giro (§13.2) |
|
||||
| 2026-10-13 | Desktop: la libreria è l'impostazione `libreria.cartella` (predefinita Immagini\Febe); il cambio vale subito per i prossimi file (`LibraryIngest.UseLayout`); l'importazione la costruisce `ImportHub` | «I nuovi file andranno in …» |
|
||||
| 2026-10-13 | Avvisi: `AlertDispatcher` nella composizione condivisa, canali `IAlertChannel` dalle vesti (Windows: notifiche dell'icona; M8: Telegram); codice `disco-quasi-pieno` già mappato | Un aggancio solo per le due vesti |
|
||||
| 2026-10-13 | Notifiche di Windows con i balloon tip di NotifyIcon; avvio con il computer in HKCU…\Run «Febe» = `"…\Febe.exe" --nascosto` | Nessun pacchetto in più |
|
||||
| 2026-10-13 | Icona da BrandMark (SkiaSharp) e IcoWriter a mano: DIB a 32 bit fino a 128, PNG a 256; una prova la confronta col disegno | Appendice C, elenco chiuso di §3 |
|
||||
| 2026-10-13 | Un solo Febe.exe: niente pdb, XML né config/ accanto (target `FebeSingleFileOnly`); `WFO0003` soppresso (app WPF, DPI dal manifesto) | §12 |
|
||||
| 2026-10-13 | Installatore NSIS per utente in %LOCALAPPDATA%\Programs\Febe senza scelta della cartella, collegamento sul desktop facoltativo (scelto di serie), HKCU Uninstall, WebView2 cercato con «pv» delle chiavi EdgeUpdate, rifiuto se Febe è aperto, `/DVERSION` obbligatorio, disinstallazione che non tocca dati né libreria e dice dove sono | Domanda 6 di §16 |
|
||||
| 2026-10-13 | «Scollega» che non riesce a cancellare il profilo: browser e motore ripartono, la sessione si ricontrolla, 400 in italiano (entrambe le vesti) | Il motore non deve restare fermo per un file bloccato |
|
||||
| 2026-10-13 | M9 («collegati a un Febe già in funzione») non fatto | Facoltativo, non banale |
|
||||
| 2026-10-13 | `AlertService` ascolta la cronologia del motore (codici degli eventi), non lo stato dell'interruttore | Una sola fonte per interfaccia e avvisi; i testi del motore portano già i fatti |
|
||||
| 2026-10-13 | «Ricetta sospesa» è un avviso a sé, sotto l'interruttore «Formato non riconosciuto»; «avviso-non-inviato» è una riga, mai un avviso | La sospensione è la conseguenza seria; niente catene di avvisi |
|
||||
| 2026-10-13 | Intervalli minimi: verifica, disconnessione, fermo e ripresa 30 min; storico 24 h per account; formato e ricetta sospesa 6 h; disco 20 h per insieme di dischi. Orari salvati in `avvisi.inviato.*` | Uno stato che va e viene non manda raffiche; un riavvio non ripete |
|
||||
| 2026-10-13 | Disco quasi pieno: meno di 10 GB o meno del 5%, libreria e dati, controllo 1 min dopo l'avvio e poi ogni 15 min; riga in Attività quando cambia l'insieme e ogni 24 h; disco non misurabile = nessun avviso | Soglie facili da spiegare; vale sia per un array grande sia per un SSD piccolo |
|
||||
| 2026-10-13 | Telegram: JSON a mano, testo semplice fino a 3.500 caratteri, 15 s, forma del gettone controllata, nessun nuovo tentativo automatico | §13.3, regola 10; l'avviso resta comunque nell'interfaccia |
|
||||
| 2026-10-13 | Indirizzo di Telegram come stringa assoluta | «bot123:ABC» relativo diventa uno schema |
|
||||
| 2026-10-13 | `NoTelegramSender` (nuovo nome) come ripiego di Febe.Web; la composizione registra `TelegramAlertChannel` | La dimostrazione e le prove non usano mai la rete |
|
||||
| 2026-10-13 | Sezione «Avvisi» in Attività (`GET /api/alerts`, 14 giorni) | Storico completato, disco e formato non avevano un posto visibile |
|
||||
| 2026-10-13 | Ricette sospese in Attività con «Riattiva» | Il motore diceva «si riattiva da Attività», ma non c'era modo |
|
||||
| 2026-10-13 | «Esporta l'elenco» a sola icona; la riga degli strumenti va a capo sopra i 1000 px | Nella riga del mockup non c'è spazio |
|
||||
| 2026-10-13 | Guida in `docs/guida`, una pagina per file, collegamenti `[Testo](Pagina)`, prova `Febe.Tests.Docs` | Formato del wiki di Gitea |
|
||||
| 2026-10-13 | Avvisi collegati una sola volta in `FebeApp` (composizione condivisa): `AlertService` di `Febe.Core.Alerts` con i canali notifica di sistema (`INativeShell`) e Telegram; tolto il gancio doppio `AlertDispatcher` del ramo desktop; `AlertServiceOptions.FolderSource` legge la cartella della libreria a ogni controllo del disco | Un solo meccanismo per le due vesti; sul desktop la libreria può cambiare mentre Febe gira |
|
||||
| 2026-10-13 | Flusso di rilascio `.gitea/workflows/rilascio.yml` a ogni tag: installatore e zip per Windows costruiti sul runner Linux, immagine Docker costruita e pubblicata sul registro di Gitea con il segreto `REGISTRY_TOKEN` (variabile facoltativa `REGISTRY`), release con allegati creata con il gettone automatico di Actions | Stesso schema di Encelado e Mimante; senza segreto l'immagine si costruisce ma non si pubblica e il lavoro lo dice |
|
||||
| 2026-10-13 | L'orologio virtuale decide se far scattare il prossimo timer o finire sotto lo stesso lock, ricontrollando quanti attori aspettano | Un timer annullato da un thread del pool chiudeva la corsa in anticipo (simulazione troncata, prova del rallentamento instabile) |
|
||||
| 2026-10-13 | Con la guida di Alberto e nessuna sessione, le regole di percorso (navigazione, documento) non sono segnali; stato HTTP, testo e controllo del cookie restano | Regola 7: accesso e verifiche aperti da lui non sono «la pagina torna all'accesso» (§7.6) |
|
||||
| 2026-10-13 | Cookie di sessione sparito fuori sessione e senza Alberto al browser = segnale di disconnessione all'interruttore; all'avvio solo se esiste `collegamento.primo`; mai dopo «Scollega» (impostazione `collegamento.scollegato`, tolta al collegamento successivo) | §7.6 e §13.3: incidente, avviso e ripresa solo con «Riprendi» |
|
||||
| 2026-10-13 | La lease di «Accedi a Instagram»/«Usa il browser» finisce da sola dopo 2 minuti in cui è l'unica del browser (vista remota chiusa, finestra fuori vista); «Ho finito»/«Annulla» tardivi non toccano la pagina se nessuno guida | Il motore non resta fermo per sempre se Alberto se ne va senza i pulsanti |
|
||||
| 2026-10-13 | Quando la guida finisce e nessuna sessione è in corso, il motore porta la pagina a riposo (non dopo verifica o disconnessione) | §6.1; un visualizzatore lasciato aperto avanzerebbe da solo su altri account (§6.3) |
|
||||
| 2026-10-13 | Vista remota: ping ogni 20 s, risposta entro 30 s | Una pagina sparita teneva la lease fino al timeout TCP |
|
||||
| 2026-10-13 | Vista remota: aperture serializzate; un avvio fallito chiude sempre la vista | «La più recente vince» anche con due aperture nello stesso momento |
|
||||
| 2026-10-13 | La sincronizzazione della coda attende l'avvio e la contabilità di una ricetta; il compito in corso conta come presente | Evita un controllo duplicato con la vecchia scadenza |
|
||||
| 2026-10-13 | Raccolte in evidenza: un compito per raccolta (identificativo Instagram), subito se mai vista, poi ogni 8 intervalli delle storie fra 1 e 7 giorni; una raccolta per account e sessione, mai su un profilo già aperto nella sessione | §4.2/§6.3: «evidenza» è attiva di serie e non veniva mai raccolta |
|
||||
| 2026-10-13 | La scheda Reel non si programma da sola nella versione 1 (la ricetta resta) | §4.3: è solo una seconda fonte, i reel della griglia arrivano già con Controllo e Storico; H6 è da provare; ogni visita costerebbe un profilo aperto in più |
|
||||
| 2026-10-13 | Un 429 (o altra regola di stato) del CDN durante uno scaricamento si segnala con `SignalDetector.ObserveDownload`; la coda si ferma 1 ora senza contare tentativi; nell'incidente solo schema e host | `loadNetworkResource` non passa dagli eventi della pagina; il percorso del CDN identifica il file (§13.2) |
|
||||
| 2026-10-13 | Attese crescenti fra i tentativi (5 min, 30 min, 2 h, 8 h) tenute in memoria; errori di connessione non contati, pausa di 5 min | Nessuna migrazione (come decisione 94); un riavvio concede al più un tentativo anticipato |
|
||||
| 2026-10-13 | `attempts` conta ogni fallimento, scadenze comprese, e non si azzera con un nuovo indirizzo; un file fallito si rianima da una nuova lettura fino a 10 fallimenti | Il ciclo scaduto → «Post singolo» resta limitato; un file rotto non costa uno scaricamento a ogni controllo |
|
||||
| 2026-10-13 | Senza pagina di ripresa lo storico e l'elenco dei seguiti tornano al punto salvato scorrendo (cursore o ultimo elemento in `…segno`); le pagine scorse si salvano e chiedono il permesso ma non contano nelle pagine della corsa | Decisione 76; mai una ripartenza silenziosa |
|
||||
| 2026-10-13 | Il controllo del profilo legge tutta la prima pagina; se finisce con un post nuovo, scende al massimo `GapPagesPerCheck` (3) pagine fino ai post noti, punto salvato in `raccolta.lacuna.{id}.*` | Post mancanti dopo una lunga assenza (check-1) |
|
||||
| 2026-10-13 | `content.owner` è un concetto necessario del vocabolario; senza la chiave `pinned` un post seguito da uno più recente sulla stessa pagina conta come fissato | vocab-1 |
|
||||
| 2026-10-13 | La posizione di un file di una serie è il posto dichiarato; il confronto avviene per identificativo, poi per posizione | reader-1 |
|
||||
| 2026-10-13 | Un lucchetto per cartella di account in `LibraryIngest`, dal controllo «identico» al registro del file | dedup-1 |
|
||||
| 2026-10-13 | I file temporanei di questo processo sono prenotati e la pulizia d'avvio non li tocca | tmp-1, senza modificare `FebeApp` |
|
||||
| 2026-10-13 | «Tieni il più grande» verso un file della libreria: quel file e tutti i file della sorgente accoppiati a lui sono un gruppo; resta solo il più grande, gli altri si saltano con nota; al momento della copia si riconfronta con il file in libreria in quel momento | Regola 12 e §9.3: due sostituzioni in fila cancellavano la prima copia (con «Sposta» l'originale più grande era perso) |
|
||||
| 2026-10-13 | Un file della sorgente con lo stesso SHA-256 del file in libreria è una sostituzione interrotta: la copia la conclude | Prima risultava «saltato, in libreria c'è il più grande» |
|
||||
| 2026-10-13 | Righe di `_febe.jsonl` non scritte: il file resta registrato, l'elemento va in `setting` `libreria.giornale-da-scrivere` e la riga si scrive alla passata successiva della coda e all'inizio e alla fine di ogni copia; evento «giornale-in-sospeso» quando l'elenco si riempie | §8.5; un errore del giornale dopo il salvataggio non vuol dire «niente scritto»; nessuna migrazione nuova |
|
||||
| 2026-10-13 | La coda scrive la riga di un elemento dopo ogni esito finale di un suo file, quando nessun file aspetta più e almeno uno è in libreria | §8.5 «una riga per ogni elemento salvato» |
|
||||
| 2026-10-13 | Ricostruzione: chiave = id, poi codice, poi primo file; l'ultima riga `save` è l'elenco completo dei file e una posizione che non compare più torna «eliminata» | Una sostituzione non divide l'elemento in due; le scelte di Alberto sono rispettate |
|
||||
| 2026-10-13 | Sostituzione di un elemento senza id né codice: dopo la nuova riga `save`, una riga `delete` non ricordata col vecchio percorso | La ricostruzione non fa rinascere l'elemento col file vecchio |
|
||||
| 2026-10-13 | Ricostruzione: un elemento senza id né codice con tutti i file mancanti non si ripristina (contato fra i mancanti, con nota); un'eliminazione ricordata senza id si riconosce dallo SHA-256 | Idempotenza; un record fantasma intercetterebbe uno scaricamento per data di pubblicazione (§9.5) |
|
||||
| 2026-10-13 | Ricostruzione: un file presente ma illeggibile si ripristina come presente con i dati del giornale, senza verifica (contatore `FilesUnreadable` e nota); un `_febe.jsonl` illeggibile salta solo la sua cartella | §8.5 «senza riscaricare nulla»: il verificatore proponeva «fallito», ma così il percorso si perde e «Post singolo» riscaricherebbe il file come «nome (2)» |
|
||||
| 2026-10-13 | Copie del database: un turno per cartella fra copia giornaliera, «Fai una copia adesso» e conservazione; si eliminano solo i `.part` fermi da 6 ore; un file che non si elimina resta per la volta dopo | Due copie insieme si cancellavano a vicenda il file temporaneo |
|
||||
| 2026-10-13 | `Mp4Reader`: dimensioni dei box confrontate con lo spazio rimasto (mai `offset + size`), al più 10.000 box figli | Un file danneggiato bloccava l'analisi fino all'esaurimento della memoria |
|
||||
| 2026-10-13 | Uno spostamento della cartella dei dati prende la guardia d'istanza della cartella nuova prima di scriverci e di registrarla; se la tiene un altro Febe lo spostamento non avviene; mutex non posseduto | Dopo lo spostamento ogni avvio legge la cartella nuova: deve trovare questo Febe (pkg-1, §12) |
|
||||
| 2026-10-13 | `febe.lock` nella cartella dei dati, aperto senza condivisione per tutta la vita del processo (desktop) | Due grafie della stessa cartella (nome corto, subst, giunzioni) darebbero due mutex |
|
||||
| 2026-10-13 | Avvio con il computer per cartella dei dati: valore `Febe` per quello consueto, `Febe-<identità>` con `--dati` per gli altri; la disinstallazione toglie anche questi | Il secondo account partiva come il primo e ne toglieva l'avvio (pkg-5) |
|
||||
| 2026-10-13 | Edge avviato da Febe in un job object con chiusura alla fine del job (`ChromiumLaunchOptions.ProcessStarted`, `IDesktopShell.EndWithFebe`) | Un Edge rimasto dopo un arresto teneva la porta 9222 per sempre (pkg-6) |
|
||||
| 2026-10-13 | Il profilo seccomp non si copia più in `/dati`: sul server sta fuori dal volume dei dati (Unraid `/mnt/user/appdata/febe-seccomp.json`, estratto dall'immagine); da root nell'avvio solo `chown -R` senza seguire i collegamenti, `/dati/home` la crea l'utente | Sostituisce la riga del 13/10 sulla copia a ogni avvio: in `/dati` l'utente del contenitore poteva allentare il filtro o far seguire collegamenti a root (pkg-2) |
|
||||
| 2026-10-13 | Rilascio: lavoro `prove` prima di tutto; la release dipende da prove, installatore e immagine; senza `REGISTRY_TOKEN` esce lo stesso e le note dicono che l'immagine non è pubblicata; un errore di costruzione o di pubblicazione ferma la release | Mai un installatore da codice non provato (pkg-3); la mancanza del segreto non deve bloccare Windows |
|
||||
| 2026-10-13 | Registro dell'immagine `192.168.30.23:3000` (HTTP): pubblicazione con buildx (builder docker-container, `http`/`insecure` nella configurazione di buildkit), credenziali nella configurazione del client invece di `docker login`; Unraid deve averlo fra gli `insecure-registries` | Convenzione delle altre immagini di casa; il demone del runner potrebbe non fidarsi del registro |
|
||||
| 2026-10-13 | Compose rilasciato come `febe-compose-X.Y.Z.tar.gz` con `chromium/seccomp.json` | Il percorso relativo del profilo resta valido (pkg-4) |
|
||||
| 2026-10-13 | `torna` della pagina di accesso: solo un percorso che inizia con una sola `/`, senza backslash, spazi o caratteri di controllo, verificato sul server (`LoginReturn`) e nella pagina, che va all'indirizzo assoluto dello stesso sito | Reindirizzamento aperto con `/\host` (websec-2, web-8) |
|
||||
| 2026-10-13 | Cookie `Secure` anche quando il proxy fidato (`FEBE_PROXY_FIDATO`) dice `X-Forwarded-Proto: https` | Dietro il proxy con HTTPS il cookie non era mai `Secure` (websec-3) |
|
||||
| 2026-10-13 | Lasciare la pagina Browser, o Collegamento durante l'accesso, senza «Ho finito»/«Annulla» vale come «Annulla»: l'interfaccia manda `POST /api/connection/cancel` uscendo e su `pagehide`; il `begin` seguente aspetta quella richiesta | Il permesso preso da `begin` non scade; `cancel` esiste già e rimette il browser sulla pagina vuota (§6.1); nessun endpoint nuovo né cambio di `IConnectionService` |
|
||||
| 2026-10-13 | `fetch` con `keepalive` invece di `navigator.sendBeacon` | Con `Referrer-Policy: no-referrer` un beacon (no-cors) parte con `Origin: null` e il controllo di §13.1 lo rifiuta |
|
||||
| 2026-10-13 | Su Windows «Usa il browser» del pannello «collegato» non si restituisce uscendo dalla pagina | La finestra del browser è a parte e Alberto può usarla mentre guarda altre pagine; va legata alla finestra dal lato server |
|
||||
| 2026-10-13 | Dopo «Ho finito» riuscito durante una verifica: pannello «Hai finito con il browser» con «Riapri il browser», senza vista né nuovo `begin`; aggiornamento dopo «Riprendi» solo se la striscia rossa era stata vista | La vista aperta tiene fermo il motore; mai riprendere il browser da soli |
|
||||
| 2026-10-13 | Vista remota: AltGr (Option su Mac) con un carattere → messaggio `char` senza Ctrl/Alt; Alt da solo su Windows/Linux resta scorciatoia; cattura del puntatore e rilascio dei pulsanti alla perdita della cattura o del fuoco | «@ # [ ] €» sulla tastiera italiana; un pulsante restava premuto sul server |
|
||||
| 2026-10-13 | Orari futuri dei fermi per rallentamento sempre «verso le»; `ItalianText.AtDay` resta ma non è più usato | §10.4 senza eccezioni; striscia e riquadro di stato davano lo stesso orario in due modi |
|
||||
| 2026-10-13 | `AccountSettingsMapper.ToDto(account, zone)`: «Da una data» come giorno locale | Il giorno UTC dell'inizio del giorno locale era un giorno prima in Europe/Rome e ogni salvataggio lo spostava indietro |
|
||||
| 2026-10-13 | `PageFrame`: dopo l'uscita `onEngine`/`onLibrary` non si iscrivono e `onLeave` esegue subito | Nulla registrato in ritardo sopravvive alla pagina |
|
||||
| 2026-10-13 | Riquadro di stato senza nome dell'account: avatar segnaposto, stato del collegamento e «Nome non ancora noto» | Niente «@null» prima del primo giro |
|
||||
| 2026-10-13 | Prove dell'interfaccia in un Chromium senza finestra guidato col protocollo DevTools diretto (`UiBrowser`, solo 127.0.0.1), inconcludenti senza Chromium | Come `tools/schermate`; il client CDP di Febe accetta solo letture |
|
||||
| 2026-10-14 | Revisione avversaria di tutto il codice (7 aree, ogni rilievo verificato da un secondo revisore indipendente): 54 rilievi confermati e corretti con prove di regressione, 2 smentiti, 3 incerti corretti dove il rimedio era sicuro | §14, regola 14: resoconti onesti |
|
||||
| 2026-10-14 | Restano noti e accettati: «Tieni il più grande» scrive con il proprio SafeFileWriter e non passa dal lucchetto per account di `LibraryIngest` (un'importazione e uno scaricamento con gli stessi byte nello stesso istante potrebbero entrare entrambi); le prove d'interfaccia con browser vero aspettano fino a 30 s | Finestra rarissima, nessuna perdita di dati: al più un doppione esatto da togliere a mano |
|
||||
@@ -0,0 +1,207 @@
|
||||
# Febe in Docker (e su Unraid)
|
||||
|
||||
La veste Docker di Febe (specifica §11): un solo contenitore con l'interfaccia web, il motore, un Chromium vero su un
|
||||
display virtuale (Xvfb) e la libreria su disco. Si usa dal browser di casa; il browser di Febe si vede e si usa dalla
|
||||
**vista remota** della pagina Impostazioni ▸ Collegamento.
|
||||
|
||||
> **Prima di tutto.** Scaricare con un programma è contro le condizioni d'uso di Instagram. Febe va piano per ridurre il
|
||||
> rischio per l'account (ritmo umano, tetti, fermo al primo segnale), ma non può azzerarlo.
|
||||
|
||||
## Che cosa c'è nell'immagine
|
||||
|
||||
- Debian stabile ridotta (`debian:trixie-slim`). Su Ubuntu il pacchetto Chromium è uno snap e nei contenitori non funziona.
|
||||
- Febe pubblicato **autosufficiente** per `linux-x64`: nell'immagine non c'è il runtime .NET.
|
||||
- `chromium` e `chromium-l10n`, `xvfb`, `ffmpeg` (miniature dei video importati), ICU, caratteri di sistema con le emoji
|
||||
(`fonts-noto-color-emoji`, `fonts-liberation`, `fonts-dejavu-core`), certificati, `tzdata`, la lingua `it_IT.UTF-8` generata.
|
||||
- `tini` come processo 1 (inoltra lo stop a Febe e raccoglie i processi di Chromium rimasti orfani) e `setpriv` per
|
||||
scendere all'utente `PUID`/`PGID`. Nessuno script fa da supervisore: è Febe ad avviare e riavviare Xvfb e Chromium.
|
||||
- Un file di criteri di Chromium (`/etc/chromium/policies/managed/febe.json`) che spegne il salvataggio delle password e
|
||||
la compilazione automatica: con l'archivio di base finirebbero in chiaro nel profilo. Nel profilo resta solo la sessione.
|
||||
- L'immagine si costruisce solo con le prove verdi: la compilazione e tutte le prove girano dentro la costruzione
|
||||
(quelle con il browser vero lì si saltano da sole, perché nello stadio di compilazione non ci sono Chromium e Xvfb;
|
||||
girano nella CI e in sviluppo).
|
||||
|
||||
## Volumi
|
||||
|
||||
| Volume | Uso | Dove metterlo |
|
||||
|---|---|---|
|
||||
| `/dati` | Database (`febe.sqlite`), **profilo del browser con la sessione di Instagram** (`browser/`), miniature, copie giornaliere del database (`copie/`, sette giorni), registro (`registro/`, quattordici giorni), file temporanei | Su un **disco locale** del server. Su Unraid: `/mnt/user/appdata/febe` (la cartella delle applicazioni sul disco di cache). Mai una condivisione di rete: SQLite e il profilo del browser lì si rovinano, e Febe si rifiuta di partire |
|
||||
| `/libreria` | Foto e video, una cartella per account, con `_febe.jsonl` | Dove vuoi, anche su una condivisione. Febe non cancella e non sostituisce mai un file da solo |
|
||||
| `/importa` | Cartelle da importare (pagina Importa) | **Sempre in sola lettura** (`:ro`): Febe copia, gli originali non si toccano |
|
||||
|
||||
## Variabili
|
||||
|
||||
| Variabile | Significato | Predefinito |
|
||||
|---|---|---|
|
||||
| `FEBE_PASSWORD` | Password dell'interfaccia. **Obbligatoria**: senza, il motore e il browser non partono e l'interfaccia mostra solo la pagina che spiega il problema | nessuno |
|
||||
| `FEBE_PORTA` | Porta dell'interfaccia dentro il contenitore | 8480 |
|
||||
| `TZ` | Fuso orario: fascia del motore, date nei nomi dei file, fuso dichiarato dal browser | Europe/Rome |
|
||||
| `LANG` | Lingua del contenitore e quindi del browser | it_IT.UTF-8 |
|
||||
| `PUID`, `PGID` | Utente e gruppo con cui gira Febe e di cui sono i file | 99, 100 (Unraid) |
|
||||
| `FEBE_HOST` | Facoltativa: i nomi con cui raggiungi l'interfaccia, separati da virgole (`tower.local,192.168.1.10`). Se c'è, ogni altro nome è rifiutato (oltre a 127.0.0.1 per il controllo di salute) | qualunque nome |
|
||||
| `FEBE_PROXY_FIDATO` | `1` se davanti c'è un proxy con HTTPS che passa `X-Forwarded-Host` e `X-Forwarded-Proto`: il controllo dell'origine usa quel nome, e quando il proxy dice `https` il cookie di sessione è `Secure` (il browser non lo manda mai in chiaro) | spenta |
|
||||
| `FEBE_SENZA_SANDBOX` | `1` avvia Chromium con `--no-sandbox`: è il compromesso descritto sotto, da usare solo se il profilo seccomp non si può usare | spenta |
|
||||
| `FEBE_CHROMIUM`, `FEBE_PORTA_DEBUG`, `FEBE_DISPLAY` | Avanzate: eseguibile di Chromium, porta di debug (sempre su 127.0.0.1), display di Xvfb | `/usr/bin/chromium`, 9222, `:99` |
|
||||
|
||||
La password dell'interfaccia non si passa mai sulla riga di comando e non finisce nei registri.
|
||||
|
||||
## Porte
|
||||
|
||||
Si pubblica **solo** la porta dell'interfaccia (8480). La porta di debug del browser (9222) ascolta solo su `127.0.0.1`
|
||||
dentro il contenitore: non va mai pubblicata, e Febe si rifiuta di usare il browser se la trova aperta altrove.
|
||||
|
||||
## Utente: PUID e PGID
|
||||
|
||||
L'avvio crea, se mancano, il gruppo `PGID` e l'utente `PUID`, assegna `/dati` a quell'utente (la prima volta, o quando
|
||||
cambi PUID/PGID: allora anche il contenuto) e passa a quell'utente con `setpriv`. `/libreria` non viene mai cambiata
|
||||
ricorsivamente: se Febe non riesce a scriverci, il registro lo dice. Febe **non gira come root**: con `PUID=0` il
|
||||
contenitore si ferma con un messaggio.
|
||||
|
||||
## Sandbox di Chromium (S5)
|
||||
|
||||
Esito della prova del 13 ottobre 2026 (dettagli in `docker/chromium/LEGGIMI.md`):
|
||||
|
||||
- come utente normale, **fuori** da Docker, la sandbox di Chromium parte da sola (spazi dei nomi utente);
|
||||
- **dentro** Docker, con il profilo seccomp predefinito, Chromium non parte affatto: `No usable sandbox!`. Il profilo
|
||||
di Docker vieta la creazione di spazi dei nomi utente a chi non ha `CAP_SYS_ADMIN`;
|
||||
- con il **profilo seccomp dedicato** di Febe (`docker/chromium/seccomp.json`: quello di Docker più `clone` e
|
||||
`unshare`) la sandbox è completa (`chrome://sandbox`: «You are adequately sandboxed») e il resto del filtro di Docker
|
||||
resta attivo. **È l'impostazione consigliata**, già scritta in `compose.yml` e nel modello di Unraid.
|
||||
|
||||
Docker legge il profilo **sul server**, quando crea il contenitore. Per questo il file sta **fuori dal volume `/dati`**:
|
||||
`/dati` è dell'utente del contenitore, e un file lì dentro potrebbe essere cambiato da chi riuscisse a far eseguire
|
||||
qualcosa a quell'utente (per esempio attraverso un difetto del browser), che allenterebbe così il proprio filtro alla
|
||||
ricreazione successiva. L'immagine contiene il profilo in `/usr/share/febe/seccomp.json`, solo da leggere; lo si
|
||||
estrae una volta (vedi Unraid, sotto) o si usa quello di `docker/chromium/` accanto a `compose.yml`. Il contenitore non
|
||||
lo tocca: si ripete l'estrazione solo quando le note di una versione lo chiedono.
|
||||
|
||||
Le prime anteprime copiavano il profilo in `/dati/seccomp.json` a ogni avvio: se «Extra Parameters» indica ancora
|
||||
quel file, estrai il profilo nel posto nuovo e correggi il percorso (il registro del contenitore lo ricorda a ogni
|
||||
avvio).
|
||||
|
||||
Se il profilo dedicato non si può usare, le alternative sono due, in quest'ordine:
|
||||
|
||||
1. `--security-opt seccomp=unconfined`: la sandbox di Chromium resta attiva, ma il contenitore perde tutto il filtro
|
||||
seccomp di Docker.
|
||||
2. `FEBE_SENZA_SANDBOX=1`: Chromium parte con `--no-sandbox`. **È un compromesso**: una pagina che sfruttasse un
|
||||
difetto del browser non troverebbe la sandbox di Chromium a fermarla, solo i limiti del contenitore. Si accetta
|
||||
soltanto perché quel browser visita esclusivamente Instagram, e solo se le due strade sopra non sono possibili.
|
||||
Chromium mostra anche una barra d'avviso in alto, che toglie circa 50 pixel alla pagina.
|
||||
|
||||
Febe non sceglie da solo: se Chromium non parte, il registro dice perché e rimanda a questa sezione.
|
||||
|
||||
## Sicurezza: da leggere prima di installare
|
||||
|
||||
- **Mai esporre l'interfaccia su Internet** senza una VPN (per esempio WireGuard o Tailscale) o un proxy con HTTPS
|
||||
davanti. Dalla vista remota passa **la password di Instagram**: in Docker tasti, password e codici di Alberto
|
||||
attraversano la rete di casa e la memoria del server per arrivare al browser di Febe. Non vengono registrati né
|
||||
conservati, ma su HTTP in chiaro sono leggibili da chi sta sulla stessa rete.
|
||||
- **Chi ha `/dati`, o una sua copia, ha la sessione di Instagram.** Vale anche per le copie di sicurezza della cartella
|
||||
delle applicazioni (per esempio il plugin di backup di Unraid): trattale come una password.
|
||||
- **Contenitore e Febe per Windows non vanno usati insieme sullo stesso account.** Un account, un motore: due Febe che
|
||||
raccolgono con lo stesso account sommano le visite e raddoppiano il rischio.
|
||||
- La sessione nasce e resta nel browser del contenitore: i cookie non si copiano da un'altra macchina.
|
||||
- L'interfaccia è protetta da password (cookie di sessione `HttpOnly`, `SameSite=Strict`, `Secure` quando arrivi in
|
||||
HTTPS, anche attraverso il proxy fidato; blocco dopo tentativi ripetuti); ogni comando e l'apertura della vista
|
||||
remota controllano che la richiesta arrivi dall'interfaccia stessa. Dopo la password, la pagina di accesso torna
|
||||
solo a una pagina di Febe, mai a un altro sito.
|
||||
|
||||
## Installazione su Unraid
|
||||
|
||||
1. L'immagine è `192.168.30.23:3000/alby96/febe:latest`, sul registro dei container del Gitea di casa (lo stesso su
|
||||
cui la pubblica il rilascio). Il registro risponde in **HTTP**: il Docker di Unraid deve averlo fra gli
|
||||
`insecure-registries`, come per le altre immagini di casa (Encelado, Mimante). Se Unraid scarica già quelle, è a
|
||||
posto; altrimenti aggiungi `"insecure-registries": ["192.168.30.23:3000"]` alla configurazione del demone Docker e
|
||||
riavvia Docker. Se il pacchetto non è pubblico, accedi dal terminale: `docker login 192.168.30.23:3000`.
|
||||
2. Dal terminale di Unraid, **una volta sola**, estrai il profilo seccomp dall'immagine e mettilo dove il modello lo
|
||||
cerca, **fuori** dalla cartella dei dati:
|
||||
|
||||
```sh
|
||||
docker run --rm --entrypoint cat 192.168.30.23:3000/alby96/febe:latest \
|
||||
/usr/share/febe/seccomp.json > /mnt/user/appdata/febe-seccomp.json
|
||||
```
|
||||
|
||||
3. Docker ▸ Aggiungi contenitore ▸ modello da `docker/unraid/febe.xml` (o dal suo indirizzo,
|
||||
`http://192.168.30.23:3000/Alby96/Febe/raw/branch/main/docker/unraid/febe.xml`). Controlla:
|
||||
- porta 8480;
|
||||
- `/dati` su `/mnt/user/appdata/febe` (disco di cache);
|
||||
- `/libreria` dove vuoi le foto; `/importa` in sola lettura;
|
||||
- **password dell'interfaccia** (obbligatoria, nascosta);
|
||||
- `TZ`, `PUID` 99, `PGID` 100 tra le impostazioni avanzate;
|
||||
- in «Extra Parameters»: `--restart=unless-stopped --stop-timeout 30 --security-opt seccomp=/mnt/user/appdata/febe-seccomp.json`.
|
||||
4. Apri `http://<IP di Unraid>:8480/`, entra con la password, vai in Impostazioni ▸ Collegamento ▸ «Accedi a
|
||||
Instagram»: la vista remota mostra la vera pagina di accesso; scrivi tu nome utente, password ed eventuale codice,
|
||||
poi «Ho finito». Febe comincia qualche minuto dopo, con l'avvio graduale.
|
||||
5. Il collegamento sopravvive ai riavvii: la sessione resta nel profilo del browser in `/dati/browser`.
|
||||
|
||||
## Docker Compose
|
||||
|
||||
`docker/compose.yml` è un esempio pronto: immagine, porta, volumi (con `/importa` in sola lettura), variabili, profilo
|
||||
seccomp con percorso relativo al file (`chromium/seccomp.json`, fuori da `/dati`), `restart: unless-stopped`, 30
|
||||
secondi per fermarsi. `init: true` non serve (c'è già `tini`) e nemmeno `shm_size` (Chromium usa `/tmp` al posto della
|
||||
memoria condivisa). Anche qui il registro `192.168.30.23:3000` deve stare fra gli `insecure-registries` del Docker.
|
||||
|
||||
```sh
|
||||
FEBE_PASSWORD='una frase lunga' docker compose -f docker/compose.yml up -d
|
||||
```
|
||||
|
||||
Fuori dal repository si usa l'archivio `febe-compose-X.Y.Z.tar.gz` allegato alla release: contiene `compose.yml` e,
|
||||
accanto, `chromium/seccomp.json`.
|
||||
|
||||
```sh
|
||||
tar -xzf febe-compose-X.Y.Z.tar.gz && cd febe-compose-X.Y.Z
|
||||
FEBE_PASSWORD='una frase lunga' docker compose up -d
|
||||
```
|
||||
|
||||
## Salute
|
||||
|
||||
`GET /salute` risponde senza password `{"stato":"ok"}` (200) oppure `{"stato":"problema"}` (503) quando un problema di
|
||||
configurazione ferma Febe (password mancante, `/dati` non scrivibile o su un disco di rete). L'immagine ha un
|
||||
`HEALTHCHECK` che lo chiede ogni 30 secondi con il programma stesso (`/app/febe --controllo-salute`: nell'immagine non
|
||||
c'è curl). Unraid mostra lo stato accanto al contenitore; da terminale: `docker inspect --format '{{.State.Health.Status}}' febe`.
|
||||
|
||||
## Problemi comuni
|
||||
|
||||
| Che cosa vedi | Che cosa fare |
|
||||
|---|---|
|
||||
| L'interfaccia mostra solo una pagina «Manca la password dell'interfaccia» | Imposta `FEBE_PASSWORD` e riavvia il contenitore |
|
||||
| «La cartella dei dati è su un disco di rete» o «non può scrivere» | Collega `/dati` a una cartella su un disco locale (su Unraid l'appdata sul disco di cache) e controlla PUID/PGID |
|
||||
| Nel registro: «Il browser non parte… No usable sandbox» | Manca il profilo seccomp: vedi «Sandbox» sopra |
|
||||
| Unraid non crea il contenitore: «opening seccomp profile … no such file» | Manca `/mnt/user/appdata/febe-seccomp.json`: passo 2 dell'installazione |
|
||||
| Unraid non scarica l'immagine: «http: server gave HTTP response to HTTPS client» | Il registro `192.168.30.23:3000` non è fra gli `insecure-registries`: passo 1 dell'installazione |
|
||||
| La porta è occupata | Cambia la porta pubblicata (o `FEBE_PORTA`) |
|
||||
|
||||
Il registro di Febe è in `/dati/registro/febe-AAAA-MM-GG.log` e nell'output del contenitore (`docker logs febe`).
|
||||
Contiene azioni ed esiti, nomi utente sì; mai password, cookie, tasti, didascalie, corpi delle risposte né indirizzi
|
||||
firmati del CDN.
|
||||
|
||||
## Arresto e aggiornamento
|
||||
|
||||
- Allo stop (`docker stop`, aggiornamento, riavvio di Unraid) Febe chiude la vista remota, ferma il motore (la sessione
|
||||
in corso si chiude), poi Chromium con SIGINT, così la sessione di Instagram è scritta nel profilo, poi Xvfb. Lascia 30
|
||||
secondi (`--stop-timeout 30`, `stop_grace_period: 30s`); di solito ne bastano pochi.
|
||||
- **Aggiornare**: scarica la nuova immagine e ricrea il contenitore (su Unraid «Force update» o «Check for updates»).
|
||||
`/dati` e `/libreria` restano; il database si aggiorna da solo all'avvio (migrazioni numerate, in una transazione).
|
||||
Per sicurezza, prima di un aggiornamento importante puoi copiare a mano `/dati/febe.sqlite` a contenitore fermo.
|
||||
- Copie del database: una al giorno in `/dati/copie/febe-AAAA-MM-GG.sqlite`, sette giorni. Per tornare indietro:
|
||||
ferma il contenitore, sostituisci `/dati/febe.sqlite` con una copia, riavvia. Se il database va perso, la pagina
|
||||
Impostazioni ▸ Dati lo ricostruisce dalla libreria (`_febe.jsonl`) senza riscaricare nulla.
|
||||
|
||||
## Sviluppo senza Docker
|
||||
|
||||
Il server si avvia anche fuori dal contenitore, contro il sito di prova locale invece di Instagram (regola 1: mai
|
||||
Instagram dalle prove):
|
||||
|
||||
```sh
|
||||
dotnet run --project tools/Febe.SitoDiProva -- --porta 8481 --porta-cdn 8482
|
||||
FEBE_PASSWORD=prova dotnet run --project src/Febe.Server -- \
|
||||
--dati /tmp/febe/dati --libreria /tmp/febe/libreria --importa /tmp/febe/importa --ascolta 127.0.0.1 \
|
||||
--sito-di-prova http://127.0.0.1:8481 --accesso-di-prova --prima-sessione 5
|
||||
```
|
||||
|
||||
- `--sito-di-prova` accetta solo indirizzi di questo computer; il «CDN» è `127.0.0.2` sulla porta successiva, oppure
|
||||
`--cdn-di-prova`. Mappe dei bersagli, lettori e segnali diventano quelli del sito di prova (`*.prova.json`).
|
||||
- `--accesso-di-prova` apre il sito una volta all'avvio, così il suo cookie di sessione esiste come dopo un accesso.
|
||||
- `--prima-sessione N` fa partire la prima sessione dopo N secondi invece di 2–10 minuti.
|
||||
- Come root servono `--senza-sandbox` (Chromium lo pretende) e, se Chromium non è nel `PATH`, `FEBE_CHROMIUM`.
|
||||
- Prova d'insieme automatica: `dotnet test tests/Febe.Tests --filter "FullyQualifiedName~Febe.Tests.Server"`.
|
||||
@@ -0,0 +1,105 @@
|
||||
# Account e impostazioni
|
||||
|
||||
La pagina **Account** elenca i profili che Febe archivia: che cosa raccoglie per ciascuno, lo stato, l'ultimo e il
|
||||
prossimo controllo, quanti elementi sono in libreria, l'interruttore «Tieni aggiornato». Un clic sulla riga apre la
|
||||
scheda dell'account.
|
||||
|
||||
Un **elemento** è una pubblicazione (un post anche con più foto e video, una storia, un contenuto di una raccolta in
|
||||
evidenza); un **file** è ogni singola foto o video. I contatori contano elementi.
|
||||
|
||||
## Aggiungere account
|
||||
|
||||
«Aggiungi account» apre una finestra con due linguette:
|
||||
|
||||
- **Dai profili che segui:** l'elenco dei profili che segui, letto da Febe a ritmo umano e dentro i tetti. La prima
|
||||
volta va letto («Leggi l'elenco»): può servire più di una sessione, e la finestra dice a che punto è («Letti 96
|
||||
profili, continuo alla prossima sessione»). L'elenco resta in memoria con la data di lettura e si rilegge solo se lo
|
||||
chiedi. I profili già presenti in Febe sono attenuati.
|
||||
- **Per nome utente:** scrivi o incolla nomi utente o indirizzi di profilo, uno per riga (`nome.utente`,
|
||||
`@nome.utente` oppure `instagram.com/nome.utente`). Serve per i profili pubblici che non segui.
|
||||
|
||||
A destra scegli il **punto di partenza**, che poi puoi cambiare account per account:
|
||||
|
||||
| Punto di partenza | Tieni aggiornato | Che cosa scarica | Quanto indietro |
|
||||
|---|---|---|---|
|
||||
| Scarica tutto e tieni aggiornato | sì | foto, video, storie, evidenza, foto del profilo | quello che scegli in «Quanto indietro nel tempo» (tutto, ultimi 50, 200 o 1.000 post, dall'inizio dell'anno) |
|
||||
| Solo le novità da oggi | sì | gli stessi | dalla data di oggi, niente storico |
|
||||
| Solo le storie | sì | storie e storie in evidenza | — |
|
||||
|
||||
Valori comuni: frequenza Normale; «Post in cui è taggato» spento (acceso solo per il tuo profilo); storico al giorno
|
||||
secondo il profilo di prudenza (300 post con «Prudente»); nessun limite alla dimensione dei video; video delle storie
|
||||
compresi; cartella predefinita. Lo storico arriva poco per volta; i primi controlli partono alla prossima sessione,
|
||||
dentro la fascia oraria.
|
||||
|
||||
## Stati di un account
|
||||
|
||||
| Stato | Che cosa significa |
|
||||
|---|---|
|
||||
| Aggiornato | Febe lo controlla secondo la sua frequenza |
|
||||
| Storico in corso | Febe sta scaricando i contenuti passati, un po' al giorno |
|
||||
| In pausa | Messo in pausa da te, oppure scaricato una volta con «Tieni aggiornato» spento |
|
||||
| Solo archivio | Vive solo in libreria e non viene mai contattato (gli account creati dall'importazione, o quelli che congeli) |
|
||||
| Non raggiungibile | Privato e non lo segui, non esiste più, non è visibile, o ha cambiato nome |
|
||||
|
||||
Il filtro **«Da controllare»** raccoglie gli account che chiedono attenzione: non raggiungibili, con nome cambiato, con
|
||||
risposte in un formato non riconosciuto. Le etichette sono neutre: «Tu», «Seguito», «Non seguito», «Privato»,
|
||||
«Pubblico».
|
||||
|
||||
Un account è riconosciuto dal suo identificativo numerico, non dal nome. Se un profilo che segui cambia nome, Febe lo
|
||||
scopre dai dati che riceve, aggiorna il nome, tiene la cartella e lo segnala. Un profilo che non segui e cambia nome
|
||||
risulta «Non raggiungibile»: puoi indicare il nuovo nome.
|
||||
|
||||
## La scheda di un account
|
||||
|
||||
Tre linguette: **Contenuti** (Post, Storie, In evidenza raggruppati per raccolta, Taggati, e Profilo se ci sono più
|
||||
foto del profilo), **Impostazioni** e **Cronologia** (i controlli con il loro esito).
|
||||
|
||||
### Impostazioni dell'account
|
||||
|
||||
- **Tieni aggiornato:** con «no» Febe fa un solo scaricamento, poi mette l'account in pausa.
|
||||
- **Frequenza dei controlli:** Bassa, Normale, Alta oppure Su misura (ogni quante ore controllare i post e l'intervallo
|
||||
massimo fra due controlli delle storie).
|
||||
|
||||
| Frequenza | Profilo che non segui: controllo | Profilo che segui: riconciliazione | Storie: al massimo ogni |
|
||||
|---|---|---|---|
|
||||
| Bassa | circa ogni 12 ore | ogni 24 ore | 8 ore |
|
||||
| Normale | circa ogni 3 ore | ogni 12 ore | 6 ore |
|
||||
| Alta | circa ogni 75 minuti | ogni 6 ore | 3 ore |
|
||||
|
||||
I profili che segui si scoprono soprattutto con il giro della pagina iniziale: il controllo del profilo serve solo a
|
||||
recuperare ciò che il giro può aver perso. Con «Storie» attivo ogni account riceve almeno tre controlli al giorno
|
||||
dentro la fascia.
|
||||
- **Cosa scaricare:** Foto dei post, Video e reel, Storie, Storie in evidenza, Post in cui è taggato, Foto del profilo.
|
||||
Quello che togli resta in libreria, ma non viene più aggiornato.
|
||||
- **Limiti per questo account:** quanto indietro nel tempo (tutto, gli ultimi N post, da una data); massimo di post di
|
||||
storico al giorno; dimensione oltre la quale un video si salta (vuoto: nessun limite); video delle storie sì o no.
|
||||
Valgono insieme ai limiti generali: vince sempre il più stretto.
|
||||
- **Cartella:** di solito una cartella con il nome dell'account dentro la libreria. Su Windows se ne può scegliere
|
||||
un'altra, anche fuori dalla libreria; in Docker le cartelle si cambiano dal contenitore.
|
||||
|
||||
Il riquadro **«Con queste impostazioni»** a destra traduce le scelte in conseguenze e si ricalcola a ogni modifica:
|
||||
ogni quanto verrà controllato davvero, quanti giorni richiede lo storico (quando il numero dei post è noto), quanto
|
||||
pesa sul tetto giornaliero. Le modifiche valgono quando premi «Salva le impostazioni».
|
||||
|
||||
### Le storie risultano viste
|
||||
|
||||
Febe salva le storie solo dopo averle **aperte** nel visualizzatore, come una visita normale: **le storie aperte da
|
||||
Febe risultano viste** e tu compari tra gli spettatori. Non esiste una visione anonima. Per un account in cui non vuoi
|
||||
comparire, spegni «Storie» (e «Storie in evidenza», che si aprono allo stesso modo).
|
||||
|
||||
## Comandi
|
||||
|
||||
- **Controlla ora:** mette quel controllo in cima alla coda. Passa comunque dai tetti: se il tetto è esaurito Febe lo
|
||||
dice e non lo fa. Fuori dalla fascia oraria chiede conferma e, avutala, esegue quel solo controllo: è l'unico caso in
|
||||
cui Febe lavora fuori fascia, perché ci sei tu.
|
||||
- **Metti in pausa / Riattiva** l'account.
|
||||
- **Apri su Instagram:** apre il profilo nel tuo browser, non in quello di Febe.
|
||||
- **Rimuovi…:** chiede sempre che cosa fare dei file. Il predefinito è **tenerli**: l'account diventa «Solo archivio» e
|
||||
non viene più contattato. «Elimina anche i file» li cancella dal disco, e non si recuperano.
|
||||
|
||||
## «Appena pubblicato» vuol dire «entro la sessione successiva»
|
||||
|
||||
Febe non lavora in tempo reale. Con il profilo «Prudente», per gli account che segui un contenuto nuovo arriva di
|
||||
norma fra 20 e 90 minuti dopo la pubblicazione, dentro la fascia oraria; per quelli che non segui, secondo la
|
||||
frequenza. Di notte Febe non lavora. Se gli account e le frequenze chiesti superano ciò che i tetti consentono, i
|
||||
controlli si diradano, non si forzano. Vedi [Limiti e comportamento](Limiti-e-comportamento).
|
||||
@@ -0,0 +1,82 @@
|
||||
# Attività e arresti
|
||||
|
||||
## La pagina Attività
|
||||
|
||||
**Attività** è il cruscotto del motore. Si aggiorna da sola.
|
||||
|
||||
- **Adesso:** che cosa sta facendo Febe («In sessione», «In ascolto», «Fuori fascia», «In pausa», «Fermo»), quando
|
||||
riprende, e un'**anteprima del browser** di Febe (un fotogramma ogni pochi secondi, non un video; la pagina vuota fra
|
||||
una sessione e l'altra).
|
||||
- **Oggi:** la striscia della giornata, 24 ore con le sessioni come tratti, il riposo, i rallentamenti e gli arresti,
|
||||
e le prossime sessioni con orario indicativo. Gli orari futuri si scrivono sempre «verso le», perché sono estratti a
|
||||
caso.
|
||||
- **Limiti di oggi:** profili aperti, storie viste, pagine di storico, dati scaricati, con i numeri; «Tutti i tetti»
|
||||
apre l'elenco completo (orari e giornalieri). Ambra sopra l'80%.
|
||||
- **In coda** (con orari indicativi) e **Appena fatto** (le ultime ricette con l'esito).
|
||||
- **Arresti e rallentamenti** degli ultimi 14 giorni, con segnale, pagina, durata e quando si sono risolti.
|
||||
- **Avvisi** degli ultimi 14 giorni: verifiche, disconnessioni, fermi e riprese, storici completati, dischi quasi
|
||||
pieni, formati non riconosciuti, e gli avvisi che non sono arrivati (vedi [Avvisi e Telegram](Avvisi-e-Telegram)).
|
||||
|
||||
Comandi: **«Metti in pausa»** (Febe non apre nulla finché non premi «Riprendi»), **«Riprendi»**, **«Apri il
|
||||
browser»**.
|
||||
|
||||
## La striscia rossa
|
||||
|
||||
Quando Febe è fermo e serve te, in cima a **tutte le pagine** compare una striscia: rossa per una verifica o una
|
||||
disconnessione, ambra per un fermo per rallentamento. Dice che cosa è successo, che cosa ha fatto Febe e che cosa devi
|
||||
fare, con «Apri il browser» e, quando serve, «Riprendi». Nella barra laterale il riquadro dello stato dice «Fermo,
|
||||
serve il tuo intervento».
|
||||
|
||||
## I tre livelli di arresto
|
||||
|
||||
| Livello | Quando | Che cosa fa Febe |
|
||||
|---|---|---|
|
||||
| **Rallentamento** | Instagram risponde «troppe richieste» (429) o chiede di attendere; pagine o risposte vuote ripetute | Chiude subito la sessione. Fermo di 1 ora la prima volta, 6 ore la seconda nelle 24 ore, 24 ore la terza. Poi tetti dimezzati per 48 ore. Riparte da solo |
|
||||
| **Verifica** | La pagina va verso una verifica, un controllo o una sospensione; avviso di comportamento automatico; richiesta di confermare l'identità | Ferma tutto e **non riparte da solo**. Striscia rossa, avvisi, pagina lasciata com'è |
|
||||
| **Disconnessione** | La pagina torna all'accesso; il cookie di sessione non c'è più | Come la verifica. **Non tenta mai di rientrare** |
|
||||
|
||||
Durante un fermo gli scaricamenti già in coda dal CDN si completano; verso il sito non parte nulla. Ogni arresto è
|
||||
registrato con data, livello, segnale e pagina.
|
||||
|
||||
## Che cosa fare dopo una verifica
|
||||
|
||||
1. **Non avere fretta.** Febe è fermo e resta fermo: non c'è nulla che peggiori aspettando.
|
||||
2. Premi **«Apri il browser»** nella striscia rossa (in Docker si apre la pagina «Browser» con la vista remota; su
|
||||
Windows la finestra «Browser di Febe» viene in primo piano). Mentre usi il browser il motore resta fermo.
|
||||
3. Nella pagina che Febe ha lasciato com'era, **completa la verifica a mano**: codice, conferma dell'identità, quello
|
||||
che Instagram chiede. Febe non risolve mai verifiche, CAPTCHA o codici in automatico.
|
||||
4. Controlla che Instagram funzioni normalmente nel browser (la tua pagina iniziale si apre), poi premi **«Ho
|
||||
finito»**.
|
||||
5. Premi **«Riprendi»**. Si attiva solo dopo che hai usato il browser.
|
||||
6. Febe riparte con l'**avvio graduale**: tetti dalla metà, che risalgono nei giorni del profilo.
|
||||
|
||||
Se le verifiche si ripetono, prima di riprendere riduci il carico: profilo più prudente, meno account, frequenze più
|
||||
basse (vedi [Limiti e comportamento](Limiti-e-comportamento)). Se Instagram ha sospeso o limitato l'account, non
|
||||
riprendere: lascia Febe in pausa.
|
||||
|
||||
## Che cosa fare dopo una disconnessione
|
||||
|
||||
1. «Apri il browser»: la pagina mostra l'accesso di Instagram.
|
||||
2. Accedi a mano (nome utente, password, eventuale codice), aspetta la pagina iniziale, «Ho finito».
|
||||
3. «Riprendi». Anche qui riparte l'avvio graduale.
|
||||
|
||||
Se non sei stato tu a chiudere la sessione (per esempio uscendo da Instagram su tutti i dispositivi), controlla la
|
||||
sicurezza del tuo account dall'app di Instagram prima di riprendere.
|
||||
|
||||
## Che cosa fare dopo un rallentamento
|
||||
|
||||
- **Niente, nell'immediato.** Febe ha già chiuso la sessione e si è fermato per il tempo fisso (1, 6 o 24 ore); poi
|
||||
riparte da solo con i tetti dimezzati per 48 ore. «Riprendi» non accorcia un rallentamento.
|
||||
- Non usare in quelle ore il browser di Febe per «recuperare» a mano.
|
||||
- Guarda **Arresti e rallentamenti**: se i rallentamenti si ripetono, la pagina lo dice. **Tre rallentamenti in sette
|
||||
giorni**: Febe propone di passare al profilo più prudente o di ridurre gli account seguiti. Fallo: i tetti sono stime,
|
||||
e un rallentamento dice che per il tuo account sono troppo alti.
|
||||
|
||||
## Formato non riconosciuto e ricette sospese
|
||||
|
||||
Se Instagram cambia il formato delle sue risposte, Febe non fallisce in silenzio: registra «formato non riconosciuto»
|
||||
(con la sola struttura delle chiavi, senza valori) e l'account va fra quelli «Da controllare». **Tre casi di fila per
|
||||
la stessa ricetta la sospendono**, e Attività lo dice. Che cosa fare: raccogliere un campione nuovo con la sonda
|
||||
passiva (vedi [Ipotesi da verificare](Ipotesi-da-verificare) e [Sviluppo](Sviluppo)), aggiornare il lettore sulla copia
|
||||
ripulita, poi riattivare la ricetta da Attività. Allo stesso modo, se Febe non trova nella pagina un comando che gli
|
||||
serve («bersaglio non trovato»), si ferma e lo segnala, senza cliccare a caso.
|
||||
@@ -0,0 +1,118 @@
|
||||
# Avvisi e Telegram
|
||||
|
||||
Quando succede qualcosa che ti riguarda, Febe te lo dice. Si regola in **Impostazioni ▸ Notifiche**.
|
||||
|
||||
## Quali eventi
|
||||
|
||||
| Evento | Che cosa significa | Che cosa fare |
|
||||
|---|---|---|
|
||||
| Verifica richiesta | Instagram chiede una verifica: Febe ha fermato tutto e non riparte da solo | Apri il browser di Febe, completa la verifica, «Ho finito», «Riprendi» |
|
||||
| Disconnessione da Instagram | La sessione non c'è più: Febe ha fermato tutto e non prova a rientrare | Apri il browser, accedi a mano, «Ho finito», «Riprendi» |
|
||||
| Fermo per rallentamento e ripresa | Instagram ha chiesto di rallentare: Febe aspetta 1, 6 o 24 ore, poi riparte da solo (due avvisi: il fermo e la ripresa) | Niente; se succede spesso, un profilo più prudente o meno account |
|
||||
| Storico di un account completato | Tutti i contenuti passati di un account sono in libreria | Niente |
|
||||
| Disco quasi pieno | Sul disco della libreria o della cartella dei dati restano meno di 10 GB, o meno del 5% del disco | Libera spazio o sposta la cartella su un disco più capiente |
|
||||
| Formato non riconosciuto | Le risposte di Instagram sono cambiate; tre volte di fila sospendono la ricetta (un avviso a parte, «Ricetta sospesa») | Campione nuovo con la sonda, poi «Riattiva» in Attività |
|
||||
|
||||
Che cosa fare, nel dettaglio: [Attività e arresti](Attivita-e-arresti).
|
||||
|
||||
## Dove arrivano
|
||||
|
||||
- **Nell'interfaccia, sempre.** Una verifica, una disconnessione o un fermo mettono la striscia in cima a tutte le
|
||||
pagine; ogni avviso è anche una riga della sezione **«Avvisi»** di Attività (gli ultimi 14 giorni), compresi quelli
|
||||
che non sei riuscito a ricevere fuori da Febe.
|
||||
- **Notifiche di Windows**, nella versione per Windows, se «Notifiche di Windows» è acceso.
|
||||
- **Telegram**, facoltativo, se scrivi il gettone di un bot e l'identificativo della chat.
|
||||
|
||||
Gli interruttori di «Quando avvisarti» decidono che cosa ti raggiunge **fuori** da Febe; nell'interfaccia vedi
|
||||
comunque tutto.
|
||||
|
||||
## Telegram: creare il bot
|
||||
|
||||
Ti serve un bot tuo, che scrive solo a te. Si crea in un paio di minuti con **BotFather**, il bot ufficiale di
|
||||
Telegram per creare bot.
|
||||
|
||||
1. In Telegram cerca **@BotFather** (ha la spunta blu) e apri la chat. Premi **Avvia**.
|
||||
2. Scrivi `/newbot`.
|
||||
3. BotFather chiede il **nome** del bot (quello che vedi nella chat, per esempio `Febe di casa`) e poi il **nome
|
||||
utente**, che deve finire con `bot` (per esempio `febe_casa_alberto_bot`).
|
||||
4. BotFather risponde con il **gettone** (token) del bot: una riga come `123456789:AAH…` (cifre, due punti, poi una
|
||||
lunga serie di lettere). **È una password:** chi lo ha può scrivere a nome del bot. Non mandarlo a nessuno e non
|
||||
pubblicarlo.
|
||||
5. Apri la chat con il tuo nuovo bot (il collegamento è nel messaggio di BotFather), premi **Avvia** e scrivigli un
|
||||
messaggio qualsiasi, per esempio «ciao». Un bot non può scrivere per primo a chi non gli ha mai scritto.
|
||||
|
||||
## Telegram: trovare l'identificativo della chat
|
||||
|
||||
L'identificativo della chat è un numero (per una chat privata è il tuo identificativo di Telegram; per un gruppo è
|
||||
negativo, per esempio `-1001234567890`).
|
||||
|
||||
1. Dopo aver scritto al bot, apri nel **tuo** browser questo indirizzo, mettendo il gettone al posto di `GETTONE`:
|
||||
|
||||
```text
|
||||
https://api.telegram.org/botGETTONE/getUpdates
|
||||
```
|
||||
|
||||
2. Nella risposta cerca `"chat":{"id":` e copia il numero che segue (con il segno meno, se c'è).
|
||||
3. Se la risposta è vuota (`"result":[]`), scrivi un altro messaggio al bot e ricarica la pagina.
|
||||
|
||||
L'indirizzo contiene il gettone: non condividerlo e non farne schermate. Per usare un gruppo: aggiungi il bot al
|
||||
gruppo, scrivi un messaggio nel gruppo e cerca l'identificativo nello stesso modo.
|
||||
|
||||
## Telegram: collegarlo a Febe
|
||||
|
||||
1. In **Impostazioni ▸ Notifiche ▸ Telegram** incolla il **gettone del bot** e l'**identificativo della chat**.
|
||||
2. **Salva.**
|
||||
3. **«Invia una prova»**: nella chat del bot deve arrivare «Febe · Prova degli avvisi». Se non arriva, Febe dice
|
||||
perché (gettone non riconosciuto, chat non trovata, bot bloccato o mai avviato, Telegram non raggiungibile).
|
||||
|
||||
Il gettone resta nella cartella dei dati di Febe: non torna mai all'interfaccia (dopo il salvataggio il campo dice solo
|
||||
«Gettone salvato»), non finisce nei registri e non compare negli errori. Per cambiarlo scrivine uno nuovo; «Togli il
|
||||
gettone» lo cancella. Se pensi che qualcuno l'abbia visto, revocalo con BotFather (`/revoke`) e salva quello nuovo.
|
||||
|
||||
## Come sono fatti i messaggi
|
||||
|
||||
Brevi, in italiano: che cosa è successo, che cosa ha fatto Febe, che cosa devi fare. Per esempio:
|
||||
|
||||
```text
|
||||
Febe · Instagram chiede una verifica
|
||||
Ho fermato tutto alle 14:32 e non riparto da solo. Che cosa fare: apri Febe, poi il browser di Febe («Apri il
|
||||
browser»), completa la verifica a mano e premi «Riprendi».
|
||||
```
|
||||
|
||||
Contengono i nomi degli account (per esempio nello storico completato) e i dati di spazio del disco; mai didascalie,
|
||||
password, cookie, indirizzi o il gettone. Febe manda **una sola chiamata HTTPS** a `api.telegram.org` per ogni avviso,
|
||||
direttamente dal server (in Docker dal contenitore), senza librerie esterne, con un tempo massimo di 15 secondi.
|
||||
|
||||
## Niente raffiche
|
||||
|
||||
Uno stato che va e viene non ti manda lo stesso messaggio più volte. Lo stesso avviso non si ripete prima di:
|
||||
|
||||
| Avviso | Intervallo minimo |
|
||||
|---|---|
|
||||
| Verifica, disconnessione | 30 minuti |
|
||||
| Fermo per rallentamento, ripresa | 30 minuti |
|
||||
| Storico completato | 24 ore per lo stesso account |
|
||||
| Formato non riconosciuto, ricetta sospesa | 6 ore |
|
||||
| Disco quasi pieno | 20 ore per lo stesso disco (la riga in Attività torna ogni 24 ore finché il disco resta pieno) |
|
||||
|
||||
Gli orari dell'ultimo invio sono salvati: anche un riavvio non manda di nuovo lo stesso avviso. Un avviso trattenuto
|
||||
resta visibile nell'interfaccia.
|
||||
|
||||
## Quando un avviso non arriva
|
||||
|
||||
Se Telegram o Windows non accettano un avviso, Febe scrive una riga «Avviso non inviato» in Attività ▸ Avvisi con il
|
||||
motivo in italiano (al massimo una all'ora per canale; il registro le ha tutte). Non riprova da solo: l'avviso resta
|
||||
comunque nella striscia e in Attività. Controlla le impostazioni e usa «Invia una prova».
|
||||
|
||||
## Disco quasi pieno
|
||||
|
||||
Febe controlla lo spazio libero dei dischi della libreria e della cartella dei dati un minuto dopo l'avvio e poi ogni
|
||||
15 minuti. Un disco è «quasi pieno» quando restano meno di **10 GB** oppure meno del **5%** della sua capacità (la
|
||||
prima delle due condizioni che si verifica). Con il disco della libreria pieno gli scaricamenti non riescono; con
|
||||
quello dei dati pieno il database non può più salvare nulla. Se il disco non si può misurare (per esempio una
|
||||
cartella di rete su Windows), il registro lo dice una volta e per quel disco l'avviso non c'è.
|
||||
|
||||
## Notifiche di Windows
|
||||
|
||||
Nella versione per Windows, «Notifiche di Windows» mostra gli avvisi nell'angolo dello schermo, dall'icona di Febe
|
||||
nell'area di notifica (un clic sulla notifica apre Febe); «Invia una prova» ne mostra una. In Docker l'interruttore è spento e segnato «Solo versione Windows».
|
||||
@@ -0,0 +1,73 @@
|
||||
# Copie e ricostruzione
|
||||
|
||||
Febe tiene due cose ben separate:
|
||||
|
||||
- la **libreria**: i tuoi file, normali, leggibili anche senza Febe, e in ogni cartella di account il file
|
||||
`_febe.jsonl` con i dati di ogni elemento;
|
||||
- la **cartella dei dati**: il database (`febe.sqlite`), che è l'indice di tutto e lo stato del motore, il profilo del
|
||||
browser con la sessione, le miniature, il registro e le **copie del database**.
|
||||
|
||||
Febe fa da solo le copie del database. **Non fa copie delle foto e dei video:** la libreria va salvata come fai con gli
|
||||
altri tuoi file (su Unraid, per esempio, con la parità dell'array e un backup a parte).
|
||||
|
||||
## Dove sono le copie del database
|
||||
|
||||
| Veste | Cartella | File |
|
||||
|---|---|---|
|
||||
| Docker | `/dati/copie` (su Unraid di solito `/mnt/user/appdata/febe/copie`) | `febe-AAAA-MM-GG.sqlite` |
|
||||
| Windows | `%LOCALAPPDATA%\Febe\copie` | `febe-AAAA-MM-GG.sqlite` |
|
||||
|
||||
- Una copia al giorno: all'avvio, se quella di oggi manca, e poi ogni notte verso le 3:20 (fuori dalla fascia di ogni
|
||||
profilo). Si tengono gli **ultimi sette giorni**; le più vecchie si cancellano da sole (solo i file con quel nome).
|
||||
- La copia si scrive con un nome temporaneo e si rinomina solo quando è completa: una copia interrotta non ha mai il
|
||||
nome definitivo.
|
||||
- In **Impostazioni ▸ Dati e copie di sicurezza** vedi l'elenco (giorno, file, peso, quando è stata fatta) e puoi
|
||||
premere **«Fai una copia adesso»**: diventa la copia di oggi, al posto di quella fatta prima oggi.
|
||||
|
||||
Una copia del database contiene tutto ciò che Febe sa: account e impostazioni, elenco degli elementi, cronologia, e
|
||||
anche le impostazioni delle notifiche **con il gettone del bot Telegram**. Non contiene la sessione di Instagram, che
|
||||
sta nel profilo del browser (`browser`); ma una copia di **tutta** la cartella dei dati la contiene: chi ha la
|
||||
cartella dei dati, o una sua copia, ha la sessione di Instagram (vedi
|
||||
[Sicurezza e riservatezza](Sicurezza-e-riservatezza)).
|
||||
|
||||
## Tornare a una copia
|
||||
|
||||
1. **Ferma Febe:** `docker stop febe` (su Unraid, Stop sul contenitore); su Windows «Esci» dal menu dell'icona
|
||||
nell'area di notifica.
|
||||
2. Nella cartella dei dati sposta da parte `febe.sqlite` (rinominalo, per esempio `febe-rovinato.sqlite`) e, se ci sono,
|
||||
`febe.sqlite-wal` e `febe.sqlite-shm`.
|
||||
3. Copia la copia scelta da `copie/` nella cartella dei dati con il nome `febe.sqlite`.
|
||||
4. Riavvia Febe. Il database si aggiorna da solo, se la copia è di una versione precedente.
|
||||
|
||||
Ciò che è successo dopo la copia (elementi scaricati, scelte fatte) non è nel database ripristinato, ma i file scaricati
|
||||
nel frattempo sono in libreria con il loro `_febe.jsonl`: una **ricostruzione** subito dopo li rimette nell'indice.
|
||||
|
||||
## Ricostruire il database dalla libreria
|
||||
|
||||
Se il database si è perso o rovinato e non hai una copia buona, Febe lo ricostruisce dalla libreria:
|
||||
**Impostazioni ▸ Dati e copie di sicurezza ▸ «Ricostruisci il database dalla libreria» ▸ «Ricostruisci…»**. Per
|
||||
confermare scrivi `ricostruisci`.
|
||||
|
||||
Che cosa fa:
|
||||
|
||||
- rilegge le cartelle degli account e i loro file `_febe.jsonl`, ricalcola SHA-256, impronte e miniature dei file sul
|
||||
disco, e rispetta le eliminazioni (un elemento eliminato «ricordando la scelta» resta eliminato);
|
||||
- **non riscarica nulla** e **non sposta, non rinomina e non cancella nessun file**;
|
||||
- gli elementi già presenti nel database restano come sono: si può lanciare anche su un database esistente;
|
||||
- mostra l'avanzamento (cartelle e file controllati) e alla fine un resoconto.
|
||||
|
||||
Che cosa non torna:
|
||||
|
||||
- gli account ricreati tornano **«In pausa»** con le impostazioni predefinite: riattivali e controlla le loro
|
||||
impostazioni;
|
||||
- la cronologia del motore, gli arresti passati e le impostazioni generali (limiti, notifiche) che stavano solo nel
|
||||
database perso.
|
||||
|
||||
Con una libreria grande può durare a lungo. È rifiutata mentre è in corso un'importazione. Se il database c'è ancora,
|
||||
fai prima una copia («Fai una copia adesso»).
|
||||
|
||||
## I file `_febe.jsonl`
|
||||
|
||||
Ogni cartella di account ha il suo `_febe.jsonl`: una riga per ogni elemento salvato e una per ogni eliminazione, sempre
|
||||
aggiunte in coda. È ciò che rende possibile la ricostruzione: **non modificarlo e non cancellarlo**, e tienilo insieme
|
||||
ai file quando sposti o copi una cartella di account.
|
||||
@@ -0,0 +1,70 @@
|
||||
# Febe
|
||||
|
||||
Febe è un archivio personale. Scarica e conserva sul tuo disco le foto, i video e le storie degli account Instagram che
|
||||
scegli, usando il tuo account, e li tiene aggiornati nel tempo. Esiste in due vesti, con lo stesso motore e la stessa
|
||||
interfaccia: un **contenitore Docker** per il server di casa (Unraid) e un'**applicazione per Windows**.
|
||||
|
||||
Febe non costruisce richieste verso Instagram: usa un browser vero, in cui accedi tu a mano, lo fa navigare con il
|
||||
ritmo di una persona e salva ciò che la pagina stessa riceve. Per questo è più lento di uno scaricatore diretto: è
|
||||
voluto.
|
||||
|
||||
## Il rischio per il tuo account: leggilo prima
|
||||
|
||||
- **Scaricare contenuti con un programma è contro le condizioni d'uso di Instagram.** Il rischio concreto è la
|
||||
limitazione o la chiusura dell'account. Non esiste un'API ufficiale per questo uso: quelle di Meta servono solo ai
|
||||
profili aziendali.
|
||||
- **Che cosa fa Febe per ridurre il rischio:** usa un browser normale, con la tua lingua e il tuo fuso orario, senza
|
||||
nascondere che cos'è; lavora solo in una fascia oraria, a sessioni brevi separate da pause lunghe e mai regolari;
|
||||
rispetta tetti giornalieri e orari per ogni tipo di azione, contati su disco (un riavvio non li azzera); al primo
|
||||
segnale di Instagram si ferma: dopo una verifica o una disconnessione non riparte da solo. Vedi
|
||||
[Limiti e comportamento](Limiti-e-comportamento) e [Attività e arresti](Attivita-e-arresti).
|
||||
- **Che cosa Febe non fa:** non risolve CAPTCHA, verifiche o codici (li completi tu, a mano); non cambia user agent,
|
||||
impronta o intestazioni del browser; non usa proxy, più indirizzi o più account per dividere il carico; non mette «mi
|
||||
piace», non segue, non commenta, non scrive messaggi; non tocca i profili privati che non ti hanno accettato.
|
||||
- **Che cosa Febe non può fare:** azzerare il rischio. I tetti sono stime prudenti, non limiti pubblicati da Instagram,
|
||||
che non li pubblica. Nessuno può garantire che bastino.
|
||||
- **Le storie aperte da Febe risultano viste:** Febe guarda le storie come faresti tu, quindi risulti tra gli
|
||||
spettatori. Per un account in cui non vuoi comparire, spegni l'interruttore «Storie» (vedi
|
||||
[Account e impostazioni](Account-e-impostazioni)).
|
||||
- **Un account, un Febe:** il contenitore e la versione per Windows non vanno usati insieme sullo stesso account.
|
||||
- I contenuti restano dei loro autori. Febe è un archivio privato: non ripubblica e non condivide nulla.
|
||||
|
||||
Il consiglio pratico: comincia con un **account di prova**, il profilo **Prudente** e un solo profilo pubblico da
|
||||
seguire; passa al tuo account solo quando hai visto come si comporta.
|
||||
|
||||
## A che punto è Febe (13 ottobre 2026)
|
||||
|
||||
Questa guida descrive ciò che c'è nel programma, non ciò che si spera. Alcune cose dipendono da prove che si possono
|
||||
fare solo con Instagram o su Windows:
|
||||
|
||||
- **Raccolta da Instagram: non ancora attiva.** Le ricette, il motore, la libreria e gli scaricamenti funzionano e sono
|
||||
provati contro un sito di prova locale. Su Instagram le ricette si rifiutano di girare («la mappa dei bersagli non è
|
||||
ancora compilata») finché la sonda passiva non ha confermato le ipotesi H1–H11. Vedi
|
||||
[Ipotesi da verificare](Ipotesi-da-verificare).
|
||||
- **Versione per Windows: pronta, non ancora provata su un Windows vero.** Programma di installazione e versione
|
||||
portabile ci sono; le prove che si fanno solo su Windows (S1–S3) sono aperte. Vedi
|
||||
[Installazione su Windows](Installazione-Windows).
|
||||
- **Docker, interfaccia, importazione, avvisi (anche Telegram), copie e ricostruzione:** pronti, da provare sul tuo
|
||||
Unraid.
|
||||
|
||||
## Pagine della guida
|
||||
|
||||
| Pagina | Di che cosa parla |
|
||||
|---|---|
|
||||
| [Installazione con Docker e Unraid](Installazione-Docker-e-Unraid) | Contenitore, volumi, variabili, profilo seccomp, aggiornamenti |
|
||||
| [Installazione su Windows](Installazione-Windows) | Programma di installazione, cartelle, area di notifica, avvio con il computer |
|
||||
| [Primo collegamento](Primo-collegamento) | Accedere a Instagram dal browser di Febe, scollegarsi |
|
||||
| [Account e impostazioni](Account-e-impostazioni) | Aggiungere account, punti di partenza, impostazioni per account |
|
||||
| [Libreria](Libreria) | Mosaico, filtri, visualizzatore, eliminazione, esportazione CSV, nomi dei file |
|
||||
| [Importazione](Importazione) | Portare in libreria foto e video che hai già, senza doppioni |
|
||||
| [Limiti e comportamento](Limiti-e-comportamento) | Profili di prudenza, tetti, fascia oraria, ritmo delle sessioni |
|
||||
| [Attività e arresti](Attivita-e-arresti) | La pagina Attività, che cosa fare dopo una verifica o un rallentamento |
|
||||
| [Avvisi e Telegram](Avvisi-e-Telegram) | Striscia, notifiche di Windows, messaggi Telegram con un bot tuo |
|
||||
| [Copie e ricostruzione](Copie-e-ricostruzione) | Dove sono le copie del database, come si torna indietro, come si ricostruisce |
|
||||
| [Sicurezza e riservatezza](Sicurezza-e-riservatezza) | Sessione, cartella dei dati, password, rete, registri |
|
||||
| [Problemi comuni](Problemi-comuni) | Che cosa vedi, che cosa fare |
|
||||
| [Ipotesi da verificare](Ipotesi-da-verificare) | Le voci H e S ancora da provare e come le provi tu |
|
||||
| [Sviluppo](Sviluppo) | Compilare, provare, dimostrazione, simulazione, sito di prova, sonda, CI e rilascio |
|
||||
|
||||
Il codice e la specifica completa sono nel repository:
|
||||
<https://gitea.encke-hake.ts.net/Alby96/Febe> (la specifica è `docs/SPECIFICA.md`).
|
||||
@@ -0,0 +1,81 @@
|
||||
# Importazione
|
||||
|
||||
**Importa** porta in libreria foto e video che hai già, anche di contenuti che su Instagram non esistono più, senza
|
||||
creare doppioni e senza toccare gli originali finché non decidi tu. Quattro passi, mostrati in alto nella pagina:
|
||||
Sorgente, Analisi, Revisione, Copia. Un'importazione alla volta.
|
||||
|
||||
## 1. Sorgente
|
||||
|
||||
- **In Docker** si importa dalle cartelle del volume `/importa`, montato **in sola lettura**: la pagina le elenca e ci
|
||||
entri con un clic. Metti lì (sul server) le cartelle da importare.
|
||||
- **Su Windows** scegli una cartella qualsiasi con «Scegli una cartella…».
|
||||
|
||||
Febe rifiuta le sorgenti che sono dentro o sopra la cartella dei dati, sopra la libreria, o dentro una cartella di
|
||||
account di Febe: una libreria non si importa in sé stessa.
|
||||
|
||||
Se la cartella sembra una **libreria di Febe**, date e codici si leggono dai suoi file `_febe.jsonl` (date esatte). Se
|
||||
sembra una **libreria di 4K Stogram**, compare l'opzione «Leggi i nomi alla maniera di 4K Stogram (ipotesi da
|
||||
verificare)»: il riconoscitore dei nomi di 4K Stogram è scritto su un ricordo, non su file veri, ed è spento per
|
||||
impostazione predefinita. Se lo usi, controlla date e codici nella revisione. Il database di 4K Stogram non viene mai
|
||||
aperto.
|
||||
|
||||
«Analizza questa cartella» passa all'analisi.
|
||||
|
||||
## 2. Analisi
|
||||
|
||||
Sola lettura: nessun file viene copiato o spostato, e nella sorgente non si scrive nemmeno un file di prova. Per ogni
|
||||
file Febe ricava: tipo dal contenuto (non solo dall'estensione), peso, SHA-256, dimensioni, impronta visiva per le
|
||||
foto, data (dal nome del file, poi dai metadati, poi dalla data di modifica), codice di Instagram se il nome lo
|
||||
contiene, account probabile dal nome della cartella, tipo probabile (storie, evidenza, taggati) dalle sottocartelle.
|
||||
|
||||
Puoi **interrompere** e **riprendere** quando vuoi, anche dopo un riavvio: l'analisi riprende da dove era rimasta.
|
||||
|
||||
## 3. Revisione
|
||||
|
||||
Quattro contatori:
|
||||
|
||||
| Esito | Che cosa significa | Che cosa succede |
|
||||
|---|---|---|
|
||||
| Nuovi | Non ci sono in libreria | Verranno copiati |
|
||||
| Già in libreria | Identici (stesso SHA-256) a un file presente in qualunque account | Saltati; il resoconto dice dove sono |
|
||||
| Doppioni probabili | Stesso codice di Instagram con file diverso, oppure stessa immagine con file diverso (impronta visiva vicina) | Decidi tu |
|
||||
| Non riconosciuti | Né foto né video | Ignorati ed elencati |
|
||||
|
||||
I doppioni si cercano anche dentro la sorgente stessa (una copia identica nella sorgente si copia una volta sola). Per
|
||||
i video vale solo lo SHA-256 (e il codice). Un file che hai eliminato «ricordando la scelta» conta come già in
|
||||
libreria: un'importazione non annulla un'eliminazione.
|
||||
|
||||
**Cartelle e account.** Una tabella lega ogni cartella della sorgente a un account: uno esistente (riconosciuto per
|
||||
identificativo o per nome), oppure un nuovo account «Solo archivio» con il nome della cartella. Una cartella senza
|
||||
account blocca solo i propri file: il pulsante finale dice quanti file importa e quanti restano fuori. Gli account
|
||||
nuovi nascono solo quando parte la copia, con «Tieni aggiornato» spento.
|
||||
|
||||
**Doppioni probabili.** Per ogni coppia vedi le due immagini con misure e peso («Più grande» sulla maggiore) e scegli:
|
||||
«Tieni il più grande e scarta l'altro», «Tieni quello già in libreria», «Tienili entrambi». Nessuna scelta è fatta in
|
||||
partenza. «Fai lo stesso per gli altri» applica la scelta ai casi simili. Se il più grande è quello da importare,
|
||||
«Tieni il più grande» sostituisce il file della libreria: il nuovo viene scritto e riletto prima che il vecchio sparisca.
|
||||
|
||||
**Copia o sposta.** Il predefinito è **Copia**: gli originali restano dove sono. Con **Sposta** ogni originale si
|
||||
cancella solo dopo che la sua copia in libreria è stata riletta e verificata con lo SHA-256; i file saltati non si
|
||||
toccano. Se la sorgente è in sola lettura, come `/importa` in Docker, «Sposta» non compare.
|
||||
|
||||
## 4. Copia
|
||||
|
||||
Ogni file viene copiato con un nome temporaneo, verificato e poi rinominato: mai una sovrascrittura. I file con data e
|
||||
codice noti prendono il nome secondo lo schema della libreria; gli altri vanno in `{account}\importati\` con il nome
|
||||
originale. Puoi interrompere e riprendere: ogni file ha il suo esito nel database.
|
||||
|
||||
Alla fine il **resoconto**: copiati (di cui spostati e sostituiti), saltati, rimasti fuori, non riusciti, per account,
|
||||
e ciò che è da guardare. «Esporta l'elenco in CSV» scarica il resoconto completo (`;`, UTF-8 con BOM). Puoi tornare
|
||||
alla revisione dei file rimasti fuori e rilanciare la copia sulla stessa importazione.
|
||||
|
||||
«Annulla l'importazione» fa dimenticare a Febe l'analisi: nessun file della sorgente viene toccato.
|
||||
|
||||
## Dopo l'importazione
|
||||
|
||||
Gli elementi importati contano come presenti. Quando Febe tiene aggiornato quell'account non li riscarica se li
|
||||
riconosce dal codice, oppure da account, tipo e data di pubblicazione entro due secondi. Se li riconosce solo dopo lo
|
||||
scaricamento: un file identico non entra due volte; uno visivamente uguale ma diverso finisce nei
|
||||
[doppioni da decidere](Libreria).
|
||||
|
||||
Le importazioni precedenti restano elencate nel passo 1 («Importazioni precedenti»), con il loro stato.
|
||||
@@ -0,0 +1,153 @@
|
||||
# Installazione con Docker e Unraid
|
||||
|
||||
La veste Docker è un solo contenitore con l'interfaccia web, il motore, un Chromium vero su un display virtuale (Xvfb)
|
||||
e la libreria su disco. La usi dal browser di casa; il browser di Febe lo vedi e lo usi dalla **vista remota** della
|
||||
pagina Impostazioni ▸ Collegamento a Instagram.
|
||||
|
||||
> **Prima di tutto.** Scaricare con un programma è contro le condizioni d'uso di Instagram: leggi il riquadro sul
|
||||
> rischio nella [pagina iniziale](Home). E leggi [Sicurezza e riservatezza](Sicurezza-e-riservatezza) prima di
|
||||
> decidere su quale rete pubblicare l'interfaccia.
|
||||
|
||||
## Che cosa serve
|
||||
|
||||
- Un server con Docker (Unraid va benissimo), processore x86-64 (l'immagine è per `linux-x64`).
|
||||
- Un **disco locale** per la cartella dei dati (su Unraid: l'appdata sul disco di cache).
|
||||
- Lo spazio per la libreria: può stare anche su una condivisione o sull'array.
|
||||
- Una password per l'interfaccia, lunga: è la sola cosa che protegge la vista remota del browser.
|
||||
|
||||
## Volumi
|
||||
|
||||
| Volume | Che cosa contiene | Dove metterlo |
|
||||
|---|---|---|
|
||||
| `/dati` | Database (`febe.sqlite`), **profilo del browser con la sessione di Instagram** (`browser/`), miniature, copie giornaliere del database (`copie/`, sette giorni), registro (`registro/`, quattordici giorni), file temporanei | Su un **disco locale** del server. Su Unraid `/mnt/user/appdata/febe`. Mai una condivisione di rete: SQLite e il profilo del browser lì si rovinano, e Febe si rifiuta di partire |
|
||||
| `/libreria` | Foto e video, una cartella per account, ognuna con il suo `_febe.jsonl` | Dove vuoi, anche su una condivisione. Febe non cancella e non sostituisce mai un file da solo |
|
||||
| `/importa` | Cartelle da importare (pagina Importa) | **Sempre in sola lettura** (`:ro`): Febe copia, gli originali non si toccano |
|
||||
|
||||
## Variabili
|
||||
|
||||
| Variabile | Significato | Predefinito |
|
||||
|---|---|---|
|
||||
| `FEBE_PASSWORD` | Password dell'interfaccia. **Obbligatoria**: senza, il motore e il browser non partono e l'interfaccia mostra solo la pagina che spiega il problema | nessuno |
|
||||
| `FEBE_PORTA` | Porta dell'interfaccia dentro il contenitore | 8480 |
|
||||
| `TZ` | Fuso orario: fascia del motore, date nei nomi dei file, fuso dichiarato dal browser | Europe/Rome |
|
||||
| `LANG` | Lingua del contenitore e quindi del browser | it_IT.UTF-8 |
|
||||
| `PUID`, `PGID` | Utente e gruppo con cui gira Febe e di cui sono i file | 99, 100 (Unraid) |
|
||||
| `FEBE_HOST` | Facoltativa: i nomi con cui raggiungi l'interfaccia, separati da virgole (`tower.local,192.168.1.10`). Se c'è, ogni altro nome è rifiutato | qualunque nome |
|
||||
| `FEBE_PROXY_FIDATO` | `1` se davanti c'è un proxy con HTTPS che passa `X-Forwarded-Host` e `X-Forwarded-Proto`: allora il cookie di sessione viaggia solo in HTTPS | spenta |
|
||||
| `FEBE_SENZA_SANDBOX` | `1` avvia Chromium senza la sua sandbox: è il compromesso descritto sotto, da usare solo se il profilo seccomp non si può usare | spenta |
|
||||
|
||||
La password non si passa mai sulla riga di comando e non finisce nei registri. Febe **non gira come root**: con
|
||||
`PUID=0` il contenitore si ferma con un messaggio.
|
||||
|
||||
## Porte
|
||||
|
||||
Si pubblica **solo** la porta dell'interfaccia (8480). La porta di debug del browser (9222) ascolta solo su
|
||||
`127.0.0.1` dentro il contenitore: non va mai pubblicata, e Febe si rifiuta di usare il browser se la trova aperta
|
||||
altrove.
|
||||
|
||||
## Installazione su Unraid
|
||||
|
||||
1. L'immagine è `192.168.30.23:3000/alby96/febe:latest`, sul registro dei container del Gitea di casa. Il registro
|
||||
risponde in **HTTP**: il Docker di Unraid deve averlo fra gli `insecure-registries`, come per le altre immagini di
|
||||
casa. Se Unraid scarica già quelle, è a posto; altrimenti aggiungi `"insecure-registries": ["192.168.30.23:3000"]`
|
||||
alla configurazione del demone Docker e riavvia Docker. Se il pacchetto non è pubblico, accedi dal terminale:
|
||||
`docker login 192.168.30.23:3000`.
|
||||
2. Dal terminale di Unraid, **una volta sola**, estrai dall'immagine il profilo seccomp e mettilo dove il modello lo
|
||||
cerca, **fuori** dalla cartella dei dati:
|
||||
|
||||
```sh
|
||||
docker run --rm --entrypoint cat 192.168.30.23:3000/alby96/febe:latest \
|
||||
/usr/share/febe/seccomp.json > /mnt/user/appdata/febe-seccomp.json
|
||||
```
|
||||
|
||||
3. Docker ▸ Aggiungi contenitore ▸ modello da `docker/unraid/febe.xml` (o dal suo indirizzo,
|
||||
`http://192.168.30.23:3000/Alby96/Febe/raw/branch/main/docker/unraid/febe.xml`). Controlla:
|
||||
- porta 8480;
|
||||
- `/dati` su `/mnt/user/appdata/febe` (disco di cache);
|
||||
- `/libreria` dove vuoi le foto; `/importa` in sola lettura;
|
||||
- **password dell'interfaccia** (obbligatoria, nascosta);
|
||||
- `TZ`, `PUID` 99, `PGID` 100 tra le impostazioni avanzate;
|
||||
- in «Extra Parameters»: `--restart=unless-stopped --stop-timeout 30 --security-opt seccomp=/mnt/user/appdata/febe-seccomp.json`.
|
||||
4. Apri `http://<IP di Unraid>:8480/`, entra con la password e segui il [Primo collegamento](Primo-collegamento).
|
||||
|
||||
## Docker Compose
|
||||
|
||||
`docker/compose.yml` nel repository è un esempio pronto: immagine, porta, volumi (con `/importa` in sola lettura),
|
||||
variabili, profilo seccomp con percorso relativo al file, `restart: unless-stopped`, 30 secondi per fermarsi. Anche
|
||||
qui il registro `192.168.30.23:3000` deve stare fra gli `insecure-registries` del Docker.
|
||||
|
||||
```sh
|
||||
FEBE_PASSWORD='una frase lunga' docker compose -f docker/compose.yml up -d
|
||||
```
|
||||
|
||||
Senza il repository, scarica dalla release l'archivio `febe-compose-X.Y.Z.tar.gz`: dentro c'è `compose.yml` con accanto
|
||||
`chromium/seccomp.json`, il profilo che il file indica.
|
||||
|
||||
```sh
|
||||
tar -xzf febe-compose-X.Y.Z.tar.gz && cd febe-compose-X.Y.Z
|
||||
FEBE_PASSWORD='una frase lunga' docker compose up -d
|
||||
```
|
||||
|
||||
Le cartelle si cambiano con `FEBE_DATI`, `FEBE_LIBRERIA` e `FEBE_IMPORTA` (predefinite sotto `/srv/febe`).
|
||||
|
||||
## La sandbox di Chromium
|
||||
|
||||
Chromium isola le pagine che apre in una **sandbox**. Dentro Docker la sandbox ha bisogno di creare spazi dei nomi
|
||||
utente, che il profilo seccomp predefinito di Docker vieta: con le impostazioni normali Chromium non parte affatto
|
||||
(`No usable sandbox!`).
|
||||
|
||||
- **Impostazione consigliata, già scritta nel modello di Unraid e in `compose.yml`:** il profilo seccomp dedicato di
|
||||
Febe (`docker/chromium/seccomp.json`), cioè quello di Docker più `clone` e `unshare`. Con questo profilo la sandbox
|
||||
di Chromium è completa e il resto del filtro di Docker resta attivo. **Così non c'è nessun compromesso sulla
|
||||
sandbox.**
|
||||
- Docker legge il profilo sul server quando **crea** il contenitore, per questo il file sta **fuori** dalla cartella
|
||||
dei dati (passo 2 sopra): dentro `/dati` lo potrebbe cambiare l'utente del contenitore. Il contenitore non lo
|
||||
aggiorna da sé; se le note di una versione lo chiedono, ripeti l'estrazione. Nelle prime anteprime il profilo stava in
|
||||
`/dati/seccomp.json`: se «Extra Parameters» indica ancora quel file, estrai il profilo nel posto nuovo e correggi
|
||||
il percorso.
|
||||
|
||||
Se il profilo dedicato non si può usare, ci sono due alternative, in quest'ordine:
|
||||
|
||||
1. `--security-opt seccomp=unconfined`: la sandbox di Chromium resta attiva, ma il contenitore perde tutto il filtro
|
||||
seccomp di Docker.
|
||||
2. `FEBE_SENZA_SANDBOX=1`: Chromium parte con `--no-sandbox`. **È un compromesso**: una pagina che sfruttasse un
|
||||
difetto del browser non troverebbe la sandbox di Chromium a fermarla, solo i limiti del contenitore. Si accetta
|
||||
soltanto perché quel browser visita esclusivamente Instagram, e solo se le due strade sopra non sono possibili.
|
||||
Chromium mostra anche una barra d'avviso in alto, che toglie circa 50 pixel alla pagina.
|
||||
|
||||
Febe non sceglie da solo: se Chromium non parte, il registro dice perché. La prova della sandbox è stata fatta il 13
|
||||
ottobre 2026 in un contenitore con il Chromium dell'ambiente di sviluppo; con l'immagine vera va ripetuta sul server
|
||||
(vedi [Ipotesi da verificare](Ipotesi-da-verificare), voce S5).
|
||||
|
||||
## Salute del contenitore
|
||||
|
||||
`GET /salute` risponde senza password `{"stato":"ok"}` oppure `{"stato":"problema"}` quando un problema di
|
||||
configurazione ferma Febe. L'immagine ha un controllo di salute che lo chiede ogni 30 secondi; Unraid mostra lo stato
|
||||
accanto al contenitore. Da terminale: `docker inspect --format '{{.State.Health.Status}}' febe`.
|
||||
|
||||
## Registro
|
||||
|
||||
Il registro di Febe è in `/dati/registro/febe-AAAA-MM-GG.log` (un file al giorno, quattordici giorni, al massimo 20 MB
|
||||
al giorno) e nell'output del contenitore (`docker logs febe`). Contiene azioni ed esiti, nomi utente sì; mai password,
|
||||
cookie, tasti, didascalie, corpi delle risposte, indirizzi firmati del CDN, né il gettone del bot Telegram.
|
||||
|
||||
## Arresto e aggiornamento
|
||||
|
||||
- Allo stop (`docker stop`, aggiornamento, riavvio di Unraid) Febe chiude la vista remota, ferma il motore, poi
|
||||
Chromium in modo che la sessione di Instagram resti scritta nel profilo, poi Xvfb. Lascia 30 secondi
|
||||
(`--stop-timeout 30`); di solito ne bastano pochi.
|
||||
- **Aggiornare:** scarica la nuova immagine e ricrea il contenitore (su Unraid «Force update»). `/dati` e `/libreria`
|
||||
restano; il database si aggiorna da solo all'avvio. Prima di un aggiornamento importante puoi copiare a mano
|
||||
`/dati/febe.sqlite` a contenitore fermo; le copie giornaliere sono comunque in `/dati/copie` (vedi
|
||||
[Copie e ricostruzione](Copie-e-ricostruzione)).
|
||||
- Il collegamento è fatto per sopravvivere ai riavvii e alla ricreazione del contenitore: la sessione è in
|
||||
`/dati/browser`. È provato in locale; nel contenitore vero è la voce S3 di
|
||||
[Ipotesi da verificare](Ipotesi-da-verificare), da confermare.
|
||||
|
||||
## Un account, un motore
|
||||
|
||||
Il contenitore e Febe per Windows **non vanno usati insieme sullo stesso account**: due Febe che raccolgono con lo
|
||||
stesso account sommano le visite e raddoppiano il rischio. La sessione nasce e resta nel browser del contenitore: i
|
||||
cookie non si copiano da un'altra macchina.
|
||||
|
||||
Se qualcosa non va: [Problemi comuni](Problemi-comuni).
|
||||
@@ -0,0 +1,131 @@
|
||||
# Installazione su Windows
|
||||
|
||||
> **Stato (13 ottobre 2026).** L'applicazione per Windows (tappa M6) c'è: programma di installazione e versione
|
||||
> portabile. Tutto ciò che non dipende da Windows ha le sue prove automatiche, ma **nessuna parte che richiede Windows
|
||||
> è ancora stata eseguita su un Windows vero** (finestre, WebView2, area di notifica, registro di sistema, programma di
|
||||
> installazione). Le tre prove che si possono fare solo lì (S1, S2, S3) sono aperte: vedi
|
||||
> [Ipotesi da verificare](Ipotesi-da-verificare). I dettagli tecnici sono nel repository, in `docs/windows.md`.
|
||||
|
||||
## Com'è fatta
|
||||
|
||||
- Un'applicazione Windows (WPF, .NET 10) in un solo file, `Febe.exe`, con l'icona nell'area di notifica. **Un solo
|
||||
Febe per cartella dei dati**: riaprendolo mentre è già aperto, torna in primo piano la finestra che c'è.
|
||||
- La finestra di Febe mostra la stessa interfaccia della versione Docker, servita da Febe stesso solo su `127.0.0.1`,
|
||||
su una porta scelta a ogni avvio e protetta da un gettone che conosce solo la finestra.
|
||||
- Il browser di Instagram è una **seconda finestra, «Browser di Febe»**: WebView2 (il motore di Edge) con il suo
|
||||
profilo nella cartella dei dati. La porti in primo piano con «Apri il browser» (Attività, striscia di un arresto) o
|
||||
«Portalo in primo piano» (Collegamento). Quando non serve **non è chiusa né ridotta a icona**: resta aperta ma fuori
|
||||
dallo schermo, perché deve continuare a caricare e scorrere (ipotesi S2). Salvataggio delle password e compilazione
|
||||
automatica sono spenti.
|
||||
- Ciò che scrivi nella finestra del browser va direttamente alla pagina di Instagram: Febe non riceve la password.
|
||||
Mentre usi il browser il motore resta fermo; quando hai finito chiudi la finestra (o «Ho finito»): torna fuori vista.
|
||||
- Funzioni di Windows offerte all'interfaccia: scelta di una cartella, «Mostra nella cartella», indirizzi aperti nel
|
||||
tuo browser predefinito (mai nel browser di Febe), notifiche di Windows, avvio con il computer.
|
||||
|
||||
## Che cosa serve
|
||||
|
||||
- Windows 10 o 11 a 64 bit.
|
||||
- Il **runtime WebView2** di Microsoft: c'è già in Windows 11 e in quasi tutti i Windows 10. Se manca, sia il
|
||||
programma di installazione sia Febe lo dicono e offrono la pagina ufficiale:
|
||||
<https://developer.microsoft.com/microsoft-edge/webview2/> (installazione «Evergreen», senza permessi di
|
||||
amministratore).
|
||||
- Nessun permesso di amministratore: Febe si installa solo per il tuo utente.
|
||||
- Un disco locale per la cartella dei dati.
|
||||
|
||||
## Installare
|
||||
|
||||
1. Scarica `Febe-Setup-<versione>.exe` dalla pagina delle release del repository,
|
||||
<https://gitea.encke-hake.ts.net/Alby96/Febe/releases>, e aprilo.
|
||||
2. Windows può avvisare che il programma non è firmato (SmartScreen): «Ulteriori informazioni» ▸ «Esegui comunque».
|
||||
3. Il programma di installazione mette `Febe.exe` in `%LOCALAPPDATA%\Programs\Febe`, crea il collegamento nel menu
|
||||
Start e, se lasci la scelta «Collegamento sul desktop», uno sul desktop. Febe compare in Impostazioni di Windows ▸
|
||||
App installate.
|
||||
4. Alla fine, «Apri Febe adesso» lo avvia.
|
||||
|
||||
Non serve installare .NET: `Febe.exe` (circa 86 MB) contiene il runtime, l'interfaccia e le librerie native. Al primo
|
||||
avvio Windows estrae le librerie native in `%TEMP%\.net\Febe`: è normale.
|
||||
|
||||
**Versione portabile.** `Febe-<versione>-portabile.zip`, dalla stessa pagina, contiene lo stesso `Febe.exe`: lo
|
||||
estrai dove vuoi e lo apri, senza installazione. Anche la versione portabile tiene i dati in `%LOCALAPPDATA%\Febe` e
|
||||
la libreria in `Immagini\Febe`, finché non scegli altre cartelle.
|
||||
|
||||
## Area di notifica e avvio con il computer
|
||||
|
||||
- L'icona di Febe sta nell'area di notifica, accanto all'orologio. Un clic apre la finestra; il menu ha **Apri**,
|
||||
**Metti in pausa** (o **Riprendi**) ed **Esci**.
|
||||
- **Chiudendo la finestra Febe resta attivo** nell'area di notifica e continua a lavorare (Impostazioni ▸ Generali ▸
|
||||
Avvio, «Chiudendo la finestra, Febe resta attivo nell'area di notifica», acceso di serie). Per fermarlo davvero:
|
||||
menu dell'icona ▸ **Esci**, che ferma tutto in ordine e chiude il browser in modo pulito, così la sessione resta
|
||||
scritta nel profilo.
|
||||
- «Avvia Febe all'accensione del computer» (Impostazioni ▸ Generali ▸ Avvio) scrive il valore `Febe` in
|
||||
`HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run`, solo per il tuo utente: all'accensione Febe parte
|
||||
con `--nascosto`, cioè con la sola icona e senza finestra.
|
||||
- Gli avvisi arrivano anche come **notifiche di Windows**, dall'icona di Febe; un clic sulla notifica apre Febe. Si
|
||||
regolano in Impostazioni ▸ Notifiche: vedi [Avvisi e Telegram](Avvisi-e-Telegram).
|
||||
|
||||
## Dove stanno le cose
|
||||
|
||||
| Che cosa | Predefinita | Che cosa contiene |
|
||||
|---|---|---|
|
||||
| Programma | `%LOCALAPPDATA%\Programs\Febe\Febe.exe` | Per la versione portabile, dove l'hai estratto |
|
||||
| Dati | `%LOCALAPPDATA%\Febe` | Database `febe.sqlite`, **profilo del browser con la sessione di Instagram** (`browser\`), miniature, copie del database (`copie\`), registro (`registro\`) |
|
||||
| Libreria | `Immagini\Febe` | Foto e video, una cartella per account |
|
||||
|
||||
- **Cambiare la libreria** (Impostazioni ▸ Generali ▸ Libreria ▸ «Cambia…»): vale subito per i nuovi file; gli
|
||||
account che hanno già file restano nelle loro cartelle. Febe non sposta nessun file.
|
||||
- **Cambiare la cartella dei dati** (Impostazioni ▸ Generali ▸ Dati di Febe ▸ «Cambia…»): la nuova cartella deve
|
||||
essere vuota e su un disco locale. Lo spostamento avviene **al prossimo avvio**, prima che Febe apra qualunque cosa:
|
||||
ogni file viene copiato, riletto e confrontato con l'originale; solo se tutte le copie sono uguali Febe usa la nuova
|
||||
cartella e cancella la vecchia (che conteneva una copia della sessione). Se qualcosa va storto resta in uso la
|
||||
vecchia, intatta. Per farlo subito: Esci e riapri Febe.
|
||||
- La cartella dei dati **deve stare su un disco locale**: SQLite e il profilo del browser non reggono le condivisioni
|
||||
di rete. Se la trova in rete, Febe non avvia il motore e mostra solo la pagina che spiega il problema.
|
||||
- Le copie del database e la ricostruzione dalla libreria: [Copie e ricostruzione](Copie-e-ricostruzione).
|
||||
|
||||
## Il primo avvio
|
||||
|
||||
Febe si apre sulla schermata di benvenuto con due pulsanti: «Collegati a Instagram» e «Importa foto e video che hai
|
||||
già». Il collegamento si fa nella finestra «Browser di Febe»: continua da [Primo collegamento](Primo-collegamento).
|
||||
|
||||
## Un account, un motore
|
||||
|
||||
Se usi anche il contenitore Docker, **non collegare i due Febe allo stesso account Instagram**: contenitore e desktop
|
||||
non vanno usati insieme sullo stesso account, perché due motori sommano le visite e raddoppiano il rischio. La
|
||||
sessione nasce nel browser di quella macchina: i cookie non si copiano da una macchina all'altra. Per un secondo
|
||||
account serve un secondo Febe con cartelle tutte sue: `Febe.exe --dati D:\FebeSecondo --libreria D:\FotoSecondo`.
|
||||
|
||||
## Chi ha la cartella dei dati ha la sessione
|
||||
|
||||
`%LOCALAPPDATA%\Febe` contiene la sessione di Instagram: chi ha quella cartella, o una sua copia (per esempio in un
|
||||
backup del profilo di Windows), ha accesso al tuo account. Trattala come una password: niente copie su chiavette,
|
||||
cartelle condivise o servizi di sincronizzazione. `%LOCALAPPDATA%` non è sincronizzato da OneDrive: lasciala lì. Vedi
|
||||
[Sicurezza e riservatezza](Sicurezza-e-riservatezza).
|
||||
|
||||
## Riga di comando
|
||||
|
||||
| Opzione | Che cosa fa |
|
||||
|---|---|
|
||||
| `--nascosto` | Parte con la sola icona nell'area di notifica (lo usa l'avvio con il computer) |
|
||||
| `--dati <cartella>` | Cartella dei dati diversa (un secondo account, le prove); «Cambia…» allora non c'è |
|
||||
| `--libreria <cartella>` | Libreria di partenza diversa (una cartella scelta poi nelle Impostazioni vince) |
|
||||
| `--browser finestra`, `composizione` o `edge` | Come è ospitato il browser di Instagram (prove dell'ipotesi S2); la scelta resta per gli avvii successivi |
|
||||
|
||||
Le opzioni per lo sviluppo e le prove con il sito di prova sono in `docs/windows.md`.
|
||||
|
||||
## Disinstallare
|
||||
|
||||
Impostazioni di Windows ▸ App ▸ App installate ▸ Febe ▸ Disinstalla. Prima esci da Febe (menu dell'icona ▸ Esci): con
|
||||
Febe aperto la disinstallazione chiede di chiuderlo e non toglie nulla.
|
||||
|
||||
La disinstallazione toglie il programma, i collegamenti, la voce in App installate e l'avvio con il computer. **Non
|
||||
cancella mai la cartella dei dati né la libreria** e non chiede nulla su di loro: alla fine dice dove sono. Se non ti
|
||||
servono più, cancellale tu: la cartella dei dati contiene la sessione di Instagram.
|
||||
|
||||
## Se qualcosa non va
|
||||
|
||||
- **«Manca il runtime WebView2 di Microsoft»** all'avvio: installalo dalla pagina ufficiale (il messaggio offre di
|
||||
aprirla), poi riapri Febe.
|
||||
- **Il collegamento risulta perso dopo un riavvio** o **il browser sembra fermo mentre è fuori vista**: sono le
|
||||
ipotesi S3 e S2; riferiscilo con l'ora e il registro di quel giorno (vedi [Ipotesi da verificare](Ipotesi-da-verificare)).
|
||||
- Il registro è in `%LOCALAPPDATA%\Febe\registro\febe-AAAA-MM-GG.log`: azioni ed esiti, mai password, cookie, tasti o
|
||||
contenuti. Altri casi: [Problemi comuni](Problemi-comuni).
|
||||
@@ -0,0 +1,62 @@
|
||||
# Ipotesi da verificare
|
||||
|
||||
Febe è costruito su alcune ipotesi che non si possono provare senza Instagram (voci **H**) o senza i due browser veri
|
||||
(voci **S**). Finché una voce non è provata, non ci si costruisce sopra: per questo la raccolta da Instagram non è
|
||||
ancora attiva. Lo stato aggiornato e i dettagli tecnici sono in `docs/sonda/esito.md` e `docs/sonda/esito-locale.md`
|
||||
nel repository; i passi precisi delle prove in `docs/prove-dal-vivo.md`.
|
||||
|
||||
Le prove dal vivo le fai **tu**, con l'**account di prova**, mai con l'account principale prima di aver visto Febe
|
||||
all'opera. Se in qualunque momento compare una verifica, un CAPTCHA o un avviso dell'account: fermati, risolvi a mano,
|
||||
annota l'ora e riferisci.
|
||||
|
||||
Legenda: **provato in locale** = misurato su una macchina di sviluppo con Chromium su un display virtuale e pagine
|
||||
locali, mai Instagram; **da provare** = serve una prova tua.
|
||||
|
||||
## Voci H: Instagram
|
||||
|
||||
Si provano tutte con la **sonda passiva** (parte A di `docs/prove-dal-vivo.md`): avvii `febe-sonda registra`, navighi
|
||||
tu in Instagram seguendo l'elenco (pagina iniziale, un profilo pubblico, un privato che segui, delle storie, una
|
||||
raccolta, le schede taggati e reel, l'elenco dei seguiti, un post), la sonda registra ciò che la pagina riceve; poi
|
||||
`febe-sonda ripulisci` e `febe-sonda verifica` sulla tua macchina, e mandi solo la cartella **ripulita**. La sonda non
|
||||
compie gesti e non apre pagine da sola.
|
||||
|
||||
| | Ipotesi | Stato | Come la provi |
|
||||
|---|---|---|---|
|
||||
| H1 | La pagina iniziale consegna i post recenti dei profili che segui con i dati completi dei file | Da provare | Sonda, pagina iniziale: scorri piano una decina di post |
|
||||
| H2 | La barra delle storie dice quali profili seguiti hanno storie attive e a quando risale l'ultima | Da provare | Sonda, pagina iniziale caricata: passa sopra la prima voce della barra |
|
||||
| H3 | La pagina di un profilo consegna identificativo, pubblico o privato, se lo segui, la prima pagina dei post con serie e video, le raccolte; scorrendo arrivano le pagine successive | Da provare | Sonda: un profilo pubblico che non segui e uno privato che segui, scorrendo 3–4 schermate |
|
||||
| H4 | Aprendo il visualizzatore arriva l'elenco delle storie con gli indirizzi dei file, e si capisce qual è l'ultima | Da provare | Sonda: apri le storie di un seguito dall'anello, guardane 2–3, chiudi con la X prima che passi all'account successivo |
|
||||
| H5 | Per i video arriva almeno un indirizzo con audio e video insieme | Da provare | Sonda: un post video e una storia video |
|
||||
| H6 | Le schede «Taggati» e «Reel» si comportano come la griglia | Da provare | Sonda: apri le due schede di un profilo e scorri |
|
||||
| H7 | I file del CDN si scaricano dal browser (`Network.loadNetworkResource`) | Provato in locale (24 MB integri); da provare con il CDN vero | Prima sessione dal vivo (parte B): i file arrivano in Libreria, stato «scaricato» |
|
||||
| H8 | I segnali di arresto si riconoscono da indirizzo e stato HTTP | Da provare (non provocarli di proposito) | Se durante la sonda compare una verifica, annota l'ora e manda la riga ripulita di `navigazioni.jsonl` |
|
||||
| H9 | Un contenuto di una raccolta in evidenza ha lo stesso identificativo che aveva come storia | Da provare | Sonda: apri una raccolta che contiene una storia ancora attiva |
|
||||
| H10 | Identificativo e nome dell'account collegato si ricavano dai dati della pagina, senza leggere i cookie | Da provare | Sonda, pagina iniziale |
|
||||
| H11 | I comandi della pagina si trovano con attributi stabili: ruolo, nome accessibile, forma del collegamento | Da provare; lo scheletro `bersagli.instagram.json` è pronto | Durante tutta la sonda: passa col puntatore sui comandi elencati prima di usarli; manda le sole righe dei comandi, con i nomi di persona sostituiti |
|
||||
|
||||
Finché H1–H11 non sono provate e la mappa dei bersagli e il vocabolario dei lettori non sono compilati sui campioni
|
||||
ripuliti, le ricette su Instagram rispondono «la mappa dei bersagli non è ancora compilata» senza aprire pagine.
|
||||
|
||||
## Voci S: i due browser
|
||||
|
||||
| | Ipotesi | Stato | Come la provi |
|
||||
|---|---|---|---|
|
||||
| S1 | In WebView2 funzionano, attraverso il protocollo DevTools, il corpo delle risposte, i gesti e i fotogrammi della pagina | **Da provare su Windows** (M6) | Con l'app per Windows contro il sito di prova (parte C3 di `docs/prove-dal-vivo.md`, senza Instagram): una raccolta completa (risposte lette, scorrimento e clic arrivati, anteprima del browser in Attività che si aggiorna) |
|
||||
| S2 | Su Windows la pagina continua a caricare e a scorrere quando la finestra del browser non è in vista | **Da provare su Windows** (M6) | Parte C4, con il sito di prova: una sessione con la finestra «Browser di Febe» fuori vista, con la finestra di Febe ridotta a icona e con lo schermo bloccato; le ricette finiscono e i file arrivano. Se non regge, si provano nell'ordine `Febe.exe --browser composizione` e poi `--browser edge` (Edge avviato come processo separato) |
|
||||
| S3 | L'accesso fatto a mano sopravvive al riavvio del programma | Provato in locale con Chromium (3 prove su 3); **da provare** nel contenitore vero e su Windows | Docker: accedi, ricrea il contenitore (o riavvia Unraid), controlla che Collegamento dica «Collegato». Windows (parte C5, account di prova): accedi, «Esci» dall'icona, riapri Febe, stessa verifica; poi riavvio di Windows e avvio con il computer |
|
||||
| S4 | In Docker, dalla vista remota, si scrive in un modulo e si naviga con un ritardo sopportabile | Provato in locale senza contenitore; **da provare** sul tuo Unraid | Il primo accesso a Instagram dalla vista remota: riferisci se il ritardo è sopportabile |
|
||||
| S5 | Chromium in Docker parte con la sua sandbox | Provato in un contenitore (con il Chromium dell'ambiente di sviluppo): col profilo seccomp predefinito non parte, col profilo dedicato di Febe la sandbox è completa. **Da ripetere** con l'immagine vera | Dalla pagina Browser (vista remota) apri `chrome://sandbox` e riferisci se dice «You are adequately sandboxed» |
|
||||
| S6 | Che cosa vede la pagina: `navigator.webdriver`, visibilità, fuoco, lingua, fuso | Provato in locale per Chromium su Xvfb (`webdriver` falso, pagina visibile, `it-IT`, `Europe/Rome`); **da provare** con il Chromium di Debian e in WebView2 | La prova automatica `ThePageSeesAnOrdinaryVisibleBrowser` con `FEBE_CHROMIUM` che punta al Chromium dell'immagine (vedi [Sviluppo](Sviluppo)); per WebView2, la prova equivalente dell'app per Windows |
|
||||
|
||||
## Altre cose da provare dal vivo
|
||||
|
||||
- **Avvisi (M8):** un arresto produce striscia, notifica e messaggio Telegram sul tuo impianto. Procedura nella parte D
|
||||
di `docs/prove-dal-vivo.md`: si fa con il sito di prova, senza Instagram. Le notifiche di Windows si provano con
|
||||
l'app per Windows, contro il sito di prova (parte D4).
|
||||
- **Telegram con il tuo bot:** «Invia una prova» in Impostazioni ▸ Notifiche. Le prove automatiche usano solo un
|
||||
Telegram finto: la chiamata vera la fai tu.
|
||||
- **Spazio libero su Unraid:** in Impostazioni ▸ Generali lo spazio libero mostrato per la libreria (spesso una
|
||||
condivisione dell'array) deve essere quello che vedi in Unraid; se non si può misurare, il registro lo dice.
|
||||
- **Esportazione CSV:** il file si apre bene con un doppio clic in Excel in italiano (colonne separate, accenti giusti).
|
||||
- **Libreria di 4K Stogram:** il riconoscitore dei nomi è un'ipotesi. Serve una ventina di nomi di file veri, con i nomi
|
||||
degli account sostituiti (domanda 4 della specifica), per riscriverlo sui dati veri.
|
||||
@@ -0,0 +1,97 @@
|
||||
# Libreria
|
||||
|
||||
La **Libreria** è il mosaico di tutti gli elementi in ordine di pubblicazione, raggruppati per giorno. Resta fluida
|
||||
anche con centinaia di migliaia di elementi: carica a finestre e le miniature si generano una volta sola.
|
||||
|
||||
## Filtri e ricerca
|
||||
|
||||
- **Tipo:** Tutto, Foto, Video, Storie, In evidenza, Taggati. «Foto» e «Video» riguardano i post (un post con almeno
|
||||
una foto, o almeno un video); storie, evidenza e taggati hanno la loro voce. «Tutto» non comprende le foto del
|
||||
profilo, che stanno nella scheda dell'account.
|
||||
- **Account**, **Periodo** (ultimi 7 o 30 giorni, quest'anno, l'anno scorso, oppure dal… al…), **Provenienza**
|
||||
(scaricati da Instagram o importati). Ogni menu mostra il nome del filtro finché non scegli un valore.
|
||||
- **Ricerca** per nome dell'account e testo della didascalia (senza distinguere maiuscole e accenti).
|
||||
- Il cursore accanto a «Seleziona» regola la grandezza delle tessere. Sulle tessere: durata per i video, numero dei file
|
||||
per i post con più file, anello tratteggiato per le storie.
|
||||
|
||||
I nuovi elementi compaiono in cima senza spostare ciò che stai guardando.
|
||||
|
||||
## Il visualizzatore
|
||||
|
||||
Un clic su una tessera apre l'elemento a tutta finestra: frecce (anche da tastiera) per scorrere, Esc per chiudere, i
|
||||
video partono senza audio. A lato: la serie dei file, didascalia, dati (data, codice, autore, raccolte), file
|
||||
(nome, dimensioni, peso, cartella) e provenienza. Azioni:
|
||||
|
||||
- **Mostra nella cartella** (Windows) oppure **Scarica** il file (dal browser, in Docker);
|
||||
- **Apri su Instagram**, nel tuo browser;
|
||||
- **Elimina dalla libreria**.
|
||||
|
||||
## Eliminare
|
||||
|
||||
Eliminare chiede conferma. I file vengono cancellati dal disco e non si recuperano.
|
||||
|
||||
- **«Elimina dalla libreria»** (il predefinito) ricorda la scelta: l'elemento resta nell'elenco come «eliminato» e non
|
||||
viene scaricato di nuovo.
|
||||
- **«Eliminalo e lascia che torni»**: Febe dimentica l'elemento; se è ancora su Instagram, al prossimo controllo lo
|
||||
scarica di nuovo.
|
||||
|
||||
L'eliminazione si scrive prima nel file `_febe.jsonl` dell'account, poi nel database, poi sul disco: anche una
|
||||
ricostruzione del database la rispetta.
|
||||
|
||||
**La libreria non cancella e non sostituisce mai un file da sola.** Se un contenuto sparisce da Instagram, il file
|
||||
resta. Un file si elimina o si sostituisce solo per una scelta tua.
|
||||
|
||||
## Selezione multipla
|
||||
|
||||
«Seleziona» attiva la scelta delle tessere; nella barra in basso: **Esporta l'elenco** degli elementi scelti oppure
|
||||
**Elimina** (con la stessa conferma di sopra). «Fine» chiude la selezione.
|
||||
|
||||
## Esportare l'elenco in CSV
|
||||
|
||||
Il pulsante con l'icona del documento nella riga degli strumenti, **«Esporta l'elenco»**, scarica in un file CSV
|
||||
l'elenco degli elementi **mostrati dai filtri di adesso** (senza filtri: tutta la libreria). Con la selezione multipla
|
||||
si esportano solo gli elementi scelti.
|
||||
|
||||
Il file si chiama `febe-elementi-AAAA-MM-GG.csv` ed è fatto per aprirsi bene in Excel con le impostazioni italiane:
|
||||
`;` come separatore, codifica UTF-8 con BOM, date e ore locali. Colonne: Account, Tipo, Data, Ora, Codice,
|
||||
Identificativo, Didascalia, Autore, Raccolte, Provenienza, Stato, File, Nomi dei file, Indirizzo. I campi che Excel
|
||||
leggerebbe come formula (che cominciano con `=`, `+`, `-`, `@`) ricevono un apostrofo davanti.
|
||||
|
||||
Il CSV contiene le didascalie: trattalo come i dati che descrive.
|
||||
|
||||
## Doppioni dopo uno scaricamento
|
||||
|
||||
Quando Febe scarica una foto che sembra la stessa immagine già salvata nello stesso account (stessa immagine, file
|
||||
diverso), le tiene entrambe e mette la coppia in **«Doppioni da decidere»** (collegamento nella riga degli strumenti e
|
||||
in Attività). Per ogni coppia scegli: tieni il più grande, tieni quello già in libreria, tienili entrambi. Niente si
|
||||
decide da solo; ciò che scarti non viene riscaricato. Un file identico byte per byte (stesso SHA-256) a uno già
|
||||
presente nello stesso account non entra due volte: il nuovo viene saltato e, se quello presente era stato importato
|
||||
senza dati di Instagram, li riceve dall'elemento appena trovato.
|
||||
|
||||
## Cartelle e nomi dei file
|
||||
|
||||
- **Libreria:** dove finiscono foto e video, una cartella per account. Può stare su un disco di rete.
|
||||
- **Dati:** database, profilo del browser, miniature, registro, copie. Deve stare su un disco locale.
|
||||
|
||||
Due schemi dei nomi, in Impostazioni ▸ Generali ▸ Nomi dei file, con anteprima del risultato. Predefiniti:
|
||||
|
||||
```text
|
||||
{account}\{tipo}\{anno}\{data}_{ora}_{codice}_{n}
|
||||
{account}\evidenza\{raccolta}\{data}_{ora}_{codice}_{n}
|
||||
|
||||
marta.demo\post\2026\2026-10-10_18-22-05_DBx3kQ2_2.jpg
|
||||
marta.demo\evidenza\Estate 2025\2025-08-02_10-11-12_3391207_1.jpg
|
||||
```
|
||||
|
||||
- Segnaposto: `account`, `tipo`, `anno`, `mese`, `data`, `ora`, `codice`, `n` (posizione del file nell'elemento),
|
||||
`raccolta`. Un segnaposto sconosciuto è un errore.
|
||||
- Data e ora nei nomi sono nel tuo fuso; la data di modifica del file è quella di pubblicazione (si può spegnere).
|
||||
- I nomi sono ripuliti per Windows (caratteri vietati, nomi riservati, punti e spazi finali); un percorso oltre 240
|
||||
caratteri si accorcia prima nel nome del file, poi nelle cartelle. Un nome già occupato diventa `nome (2).ext`: mai
|
||||
una sovrascrittura.
|
||||
- Cambiare lo schema vale per i prossimi file: quelli già salvati non si rinominano.
|
||||
|
||||
Ogni cartella di account ha il suo **`_febe.jsonl`**: una riga per ogni elemento salvato (identificativi, date,
|
||||
didascalia, nomi dei file) e una per ogni eliminazione. Non va modificato né cancellato: è ciò che permette di
|
||||
ricostruire il database (vedi [Copie e ricostruzione](Copie-e-ricostruzione)). La libreria resta una cartella di file
|
||||
normali, leggibile anche senza Febe.
|
||||
@@ -0,0 +1,102 @@
|
||||
# Limiti e comportamento
|
||||
|
||||
Febe non cerca di sembrare un utente qualsiasi: cerca di comportarsi come **te che usi Instagram dal tuo computer**.
|
||||
Stesso dispositivo, stessa rete, orari plausibili, poche visite brevi, pause lunghe, nessuna fretta. La casualità
|
||||
riguarda il comportamento (quando, quanto, in che ordine, a che velocità); l'identità del browser non cambia mai.
|
||||
|
||||
Nessuno può garantire che basti. Per questo ci sono tre livelli indipendenti: un ritmo credibile, **tetti rigidi**
|
||||
che valgono anche quando il ritmo sbaglia, e un **interruttore** che ferma tutto al primo segnale (vedi
|
||||
[Attività e arresti](Attivita-e-arresti)).
|
||||
|
||||
Si regola in **Impostazioni ▸ Limiti e comportamento**.
|
||||
|
||||
## I valori sono stime prudenti
|
||||
|
||||
Instagram non pubblica limiti ufficiali. **I valori dei profili sono stime di partenza scelte con prudenza: non sono
|
||||
limiti ufficiali e non sono misure.** Riducono il rischio di rallentamenti e verifiche, senza azzerarlo, e vanno
|
||||
ritoccati guardando che cosa succede.
|
||||
|
||||
## Profili di prudenza
|
||||
|
||||
| | Prudente | Equilibrato | Rapido |
|
||||
|---|---|---|---|
|
||||
| Fascia oraria | 07:30–23:30, spostata ogni giorno fino a ± 40 min | 07:00–24:00, ± 30 min | 06:30–00:30, ± 30 min |
|
||||
| Durata di una sessione | 2–10 min | 3–14 min | 4–18 min |
|
||||
| Pausa tra le sessioni | 20–90 min | 12–60 min | 8–40 min |
|
||||
| Home, all'ora / al giorno | 4 / 30 | 5 / 45 | 6 / 60 |
|
||||
| Profili aperti | 12 / 100 | 20 / 180 | 30 / 300 |
|
||||
| Storie viste | 50 / 300 | 80 / 500 | 120 / 800 |
|
||||
| Pagine di storico | 20 / 100 | 30 / 180 | 45 / 300 |
|
||||
| Post singoli | 10 / 60 | 15 / 100 | 20 / 160 |
|
||||
| Pagine dell'elenco dei seguiti | 15 / 60 | 20 / 90 | 30 / 150 |
|
||||
| Dati scaricati al giorno | 4 GB | 8 GB | 16 GB |
|
||||
| Storico per account al giorno | 300 post | 500 post | 800 post |
|
||||
| Avvio graduale | 7 giorni | 5 giorni | 3 giorni |
|
||||
|
||||
- **«Prudente» è il predefinito e il consigliato.** «Rapido» chiede conferma e porta l'etichetta «Più rischio»:
|
||||
recupera prima, ma rallentamenti e verifiche diventano più probabili.
|
||||
- Se cambi un valore, il profilo diventa **«Su misura»**; scegliendo un profilo torni ai suoi valori.
|
||||
- «Storico per account al giorno» è il valore di partenza del limite che ogni account ha nelle sue impostazioni.
|
||||
- Limiti di ciò che l'interfaccia accetta: pausa minima non sotto i 5 minuti; sessione non oltre i 30; fascia non oltre
|
||||
le 20 ore; nessun tetto oltre il doppio di «Rapido»; almeno un giorno attivo.
|
||||
- I limiti salvati valgono da subito, anche per il motore che sta lavorando.
|
||||
|
||||
## La giornata di Febe
|
||||
|
||||
- **Fascia oraria e giorni.** Febe lavora solo dentro la fascia, con inizio e fine spostati ogni giorno di una quantità
|
||||
casuale (mai uniforme, e lo spostamento non si riestrae a un riavvio), e solo nei giorni attivi (tutti, di partenza).
|
||||
Fuori fascia non apre nulla di sua iniziativa: è tutto fermo, come per una persona che dorme. L'unica eccezione è
|
||||
«Controlla ora» confermato da te.
|
||||
- **Sessioni e pause.** Dentro la fascia l'attività è fatta di sessioni brevi separate da pause. Durate e pause si
|
||||
estraggono ogni volta a caso dentro gli estremi del profilo (distribuzione log-normale), mai uno schema fisso.
|
||||
- **Pavimento.** La pausa minima vale sempre, anche con molto lavoro arretrato: l'arretrato si smaltisce nei giorni,
|
||||
non stringendo le pause.
|
||||
- **Avvio del programma.** La prima sessione parte fra 2 e 10 minuti dopo l'avvio. Tetti e registro delle azioni sono
|
||||
su disco: **un riavvio non azzera nulla**, e un programma che riparte più volte non produce più traffico di uno che
|
||||
resta acceso.
|
||||
- **Composizione di una sessione.** Di norma comincia con il giro della pagina iniziale (i post recenti dei profili che
|
||||
segui e la barra delle storie), prosegue con le storie, poi con i controlli dei profili scaduti, infine con qualche
|
||||
pagina di storico. Circa una sessione su tre si limita al giro e alle storie. L'ordine degli account è estratto a caso
|
||||
con pesi (frequenza e ritardo), mai lo stesso. Lo storico avanza su un solo account per sessione.
|
||||
- **Umore della sessione.** Ogni sessione ha un fattore di velocità estratto una volta: alcune sono svelte, altre lente.
|
||||
- **Riposo.** A fine sessione, nelle pause e di notte il browser sta su una pagina vuota: nessuna pagina di Instagram
|
||||
resta aperta fuori da una sessione.
|
||||
- **Lo storico non corre più veloce degli scaricamenti.** Lo storico di un account si sospende finché quell'account ha
|
||||
più di 60 file in attesa o il tetto dei dati è raggiunto: gli indirizzi dei file scadono, accumularli non serve.
|
||||
|
||||
## Tetti
|
||||
|
||||
Ogni azione verso il sito passa dal **Governatore**, che controlla nell'ordine: interruttore, fascia oraria, sessione
|
||||
in corso, tetto della categoria (giornaliero e orario), distanza minima dall'azione precedente (circa 4 secondi con il
|
||||
ritmo «naturale»), limiti dell'account. Risponde con un permesso o con un rifiuto motivato.
|
||||
|
||||
- I tetti orari valgono sugli ultimi 60 minuti, quelli giornalieri sul giorno di calendario nel tuo fuso.
|
||||
- Sopra l'80% di un tetto il segno diventa ambra. Raggiunto un tetto, quel tipo di attività si ferma fino all'ora o al
|
||||
giorno dopo; le altre proseguono.
|
||||
- Quando valgono insieme più riduzioni (avvio graduale, tetti dimezzati dopo un rallentamento) si applica la più forte,
|
||||
non il loro prodotto.
|
||||
|
||||
## Avvio graduale
|
||||
|
||||
Se attivo (lo è di partenza), nei primi giorni dopo il primo collegamento e **dopo ogni «Riprendi» che segue una
|
||||
verifica o una disconnessione** i tetti partono dalla metà e risalgono in modo lineare fino al valore pieno, nei
|
||||
giorni previsti dal profilo. In Attività la nota dice a che punto sono («Avvio graduale: tetti al 64%»).
|
||||
|
||||
## Ritmo dei gesti
|
||||
|
||||
Lento, Naturale (predefinito) o Svelto: moltiplica tutte le attese fra un gesto e l'altro. Il puntatore si muove lungo
|
||||
traiettorie curve, lo scorrimento arriva a raffiche con soste di lettura, le storie si guardano per qualche secondo;
|
||||
ogni tanto c'è una distrazione più lunga. Febe non clicca mai nulla che non sia il bersaglio di una ricetta, e se non
|
||||
trova il bersaglio si ferma e lo segnala, invece di provare a caso.
|
||||
|
||||
## Arresti
|
||||
|
||||
Le durate dei fermi dopo un rallentamento sono fisse e non si modificano: **1 ora** la prima volta, **6 ore** la
|
||||
seconda nelle 24 ore, **24 ore** la terza; poi tetti dimezzati per 48 ore. Dopo una verifica o una disconnessione Febe
|
||||
non riparte da solo. Vedi [Attività e arresti](Attivita-e-arresti).
|
||||
|
||||
## Giudicare un profilo prima di usarlo
|
||||
|
||||
La simulazione fa girare il motore per 30 giorni (o quanti vuoi) contro un mondo finto e dice sessioni al giorno,
|
||||
azioni per categoria, tempi fra pubblicazione e scoperta, giorni per uno storico di 2.000 post e superamenti dei tetti
|
||||
(devono essere zero). Vedi [Sviluppo](Sviluppo).
|
||||
@@ -0,0 +1,84 @@
|
||||
# Primo collegamento
|
||||
|
||||
Febe lavora con il tuo account Instagram attraverso il **browser di Febe**, in cui accedi tu, a mano, nella vera
|
||||
pagina di Instagram. Password e codici li scrivi tu; Febe non li conserva mai. Ciò che resta è il profilo del browser
|
||||
nella cartella dei dati, con la sessione.
|
||||
|
||||
> Usa prima un **account di prova**. Passa al tuo account principale solo dopo aver visto Febe all'opera, e sempre con
|
||||
> il profilo «Prudente» (vedi [Limiti e comportamento](Limiti-e-comportamento)).
|
||||
|
||||
## Entrare nell'interfaccia (Docker)
|
||||
|
||||
Apri `http://<server>:8480/`: la pagina «Accedi a Febe» chiede la password del contenitore (`FEBE_PASSWORD`). Dopo
|
||||
cinque tentativi sbagliati da uno stesso indirizzo (o venti in tutto) l'accesso si blocca per un quarto d'ora. «Esci»
|
||||
chiude la sessione dell'interfaccia.
|
||||
|
||||
La prima volta, con la libreria vuota, compare la schermata di benvenuto: «Collegati a Instagram» oppure «Importa foto e
|
||||
video che hai già».
|
||||
|
||||
## Collegarsi a Instagram
|
||||
|
||||
Apri **Impostazioni ▸ Collegamento a Instagram** (o «Collegati a Instagram» dal benvenuto). Mentre sei in questa
|
||||
pagina il motore resta fermo.
|
||||
|
||||
**In Docker** la pagina carica subito la vera pagina di accesso di Instagram nella **vista remota**: il riquadro grande
|
||||
è il browser del server, che puoi usare con mouse e tastiera.
|
||||
|
||||
1. Accedi nella pagina: nome utente, password e, se l'hai attivata, la verifica in due passaggi.
|
||||
2. Aspetta la tua pagina iniziale. Se Instagram chiede di salvare l'accesso, accetta.
|
||||
3. Premi **«Ho finito»**: Febe controlla che l'accesso sia riuscito (guarda solo se il cookie di sessione esiste, senza
|
||||
leggerne il valore) e nasconde il browser.
|
||||
|
||||
**Su Windows** il browser è la finestra a parte «Browser di Febe» («Portalo in primo piano» la mostra): accedi lì, poi
|
||||
premi «Ho finito» nella finestra di Febe.
|
||||
|
||||
«Annulla» torna alle impostazioni senza collegarti.
|
||||
|
||||
## La password: due verità diverse
|
||||
|
||||
- **In Docker** la password la scrivi a distanza: i tasti passano dal server di Febe, che li inoltra al browser senza
|
||||
registrarli né salvarli. Ma attraversano la rete di casa e la memoria del server: per questo **la password di
|
||||
Instagram passa dal server**, e l'interfaccia non va mai esposta su Internet senza una VPN o un proxy con HTTPS
|
||||
(vedi [Sicurezza e riservatezza](Sicurezza-e-riservatezza)).
|
||||
- **Su Windows** la scrivi direttamente nella pagina di Instagram: Febe non la riceve e non la salva.
|
||||
|
||||
In tutti e due i casi resta solo la sessione del browser, nella cartella dei dati: **chi ha la cartella dei dati, o
|
||||
una sua copia, ha la sessione di Instagram.**
|
||||
|
||||
## Dopo il collegamento
|
||||
|
||||
- Il collegamento sopravvive ai riavvii: la sessione è nel profilo del browser (provato in locale; nel contenitore vero
|
||||
e su Windows è la voce S3 di [Ipotesi da verificare](Ipotesi-da-verificare)).
|
||||
- Comincia l'**avvio graduale**: per alcuni giorni i tetti partono dalla metà e risalgono piano (7 giorni con
|
||||
«Prudente»).
|
||||
- La prima sessione parte tra 2 e 10 minuti dopo l'avvio, e solo dentro la fascia oraria.
|
||||
- Lo stato del collegamento è sempre in fondo alla barra laterale: collegato, da collegare, verifica richiesta, sessione
|
||||
chiusa.
|
||||
- Il tuo profilo compare tra gli account segnato «Tu», con «Post in cui è taggato» attivo: è così che si scaricano i
|
||||
post in cui sei taggato. (Riconoscere il tuo account dai dati della pagina è l'ipotesi H10, ancora da confermare.)
|
||||
|
||||
Poi aggiungi gli account da seguire: [Account e impostazioni](Account-e-impostazioni).
|
||||
|
||||
## Usare il browser a mano
|
||||
|
||||
Da collegato, **«Usa il browser»** apre il browser di Febe (in Docker la pagina «Browser», con la vista remota e i
|
||||
comandi «Indietro» e «Ricarica»; su Windows la finestra). Serve per controllare qualcosa a mano. Mentre lo usi il
|
||||
motore resta fermo; quando hai finito premi «Ho finito». Se lasci la pagina Browser, o la pagina Collegamento mentre
|
||||
accedi, senza premere «Ho finito» (un'altra pagina, la scheda chiusa o ricaricata), vale come «Annulla»: il browser
|
||||
torna sulla pagina vuota e il motore può lavorare di nuovo.
|
||||
|
||||
## Scollegarsi
|
||||
|
||||
**«Scollega…»** chiede conferma, ferma il motore e cancella il profilo del browser, con la sessione. Per chiudere la
|
||||
sessione anche dal lato di Instagram, prima esci dal sito usando tu il browser (menu del profilo, «Esci»), poi torna in
|
||||
Collegamento e scollega.
|
||||
|
||||
## Un account, un motore
|
||||
|
||||
Usa un solo Febe per account: il contenitore e la versione per Windows non vanno collegati insieme allo stesso
|
||||
profilo, e non vanno usati insieme sullo stesso account.
|
||||
|
||||
## Se compare una verifica
|
||||
|
||||
Se Instagram chiede una verifica mentre ti colleghi, completala a mano nella stessa pagina. Se la chiede più tardi,
|
||||
mentre Febe lavora, Febe si ferma: vedi [Attività e arresti](Attivita-e-arresti).
|
||||
@@ -0,0 +1,109 @@
|
||||
# Problemi comuni
|
||||
|
||||
Che cosa vedi, perché succede, che cosa fare. Quasi sempre il primo posto da guardare è il **registro**: in Docker
|
||||
`/dati/registro/febe-AAAA-MM-GG.log` e `docker logs febe`; su Windows la cartella `registro` dentro la cartella dei
|
||||
dati.
|
||||
|
||||
## Avvio e configurazione
|
||||
|
||||
| Che cosa vedi | Che cosa fare |
|
||||
|---|---|
|
||||
| L'interfaccia mostra solo la pagina «Febe non può partire» con «Manca la password dell'interfaccia» | Imposta `FEBE_PASSWORD` nel contenitore e riavvialo. Fino ad allora motore e browser restano spenti, e nessun dato è perso |
|
||||
| «La cartella dei dati è su un disco di rete» | Collega `/dati` (su Windows la cartella dei dati) a una cartella su un disco locale: su Unraid l'appdata sul disco di cache. SQLite e il profilo del browser in rete si rovinano |
|
||||
| «La cartella dei dati non è scrivibile» | Controlla `PUID`/`PGID` e i permessi della cartella sul server |
|
||||
| Il contenitore si ferma subito con un messaggio su `PUID=0` | Febe non gira come root: usa un utente normale (su Unraid 99/100) |
|
||||
| Unraid non crea il contenitore: «opening seccomp profile … no such file» | Manca `/mnt/user/appdata/febe-seccomp.json`: è il passo 2 dell'[installazione](Installazione-Docker-e-Unraid) |
|
||||
| Nel registro: «Il browser non parte… No usable sandbox» | Il contenitore gira senza il profilo seccomp dedicato: aggiungi `--security-opt seccomp=…` (vedi la sezione sulla sandbox in [Installazione con Docker e Unraid](Installazione-Docker-e-Unraid)) |
|
||||
| La pagina Collegamento dice «Il browser di Febe non è disponibile» | Febe non ha avviato il suo browser: leggi il registro, riavvia; di solito è la sandbox (riga sopra) o la porta di debug occupata |
|
||||
| La porta è occupata | Cambia la porta pubblicata (o `FEBE_PORTA`) |
|
||||
| Unraid non scarica l'immagine | Il registro `192.168.30.23:3000` è in HTTP: deve stare fra gli `insecure-registries` del Docker di Unraid (vedi l'[installazione](Installazione-Docker-e-Unraid)); se il pacchetto non è pubblico, accedi dal terminale: `docker login 192.168.30.23:3000` |
|
||||
| Il browser rifiuta l'interfaccia con un errore 400 sul nome | `FEBE_HOST` è impostata e il nome con cui apri l'interfaccia non è nell'elenco: aggiungilo |
|
||||
| «Password sbagliata» anche con quella giusta, poi «bloccato» | Dopo 5 errori da uno stesso indirizzo (20 in tutto) l'accesso si blocca per 15 minuti: aspetta, poi riprova |
|
||||
| Su Windows: Febe dice che manca WebView2 | Installa il runtime WebView2 dal collegamento che Febe mostra |
|
||||
|
||||
## Collegamento
|
||||
|
||||
| Che cosa vedi | Che cosa fare |
|
||||
|---|---|
|
||||
| La vista remota è lenta o non risponde | La vista è un'immagine della pagina inviata dal server: aspetta qualche secondo dopo ogni clic. Se dice «La vista remota non risponde», premi «Riprova»; se si apre in un'altra finestra, la precedente si chiude da sola (una vista alla volta) |
|
||||
| «Ho finito» dice che l'accesso non è riuscito | Nella pagina deve comparire la tua pagina iniziale di Instagram, non il modulo di accesso: completa l'accesso, poi di nuovo «Ho finito» |
|
||||
| Dopo un riavvio Febe chiede di nuovo l'accesso | Non dovrebbe: la sessione è nel profilo del browser in `/dati/browser`. Controlla che `/dati` sia un volume persistente e non sia stato cancellato; riferisci il caso (è la voce S3 di [Ipotesi da verificare](Ipotesi-da-verificare)) |
|
||||
|
||||
## Il motore non scarica nulla
|
||||
|
||||
Controlla in quest'ordine, guardando [Attività](Attivita-e-arresti):
|
||||
|
||||
1. **Raccolta da Instagram non ancora attiva.** Se in «Appena fatto» vedi «non può girare su instagram: la mappa dei
|
||||
bersagli non è ancora compilata», è lo stato attuale del progetto: le ricette su Instagram aspettano i risultati
|
||||
della sonda (ipotesi H1–H11, vedi [Ipotesi da verificare](Ipotesi-da-verificare)). Non è un guasto.
|
||||
2. **Non collegato**, **verifica richiesta** o **sessione chiusa**: la barra laterale lo dice. Vedi
|
||||
[Primo collegamento](Primo-collegamento) e [Attività e arresti](Attivita-e-arresti).
|
||||
3. **Fuori fascia** o **giorno non attivo**: Attività dice «Fuori fascia» e quando riprende.
|
||||
4. **In pausa**: «Riprendi».
|
||||
5. **Avvio appena fatto:** la prima sessione parte 2–10 minuti dopo l'avvio.
|
||||
6. **Tetto raggiunto** (ambra o pieno in «Limiti di oggi»), oppure **avvio graduale** con i tetti ancora bassi.
|
||||
7. L'account è **In pausa**, **Solo archivio** o **Non raggiungibile**, oppure ha «Tieni aggiornato» spento ed è già
|
||||
stato scaricato una volta.
|
||||
8. **Disco pieno:** vedi sotto.
|
||||
|
||||
## File e libreria
|
||||
|
||||
| Che cosa vedi | Che cosa fare |
|
||||
|---|---|
|
||||
| File «da scaricare» che non arrivano | Gli scaricamenti hanno un loro tetto giornaliero di dati; durante un fermo continuano solo quelli già in coda. Un indirizzo scaduto torna «da scaricare» e si recupera rileggendo il post; per le storie scadute non c'è recupero |
|
||||
| Elementi «falliti» | Dopo cinque tentativi non riusciti un file resta «fallito»; anche una storia scaduta prima dello scaricamento finisce così |
|
||||
| Nel visualizzatore: «Il file non è sul disco» | Il file è stato spostato o cancellato fuori da Febe. Rimettilo dov'era o elimina l'elemento |
|
||||
| «N doppioni da decidere» | Foto che sembrano la stessa immagine salvata due volte: decidi tu in «Doppioni da decidere» (vedi [Libreria](Libreria)) |
|
||||
| Un elemento eliminato torna | Hai usato «Eliminalo e lascia che torni»: elimina di nuovo con «Elimina dalla libreria» |
|
||||
| Il CSV si apre male in Excel | Aprilo con doppio clic (non con «Importa testo» impostando un altro separatore): è fatto per Excel in italiano, con `;` e UTF-8 con BOM |
|
||||
|
||||
## Disco quasi pieno
|
||||
|
||||
L'avviso «Disco quasi pieno» arriva quando sul disco della libreria o della cartella dei dati restano meno di 10 GB o
|
||||
meno del 5%. Libera spazio su quel disco. Per spostare la libreria: in Docker cambia il volume `/libreria` (sposta prima
|
||||
i file, con Febe fermo); su Windows usa «Cambia…» in Impostazioni ▸ Generali (i nuovi account vanno nella cartella
|
||||
nuova, quelli vecchi restano dove sono). La cartella dei dati: in Docker sposta il volume `/dati` con il contenitore
|
||||
fermo; su Windows «Cambia…» vale dal prossimo avvio di Febe.
|
||||
|
||||
## Formato non riconosciuto, ricetta sospesa, bersaglio non trovato
|
||||
|
||||
Vuol dire che Instagram ha cambiato le sue risposte o le sue pagine. Febe non insiste: dopo tre volte di fila sospende
|
||||
la ricetta e Attività lo dice. Che cosa fare:
|
||||
|
||||
1. Avvia la **sonda passiva** e raccogli un campione nuovo navigando tu le pagine interessate (procedura in
|
||||
`docs/prove-dal-vivo.md`, parte A, nel repository).
|
||||
2. Ripulisci e verifica il campione, e fallo arrivare a chi aggiorna i lettori o la mappa dei bersagli.
|
||||
3. Dopo l'aggiornamento di Febe, premi **«Riattiva»** sulla ricetta sospesa in Attività.
|
||||
|
||||
Non riattivare una ricetta solo per farla ripartire: si sospenderebbe di nuovo dopo tre tentativi.
|
||||
|
||||
## Avvisi
|
||||
|
||||
| Messaggio di «Invia una prova» | Che cosa fare |
|
||||
|---|---|
|
||||
| «Telegram non riconosce il gettone del bot» | Copia di nuovo il gettone per intero dal messaggio di BotFather |
|
||||
| «Il gettone del bot non ha la forma giusta» | Il gettone è fatto di cifre, due punti e una lunga serie di lettere, senza spazi |
|
||||
| «Telegram non trova la chat» | Controlla l'identificativo e scrivi almeno un messaggio al bot prima di riprovare |
|
||||
| «Il bot non può scriverti» | Apri la chat con il bot e premi «Avvia» (o sbloccalo; in un gruppo, aggiungilo) |
|
||||
| «Telegram non ha risposto» o «non è raggiungibile» | Il server (in Docker, il contenitore) deve poter uscire su Internet verso `api.telegram.org` |
|
||||
| «Questa istanza di Febe non invia messaggi Telegram» | Sei nella dimostrazione o in una prova: lì non parte nulla |
|
||||
|
||||
Gli avvisi che non sono arrivati sono elencati in Attività ▸ Avvisi come «Avviso non inviato». Vedi
|
||||
[Avvisi e Telegram](Avvisi-e-Telegram).
|
||||
|
||||
## Importazione
|
||||
|
||||
| Che cosa vedi | Che cosa fare |
|
||||
|---|---|
|
||||
| «Sposta» non c'è | La sorgente è in sola lettura (sempre, in Docker con `/importa`): si può solo copiare |
|
||||
| Non trovi la cartella da importare (Docker) | Deve stare dentro il volume `/importa` del contenitore |
|
||||
| La sorgente è rifiutata | È dentro o sopra la cartella dei dati, sopra la libreria o dentro una cartella di account di Febe |
|
||||
| «Importa N file» importa meno file di quanti ne hai | Le cartelle senza account e i doppioni non ancora decisi restano fuori: il pulsante dice quanti |
|
||||
| Date sbagliate su una libreria di 4K Stogram | Il riconoscitore dei nomi di 4K Stogram è un'ipotesi non verificata: rifai l'analisi senza l'opzione, o controlla date e codici nella revisione |
|
||||
|
||||
## Database
|
||||
|
||||
| Che cosa vedi | Che cosa fare |
|
||||
|---|---|
|
||||
| Il database si è rovinato o è sparito | Torna a una copia di `copie/`, oppure ricostruiscilo dalla libreria: vedi [Copie e ricostruzione](Copie-e-ricostruzione) |
|
||||
| «Ricostruisci» è rifiutato | C'è un'importazione in corso: aspetta che finisca |
|
||||
@@ -0,0 +1,90 @@
|
||||
# Sicurezza e riservatezza
|
||||
|
||||
## La sessione di Instagram sta nella cartella dei dati
|
||||
|
||||
Quando accedi a Instagram nel browser di Febe, la sessione resta nel profilo del browser, dentro la cartella dei dati
|
||||
(`/dati/browser` in Docker, `%LOCALAPPDATA%\Febe\browser` su Windows). Febe non la esporta, non la mostra e non la
|
||||
copia altrove.
|
||||
|
||||
- **Chi ha la cartella dei dati, o una sua copia, ha la sessione di Instagram**: può usare il tuo account senza
|
||||
password. Vale anche per i backup che includono quella cartella (il backup dell'appdata di Unraid, un backup del
|
||||
profilo di Windows): trattali come una password.
|
||||
- La cartella dei dati contiene anche il gettone del bot Telegram (nel database e nelle sue copie).
|
||||
- Se pensi che qualcuno abbia avuto la cartella, esci da Instagram su tutti i dispositivi dall'app e cambia la password;
|
||||
poi scollega Febe e ricollegalo.
|
||||
- I cookie non si copiano da una macchina all'altra: ogni Febe fa il suo accesso.
|
||||
|
||||
## Docker: l'interfaccia non va esposta su Internet
|
||||
|
||||
- **Non esporre mai l'interfaccia Docker su Internet** senza una VPN (per esempio WireGuard o Tailscale) o un proxy con
|
||||
HTTPS davanti.
|
||||
- **In Docker la password di Instagram passa dal server.** Dalla vista remota tasti, password e codici attraversano la
|
||||
rete di casa e la memoria del server per arrivare al browser di Febe. Non vengono registrati né conservati, ma su HTTP
|
||||
in chiaro sono leggibili da chi sta sulla stessa rete. Per questo conviene fare l'accesso da una rete di cui ti fidi,
|
||||
o attraverso la VPN o il proxy con HTTPS.
|
||||
- L'interfaccia è protetta da password (`FEBE_PASSWORD`), con un cookie di sessione non leggibile dagli script e
|
||||
limitato allo stesso sito (`HttpOnly`, `SameSite=Strict`), valido 30 giorni; dopo 5 tentativi sbagliati da uno
|
||||
stesso indirizzo, o 20 in tutto in un quarto d'ora, l'accesso si blocca per 15 minuti. Quando arrivi in HTTPS (anche
|
||||
attraverso il proxy fidato) il cookie è anche `Secure`: il browser non lo manda mai in chiaro. Dopo la password la
|
||||
pagina di accesso torna solo a una pagina di Febe: un collegamento costruito per portarti su un altro sito non funziona.
|
||||
- Ogni comando, gli eventi dal server e la vista remota controllano che la richiesta arrivi dall'interfaccia stessa
|
||||
(intestazione `Origin`): un'altra pagina aperta nel tuo browser non può comandare Febe né la vista remota.
|
||||
- `FEBE_HOST` limita i nomi con cui si raggiunge l'interfaccia (difesa in più contro il DNS rebinding);
|
||||
`FEBE_PROXY_FIDATO=1` serve dietro un proxy con HTTPS, che deve passare `X-Forwarded-Host` e `X-Forwarded-Proto`.
|
||||
- Si pubblica solo la porta dell'interfaccia; la porta di debug del browser resta dentro il contenitore, su `127.0.0.1`.
|
||||
|
||||
## Windows
|
||||
|
||||
Il server di Febe ascolta solo su `127.0.0.1` e accetta richieste solo con un gettone generato a ogni avvio, che conosce
|
||||
solo la finestra di Febe; si controllano anche `Host` e `Origin`. La password di Instagram la scrivi direttamente nella
|
||||
pagina di Instagram, nella finestra «Browser di Febe»: Febe non la riceve.
|
||||
|
||||
## La sandbox di Chromium (Docker)
|
||||
|
||||
Con il profilo seccomp dedicato di Febe (l'impostazione consigliata, già nel modello di Unraid e in `compose.yml`) la
|
||||
sandbox di Chromium è completa: **nessun compromesso**. Il compromesso esiste solo se scegli `FEBE_SENZA_SANDBOX=1`
|
||||
(`--no-sandbox`): una pagina che sfruttasse un difetto del browser non troverebbe la sandbox a fermarla, solo i limiti
|
||||
del contenitore. Si accetta solo perché quel browser visita esclusivamente Instagram, e solo se il profilo seccomp non
|
||||
si può usare. Dettagli in [Installazione con Docker e Unraid](Installazione-Docker-e-Unraid).
|
||||
|
||||
## Il browser di Febe
|
||||
|
||||
- È un browser normale: nessuna modifica di user agent, impronta, lingua, fuso orario o intestazioni; niente modalità
|
||||
senza finestra; niente proxy; nessuna estensione «stealth».
|
||||
- Salvataggio delle password e compilazione automatica sono spenti: nel profilo resta solo la sessione.
|
||||
- Fra una sessione e l'altra sta su una pagina vuota; non segue mai collegamenti che portano fuori da Instagram.
|
||||
- Verso Instagram parla solo il browser di Febe. L'unica altra connessione verso i server di Instagram è lo
|
||||
scaricamento dei file già indicati dalla pagina, dal solo CDN (e oggi passa anch'essa dal browser).
|
||||
|
||||
## Sola lettura
|
||||
|
||||
Febe non mette «mi piace», non segue, non commenta, non scrive messaggi, non reagisce alle storie, non tocca annunci né
|
||||
suggerimenti. L'unica traccia che lascia è quella di una normale visita, **compresa la visualizzazione delle storie:
|
||||
le storie aperte da Febe risultano viste.** Un profilo privato che non ti ha accettato non si tocca.
|
||||
|
||||
## Un account, un motore
|
||||
|
||||
Il contenitore e la versione per Windows **non vanno usati insieme sullo stesso account**: due motori sommano le
|
||||
visite e il rischio.
|
||||
|
||||
## Che cosa finisce nei registri
|
||||
|
||||
Il registro contiene azioni ed esiti: nomi utente sì; didascalie, corpi delle risposte, password, cookie, tasti,
|
||||
indirizzi firmati dei file, gettoni (compreso quello di Telegram) no. Il client del browser registra solo i nomi dei
|
||||
comandi, mai i loro parametri. Il registro è nella cartella dei dati (`registro`), un file al giorno, tenuto
|
||||
quattordici giorni.
|
||||
|
||||
## Che cosa esce da Febe
|
||||
|
||||
| Verso | Che cosa | Quando |
|
||||
|---|---|---|
|
||||
| Instagram | Le visite del browser di Febe, con la tua sessione | Nelle sessioni, dentro la fascia |
|
||||
| CDN di Instagram | Lo scaricamento dei file indicati dalla pagina | Quando ci sono file in coda |
|
||||
| Telegram (`api.telegram.org`) | Il testo degli avvisi | Solo se hai configurato il bot |
|
||||
|
||||
Nient'altro: niente statistiche, niente aggiornamenti automatici, nessun carattere o icona caricato dalla rete.
|
||||
|
||||
## I contenuti restano dei loro autori
|
||||
|
||||
Febe è un archivio privato: non ripubblica e non condivide nulla. Le esportazioni CSV contengono le didascalie:
|
||||
trattale come i dati che descrivono.
|
||||
@@ -0,0 +1,155 @@
|
||||
# Sviluppo
|
||||
|
||||
Febe è scritto in C# 14 su .NET 10, in un'unica soluzione (`Febe.slnx`). L'interfaccia è HTML, CSS e JavaScript senza
|
||||
framework né fase di build. La specifica è `docs/SPECIFICA.md`; le scelte prese strada facendo sono in
|
||||
`docs/decisioni.md`, lo stato del lavoro in `docs/stato.md`.
|
||||
|
||||
## Due regole prima di tutto
|
||||
|
||||
- **Nessuna prova, script o verifica contatta Instagram** (né Meta, né il loro CDN): si usa solo il sito di prova
|
||||
locale. Le prove dal vivo le lancia Alberto. Lo stesso vale per **Telegram**: le prove usano un gestore HTTP finto,
|
||||
mai `api.telegram.org`.
|
||||
- **Dipendenze a elenco chiuso** (`Directory.Packages.props`): Microsoft.Data.Sqlite, SkiaSharp (con le librerie native
|
||||
per Linux), Microsoft.Web.WebView2, MSTest. Tutto il resto viene dalla libreria di base di .NET.
|
||||
|
||||
## Com'è fatto il repository
|
||||
|
||||
| Cartella | Che cosa c'è |
|
||||
|---|---|
|
||||
| `src/Febe.Core` | Dominio e logica senza piattaforma: motore, Governatore, interruttore, ricette, lettori, libreria, importazione, avvisi (`Alerts/`) |
|
||||
| `src/Febe.Data` | SQLite, migrazioni come file SQL numerati, scrittore unico |
|
||||
| `src/Febe.Browser` | Client del protocollo DevTools, `ChromiumProcessHost`, gesti, cattura delle risposte, vista remota |
|
||||
| `src/Febe.Web` | API, eventi dal server, interfaccia in `wwwroot/` incorporata nell'assembly (vedi `src/Febe.Web/LEGGIMI.md`) |
|
||||
| `src/Febe.Server` | L'eseguibile per Linux e Docker (`febe`), con la dimostrazione e la simulazione |
|
||||
| `src/Febe.Desktop` | L'eseguibile per Windows (WPF, WebView2) |
|
||||
| `tests/Febe.Tests` | Le prove (MSTest), con i campioni ripuliti in `tests/campioni/` |
|
||||
| `tools/Febe.SitoDiProva` | Il sito locale per le prove senza Instagram |
|
||||
| `tools/Febe.Sonda` | La sonda passiva per raccogliere i campioni |
|
||||
| `tools/schermate` | Le schermate dell'interfaccia per il confronto con i mockup |
|
||||
| `docker/` | `Dockerfile`, `compose.yml`, `entrypoint.sh`, file di Chromium (criteri, profilo seccomp), modello di Unraid |
|
||||
| `docs/` | Specifica, decisioni, stato, Docker, prove dal vivo, esiti della sonda, mockup, schermate, e questa guida (`docs/guida/`) |
|
||||
|
||||
## Compilare e provare
|
||||
|
||||
```sh
|
||||
dotnet build Febe.slnx -warnaserror
|
||||
dotnet test tests/Febe.Tests
|
||||
dotnet test tests/Febe.Tests --filter "FullyQualifiedName~Febe.Tests.Alerts"
|
||||
```
|
||||
|
||||
- Gli avvisi del compilatore sono errori. `Febe.Desktop` si compila anche da Linux (`EnableWindowsTargeting`), ma gira
|
||||
solo su Windows.
|
||||
- Le prove con un browser vero cercano Chromium in `FEBE_CHROMIUM` (o nel `PATH`) e Xvfb nel `PATH`; se mancano
|
||||
risultano inconcludenti, non fallite. Lo stesso per le prove d'insieme del server (`Febe.Tests.Server`), che avviano
|
||||
la composizione vera contro il sito di prova.
|
||||
- Il motore si prova con un orologio virtuale e un seme fisso; le prove d'insieme con un orologio compresso (10×).
|
||||
- La prova `Febe.Tests.Docs` controlla che questa guida dica tutto ciò che la specifica chiede (§15) e che ogni
|
||||
collegamento fra le pagine porti a una pagina che esiste.
|
||||
|
||||
## Dimostrazione
|
||||
|
||||
```sh
|
||||
dotnet run --project src/Febe.Server -- --demo [--porta 8480] [--fuso Europe/Rome]
|
||||
```
|
||||
|
||||
Parte senza browser e senza rete, solo su `127.0.0.1` e senza password, con una libreria temporanea di account finti
|
||||
(`.demo`), immagini generate e un motore finto; la cartella si cancella alla chiusura. Non scrive mai nella libreria
|
||||
vera e non invia messaggi Telegram.
|
||||
|
||||
- Scene: `?scena=normale`, `sessione`, `fermo`, `scollegato`, `errore`; tema `?tema=chiaro` o `scuro`; veste
|
||||
`?veste=desktop` o `docker`.
|
||||
- Indirizzi diretti: `/account?dialogo=aggiungi`, `/account/3/impostazioni`, `/importa?passo=3`, `/doppioni`.
|
||||
- Per modificare l'interfaccia senza ricompilare:
|
||||
`FEBE_INTERFACCIA=$PWD/src/Febe.Web/wwwroot dotnet run --project src/Febe.Server -- --demo`, poi basta ricaricare.
|
||||
|
||||
## Simulazione
|
||||
|
||||
```sh
|
||||
dotnet run --project src/Febe.Server -- --simula 30g --profilo prudente [--csv resoconto.csv] [--seme 7]
|
||||
```
|
||||
|
||||
Fa girare il motore vero con l'orologio virtuale contro un mondo finto (40 account, 25 seguiti, uno con uno storico di
|
||||
2.000 post, qualche rallentamento a caso) e scrive il resoconto: sessioni al giorno, azioni per categoria al giorno e
|
||||
nell'ora peggiore, tempo medio e massimo fra pubblicazione e scoperta, giorni per lo storico, superamenti dei tetti
|
||||
(devono essere zero). Profili: `prudente`, `equilibrato`, `rapido`. È il modo per giudicare un profilo prima di usarlo.
|
||||
|
||||
## Il sito di prova
|
||||
|
||||
```sh
|
||||
dotnet run --project tools/Febe.SitoDiProva -- --porta 8481 --porta-cdn 8482
|
||||
```
|
||||
|
||||
Un sito locale con pagine spoglie e dati sintetici (`alberto.prova`, `marta.prova`, …): pagina iniziale con barra delle
|
||||
storie, profili con griglia che carica scorrendo, visualizzatore delle storie e delle raccolte, elenco dei seguiti, post
|
||||
singoli, e i casi di arresto. Non somiglia a Instagram e non ha pagine di accesso. I casi di arresto si comandano da
|
||||
fuori: `/_controllo/modo?valore=troppe-richieste|verifica|sessione-scaduta|vuoto|formato-sconosciuto|normale`.
|
||||
Dettagli in `tools/Febe.SitoDiProva/LEGGIMI.md`.
|
||||
|
||||
Il server vero contro il sito di prova (mai Instagram):
|
||||
|
||||
```sh
|
||||
FEBE_PASSWORD=prova dotnet run --project src/Febe.Server -- \
|
||||
--dati /tmp/febe/dati --libreria /tmp/febe/libreria --importa /tmp/febe/importa --ascolta 127.0.0.1 \
|
||||
--sito-di-prova http://127.0.0.1:8481 --accesso-di-prova --prima-sessione 5
|
||||
```
|
||||
|
||||
`--sito-di-prova` accetta solo indirizzi di questo computer; `--accesso-di-prova` apre il sito una volta all'avvio,
|
||||
così il suo cookie di sessione esiste come dopo un accesso; `--prima-sessione N` fa partire la prima sessione dopo N
|
||||
secondi. Come root servono `--senza-sandbox` e, se Chromium non è nel `PATH`, `FEBE_CHROMIUM`. Per provare gli avvisi:
|
||||
imposta Telegram in Impostazioni ▸ Notifiche e chiedi al sito una verifica con `/_controllo/modo?valore=verifica`.
|
||||
|
||||
## La sonda
|
||||
|
||||
```sh
|
||||
febe-sonda registra --cartella <fuori dal repository> [--display :0 | --xvfb] [--chromium <file>]
|
||||
febe-sonda ripulisci --da <grezzi> --a <ripuliti>
|
||||
febe-sonda verifica --grezzi <grezzi> --ripuliti <ripuliti>
|
||||
```
|
||||
|
||||
(oppure `dotnet run --project tools/Febe.Sonda -- …`). È passiva: apre il browser e registra ciò che la pagina riceve
|
||||
mentre navighi tu; non compie gesti. I campioni grezzi stanno fuori dal repository, contengono dati di altre persone e
|
||||
si cancellano dopo l'uso; nel repository entrano solo i campioni ripuliti. La procedura completa è la parte A di
|
||||
`docs/prove-dal-vivo.md`; vedi anche [Ipotesi da verificare](Ipotesi-da-verificare).
|
||||
|
||||
## Schermate
|
||||
|
||||
`bash tools/schermate/tutte.sh 8490` rifà le schermate di `docs/schermate/` da una dimostrazione avviata su quella
|
||||
porta, per il confronto con i mockup (§10.7 della specifica); le differenze rimaste sono in
|
||||
`docs/schermate/differenze.md`. Lo strumento accetta solo indirizzi di questo computer.
|
||||
|
||||
## Immagine Docker
|
||||
|
||||
```sh
|
||||
docker build -f docker/Dockerfile -t febe .
|
||||
```
|
||||
|
||||
La compilazione e tutte le prove girano dentro la costruzione dell'immagine (quelle con il browser vero lì si saltano
|
||||
da sole). Vedi [Installazione con Docker e Unraid](Installazione-Docker-e-Unraid) e `docs/docker.md`.
|
||||
|
||||
## CI e rilascio
|
||||
|
||||
Il repository è sul Gitea di casa (<https://gitea.encke-hake.ts.net/Alby96/Febe>); la CI usa Gitea Actions in
|
||||
`.gitea/workflows/`:
|
||||
|
||||
- `verifica.yml`, a ogni push e pull request: compilazione con gli avvisi come errori, tutte le prove, costruzione
|
||||
dell'immagine Docker (senza pubblicarla) e due controlli sull'immagine (Chromium presente, lingua italiana generata);
|
||||
- `rilascio.yml`, a ogni tag `vX.Y.Z`: immagine Docker sul registro di Gitea, installatore Windows e release. Al 13
|
||||
ottobre 2026 è in preparazione: se il file non c'è ancora in `.gitea/workflows/`, il rilascio non è automatico.
|
||||
|
||||
La versione sta solo in `Directory.Build.props` (`<Version>`); il tag deve coincidere.
|
||||
|
||||
## La guida
|
||||
|
||||
Le pagine di questa guida sono i file di `docs/guida/`, una pagina del wiki per file (`_Sidebar.md` è la navigazione).
|
||||
Il wiki di Gitea è un repository git a parte: per pubblicarla si copiano i file in
|
||||
`https://gitea.encke-hake.ts.net/Alby96/Febe.wiki.git` e si fa push. I collegamenti fra le pagine sono nel formato del
|
||||
wiki, `[Testo](Nome-Pagina)`, senza `.md`.
|
||||
|
||||
## Convenzioni
|
||||
|
||||
- Codice e commenti in inglese; interfaccia, documenti e messaggi in italiano (glossario: appendice D della specifica).
|
||||
- Nel motore mai `DateTime.Now`, `Task.Delay` o `Random` diretti: si usano `IClock` e `IRandomSource`.
|
||||
- Mai password, cookie, tasti, gettoni o corpi di risposta nei registri; il client DevTools registra solo i nomi dei
|
||||
comandi. Gli indirizzi verso Telegram contengono il gettone del bot: non si registrano mai.
|
||||
- La libreria non cancella e non sostituisce file da sola.
|
||||
- Una scelta tecnica nuova si scrive in `docs/decisioni.md` con data e motivo.
|
||||
@@ -0,0 +1,23 @@
|
||||
**[Febe](Home)**
|
||||
|
||||
**Installare**
|
||||
- [Docker e Unraid](Installazione-Docker-e-Unraid)
|
||||
- [Windows](Installazione-Windows)
|
||||
- [Primo collegamento](Primo-collegamento)
|
||||
|
||||
**Usare Febe**
|
||||
- [Account e impostazioni](Account-e-impostazioni)
|
||||
- [Libreria](Libreria)
|
||||
- [Importazione](Importazione)
|
||||
- [Limiti e comportamento](Limiti-e-comportamento)
|
||||
- [Attività e arresti](Attivita-e-arresti)
|
||||
- [Avvisi e Telegram](Avvisi-e-Telegram)
|
||||
|
||||
**Tenere al sicuro**
|
||||
- [Copie e ricostruzione](Copie-e-ricostruzione)
|
||||
- [Sicurezza e riservatezza](Sicurezza-e-riservatezza)
|
||||
- [Problemi comuni](Problemi-comuni)
|
||||
|
||||
**Prove e sviluppo**
|
||||
- [Ipotesi da verificare](Ipotesi-da-verificare)
|
||||
- [Sviluppo](Sviluppo)
|
||||
|
After Width: | Height: | Size: 944 KiB |
|
After Width: | Height: | Size: 1.1 MiB |
|
After Width: | Height: | Size: 236 KiB |
|
After Width: | Height: | Size: 161 KiB |
|
After Width: | Height: | Size: 143 KiB |
@@ -0,0 +1,14 @@
|
||||
# Mockup
|
||||
|
||||
Le immagini sono il riferimento grafico di §10.3 della specifica. Sono in scala 1,25 (1800 pixel di larghezza).
|
||||
|
||||
| File | Stato |
|
||||
|---|---|
|
||||
| `00-panoramica.png` | Originale |
|
||||
| `01-libreria.png` | Originale |
|
||||
| `03-account.png` | Originale |
|
||||
| `08-impostazioni-generali.png` | Originale |
|
||||
| `10-collegamento-instagram.png` | Originale |
|
||||
| `miniature/02…14` | **Ritagli ingranditi della panoramica**: gli originali a piena risoluzione non sono stati forniti. Bastano per disposizione e gerarchia, non per misure e testi minuti |
|
||||
|
||||
Quando arrivano gli originali mancanti vanno messi qui con i nomi di §10.3 e i ritagli in `miniature/` si possono cancellare.
|
||||
|
After Width: | Height: | Size: 340 KiB |
|
After Width: | Height: | Size: 384 KiB |
|
After Width: | Height: | Size: 326 KiB |
|
After Width: | Height: | Size: 329 KiB |
|
After Width: | Height: | Size: 312 KiB |
|
After Width: | Height: | Size: 414 KiB |
|
After Width: | Height: | Size: 342 KiB |
|
After Width: | Height: | Size: 626 KiB |
|
After Width: | Height: | Size: 568 KiB |
|
After Width: | Height: | Size: 803 KiB |
@@ -0,0 +1,282 @@
|
||||
# Prove dal vivo (specifica §14.4)
|
||||
|
||||
Le esegue **solo Alberto**, con l'**account di prova** (domanda 2 di §16), mai con l'account principale prima della
|
||||
fine di M3. Ogni elenco dice che cosa fare, che cosa aspettarsi e che cosa riferire. Se in qualunque momento compare
|
||||
una verifica, un CAPTCHA o un avviso dell'account: **fermarsi**, risolvere a mano nel browser, annotare l'ora e
|
||||
riferire.
|
||||
|
||||
---
|
||||
|
||||
## A. Sonda passiva di M0
|
||||
|
||||
Scopo: raccogliere ciò che Instagram manda al browser mentre navighi tu, per scrivere lettori e mappa dei bersagli
|
||||
(ipotesi H1–H11 di `docs/sonda/esito.md`). **La sonda non compie gesti e non apre pagine da sola**: naviga solo Alberto.
|
||||
|
||||
### A1. Prima di cominciare
|
||||
|
||||
- Una cartella **fuori da qualunque repository git**, per esempio `~/febe-sonda/2026-10-14`. La sonda rifiuta una
|
||||
cartella dentro un repository.
|
||||
- Il programma: `dotnet run --project tools/Febe.Sonda -- …` dal repository, oppure l'eseguibile `febe-sonda`.
|
||||
- Su Linux con un desktop basta il display normale; in Docker serve un display visibile (la sonda non ha una sua
|
||||
vista remota): conviene farla su un computer con lo schermo.
|
||||
|
||||
### A2. Avvio
|
||||
|
||||
```sh
|
||||
febe-sonda registra --cartella ~/febe-sonda/2026-10-14 [--display :0] [--chromium /percorso/chromium]
|
||||
```
|
||||
|
||||
Si apre una finestra di Chromium vuota. Nella finestra scrivi tu `instagram.com` e accedi con l'account di prova
|
||||
(password e codici li scrivi tu: la sonda non li vede e non li registra; registra solo le risposte JSON e i comandi
|
||||
su cui passi).
|
||||
|
||||
### A3. Che cosa aprire, nell'ordine
|
||||
|
||||
Muoviti con calma, come faresti di solito. Per i comandi elencati in **grassetto**, prima di usarli **passaci sopra
|
||||
col puntatore per un secondo**: è così che la sonda ne registra ruolo e nome accessibile (H11).
|
||||
|
||||
1. **Home.** Attendi il caricamento; scorri piano per una decina di post. Passa sopra la **prima voce della barra
|
||||
delle storie**. Ci si aspetta: la barra in alto, i post dei profili seguiti.
|
||||
2. **Un profilo pubblico che non segui.** Scrivi l'indirizzo del profilo. Passa sopra **la foto del profilo**, le
|
||||
**schede** (post, reel, taggati) e una **raccolta in evidenza**. Scorri la griglia per 3–4 schermate (devono
|
||||
caricarsi altri post).
|
||||
3. **Un profilo privato che segui.** Come al passo 2.
|
||||
4. **Le storie di un seguito.** Dal suo profilo clicca la **foto con l'anello**. Guarda 2–3 storie; per andare avanti
|
||||
clicca la **zona a destra** (passandoci sopra prima). Prima che finiscano, passa sopra la **X** e **chiudi**: non
|
||||
lasciare che il visualizzatore passi da solo all'account successivo.
|
||||
5. **Una raccolta in evidenza.** Da un profilo apri una **raccolta**, guarda 2 contenuti, **chiudi** con la X. Se
|
||||
puoi, scegli una raccolta che contenga una storia ancora attiva (H9): per esempio pubblica una storia con l'account
|
||||
di prova e mettila in evidenza.
|
||||
6. **La scheda «Taggati»** di un profilo (anche il tuo) e la scheda **«Reel»**: aprile e scorri un poco.
|
||||
7. **L'elenco dei profili che segui.** Dal tuo profilo apri **«Seguiti»** e scorri 3–4 schermate.
|
||||
8. **Un post singolo**: aprine uno dalla griglia, meglio se è una serie con un video.
|
||||
|
||||
Ci si aspetta: nessuna verifica, nessun avviso. La console della sonda non scrive nulla mentre navighi.
|
||||
|
||||
### A4. Fine della registrazione
|
||||
|
||||
Premi **Invio** nella console. La sonda dice quante risposte, navigazioni e interazioni ha registrato. Nella cartella:
|
||||
`risposte/`, `navigazioni.jsonl`, `interazioni.jsonl`, `LEGGIMI.txt` e `profilo-browser/` (contiene la sessione:
|
||||
**non si invia mai**).
|
||||
|
||||
### A5. Ripulitura e verifica (sulla tua macchina)
|
||||
|
||||
```sh
|
||||
febe-sonda ripulisci --da ~/febe-sonda/2026-10-14 --a ~/febe-sonda/2026-10-14-ripuliti
|
||||
febe-sonda verifica --grezzi ~/febe-sonda/2026-10-14 --ripuliti ~/febe-sonda/2026-10-14-ripuliti
|
||||
```
|
||||
|
||||
La verifica deve dire **«Verifica superata»**. Se no, dice in quali file sopravvive un frammento (mai il frammento
|
||||
stesso): non inviare nulla e riferisci il messaggio.
|
||||
|
||||
### A6. Che cosa mandare
|
||||
|
||||
1. La cartella **ripulita** (compressa) e il testo della verifica.
|
||||
2. Per la mappa dei bersagli (H11): dal file **grezzo** `interazioni.jsonl`, le sole righe dei comandi
|
||||
dell'interfaccia (anello delle storie, zona «avanti», X di chiusura, schede, raccolta, voce della barra, «Seguiti»).
|
||||
**Prima di inviarle**, sostituisci a mano ogni nome di persona con `NOME`: servono il ruolo, il nome del comando
|
||||
(per esempio «Chiudi») e la forma del collegamento, non i nomi.
|
||||
3. Le note: a che ora hai fatto ogni passo, se qualcosa è andato diversamente da come descritto.
|
||||
|
||||
Mai: la cartella grezza, la cartella `profilo-browser`, schermate con nomi di altre persone.
|
||||
|
||||
### A7. Dopo
|
||||
|
||||
Quando i lettori e la mappa sono stati scritti sui campioni ripuliti, **cancella la cartella grezza** (§14.5).
|
||||
|
||||
---
|
||||
|
||||
## B. Prima sessione dal vivo, dopo M3
|
||||
|
||||
Scopo: vedere Febe fare una sessione vera, piccola, con il profilo **Prudente**, e i file arrivare in libreria.
|
||||
|
||||
### B1. Condizioni
|
||||
|
||||
- M3 chiusa: prove del motore verdi e numeri della simulazione di 30 giorni letti da te.
|
||||
- `bersagli.instagram.json` e `lettori.instagram.json` compilati sui campioni di M0 e portati a «confermato»
|
||||
(altrimenti le ricette rispondono «la mappa dei bersagli non è ancora compilata» e non fanno nulla).
|
||||
- Account di prova; nessun altro Febe acceso sullo stesso account.
|
||||
|
||||
### B2. Passi
|
||||
|
||||
1. Avvia Febe (Docker o Windows) e apri **Collegamento**: accedi a mano con l'account di prova.
|
||||
2. In **Limiti e comportamento** controlla che il profilo sia **Prudente**.
|
||||
3. Aggiungi **un solo** profilo **pubblico**, con pochi post (meno di 30), punto di partenza «Scarica tutto e tieni
|
||||
aggiornato». Nient'altro.
|
||||
4. Attendi: la prima sessione parte fra 2 e 10 minuti dall'avvio. Guarda la pagina **Attività**.
|
||||
|
||||
### B3. Che cosa aspettarsi
|
||||
|
||||
- Una sessione breve (2–10 minuti): un'apertura del profilo, qualche pagina di storico, poche azioni in tutto.
|
||||
- Nessuna striscia rossa; nessun «formato non riconosciuto».
|
||||
- In **Libreria**, nella cartella del profilo: `post/<anno>/<data>_<ora>_<codice>_<n>.jpg|mp4`, e il file
|
||||
`_febe.jsonl`. I file si aprono e sono le versioni grandi.
|
||||
- A fine sessione il browser torna alla pagina vuota.
|
||||
|
||||
### B4. Che cosa riferire
|
||||
|
||||
- Schermata della pagina Attività a fine sessione (striscia della giornata e tetti).
|
||||
- L'elenco dei file arrivati (nomi e dimensioni) e se qualcuno è rimasto «da scaricare», «scaduto» o «fallito».
|
||||
- Ogni evento in giallo o rosso della cronologia, con l'ora.
|
||||
- Se è comparsa una verifica: che cosa diceva, a che ora, che cosa stava facendo Febe (la pagina resta com'era).
|
||||
|
||||
### B5. Se qualcosa va storto
|
||||
|
||||
Febe si ferma da sola al primo segnale e non riparte senza «Riprendi». Non premere «Riprendi» prima di aver
|
||||
risolto a mano nel browser e di avermi riferito che cosa è successo.
|
||||
|
||||
---
|
||||
|
||||
## C. Febe per Windows (M6): ipotesi S1, S2, S3
|
||||
|
||||
Scopo: provare su un Windows vero ciò che su Linux non si può eseguire (`docs/windows.md`). C1–C4 usano **solo il sito
|
||||
di prova locale**: nessun contatto con Instagram. Solo C5 usa Instagram, con l'account di prova. Ogni passo dice che
|
||||
cosa aspettarsi; riferisci per ogni voce «sì/no» e, dove chiesto, la schermata o la riga del registro
|
||||
(`%LOCALAPPDATA%\Febe\registro\` o la cartella dei dati di prova, `registro\`).
|
||||
|
||||
### C1. Preparazione
|
||||
|
||||
- Un Windows 10 o 11 a 64 bit (va bene una macchina virtuale **pulita**: è anche la prova d'installazione di M6).
|
||||
- `Febe-Setup-<versione>.exe` (da `installer/costruisci.sh` o dalla release).
|
||||
- Il sito di prova come eseguibile, preparato da Linux nel repository:
|
||||
`dotnet publish tools/Febe.SitoDiProva -c Release -r win-x64 --self-contained true -p:PublishSingleFile=true -o out/sito-di-prova`
|
||||
e copiato sul Windows (`febe-sito-di-prova.exe`). In alternativa, con il .NET SDK 10 sul Windows:
|
||||
`dotnet run --project tools/Febe.SitoDiProva`.
|
||||
- Nessun altro Febe acceso sullo stesso account (nemmeno il contenitore).
|
||||
|
||||
### C2. Installazione (M6, «installazione su un Windows pulito»)
|
||||
|
||||
1. Apri il programma di installazione. Atteso: nessuna richiesta di permessi di amministratore; testi in italiano;
|
||||
pagina con la scelta «Collegamento sul desktop». Se manca WebView2: il messaggio con la pagina di Microsoft.
|
||||
2. Fine dell'installazione con «Apri Febe adesso». Atteso: si apre la finestra di Febe (benvenuto) e l'icona nell'area
|
||||
di notifica; in App installate c'è «Febe», versione giusta, editore Alberto Balbo, con l'icona del marchio.
|
||||
3. Riapri Febe dal menu Start mentre è già aperto. Atteso: torna in primo piano la stessa finestra, nessun secondo Febe.
|
||||
4. Chiudi la finestra con la X. Atteso: Febe resta nell'area di notifica (la prima volta una notifica lo dice);
|
||||
clic sull'icona: la finestra torna.
|
||||
5. Menu dell'icona ▸ Esci. Atteso: l'icona sparisce, nessun processo `Febe.exe` né `msedgewebview2.exe` di Febe resta
|
||||
in Gestione attività dopo una decina di secondi.
|
||||
|
||||
### C3. S1 — CDP in WebView2 sul sito di prova
|
||||
|
||||
1. Avvia il sito di prova: `febe-sito-di-prova.exe --porta 8481` (lascia aperta la finestra del terminale). Il suo
|
||||
«CDN» ascolta su `127.0.0.2:8482`; se Windows non lo accetta, `--indirizzo-cdn 127.0.0.1` e a Febe, al passo 2,
|
||||
anche `--cdn-di-prova http://127.0.0.1:8482`.
|
||||
2. Avvia Febe **con cartelle di prova** (i dati veri non si toccano):
|
||||
`"%LOCALAPPDATA%\Programs\Febe\Febe.exe" --dati C:\FebeProva\dati --libreria C:\FebeProva\libreria --sito-di-prova http://127.0.0.1:8481 --accesso-di-prova --prima-sessione 30`
|
||||
3. In Account ▸ Aggiungi account ▸ «Per nome utente»: `marta.prova` e `luca.prova`, «Scarica tutto e tieni aggiornato».
|
||||
4. Su `marta.prova`: «Controlla ora».
|
||||
5. Atteso entro qualche minuto, in **Attività**: una sessione con righe «ricetta.…» senza errori; l'anteprima del
|
||||
browser mostra le pagine del sito di prova (fotogrammi con `Page.captureScreenshot`); in **Libreria** le foto e i video
|
||||
di Marta con le miniature (corpo delle risposte con `Network.getResponseBody`, scorrimento con
|
||||
`Input.dispatchMouseEvent`, scaricamenti con `Network.loadNetworkResource` e `IO.read`).
|
||||
6. Riferisci: numero di file arrivati; eventuali righe gialle o rosse di Attività; nel registro, le righe
|
||||
`[browser]` con «WebView2» e qualunque «Comando CDP … è fallito».
|
||||
7. Prima prova di S3 senza Instagram: Esci, riapri Febe con lo stesso comando **senza** `--accesso-di-prova`. Atteso:
|
||||
Collegamento dice «Collegato» (il cookie del sito di prova è rimasto nel profilo `C:\FebeProva\dati\browser`).
|
||||
|
||||
### C4. S2 — la pagina lavora fuori vista
|
||||
|
||||
Stessa configurazione di C3 (altra cartella dati, per partire puliti: `C:\FebeProva2\…`).
|
||||
|
||||
1. **Fuori vista**: durante la sessione la finestra «Browser di Febe» non si vede (è fuori dallo schermo). Atteso:
|
||||
la sessione procede come in C3 (le stesse ricette, i file arrivano), l'anteprima di Attività cambia.
|
||||
2. **Finestra di Febe ridotta a icona**: riduci a icona la finestra di Febe, aspetta 5 minuti, riaprila. Atteso: la
|
||||
sessione è andata avanti (nuove righe in Attività, nuovi file).
|
||||
3. **Schermo bloccato**: «Controlla ora» su `luca.prova` (40 post, storico su più pagine), poi blocca lo schermo
|
||||
(Win+L) per 10 minuti. Atteso: al rientro, lo storico di Luca è avanzato di più pagine; nessuna riga
|
||||
«bersaglio non trovato» o «pagina vuota» nell'intervallo.
|
||||
4. «Apri il browser» (Attività) durante una sessione. Atteso: la finestra viene in primo piano con la pagina, la
|
||||
sessione si chiude (il motore si ferma mentre la usi); chiudendo la finestra torna fuori vista e il motore riprende
|
||||
alla sessione successiva.
|
||||
5. **Se 1–3 non reggono**: rifai C4 con `--browser composizione` (resta scelto per gli avvii successivi), poi con
|
||||
`--browser edge` (serve Edge installato). Riferisci quale dei tre regge. Con `composizione`, prova anche a scrivere
|
||||
e cliccare nella finestra del browser (mouse e tastiera passano da Febe).
|
||||
|
||||
### C5. S3 — l'accesso sopravvive al riavvio (Instagram, account di prova)
|
||||
|
||||
1. Avvia Febe normalmente (cartelle predefinite, nessuna opzione). Impostazioni ▸ Collegamento: accedi a mano nella
|
||||
finestra «Browser di Febe» con l'**account di prova**, poi «Ho finito». Atteso: «Collegato».
|
||||
2. Menu dell'icona ▸ **Esci**; riapri Febe. Atteso: Collegamento dice «Collegato» senza un nuovo accesso.
|
||||
3. Riavvia Windows (con Febe aperto, senza Esci). Atteso: dopo il riavvio, aprendo Febe, ancora «Collegato».
|
||||
4. «Avvia Febe all'accensione del computer» acceso, riavvia Windows. Atteso: Febe parte da solo nell'area di notifica,
|
||||
senza finestra; collegato.
|
||||
5. «Scollega» ▸ «Scollega e cancella la sessione». Atteso: «Non collegato»; la cartella `%LOCALAPPDATA%\Febe\browser`
|
||||
è stata ricreata vuota.
|
||||
6. Riferisci per ogni passo «sì/no»; se un passo fallisce, l'ora e le righe `[collegamento]` e `[browser]` del registro.
|
||||
|
||||
### C6. Disinstallazione
|
||||
|
||||
1. Esci da Febe, poi App installate ▸ Febe ▸ Disinstalla. Atteso: nessuna domanda sui dati; alla fine il testo dice dove
|
||||
sono la cartella dei dati e la libreria; `%LOCALAPPDATA%\Febe` e `Immagini\Febe` sono ancora lì; sparisce il valore
|
||||
`Febe` in `HKCU\Software\Microsoft\Windows\CurrentVersion\Run`.
|
||||
2. Con Febe aperto la disinstallazione deve dire di chiuderlo e non togliere nulla.
|
||||
|
||||
---
|
||||
|
||||
## D. Avvisi dopo M8: un arresto produce striscia, notifica e messaggio
|
||||
|
||||
Scopo: vedere sul tuo impianto che un arresto arriva in tutti i canali (specifica §13.3, «Fatto quando» di M8). **Non
|
||||
serve Instagram e non va provocato su Instagram**: l'arresto lo produce il sito di prova locale.
|
||||
|
||||
### D1. Condizioni
|
||||
|
||||
- Un bot Telegram tuo, con gettone e identificativo della chat (procedura nella guida, pagina «Avvisi e Telegram»).
|
||||
- Una macchina con il repository, .NET 10, Chromium e Xvfb (la stessa delle prove di sviluppo). Le notifiche di
|
||||
Windows si provano con Febe per Windows (vedi D4).
|
||||
|
||||
### D2. Passi
|
||||
|
||||
1. Avvia il sito di prova e Febe contro di lui (cartelle temporanee, mai quelle vere):
|
||||
|
||||
```sh
|
||||
dotnet run --project tools/Febe.SitoDiProva -- --porta 8481 --porta-cdn 8482
|
||||
FEBE_PASSWORD=prova dotnet run --project src/Febe.Server -- \
|
||||
--dati /tmp/febe-m8/dati --libreria /tmp/febe-m8/libreria --importa /tmp/febe-m8/importa --ascolta 127.0.0.1 \
|
||||
--sito-di-prova http://127.0.0.1:8481 --accesso-di-prova --prima-sessione 5
|
||||
```
|
||||
|
||||
2. Apri `http://127.0.0.1:8480/`, entra con `prova`. In **Impostazioni ▸ Notifiche** incolla gettone e chat, salva,
|
||||
**«Invia una prova»**: nella chat deve arrivare «Febe · Prova degli avvisi».
|
||||
3. Aggiungi due account per nome utente: `marta.prova` e `luca.prova`, «Scarica tutto e tieni aggiornato».
|
||||
4. Quando in **Attività** vedi la prima sessione in corso, chiedi al sito una verifica:
|
||||
|
||||
```sh
|
||||
curl 'http://127.0.0.1:8481/_controllo/modo?valore=verifica'
|
||||
```
|
||||
|
||||
5. Alla prossima azione verso il sito Febe si ferma.
|
||||
|
||||
### D3. Che cosa aspettarsi
|
||||
|
||||
- In cima a ogni pagina la **striscia rossa** «Instagram chiede una verifica», con «Apri il browser».
|
||||
- In Attività, sezione **Avvisi**, la riga della verifica.
|
||||
- Su Telegram, entro pochi secondi, **un solo messaggio** che comincia con «Febe · Instagram chiede una verifica» e
|
||||
dice che cosa fare.
|
||||
- Nel registro (`/tmp/febe-m8/dati/registro/`) la riga «Avviso «Instagram chiede una verifica» inviato: Telegram».
|
||||
**Nessuna riga** contiene il gettone o l'indirizzo di Telegram.
|
||||
- Poi: `curl 'http://127.0.0.1:8481/_controllo/modo?valore=normale'`, «Apri il browser», «Ho finito», «Riprendi».
|
||||
Ripeti il passo 4 alla sessione successiva (parte 2–10 minuti dopo «Riprendi»): la striscia torna, ma il messaggio
|
||||
Telegram **non** si ripete, perché sono passati meno di 30 minuti dal primo.
|
||||
- Facoltativo: `valore=troppe-richieste` produce «Instagram ha chiesto di rallentare» (striscia ambra e messaggio) e,
|
||||
un'ora dopo, «Fine del fermo per rallentamento».
|
||||
|
||||
### D4. Notifiche di Windows (Febe per Windows)
|
||||
|
||||
Gli avvisi sono gli stessi nelle due vesti (stessa composizione); su Windows arrivano anche come notifica.
|
||||
|
||||
1. Su Febe per Windows (installata come in C2), in Impostazioni ▸ Notifiche accendi «Notifiche di Windows» e premi
|
||||
«Invia una prova». Atteso: la notifica compare nell'angolo dello schermo, accanto all'icona di Febe.
|
||||
2. Con la configurazione di C3 (sito di prova, cartelle `C:\FebeProva\…`), quando in Attività vedi una sessione in
|
||||
corso, chiedi al sito una verifica: apri `http://127.0.0.1:8481/_controllo/modo?valore=verifica` in un browser
|
||||
qualunque (o con `curl` dal terminale). Atteso: la striscia rossa in Febe e, entro pochi secondi, la notifica di
|
||||
Windows «Instagram chiede una verifica»; con Telegram configurato anche il messaggio, come in D3.
|
||||
3. Riporta il sito alla normalità con `…/_controllo/modo?valore=normale`, poi «Apri il browser», chiudi la finestra
|
||||
del browser e «Riprendi».
|
||||
|
||||
### D5. Che cosa riferire
|
||||
|
||||
- Schermate della striscia e della sezione Avvisi, il testo del messaggio Telegram arrivato.
|
||||
- Se un messaggio non è arrivato: la riga «Avviso non inviato» di Attività (dice il motivo, senza il gettone).
|
||||
- Nel contenitore su Unraid: il risultato di «Invia una prova» (dice se il contenitore raggiunge Telegram).
|
||||
- Su Windows (D4): «sì/no» per la notifica di prova e per quella della verifica; se manca, la riga `[avvisi]` del
|
||||
registro di quell'ora.
|
||||
|
After Width: | Height: | Size: 941 KiB |
|
After Width: | Height: | Size: 112 KiB |
|
After Width: | Height: | Size: 88 KiB |
|
After Width: | Height: | Size: 254 KiB |
|
After Width: | Height: | Size: 239 KiB |
|
After Width: | Height: | Size: 214 KiB |
|
After Width: | Height: | Size: 202 KiB |
|
After Width: | Height: | Size: 189 KiB |
|
After Width: | Height: | Size: 236 KiB |
|
After Width: | Height: | Size: 176 KiB |
|
After Width: | Height: | Size: 170 KiB |
|
After Width: | Height: | Size: 205 KiB |
|
After Width: | Height: | Size: 83 KiB |
|
After Width: | Height: | Size: 80 KiB |
|
After Width: | Height: | Size: 106 KiB |
|
After Width: | Height: | Size: 126 KiB |
|
After Width: | Height: | Size: 144 KiB |
|
After Width: | Height: | Size: 146 KiB |
|
After Width: | Height: | Size: 160 KiB |
|
After Width: | Height: | Size: 920 KiB |
|
After Width: | Height: | Size: 377 KiB |
|
After Width: | Height: | Size: 126 KiB |
|
After Width: | Height: | Size: 147 KiB |
|
After Width: | Height: | Size: 68 KiB |
|
After Width: | Height: | Size: 72 KiB |
|
After Width: | Height: | Size: 745 KiB |
|
After Width: | Height: | Size: 256 KiB |
|
After Width: | Height: | Size: 161 KiB |
@@ -0,0 +1,105 @@
|
||||
# Schermate dell'interfaccia e differenze dai mockup
|
||||
|
||||
Schermate prese il 13 ottobre 2026 dalla modalità dimostrativa (`dotnet run --project src/Febe.Server -- --demo`),
|
||||
con Chromium senza finestra a 1440 × 900 in scala 1,25 (come i mockup), salvo dove indicato. Il senza finestra si usa
|
||||
solo per l'interfaccia di Febe (§10.7).
|
||||
|
||||
| Schermata | Indirizzo | Mockup |
|
||||
|---|---|---|
|
||||
| `01-libreria.png` | `/libreria?tema=chiaro`, puntatore su una tessera | `docs/mockup/01-libreria.png` |
|
||||
| `02-visualizzatore.png` | `/libreria`, clic su un post con più file, seconda foto | `miniature/02-visualizzatore.png` |
|
||||
| `03-account.png` | `/account?tema=chiaro` | `docs/mockup/03-account.png` |
|
||||
| `03-account-telefono.png` | `/account`, 390 × 844 | (nessuno: tabella come elenco) |
|
||||
| `04-aggiungi-account.png` | `/account?dialogo=aggiungi`, tre profili scelti | `miniature/04-aggiungi-account.png` |
|
||||
| `05-account-impostazioni.png` | `/account/3/impostazioni` (@studio.lumen.demo) | `miniature/05-account-impostazioni.png` |
|
||||
| `11-libreria-fermo-tema-scuro.png` | `/libreria?scena=fermo&tema=scuro` | striscia rossa di `miniature/11-attivita-fermo-tema-scuro.png` |
|
||||
| `12-account-storie-tema-scuro.png` | `/account/2?tema=scuro&tipo=storie` (@marta.demo) | `miniature/12-account-storie-tema-scuro.png` |
|
||||
| `14-finestra-stretta.png` | `/libreria`, 860 × 900 | parte sinistra di `miniature/14-finestra-stretta-e-telefono.png` |
|
||||
| `14-telefono.png` | `/libreria`, 390 × 844 | (il mockup mostra Attività al telefono) |
|
||||
| `account-cronologia.png` | `/account/2/cronologia` | (nessuno) |
|
||||
| `06-attivita.png` | `/attivita?scena=sessione&tema=chiaro` | `miniature/06-attivita.png` |
|
||||
| `06-attivita-tutti-i-tetti.png` | come sopra, «Tutti i tetti» aperto | (nessuno: §7.4) |
|
||||
| `07-limiti-e-comportamento.png` | `/impostazioni/limiti`, 1440 × 1470 | `miniature/07-limiti-e-comportamento.png` |
|
||||
| `07-limiti-su-misura.png` | come sopra, un tetto cambiato: «Su misura» e barra di salvataggio attiva | (nessuno: §7.5) |
|
||||
| `08-impostazioni-generali.png` | `/impostazioni/generali` | `docs/mockup/08-impostazioni-generali.png` |
|
||||
| `09-importa-sorgente.png` | `/importa?passo=1&veste=docker` | (nessuno: passo 1 di §9.1) |
|
||||
| `09-importa-revisione.png` | `/importa?passo=3`, primo doppione deciso («Tieni il più grande») | `miniature/09-importa-revisione.png` |
|
||||
| `09-importa-telefono.png` | `/importa?passo=3`, 390 × 844 | (nessuno) |
|
||||
| `10-collegamento-instagram.png` | `/impostazioni/collegamento?scena=scollegato&veste=docker` | `docs/mockup/10-collegamento-instagram.png` |
|
||||
| `10-collegamento-windows.png` | come sopra con `veste=windows` | (nessuno: variante di §6.4) |
|
||||
| `10-collegamento-collegato.png` | `/impostazioni/collegamento?veste=docker`, account collegato | (nessuno) |
|
||||
| `10-browser.png` | `/browser?scena=fermo&veste=docker` | mockup 10 senza colonna dei passi |
|
||||
| `11-attivita-fermo-tema-scuro.png` | `/attivita?scena=fermo&tema=scuro` | `miniature/11-attivita-fermo-tema-scuro.png` |
|
||||
| `14-attivita-finestra-stretta.png` | `/attivita?scena=sessione`, 860 × 900 | parte sinistra di `miniature/14-finestra-stretta-e-telefono.png` |
|
||||
| `14-attivita-telefono.png` | `/attivita?scena=sessione`, 390 × 844 | parte destra di `miniature/14-finestra-stretta-e-telefono.png` |
|
||||
| `14-attivita-finestra-stretta-normale.png` | `/attivita?scena=normale`, 860 × 900 | (come sopra, motore in ascolto) |
|
||||
| `14-attivita-telefono-normale.png` | `/attivita?scena=normale`, 390 × 844 | (come sopra, motore in ascolto) |
|
||||
| `impostazioni-notifiche.png` | `/impostazioni/notifiche` | (nessuno: §13.3) |
|
||||
| `impostazioni-dati.png` | `/impostazioni/dati` | (nessuno: §8.2, §8.5) |
|
||||
| `impostazioni-informazioni.png` | `/impostazioni/informazioni` | (nessuno) |
|
||||
| `doppioni-download.png` | `/doppioni` | confronto di `miniature/09-importa-revisione.png` (§9.5) |
|
||||
| `primo-avvio.png` | `/libreria?scena=scollegato`, libreria vuota disegnata dal passo `benvenuto.js` | (nessuno: §10.3) |
|
||||
| `errore-configurazione.png` | `/libreria?scena=errore` | (nessuno) |
|
||||
|
||||
## Differenze che restano
|
||||
|
||||
Disposizione, gerarchia, misure delle colonne, testi e colori corrispondono. Restano queste differenze, volute o
|
||||
dovute ai dati dimostrativi:
|
||||
|
||||
- **Contenuti dimostrativi.** Immagini, orari, conteggi e ordine delle righe vengono dalla libreria finta generata a
|
||||
ogni avvio (ora reale del computer), quindi non coincidono con quelli disegnati: ad esempio «18.274 elementi di 37
|
||||
account» invece di «48.212 elementi di 38 account» (un account non raggiungibile non ha elementi), e oggi ci sono
|
||||
più storie verticali che nel mockup.
|
||||
- **Libreria, intestazione dei giorni.** Anche «Ieri» mostra quanti elementi ha («lunedì 12 ottobre, 61 elementi»);
|
||||
nel mockup il numero c'è solo per «Oggi». Tenuto: l'informazione è utile e coerente con gli altri giorni.
|
||||
- **Libreria, tessere.** Il segno della storia (cerchio tratteggiato) compare su tutte le storie; nel mockup su poche
|
||||
perché i dati sono diversi. La tessera con il puntatore sopra mostra avatar, nome e ora come nel mockup.
|
||||
- **Avatar.** I colori di fondo delle iniziali sono più scuri di quelli del mockup, per avere contrasto di almeno 4,5:1
|
||||
con il testo bianco (§10.5).
|
||||
- **Visualizzatore.** La scheda mostra anche «Codice» e «Posizione» del file; il nome del file va a capo quando è
|
||||
lungo (nel mockup sta su una riga perché il nome disegnato è più corto). Il segno «Profilo privato» compare solo per
|
||||
gli account privati.
|
||||
- **Account.** L'ordine delle righe segue l'ultimo controllo reale dei dati dimostrativi; nel mockup i tempi sono
|
||||
«8 min fa», «12 min fa». Con nuovi post e nuove storie insieme la riga dice «1 nuovo post e 2 nuove storie oggi».
|
||||
- **Scheda account, impostazioni.** La cartella mostra il percorso della cartella temporanea della dimostrazione.
|
||||
Il riquadro «Con queste impostazioni» usa i testi del calcolatore del motore, più lunghi di quelli del mockup.
|
||||
- **Storie in tema scuro.** Le tessere delle storie non hanno l'anello attorno all'elemento scelto: nel mockup c'è
|
||||
una tessera selezionata, qui la schermata è senza selezione.
|
||||
- **Telefono, libreria.** `14-telefono.png` mostra la libreria; la pagina Attività del mockup al telefono è in
|
||||
`14-attivita-telefono.png`. I filtri a pastiglia vanno a capo su due righe.
|
||||
|
||||
### Seconda parte (Attività, Impostazioni, Collegamento, Importa)
|
||||
|
||||
Rifatte con `bash tools/schermate/tutte.sh 8490` (le righe dopo «Part 2»), su una dimostrazione appena avviata: la
|
||||
schermata del motore fermo si prende per prima, perché «Riprendi» resta spento finché il browser non è stato usato.
|
||||
|
||||
- **Attività, anteprima del browser.** Nella dimostrazione l'anteprima compone tre immagini della libreria finta
|
||||
(sessione) o un riquadro neutro con l'indirizzo (in ascolto, fermo): la vera schermata del browser arriva dalla
|
||||
composizione (`IBrowserPreview`). Il motore in ascolto mostra «about:blank» con la luna, come prevede §7.6.
|
||||
- **Attività, numeri e righe.** Sessioni, conteggi, orari «verso le» e righe di «In coda» e «Appena fatto» vengono
|
||||
dal motore finto e dall'ora reale. Nella scena fermo l'elenco «In coda» dice «Sospeso» invece degli orari. In
|
||||
«Appena fatto» la riga della verifica ha il segno rosso «Tutto fermo».
|
||||
- **Attività, doppioni.** Quando ci sono doppioni da decidere dopo uno scaricamento compare un avviso con il
|
||||
collegamento a «Doppioni da decidere», sotto gli elenchi: il mockup non lo prevede (§9.5).
|
||||
- **Attività, fermo.** La striscia rossa ha «Riprendi» solo nell'intestazione della pagina (non doppio). Nel giorno
|
||||
la parte dopo l'arresto è tratteggiata in rosso, come nel mockup; lo storico degli incidenti sta in fondo.
|
||||
- **Limiti e comportamento.** Gli orari sono campi di testo a 24 ore («07:30») invece del selettore d'ora del
|
||||
browser, che in alcune lingue mostra AM/PM. I giorni sono cerchi con l'iniziale. La barra di salvataggio resta
|
||||
sempre visibile: spenta con «Nessuna modifica», si accende alla prima modifica.
|
||||
- **Impostazioni generali.** In più rispetto al mockup: lo spazio libero accanto alle cartelle, la nota «Per ora
|
||||
c'è solo l'italiano» sotto la lingua e la riga «Solo versione Windows» accanto ad «Avvio». In Docker le cartelle
|
||||
non si cambiano dall'interfaccia (si cambiano i volumi del contenitore) e la sezione Avvio non c'è.
|
||||
- **Importa, revisione.** Percorso della cartella temporanea della dimostrazione; le immagini dei doppioni sono
|
||||
disegni generati. Il riquadro dei doppioni passa al caso seguente dopo ogni scelta: la schermata torna al primo
|
||||
caso per mostrarne la decisione. La riga «restano fuori» va a capo su due righe quando spiega più motivi.
|
||||
- **Collegamento.** Nella dimostrazione la vista remota non riceve immagini (non c'è un browser vero): al posto della
|
||||
pagina di Instagram c'è un riquadro neutro con lo schema di un modulo e la frase «Qui compare la vera pagina di
|
||||
accesso di Instagram, caricata dal sito. Febe non la ridisegna e non la imita.» La variante Windows sostituisce la
|
||||
vista con «Il browser di Febe è aperto in un'altra finestra» e «Portalo in primo piano».
|
||||
- **Dati e copie.** La dimostrazione parte senza copie del database («Nessuna copia ancora.»): la prima si fa con
|
||||
«Fai una copia adesso» o la notte successiva.
|
||||
- **Primo avvio.** La dimostrazione ha sempre una libreria; la schermata è disegnata dal passo `benvenuto.js`,
|
||||
che mette nel corpo della pagina quello che la libreria mostra quando è vuota e Febe non è collegato.
|
||||
- **Finestra stretta e telefono.** A 860 px il menu delle impostazioni diventa una fila di schede sopra il contenuto
|
||||
e le colonne laterali (passi del collegamento, doppioni dell'importazione) vanno sotto. Al telefono la tabella
|
||||
delle cartelle dell'importazione diventa un elenco di schede e «Esporta l'elenco in CSV» resta solo come icona.
|
||||
|
After Width: | Height: | Size: 238 KiB |
|
After Width: | Height: | Size: 71 KiB |
|
After Width: | Height: | Size: 128 KiB |
|
After Width: | Height: | Size: 150 KiB |
|
After Width: | Height: | Size: 171 KiB |
|
After Width: | Height: | Size: 87 KiB |
@@ -0,0 +1,93 @@
|
||||
# Esito delle prove in locale: S5 e S6 (Chromium su Xvfb)
|
||||
|
||||
Prove del 13 ottobre 2026 sullo strato browser (`Febe.Browser`), fatte **solo in locale**: Chromium su un display virtuale Xvfb e pagine servite dalla prova stessa su `127.0.0.1`. Nessun contatto con Instagram o Meta. Nulla di quanto segue dice qualcosa sul comportamento di Instagram (voci H) o su WebView2 (S1, S2 e la parte Windows di S6): quelle restano **da provare**.
|
||||
|
||||
## Ambiente
|
||||
|
||||
| | |
|
||||
|---|---|
|
||||
| Macchina | Linux 6.18.44 (macchina virtuale di sviluppo, non un contenitore Docker), Ubuntu 24.04.5, 4 CPU |
|
||||
| Browser | Chromium 141.0.7390.37 (build di Playwright `chromium-1194`), **non** il pacchetto `chromium` di Debian che userà l'immagine |
|
||||
| Display | Xvfb 2:21.1.12 (`Xvfb :N -screen 0 1280x900x24 -nolisten tcp -noreset`) |
|
||||
| .NET | SDK 10.0.112 |
|
||||
| Lingua di sistema | solo `C`, `C.utf8`, `POSIX`: la lingua `it_IT.UTF-8` **non è generata** |
|
||||
| Spazi dei nomi utente | `max_user_namespaces` = 64299; `unshare --user` funziona per un utente normale |
|
||||
|
||||
Il processo delle prove gira come `root`. Per le prove automatiche Chromium parte quindi con `--no-sandbox` (vedi S5); per S5 lo si è avviato anche come utente normale (`ubuntu`, uid 1000) con `runuser`.
|
||||
|
||||
## S5 — La sandbox di Chromium
|
||||
|
||||
Comando di base (cambia solo l'utente e l'eventuale `--no-sandbox`):
|
||||
|
||||
```sh
|
||||
DISPLAY=:93 LANG=it_IT.UTF-8 TZ=Europe/Rome chrome --user-data-dir=<profilo> --no-first-run \
|
||||
--no-default-browser-check --password-store=basic --disable-dev-shm-usage --window-size=1280,900 \
|
||||
--remote-debugging-port=<porta fissa> about:blank
|
||||
```
|
||||
|
||||
Lo stato della sandbox si è letto aprendo `chrome://sandbox` e leggendo il testo della pagina con `Runtime.evaluate` in sola lettura.
|
||||
|
||||
| Caso | Che cosa è successo |
|
||||
|---|---|
|
||||
| `root`, senza `--no-sandbox` | Chromium **non parte**: `ERROR:content/browser/zygote_host/zygote_host_impl_linux.cc:101] Running as root without --no-sandbox is not supported. See https://crbug.com/638180.` |
|
||||
| `root`, con `--no-sandbox` | Parte. `chrome://sandbox`: `Layer 1 Sandbox None`, `PID namespaces No`, `Network namespaces No`, `Seccomp-BPF sandbox No`, **«You are NOT adequately sandboxed.»** In più Chromium mostra la barra d'avviso sull'opzione non supportata, che ruba circa 50 pixel di altezza alla pagina (vedi S6, dimensioni) |
|
||||
| `ubuntu` (uid 1000), senza `--no-sandbox` | Parte con la sandbox attiva. `chrome://sandbox`: `Layer 1 Sandbox Namespace`, `PID namespaces Yes`, `Network namespaces Yes`, `Seccomp-BPF sandbox Yes`, `Seccomp-BPF sandbox supports TSYNC Yes`, **«You are adequately sandboxed.»** |
|
||||
|
||||
Che cosa se ne ricava, e che cosa no:
|
||||
|
||||
- Come utente normale, su questa macchina, la sandbox di Chromium parte con le impostazioni normali, grazie agli spazi dei nomi utente. È la condizione che chiede §11 (utente non root con `PUID`/`PGID`).
|
||||
- **Non è provato in Docker.** Il profilo seccomp predefinito di Docker può impedire la creazione di spazi dei nomi utente: l'esito dentro il contenitore va misurato in M5 con lo stesso controllo (`chrome://sandbox`). Le alternative restano quelle di §11 (profilo seccomp dedicato, oppure `--no-sandbox` scritto nella guida come compromesso).
|
||||
- `ChromiumProcessHost` aggiunge `--no-sandbox` **solo** se lo si chiede esplicitamente (`ChromiumLaunchOptions.NoSandbox`); non lo decide da sé. Le prove automatiche lo chiedono perché girano come `root`.
|
||||
|
||||
## S6 — Che cosa vede la pagina
|
||||
|
||||
Valori letti con `Runtime.evaluate` in sola lettura su una pagina locale (`/ambiente`) e su `about:blank`, con `LANG=it_IT.UTF-8` e `TZ=Europe/Rome` nell'ambiente del solo processo del browser. Prova automatica: `BrowserIntegrationTests.ThePageSeesAnOrdinaryVisibleBrowser`. Uscita registrata:
|
||||
|
||||
```text
|
||||
S6 (Chromium su Xvfb): {"webdriver":false,"visibility":"visible","hidden":false,"focus":false,"language":"it-IT",
|
||||
"languages":["it-IT"],"timeZone":"Europe/Rome","userAgent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36
|
||||
(KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36","width":1279,"height":759,"outerWidth":1279,"outerHeight":899}
|
||||
Fuoco dopo il primo movimento del puntatore: true
|
||||
```
|
||||
|
||||
| Proprietà | Valore visto | Note |
|
||||
|---|---|---|
|
||||
| `navigator.webdriver` con la porta di debug fissa | `false` | Sia come `root` con `--no-sandbox` sia come utente normale con la sandbox |
|
||||
| `navigator.webdriver` con `--enable-automation` | `true` | Misurato come utente normale; Febe non usa mai questa opzione |
|
||||
| `navigator.webdriver` con `--remote-debugging-port=0` | `true` | Porta scelta da Chromium e letta da `DevToolsActivePort`; Febe rifiuta la porta 0 |
|
||||
| `document.visibilityState` / `document.hidden` | `visible` / `false` | Sul display virtuale la pagina è visibile |
|
||||
| `document.hasFocus()` | `false` all'avvio, `true` dopo il primo evento del puntatore | Senza gestore di finestre nessuno dà il fuoco alla finestra; lo dà il primo evento di `Input.dispatchMouseEvent` |
|
||||
| `navigator.language` / `languages` | `it-IT` / `["it-IT"]` | Da `LANG`, **anche se la lingua italiana non è generata nel sistema**: Chromium usa i propri file di lingua (`locales/it.pak`) |
|
||||
| Fuso orario (`Intl…timeZone`) | `Europe/Rome` | Da `TZ` |
|
||||
| User agent | quello normale di Chrome 141 per Linux, senza «Headless» | Nessuna modifica |
|
||||
| Finestra | `--window-size=1280,900` → esterno 1279×899; interno 1279×760 con la sandbox, 1279×707 con `--no-sandbox` finché è visibile la sua barra d'avviso (nelle prove automatiche, più avanti, anche 1279×759) | La barra del browser occupa circa 140 pixel; quella d'avviso circa 53 |
|
||||
|
||||
## Altre misure utili per §6.1
|
||||
|
||||
Tutte dalle prove automatiche in `tests/Febe.Tests/Browser/` (comando in fondo), sempre su pagine locali.
|
||||
|
||||
- **Porta di debug solo su `127.0.0.1`.** L'elenco dei punti di ascolto letto da .NET (`IPGlobalProperties`, cioè `/proc/net/tcp`) mostra solo `127.0.0.1:<porta>`. `ChromiumProcessHost` lo controlla a ogni avvio e annulla l'avvio altrimenti.
|
||||
- **Rotella.** Due raffiche (9 eventi) hanno chiesto 1017 pixel e la pagina è scesa di esattamente 1017; gli eventi `wheel` visti dalla pagina hanno `isTrusted = true`.
|
||||
- **Clic.** Il clic arriva al pulsante trovato con la mappa dei bersagli, con `isTrusted = true`, preceduto da molti `mousemove` (il puntatore viaggia, non salta).
|
||||
- **Input appena dopo il caricamento.** Un clic e un tasto inviati pochi millisecondi dopo `readyState = complete` **non sono arrivati** alla pagina; mezzo secondo dopo sì. Probabilmente Chromium scarta l'input che arriva prima del primo disegno della pagina (non verificato oltre). Le ricette aspettano comunque 1–6 s dopo il caricamento (§7.7); le prove aspettano 0,5 s.
|
||||
- **Vista remota.** `Page.startScreencast` consegna fotogrammi JPEG su una pagina animata (la prova si ferma al quinto; ognuno è confermato con `Page.screencastFrameAck`, senza il quale Chromium non manda il successivo). Clic e tasti inoltrati dalla vista remota hanno scritto «Ciao è» in un campo di testo: è l'equivalente locale di S4, senza rete di mezzo e senza contenitore.
|
||||
- **Scaricamento.** `Network.loadNetworkResource` (con l'identificativo del frame da `Page.getFrameTree`) e `IO.read` a blocchi da 1 MB hanno scaricato un file di 24 MB (25 165 824 byte) in circa 2,2 s, con SHA-256 identico all'originale.
|
||||
- **Corpi delle risposte.** `Network.getResponseBody` restituisce i JSON letti dalla pagina. Se la pagina chiama `fetch()` ma non legge il corpo, Chromium **non** manda `Network.loadingFinished` e dopo la navigazione il corpo non è più disponibile («No resource with given identifier found»). La cattura quindi vede solo i corpi che la pagina usa davvero; i segnali basati sullo stato HTTP (429) funzionano comunque, perché arrivano con `Network.responseReceived`.
|
||||
- **Arresto e sessione (S3 in locale).** Con `SIGTERM` Chromium esce in circa 35 ms e in 3 prove su 4 **non** ha scritto nel profilo un cookie impostato da meno di 30 secondi (resta un `Cookies-journal`). Con `SIGINT` (4 prove su 4) e con `SIGHUP` (3 su 3) esce in 95–130 ms e il cookie è scritto. Dopo 32 secondi il cookie era già nel file anche senza arresto (scrittura periodica di Chromium). Per questo `ChromiumProcessHost` ferma Chromium con `SIGINT`; con questa scelta la prova `TheSessionCookieSurvivesACleanRestartOfTheBrowser` è passata in 3 esecuzioni su 3.
|
||||
- **Processi figli.** Dopo un arresto con `SIGTERM`, mezzo secondo più tardi 5 degli 8 processi di Chromium (zygote, servizio di rete, GPU) erano ancora vivi; dopo 5 secondi nessuno. Con `SIGINT` non è stato misurato. In Docker, se `Febe.Server` è il processo 1, serve un `init` che raccolga gli orfani (per esempio `init: true` in compose): da verificare in M5.
|
||||
- **Caduta del browser.** Ucciso Chromium, il supervisore lo riavvia dopo l'attesa prevista, il collegamento CDP si riapre da solo e la cattura delle risposte riprende (`Network.enable` di nuovo) senza che chi la usa debba fare nulla.
|
||||
|
||||
## Come ripetere
|
||||
|
||||
```sh
|
||||
dotnet build Febe.slnx -warnaserror
|
||||
dotnet test tests/Febe.Tests --filter "FullyQualifiedName~BrowserIntegrationTests|FullyQualifiedName~BrowserLifecycleTests" --logger "console;verbosity=detailed"
|
||||
```
|
||||
|
||||
Le prove cercano Chromium in `FEBE_CHROMIUM` (oppure nel percorso dell'ambiente di sviluppo o nel `PATH`) e Xvfb nel `PATH`; se mancano risultano «inconcludenti», non fallite. Le misure con l'utente normale, con `--enable-automation` e con la porta 0 sono state fatte a mano, avviando Chromium con il comando di S5 e collegandosi con `CdpClient` alla porta indicata.
|
||||
|
||||
## Che cosa resta da provare
|
||||
|
||||
- S5 dentro il contenitore Docker vero, come utente non root, con il profilo seccomp predefinito (M5).
|
||||
- S6 con il Chromium di Debian e con `chromium-l10n` (M5), e in WebView2 su Windows (M6).
|
||||
- Tutte le voci H: richiedono Instagram e la sonda passiva guidata da Alberto (M0).
|
||||
@@ -0,0 +1,41 @@
|
||||
# Esito delle ipotesi di M0 (specifica §6.6)
|
||||
|
||||
Stato al 13 ottobre 2026. Finché una voce non ha un esito con le prove, **non ci si costruisce sopra**: per questo i
|
||||
file di Instagram sono ancora scheletri e le ricette si rifiutano di girare su Instagram (vedi in fondo).
|
||||
|
||||
Legenda: **provato in locale** = misurato su questa macchina con Chromium su Xvfb e pagine locali, mai Instagram;
|
||||
**da provare dal vivo** = serve Alberto, con l'account di prova e la sonda (`docs/prove-dal-vivo.md`, parte A).
|
||||
|
||||
| | Ipotesi | Stato | Come si prova (procedura esatta) | Che cosa ne dipende |
|
||||
|---|---|---|---|---|
|
||||
| H1 | La home consegna i post recenti dei seguiti con i dati completi dei file | **Da provare dal vivo** | Sonda, passo A3.1: aprire la home, attendere il caricamento, scorrere piano per una decina di post. Nei campioni ripuliti cercare risposte con elenchi di contenuti (identificativo, data, versioni delle immagini con dimensioni, figli delle serie) | Giro dei seguiti; `pages.home` di `bersagli.instagram.json`; concetti `content.*` e `version.*` di `lettori.instagram.json` |
|
||||
| H2 | La barra delle storie dice quali seguiti hanno storie attive e a quando risale l'ultima | **Da provare dal vivo** | Passo A3.1: con la home caricata, la sonda registra le risposte della barra; nei ripuliti cercare elenchi di profili con un campo data dell'ultima storia | `profile.latestStoryAt`; bersaglio `home-story` |
|
||||
| H3 | Il profilo consegna identificativo, pubblico/privato, se è seguito, prima pagina dei post con serie e video, elenco delle raccolte; lo scorrimento carica le pagine successive | **Da provare dal vivo** | Passi A3.2 e A3.3: profilo pubblico non seguito e profilo privato seguito, scorrendo 3–4 schermate. Nei ripuliti: un nodo profilo con i campi di stato, pagine di contenuti successive con un punto di ripresa | Controllo del profilo, Storico; `profile.*`, `highlight.*`, `page.*`; `pages.profile`, `pages.profileFrom` (facoltativa: se il sito non riparte da un cursore, lo storico riprende scorrendo) |
|
||||
| H4 | Aprendo il visualizzatore arriva l'elenco delle storie con gli indirizzi dei file, e si capisce qual è l'ultima | **Da provare dal vivo** | Passo A3.4: aprire le storie di un seguito dall'anello del profilo, guardarne 2–3, chiudere con la X **prima** che passi all'account successivo. Nei ripuliti: un elenco di contenuti con data di scadenza; in `navigazioni.jsonl` la forma dell'indirizzo del visualizzatore | Storie di un account; `content.expiresAt`; `pages.storyViewer`; bersagli `profile-story-ring`, `viewer-next`, `viewer-close` |
|
||||
| H5 | Per i video arriva almeno un indirizzo unico con audio e video insieme | **Da provare dal vivo** | Passi A3.2 e A3.4 su un post video e su una storia video. Nei ripuliti: le versioni del video e un campo che dica se hanno l'audio | `version.hasAudio`; scelta della versione di §6.5 punto 1 (se nessuna versione ha audio e video insieme, va riletta §4.9: l'unione delle tracce è fuori dalla versione 1) |
|
||||
| H6 | Le schede «taggati» e «reel» si comportano come la griglia | **Da provare dal vivo** | Passo A3.6: aprire le due schede di un profilo e scorrere | Taggati, Reel; bersagli `profile-tab-tagged`, `profile-tab-reels`; `pages.taggedFrom`, `pages.reelsFrom` |
|
||||
| H7 | I file del CDN si scaricano con `Network.loadNetworkResource`; se no, con la via di riserva di §6.5 | **Da provare dal vivo**. In locale: scaricati integri (24 MB in 2,2 s; foto e video del sito di prova byte per byte) | Dopo la sonda, con la prima sessione dal vivo (parte B): file arrivati in Libreria, stato «scaricato». **Osservazione locale**: dalla pagina di riposo `about:blank` Chromium rifiuta gli indirizzi locali del CDN di prova (`net::ERR_BLOCKED_BY_PRIVATE_NETWORK_ACCESS_CHECKS`); dalle pagine del sito funziona. Con il CDN pubblico va misurato se lo scaricamento regge anche dalla pagina di riposo | `BrowserFileFetcher`; la via `HttpClient` di §6.5 punto 3 **non è scritta**: resta dietro `IFileFetcher` finché H7 non dice che serve. Codici HTTP di «indirizzo scaduto» (in locale 403 e 410) |
|
||||
| H8 | I segnali di arresto si riconoscono da indirizzo e stato HTTP | **Da provare dal vivo** (non provocare segnali di proposito) | Se durante la sonda compare una verifica o un avviso, annotare l'ora e mandare la riga corrispondente di `navigazioni.jsonl` ripulita. Sul sito di prova i casi 429, `/verifica`, sessione terminata e pagine vuote fermano le ricette (prove `StopAndDownloadIntegrationTests`) | `segnali.json` (le regole su Instagram restano ipotesi segnate H8) |
|
||||
| H9 | Un contenuto di una raccolta ha lo stesso identificativo che aveva come storia | **Da provare dal vivo** | Passo A3.5: aprire una raccolta che contenga una storia ancora attiva (o pubblicata e poi messa in evidenza dall'account di prova). Confrontare gli identificativi nei ripuliti: la ripulitura dà a valori uguali lo stesso valore finto | Raccolta in evidenza (collegamento senza riscaricare); sul sito di prova funziona così per costruzione |
|
||||
| H10 | Identificativo e nome dell'account collegato si ricavano dai dati, senza leggere i cookie | **Da provare dal vivo** | Passo A3.1: nei ripuliti della home cercare un nodo che descriva l'account collegato | `viewer` di `lettori.instagram.json`; il profilo «Tu» |
|
||||
| H11 | I bersagli si trovano con attributi stabili: ruolo, nome accessibile, forma del collegamento | **Da provare dal vivo**. Scheletro pronto: `bersagli.instagram.json` | Durante tutta la sonda: passare col puntatore e cliccare i comandi elencati al passo A3; la sonda registra ruolo, nome accessibile e forma del collegamento in `interazioni.jsonl`. Alberto manda le righe dei soli comandi dell'interfaccia (passo A6) | Tutte le ricette |
|
||||
| S1 | In WebView2 funzionano corpo delle risposte, gesti e fotogrammi | **Da provare** su Windows. Pronto: `WebView2Browser` (Febe.Desktop) con l'adattatore `WebView2CdpSession` (stesso elenco ammesso del client Chromium, provato su Linux con un finto WebView2) | `docs/prove-dal-vivo.md`, parte C3: Febe per Windows con `--sito-di-prova`, una sessione intera (`Network.getResponseBody`, `Input.dispatchMouseEvent`, `Network.loadNetworkResource`/`IO.read`) e l'anteprima di Attività (`Page.captureScreenshot`). `Page.startScreencast` su Windows non serve (la vista remota è solo di Docker) | `WebView2Browser`, `WebView2CdpSession` |
|
||||
| S2 | Su Windows la pagina carica e scorre con la finestra fuori vista | **Da provare** su Windows. Pronti i tre modi di §6.6, scelti con `Febe.exe --browser finestra\|composizione\|edge` (predefinito `finestra`: fuori dallo schermo, `IsVisible` sempre vero, `--disable-features=CalculateNativeWinOcclusion --disable-backgrounding-occluded-windows`) | `docs/prove-dal-vivo.md`, parte C4: sessione sul sito di prova con il browser fuori vista, con la finestra di Febe ridotta a icona e con lo schermo bloccato; se non regge, `composizione` e poi `edge` | `WebView2Browser`, `CompositionHost`, `EdgeBrowser` |
|
||||
| S3 | L'accesso a mano sopravvive al riavvio | **Provato in locale per Docker/Chromium** (cookie scritto con arresto SIGINT, 3 esecuzioni su 3; vedi `esito-locale.md`); **da provare** su Windows (all'arresto Febe chiude WebView2 e ne aspetta l'uscita prima di finire) e nel contenitore vero | Docker: accedere, riavviare il contenitore, controllare il collegamento. Windows: `docs/prove-dal-vivo.md`, parti C3.7 (sito di prova) e C5 (Instagram, account di prova: Esci e riapri, riavvio di Windows, avvio con il computer) | Profilo del browser nella cartella dei dati |
|
||||
| S4 | In Docker, con la vista remota, si scrive in un modulo e si naviga con un ritardo sopportabile | **Provato in locale senza contenitore** (clic e tasti dalla vista remota arrivano alla pagina; vedi `esito-locale.md`); **da provare** nel contenitore su Unraid (M5) | Dalla pagina Collegamento: scrivere in un campo del sito di prova, poi accedere al sito vero con l'account di prova | Vista remota |
|
||||
| S5 | Chromium in Docker parte con la sandbox | **Provato in locale** (`esito-locale.md`): come utente normale la sandbox è attiva; come root Chromium non parte senza `--no-sandbox`. **Da provare** nel contenitore con il profilo seccomp predefinito (M5) | `chrome://sandbox` letto in sola lettura, come in `esito-locale.md` | Compromesso eventuale di §11, da scrivere nella guida |
|
||||
| S6 | Che cosa vede la pagina: `navigator.webdriver`, visibilità, fuoco, lingua, fuso | **Provato in locale per Chromium su Xvfb** (`esito-locale.md`): `webdriver` falso con porta fissa, pagina visibile, `it-IT`, `Europe/Rome`, fuoco dopo il primo evento del puntatore. **Da provare** con il Chromium di Debian (M5) e in WebView2 (M6) | Prova `BrowserIntegrationTests.ThePageSeesAnOrdinaryVisibleBrowser` | — |
|
||||
|
||||
## Che cosa è pronto per ricevere gli esiti
|
||||
|
||||
- `src/Febe.Core/Config/bersagli.instagram.json` (copiato in `config/`): **scheletro**. Elenca le pagine e i bersagli
|
||||
di cui le ricette hanno bisogno, tutti vuoti e segnati con l'ipotesi da cui dipendono. Finché una voce necessaria è
|
||||
vuota, la ricetta risponde «non può girare su instagram: la mappa dei bersagli non è ancora compilata (mancano …)»
|
||||
senza aprire pagine e senza chiedere permessi.
|
||||
- `src/Febe.Core/Config/lettori.instagram.json`: **ipotesi**. Contiene solo gli indizi di §6.4 (`pk`, `code`,
|
||||
`taken_at`, `image_versions2.candidates`, `video_versions`, `carousel_media`); ogni altro concetto è vuoto. Con lo
|
||||
stato «ipotesi» le ricette non girano. Va riempito sui campioni ripuliti e portato a «confermato».
|
||||
- `segnali.json`: regole di partenza, ancora ipotesi H8.
|
||||
- Sonda: `febe-sonda registra`, `ripulisci`, `verifica` (procedura in `docs/prove-dal-vivo.md`).
|
||||
- Il sito di prova fa girare tutte le ricette con un browser vero (`tests/Febe.Tests/Collection/`): è la prova che la
|
||||
raccolta funziona **quando** mappa e vocabolario saranno compilati, non che Instagram si comporti allo stesso modo.
|
||||
@@ -0,0 +1,47 @@
|
||||
# Stato
|
||||
|
||||
Filo fra le sessioni (specifica §15): che cosa è fatto, che cosa è in corso, che cosa è rimandato e perché.
|
||||
Aggiornato il 13 ottobre 2026, versione 0.1.0 (anteprima).
|
||||
|
||||
## In breve
|
||||
|
||||
Tutte le tappe M0–M8 sono state realizzate in una volta, su richiesta di Alberto del 13 ottobre 2026, sul ramo
|
||||
`febe-v1`. Il programma è completo e provato **contro il sito di prova locale** (§14.2) con un Chromium vero su Xvfb.
|
||||
**Non ha mai contattato Instagram** (regola 9): per questo le ricette, per costruzione, **si rifiutano di girare su
|
||||
Instagram** finché la sonda di M0 non ha prodotto i campioni da cui compilare `bersagli.instagram.json` (H11) e
|
||||
`lettori.instagram.json` (regola 10). Il prossimo passo è di Alberto: la sonda (`docs/prove-dal-vivo.md`, parte A).
|
||||
|
||||
## Fatto, con i controlli
|
||||
|
||||
| Tappa | Contenuto | Controllo «Fatto quando» |
|
||||
|---|---|---|
|
||||
| M0 | Client CDP con elenco dei comandi ammessi, `ChromiumProcessHost` e Xvfb sorvegliati, sonda passiva con ripulitura e verifica, sito di prova, esito delle ipotesi | S5 e S6 provati in locale (`docs/sonda/esito-locale.md`); prova della ripulitura verde su campioni sintetici; mappa dei bersagli del sito di prova; **H1–H11 da provare dal vivo** (`docs/sonda/esito.md`) |
|
||||
| M1 | Schema SQLite (15 tabelle, migrazioni numerate, scrittore unico), nomi dei file, scrittura sicura, miniature, impronte, `_febe.jsonl`, copie, eliminazione, ricostruzione | Prove di libreria e doppioni verdi; ricostruzione del database da una libreria di prova riuscita; 200.000 elementi: finestra della libreria 3–6 ms |
|
||||
| M2 | Lettori per forma, cattura, gesti, ricette, mappe dei bersagli, coda degli scaricamenti, sito di prova completo | Tutte le nove ricette verdi contro il sito di prova con Chromium vero, casi di arresto compresi |
|
||||
| M3 | Governatore, interruttore, fascia, sessioni, composizione, avvio graduale, cruscotto, simulazione | Prove del motore verdi; `--simula 30g` per i tre profili: **zero superamenti**, nessuna azione fuori fascia, nessuna pausa sotto il pavimento. **Arresto di M3**: Alberto legge i numeri (`docs/decisioni.md` e il resoconto della simulazione) |
|
||||
| M4 | API, eventi, ossatura, tutte le schermate, tema scuro, finestra stretta, modalità dimostrativa | Schermate confrontate con i mockup (`docs/schermate/`, differenze in `docs/schermate/differenze.md`); gli originali di 02, 04–07, 09, 11–14 non sono stati forniti: confronto sui ritagli della panoramica |
|
||||
| M5 | Composizione reale, vista remota, password, pagina di errore, `/salute`, Dockerfile, compose, modello Unraid | Prova d'insieme del server reale contro il sito di prova; immagine costruita dalla CI sul runner; **non provata su Unraid** |
|
||||
| M6 | Febe per Windows (WPF, WebView2Host, area di notifica, funzioni native), installatore NSIS | `Febe.exe` (file unico) e `Febe-Setup-0.1.0.exe` costruiti su Linux; **mai eseguiti su Windows**: S1–S3 da provare (`docs/prove-dal-vivo.md`, parte C) |
|
||||
| M7 | Importazione in quattro passi, riconoscitori, doppioni, copia verificata | Prove di importazione verdi; riconoscitore 4K Stogram solo come ipotesi (domanda 4 di §16) |
|
||||
| M8 | Avvisi (interfaccia, notifiche di Windows, Telegram), esportazione CSV, guida | Un arresto simulato produce striscia, notifica e messaggio (prova automatica con canali finti); guida in `docs/guida/`, pubblicata nel wiki |
|
||||
|
||||
Revisione avversaria completata il 14 ottobre (54 rilievi confermati e corretti, vedi `docs/decisioni.md`).
|
||||
|
||||
Prove automatiche: `dotnet test tests/Febe.Tests` — 750 prove, tutte verdi (le prove con il browser vero si
|
||||
saltano da sole dove mancano Chromium e Xvfb, come sul runner della CI).
|
||||
|
||||
## Da fare (di Alberto)
|
||||
|
||||
1. **Sonda di M0** con l'account di prova (domanda 2 di §16): `docs/prove-dal-vivo.md`, parte A. Poi mandare i
|
||||
campioni **ripuliti** e le righe di `interazioni.jsonl` dei comandi dell'interfaccia: con quelli si compilano
|
||||
`bersagli.instagram.json` e `lettori.instagram.json` e si portano le ipotesi H1–H11 a un esito.
|
||||
2. **Prima sessione dal vivo** dopo la sonda, con il profilo Prudente su un profilo pubblico (parte B).
|
||||
3. **Windows**: S1–S3 (parte C). **Docker su Unraid**: S3–S6 nel contenitore vero.
|
||||
4. Le domande aperte di §16 (sono state adottate le proposte della terza colonna, vedi `docs/decisioni.md`).
|
||||
5. Il segreto `REGISTRY_TOKEN` nel repository, perché il rilascio pubblichi l'immagine sul registro di Gitea.
|
||||
|
||||
## Rimandato, e perché
|
||||
|
||||
- Via `HttpClient` verso il CDN (§6.5 punto 3): dipende da H7.
|
||||
- Riconoscitore di 4K Stogram vero e lettura di `stogram.sqlite`: servono i nomi veri dei file (domanda 4).
|
||||
- M9 (desktop collegato a un Febe remoto, seconda lingua): facoltativa.
|
||||
@@ -0,0 +1,219 @@
|
||||
# Febe per Windows
|
||||
|
||||
La veste Windows di Febe (specifica §12): lo stesso motore e la stessa interfaccia del contenitore Docker, in
|
||||
un'applicazione per Windows 10 e 11. La finestra di Febe mostra l'interfaccia; il browser con cui Febe visita Instagram
|
||||
è una **seconda finestra, «Browser di Febe»**, che resta aperta ma fuori vista quando non ti serve.
|
||||
|
||||
> **Prima di tutto.** Scaricare con un programma è contro le condizioni d'uso di Instagram. Febe va piano per ridurre il
|
||||
> rischio per l'account (ritmo umano, tetti, fermo al primo segnale), ma non può azzerarlo. Le storie che Febe apre
|
||||
> risultano viste da te.
|
||||
|
||||
> **Stato.** Questa versione è stata costruita e provata su Linux: tutto ciò che non dipende da Windows ha le sue prove
|
||||
> automatiche, ma **nessuna parte che richiede Windows è ancora stata eseguita su un Windows vero** (finestre, WebView2,
|
||||
> area di notifica, registro, programma di installazione). Le prove da fare sono in fondo a questa pagina e in
|
||||
> `docs/prove-dal-vivo.md`, parte C.
|
||||
|
||||
## Che cosa serve
|
||||
|
||||
- Windows 10 o 11 a 64 bit.
|
||||
- Il **runtime WebView2** di Microsoft: c'è già in Windows 11 e in quasi tutti i Windows 10. Se manca, sia il programma
|
||||
di installazione sia Febe lo dicono e offrono la pagina ufficiale:
|
||||
<https://developer.microsoft.com/microsoft-edge/webview2/> (installazione «Evergreen», senza permessi di amministratore).
|
||||
- Nessun permesso di amministratore: Febe si installa solo per il tuo utente.
|
||||
|
||||
## Installazione
|
||||
|
||||
1. Scarica `Febe-Setup-<versione>.exe` dalla pagina delle release del repository e aprilo.
|
||||
2. Windows può avvisare che il programma non è firmato (SmartScreen): «Ulteriori informazioni» ▸ «Esegui comunque».
|
||||
3. Il programma di installazione mette `Febe.exe` in `%LOCALAPPDATA%\Programs\Febe`, crea il collegamento nel menu Start
|
||||
e, se lo lasci scelto, uno sul desktop. Febe compare in Impostazioni di Windows ▸ App installate (editore Alberto Balbo).
|
||||
4. Alla fine puoi aprire Febe subito.
|
||||
|
||||
**Versione portabile.** `Febe-<versione>-portabile.zip` contiene lo stesso `Febe.exe` (e un `LEGGIMI.txt`): si copia
|
||||
dove si vuole e si apre, senza installazione. Anche la versione portabile tiene i dati in `%LOCALAPPDATA%\Febe` e la
|
||||
libreria in `Immagini\Febe`, finché non scegli altre cartelle.
|
||||
|
||||
`Febe.exe` è un file solo (circa 86 MB): contiene il runtime .NET, l'interfaccia e le librerie native (SQLite, SkiaSharp,
|
||||
WebView2Loader). Al primo avvio Windows estrae le librerie native in `%TEMP%\.net\Febe`: è normale.
|
||||
|
||||
## Il primo collegamento a Instagram
|
||||
|
||||
1. Apri Febe: la finestra mostra l'interfaccia (la prima volta, la schermata di benvenuto).
|
||||
2. Vai in **Impostazioni ▸ Collegamento** (o «Collegati a Instagram» dal benvenuto). Si apre in primo piano la finestra
|
||||
**«Browser di Febe»** con la vera pagina di accesso di Instagram.
|
||||
3. Scrivi tu nome utente, password e l'eventuale codice della verifica in due passaggi **in quella finestra**: vanno
|
||||
direttamente alla pagina di Instagram. Febe non riceve e non salva la password; il salvataggio delle password e la
|
||||
compilazione automatica del browser sono spenti.
|
||||
4. Quando vedi la tua pagina iniziale di Instagram, torna alla finestra di Febe e premi **«Ho finito»**: Febe controlla
|
||||
che la sessione ci sia (guarda solo se il cookie esiste, mai il suo valore) e rimette il browser fuori vista.
|
||||
5. La prima sessione arriva qualche minuto dopo, con calma: nei primi giorni i tetti sono ridotti (avvio graduale).
|
||||
|
||||
La sessione resta nel profilo del browser, in `%LOCALAPPDATA%\Febe\browser`, e sopravvive ai riavvii di Febe e di
|
||||
Windows (ipotesi S3, da confermare: vedi sotto).
|
||||
|
||||
### La finestra «Browser di Febe»
|
||||
|
||||
- Ha una dimensione fissa, sempre la stessa (la pagina è di 1280 × 900 punti), e sotto la pagina una barra con
|
||||
«Indietro», «Ricarica» e l'indirizzo (senza la parte dopo il `?`).
|
||||
- Quando non ti serve **non è chiusa né ridotta a icona**: è aperta ma spostata fuori dallo schermo, perché il browser
|
||||
deve continuare a caricare e scorrere anche quando non lo guardi (ipotesi S2). Non ha un pulsante nella barra delle
|
||||
applicazioni.
|
||||
- La porti in primo piano dalla finestra di Febe: «Apri il browser» (Attività, striscia rossa di un arresto) o
|
||||
«Portalo in primo piano» (Collegamento).
|
||||
- **Mentre la usi il motore resta fermo.** Quando hai finito, chiudila (la X o «Ho finito» nel Collegamento): torna
|
||||
fuori vista e il motore può ripartire. Dopo una verifica, «Riprendi» si accende solo dopo che hai usato il browser.
|
||||
- «Scollega» (Collegamento) chiede conferma, ferma il motore, chiude il browser e cancella `Dati\browser` con la sessione.
|
||||
Per chiudere la sessione anche dal lato di Instagram, prima esci dal sito usando tu il browser.
|
||||
|
||||
## Un account, un motore
|
||||
|
||||
**Non usare insieme Febe per Windows e il contenitore Docker con lo stesso account Instagram.** Due Febe che raccolgono
|
||||
con lo stesso account sommano le visite e raddoppiano il rischio. Lo dice anche la pagina Collegamento. Per un secondo
|
||||
account serve un secondo Febe con cartelle tutte sue (`Febe.exe --dati D:\FebeSecondo --libreria D:\FotoSecondo`).
|
||||
Febe impedisce due avvii sulla stessa cartella dei dati: un secondo avvio porta in primo piano quello già aperto.
|
||||
Vale anche subito dopo uno spostamento della cartella dei dati (il Febe che l'ha spostata tiene anche il nome della
|
||||
nuova) e con due modi di scrivere la stessa cartella (nome corto, `subst`, collegamenti): finché Febe è aperto tiene
|
||||
il file `febe.lock` nella cartella dei dati, e un secondo Febe che lo trova occupato si ferma e lo dice.
|
||||
|
||||
## Area di notifica
|
||||
|
||||
L'icona di Febe (il marchio: un quadrato blu con un anello e una luna) sta nell'area di notifica, accanto all'orologio.
|
||||
Un clic apre la finestra; il menu ha **Apri**, **Metti in pausa** (o **Riprendi**, quando Febe è in pausa o fermo per una
|
||||
verifica) ed **Esci**. Il suggerimento dell'icona dice che cosa sta facendo Febe.
|
||||
|
||||
**Chiudendo la finestra Febe resta attivo** nell'area di notifica e continua a lavorare (Impostazioni ▸ Generali ▸
|
||||
Avvio, «Chiudendo la finestra, Febe resta attivo nell'area di notifica», acceso di serie). Per fermarlo davvero:
|
||||
menu dell'icona ▸ **Esci**. Esci ferma tutto in ordine (motore, scaricamenti, browser): il browser si chiude in modo
|
||||
pulito e la sessione resta scritta nel profilo.
|
||||
|
||||
### Notifiche di Windows
|
||||
|
||||
Gli avvisi di §13.3 (verifica richiesta, disconnessione, fermo per rallentamento e fine del fermo, storico completato,
|
||||
formato non riconosciuto e ricetta sospesa, disco quasi pieno) arrivano come notifiche di Windows, dall'icona di Febe.
|
||||
Si scelgono in Impostazioni ▸ Notifiche («Notifiche di Windows» e gli eventi), dove si può aggiungere anche Telegram:
|
||||
gli avvisi sono gli stessi della veste Docker (`AlertService`, nella composizione condivisa), e le notifiche passano dal
|
||||
guscio di Windows (`NativeShellAlertChannel` su `WindowsShell.NotifyAsync`). Un clic sulla notifica apre Febe. La prova
|
||||
dal vivo è la parte D4 di `docs/prove-dal-vivo.md`.
|
||||
|
||||
## Avvio con il computer
|
||||
|
||||
Impostazioni ▸ Generali ▸ Avvio ▸ «Avvia Febe all'accensione del computer». Febe scrive il valore `Febe` in
|
||||
`HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run` (solo per il tuo utente) e all'accensione parte con
|
||||
`--nascosto`: solo l'icona nell'area di notifica, la finestra resta chiusa. Togliendo la spunta il valore sparisce;
|
||||
lo toglie anche la disinstallazione.
|
||||
|
||||
Un Febe avviato con `--dati` (un secondo account) ha un valore suo, `Febe-` seguito da sedici cifre esadecimali, con
|
||||
`--nascosto --dati "<cartella>"`: all'accensione parte quella cartella, e l'interruttore di un Febe non accende, non
|
||||
mostra e non toglie l'avvio dell'altro. La disinstallazione toglie anche questi valori, se avviano il Febe.exe
|
||||
disinstallato.
|
||||
|
||||
## Dove stanno le cose
|
||||
|
||||
| Che cosa | Dove | Note |
|
||||
|---|---|---|
|
||||
| Programma | `%LOCALAPPDATA%\Programs\Febe\Febe.exe` | Dove l'hai copiato, per la versione portabile |
|
||||
| **Dati di Febe** | `%LOCALAPPDATA%\Febe` | Database `febe.sqlite`, **profilo del browser con la sessione di Instagram** (`browser\`), dati della finestra dell'interfaccia (`interfaccia\`), miniature, copie del database (`copie\`, sette giorni), registro (`registro\`, quattordici giorni) |
|
||||
| **Libreria** | `Immagini\Febe` | Foto e video, una cartella per account, con `_febe.jsonl` |
|
||||
|
||||
- **Chi ha la cartella dei dati, o una sua copia, ha la sessione di Instagram.** Trattala come una password: niente
|
||||
copie su chiavette, cartelle condivise o servizi di sincronizzazione (OneDrive, Dropbox…). `%LOCALAPPDATA%` non è
|
||||
sincronizzato da OneDrive: lasciala lì.
|
||||
- La cartella dei dati deve stare su un **disco locale**: su una cartella di rete Febe non parte e lo spiega.
|
||||
- **Cambiare la libreria** (Impostazioni ▸ Generali ▸ Libreria ▸ «Cambia…»): vale subito per i nuovi file; gli account
|
||||
che hanno già file restano nelle loro cartelle. Febe non sposta nessun file.
|
||||
- **Cambiare la cartella dei dati** (Impostazioni ▸ Generali ▸ Dati di Febe ▸ «Cambia…»): la nuova cartella deve essere
|
||||
vuota e su un disco locale. Lo spostamento avviene **al prossimo avvio**, prima che Febe apra qualunque cosa: copia
|
||||
ogni file, lo rilegge e ne confronta lo SHA-256 con l'originale; solo se tutte le copie sono uguali usa la nuova
|
||||
cartella e cancella la vecchia (che conteneva una copia della sessione). Se qualcosa va storto la vecchia cartella resta
|
||||
quella in uso, intatta, e la copia parziale viene tolta. Per farlo subito: Esci e riapri Febe. La cartella scelta è
|
||||
scritta in `HKEY_CURRENT_USER\Software\Febe` (`CartellaDati`); con `--dati` decide invece la riga di comando.
|
||||
|
||||
## Riga di comando
|
||||
|
||||
| Opzione | Che cosa fa |
|
||||
|---|---|
|
||||
| `--nascosto` | Parte con la sola icona nell'area di notifica (lo usa l'avvio con il computer) |
|
||||
| `--dati <cartella>` | Cartella dei dati diversa (un secondo account, le prove); «Cambia…» allora non c'è |
|
||||
| `--libreria <cartella>` | Libreria di partenza diversa (una cartella scelta poi nelle Impostazioni vince) |
|
||||
| `--browser finestra\|composizione\|edge` | Come è ospitato il browser di Instagram (prove di S2, sotto); la scelta resta per gli avvii successivi |
|
||||
| `--sviluppo` | Strumenti di sviluppo nella finestra dell'interfaccia (mai nel browser di Febe) |
|
||||
| `--sito-di-prova http://127.0.0.1:8481` | Sviluppo e prove: il browser lavora sul sito di prova locale invece che su Instagram |
|
||||
| `--accesso-di-prova` | Solo con `--sito-di-prova`: apre il sito una volta, come dopo un accesso |
|
||||
| `--prima-sessione <secondi>` | La prima sessione dopo questi secondi invece che dopo 2–10 minuti |
|
||||
|
||||
## Sicurezza dell'interfaccia
|
||||
|
||||
L'interfaccia è servita da Febe stesso su `127.0.0.1`, su una porta scelta a ogni avvio, e risponde solo con il
|
||||
**gettone di quell'avvio**, che conosce solo la finestra di Febe: la finestra apre `/?gettone=…` una volta, il gettone
|
||||
diventa un cookie `HttpOnly`, `SameSite=Strict` e sparisce dall'indirizzo. Si controllano anche `Host` e `Origin`:
|
||||
un'altra pagina aperta nel tuo browser non può comandare Febe. Gli indirizzi esterni (guida, repository, «Apri su
|
||||
Instagram») si aprono nel tuo browser predefinito, mai nel browser di Febe.
|
||||
|
||||
## Il browser di Febe e le ipotesi S1–S3
|
||||
|
||||
Su Windows il browser di Instagram è WebView2 (il motore di Edge), pilotato con il protocollo DevTools attraverso
|
||||
`CallDevToolsProtocolMethodAsync` e `GetDevToolsProtocolEventReceiver` (non il pacchetto `DevToolsProtocolExtension`,
|
||||
deprecato), con lo **stesso elenco di comandi ammessi** del Chromium di Docker e gli stessi rifiuti: nessun comando
|
||||
fuori elenco arriva al browser, `Runtime.evaluate` solo in lettura, nel registro solo i nomi dei comandi.
|
||||
|
||||
Per S2 (la pagina deve continuare a caricare e scorrere quando la finestra non è in vista) ci sono tre modi, nell'ordine
|
||||
della specifica (§6.6); si sceglie con `--browser` e la scelta resta:
|
||||
|
||||
1. **`finestra`** (predefinito): la finestra «Browser di Febe» aperta ma fuori dallo schermo; il controllo WebView2
|
||||
resta sempre «visibile» (`IsVisible` vero: se diventa falso WebView2 smette di disegnare) e il rilevamento
|
||||
dell'occlusione è spento dagli argomenti del browser: `--disable-features=CalculateNativeWinOcclusion` e
|
||||
`--disable-backgrounding-occluded-windows`. Non sono vietati dalla regola 2: cambiano come il browser organizza il
|
||||
proprio lavoro, non ciò che dichiara (user agent, client hints, `navigator`, lingua, fuso e intestazioni restano
|
||||
quelli di un Edge normale; nella pagina non entra nulla).
|
||||
2. **`composizione`**: lo stesso, con WebView2 ospitato come visual di DirectComposition invece che come finestra figlia;
|
||||
Febe passa al browser il mouse e il puntatore della zona della pagina.
|
||||
3. **`edge`**: Microsoft Edge avviato come processo e pilotato come il Chromium di Docker (`ChromiumProcessHost`, porta
|
||||
di debug fissa 9222 solo su 127.0.0.1), profilo in `Dati\browser\edge`; la sua finestra viene spostata fuori
|
||||
dallo schermo. Se Edge non c'è, Febe usa la `finestra`. Ogni Edge avviato da Febe sta in un *job object* di Windows
|
||||
che lo chiude insieme a Febe.exe, anche se Febe si chiude all'improvviso o da Gestione attività: un Edge rimasto
|
||||
aperto terrebbe la porta 9222 e il browser di Febe non ripartirebbe più.
|
||||
|
||||
Le prove da fare su un Windows vero, con la procedura esatta, sono in `docs/prove-dal-vivo.md`, **parte C**. In breve:
|
||||
|
||||
- **S1** — con il sito di prova: una sessione intera (gesti, corpo delle risposte, scaricamenti) e l'anteprima di Attività.
|
||||
- **S2** — la stessa sessione con il browser fuori vista, con la finestra di Febe ridotta a icona e con lo schermo bloccato;
|
||||
poi, se serve, `composizione` e `edge`.
|
||||
- **S3** — accesso a mano, «Esci», riapertura, riavvio di Windows: il collegamento deve restare.
|
||||
|
||||
## Disinstallare
|
||||
|
||||
Impostazioni di Windows ▸ App ▸ App installate ▸ Febe ▸ Disinstalla (oppure «Disinstalla Febe.exe» nella cartella del
|
||||
programma). Prima esci da Febe (menu dell'icona ▸ Esci).
|
||||
|
||||
La disinstallazione toglie il programma, i collegamenti, la voce in App installate e l'avvio con il computer. **Non
|
||||
cancella mai la cartella dei dati né la libreria** e non chiede nulla su di loro: alla fine dice dove sono. Se non ti
|
||||
servono più, cancellale tu — la cartella dei dati contiene la sessione di Instagram.
|
||||
|
||||
## Costruire il programma di installazione
|
||||
|
||||
Da Linux (CI, rilascio) o da Windows con bash, con il .NET SDK 10 e NSIS 3 (`apt-get install nsis`):
|
||||
|
||||
```sh
|
||||
installer/costruisci.sh # versione di Directory.Build.props
|
||||
installer/costruisci.sh 0.2.0 # oppure una versione esplicita
|
||||
```
|
||||
|
||||
Il risultato è in `out/`: `Febe-Setup-<versione>.exe` e `Febe-<versione>-portabile.zip`, ognuno sotto i 100 MB
|
||||
(limite degli allegati di Gitea; con la versione 0.1.0: Febe.exe 86 MB, installazione 80 MB, zip 81 MB). Lo script
|
||||
controlla che la pubblicazione abbia prodotto un solo file e che nulla superi il limite. Lo script NSIS è
|
||||
`installer/febe.nsi` (Unicode, testi in italiano, versione passata con `/DVERSION=…`).
|
||||
|
||||
L'icona `src/Febe.Desktop/Febe.ico` (16, 24, 32, 48, 64, 128 e 256 pixel) è disegnata dal marchio dell'appendice C con
|
||||
SkiaSharp e scritta a mano: per rigenerarla dopo un cambio del marchio,
|
||||
`FEBE_RIGENERA_ICONA=1 dotnet test tests/Febe.Tests --filter IconTests`.
|
||||
|
||||
## Problemi comuni
|
||||
|
||||
| Che cosa vedi | Che cosa fare |
|
||||
|---|---|
|
||||
| All'avvio: «Manca il runtime WebView2 di Microsoft» | Installa il runtime dalla pagina ufficiale (il messaggio offre di aprirla), poi riapri Febe |
|
||||
| «La cartella dei dati è su un disco di rete» o «non può scrivere» | Riapri Febe con una cartella dei dati su un disco locale (`--dati`), oppure libera la cartella |
|
||||
| Aprendo Febe si porta solo in primo piano la finestra già aperta | È voluto: un solo Febe per cartella dei dati. Per fermarlo: menu dell'icona ▸ Esci |
|
||||
| Il collegamento risulta perso dopo un riavvio | È l'ipotesi S3: riferiscilo (parte C di `docs/prove-dal-vivo.md`) con l'ora e il registro di quel giorno |
|
||||
| Il browser sembra fermo mentre è fuori vista | È l'ipotesi S2: prova `Febe.exe --browser composizione`, poi `--browser edge`, e riferisci |
|
||||
| Il registro | `%LOCALAPPDATA%\Febe\registro\febe-AAAA-MM-GG.log`: azioni ed esiti, mai password, cookie, tasti o contenuti |
|
||||
@@ -0,0 +1,98 @@
|
||||
#!/usr/bin/env bash
|
||||
# Febe per Windows: pubblica Febe.exe in un file solo e ne fa il programma di installazione e lo zip portabile.
|
||||
#
|
||||
# installer/costruisci.sh [versione]
|
||||
#
|
||||
# Gira su Linux (CI e rilascio) come su Windows con bash: servono il .NET SDK 10 e makensis (NSIS 3, «apt-get install
|
||||
# nsis»). La versione, se non la si passa, è quella di Directory.Build.props (il tag deve coincidere).
|
||||
# Risultato in out/:
|
||||
# Febe-Setup-<versione>.exe installazione per l'utente, senza permessi di amministratore
|
||||
# Febe-<versione>-portabile.zip Febe.exe e LEGGIMI.txt, da copiare dove si vuole
|
||||
# Ognuno deve restare sotto i 100 MB (limite degli allegati di Gitea).
|
||||
set -euo pipefail
|
||||
|
||||
radice="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
|
||||
cd "$radice"
|
||||
|
||||
versione="${1:-$(sed -n 's:.*<Version>\(.*\)</Version>.*:\1:p' Directory.Build.props | head -n 1)}"
|
||||
if [[ ! "$versione" =~ ^[0-9]+\.[0-9]+\.[0-9]+([-+][0-9A-Za-z.-]+)?$ ]]; then
|
||||
echo "Versione non valida: «$versione» (serve x.y.z)." >&2
|
||||
exit 2
|
||||
fi
|
||||
|
||||
# La versione dei file di Windows vuole quattro numeri.
|
||||
numeri="${versione%%[-+]*}"
|
||||
versione_file="${numeri}.0"
|
||||
|
||||
command -v dotnet >/dev/null || { echo "Manca il .NET SDK (dotnet)." >&2; exit 2; }
|
||||
command -v makensis >/dev/null || { echo "Manca makensis: installa NSIS (apt-get install nsis)." >&2; exit 2; }
|
||||
|
||||
uscita="$radice/out"
|
||||
pubblicazione="$uscita/pubblicazione"
|
||||
rm -rf "$pubblicazione"
|
||||
mkdir -p "$pubblicazione"
|
||||
|
||||
echo "== Pubblicazione di Febe.exe $versione (win-x64, un file solo)"
|
||||
dotnet publish src/Febe.Desktop/Febe.Desktop.csproj -c Release -r win-x64 --self-contained true \
|
||||
-p:PublishSingleFile=true -p:IncludeNativeLibrariesForSelfExtract=true -p:EnableCompressionInSingleFile=true \
|
||||
-p:Version="$versione" -nologo -o "$pubblicazione"
|
||||
|
||||
# Un file solo: niente accanto all'eseguibile.
|
||||
altri="$(find "$pubblicazione" -mindepth 1 ! -name Febe.exe)"
|
||||
if [[ -n "$altri" ]]; then
|
||||
echo "La pubblicazione ha prodotto altri file oltre a Febe.exe:" >&2
|
||||
echo "$altri" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo "== Programma di installazione"
|
||||
setup="$uscita/Febe-Setup-$versione.exe"
|
||||
rm -f "$setup"
|
||||
(cd installer && makensis -V2 -INPUTCHARSET UTF8 \
|
||||
-DVERSION="$versione" -DVERSIONE_FILE="$versione_file" \
|
||||
-DSORGENTE="$pubblicazione" -DUSCITA="$setup" febe.nsi)
|
||||
|
||||
echo "== Zip portabile"
|
||||
zip_portabile="$uscita/Febe-$versione-portabile.zip"
|
||||
rm -f "$zip_portabile"
|
||||
leggimi="$pubblicazione/LEGGIMI.txt"
|
||||
cat > "$leggimi" <<TESTO
|
||||
Febe $versione per Windows, versione portabile
|
||||
|
||||
Febe.exe funziona da qualunque cartella, senza installazione e senza permessi di amministratore.
|
||||
Serve il runtime WebView2 di Microsoft (c'è già in Windows 11 e in quasi tutti i Windows 10;
|
||||
altrimenti: https://developer.microsoft.com/microsoft-edge/webview2/).
|
||||
|
||||
Anche la versione portabile tiene i suoi dati in %LOCALAPPDATA%\Febe (database e sessione del browser
|
||||
di Instagram) e le foto e i video in Immagini\Febe, se non scegli altre cartelle nelle Impostazioni.
|
||||
Per un secondo account, con cartelle tutte sue: Febe.exe --dati D:\FebeSecondo
|
||||
|
||||
Chi ha la cartella dei dati, o una sua copia, ha la sessione di Instagram: trattala come una password.
|
||||
Non usare insieme Febe per Windows e il contenitore Docker con lo stesso account.
|
||||
|
||||
Guida: https://gitea.encke-hake.ts.net/Alby96/Febe/wiki
|
||||
TESTO
|
||||
sed -i 's/$/\r/' "$leggimi"
|
||||
if command -v zip >/dev/null; then
|
||||
(cd "$pubblicazione" && zip -q -9 "$zip_portabile" Febe.exe LEGGIMI.txt)
|
||||
else
|
||||
python3 - "$zip_portabile" "$pubblicazione" <<'PY'
|
||||
import os, sys, zipfile
|
||||
target, folder = sys.argv[1], sys.argv[2]
|
||||
with zipfile.ZipFile(target, "w", zipfile.ZIP_DEFLATED, compresslevel=9) as archive:
|
||||
for name in ("Febe.exe", "LEGGIMI.txt"):
|
||||
archive.write(os.path.join(folder, name), name)
|
||||
PY
|
||||
fi
|
||||
rm -f "$leggimi"
|
||||
|
||||
limite=$((100 * 1024 * 1024))
|
||||
echo "== Risultato"
|
||||
for file in "$pubblicazione/Febe.exe" "$setup" "$zip_portabile"; do
|
||||
dimensione=$(stat -c %s "$file")
|
||||
awk -v nome="$(basename "$file")" -v byte="$dimensione" 'BEGIN { printf "%-48s %6.1f MB\n", nome, byte / 1048576 }'
|
||||
if (( dimensione >= limite )); then
|
||||
echo "$(basename "$file") supera i 100 MB: Gitea non lo accetta come allegato." >&2
|
||||
exit 1
|
||||
fi
|
||||
done
|
||||
@@ -0,0 +1,232 @@
|
||||
; Febe — programma di installazione per Windows (specifica §12, domanda 6 di §16).
|
||||
;
|
||||
; makensis -INPUTCHARSET UTF8 -DVERSION=0.1.0 -DVERSIONE_FILE=0.1.0.0 \
|
||||
; -DSORGENTE=out/pubblicazione -DUSCITA=out/Febe-Setup-0.1.0.exe installer/febe.nsi
|
||||
;
|
||||
; Di solito lo lancia installer/costruisci.sh, che prima pubblica Febe.exe in un file solo.
|
||||
;
|
||||
; - Installazione per l'utente, senza permessi di amministratore, in %LOCALAPPDATA%\Programs\Febe.
|
||||
; - Collegamento nel menu Start; collegamento sul desktop facoltativo.
|
||||
; - Disinstallazione registrata in HKCU (Programmi e funzionalità / App installate).
|
||||
; - La disinstallazione non tocca MAI la cartella dei dati né la libreria e non chiede nulla su di loro: dice dove sono.
|
||||
; - Controllo del runtime WebView2 di Microsoft, con il collegamento alla pagina ufficiale se manca.
|
||||
|
||||
Unicode true
|
||||
ManifestDPIAware true
|
||||
RequestExecutionLevel user
|
||||
SetCompressor /SOLID lzma
|
||||
|
||||
!ifndef VERSION
|
||||
!error "Manca la versione: passala con /DVERSION=x.y.z (installer/costruisci.sh la legge da Directory.Build.props)."
|
||||
!endif
|
||||
!ifndef SORGENTE
|
||||
!define SORGENTE "../out/pubblicazione"
|
||||
!endif
|
||||
!ifndef USCITA
|
||||
!define USCITA "../out/Febe-Setup-${VERSION}.exe"
|
||||
!endif
|
||||
|
||||
!define NOME "Febe"
|
||||
!define EDITORE "Alberto Balbo"
|
||||
!define ESEGUIBILE "Febe.exe"
|
||||
!define DISINSTALLA "Disinstalla Febe.exe"
|
||||
!define CHIAVE_DISINSTALLA "Software\Microsoft\Windows\CurrentVersion\Uninstall\Febe"
|
||||
!define CHIAVE_FEBE "Software\Febe"
|
||||
!define CHIAVE_AVVIO "Software\Microsoft\Windows\CurrentVersion\Run"
|
||||
!define WEBVIEW2_GUID "{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}"
|
||||
!define WEBVIEW2_PAGINA "https://developer.microsoft.com/microsoft-edge/webview2/"
|
||||
!define SITO "https://gitea.encke-hake.ts.net/Alby96/Febe"
|
||||
|
||||
Name "${NOME}"
|
||||
OutFile "${USCITA}"
|
||||
InstallDir "$LOCALAPPDATA\Programs\Febe"
|
||||
BrandingText "${NOME} ${VERSION}"
|
||||
ShowInstDetails show
|
||||
ShowUninstDetails show
|
||||
|
||||
!ifdef VERSIONE_FILE
|
||||
VIProductVersion "${VERSIONE_FILE}"
|
||||
VIAddVersionKey /LANG=1040 "ProductName" "${NOME}"
|
||||
VIAddVersionKey /LANG=1040 "ProductVersion" "${VERSION}"
|
||||
VIAddVersionKey /LANG=1040 "CompanyName" "${EDITORE}"
|
||||
VIAddVersionKey /LANG=1040 "LegalCopyright" "${EDITORE}"
|
||||
VIAddVersionKey /LANG=1040 "FileDescription" "Installazione di ${NOME}"
|
||||
VIAddVersionKey /LANG=1040 "FileVersion" "${VERSION}"
|
||||
!endif
|
||||
|
||||
!include "MUI2.nsh"
|
||||
!include "LogicLib.nsh"
|
||||
!include "FileFunc.nsh"
|
||||
|
||||
!define MUI_ICON "../src/Febe.Desktop/Febe.ico"
|
||||
!define MUI_UNICON "../src/Febe.Desktop/Febe.ico"
|
||||
!define MUI_ABORTWARNING
|
||||
|
||||
; ------------------------------------------------------------------------------------------------ pagine
|
||||
!define MUI_WELCOMEPAGE_TITLE "Installazione di Febe ${VERSION}"
|
||||
!define MUI_WELCOMEPAGE_TEXT "Febe è l'archivio personale di foto, video e storie da Instagram.$\r$\n$\r$\nVerrà installato solo per te, in $LOCALAPPDATA\Programs\Febe: non servono permessi di amministratore.$\r$\n$\r$\nI dati di Febe (database e sessione del browser) andranno in $LOCALAPPDATA\Febe, le foto e i video nella cartella Immagini\Febe; le cartelle si possono cambiare dalle Impostazioni."
|
||||
!insertmacro MUI_PAGE_WELCOME
|
||||
!insertmacro MUI_PAGE_COMPONENTS
|
||||
!insertmacro MUI_PAGE_INSTFILES
|
||||
!define MUI_FINISHPAGE_TITLE "Febe è installato"
|
||||
!define MUI_FINISHPAGE_TEXT "Febe si apre in una sua finestra e resta attivo nell'area di notifica, accanto all'orologio.$\r$\n$\r$\nPer collegarlo a Instagram: Impostazioni ▸ Collegamento. Non usare insieme Febe per Windows e il contenitore Docker con lo stesso account."
|
||||
!define MUI_FINISHPAGE_RUN "$INSTDIR\${ESEGUIBILE}"
|
||||
!define MUI_FINISHPAGE_RUN_TEXT "Apri Febe adesso"
|
||||
!insertmacro MUI_PAGE_FINISH
|
||||
|
||||
!define MUI_UNCONFIRMPAGE_TEXT_TOP "Il programma Febe verrà tolto da questo computer. I tuoi dati restano dove sono: la disinstallazione non cancella né la cartella dei dati né la libreria con le foto e i video."
|
||||
!insertmacro MUI_UNPAGE_CONFIRM
|
||||
!insertmacro MUI_UNPAGE_INSTFILES
|
||||
!define MUI_FINISHPAGE_TITLE "Febe è stato disinstallato"
|
||||
!define MUI_FINISHPAGE_TEXT "I dati di Febe non sono stati toccati:$\r$\n$\r$\n- cartella dei dati: $R8$\r$\n- libreria: $R9, o la cartella scelta nelle Impostazioni.$\r$\n$\r$\nLa cartella dei dati contiene la sessione di Instagram: se non ti serve più, cancellala tu."
|
||||
!insertmacro MUI_UNPAGE_FINISH
|
||||
|
||||
!insertmacro MUI_LANGUAGE "Italian"
|
||||
|
||||
LangString DESC_Programma ${LANG_ITALIAN} "Febe.exe, il menu Start e la voce in App installate."
|
||||
LangString DESC_Desktop ${LANG_ITALIAN} "Un collegamento a Febe sul desktop."
|
||||
|
||||
; ------------------------------------------------------------------------------------------------ funzioni
|
||||
; Febe in esecuzione tiene aperto Febe.exe: non si può sovrascrivere né cancellare.
|
||||
!macro FebeChiuso UN
|
||||
Function ${UN}FebeChiuso
|
||||
IfFileExists "$INSTDIR\${ESEGUIBILE}" 0 fatto
|
||||
riprova:
|
||||
ClearErrors
|
||||
FileOpen $0 "$INSTDIR\${ESEGUIBILE}" a
|
||||
${If} ${Errors}
|
||||
MessageBox MB_RETRYCANCEL|MB_ICONEXCLAMATION "Febe è aperto. Chiudilo dall'area di notifica (clic destro sull'icona ▸ Esci), poi premi Riprova." /SD IDCANCEL IDRETRY riprova
|
||||
Abort
|
||||
${EndIf}
|
||||
FileClose $0
|
||||
fatto:
|
||||
FunctionEnd
|
||||
!macroend
|
||||
!insertmacro FebeChiuso ""
|
||||
!insertmacro FebeChiuso "un."
|
||||
|
||||
; Il runtime WebView2 (Evergreen) è installato per tutto il computer o solo per l'utente: «pv» è la sua versione.
|
||||
Function WebView2Presente
|
||||
StrCpy $1 ""
|
||||
ReadRegStr $1 HKLM "SOFTWARE\WOW6432Node\Microsoft\EdgeUpdate\Clients\${WEBVIEW2_GUID}" "pv"
|
||||
${If} $1 == ""
|
||||
${OrIf} $1 == "0.0.0.0"
|
||||
ReadRegStr $1 HKLM "SOFTWARE\Microsoft\EdgeUpdate\Clients\${WEBVIEW2_GUID}" "pv"
|
||||
${EndIf}
|
||||
${If} $1 == ""
|
||||
${OrIf} $1 == "0.0.0.0"
|
||||
ReadRegStr $1 HKCU "Software\Microsoft\EdgeUpdate\Clients\${WEBVIEW2_GUID}" "pv"
|
||||
${EndIf}
|
||||
${If} $1 == "0.0.0.0"
|
||||
StrCpy $1 ""
|
||||
${EndIf}
|
||||
Push $1
|
||||
FunctionEnd
|
||||
|
||||
; ------------------------------------------------------------------------------------------------ installazione
|
||||
Section "Febe" SEC_PROGRAMMA
|
||||
SectionIn RO
|
||||
Call FebeChiuso
|
||||
SetOutPath "$INSTDIR"
|
||||
File "${SORGENTE}/${ESEGUIBILE}"
|
||||
WriteUninstaller "$INSTDIR\${DISINSTALLA}"
|
||||
|
||||
; Menu Start (dell'utente).
|
||||
SetShellVarContext current
|
||||
CreateShortCut "$SMPROGRAMS\Febe.lnk" "$INSTDIR\${ESEGUIBILE}" "" "$INSTDIR\${ESEGUIBILE}" 0 SW_SHOWNORMAL "" "Archivio personale di foto, video e storie da Instagram"
|
||||
|
||||
; App installate (Programmi e funzionalità), per l'utente.
|
||||
WriteRegStr HKCU "${CHIAVE_DISINSTALLA}" "DisplayName" "${NOME}"
|
||||
WriteRegStr HKCU "${CHIAVE_DISINSTALLA}" "DisplayVersion" "${VERSION}"
|
||||
WriteRegStr HKCU "${CHIAVE_DISINSTALLA}" "Publisher" "${EDITORE}"
|
||||
WriteRegStr HKCU "${CHIAVE_DISINSTALLA}" "DisplayIcon" "$INSTDIR\${ESEGUIBILE},0"
|
||||
WriteRegStr HKCU "${CHIAVE_DISINSTALLA}" "InstallLocation" "$INSTDIR"
|
||||
WriteRegStr HKCU "${CHIAVE_DISINSTALLA}" "UninstallString" '"$INSTDIR\${DISINSTALLA}"'
|
||||
WriteRegStr HKCU "${CHIAVE_DISINSTALLA}" "QuietUninstallString" '"$INSTDIR\${DISINSTALLA}" /S'
|
||||
WriteRegStr HKCU "${CHIAVE_DISINSTALLA}" "URLInfoAbout" "${SITO}"
|
||||
WriteRegDWORD HKCU "${CHIAVE_DISINSTALLA}" "NoModify" 1
|
||||
WriteRegDWORD HKCU "${CHIAVE_DISINSTALLA}" "NoRepair" 1
|
||||
${GetSize} "$INSTDIR" "/S=0K" $0 $1 $2
|
||||
WriteRegDWORD HKCU "${CHIAVE_DISINSTALLA}" "EstimatedSize" "$0"
|
||||
|
||||
; WebView2: senza, Febe non può mostrare nulla. Lo dice anche Febe al primo avvio.
|
||||
Call WebView2Presente
|
||||
Pop $1
|
||||
${If} $1 == ""
|
||||
DetailPrint "Runtime WebView2 di Microsoft: non trovato."
|
||||
MessageBox MB_YESNO|MB_ICONINFORMATION "Febe ha bisogno del runtime WebView2 di Microsoft, che su questo computer non c'è (Windows 11 e quasi tutti i Windows 10 lo hanno già).$\r$\n$\r$\nSi installa gratis dalla pagina ufficiale di Microsoft, senza permessi di amministratore. Vuoi aprirla adesso?" /SD IDNO IDNO fine_webview2
|
||||
ExecShell "open" "${WEBVIEW2_PAGINA}"
|
||||
fine_webview2:
|
||||
${Else}
|
||||
DetailPrint "Runtime WebView2 di Microsoft: $1."
|
||||
${EndIf}
|
||||
SectionEnd
|
||||
|
||||
Section "Collegamento sul desktop" SEC_DESKTOP
|
||||
SetShellVarContext current
|
||||
CreateShortCut "$DESKTOP\Febe.lnk" "$INSTDIR\${ESEGUIBILE}" "" "$INSTDIR\${ESEGUIBILE}" 0 SW_SHOWNORMAL "" "Archivio personale di foto, video e storie da Instagram"
|
||||
SectionEnd
|
||||
|
||||
!insertmacro MUI_FUNCTION_DESCRIPTION_BEGIN
|
||||
!insertmacro MUI_DESCRIPTION_TEXT ${SEC_PROGRAMMA} $(DESC_Programma)
|
||||
!insertmacro MUI_DESCRIPTION_TEXT ${SEC_DESKTOP} $(DESC_Desktop)
|
||||
!insertmacro MUI_FUNCTION_DESCRIPTION_END
|
||||
|
||||
; ------------------------------------------------------------------------------------------------ disinstallazione
|
||||
Function un.onInit
|
||||
; Dove sono i dati, per dirlo alla fine: la cartella scelta nelle Impostazioni o quella predefinita.
|
||||
ReadRegStr $R8 HKCU "${CHIAVE_FEBE}" "CartellaDati"
|
||||
${If} $R8 == ""
|
||||
StrCpy $R8 "$LOCALAPPDATA\Febe"
|
||||
${EndIf}
|
||||
StrCpy $R9 "$PICTURES\Febe"
|
||||
FunctionEnd
|
||||
|
||||
; «Avvia con il computer» dei Febe avviati con --dati (un secondo account): valori «Febe-…» che avviano questo Febe.exe.
|
||||
Function un.TogliAvviiConDati
|
||||
StrCpy $3 '"$INSTDIR\${ESEGUIBILE}"'
|
||||
StrLen $4 $3
|
||||
StrCpy $0 0
|
||||
ciclo:
|
||||
ClearErrors
|
||||
EnumRegValue $1 HKCU "${CHIAVE_AVVIO}" $0
|
||||
IfErrors fine
|
||||
StrCmp $1 "" fine
|
||||
StrCpy $2 $1 5
|
||||
${If} $2 == "Febe-"
|
||||
ReadRegStr $5 HKCU "${CHIAVE_AVVIO}" $1
|
||||
StrCpy $6 $5 $4
|
||||
${If} $6 == $3
|
||||
DeleteRegValue HKCU "${CHIAVE_AVVIO}" $1
|
||||
; Il valore successivo prende il posto di quello tolto: stesso indice.
|
||||
Goto ciclo
|
||||
${EndIf}
|
||||
${EndIf}
|
||||
IntOp $0 $0 + 1
|
||||
Goto ciclo
|
||||
fine:
|
||||
FunctionEnd
|
||||
|
||||
Section "Uninstall"
|
||||
Call un.FebeChiuso
|
||||
SetShellVarContext current
|
||||
|
||||
; Solo i file del programma. MAI la cartella dei dati, MAI la libreria: non si chiede nulla su di loro.
|
||||
Delete "$INSTDIR\${ESEGUIBILE}"
|
||||
Delete "$INSTDIR\${DISINSTALLA}"
|
||||
RMDir "$INSTDIR"
|
||||
Delete "$SMPROGRAMS\Febe.lnk"
|
||||
Delete "$DESKTOP\Febe.lnk"
|
||||
|
||||
; «Avvia Febe all'accensione del computer» punterebbe a un programma che non c'è più: il valore «Febe» e quelli
|
||||
; «Febe-…» dei Febe avviati con --dati.
|
||||
DeleteRegValue HKCU "${CHIAVE_AVVIO}" "Febe"
|
||||
Call un.TogliAvviiConDati
|
||||
DeleteRegKey HKCU "${CHIAVE_DISINSTALLA}"
|
||||
|
||||
; Le librerie native che Febe.exe estrae da sé al primo avvio (non sono dati).
|
||||
RMDir /r "$TEMP\.net\Febe"
|
||||
|
||||
DetailPrint "I dati restano: cartella dei dati $R8; libreria $R9 (o quella scelta nelle Impostazioni)."
|
||||
DetailPrint "La cartella dei dati contiene la sessione di Instagram: se non ti serve più, cancellala tu."
|
||||
SectionEnd
|
||||
@@ -0,0 +1,636 @@
|
||||
using System.Globalization;
|
||||
using Febe.Browser.Cdp;
|
||||
using Febe.Browser.Hosting;
|
||||
using Febe.Core.Abstractions;
|
||||
using Febe.Core.Collection;
|
||||
using Febe.Core.Domain;
|
||||
using Febe.Core.Engine;
|
||||
using Febe.Core.Storage;
|
||||
using Febe.Web.Api;
|
||||
using Febe.Web.Connection;
|
||||
using Febe.Web.Engine;
|
||||
|
||||
namespace Febe.App;
|
||||
|
||||
/// <summary>
|
||||
/// The link to Instagram over the real browser, the same in both shells (spec §4.1, §10.3, PROTOCOLLO.md). «Collegato»
|
||||
/// means that the session cookie exists in the browser profile: only its existence is checked
|
||||
/// (<c>Network.getCookies</c>, names only), never its value. Opening the login page is Alberto's action, not the
|
||||
/// engine's (rule 7, last sentence): it happens only while he holds the «driving» lease and the engine is still.
|
||||
/// On Windows the browser is the window «Browser di Febe»: «Accedi» and «Portalo in primo piano» bring it to the front,
|
||||
/// «Ho finito» and «Annulla» put it back out of view, «Scollega» closes it before deleting the profile. In Docker
|
||||
/// showing and hiding do nothing (the remote view shows the browser).
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// The lease taken by «Accedi a Instagram» and «Usa il browser» ends with «Ho finito», «Annulla» or «Scollega», and also
|
||||
/// by itself when for <see cref="DrivingGrace"/> it is the only sign that Alberto uses the browser — no remote view open
|
||||
/// in Docker, the window «Browser di Febe» out of view on Windows: he went away without either button, and the engine
|
||||
/// must not stay still for ever.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// A session cookie that disappears outside a session (or is missing at start-up after a connection) is a disconnection
|
||||
/// (spec §7.6): reported to the breaker as the recipes would, so that it is an incident with its alert and only
|
||||
/// «Riprendi» restarts the engine. Not when Alberto himself is at the browser, nor after his «Scollega».
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposable
|
||||
{
|
||||
/// <summary>Setting written at the first connection ever (Unix ms): the gradual start begins only once.</summary>
|
||||
public const string FirstConnectionKey = "collegamento.primo";
|
||||
|
||||
/// <summary>Setting set by «Scollega» and removed by the next connection: until then a missing session is expected.</summary>
|
||||
public const string DisconnectedByUserKey = "collegamento.scollegato";
|
||||
|
||||
/// <summary>A cookie check younger than this is reused by the status (the sidebar asks often).</summary>
|
||||
public static readonly TimeSpan CookieCacheLifetime = TimeSpan.FromSeconds(3);
|
||||
|
||||
/// <summary>How often the cookie is looked at in the background (outside sessions it is the only way to notice).</summary>
|
||||
public static readonly TimeSpan BackgroundCheck = TimeSpan.FromSeconds(30);
|
||||
|
||||
private readonly IFebeBrowser _browser;
|
||||
private readonly IFebeStorage _storage;
|
||||
private readonly BrowserUseTracker _tracker;
|
||||
private readonly IClock _clock;
|
||||
private readonly FebeLog _log;
|
||||
private readonly string _loginUrl;
|
||||
private readonly SessionCookieOptions _cookie;
|
||||
private readonly SemaphoreSlim _commands = new(1, 1);
|
||||
private readonly Lock _gate = new();
|
||||
private EngineHost? _engine;
|
||||
private IDisposable? _lease;
|
||||
private CancellationTokenSource? _leaseWatch;
|
||||
private DateTimeOffset _lastDrivingSign;
|
||||
private bool? _connected;
|
||||
private bool? _disconnectedByUser;
|
||||
private DateTimeOffset _checkedAt = DateTimeOffset.MinValue;
|
||||
|
||||
public BrowserConnectionService(IFebeBrowser browser, IFebeStorage storage, BrowserUseTracker tracker, IClock clock, FebeLog log, string loginUrl, SessionCookieOptions cookie)
|
||||
{
|
||||
_browser = browser ?? throw new ArgumentNullException(nameof(browser));
|
||||
_storage = storage ?? throw new ArgumentNullException(nameof(storage));
|
||||
_tracker = tracker ?? throw new ArgumentNullException(nameof(tracker));
|
||||
_clock = clock ?? throw new ArgumentNullException(nameof(clock));
|
||||
_log = log ?? throw new ArgumentNullException(nameof(log));
|
||||
_loginUrl = loginUrl ?? throw new ArgumentNullException(nameof(loginUrl));
|
||||
_cookie = cookie ?? throw new ArgumentNullException(nameof(cookie));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Whether the browser holds the session, from the last check (null before the first one). The engine reads it
|
||||
/// on every turn (<see cref="EngineRuntime.IsConnected"/>): it never waits for the browser.
|
||||
/// </summary>
|
||||
public bool? IsConnected
|
||||
{
|
||||
get
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
return _connected;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Hook for the readers (hypothesis H10): when the data of the page tell which account is connected, the composition
|
||||
/// marks it as «Tu» (<see cref="Account.IsMine"/>); the status shows that account. Raised after every change of the
|
||||
/// connection, so that whoever learns the account can look again.
|
||||
/// </summary>
|
||||
public event EventHandler<bool>? ConnectionChanged;
|
||||
|
||||
/// <summary>
|
||||
/// How long the lease of «Accedi a Instagram» / «Usa il browser» outlives every other lease of the browser (remote
|
||||
/// view, window in front) before it ends by itself. Read at every look; tests shorten it.
|
||||
/// </summary>
|
||||
public TimeSpan DrivingGrace { get; set; } = TimeSpan.FromMinutes(2);
|
||||
|
||||
/// <summary>The engine, once it exists (it is built after the browser).</summary>
|
||||
public void AttachEngine(EngineHost engine) => _engine = engine ?? throw new ArgumentNullException(nameof(engine));
|
||||
|
||||
public async Task<ConnectionStatus> GetStatusAsync(CancellationToken ct)
|
||||
{
|
||||
var driving = _browser.UserIsDriving;
|
||||
if (!_browser.IsAvailable)
|
||||
{
|
||||
return new ConnectionStatus(ConnectionState.BrowserUnavailable, null, null, driving, null);
|
||||
}
|
||||
|
||||
var breaker = _engine?.Services.Breaker.State.Status;
|
||||
var state = breaker is BreakerStatus.Challenge or BreakerStatus.Disconnected
|
||||
? ConnectionState.VerificationRequired
|
||||
: await CheckAsync(force: false, mayReport: true, ct).ConfigureAwait(false) == true ? ConnectionState.Connected : ConnectionState.NotConnected;
|
||||
|
||||
Account? mine = null;
|
||||
if (state != ConnectionState.NotConnected)
|
||||
{
|
||||
mine = await _storage.Accounts.GetMineAsync(ct).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
return new ConnectionStatus(state, mine?.Username, mine?.DisplayName, driving, await CurrentUrlAsync(ct).ConfigureAwait(false));
|
||||
}
|
||||
|
||||
public async Task BeginUserDrivingAsync(bool openLogin, CancellationToken ct)
|
||||
{
|
||||
EnsureBrowser();
|
||||
await _commands.WaitAsync(ct).ConfigureAwait(false);
|
||||
try
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
if (_lease is null)
|
||||
{
|
||||
_lease = _browser.UserDriving.Begin();
|
||||
var watch = new CancellationTokenSource();
|
||||
_leaseWatch = watch;
|
||||
var lease = _lease;
|
||||
_ = Task.Run(() => WatchLeaseAsync(lease, watch.Token), CancellationToken.None);
|
||||
}
|
||||
|
||||
_lastDrivingSign = _clock.Now;
|
||||
}
|
||||
|
||||
_tracker.MarkUsed(_clock.Now);
|
||||
if (openLogin)
|
||||
{
|
||||
// The engine ends its session when the lease starts; wait for it before taking the page.
|
||||
await WaitForSessionEndAsync(ct).ConfigureAwait(false);
|
||||
var result = await _browser.Cdp.NavigateAsync(_loginUrl, ct).ConfigureAwait(false);
|
||||
_log.Info("collegamento", result.Succeeded
|
||||
? "Alberto usa il browser: pagina di accesso aperta."
|
||||
: "Alberto usa il browser: la pagina di accesso non si è aperta (errore di rete del browser).");
|
||||
}
|
||||
else
|
||||
{
|
||||
_log.Info("collegamento", "Alberto usa il browser.");
|
||||
}
|
||||
|
||||
// Windows: the window «Browser di Febe» comes to the front (Docker: nothing, the remote view shows it).
|
||||
await ShowQuietlyAsync(ct).ConfigureAwait(false);
|
||||
}
|
||||
finally
|
||||
{
|
||||
_commands.Release();
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<FinishResult> FinishAsync(CancellationToken ct)
|
||||
{
|
||||
await _commands.WaitAsync(ct).ConfigureAwait(false);
|
||||
try
|
||||
{
|
||||
if (!_browser.IsAvailable)
|
||||
{
|
||||
ReleaseLease();
|
||||
return new FinishResult(false, "Il browser di Febe non è in funzione in questo momento, quindi Febe non può controllare il collegamento. Riprova fra qualche minuto; se il problema resta, guarda il registro.");
|
||||
}
|
||||
|
||||
// Alberto has just been at the browser: a session he did not complete is said here, not reported as a stop.
|
||||
var connected = await CheckAsync(force: true, mayReport: false, ct).ConfigureAwait(false) == true;
|
||||
_tracker.MarkUsed(_clock.Now);
|
||||
var first = connected && await MarkConnectedAsync(ct).ConfigureAwait(false);
|
||||
await RestIfAlbertosAsync().ConfigureAwait(false);
|
||||
await HideQuietlyAsync().ConfigureAwait(false);
|
||||
ReleaseLease();
|
||||
|
||||
var stopped = _engine?.Services.Breaker.State.Status is BreakerStatus.Challenge or BreakerStatus.Disconnected;
|
||||
string message;
|
||||
if (!connected)
|
||||
{
|
||||
message = "Febe non trova la sessione di Instagram nel browser: l'accesso non sembra completato. Riprova con «Accedi a Instagram» e premi «Ho finito» solo dopo aver visto la tua pagina iniziale.";
|
||||
}
|
||||
else if (stopped)
|
||||
{
|
||||
message = "Collegato. Febe è ancora fermo per la verifica o la disconnessione: premi «Riprendi» quando vuoi che ricominci.";
|
||||
}
|
||||
else if (first)
|
||||
{
|
||||
message = "Collegato a Instagram. Febe comincia fra qualche minuto, con calma: nei primi giorni i tetti sono ridotti (avvio graduale).";
|
||||
}
|
||||
else
|
||||
{
|
||||
message = "Collegato a Instagram. Febe riprende da solo alla prossima sessione.";
|
||||
}
|
||||
|
||||
_log.Info("collegamento", connected ? "«Ho finito»: sessione presente nel browser." : "«Ho finito»: sessione assente nel browser.");
|
||||
return new FinishResult(connected, message);
|
||||
}
|
||||
finally
|
||||
{
|
||||
_commands.Release();
|
||||
}
|
||||
}
|
||||
|
||||
public async Task CancelAsync(CancellationToken ct)
|
||||
{
|
||||
await _commands.WaitAsync(ct).ConfigureAwait(false);
|
||||
try
|
||||
{
|
||||
if (_browser.IsAvailable)
|
||||
{
|
||||
await RestIfAlbertosAsync().ConfigureAwait(false);
|
||||
await HideQuietlyAsync().ConfigureAwait(false);
|
||||
}
|
||||
|
||||
ReleaseLease();
|
||||
_log.Info("collegamento", "«Annulla»: il browser torna a riposo.");
|
||||
}
|
||||
finally
|
||||
{
|
||||
_commands.Release();
|
||||
}
|
||||
}
|
||||
|
||||
public async Task DisconnectAsync(CancellationToken ct)
|
||||
{
|
||||
await _commands.WaitAsync(ct).ConfigureAwait(false);
|
||||
var hold = _browser.UserDriving.Begin();
|
||||
try
|
||||
{
|
||||
// From now on a missing session is Alberto's choice, not a disconnection to report (until he connects again).
|
||||
await RememberUserDisconnectAsync().ConfigureAwait(false);
|
||||
var engine = _engine;
|
||||
if (engine is not null)
|
||||
{
|
||||
await engine.StopAsync().ConfigureAwait(false);
|
||||
}
|
||||
|
||||
// Windows: the browser window goes out of view and WebView2 closes before its folder is deleted.
|
||||
await HideQuietlyAsync().ConfigureAwait(false);
|
||||
Exception? failure = null;
|
||||
try
|
||||
{
|
||||
await _browser.RestartWithEmptyProfileAsync(ct).ConfigureAwait(false);
|
||||
SetConnected(false);
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
|
||||
{
|
||||
// A file of the profile stayed (Windows: a process of the browser held it). The engine starts again
|
||||
// anyway; whether the session is still there is checked again, never assumed.
|
||||
failure = ex;
|
||||
await RefreshAsync(CancellationToken.None).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
if (engine is not null)
|
||||
{
|
||||
if (failure is null)
|
||||
{
|
||||
await engine.Services.Events.WriteAsync(
|
||||
EventSeverity.Info,
|
||||
"collegamento.scollegato",
|
||||
"Scollegato da te: il profilo del browser con la sessione di Instagram è stato cancellato.",
|
||||
ct: CancellationToken.None).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
await engine.StartAsync(CancellationToken.None).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
if (failure is not null)
|
||||
{
|
||||
_log.Warn("collegamento", "«Scollega»: il profilo del browser non si è potuto cancellare del tutto.", failure);
|
||||
throw new BadRequestException("«Scollega» non è riuscito del tutto: " + failure.Message);
|
||||
}
|
||||
|
||||
_log.Info("collegamento", "«Scollega»: motore fermo, profilo del browser cancellato, browser ripartito vuoto.");
|
||||
}
|
||||
finally
|
||||
{
|
||||
ReleaseLease();
|
||||
hold.Dispose();
|
||||
_commands.Release();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Looks at the cookie now (outside the cache) and records the change. Used at start-up, by the background loop
|
||||
/// and after the test site's automatic login. A session that went away (or is missing at start-up after a
|
||||
/// connection) while Alberto is not at the browser is reported to the breaker as a disconnection (spec §7.6).
|
||||
/// </summary>
|
||||
public async Task<bool?> RefreshAsync(CancellationToken ct)
|
||||
{
|
||||
if (!_browser.IsAvailable)
|
||||
{
|
||||
return IsConnected;
|
||||
}
|
||||
|
||||
var connected = await CheckAsync(force: true, mayReport: true, ct).ConfigureAwait(false);
|
||||
if (connected == true)
|
||||
{
|
||||
await MarkConnectedAsync(ct).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
return connected;
|
||||
}
|
||||
|
||||
/// <summary>The background check of the cookie, every <see cref="BackgroundCheck"/>, until cancelled.</summary>
|
||||
public async Task RunAsync(CancellationToken ct)
|
||||
{
|
||||
while (!ct.IsCancellationRequested)
|
||||
{
|
||||
try
|
||||
{
|
||||
await _clock.Delay(BackgroundCheck, ct).ConfigureAwait(false);
|
||||
if (!_browser.UserIsDriving)
|
||||
{
|
||||
await RefreshAsync(ct).ConfigureAwait(false);
|
||||
}
|
||||
}
|
||||
catch (OperationCanceledException) when (ct.IsCancellationRequested)
|
||||
{
|
||||
return;
|
||||
}
|
||||
catch (Exception ex) when (ex is CdpDisconnectedException or BrowserUnavailableException or CdpCommandException or TimeoutException or IOException)
|
||||
{
|
||||
// The browser is restarting: the next turn looks again.
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public ValueTask DisposeAsync()
|
||||
{
|
||||
ReleaseLease();
|
||||
_commands.Dispose();
|
||||
return ValueTask.CompletedTask;
|
||||
}
|
||||
|
||||
private async Task<bool?> CheckAsync(bool force, bool mayReport, CancellationToken ct)
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
if (!force && _connected is not null && _clock.Now - _checkedAt < CookieCacheLifetime)
|
||||
{
|
||||
return _connected;
|
||||
}
|
||||
}
|
||||
|
||||
bool has;
|
||||
try
|
||||
{
|
||||
has = await SessionCookieProbe.HasSessionCookieAsync(_browser.Cdp, _cookie, ct).ConfigureAwait(false);
|
||||
}
|
||||
catch (Exception ex) when (ex is CdpDisconnectedException or BrowserUnavailableException or CdpCommandException or TimeoutException)
|
||||
{
|
||||
return IsConnected;
|
||||
}
|
||||
|
||||
var previous = SetConnected(has);
|
||||
if (has)
|
||||
{
|
||||
await ForgetUserDisconnectAsync(ct).ConfigureAwait(false);
|
||||
}
|
||||
else if (mayReport && previous != false && !_browser.UserIsDriving)
|
||||
{
|
||||
await ReportLostSessionAsync(previous, ct).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
return has;
|
||||
}
|
||||
|
||||
/// <summary>Records the state of the cookie; returns the one before (null before the first check).</summary>
|
||||
private bool? SetConnected(bool connected)
|
||||
{
|
||||
bool? previous;
|
||||
lock (_gate)
|
||||
{
|
||||
previous = _connected;
|
||||
_connected = connected;
|
||||
_checkedAt = _clock.Now;
|
||||
}
|
||||
|
||||
if (previous != connected)
|
||||
{
|
||||
_log.Info("collegamento", connected ? "Sessione presente nel browser: collegato." : "Nessuna sessione nel browser: non collegato.");
|
||||
|
||||
// Wakes the engine: it looks again whether it can work (it only cancels a session if Alberto is driving).
|
||||
_engine?.NotifyUserDrivingChanged();
|
||||
ConnectionChanged?.Invoke(this, connected);
|
||||
}
|
||||
|
||||
return previous;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The session cookie is gone while Alberto is not at the browser (spec §7.6 «il cookie di sessione non c'è più»):
|
||||
/// the same disconnection the recipes report, so the breaker writes the incident, the alert goes out and only
|
||||
/// «Riprendi» (with the gradual start) restarts the engine. Not after «Scollega», and at start-up only when the
|
||||
/// profile had been connected.
|
||||
/// </summary>
|
||||
private async Task ReportLostSessionAsync(bool? previous, CancellationToken ct)
|
||||
{
|
||||
if (_engine is not { } engine || await IsDisconnectedByUserAsync(ct).ConfigureAwait(false))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (previous is null && await _storage.Settings.GetInt64Async(FirstConnectionKey, ct).ConfigureAwait(false) is null)
|
||||
{
|
||||
return; // never connected: nothing was lost
|
||||
}
|
||||
|
||||
engine.Services.Breaker.Report(new Signal(SignalLevel.Disconnect, SignalRules.SessionCookieMissingCode, null, _clock.Now));
|
||||
_log.Warn("collegamento", "La sessione di Instagram non c'è più nel browser: Febe si ferma finché non accedi di nuovo e premi «Riprendi».");
|
||||
}
|
||||
|
||||
private async Task<bool> IsDisconnectedByUserAsync(CancellationToken ct)
|
||||
{
|
||||
if (_disconnectedByUser is { } known)
|
||||
{
|
||||
return known;
|
||||
}
|
||||
|
||||
var stored = await _storage.Settings.GetBoolAsync(DisconnectedByUserKey, false, ct).ConfigureAwait(false);
|
||||
_disconnectedByUser = stored;
|
||||
return stored;
|
||||
}
|
||||
|
||||
private async Task RememberUserDisconnectAsync()
|
||||
{
|
||||
_disconnectedByUser = true;
|
||||
await _storage.Settings.SetBoolAsync(DisconnectedByUserKey, true, CancellationToken.None).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
/// <summary>A session is in the browser again: from now on its loss is a disconnection.</summary>
|
||||
private async Task ForgetUserDisconnectAsync(CancellationToken ct)
|
||||
{
|
||||
if (await IsDisconnectedByUserAsync(ct).ConfigureAwait(false))
|
||||
{
|
||||
_disconnectedByUser = false;
|
||||
await _storage.Settings.SetAsync(DisconnectedByUserKey, null, ct).ConfigureAwait(false);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The «driving» lease of this service ends by itself once it has been the only lease of the browser for
|
||||
/// <see cref="DrivingGrace"/>: the remote view closed (Docker) or the window went out of view (Windows), and
|
||||
/// neither «Ho finito» nor «Annulla» came. The page is not touched here (the engine puts it to rest).
|
||||
/// </summary>
|
||||
private async Task WatchLeaseAsync(IDisposable lease, CancellationToken ct)
|
||||
{
|
||||
try
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
var grace = DrivingGrace;
|
||||
var poll = TimeSpan.FromTicks(Math.Clamp(grace.Ticks / 8, TimeSpan.FromMilliseconds(20).Ticks, TimeSpan.FromSeconds(5).Ticks));
|
||||
await _clock.Delay(poll, ct).ConfigureAwait(false);
|
||||
DateTimeOffset lastSign;
|
||||
lock (_gate)
|
||||
{
|
||||
if (!ReferenceEquals(_lease, lease))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Besides this lease: the remote view, the browser window in front, «Scollega» in progress.
|
||||
if (_browser.UserDriving.Leases > 1)
|
||||
{
|
||||
_lastDrivingSign = _clock.Now;
|
||||
}
|
||||
|
||||
lastSign = _lastDrivingSign;
|
||||
}
|
||||
|
||||
if (_clock.Now - lastSign >= grace && ReleaseLease(lease))
|
||||
{
|
||||
_log.Info("collegamento", $"Nessuna vista del browser aperta da {ItalianText.Duration(grace)} senza «Ho finito» né «Annulla»: il motore può riprendere.");
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (OperationCanceledException) when (ct.IsCancellationRequested)
|
||||
{
|
||||
// The lease ended with a command of Alberto.
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>The first connection ever starts the gradual start (spec §7.2). True when it was the first.</summary>
|
||||
private async Task<bool> MarkConnectedAsync(CancellationToken ct)
|
||||
{
|
||||
if (await _storage.Settings.GetInt64Async(FirstConnectionKey, ct).ConfigureAwait(false) is not null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
var now = _clock.Now;
|
||||
await _storage.Settings.SetAsync(FirstConnectionKey, now.ToUnixTimeMilliseconds().ToString(CultureInfo.InvariantCulture), ct).ConfigureAwait(false);
|
||||
if (_engine is { } engine)
|
||||
{
|
||||
await engine.Services.NotifyFirstConnectionAsync(ct).ConfigureAwait(false);
|
||||
await engine.Services.Events.WriteAsync(
|
||||
EventSeverity.Info,
|
||||
"collegamento.primo",
|
||||
"Primo collegamento a Instagram: comincia l'avvio graduale.",
|
||||
ct: ct).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
_log.Info("collegamento", "Primo collegamento: comincia l'avvio graduale.");
|
||||
return true;
|
||||
}
|
||||
|
||||
private async Task WaitForSessionEndAsync(CancellationToken ct)
|
||||
{
|
||||
if (_engine is not { } engine)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var deadline = _clock.Now + TimeSpan.FromSeconds(15);
|
||||
while (engine.Services.Runtime.CurrentSession is not null && _clock.Now < deadline)
|
||||
{
|
||||
await _clock.Delay(TimeSpan.FromMilliseconds(100), ct).ConfigureAwait(false);
|
||||
}
|
||||
}
|
||||
|
||||
private async Task<string?> CurrentUrlAsync(CancellationToken ct)
|
||||
{
|
||||
try
|
||||
{
|
||||
var url = await _browser.Cdp.GetMainFrameUrlAsync(ct).ConfigureAwait(false);
|
||||
return Addresses.WithoutQuery(url);
|
||||
}
|
||||
catch (Exception ex) when (ex is CdpDisconnectedException or BrowserUnavailableException or CdpCommandException or TimeoutException or KeyNotFoundException or InvalidOperationException)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Puts the page to rest while it is Alberto's (a lease holds the engine still). Once every lease ended — this
|
||||
/// service's ended by itself after <see cref="DrivingGrace"/> — the page is the engine's again: a late «Ho finito» or
|
||||
/// «Annulla» must not navigate under a session (the engine rested the page when the driving ended).
|
||||
/// </summary>
|
||||
private Task RestIfAlbertosAsync() => _browser.UserIsDriving ? RestQuietlyAsync() : Task.CompletedTask;
|
||||
|
||||
private async Task RestQuietlyAsync()
|
||||
{
|
||||
try
|
||||
{
|
||||
await _browser.RestAsync(CancellationToken.None).ConfigureAwait(false);
|
||||
}
|
||||
catch (Exception ex) when (ex is CdpDisconnectedException or BrowserUnavailableException or CdpCommandException or TimeoutException)
|
||||
{
|
||||
// The browser is restarting: it starts on the rest page anyway.
|
||||
}
|
||||
}
|
||||
|
||||
private async Task ShowQuietlyAsync(CancellationToken ct)
|
||||
{
|
||||
try
|
||||
{
|
||||
await _browser.ShowToUserAsync(ct).ConfigureAwait(false);
|
||||
}
|
||||
catch (Exception ex) when (ex is InvalidOperationException or TimeoutException or IOException)
|
||||
{
|
||||
_log.Warn("collegamento", "La finestra del browser non è venuta in primo piano.", ex);
|
||||
}
|
||||
}
|
||||
|
||||
private async Task HideQuietlyAsync()
|
||||
{
|
||||
try
|
||||
{
|
||||
await _browser.HideFromUserAsync(CancellationToken.None).ConfigureAwait(false);
|
||||
}
|
||||
catch (Exception ex) when (ex is InvalidOperationException or TimeoutException or IOException)
|
||||
{
|
||||
_log.Warn("collegamento", "La finestra del browser non si è nascosta.", ex);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Ends the lease (only <paramref name="expected"/>, when given). True when a lease ended.</summary>
|
||||
private bool ReleaseLease(IDisposable? expected = null)
|
||||
{
|
||||
IDisposable? lease;
|
||||
CancellationTokenSource? watch;
|
||||
lock (_gate)
|
||||
{
|
||||
if (expected is not null && !ReferenceEquals(_lease, expected))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
lease = _lease;
|
||||
watch = _leaseWatch;
|
||||
_lease = null;
|
||||
_leaseWatch = null;
|
||||
}
|
||||
|
||||
if (watch is not null)
|
||||
{
|
||||
watch.Cancel();
|
||||
watch.Dispose();
|
||||
}
|
||||
|
||||
lease?.Dispose();
|
||||
return lease is not null;
|
||||
}
|
||||
|
||||
private void EnsureBrowser()
|
||||
{
|
||||
if (!_browser.IsAvailable)
|
||||
{
|
||||
throw new BadRequestException(_browser.LastError is { } error
|
||||
? "Il browser di Febe non è in funzione: " + error
|
||||
: "Il browser di Febe si sta avviando: riprova fra qualche secondo.");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,298 @@
|
||||
using System.Globalization;
|
||||
using Febe.Browser.Cdp;
|
||||
using Febe.Browser.Hosting;
|
||||
using Febe.Core.Abstractions;
|
||||
|
||||
namespace Febe.App;
|
||||
|
||||
/// <summary>How a Chromium-family browser is started and looked after (spec §6.1, §11; S2 fallback on Windows).</summary>
|
||||
public sealed record ChromiumBrowserSettings
|
||||
{
|
||||
/// <summary>The profile folder given to the browser (<c>--user-data-dir</c>): it holds the Instagram session.</summary>
|
||||
public required string ProfileDirectory { get; init; }
|
||||
|
||||
/// <summary>
|
||||
/// The folder «Scollega» deletes while the browser is stopped. Null: <see cref="ProfileDirectory"/>. On Windows the
|
||||
/// Edge profile is a subfolder of <c>Dati\browser</c>, and «Scollega» deletes the whole <c>Dati\browser</c>.
|
||||
/// </summary>
|
||||
public string? ProfileFolderToDelete { get; init; }
|
||||
|
||||
/// <summary>Folder created before the start (Docker: the HOME of the browser process). Null: none.</summary>
|
||||
public string? HomeDirectory { get; init; }
|
||||
|
||||
/// <summary>Size of the browser window, always the same (spec §6.1).</summary>
|
||||
public int WindowWidth { get; init; } = 1280;
|
||||
|
||||
public int WindowHeight { get; init; } = 900;
|
||||
|
||||
/// <summary>The fixed DevTools port, on 127.0.0.1 only (spec §6.1).</summary>
|
||||
public int DebugPort { get; init; } = 9222;
|
||||
|
||||
/// <summary>The executable; null: <see cref="ChromiumCommandLine.FindExecutable"/>.</summary>
|
||||
public string? ExecutablePath { get; init; }
|
||||
|
||||
/// <summary>The Xvfb display (Docker, «:99»). Null: no virtual display, the browser opens a normal window.</summary>
|
||||
public string? Display { get; init; }
|
||||
|
||||
/// <summary>Arguments, environment, cookie of the session, restart policy.</summary>
|
||||
public ChromiumLaunchOptions Launch { get; init; } = new();
|
||||
|
||||
/// <summary>Added to the «browser ready» log line (Docker: «, senza sandbox (FEBE_SENZA_SANDBOX)»).</summary>
|
||||
public string? ReadyRemark { get; init; }
|
||||
|
||||
/// <summary>Added to a start error that mentions the sandbox (Docker: where the seccomp profile is explained).</summary>
|
||||
public string? SandboxAdvice { get; init; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// A Chromium-family browser started and supervised by Febe itself, never by a shell script (spec §5, §6.1, §11): the
|
||||
/// distribution's Chromium on Xvfb in Docker, or Edge on Windows as the last fallback of S2. A start that fails
|
||||
/// (browser missing, sandbox refused, port taken) is retried with a growing wait; once running, the supervisors of
|
||||
/// <see cref="XvfbProcess"/> and <see cref="ChromiumProcessHost"/> restart what crashes.
|
||||
/// </summary>
|
||||
public sealed class ChromiumBrowser : IFebeBrowser
|
||||
{
|
||||
private static readonly TimeSpan[] Retry = [TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(30), TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(5)];
|
||||
|
||||
private readonly ChromiumBrowserSettings _settings;
|
||||
private readonly IClock _clock;
|
||||
private readonly FebeLog _log;
|
||||
private readonly TaskCompletionSource _ready = new(TaskCreationOptions.RunContinuationsAsynchronously);
|
||||
private XvfbProcess? _xvfb;
|
||||
private volatile bool _started;
|
||||
private volatile string? _lastError;
|
||||
|
||||
public ChromiumBrowser(ChromiumBrowserSettings settings, IClock clock, FebeLog log)
|
||||
{
|
||||
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
|
||||
ArgumentNullException.ThrowIfNull(clock);
|
||||
_log = log ?? throw new ArgumentNullException(nameof(log));
|
||||
|
||||
// Processes start, time out and restart in wall-clock time, whatever clock the engine runs on.
|
||||
_clock = new SystemClock(clock.LocalZone);
|
||||
ProfileDirectory = Path.GetFullPath(settings.ProfileDirectory);
|
||||
HomeDirectory = settings.HomeDirectory is { } home ? Path.GetFullPath(home) : null;
|
||||
Host = new ChromiumProcessHost(settings.Launch, _clock, log.ForBrowser());
|
||||
BrowserOptions = new BrowserOptions(
|
||||
ProfileDirectory,
|
||||
settings.WindowWidth,
|
||||
settings.WindowHeight,
|
||||
settings.DebugPort,
|
||||
settings.ExecutablePath,
|
||||
settings.Display);
|
||||
}
|
||||
|
||||
/// <summary>The browser: stable for the whole life of the composition (a «Scollega» restarts it in place).</summary>
|
||||
public ChromiumProcessHost Host { get; }
|
||||
|
||||
public BrowserOptions BrowserOptions { get; }
|
||||
|
||||
public ICdpSession Cdp => Host.Cdp;
|
||||
|
||||
public UserDrivingGate UserDriving => Host.UserDriving;
|
||||
|
||||
public string ProfileDirectory { get; }
|
||||
|
||||
/// <summary>HOME of the browser process (certificate database, font cache); null when not set.</summary>
|
||||
public string? HomeDirectory { get; }
|
||||
|
||||
public int WindowWidth => BrowserOptions.WindowWidth;
|
||||
|
||||
public int WindowHeight => BrowserOptions.WindowHeight;
|
||||
|
||||
/// <summary>True when the browser runs on a virtual display (Docker).</summary>
|
||||
public bool UsesXvfb => _settings.Display is not null;
|
||||
|
||||
/// <summary>True when the browser runs and a page connection is attached.</summary>
|
||||
public bool IsAvailable => _started && Host.IsAttached;
|
||||
|
||||
/// <summary>Completes when the browser started the first time.</summary>
|
||||
public Task Ready => _ready.Task;
|
||||
|
||||
public string? LastError => _lastError;
|
||||
|
||||
public bool UserIsDriving => Host.UserIsDriving;
|
||||
|
||||
public async Task RunAsync(CancellationToken ct)
|
||||
{
|
||||
for (var attempt = 0; !ct.IsCancellationRequested; attempt++)
|
||||
{
|
||||
try
|
||||
{
|
||||
await StartOnceAsync(ct).ConfigureAwait(false);
|
||||
_started = true;
|
||||
_lastError = null;
|
||||
_ready.TrySetResult();
|
||||
_log.Info("browser", $"Browser pronto: finestra {WindowWidth.ToString(CultureInfo.InvariantCulture)}×{WindowHeight.ToString(CultureInfo.InvariantCulture)}, porta di debug {_settings.DebugPort.ToString(CultureInfo.InvariantCulture)} solo su 127.0.0.1{_settings.ReadyRemark}.");
|
||||
return;
|
||||
}
|
||||
catch (OperationCanceledException) when (ct.IsCancellationRequested)
|
||||
{
|
||||
return;
|
||||
}
|
||||
catch (Exception ex) when (ex is not OutOfMemoryException)
|
||||
{
|
||||
_lastError = Explain(ex);
|
||||
var wait = Retry[Math.Min(attempt, Retry.Length - 1)];
|
||||
_log.Error("browser", $"Il browser non parte: {_lastError} Nuovo tentativo fra {wait.TotalSeconds.ToString("0", CultureInfo.InvariantCulture)} s.");
|
||||
|
||||
// A failed start leaves nothing running in the host (it can be started again); Xvfb, if it started, stays.
|
||||
try
|
||||
{
|
||||
await _clock.Delay(wait, ct).ConfigureAwait(false);
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public Task<NavigationResult> RestAsync(CancellationToken ct) => Host.RestAsync(ct);
|
||||
|
||||
/// <summary>Nothing: in Docker the remote view shows the browser (on Windows, <c>EdgeBrowser</c> moves the window).</summary>
|
||||
public Task ShowToUserAsync(CancellationToken ct) => Task.CompletedTask;
|
||||
|
||||
/// <summary>Nothing: on Xvfb the window is never in anyone's view.</summary>
|
||||
public Task HideFromUserAsync(CancellationToken ct) => Task.CompletedTask;
|
||||
|
||||
/// <summary>
|
||||
/// «Scollega» (spec §4.1): stops the browser (SIGINT on Linux, so it closes cleanly), deletes the profile folder with
|
||||
/// the Instagram session, and starts the browser again with an empty profile.
|
||||
/// </summary>
|
||||
public async Task RestartWithEmptyProfileAsync(CancellationToken ct)
|
||||
{
|
||||
if (!_started)
|
||||
{
|
||||
DeleteProfile();
|
||||
return;
|
||||
}
|
||||
|
||||
await Host.RestartAsync(DeleteProfile, ct).ConfigureAwait(false);
|
||||
_log.Info("browser", "Profilo del browser cancellato; il browser è ripartito vuoto.");
|
||||
}
|
||||
|
||||
public async ValueTask DisposeAsync()
|
||||
{
|
||||
await StopProcessesAsync().ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private async Task StartOnceAsync(CancellationToken ct)
|
||||
{
|
||||
if (HomeDirectory is { } home)
|
||||
{
|
||||
Directory.CreateDirectory(home);
|
||||
}
|
||||
|
||||
if (_settings.Display is { } display && _xvfb is null)
|
||||
{
|
||||
RemoveStaleDisplayLock(display);
|
||||
var xvfb = new XvfbProcess(display, WindowWidth, WindowHeight, clock: _clock, log: _log.ForBrowser());
|
||||
await xvfb.StartAsync(ct).ConfigureAwait(false);
|
||||
_xvfb = xvfb;
|
||||
}
|
||||
|
||||
RemoveStaleProfileLocks(ProfileDirectory);
|
||||
await Host.StartAsync(BrowserOptions, ct).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private async Task StopProcessesAsync()
|
||||
{
|
||||
try
|
||||
{
|
||||
await Host.StopAsync().ConfigureAwait(false);
|
||||
}
|
||||
catch (Exception ex) when (ex is InvalidOperationException or IOException)
|
||||
{
|
||||
}
|
||||
|
||||
if (_xvfb is { } xvfb)
|
||||
{
|
||||
_xvfb = null;
|
||||
await xvfb.DisposeAsync().ConfigureAwait(false);
|
||||
}
|
||||
}
|
||||
|
||||
private void DeleteProfile()
|
||||
{
|
||||
var folder = _settings.ProfileFolderToDelete is { } root ? Path.GetFullPath(root) : ProfileDirectory;
|
||||
if (Directory.Exists(folder))
|
||||
{
|
||||
Directory.Delete(folder, recursive: true);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Chromium's «profile in use on another computer» lock: after the container is recreated the host name changes and
|
||||
/// Chromium would refuse the profile with a dialog nobody sees. Only Febe starts this browser, and it is not running
|
||||
/// now, so the lock files are stale by definition.
|
||||
/// </summary>
|
||||
internal static void RemoveStaleProfileLocks(string profileDirectory)
|
||||
{
|
||||
foreach (var name in new[] { "SingletonLock", "SingletonSocket", "SingletonCookie" })
|
||||
{
|
||||
var path = Path.Combine(profileDirectory, name);
|
||||
try
|
||||
{
|
||||
if (File.Exists(path) || new FileInfo(path).LinkTarget is not null)
|
||||
{
|
||||
File.Delete(path);
|
||||
}
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// A display lock left by an Xvfb of an earlier run of the same container (restart after a crash): its process
|
||||
/// number may now belong to another process, so a lock whose owner is not an Xvfb is removed.
|
||||
/// </summary>
|
||||
internal static void RemoveStaleDisplayLock(string display)
|
||||
{
|
||||
if (!OperatingSystem.IsLinux() || !int.TryParse(display.AsSpan(1), NumberStyles.None, CultureInfo.InvariantCulture, out var number))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var id = number.ToString(CultureInfo.InvariantCulture);
|
||||
var lockFile = $"/tmp/.X{id}-lock";
|
||||
try
|
||||
{
|
||||
if (!File.Exists(lockFile))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var owner = int.TryParse(File.ReadAllText(lockFile).Trim(), NumberStyles.None, CultureInfo.InvariantCulture, out var pid) ? pid : 0;
|
||||
var comm = owner > 0 && File.Exists($"/proc/{owner.ToString(CultureInfo.InvariantCulture)}/comm")
|
||||
? File.ReadAllText($"/proc/{owner.ToString(CultureInfo.InvariantCulture)}/comm").Trim()
|
||||
: string.Empty;
|
||||
if (comm.Equals("Xvfb", StringComparison.Ordinal))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
File.Delete(lockFile);
|
||||
var socket = $"/tmp/.X11-unix/X{id}";
|
||||
if (File.Exists(socket))
|
||||
{
|
||||
File.Delete(socket);
|
||||
}
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
private string Explain(Exception ex) => ex switch
|
||||
{
|
||||
FileNotFoundException => ex.Message,
|
||||
PlatformNotSupportedException => ex.Message,
|
||||
TimeoutException => ex.Message,
|
||||
InvalidOperationException when ex.Message.Contains("sandbox", StringComparison.OrdinalIgnoreCase) => ex.Message + _settings.SandboxAdvice,
|
||||
_ => $"{ex.GetType().Name}: {ex.Message}",
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
using Febe.Core.Engine;
|
||||
|
||||
namespace Febe.App;
|
||||
|
||||
/// <summary>
|
||||
/// The recipe runner of the engine before the browser exists: the engine and its monitor are built at start-up (the
|
||||
/// interface shows them at once), the collection pipeline only when Chromium is up. The engine loop is started after
|
||||
/// <see cref="Target"/> is set, so a recipe never runs without it.
|
||||
/// </summary>
|
||||
public sealed class DeferredRecipeRunner : IRecipeRunner
|
||||
{
|
||||
private volatile IRecipeRunner? _target;
|
||||
|
||||
/// <summary>The real runner (the collection pipeline's), once the browser is up.</summary>
|
||||
public IRecipeRunner? Target
|
||||
{
|
||||
get => _target;
|
||||
set => _target = value;
|
||||
}
|
||||
|
||||
public Task<RecipeOutcome> RunAsync(RecipeRequest request, ISessionContext session, CancellationToken ct) =>
|
||||
_target is { } target
|
||||
? target.RunAsync(request, session, ct)
|
||||
: Task.FromResult(new RecipeOutcome(RecipeStatus.Cancelled, 0, 0, "Il browser non è ancora pronto."));
|
||||
|
||||
public Task RestAsync(CancellationToken ct) => _target?.RestAsync(ct) ?? Task.CompletedTask;
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
<!-- La composizione condivisa delle due vesti (specifica §5, «I due involucri»): database, libreria, importazione,
|
||||
copie, browser, raccolta, scaricamenti, motore, collegamento, avvisi e interfaccia web. Le parti che cambiano fra
|
||||
Docker e Windows (browser, guscio nativo, cartelle, accesso) arrivano da IFebePlatform. -->
|
||||
<ItemGroup>
|
||||
<FrameworkReference Include="Microsoft.AspNetCore.App" />
|
||||
<ProjectReference Include="..\Febe.Core\Febe.Core.csproj" />
|
||||
<ProjectReference Include="..\Febe.Data\Febe.Data.csproj" />
|
||||
<ProjectReference Include="..\Febe.Browser\Febe.Browser.csproj" />
|
||||
<ProjectReference Include="..\Febe.Web\Febe.Web.csproj" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<InternalsVisibleTo Include="Febe.Tests" />
|
||||
</ItemGroup>
|
||||
</Project>
|
||||