harnery 0.32.0 → 0.34.0

package/dist/core/hooks/codex-authorization.d.ts

@@ -0,0 +1,30 @@
+export type CodexHookTrustStatus = "managed" | "trusted" | "untrusted" | "modified";
+export type CodexHookAuthorizationStatus = "runnable" | "review_required" | "disabled" | "not_wired" | "error";
+export interface CodexHookAuthorizationResult {
+    status: CodexHookAuthorizationStatus;
+    detail: string;
+    hookCount: number;
+    disabledCount: number;
+    trustCounts: Partial<Record<CodexHookTrustStatus, number>>;
+}
+export interface CodexHookAuthorizationProbeOptions {
+    cwd: string;
+    codexBin?: string;
+    appServerArgs?: string[];
+    env?: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+}
+/**
+ * Convert Codex app-server's `hooks/list` response into the one authorization
+ * state doctor needs. This is intentionally read-only: hashes are observed but
+ * never persisted, and only commands containing Harnery's `agent-hook` binary
+ * are included in the result.
+ */
+export declare function assessCodexHookList(response: unknown, cwd: string): CodexHookAuthorizationResult;
+/**
+ * Ask the active Codex CLI for hook authorization through its app-server
+ * protocol. The child is closed as soon as `hooks/list` responds. Harnery never
+ * calls the trust-write method and never reads Codex's private config format.
+ */
+export declare function probeCodexHookAuthorization(options: CodexHookAuthorizationProbeOptions): Promise<CodexHookAuthorizationResult>;
+//# sourceMappingURL=codex-authorization.d.ts.map

package/dist/core/hooks/codex-authorization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-authorization.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/codex-authorization.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,oBAAoB,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,CAAC;AAEpF,MAAM,MAAM,4BAA4B,GACpC,UAAU,GACV,iBAAiB,GACjB,UAAU,GACV,WAAW,GACX,OAAO,CAAC;AAEZ,MAAM,WAAW,4BAA4B;IAC3C,MAAM,EAAE,4BAA4B,CAAC;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,OAAO,CAAC,MAAM,CAAC,oBAAoB,EAAE,MAAM,CAAC,CAAC,CAAC;CAC5D;AAED,MAAM,WAAW,kCAAkC;IACjD,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AA0BD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,4BAA4B,CAqGhG;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,kCAAkC,GAC1C,OAAO,CAAC,4BAA4B,CAAC,CAoFvC"}

package/dist/core/hooks/codex-authorization.js

