parawatch 0.3.15 → 0.3.17

package/dist/core/relay.js

@@ -0,0 +1,474 @@
+/**
+ * Keeping the shared folder in step through a relay server (src/relay/server.ts) instead of a sync
+ * tool. The folder stays where it is on every machine; this mirror uploads what changed here and
+ * writes what changed elsewhere, file by file.
+ *
+ * Everything is sealed on the machine with the space key, which the server never sees: a file's
+ * path and its bytes go in one AES-256-GCM box, and the server knows it only by a keyed hash of the
+ * path. The server sees how many files there are, their sizes and when they change.
+ *
+ * The join code carries the server, the space, its token and the key. Anyone with it can read and
+ * write the space, so it is passed between one's own machines by hand.
+ */
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { UserError } from "./errors.js";
+import { homeDir, readConfig } from "./store.js";
+import { findConflicts, folderPeers } from "./sync.js";
+const CODE_PREFIX = "pwr1.";
+/** Files bigger than this stay on their machine (a long screen recording, say). */
+export const MIRROR_MAX_FILE = 200 * 1024 * 1024;
+function keysOf(key) {
+    const raw = Buffer.from(key, "base64url");
+    if (raw.length !== 32)
+        throw new UserError("the relay key is not 32 bytes; join again with a fresh code");
+    const derive = (info) => Buffer.from(crypto.hkdfSync("sha256", raw, Buffer.alloc(0), info, 32));
+    return { enc: derive("parawatch relay seal v1"), name: derive("parawatch relay name v1") };
+}
+/** The name the server knows a path by. */
+export function sealedName(keys, rel) {
+    return crypto.createHmac("sha256", keys.name).update(rel).digest("hex").slice(0, 40);
+}
+/** One box: version, nonce, tag, then the path and the bytes, encrypted together. */
+export function seal(keys, rel, data) {
+    const iv = crypto.randomBytes(12);
+    const c = crypto.createCipheriv("aes-256-gcm", keys.enc, iv);
+    const p = Buffer.from(rel, "utf8");
+    const len = Buffer.alloc(4);
+    len.writeUInt32BE(p.length);
+    const body = Buffer.concat([c.update(len), c.update(p), c.update(data), c.final()]);
+    return Buffer.concat([Buffer.from([1]), iv, c.getAuthTag(), body]);
+}
+export function open(keys, box) {
+    if (box.length < 29 || box[0] !== 1)
+        throw new Error("not a sealed parawatch file");
+    const d = crypto.createDecipheriv("aes-256-gcm", keys.enc, box.subarray(1, 13));
+    d.setAuthTag(box.subarray(13, 29));
+    const plain = Buffer.concat([d.update(box.subarray(29)), d.final()]);
+    const n = plain.readUInt32BE(0);
+    return { rel: plain.subarray(4, 4 + n).toString("utf8"), data: plain.subarray(4 + n) };
+}
+export function newKey() {
+    return crypto.randomBytes(32).toString("base64url");
+}
+// ------------------------------------------------------------------ join codes
+export function joinCode(c) {
+    return CODE_PREFIX + Buffer.from(JSON.stringify({ u: c.url, s: c.space, t: c.token, k: c.key })).toString("base64url");
+}
+export function readJoinCode(code) {
+    const t = code.trim();
+    if (!t.startsWith(CODE_PREFIX))
+        throw new UserError("that is not a parawatch relay code (it starts with pwr1.)");
+    try {
+        const o = JSON.parse(Buffer.from(t.slice(CODE_PREFIX.length), "base64url").toString("utf8"));
+        if (typeof o.u !== "string" || typeof o.s !== "string" || typeof o.t !== "string" || typeof o.k !== "string")
+            throw new Error("missing parts");
+        keysOf(o.k);
+        return { url: o.u.replace(/\/+$/, ""), space: o.s, token: o.t, key: o.k };
+    }
+    catch (err) {
+        if (err instanceof UserError)
+            throw err;
+        throw new UserError("that relay code is cut short or changed; copy it again");
+    }
+}
+/** The relay this machine uses, from config.json, when its sync adapter is the relay. */
+export function relayConfig() {
+    const s = readConfig().sync;
+    if (s?.adapter !== "relay")
+        return undefined;
+    const r = s.relay;
+    return r && r.url && r.space && r.token && r.key ? r : undefined;
+}
+export class RelayClient {
+    c;
+    f;
+    constructor(c, f = fetch) {
+        this.c = c;
+        this.f = f;
+    }
+    base() {
+        return `${this.c.url}/v1/spaces/${this.c.space}`;
+    }
+    async call(pathname, init = {}, signal) {
+        const res = await this.f(`${this.base()}${pathname}`, { ...init, signal, headers: { ...(init.headers ?? {}), authorization: `Bearer ${this.c.token}` } });
+        if (!res.ok) {
+            let why = `${res.status}`;
+            try {
+                why = (await res.json()).error ?? why;
+            }
+            catch {
+                // not JSON
+            }
+            throw new Error(`relay ${init.method ?? "GET"} ${pathname.split("/")[1]}: ${why}`);
+        }
+        return res;
+    }
+    async changes(after, wait = 0, signal) {
+        return (await (await this.call(`/changes?after=${after}&wait=${wait}`, {}, signal)).json());
+    }
+    async get(name) {
+        return Buffer.from(await (await this.call(`/files/${name}`)).arrayBuffer());
+    }
+    async put(name, body) {
+        return (await (await this.call(`/files/${name}`, { method: "PUT", body: new Uint8Array(body), headers: { "content-type": "application/octet-stream" } })).json()).seq;
+    }
+    async remove(name) {
+        return (await (await this.call(`/files/${name}`, { method: "DELETE" })).json()).seq;
+    }
+    static async createSpace(url, invite, f = fetch) {
+        const res = await f(`${url.replace(/\/+$/, "")}/v1/spaces`, { method: "POST", headers: { authorization: `Bearer ${invite}` } });
+        if (!res.ok) {
+            let why = `${res.status}`;
+            try {
+                why = (await res.json()).error ?? why;
+            }
+            catch {
+                // not JSON
+            }
+            throw new UserError(`the relay would not make a space: ${why}`);
+        }
+        return (await res.json());
+    }
+}
+export function mirrorStatePath() {
+    return path.join(homeDir(), "relay-state.json");
+}
+export function readMirrorState(space, file = mirrorStatePath()) {
+    try {
+        const s = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (s.v === 1 && s.space === space && s.files)
+            return s;
+    }
+    catch {
+        // none yet
+    }
+    return { v: 1, space, cursor: 0, files: {} };
+}
+/** Files the mirror leaves alone: hidden and temporary files, and copies a sync tool made. */
+function ignored(rel) {
+    return rel.split("/").some((p) => p.startsWith(".") || p.endsWith(".tmp") || /\.sync-conflict-/.test(p) || p === "~syncthing~");
+}
+/** Is `rel` a safe relative path inside the folder? A sealed file names its own path. */
+function safeRel(rel) {
+    return !!rel && !rel.startsWith("/") && !/^[a-zA-Z]:/.test(rel) && !rel.split("/").some((p) => p === ".." || p === "" || p === ".") && !rel.includes("\\");
+}
+const hashOf = (b) => crypto.createHash("sha256").update(b).digest("hex");
+export class RelayMirror {
+    o;
+    keys;
+    client;
+    state;
+    names = new Map();
+    stopped = false;
+    abort;
+    pushing = false;
+    constructor(o) {
+        this.o = o;
+        this.keys = keysOf(o.config.key);
+        this.client = new RelayClient(o.config, o.fetch);
+        this.state = readMirrorState(o.config.space, o.stateFile);
+        for (const rel of Object.keys(this.state.files))
+            this.names.set(sealedName(this.keys, rel), rel);
+    }
+    save() {
+        try {
+            const file = this.o.stateFile ?? mirrorStatePath();
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            fs.writeFileSync(`${file}.tmp`, JSON.stringify(this.state) + "\n");
+            fs.renameSync(`${file}.tmp`, file);
+        }
+        catch {
+            // kept in memory; the next save writes it
+        }
+    }
+    log(line) {
+        this.o.log?.(line);
+    }
+    /** Every file in the folder, as relative paths with forward slashes. */
+    scan() {
+        const out = new Map();
+        const walk = (dir, rel) => {
+            let entries = [];
+            try {
+                entries = fs.readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const e of entries) {
+                const r = rel ? `${rel}/${e.name}` : e.name;
+                if (ignored(r))
+                    continue;
+                const p = path.join(dir, e.name);
+                if (e.isDirectory())
+                    walk(p, r);
+                else if (e.isFile()) {
+                    try {
+                        const st = fs.statSync(p);
+                        out.set(r, { size: st.size, mtime: st.mtimeMs });
+                    }
+                    catch {
+                        // gone meanwhile
+                    }
+                }
+            }
+        };
+        walk(this.o.dir, "");
+        return out;
+    }
+    /** Bring down what changed on the server since the last look; `wait` holds until something does. */
+    async pull(wait = 0) {
+        this.abort = new AbortController();
+        const { head, changes } = await this.client.changes(this.state.cursor, wait, this.abort.signal);
+        let n = 0;
+        for (const ch of changes) {
+            const known = this.names.get(ch.name);
+            if (ch.deleted) {
+                if (known) {
+                    const p = path.join(this.o.dir, ...known.split("/"));
+                    const k = this.state.files[known];
+                    // only a file this machine has not changed since goes away
+                    try {
+                        const buf = fs.readFileSync(p);
+                        if (k && hashOf(buf) === k.hash)
+                            fs.rmSync(p, { force: true });
+                    }
+                    catch {
+                        // already gone
+                    }
+                    delete this.state.files[known];
+                    this.names.delete(ch.name);
+                    n++;
+                }
+                continue;
+            }
+            if ((ch.size ?? 0) > MIRROR_MAX_FILE + 1024)
+                continue;
+            let rel;
+            let data;
+            try {
+                ({ rel, data } = open(this.keys, await this.client.get(ch.name)));
+            }
+            catch (err) {
+                this.log(`could not open a file from the relay: ${err.message}`);
+                continue;
+            }
+            if (!safeRel(rel) || ignored(rel) || sealedName(this.keys, rel) !== ch.name) {
+                this.log(`left out a file with a path it may not have: ${JSON.stringify(rel)}`);
+                continue;
+            }
+            const p = path.join(this.o.dir, ...rel.split("/"));
+            const hash = hashOf(data);
+            const k = this.state.files[rel];
+            let here;
+            try {
+                here = fs.readFileSync(p);
+            }
+            catch {
+                // not here yet
+            }
+            const hereHash = here ? hashOf(here) : undefined;
+            // a change made here that has not gone up yet wins; it goes up on the next push
+            if (here && k && hereHash !== k.hash && hereHash !== hash)
+                continue;
+            if (hereHash !== hash) {
+                fs.mkdirSync(path.dirname(p), { recursive: true });
+                const tmp = path.join(path.dirname(p), `.${path.basename(p)}.relay.tmp`);
+                fs.writeFileSync(tmp, data);
+                fs.renameSync(tmp, p);
+                n++;
+            }
+            const st = fs.statSync(p);
+            this.state.files[rel] = { hash, size: st.size, mtime: st.mtimeMs };
+            this.names.set(ch.name, rel);
+        }
+        this.state.cursor = head;
+        this.state.lastOk = new Date().toISOString();
+        this.state.error = undefined;
+        this.save();
+        return n;
+    }
+    /** Send up what changed here since the last look. */
+    async push() {
+        if (this.pushing)
+            return 0;
+        this.pushing = true;
+        try {
+            if (!fs.existsSync(this.o.dir))
+                throw new Error(`the shared folder ${this.o.dir} is not there`);
+            const seen = this.scan();
+            let n = 0;
+            let pending = 0;
+            const skipped = [];
+            for (const [rel, st] of seen) {
+                const k = this.state.files[rel];
+                if (k && k.size === st.size && k.mtime === st.mtime)
+                    continue;
+                if (st.size > MIRROR_MAX_FILE) {
+                    skipped.push(rel);
+                    continue;
+                }
+                let data;
+                try {
+                    data = fs.readFileSync(path.join(this.o.dir, ...rel.split("/")));
+                }
+                catch {
+                    continue;
+                }
+                const hash = hashOf(data);
+                if (k && k.hash === hash) {
+                    this.state.files[rel] = { ...k, size: st.size, mtime: st.mtime };
+                    continue;
+                }
+                pending++;
+                const name = sealedName(this.keys, rel);
+                await this.client.put(name, seal(this.keys, rel, data));
+                this.state.files[rel] = { hash, size: st.size, mtime: st.mtime };
+                this.names.set(name, rel);
+                pending--;
+                n++;
+            }
+            // a folder that reads as empty while files were here is more likely unmounted than emptied
+            const vanished = Object.keys(this.state.files).filter((rel) => !seen.has(rel) && !ignored(rel));
+            if (vanished.length && !seen.size)
+                throw new Error(`the shared folder ${this.o.dir} reads as empty; nothing was deleted on the relay`);
+            for (const rel of vanished) {
+                const name = sealedName(this.keys, rel);
+                await this.client.remove(name);
+                delete this.state.files[rel];
+                this.names.delete(name);
+                n++;
+            }
+            this.state.pending = pending;
+            this.state.skipped = skipped.length ? skipped.slice(0, 20) : undefined;
+            if (n)
+                this.save();
+            return n;
+        }
+        finally {
+            this.pushing = false;
+        }
+    }
+    /** Pull first so a machine joining late takes what is there instead of sending it back. */
+    async once() {
+        const pulled = await this.pull(0);
+        const pushed = await this.push();
+        return { pulled, pushed };
+    }
+    /** Keep the folder in step until stopped: a held request for changes there, a look here every second. */
+    async run() {
+        let backoff = 1000;
+        const pushLoop = async () => {
+            while (!this.stopped) {
+                try {
+                    await this.push();
+                }
+                catch (err) {
+                    this.fail(err);
+                }
+                await sleep(1000);
+            }
+        };
+        try {
+            await this.pull(0);
+        }
+        catch (err) {
+            this.fail(err);
+        }
+        void pushLoop();
+        while (!this.stopped) {
+            try {
+                await this.pull(25);
+                backoff = 1000;
+            }
+            catch (err) {
+                if (this.stopped)
+                    break;
+                this.fail(err);
+                await sleep(backoff);
+                backoff = Math.min(backoff * 2, 60_000);
+            }
+        }
+    }
+    fail(err) {
+        const msg = err.message ?? String(err);
+        if (this.state.error !== msg)
+            this.log(`relay: ${msg}`);
+        this.state.error = msg;
+        this.save();
+    }
+    stop() {
+        this.stopped = true;
+        this.abort?.abort();
+    }
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Only one mirror per machine: the app and `parawatch relay run` would otherwise race. */
+export function takeMirrorLock() {
+    const file = path.join(homeDir(), "relay.pid");
+    try {
+        const pid = Number(fs.readFileSync(file, "utf8"));
+        if (pid && pid !== process.pid) {
+            try {
+                process.kill(pid, 0);
+                return undefined;
+            }
+            catch (err) {
+                if (err.code === "EPERM")
+                    return undefined;
+            }
+        }
+    }
+    catch {
+        // no lock
+    }
+    fs.mkdirSync(homeDir(), { recursive: true });
+    fs.writeFileSync(file, String(process.pid));
+    return () => {
+        try {
+            if (fs.readFileSync(file, "utf8").trim() === String(process.pid))
+                fs.rmSync(file, { force: true });
+        }
+        catch {
+            // gone
+        }
+    };
+}
+// ------------------------------------------------------------------ status
+/** How the mirror is doing, for `parawatch sync`, `doctor` and the app. */
+export const relayAdapter = {
+    name: "relay",
+    about: "a parawatch relay server, sealed end to end",
+    async status(ctx) {
+        const c = relayConfig();
+        const peers = folderPeers(ctx.dir, ctx.device);
+        if (!c)
+            return { adapter: "relay", dir: ctx.dir, device: ctx.device, ok: false, peers, conflicts: [], error: "no relay is set up: run `parawatch relay setup` or `parawatch relay join`" };
+        const st = readMirrorState(c.space);
+        let reachable = true;
+        let error = st.error;
+        try {
+            const res = await (ctx.fetch ?? fetch)(`${c.url}/healthz`, { signal: AbortSignal.timeout(ctx.timeoutMs ?? 3000) });
+            reachable = res.ok;
+        }
+        catch (err) {
+            reachable = false;
+            error = `cannot reach ${c.url}: ${err.message}`;
+        }
+        const fresh = !!st.lastOk && Date.now() - Date.parse(st.lastOk) < 2 * 60_000;
+        return {
+            adapter: "relay",
+            dir: ctx.dir,
+            device: ctx.device,
+            ok: reachable && fresh && !st.error,
+            lastSync: st.lastOk,
+            peers,
+            conflicts: findConflicts(ctx.dir),
+            ...(st.pending ? { pending: st.pending } : {}),
+            ...(error ? { error } : !fresh ? { error: "nothing is keeping the folder in step: open the app, or run `parawatch relay run`" } : {}),
+        };
+    },
+};
+//# sourceMappingURL=relay.js.map

package/dist/core/remoteChat.js

@@ -0,0 +1,212 @@
+/**
+ * Codex conversations of another machine. The log and the codex command stay on the machine the
+ * session ran on (the host); the machine showing it (the viewer) asks through the shared folder:
+ *
+ *   chats/<viewer>/watching.json   the sessions the viewer has open, rewritten while they are
+ *   chats/<viewer>/asks.jsonl      messages to send and stops, written by the viewer only
+ *   chats/<host>/<session>.json    the conversation as the host reads it, rewritten as it changes
+ *
+ * Every file has one writer, so the sync tool never has two versions of one to reconcile.
+ */
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { DEVICE_NAME, deviceName, sharedDir } from "./store.js";
+/** How often a viewer says it still has its chats open, and when a host stops serving one. */
+export const WATCH_EVERY_MS = 20_000;
+export const WATCH_GONE_MS = 75_000;
+/** How often a host rewrites a watched chat that did not change, and when the viewer gives up on it. */
+export const HOST_BEAT_MS = 30_000;
+export const HOST_QUIET_MS = 100_000;
+/** A message that took longer than this to reach the host is not sent: the person has moved on. */
+export const ASK_LATE_MS = 2 * 60_000;
+/** How long asks and their results are kept. */
+export const ASK_KEEP_MS = 10 * 60_000;
+/** The most conversation items a host shares; the rest count as earlier. */
+export const SHARED_ITEMS = 150;
+/** The first version whose app answers for its Codex sessions. */
+export const REMOTE_CHAT_SINCE = "0.3.16";
+const SESSION_ID = /^[A-Za-z0-9_-]{1,80}$/;
+export function validSession(id) {
+    return SESSION_ID.test(id);
+}
+function chatsDir(shared = sharedDir()) {
+    return shared ? path.join(shared, "chats") : undefined;
+}
+function writeAtomic(file, body) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.tmp`);
+    fs.writeFileSync(tmp, body);
+    fs.renameSync(tmp, file);
+}
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The machines with a folder under `chats/`, other than this one. */
+function otherDevices(dir, me) {
+    try {
+        return fs.readdirSync(dir).filter((n) => DEVICE_NAME.test(n) && n !== me);
+    }
+    catch {
+        return [];
+    }
+}
+// ------------------------------------------------------------------ viewer
+/** Say which sessions of other machines this one has open. */
+export function writeWatching(open, now = Date.now(), shared = sharedDir()) {
+    const dir = chatsDir(shared);
+    if (!dir)
+        return;
+    const me = deviceName();
+    const body = { v: 1, device: me, at: new Date(now).toISOString(), open };
+    try {
+        writeAtomic(path.join(dir, me, "watching.json"), JSON.stringify(body) + "\n");
+    }
+    catch {
+        // the folder may be busy syncing; the next beat writes it again
+    }
+}
+/** Add a message or a stop for a host, dropping asks old enough that no host still needs them. */
+export function appendAsk(a, now = Date.now(), shared = sharedDir()) {
+    const dir = chatsDir(shared);
+    if (!dir)
+        throw new Error("This machine shares no folder with others.");
+    const me = deviceName();
+    const ask = { id: `${me}-${now.toString(36)}-${crypto.randomBytes(3).toString("hex")}`, at: new Date(now).toISOString(), ...a };
+    const file = path.join(dir, me, "asks.jsonl");
+    const kept = readAskLines(file).filter((x) => now - Date.parse(x.at) < ASK_KEEP_MS);
+    writeAtomic(file, [...kept, ask].map((x) => JSON.stringify(x) + "\n").join(""));
+    return ask;
+}
+/** What the host last wrote about a session, if anything. */
+export function readHosted(host, id, shared = sharedDir()) {
+    const dir = chatsDir(shared);
+    if (!dir || !DEVICE_NAME.test(host) || !validSession(id))
+        return undefined;
+    const h = readJson(path.join(dir, host, `${id}.json`));
+    return h && h.v === 1 && h.id === id ? h : undefined;
+}
+export function hostedPath(host, id, shared = sharedDir()) {
+    const dir = chatsDir(shared);
+    return dir && DEVICE_NAME.test(host) && validSession(id) ? path.join(dir, host, `${id}.json`) : undefined;
+}
+// ------------------------------------------------------------------ host
+/** The sessions of this machine that another machine has open now, and which machines. */
+export function watchedHere(now = Date.now(), shared = sharedDir()) {
+    const dir = chatsDir(shared);
+    const out = new Map();
+    if (!dir)
+        return out;
+    const me = deviceName();
+    for (const d of otherDevices(dir, me)) {
+        const w = readJson(path.join(dir, d, "watching.json"));
+        if (!w || !Array.isArray(w.open) || now - Date.parse(w.at) > WATCH_GONE_MS)
+            continue;
+        for (const o of w.open) {
+            if (o?.host !== me || typeof o.id !== "string" || !validSession(o.id))
+                continue;
+            out.set(o.id, [...(out.get(o.id) ?? []), d]);
+        }
+    }
+    return out;
+}
+function readAskLines(file) {
+    let text = "";
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of text.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const a = JSON.parse(line);
+            if (typeof a.id === "string" && typeof a.session === "string" && Number.isFinite(Date.parse(a.at)) && (a.op === "send" || a.op === "stop"))
+                out.push(a);
+        }
+        catch {
+            // a line half written by the sync tool; it is whole next time
+        }
+    }
+    return out;
+}
+/** Asks other machines left for this one, oldest first. */
+export function asksHere(shared = sharedDir()) {
+    const dir = chatsDir(shared);
+    if (!dir)
+        return [];
+    const me = deviceName();
+    const out = [];
+    for (const d of otherDevices(dir, me)) {
+        for (const a of readAskLines(path.join(dir, d, "asks.jsonl"))) {
+            // an ask names its own machine in its id, so one machine cannot answer for another
+            if (a.host === me && a.id.startsWith(`${d}-`) && validSession(a.session))
+                out.push(a);
+        }
+    }
+    return out.sort((a, b) => a.at.localeCompare(b.at));
+}
+/** The conversation with only its latest items, so the shared file stays small. */
+export function slimState(s, max = SHARED_ITEMS) {
+    if (!s.view || s.view.items.length <= max)
+        return s;
+    const cut = s.view.items.length - max;
+    return { ...s, view: { ...s.view, items: s.view.items.slice(cut), earlier: s.view.earlier + cut } };
+}
+export function writeHosted(h, shared = sharedDir()) {
+    const me = deviceName();
+    const file = hostedPath(me, h.id, shared);
+    if (!file)
+        return;
+    const body = { v: 1, host: me, ...h, state: slimState(h.state) };
+    try {
+        writeAtomic(file, JSON.stringify(body) + "\n");
+    }
+    catch {
+        // the folder may be busy syncing; the next change or beat writes it again
+    }
+}
+export function removeHosted(id, shared = sharedDir()) {
+    const file = hostedPath(deviceName(), id, shared);
+    if (!file)
+        return;
+    try {
+        fs.rmSync(file, { force: true });
+    }
+    catch {
+        // gone or busy; nobody reads it once it is not watched
+    }
+}
+/** Asks this machine already handled, read back from what it wrote, so a restart does not send twice. */
+export function handledHere(shared = sharedDir()) {
+    const dir = chatsDir(shared);
+    const out = new Map();
+    if (!dir)
+        return out;
+    const mine = path.join(dir, deviceName());
+    let names = [];
+    try {
+        names = fs.readdirSync(mine);
+    }
+    catch {
+        return out;
+    }
+    for (const n of names) {
+        const m = /^(.+)\.json$/.exec(n);
+        if (!m || m[1] === "watching" || !validSession(m[1]))
+            continue;
+        const h = readJson(path.join(mine, n));
+        if (h?.asks)
+            out.set(m[1], h.asks);
+    }
+    return out;
+}
+//# sourceMappingURL=remoteChat.js.map