@cmgmyr/hive 1.2.1 → 1.3.0

package/dist/globalConfig.js

@@ -0,0 +1,247 @@
+import { randomUUID } from "node:crypto";
+import { chmodSync, closeSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { isMap, parse, parseDocument } from "yaml";
+import { storeDir } from "./dataDir.js";
+import { errorMessage } from "./result.js";
+export const ATTACH_MODES = ["auto", "raw", "control"];
+export const AUTO_ATTACH_MODES = ["auto", "on", "off"];
+export function isAttachMode(value) {
+    return ATTACH_MODES.includes(value);
+}
+export function isAutoAttach(value) {
+    return AUTO_ATTACH_MODES.includes(value);
+}
+export function globalConfigPath() {
+    return join(storeDir(), "hive.yml");
+}
+function isMapping(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+export function isEmptyYamlDocument(text) {
+    return text.split(/\r?\n/).every((line) => /^\s*(?:#.*)?$/.test(line));
+}
+function readLayer(path, kind, warnings) {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            warnings.push(`${path}: could not read configuration: ${errorMessage(error)}`);
+        }
+        return null;
+    }
+    let value;
+    try {
+        value = kind === "yaml" ? parse(text) : JSON.parse(text);
+    }
+    catch (error) {
+        warnings.push(`${path}: ${kind === "yaml" ? "hive.yml is not valid YAML" : "config.json is not valid JSON"}: ${errorMessage(error)}`);
+        return null;
+    }
+    if (kind === "yaml" && value == null && isEmptyYamlDocument(text))
+        return null;
+    if (!isMapping(value)) {
+        warnings.push(`${path}: ${kind === "yaml" ? "configuration must be a YAML mapping." : "config.json must be a JSON object."}`);
+        return null;
+    }
+    return value;
+}
+export function readGlobalConfig() {
+    const dir = storeDir();
+    const warnings = [];
+    const root = readLayer(join(dir, "hive.yml"), "yaml", warnings);
+    const legacy = readLayer(join(dir, "config.json"), "json", warnings) ?? {};
+    return { root, legacy, warnings };
+}
+function readEditableDocument(path, allowMissing) {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        if (allowMissing && error.code === "ENOENT")
+            return parseDocument("");
+        throw new Error(`${path}: could not read hive.yml: ${errorMessage(error)}`);
+    }
+    const document = parseDocument(text);
+    if (document.errors.length > 0) {
+        throw new Error(`${path}: hive.yml is not valid YAML: ${document.errors.map(errorMessage).join("; ")}`);
+    }
+    if (!isMap(document.contents))
+        throw new Error(`${path}: hive.yml must be a YAML mapping.`);
+    return document;
+}
+function writeAtomicYaml(path, text) {
+    let mode = 0o600;
+    try {
+        mode = statSync(path).mode & 0o777;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const candidate = join(dirname(path), `.${basename(path)}.${process.pid}.${randomUUID()}.tmp`);
+    let temp = null;
+    let fd = null;
+    try {
+        fd = openSync(candidate, "wx", 0o600);
+        temp = candidate;
+        writeFileSync(fd, text, { encoding: "utf8" });
+        closeSync(fd);
+        fd = null;
+        chmodSync(candidate, mode);
+        renameSync(candidate, path);
+        temp = null;
+    }
+    finally {
+        if (fd !== null) {
+            try {
+                closeSync(fd);
+            }
+            catch {
+            }
+        }
+        if (temp !== null) {
+            try {
+                unlinkSync(temp);
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+        }
+    }
+}
+function updateGlobalDocument(dir, update) {
+    mkdirSync(dir, { recursive: true });
+    const path = join(dir, "hive.yml");
+    const document = readEditableDocument(path, true);
+    if (!update(document))
+        return false;
+    let text;
+    try {
+        text = document.toString();
+    }
+    catch (error) {
+        throw new Error(`${path}: could not serialize hive.yml: ${errorMessage(error)}`);
+    }
+    try {
+        writeAtomicYaml(path, text);
+    }
+    catch (error) {
+        throw new Error(`${path}: could not write hive.yml: ${errorMessage(error)}`);
+    }
+    return true;
+}
+export function writeGlobalConfigKey(key, value) {
+    const dir = storeDir();
+    updateGlobalDocument(dir, (document) => {
+        document.set(key, value);
+        return true;
+    });
+}
+export function migrateLegacyConfig() {
+    const dir = storeDir();
+    const legacyPath = join(dir, "config.json");
+    const archivePath = `${legacyPath}.migrated`;
+    const globalPath = join(dir, "hive.yml");
+    const refusal = (path, warning) => ({
+        migrated: false,
+        notice: null,
+        warnings: [`${path}: ${warning}`],
+    });
+    let legacyText;
+    try {
+        legacyText = readFileSync(legacyPath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { migrated: false, notice: null, warnings: [] };
+        return refusal(legacyPath, `could not read config.json: ${errorMessage(error)}`);
+    }
+    try {
+        lstatSync(archivePath);
+        return refusal(legacyPath, `archive ${archivePath} already exists; refusing to overwrite it.`);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            return refusal(archivePath, `could not check migration archive: ${errorMessage(error)}`);
+        }
+    }
+    let legacy;
+    try {
+        const raw = JSON.parse(legacyText);
+        if (!isMapping(raw))
+            return refusal(legacyPath, "config.json must be a JSON object.");
+        legacy = raw;
+    }
+    catch (error) {
+        return refusal(legacyPath, `config.json is not valid JSON: ${errorMessage(error)}`);
+    }
+    try {
+        updateGlobalDocument(dir, (document) => {
+            let changed = false;
+            for (const [key, value] of Object.entries(legacy)) {
+                if (key === "review_tags" || document.has(key))
+                    continue;
+                document.set(key, value);
+                changed = true;
+            }
+            return changed;
+        });
+    }
+    catch (error) {
+        const message = errorMessage(error);
+        const warning = message.startsWith(`${globalPath}:`)
+            ? message
+            : `${globalPath}: could not update hive.yml: ${message}`;
+        return { migrated: false, notice: null, warnings: [warning] };
+    }
+    try {
+        renameSync(legacyPath, archivePath);
+    }
+    catch (error) {
+        return refusal(legacyPath, `could not archive config.json as ${archivePath}: ${errorMessage(error)}`);
+    }
+    return {
+        migrated: true,
+        notice: `hive: migrated ${legacyPath} into ${globalPath}; original saved as ${archivePath}.`,
+        warnings: [],
+    };
+}
+export function resolveAttachSetting(key, global, legacy, warnings) {
+    const mode = key === "attach";
+    const env = mode
+        ? isAttachMode(process.env.HIVE_ATTACH_MODE) ? process.env.HIVE_ATTACH_MODE : null
+        : process.env.HIVE_AUTO_ATTACH === "0"
+            ? "off"
+            : isAutoAttach(process.env.HIVE_AUTO_ATTACH) ? process.env.HIVE_AUTO_ATTACH : null;
+    if (env != null)
+        return mode ? { mode: env, source: "env" } : { value: env, source: "env" };
+    const path = globalConfigPath();
+    if (global && Object.hasOwn(global, key)) {
+        const value = global[key];
+        if (value == null)
+            return mode ? { mode: "auto", source: "global" } : { value: "auto", source: "global" };
+        if (mode ? isAttachMode(value) : isAutoAttach(value)) {
+            return mode ? { mode: value, source: "global" } : { value: value, source: "global" };
+        }
+        warnings.push(`${path}: ${key} must be one of ${(mode ? ["auto", "raw", "control"] : ["auto", "on", "off"]).join(", ")}; ignoring "${String(value)}".`);
+        return mode ? { mode: "auto", source: "built-in" } : { value: "auto", source: "built-in" };
+    }
+    if (Object.hasOwn(legacy, key)) {
+        const value = legacy[key];
+        if (value == null)
+            return mode ? { mode: "auto", source: "global" } : { value: "auto", source: "global" };
+        if (mode ? isAttachMode(value) : isAutoAttach(value)) {
+            return mode ? { mode: value, source: "global" } : { value: value, source: "global" };
+        }
+        warnings.push(`${path.replace(/hive\.yml$/, "config.json")}: ${key} has an invalid value; ignoring it.`);
+    }
+    return mode ? { mode: "auto", source: "built-in" } : { value: "auto", source: "built-in" };
+}

package/dist/harnesses.js

@@ -171,3 +171,11 @@ export function transcriptDirFor(command) {
 export function hasTranscriptSignal(row) {
     return transcriptDirFor(row.command) || row.transcript_path !== "";
 }
+export function readOnlyExtraArgsAllowed(harness, args = []) {
+    const allowlist = {
+        codex: { flag: "-c", value: /^model_reasoning_effort=(low|medium|high|xhigh)$/ },
+        claude: { flag: "--effort", value: /^(low|medium|high|xhigh|max)$/ },
+    };
+    const allowed = allowlist[harness];
+    return allowed != null && args.length % 2 === 0 && args.every((arg, index) => index % 2 === 0 ? arg === allowed.flag : allowed.value.test(arg));
+}

package/dist/help.js

@@ -1,5 +1,5 @@
 export function helpOverview() {
-    return `HIVE — shared memory and coordination across Claude Code sessions
+    return `HIVE — a lead session and a crew of Claude Code and Codex workers, sharing one local store
 
 Many workers, one shared memory. Multiple Claude sessions (and humans) share
 one project-scoped state store: pads, todos, kv, leases.
@@ -126,7 +126,7 @@ If the human asks to change how work runs here, that is an edit to the
 runbook (fork it first), not a pad write.`,
     agents: `AGENTS — spawn and drive worker sessions in tmux
 
-  agent_spawn(name?, model?, command?, extra_args?, cwd?, placement?, layout?) —
+  agent_spawn(name?, model?, command?, extra_args?, read_only?, cwd?, placement?, layout?) —
     start a worker (default command: claude) in session hive-main.
     placement="split" (default) tiles the worker as a pane in the lead's
     window so the whole crew shares one screen; placement="window" gives it

package/dist/hooks.js

@@ -39,7 +39,8 @@ export function ensureWorkerHooksFile(agentId, options) {
     const settings = {
         ...stateHookSettings(),
         statusLine: statusLineEntry(effectiveClaudeStatusLine(worker.cwd)),
-        permissions: { deny: ["SendMessage", "ListAgents"] },
+        permissions: { deny: ["SendMessage", "ListAgents", ...(options.readOnly ? ["Edit", "Write", "NotebookEdit"] : [])] },
+        ...(options.readOnly ? { sandbox: { enabled: true, failIfUnavailable: true, autoAllowBashIfSandboxed: true, allowUnsandboxedCommands: false, filesystem: { denyWrite: ["//"] } } } : {}),
         crossSessionInbound: "refuse",
     };
     if (options.includePostToolUse)

package/dist/kickoff.js

@@ -1,6 +1,5 @@
 import { execFileSync } from "node:child_process";
-import { existsSync, realpathSync } from "node:fs";
-import { join } from "node:path";
+import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { cutToUnitBudget } from "./slug.js";
 export const OUTPUT_BUDGET = 10_000;
@@ -116,12 +115,12 @@ export async function evaluate(cwd, opts = {}) {
     catch {
         return { fired: false, reason: "cwd does not exist" };
     }
-    if (!existsSync(join(dir, "hive.yml")))
-        return { fired: false, reason: "no hive.yml here" };
     const { activeProfile, DEFAULT_LEAD_BRANCHES, loadProjectYml } = await import("./projectYml.js");
     const { profileExists } = await import("./profiles.js");
     const { config, warnings } = loadProjectYml(dir);
     const silent = (reason) => ({ fired: false, reason, warnings });
+    if (config == null)
+        return silent("no hive.yml here");
     const profile = activeProfile(config);
     if (!profile)
         return silent("no profile in hive.yml");