@westbayberry/dg 2.1.0 → 2.2.0

package/dist/agents/codex.js

@@ -0,0 +1,65 @@
+import { join } from "node:path";
+import { dirExists, ownedJsonHook, probeMinCliVersion } from "./persistence.js";
+function configPath(home) {
+    return join(home, ".codex", "hooks.json");
+}
+function parseInput(stdin) {
+    try {
+        const obj = JSON.parse(stdin);
+        const command = obj.tool_input?.command;
+        if (typeof command !== "string") {
+            return null;
+        }
+        return typeof obj.cwd === "string" ? { command, cwd: obj.cwd } : { command };
+    }
+    catch {
+        return null;
+    }
+}
+function emitDecision(verdict) {
+    if (verdict.decision === "allow") {
+        return { stdout: "", exitCode: 0 };
+    }
+    const reason = verdict.reason ?? "Dependency Guardian firewall";
+    const suffix = verdict.decision === "ask" ? " (flagged for review — run the install in a terminal to decide)" : "";
+    return {
+        stdout: JSON.stringify({ decision: "block", reason: `${reason}${suffix}` }),
+        exitCode: 0,
+    };
+}
+function renderHookFile(dgCommand) {
+    return {
+        hooks: {
+            PreToolUse: [
+                {
+                    matcher: "Bash",
+                    hooks: [{ type: "command", command: dgCommand, timeout: 60, statusMessage: "Dependency Guardian install check" }],
+                },
+            ],
+        },
+    };
+}
+function probeHookSupport(home, deps) {
+    if (!dirExists(join(home, ".codex"))) {
+        return { supported: false, detail: "~/.codex not found (is Codex CLI installed?)" };
+    }
+    return probeMinCliVersion("codex", "0.124.0", "Codex CLI", deps);
+}
+export const codexIntegration = {
+    id: "codex",
+    label: "Codex CLI",
+    kind: "owned-json",
+    maturity: "verified",
+    minVersion: "0.124.0",
+    postInstallNote: "Codex asks to trust new hooks: approve the dg hook when Codex prompts on its next start.",
+    configPath,
+    detect: (home) => dirExists(join(home, ".codex")),
+    probeHookSupport,
+    parseInput,
+    emitDecision,
+    ...ownedJsonHook({
+        agent: "codex",
+        checkName: "dg PreToolUse hook",
+        render: renderHookFile,
+    }),
+};

package/dist/agents/copilot-cli.js

