project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/long-task-hook-install.js

@@ -1,381 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-const MANAGED_STATUS = "Tiny Context long-task live authority gate";
-const PRE_TOOL_USE_MATCHER = "^(spawn_agent|Agent)$";
-const LONG_TASK_IMPLEMENTATION_AGENT_MATCHER = "^long_task_implementation$";
-const MANAGED_HOOK_EVENTS = [
-    "PreToolUse",
-    "SessionStart",
-    "PostCompact",
-    "Stop",
-    "SubagentStart",
-];
-const MANAGED_MATCHERS = new Set([
-    PRE_TOOL_USE_MATCHER,
-    LONG_TASK_IMPLEMENTATION_AGENT_MATCHER,
-]);
-const LEGACY_MANAGED_STATUSES = new Set([
-    "Tiny Context long-task live authority gate",
-    "Tiny Context long-task authority gate",
-    "Tiny Context long-task completion gate",
-    "Tiny Context composite completion gate",
-]);
-const LEGACY_REPO_LOCAL_COMMANDS = new Set([
-    'node "$(git rev-parse --show-toplevel)/.codex/hooks/long-task-hook.mjs"',
-    "powershell -NoProfile -Command \"$r=(git rev-parse --show-toplevel); node (Join-Path $r '.codex/hooks/long-task-hook.mjs')\"",
-    "node .codex/hooks/long-task-hook.mjs",
-    'node ".codex/hooks/long-task-hook.mjs"',
-    "node .codex\\hooks\\long-task-hook.mjs",
-    'node ".codex\\hooks\\long-task-hook.mjs"',
-]);
-export const LONG_TASK_HOOK_TRUST_REVIEW_NOTICE = "Codex Hook review required: open /hooks and trust the current Tiny Context project Hook before relying on PreToolUse, SubagentStart, SessionStart or Stop behavior. Tiny Context cannot observe or persist Codex Hook trust.";
-const DEFAULT_FILE_OPERATIONS = {
-    lstat: (target) => fs.lstat(target),
-    readFile: (target, encoding) => fs.readFile(target, encoding),
-    mkdir: (target, options) => fs.mkdir(target, options),
-    writeFile: (target, content, options) => fs.writeFile(target, content, options),
-    rename: (source, destination) => fs.rename(source, destination),
-    rm: (target, options) => fs.rm(target, options),
-    randomId: () => randomUUID(),
-};
-export async function installLongTaskHooks(projectRoot, report, fileOperations = {}) {
-    const operations = operationsWith(fileOperations);
-    const packageRoot = fileURLToPath(new URL("../../", import.meta.url));
-    const entry = path.join(packageRoot, "dist", "long-task-hook.js");
-    const entryStatus = await lstatOrNull(entry, operations);
-    if (!entryStatus || entryStatus.isSymbolicLink() || !entryStatus.isFile()) {
-        report.blocked.push("package-owned dist/long-task-hook.js is missing");
-        return;
-    }
-    const config = path.join(projectRoot, ".codex", "hooks.json");
-    const legacyScript = path.join(projectRoot, ".codex", "hooks", "long-task-hook.mjs");
-    try {
-        const legacy = await inspectLegacyScript(projectRoot, operations);
-        const loaded = await readHookConfig(projectRoot, true, operations);
-        const command = packageOwnedCommand(entry);
-        const packageHooksWereCurrent = packageHooksAreCurrent(loaded.root, command);
-        const next = mergeManagedHooks(loaded.root, command);
-        const content = `${JSON.stringify(next, null, 2)}\n`;
-        if (loaded.snapshot.kind === "regular" &&
-            loaded.snapshot.content === content) {
-            report.skipped.push(".codex/hooks.json");
-        }
-        else {
-            await publishHookConfig(config, loaded.snapshot, content, operations);
-            report.changed.push(".codex/hooks.json");
-            if (!packageHooksWereCurrent)
-                addNotice(report);
-        }
-        await removeLegacyScriptIfPresent(projectRoot, legacyScript, legacy, report, operations);
-    }
-    catch (error) {
-        report.blocked.push(`.codex/hooks.json: ${message(error)}`);
-    }
-}
-export async function uninstallLongTaskHooks(projectRoot, report, fileOperations = {}) {
-    const operations = operationsWith(fileOperations);
-    const packageRoot = fileURLToPath(new URL("../../", import.meta.url));
-    const command = packageOwnedCommand(path.join(packageRoot, "dist", "long-task-hook.js"));
-    const config = path.join(projectRoot, ".codex", "hooks.json");
-    const legacyScript = path.join(projectRoot, ".codex", "hooks", "long-task-hook.mjs");
-    try {
-        const legacy = await inspectLegacyScript(projectRoot, operations);
-        const loaded = await readHookConfig(projectRoot, false, operations);
-        let removed = 0;
-        const hooks = hookMap(loaded.root);
-        for (const event of MANAGED_HOOK_EVENTS) {
-            if (!Array.isArray(hooks[event]))
-                continue;
-            const cleaned = removeManagedHookEntries(hooks[event], command);
-            removed += cleaned.removed;
-            if (cleaned.groups.length)
-                hooks[event] = cleaned.groups;
-            else
-                delete hooks[event];
-        }
-        if (removed > 0 && loaded.snapshot.kind === "regular") {
-            loaded.root.hooks = hooks;
-            if (Object.keys(hooks).length === 0 &&
-                Object.keys(loaded.root).length === 1)
-                await removeHookConfig(config, loaded.snapshot, operations);
-            else
-                await publishHookConfig(config, loaded.snapshot, `${JSON.stringify(loaded.root, null, 2)}\n`, operations);
-            report.changed.push(".codex/hooks.json");
-        }
-        await removeLegacyScriptIfPresent(projectRoot, legacyScript, legacy, report, operations);
-    }
-    catch (error) {
-        report.blocked.push(`.codex/hooks.json: ${message(error)}`);
-    }
-}
-export function packageOwnedCommand(entry) {
-    return `node "${path.resolve(entry).replace(/"/gu, '\\"')}"`;
-}
-export function removeManagedHookEntries(groups, currentPackageCommand = "") {
-    if (!Array.isArray(groups))
-        return { groups: [], removed: 0 };
-    const retained = [];
-    let removed = 0;
-    for (const groupValue of groups) {
-        if (!isObject(groupValue) || !Array.isArray(groupValue.hooks)) {
-            retained.push(groupValue);
-            continue;
-        }
-        const hooks = groupValue.hooks.filter((entry) => {
-            if (!isManagedHookEntry(entry, currentPackageCommand))
-                return true;
-            removed += 1;
-            return false;
-        });
-        if (hooks.length > 0) {
-            retained.push({ ...groupValue, hooks });
-            continue;
-        }
-        const keys = Object.keys(groupValue);
-        if (keys.every((key) => key === "hooks"))
-            continue;
-        if (MANAGED_MATCHERS.has(String(groupValue.matcher ?? "")) &&
-            keys.every((key) => key === "matcher" || key === "hooks"))
-            continue;
-        retained.push({ ...groupValue, hooks });
-    }
-    return { groups: retained, removed };
-}
-export function isManagedHookEntry(entry, currentPackageCommand = "") {
-    const row = object(entry);
-    if (row.type !== "command")
-        return false;
-    const commands = [row.command, row.commandWindows]
-        .filter((value) => typeof value === "string")
-        .map((value) => value.trim());
-    if (commands.some((command) => LEGACY_REPO_LOCAL_COMMANDS.has(command)))
-        return true;
-    const status = String(row.statusMessage ?? "");
-    if (!LEGACY_MANAGED_STATUSES.has(status))
-        return false;
-    return commands.some((command) => (Boolean(currentPackageCommand) && command === currentPackageCommand) ||
-        isHistoricalPackageOwnedCommand(command));
-}
-function mergeManagedHooks(root, command) {
-    const hooks = hookMap(root);
-    root.hooks = hooks;
-    for (const event of MANAGED_HOOK_EVENTS) {
-        const current = hooks[event];
-        if (current !== undefined && !Array.isArray(current))
-            throw new Error(`hook_event_not_array:${event}`);
-        const cleaned = removeManagedHookEntries(current ?? [], command);
-        cleaned.groups.push(managedHookGroup(event, command));
-        hooks[event] = cleaned.groups;
-    }
-    return root;
-}
-function managedHookGroup(event, command) {
-    return {
-        ...(event === "PreToolUse" ? { matcher: PRE_TOOL_USE_MATCHER } : {}),
-        ...(event === "SubagentStart"
-            ? { matcher: LONG_TASK_IMPLEMENTATION_AGENT_MATCHER }
-            : {}),
-        hooks: [
-            {
-                type: "command",
-                command,
-                commandWindows: command,
-                timeout: event === "Stop" ? 3600 : 10,
-                statusMessage: MANAGED_STATUS,
-            },
-        ],
-    };
-}
-function packageHooksAreCurrent(root, command) {
-    let hooks;
-    try {
-        hooks = hookMap(root);
-    }
-    catch {
-        return false;
-    }
-    return MANAGED_HOOK_EVENTS.every((event) => {
-        const groups = hooks[event];
-        if (!Array.isArray(groups))
-            return false;
-        const matches = [];
-        for (const groupValue of groups) {
-            if (!isObject(groupValue) || !Array.isArray(groupValue.hooks))
-                continue;
-            for (const entryValue of groupValue.hooks) {
-                if (!isManagedHookEntry(entryValue, command))
-                    continue;
-                matches.push({ group: groupValue, entry: object(entryValue) });
-            }
-        }
-        if (matches.length !== 1)
-            return false;
-        const [{ group, entry }] = matches;
-        const expectedMatcher = event === "PreToolUse"
-            ? PRE_TOOL_USE_MATCHER
-            : event === "SubagentStart"
-                ? LONG_TASK_IMPLEMENTATION_AGENT_MATCHER
-                : undefined;
-        return (entry.type === "command" &&
-            entry.command === command &&
-            entry.commandWindows === command &&
-            entry.timeout === (event === "Stop" ? 3600 : 10) &&
-            entry.statusMessage === MANAGED_STATUS &&
-            (expectedMatcher === undefined
-                ? !Object.hasOwn(group, "matcher")
-                : group.matcher === expectedMatcher));
-    });
-}
-async function readHookConfig(projectRoot, createDirectory, operations) {
-    const directory = await inspectCodexDirectory(projectRoot, createDirectory, operations);
-    if (directory === "absent")
-        return { root: {}, snapshot: { kind: "absent" } };
-    const config = path.join(projectRoot, ".codex", "hooks.json");
-    const status = await lstatOrNull(config, operations);
-    if (!status)
-        return { root: {}, snapshot: { kind: "absent" } };
-    if (status.isSymbolicLink())
-        throw new Error("destination_symlink_or_junction");
-    if (!status.isFile())
-        throw new Error("destination_not_regular_file");
-    const content = await operations.readFile(config, "utf8");
-    let decoded;
-    try {
-        decoded = JSON.parse(content);
-    }
-    catch {
-        throw new Error("invalid JSON");
-    }
-    if (!isObject(decoded))
-        throw new Error("root_not_object");
-    hookMap(decoded);
-    return { root: decoded, snapshot: { kind: "regular", content } };
-}
-function hookMap(root) {
-    if (root.hooks === undefined)
-        return {};
-    if (!isObject(root.hooks))
-        throw new Error("hooks_not_object");
-    return root.hooks;
-}
-async function inspectCodexDirectory(projectRoot, create, operations) {
-    const directory = path.join(projectRoot, ".codex");
-    let status = await lstatOrNull(directory, operations);
-    if (!status && create) {
-        await operations.mkdir(directory, { recursive: true });
-        status = await lstatOrNull(directory, operations);
-    }
-    if (!status)
-        return "absent";
-    if (status.isSymbolicLink())
-        throw new Error("parent_symlink_or_junction:.codex");
-    if (!status.isDirectory())
-        throw new Error("parent_not_directory:.codex");
-    return "regular";
-}
-async function inspectLegacyScript(projectRoot, operations) {
-    if ((await inspectCodexDirectory(projectRoot, false, operations)) === "absent")
-        return { kind: "absent" };
-    const parent = path.join(projectRoot, ".codex", "hooks");
-    const parentStatus = await lstatOrNull(parent, operations);
-    if (!parentStatus)
-        return { kind: "absent" };
-    if (parentStatus.isSymbolicLink())
-        throw new Error("legacy_parent_symlink_or_junction");
-    if (!parentStatus.isDirectory())
-        throw new Error("legacy_parent_not_directory");
-    const target = path.join(parent, "long-task-hook.mjs");
-    const targetStatus = await lstatOrNull(target, operations);
-    if (!targetStatus)
-        return { kind: "absent" };
-    if (targetStatus.isSymbolicLink())
-        throw new Error("legacy_hook_symlink_or_junction");
-    if (!targetStatus.isFile())
-        throw new Error("legacy_hook_not_regular_file");
-    return { kind: "regular" };
-}
-async function removeLegacyScriptIfPresent(projectRoot, target, initial, report, operations) {
-    if (initial.kind === "absent")
-        return;
-    const current = await inspectLegacyScript(projectRoot, operations);
-    if (current.kind !== "regular")
-        throw new Error("legacy_hook_changed_before_delete");
-    await operations.rm(target, { force: true });
-    report.changed.push(".codex/hooks/long-task-hook.mjs");
-}
-async function publishHookConfig(target, initial, content, operations) {
-    const temp = `${target}.tmp-${process.pid}-${operations.randomId()}`;
-    let renamed = false;
-    try {
-        await operations.writeFile(temp, content, { flag: "wx" });
-        await assertTargetUnchanged(target, initial, operations);
-        await operations.rename(temp, target);
-        renamed = true;
-    }
-    finally {
-        if (!renamed)
-            await operations.rm(temp, { force: true }).catch(() => { });
-    }
-}
-async function removeHookConfig(target, initial, operations) {
-    await assertTargetUnchanged(target, initial, operations);
-    await operations.rm(target, { force: true });
-}
-async function assertTargetUnchanged(target, initial, operations) {
-    const projectRoot = path.dirname(path.dirname(target));
-    await inspectCodexDirectory(projectRoot, false, operations);
-    const status = await lstatOrNull(target, operations);
-    if (initial.kind === "absent") {
-        if (status)
-            throw new Error("concurrent change: destination appeared");
-        return;
-    }
-    if (!status || status.isSymbolicLink() || !status.isFile())
-        throw new Error("concurrent change: destination type changed");
-    if ((await operations.readFile(target, "utf8")) !== initial.content)
-        throw new Error("concurrent change: destination content changed");
-}
-function addNotice(report) {
-    (report.notices ??= []).push(LONG_TASK_HOOK_TRUST_REVIEW_NOTICE);
-}
-function operationsWith(overrides) {
-    return { ...DEFAULT_FILE_OPERATIONS, ...overrides };
-}
-async function lstatOrNull(target, operations) {
-    try {
-        return await operations.lstat(target);
-    }
-    catch (error) {
-        if (code(error) === "ENOENT")
-            return null;
-        throw error;
-    }
-}
-function isHistoricalPackageOwnedCommand(command) {
-    const match = /^node "([^"\r\n]+)"$/u.exec(command);
-    if (!match)
-        return false;
-    const absolute = match[1];
-    if (!path.isAbsolute(absolute) &&
-        !path.win32.isAbsolute(absolute) &&
-        !path.posix.isAbsolute(absolute))
-        return false;
-    const normalized = absolute.replace(/\\/gu, "/");
-    return (/\/node_modules\/project-tiny-context-harness\/dist\/long-task-hook\.js$/u.test(normalized) || /\/packages\/ty-context\/dist\/long-task-hook\.js$/u.test(normalized));
-}
-function object(value) {
-    return isObject(value) ? value : {};
-}
-function isObject(value) {
-    return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function code(error) {
-    return typeof error === "object" && error !== null && "code" in error
-        ? String(error.code)
-        : "";
-}
-function message(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/lib/long-task-hook-preflight.d.ts

@@ -1,7 +0,0 @@
-export interface CompletionGateCheck {
-    status: "available" | "completion_gate_unavailable";
-    bundle_sha256: string;
-    hook_sha256: string;
-    findings: string[];
-}
-export declare function checkLongTaskCompletionGate(repositoryRoot: string, packageRoot: string): Promise<CompletionGateCheck>;

package/dist/lib/long-task-hook-preflight.js

@@ -1,58 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { packageOwnedCommand } from "./long-task-hook-install.js";
-import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-import { sha256Hex } from "./strict-codec.js";
-export async function checkLongTaskCompletionGate(repositoryRoot, packageRoot) {
-    const config = path.join(path.resolve(repositoryRoot), ".codex", "hooks.json");
-    const entry = path.join(path.resolve(packageRoot), "dist", "long-task-hook.js");
-    const expectedCommand = packageOwnedCommand(entry);
-    const findings = [];
-    let configHash = "missing";
-    let hookHash = "missing";
-    try {
-        hookHash = sha256Hex(await readFile(await assertProtectedRepositoryFile(packageRoot, entry, "package_owned_hook")));
-    }
-    catch {
-        findings.push("package_owned_hook_missing");
-    }
-    try {
-        const content = await readFile(await assertProtectedRepositoryFile(repositoryRoot, config, "completion_hook_config"), "utf8");
-        configHash = sha256Hex(content);
-        const value = JSON.parse(content);
-        for (const event of ["SessionStart", "PostCompact", "Stop"]) {
-            const handlers = managedHandlers(value.hooks?.[event], expectedCommand);
-            if (handlers.length !== 1)
-                findings.push(`completion_hook_event_missing:${event}`);
-            else {
-                const timeout = handlers[0].timeout;
-                const expected = event === "Stop" ? 3600 : 10;
-                if (timeout !== expected)
-                    findings.push(`completion_hook_timeout_invalid:${event}`);
-            }
-        }
-    }
-    catch {
-        findings.push("hooks_config_missing_or_invalid");
-    }
-    const bundle_sha256 = sha256Hex(`${configHash}:${hookHash}`);
-    return {
-        status: findings.length ? "completion_gate_unavailable" : "available",
-        bundle_sha256,
-        hook_sha256: hookHash,
-        findings,
-    };
-}
-function managedHandlers(value, expectedCommand) {
-    if (Array.isArray(value))
-        return value.flatMap((item) => managedHandlers(item, expectedCommand));
-    if (value && typeof value === "object") {
-        const item = value;
-        if (item.type === "command" &&
-            item.command === expectedCommand &&
-            item.commandWindows === expectedCommand)
-            return [item];
-        return Object.values(item).flatMap((child) => managedHandlers(child, expectedCommand));
-    }
-    return [];
-}

package/dist/lib/long-task-json-pointer-observation.d.ts

@@ -1,59 +0,0 @@
-export declare const JSON_POINTER_EXACT_CAPABILITY = "json-pointer-exact-v1";
-export declare const JSON_POINTER_EXACT_ORACLE_IDENTITY = "ty-context-json-pointer-exact";
-export declare const JSON_POINTER_EXACT_ORACLE_VERSION = "1.0.0";
-export declare const JSON_POINTER_EXACT_METHODS: readonly ["exact_value", "content", "component_state"];
-export declare const JSON_POINTER_EXACT_LIMITS: Readonly<{
-    max_file_bytes: 1048576;
-    max_depth: 64;
-    max_pointer_bytes: 4096;
-    max_pointer_segments: 128;
-    max_canonical_value_bytes: 262144;
-    max_artifacts_per_check: 256;
-    max_total_artifact_bytes: 16777216;
-}>;
-export declare const JSON_POINTER_EXACT_SPEC_SHA256: string;
-export interface JsonPointerExactBudget {
-    readonly seen_artifact_paths: Set<string>;
-    total_artifact_bytes: number;
-}
-export interface JsonPointerExactLocator {
-    kind: string;
-    value: string;
-}
-export interface JsonPointerExactObservation {
-    capability: typeof JSON_POINTER_EXACT_CAPABILITY;
-    artifact_path: string;
-    artifact_sha256: string;
-    locator: {
-        kind: "json_pointer";
-        value: string;
-    };
-    value_sha256: string;
-    canonical_value_bytes: number;
-    sensitivity: "plain";
-}
-export declare function createJsonPointerExactBudget(): JsonPointerExactBudget;
-export declare function isJsonPointerExactOracle(oracle: {
-    trust?: string;
-    identity?: string;
-    version?: string;
-    sha256?: string | null;
-}): boolean;
-export declare function extractJsonPointerExactObservationFromBytes(input: {
-    artifact_path: string;
-    bytes: Uint8Array;
-    locator: JsonPointerExactLocator;
-    sensitivity: string;
-    budget?: JsonPointerExactBudget;
-}): JsonPointerExactObservation;
-export declare function validateJsonPointerExactLocator(locator: JsonPointerExactLocator): {
-    kind: "json_pointer";
-    value: string;
-};
-export declare function normalizeObservationArtifactPath(value: string): string;
-export declare function invalidObservation(code: string): Error;
-export declare function observationErrorMessage(error: unknown): string;
-export declare function resolveJsonPointer(root: unknown, pointer: string): unknown;
-export declare function parseJsonWithoutDuplicateKeys(content: string): unknown;
-export declare function decodeUtf8Json(bytes: Uint8Array): string;
-export declare function assertJsonTree(value: unknown, depth: number): void;