parawatch 0.2.1 → 0.3.2

package/dist/core/store.js

@@ -2,8 +2,8 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { UserError } from "./errors.js";
-import { SCHEMA_VERSION } from "./types.js";
-/** Directory holding all parawatch state for this user. */
+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)
@@ -11,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;
@@ -60,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);
 }
-export function parseEventLines(text) {
+/** 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, 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
@@ -89,6 +214,7 @@ 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]);
@@ -101,40 +227,94 @@ export function storeFormat(events) {
             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();
     const format = storeFormat(events);
-    if (format > SCHEMA_VERSION) {
-        throw new UserError(`${eventsPath()} was written by a newer parawatch (format ${format}; this one knows ${SCHEMA_VERSION}). Update this copy before it writes: npm i -g parawatch@latest, or update the app.`);
+    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.`);
     }
-    let seq = events[events.length - 1]?.seq ?? 0;
+    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

package/dist/core/sync.js

@@ -0,0 +1,317 @@
+/**
+ * Sharing the log between machines. Parawatch only reads and writes files in a shared folder:
+ * each machine appends to `events/<device>.jsonl` and reads them all. Moving that folder between
+ * machines is the job of a sync tool, and a sync adapter only reports how that tool is doing.
+ *
+ * Layout of the shared folder:
+ *   events/<device>.jsonl   each machine's own log; only that machine writes it
+ *   devices/<device>.json   each machine's paths, version and last sign of life
+ *   listeners/              waits running on any machine
+ *   attachments/            pasted images, so every machine can open them
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { UserError } from "./errors.js";
+import { DEVICE_NAME, configPath, deviceName, eventFiles, expandHome, homeDir, parseEventLines, readConfig, sharedDir, withLock, writeConfig, } from "./store.js";
+import { syncthingAdapter } from "./syncthing.js";
+function devicesDir(shared) {
+    return path.join(shared, "devices");
+}
+function hostPrint() {
+    return `${os.hostname()}:${os.homedir()}`;
+}
+export function readDevice(name, shared = sharedDir()) {
+    if (!shared)
+        return undefined;
+    try {
+        return JSON.parse(fs.readFileSync(path.join(devicesDir(shared), `${name}.json`), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readDevices(shared = sharedDir()) {
+    if (!shared)
+        return [];
+    let names = [];
+    try {
+        names = fs.readdirSync(devicesDir(shared)).filter((n) => /^[a-z0-9][a-z0-9-]*\.json$/.test(n));
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const n of names) {
+        const d = readDevice(n.slice(0, -5), shared);
+        if (d)
+            out.push(d);
+    }
+    return out;
+}
+const DEVICE_REFRESH_MS = 10 * 60_000;
+/** Write this machine's device file when something changed or it is getting old. */
+export function touchDevice(version, opts = {}) {
+    const shared = sharedDir();
+    if (!shared)
+        return undefined;
+    const name = deviceName();
+    const before = readDevice(name, shared);
+    const me = {
+        name,
+        platform: process.platform,
+        host: hostPrint(),
+        home: os.homedir(),
+        shared,
+        roots: { ...(before?.host === hostPrint() ? before.roots : {}), ...(opts.roots ?? {}) },
+        version: version ?? before?.version,
+        at: new Date().toISOString(),
+    };
+    if (!Object.keys(me.roots).length)
+        delete me.roots;
+    const same = before &&
+        before.host === me.host &&
+        before.shared === me.shared &&
+        before.version === me.version &&
+        JSON.stringify(before.roots ?? {}) === JSON.stringify(me.roots ?? {}) &&
+        Date.now() - Date.parse(before.at) < DEVICE_REFRESH_MS;
+    if (same && !opts.force)
+        return before;
+    try {
+        const dir = devicesDir(shared);
+        fs.mkdirSync(dir, { recursive: true });
+        const file = path.join(dir, `${name}.json`);
+        const tmp = path.join(dir, `.${name}.${process.pid}.tmp`);
+        fs.writeFileSync(tmp, JSON.stringify(me, null, 2) + "\n");
+        fs.renameSync(tmp, file);
+    }
+    catch {
+        // the shared folder may be read only for a moment; try again next time
+    }
+    return me;
+}
+// ------------------------------------------------------------------ paths
+function splitPath(p) {
+    return p.split(/[\\/]+/).filter(Boolean);
+}
+function startsWithPath(p, root, caseless) {
+    const a = splitPath(p);
+    const b = splitPath(root);
+    if (!b.length || a.length < b.length)
+        return undefined;
+    for (let i = 0; i < b.length; i++) {
+        const x = caseless ? a[i].toLowerCase() : a[i];
+        const y = caseless ? b[i].toLowerCase() : b[i];
+        if (x !== y)
+            return undefined;
+    }
+    return a.slice(b.length);
+}
+function joinOn(platform, root, rest) {
+    const p = platform === "win32" ? path.win32 : path.posix;
+    return rest.length ? p.join(root, ...rest) : root;
+}
+/**
+ * A path from another machine, as the same place on this one: under that machine's shared
+ * folder, a named root, or its home. The longest match wins; anything else is left as it is.
+ */
+export function mapPath(p, from, me) {
+    if (!from || !me || from.name === me.name || /^[a-z]+:\/\//i.test(p))
+        return p;
+    const caseless = from.platform === "win32";
+    const pairs = [[from.shared, me.shared]];
+    for (const [k, v] of Object.entries(from.roots ?? {})) {
+        const mine = me.roots?.[k];
+        if (mine)
+            pairs.push([v, mine]);
+    }
+    pairs.push([from.home, me.home]);
+    let best;
+    for (const [theirs, mine] of pairs) {
+        const rest = startsWithPath(p, theirs, caseless);
+        const len = splitPath(theirs).length;
+        if (rest && (!best || len > best.len))
+            best = { rest, root: mine, len };
+    }
+    return best ? joinOn(me.platform, best.root, best.rest) : p;
+}
+/** The path map for reading the shared log on this machine, or undefined when nothing is shared. */
+export function pathMap() {
+    const shared = sharedDir();
+    if (!shared)
+        return undefined;
+    const devices = new Map(readDevices(shared).map((d) => [d.name, d]));
+    const name = deviceName();
+    const me = devices.get(name) ?? { name, platform: process.platform, host: hostPrint(), home: os.homedir(), shared, at: "" };
+    if (devices.size <= 1)
+        return undefined;
+    return (p, from) => (from ? mapPath(p, devices.get(from), me) : p);
+}
+const CONFLICT = /\.sync-conflict-|conflicted copy|\(conflict\)|\.conflict\d*$/i;
+/** Conflict copies anywhere in the shared folder (sync tools name them in their own ways). */
+export function findConflicts(dir, depth = 3) {
+    const out = [];
+    const walk = (d, left) => {
+        let names = [];
+        try {
+            names = fs.readdirSync(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const n of names) {
+            const p = path.join(d, n.name);
+            if (CONFLICT.test(n.name))
+                out.push(p);
+            else if (n.isDirectory() && left > 0 && !n.name.startsWith(".st"))
+                walk(p, left - 1);
+        }
+    };
+    walk(dir, depth);
+    return out.sort();
+}
+/** Other machines as the shared folder shows them: their device files and their logs. */
+export function folderPeers(dir, me) {
+    const peers = new Map();
+    for (const d of readDevices(dir))
+        if (d.name !== me)
+            peers.set(d.name, { name: d.name, lastSeen: d.at, version: d.version });
+    try {
+        for (const n of fs.readdirSync(path.join(dir, "events"))) {
+            const m = /^([a-z0-9][a-z0-9-]*)\.jsonl$/.exec(n);
+            if (!m || m[1] === me)
+                continue;
+            const at = fs.statSync(path.join(dir, "events", n)).mtime.toISOString();
+            const p = peers.get(m[1]) ?? { name: m[1] };
+            if (!p.lastSeen || at > p.lastSeen)
+                p.lastSeen = at;
+            peers.set(m[1], p);
+        }
+    }
+    catch {
+        // no logs yet
+    }
+    return [...peers.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+/** Any folder something else keeps in step: a cloud drive, a network share, a git checkout. */
+export const folderAdapter = {
+    name: "folder",
+    about: "a folder kept in step by something else (a cloud drive, a network share)",
+    async status(ctx) {
+        const peers = folderPeers(ctx.dir, ctx.device);
+        const newest = peers.map((p) => p.lastSeen ?? "").sort().pop() || undefined;
+        return { adapter: "folder", dir: ctx.dir, device: ctx.device, ok: fs.existsSync(ctx.dir), lastSync: newest, peers, conflicts: findConflicts(ctx.dir) };
+    },
+};
+let registry;
+// built on first use: the Syncthing module imports helpers from this one
+function adapters() {
+    registry ??= new Map([
+        [folderAdapter.name, folderAdapter],
+        [syncthingAdapter.name, syncthingAdapter],
+    ]);
+    return registry;
+}
+/** Add an adapter (another sync tool). The name is what `sync.adapter` in config.json picks. */
+export function registerAdapter(a) {
+    adapters().set(a.name, a);
+}
+export function adapterNames() {
+    return [...adapters().keys()];
+}
+export function syncAdapter(name) {
+    return adapters().get(name ?? "folder") ?? folderAdapter;
+}
+/** How sharing is doing, or undefined when this machine keeps its log to itself. */
+export async function syncStatus(opts = {}) {
+    const dir = sharedDir();
+    if (!dir)
+        return undefined;
+    const cfg = readConfig().sync ?? {};
+    const a = syncAdapter(typeof cfg.adapter === "string" ? cfg.adapter : undefined);
+    const own = cfg[a.name];
+    const ctx = { dir, device: deviceName(), config: own && typeof own === "object" ? own : {}, fetch: opts.fetch, timeoutMs: opts.timeoutMs };
+    try {
+        return await a.status(ctx);
+    }
+    catch (err) {
+        return { adapter: a.name, dir, device: ctx.device, ok: false, peers: folderPeers(dir, ctx.device), conflicts: findConflicts(dir), error: err.message };
+    }
+}
+/** The line left in the old single-machine log, so an older parawatch refuses to write there. */
+export function movedMarker(to, seq) {
+    return JSON.stringify({ v: 2, seq, ts: new Date().toISOString(), type: "store.moved", to }) + "\n";
+}
+/**
+ * Start writing to a shared folder. This machine's log moves there as `events/<device>.jsonl`,
+ * keeping every event and seq as it was, so ids, cursors and answers stay valid. The old file is
+ * kept as a backup and replaced by a marker that makes older copies stop writing to it.
+ * Running it again with the same folder and name changes nothing.
+ */
+export function setupSync(input) {
+    const dir = path.resolve(expandHome(input.dir.trim()));
+    const cfg = readConfig();
+    const device = (input.device ?? (typeof cfg.device === "string" ? cfg.device : undefined) ?? deviceName()).trim();
+    if (!DEVICE_NAME.test(device))
+        throw new UserError(`device name "${device}" may only use a-z, 0-9 and -, up to 32 characters`);
+    const adapter = input.adapter ?? (typeof cfg.sync?.adapter === "string" ? cfg.sync.adapter : "folder");
+    if (!adapters().has(adapter))
+        throw new UserError(`unknown sync adapter "${adapter}" (known: ${adapterNames().join(", ")})`);
+    const current = sharedDir();
+    if (current && current !== dir)
+        throw new UserError(`this machine already shares ${current}. Moving to another folder is not supported yet.`);
+    return withLock(() => {
+        fs.mkdirSync(path.join(dir, "events"), { recursive: true });
+        const target = path.join(dir, "events", `${device}.jsonl`);
+        const theirs = readDevice(device, dir);
+        if (theirs && theirs.host !== hostPrint()) {
+            throw new UserError(`another machine (${theirs.host}) already writes as "${device}" in ${dir}. Pick another name with --device.`);
+        }
+        const legacy = path.join(homeDir(), "events.jsonl");
+        let moved = 0;
+        let backup;
+        const text = fs.existsSync(legacy) ? fs.readFileSync(legacy, "utf8") : "";
+        const events = parseEventLines(text).filter((e) => e.type !== "store.moved");
+        if (events.length) {
+            const already = fs.existsSync(target) ? parseEventLines(fs.readFileSync(target, "utf8")) : [];
+            if (already.length)
+                throw new UserError(`${target} already has ${already.length} events and this machine has its own log too. Pick another --device name.`);
+            const tmp = path.join(dir, "events", `.${device}.${process.pid}.tmp`);
+            fs.writeFileSync(tmp, events.map((e) => JSON.stringify(e) + "\n").join(""));
+            fs.renameSync(tmp, target);
+            backup = `${legacy}.before-sync`;
+            fs.copyFileSync(legacy, backup);
+            fs.writeFileSync(legacy, movedMarker(target, (events[events.length - 1]?.seq ?? 0) + 1));
+            moved = events.length;
+        }
+        const sync = { ...(cfg.sync ?? {}), dir: input.dir.trim().startsWith("~") ? input.dir.trim() : dir, adapter };
+        writeConfig({ ...cfg, device, sync });
+        touchDevice(input.version, { force: true });
+        const others = eventFiles()
+            .map((f) => f.device)
+            .filter((d) => d !== device);
+        return { dir, device, adapter, moved, backup, others };
+    });
+}
+/** Name a folder on this machine so paths under it map to the same name on other machines. */
+export function setRoot(name, folder, version) {
+    if (!sharedDir())
+        throw new UserError("this machine does not share its log yet: run `parawatch sync setup <folder>` first");
+    if (!/^[a-z0-9][a-z0-9_-]{0,31}$/i.test(name) || name === "home" || name === "shared")
+        throw new UserError(`root name "${name}" may use letters, digits, _ and -, and cannot be home or shared`);
+    const before = readDevice(deviceName());
+    const roots = { ...(before?.roots ?? {}) };
+    if (folder)
+        roots[name] = path.resolve(expandHome(folder));
+    else
+        delete roots[name];
+    const shared = sharedDir();
+    const me = { name: deviceName(), platform: process.platform, host: hostPrint(), home: os.homedir(), shared, roots, version: version ?? before?.version, at: new Date().toISOString() };
+    if (!Object.keys(roots).length)
+        delete me.roots;
+    fs.mkdirSync(devicesDir(shared), { recursive: true });
+    fs.writeFileSync(path.join(devicesDir(shared), `${me.name}.json`), JSON.stringify(me, null, 2) + "\n");
+    return me;
+}
+export { configPath };
+//# sourceMappingURL=sync.js.map