strom-research 1.12.0 → 1.12.1

package/assets/lang/cs.json

@@ -66,6 +66,7 @@
   "ui.doc.links.isolated": "izolovaná instalace: odkazy nezapisuje",
   "ui.doc.app.isolated": "izolovaná instalace: úmyslně se nepoužívá",
   "ui.doc.shortcut.isolated": "izolovaná instalace: úmyslně žádný",
+  "ui.doc.shortcut.no": "nechtěný (strom setup se zeptá znovu)",
   "ui.dialog.waiting": "Otázka čeká v okně systému na obrazovce (může být za ostatními okny) – odpověď patří tam, čeká se nejvýš {minutes} min: {question}",
   "ui.consent.level.auto": "Nechat agenta pracovat samostatně? Ptát se bude jen u riskantních kroků.",
   "ui.consent.level.full": "Povolit agentovi dělat bez ptaní všechno kromě toho, co strom zakazuje?\n\nJen pro počítač, na kterém není nic jiného důležitého.",
@@ -415,6 +416,9 @@
   "ui.o.disk": "disk",
   "ui.o.disk.tidy": "vedle výzkumu si strom drží {strom}, z toho jde uvolnit {size} – řekni to jednou uživateli: strom tidy to s jeho souhlasem uvolní (výzkum zůstane)",
   "ui.app.drag": "Aplikace Strom se otevřela. Do jejího okna přetáhnout soubor {file}{shown} – poprvé z něj bude nový rodokmen, příště se tentýž rodokmen aktualizuje. S Chrome nebo Edge na tomto počítači ho strom předá sám.",
+  "ui.app.browser.gone": "Aplikace Strom se otevírala v {gone}, ten už na tomto počítači není; nově se otevírá v {now} (jiný: strom config set app.browser chrome|edge|brave|opera|firefox|chromium).",
+  "ui.app.browser.gone.none": "Aplikace Strom se otevírala v {gone}, ten už na tomto počítači není, a jiný prohlížeč, ze kterého se k výzkumu připojí (Chrome, Edge, Brave, Firefox), tu není. Po instalaci některého z nich ho strom app otevře v něm.",
+  "ui.app.moved": "Strom výzkumu se otevírá v {browser}: přenos stromu je tím dokončený, aplikace Strom pokračuje tam a s výzkumem je spojená. Fotky stromu ve výzkumu nejsou – zůstaly v {from} a v souboru {file}.",
   "ui.app.drag.shown": " (je ukázaný v okně se soubory)",
   "ui.app.nolive": "Průběžné sledování výzkumu potřebuje Chrome nebo Edge – Safari webové stránce nedovolí přístup k tomuto počítači.",
   "ui.app.images": "S obrázky: {n} zápisů vyříznutých ze skenů ({mb} MB).",
@@ -1042,14 +1046,54 @@
   "ui.link.new.wait": "Čekám, až aplikace Strom strom předá – potvrdit to v ní (nejvýš {min} min; Ctrl+C přeruší).",
   "ui.link.new.elsewhere": "Tahle kopie aplikace Strom ten strom nezná. Otevřít adresu výše v té, ve které to začalo (třeba v betě) – výzkum na ni počká.",
   "ui.link.new.none": "Aplikace Strom žádný strom nepředala. Výzkum „{name}“ tu je, zatím prázdný: začít znovu z aplikace, nebo do něj přidat v nabídce stromu.",
+  "ui.link.new.none.trashed": "Aplikace Strom žádný strom nepředala, výzkum „{name}“ se tedy nezaložil (jeho prázdná složka je v koši). Začít znovu jde z aplikace.",
   "ui.link.new.waited": "Z aplikace Strom do {min} min žádný strom nepřišel. Výzkum „{name}“ tu je, zatím prázdný.",
+  "ui.link.new.blocked": "Aplikace Strom se k výzkumu zatím nepřipojila. Možná příčina: prohlížeč jí zablokoval přístup k aplikacím na tomto zařízení (místní síť) – Chrome, Edge a Brave se na to ptají, Firefox podle svého nastavení. Povolit to jde ikonou vlevo od adresy → přístup k místní síti / k tomuto zařízení → Povolit, potom stránku načíst znovu.",
+  "ui.link.new.blocked.chromium": "Aplikace Strom se k výzkumu zatím nepřipojila. Možná příčina: {browser} jí zablokoval přístup k aplikacím na tomto zařízení. Povolit to jde ikonou vlevo od adresy → Aplikace na zařízení (anglicky Apps on device; ve starších verzích Přístup k místní síti) → Povolit, potom stránku načíst znovu.",
+  "ui.link.new.blocked.brave": "Aplikace Strom se k výzkumu zatím nepřipojila. Možná příčina: Brave jí zablokoval přístup k localhostu. Povolit to jde ikonou vlevo od adresy → Přístup k localhostu (anglicky Localhost access) → Povolit, potom stránku načíst znovu.",
+  "ui.link.new.blocked.firefox": "Aplikace Strom se k výzkumu zatím nepřipojila. Možná příčina: Firefox jí zablokoval přístup k aplikacím a službám na tomto zařízení. Povolit to jde ikonou vlevo od adresy → přístup k aplikacím a službám na tomto zařízení → Povolit, potom stránku načíst znovu.",
+  "ui.link.new.into.ask": "Výzkum „{name}“ (založený {when}) strom z aplikace Strom zatím nedostal. Přidat strom do něj?",
+  "ui.link.new.into": "Do výzkumu „{name}“",
+  "ui.link.new.into.new": "Založit nový výzkum",
   "ui.link.new.empty": "Strom, který aplikace Strom poslala, nemá žádné osoby – není co zkoumat. Výzkum „{name}“ tu je, zatím prázdný.",
   "ui.link.new.failed": "Aplikace Strom strom předat nemohla. Výzkum „{name}“ tu je, zatím prázdný: zkusit to z aplikace znovu.",
   "ui.link.new.taken": "✓ Rodokmen je ve výzkumu „{name}“: osob {persons}, rodin {families}, pramenů {sources} – jako vodítka; co doloží záznamy, najde agent.",
   "ui.link.new.taken.archive": "✓ Rodokmen je ve výzkumu „{name}“: osob {persons}, rodin {families}, pramenů {sources} – jako vodítka; co doloží záznamy, najde agent, až bude zapnutý.",
