@westbayberry/dg 1.3.2 → 2.0.0

package/dist/commands/setup.js

@@ -0,0 +1,302 @@
+import { EXIT_UNAVAILABLE, EXIT_USAGE } from "./types.js";
+import { LockBusyError } from "../state/index.js";
+import { activationCommand as shellActivationCommand, applySetupPlanWithLock, buildSetupPlan, renderSetupPlan } from "../setup/plan.js";
+import { buildServiceSetupPlan, configureService, renderServicePlan } from "../service/state.js";
+import { optionalSupportGate } from "../setup/optional-support.js";
+import { resolvePresentation } from "../presentation/mode.js";
+import { createTheme } from "../presentation/theme.js";
+import { closeSync, openSync, readSync } from "node:fs";
+import { homedir } from "node:os";
+import { authStatus } from "../auth/store.js";
+export const setupCommand = {
+    name: "setup",
+    summary: "Protect plain npm/pip/yarn installs (no dg prefix needed).",
+    usage: "dg setup [--print] [--yes] [--shell <auto|zsh|bash|fish>] [--service]",
+    flags: [
+        { flag: "--print", summary: "Preview the exact write plan and change nothing." },
+        { flag: "--yes", summary: "Apply without the interactive prompt (required when non-interactive)." },
+        { flag: "--shell", value: "<auto|zsh|bash|fish>", summary: "Target shell rc to write (default: auto-detect)." },
+        { flag: "--service", summary: "Set up service mode (Pro/Team; persistent proxy + managed CA)." }
+    ],
+    examples: ["dg setup --print", "dg setup --yes", "dg setup --shell zsh --yes"],
+    details: [
+        "In a terminal, shows what it writes and asks before applying, then reloads your shell. Use --yes to apply non-interactively and --print to preview only.",
+        "Writes only dg-owned reversible files and repairs setup drift; undo with dg uninstall. The per-repo git pre-commit hook is separate — see dg guard-commit."
+    ],
+    handler: (context) => setupHandler(context.args)
+};
+const WINDOWS_UNSUPPORTED = "dg setup does not support Windows yet — Linux and macOS only.\n";
+function setupHandler(args) {
+    const parsed = parseSetupArgs(args);
+    if ("error" in parsed) {
+        return {
+            exitCode: parsed.exitCode,
+            stdout: "",
+            stderr: parsed.error
+        };
+    }
+    if (process.platform === "win32") {
+        return {
+            exitCode: EXIT_UNAVAILABLE,
+            stdout: "",
+            stderr: WINDOWS_UNSUPPORTED
+        };
+    }
+    if (parsed.service) {
+        return serviceSetupHandler(parsed);
+    }
+    const plan = buildSetupPlan({
+        shell: parsed.shell
+    });
+    const renderedPlan = renderSetupPlan(plan);
+    if (parsed.printOnly) {
+        return {
+            exitCode: 0,
+            stdout: renderedPlan,
+            stderr: ""
+        };
+    }
+    if (!parsed.yes) {
+        if (isInteractive()) {
+            return runInteractiveSetup(plan);
+        }
+        return {
+            exitCode: EXIT_USAGE,
+            stdout: renderedPlan,
+            stderr: "dg setup requires --yes to apply this non-interactive write plan.\n"
+        };
+    }
+    try {
+        applySetupPlanWithLock(plan);
+    }
+    catch (error) {
+        if (error instanceof LockBusyError) {
+            return {
+                exitCode: 1,
+                stdout: renderedPlan,
+                stderr: `dg setup cannot apply while another setup or uninstall is running: ${error.path}\n`
+            };
+        }
+        throw error;
+    }
+    return {
+        exitCode: 0,
+        stdout: `${renderedPlan}\nSet up — active in new terminals. Activate this shell now: ${activationCommand(plan)}\n`,
+        stderr: ""
+    };
+}
+function isInteractive() {
+    return Boolean(process.stdin.isTTY && process.stderr.isTTY);
+}
+function runInteractiveSetup(plan) {
+    const theme = createTheme(resolvePresentation().color);
+    const accent = (text) => theme.paint("accent", text);
+    const muted = (text) => theme.paint("muted", text);
+    const err = process.stderr;
+    err.write(`\n  Scans ${accent("npm")}/${accent("pip")}/${accent("yarn")}/${muted("…")} installs automatically — no ${accent("dg")} prefix.\n`);
+    err.write(`  ${muted("Writes")} ${accent(tildify(plan.rcPath))}${muted(".")} ${muted("Reversible with")} ${accent("dg uninstall")}${muted(".")}\n\n`);
+    const answer = promptYesNoSync(`  ${accent("Proceed?")}`, theme);
+    if (answer === "no-tty") {
+        return {
+            exitCode: EXIT_USAGE,
+            stdout: "",
+            stderr: `  ${muted("no terminal to read consent — re-run with")} ${accent("dg setup --yes")} ${muted("to apply non-interactively")}\n`
+        };
+    }
+    if (answer !== "yes") {
+        return { exitCode: 0, stdout: "", stderr: `  ${muted("cancelled — nothing written")}\n` };
+    }
+    try {
+        applySetupPlanWithLock(plan);
+    }
+    catch (error) {
+        if (error instanceof LockBusyError) {
+            return {
+                exitCode: 1,
+                stdout: "",
+                stderr: `  dg setup cannot apply while another setup or uninstall is running: ${error.path}\n`
+            };
+        }
+        throw error;
+    }
+    err.write(`\n  ${theme.paint("pass", "✓ set up — active in new terminals")}\n`);
+    err.write(`  ${muted("Activate this shell now:")}  ${accent(activationCommand(plan))}\n`);
+    return { exitCode: 0, stdout: "", stderr: "" };
+}
+function activationCommand(plan) {
+    return shellActivationCommand(plan.shell, tildify(plan.rcPath));
+}
+function promptYesNoSync(question, theme) {
+    process.stderr.write(`${question} ${theme.paint("muted", "[y/N]")} `);
+    let tty;
+    try {
+        tty = openSync("/dev/tty", "rs");
+    }
+    catch {
+        return "no-tty";
+    }
+    try {
+        const byte = Buffer.alloc(1);
+        let answer = "";
+        for (;;) {
+            let read = 0;
+            try {
+                read = readSync(tty, byte, 0, 1, null);
+            }
+            catch (error) {
+                if (error.code === "EAGAIN") {
+                    continue;
+                }
+                break;
+            }
+            if (read === 0) {
+                break;
+            }
+            const char = byte.toString("utf8");
+            if (char === "\n" || char === "\r") {
+                break;
+            }
+            answer += char;
+        }
+        const normalized = answer.trim().toLowerCase();
+        return normalized === "y" || normalized === "yes" ? "yes" : "no";
+    }
+    finally {
+        closeSync(tty);
+    }
+}
+function tildify(path) {
+    const home = homedir();
+    return home && path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+}
+function parseSetupArgs(args) {
+    let printOnly = false;
+    let yes = false;
+    let shell = "auto";
+    let service = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--print") {
+            printOnly = true;
+        }
+        else if (arg === "--yes") {
+            yes = true;
+        }
+        else if (arg === "--service") {
+            service = true;
+        }
+        else if (arg === "--python-hook" || arg?.startsWith("--python-hook=")) {
+            return {
+                exitCode: EXIT_UNAVAILABLE,
+                error: `dg setup --python-hook is gated and no files were changed. ${optionalSupportGate("python-hook").message}.\n`
+            };
+        }
+        else if (arg === "--git-hooks") {
+            return {
+                exitCode: EXIT_USAGE,
+                error: "dg setup --git-hooks moved — run 'dg guard-commit' inside the repo you want to protect.\n"
+            };
+        }
+        else if (arg === "--shell") {
+            const value = args[index + 1];
+            if (!value) {
+                return {
+                    exitCode: EXIT_USAGE,
+                    error: "dg setup --shell requires one of: auto, zsh, bash, fish.\n"
+                };
+            }
+            const parsedShell = parseShell(value);
+            if (!parsedShell) {
+                if (value === "powershell") {
+                    return {
+                        exitCode: EXIT_UNAVAILABLE,
+                        error: `dg setup --shell powershell is gated and no files were changed. ${optionalSupportGate("windows").message}.\n`
+                    };
+                }
+                return {
+                    exitCode: EXIT_USAGE,
+                    error: `dg setup does not support shell '${value}' in this build. Supported shells: auto, zsh, bash, fish.\n`
+                };
+            }
+            shell = parsedShell;
+            index += 1;
+        }
+        else if (arg?.startsWith("--shell=")) {
+            const value = arg.slice("--shell=".length);
+            const parsedShell = parseShell(value);
+            if (!parsedShell) {
+                if (value === "powershell") {
+                    return {
+                        exitCode: EXIT_UNAVAILABLE,
+                        error: `dg setup --shell powershell is gated and no files were changed. ${optionalSupportGate("windows").message}.\n`
+                    };
+                }
+                return {
+                    exitCode: EXIT_USAGE,
+                    error: `dg setup does not support shell '${value}' in this build. Supported shells: auto, zsh, bash, fish.\n`
+                };
+            }
+            shell = parsedShell;
+        }
+        else {
+            return {
+                exitCode: EXIT_USAGE,
+                error: `dg setup: unknown option '${arg}'. Run 'dg setup --help'.\n`
+            };
+        }
+    }
+    return {
+        printOnly,
+        yes,
+        shell,
+        service
+    };
+}
+function parseShell(value) {
+    if (value === "auto" || value === "zsh" || value === "bash" || value === "fish") {
+        return value;
+    }
+    return null;
+}
+function serviceSetupHandler(parsed) {
+    const renderedPlan = renderServicePlan("Dependency Guardian service setup write plan", buildServiceSetupPlan());
+    if (parsed.printOnly) {
+        return {
+            exitCode: 0,
+            stdout: renderedPlan,
+            stderr: ""
+        };
+    }
+    if (!authStatus().authenticated) {
+        return {
+            exitCode: EXIT_UNAVAILABLE,
+            stdout: "",
+            stderr: "dg setup --service is a Pro or Team feature. Run 'dg login' to connect a paid account, then 'dg setup --service'. See https://westbayberry.com/pricing\n"
+        };
+    }
+    if (!parsed.yes) {
+        return {
+            exitCode: EXIT_USAGE,
+            stdout: renderedPlan,
+            stderr: "dg setup --service requires --yes to apply this non-interactive write plan.\n"
+        };
+    }
+    try {
+        const result = configureService();
+        return {
+            exitCode: 0,
+            stdout: `${renderedPlan}\nService mode ${result.changed ? "configured" : "already configured"}. Run 'dg service start' to start it.\n`,
+            stderr: ""
+        };
+    }
+    catch (error) {
+        if (error instanceof LockBusyError) {
+            return {
+                exitCode: 1,
+                stdout: renderedPlan,
+                stderr: `dg setup --service cannot apply while service state is locked: ${error.path}\n`
+            };
+        }
+        throw error;
+    }
+}