@@ -0,0 +1,199 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === "string")
+        : [];
+}
+function trustStatus(value) {
+    return value === "managed" || value === "trusted" || value === "untrusted" || value === "modified"
+        ? value
+        : null;
+}
+function normalizedPath(value) {
+    return value.replaceAll("\\", "/").replace(/\/$/, "").toLowerCase();
+}
+/**
+ * Convert Codex app-server's `hooks/list` response into the one authorization
+ * state doctor needs. This is intentionally read-only: hashes are observed but
+ * never persisted, and only commands containing Harnery's `agent-hook` binary
+ * are included in the result.
+ */
+export function assessCodexHookList(response, cwd) {
+    if (!isObject(response) || !isObject(response.result) || !Array.isArray(response.result.data)) {
+        return {
+            status: "error",
+            detail: "Codex hooks/list returned an invalid response",
+            hookCount: 0,
+            disabledCount: 0,
+            trustCounts: {},
+        };
+    }
+    const entries = response.result.data.filter(isObject);
+    const expected = normalizedPath(cwd);
+    const entry = entries.find((candidate) => {
+        const candidateCwd = candidate.cwd;
+        return typeof candidateCwd === "string" && normalizedPath(candidateCwd) === expected;
+    }) ?? (entries.length === 1 ? entries[0] : undefined);
+    if (!entry) {
+        return {
+            status: "error",
+            detail: "Codex hooks/list omitted the requested workspace",
+            hookCount: 0,
+            disabledCount: 0,
+            trustCounts: {},
+        };
+    }
+    const errors = stringArray(entry.errors);
+    if (errors.length > 0) {
+        return {
+            status: "error",
+            detail: `Codex could not load hooks: ${errors.join("; ")}`,
+            hookCount: 0,
+            disabledCount: 0,
+            trustCounts: {},
+        };
+    }
+    const hooks = Array.isArray(entry.hooks) ? entry.hooks.filter(isObject) : [];
+    const harneryHooks = hooks.filter((hook) => typeof hook.command === "string" && /(?:^|[\\/\s])agent-hook(?:\s|$)/.test(hook.command));
+    if (harneryHooks.length === 0) {
+        return {
+            status: "not_wired",
+            detail: "Codex discovered no Harnery hooks",
+            hookCount: 0,
+            disabledCount: 0,
+            trustCounts: {},
+        };
+    }
+    const counts = {};
+    let disabledCount = 0;
+    for (const hook of harneryHooks) {
+        const status = trustStatus(hook.trustStatus);
+        if (!status) {
+            return {
+                status: "error",
+                detail: "Codex returned an unknown hook trust state",
+                hookCount: harneryHooks.length,
+                disabledCount,
+                trustCounts: counts,
+            };
+        }
+        counts[status] = (counts[status] ?? 0) + 1;
+        if (hook.enabled !== true)
+            disabledCount += 1;
+    }
+    const reviewCount = (counts.untrusted ?? 0) + (counts.modified ?? 0);
+    const warnings = stringArray(entry.warnings);
+    const warningSuffix = warnings.length > 0 ? `; ${warnings.length} Codex warning(s)` : "";
+    if (reviewCount > 0) {
+        return {
+            status: "review_required",
+            detail: `${reviewCount} of ${harneryHooks.length} Harnery hooks require review` +
+                ` (${counts.untrusted ?? 0} new, ${counts.modified ?? 0} modified)${warningSuffix}`,
+            hookCount: harneryHooks.length,
+            disabledCount,
+            trustCounts: counts,
+        };
+    }
+    if (disabledCount > 0) {
+        return {
+            status: "disabled",
+            detail: `${disabledCount} of ${harneryHooks.length} trusted Harnery hooks are disabled${warningSuffix}`,
+            hookCount: harneryHooks.length,
+            disabledCount,
+            trustCounts: counts,
+        };
+    }
+    return {
+        status: "runnable",
+        detail: `${harneryHooks.length} Harnery hooks trusted and enabled${warningSuffix}`,
+        hookCount: harneryHooks.length,
+        disabledCount: 0,
+        trustCounts: counts,
+    };
+}
+/**
+ * Ask the active Codex CLI for hook authorization through its app-server
+ * protocol. The child is closed as soon as `hooks/list` responds. Harnery never
+ * calls the trust-write method and never reads Codex's private config format.
+ */
+export function probeCodexHookAuthorization(options) {
+    const codexBin = options.codexBin ?? "codex";
+    const args = options.appServerArgs ?? ["app-server"];
+    const timeoutMs = options.timeoutMs ?? 5_000;
+    return new Promise((resolve) => {
+        const child = spawn(codexBin, args, {
+            cwd: options.cwd,
+            env: options.env ?? process.env,
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        const lines = createInterface({ input: child.stdout });
+        let settled = false;
+        let stderr = "";
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            lines.close();
+            child.stdin.end();
+            child.kill();
+            resolve(result);
+        };
+        const fail = (detail) => finish({ status: "error", detail, hookCount: 0, disabledCount: 0, trustCounts: {} });
+        const timer = setTimeout(() => {
+            fail(`Codex hooks/list timed out after ${timeoutMs}ms`);
+        }, timeoutMs);
+        child.stderr.on("data", (chunk) => {
+            if (stderr.length < 4_096)
+                stderr += chunk.toString();
+        });
+        child.stdin.on("error", (error) => fail(`Codex app-server input failed: ${error.message}`));
+        child.on("error", (error) => fail(`could not start Codex app-server: ${error.message}`));
+        child.on("close", (code) => {
+            if (!settled) {
+                const suffix = stderr.trim() ? `: ${stderr.trim().slice(0, 500)}` : "";
+                fail(`Codex app-server exited before hooks/list completed (exit ${code ?? "unknown"})${suffix}`);
+            }
+        });
+        lines.on("line", (line) => {
+            let message;
+            try {
+                const parsed = JSON.parse(line);
+                if (!isObject(parsed))
+                    return;
+                message = parsed;
+            }
+            catch {
+                return;
+            }
+            if (message.id === 0) {
+                if (message.error) {
+                    fail("Codex app-server rejected initialization");
+                    return;
+                }
+                child.stdin.write(`${JSON.stringify({ method: "initialized" })}\n`);
+                child.stdin.write(`${JSON.stringify({ method: "hooks/list", id: 1, params: { cwds: [options.cwd] } })}\n`);
+                return;
+            }
+            if (message.id === 1) {
+                if (message.error) {
+                    fail("Codex app-server rejected hooks/list");
+                    return;
+                }
+                finish(assessCodexHookList(message, options.cwd));
+            }
+        });
+        child.stdin.write(`${JSON.stringify({
+            method: "initialize",
+            id: 0,
+            params: {
+                clientInfo: { name: "harnery_doctor", title: "Harnery Doctor", version: "0.0.0" },
+            },
+        })}\n`);
+    });
+}

package/dist/core/hooks/effects/image-capture.d.ts

@@ -1,43 +1,29 @@
 /**
- * Image-feed capture: a non-coordination side effect fired from the normalized
- * `agent-hook` tool handlers (see effects/index.ts for the family rationale).
+ * Privacy-safe image artifact capture for normalized tool hooks.
  *
- * When an agent VIEWS an image (Read tool on a `.png`/`.jpg`/…) or PRODUCES one
- * (a Bash command writes an image file via `harn browse`, `harn image`, `--diff`, …),
- * we content-address the bytes into `.harnery/images/<sha256>.<ext>` (dedup:
- * identical bytes collapse to one blob) and emit an `image.captured` event into
- * the canonical stream. The web image feed (`/images`) groups those events by
- * hash and streams them live over the existing SSE infra.
- *
- * Why this lives at the hook layer: it's the single adapter-agnostic chokepoint
- * that sees every tool call across Claude Code / Cursor / Codex with the full
- * `tool_input` (file paths) and `tool_response`. No per-command code needed.
- *
- * Everything here is best-effort and MUST NOT throw; callers wrap it in
- * try/catch + logError, matching every other effect.
+ * Image bytes are content-addressed under `.harnery/images/`. The canonical V3
+ * ledger receives an `artifact.observed` record after the source tool event is
+ * durable, so the web feed can recover provenance without retaining command,
+ * output, intent, or absolute paths.
  */
+import type { EventV3 } from "../../events/v3/contract.js";
 import type { ParsedPayload } from "../adapter/parse.js";
-import type { Adapter } from "../events/schema.js";
-export interface CaptureContext {
-    eventType: "tool.pre_use" | "tool.post_use";
-    /** The built event data (tool_name, tool_input string, intent, tool_use_id). */
-    data: Record<string, unknown>;
-    /** The full parsed payload, used for the un-clamped command + tool_response. */
-    payload: ParsedPayload | null;
-    instanceId: string;
-    sessionId: string;
-    adapter: Adapter;
+export interface CapturedImageArtifact {
+    hash: string;
+    ext: string;
+    bytes: number;
+    role: "viewed" | "produced";
+    workspace_path?: string;
 }
+/** Copy every qualifying image referenced by one tool hook into the blob store. */
+export declare function captureImages(coordRoot: string, eventType: "tool.requested" | "tool.completed", payload: ParsedPayload | null): CapturedImageArtifact[];
 /**
- * Inspect one tool event for image references and capture any that resolve to
- * a real image on disk. Emits zero or more `image.captured` events.
- */
-export declare function captureImages(coordRoot: string, ctx: CaptureContext): void;
-/**
- * Prune `.harnery/images/` past a size cap (default 2 GB) and an age cap
- * (default 30 days), oldest-mtime-first. Fired on session.start next to
- * journalJanitor. Pure-fs, fail-soft. Orphaned `image.captured` events whose
- * blob was pruned render as an "expired" placeholder in the gallery.
+ * Emit content-addressed image references as canonical V3 artifact events.
+ * Each observation uses a one-event producer boot, which preserves independent
+ * producer sequence continuity while the ledger writer serializes appends.
  */
+export declare function recordImageArtifactsV3(coordRoot: string, sourceEvent: EventV3, artifacts: readonly CapturedImageArtifact[]): void;
+export declare function buildImageArtifactEventV3(sourceEvent: EventV3, artifact: CapturedImageArtifact): EventV3;
+/** Prune the bounded blob store by age and total size, oldest first. */
 export declare function imageJanitor(coordRoot: string): void;
 //# sourceMappingURL=image-capture.d.ts.map

package/dist/core/hooks/effects/image-capture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-capture.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/effects/image-capture.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAcH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAoBnD,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,cAAc,GAAG,eAAe,CAAC;IAC5C,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,gFAAgF;IAChF,OAAO,EAAE,aAAa,GAAG,IAAI,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;CAClB;AAUD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,cAAc,GAAG,IAAI,CAoC1E;AA2FD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAmDpD"}
+{"version":3,"file":"image-capture.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/effects/image-capture.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAeH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAE3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAgBzD,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAC;IAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAQD,mFAAmF;AACnF,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,gBAAgB,GAAG,gBAAgB,EAC9C,OAAO,EAAE,aAAa,GAAG,IAAI,GAC5B,qBAAqB,EAAE,CA0BzB;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,OAAO,EACpB,SAAS,EAAE,SAAS,qBAAqB,EAAE,GAC1C,IAAI,CAKN;AAED,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,OAAO,EACpB,QAAQ,EAAE,qBAAqB,GAC9B,OAAO,CA4CT;AAED,wEAAwE;AACxE,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CA0CpD"}