+  "ui.link.new.taken.empty": "✓ Aplikace Strom předala strom, zatím prázdný: výzkum „{name}“ je s ní propojený. Osoby přidané v aplikaci přijdou do výzkumu, až se odešlou.",
   "ui.link.new.back": "Aplikace Strom teď strom ukazuje jako strom výzkumu.",
   "ui.link.new.chat": "Začít teď rozhovor s agentem?",
   "ui.link.new.say": "Předal(a) jsem náš rodokmen z aplikace Strom – podívej se, co v něm je, a navrhni, čím začít.",
+  "ui.move.file": "Soubor stromu z aplikace Strom: {file}",
+  "ui.move.file.ask": "Soubor stromu z aplikace Strom ({name}) se mezi staženými soubory nenašel. Cesta k němu – soubor lze přetáhnout do tohoto okna (0: zrušit)",
+  "ui.move.file.other": "Tenhle soubor není strom, který aplikace Strom přenáší (jiný strom, nebo jiný druh souboru).",
+  "ui.move.file.kept": "Soubor stromu zůstává na místě: {file}",
+  "ui.move.file.trashed": "Strom je teď ve výzkumu i v prohlížeči; jeho soubor šel do koše: {file}",
+  "ui.move.fresh": "{browser} se při prvním spuštění může ptát na přihlášení a výchozí prohlížeč. Až to bude zodpovězené a aplikace Strom se v něm neotevře, otevřít v {browser} adresu níže.",
+  "ui.move.ask": "Strom „{tree}“ (osob: {persons}) se přenese do {browser} a dál se bude pracovat tam. Přenést?",
+  "ui.move.which": "Do kterého prohlížeče se strom „{tree}“ (osob: {persons}) přenese?",
+  "ui.move.yes": "Přenést",
+  "ui.move.no": "Ne",
+  "ui.move.none": "Nepřenášet",
+  "ui.move.empty": "Aplikace Strom se otevře v {browser} a dál se bude pracovat tam. Pokračovat?",
+  "ui.move.empty.which": "Ve kterém prohlížeči se aplikace Strom otevře?",
+  "ui.move.go": "Pokračovat",
+  "ui.move.stays": "Strom zůstává v {from}, nic se nezaložilo.",
+  "ui.move.from.other": "původním prohlížeči",
+  "ui.move.from.mobile": "telefonu nebo tabletu",
+  "ui.move.then": "Co dál?",
+  "ui.move.end": "Konec",
+  "ui.move.cancel": "Zrušit",
+  "ui.move.cancelled": "Nic se nezaložilo.",
+  "ui.move.without": "Pokračovat bez prohlížeče: výzkum (nebo archiv) ze souboru",
+  "ui.move.without.what": "Aplikace v {from} se k výzkumu nepřipojí: nic z aplikace nepůjde živě – ani výzkum, ani archiv. Změny z aplikace jdou do výzkumu souborem (v aplikaci Export → GEDCOM, ve výzkumu strom sync <soubor>), verze výzkumu se do aplikace vrací importem souboru a fotky touto cestou nejdou.",
+  "ui.move.without.later.here": "Plné spojení je jen přes Chrome, Edge, Brave nebo Firefox a {browser} tu je: strom app (v menu Aplikace Strom) v něm kdykoli otevře výzkum a přenos se tím dokončí.",
+  "ui.move.without.later.none": "Plné spojení je jen přes Chrome, Edge, Brave nebo Firefox: po instalaci některého z nich strom app (v menu Aplikace Strom) otevře výzkum v něm a přenos se tím dokončí.",
+  "ui.move.nobrowser": "Na tomto počítači není prohlížeč, ze kterého se aplikace Strom k výzkumu připojí. Strom se může přenést do prohlížeče, který to umí – Google Chrome nebo Microsoft Edge, ke stažení zdarma.",
+  "ui.move.get.chrome": "Otevřít stránku ke stažení Google Chrome (nic se neinstaluje samo)",
+  "ui.move.get.edge": "Otevřít stránku ke stažení Microsoft Edge (nic se neinstaluje samo)",
+  "ui.move.get.opened": "Stránka ke stažení je otevřená ve výchozím prohlížeči: {url}",
+  "ui.move.get.wait": "Po instalaci prohlížeče (toto okno zatím nechat otevřené): Enter pokračuje – prohlížeč se hledá znovu a teprve potom výzkum čeká na strom",
+  "ui.move.terminal": "Přenos stromu potřebuje odpověď člověka v terminálu, nic se nezaložilo.",
   "ui.more.sync.noapp": "Načíst změny z jiného rodokmenu (.ged, .json)",
   "ui.sync.path.noapp": "Přetáhnout sem soubor s rodokmenem (.ged nebo .json), nebo napsat cestu (Enter nebo 0 zpět)",
   "ui.sync.path": "Přetáhnout sem soubor vyexportovaný z aplikace Strom (.ged nebo .json), nebo napsat cestu (Enter nebo 0 zpět)",

package/assets/lang/de.json

