@shanesaravia/hive 0.1.0

package/packages/server/dist/watch/jobsWatcher.js

@@ -0,0 +1,224 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { config } from "../config.js";
+/**
+ * Watches ~/.claude/jobs/<jobId>/state.json for every job directory (fs.watch
+ * with recursive: true on macOS) and tails each job's timeline.jsonl by byte
+ * offset rather than re-reading the whole file, since these logs grow large.
+ */
+export class JobsWatcher {
+    jobs = new Map();
+    timelineOffsets = new Map();
+    jobsListeners = new Set();
+    timelineListeners = new Set();
+    debounceTimer;
+    watchers = [];
+    start() {
+        const directories = [config.jobsDir, config.codexJobsDir];
+        for (const directory of directories)
+            fs.mkdirSync(directory, { recursive: true });
+        this.reloadAll();
+        this.watchers = directories.map((directory) => fs.watch(directory, { persistent: true, recursive: true }, () => {
+            this.scheduleReload();
+        }));
+    }
+    stop() {
+        for (const watcher of this.watchers)
+            watcher.close();
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+    }
+    onJobsChange(listener) {
+        this.jobsListeners.add(listener);
+    }
+    onTimelineAppend(listener) {
+        this.timelineListeners.add(listener);
+    }
+    getAll() {
+        return this.jobs;
+    }
+    scheduleReload() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => this.reloadAll(), 50);
+    }
+    reloadAll() {
+        const next = new Map();
+        for (const directory of [config.jobsDir, config.codexJobsDir])
+            for (const jobId of listDirectories(directory)) {
+                const statePath = path.join(directory, jobId, "state.json");
+                try {
+                    const raw = fs.readFileSync(statePath, "utf-8");
+                    const job = JSON.parse(raw);
+                    // The daemon compresses the model's final message: blocked turns keep
+                    // only a terse question in needs/detail, and done turns store a
+                    // one-line summary in output.result. The full reply lives in the
+                    // session transcript (timeline text is a 4KB tail as fallback).
+                    if (job.state === "done" || job.state === "blocked") {
+                        job.lastText = this.resolveLastText(jobId, job, directory);
+                    }
+                    next.set(jobId, job);
+                }
+                catch {
+                    continue;
+                }
+                this.tailTimeline(jobId, directory);
+            }
+        this.jobs = next;
+        for (const listener of this.jobsListeners)
+            listener(this.jobs);
+    }
+    lastTextCache = new Map();
+    /** Cached per job/updatedAt so reloads don't re-read transcripts. */
+    resolveLastText(jobId, job, directory) {
+        const cached = this.lastTextCache.get(jobId);
+        if (cached && cached.updatedAt === job.updatedAt)
+            return cached.text;
+        const text = readTranscriptFinalText(job.sessionId)
+            ?? readLatestTimelineText(path.join(directory, jobId, "timeline.jsonl"));
+        this.lastTextCache.set(jobId, { updatedAt: job.updatedAt, text });
+        return text;
+    }
+    tailTimeline(jobId, directory) {
+        const timelinePath = path.join(directory, jobId, "timeline.jsonl");
+        let size;
+        try {
+            size = fs.statSync(timelinePath).size;
+        }
+        catch {
+            return;
+        }
+        const prevOffset = this.timelineOffsets.get(jobId) ?? 0;
+        if (size <= prevOffset) {
+            if (size < prevOffset)
+                this.timelineOffsets.set(jobId, 0); // file truncated/rotated
+            return;
+        }
+        const fd = fs.openSync(timelinePath, "r");
+        try {
+            const buf = Buffer.alloc(size - prevOffset);
+            fs.readSync(fd, buf, 0, buf.length, prevOffset);
+            this.timelineOffsets.set(jobId, size);
+            const lines = buf
+                .toString("utf-8")
+                .split("\n")
+                .map((l) => l.trim())
+                .filter(Boolean);
+            if (lines.length) {
+                for (const listener of this.timelineListeners)
+                    listener(jobId, lines);
+            }
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+}
+const TRANSCRIPT_TAIL_BYTES = 256 * 1024;
+/** Locates the session's transcript under ~/.claude/projects and returns the
+ * last assistant text message — the model's actual final reply. */
+function readTranscriptFinalText(sessionId) {
+    if (!sessionId)
+        return undefined;
+    const root = path.join(os.homedir(), ".claude", "projects");
+    let dirs;
+    try {
+        dirs = fs.readdirSync(root);
+    }
+    catch {
+        return undefined;
+    }
+    for (const dir of dirs) {
+        const file = path.join(root, dir, `${sessionId}.jsonl`);
+        if (!fs.existsSync(file))
+            continue;
+        return finalAssistantText(file);
+    }
+    return undefined;
+}
+function finalAssistantText(file) {
+    let fd;
+    try {
+        fd = fs.openSync(file, "r");
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const size = fs.fstatSync(fd).size;
+        const offset = Math.max(0, size - TRANSCRIPT_TAIL_BYTES);
+        const buf = Buffer.alloc(size - offset);
+        fs.readSync(fd, buf, 0, buf.length, offset);
+        const lines = buf.toString("utf-8").split("\n");
+        // Skip a line truncated by the tail window (index 0 when offset > 0).
+        for (let i = lines.length - 1; i >= (offset > 0 ? 1 : 0); i--) {
+            const line = lines[i].trim();
+            if (!line)
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                if (entry.type !== "assistant" || !Array.isArray(entry.message?.content))
+                    continue;
+                const text = entry.message.content
+                    .filter((item) => item?.type === "text" && typeof item.text === "string")
+                    .map((item) => item.text)
+                    .join("\n")
+                    .trim();
+                if (text)
+                    return text;
+            }
+            catch {
+                continue;
+            }
+        }
+        return undefined;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+const TIMELINE_TAIL_BYTES = 64 * 1024;
+/** Latest non-empty assistant `text` from the tail of a timeline.jsonl. */
+function readLatestTimelineText(timelinePath) {
+    let fd;
+    try {
+        fd = fs.openSync(timelinePath, "r");
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const size = fs.fstatSync(fd).size;
+        const offset = Math.max(0, size - TIMELINE_TAIL_BYTES);
+        const buf = Buffer.alloc(size - offset);
+        fs.readSync(fd, buf, 0, buf.length, offset);
+        const lines = buf.toString("utf-8").split("\n");
+        // Skip a line truncated by the tail window (index 0 when offset > 0).
+        for (let i = lines.length - 1; i >= (offset > 0 ? 1 : 0); i--) {
+            const line = lines[i].trim();
+            if (!line)
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                if (typeof entry.text === "string" && entry.text.trim())
+                    return entry.text;
+            }
+            catch {
+                continue;
+            }
+        }
+        return undefined;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function listDirectories(directory) {
+    try {
+        return fs.readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+}

package/packages/server/dist/watch/sessionsWatcher.js

@@ -0,0 +1,65 @@
+import fs from "node:fs";
+import path from "node:path";
+import { config } from "../config.js";
+/**
+ * Watches ~/.claude/sessions/*.json with fs.watch (no polling) and keeps an
+ * in-memory map of live sessions keyed by pid. Debounced to coalesce bursts
+ * of writes into a single roster rebuild.
+ */
+export class SessionsWatcher {
+    sessions = new Map();
+    listeners = new Set();
+    debounceTimer;
+    watchers = [];
+    start() {
+        const directories = [config.sessionsDir, config.codexSessionsDir];
+        for (const directory of directories)
+            fs.mkdirSync(directory, { recursive: true });
+        this.reloadAll();
+        this.watchers = directories.map((directory) => fs.watch(directory, { persistent: true }, () => {
+            this.scheduleReload();
+        }));
+    }
+    stop() {
+        for (const watcher of this.watchers)
+            watcher.close();
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+    }
+    onChange(listener) {
+        this.listeners.add(listener);
+    }
+    getAll() {
+        return this.sessions;
+    }
+    scheduleReload() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => this.reloadAll(), 50);
+    }
+    reloadAll() {
+        const next = new Map();
+        for (const directory of [config.sessionsDir, config.codexSessionsDir])
+            for (const entry of safeEntries(directory)) {
+                if (!entry.endsWith(".json"))
+                    continue;
+                try {
+                    const raw = fs.readFileSync(path.join(directory, entry), "utf-8");
+                    const parsed = JSON.parse(raw);
+                    next.set(parsed.pid, parsed);
+                }
+                catch {
+                    // file mid-write or malformed; skip this cycle, next watch event will retry
+                }
+            }
+        this.sessions = next;
+        for (const listener of this.listeners)
+            listener(this.sessions);
+    }
+}
+function safeEntries(directory) { try {
+    return fs.readdirSync(directory);
+}
+catch {
+    return [];
+} }