parawatch 0.2.1 → 0.3.1

package/dist/core/ops.js

@@ -1,10 +1,19 @@
 import fs from "node:fs";
 import path from "node:path";
 import { UserError } from "./errors.js";
-import { appendEvent, eventsPath, homeDir, readCursor, readEvents, writeCursor } from "./store.js";
-import { fold, nextId } from "./state.js";
+import { advance, appendEvent, deviceName, eventsDir, homeDir, isAfter, readCursor, readEvents, sharedDir, writeCursor } from "./store.js";
+import { findId, fold, nextId } from "./state.js";
+import { pathMap } from "./sync.js";
 import { CARD_KINDS, HUMAN, PR_CHANGES } from "./types.js";
 export { UserError };
+/** Current state, with other machines' paths made local. */
+export function readState(events = readEvents()) {
+    return fold(events, pathMap());
+}
+/** The machine name ids carry, when the log is shared. */
+function idDevice() {
+    return sharedDir() ? deviceName() : undefined;
+}
 function cleanList(xs) {
     const out = (xs ?? []).map((x) => x.trim()).filter(Boolean);
     return out.length ? out : undefined;
@@ -22,7 +31,7 @@ export function addProject(name, paths) {
     }));
 }
 export function removeProject(name) {
-    const s = fold(readEvents());
+    const s = readState();
     if (!s.projects.has(name))
         throw new UserError(`no project named "${name}"`);
     appendEvent(() => ({ type: "project.remove", name }));
@@ -80,7 +89,7 @@ export function openCard(input) {
     const since = input.since?.trim() ? parseWhen(input.since) : undefined;
     let id = "";
     appendEvent((events) => {
-        id = nextId(events, "c");
+        id = nextId(events, "c", idDevice());
         const session = input.session?.trim() || undefined;
         const from = input.from?.trim() || sessionTitle(fold(events).claims, session);
         return {
@@ -105,19 +114,31 @@ export function openCard(input) {
             },
         };
     });
-    const card = fold(readEvents()).cards.get(id);
+    const card = readState().cards.get(id);
     if (!card)
         throw new Error("card vanished right after it was written");
     return card;
 }
+/** A card by id; a shared id may leave out its machine (`c3` for `pc-c3`). */
+export function findCard(state, id) {
+    const k = findId(state.cards, id);
+    return k ? state.cards.get(k) : undefined;
+}
 function requireCard(id) {
-    const card = fold(readEvents()).cards.get(id);
+    const card = findCard(readState(), id);
     if (!card)
         throw new UserError(`no card "${id}"`);
     return card;
 }
+function requireRun(id) {
+    const k = findId(readState().runs, id);
+    if (!k)
+        throw new UserError(`no declared run "${id}"`);
+    return k;
+}
 export function answerCard(id, a) {
     const card = requireCard(id);
+    id = card.id;
     if (card.status === "closed")
         throw new UserError(`card ${id} is already closed`);
     if (a.choice === undefined && !a.comment?.trim() && !cleanList(a.attach)) {
@@ -129,23 +150,26 @@ export function answerCard(id, a) {
             throw new UserError(n ? `--choice must be between 1 and ${n}` : `card ${id} has no options`);
         }
     }
-    appendEvent(() => ({
+    const shared = !!sharedDir();
+    appendEvent((events) => ({
         type: "card.answer",
         card: id,
         by: a.by || HUMAN,
         choice: a.choice,
         comment: a.comment?.trim() || undefined,
         attach: absPaths(a.attach),
+        // what this machine knew when answering, so a crossing answer from another machine shows
+        seen: shared ? events.filter((e) => e.type === "card.answer" && e.card === id).length : undefined,
     }));
 }
 export function commentCard(id, text, by) {
-    requireCard(id);
+    id = requireCard(id).id;
     if (!text.trim())
         throw new UserError("a comment needs text");
     appendEvent(() => ({ type: "card.comment", card: id, by, text: text.trim() }));
 }
 export function editCard(id, set) {
-    requireCard(id);
+    id = requireCard(id).id;
     const clean = {};
     if (set.kind !== undefined)
         clean.kind = checkKind(set.kind);
@@ -175,7 +199,7 @@ export function closeCard(id, note) {
     const card = requireCard(id);
     if (card.status === "closed")
         return;
-    appendEvent(() => ({ type: "card.close", card: id, note: note?.trim() || undefined }));
+    appendEvent(() => ({ type: "card.close", card: card.id, note: note?.trim() || undefined }));
 }
 export function startRun(r) {
     if (r.heartbeat !== undefined && (!Number.isFinite(r.heartbeat) || r.heartbeat <= 0))
@@ -183,25 +207,22 @@ export function startRun(r) {
     const log = r.log?.trim() ? path.resolve(r.log) : undefined;
     let id = "";
     appendEvent((events) => {
-        id = nextId(events, "r");
+        id = nextId(events, "r", idDevice());
         return { type: "run.start", run: { id, project: r.project, task: r.task, title: r.title, parent: r.parent, heartbeat: r.heartbeat, log } };
     });
     return id;
 }
 export function noteRun(id, text) {
-    if (!fold(readEvents()).runs.has(id))
-        throw new UserError(`no declared run "${id}"`);
-    appendEvent(() => ({ type: "run.note", run: id, text }));
+    const run = requireRun(id);
+    appendEvent(() => ({ type: "run.note", run, text }));
 }
 export function beatRun(id) {
-    if (!fold(readEvents()).runs.has(id))
-        throw new UserError(`no declared run "${id}"`);
-    appendEvent(() => ({ type: "run.beat", run: id }));
+    const run = requireRun(id);
+    appendEvent(() => ({ type: "run.beat", run }));
 }
 export function endRun(id, status, note) {
-    if (!fold(readEvents()).runs.has(id))
-        throw new UserError(`no declared run "${id}"`);
-    appendEvent(() => ({ type: "run.end", run: id, status, note }));
+    const run = requireRun(id);
+    appendEvent(() => ({ type: "run.end", run, status, note }));
 }
 /**
  * Say which project and task a session works on. A claim without a project keeps the session's
@@ -210,7 +231,7 @@ export function endRun(id, status, note) {
 export function claimSession(input) {
     if (input.session.length < 6)
         throw new UserError("give at least 6 characters of the session id");
-    const before = fold(readEvents()).claims.find((c) => c.session === input.session);
+    const before = readState().claims.find((c) => c.session === input.session);
     const project = input.project?.trim() || before?.project;
     if (!project)
         throw new UserError("this session has not claimed a project yet: give --project");
@@ -233,7 +254,7 @@ export function claimSession(input) {
 }
 // ---------------------------------------------------------------- pull requests
 export function linkPr(link) {
-    const claims = fold(readEvents()).claims;
+    const claims = readState().claims;
     const claim = link.session ? claims.find((c) => link.session.startsWith(c.session)) : undefined;
     const project = link.project?.trim() || claim?.project;
     appendEvent(() => ({
@@ -242,7 +263,7 @@ export function linkPr(link) {
     }));
 }
 export function unlinkPr(key) {
-    if (!fold(readEvents()).prLinks.has(key))
+    if (!readState().prLinks.has(key))
         throw new UserError(`no linked pull request ${key}`);
     appendEvent(() => ({ type: "pr.unlink", pr: key }));
 }
@@ -252,26 +273,45 @@ export function prEvent(pr, change, opts = {}) {
         throw new UserError(`change must be one of ${PR_CHANGES.join(", ")}`);
     appendEvent(() => ({ type: "pr.change", pr, change: change, by: opts.by, text: opts.text?.trim() || undefined, title: opts.title, source: "external" }));
 }
+/** Two machines that both read GitHub report the same change; the later report is an echo. */
+const ECHO_MS = 30 * 60_000;
 /**
- * Human answers and comments newer than `afterSeq`, on cards that are not closed, and news on pull
- * requests linked to the project.
+ * Human answers and comments after `after` (a position, or a seq on a single machine), on cards
+ * that are not closed, and news on pull requests linked to the project. An answer given on
+ * another machine before it saw an earlier answer is kept on the card but not delivered.
  */
-export function inboxFrom(events, afterSeq, filter) {
-    const state = fold(events);
+export function inboxFrom(events, after, filter, state = readState(events)) {
+    const pos = typeof after === "number" ? { [deviceName()]: after } : after;
     const out = [];
+    const reported = new Map();
+    const answerNo = new Map();
     for (const ev of events) {
-        if (ev.seq <= afterSeq)
-            continue;
         if (ev.type === "pr.change") {
+            const k = `${ev.pr.key}|${ev.change}|${ev.text ?? ""}`;
+            const prev = reported.get(k);
+            const at = Date.parse(ev.ts);
+            reported.set(k, { dev: ev.dev, at });
+            if (prev && prev.dev !== ev.dev && at - prev.at < ECHO_MS)
+                continue;
+            if (!isAfter(ev, pos))
+                continue;
             const link = state.prLinks.get(ev.pr.key);
             if (!link || filter.card || (filter.project && link.project !== filter.project))
                 continue;
-            out.push({ seq: ev.seq, at: ev.ts, kind: "pr", by: ev.by ?? ev.source, pr: { ref: ev.pr, change: ev.change, title: ev.title, text: ev.text, project: link.project } });
+            out.push({ seq: ev.seq, dev: ev.dev, at: ev.ts, kind: "pr", by: ev.by ?? ev.source, pr: { ref: ev.pr, change: ev.change, title: ev.title, text: ev.text, project: link.project } });
             continue;
         }
         if (ev.type !== "card.answer" && ev.type !== "card.comment")
             continue;
-        if (ev.by !== HUMAN)
+        let late = false;
+        if (ev.type === "card.answer") {
+            const n = answerNo.get(ev.card) ?? 0;
+            answerNo.set(ev.card, n + 1);
+            late = typeof ev.seen === "number" && ev.seen < n;
+        }
+        if (!isAfter(ev, pos))
+            continue;
+        if (ev.by !== HUMAN || late)
             continue;
         const card = state.cards.get(ev.card);
         if (!card || card.status === "closed")
@@ -283,6 +323,7 @@ export function inboxFrom(events, afterSeq, filter) {
         if (ev.type === "card.answer") {
             out.push({
                 seq: ev.seq,
+                dev: ev.dev,
                 at: ev.ts,
                 kind: "answer",
                 card,
@@ -294,26 +335,50 @@ export function inboxFrom(events, afterSeq, filter) {
             });
         }
         else {
-            out.push({ seq: ev.seq, at: ev.ts, kind: "comment", card, by: ev.by, comment: ev.text });
+            out.push({ seq: ev.seq, dev: ev.dev, at: ev.ts, kind: "comment", card, by: ev.by, comment: ev.text });
         }
     }
     return out;
 }
 // ---------------------------------------------------------------- listeners
+/** Waits are visible to every machine when the log is shared. */
 function listenersDir() {
-    return path.join(homeDir(), "listeners");
+    return path.join(sharedDir() ?? homeDir(), "listeners");
 }
+/** How often a wait says it is still there, and when one on another machine counts as gone. */
+const LISTENER_BEAT_MS = 60_000;
+const LISTENER_GONE_MS = 3 * LISTENER_BEAT_MS;
 /** Mark this process as waiting, so cards can say whether an answer reaches an agent at once. */
 export function startListening(l) {
-    const file = path.join(listenersDir(), `${process.pid}.json`);
+    const shared = !!sharedDir();
+    const file = path.join(listenersDir(), shared ? `${deviceName()}-${process.pid}.json` : `${process.pid}.json`);
     fs.mkdirSync(listenersDir(), { recursive: true });
-    const me = { ...l, pid: process.pid, since: new Date().toISOString() };
-    fs.writeFileSync(file, JSON.stringify(me) + "\n");
+    const me = { ...l, pid: process.pid, since: new Date().toISOString(), ...(shared ? { device: deviceName(), beat: new Date().toISOString() } : {}) };
+    const write = () => {
+        try {
+            const tmp = `${file}.tmp`;
+            fs.writeFileSync(tmp, JSON.stringify(me) + "\n");
+            fs.renameSync(tmp, file);
+        }
+        catch {
+            // the folder may be busy syncing; the next beat writes it again
+        }
+    };
+    write();
+    const timer = shared
+        ? setInterval(() => {
+            me.beat = new Date().toISOString();
+            write();
+        }, LISTENER_BEAT_MS)
+        : undefined;
+    timer?.unref();
     let done = false;
     const stop = () => {
         if (done)
             return;
         done = true;
+        if (timer)
+            clearInterval(timer);
         fs.rmSync(file, { force: true });
     };
     process.once("exit", stop);
@@ -334,8 +399,11 @@ function alive(pid) {
         return err.code === "EPERM";
     }
 }
-/** Waits running now. Files left by a process that died are removed. */
-export function listeners() {
+/**
+ * Waits running now, on this machine and (when shared) the others. Files left by a process that
+ * died here are removed; a wait on another machine counts while its beat is fresh.
+ */
+export function listeners(now = Date.now()) {
     let names;
     try {
         names = fs.readdirSync(listenersDir()).filter((f) => f.endsWith(".json"));
@@ -343,12 +411,17 @@ export function listeners() {
     catch {
         return [];
     }
+    const me = deviceName();
     const out = [];
     for (const n of names) {
         const file = path.join(listenersDir(), n);
         try {
             const l = JSON.parse(fs.readFileSync(file, "utf8"));
-            if (alive(l.pid))
+            if (l.device && l.device !== me) {
+                if (l.beat && now - Date.parse(l.beat) < LISTENER_GONE_MS)
+                    out.push(l);
+            }
+            else if (alive(l.pid))
                 out.push(l);
             else
                 fs.rmSync(file, { force: true });
@@ -366,12 +439,12 @@ export function listenersFor(card, ls) {
 export function consumerName(opts) {
     return opts.as || opts.project || (opts.card ? `card-${opts.card}` : "default");
 }
-export function readInbox(consumer, filter, advance) {
+export function readInbox(consumer, filter, move) {
     const events = readEvents();
-    const items = inboxFrom(events, readCursor(consumer), filter);
-    const last = items[items.length - 1];
-    if (advance && last)
-        writeCursor(consumer, last.seq);
+    const pos = readCursor(consumer);
+    const items = inboxFrom(events, pos, filter);
+    if (move && items.length)
+        writeCursor(consumer, advance(pos, items));
     return items;
 }
 /**
@@ -383,7 +456,7 @@ export async function waitInbox(consumer, filter, timeoutMs, pollMs = 1000) {
     let watcher;
     let wake;
     try {
-        const dir = path.dirname(eventsPath());
+        const dir = eventsDir();
         fs.mkdirSync(dir, { recursive: true });
         watcher = fs.watch(dir, () => wake?.());
     }

package/dist/core/snapshot.js

@@ -1,8 +1,7 @@
 import { prViews, keyOf, parsePrRef, readCache, githubConfig } from "./github.js";
-import { linkPr, listeners } from "./ops.js";
+import { linkPr, listeners, readState } from "./ops.js";
 import { collectRuns } from "./runs.js";
-import { fold } from "./state.js";
-import { readEvents } from "./store.js";
+import { deviceName, eventFiles, sharedDir } from "./store.js";
 import { SCHEMA_VERSION } from "./types.js";
 /**
  * `closed`: also carry the most recently closed cards, newest first, so a panel can show them
@@ -11,10 +10,10 @@ import { SCHEMA_VERSION } from "./types.js";
  * GitHub is read from the last reading only; `syncGithub` refreshes it.
  */
 export function snapshot(opts = {}) {
-    let state = fold(readEvents());
+    let state = readState();
     const runs = collectRuns(state, { sinceHours: opts.sinceHours ?? 6, project: opts.project, keepRepeats: opts.keepRepeats });
     if (linkCreatedPrs(runs, state))
-        state = fold(readEvents());
+        state = readState();
     const all = [...state.cards.values()].filter((c) => !opts.project || c.project === opts.project);
     const cards = [...all.filter((c) => c.status !== "closed"), ...recentlyClosed(all, opts.closed ?? 0)];
     quietAnsweredAsks(runs, all);
@@ -32,6 +31,7 @@ export function snapshot(opts = {}) {
         prs,
         github: { enabled, fetchedAt: cache.fetchedAt, error: cache.error },
         listeners: listeners(),
+        devices: sharedDir() ? { me: deviceName(), others: eventFiles().map((f) => f.device).filter((d) => d !== deviceName()) } : undefined,
     };
 }
 /** A pull request a session's log shows it opened belongs to that session, unless linked already. */

package/dist/core/state.js

@@ -1,23 +1,38 @@
-/** Rebuild current state from the event log. */
-export function fold(events) {
+function mapAll(xs, map, from) {
+    return xs && map ? xs.map((x) => map(x, from)) : xs;
+}
+/** Rebuild current state from the event log. `map` makes other machines' paths local. */
+export function fold(events, map) {
     const s = { projects: new Map(), cards: new Map(), runs: new Map(), claims: [], prLinks: new Map(), lastSeq: 0 };
     for (const ev of events) {
         s.lastSeq = Math.max(s.lastSeq, ev.seq);
         switch (ev.type) {
             case "project.add":
-                s.projects.set(ev.project.name, ev.project);
+                s.projects.set(ev.project.name, { ...ev.project, paths: mapAll(ev.project.paths, map, ev.dev) ?? [] });
                 break;
             case "project.remove":
                 s.projects.delete(ev.name);
                 break;
-            case "card.open":
-                s.cards.set(ev.card.id, { ...ev.card, openedAt: ev.ts, status: "open", answers: [], comments: [] });
+            case "card.open": {
+                const card = { ...ev.card, openedAt: ev.ts, status: "open", answers: [], comments: [] };
+                if (ev.v >= 2 && ev.dev)
+                    card.dev = ev.dev;
+                card.attach = mapAll(card.attach, map, ev.dev);
+                card.open = mapAll(card.open, map, ev.dev);
+                s.cards.set(ev.card.id, card);
                 break;
+            }
             case "card.answer": {
                 const c = s.cards.get(ev.card);
                 if (!c)
                     break;
-                c.answers.push({ seq: ev.seq, at: ev.ts, by: ev.by, choice: ev.choice, comment: ev.comment, attach: ev.attach });
+                const a = { seq: ev.seq, at: ev.ts, by: ev.by, choice: ev.choice, comment: ev.comment, attach: mapAll(ev.attach, map, ev.dev) };
+                if (ev.v >= 2 && ev.dev)
+                    a.dev = ev.dev;
+                // written on another machine before that machine saw an earlier answer: the earlier one stands
+                if (typeof ev.seen === "number" && ev.seen < c.answers.length)
+                    a.late = true;
+                c.answers.push(a);
                 if (c.status === "open")
                     c.status = "answered";
                 break;
@@ -93,15 +108,31 @@ export function fold(events) {
     }
     return s;
 }
-/** Next id with a prefix, counting the events that created that kind of thing. */
-export function nextId(events, prefix) {
+/**
+ * Next id with a prefix, counting the events that created that kind of thing. In a shared folder
+ * (`device` given) only that machine's own log counts and the id carries the machine's name, so
+ * two machines never pick the same id: `pc-c3`.
+ */
+export function nextId(events, prefix, device) {
     let n = 0;
     for (const ev of events) {
+        if (device && ev.dev !== device)
+            continue;
         if (prefix === "c" && ev.type === "card.open")
             n++;
         if (prefix === "r" && ev.type === "run.start")
             n++;
     }
-    return `${prefix}${n + 1}`;
+    return device ? `${device}-${prefix}${n + 1}` : `${prefix}${n + 1}`;
+}
+/**
+ * Find a card or run by id. A shared id may be given without its machine (`c3` for `pc-c3`) as
+ * long as only one machine has it; an exact id always wins.
+ */
+export function findId(map, id) {
+    if (map.has(id))
+        return id;
+    const hits = [...map.keys()].filter((k) => k.endsWith(`-${id}`));
+    return hits.length === 1 ? hits[0] : undefined;
 }
 //# sourceMappingURL=state.js.map