@westbayberry/dg 2.0.2 → 2.0.4

package/dist/bin/dg.js

@@ -66,6 +66,11 @@ else {
 // The auth flows (browser login, paid-verify gate, deep audit upload) already
 // tell the user exactly what to do; the throttled nudges would just be noise.
 if (!deviceLogin.handled && !verifyPackage.handled && !audit.handled) {
-    const { maybeShowNudges } = await import("../runtime/nudges.js");
-    maybeShowNudges(args);
+    try {
+        const { maybeShowNudges } = await import("../runtime/nudges.js");
+        maybeShowNudges(args);
+    }
+    catch {
+        // dg deleted its own files mid-run (uninstall of itself); nudges are cosmetic.
+    }
 }

package/dist/install-ui/LiveInstall.js

@@ -9,12 +9,12 @@ function rule() {
     return "─".repeat(width);
 }
 export const LiveInstall = ({ view }) => {
+    if (view.phase === "scanning") {
+        return (_jsxs(Box, { paddingX: 1, children: [_jsx(Text, { color: "cyan", children: _jsx(InkSpinner, { type: "dots" }) }), _jsxs(Text, { children: [" ", view.total === 0 ? "DG starting protection…" : `DG verifying ${packageCount(view.total)}…`] }), view.current ? _jsxs(Text, { dimColor: true, children: ["  ", view.current] }) : null] }));
+    }
     if (view.total === 0 && !view.blocked) {
         return null;
     }
-    if (view.phase === "scanning") {
-        return (_jsxs(Box, { paddingX: 1, children: [_jsx(Text, { color: "cyan", children: _jsx(InkSpinner, { type: "dots" }) }), _jsxs(Text, { children: [" DG verifying ", packageCount(view.total), "\u2026"] }), view.current ? _jsxs(Text, { dimColor: true, children: ["  ", view.current] }) : null] }));
-    }
     if (view.blocked) {
         const blocked = view.blocked;
         return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { color: "gray", children: rule() }), blocked.kind === "blocked" ? (_jsxs(Text, { color: "red", children: ["\u2718  DG blocked install \u2014 ", blocked.headline] })) : (_jsxs(Text, { color: "yellow", children: ["?  DG could not verify ", blocked.packageName, " \u2014 ", blocked.headline] })), _jsxs(Text, { children: ["   ", blocked.packageName, "   ", blocked.reason] }), blocked.override ? _jsxs(Text, { dimColor: true, children: ["   ", "Override: ", blocked.override] }) : null, blocked.nextStep ? _jsxs(Text, { dimColor: true, children: ["   ", "Next: ", blocked.nextStep] }) : null] }));

package/dist/setup/plan.js

