@hades200082/envsync 0.0.2

package/dist/src/runner.js

@@ -0,0 +1,213 @@
+import { refreshEnvironment } from "./env.js";
+import { c, log } from "./log.js";
+import { resolveCommand } from "./resolve.js";
+import { defaultShell, runShell } from "./shell.js";
+import { findOnPath } from "./which.js";
+export async function runAll(config, platform, options) {
+    const ctx = { config, platform, options };
+    const outcomes = [];
+    for (const tool of config.tools) {
+        if (options.only.length && !options.only.includes(tool.name))
+            continue;
+        if (options.skip.includes(tool.name)) {
+            outcomes.push({ name: tool.name, status: "skipped", detail: "--skip" });
+            continue;
+        }
+        outcomes.push(await runTool(tool, ctx));
+    }
+    return outcomes;
+}
+async function runTool(tool, ctx) {
+    const { platform, options } = ctx;
+    const name = tool.name;
+    if (tool.platforms && !tool.platforms.some((p) => platform.selectors.includes(p))) {
+        log.step(name, c.dim(`skipped (platforms: ${tool.platforms.join(", ")})`));
+        return { name, status: "skipped", detail: "platform filter" };
+    }
+    const check = resolveCommand(tool.check, platform.selectors);
+    const install = resolveCommand(tool.install, platform.selectors);
+    const update = resolveCommand(tool.update, platform.selectors);
+    if (options.statusOnly)
+        return await reportStatus(tool, check, install, ctx);
+    if (check.kind === "command") {
+        const present = await runCheck(name, check.command, ctx);
+        if (present) {
+            log.step(name, "already installed");
+            return await maybeUpdate(tool, update, ctx, "up-to-date");
+        }
+        log.step(name, "not installed");
+        const installed = await runInstall(tool, install, ctx);
+        if (installed.status !== "installed")
+            return installed;
+        if (options.dryRun)
+            return installed;
+        const verified = await runCheck(name, check.command, ctx);
+        if (!verified) {
+            log.warn(name, "install finished but the check still fails. A new terminal may be needed for PATH changes.");
+            return { name, status: "unverified" };
+        }
+        log.ok(name, "installed");
+        return installed;
+    }
+    if (check.kind === "skipped") {
+        log.step(name, c.dim(`skipped (check is null for ${check.selector})`));
+        return { name, status: "skipped", detail: `check null for ${check.selector}` };
+    }
+    // No usable check: run install (if any) and then update (if any).
+    let installed;
+    if (install.kind !== "undefined") {
+        installed = await runInstall(tool, install, ctx);
+        if (installed.status === "failed" || installed.status === "unsupported")
+            return installed;
+    }
+    return await maybeUpdate(tool, update, ctx, installed?.status ?? "unsupported");
+}
+async function reportStatus(tool, check, install, ctx) {
+    const name = tool.name;
+    if (check.kind !== "command") {
+        const detail = install.kind === "command" ? "no check command" : "no check or install for this machine";
+        log.step(name, c.dim(detail));
+        return { name, status: "skipped", detail };
+    }
+    const present = await runCheck(name, check.command, ctx);
+    if (present) {
+        log.ok(name, "present");
+        return { name, status: "present" };
+    }
+    log.warn(name, "missing");
+    return { name, status: "missing" };
+}
+/**
+ * Run the update command if there is one for this machine. `fallback` is the
+ * status to report when nothing runs: "up-to-date" when the check passed,
+ * "installed" when install just ran, "unsupported" when nothing at all ran.
+ */
+async function maybeUpdate(tool, update, ctx, fallback) {
+    const name = tool.name;
+    if (update.kind === "undefined") {
+        if (fallback === "unsupported")
+            log.warn(name, "nothing to run: no install or update command defined");
+        return { name, status: fallback };
+    }
+    // When nothing else ran, an update that is deliberately not run counts as a skip, not a failure.
+    const nothingRan = fallback === "unsupported";
+    if (ctx.options.installOnly) {
+        return nothingRan ? { name, status: "skipped", detail: "--install-only" } : { name, status: fallback };
+    }
+    if (update.kind === "skipped") {
+        log.debug(`${name}: update is null for ${update.selector}`);
+        return nothingRan ? { name, status: "skipped", detail: `update null for ${update.selector}` } : { name, status: fallback };
+    }
+    if (update.kind === "no-match") {
+        log.warn(name, `no update command for this machine (have: ${update.available.join(", ")})`);
+        return { name, status: fallback };
+    }
+    if (ctx.options.dryRun) {
+        log.step(name, `would run update (${update.command.selector}):`);
+        log.command(update.command.run);
+        return { name, status: "would-update" };
+    }
+    log.step(name, `updating (${update.command.selector})`);
+    log.command(update.command.run);
+    const result = await execute(update.command, ctx);
+    if (result !== 0) {
+        log.error(name, `update failed with exit code ${result}`);
+        return { name, status: "failed", detail: `update exit ${result}` };
+    }
+    await refreshEnvironment(ctx.platform);
+    log.ok(name, "updated");
+    return { name, status: "updated" };
+}
+async function runInstall(tool, install, ctx) {
+    const name = tool.name;
+    if (install.kind === "undefined") {
+        log.warn(name, "no install command defined");
+        return { name, status: "unsupported", detail: "no install command" };
+    }
+    if (install.kind === "skipped") {
+        log.step(name, c.dim(`install skipped (null for ${install.selector})`));
+        return { name, status: "skipped", detail: `install null for ${install.selector}` };
+    }
+    if (install.kind === "no-match") {
+        log.warn(name, `no install command for this machine (have: ${install.available.join(", ")}; this machine matches: ${ctx.platform.selectors.join(", ")})`);
+        return { name, status: "unsupported", detail: "no install command for this machine" };
+    }
+    if (ctx.options.dryRun) {
+        log.step(name, `would run install (${install.command.selector}):`);
+        log.command(install.command.run);
+        return { name, status: "would-install" };
+    }
+    log.step(name, `installing (${install.command.selector})`);
+    log.command(install.command.run);
+    const code = await execute(install.command, ctx);
+    if (code !== 0) {
+        log.error(name, `install failed with exit code ${code}`);
+        return { name, status: "failed", detail: `install exit ${code}` };
+    }
+    await refreshEnvironment(ctx.platform);
+    return { name, status: "installed" };
+}
+/** A bare word is looked up on PATH; anything else runs and must exit 0. */
+async function runCheck(name, command, ctx) {
+    const run = command.run.trim();
+    if (run !== "" && !/\s/.test(run)) {
+        const found = findOnPath(run);
+        log.debug(`${name}: check "${run}" on PATH: ${found ?? "not found"}`);
+        return found !== undefined;
+    }
+    log.debug(`${name}: check: ${run}`);
+    try {
+        const shell = pickShell(command, ctx);
+        const result = await runShell(shell, run, ctx.platform, {
+            capture: true,
+            failFast: command.failFast,
+            timeoutMs: 120_000,
+            env: { ...process.env, ENVSYNC_SHELL: shell },
+        });
+        log.debug(`${name}: check exit ${result.code}`);
+        return result.code === 0;
+    }
+    catch (err) {
+        log.debug(`${name}: check could not start: ${err.message}`);
+        return false;
+    }
+}
+async function execute(command, ctx) {
+    try {
+        const shell = pickShell(command, ctx);
+        const result = await runShell(shell, command.run, ctx.platform, {
+            failFast: command.failFast,
+            env: { ...process.env, ENVSYNC_SHELL: shell },
+        });
+        return result.code;
+    }
+    catch (err) {
+        log.error(null, `could not start shell: ${err.message}`);
+        return 127;
+    }
+}
+function pickShell(command, ctx) {
+    return command.shell ?? ctx.config.shell?.[ctx.platform.os] ?? defaultShell(ctx.platform.os);
+}
+export function summarize(outcomes) {
+    const label = {
+        installed: c.green,
+        updated: c.green,
+        "up-to-date": c.green,
+        present: c.green,
+        missing: c.yellow,
+        unverified: c.yellow,
+        skipped: c.dim,
+        unsupported: c.yellow,
+        failed: c.red,
+        "would-install": c.cyan,
+        "would-update": c.cyan,
+    };
+    const width = Math.max(4, ...outcomes.map((o) => o.name.length));
+    const lines = outcomes.map((o) => {
+        const detail = o.detail ? c.dim(`  (${o.detail})`) : "";
+        return `  ${o.name.padEnd(width)}  ${label[o.status](o.status)}${detail}`;
+    });
+    const failed = outcomes.filter((o) => o.status === "failed").length;
+    return { text: lines.join("\n"), failed };
+}