@@ -66,6 +66,7 @@
   "ui.doc.links.isolated": "isolierte Installation: registriert keine Links",
   "ui.doc.app.isolated": "isolierte Installation: absichtlich nicht verwendet",
   "ui.doc.shortcut.isolated": "isolierte Installation: absichtlich keine",
+  "ui.doc.shortcut.no": "nicht gewünscht (strom setup fragt erneut)",
   "ui.dialog.waiting": "Die Frage wartet in einem Systemfenster auf dem Bildschirm (es kann hinter anderen Fenstern liegen) – dort antworten, gewartet wird höchstens {minutes} Min.: {question}",
   "ui.consent.level.auto": "Den Agenten selbstständig arbeiten lassen? Er fragt nur bei riskanten Schritten nach.",
   "ui.consent.level.full": "Dem Agenten erlauben, ohne Nachfrage alles zu tun außer dem, was strom verbietet?\n\nNur auf einem Computer, auf dem sonst nichts Wichtiges liegt.",
@@ -415,6 +416,9 @@
   "ui.o.disk": "Speicher",
   "ui.o.disk.tidy": "neben der Forschung hält strom {strom}, davon lassen sich {size} freigeben – sag es dem Benutzer einmal: strom tidy gibt es mit seiner Zustimmung frei (die Forschung bleibt)",
   "ui.app.drag": "Die Strom-App ist geöffnet. Die Datei {file}{shown} in ihr Fenster ziehen – beim ersten Mal wird daraus ein neuer Stammbaum, danach wird derselbe Stammbaum aktualisiert. Mit Chrome oder Edge auf diesem Computer übergibt strom sie selbst.",
+  "ui.app.browser.gone": "Die Strom-App öffnete sich in {gone}, der nicht mehr auf diesem Computer ist; ab jetzt öffnet sie sich in {now} (ein anderer: strom config set app.browser chrome|edge|brave|opera|firefox|chromium).",
+  "ui.app.browser.gone.none": "Die Strom-App öffnete sich in {gone}, der nicht mehr auf diesem Computer ist, und kein anderer Browser hier erreicht die Forschung (Chrome, Edge, Brave, Firefox). Sobald einer installiert ist, öffnet strom app die Forschung dort.",
+  "ui.app.moved": "Der Stammbaum der Forschung öffnet sich in {browser}: die Übertragung des Stammbaums ist damit abgeschlossen, die Strom-App arbeitet dort weiter und ist mit der Forschung verbunden. Fotos des Stammbaums sind nicht in der Forschung – sie blieben in {from} und in der Datei {file}.",
   "ui.app.drag.shown": " (im Dateifenster angezeigt)",
   "ui.app.nolive": "Die Forschung laufend zu verfolgen braucht Chrome oder Edge – Safari lässt eine Webseite nicht auf diesen Computer zugreifen.",
   "ui.app.images": "Mit Bildern: {n} Einträge aus ihren Scans ausgeschnitten ({mb} MB).",
@@ -1042,14 +1046,54 @@
   "ui.link.new.wait": "Ich warte, bis die Strom-App den Stammbaum übergibt – dort bestätigen (höchstens {min} Min.; Strg+C bricht ab).",
   "ui.link.new.elsewhere": "Diese Kopie der Strom-App kennt den Stammbaum nicht. Die Adresse oben in der Kopie öffnen, in der alles begann (etwa in der Beta) – die Forschung wartet darauf.",
   "ui.link.new.none": "Die Strom-App hat keinen Stammbaum übergeben. Die Forschung „{name}“ ist hier, noch leer: erneut aus der App beginnen, oder im Menü von strom etwas hinzufügen.",
+  "ui.link.new.none.trashed": "Die Strom-App hat keinen Stammbaum übergeben, die Forschung „{name}“ wurde also nicht angelegt (ihr leerer Ordner ist im Papierkorb). Erneut aus der App beginnen.",
   "ui.link.new.waited": "Innerhalb von {min} Min. kam kein Stammbaum aus der Strom-App. Die Forschung „{name}“ ist hier, noch leer.",
+  "ui.link.new.blocked": "Die Strom-App hat die Forschung noch nicht erreicht. Mögliche Ursache: der Browser hat ihr den Zugriff auf Apps auf diesem Gerät (das lokale Netzwerk) gesperrt – Chrome, Edge und Brave fragen danach, Firefox je nach Einstellung. Erlauben: Symbol links neben der Adresse → Zugriff auf das lokale Netzwerk / dieses Gerät → Erlauben, dann die Seite neu laden.",
+  "ui.link.new.blocked.chromium": "Die Strom-App hat die Forschung noch nicht erreicht. Mögliche Ursache: {browser} hat ihr den Zugriff auf Apps auf diesem Gerät gesperrt. Erlauben: Symbol links neben der Adresse → Apps auf dem Gerät (englisch Apps on device; in älteren Versionen Zugriff auf das lokale Netzwerk) → Erlauben, dann die Seite neu laden.",
+  "ui.link.new.blocked.brave": "Die Strom-App hat die Forschung noch nicht erreicht. Mögliche Ursache: Brave hat ihr den Zugriff auf localhost gesperrt. Erlauben: Symbol links neben der Adresse → Zugriff auf localhost (englisch Localhost access) → Erlauben, dann die Seite neu laden.",
+  "ui.link.new.blocked.firefox": "Die Strom-App hat die Forschung noch nicht erreicht. Mögliche Ursache: Firefox hat ihr den Zugriff auf Apps und Dienste auf diesem Gerät gesperrt. Erlauben: Symbol links neben der Adresse → Zugriff auf Apps und Dienste auf diesem Gerät → Erlauben, dann die Seite neu laden.",
+  "ui.link.new.into.ask": "Die Forschung „{name}“ (angelegt {when}) hat ihren Stammbaum aus der Strom-App noch nicht bekommen. Den Stammbaum dort hinzufügen?",
+  "ui.link.new.into": "In die Forschung „{name}“",
+  "ui.link.new.into.new": "Eine neue Forschung anlegen",
   "ui.link.new.empty": "Der Stammbaum, den die Strom-App geschickt hat, hat keine Personen – es gibt nichts zu erforschen. Die Forschung „{name}“ ist hier, noch leer.",
   "ui.link.new.failed": "Die Strom-App konnte den Stammbaum nicht übergeben. Die Forschung „{name}“ ist hier, noch leer: es erneut aus der App versuchen.",
   "ui.link.new.taken": "✓ Der Stammbaum ist in der Forschung „{name}“: {persons} Personen, {families} Familien, {sources} Quellen – als Hinweise; was Quellen belegen, findet der Agent.",
   "ui.link.new.taken.archive": "✓ Der Stammbaum ist in der Forschung „{name}“: {persons} Personen, {families} Familien, {sources} Quellen – als Hinweise; was Quellen belegen, findet ein Agent, sobald einer eingeschaltet ist.",
