strom-research 1.5.0 → 1.6.0

package/dist/commands/links.js

@@ -0,0 +1,367 @@
+// strom-research:// links from the Strom app (core/links.ts): strom link open
+// is what the system runs for one; strom link on|off|status registers the
+// scheme for this user, takes it off, says where it leads.
+import fs from "node:fs";
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { register } from "../cli/registry.js";
+import { lines } from "../cli/format.js";
+import { ui } from "../cli/ui.js";
+import { readJsonIfExists } from "../core/json.js";
+import { Tree } from "../core/tree.js";
+import { LinkError, linkHandlerState, linkText, parseLink, registerLinks, unregisterLinks } from "../core/links.js";
+import { displayName, lifespan } from "../core/people.js";
+import { PROFILES } from "../agents/profiles.js";
+import { whereToTalk } from "../core/apps.js";
+import { pause } from "../cli/menu-parts.js";
+import { fullExcerpt } from "../core/excerpt.js";
+import { openForUser } from "../core/open.js";
+import { openInNewTerminal } from "../core/shortcut.js";
+import { systemNotice } from "../core/dialog.js";
+import { configDir } from "../core/paths.js";
+/** The researches here with this id — a copy of a research folder has its id too; the current one first. */
+function researchesWithId(ctx, id) {
+    const current = ctx.settings.config.currentTree;
+    return ctx
+        .knownTrees()
+        .filter((k) => readJsonIfExists(path.join(k.root, "strom.json"))?.id?.toLowerCase() === id)
+        .sort((a, b) => Number(b.root === current) - Number(a.root === current));
+}
+/**
+ * What a link could not do, said where the person is: the terminal, else a window (a link opens strom with none).
+ * The result carries it too.
+ */
+async function say(ctx, key, values = {}, data = {}) {
+    const lang = ctx.uiLang();
+    const text = ui(lang, key, values);
+    if (!ctx.io.tty)
+        systemNotice(ui(lang, "ui.dialog.title"), text, ui(lang, "ui.link.ok"), ctx.env);
+    return { text, data: { done: false, ...data } };
+}
+/** The person's answer about links, kept: the question when the app opens is not asked again. */
+function keepAnswer(ctx, answer) {
+    ctx.settings.reload();
+    ctx.settings.config.links = answer;
+    ctx.settings.save();
+}
+/** macOS: the terminal program this runs in, by its mark (TERM_PROGRAM). */
+const TERMINALS = { Apple_Terminal: "Terminal", "iTerm.app": "iTerm", WezTerm: "WezTerm", ghostty: "Ghostty" };
+/**
+ * The terminal a link opened comes in front of the Strom app when the app has answered (the tree came, or
+ * nothing did): the person sees what came of it. macOS; elsewhere the window stays where it is.
+ */
+function bringForward(env) {
+    const app = TERMINALS[env.TERM_PROGRAM ?? ""];
+    if (process.platform !== "darwin" || !app || env.STROM_NO_OPEN === "1")
+        return;
+    spawnSync("osascript", ["-e", `tell application "${app}" to activate`], { stdio: "ignore", timeout: 5000 });
+}
+/** strom itself in a research's folder (none: where strom is), as the menu runs it — quiet: its output not shown; said: handed over. */
+function runnerOf(ctx) {
+    return async (root) => {
+        const { main } = await import("../cli/main.js");
+        return (argv, quiet, said) => main(argv, said ? { ...ctx.io, stdout: said } : quiet ? { ...ctx.io, stdout: () => undefined } : ctx.io, ctx.env, root ?? ctx.cwd);
+    };
+}
+/** A person of the research a link names: the one they were merged into; one taken out is none. */
+function personOf(root, ctx, id) {
+    const tree = Tree.open(root, ctx.env);
+    let p = tree.get(id);
+    if (p?.mergedInto)
+        p = tree.get(p.mergedInto);
+    return p && !p.retracted ? p : undefined;
+}
+/** A person as the user reads them, with the ID to name them by: "Jan Novák (*1905) [P0012]". */
+function who(p) {
+    const span = lifespan(p);
+    return `${displayName(p)}${span ? ` (${span})` : ""} [${p.id}]`;
+}
+/** The conversation's first message about one person: only who (from the research's own record), what to ask is the person's. */
+function aboutPerson(lang, p) {
+    return ui(lang, "ui.link.chat.say", { person: who(p) });
+}
+/** The conversation's first message about a conflict: its ID and title from the research itself. */
+function aboutConflict(root, ctx, id) {
+    const tree = Tree.open(root, ctx.env);
+    const c = tree.get(id);
+    return c && c.type === "conflict" && c.state === "open" ? ui(tree.lang, "ui.link.conflict.say", { id: c.id, title: c.title }) : undefined;
+}
+/** What a link asks, in this terminal: which copy of the research, then as the menu does it. */
+async function inTerminal(ctx, link) {
+    const lang = ctx.uiLang();
+    const copies = researchesWithId(ctx, link.tree);
+    if (!copies.length)
+        return say(ctx, "ui.link.notree", {}, { tree: link.tree });
+    let root = copies[0].root;
+    if (copies.length > 1) {
+        const i = await ctx.choose(ui(lang, link.action === "send" ? "ui.link.which" : "ui.link.which.one"), copies.map((c) => ({ label: `${c.name} (${ctx.display(c.root)})` })), 0, { back: ui(lang, "ui.browse.back") });
+        if (i === undefined)
+            return { text: "", data: { done: false } };
+        root = copies[i].root;
+    }
+    const run = await runnerOf(ctx)(root);
+    const tree = Tree.open(root, ctx.env);
+    const treeLang = tree.lang;
+    const end = async (done) => {
+        await pause(ctx, treeLang, "ui.enter.close");
+        return { text: "", data: { done, action: link.action, tree: root } };
+    };
+    const said = async (key, values = {}) => {
+        ctx.io.stdout(ui(treeLang, key, values) + "\n");
+        return end(false);
+    };
+    const agent = PROFILES[ctx.settings.agent(tree.config).value]?.name ?? ctx.settings.agent(tree.config).value;
+    switch (link.action) {
+        case "send": {
+            const { syncFromApp } = await import("../cli/menu-research.js");
+            await syncFromApp(ctx, run, treeLang, root, "ui.enter.close", () => bringForward(ctx.env));
+            return { text: "", data: { done: true, action: link.action, tree: root } };
+        }
+        // the research's menu, as `strom` in its folder; the research into the app's window, as strom app; strom's own
+        // commands, which ask themselves
+        case "open":
+        case "app":
+            return { text: "", data: { done: (await run(link.action === "open" ? [] : ["app"])) === 0, action: link.action, tree: root } };
+        case "update":
+        case "setup":
+            return end((await run([link.action])) === 0);
+        case "sessions": {
+            const { sessionsView } = await import("../cli/menu-links.js");
+            sessionsView(ctx, treeLang, root);
+            return end(true);
+        }
+        case "task": {
+            if (link.do) {
+                const { taskDo } = await import("../cli/menu-links.js");
+                return end(await taskDo(ctx, run, treeLang, root, link.task, link.do));
+            }
+            const { waitingTask } = await import("../cli/menu-waiting.js");
+            if (!(await waitingTask(ctx, run, treeLang, root, link.task)))
+                return said("ui.link.notask");
+            return end(true);
+        }
+        case "conflict": {
+            if (link.do === "decide") {
+                const { decideConflict } = await import("../cli/menu-links.js");
+                return end(await decideConflict(ctx, run, treeLang, root, link.id));
+            }
+            // left to the agent: it costs — said and asked first, then the conversation about it
+            const say = aboutConflict(root, ctx, link.id);
+            if (!say)
+                return said("ui.link.conflict.none", { id: link.id });
+            const { asks } = await import("../cli/menu-links.js");
+            if (!(await asks(ctx, treeLang, root, ui(treeLang, "ui.link.what.conflict.agent", { agent, title: tree.get(link.id).title }), ui(treeLang, "ui.link.cost"))))
+                return end(false);
+            return { text: "", data: { done: (await run(["chat", `--say=${say}`])) === 0, action: link.action, tree: root } };
+        }
+        case "sync-undo": {
+            const { undoSending } = await import("../cli/menu-links.js");
+            return end(await undoSending(ctx, run, treeLang, root, link.intake));
+        }
+    }
+    const named = "person" in link ? link.person : undefined;
+    const person = named ? personOf(root, ctx, named) : undefined;
+    if (named && !person)
+        return said("ui.link.noperson", { person: named });
+    const { asks } = await import("../cli/menu-links.js");
+    switch (link.action) {
+        case "chat": {
+            // the agent costs: said and asked first, then the conversation as strom chat starts it
+            const what = person ? ui(treeLang, "ui.link.what.chat.person", { agent, person: who(person) }) : ui(treeLang, "ui.link.what.chat", { agent });
+            if (!(await asks(ctx, treeLang, root, what, ui(treeLang, "ui.link.cost"))))
+                return { text: "", data: { done: false, action: link.action, tree: root } };
+            return { text: "", data: { done: (await run(["chat", ...(person ? [`--say=${aboutPerson(treeLang, person)}`] : [])])) === 0, action: link.action, tree: root } };
+        }
+        case "story": {
+            const { approveStory } = await import("../cli/menu-links.js");
+            return end(await approveStory(ctx, run, treeLang, root, person, who(person)));
+        }
+        case "review": {
+            const what = ui(treeLang, `ui.link.what.review.${link.scope}`, { person: who(person) });
+            if (await asks(ctx, treeLang, root, what, ui(treeLang, "ui.link.tasks"))) {
+                const { reviewOne } = await import("../cli/menu-research.js");
+                await reviewOne(ctx, run, treeLang, root, person.id, link.scope);
+            }
+            return end(true);
+        }
+        case "research": {
+            // the same direction still going: only named, nothing asked
+            const same = tree.list("research").find((r) => r.focus === person.id && r.direction === link.direction && r.state === "active");
+            if (same)
+                return said("ui.research.exists", { name: same.name });
+            const what = ui(treeLang, `ui.link.what.research.${link.direction}`, { person: who(person) });
+            if (await asks(ctx, treeLang, root, what, ui(treeLang, "ui.link.tasks"))) {
+                const { startDirection } = await import("../cli/menu-research.js");
+                await startDirection(ctx, run, treeLang, root, link.direction, ["--person", person.id], displayName(person));
+            }
+            return end(true);
+        }
+    }
+}
+/**
+ * What needs no terminal: the research as it is now into the app's window (strom app), a conversation in the
+ * agent's desktop app (its first message waits there for the person to send it). Undefined: a terminal is needed.
+ */
+async function withoutTerminal(ctx, link, root) {
+    const run = await runnerOf(ctx)(root);
+    if (link.action === "app")
+        return { text: "", data: { done: (await run(["app"], true)) === 0, action: "app", tree: root } };
+    if (link.action !== "chat" && !(link.action === "conflict" && link.do === "agent"))
+        return undefined;
+    const tree = Tree.open(root, ctx.env);
+    if (whereToTalk(ctx.settings.agent(tree.config).value, ctx.settings.agentWhere(), ctx.env) !== "app")
+        return undefined;
+    let first;
+    if (link.action === "conflict") {
+        first = aboutConflict(root, ctx, link.id);
+        if (!first)
+            return say(ctx, "ui.link.conflict.none", { id: link.id }, { tree: link.tree });
+    }
+    else if (link.action === "chat" && link.person) {
+        const person = personOf(root, ctx, link.person);
+        if (!person)
+            return say(ctx, "ui.link.noperson", { person: link.person }, { tree: link.tree });
+        first = aboutPerson(tree.lang, person);
+    }
+    return { text: "", data: { done: (await run(["chat", ...(first ? [`--say=${first}`] : [])], true)) === 0, action: link.action, tree: root } };
+}
+/** An excerpt in full: the first research here that has it. */
+function excerptOf(ctx, link) {
+    const shared = ctx.settings.shared()?.value;
+    const copies = researchesWithId(ctx, link.tree);
+    if (!copies.length || !shared)
+        return { missing: "tree" };
+    let found = { missing: "clip" };
+    for (const c of copies) {
+        const s = Tree.open(c.root, ctx.env).get(link.source);
+        if (!s || s.retracted)
+            continue;
+        found = fullExcerpt(Tree.open(c.root, ctx.env), shared, s, link.clip);
+        if (!("missing" in found))
+            return found;
+    }
+    return found;
+}
+register({
+    path: ["link", "open"],
+    summary: "Do what a strom-research:// link from the Strom app asks (the system runs it): send the edited tree back, an excerpt in full, …",
+    group: "setup",
+    description: "strom-research://send?tree=<research id> — the Strom app sends the edited tree to this research (a terminal opens,\n" +
+        "what it brings is shown and written on the user's word, as the menu's \"straight from the Strom app\").\n" +
+        "strom-research://excerpt?tree=<id>&source=S0042&clip=<its mark> — the excerpt from the scan, not made smaller, in the\n" +
+        "viewer of the system (the page in the online archive when the scan is not here). Nothing is written.\n" +
+        "strom-research://app?tree=<id> — the research as it is now into the app's open window (strom app).\n" +
+        "strom-research://open?tree=<id> — the research's menu in a terminal.\n" +
+        "strom-research://chat?tree=<id>[&person=P0012] — a conversation with the agent (strom chat; of one person: its first\n" +
+        "message names only who). strom-research://task?tree=<id>&task=T0007 — the task that waits for the user, answered.\n" +
+        "strom-research://review?tree=<id>&person=P0012&scope=person|family|line — the person reviewed (strom review).\n" +
+        "strom-research://research?tree=<id>&person=P0012&direction=ancestors|descendants — a new direction (research new).\n" +
+        "strom-research://task?…&task=T0007&do=park|drop|wake — the task put aside, given up, back in the queue (the reason asked).\n" +
+        "strom-research://conflict?tree=<id>&id=X0007&do=decide|agent — decided by the user (which claim, why) or left to the agent.\n" +
+        "strom-research://story?tree=<id>&person=P0012&do=final — the story approved (strom story approve).\n" +
+        "strom-research://sync-undo?tree=<id>&intake=I0042 — a sending from the app taken back (strom sync undo).\n" +
+        "strom-research://update|sessions|setup?tree=<id> — strom update, the agent's sessions and their cost, strom setup.\n" +
+        "strom-research://new?app=<the app's mark> — a tree of the app becomes a new research: named, made, the app hands the\n" +
+        "tree to its bridge (?adopt=, GET/POST /adopt), taken in as leads, sent back to the app.\n" +
+        "What writes tasks or starts the agent is said and asked in the terminal first. Any page can open such a link:\n" +
+        "each part is checked (only IDs and fixed values, never text), an unknown research, person, task or excerpt is\n" +
+        "only said. No link: the menu.",
+    args: [{ name: "link", description: "the strom-research:// link" }],
+    examples: ["strom link open 'strom-research://send?tree=0f8c2d4e-1b2a-4c3d-9e8f-7a6b5c4d3e2f'"],
+    async run(ctx, { args }) {
+        let link;
+        try {
+            link = parseLink(args[0]);
+        }
+        catch (e) {
+            if (!(e instanceof LinkError))
+                throw e;
+            return say(ctx, "ui.link.bad", { why: e.message });
+        }
+        if (link.action === "menu") {
+            const where = ctx.settings.home()?.value ?? configDir(ctx.env);
+            fs.mkdirSync(where, { recursive: true });
+            openInNewTerminal([], where, ctx.env);
+            return { text: "", data: { done: true, action: "menu" } };
+        }
+        // a tree of the app becomes a research: always in a terminal (it asks the name, waits for the app)
+        if (link.action === "new") {
+            if (ctx.io.tty) {
+                const { newFromApp } = await import("../cli/menu-links.js");
+                const { openAppAt } = await import("./sync.js");
+                const done = await newFromApp(ctx, runnerOf(ctx), link.app, (url) => openAppAt(ctx, url), () => bringForward(ctx.env));
+                if (!done)
+                    await pause(ctx, ctx.uiLang(), "ui.enter.close");
+                return { text: "", data: { done, action: "new" } };
+            }
+            const where = ctx.settings.home()?.value ?? configDir(ctx.env);
+            fs.mkdirSync(where, { recursive: true });
+            if (openInNewTerminal(["link", "open", linkText(link)], where, ctx.env) === false)
+                return say(ctx, "ui.link.noterminal.new");
+            return { text: "", data: { done: true, action: "new" } };
+        }
+        if (link.action !== "excerpt") {
+            // a terminal to show it in: this one, or a new window (the system started strom with none)
+            if (ctx.io.tty)
+                return inTerminal(ctx, link);
+            const copies = researchesWithId(ctx, link.tree);
+            if (!copies.length)
+                return say(ctx, "ui.link.notree", {}, { tree: link.tree });
+            const quiet = await withoutTerminal(ctx, link, copies[0].root);
+            if (quiet)
+                return quiet;
+            const opened = openInNewTerminal(["link", "open", linkText(link)], copies[0].root, ctx.env);
+            if (opened === false)
+                return link.action === "send"
+                    ? say(ctx, "ui.link.noterminal", { item: `${ui(ctx.uiLang(), "ui.more.title")} → ${ui(ctx.uiLang(), "ui.more.sync")}` })
+                    : say(ctx, "ui.link.noterminal.any", { name: copies[0].name });
+            return { text: "", data: { done: true, action: link.action, tree: copies[0].root } };
+        }
+        const got = excerptOf(ctx, link);
+        if ("file" in got) {
+            openForUser(got.file, ctx.env);
+            return { text: ctx.display(got.file), data: { done: true, action: "excerpt", file: got.file } };
+        }
+        if ("url" in got) {
+            openForUser(got.url, ctx.env);
+            return { text: got.url, data: { done: true, action: "excerpt", url: got.url } };
+        }
+        return say(ctx, got.missing === "tree" ? "ui.link.notree" : got.missing === "scan" ? "ui.link.noscan" : "ui.link.noclip", { source: link.source }, { tree: link.tree, source: link.source, clip: link.clip });
+    },
+}, {
+    path: ["link", "on"],
+    summary: "Let the Strom app start the research on this computer: register strom-research:// links for this user (the user's yes)",
+    group: "setup",
+    description: "The Strom app on this computer then sends the edited tree back with one click and opens an excerpt in full quality.\n" +
+        "For this user alone, no admin rights: macOS an applet in ~/Applications, Windows a key under HKCU, Linux a .desktop\n" +
+        "entry. The user's decision: an agent asks them (a window of the system). strom link off takes it away.",
+    run(ctx) {
+        const lang = ctx.uiLang();
+        if (linkHandlerState(ctx.env) === "ours")
+            return { text: ui(lang, "ui.link.on.done"), data: { on: true } };
+        ctx.requireHuman("Let the Strom app start strom on this computer (strom-research:// links)?", "strom link on", "links", ui(lang, "ui.setup.links"));
+        const on = registerLinks(ctx.env);
+        if (on)
+            keepAnswer(ctx, "yes");
+        return { text: ui(lang, on ? "ui.link.on.done" : "ui.link.on.failed"), data: { on }, ...(on ? {} : { exitCode: 1 }) };
+    },
+}, {
+    path: ["link", "off"],
+    summary: "Take the strom-research:// links off this computer: the Strom app no longer starts the research",
+    group: "setup",
+    run(ctx) {
+        const off = unregisterLinks(ctx.env);
+        if (off)
+            keepAnswer(ctx, "no");
+        return { text: ui(ctx.uiLang(), off ? "ui.link.off.done" : "ui.link.off.failed"), data: { on: !off }, ...(off ? {} : { exitCode: 1 }) };
+    },
+}, {
+    path: ["link", "status"],
+    summary: "Where strom-research:// links lead on this computer: to this strom, to another program, nowhere",
+    group: "setup",
+    run(ctx) {
+        const state = linkHandlerState(ctx.env);
+        const lang = ctx.uiLang();
+        return { text: lines(`${ui(lang, "ui.doc.links")}: ${ui(lang, `ui.doc.links.${state}`)}`, state === "ours" ? undefined : "→ strom link on"), data: { state } };
+    },
+});