package/dist/commands/status.js

@@ -0,0 +1,115 @@
+import { authStatus, displayTier } from "../auth/store.js";
+import { loadUserConfig } from "../config/settings.js";
+import { resolvePresentation } from "../presentation/mode.js";
+import { createTheme } from "../presentation/theme.js";
+import { doctorReport } from "../setup/plan.js";
+import { gitHookStatusState } from "../setup/git-hook.js";
+import { EXIT_USAGE } from "./types.js";
+export const statusCommand = {
+    name: "status",
+    summary: "Show what dg protects on this machine right now.",
+    usage: "dg status [--json]",
+    flags: [{ flag: "--json", summary: "Machine-readable status snapshot." }],
+    examples: ["dg status", "dg status --json"],
+    details: [
+        "A quick snapshot: account connection, bare-command protection, commit guard (inside a repo), and the active policy.",
+        "For full diagnostics with fix commands, run 'dg doctor'."
+    ],
+    handler: (context) => runStatusCommand(context.args)
+};
+function runStatusCommand(args) {
+    const json = args.includes("--json");
+    const unknown = args.find((arg) => arg !== "--json");
+    if (unknown) {
+        return {
+            exitCode: EXIT_USAGE,
+            stdout: "",
+            stderr: `dg status: unknown option '${unknown}'. Run 'dg status --help'.\n`
+        };
+    }
+    const report = buildStatusReport();
+    if (json) {
+        return {
+            exitCode: 0,
+            stdout: `${JSON.stringify(report, null, 2)}\n`,
+            stderr: ""
+        };
+    }
+    return {
+        exitCode: 0,
+        stdout: renderStatus(report, createTheme(resolvePresentation().color)),
+        stderr: ""
+    };
+}
+function buildStatusReport() {
+    const checks = doctorReport().checks;
+    const checkPassed = (name) => checks.find((check) => check.name === name)?.status === "pass";
+    const auth = safeAuthStatus();
+    const policy = loadUserConfig().policy;
+    return {
+        account: auth,
+        protection: { shims: checkPassed("shims"), path: checkPassed("path") },
+        commitGuard: safeCommitGuard(),
+        policy: { mode: policy.mode, trustProjectAllowlists: policy.trustProjectAllowlists }
+    };
+}
+function safeCommitGuard() {
+    try {
+        return gitHookStatusState();
+    }
+    catch {
+        return "not-a-repo";
+    }
+}
+function safeAuthStatus() {
+    try {
+        const status = authStatus();
+        return {
+            connected: status.authenticated,
+            tokenPreview: status.tokenPreview,
+            ...(status.email ? { email: status.email } : {}),
+            ...(status.tier ? { tier: status.tier } : {})
+        };
+    }
+    catch {
+        return { connected: false, tokenPreview: "" };
+    }
+}
+function renderStatus(report, theme) {
+    const account = report.account.connected
+        ? report.account.email && report.account.tier
+            ? `${theme.paint("pass", "✓")} ${report.account.email} · ${displayTier(report.account.tier)} plan`
+            : `${theme.paint("pass", "✓")} connected (${report.account.tokenPreview})`
+        : `${theme.paint("warn", "⚠")} not connected — run ${theme.paint("accent", "dg login")}`;
+    const bare = report.protection.shims && report.protection.path
+        ? `${theme.paint("pass", "✓")} bare npm/pip installs are protected`
+        : report.protection.shims
+            ? `${theme.paint("warn", "⚠")} set up — active in new terminals (or prefix commands with ${theme.paint("accent", "dg")})`
+            : `${theme.paint("warn", "⚠")} not set up — run ${theme.paint("accent", "dg setup")}, or prefix commands with ${theme.paint("accent", "dg")}`;
+    const lines = [
+        "Dependency Guardian status",
+        "",
+        `  Account      ${account}`,
+        `  Installs     ${bare}`
+    ];
+    const guard = commitGuardLine(report.commitGuard, theme);
+    if (guard) {
+        lines.push(`  Commit guard ${guard}`);
+    }
+    lines.push(`  Policy       ${report.policy.mode} mode; project allowlists ${report.policy.trustProjectAllowlists ? "trusted" : "untrusted"}`);
+    lines.push("");
+    lines.push(`Full diagnostics: ${theme.paint("accent", "dg doctor")}`);
+    return `${lines.join("\n")}\n`;
+}
+function commitGuardLine(state, theme) {
+    if (state === "not-a-repo") {
+        return null;
+    }
+    if (state === "active") {
+        return `${theme.paint("pass", "✓")} this repo's commits are scanned`;
+    }
+    if (state === "dead") {
+        return `${theme.paint("warn", "⚠")} installed but git isn't using it — run ${theme.paint("accent", "dg guard-commit --check")}`;
+    }
+    return `${theme.paint("warn", "⚠")} off — run ${theme.paint("accent", "dg guard-commit")}`;
+}