+  "ui.link.new.taken.empty": "✓ Die Strom-App hat ihren Stammbaum übergeben, noch leer: die Forschung „{name}“ ist mit ihr verbunden. Die in der App hinzugefügten Personen kommen in die Forschung, sobald sie gesendet werden.",
   "ui.link.new.back": "Die Strom-App zeigt den Stammbaum jetzt als Stammbaum der Forschung.",
   "ui.link.new.chat": "Jetzt das Gespräch mit dem Agenten beginnen?",
   "ui.link.new.say": "Ich habe unseren Stammbaum aus der Strom-App übergeben – schau dir an, was darin ist, und schlag vor, womit wir beginnen.",
+  "ui.move.file": "Datei des Stammbaums aus der Strom-App: {file}",
+  "ui.move.file.ask": "Die Datei des Stammbaums aus der Strom-App ({name}) wurde bei den Downloads nicht gefunden. Pfad zur Datei – sie kann in dieses Fenster gezogen werden (0: abbrechen)",
+  "ui.move.file.other": "Diese Datei ist nicht der Stammbaum, den die Strom-App überträgt (ein anderer Stammbaum oder eine andere Art von Datei).",
+  "ui.move.file.kept": "Die Datei des Stammbaums bleibt, wo sie ist: {file}",
+  "ui.move.file.trashed": "Der Stammbaum ist jetzt in der Forschung und im Browser; seine Datei kam in den Papierkorb: {file}",
+  "ui.move.fresh": "{browser} fragt beim ersten Start womöglich nach Anmeldung und Standardbrowser. Ist das beantwortet und hat sich die Strom-App darin nicht geöffnet, die Adresse unten in {browser} öffnen.",
+  "ui.move.ask": "Der Stammbaum „{tree}“ (Personen: {persons}) zieht in {browser} um, und dort wird weitergearbeitet. Übertragen?",
+  "ui.move.which": "In welchen Browser zieht der Stammbaum „{tree}“ (Personen: {persons}) um?",
+  "ui.move.yes": "Übertragen",
+  "ui.move.no": "Nein",
+  "ui.move.none": "Nicht übertragen",
+  "ui.move.empty": "Die Strom-App öffnet sich in {browser}, und dort wird weitergearbeitet. Fortfahren?",
+  "ui.move.empty.which": "In welchem Browser öffnet sich die Strom-App?",
+  "ui.move.go": "Fortfahren",
+  "ui.move.stays": "Der Stammbaum bleibt in {from}; nichts wurde angelegt.",
+  "ui.move.from.other": "dem ursprünglichen Browser",
+  "ui.move.from.mobile": "dem Telefon oder Tablet",
+  "ui.move.then": "Wie weiter?",
+  "ui.move.end": "Ende",
+  "ui.move.cancel": "Abbrechen",
+  "ui.move.cancelled": "Nichts wurde angelegt.",
+  "ui.move.without": "Ohne Browser weiter: die Forschung (oder ein Archiv) aus der Datei",
+  "ui.move.without.what": "Die App in {from} verbindet sich nicht mit der Forschung: nichts aus der App geht live – weder eine Forschung noch ein Archiv. Änderungen aus der App gehen als Datei in die Forschung (in der App Export → GEDCOM, in der Forschung strom sync <Datei>), die Version der Forschung kommt per Dateiimport zurück, und Fotos gehen diesen Weg nicht.",
+  "ui.move.without.later.here": "Die volle Verbindung gibt es nur über Chrome, Edge, Brave oder Firefox, und {browser} ist hier: strom app (im Menü die Strom-App) öffnet die Forschung jederzeit darin, und die Übertragung ist abgeschlossen.",
+  "ui.move.without.later.none": "Die volle Verbindung gibt es nur über Chrome, Edge, Brave oder Firefox: sobald einer installiert ist, öffnet strom app (im Menü die Strom-App) die Forschung dort, und die Übertragung ist abgeschlossen.",
+  "ui.move.nobrowser": "Auf diesem Computer gibt es keinen Browser, aus dem sich die Strom-App mit der Forschung verbindet. Der Stammbaum kann in einen Browser umziehen, der es kann – Google Chrome oder Microsoft Edge, kostenlos herunterzuladen.",
+  "ui.move.get.chrome": "Die Download-Seite von Google Chrome öffnen (nichts wird von selbst installiert)",
+  "ui.move.get.edge": "Die Download-Seite von Microsoft Edge öffnen (nichts wird von selbst installiert)",
+  "ui.move.get.opened": "Die Download-Seite ist im Standardbrowser geöffnet: {url}",
+  "ui.move.get.wait": "Nach der Installation des Browsers (dieses Fenster bleibt so lange offen): Enter macht weiter – der Browser wird erneut gesucht, und erst dann wartet die Forschung auf den Stammbaum",
+  "ui.move.terminal": "Das Übertragen des Stammbaums braucht die Antwort eines Menschen im Terminal; nichts wurde angelegt.",
   "ui.more.sync.noapp": "Änderungen aus einem anderen Stammbaum übernehmen (.ged, .json)",
   "ui.sync.path.noapp": "Die Stammbaum-Datei (.ged oder .json) hierher ziehen oder den Pfad eingeben (Enter oder 0 zurück)",
   "ui.sync.path": "Die aus der Strom-App exportierte Datei (.ged oder .json) hierher ziehen oder den Pfad eingeben (Enter oder 0 zurück)",