@@ -0,0 +1,115 @@
+import { join } from "node:path";
+import { dirExists, mergedJsonHook, probeMinCliVersion } from "./persistence.js";
+const SIGNATURE = "hook-exec copilot-cli";
+function configPath(home) {
+    return join(home, ".copilot", "settings.json");
+}
+function isDgEntry(entry) {
+    return (typeof entry === "object" &&
+        entry !== null &&
+        typeof entry.command === "string" &&
+        entry.command.includes(SIGNATURE));
+}
+// Native camelCase event contract (PascalCase keys switch copilot into its
+// VS Code snake_case compat mode, a different payload shape). toolName for
+// the shell tool is "bash" — the UI's "shell" label is display-only.
+function dgEntry(dgCommand) {
+    return { type: "command", matcher: "bash", command: dgCommand, timeoutSec: 60 };
+}
+export function insertDgHook(settings, dgCommand) {
+    const next = { ...settings };
+    const hooks = typeof next.hooks === "object" && next.hooks !== null ? { ...next.hooks } : {};
+    const pre = Array.isArray(hooks.preToolUse) ? hooks.preToolUse : [];
+    hooks.preToolUse = [...pre.filter((e) => !isDgEntry(e)), dgEntry(dgCommand)];
+    next.hooks = hooks;
+    return next;
+}
+export function removeDgHook(settings) {
+    const next = { ...settings };
+    if (typeof next.hooks !== "object" || next.hooks === null) {
+        return { settings: next, changed: false, empty: Object.keys(next).length === 0 };
+    }
+    const hooks = { ...next.hooks };
+    const pre = Array.isArray(hooks.preToolUse) ? hooks.preToolUse : [];
+    const withoutDg = pre.filter((e) => !isDgEntry(e));
+    const changed = withoutDg.length !== pre.length;
+    if (withoutDg.length > 0) {
+        hooks.preToolUse = withoutDg;
+    }
+    else {
+        delete hooks.preToolUse;
+    }
+    if (Object.keys(hooks).length > 0) {
+        next.hooks = hooks;
+    }
+    else {
+        delete next.hooks;
+    }
+    return { settings: next, changed, empty: Object.keys(next).length === 0 };
+}
+function hasDgHook(settings) {
+    const hooks = settings.hooks?.preToolUse;
+    return Array.isArray(hooks) && hooks.some((e) => isDgEntry(e));
+}
+function toolArgsObject(raw) {
+    if (typeof raw === "string") {
+        try {
+            const parsed = JSON.parse(raw);
+            return typeof parsed === "object" && parsed !== null ? parsed : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return typeof raw === "object" && raw !== null ? raw : null;
+}
+function parseInput(stdin) {
+    try {
+        const obj = JSON.parse(stdin);
+        const args = toolArgsObject(obj.toolArgs);
+        const command = args?.command;
+        if (typeof command !== "string") {
+            return null;
+        }
+        return typeof obj.cwd === "string" ? { command, cwd: obj.cwd } : { command };
+    }
+    catch {
+        return null;
+    }
+}
+function emitDecision(verdict) {
+    if (verdict.decision === "allow") {
+        return { stdout: "{}", exitCode: 0 };
+    }
+    return {
+        stdout: JSON.stringify({
+            permissionDecision: verdict.decision,
+            ...(verdict.reason ? { permissionDecisionReason: verdict.reason } : {}),
+        }),
+        exitCode: 0,
+    };
+}
+function probeHookSupport(home, deps) {
+    if (!dirExists(join(home, ".copilot"))) {
+        return { supported: false, detail: "~/.copilot not found (is GitHub Copilot CLI installed?)" };
+    }
+    return probeMinCliVersion("copilot", "1.0.61", "GitHub Copilot CLI", deps);
+}
+export const copilotCliIntegration = {
+    id: "copilot-cli",
+    label: "GitHub Copilot CLI",
+    kind: "merged-json",
+    maturity: "verified",
+    minVersion: "1.0.61",
+    configPath,
+    detect: (home) => dirExists(join(home, ".copilot")),
+    probeHookSupport,
+    parseInput,
+    emitDecision,
+    ...mergedJsonHook({
+        checkName: "dg preToolUse hook",
+        insert: insertDgHook,
+        remove: removeDgHook,
+        isInstalled: hasDgHook,
+    }),
+};

package/dist/agents/cursor.js

@@ -0,0 +1,113 @@
+import { join } from "node:path";
+import { dirExists, mergedJsonHook, readSettings } from "./persistence.js";
+const SIGNATURE = "hook-exec cursor";
+function configPath(home) {
+    return join(home, ".cursor", "hooks.json");
+}
+function isDgEntry(entry) {
+    return (typeof entry === "object" &&
+        entry !== null &&
+        typeof entry.command === "string" &&
+        entry.command.includes(SIGNATURE));
+}
+function hookList(settings) {
+    const hooks = settings.hooks;
+    if (typeof hooks !== "object" || hooks === null) {
+        return [];
+    }
+    const list = hooks.beforeShellExecution;
+    return Array.isArray(list) ? list : [];
+}
+function insertHook(settings, dgCommand) {
+    const next = { ...settings };
+    const hooks = typeof next.hooks === "object" && next.hooks !== null ? { ...next.hooks } : {};
+    const list = Array.isArray(hooks.beforeShellExecution) ? hooks.beforeShellExecution : [];
+    hooks.beforeShellExecution = [...list.filter((entry) => !isDgEntry(entry)), { command: dgCommand }];
+    next.hooks = hooks;
+    if (next.version === undefined) {
+        next.version = 1;
+    }
+    return next;
+}
+function effectivelyEmpty(obj) {
+    const keys = Object.keys(obj);
+    return keys.length === 0 || (keys.length === 1 && keys[0] === "version");
+}
+function removeHook(settings) {
+    const next = { ...settings };
+    if (typeof next.hooks !== "object" || next.hooks === null) {
+        return { settings: next, changed: false, empty: effectivelyEmpty(next) };
+    }
+    const hooks = { ...next.hooks };
+    const list = Array.isArray(hooks.beforeShellExecution) ? hooks.beforeShellExecution : [];
+    const withoutDg = list.filter((entry) => !isDgEntry(entry));
+    const changed = withoutDg.length !== list.length;
+    if (withoutDg.length > 0) {
+        hooks.beforeShellExecution = withoutDg;
+    }
+    else {
+        delete hooks.beforeShellExecution;
+    }
+    if (Object.keys(hooks).length > 0) {
+        next.hooks = hooks;
+    }
+    else {
+        delete next.hooks;
+    }
+    return { settings: next, changed, empty: effectivelyEmpty(next) };
+}
+function hasDgHook(settings) {
+    return hookList(settings).some((entry) => isDgEntry(entry));
+}
+function parseInput(stdin) {
+    try {
+        const obj = JSON.parse(stdin);
+        if (typeof obj.command !== "string") {
+            return null;
+        }
+        return typeof obj.cwd === "string" ? { command: obj.command, cwd: obj.cwd } : { command: obj.command };
+    }
+    catch {
+        return null;
+    }
+}
+function emitDecision(verdict) {
+    if (verdict.decision === "allow") {
+        return { stdout: JSON.stringify({ permission: "allow" }), exitCode: 0 };
+    }
+    const reason = verdict.reason ?? "Dependency Guardian firewall";
+    return {
+        stdout: JSON.stringify({ permission: verdict.decision, user_message: reason, agent_message: reason }),
+        exitCode: 0,
+    };
+}
+function probeHookSupport(home) {
+    if (!dirExists(join(home, ".cursor"))) {
+        return { supported: false, detail: "~/.cursor not found (is Cursor installed?)" };
+    }
+    try {
+        readSettings(configPath(home));
+    }
+    catch {
+        return { supported: false, detail: `${configPath(home)} exists but is not a JSON object dg can merge into` };
+    }
+    return { supported: true, detail: "requires Cursor 1.7+; dg cannot read your Cursor version from disk" };
+}
+export const cursorIntegration = {
+    id: "cursor",
+    label: "Cursor",
+    kind: "merged-json",
+    maturity: "verified",
+    minVersion: "1.7",
+    configPath,
+    detect: (home) => dirExists(join(home, ".cursor")),
+    probeHookSupport,
+    parseInput,
+    emitDecision,
+    ...mergedJsonHook({
+        checkName: "dg beforeShellExecution hook",
+        insert: insertHook,
+        remove: removeHook,
+        isInstalled: hasDgHook,
+    }),
+};

package/dist/agents/gemini.js

@@ -0,0 +1,107 @@
+import { join } from "node:path";
+import { dirExists, mergedJsonHook, probeMinCliVersion } from "./persistence.js";
+const SIGNATURE = "hook-exec gemini";
+function configPath(home) {
+    return join(home, ".gemini", "settings.json");
+}
+function isDgGroup(group) {
+    if (typeof group !== "object" || group === null) {
+        return false;
+    }
+    const hooks = group.hooks;
+    if (!Array.isArray(hooks)) {
+        return false;
+    }
+    return hooks.some((h) => typeof h === "object" &&
+        h !== null &&
+        typeof h.command === "string" &&
+        h.command.includes(SIGNATURE));
+}
+// No timeout field: gemini reads it in MILLISECONDS (default 60000); the
+// Claude-style seconds value 60 made gemini kill the hook at 60ms and run
+// the command ungated (gemini fails open on hook timeout).
+function dgGroup(dgCommand) {
+    return { matcher: "run_shell_command", hooks: [{ type: "command", command: dgCommand }] };
+}
+function insertHook(settings, dgCommand) {
+    const next = { ...settings };
+    const hooks = typeof next.hooks === "object" && next.hooks !== null ? { ...next.hooks } : {};
+    const pre = Array.isArray(hooks.BeforeTool) ? hooks.BeforeTool : [];
+    hooks.BeforeTool = [...pre.filter((g) => !isDgGroup(g)), dgGroup(dgCommand)];
+    next.hooks = hooks;
+    return next;
+}
+function removeHook(settings) {
+    const next = { ...settings };
+    if (typeof next.hooks !== "object" || next.hooks === null) {
+        return { settings: next, changed: false, empty: Object.keys(next).length === 0 };
+    }
+    const hooks = { ...next.hooks };
+    const pre = Array.isArray(hooks.BeforeTool) ? hooks.BeforeTool : [];
+    const withoutDg = pre.filter((g) => !isDgGroup(g));
+    const changed = withoutDg.length !== pre.length;
+    if (withoutDg.length > 0) {
+        hooks.BeforeTool = withoutDg;
+    }
+    else {
+        delete hooks.BeforeTool;
+    }
+    if (Object.keys(hooks).length > 0) {
+        next.hooks = hooks;
+    }
+    else {
+        delete next.hooks;
+    }
+    return { settings: next, changed, empty: Object.keys(next).length === 0 };
+}
+function hasDgHook(settings) {
+    const hooks = settings.hooks?.BeforeTool;
+    return Array.isArray(hooks) && hooks.some((g) => isDgGroup(g));
+}
+function parseInput(stdin) {
+    try {
+        const obj = JSON.parse(stdin);
+        const command = obj.tool_args?.command ?? obj.tool_input?.command;
+        if (typeof command !== "string") {
+            return null;
+        }
+        return typeof obj.cwd === "string" ? { command, cwd: obj.cwd } : { command };
+    }
+    catch {
+        return null;
+    }
+}
+function emitDecision(verdict) {
+    if (verdict.decision === "allow") {
+        return { stdout: "{}", exitCode: 0 };
+    }
+    const reason = verdict.reason ?? "Dependency Guardian firewall";
+    return {
+        stdout: JSON.stringify({ decision: "block", reason }),
+        exitCode: 0,
+    };
+}
+function probeHookSupport(home, deps) {
+    if (!dirExists(join(home, ".gemini"))) {
+        return { supported: false, detail: "~/.gemini not found (is Gemini CLI installed?)" };
+    }
+    return probeMinCliVersion("gemini", "0.26.0", "Gemini CLI", deps);
+}
+export const geminiIntegration = {
+    id: "gemini",
+    label: "Gemini CLI",
+    kind: "merged-json",
+    maturity: "verified",
+    minVersion: "0.26.0",
+    configPath,
+    detect: (home) => dirExists(join(home, ".gemini")),
+    probeHookSupport,
+    parseInput,
+    emitDecision,
+    ...mergedJsonHook({
+        checkName: "dg BeforeTool hook",
+        insert: insertHook,
+        remove: removeHook,
+        isInstalled: hasDgHook,
+    }),
+};

package/dist/agents/persistence.js

@@ -0,0 +1,285 @@
+import { existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { dirname } from "node:path";
+import { randomBytes } from "node:crypto";
+import { readCleanupRegistry, recordCleanupEntry, removeCleanupEntry, } from "../state/index.js";
+export const LEGACY_AGENT_HOOK_SENTINEL = "dg-agent-hook-v1";
+export function agentHookSentinel(agent) {
+    return `${LEGACY_AGENT_HOOK_SENTINEL}:${agent}`;
+}
+export class AgentHookError extends Error {
+}
+export function dirExists(path) {
+    try {
+        return lstatSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function assertSafeNode(path, role) {
+    let stats;
+    try {
+        stats = lstatSync(path);
+    }
+    catch {
+        return;
+    }
+    if (stats.isSymbolicLink()) {
+        throw new AgentHookError(`${path} is a symlink; refusing to write through it. Edit the link target directly, then retry.`);
+    }
+    if (typeof process.getuid === "function" && stats.uid !== process.getuid()) {
+        throw new AgentHookError(`${path} (${role}) is owned by another user; refusing to write to it.`);
+    }
+    if ((stats.mode & 0o002) !== 0) {
+        throw new AgentHookError(`${path} (${role}) is world-writable; refusing to write to it. Tighten its permissions, then retry.`);
+    }
+}
+export function assertSafeWriteTarget(path) {
+    assertSafeNode(dirname(path), "directory");
+    assertSafeNode(path, "file");
+}
+export function readSettings(path) {
+    if (!existsSync(path)) {
+        return { settings: {}, existed: false };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        throw new AgentHookError(`${path} is not valid JSON; refusing to modify it. Fix or remove it, then retry.`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new AgentHookError(`${path} is not a JSON object; refusing to modify it.`);
+    }
+    return { settings: parsed, existed: true };
+}
+export function writeSettingsAtomic(path, settings) {
+    mkdirSync(dirname(path), { recursive: true });
+    assertSafeWriteTarget(path);
+    const tmp = `${path}.dg-${randomBytes(6).toString("hex")}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(settings, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+    try {
+        renameSync(tmp, path);
+    }
+    catch (error) {
+        rmSync(tmp, { force: true });
+        throw error;
+    }
+}
+async function wasCreatedByDg(ctx) {
+    try {
+        const reg = await readCleanupRegistry(ctx.paths);
+        return reg.entries.some((e) => e.kind === "agent-hook" && e.path === ctx.settingsPath && e.original === "dg-created");
+    }
+    catch {
+        return false;
+    }
+}
+async function recordHookEntry(ctx, legacySentinels, created) {
+    for (const sentinel of legacySentinels) {
+        await removeCleanupEntry(ctx.paths, { kind: "agent-hook", path: ctx.settingsPath, sentinel });
+    }
+    await recordCleanupEntry(ctx.paths, {
+        kind: "agent-hook",
+        path: ctx.settingsPath,
+        mode: "mode1",
+        sentinel: agentHookSentinel(ctx.agent),
+        ...(created ? { original: "dg-created" } : {}),
+    });
+}
+async function removeHookEntries(ctx, legacySentinels) {
+    await removeCleanupEntry(ctx.paths, { kind: "agent-hook", path: ctx.settingsPath, sentinel: agentHookSentinel(ctx.agent) });
+    for (const sentinel of legacySentinels) {
+        await removeCleanupEntry(ctx.paths, { kind: "agent-hook", path: ctx.settingsPath, sentinel });
+    }
+}
+export function mergedJsonHook(config) {
+    const legacy = config.legacySentinels ?? [];
+    return {
+        isInstalledCheckName: config.checkName,
+        async apply(ctx) {
+            const { settings, existed } = readSettings(ctx.settingsPath);
+            writeSettingsAtomic(ctx.settingsPath, config.insert(settings, ctx.dgCommand));
+            await recordHookEntry(ctx, legacy, !existed);
+            return { created: !existed };
+        },
+        async remove(ctx) {
+            let removed = false;
+            if (existsSync(ctx.settingsPath)) {
+                let settings = null;
+                try {
+                    settings = readSettings(ctx.settingsPath).settings;
+                }
+                catch {
+                    settings = null;
+                }
+                if (settings) {
+                    const result = config.remove(settings);
+                    if (result.changed) {
+                        removed = true;
+                        if (result.empty && (await wasCreatedByDg(ctx))) {
+                            rmSync(ctx.settingsPath, { force: true });
+                        }
+                        else {
+                            writeSettingsAtomic(ctx.settingsPath, result.settings);
+                        }
+                    }
+                }
+            }
+            await removeHookEntries(ctx, legacy);
+            return { removed };
+        },
+        verify(ctx) {
+            const checks = [];
+            const present = existsSync(ctx.settingsPath);
+            checks.push({ name: "settings file", ok: present, detail: present ? ctx.settingsPath : `${ctx.settingsPath} (absent)` });
+            if (!present) {
+                return checks;
+            }
+            let installed = false;
+            try {
+                installed = config.isInstalled(readSettings(ctx.settingsPath).settings);
+            }
+            catch {
+                installed = false;
+            }
+            checks.push({ name: config.checkName, ok: installed, detail: installed ? "installed" : "not installed" });
+            return checks;
+        },
+        reverseEntry(entry, removed, missing, warnings) {
+            if (!existsSync(entry.path)) {
+                missing.push(entry.path);
+                return;
+            }
+            let settings;
+            try {
+                const parsed = JSON.parse(readFileSync(entry.path, "utf8"));
+                if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+                    warnings.push(`${entry.path}: not a JSON object; left untouched`);
+                    return;
+                }
+                settings = parsed;
+            }
+            catch {
+                warnings.push(`${entry.path}: unreadable JSON; left untouched`);
+                return;
+            }
+            const result = config.remove(settings);
+            if (!result.changed) {
+                missing.push(entry.path);
+                return;
+            }
+            if (result.empty && entry.original === "dg-created") {
+                rmSync(entry.path, { force: true });
+            }
+            else {
+                try {
+                    writeSettingsAtomic(entry.path, result.settings);
+                }
+                catch (error) {
+                    warnings.push(`${entry.path}: ${error instanceof Error ? error.message : "could not rewrite settings"}`);
+                    return;
+                }
+            }
+            removed.push(entry.path);
+        },
+    };
+}
+export function ownedJsonHook(config) {
+    const sentinel = agentHookSentinel(config.agent);
+    const ownsFile = (path) => {
+        try {
+            const parsed = JSON.parse(readFileSync(path, "utf8"));
+            return parsed?.dgSentinel === sentinel;
+        }
+        catch {
+            return false;
+        }
+    };
+    return {
+        isInstalledCheckName: config.checkName,
+        async apply(ctx) {
+            const existed = existsSync(ctx.settingsPath);
+            if (existed && !ownsFile(ctx.settingsPath)) {
+                throw new AgentHookError(`${ctx.settingsPath} already exists and was not written by dg; refusing to overwrite it. Merge the output of 'dg agents --print ${ctx.agent}' yourself, or remove the file and retry.`);
+            }
+            writeSettingsAtomic(ctx.settingsPath, { dgSentinel: sentinel, ...config.render(ctx.dgCommand) });
+            await recordHookEntry(ctx, [], !existed);
+            return { created: !existed };
+        },
+        async remove(ctx) {
+            let removed = false;
+            if (existsSync(ctx.settingsPath) && ownsFile(ctx.settingsPath)) {
+                rmSync(ctx.settingsPath, { force: true });
+                removed = true;
+            }
+            await removeHookEntries(ctx, []);
+            return { removed };
+        },
+        verify(ctx) {
+            const checks = [];
+            const present = existsSync(ctx.settingsPath);
+            checks.push({ name: "hook file", ok: present, detail: present ? ctx.settingsPath : `${ctx.settingsPath} (absent)` });
+            if (!present) {
+                return checks;
+            }
+            const installed = ownsFile(ctx.settingsPath);
+            checks.push({ name: config.checkName, ok: installed, detail: installed ? "installed" : "present but not dg-owned" });
+            return checks;
+        },
+        reverseEntry(entry, removed, missing, warnings) {
+            if (!existsSync(entry.path)) {
+                missing.push(entry.path);
+                return;
+            }
+            if (!ownsFile(entry.path)) {
+                warnings.push(`${entry.path}: not dg-owned; left untouched`);
+                return;
+            }
+            rmSync(entry.path, { force: true });
+            removed.push(entry.path);
+        },
+    };
+}
+function defaultExecVersion(binary, args) {
+    try {
+        const result = spawnSync(binary, [...args], { encoding: "utf8", timeout: 1500 });
+        if (result.status !== 0 || typeof result.stdout !== "string") {
+            return null;
+        }
+        return result.stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+function parseSemver(text) {
+    const match = /(\d+)\.(\d+)(?:\.(\d+))?/.exec(text);
+    if (!match) {
+        return null;
+    }
+    return [Number(match[1]), Number(match[2]), Number(match[3] ?? "0")];
+}
+export function probeMinCliVersion(binary, minVersion, label, deps) {
+    const execVersion = deps?.execVersion ?? defaultExecVersion;
+    const output = execVersion(binary, ["--version"]);
+    if (!output) {
+        return { supported: false, detail: `cannot confirm ${label} >= ${minVersion} (the ${binary} CLI did not report a version)` };
+    }
+    const found = parseSemver(output);
+    const wanted = parseSemver(minVersion);
+    if (!found || !wanted) {
+        return { supported: false, detail: `cannot confirm ${label} >= ${minVersion} (unrecognized version '${output}')` };
+    }
+    for (let index = 0; index < 3; index += 1) {
+        if ((found[index] ?? 0) > (wanted[index] ?? 0)) {
+            break;
+        }
+        if ((found[index] ?? 0) < (wanted[index] ?? 0)) {
+            return { supported: false, detail: `${label} ${found.join(".")} is older than ${minVersion}, which added the hook dg needs` };
+        }
+    }
+    return { supported: true, detail: `${label} ${found.join(".")}` };
+}