parawatch 0.0.0-stage → 0.1.0

package/dist/adapters/jsonl.js

@@ -0,0 +1,144 @@
+import fs from "node:fs";
+/** Read up to `bytes` from the start of a file, dropping a torn last line. */
+export function readHeadLines(file, bytes) {
+    const fd = fs.openSync(file, "r");
+    try {
+        const buf = Buffer.alloc(bytes);
+        const n = fs.readSync(fd, buf, 0, bytes, 0);
+        const text = buf.subarray(0, n).toString("utf8");
+        const lines = text.split("\n");
+        if (n === bytes)
+            lines.pop();
+        return parseLines(lines);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** Read up to `bytes` from the end of a file, dropping a torn first line. Agent logs can be hundreds of MB. */
+export function readTailLines(file, bytes) {
+    const size = fs.statSync(file).size;
+    const start = Math.max(0, size - bytes);
+    const fd = fs.openSync(file, "r");
+    try {
+        const len = size - start;
+        const buf = Buffer.alloc(len);
+        const n = fs.readSync(fd, buf, 0, len, start);
+        const lines = buf.subarray(0, n).toString("utf8").split("\n");
+        if (start > 0)
+            lines.shift();
+        return parseLines(lines);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** Raw text from the start of a file, for lines too long to parse whole (inline images). */
+export function readHeadText(file, bytes) {
+    const fd = fs.openSync(file, "r");
+    try {
+        const buf = Buffer.alloc(bytes);
+        const n = fs.readSync(fd, buf, 0, bytes, 0);
+        return buf.subarray(0, n).toString("utf8");
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** Every JSON string value of a "text" key found in raw, possibly truncated, JSON text. */
+export function textValues(raw) {
+    const out = [];
+    const re = /"text":"((?:[^"\\]|\\.)*)"/g;
+    for (let m = re.exec(raw); m; m = re.exec(raw)) {
+        try {
+            out.push(JSON.parse(`"${m[1]}"`));
+        }
+        catch {
+            // malformed escape; skip
+        }
+    }
+    return out;
+}
+function parseLines(lines) {
+    const out = [];
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch {
+            // skip partial or foreign lines
+        }
+    }
+    return out;
+}
+export function oneLine(s, max = 100) {
+    const flat = s.replace(/\s+/g, " ").trim();
+    return flat.length > max ? flat.slice(0, max - 1) + "…" : flat;
+}
+export function isObj(x) {
+    return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+export function str(x) {
+    return typeof x === "string" ? x : undefined;
+}
+export const ACTIVITY_MINUTES = 60;
+/** Which of the last `window` minutes saw any of these times: minutes before now, ascending. */
+export function activeMinutes(times, now, window = ACTIVITY_MINUTES) {
+    const set = new Set();
+    for (const t of times) {
+        if (!Number.isFinite(t))
+            continue;
+        const m = Math.floor((now - t) / 60_000);
+        if (m >= 0 && m < window)
+            set.add(m);
+    }
+    return [...set].sort((a, b) => a - b);
+}
+const STAMP = /"timestamp":"([^"]{10,40})"/g;
+/** Every record timestamp in raw log text, in milliseconds. */
+export function timestampsIn(text) {
+    const out = [];
+    for (let m = STAMP.exec(text); m; m = STAMP.exec(text)) {
+        const t = Date.parse(m[1]);
+        if (Number.isFinite(t))
+            out.push(t);
+    }
+    STAMP.lastIndex = 0;
+    return out;
+}
+// How far back the first look at a log goes. Later looks read only what was appended since.
+const FIRST_LOOK_BYTES = 16 * 1024 * 1024;
+const seen = new Map();
+/**
+ * The active minutes of an append-only log. A long-running process (the desktop app) keeps what
+ * it has read, so each refresh reads only the new end of the file.
+ */
+export function logActivity(file, now) {
+    const size = fs.statSync(file).size;
+    let entry = seen.get(file);
+    if (!entry || size < entry.offset)
+        entry = { offset: Math.max(0, size - FIRST_LOOK_BYTES), times: [] };
+    if (size > entry.offset) {
+        const fd = fs.openSync(file, "r");
+        try {
+            const len = size - entry.offset;
+            const buf = Buffer.alloc(len);
+            const n = fs.readSync(fd, buf, 0, len, entry.offset);
+            const text = buf.subarray(0, n).toString("utf8");
+            // stop at the last full line so a record being written is read next time
+            const end = text.lastIndexOf("\n") + 1;
+            entry.times.push(...timestampsIn(text.slice(0, end)));
+            entry.offset += Buffer.byteLength(text.slice(0, end), "utf8");
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    const horizon = now - ACTIVITY_MINUTES * 60_000;
+    entry.times = entry.times.filter((t) => t >= horizon);
+    seen.set(file, entry);
+    return activeMinutes(entry.times, now);
+}
+//# sourceMappingURL=jsonl.js.map

package/dist/bin/cli.js

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import { Command } from "commander";
+import { UserError, addProject, answerCard, claimSession, closeCard, commentCard, consumerName, editCard, endRun, noteRun, openCard, readInbox, removeProject, startRun, waitInbox, } from "../core/ops.js";
+import { readEvents } from "../core/store.js";
+import { followEvents } from "../core/follow.js";
+import { fold } from "../core/state.js";
+import { collectRuns } from "../core/runs.js";
+import { cardDetail, cardLine, cardRows, inboxLine, runsTree, view } from "../core/format.js";
+import { hookContext, notify, writeInstructions } from "../core/integrate.js";
+import { installSkill, skillSource, skillTargets } from "../core/skill.js";
+import { cardContextLine, resolveGoto } from "../core/desktop.js";
+import { snapshot } from "../core/snapshot.js";
+import { SCHEMA_VERSION } from "../core/types.js";
+const collect = (v, prev = []) => [...prev, v];
+const int = (v) => {
+    const n = Number(v);
+    if (!Number.isInteger(n))
+        throw new UserError(`"${v}" is not a whole number`);
+    return n;
+};
+const print = (x) => process.stdout.write(JSON.stringify(x) + "\n");
+/** The agent session running this command, when its runtime says so. */
+function currentSession() {
+    return process.env.CLAUDE_CODE_SESSION_ID || process.env.CODEX_THREAD_ID || undefined;
+}
+const program = new Command();
+program
+    .name("parawatch")
+    .description("See what your agents are doing, what needs you, and wake the right agent when you answer.")
+    .version("0.1.0");
+// ------------------------------------------------------------------ cards
+function cardCommand(kind, name, summary) {
+    return program
+        .command(`${name} <title>`)
+        .description(summary)
+        .requiredOption("-p, --project <name>", "project this card belongs to")
+        .option("-t, --task <task>", "task within the project")
+        .option("-b, --body <text>", "two or three lines of context")
+        .option("--attach <file>", "image, video or file to look at (repeatable)", collect)
+        .option("--from <who>", "who is asking (defaults to the calling session's claimed title)")
+        .option("--session <id>", "the agent session asking (defaults to the calling session)")
+        .option("--since <date>", "when the matter first came up, if earlier (YYYY-MM-DD)")
+        .option("--json", "print the card as JSON");
+}
+/** Options every card kind shares. */
+function common(o) {
+    return {
+        project: o.project,
+        task: o.task,
+        body: o.body,
+        attach: o.attach,
+        from: o.from,
+        session: o.session ?? currentSession(),
+        since: o.since,
+    };
+}
+function finishCard(input, json) {
+    const card = openCard(input);
+    notify(card);
+    if (json)
+        print(card);
+    else
+        process.stdout.write(`${card.id}\n`);
+}
+cardCommand("decide", "ask", "ask the human to decide")
+    .option("-o, --option <text>", "a choice (repeatable)", collect)
+    .option("-r, --recommend <n>", "the recommended choice, 1-based", int)
+    .action((title, o) => finishCard({ kind: "decide", title, ...common(o), options: o.option, recommend: o.recommend }, o.json));
+cardCommand("try", "try", "ask the human to try a build, watch a video or look at a screen")
+    .option("--open <path>", "app, file or URL to open (repeatable)", collect)
+    .option("-l, --look <text>", "what to look at")
+    .action((title, o) => finishCard({ kind: "try", title, ...common(o), open: o.open, look: o.look }, o.json));
+cardCommand("block", "block", "something only the human can do, and you are stuck until they do it")
+    .action((title, o) => finishCard({ kind: "block", title, ...common(o) }, o.json));
+cardCommand("todo", "todo", "something only the human can do, but nothing waits on it now")
+    .action((title, o) => finishCard({ kind: "todo", title, ...common(o) }, o.json));
+program
+    .command("edit <card>")
+    .description("change a card: its kind, wording, task, who asked or when it came up (an empty value clears)")
+    .option("-k, --kind <kind>", "decide, try, block or todo")
+    .option("--title <text>", "new title")
+    .option("-b, --body <text>", "new body")
+    .option("-t, --task <task>", "task within the project")
+    .option("--from <who>", "who asked")
+    .option("--session <id>", "the agent session that asked")
+    .option("--since <date>", "when the matter first came up (YYYY-MM-DD)")
+    .option("--json", "print the card as JSON")
+    .action((id, o) => {
+    const card = editCard(id, { kind: o.kind, title: o.title, body: o.body, task: o.task, from: o.from, session: o.session, since: o.since });
+    if (o.json)
+        print(card);
+    else
+        process.stdout.write(cardLine(card) + "\n");
+});
+program
+    .command("goto <target>")
+    .description("open the agent session behind a card (or a session id) in the Claude desktop app")
+    .option("--copy", "also put a line about the card on the clipboard, to paste into that session")
+    .option("--print", "print the link instead of opening it")
+    .action((target, o) => {
+    const g = resolveGoto(target, fold(readEvents()));
+    if (o.copy && g.card) {
+        const line = cardContextLine(g.card);
+        try {
+            execFileSync("pbcopy", { input: line });
+        }
+        catch {
+            process.stderr.write(`parawatch: could not copy to the clipboard; the line is: ${line}\n`);
+        }
+    }
+    if (!g.url)
+        throw new UserError(`${g.name} is not a Claude desktop session. In a terminal: claude --resume ${g.session}`);
+    if (o.print) {
+        process.stdout.write(g.url + "\n");
+        return;
+    }
+    execFileSync("open", [g.url]);
+    process.stdout.write(`Opened ${g.name}${g.desktop?.archived ? " (archived)" : ""}\n`);
+});
+program
+    .command("answer <card>")
+    .description("answer a card (this is what wakes the waiting agent)")
+    .option("-c, --choice <n>", "chosen option, 1-based", int)
+    .option("-m, --comment <text>", "free text")
+    .option("--attach <file>", "a screenshot or file (repeatable)", collect)
+    .option("--by <who>", "who answers", "human")
+    .action((id, o) => answerCard(id, { choice: o.choice, comment: o.comment, attach: o.attach, by: o.by }));
+program
+    .command("comment <card> <text>")
+    .description("add a comment to a card")
+    .option("--by <who>", "who comments (use 'human' to wake the agent)", "agent")
+    .action((id, text, o) => commentCard(id, text, o.by));
+program
+    .command("close <card>")
+    .description("close a card once it has been acted on")
+    .option("-n, --note <text>", "what was done")
+    .action((id, o) => closeCard(id, o.note));
+program
+    .command("show <card>")
+    .description("show one card with its answers")
+    .option("--json", "JSON output")
+    .action((id, o) => {
+    const card = fold(readEvents()).cards.get(id);
+    if (!card)
+        throw new UserError(`no card "${id}"`);
+    if (o.json)
+        print(card);
+    else
+        process.stdout.write(cardDetail(card) + "\n");
+});
+program
+    .command("cards")
+    .description("list cards (open and answered by default)")
+    .option("-p, --project <name>", "only this project")
+    .option("-a, --all", "include closed cards")
+    .option("--json", "JSON output")
+    .action((o) => {
+    const cards = [...fold(readEvents()).cards.values()].filter((c) => (o.all || c.status !== "closed") && (!o.project || c.project === o.project));
+    if (o.json)
+        print({ v: SCHEMA_VERSION, cards });
+    else
+        process.stdout.write(cards.length ? cardRows(cards, view()).join("\n") + "\n" : "No cards.\n");
+});
+// ------------------------------------------------------------------ inbox
+function inboxOptions(c) {
+    return c
+        .option("-p, --project <name>", "only answers for this project")
+        .option("--card <id>", "only answers to this card")
+        .option("--as <consumer>", "cursor name (defaults to the project)")
+        .option("--json", "JSON output");
+}
+inboxOptions(program.command("wait").description("block until the human answers, print the answers and exit"))
+    .option("--timeout <seconds>", "give up after this long (exit code 2); 0 waits forever", int, 0)
+    .action(async (o) => {
+    const items = await waitInbox(consumerName(o), { project: o.project, card: o.card }, o.timeout * 1000);
+    if (!items.length) {
+        process.exitCode = 2;
+        return;
+    }
+    if (o.json)
+        print({ v: SCHEMA_VERSION, items });
+    else
+        process.stdout.write(items.map(inboxLine).join("\n") + "\n");
+});
+inboxOptions(program.command("inbox").description("print unhandled answers without waiting"))
+    .option("--peek", "do not mark them as seen")
+    .action((o) => {
+    const items = readInbox(consumerName(o), { project: o.project, card: o.card }, !o.peek);
+    if (o.json)
+        print({ v: SCHEMA_VERSION, items });
+    else if (items.length)
+        process.stdout.write(items.map(inboxLine).join("\n") + "\n");
+});
+program
+    .command("watch")
+    .description("stream every new event as one JSON line (for plugins and monitors)")
+    .option("--from <seq>", "replay events after this sequence number first", int)
+    .action(async (o) => {
+    followEvents(print, o.from);
+    await new Promise(() => { });
+});
+// ------------------------------------------------------------------ runs
+program
+    .command("runs")
+    .description("agents seen in their logs, grouped by project")
+    .option("-p, --project <name>", "only this project")
+    .option("--since <hours>", "look at logs touched in the last N hours", int, 6)
+    .option("-a, --all", "include runs that ended a while ago")
+    .option("--runtime <name>", "only this adapter (repeatable)", collect)
+    .option("-w, --wide", "show runtime and ids")
+    .option("--json", "JSON output")
+    .action((o) => {
+    const runs = collectRuns(fold(readEvents()), { sinceHours: o.since, project: o.project, includeEnded: o.all, runtimes: o.runtime });
+    if (o.json)
+        print({ v: SCHEMA_VERSION, runs });
+    else
+        process.stdout.write((runs.length ? runsTree(runs, view({ wide: o.wide, all: o.all })) : "Nothing running.") + "\n");
+});
+const run = program.command("run").description("report a job that leaves no agent log");
+run
+    .command("start <title>")
+    .requiredOption("-p, --project <name>", "project")
+    .option("-t, --task <task>", "task")
+    .option("--parent <id>", "the run that started this one (defaults to the calling session)")
+    .action((title, o) => {
+    process.stdout.write(startRun({ title, project: o.project, task: o.task, parent: o.parent ?? currentSession() }) + "\n");
+});
+run.command("note <id> <text>").action((id, text) => noteRun(id, text));
+run
+    .command("end <id>")
+    .option("--failed", "it failed")
+    .option("-n, --note <text>", "how it ended")
+    .action((id, o) => endRun(id, o.failed ? "failed" : "done", o.note));
+program
+    .command("claim [session]")
+    .description("say which project an agent session belongs to (id prefix, 6+ characters; defaults to the calling session)")
+    .requiredOption("-p, --project <name>", "project")
+    .option("-t, --task <task>", "task")
+    .option("--role <role>", "for example lead or worker")
+    .option("--title <title>", "name to show")
+    .action((session, o) => {
+    const id = session ?? currentSession();
+    if (!id)
+        throw new UserError("no session id given and none found in the environment (CLAUDE_CODE_SESSION_ID, CODEX_THREAD_ID)");
+    claimSession({ session: id, project: o.project, task: o.task, role: o.role, title: o.title });
+    process.stdout.write(`${id.slice(0, 8)} → ${o.project}${o.role ? ` (${o.role})` : ""}\n`);
+});
+// ------------------------------------------------------------------ status
+program
+    .command("status")
+    .description("everything at a glance: what needs you, then what is running")
+    .option("-p, --project <name>", "only this project")
+    .option("--since <hours>", "look at logs touched in the last N hours", int, 6)
+    .option("-w, --wide", "show runtime and ids")
+    .option("--json", "JSON output")
+    .action((o) => {
+    const snap = snapshot({ sinceHours: o.since, project: o.project });
+    if (o.json) {
+        print(snap);
+        return;
+    }
+    const { cards, runs } = snap;
+    const v = view({ wide: o.wide });
+    const head = (title, n, ...extra) => v.color ? `\x1b[1m${title}\x1b[0m  \x1b[2m${n}${extra.join("")}\x1b[0m` : `${title}  ${n}${extra.join("")}`;
+    const open = cards.filter((c) => c.status === "open" && c.kind !== "todo");
+    const todo = cards.filter((c) => c.status === "open" && c.kind === "todo");
+    const answered = cards.filter((c) => c.status === "answered");
+    const out = [];
+    out.push(head("NEEDS YOU", open.length || "nothing"));
+    out.push(...cardRows(open, v, Date.now(), "  "));
+    if (todo.length) {
+        out.push("", head("TO DO, NOTHING WAITS ON IT", todo.length));
+        out.push(...cardRows(todo, v, Date.now(), "  "));
+    }
+    if (answered.length) {
+        out.push("", head("ANSWERED, WAITING FOR THE AGENT", answered.length));
+        out.push(...cardRows(answered, v, Date.now(), "  "));
+    }
+    const working = runs.filter((r) => r.state === "working" || r.state === "waiting").length;
+    out.push("", head("AGENTS", runs.length ? `${working} working` : "nothing running"));
+    if (runs.length)
+        out.push(runsTree(runs, v));
+    process.stdout.write(out.join("\n") + "\n");
+});
+// ------------------------------------------------------------------ skill
+const skill = program.command("skill").description("the agent skill that teaches agents to use parawatch");
+skill
+    .command("path")
+    .description("print where the skill lives")
+    .action(() => {
+    process.stdout.write(skillSource() + "\n");
+});
+skill
+    .command("install")
+    .description("link the skill into Claude Code (~/.claude/skills) and Codex (~/.codex/skills)")
+    .option("--runtime <name>", "only this runtime: claude-code or codex (repeatable)", collect)
+    .option("--force", "replace a folder that is already there")
+    .action((o) => {
+    for (const r of installSkill(skillTargets(), { only: o.runtime, force: o.force })) {
+        process.stdout.write(`${r.runtime.padEnd(12)} ${r.result.padEnd(15)} ${r.path}${r.note ? `  (${r.note})` : ""}\n`);
+    }
+});
+// ------------------------------------------------------------------ setup
+const project = program.command("project").description("projects you work on");
+project
+    .command("add <name> [paths...]")
+    .description("register a project and the checkouts or folders it lives in")
+    .action((name, paths) => addProject(name, paths.length ? paths : [process.cwd()]));
+project.command("remove <name>").action((name) => removeProject(name));
+project
+    .command("list")
+    .option("--json", "JSON output")
+    .action((o) => {
+    const ps = [...fold(readEvents()).projects.values()];
+    if (o.json)
+        print({ v: SCHEMA_VERSION, projects: ps });
+    else
+        process.stdout.write(ps.map((p) => `${p.name}  ${p.paths.join(", ")}`).join("\n") + (ps.length ? "\n" : "No projects.\n"));
+});
+program
+    .command("init")
+    .description("add parawatch instructions for agents to an instruction file")
+    .option("-f, --file <path>", "file to write", "AGENTS.md")
+    .option("-p, --project <name>", "project name to put in the examples")
+    .action((o) => {
+    const changed = writeInstructions(o.file, o.project);
+    process.stdout.write(changed ? `Updated ${o.file}\n` : `${o.file} already up to date\n`);
+});
+program
+    .command("hook <runtime>")
+    .description("hook entry point; 'claude-code' reads the hook JSON on stdin")
+    .option("-p, --project <name>", "project, when it cannot be told from the session")
+    .action((runtime, o) => {
+    if (runtime !== "claude-code")
+        throw new UserError(`no hook for "${runtime}"`);
+    let input = {};
+    try {
+        input = JSON.parse(fs.readFileSync(0, "utf8") || "{}");
+    }
+    catch {
+        input = {};
+    }
+    const text = hookContext(input, o.project);
+    if (!text)
+        return;
+    if (input.hook_event_name)
+        print({ hookSpecificOutput: { hookEventName: input.hook_event_name, additionalContext: text } });
+    else
+        process.stdout.write(text + "\n");
+});
+program.parseAsync().catch((err) => {
+    if (err instanceof UserError) {
+        process.stderr.write(`parawatch: ${err.message}\n`);
+        process.exit(1);
+    }
+    throw err;
+});
+//# sourceMappingURL=cli.js.map

package/dist/core/desktop.js

@@ -0,0 +1,78 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { sessionTitle, UserError } from "./ops.js";
+/**
+ * Where the Claude desktop app keeps its Code sessions: one JSON file per session, named
+ * `local_<id>.json`, holding the CLI session id the app runs (`cliSessionId`).
+ */
+export function desktopSessionsDir() {
+    return (process.env.PARAWATCH_CLAUDE_DESKTOP_DIR ||
+        path.join(os.homedir(), "Library", "Application Support", "Claude", "claude-code-sessions"));
+}
+function* sessionFiles(dir, depth = 0) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        const p = path.join(dir, e.name);
+        if (e.isDirectory() && depth < 3)
+            yield* sessionFiles(p, depth + 1);
+        else if (e.isFile() && /^local_[A-Za-z0-9-]+\.json$/.test(e.name))
+            yield p;
+    }
+}
+/** The desktop app session running a CLI session (full id or a prefix of 6+ characters). */
+export function findDesktopSession(cliSession, dir = desktopSessionsDir()) {
+    if (cliSession.length < 6)
+        return undefined;
+    let best;
+    for (const file of sessionFiles(dir)) {
+        let d;
+        try {
+            d = JSON.parse(fs.readFileSync(file, "utf8"));
+        }
+        catch {
+            continue;
+        }
+        const ids = [d.cliSessionId, d.lastAssistantCliSessionId].filter((x) => typeof x === "string");
+        if (!ids.some((x) => x.startsWith(cliSession)))
+            continue;
+        const s = {
+            id: typeof d.sessionId === "string" ? d.sessionId : path.basename(file, ".json"),
+            cliSessionId: ids[0],
+            title: typeof d.title === "string" ? d.title : undefined,
+            cwd: typeof d.cwd === "string" ? d.cwd : undefined,
+            archived: d.isArchived === true,
+            lastActivityAt: typeof d.lastActivityAt === "number" ? d.lastActivityAt : 0,
+        };
+        // prefer a live session, then the most recent one
+        if (!best || (best.archived && !s.archived) || (best.archived === s.archived && s.lastActivityAt > best.lastActivityAt))
+            best = s;
+    }
+    return best;
+}
+/** A link that opens the session in the Claude desktop app. */
+export function desktopSessionUrl(s) {
+    return `claude://code/continue?session=${encodeURIComponent(s.id)}&source=parawatch`;
+}
+/** Where `goto` leads for a card id or a session id (prefix). */
+export function resolveGoto(target, state) {
+    const card = state.cards.get(target);
+    const session = card ? card.session : target;
+    if (!session) {
+        throw new UserError(`card ${target} does not say which session opened it (set one with: parawatch edit ${target} --session <id>)`);
+    }
+    const desktop = findDesktopSession(session);
+    const name = sessionTitle(state.claims, session) ?? desktop?.title ?? session.slice(0, 8);
+    return { name, session, card, desktop, url: desktop ? desktopSessionUrl(desktop) : undefined };
+}
+/** A line to paste into the session so it knows which card the human means. */
+export function cardContextLine(card) {
+    return `About parawatch card ${card.id} ("${card.title}"): `;
+}
+//# sourceMappingURL=desktop.js.map

package/dist/core/follow.js

@@ -0,0 +1,70 @@
+import fs from "node:fs";
+import { eventsPath, homeDir, parseEventLines } from "./store.js";
+/**
+ * Call `onEvent` for every event appended after `afterSeq` (or after the current end when it is
+ * undefined). Watches the store folder and also checks once a second. Returns a stop function.
+ */
+export function followEvents(onEvent, afterSeq) {
+    const file = eventsPath();
+    let offset = 0;
+    let lastSeq = afterSeq ?? Infinity;
+    try {
+        const text = fs.readFileSync(file, "utf8");
+        offset = Buffer.byteLength(text);
+        const events = parseEventLines(text);
+        const end = events[events.length - 1]?.seq ?? 0;
+        if (afterSeq === undefined)
+            lastSeq = end;
+        else {
+            for (const ev of events)
+                if (ev.seq > afterSeq)
+                    onEvent(ev);
+            lastSeq = Math.max(afterSeq, end);
+        }
+    }
+    catch {
+        lastSeq = afterSeq ?? 0;
+    }
+    const pump = () => {
+        let size = 0;
+        try {
+            size = fs.statSync(file).size;
+        }
+        catch {
+            return;
+        }
+        if (size < offset)
+            offset = 0; // file replaced
+        if (size === offset)
+            return;
+        const fd = fs.openSync(file, "r");
+        const buf = Buffer.alloc(size - offset);
+        fs.readSync(fd, buf, 0, buf.length, offset);
+        fs.closeSync(fd);
+        const text = buf.toString("utf8");
+        const cut = text.lastIndexOf("\n");
+        if (cut < 0)
+            return;
+        offset += Buffer.byteLength(text.slice(0, cut + 1));
+        for (const ev of parseEventLines(text.slice(0, cut + 1))) {
+            if (ev.seq > lastSeq) {
+                onEvent(ev);
+                lastSeq = ev.seq;
+            }
+        }
+    };
+    let watcher;
+    try {
+        fs.mkdirSync(homeDir(), { recursive: true });
+        watcher = fs.watch(homeDir(), () => pump());
+    }
+    catch {
+        watcher = undefined; // the timer alone still works
+    }
+    const timer = setInterval(pump, 1000);
+    return () => {
+        clearInterval(timer);
+        watcher?.close();
+    };
+}
+//# sourceMappingURL=follow.js.map