package/dist/src/shell.js

@@ -0,0 +1,101 @@
+import { spawn } from "node:child_process";
+import { findOnPath } from "./which.js";
+/** Pick the shell to use when neither the command nor the config names one. */
+export function defaultShell(os, has = (b) => findOnPath(b) !== undefined) {
+    if (os === "windows")
+        return has("pwsh") ? "pwsh" : "powershell";
+    return has("bash") ? "bash" : "sh";
+}
+/**
+ * Build the argv for a shell. The command text is passed as a single argument
+ * (base64 for PowerShell), so no quoting is needed and it can span lines.
+ */
+export function buildInvocation(shell, run, os, failFast = false) {
+    switch (shell) {
+        case "bash":
+        case "sh":
+        case "zsh":
+            return { file: locateUnixShell(shell, os), args: ["-c", failFast ? `set -e\n${run}` : run] };
+        case "pwsh":
+        case "powershell":
+            return {
+                file: shell === "pwsh" ? "pwsh" : "powershell.exe",
+                args: [
+                    "-NoLogo",
+                    "-NoProfile",
+                    "-ExecutionPolicy",
+                    "Bypass",
+                    "-EncodedCommand",
+                    encodePowerShell(wrapPowerShell(run, failFast)),
+                ],
+            };
+        case "cmd":
+            return { file: "cmd.exe", args: ["/d", "/s", "/c", failFast ? joinCmdSteps(run) : run] };
+    }
+}
+function locateUnixShell(shell, os) {
+    if (os !== "windows")
+        return shell;
+    // Git Bash is the usual case on Windows. Prefer PATH, then the default install dir.
+    const onPath = findOnPath(shell);
+    if (onPath)
+        return onPath;
+    const programFiles = process.env.ProgramFiles ?? "C:\\Program Files";
+    const exe = shell === "zsh" ? "bash" : shell;
+    return `${programFiles}\\Git\\bin\\${exe}.exe`;
+}
+/**
+ * PowerShell does not propagate a native command's exit code from -Command
+ * reliably, and a failed cmdlet leaves the exit code at 0. Wrap the script so
+ * both cases surface as a non-zero exit.
+ */
+export function wrapPowerShell(run, failFast = false) {
+    return [
+        ...(failFast ? ["$ErrorActionPreference = 'Stop'", "$PSNativeCommandUseErrorActionPreference = $true"] : []),
+        "$global:LASTEXITCODE = 0",
+        run,
+        "if (-not $?) { if ($LASTEXITCODE) { exit $LASTEXITCODE } else { exit 1 } }",
+        "if ($LASTEXITCODE) { exit $LASTEXITCODE }",
+        "exit 0",
+    ].join("\n");
+}
+/** cmd.exe only reads the first line of /c, so steps become one && chain. */
+export function joinCmdSteps(run) {
+    return run
+        .split(/\r?\n/)
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .join(" && ");
+}
+export function encodePowerShell(script) {
+    return Buffer.from(script, "utf16le").toString("base64");
+}
+export function runShell(shell, run, platform, options = {}) {
+    const { file, args } = buildInvocation(shell, run, platform.os, options.failFast ?? false);
+    return new Promise((resolve, reject) => {
+        const child = spawn(file, args, {
+            cwd: options.cwd ?? process.cwd(),
+            env: options.env ?? process.env,
+            stdio: options.capture ? ["ignore", "pipe", "pipe"] : "inherit",
+            windowsHide: true,
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (d) => (stdout += d.toString()));
+        child.stderr?.on("data", (d) => (stderr += d.toString()));
+        let timer;
+        if (options.timeoutMs) {
+            timer = setTimeout(() => child.kill(), options.timeoutMs);
+        }
+        child.on("error", (err) => {
+            if (timer)
+                clearTimeout(timer);
+            reject(err);
+        });
+        child.on("close", (code, signal) => {
+            if (timer)
+                clearTimeout(timer);
+            resolve({ code: code ?? (signal ? 1 : 0), stdout, stderr });
+        });
+    });
+}

package/dist/src/template.js

@@ -0,0 +1,43 @@
+export const SCHEMA_URL = "https://raw.githubusercontent.com/hades200082/env-sync/master/schema.json";
+/** Starter config written by `envsync --init`. Mirrors examples/envsync.json. */
+export function starterConfig() {
+    const config = {
+        $schema: SCHEMA_URL,
+        tools: [
+            {
+                name: "gh",
+                description: "GitHub CLI",
+                check: "gh",
+                install: {
+                    apt: [
+                        "type -p wget >/dev/null || (sudo apt-get update && sudo apt-get install wget -y)",
+                        "sudo mkdir -p -m 755 /etc/apt/keyrings",
+                        "out=$(mktemp) && wget -nv -O$out https://cli.github.com/packages/githubcli-archive-keyring.gpg",
+                        "cat $out | sudo tee /etc/apt/keyrings/githubcli-archive-keyring.gpg > /dev/null",
+                        "sudo chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg",
+                        "sudo mkdir -p -m 755 /etc/apt/sources.list.d",
+                        'echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null',
+                        "sudo apt-get update",
+                        "sudo apt-get install gh -y",
+                    ],
+                    dnf: "sudo dnf install -y 'dnf-command(config-manager)' && sudo dnf config-manager --add-repo https://cli.github.com/packages/rpm/gh-cli.repo && sudo dnf install -y gh --repo gh-cli",
+                    brew: "brew install gh",
+                    winget: "winget install --id GitHub.cli --exact --accept-source-agreements --accept-package-agreements",
+                },
+                update: {
+                    apt: "sudo apt-get update && sudo apt-get install -y --only-upgrade gh",
+                    dnf: "sudo dnf upgrade -y gh",
+                    brew: "brew upgrade gh || true",
+                    winget: "winget upgrade --id GitHub.cli --exact --accept-source-agreements --accept-package-agreements",
+                },
+            },
+            {
+                name: "skills",
+                description: "Agent skills installed with the skills CLI",
+                install: "npx -y skills@latest add mattpocock/skills -a claude-code -g -y",
+                update: "npx -y skills@latest update -g -y",
+            },
+        ],
+    };
+    return JSON.stringify(config, null, 2) + "\n";
+}

package/dist/src/types.js

@@ -0,0 +1 @@
+export const SHELL_NAMES = ["bash", "sh", "zsh", "pwsh", "powershell", "cmd"];

package/dist/src/update-check.js

@@ -0,0 +1,44 @@
+import { log } from "./log.js";
+/** Returns the newer version on the registry, or undefined. Never throws; times out fast. */
+export async function checkForNewerVersion(name, current, timeoutMs = 3000) {
+    try {
+        const response = await fetch(`https://registry.npmjs.org/${name}/latest`, {
+            signal: AbortSignal.timeout(timeoutMs),
+            headers: { Accept: "application/json" },
+        });
+        if (!response.ok)
+            return undefined;
+        const body = (await response.json());
+        if (typeof body.version !== "string")
+            return undefined;
+        return compareVersions(body.version, current) > 0 ? body.version : undefined;
+    }
+    catch (err) {
+        log.debug(`update check skipped: ${err.message}`);
+        return undefined;
+    }
+}
+/** Compare two dotted versions. Positive when a > b. Pre-release suffixes sort before the release. */
+export function compareVersions(a, b) {
+    const parse = (v) => {
+        const [core = "", pre] = v.replace(/^v/, "").split("-", 2);
+        const nums = core.split(".").map((n) => Number.parseInt(n, 10) || 0);
+        while (nums.length < 3)
+            nums.push(0);
+        return { nums, pre };
+    };
+    const pa = parse(a);
+    const pb = parse(b);
+    for (let i = 0; i < 3; i++) {
+        const diff = (pa.nums[i] ?? 0) - (pb.nums[i] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    if (pa.pre && !pb.pre)
+        return -1;
+    if (!pa.pre && pb.pre)
+        return 1;
+    if (pa.pre && pb.pre)
+        return pa.pre.localeCompare(pb.pre);
+    return 0;
+}

package/dist/src/validate.js

@@ -0,0 +1,127 @@
+import { SHELL_NAMES } from "./types.js";
+export class ConfigError extends Error {
+    problems;
+    constructor(problems) {
+        super(`Invalid envsync config:\n${problems.map((p) => `  - ${p}`).join("\n")}`);
+        this.problems = problems;
+        this.name = "ConfigError";
+    }
+}
+const OS_FAMILIES = ["linux", "macos", "windows"];
+const TOOL_KEYS = new Set(["name", "description", "check", "install", "update", "platforms"]);
+const ROOT_KEYS = new Set(["$schema", "shell", "tools"]);
+/** Throws ConfigError with every problem found, not only the first. */
+export function validateConfig(input) {
+    const problems = [];
+    if (!isRecord(input))
+        throw new ConfigError(["root must be an object"]);
+    for (const key of Object.keys(input)) {
+        if (!ROOT_KEYS.has(key))
+            problems.push(`unknown root key "${key}"`);
+    }
+    if (input.shell !== undefined) {
+        if (!isRecord(input.shell))
+            problems.push("shell must be an object like { \"windows\": \"pwsh\" }");
+        else {
+            for (const [os, shell] of Object.entries(input.shell)) {
+                if (!OS_FAMILIES.includes(os))
+                    problems.push(`shell.${os}: unknown OS, expected one of ${OS_FAMILIES.join(", ")}`);
+                if (typeof shell !== "string" || !SHELL_NAMES.includes(shell)) {
+                    problems.push(`shell.${os}: expected one of ${SHELL_NAMES.join(", ")}`);
+                }
+            }
+        }
+    }
+    if (!Array.isArray(input.tools)) {
+        problems.push("tools must be an array");
+        throw new ConfigError(problems);
+    }
+    const names = new Set();
+    input.tools.forEach((tool, index) => {
+        const where = `tools[${index}]`;
+        if (!isRecord(tool)) {
+            problems.push(`${where}: must be an object`);
+            return;
+        }
+        for (const key of Object.keys(tool)) {
+            if (!TOOL_KEYS.has(key))
+                problems.push(`${where}: unknown key "${key}"`);
+        }
+        if (typeof tool.name !== "string" || tool.name.trim() === "") {
+            problems.push(`${where}.name: required, must be a non-empty string`);
+        }
+        else {
+            if (names.has(tool.name))
+                problems.push(`${where}.name: duplicate tool name "${tool.name}"`);
+            names.add(tool.name);
+        }
+        if (tool.description !== undefined && typeof tool.description !== "string") {
+            problems.push(`${where}.description: must be a string`);
+        }
+        for (const field of ["check", "install", "update"]) {
+            if (tool[field] !== undefined)
+                checkCommand(tool[field], `${where}.${field}`, problems);
+        }
+        if (tool.install === undefined && tool.update === undefined) {
+            problems.push(`${where}: needs at least one of install or update`);
+        }
+        if (tool.platforms !== undefined) {
+            if (!Array.isArray(tool.platforms) || !tool.platforms.every((p) => typeof p === "string")) {
+                problems.push(`${where}.platforms: must be an array of selector strings`);
+            }
+        }
+    });
+    if (problems.length)
+        throw new ConfigError(problems);
+    return input;
+}
+function isCommandText(value) {
+    return typeof value === "string" || (Array.isArray(value) && value.every((v) => typeof v === "string"));
+}
+function checkCommand(value, where, problems) {
+    if (value === null || isCommandText(value))
+        return;
+    if (Array.isArray(value)) {
+        problems.push(`${where}: array steps must all be strings`);
+        return;
+    }
+    if (!isRecord(value)) {
+        problems.push(`${where}: expected a string, array of strings, null, { "run": ... } or a platform map`);
+        return;
+    }
+    if ("run" in value) {
+        checkCommandObject(value, where, problems);
+        return;
+    }
+    if (Object.keys(value).length === 0) {
+        problems.push(`${where}: platform map is empty`);
+        return;
+    }
+    for (const [selector, entry] of Object.entries(value)) {
+        const inner = `${where}.${selector}`;
+        if (entry === null || isCommandText(entry))
+            continue;
+        if (isRecord(entry) && "run" in entry) {
+            checkCommandObject(entry, inner, problems);
+            continue;
+        }
+        problems.push(`${inner}: expected a string, array of strings, null or { "run": ... } (platform maps do not nest)`);
+    }
+}
+function checkCommandObject(value, where, problems) {
+    if (!isCommandText(value.run))
+        problems.push(`${where}.run: must be a string or array of strings`);
+    if (value.shell !== undefined && (typeof value.shell !== "string" || !SHELL_NAMES.includes(value.shell))) {
+        problems.push(`${where}.shell: expected one of ${SHELL_NAMES.join(", ")}`);
+    }
+    for (const key of Object.keys(value)) {
+        if (key !== "run" && key !== "shell")
+            problems.push(`${where}: unknown key "${key}"`);
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function toolNames(config) {
+    return config.tools.map((t) => t.name);
+}

package/dist/src/which.js

@@ -0,0 +1,53 @@
+import fs from "node:fs";
+import path from "node:path";
+/** Find an executable on PATH. Honours PATHEXT on Windows. Returns the full path or undefined. */
+export function findOnPath(name, env = process.env, platform = process.platform) {
+    if (name.includes("/") || name.includes("\\")) {
+        return isExecutable(name, platform) ? name : undefined;
+    }
+    const pathValue = env.PATH ?? env.Path ?? env.path ?? "";
+    const dirs = pathValue.split(path.delimiter).filter(Boolean);
+    const exts = platform === "win32"
+        ? (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean)
+        : [""];
+    const hasExt = platform === "win32" && path.extname(name) !== "";
+    for (const dir of dirs) {
+        if (hasExt || platform !== "win32") {
+            const candidate = path.join(dir, name);
+            if (isExecutable(candidate, platform))
+                return candidate;
+        }
+        if (platform === "win32") {
+            for (const ext of exts) {
+                const candidate = path.join(dir, name + ext.toLowerCase());
+                if (isExecutable(candidate, platform))
+                    return candidate;
+            }
+        }
+    }
+    return undefined;
+}
+function isExecutable(file, platform) {
+    try {
+        const stat = fs.statSync(file);
+        if (!stat.isFile())
+            return false;
+        if (platform === "win32")
+            return true;
+        fs.accessSync(file, fs.constants.X_OK);
+        return true;
+    }
+    catch {
+        if (platform !== "win32")
+            return false;
+        // App execution aliases (winget, python from the Store) are reparse points
+        // that stat() refuses with EACCES. lstat() sees them as symlinks.
+        try {
+            const l = fs.lstatSync(file);
+            return l.isSymbolicLink() || l.isFile();
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@hades200082/envsync",
+  "version": "0.0.2",
+  "description": "Install and update your CLI tools and agent skills on every machine from one JSON file.",
+  "keywords": [
+    "cli",
+    "dotfiles",
+    "provisioning",
+    "install",
+    "tooling",
+    "agent-skills",
+    "claude-code",
+    "cross-platform"
+  ],
+  "license": "GPL-3.0-only",
+  "author": "Lee Conlin",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hades200082/env-sync.git"
+  },
+  "homepage": "https://github.com/hades200082/env-sync#readme",
+  "bugs": {
+    "url": "https://github.com/hades200082/env-sync/issues"
+  },
+  "type": "module",
+  "bin": {
+    "envsync": "dist/src/cli.js"
+  },
+  "files": [
+    "dist/src",
+    "schema.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
+    "test": "npm run build && node scripts/run-tests.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "typescript": "^5.5.0"
+  }
+}