package/dist/commands/suggest.js

@@ -0,0 +1,35 @@
+const MAX_SUGGESTION_DISTANCE = 3;
+function editDistance(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const width = n + 1;
+    const dp = new Int32Array((m + 1) * width);
+    for (let i = 0; i <= m; i += 1) {
+        dp[i * width] = i;
+    }
+    for (let j = 0; j <= n; j += 1) {
+        dp[j] = j;
+    }
+    for (let i = 1; i <= m; i += 1) {
+        for (let j = 1; j <= n; j += 1) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            const up = dp[(i - 1) * width + j] ?? 0;
+            const left = dp[i * width + (j - 1)] ?? 0;
+            const diagonal = dp[(i - 1) * width + (j - 1)] ?? 0;
+            dp[i * width + j] = Math.min(up + 1, left + 1, diagonal + cost);
+        }
+    }
+    return dp[m * width + n] ?? 0;
+}
+export function closestCommand(input, commands) {
+    let best = null;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (const command of commands) {
+        const distance = editDistance(input, command);
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            best = command;
+        }
+    }
+    return best !== null && bestDistance <= MAX_SUGGESTION_DISTANCE ? best : null;
+}

package/dist/commands/types.js

@@ -0,0 +1,4 @@
+export const EXIT_USAGE = 2;
+export const EXIT_NOTHING_TO_SCAN = 10;
+export const EXIT_UNAVAILABLE = 69;
+export const EXIT_TOOL_ERROR = 70;

