parawatch 0.2.0 → 0.3.1

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

package/dist/core/store.js

@@ -1,8 +1,9 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { SCHEMA_VERSION } from "./types.js";
-/** Directory holding all parawatch state for this user. */
+import { UserError } from "./errors.js";
+import { STORE_FORMAT } from "./types.js";
+/** Directory holding all parawatch state for this user on this machine. */
 export function homeDir() {
     const explicit = process.env.PARAWATCH_HOME;
     if (explicit)
@@ -10,20 +11,109 @@ export function homeDir() {
     const xdg = process.env.XDG_STATE_HOME || path.join(os.homedir(), ".local", "state");
     return path.join(xdg, "parawatch");
 }
-export function eventsPath() {
-    return path.join(homeDir(), "events.jsonl");
+export function configPath() {
+    return path.join(homeDir(), "config.json");
+}
+export function readConfig() {
+    try {
+        const raw = JSON.parse(fs.readFileSync(configPath(), "utf8"));
+        return raw && typeof raw === "object" ? raw : {};
+    }
+    catch {
+        return {};
+    }
 }
-function ensureHome() {
+export function writeConfig(c) {
     fs.mkdirSync(homeDir(), { recursive: true });
+    const tmp = `${configPath()}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(c, null, 2) + "\n");
+    fs.renameSync(tmp, configPath());
+}
+export function expandHome(p) {
+    return p === "~" ? os.homedir() : p.startsWith("~/") || p.startsWith("~\\") ? path.join(os.homedir(), p.slice(2)) : p;
+}
+export const DEVICE_NAME = /^[a-z0-9][a-z0-9-]{0,31}$/;
+/** A device name made from the host name: lower case, letters, digits and dashes. */
+export function defaultDevice(host = os.hostname()) {
+    const short = host.split(".")[0] ?? "";
+    const clean = short.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32);
+    return DEVICE_NAME.test(clean) ? clean : "this";
+}
+/** The name this machine writes under. */
+export function deviceName() {
+    const env = process.env.PARAWATCH_DEVICE?.trim();
+    if (env)
+        return env;
+    const c = readConfig().device;
+    return typeof c === "string" && DEVICE_NAME.test(c) ? c : defaultDevice();
+}
+/**
+ * The shared folder this machine writes its own log into, when set. Something outside parawatch
+ * (Syncthing, a cloud folder) carries that folder between machines.
+ */
+export function sharedDir() {
+    const env = process.env.PARAWATCH_SHARED?.trim();
+    if (env)
+        return path.resolve(expandHome(env));
+    const d = readConfig().sync?.dir;
+    return typeof d === "string" && d.trim() ? path.resolve(expandHome(d.trim())) : undefined;
+}
+// ------------------------------------------------------------------ files
+/** Where the event logs live: the home alone, or `events/` in the shared folder. */
+export function eventsDir() {
+    const shared = sharedDir();
+    return shared ? path.join(shared, "events") : homeDir();
+}
+/** The one file this machine appends to. */
+export function eventsPath() {
+    const shared = sharedDir();
+    return shared ? path.join(shared, "events", `${deviceName()}.jsonl`) : path.join(homeDir(), "events.jsonl");
+}
+/** A device log: `<device>.jsonl`. Sync tools' temp and conflict copies never match. */
+const DEVICE_FILE = /^([a-z0-9][a-z0-9-]{0,31})\.jsonl$/;
+/** Every log to read: one per device in a shared folder, or the single local file. */
+export function eventFiles() {
+    const shared = sharedDir();
+    if (!shared)
+        return [{ device: deviceName(), file: eventsPath() }];
+    const dir = path.join(shared, "events");
+    const me = deviceName();
+    const out = [];
+    let names = [];
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        // nothing shared yet
+    }
+    for (const n of names.sort()) {
+        const m = DEVICE_FILE.exec(n);
+        if (m)
+            out.push({ device: m[1], file: path.join(dir, n) });
+    }
+    if (!out.some((f) => f.device === me))
+        out.push({ device: me, file: eventsPath() });
+    return out.sort((a, b) => a.device.localeCompare(b.device));
 }
+/** Where pasted attachments go: inside the shared folder when there is one, so every machine has them. */
+export function attachmentsDir() {
+    return path.join(sharedDir() ?? homeDir(), "attachments");
+}
+function ensureDir(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+// ------------------------------------------------------------------ lock
 const LOCK_STALE_MS = 30_000;
 const LOCK_WAIT_MS = 10_000;
 function sleepSync(ms) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
-/** Run fn while holding an exclusive lock file. Several agents may write at once. */
+/**
+ * Run fn while holding an exclusive lock file. Several agents on this machine may write at once.
+ * The lock is local: each machine only ever writes its own log, so machines never share one.
+ */
 export function withLock(fn) {
-    ensureHome();
+    ensureDir(homeDir());
     const lock = path.join(homeDir(), "lock");
     const started = Date.now();
     let fd;
@@ -59,28 +149,64 @@ export function withLock(fn) {
         fs.rmSync(lock, { force: true });
     }
 }
-/** Parse every event line. Broken lines are skipped, not fatal. */
-export function readEvents() {
+// ------------------------------------------------------------------ reading
+function readFileEvents(f) {
     let text;
     try {
-        text = fs.readFileSync(eventsPath(), "utf8");
+        text = fs.readFileSync(f.file, "utf8");
     }
     catch (err) {
         if (err.code === "ENOENT")
             return [];
         throw err;
     }
-    return parseEventLines(text);
+    return parseEventLines(text, f.device);
+}
+/**
+ * Every event, from every machine, in time order. Each machine's own order is kept as written;
+ * between machines the clock decides, then the device name, so every machine sees the same order.
+ */
+export function readEvents() {
+    const lists = eventFiles().map(readFileEvents).filter((l) => l.length);
+    if (lists.length <= 1)
+        return lists[0] ?? [];
+    return mergeLogs(lists);
+}
+/** Merge per-device logs, each already in its own order, into one. */
+export function mergeLogs(lists) {
+    const at = lists.map(() => 0);
+    const out = [];
+    for (;;) {
+        let pick = -1;
+        for (let i = 0; i < lists.length; i++) {
+            const ev = lists[i][at[i]];
+            if (!ev)
+                continue;
+            if (pick < 0) {
+                pick = i;
+                continue;
+            }
+            const best = lists[pick][at[pick]];
+            if (ev.ts < best.ts || (ev.ts === best.ts && (ev.dev ?? "") < (best.dev ?? "")))
+                pick = i;
+        }
+        if (pick < 0)
+            return out;
+        out.push(lists[pick][at[pick]++]);
+    }
 }
-export function parseEventLines(text) {
+export function parseEventLines(text, device) {
     const out = [];
     for (const line of text.split("\n")) {
         if (!line.trim())
             continue;
         try {
             const ev = JSON.parse(line);
-            if (typeof ev.seq === "number" && typeof ev.type === "string")
-                out.push(ev);
+            if (typeof ev.seq !== "number" || typeof ev.type !== "string")
+                continue;
+            if (device)
+                ev.dev = device;
+            out.push(ev);
         }
         catch {
             // a torn or hand-edited line; keep going
@@ -88,40 +214,107 @@ export function parseEventLines(text) {
     }
     return out;
 }
+// ------------------------------------------------------------------ writing
 /** Append one event. `build` sees the current events so it can pick ids under the lock. */
 export function appendEvent(build) {
     return withLock(() => appendLocked((events) => [build(events)])[0]);
 }
+/** The newest event format in the log. A reader may skip what it does not know; a writer may not. */
+export function storeFormat(events) {
+    let v = 0;
+    for (const e of events)
+        if (typeof e.v === "number" && e.v > v)
+            v = e.v;
+    return v;
+}
+/**
+ * The format this machine writes. A log kept on one machine stays at format 1, which every
+ * earlier parawatch reads and writes. A shared folder writes format 2.
+ */
+export function writeFormat() {
+    return sharedDir() ? 2 : 1;
+}
 /** Append events while already holding the lock (inside `withLock`). */
 export function appendLocked(build) {
     const events = readEvents();
-    let seq = events[events.length - 1]?.seq ?? 0;
+    const format = storeFormat(events);
+    if (format > STORE_FORMAT) {
+        throw new UserError(`${eventsDir()} was written by a newer parawatch (format ${format}; this one knows ${STORE_FORMAT}). Update this copy before it writes: npm i -g parawatch@latest, or update the app.`);
+    }
+    const me = deviceName();
+    const own = sharedDir() ? events.filter((e) => e.dev === me) : events;
+    let seq = 0;
+    for (const e of own)
+        if (e.seq > seq)
+            seq = e.seq;
     const ts = new Date().toISOString();
-    const out = build(events).map((body) => ({ v: SCHEMA_VERSION, seq: ++seq, ts, ...body }));
-    if (out.length)
+    const v = writeFormat();
+    const out = build(events).map((body) => ({ v, seq: ++seq, ts, ...body }));
+    if (out.length) {
+        ensureDir(path.dirname(eventsPath()));
         fs.appendFileSync(eventsPath(), out.map((e) => JSON.stringify(e) + "\n").join(""));
+        for (const e of out)
+            e.dev = me;
+    }
     return out;
 }
+/** Whether an event comes after a position. */
+export function isAfter(ev, pos) {
+    return ev.seq > (pos[ev.dev ?? deviceName()] ?? 0);
+}
+/** A position moved past these events. */
+export function advance(pos, events) {
+    const next = { ...pos };
+    const me = deviceName();
+    for (const e of events) {
+        const d = e.dev ?? me;
+        if (e.seq > (next[d] ?? 0))
+            next[d] = e.seq;
+    }
+    return next;
+}
+/** The position at the end of these events. */
+export function endOf(events) {
+    return advance({}, events);
+}
+/** A number given on the command line: the same seq in every device's log. */
+export function everywhere(seq, events) {
+    const pos = { [deviceName()]: seq };
+    for (const e of events)
+        if (e.dev)
+            pos[e.dev] = seq;
+    return pos;
+}
 const CURSOR_NAME = /^[A-Za-z0-9._-]+$/;
 function cursorPath(name) {
     if (!CURSOR_NAME.test(name))
         throw new Error(`parawatch: bad consumer name "${name}"`);
     return path.join(homeDir(), "cursors", `${name}.json`);
 }
+/**
+ * A cursor file holds `seq` (this machine's log, as every version wrote it) and `pos` (every
+ * device). Cursors stay on the machine: two machines never share a reader.
+ */
 export function readCursor(name) {
     try {
         const data = JSON.parse(fs.readFileSync(cursorPath(name), "utf8"));
-        return typeof data.seq === "number" ? data.seq : 0;
+        const me = deviceName();
+        const pos = data.pos && typeof data.pos === "object" && sharedDir() ? { ...data.pos } : {};
+        if (typeof data.seq === "number" && pos[me] === undefined)
+            pos[me] = data.seq;
+        return pos;
     }
     catch {
-        return 0;
+        return {};
     }
 }
-export function writeCursor(name, seq) {
+export function writeCursor(name, pos) {
     const file = cursorPath(name);
-    fs.mkdirSync(path.dirname(file), { recursive: true });
+    ensureDir(path.dirname(file));
     const tmp = `${file}.${process.pid}.tmp`;
-    fs.writeFileSync(tmp, JSON.stringify({ seq, at: new Date().toISOString() }) + "\n");
+    const seq = pos[deviceName()] ?? 0;
+    const body = sharedDir() ? { seq, pos, at: new Date().toISOString() } : { seq, at: new Date().toISOString() };
+    fs.writeFileSync(tmp, JSON.stringify(body) + "\n");
     fs.renameSync(tmp, file);
 }
 //# sourceMappingURL=store.js.map