@cmgmyr/hive 0.1.0

package/dist/statusline.js

@@ -0,0 +1,82 @@
+import { execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { claudeConfigDir } from "./claudeDir.js";
+import { claudeWindowPath } from "./transcript.js";
+import { shellQuote } from "./tmux.js";
+export function effectiveClaudeStatusLine(cwd) {
+    let setting = null;
+    for (const path of [
+        join(claudeConfigDir(), "settings.json"),
+        join(cwd, ".claude", "settings.json"),
+        join(cwd, ".claude", "settings.local.json"),
+    ]) {
+        try {
+            const value = JSON.parse(readFileSync(path, "utf8")).statusLine;
+            if (value === undefined)
+                continue;
+            setting = value?.type === "command" && typeof value.command === "string" ? value : null;
+        }
+        catch { }
+    }
+    return setting;
+}
+export function recordClaudeWindowSize(actorId, statusLineInput) {
+    if (!actorId.startsWith("agent:"))
+        return;
+    let staging;
+    try {
+        const size = JSON.parse(statusLineInput)?.context_window?.context_window_size;
+        if (typeof size !== "number" || !Number.isSafeInteger(size) || size <= 0)
+            return;
+        const path = claudeWindowPath(actorId);
+        const body = JSON.stringify(size) + "\n";
+        try {
+            if (readFileSync(path, "utf8") === body)
+                return;
+        }
+        catch { }
+        mkdirSync(dirname(path), { recursive: true });
+        staging = `${path}.${randomUUID()}.tmp`;
+        writeFileSync(staging, body, { flag: "wx", mode: 0o600 });
+        renameSync(staging, path);
+    }
+    catch {
+    }
+    finally {
+        if (staging) {
+            try {
+                unlinkSync(staging);
+            }
+            catch { }
+        }
+    }
+}
+export function statusLineEntry(userSetting) {
+    const script = fileURLToPath(import.meta.url);
+    return {
+        ...userSetting,
+        type: "command",
+        command: `${shellQuote(process.execPath)} ${shellQuote(script)} ${shellQuote(userSetting?.command ?? "")}`,
+    };
+}
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    try {
+        const input = readFileSync(0);
+        recordClaudeWindowSize(process.env.HIVE_AGENT_ID ?? "", input.toString("utf8"));
+        const command = process.argv[2];
+        if (command) {
+            try {
+                process.stdout.write(execFileSync("/bin/sh", ["-c", command], { input, stdio: ["pipe", "pipe", "inherit"] }));
+            }
+            catch (error) {
+                const stdout = error.stdout;
+                if (stdout)
+                    process.stdout.write(stdout);
+            }
+        }
+    }
+    catch { }
+}

package/dist/strictInput.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+function isBuiltSchema(value) {
+    return typeof value === "object" && value !== null && ("_zod" in value || "_def" in value);
+}
+function strictSchemaFor(toolName, inputSchema) {
+    if (inputSchema === undefined)
+        return undefined;
+    if (isBuiltSchema(inputSchema)) {
+        throw new Error(`Tool "${toolName}" passed a built Zod schema as its inputSchema. hive registers tools with a ` +
+            "raw shape so src/strictInput.ts can make every tool strict in one place. Pass the shape, or " +
+            "make your schema strict yourself and widen this check deliberately.");
+    }
+    return z.strictObject(inputSchema);
+}
+// The SDK requires structuredContent whenever outputSchema is declared but never populates it itself,
+// so this stays scoped to declaring tools rather than attached blanket in src/result.ts's ok().
+function withStructuredContent(name, cb) {
+    return async (...args) => {
+        const result = (await cb(...args));
+        if (result.isError || result.structuredContent)
+            return result;
+        const first = result.content[0];
+        const text = first?.type === "text" ? first.text : undefined;
+        let parsed;
+        try {
+            parsed = text !== undefined ? JSON.parse(text) : undefined;
+        }
+        catch {
+            parsed = undefined;
+        }
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+            result.structuredContent = parsed;
+            return result;
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `hive: tool "${name}" declares outputSchema but its result was not a JSON object, so ` +
+                        "src/strictInput.ts's withStructuredContent could not build structuredContent from it. This " +
+                        "is a bug in the tool's handler, not in this call's input.",
+                },
+            ],
+            isError: true,
+        };
+    };
+}
+export function enforceStrictInput(server) {
+    const register = server.registerTool.bind(server);
+    server.registerTool = ((name, config, cb) => register(name, { ...config, inputSchema: strictSchemaFor(name, config.inputSchema) }, (config.outputSchema ? withStructuredContent(name, cb) : cb)));
+    return server;
+}

