akm-cli 0.9.15 → 0.9.16-alpha.2

package/dist/commands/sources/add-cli.js

@@ -8,9 +8,9 @@ import { UsageError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
 import { warn } from "../../core/warn.js";
 import { auditStashForDangerousKeys } from "./dangerous-env-audit.js";
-import { akmRemove } from "./installed-stashes.js";
+import { akmRemove, akmUpdate } from "./installed-stashes.js";
 import { akmAdd } from "./source-add.js";
-import { addStash } from "./source-manage.js";
+import { addStash, removeStash } from "./source-manage.js";
 // ── Shared website-options helper ──────────
 export function buildWebsiteOptions(args) {
     // getStringArg maps absent/blank to undefined; parsePositiveIntFlag maps
@@ -86,28 +86,41 @@ export const addCommand = defineJsonCommand({
             description: "Mark a git bundle as writable so changes can be pushed back",
             default: false,
         },
+        before: { type: "string", description: "Insert the new bundle before this configured bundle" },
+        after: { type: "string", description: "Insert the new bundle after this configured bundle" },
+        credential: {
+            type: "string",
+            description: "Git HTTPS bearer credential reference ($VAR or secret://name); never a literal token",
+        },
         "max-pages": { type: "string", description: "Maximum pages to crawl for website sources (default: 50)" },
         "max-depth": { type: "string", description: "Maximum crawl depth for website sources (default: 3)" },
-        "allow-insecure": {
+        "allow-insecure-transport": {
+            type: "boolean",
+            description: "Allow a plain HTTP source URL after explicitly accepting transport substitution risk.",
+            default: false,
+        },
+        "allow-dangerous-env-keys": {
             type: "boolean",
-            description: "Allow a plain HTTP source URL and skip confirmation for dangerous env keys (e.g. LD_PRELOAD, PATH). Use only after explicitly reviewing the bundle.",
+            description: "Allow reviewed process-hijacking env keys (e.g. LD_PRELOAD, PATH) in the installed bundle.",
             default: false,
         },
     },
     async run({ args }) {
         const ref = args.ref.trim();
-        const allowInsecure = args["allow-insecure"];
-        const allowDangerousKeys = allowInsecure;
+        const allowInsecureTransport = args["allow-insecure-transport"];
+        const allowDangerousKeys = args["allow-dangerous-env-keys"];
+        if (args.before && args.after)
+            throw new UsageError("Only one of --before or --after may be used.");
         // --provider → declarative bundle source (URL for git/website; bare
-        // package spec for npm — R-013). Config-only write; content is not
-        // synced until a later `akm update`.
+        // package spec for npm — R-013). Git is materialized below before success;
+        // other providers remain declarative until bundle update.
         if (args.provider) {
             if (shouldWarnOnPlainHttp(ref)) {
-                if (!allowInsecure) {
+                if (!allowInsecureTransport) {
                     throw new UsageError("Source URL uses plain HTTP (not HTTPS). An on-path attacker could substitute a malicious payload. " +
-                        "Use https:// or pass --allow-insecure if you have explicitly accepted the risk.", "INVALID_FLAG_VALUE", "Re-run with `--allow-insecure` only after confirming the URL is trusted.");
+                        "Use https:// or pass --allow-insecure-transport if you have explicitly accepted the risk.", "INVALID_FLAG_VALUE", "Re-run with `--allow-insecure-transport` only after confirming the URL is trusted.");
                 }
-                warn("Warning: source URL uses plain HTTP (not HTTPS). --allow-insecure was set; an on-path attacker could substitute a malicious payload.");
+                warn("Warning: source URL uses plain HTTP (not HTTPS). --allow-insecure-transport was set; an on-path attacker could substitute a malicious payload.");
             }
             let parsedOptions;
             if (args.options) {
@@ -130,7 +143,34 @@ export const addCommand = defineJsonCommand({
                 providerType: args.provider,
                 options: parsedOptions,
                 writable: args.writable,
+                before: args.before,
+                after: args.after,
+                credential: args.credential,
             });
+            // Declarative git sources must be materialized and indexed before add
+            // reports success. This also makes --provider git behave consistently
+            // with inferred/registry git installs (#968/#970).
+            if (args.provider === "git" && result.added && result.entry?.name) {
+                let updated;
+                try {
+                    updated = await akmUpdate({ target: result.entry.name, allowDangerousEnvKeys: allowDangerousKeys });
+                }
+                catch (error) {
+                    removeStash(result.entry.name);
+                    throw error;
+                }
+                appendEvent({
+                    eventType: "add",
+                    metadata: {
+                        target: ref,
+                        provider: args.provider,
+                        name: args.name ?? null,
+                        writable: args.writable === true,
+                    },
+                });
+                output("add", { ...result, index: updated.index });
+                return;
+            }
             appendEvent({
                 eventType: "add",
                 metadata: { target: ref, provider: args.provider, name: args.name ?? null, writable: args.writable === true },
@@ -139,11 +179,11 @@ export const addCommand = defineJsonCommand({
             return;
         }
         if (shouldWarnOnPlainHttp(ref)) {
-            if (!allowInsecure) {
+            if (!allowInsecureTransport) {
                 throw new UsageError("Source URL uses plain HTTP (not HTTPS). An on-path attacker could substitute a malicious payload. " +
-                    "Use https:// or pass --allow-insecure if you have explicitly accepted the risk.", "INVALID_FLAG_VALUE", "Re-run with `--allow-insecure` only after confirming the URL is trusted.");
+                    "Use https:// or pass --allow-insecure-transport if you have explicitly accepted the risk.", "INVALID_FLAG_VALUE", "Re-run with `--allow-insecure-transport` only after confirming the URL is trusted.");
             }
-            warn("Warning: source URL uses plain HTTP (not HTTPS). --allow-insecure was set; an on-path attacker could substitute a malicious payload.");
+            warn("Warning: source URL uses plain HTTP (not HTTPS). --allow-insecure-transport was set; an on-path attacker could substitute a malicious payload.");
         }
         const websiteOptions = buildWebsiteOptions(args);
         const result = await akmAdd({
@@ -152,6 +192,9 @@ export const addCommand = defineJsonCommand({
             options: Object.keys(websiteOptions).length > 0 ? websiteOptions : undefined,
             writable: args.writable,
             adapter: args.adapter,
+            before: args.before,
+            after: args.after,
+            credential: args.credential,
         });
         appendEvent({
             eventType: "add",
@@ -165,8 +208,8 @@ export const addCommand = defineJsonCommand({
         // Resolve the stash root from the install result and scan any env files
         // for dangerous env var keys.  When findings are present the install is
         // gated: TTY → interactive confirmation prompt; non-TTY without
-        // --allow-insecure → hard failure (exit 1).  Pass
-        // --allow-insecure to skip the prompt non-interactively.
+        // --allow-dangerous-env-keys → hard failure (exit 1). Pass the dedicated
+        // flag to skip the prompt non-interactively.
         const installedStashRoot = result.installed?.stashRoot ??
             (result.sourceAdded && "stashRoot" in result.sourceAdded ? result.sourceAdded.stashRoot : undefined);
         if (installedStashRoot) {

package/dist/commands/sources/bundle-cli.js

@@ -24,8 +24,9 @@
  * `proposal-new` shape). `show` is a new shape, `bundle-show`.
  */
 import { defineGroupCommand, defineJsonCommand, output } from "../../cli/shared.js";
-import { NotFoundError, UsageError } from "../../core/errors.js";
+import { NotFoundError, TransientError, UsageError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
+import { warn } from "../../core/warn.js";
 import { addCommand } from "./add-cli.js";
 import { akmInit } from "./init.js";
 import { akmListSources, akmRemove, akmUpdate } from "./installed-stashes.js";
@@ -118,12 +119,20 @@ const removeCommand = defineJsonCommand({
     },
 });
 const updateCommand = defineJsonCommand({
-    meta: { name: "update", description: "Refresh one or all configured bundles and reconcile their index" },
+    meta: {
+        name: "update",
+        description: "Refresh one or all configured bundles and reconcile their index. Git refresh is explicit; schedule this command for automatic updates.",
+    },
     args: {
         target: { type: "positional", description: "Bundle to update (id or ref)", required: false },
         all: { type: "boolean", description: "Update all configured bundles and report each outcome", default: false },
         force: { type: "boolean", description: "Force fresh download even if version is unchanged", default: false },
-        "allow-insecure": {
+        "skip-if-locked": {
+            type: "boolean",
+            description: "Exit successfully when index/state database contention shows another akm operation is active",
+            default: false,
+        },
+        "allow-dangerous-env-keys": {
             type: "boolean",
             description: "Allow an update containing dangerous env keys (e.g. LD_PRELOAD, PATH). Use only after explicitly reviewing the staged bundle.",
             default: false,
@@ -140,20 +149,31 @@ const updateCommand = defineJsonCommand({
         },
     },
     async run({ args }) {
-        const result = await akmUpdate({
-            target: args.target,
-            all: args.all,
-            force: args.force,
-            yes: args.yes,
-            allowInsecure: args["allow-insecure"],
-        });
+        let result;
+        try {
+            result = await akmUpdate({
+                target: args.target,
+                all: args.all,
+                force: args.force,
+                yes: args.yes,
+                allowDangerousEnvKeys: args["allow-dangerous-env-keys"],
+            });
+        }
+        catch (error) {
+            const skippable = isSkippableBundleUpdateLock(error);
+            if (!args["skip-if-locked"] || !skippable)
+                throw error;
+            warn(`[bundle update] ${error.message}; skipping (--skip-if-locked)`);
+            output("update", { ok: true, skipped: { reason: "lock-held", code: error.code } });
+            return;
+        }
         appendEvent({
             eventType: "update",
             metadata: {
                 target: args.target ?? null,
                 all: args.all === true,
                 force: args.force === true,
-                allowInsecure: args["allow-insecure"] === true,
+                allowDangerousEnvKeys: args["allow-dangerous-env-keys"] === true,
                 processed: Array.isArray(result.processed)
                     ? result.processed.length
                     : 0,
@@ -162,6 +182,10 @@ const updateCommand = defineJsonCommand({
         output("update", result);
     },
 });
+export function isSkippableBundleUpdateLock(error) {
+    return (error instanceof TransientError &&
+        ["INDEX_DB_CONTENDED", "STATE_DB_CONTENDED", "MAINTENANCE_BARRIER_BUSY"].includes(error.code));
+}
 export const bundleCommand = defineGroupCommand({
     meta: {
         name: "bundle",

package/dist/commands/sources/bundle-config-ops.js

@@ -14,8 +14,38 @@
  */
 import path from "node:path";
 import { bundleKeyForContentRoot, primaryBundlePath } from "../../core/config/config.js";
+import { UsageError } from "../../core/errors.js";
 import { deriveBundleId } from "../../indexer/installations.js";
 export { primaryBundlePath };
+/**
+ * Insert or move a bundle at an explicit config-map position. Object insertion
+ * order is bundle resolution priority after `defaultBundle`, which always
+ * remains first. Without a position an existing key keeps its place and a new
+ * key is appended.
+ */
+export function placeBundle(bundles, key, entry, position = {}) {
+    if (position.before && position.after) {
+        throw new UsageError("Only one of --before or --after may be used.");
+    }
+    const target = position.before ?? position.after;
+    if (!target)
+        return { ...bundles, [key]: entry };
+    if (target === key)
+        throw new UsageError(`Bundle "${key}" cannot be positioned relative to itself.`);
+    if (!(target in bundles))
+        throw new UsageError(`Bundle position target "${target}" is not configured.`);
+    const ordered = {};
+    for (const [existingKey, existingEntry] of Object.entries(bundles)) {
+        if (existingKey === key)
+            continue;
+        if (position.before === existingKey)
+            ordered[key] = entry;
+        ordered[existingKey] = existingEntry;
+        if (position.after === existingKey)
+            ordered[key] = entry;
+    }
+    return ordered;
+}
 /**
  * Upsert the primary filesystem bundle (`{ path, writable: true }`) and point
  * `defaultBundle` at it. Reuses the current default key when it already names a

package/dist/commands/sources/dangerous-env-audit.js

@@ -85,13 +85,13 @@ export async function auditStashForDangerousKeys(opts) {
     }
     const stance = decideDangerousKeyInstall({
         findingsPresent: allFindings.length > 0,
-        allowInsecure: opts.allowDangerousKeys,
+        allowDangerousEnvKeys: opts.allowDangerousKeys,
     });
     if (stance === "allow")
         return { blocked: false, findings: allFindings };
     if (stance === "warn-allow") {
         for (const finding of allFindings) {
-            warn(`[dangerous-env-key] ${finding.relPath}: key \`${finding.keyName}\` in ${finding.envRef} can hijack process execution via \`akm env run\`. Proceeding because --allow-insecure was set.`);
+            warn(`[dangerous-env-key] ${finding.relPath}: key \`${finding.keyName}\` in ${finding.envRef} can hijack process execution via \`akm env run\`. Proceeding because --allow-dangerous-env-keys was set.`);
         }
         return { blocked: false, findings: allFindings };
     }
@@ -113,11 +113,11 @@ export async function auditStashForDangerousKeys(opts) {
         const confirmed = await p.confirm({ message: `${operationTitle} anyway?`, initialValue: false });
         if (!p.isCancel(confirmed) && confirmed === true)
             return { blocked: false, findings: allFindings };
-        error = `${operationTitle} aborted: stash contains dangerous env keys. Remove the keys or re-run with --allow-insecure to bypass.`;
+        error = `${operationTitle} aborted: stash contains dangerous env keys. Remove the keys or re-run with --allow-dangerous-env-keys to bypass.`;
     }
     else {
         const keyList = allFindings.map((finding) => `  - ${finding.keyName} (${finding.envRef})`).join("\n");
-        error = `${operationTitle} blocked: stash "${opts.ref}" contains dangerous env keys that can hijack process execution via \`akm env run\`:\n${keyList}\nRe-run with --allow-insecure to bypass this check after reviewing the env file.`;
+        error = `${operationTitle} blocked: stash "${opts.ref}" contains dangerous env keys that can hijack process execution via \`akm env run\`:\n${keyList}\nRe-run with --allow-dangerous-env-keys to bypass this check after reviewing the env file.`;
     }
     const rollbackWarning = await opts.rollback?.();
     if (opts.renderBlockedError !== false) {

package/dist/commands/sources/installed-stashes.js

@@ -18,7 +18,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { detectAdapterId } from "../../core/adapter/detect-adapter.js";
 import { isWithin, resolveStashDir } from "../../core/common.js";
-import { acquireConfigReadFence, bundleComponentConfig, getSources, loadConfig } from "../../core/config/config.js";
+import { acquireConfigReadFence, bundleComponentConfig, getSources, loadConfig, resolveSecret, } from "../../core/config/config.js";
 import { AkmError, ConfigError, NotFoundError, UsageError } from "../../core/errors.js";
 import { isPathAbsent } from "../../core/path-access.js";
 import { getDbPath, getRegistryCacheDir } from "../../core/paths.js";
@@ -106,6 +106,7 @@ function listManagedInstalls(config) {
             componentRoot,
             requiredRoots: lock.localRoot ? [path.resolve(lock.localRoot, componentRoot)] : [],
             auditConfigGeneration: bundleAuditGeneration(bundle),
+            ...(bundle.credential !== undefined ? { credential: bundle.credential } : {}),
         });
     }
     return out;
@@ -641,12 +642,12 @@ async function verifyPublishedAudit(prepared, id) {
         throw new ConfigError(`Writable source "${id}" changed while its audited Git target was materialized; refusing to activate unaudited bytes.`, "DANGEROUS_ENV_AUDIT_FAILED");
     }
 }
-async function auditPreparedUpdate(prepared, id, ref, allowInsecure) {
+async function auditPreparedUpdate(prepared, id, ref, allowDangerousEnvKeys) {
     updateTransactionHook("staged", id);
     const decision = await auditStashForDangerousKeys({
         stashRoot: prepared.auditRoot,
         ref,
-        allowDangerousKeys: allowInsecure,
+        allowDangerousKeys: allowDangerousEnvKeys,
         isTTY: process.stdin.isTTY === true,
         operation: "update",
         renderBlockedError: false,
@@ -713,6 +714,7 @@ function prepareWritableManagedUpdate(managed, force) {
         writable: true,
         writableRoot: stagedContentRoot,
         ...(stagedPhysicalRequiredRoots.length > 0 ? { writableRequiredRoots: stagedPhysicalRequiredRoots } : {}),
+        ...(managed.credential ? { credential: resolveSecret(managed.credential, storeSecretResolver.resolveSecret) } : {}),
     })
         .then((staged) => {
         const auditedTargetHead = gitHead(stagedRepo);
@@ -759,6 +761,9 @@ async function prepareManagedUpdate(managed, force) {
             force,
             writable: false,
             cacheRootDir: stagingParent,
+            ...(managed.credential
+                ? { credential: resolveSecret(managed.credential, storeSecretResolver.resolveSecret) }
+                : {}),
         });
         if (!pathAtOrBelow(staged.cacheDir, stagingParent)) {
             // Test/provider seams may return an already-isolated candidate. It remains
@@ -795,9 +800,9 @@ function resolveComponentAuditRoot(contentRoot, componentRoot, id) {
     }
     return resolved;
 }
-async function publishPreparedPlainUpdate(id, ref, prepared, stashDir, allowInsecure, full, expectedConfigGeneration) {
+async function publishPreparedPlainUpdate(id, ref, prepared, stashDir, allowDangerousEnvKeys, full, expectedConfigGeneration) {
     try {
-        await auditPreparedUpdate(prepared, id, ref, allowInsecure);
+        await auditPreparedUpdate(prepared, id, ref, allowDangerousEnvKeys);
         return await withAssetMutationLease("source-update", async () => {
             let transaction;
             let releaseConfigFence;
@@ -871,14 +876,18 @@ async function prepareGitPlainUpdate(gitSource, componentRoot, writable) {
     const stagingParent = createStagingParent(path.dirname(livePaths.rootDir));
     const stagedPaths = getCachePaths(repo.canonicalUrl, stagingParent);
     try {
-        const expectedOldHead = writable ? gitHead(livePaths.repoDir) : undefined;
-        if (writable && fs.existsSync(livePaths.rootDir)) {
+        const hasLiveCheckout = writable && fs.existsSync(livePaths.repoDir);
+        const expectedOldHead = hasLiveCheckout ? gitHead(livePaths.repoDir) : undefined;
+        if (hasLiveCheckout) {
             fs.cpSync(livePaths.rootDir, stagedPaths.rootDir, { recursive: true, preserveTimestamps: true });
         }
         const staged = await syncMirroredRepo(gitSource, {
             force: true,
             writable,
             cacheRootDir: stagingParent,
+            ...(gitSource.credential
+                ? { credential: resolveSecret(gitSource.credential, storeSecretResolver.resolveSecret) }
+                : {}),
         });
         const configuredStagedAuditRoot = resolveComponentAuditRoot(resolveGitContentRoot(staged.contentDir), componentRoot, gitSource.name ?? "git");
         if (!pathAtOrBelow(staged.cacheDir, stagingParent)) {
@@ -901,7 +910,13 @@ async function prepareGitPlainUpdate(gitSource, componentRoot, writable) {
             const physicalStagedRepo = canonicalWritablePath(stagedPaths.repoDir, "staged plain Git checkout");
             auditRoot = containedWritablePath(configuredStagedAuditRoot, physicalStagedRepo, `Post-sync component root for "${gitSource.name ?? "git"}"`);
             publishedAuditRoot = remapStagedPath(configuredStagedAuditRoot, staged.cacheDir, livePaths.rootDir);
-            publishedAuditContainmentRoot = canonicalWritablePath(livePaths.repoDir, "plain Git checkout");
+            if (hasLiveCheckout) {
+                publishedAuditContainmentRoot = canonicalWritablePath(livePaths.repoDir, "plain Git checkout");
+            }
+            else {
+                const physicalCacheParent = canonicalWritablePath(path.dirname(livePaths.rootDir), "plain Git cache parent");
+                publishedAuditContainmentRoot = path.join(physicalCacheParent, path.basename(livePaths.rootDir), path.relative(livePaths.rootDir, livePaths.repoDir));
+            }
             publishedAuditExpectedPhysicalRoot = path.join(publishedAuditContainmentRoot, path.relative(physicalStagedRepo, auditRoot));
         }
         return {
@@ -909,7 +924,7 @@ async function prepareGitPlainUpdate(gitSource, componentRoot, writable) {
             ...(publishedAuditRoot ? { publishedAuditRoot } : {}),
             ...(publishedAuditContainmentRoot ? { publishedAuditContainmentRoot } : {}),
             ...(publishedAuditExpectedPhysicalRoot ? { publishedAuditExpectedPhysicalRoot } : {}),
-            publication: writable
+            publication: writable && hasLiveCheckout
                 ? writableGitPublication({
                     stagedRepo: stagedPaths.repoDir,
                     liveRepo: livePaths.repoDir,
@@ -924,14 +939,14 @@ async function prepareGitPlainUpdate(gitSource, componentRoot, writable) {
         throw error;
     }
 }
-async function syncGitPlainSource(gitSource, stashDir, allowInsecure) {
+async function syncGitPlainSource(gitSource, stashDir, allowDangerousEnvKeys) {
     const id = gitSource.name ?? gitSource.url ?? "";
     const currentConfig = loadConfig();
     const currentSource = currentPlainSource(currentConfig, id, "git");
     const ref = currentSource.url ?? "";
     const fence = bundleAuditFence(currentConfig, id);
     const prepared = await prepareGitPlainUpdate(currentSource, fence.componentRoot, fence.writable);
-    const index = await publishPreparedPlainUpdate(id, ref, prepared, stashDir, allowInsecure, true, fence.generation);
+    const index = await publishPreparedPlainUpdate(id, ref, prepared, stashDir, allowDangerousEnvKeys, true, fence.generation);
     return { item: { id, kind: "git", ref }, index };
 }
 async function prepareWebsitePlainUpdate(websiteSource, componentRoot) {
@@ -962,24 +977,24 @@ async function prepareWebsitePlainUpdate(websiteSource, componentRoot) {
         throw error;
     }
 }
-async function syncWebsitePlainSource(websiteSource, stashDir, allowInsecure) {
+async function syncWebsitePlainSource(websiteSource, stashDir, allowDangerousEnvKeys) {
     const id = websiteSource.name ?? websiteSource.url ?? "";
     const currentConfig = loadConfig();
     const currentSource = currentPlainSource(currentConfig, id, "website");
     const ref = currentSource.url ?? "";
     const fence = bundleAuditFence(currentConfig, id);
     const prepared = await prepareWebsitePlainUpdate(currentSource, fence.componentRoot);
-    const index = await publishPreparedPlainUpdate(id, ref, prepared, stashDir, allowInsecure, true, fence.generation);
+    const index = await publishPreparedPlainUpdate(id, ref, prepared, stashDir, allowDangerousEnvKeys, true, fence.generation);
     return { item: { id, kind: "website", ref }, index };
 }
 /** Sync a git-mirrored (plain) source and return an UpdateResponse (single-target path). */
-async function updateGitSource(stashDir, target, all, gitSource, allowInsecure) {
-    const synced = await syncGitPlainSource(gitSource, stashDir, allowInsecure);
+async function updateGitSource(stashDir, target, all, gitSource, allowDangerousEnvKeys) {
+    const synced = await syncGitPlainSource(gitSource, stashDir, allowDangerousEnvKeys);
     return buildUpdateResponse(stashDir, target, all, [], { plainSynced: [synced.item], index: synced.index });
 }
 /** Re-crawl a website (plain) source and return an UpdateResponse (single-target path). */
-async function updateWebsiteSource(stashDir, target, all, websiteSource, allowInsecure) {
-    const synced = await syncWebsitePlainSource(websiteSource, stashDir, allowInsecure);
+async function updateWebsiteSource(stashDir, target, all, websiteSource, allowDangerousEnvKeys) {
+    const synced = await syncWebsitePlainSource(websiteSource, stashDir, allowDangerousEnvKeys);
     return buildUpdateResponse(stashDir, target, all, [], { plainSynced: [synced.item], index: synced.index });
 }
 /** Reconcile a filesystem source's current bytes without provider hydration. */
@@ -1042,7 +1057,7 @@ function managedInstallViewOfPlainNpm(npmSource) {
  * scripts; only the branch that can `rm -rf` needs a gate, not the whole
  * command).
  */
-async function updateManagedInstall(managed, force, yes, stashDir, allowInsecure) {
+async function updateManagedInstall(managed, force, yes, stashDir, allowDangerousEnvKeys) {
     // No pre-cleanup of the old root, even under --force: the providers already
     // re-materialize staging-first (git clones into a `.tmp-*` sibling and swaps
     // only on success), so destroying `managed.localRoot` BEFORE `syncFromRef`
@@ -1051,7 +1066,7 @@ async function updateManagedInstall(managed, force, yes, stashDir, allowInsecure
     // config/lock publication and reindexing both succeed.
     const prepared = await prepareManagedUpdate(managed, force);
     try {
-        await auditPreparedUpdate(prepared, managed.installId, managed.ref, allowInsecure);
+        await auditPreparedUpdate(prepared, managed.installId, managed.ref, allowDangerousEnvKeys);
         const synced = prepared.synced;
         const installedEntry = {
             id: managed.installId,
@@ -1259,14 +1274,14 @@ export async function akmUpdate(input) {
     const all = input?.all === true;
     const force = input?.force === true;
     const yes = input?.yes === true;
-    const allowInsecure = input?.allowInsecure === true;
+    const allowDangerousEnvKeys = input?.allowDangerousEnvKeys === true;
     const config = loadConfig();
     const managedInstalls = listManagedInstalls(config);
     if (target && !all) {
         // Registry-managed install (lock-backed) — re-download from its locator.
         const managed = resolveManagedTarget(config, target);
         if (managed) {
-            const updated = await updateManagedInstall(managed, force, yes, stashDir, allowInsecure);
+            const updated = await updateManagedInstall(managed, force, yes, stashDir, allowDangerousEnvKeys);
             return buildUpdateResponse(stashDir, target, all, [updated.item], { index: updated.index });
         }
         // Plain git / website source (bundles without a lock) — provider re-sync.
@@ -1295,7 +1310,7 @@ export async function akmUpdate(input) {
             return false;
         });
         if (gitMatch)
-            return updateGitSource(stashDir, target, all, gitMatch, allowInsecure);
+            return updateGitSource(stashDir, target, all, gitMatch, allowDangerousEnvKeys);
         const websiteMatch = stashes.find((s) => {
             if (s.type !== "website")
                 return false;
@@ -1308,7 +1323,7 @@ export async function akmUpdate(input) {
             return false;
         });
         if (websiteMatch)
-            return updateWebsiteSource(stashDir, target, all, websiteMatch, allowInsecure);
+            return updateWebsiteSource(stashDir, target, all, websiteMatch, allowDangerousEnvKeys);
         // Plain npm source (bundle without a lock) — sync via the registry
         // pipeline and promote to a managed install (see
         // managedInstallViewOfPlainNpm's doc comment for why npm can't stay
@@ -1323,7 +1338,7 @@ export async function akmUpdate(input) {
             return false;
         });
         if (npmMatch) {
-            const updated = await updateManagedInstall(managedInstallViewOfPlainNpm(npmMatch), force, yes, stashDir, allowInsecure);
+            const updated = await updateManagedInstall(managedInstallViewOfPlainNpm(npmMatch), force, yes, stashDir, allowDangerousEnvKeys);
             return buildUpdateResponse(stashDir, target, all, [updated.item], { index: updated.index });
         }
         const filesystemMatch = stashes.find((source) => {
@@ -1346,7 +1361,7 @@ export async function akmUpdate(input) {
     let latestIndex;
     for (const managed of selected) {
         try {
-            const updated = await updateManagedInstall(managed, force, yes, stashDir, allowInsecure);
+            const updated = await updateManagedInstall(managed, force, yes, stashDir, allowDangerousEnvKeys);
             processed.push(updated.item);
             latestIndex = updated.index;
         }
@@ -1371,17 +1386,17 @@ export async function akmUpdate(input) {
             const id = plain.name ?? plain.path ?? plain.url ?? "";
             try {
                 if (plain.type === "git") {
-                    const updated = await syncGitPlainSource(plain, stashDir, allowInsecure);
+                    const updated = await syncGitPlainSource(plain, stashDir, allowDangerousEnvKeys);
                     plainSynced.push(updated.item);
                     latestIndex = updated.index;
                 }
                 else if (plain.type === "npm") {
-                    const updated = await updateManagedInstall(managedInstallViewOfPlainNpm(plain), force, yes, stashDir, allowInsecure);
+                    const updated = await updateManagedInstall(managedInstallViewOfPlainNpm(plain), force, yes, stashDir, allowDangerousEnvKeys);
                     processed.push(updated.item);
                     latestIndex = updated.index;
                 }
                 else if (plain.type === "website") {
-                    const updated = await syncWebsitePlainSource(plain, stashDir, allowInsecure);
+                    const updated = await syncWebsitePlainSource(plain, stashDir, allowDangerousEnvKeys);
                     plainSynced.push(updated.item);
                     latestIndex = updated.index;
                 }