@@ -1,4 +1,4 @@
-import { accessSync, constants, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { accessSync, constants, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { basename, delimiter, dirname, join, resolve } from "node:path";
 import { chmodSync } from "node:fs";
 import { createTheme } from "../presentation/theme.js";
@@ -14,6 +14,8 @@ import { OPTIONAL_SUPPORT_GATES } from "./optional-support.js";
 export const SHIM_COMMANDS = Object.freeze(["npm", "npx", "pnpm", "pnpx", "yarn", "pip", "pipx", "uv", "uvx", "cargo"]);
 export const SHIM_SENTINEL = "dg-shim-v1";
 export const RC_SENTINEL = "dg-shell-rc-v1";
+export const RC_FUNCTIONS_SENTINEL = "dg-shim-functions-v1";
+const RC_SHIM_HELPER = "__dg_shim";
 export const GUARD_HOOK_SENTINEL = "dg-git-hook-v1";
 export const RC_BEGIN = "# >>> dg setup >>>";
 export const RC_END = "# <<< dg setup <<<";
@@ -21,6 +23,9 @@ const LEGACY_RC_MARKERS = [
     { begin: "# >>> dg-managed >>>", end: "# <<< dg-managed <<<" }
 ];
 const LEGACY_RC_CANDIDATES = [".zshrc", ".bashrc", ".bash_profile", ".profile", join(".config", "fish", "config.fish")];
+const LEGACY_PYTHON_HOOK_PY = "dg_pip_hook.py";
+const LEGACY_PYTHON_HOOK_PTH = "dg_pip_hook.pth";
+const LEGACY_PYTHON_HOOK_MARKER = "Dependency Guardian pip-install interceptor";
 export const SETUP_UNINSTALL_LOCK = "setup-uninstall";
 export const SETUP_UNINSTALL_LOCK_STALE_MS = 30 * 60 * 1000;
 export const STALE_SESSION_OLDER_THAN_MS = 24 * 60 * 60 * 1000;
@@ -38,6 +43,7 @@ const DOCTOR_GROUP_BY_NAME = {
     telemetry: "setup",
     shims: "setup",
     "shell-rc": "setup",
+    "python-hook-drift": "setup",
     path: "setup",
     "stale-sessions": "setup",
     service: "setup",
@@ -53,6 +59,7 @@ const DOCTOR_FIX_BY_NAME = {
     telemetry: "fix ~/.dg config",
     shims: "dg setup",
     "shell-rc": "dg setup",
+    "python-hook-drift": "dg uninstall, or re-run dg setup, to remove the stale pip hook",
     path: "reload your shell after setup",
     "stale-sessions": "clears on the next protected run",
     auth: "dg login"
@@ -142,6 +149,7 @@ export function applySetupPlan(plan, now = new Date()) {
     });
     writeFileSync(plan.rcPath, withRcBlock(readText(plan.rcPath), plan), "utf8");
     entries.push(cleanupEntry("rc", plan.rcPath, "mode1", now, RC_SENTINEL));
+    sweepLegacyPythonHooks(plan.paths.homeDir, [], []);
     const registry = withRegistryLock(plan.paths, () => {
         const merged = mergeRegistry(readRegistry(plan.paths).registry, entries);
         writeRegistry(plan.paths, merged);
@@ -196,6 +204,7 @@ export function uninstallSetup(options) {
             }
         }
         sweepLegacyRcBlocks(paths.homeDir, removed, warnings);
+        sweepLegacyPythonHooks(paths.homeDir, removed, warnings);
         if (!options.all && !registryRead.malformed && options.keepConfig) {
             writeRegistryWithLock(paths, {
                 version: 1,
@@ -266,12 +275,21 @@ export function doctorReport(options = {}) {
     });
     const rcEntries = registryRead.registry.entries.filter((entry) => entry.owner === "dg" && entry.kind === "rc");
     const missingRc = rcEntries.filter((entry) => !readText(entry.path).includes(RC_SENTINEL));
+    const functionsPresent = rcEntries.some((entry) => readText(entry.path).includes(RC_FUNCTIONS_SENTINEL));
     checks.push({
         name: "shell-rc",
         status: rcEntries.length > 0 && missingRc.length === 0 ? "pass" : "warn",
         message: rcEntries.length === 0 ? "No dg shell rc block is registered" : `Registered shell rc blocks: ${rcEntries.length}`
     });
-    checks.push(pathPrecedenceCheck(env, shimDir));
+    const staleHookSites = legacyPythonHookSites(paths.homeDir);
+    checks.push({
+        name: "python-hook-drift",
+        status: staleHookSites.length === 0 ? "pass" : "warn",
+        message: staleHookSites.length === 0
+            ? "No legacy dg pip hooks in user site-packages"
+            : `Legacy dg pip hooks break pip in: ${staleHookSites.join(", ")}`
+    });
+    checks.push(pathPrecedenceCheck(env, shimDir, functionsPresent));
     checks.push({
         name: "stale-sessions",
         status: staleSessions.length === 0 ? "pass" : "warn",
@@ -453,11 +471,31 @@ function reloadInstructions(shell) {
     }
     return ["start a new shell or run: source ~/.zshrc", "clear cached command paths with: rehash"];
 }
-// Absolute path: a bare `exec dg` resolves through PATH, so anything that
-// shadows dg (npm run prepending node_modules/.bin with a vendored copy)
-// hijacks every shimmed package manager.
+// The baked absolute dg path stops a PATH-shadowing dg from hijacking the shim;
+// the fallbacks make it fail open — a removed or moved dg (uninstall, mid-upgrade)
+// runs the real manager instead of bricking it.
 export function shimSource(command) {
-    return `#!/bin/sh\n# ${SHIM_SENTINEL}\nDG_SHIM_ACTIVE="\${DG_SHIM_ACTIVE:+$DG_SHIM_ACTIVE,}${command}:$$" exec "${escapeDoubleQuotedSh(dgEntrypoint())}" ${command} "$@"\n`;
+    const dg = escapeDoubleQuotedSh(dgEntrypoint());
+    const nonce = '"${DG_SHIM_ACTIVE:+$DG_SHIM_ACTIVE,}' + `${command}:$$"`;
+    return [
+        "#!/bin/sh",
+        `# ${SHIM_SENTINEL}`,
+        `if [ -x "${dg}" ]; then`,
+        `  DG_SHIM_ACTIVE=${nonce} exec "${dg}" ${command} "$@"`,
+        "fi",
+        `dg_path=$(printf '%s' "$PATH" | awk -v RS=':' -v ORS=':' '$0 != ENVIRON["HOME"] "/.dg/shims"' | sed 's/:$//')`,
+        `dg_bin=$(PATH="$dg_path" command -v dg 2>/dev/null)`,
+        `if [ -n "$dg_bin" ]; then`,
+        `  DG_SHIM_ACTIVE=${nonce} exec "$dg_bin" ${command} "$@"`,
+        "fi",
+        `real_bin=$(PATH="$dg_path" command -v ${command} 2>/dev/null)`,
+        `if [ -n "$real_bin" ]; then`,
+        `  exec "$real_bin" "$@"`,
+        "fi",
+        `echo "dg: protection unavailable and no real ${command} found on PATH" >&2`,
+        "exit 127",
+        ""
+    ].join("\n");
 }
 function escapeDoubleQuotedSh(value) {
     return value.replace(/[\\"$`]/g, "\\$&");
@@ -475,11 +513,20 @@ function withRcBlock(existing, plan) {
     const prefix = withoutExisting.length > 0 && !withoutExisting.endsWith("\n") ? `${withoutExisting}\n` : withoutExisting;
     return `${prefix}${block}`;
 }
+// The PATH export covers child processes that inherit it; the shell functions
+// win even when a virtualenv prepends its own bin ahead of the shim dir, since
+// a function is resolved before PATH. Each delegates to the fail-open shim and
+// falls back to the real command if the shim is gone.
 function posixRcBlock(shimDir) {
-    return `${RC_BEGIN}\n# ${RC_SENTINEL}\nexport PATH="${escapeDoubleQuotedSh(shimDir)}:$PATH"\n${RC_END}\n`;
+    const dir = escapeDoubleQuotedSh(shimDir);
+    const helper = `${RC_SHIM_HELPER}() { local __dg_c="$1"; shift; if [ -x "${dir}/$__dg_c" ]; then "${dir}/$__dg_c" "$@"; else command "$__dg_c" "$@"; fi; }`;
+    const fns = SHIM_COMMANDS.map((command) => `${command}() { ${RC_SHIM_HELPER} ${command} "$@"; }`).join("\n");
+    return `${RC_BEGIN}\n# ${RC_SENTINEL}\n# ${RC_FUNCTIONS_SENTINEL}\nexport PATH="${dir}:$PATH"\n${helper}\n${fns}\n${RC_END}\n`;
 }
 function fishRcBlock(shimDir) {
-    return `${RC_BEGIN}\n# ${RC_SENTINEL}\nfish_add_path -p "${escapeDoubleQuotedFish(shimDir)}"\n${RC_END}\n`;
+    const dir = escapeDoubleQuotedFish(shimDir);
+    const fns = SHIM_COMMANDS.map((command) => `function ${command}; if test -x "${dir}/${command}"; "${dir}/${command}" $argv; else; command ${command} $argv; end; end`).join("\n");
+    return `${RC_BEGIN}\n# ${RC_SENTINEL}\n# ${RC_FUNCTIONS_SENTINEL}\nfish_add_path -p "${dir}"\n${fns}\n${RC_END}\n`;
 }
 function stripRcBlock(existing) {
     const pattern = new RegExp(`${escapeRegex(RC_BEGIN)}\\n[\\s\\S]*?${escapeRegex(RC_END)}\\n?`, "g");
@@ -517,6 +564,55 @@ function sweepLegacyRcBlocks(homeDir, removed, warnings) {
         }
     }
 }
+export function legacyPythonHookSites(homeDir) {
+    return candidateSitePackagesDirs(homeDir).filter((dir) => existsSync(join(dir, LEGACY_PYTHON_HOOK_PTH)) || readText(join(dir, LEGACY_PYTHON_HOOK_PY)).includes(LEGACY_PYTHON_HOOK_MARKER));
+}
+function sweepLegacyPythonHooks(homeDir, removed, warnings) {
+    for (const dir of candidateSitePackagesDirs(homeDir)) {
+        const pyPath = join(dir, LEGACY_PYTHON_HOOK_PY);
+        const pthPath = join(dir, LEGACY_PYTHON_HOOK_PTH);
+        const pyIsHook = readText(pyPath).includes(LEGACY_PYTHON_HOOK_MARKER);
+        const pthPresent = existsSync(pthPath);
+        if (!pyIsHook && !pthPresent) {
+            continue;
+        }
+        if (pthPresent) {
+            removePythonHookFile(pthPath, removed, warnings);
+        }
+        if (pyIsHook) {
+            removePythonHookFile(pyPath, removed, warnings);
+        }
+    }
+}
+function removePythonHookFile(path, removed, warnings) {
+    try {
+        rmSync(path, { force: true });
+        removed.push(`${path} (legacy dg pip hook)`);
+    }
+    catch (error) {
+        warnings.push(`could not remove legacy dg pip hook ${path}: ${error instanceof Error ? error.message : "remove error"}`);
+    }
+}
+function candidateSitePackagesDirs(homeDir) {
+    const dirs = [];
+    for (const version of safeReaddir(join(homeDir, "Library", "Python"))) {
+        dirs.push(join(homeDir, "Library", "Python", version, "lib", "python", "site-packages"));
+    }
+    for (const entry of safeReaddir(join(homeDir, ".local", "lib"))) {
+        if (entry.startsWith("python")) {
+            dirs.push(join(homeDir, ".local", "lib", entry, "site-packages"));
+        }
+    }
+    return dirs;
+}
+function safeReaddir(dir) {
+    try {
+        return readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+}
 export function cleanupEntry(kind, path, mode, now, sentinel) {
     return {
         kind,
@@ -694,7 +790,7 @@ function serviceCheck(env) {
         message: `Service mode is running at ${state.proxy.proxyUrl}; trust installed: ${state.trustInstalled ? "yes" : "no"}`
     };
 }
-function pathPrecedenceCheck(env, shimDir) {
+function pathPrecedenceCheck(env, shimDir, functionsPresent) {
     const pathEntries = (env.PATH ?? "").split(delimiter).filter(Boolean);
     const shimIndex = pathEntries.indexOf(shimDir);
     const activateFix = `activate this shell: ${currentShellActivation(env)} — or open a new terminal`;
@@ -728,11 +824,18 @@ function pathPrecedenceCheck(env, shimDir) {
         };
     }
     if (offender) {
+        if (functionsPresent) {
+            return {
+                name: "path",
+                status: "pass",
+                message: `${offender.dir} resolves ${offender.command} first (e.g. an active virtualenv); dg shell functions intercept bare installs regardless`
+            };
+        }
         return {
             name: "path",
             status: "warn",
             message: `${shimDir} is on PATH but ${offender.dir} resolves ${offender.command} first`,
-            fix: activateFix
+            fix: `re-run dg setup to intercept inside virtualenvs — or ${activateFix}`
         };
     }
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@westbayberry/dg",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "Dependency Guardian supply-chain firewall CLI",
   "type": "module",
   "bin": {