package/dist/teardown.js

@@ -0,0 +1,89 @@
+import { appendFileSync, existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+export const TEARDOWN_LOG = "teardowns.jsonl";
+// A backstop against a runaway writer, not a retention policy.
+export const TEARDOWN_MAX_RECORDS = 200;
+export const NOT_ATTRIBUTED = "not attributed";
+export const TEARDOWN_TRIGGER = "no panes on the socket";
+export function teardownLogPath(dataDir) {
+    return join(dataDir, TEARDOWN_LOG);
+}
+export function sqlNow(now = new Date()) {
+    return now.toISOString().replace("T", " ").slice(0, 23);
+}
+const sqlToDate = (ts) => new Date(`${ts.replace(" ", "T")}Z`);
+export function teardownWindow(from, to, basis) {
+    const seconds = (sqlToDate(to).getTime() - sqlToDate(from).getTime()) / 1000;
+    return { from, to, basis, width_seconds: Number.isFinite(seconds) ? Math.max(0, seconds) : 0 };
+}
+export function appendTeardown(dataDir, record) {
+    const path = teardownLogPath(dataDir);
+    const line = JSON.stringify(record);
+    const existing = existsSync(path) ? readFileSync(path, "utf8").split("\n").filter(Boolean) : [];
+    if (existing.length + 1 > TEARDOWN_MAX_RECORDS) {
+        // Trimming rewrites the whole file, so it goes via a temp path and a rename: a crash mid-write
+        // would otherwise cost the entire log, and this file is the only durable trace of the thing it
+        // describes.
+        const staging = `${path}.trimming`;
+        writeFileSync(staging, `${[...existing, line].slice(-TEARDOWN_MAX_RECORDS).join("\n")}\n`);
+        renameSync(staging, path);
+        return;
+    }
+    appendFileSync(path, `${line}\n`);
+}
+// Every field a reader DEREFERENCES is checked, members included. project_id is deliberately not
+// required: a record written before that field existed is readable, and its members count as
+// unknown-project rather than costing the whole record.
+function isTeardownMember(v) {
+    const m = v;
+    return (typeof m === "object" &&
+        m !== null &&
+        typeof m.agent_id === "number" &&
+        typeof m.actor_id === "string" &&
+        typeof m.name === "string" &&
+        typeof m.cwd === "string" &&
+        typeof m.session_id === "string" &&
+        typeof m.swept === "boolean");
+}
+function isTeardownRecord(v) {
+    const r = v;
+    return (typeof r === "object" &&
+        r !== null &&
+        typeof r.detected_at === "string" &&
+        typeof r.socket === "string" &&
+        typeof r.attribution === "string" &&
+        typeof r.window === "object" &&
+        r.window !== null &&
+        typeof r.window.from === "string" &&
+        typeof r.window.to === "string" &&
+        typeof r.window.width_seconds === "number" &&
+        Array.isArray(r.crew) &&
+        r.crew.every(isTeardownMember));
+}
+// This file sits in the user's data dir and doctor is what people run once things are ALREADY
+// broken, so a record hive did not write must cost that record and never the report.
+export function readTeardowns(dataDir) {
+    const path = teardownLogPath(dataDir);
+    if (!existsSync(path))
+        return [];
+    const records = [];
+    for (const line of readFileSync(path, "utf8").split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (isTeardownRecord(parsed))
+                records.push(parsed);
+        }
+        catch {
+            // A half-written last line costs the reader that record, never the whole file.
+        }
+    }
+    return records;
+}
+export function describeTeardownWindow(w) {
+    const width = w.width_seconds < 90 ? `${Math.round(w.width_seconds)}s` : `${Math.round(w.width_seconds / 60)}m`;
+    return w.basis === "observed"
+        ? `between ${w.from} and ${w.to} (${width} wide; hive was watching this socket and saw it alive at the start of that window)`
+        : `between ${w.from} and ${w.to} (${width} wide; NO hive process survived to watch, so the start is only the newest evidence in the store, not a sighting)`;
+}