package/dist/cli/main.js

@@ -17,7 +17,7 @@ import { noticeStromApp } from "../core/stromapp.js";
 import { isNewer } from "../core/update.js";
 import { installation } from "../core/self.js";
 import { refreshGlobal } from "../agents/global.js";
-import { refreshLinks } from "../core/links.js";
+import { expandFromLine, refreshLinks } from "../core/links.js";
 import { clockLine, FINISH_LINE, finishAsked } from "../core/clock.js";
 import { currentSession } from "../core/session.js";
 import { checkArgs, GroupOnly, parseOptions, resolveCommand, splitPassthrough } from "./execute.js";
@@ -106,6 +106,8 @@ export async function main(argv, io, env, cwd) {
     const json = argv.includes("--json");
     const debug = argv.includes("--debug");
     resetCache(undefined, "command");
+    // the app's install line in its one variable (STROM_FROM): read as the five of an older line
+    expandFromLine(env);
     // what ran, for the reminder of the session's time
     let ran;
     let command;

package/dist/cli/menu-links.js

@@ -12,10 +12,16 @@ import { lines, truncate } from "./format.js";
 import { isArchive } from "../core/mode.js";
 import { Tree } from "../core/tree.js";
 import { monthSpend } from "../core/session.js";
-import { adoptFailedSince, adoptedAt, awaitAdoption, nothingSince, undoSync } from "../core/sync.js";
+import { adoptAskedSince, adoptFailedSince, adoptedAt, adoptionNeverCame, awaitAdoption, nothingSince, SYNC_INBOX, undoSync, withoutImages } from "../core/sync.js";
+import { moveToTrash } from "../core/trash.js";
+import { noteMovedByFile } from "../core/transfer.js";
+import { appBrowsers, browserKind, kindReaches } from "../core/chromium.js";
+import { appWindow } from "../core/appbrowser.js";
+import { moveTree } from "./move.js";
 import { changeLines } from "../core/changelog.js";
 import { startLive } from "../core/live.js";
 import { adoptAppUrl, appTreeNameFromInstall } from "../core/stromapp.js";
+import { stromReadsTags } from "../gedcom/export.js";
 import { appMarkFromInstall } from "../core/links.js";
 import { settleFromApp } from "./wizard.js";
 import { isValidLang } from "../core/lang.js";
@@ -25,6 +31,7 @@ import { claimText } from "../core/people.js";
 import { PROFILES } from "../agents/profiles.js";
 import { foldText, safeFolderName } from "../core/text.js";
 import { StromError } from "../core/errors.js";
+import { forgetTree } from "../commands/trees.js";
 /** What the Strom app asks, said before anything is done; true when the person goes on. */
 export async function asks(ctx, lang, root, what, note, suggested = true) {
     const name = Tree.open(root, ctx.env).config.name;
@@ -32,6 +39,8 @@ export async function asks(ctx, lang, root, what, note, suggested = true) {
     return ctx.confirm(translator(lang)("ui.link.go"), suggested);
 }
 const out = (ctx, line) => ctx.io.stdout(line + "\n");
+/** The app that loads the research's version itself right after a hand-over (the research's numbers for its people). */
+const APP_LOADS_ADOPTED = "3.9.0";
 /** What stopped it, said; nothing was done. */
 function stop(ctx, line) {
     out(ctx, line);
@@ -213,12 +222,51 @@ export async function undoSending(ctx, run, lang, root, id, fromMenu = false) {
         return false;
     return (await run(["sync", "undo", id])) === 0;
 }
+/**
+ * The research made from the tree's file with no browser to connect: taken in as the app's trees are (strom sync
+ * --apply --force, without its images: its sources the research's), then what came of it said — and the first
+ * conversation offered.
+ */
+async function fromFile(ctx, run, root, name, file, from) {
+    const t = translator(Tree.open(root, ctx.env).lang);
+    // the move is finished later — strom app, once a browser that reaches strom is here (D10)
+    noteMovedByFile(root, { from, file });
+    const dir = path.join(root, SYNC_INBOX);
+    fs.mkdirSync(dir, { recursive: true });
+    const kept = path.join(dir, `${safeFolderName(name)}.json`);
+    fs.writeFileSync(kept, withoutImages(fs.readFileSync(file, "utf8")));
+    if ((await run(["sync", kept, "--apply", "--force"], true)) !== 0)
+        return stop(ctx, t("ui.link.new.failed", { name }));
+    const tree = Tree.open(root, ctx.env);
+    const sources = tree.list("source").filter((s) => !s.retracted && s.kind !== "family-tree").length;
+    // a tree with no people yet (C1): handed over all the same — the research linked, its people come by the app's sends
+    if (tree.countLive("person") === 0)
+        out(ctx, t("ui.link.new.taken.empty", { name }));
+    else
+        out(ctx, t(isArchive(tree) ? "ui.link.new.taken.archive" : "ui.link.new.taken", { name, persons: tree.countLive("person"), families: tree.countLive("family"), sources }));
+    if (isArchive(tree))
+        out(ctx, t("ui.link.new.archive"));
+    else
+        await offerChat(ctx, run, tree.lang, root, t("ui.link.new.chat"), t("ui.link.new.say"));
+    return true;
+}
 /**
  * A tree of the Strom app becomes a new research (strom-research://new?app=<its mark>): named, its language and
  * agent chosen, made; the app opened to hand the tree over (?adopt=<the bridge>), the tree taken in as leads,
  * the research sent back to the app — then the conversation offered.
  */
-export async function newFromApp(ctx, runIn, token, openAt, forward) {
+export async function newFromApp(ctx, runIn, token, openAt, forward, opts = {}) {
+    // The browser the app runs in (its link's browser=, the line's STROM_FROM_BROWSER — the app's 3.9.1): the app keeps
+    // the tree there. One the app cannot reach strom from (Safari), or the tree saved as a file for that (STROM_FROM_FILE):
+    // the tree moves to a browser that can — asked first, before anything is set up (no: nothing is)
+    const from = opts.browser ?? browserKind(ctx.env.STROM_FROM_BROWSER);
+    const given = opts.file ?? (ctx.env.STROM_FROM_FILE?.trim() || undefined);
+    let move;
+    if (given || (from && !kindReaches(from))) {
+        move = await moveTree(ctx, token, from, given);
+        if (!move)
+            return false;
+    }
     // strom not set up yet (the app is how this person came): the setup first — the agent and where to talk with it
     // chosen there, not asked again
     const setUp = !ctx.settings.home()?.value;
@@ -230,6 +278,13 @@ export async function newFromApp(ctx, runIn, token, openAt, forward) {
     }
     else if (appMarkFromInstall(ctx.env))
         await settleFromApp(ctx, ctx.uiLang(), { shortcut: true });
+    // the copy of the app the tree comes from, carried by its file when the line had no room for it (Win + R: 259
+    // characters) — kept as the line's STROM_APP_URL is
+    if (move?.mark.app && !ctx.env.STROM_APP_URL?.trim()) {
+        ctx.settings.reload();
+        ctx.settings.config.stromAppUrl = move.mark.app;
+        ctx.settings.save();
+    }
     let lang = ctx.uiLang();
     let t = translator(lang);
     out(ctx, t("ui.link.new.title"));
@@ -237,62 +292,120 @@ export async function newFromApp(ctx, runIn, token, openAt, forward) {
     // the name; an empty research of that name (a handover that did not come) is taken again
     let name = "";
     let root;
-    // suggested: the app's tree's name (its line carries it), else the usual one — Enter never ends the handover
-    const suggested = appTreeNameFromInstall(ctx.env) ?? t("ui.tree.default");
-    for (;;) {
-        name = ((await ctx.ask(t("ui.link.new.name"), suggested)) || suggested).trim().replace(/\s+/gu, " ");
-        if (!name || name === "0")
+    // a research made for a tree of the app that never came (installed from an older app, the tree stayed in Safari):
+    // the tree goes into it, nothing set up again (suggested) — or a new research (D4)
+    const waiting = ctx
+        .knownTrees()
+        .map((k) => ({ ...k, never: adoptionNeverCame(k.root) }))
+        .filter((k) => Boolean(k.never))
+        .sort((a, b) => Date.parse(b.never.at) - Date.parse(a.never.at))[0];
+    if (waiting) {
+        const tw = Tree.open(waiting.root, ctx.env);
+        const i = await ctx.choose(t("ui.link.new.into.ask", { name: tw.config.name, when: humanWhen(waiting.never.at, lang) }), [{ label: t("ui.link.new.into", { name: tw.config.name }) }, { label: t("ui.link.new.into.new") }], 0, { back: t("ui.move.cancel") });
+        if (i === undefined) {
+            if (move)
+                out(ctx, t("ui.move.file.kept", { file: ctx.display(move.file) }));
             return false;
-        const same = ctx.knownTrees().find((k) => foldText(k.name) === foldText(name) || path.basename(k.root) === safeFolderName(name));
-        if (!same)
-            break;
-        if (Tree.open(same.root, ctx.env).count("person") === 0) {
-            root = same.root;
-            break;
         }
-        out(ctx, t("ui.link.new.exists", { name }));
-        if (outOfAnswers(ctx))
-            return false;
-    }
-    for (;;) {
-        const a = (await ctx.ask(t("ui.setup.lang"), lang)).trim().toLowerCase();
-        if (a === "0")
-            return false;
-        if (isValidLang(a)) {
-            lang = a;
+        if (i === 0) {
+            root = waiting.root;
+            name = tw.config.name;
+            lang = tw.lang;
             t = translator(lang);
-            break;
         }
-        if (outOfAnswers(ctx))
-            return false;
     }
+    const joined = Boolean(root);
+    // suggested: the app's tree's name (its line carries it), else the usual one — Enter never ends the handover
+    const suggested = (move?.mark.tree || undefined) ?? appTreeNameFromInstall(ctx.env) ?? t("ui.tree.default");
     const ways = waysHere(agentsHere(ctx.env));
     const mine = ctx.settings.agent().value;
     let agent = mine;
     let where;
-    // an archive (the setup's choice: no agent) needs none; each agent's app and terminal a line of their own
-    if (!setUp && ways.length > 1 && ctx.settings.config.mode !== "archive") {
-        const i = await chooseWay(ctx, lang, ways, suggestedWay(ways, mine, ctx.settings.agentWhere()), { back: t("ui.browse.back") });
-        if (i === undefined)
-            return false;
-        agent = ways[i].agent;
-        where = ways[i].where;
+    let archive = false;
+    // asked step by step, 0 one step back (the name's 0: nothing set up, found on a Mac: 0 at the agent ended it all); a
+    // research joined asks none. With an agent here the research with it is suggested and an archive is the other choice,
+    // as in the setup (an archive the setup chose, or the setup just run: as it is); each agent's app and terminal a line
+    // of their own
+    for (let step = joined ? 3 : 0; step < 3;) {
+        if (step === 0) {
+            name = ((await ctx.ask(t("ui.link.new.name"), suggested)) || suggested).trim().replace(/\s+/gu, " ");
+            if (!name || name === "0") {
+                if (move)
+                    out(ctx, t("ui.move.file.kept", { file: ctx.display(move.file) }));
+                return false;
+            }
+            const same = ctx.knownTrees().find((k) => foldText(k.name) === foldText(name) || path.basename(k.root) === safeFolderName(name));
+            root = same?.root;
+            if (same && Tree.open(same.root, ctx.env).count("person") > 0) {
+                root = undefined;
+                out(ctx, t("ui.link.new.exists", { name }));
+                if (outOfAnswers(ctx))
+                    return false;
+                continue;
+            }
+            step = 1;
+        }
+        else if (step === 1) {
+            const a = (await ctx.ask(t("ui.setup.lang"), lang)).trim().toLowerCase();
+            if (a === "0")
+                step = 0;
+            else if (isValidLang(a)) {
+                lang = a;
+                t = translator(lang);
+                step = 2;
+            }
+            else if (outOfAnswers(ctx))
+                return false;
+        }
+        else {
+            step = 3;
+            // no agent here: an archive, nothing asked (N9: the setup run before an agent left, its research mode kept)
+            if (!root && ways.length === 0)
+                archive = true;
+            if (root || setUp || ways.length === 0 || ctx.settings.config.mode === "archive")
+                continue;
+            const pick = suggestedWay(ways, mine, ctx.settings.agentWhere());
+            const k = await ctx.choose(t("ui.setup.fromapp"), [{ label: t("ui.setup.fromapp.archive") }, { label: t("ui.setup.fromapp.agent", { agent: PROFILES[ways[pick].agent].name }) }], 1, { back: t("ui.browse.back") });
+            archive = k === 0;
+            if (k === undefined)
+                step = 1;
+            else if (k === 1 && ways.length > 1) {
+                const i = await chooseWay(ctx, lang, ways, pick, { back: t("ui.browse.back") });
+                if (i === undefined)
+                    step = 2;
+                else {
+                    agent = ways[i].agent;
+                    where = ways[i].where;
+                }
+            }
+        }
     }
+    // made here: an empty research of it is not left behind when the app hands nothing over (N4)
+    const made = !root;
     if (!root) {
         let said = "";
-        const code = await (await runIn(undefined))(["init", name, "--lang", lang, "--json"], true, (s) => (said += s));
+        const code = await (await runIn(undefined))(["init", name, "--lang", lang, ...(archive ? ["--mode", "archive"] : []), "--json"], true, (s) => (said += s));
         if (code !== 0)
             return false;
         root = JSON.parse(said).root;
     }
     const run = await runIn(root);
-    if (agent !== mine)
+    if (!archive && agent !== mine)
         await run(["agents", "use", agent, "--for-tree"], true);
     // where the person talks with the agents (the setting of this computer, as the setup keeps it)
     if (where && where !== ctx.settings.agentWhere())
         await run(["config", "set", "agent.where", where], true);
-    // the app hands its tree over to the bridge of this research
-    awaitAdoption(root, token);
+    // no browser: the research made from the file — the app and the research go on through files
+    if (move && "without" in move)
+        return fromFile(ctx, run, root, name, move.file, move.from);
+    // the browser the app opens in from now on: the one it moves to, else the one the tree came from (while it is here)
+    const keep = move && "browser" in move ? move.browser.kind : from && kindReaches(from) && appBrowsers(ctx.env).some((b) => b.kind === from) ? from : undefined;
+    if (keep && keep !== ctx.settings.appBrowser()) {
+        await run(["config", "set", "app.browser", keep], true);
+        ctx.settings.reload();
+    }
+    // the app hands its tree over to the bridge of this research (a tree moving: the app there takes its file first)
+    awaitAdoption(root, token, move?.file, !made);
     const info = startLive(root, ctx.env, { current: true });
     if (!info)
         throw new StromError("the bridge did not start", { hint: "strom live serve shows why" });
@@ -300,7 +413,26 @@ export async function newFromApp(ctx, runIn, token, openAt, forward) {
     const since = Date.now();
     const waitMs = Number(ctx.env.STROM_ADOPT_WAIT_MS ?? 30 * 60_000);
     const minutes = Math.max(1, Math.round(waitMs / 60_000));
+    // a browser installed just now asks its own questions at its first start (signing in, the default browser): the
+    // address to open in it once they are answered (D8)
+    if (move && "browser" in move && move.installed)
+        out(ctx, t("ui.move.fresh", { browser: move.browser.name }));
     out(ctx, openAt(url) ? `${t("ui.link.new.wait", { min: minutes })}\n${t("ui.sync.wait.open", { url })}` : t("ui.app.url", { url }));
+    // the file of the move: in the trash once the tree is handed over, else kept where it is (said, D9)
+    const keptFile = () => {
+        if (move)
+            out(ctx, t("ui.move.file.kept", { file: ctx.display(move.file) }));
+    };
+    // the app has not asked the research a thing for a while: a browser may keep it from strom (its permission for the
+    // local network, D7) — said once, and again at the end
+    const blockedAfter = Number(ctx.env.STROM_ADOPT_HINT_MS ?? 2 * 60_000);
+    let toldBlocked = false;
+    // named as the browser the app opened in names it (Edge 154: Apps on device, not Local network — F5)
+    const opensIn = appWindow(ctx.settings, ctx.env).browser;
+    const blocked = opensIn?.kind === "brave" ? t("ui.link.new.blocked.brave")
+        : opensIn?.kind === "firefox" ? t("ui.link.new.blocked.firefox")
+            : opensIn && kindReaches(opensIn.kind) ? t("ui.link.new.blocked.chromium", { browser: opensIn.name })
+                : t("ui.link.new.blocked");
     // the bridge takes the tree in itself (as the app's trees are, its sources the research's): whether or not this
     // terminal still waits, it is in once the app has handed it over — here only what came of it
     let done;
@@ -314,6 +446,7 @@ export async function newFromApp(ctx, runIn, token, openAt, forward) {
         const failed = adoptFailedSince(root, since);
         if (failed) {
             forward();
+            keptFile();
             return stop(ctx, [t(failed.why === "empty" ? "ui.link.new.empty" : "ui.link.new.failed", { name }), failed.reason].filter(Boolean).join("\n"));
         }
         const nothing = nothingSince(root, since);
@@ -324,20 +457,51 @@ export async function newFromApp(ctx, runIn, token, openAt, forward) {
         }
         else if (nothing) {
             forward();
-            out(ctx, t("ui.link.new.none", { name }));
+            // the app said no (Nepředávat): nothing set up halfway — the research made for it, still empty, into the trash
+            if (made && Tree.open(root, ctx.env).count("person") === 0) {
+                forgetTree(ctx, root, "the Strom app handed no tree over");
+                out(ctx, t("ui.link.new.none.trashed", { name }));
+            }
+            else
+                out(ctx, t("ui.link.new.none", { name }));
+            keptFile();
             return false;
         }
+        if (!toldBlocked && Date.now() - since > blockedAfter && !adoptAskedSince(root, since)) {
+            toldBlocked = true;
+            out(ctx, blocked);
+        }
         await new Promise((r) => setTimeout(r, 500));
     }
     forward();
-    if (!done)
-        return stop(ctx, t("ui.link.new.waited", { name, min: minutes }));
+    if (!done) {
+        keptFile();
+        return stop(ctx, lines(t("ui.link.new.waited", { name, min: minutes }), adoptAskedSince(root, since) ? undefined : blocked));
+    }
+    // handed over: the file of the move is the browser's now — into the trash (never deleted for good)
+    if (move && "browser" in move && fs.existsSync(move.file)) {
+        try {
+            moveToTrash(move.file, ctx.env);
+            out(ctx, t("ui.move.file.trashed", { file: ctx.display(move.file) }));
+        }
+        catch {
+            keptFile();
+        }
+    }
     const tree = Tree.open(root, ctx.env);
     const sources = tree.list("source").filter((s) => !s.retracted && s.kind !== "family-tree").length;
-    out(ctx, t(isArchive(tree) ? "ui.link.new.taken.archive" : "ui.link.new.taken", { name, persons: tree.countLive("person"), families: tree.countLive("family"), sources }));
-    // the research as it is now back into the app's window: the same tree, now of the research (not opened: its address said)
+    // a tree with no people yet (C1): handed over all the same — the research linked, its people come by the app's sends
+    if (tree.countLive("person") === 0)
+        out(ctx, t("ui.link.new.taken.empty", { name }));
+    else
+        out(ctx, t(isArchive(tree) ? "ui.link.new.taken.archive" : "ui.link.new.taken", { name, persons: tree.countLive("person"), families: tree.countLive("family"), sources }));
+    // the research as it is now back into the app's window: the same tree, now of the research (not opened: its address
+    // said) — an app from 3.9.0 loads it itself right after the hand-over, so nothing is opened a second time (N12: a
+    // second tab asking to load the research's version)
     let said = "";
-    if ((await run(["app", "--json"], true, (s) => (said += s))) === 0) {
+    if (done?.app && stromReadsTags(done.app, APP_LOADS_ADOPTED))
+        out(ctx, t("ui.link.new.back"));
+    else if ((await run(["app", "--json"], true, (s) => (said += s))) === 0) {
         const shown = JSON.parse(said);
         // no browser to hand it over: the file to drag into the app
         if (shown.via === "drag" && shown.file)

package/dist/cli/menu.js

@@ -23,7 +23,7 @@ import { othersAtWork } from "../core/session.js";
 import { DEFAULT_RUN_MINUTES } from "../core/config.js";
 import { truncate } from "./format.js";
 import { installedStromApp, noticeStromApp, stromAppState, stromAppUrl } from "../core/stromapp.js";
-import { chromiumBrowser } from "../core/chromium.js";
+import { appBrowsers } from "../core/chromium.js";
 import { liveWorkers, runsAtWork } from "../core/workers.js";
 import { askStromApp, settleInstall, shortcutName } from "./wizard.js";
 import { openForUser } from "../core/open.js";
@@ -252,9 +252,9 @@ export async function runMenu(ctx, run) {
                                 out(t("ui.run.which.bad", { n: shown.length }));
                         }
                     }
-                    // With the Strom app, the work can be watched live meanwhile (a Chromium browser reaches the bridge); the last answer is suggested.
+                    // With the Strom app, the work can be watched live meanwhile (a browser here reaches the bridge); the last answer is suggested.
                     const app = stromAppState(ctx.settings);
-                    if ((app === "yes" || app === "seen") && chromiumBrowser(ctx.env)) {
+                    if ((app === "yes" || app === "seen") && appBrowsers(ctx.env).length > 0) {
                         const follow = await ctx.confirm(t("ui.run.follow"), ctx.settings.config.stromAppFollow !== "no");
                         if (ctx.settings.config.stromAppFollow !== (follow ? "yes" : "no")) {
                             ctx.settings.config.stromAppFollow = follow ? "yes" : "no";