@westbayberry/dg 2.2.0 → 2.3.1

package/dist/setup/plan.js

@@ -1,22 +1,24 @@
-import { accessSync, constants, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { accessSync, constants, copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { basename, delimiter, dirname, join, resolve, sep } from "node:path";
 import { chmodSync } from "node:fs";
+import { fileURLToPath } from "node:url";
 import { randomBytes } from "node:crypto";
 import { homedir } from "node:os";
 import { createTheme } from "../presentation/theme.js";
-import { reverseAgentHookEntry } from "../agents/registry.js";
+import { AGENTS, AGENT_IDS, agentLabel, resolveAgentHookContext, reverseAgentHookEntry } from "../agents/registry.js";
+import { GATE_ENABLE_HINT, readNetworkGatePosture } from "../agents/gate-posture.js";
 import { acquireLockSync, findStaleSessionsSync, preserveCorruptCleanupRegistrySync, resolveDgPaths, sweepStaleSessionsSync, CLEANUP_REGISTRY_LOCK } from "../state/index.js";
 import { currentNodeVersion, isSupportedNode } from "../runtime/node-version.js";
 import { dgVersion } from "../commands/version.js";
 import { compareVersions, readLatestVersion } from "../commands/update.js";
 import { AuthError, authStatus, displayTier, readAuthState } from "../auth/store.js";
-import { ConfigError, loadUserConfig } from "../config/settings.js";
+import { ConfigError, DEFAULT_CONFIG, loadUserConfig } from "../config/settings.js";
 import { describeCooldownSettings } from "../policy/cooldown.js";
 import { resolveRealBinary } from "../launcher/resolve-real-binary.js";
 import { packageManagerNames } from "../launcher/classify.js";
 import { readServiceState } from "../service/state.js";
 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_COMMANDS = Object.freeze(["npm", "npx", "pnpm", "pnpx", "yarn", "pip", "pip3", "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";
@@ -35,6 +37,14 @@ const LEGACY_PYTHON_HOOK_PTH_MARKER = "import dg_pip_hook";
 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;
+function readShimFailClosed(env) {
+    try {
+        return loadUserConfig(env).policy.shimFailClosed;
+    }
+    catch {
+        return false;
+    }
+}
 const DOCTOR_GROUP_BY_NAME = {
     node: "environment",
     package: "environment",
@@ -56,6 +66,7 @@ const DOCTOR_GROUP_BY_NAME = {
     "commit-guard": "setup",
     "stale-sessions": "setup",
     service: "setup",
+    "agent-gate": "setup",
     auth: "account",
     api: "account"
 };
@@ -102,6 +113,7 @@ export function buildSetupPlan(options) {
         shell,
         shimDir,
         rcPath,
+        failClosed: readShimFailClosed(env),
         writes: [
             {
                 kind: "directory",
@@ -147,13 +159,14 @@ export function applySetupPlan(plan, now = new Date()) {
     });
     for (const command of SHIM_COMMANDS) {
         const path = join(plan.shimDir, command);
-        writeFileSync(path, shimSource(command), {
+        writeFileSync(path, shimSource(command, { failClosed: plan.failClosed }), {
             encoding: "utf8",
             mode: 0o755
         });
         chmodSync(path, 0o755);
         entries.push(cleanupEntry("shim", path, "mode1", now, SHIM_SENTINEL));
     }
+    installStandaloneUninstaller(plan.paths.homeDir);
     mkdirSync(dirname(plan.rcPath), {
         recursive: true,
         mode: 0o700
@@ -182,6 +195,45 @@ export function applySetupPlanWithLock(plan, now = new Date()) {
         lock.release();
     }
 }
+// Shims written by a dg that predates the self-cleaning template carry no
+// auto-cleanup, so a plain `npm uninstall -g` leaves them stranded forever.
+// Rewriting the installed shims and reinstalling the standalone uninstaller on
+// the first run after a version bump propagates the current template to setups
+// created by older releases.
+export function refreshSetupOnUpgrade(env = process.env) {
+    const paths = resolveDgPaths(env);
+    const shimDir = join(paths.homeDir, ".dg", "shims");
+    if (!isShimFile(join(shimDir, "npm"))) {
+        return false;
+    }
+    const failClosed = readShimFailClosed(env);
+    try {
+        const lock = acquireLockSync(paths, SETUP_UNINSTALL_LOCK, {
+            staleMs: SETUP_UNINSTALL_LOCK_STALE_MS
+        });
+        try {
+            for (const command of SHIM_COMMANDS) {
+                const shimPath = join(shimDir, command);
+                if (!isShimFile(shimPath)) {
+                    continue;
+                }
+                writeFileSync(shimPath, shimSource(command, { failClosed }), {
+                    encoding: "utf8",
+                    mode: 0o755
+                });
+                chmodSync(shimPath, 0o755);
+            }
+            installStandaloneUninstaller(paths.homeDir);
+        }
+        finally {
+            lock.release();
+        }
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
 export function uninstallSetup(options) {
     const paths = resolveDgPaths(options.env ?? process.env);
     const hadCacheDirBeforeLock = existsSync(paths.cacheDir);
@@ -328,6 +380,7 @@ export function doctorReport(options = {}) {
     });
     checks.push(...unavailableDoctorChecks());
     checks.push(serviceCheck(env));
+    checks.push(agentGateCheck(env, paths.homeDir));
     return {
         version: dgVersion(),
         checks: checks.map(enrichDoctorCheck)
@@ -596,10 +649,10 @@ function reloadInstructions(shell) {
 // 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) {
+export function shimSource(command, options = {}) {
     const dg = escapeDoubleQuotedSh(dgEntrypoint());
     const nonce = '"${DG_SHIM_ACTIVE:+$DG_SHIM_ACTIVE,}' + `${command}:$$"`;
-    return [
+    const head = [
         "#!/bin/sh",
         `# ${SHIM_SENTINEL}`,
         `if [ -x "${dg}" ]; then`,
@@ -610,6 +663,27 @@ export function shimSource(command) {
         `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"
+    ];
+    // dg is gone from this machine. fail-closed (managed/CI) refuses the command
+    // so an unscanned install can't slip through; the operator removes the guard
+    // explicitly via `dg uninstall` while dg is present. fail-open (default)
+    // self-cleans dg's footprint and falls back to the real binary, because a
+    // plain `npm uninstall -g dg` cannot run cleanup and must not brick npm.
+    const failClosedTail = [
+        `echo "dg: install firewall required by policy (policy.shimFailClosed) but dg is unavailable; refusing to run ${command}" >&2`,
+        `echo "dg: reinstall dg, or run 'dg uninstall' while dg is present, to remove this guard" >&2`,
+        "exit 127",
+        ""
+    ];
+    const failOpenTail = [
+        `dg_home=$(dirname "$shim_dir")`,
+        `if [ -f "$dg_home/uninstall.mjs" ] && command -v node >/dev/null 2>&1; then`,
+        `  ( sleep 10`,
+        `    if [ ! -x "${dg}" ] && ! PATH="$dg_path" command -v dg >/dev/null 2>&1; then`,
+        `      node "$dg_home/uninstall.mjs" --quiet >/dev/null 2>&1`,
+        `    fi`,
+        `  ) >/dev/null 2>&1 &`,
         "fi",
         `real_bin=$(PATH="$dg_path" command -v ${command} 2>/dev/null)`,
         `if [ -n "$real_bin" ]; then`,
@@ -618,7 +692,8 @@ export function shimSource(command) {
         `echo "dg: protection unavailable and no real ${command} found on PATH" >&2`,
         "exit 127",
         ""
-    ].join("\n");
+    ];
+    return [...head, ...(options.failClosed ? failClosedTail : failOpenTail)].join("\n");
 }
 function escapeDoubleQuotedSh(value) {
     return value.replace(/[\\"$`]/g, "\\$&");
@@ -630,6 +705,25 @@ function dgEntrypoint() {
     const argv1 = process.argv[1];
     return argv1 ? resolve(argv1) : "dg";
 }
+function standaloneUninstallerSource() {
+    try {
+        return fileURLToPath(new URL("../standalone/uninstall.mjs", import.meta.url));
+    }
+    catch {
+        return undefined;
+    }
+}
+function installStandaloneUninstaller(homeDir) {
+    const source = standaloneUninstallerSource();
+    if (!source || !existsSync(source)) {
+        return;
+    }
+    const dgRoot = join(homeDir, ".dg");
+    mkdirSync(dgRoot, { recursive: true, mode: 0o700 });
+    const dest = join(dgRoot, "uninstall.mjs");
+    copyFileSync(source, dest);
+    chmodSync(dest, 0o600);
+}
 function withRcBlock(existing, plan) {
     const withoutExisting = stripRcBlock(existing);
     const block = plan.shell === "fish" ? fishRcBlock(plan.shimDir) : posixRcBlock(plan.shimDir);
@@ -846,7 +940,19 @@ function configCheck(paths, env) {
     }
     try {
         accessSync(paths.configDir, constants.R_OK);
-        loadUserConfig(env);
+        const config = loadUserConfig(env);
+        if (config.api.baseUrl !== DEFAULT_CONFIG.api.baseUrl) {
+            // The verdict API is the firewall's source of truth. A non-default
+            // endpoint is legitimate for enterprise self-host, but a silent repoint
+            // is also how an attacker would make every verdict come back clean, so
+            // surface it on the standard health check rather than trusting it quietly.
+            return {
+                name: "config",
+                status: "warn",
+                message: `dg is fetching verdicts from a non-default API endpoint: ${config.api.baseUrl} (default ${DEFAULT_CONFIG.api.baseUrl})`,
+                fix: `if you did not set this, your verdict source may be tampered — restore with: dg config set api.baseUrl ${DEFAULT_CONFIG.api.baseUrl}`
+            };
+        }
         return {
             name: "config",
             status: "pass",
@@ -962,6 +1068,45 @@ function serviceCheck(env) {
         message: `Service mode is running at ${state.proxy.proxyUrl}; trust installed: ${state.trustInstalled ? "yes" : "no"}`
     };
 }
+function hookedAgentLabels(env, home) {
+    const labels = [];
+    for (const agent of AGENT_IDS) {
+        const integration = AGENTS[agent];
+        if (!integration.detect(home)) {
+            continue;
+        }
+        const ctx = resolveAgentHookContext(agent, { env, home });
+        const hooked = integration.verify(ctx).find((check) => check.name === integration.isInstalledCheckName)?.ok ?? false;
+        if (hooked) {
+            labels.push(agentLabel(agent));
+        }
+    }
+    return labels;
+}
+function agentGateCheck(env, home) {
+    const hooked = hookedAgentLabels(env, home);
+    if (hooked.length === 0) {
+        return {
+            name: "agent-gate",
+            status: "unavailable",
+            message: "No AI agent has the dg install hook; run 'dg agents on' to protect agent-run installs"
+        };
+    }
+    const posture = readNetworkGatePosture(env);
+    if (posture.live) {
+        return {
+            name: "agent-gate",
+            status: "pass",
+            message: `${hooked.join(", ")} hooked; network gate live at ${posture.proxyUrl} (installs screened at fetch by artifact hash)`
+        };
+    }
+    return {
+        name: "agent-gate",
+        status: "warn",
+        message: `${hooked.join(", ")} hooked but the fetch-time network gate is OFF — static pre-screen only; absolute-path, manifest-only, dynamic, and unsupported-manager installs are NOT screened`,
+        fix: GATE_ENABLE_HINT
+    };
+}
 function pathPrecedenceCheck(env, shimDir, functionsPresent) {
     const pathEntries = (env.PATH ?? "").split(delimiter).filter(Boolean);
     const shimIndex = pathEntries.indexOf(shimDir);
@@ -1148,9 +1293,8 @@ function scriptGateCheck(env) {
         if (mode === "enforce") {
             return {
                 name: "script-gate",
-                status: "warn",
-                message: "scriptGate.mode is enforce, but this dg release observes only — installs report script-running packages without blocking",
-                fix: "enforcement ships in an upcoming release; dg config set scriptGate.mode observe clears this warning"
+                status: "pass",
+                message: "Install-script gate enforces: protected npm/yarn installs run with --ignore-scripts so packages cannot run lifecycle scripts (pnpm blocks them natively)"
             };
         }
         return {

package/dist/setup/uninstall-standalone.js

@@ -0,0 +1,25 @@
+import { rmSync } from "node:fs";
+import { join } from "node:path";
+import { uninstallSetup } from "./plan.js";
+import { LockBusyError, resolveDgPaths } from "../state/index.js";
+function run() {
+    const quiet = process.argv.includes("--quiet");
+    try {
+        const result = uninstallSetup({ keepConfig: false, all: true });
+        if (!quiet) {
+            process.stderr.write(`Dependency Guardian cleaned up ${result.removed.length} leftover item(s) after the package was removed.\n`);
+        }
+    }
+    catch (error) {
+        if (!quiet && !(error instanceof LockBusyError)) {
+            process.stderr.write(`dg self-cleanup could not finish: ${error.message}\n`);
+        }
+    }
+    try {
+        rmSync(join(resolveDgPaths().homeDir, ".dg"), { recursive: true, force: true });
+    }
+    catch {
+        return;
+    }
+}
+run();

package/dist/setup-ui/wizard.js

@@ -175,7 +175,8 @@ export const SetupWizardApp = (props) => {
 export async function runSetupWizard(plan, options = {}) {
     const env = options.env ?? process.env;
     const ci = process.env.CI;
-    if (ci === "" || ci === "0" || ci === "false") {
+    const restoreCi = ci === "" || ci === "0" || ci === "false";
+    if (restoreCi) {
         delete process.env.CI;
     }
     const agents = collectAgentOffers();
@@ -193,11 +194,18 @@ export async function runSetupWizard(plan, options = {}) {
         } }), { exitOnCtrlC: true });
     await instance.waitUntilExit();
     leaveTui();
+    if (restoreCi) {
+        process.env.CI = ci;
+    }
     const theme = createTheme(resolvePresentation().color);
     const accent = (text) => theme.paint("accent", text);
     const muted = (text) => theme.paint("muted", text);
     const outcome = state.outcome;
     if (outcome === null) {
+        // Aborted (e.g. Ctrl-C). Record the skip so the wizard does not re-intercept
+        // every subsequent dg command until the user explicitly declines or applies it.
+        markWizardSkipped(env);
+        markFirstRunShown(env);
         return { exitCode: 0, stdout: "", stderr: "" };
     }
     if (outcome.kind === "declined") {