package/dist/commands/unavailable.js

@@ -0,0 +1,11 @@
+import { EXIT_UNAVAILABLE } from "./types.js";
+export function unavailableCommand(feature, nextStep) {
+    return (context) => {
+        const invoked = ["dg", ...context.commandPath, ...context.args].join(" ");
+        return {
+            exitCode: EXIT_UNAVAILABLE,
+            stdout: "",
+            stderr: `${invoked} is not available in this CLI build. ${feature}. ${nextStep}\n`
+        };
+    };
+}

package/dist/commands/uninstall.js

@@ -0,0 +1,111 @@
+import { EXIT_USAGE } from "./types.js";
+import { LockBusyError } from "../state/index.js";
+import { uninstallSetup } from "../setup/plan.js";
+import { serviceUninstallHandler } from "./service.js";
+export const uninstallCommand = {
+    name: "uninstall",
+    summary: "Reverse dg-owned setup writes.",
+    usage: "dg uninstall [--yes] [--service] [--all] [--keep-config]",
+    flags: [
+        { flag: "--yes", summary: "Remove without the confirmation prompt." },
+        { flag: "--keep-config", summary: "Keep ~/.dg config and cache." },
+        { flag: "--all", summary: "Also remove the config directory — a full wipe." },
+        { flag: "--service", summary: "Reverse only service-mode writes." }
+    ],
+    examples: ["dg uninstall", "dg uninstall --yes --keep-config", "dg uninstall --all --yes"],
+    details: [
+        "Removes only dg-owned writes (shims, shell-rc block, git hooks), tolerates missing or malformed state, runs twice safely, and preserves user content."
+    ],
+    handler: (context) => uninstallHandler(context.args)
+};
+function uninstallHandler(args) {
+    const parsed = parseUninstallArgs(args);
+    if ("error" in parsed) {
+        return {
+            exitCode: parsed.exitCode,
+            stdout: "",
+            stderr: parsed.error
+        };
+    }
+    if (parsed.service) {
+        return serviceUninstallHandler(args.filter((arg) => arg !== "--service"));
+    }
+    if (!parsed.yes) {
+        return {
+            exitCode: EXIT_USAGE,
+            stdout: "Dependency Guardian uninstall will remove only registered dg-owned setup writes.\n",
+            stderr: "dg uninstall requires --yes to remove files in non-interactive mode.\n"
+        };
+    }
+    let result;
+    try {
+        result = uninstallSetup({
+            keepConfig: parsed.keepConfig,
+            all: parsed.all
+        });
+    }
+    catch (error) {
+        if (error instanceof LockBusyError) {
+            return {
+                exitCode: 1,
+                stdout: "Dependency Guardian uninstall will remove only registered dg-owned setup writes.\n",
+                stderr: `dg uninstall cannot run while another setup or uninstall is running: ${error.path}\n`
+            };
+        }
+        throw error;
+    }
+    const lines = [
+        "Dependency Guardian uninstall",
+        "",
+        ...result.removed.map((path) => `removed: ${path}`),
+        ...result.staleSessions.map((id) => `stale session removed: ${id}`),
+        ...result.missing.map((path) => `already absent: ${path}`),
+        ...result.warnings.map((warning) => `warning: ${warning}`),
+        result.removed.length === 0 && result.staleSessions.length === 0 && result.warnings.length === 0
+            ? "No dg-owned setup writes were present."
+            : "Uninstall completed."
+    ];
+    return {
+        exitCode: 0,
+        stdout: `${lines.join("\n")}\n`,
+        stderr: ""
+    };
+}
+function parseUninstallArgs(args) {
+    let yes = false;
+    let keepConfig = false;
+    let all = false;
+    let service = false;
+    for (const arg of args) {
+        if (arg === "--yes") {
+            yes = true;
+        }
+        else if (arg === "--keep-config") {
+            keepConfig = true;
+        }
+        else if (arg === "--all") {
+            all = true;
+        }
+        else if (arg === "--service") {
+            service = true;
+        }
+        else {
+            return {
+                exitCode: EXIT_USAGE,
+                error: `dg uninstall: unknown option '${arg}'. Run 'dg uninstall --help'.\n`
+            };
+        }
+    }
+    if (all && keepConfig) {
+        return {
+            exitCode: EXIT_USAGE,
+            error: "dg uninstall: --all and --keep-config conflict — choose one. Run 'dg uninstall --help'.\n"
+        };
+    }
+    return {
+        yes,
+        keepConfig,
+        all,
+        service
+    };
+}