package/dist/commands/output.js

@@ -12,6 +12,8 @@ import { resolveResearch } from "./research.js";
 import { UsageError } from "../core/errors.js";
 import { excerptSettings, planExcerpts } from "../core/excerpt.js";
 import { runGit, tracked } from "../core/git.js";
+import { Settings } from "../core/config.js";
+import { appOpensLinks } from "../core/stromapp.js";
 import { EXCERPT_QUALITIES, EXCERPT_SCOPES } from "../core/model.js";
 function findingRows(f) {
     return table(f.slice(0, 30).map((x) => [x.level === "error" ? "ERROR" : "warn", `line ${x.line}`, x.message]));
@@ -67,7 +69,11 @@ export function writeTreeGed(tree, opts) {
     const images = set && set.for !== "none"
         ? planExcerpts(tree, set.shared, { quality: set.quality, for: set.for, maxBytes: set.mb * 1024 * 1024, persons, budgetMs: opts.budgetMs })
         : undefined;
-    const result = exportGedcom(tree, { for: opts.for, stromVersion: opts.stromVersion, ...(persons ? { persons } : {}), ...(images ? { excerpts: images.of } : {}) });
+    // each excerpt's mark, for an app that asks for it in full (a strom-research:// link)
+    // an app that opens links shows what the research knows of a person too (the same version)
+    const research = opts.for === "strom" && appOpensLinks(new Settings(tree.env, {}), opts.stromVersion);
+    const clips = research && !!images;
+    const result = exportGedcom(tree, { for: opts.for, stromVersion: opts.stromVersion, ...(persons ? { persons } : {}), ...(images ? { excerpts: images.of } : {}), ...(clips ? { clips } : {}), ...(research ? { research } : {}) });
     const findings = validateGedcom(result.text, opts.for === "standard" ? { strict: true } : {});
     const file = opts.out ?? gedFile(tree, opts.for, opts.research);
     if (!hasGedErrors(findings) && !tree.dryRun) {

package/dist/commands/setup.js

@@ -20,9 +20,10 @@ import { VERSION } from "../core/tree.js";
 import { installUpdate, isNewer, knownNewerVersion, latestVersion, newerNode, newerVersion } from "../core/update.js";
 import { desktopDir } from "../core/paths.js";
 import { planMove } from "../core/relocate.js";
-import { researchUrl, stromAppUrl, stromAppState } from "../core/stromapp.js";
+import { appOpensLinks, researchUrl, stromAppUrl, stromAppState } from "../core/stromapp.js";
 import { isInstalled } from "../agents/global.js";
-import { shortcutName } from "../cli/wizard.js";
+import { offerLinks, shortcutName } from "../cli/wizard.js";
+import { linkHandlerState } from "../core/links.js";
 import { globalTargets, installGlobal } from "../agents/global.js";
 import { ui } from "../cli/ui.js";
 import { PERMISSION_LEVELS } from "../core/config.js";
@@ -225,6 +226,14 @@ function diagnose(ctx) {
         add("shortcut", "warn", t("ui.doc.none"), FIX, "shortcut");
     const app = stromAppState(ctx.settings);
     add("app", "ok", t(`ui.doc.app.${app}`), app === "unknown" ? FIX : undefined, app === "unknown" ? "app" : undefined);
+    // …and whether it may start the research here (strom-research:// links): only while the app is wanted
+    if (app !== "no" && appOpensLinks(ctx.settings)) {
+        const links = linkHandlerState(ctx.env);
+        if (links === "ours")
+            add("links", "ok", t("ui.doc.links.ours"));
+        else
+            add("links", "warn", t(`ui.doc.links.${links}`), FIX, "links");
+    }
     if (ctx.hasTree()) {
         const tr = ctx.tree();
         const errs = check(tr).filter((f) => f.level === "error").length + verifyFull(tr).findings.filter((f) => f.level === "error").length;
@@ -257,6 +266,8 @@ async function repair(ctx, checks, out) {
         for (const f of createShortcut(shortcutName(lang), ctx.env))
             out(ui(lang, "ui.setup.shortcut.done", { file: ctx.display(f) }));
     }
+    if (todo.has("links") && person)
+        await offerLinks(ctx, lang);
     if (todo.has("app") && person && (await ctx.confirm(ui(lang, "ui.fix.app"), false))) {
         openForUser(stromAppUrl(ctx.settings), ctx.env);
         out(ui(lang, "ui.app.install"));

package/dist/commands/start.js

@@ -18,7 +18,8 @@ import { DESKTOP_APPS, agentsHere, whereToTalk } from "../core/apps.js";
 import { assertIntact } from "../core/integrity.js";
 import { treeBrowserConnectors } from "../core/connector.js";
 import { browserNote } from "./connectors.js";
-import { appOpensResearch, importAppUrl, installedStromApp, liveAppUrl, noticeStromApp, STROM_APP_URL, stromAppUrl } from "../core/stromapp.js";
+import { offerLinks } from "../cli/wizard.js";
+import { appOpensLinks, appOpensResearch, importAppUrl, installedStromApp, liveAppUrl, noticeStromApp, STROM_APP_URL, stromAppUrl } from "../core/stromapp.js";
 import { liveRunning, serveLive, startLive, stopLive } from "../core/live.js";
 import { openForUser } from "../core/open.js";
 import { createShortcut, openInNewTerminal } from "../core/shortcut.js";
@@ -193,7 +194,7 @@ register({
         { name: "images", type: "boolean", description: "each entry with its image (the default; kept for older scripts)" },
     ],
     examples: ["strom app", "strom app --live", "strom app install"],
-    run(ctx, { opts }) {
+    async run(ctx, { opts }) {
         const lang = ctx.uiLang();
         const root = appOpensResearch(ctx.settings) ? ctx.locateTree() : undefined;
         if (root) {
@@ -217,6 +218,9 @@ register({
             const webApp = installed?.appId && installed.browser ? { browser: installed.browser, appId: installed.appId, ...(installed.profile ? { profile: installed.profile } : {}) } : undefined;
             const browser = chromiumBrowser(ctx.env);
             if (webApp || browser) {
+                // The first time a person opens the research in an app that opens links: may it start the research here? (once)
+                if (ctx.interactive && !isAgent(ctx.env) && appOpensLinks(ctx.settings, ctx.settings.stromVersion(tree.config)) && ctx.settings.config.links === undefined)
+                    await offerLinks(ctx, lang, { ask: false });
                 // The bridge serves the tree's GEDCOM to the app; it ends by itself when nobody asks it anything.
                 const info = startLive(root, ctx.env, { current: true });
                 if (!info)

package/dist/commands/story.js

@@ -4,7 +4,7 @@
 import fs from "node:fs";
 import { register } from "../cli/registry.js";
 import { lines } from "../cli/format.js";
-import { setStory, findEventOwner } from "../core/actions.js";
+import { approveStory, setStory, findEventOwner } from "../core/actions.js";
 import { UsageError } from "../core/errors.js";
 import { csvOpt, normId, textOpt } from "../core/records.js";
 import { resolvePerson } from "../core/people.js";
@@ -43,6 +43,22 @@ register({
         const missing = rec.story.facts.length === 0 ? "note: no --fact given — say which facts the story rests on" : undefined;
         return { text: lines(...tree.written.map((o) => o.summary), tree.dryRun ? "(dry run — nothing written)" : undefined, missing), data: { story: rec.story } };
     },
+}, {
+    path: ["story", "approve"],
+    summary: "The user approved the story as it is: no longer a draft",
+    group: "people",
+    tree: true,
+    writes: true,
+    description: "Only on the user's word (they read it and said it is right): the text stays, the draft becomes the story of the family book.",
+    args: [{ name: "who", description: "person (ID or name) or family (F…)", required: true }],
+    examples: ["strom story approve P0001"],
+    run(ctx, { args }) {
+        const tree = ctx.tree();
+        const id = owner(tree, args[0]);
+        const was = tree.get(id)?.story?.status;
+        const rec = approveStory(tree, id);
+        return { text: was === "final" ? `${id} story was approved already` : lines(...tree.written.map((o) => o.summary)), data: { story: rec.story } };
+    },
 }, {
     path: ["story", "show"],
     summary: "The story of a person or a couple, with the facts it rests on",

package/dist/commands/sync.js

@@ -53,6 +53,13 @@ function planText(tree, plan, incoming, file, lang, edits) {
         return ui(lang, "ui.sync.nothing", { file: path.basename(file) });
     return lines(ui(lang, "ui.sync.title", { file: path.basename(file), n: plan.changes.length }), plan.base ? ui(lang, "ui.sync.base", { head: plan.head.slice(0, 8) }) : ui(lang, plan.head ? "ui.sync.headmissing" : "ui.sync.nobase", { head: plan.head?.slice(0, 8) ?? "" }), plan.partial ? ui(lang, "ui.sync.partial") : undefined, plan.identity.strangers.length ? ui(lang, "ui.sync.strangers", { ids: plan.identity.strangers.join(", ") }) : undefined, "", ...plan.changes.map((c) => `  ${changeLine(tree, c, incoming, lang)}`), "", ui(lang, "ui.sync.edits", { mode: ui(lang, edits === "user" ? "ui.sync.mode.user" : "ui.sync.mode.conflict") }), ui(lang, "ui.sync.next", { file: shown }));
 }
+/** The Strom app at this address: installed from a Chromium browser first, else in such a browser's tab (never Safari: it cannot reach the bridge). */
+export function openAppAt(ctx, url) {
+    const installed = installedStromApp(ctx.env, process.platform, stromAppUrl(ctx.settings));
+    const webApp = installed?.appId && installed.browser ? { browser: installed.browser, appId: installed.appId, ...(installed.profile ? { profile: installed.profile } : {}) } : undefined;
+    const browser = chromiumBrowser(ctx.env);
+    return Boolean((webApp && openWebApp(webApp, url, ctx.env)) || (browser && openInBrowser(browser, url, ctx.env)));
+}
 /**
  * The Strom app sends the tree itself: the bridge started, the app opened with ?send= (installed from a Chromium
  * browser first, else in such a browser's tab), and the tree waited for. The file it came as, or what to do instead.
@@ -64,13 +71,10 @@ async function fromApp(ctx, root, lang) {
     if (!info)
         throw new StromError("the bridge did not start", { hint: "strom live serve shows why" });
     const url = sendAppUrl(info.url, ctx.settings);
-    const installed = installedStromApp(ctx.env, process.platform, stromAppUrl(ctx.settings));
-    const webApp = installed?.appId && installed.browser ? { browser: installed.browser, appId: installed.appId, ...(installed.profile ? { profile: installed.profile } : {}) } : undefined;
-    const browser = chromiumBrowser(ctx.env);
     const since = Date.now();
-    const opened = (webApp && openWebApp(webApp, url, ctx.env)) || (browser && openInBrowser(browser, url, ctx.env));
+    const opened = openAppAt(ctx, url);
     const minutes = Math.max(1, Math.round(Number(ctx.env.STROM_SYNC_WAIT_MS ?? 10 * 60_000) / 60_000));
-    ctx.io.stderr(`${opened ? ui(lang, "ui.sync.wait", { min: minutes }) : ui(lang, "ui.app.url", { url })}\n`);
+    ctx.io.stderr(`${opened ? `${ui(lang, "ui.sync.wait", { min: minutes })}\n${ui(lang, "ui.sync.wait.open", { url })}` : ui(lang, "ui.app.url", { url })}\n`);
     const until = since + Number(ctx.env.STROM_SYNC_WAIT_MS ?? 10 * 60_000);
     while (Date.now() < until) {
         const file = receivedSince(root, since);
@@ -84,6 +88,14 @@ async function fromApp(ctx, root, lang) {
     }
     return { text: ui(lang, "ui.sync.waited", { min: minutes }) };
 }
+/** A family tree file without the images written into it (data: URLs): a GEDCOM's FILE with its CONC lines, a JSON's strings. */
+export function withoutImages(text) {
+    const left = (bytes) => `[image left out, ${Math.round(bytes / 1024)} kB]`;
+    // GEDCOM: n FILE data:… and the n+1 CONC/CONT lines that go on with it
+    const ged = text.replace(/^(\d+) FILE data:[^\r\n]*(?:\r?\n(?:\d+) CON[CT] [^\r\n]*)*/gm, (m, level) => `${level} FILE ${left(m.length)}`);
+    // JSON: "data:image/…;base64,…"
+    return ged.replace(/"data:image\/[^"]*"/g, (m) => `"${left(m.length)}"`);
+}
 function numbers(v, max) {
     if (v === undefined)
         return undefined;
@@ -180,7 +192,9 @@ register({
             if (stored) {
                 tree.remember(path.join(tree.root, stored));
                 fs.mkdirSync(path.join(tree.root, "inputs"), { recursive: true });
-                fs.copyFileSync(file, path.join(tree.root, stored));
+                // kept as the document the source cites — without the images in it (the research's own excerpts, back from
+                // the app: megabytes in the history for nothing)
+                fs.writeFileSync(path.join(tree.root, stored), withoutImages(fs.readFileSync(file, "utf8")));
             }
             input = create(tree, "input", { name: path.basename(file), ...(stored ? { file: stored } : {}), sha, size, mime: mimeOf(file), from: ctx.display(file), kind: "tree", state: "processed" }, (iid) => `+${iid} input tree "${truncate(path.basename(file), 50)}" (sync)`);
             const day = humanDay(now(), lang);

package/dist/core/actions.js

@@ -850,3 +850,18 @@ export function setStory(tree, id, input) {
         return updated;
     });
 }
+/** The user approved the story as it is: no longer a draft (the text stays). */
+export function approveStory(tree, id) {
+    return tree.withTreeLock(() => {
+        const rec = tree.get(id);
+        if (!rec || (rec.type !== "person" && rec.type !== "family"))
+            throw new UsageError(`no person or family ${id}`);
+        if (!rec.story)
+            throw new UsageError(`${id} has no story yet`, { hint: `strom story set ${id} --text @file --fact E…` });
+        if (rec.story.status === "final")
+            return rec;
+        const updated = { ...rec, story: { ...rec.story, status: "final" }, updated: now() };
+        tree.put(updated, { op: "story.approve", targets: [id], summary: `${id} story approved` });
+        return updated;
+    });
+}

package/dist/core/dialog.js

@@ -59,3 +59,28 @@ export function systemDialog(text, env, platform = process.platform) {
     }
     return undefined;
 }
+/**
+ * Say something in a window (one button): what a link from the Strom app could not do, with no terminal to say it
+ * in. False when this computer cannot show one.
+ */
+export function systemNotice(title, message, ok, env, platform = process.platform) {
+    if (env.STROM_NO_DIALOG === "1")
+        return false;
+    const run = (cmd, args) => spawnSync(cmd, args, { encoding: "utf8", timeout: (WAIT_SECONDS + 10) * 1000, windowsHide: false, env: env });
+    if (platform === "darwin") {
+        const script = `display dialog ${appleString(message)} with title ${appleString(title)} buttons {${appleString(ok)}} default button ${appleString(ok)} with icon note giving up after ${WAIT_SECONDS}`;
+        return !run("osascript", ["-e", script]).error;
+    }
+    if (platform === "win32") {
+        const ps = `Add-Type -AssemblyName PresentationFramework; [void][System.Windows.MessageBox]::Show(${psString(message)}, ${psString(title)}, 'OK', 'Information', 'OK', 'DefaultDesktopOnly')`;
+        const r = run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", ps]);
+        return !r.error && r.status === 0;
+    }
+    if (!env.DISPLAY && !env.WAYLAND_DISPLAY)
+        return false;
+    if (which("zenity", env))
+        return !run("zenity", ["--info", "--title", title, "--text", message, "--timeout", String(WAIT_SECONDS)]).error;
+    if (which("kdialog", env))
+        return !run("kdialog", ["--title", title, "--msgbox", message]).error;
+    return false;
+}