akm-cli 0.8.0-rc2 → 0.8.0

package/dist/commands/install-audit.js

@@ -1,385 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { filterNonEmptyStrings, toPosix } from "../core/common";
-const DEFAULT_INSTALL_AUDIT_CONFIG = {
-    enabled: true,
-    blockOnCritical: true,
-    blockUnlistedRegistries: false,
-    registryAllowlist: [],
-    allowedFindings: [],
-};
-const MAX_SCANNED_FILE_BYTES = 256 * 1024;
-const LIFECYCLE_SCRIPT_NAMES = new Set([
-    "preinstall",
-    "install",
-    "postinstall",
-    "prepublish",
-    "prepublishOnly",
-    "prepare",
-]);
-const TEXT_FILE_EXTENSIONS = new Set([
-    ".cjs",
-    ".cts",
-    ".js",
-    ".json",
-    ".jsonc",
-    ".jsx",
-    ".mjs",
-    ".md",
-    ".ps1",
-    ".py",
-    ".rb",
-    ".sh",
-    ".toml",
-    ".ts",
-    ".tsx",
-    ".txt",
-    ".yaml",
-    ".yml",
-]);
-const BLOCKED_PACKAGE_DIRECTORIES = new Set(["node_modules", "venv", ".venv", "site-packages"]);
-const CONTENT_RULES = [
-    {
-        id: "prompt-ignore-previous-instructions",
-        severity: "high",
-        category: "prompt-injection",
-        message: "Contains instructions to ignore prior prompts or instructions.",
-        pattern: /\b(ignore|disregard|forget)\b[^.\n]{0,100}\b(previous|prior|earlier)\b[^.\n]{0,100}\b(instructions?|prompts?|messages?)\b/i,
-    },
-    {
-        id: "prompt-reveal-hidden-secrets",
-        severity: "critical",
-        category: "prompt-injection",
-        message: "Contains instructions to reveal hidden prompts or secrets.",
-        pattern: /\b(?:reveal|print|dump|show|output|return|exfiltrat(?:e|ion))\b[^.\n]{0,60}\b(?:your|the)\b[^.\n]{0,40}\b(system prompt|hidden instructions?|developer message|api key|token|secret|password)\b/i,
-    },
-    {
-        id: "prompt-bypass-guardrails",
-        severity: "high",
-        category: "prompt-injection",
-        message: "Contains instructions to bypass safety or security controls.",
-        pattern: /\b(bypass|disable|ignore)\b[^.\n]{0,100}\b(safety|security|guardrails|restrictions|policies)\b/i,
-    },
-    {
-        id: "remote-shell-pipe",
-        severity: "critical",
-        category: "malicious-code",
-        message: "Downloads remote content and pipes it directly into a shell.",
-        pattern: /\b(curl|wget)\b[^\n|]{0,200}\|\s*(sh|bash|zsh)\b/i,
-    },
-    {
-        id: "powershell-download-exec",
-        severity: "critical",
-        category: "malicious-code",
-        message: "Downloads remote content and executes it in PowerShell.",
-        pattern: /\b(Invoke-WebRequest|iwr|curl)\b[^\n|]{0,200}\|\s*(iex|Invoke-Expression)\b/i,
-    },
-    {
-        id: "powershell-encoded-command",
-        severity: "critical",
-        category: "malicious-code",
-        message: "Uses an encoded PowerShell command.",
-        pattern: /\bpowershell(?:\.exe)?\b[^\n]{0,120}\s-(?:enc|encodedcommand)\b/i,
-    },
-    {
-        id: "credential-exfiltration-language",
-        severity: "high",
-        category: "malicious-code",
-        message: "Contains language associated with credential or secret exfiltration.",
-        pattern: /\b(exfiltrat(?:e|ion)|harvest|steal)\b[^.\n]{0,120}\b(credentials?|tokens?|secrets?|ssh keys?|passwords?|cookies?)\b/i,
-    },
-];
-export function resolveInstallAuditConfig(config) {
-    const installAudit = config?.security?.installAudit;
-    const allowlist = filterNonEmptyStrings(installAudit?.registryAllowlist) ??
-        filterNonEmptyStrings(installAudit?.registryWhitelist) ??
-        [];
-    return {
-        enabled: installAudit?.enabled ?? DEFAULT_INSTALL_AUDIT_CONFIG.enabled,
-        blockOnCritical: installAudit?.blockOnCritical ?? DEFAULT_INSTALL_AUDIT_CONFIG.blockOnCritical,
-        blockUnlistedRegistries: installAudit?.blockUnlistedRegistries ?? DEFAULT_INSTALL_AUDIT_CONFIG.blockUnlistedRegistries,
-        registryAllowlist: allowlist.map((entry) => entry.trim().toLowerCase()),
-        allowedFindings: installAudit?.allowedFindings ?? DEFAULT_INSTALL_AUDIT_CONFIG.allowedFindings,
-    };
-}
-export function enforceRegistryInstallPolicy(registryLabels, config, ref) {
-    const resolved = resolveInstallAuditConfig(config);
-    if (!resolved.blockUnlistedRegistries)
-        return;
-    if (resolved.registryAllowlist.length === 0) {
-        throw new Error(`Install blocked for ${ref}: no registries are allowlisted. Configure security.installAudit.registryAllowlist or disable security.installAudit.blockUnlistedRegistries.`);
-    }
-    const matched = registryLabels.some((label) => resolved.registryAllowlist.includes(label.toLowerCase()));
-    if (matched)
-        return;
-    throw new Error(`Install blocked for ${ref}: registry is not allowlisted. Allowed: ${resolved.registryAllowlist.join(", ")}. Seen: ${registryLabels.join(", ")}.`);
-}
-export function auditInstallCandidate(input) {
-    const resolved = resolveInstallAuditConfig(input.config);
-    if (!resolved.enabled) {
-        return {
-            enabled: false,
-            passed: true,
-            blocked: false,
-            trusted: false,
-            registryLabels: [...input.registryLabels],
-            findings: [],
-            scannedFiles: 0,
-            scannedBytes: 0,
-            summary: buildSummary([]),
-        };
-    }
-    const findings = [];
-    const counters = { scannedFiles: 0, scannedBytes: 0 };
-    scanDirectory(input.rootDir, input.rootDir, findings, counters);
-    const { findings: activeFindings, waivedFindings } = splitAllowedFindings(findings, input.ref, resolved.allowedFindings);
-    const summary = buildSummary(activeFindings);
-    const blocked = !input.trustThisInstall && resolved.blockOnCritical && summary.critical > 0;
-    return {
-        enabled: true,
-        passed: activeFindings.length === 0,
-        blocked,
-        trusted: Boolean(input.trustThisInstall),
-        registryLabels: [...input.registryLabels],
-        findings: activeFindings,
-        scannedFiles: counters.scannedFiles,
-        scannedBytes: counters.scannedBytes,
-        summary,
-        ...(waivedFindings.length > 0 ? { waivedFindings } : {}),
-    };
-}
-export function formatInstallAuditFailure(ref, report) {
-    return formatInstallAuditFailureForAction(ref, report, "add");
-}
-export function formatInstallAuditFailureForAction(ref, report, action) {
-    const lines = [`Security audit failed for ${ref}.`, formatInstallAuditSummary(report)];
-    for (const finding of report.findings.slice(0, 5)) {
-        lines.push(`- [${finding.severity}] ${finding.message}${finding.file ? ` (${finding.file})` : ""}`);
-    }
-    if (report.findings.length > 5) {
-        lines.push(`- ${report.findings.length - 5} more finding(s) omitted`);
-    }
-    const trustCommand = action === "update" ? `akm update ${ref} --trust` : `akm add ${ref} --trust`;
-    lines.push("Disable blocking with `security.installAudit.blockOnCritical = false`, or disable audits with `security.installAudit.enabled = false`." +
-        ` Or pass --trust on a one-off '${trustCommand}' to bypass this audit for this ${action} only.`);
-    return lines.join("\n");
-}
-export function formatInstallAuditSummary(report) {
-    if (!report.enabled)
-        return "Audit: disabled";
-    const severitySummary = [];
-    if (report.summary.critical > 0)
-        severitySummary.push(`${report.summary.critical} critical`);
-    if (report.summary.high > 0)
-        severitySummary.push(`${report.summary.high} high`);
-    if (report.summary.moderate > 0)
-        severitySummary.push(`${report.summary.moderate} moderate`);
-    if (report.summary.low > 0)
-        severitySummary.push(`${report.summary.low} low`);
-    const detail = severitySummary.length > 0 ? severitySummary.join(", ") : "no findings";
-    const status = report.blocked ? "blocked" : report.passed ? "passed" : report.trusted ? "trusted" : "warnings";
-    const waived = report.waivedFindings?.length ? `; waived ${report.waivedFindings.length}` : "";
-    return `Audit: ${status} (${detail}; scanned ${report.scannedFiles} file${report.scannedFiles === 1 ? "" : "s"}${waived})`;
-}
-export function deriveRegistryLabels(input) {
-    const labels = new Set();
-    labels.add(input.source);
-    if (input.source === "github")
-        labels.add("github.com");
-    if (input.source === "npm")
-        labels.add("npm");
-    addUrlLabels(labels, input.artifactUrl);
-    addUrlLabels(labels, input.gitUrl);
-    if (input.source === "github" && input.ref.startsWith("github:")) {
-        labels.add("github");
-    }
-    return [...labels];
-}
-function scanDirectory(dir, rootDir, findings, counters) {
-    let entries;
-    try {
-        entries = fs.readdirSync(dir, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    for (const entry of entries) {
-        if (entry.name === ".git")
-            continue;
-        const fullPath = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            if (BLOCKED_PACKAGE_DIRECTORIES.has(entry.name)) {
-                const relativePath = path.relative(rootDir, fullPath) || entry.name;
-                findings.push({
-                    id: "bundled-package-directory",
-                    severity: "critical",
-                    category: "vendored-dependency",
-                    message: `Contains bundled dependency directory "${entry.name}".`,
-                    file: relativePath,
-                    snippet: relativePath,
-                });
-                continue;
-            }
-            scanDirectory(fullPath, rootDir, findings, counters);
-            continue;
-        }
-        if (!entry.isFile())
-            continue;
-        scanFile(fullPath, rootDir, findings, counters);
-    }
-}
-function scanFile(filePath, rootDir, findings, counters) {
-    const ext = path.extname(filePath).toLowerCase();
-    const basename = path.basename(filePath).toLowerCase();
-    if (basename !== "package.json" && !TEXT_FILE_EXTENSIONS.has(ext))
-        return;
-    let fileSize;
-    try {
-        fileSize = fs.statSync(filePath).size;
-    }
-    catch {
-        return;
-    }
-    const readSize = Math.min(fileSize, MAX_SCANNED_FILE_BYTES);
-    const buf = Buffer.alloc(readSize);
-    let bytesRead;
-    try {
-        const fd = fs.openSync(filePath, "r");
-        try {
-            bytesRead = fs.readSync(fd, buf, 0, readSize, 0);
-        }
-        finally {
-            fs.closeSync(fd);
-        }
-    }
-    catch {
-        return;
-    }
-    if (bytesRead === 0)
-        return;
-    const bytes = buf.subarray(0, bytesRead);
-    if (bytes.includes(0))
-        return;
-    counters.scannedFiles += 1;
-    counters.scannedBytes += bytesRead;
-    const content = bytes.toString("utf8");
-    const relativePath = path.relative(rootDir, filePath) || path.basename(filePath);
-    const genericContent = basename === "package.json" ? stripPackageJsonScripts(content) : content;
-    for (const rule of CONTENT_RULES) {
-        const match = genericContent.match(rule.pattern);
-        if (!match)
-            continue;
-        findings.push({
-            id: rule.id,
-            severity: rule.severity,
-            category: rule.category,
-            message: rule.message,
-            file: relativePath,
-            snippet: clipSnippet(match[0]),
-        });
-    }
-    if (basename === "package.json") {
-        scanPackageJson(content, relativePath, findings);
-    }
-}
-function stripPackageJsonScripts(content) {
-    let parsed;
-    try {
-        parsed = JSON.parse(content);
-    }
-    catch {
-        return content;
-    }
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
-        return content;
-    const packageJson = { ...parsed };
-    delete packageJson.scripts;
-    return JSON.stringify(packageJson, null, 2);
-}
-function scanPackageJson(content, relativePath, findings) {
-    let parsed;
-    try {
-        parsed = JSON.parse(content);
-    }
-    catch {
-        return;
-    }
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
-        return;
-    const scripts = parsed.scripts;
-    if (typeof scripts !== "object" || scripts === null || Array.isArray(scripts))
-        return;
-    for (const [name, command] of Object.entries(scripts)) {
-        if (!LIFECYCLE_SCRIPT_NAMES.has(name) || typeof command !== "string")
-            continue;
-        for (const rule of CONTENT_RULES) {
-            if (!rule.pattern.test(command))
-                continue;
-            findings.push({
-                id: `lifecycle-${name}-${rule.id}`,
-                severity: rule.severity,
-                category: "install-script",
-                message: `Lifecycle script "${name}" is suspicious: ${rule.message.toLowerCase()}`,
-                file: relativePath,
-                snippet: clipSnippet(command),
-            });
-        }
-    }
-}
-function clipSnippet(value) {
-    const normalized = value.replace(/\s+/g, " ").trim();
-    return normalized.length <= 140 ? normalized : `${normalized.slice(0, 137)}...`;
-}
-function buildSummary(findings) {
-    const summary = { low: 0, moderate: 0, high: 0, critical: 0, total: findings.length };
-    for (const finding of findings) {
-        summary[finding.severity] += 1;
-    }
-    return summary;
-}
-function splitAllowedFindings(findings, ref, allowedFindings) {
-    const active = [];
-    const waived = [];
-    for (const finding of findings) {
-        if (matchesAllowedFinding(finding, ref, allowedFindings)) {
-            waived.push(finding);
-            continue;
-        }
-        active.push(finding);
-    }
-    return { findings: active, waivedFindings: waived };
-}
-function matchesAllowedFinding(finding, ref, allowedFindings) {
-    // Normalize paths so a waiver written against `scripts/setup.sh` matches
-    // a finding emitted as `./scripts/setup.sh` or `scripts//setup.sh`. On
-    // Windows we also fold case, mirroring `isWithin`'s comparison rules.
-    const findingPathNormalized = normalizeWaiverPath(finding.file);
-    return allowedFindings.some((allowed) => {
-        if (allowed.id !== finding.id)
-            return false;
-        if (allowed.ref && allowed.ref !== ref)
-            return false;
-        if (allowed.path && normalizeWaiverPath(allowed.path) !== findingPathNormalized)
-            return false;
-        return true;
-    });
-}
-function normalizeWaiverPath(value) {
-    if (!value)
-        return value;
-    // Strip a leading `./` and POSIX-ify after path.normalize so Windows path
-    // separators don't trigger spurious mismatches.
-    const normalized = toPosix(path.normalize(value)).replace(/^\.\/+/, "");
-    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
-}
-function addUrlLabels(labels, rawUrl) {
-    if (!rawUrl)
-        return;
-    try {
-        const parsed = new URL(rawUrl);
-        labels.add(parsed.hostname.toLowerCase());
-    }
-    catch {
-        // Ignore non-URL refs (for example git@host:path)
-    }
-}

package/dist/commands/vault.js

@@ -1,310 +0,0 @@
-/**
- * Vault asset type — secret storage backed by `.env` files.
- *
- * Invariant: vault values must never be written to stdout, returned through
- * the indexer, the `akm show` renderer, or any structured output channel.
- * The supported load paths are:
- *
- *   - `source "$(akm vault path vault:<name>)"` — direct shell loading path.
- *   - `injectIntoEnv(vaultPath, target)` / `loadEnv(vaultPath)` — programmatic
- *     APIs for modules that need values in process memory.
- *
- * Value parsing is delegated to the `dotenv` package — we deliberately do not
- * implement our own quoting/escaping rules for security-sensitive content.
- */
-import fs from "node:fs";
-import path from "node:path";
-import dotenv from "dotenv";
-import { writeFileAtomic } from "../core/common";
-/** Matches a KEY=value assignment line, capturing only the key. */
-const ASSIGN_RE = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/;
-/** Scan lines and return KEY names in file order, without duplicates. */
-function scanKeys(text) {
-    const keys = [];
-    const seen = new Set();
-    for (const line of text.split(/\r?\n/)) {
-        const m = line.match(ASSIGN_RE);
-        if (!m)
-            continue;
-        const key = m[1];
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        keys.push(key);
-    }
-    return keys;
-}
-/**
- * Scan lines and return start-of-line `#` comments (with the leading `#` and
- * any leading whitespace stripped). Inline/trailing `#` after an assignment is
- * never extracted.
- */
-function scanComments(text) {
-    const comments = [];
-    for (const line of text.split(/\r?\n/)) {
-        const trimmed = line.trimStart();
-        if (trimmed.startsWith("#")) {
-            comments.push(trimmed.slice(1).trimStart());
-        }
-    }
-    return comments;
-}
-/**
- * Read and return ONLY non-secret metadata (keys + start-of-line comments).
- *
- * The function reads the whole file into memory (same as any dotenv parser)
- * but deliberately does not parse values — the LHS-only regex scanners above
- * ensure no value content is retained or returned. The guarantee is that
- * values never leave this function.
- */
-export function listKeys(vaultPath) {
-    if (!fs.existsSync(vaultPath))
-        return { keys: [], comments: [] };
-    const text = fs.readFileSync(vaultPath, "utf8");
-    return { keys: scanKeys(text), comments: scanComments(text) };
-}
-/**
- * Return structured `entries` pairing each key with the nearest preceding
- * comment line (if any). This replaces the parallel `keys[]` + `comments[]`
- * shape used internally by `listKeys` with a single merged array, which is
- * easier for callers to consume (QA #35).
- *
- * Values are never included — the same privacy guarantee as `listKeys`.
- */
-export function listEntries(vaultPath) {
-    if (!fs.existsSync(vaultPath))
-        return [];
-    const text = fs.readFileSync(vaultPath, "utf8");
-    const lines = text.split(/\r?\n/);
-    const seen = new Set();
-    const entries = [];
-    let pendingComment;
-    for (const line of lines) {
-        const trimmed = line.trimStart();
-        if (trimmed.startsWith("#")) {
-            // Capture the most recent comment before a key
-            pendingComment = trimmed.slice(1).trimStart() || undefined;
-            continue;
-        }
-        const m = line.match(ASSIGN_RE);
-        if (m) {
-            const key = m[1];
-            if (!seen.has(key)) {
-                seen.add(key);
-                const entry = { key };
-                if (pendingComment)
-                    entry.comment = pendingComment;
-                entries.push(entry);
-            }
-            pendingComment = undefined;
-        }
-        else {
-            // Any non-comment, non-assignment line (including blank lines)
-            // breaks "nearest preceding comment line" association.
-            pendingComment = undefined;
-        }
-    }
-    return entries;
-}
-/**
- * Read all KEY=value pairs from a vault file. Intended for programmatic
- * callers that need to inject values into a process environment. Callers
- * MUST NOT write the returned values to stdout or any logged output.
- *
- * Value parsing (quoting, escapes, multi-line, etc.) is delegated to dotenv.
- */
-export function loadEnv(vaultPath) {
-    if (!fs.existsSync(vaultPath))
-        return {};
-    const buf = fs.readFileSync(vaultPath);
-    return dotenv.parse(buf);
-}
-/**
- * Load a vault and assign its values into `target` (defaults to `process.env`).
- * Returns the list of keys that were set so the caller can log/observe without
- * touching values.
- *
- * Existing keys in `target` are overwritten — callers who want to preserve
- * pre-existing environment variables should filter before calling.
- */
-export function injectIntoEnv(vaultPath, target = process.env) {
-    const env = loadEnv(vaultPath);
-    for (const [key, value] of Object.entries(env)) {
-        target[key] = value;
-    }
-    return Object.keys(env);
-}
-/**
- * Serialise a vault's values as a POSIX shell script of `export KEY='value'`
- * lines, with single-quote escaping (`'\''`). Every line is an assignment of
- * a literal string — there is no expansion, command substitution, or
- * non-assignment content, so sourcing the output is safe regardless of what
- * the vault file contains.
- *
- * Retained for programmatic callers/tests that need a literal export script.
- */
-export function buildShellExportScript(vaultPath) {
-    const env = loadEnv(vaultPath);
-    const lines = [];
-    for (const [key, value] of Object.entries(env)) {
-        // Defence in depth: dotenv already validates key shape, but reject any
-        // key we wouldn't be able to export safely.
-        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
-            continue;
-        const escaped = value.replace(/'/g, "'\\''");
-        lines.push(`export ${key}='${escaped}'`);
-    }
-    return lines.length > 0 ? `${lines.join("\n")}\n` : "";
-}
-/**
- * Set a key in the vault file, preserving line order and comments. Creates
- * the file (and parent directory) if it does not exist.
- *
- * `quoteValue` picks the safest representation that dotenv round-trips:
- * single-quoted when the value has no `'`, double-quoted when it has `'` but
- * no `"` and no literal `\n`/`\r` escape sequences, and unquoted only for
- * values that contain no characters requiring escaping (see quoteValue for
- * the full rule set). Values containing newlines or both quote types are
- * rejected outright. Round-trip safety is enforced by the test suite.
- *
- * When `comment` is provided it is written as a `# <comment>` line
- * immediately before the `KEY=value` line:
- *  - New key: the comment line is inserted just before the appended key.
- *  - Existing key: if the preceding line is already a comment it is replaced
- *    with the new comment; otherwise a new comment line is inserted.
- * When `comment` is absent the surrounding comment lines are left unchanged.
- */
-export function setKey(vaultPath, key, value, comment) {
-    validateKeyName(key);
-    if (comment !== undefined && /[\r\n]/.test(comment)) {
-        throw new Error("Vault key comment cannot contain newline characters.");
-    }
-    ensureParentDir(vaultPath);
-    const existing = fs.existsSync(vaultPath) ? fs.readFileSync(vaultPath, "utf8") : "";
-    const lines = existing.length > 0 ? existing.split(/\r?\n/) : [];
-    const formatted = `${key}=${quoteValue(value)}`;
-    let replaced = false;
-    for (let i = 0; i < lines.length; i++) {
-        const m = lines[i].match(ASSIGN_RE);
-        if (m && m[1] === key) {
-            lines[i] = formatted;
-            replaced = true;
-            if (comment !== undefined) {
-                const commentLine = `# ${comment}`;
-                const prevIsComment = i > 0 && lines[i - 1].trimStart().startsWith("#");
-                if (prevIsComment) {
-                    lines[i - 1] = commentLine;
-                }
-                else {
-                    lines.splice(i, 0, commentLine);
-                }
-            }
-            break;
-        }
-    }
-    if (!replaced) {
-        if (comment !== undefined) {
-            const commentLine = `# ${comment}`;
-            if (lines.length > 0 && lines[lines.length - 1] === "") {
-                lines[lines.length - 1] = commentLine;
-                lines.push(formatted);
-                lines.push("");
-            }
-            else {
-                lines.push(commentLine);
-                lines.push(formatted);
-            }
-        }
-        else if (lines.length > 0 && lines[lines.length - 1] === "") {
-            lines[lines.length - 1] = formatted;
-            lines.push("");
-        }
-        else {
-            lines.push(formatted);
-        }
-    }
-    let out = lines.join("\n");
-    if (!out.endsWith("\n"))
-        out += "\n";
-    writeFileAtomic(vaultPath, out, 0o600);
-}
-/** Remove a key from the vault file. Returns true if the key was present. */
-export function unsetKey(vaultPath, key) {
-    if (!fs.existsSync(vaultPath))
-        return false;
-    const text = fs.readFileSync(vaultPath, "utf8");
-    const lines = text.split(/\r?\n/);
-    const kept = [];
-    let removed = false;
-    for (const line of lines) {
-        const m = line.match(ASSIGN_RE);
-        if (m && m[1] === key) {
-            removed = true;
-            continue;
-        }
-        kept.push(line);
-    }
-    if (!removed)
-        return false;
-    let out = kept.join("\n");
-    if (out.length > 0 && !out.endsWith("\n"))
-        out += "\n";
-    writeFileAtomic(vaultPath, out, 0o600);
-    return true;
-}
-/** Create an empty vault file (does nothing if it already exists). */
-export function createVault(vaultPath) {
-    ensureParentDir(vaultPath);
-    if (fs.existsSync(vaultPath))
-        return;
-    writeFileAtomic(vaultPath, "", 0o600);
-}
-/**
- * Characters that are safe in an UNquoted dotenv value AND are not
- * metacharacters in POSIX shells. Anything outside this set forces quoting,
- * which is defense-in-depth for any caller that might ever `source` the
- * vault file directly instead of going through `akm vault path`.
- */
-const UNQUOTED_SAFE_RE = /^[A-Za-z0-9_.:/@%+,-]+$/;
-/**
- * Quote a value for safe storage in a .env file that round-trips through
- * `dotenv.parse` AND is safe if the file is ever `source`d by a POSIX shell.
- *
- * Strategy:
- *   - empty → empty
- *   - all-safe chars (alnum + `_.:/@%+,-`) → unquoted
- *   - no `'` → single-quote (dotenv and shell both treat single-quoted
- *                            content literally: no expansion, no escapes)
- *   - no `"` and no literal `\n`/`\r` escape sequence → double-quote
- *                            (dotenv unescapes `\n`/`\r` on read, so we
- *                            can't double-quote a value that contains
- *                            those literal sequences)
- *   - newlines or both quote types → reject
- *
- * dotenv intentionally does NOT support `\"` inside double-quoted values, so
- * we never produce that pattern.
- */
-function quoteValue(value) {
-    if (value.length === 0)
-        return "";
-    if (/[\n\r]/.test(value)) {
-        throw new Error("Vault values cannot contain literal newlines.");
-    }
-    if (UNQUOTED_SAFE_RE.test(value))
-        return value;
-    if (!value.includes("'"))
-        return `'${value}'`;
-    if (!value.includes('"') && !/\\[nr]/.test(value))
-        return `"${value}"`;
-    throw new Error("Vault value contains both single and double quote characters; not supported.");
-}
-function validateKeyName(key) {
-    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
-        throw new Error(`Invalid vault key name: "${key}". Must match [A-Za-z_][A-Za-z0-9_]*`);
-    }
-}
-function ensureParentDir(filePath) {
-    const dir = path.dirname(filePath);
-    if (!fs.existsSync(dir))
-        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-}