@aident-ai/cli 0.2.0 → 0.2.1-rc.0

package/dist/dsh.mjs

@@ -1,4 +1,36 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
   this[name] = __returnValue.bind(null, newValue);
@@ -637,7 +669,7 @@ function normalizeBaseUrl(url) {
 }
 
 // src/version.ts
-var VERSION = "0.2.0";
+var VERSION = "0.2.1-rc.0";
 
 // src/catalogCache.ts
 var CACHE_TTL_MS = 5 * 60 * 1000;
@@ -688,8 +720,8 @@ function isCommandCatalog(value) {
 
 // src/loadoutSkill.ts
 import { createHash as createHash3 } from "node:crypto";
-import { lstat as lstat2, readdir as readdir2, readFile as readFile5, realpath as realpath2 } from "node:fs/promises";
-import { basename, dirname as dirname2, join as join6 } from "node:path";
+import { lstat as lstat3, readdir as readdir2, readFile as readFile5, realpath as realpath2 } from "node:fs/promises";
+import { basename, dirname as dirname3, join as join6 } from "node:path";
 
 // src/loadoutSkillHosts.ts
 import { existsSync } from "node:fs";
@@ -864,10 +896,11 @@ function getConfiguredScope(root, repositoryRoot) {
 
 // src/update.ts
 import { execFile } from "node:child_process";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { constants } from "node:fs";
-import { access, mkdir as mkdir4, readFile as readFile4, realpath, writeFile as writeFile4 } from "node:fs/promises";
+import { access, lstat as lstat2, mkdir as mkdir4, readFile as readFile4, realpath, rename as rename2, symlink, unlink as unlink2, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import { delimiter, isAbsolute as isAbsolute2, join as join5, posix, win32 as win322 } from "node:path";
+import { delimiter, dirname as dirname2, isAbsolute as isAbsolute2, join as join5, posix, win32 as win322 } from "node:path";
 
 // src/directoryLock.ts
 import { randomUUID } from "node:crypto";
@@ -888,14 +921,14 @@ async function tryAcquireDirectoryLock(path, options = {}) {
     if (!existing?.isDirectory())
       return null;
     const ownerBefore = await readLockOwner(path);
-    if (now - existing.mtimeMs < staleAfterMs)
-      return null;
     if (ownerBefore) {
       if ((options.isProcessAlive ?? isProcessAlive)(ownerBefore.pid))
         return null;
       if (!await containsOnlyOwnerFile(path))
         return null;
     } else {
+      if (now - existing.mtimeMs < staleAfterMs)
+        return null;
       if (!await isEmptyDirectory(path) && !await containsOnlyOwnerFile(path))
         return null;
     }
@@ -1010,113 +1043,113 @@ function hasCode(error, code) {
 // ../../node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {
-  void: () => voidType,
-  util: () => util,
-  unknown: () => unknownType,
-  union: () => unionType,
-  undefined: () => undefinedType,
-  tuple: () => tupleType,
-  transformer: () => effectsType,
-  symbol: () => symbolType,
-  string: () => stringType,
-  strictObject: () => strictObjectType,
-  setErrorMap: () => setErrorMap,
-  set: () => setType,
-  record: () => recordType,
-  quotelessJson: () => quotelessJson,
-  promise: () => promiseType,
-  preprocess: () => preprocessType,
-  pipeline: () => pipelineType,
-  ostring: () => ostring,
-  optional: () => optionalType,
-  onumber: () => onumber,
-  oboolean: () => oboolean,
-  objectUtil: () => objectUtil,
-  object: () => objectType,
-  number: () => numberType,
-  nullable: () => nullableType,
-  null: () => nullType,
-  never: () => neverType,
-  nativeEnum: () => nativeEnumType,
-  nan: () => nanType,
-  map: () => mapType,
-  makeIssue: () => makeIssue,
-  literal: () => literalType,
-  lazy: () => lazyType,
-  late: () => late,
-  isValid: () => isValid,
-  isDirty: () => isDirty,
-  isAsync: () => isAsync,
-  isAborted: () => isAborted,
-  intersection: () => intersectionType,
-  instanceof: () => instanceOfType,
-  getParsedType: () => getParsedType,
-  getErrorMap: () => getErrorMap,
-  function: () => functionType,
-  enum: () => enumType,
-  effect: () => effectsType,
-  discriminatedUnion: () => discriminatedUnionType,
-  defaultErrorMap: () => en_default,
-  datetimeRegex: () => datetimeRegex,
-  date: () => dateType,
-  custom: () => custom,
-  coerce: () => coerce,
-  boolean: () => booleanType,
-  bigint: () => bigIntType,
-  array: () => arrayType,
-  any: () => anyType,
-  addIssueToContext: () => addIssueToContext,
-  ZodVoid: () => ZodVoid,
-  ZodUnknown: () => ZodUnknown,
-  ZodUnion: () => ZodUnion,
-  ZodUndefined: () => ZodUndefined,
-  ZodType: () => ZodType,
-  ZodTuple: () => ZodTuple,
-  ZodTransformer: () => ZodEffects,
-  ZodSymbol: () => ZodSymbol,
-  ZodString: () => ZodString,
-  ZodSet: () => ZodSet,
-  ZodSchema: () => ZodType,
-  ZodRecord: () => ZodRecord,
-  ZodReadonly: () => ZodReadonly,
-  ZodPromise: () => ZodPromise,
-  ZodPipeline: () => ZodPipeline,
-  ZodParsedType: () => ZodParsedType,
-  ZodOptional: () => ZodOptional,
-  ZodObject: () => ZodObject,
-  ZodNumber: () => ZodNumber,
-  ZodNullable: () => ZodNullable,
-  ZodNull: () => ZodNull,
-  ZodNever: () => ZodNever,
-  ZodNativeEnum: () => ZodNativeEnum,
-  ZodNaN: () => ZodNaN,
-  ZodMap: () => ZodMap,
-  ZodLiteral: () => ZodLiteral,
-  ZodLazy: () => ZodLazy,
-  ZodIssueCode: () => ZodIssueCode,
-  ZodIntersection: () => ZodIntersection,
-  ZodFunction: () => ZodFunction,
-  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
-  ZodError: () => ZodError,
-  ZodEnum: () => ZodEnum,
-  ZodEffects: () => ZodEffects,
-  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
-  ZodDefault: () => ZodDefault,
-  ZodDate: () => ZodDate,
-  ZodCatch: () => ZodCatch,
-  ZodBranded: () => ZodBranded,
-  ZodBoolean: () => ZodBoolean,
-  ZodBigInt: () => ZodBigInt,
-  ZodArray: () => ZodArray,
-  ZodAny: () => ZodAny,
-  Schema: () => ZodType,
-  ParseStatus: () => ParseStatus,
-  OK: () => OK,
-  NEVER: () => NEVER,
-  INVALID: () => INVALID,
-  EMPTY_PATH: () => EMPTY_PATH,
+  BRAND: () => BRAND,
   DIRTY: () => DIRTY,
-  BRAND: () => BRAND
+  EMPTY_PATH: () => EMPTY_PATH,
+  INVALID: () => INVALID,
+  NEVER: () => NEVER,
+  OK: () => OK,
+  ParseStatus: () => ParseStatus,
+  Schema: () => ZodType,
+  ZodAny: () => ZodAny,
+  ZodArray: () => ZodArray,
+  ZodBigInt: () => ZodBigInt,
+  ZodBoolean: () => ZodBoolean,
+  ZodBranded: () => ZodBranded,
+  ZodCatch: () => ZodCatch,
+  ZodDate: () => ZodDate,
+  ZodDefault: () => ZodDefault,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodEffects: () => ZodEffects,
+  ZodEnum: () => ZodEnum,
+  ZodError: () => ZodError,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+  ZodFunction: () => ZodFunction,
+  ZodIntersection: () => ZodIntersection,
+  ZodIssueCode: () => ZodIssueCode,
+  ZodLazy: () => ZodLazy,
+  ZodLiteral: () => ZodLiteral,
+  ZodMap: () => ZodMap,
+  ZodNaN: () => ZodNaN,
+  ZodNativeEnum: () => ZodNativeEnum,
+  ZodNever: () => ZodNever,
+  ZodNull: () => ZodNull,
+  ZodNullable: () => ZodNullable,
+  ZodNumber: () => ZodNumber,
+  ZodObject: () => ZodObject,
+  ZodOptional: () => ZodOptional,
+  ZodParsedType: () => ZodParsedType,
+  ZodPipeline: () => ZodPipeline,
+  ZodPromise: () => ZodPromise,
+  ZodReadonly: () => ZodReadonly,
+  ZodRecord: () => ZodRecord,
+  ZodSchema: () => ZodType,
+  ZodSet: () => ZodSet,
+  ZodString: () => ZodString,
+  ZodSymbol: () => ZodSymbol,
+  ZodTransformer: () => ZodEffects,
+  ZodTuple: () => ZodTuple,
+  ZodType: () => ZodType,
+  ZodUndefined: () => ZodUndefined,
+  ZodUnion: () => ZodUnion,
+  ZodUnknown: () => ZodUnknown,
+  ZodVoid: () => ZodVoid,
+  addIssueToContext: () => addIssueToContext,
+  any: () => anyType,
+  array: () => arrayType,
+  bigint: () => bigIntType,
+  boolean: () => booleanType,
+  coerce: () => coerce,
+  custom: () => custom,
+  date: () => dateType,
+  datetimeRegex: () => datetimeRegex,
+  defaultErrorMap: () => en_default,
+  discriminatedUnion: () => discriminatedUnionType,
+  effect: () => effectsType,
+  enum: () => enumType,
+  function: () => functionType,
+  getErrorMap: () => getErrorMap,
+  getParsedType: () => getParsedType,
+  instanceof: () => instanceOfType,
+  intersection: () => intersectionType,
+  isAborted: () => isAborted,
+  isAsync: () => isAsync,
+  isDirty: () => isDirty,
+  isValid: () => isValid,
+  late: () => late,
+  lazy: () => lazyType,
+  literal: () => literalType,
+  makeIssue: () => makeIssue,
+  map: () => mapType,
+  nan: () => nanType,
+  nativeEnum: () => nativeEnumType,
+  never: () => neverType,
+  null: () => nullType,
+  nullable: () => nullableType,
+  number: () => numberType,
+  object: () => objectType,
+  objectUtil: () => objectUtil,
+  oboolean: () => oboolean,
+  onumber: () => onumber,
+  optional: () => optionalType,
+  ostring: () => ostring,
+  pipeline: () => pipelineType,
+  preprocess: () => preprocessType,
+  promise: () => promiseType,
+  quotelessJson: () => quotelessJson,
+  record: () => recordType,
+  set: () => setType,
+  setErrorMap: () => setErrorMap,
+  strictObject: () => strictObjectType,
+  string: () => stringType,
+  symbol: () => symbolType,
+  transformer: () => effectsType,
+  tuple: () => tupleType,
+  undefined: () => undefinedType,
+  union: () => unionType,
+  unknown: () => unknownType,
+  util: () => util,
+  void: () => voidType
 });
 
 // ../../node_modules/zod/v3/helpers/util.js
@@ -5077,7 +5110,7 @@ async function detectCliInstallOwnership(executablePath = process.argv[1], homeD
       });
     }
   }
-  if (paths.some(isAidentCliPackagePath)) {
+  if (paths.some(isAidentCliPackagePath) || platform === "win32") {
     for (const manager of ["pnpm" /* Pnpm */, "npm" /* Npm */]) {
       if (matches.has(manager))
         continue;
@@ -5085,7 +5118,9 @@ async function detectCliInstallOwnership(executablePath = process.argv[1], homeD
       if (!managerExecutablePath)
         continue;
       const globalInstall = await getManagerGlobalInstall(manager, managerExecutablePath, runFile, resolveRealpath, platform);
-      if (globalInstall && paths.some((path) => isPathWithin(globalInstall.packageRoot, path))) {
+      const packagePathOwned = globalInstall && paths.some((path) => isPathWithin(globalInstall.packageRoot, path));
+      const shimOwned = globalInstall && platform === "win32" && await isWindowsPackageManagerShim(executablePath, manager, globalInstall.managerInstallRoot, globalInstall.managerBinRoot, readTextFile);
+      if (globalInstall && (packagePathOwned || shimOwned)) {
         matches.set(manager, {
           ...ownership(manager, executablePath, resolvedExecutablePath),
           managerExecutablePath,
@@ -5100,6 +5135,19 @@ async function detectCliInstallOwnership(executablePath = process.argv[1], homeD
     return [...matches.values()][0];
   return unknownOwnership(executablePath);
 }
+async function isWindowsPackageManagerShim(executablePath, manager, managerInstallRoot, managerBinRoot, readTextFile) {
+  if (!/^aident(?:\.cmd|\.ps1)?$/i.test(win322.basename(executablePath)))
+    return false;
+  const expectedBinRoot = manager === "pnpm" /* Pnpm */ ? managerBinRoot : managerInstallRoot;
+  if (!expectedBinRoot || normalizePath(win322.dirname(executablePath), "win32") !== normalizePath(expectedBinRoot, "win32")) {
+    return false;
+  }
+  const content = await readTextFile(executablePath).catch(() => "");
+  if (content.length > 16384)
+    return false;
+  const normalized = normalizePath(content, "win32");
+  return normalized.includes("@aident-ai/cli") && normalized.includes("dist/cli.mjs");
+}
 async function updateCli(params, deps = {}) {
   if (!isAidentSemver(params.currentVersion)) {
     throw new Error(`Invalid installed Aident CLI version: ${params.currentVersion}`);
@@ -5198,6 +5246,137 @@ async function updateCli(params, deps = {}) {
     await lock.release();
   }
 }
+async function replacePackageManagedCliWithNative(params, deps = {}) {
+  const platform = params.platform ?? process.platform;
+  const resolveRealpath = deps.realpath ?? realpath;
+  const runFile = deps.execFile ?? runExecFile;
+  const readVersion = deps.readVersion ?? (async (path, options) => parseCliVersionOutput((await runFile(path, ["--version"], options)).stdout));
+  const [activeRealpath, nativeRealpath] = await Promise.all([
+    resolveRealpath(params.activeExecutablePath).catch(() => params.activeExecutablePath),
+    resolveRealpath(params.nativeExecutablePath)
+  ]);
+  const nativeVersion = await readVersion(params.nativeExecutablePath);
+  if (!nativeVersion)
+    throw new Error("The bundled Aident CLI could not report a valid version");
+  if (normalizePath(activeRealpath, platform) === normalizePath(nativeRealpath, platform)) {
+    return {
+      status: "current",
+      owner: "native",
+      version: nativeVersion,
+      activePath: params.activeExecutablePath
+    };
+  }
+  const detectOwnership = deps.detectInstallOwnership ?? (() => detectCliInstallOwnership(params.activeExecutablePath, params.homeDir ?? homedir3(), {
+    platform,
+    execFile: (file, args) => runFile(file, args)
+  }));
+  const ownership = await detectOwnership();
+  if (!["npm" /* Npm */, "pnpm" /* Pnpm */, "bun" /* Bun */, "volta" /* Volta */].includes(ownership.method)) {
+    throw new Error(`The existing Aident CLI owner is ${ownership.method} and cannot be replaced automatically`);
+  }
+  assertCompletePackageManagerOwnership(ownership);
+  const prepareUpdateDirectory = deps.prepareUpdateDirectory ?? prepareCliUpdateDirectory;
+  const updateDirectory = await prepareUpdateDirectory();
+  const acquireLock = deps.acquireLock ?? acquireCliUpdateLock;
+  const lock = await acquireLock();
+  if (!lock)
+    throw new Error("Another Aident CLI update is already running");
+  let createdActivationLink = false;
+  let transactionId;
+  try {
+    const prepareManagerConfig = deps.prepareManagerConfig ?? prepareTrustedManagerConfig;
+    const managerConfig = await prepareManagerConfig(updateDirectory, ownership);
+    const managerExecOptions = getManagerExecOptions(updateDirectory, ownership, managerConfig);
+    const previousVersion = await readVersion(params.activeExecutablePath);
+    if (!previousVersion)
+      throw new Error("The existing Aident CLI could not report a valid version");
+    transactionId = randomUUID2();
+    const activationExists = await (deps.pathExists ?? pathExists)(params.activationPath);
+    if (activationExists) {
+      const activationRealpath = await resolveRealpath(params.activationPath).catch(() => params.activationPath);
+      if (normalizePath(activationRealpath, platform) !== normalizePath(nativeRealpath, platform) && normalizePath(activationRealpath, platform) !== normalizePath(activeRealpath, platform)) {
+        throw new Error("The native Aident command path is owned by another executable");
+      }
+    }
+    const removeInvocation = getRemovalInvocation(ownership, managerConfig);
+    try {
+      await runFile(removeInvocation.file, removeInvocation.args, managerExecOptions);
+      if (!await (deps.pathExists ?? pathExists)(params.activationPath)) {
+        await (deps.createSymlink ?? createNativeCliSymlink)(params.nativeExecutablePath, params.activationPath);
+        createdActivationLink = true;
+      }
+      const activationRealpath = await resolveRealpath(params.activationPath);
+      const activatedVersion = await readVersion(params.activationPath);
+      if (normalizePath(activationRealpath, platform) !== normalizePath(nativeRealpath, platform) || activatedVersion !== nativeVersion) {
+        throw new Error("The bundled Aident CLI did not become the active command");
+      }
+      await (deps.writeReplacementState ?? writePackageManagedCliReplacementState)(params.homeDir ?? homedir3(), {
+        schemaVersion: 1,
+        transactionId,
+        previousVersion,
+        activeExecutablePath: params.activeExecutablePath,
+        nativeExecutablePath: params.nativeExecutablePath,
+        activationPath: params.activationPath,
+        createdActivationLink,
+        ownership
+      });
+    } catch (error) {
+      if (createdActivationLink) {
+        await (deps.removeFile ?? unlink2)(params.activationPath).catch(() => {
+          return;
+        });
+      }
+      const restored = await restorePackageManagedCli(runFile, ownership, managerConfig, managerExecOptions, params.activeExecutablePath, previousVersion, updateDirectory, readVersion);
+      await (deps.removeReplacementState ?? removePackageManagedCliReplacementState)(params.homeDir ?? homedir3()).catch(() => {
+        return;
+      });
+      throw sanitizedExecError(`Aident CLI replacement failed${restored ? "; restored the previous package-managed CLI" : "; rollback failed"}`, error);
+    }
+    return {
+      status: "replaced",
+      owner: ownership.method,
+      version: nativeVersion,
+      previousVersion,
+      activePath: params.activationPath,
+      transactionId
+    };
+  } finally {
+    await lock.release();
+  }
+}
+async function completePackageManagedCliReplacement(transactionId, homeDir = homedir3()) {
+  const state = await readPackageManagedCliReplacementState(homeDir);
+  if (!state || state.transactionId !== transactionId)
+    throw new Error("Aident CLI replacement transaction not found");
+  await removePackageManagedCliReplacementState(homeDir);
+}
+async function rollbackPackageManagedCliReplacement(transactionId, homeDir = homedir3()) {
+  const state = await readPackageManagedCliReplacementState(homeDir);
+  if (!state || state.transactionId !== transactionId)
+    throw new Error("Aident CLI replacement transaction not found");
+  assertCompletePackageManagerOwnership(state.ownership);
+  const updateDirectory = await prepareCliUpdateDirectory();
+  const lock = await acquireCliUpdateLock();
+  if (!lock)
+    throw new Error("Another Aident CLI update is already running");
+  try {
+    if (state.createdActivationLink) {
+      const activationRealpath = await realpath(state.activationPath).catch(() => null);
+      const nativeRealpath = await realpath(state.nativeExecutablePath).catch(() => state.nativeExecutablePath);
+      if (activationRealpath && normalizePath(activationRealpath) === normalizePath(nativeRealpath)) {
+        await unlink2(state.activationPath);
+      }
+    }
+    const config = await prepareTrustedManagerConfig(updateDirectory, state.ownership);
+    const options = getManagerExecOptions(updateDirectory, state.ownership, config);
+    const restored = await restorePackageManagedCli(runExecFile, state.ownership, config, options, state.activeExecutablePath, state.previousVersion, updateDirectory, async (path, execOptions) => parseCliVersionOutput((await runExecFile(path, ["--version"], execOptions)).stdout));
+    if (!restored)
+      throw new Error("Failed to restore the previous package-managed Aident CLI");
+    await removePackageManagedCliReplacementState(homeDir);
+  } finally {
+    await lock.release();
+  }
+}
 function manualUpdateResult(currentVersion, targetVersion, method) {
   return {
     status: "manual-required" /* ManualRequired */,
@@ -5413,6 +5592,109 @@ function getUpdateInvocation(ownership2, targetVersion, config) {
       throw new Error(`No update invocation exists for ${ownership2.method}`);
   }
 }
+function getRemovalInvocation(ownership2, config) {
+  const managerExecutablePath = ownership2.managerExecutablePath;
+  switch (ownership2.method) {
+    case "npm" /* Npm */:
+      return {
+        file: managerExecutablePath,
+        args: [
+          `--userconfig=${config.npmUserConfig}`,
+          `--globalconfig=${config.npmGlobalConfig}`,
+          `--prefix=${ownership2.managerInstallRoot}`,
+          "uninstall",
+          "--global",
+          "--ignore-scripts",
+          AIDENT_CLI_PACKAGE
+        ]
+      };
+    case "pnpm" /* Pnpm */:
+      return {
+        file: managerExecutablePath,
+        args: [
+          `--global-dir=${ownership2.managerInstallRoot}`,
+          `--global-bin-dir=${ownership2.managerBinRoot}`,
+          "remove",
+          "--global",
+          "--ignore-scripts",
+          AIDENT_CLI_PACKAGE
+        ]
+      };
+    case "bun" /* Bun */:
+      return {
+        file: managerExecutablePath,
+        args: [`--config=${config.bunConfig}`, "remove", "--global", AIDENT_CLI_PACKAGE]
+      };
+    case "volta" /* Volta */:
+      return { file: managerExecutablePath, args: ["uninstall", AIDENT_CLI_PACKAGE] };
+    case "ephemeral" /* Ephemeral */:
+    case "unknown" /* Unknown */:
+      throw new Error(`No removal invocation exists for ${ownership2.method}`);
+  }
+}
+function assertCompletePackageManagerOwnership(ownership2) {
+  if (!ownership2.managerExecutablePath || !ownership2.managerInstallRoot) {
+    throw new Error("Aident CLI package-manager ownership is incomplete");
+  }
+  if ((ownership2.method === "pnpm" /* Pnpm */ || ownership2.method === "bun" /* Bun */) && !ownership2.managerBinRoot) {
+    throw new Error("Aident CLI package-manager binary ownership is incomplete");
+  }
+}
+async function restorePackageManagedCli(exec, ownership2, config, managerExecOptions, activeExecutablePath, previousVersion, updateDirectory, readVersion) {
+  if (await readVersion(activeExecutablePath).catch(() => null) === previousVersion)
+    return true;
+  const invocation = getUpdateInvocation(ownership2, previousVersion, config);
+  try {
+    await exec(invocation.file, invocation.args, managerExecOptions);
+    return await readVersion(activeExecutablePath, { cwd: updateDirectory }).catch(() => null) === previousVersion;
+  } catch {
+    return false;
+  }
+}
+async function pathExists(path) {
+  return lstat2(path).then(() => true).catch(() => false);
+}
+function getPackageManagedCliReplacementStatePath(homeDir) {
+  return join5(homeDir, ".aident", "cli-replacement.json");
+}
+async function writePackageManagedCliReplacementState(homeDir, state) {
+  const path = getPackageManagedCliReplacementStatePath(homeDir);
+  const temporary = `${path}.${state.transactionId}.tmp`;
+  await mkdir4(dirname2(path), { recursive: true, mode: 448 });
+  await writeFile4(temporary, `${JSON.stringify(state)}
+`, { mode: 384, flag: "wx" });
+  await rename2(temporary, path);
+}
+async function readPackageManagedCliReplacementState(homeDir) {
+  try {
+    const content = await readFile4(getPackageManagedCliReplacementStatePath(homeDir), "utf8");
+    if (content.length > 16384)
+      return null;
+    const state = JSON.parse(content);
+    if (state.schemaVersion !== 1 || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(state.transactionId) || !isAidentSemver(state.previousVersion) || !isAbsolute2(state.activeExecutablePath) || !isAbsolute2(state.nativeExecutablePath) || !isAbsolute2(state.activationPath) || typeof state.createdActivationLink !== "boolean" || !isPackageManagedCliOwnershipState(state.ownership)) {
+      return null;
+    }
+    return state;
+  } catch {
+    return null;
+  }
+}
+function isPackageManagedCliOwnershipState(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const ownership2 = value;
+  if (!ownership2.method || !["npm" /* Npm */, "pnpm" /* Pnpm */, "bun" /* Bun */, "volta" /* Volta */].includes(ownership2.method) || typeof ownership2.managerExecutablePath !== "string" || !isAbsolute2(ownership2.managerExecutablePath) || typeof ownership2.managerInstallRoot !== "string" || !isAbsolute2(ownership2.managerInstallRoot)) {
+    return false;
+  }
+  return ownership2.method !== "pnpm" /* Pnpm */ && ownership2.method !== "bun" /* Bun */ || typeof ownership2.managerBinRoot === "string" && isAbsolute2(ownership2.managerBinRoot);
+}
+async function removePackageManagedCliReplacementState(homeDir) {
+  await unlink2(getPackageManagedCliReplacementStatePath(homeDir));
+}
+async function createNativeCliSymlink(target, path) {
+  await mkdir4(dirname2(path), { recursive: true });
+  await symlink(target, path, process.platform === "win32" ? "file" : undefined);
+}
 function getManagerCommand(method, platform = process.platform) {
   const windows = platform === "win32";
   switch (method) {
@@ -5556,9 +5838,17 @@ function runExecFile(file, args, options = {}) {
   });
 }
 function getPlatformExecFileInvocation(file, args, platform = process.platform, commandProcessor = process.env.ComSpec) {
-  if (platform !== "win32" || !/\.(?:cmd|bat)$/i.test(file)) {
+  if (platform !== "win32") {
     return { file, args: [...args] };
   }
+  if (/\.ps1$/i.test(file)) {
+    return {
+      file: "powershell.exe",
+      args: ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", file, ...args]
+    };
+  }
+  if (!/\.(?:cmd|bat)$/i.test(file))
+    return { file, args: [...args] };
   if ([file, ...args].some((value) => /["%!^&|<>()\r\n]/.test(value))) {
     throw new Error("Unsafe Windows package-manager command path or argument");
   }
@@ -5659,6 +5949,12 @@ var AidentDesktopArtifactFormat;
   AidentDesktopArtifactFormat2["WindowsNsisV1"] = "windows-nsis-v1";
   AidentDesktopArtifactFormat2["LinuxTarZstV1"] = "linux-tar-zst-v1";
 })(AidentDesktopArtifactFormat ||= {});
+var AidentDesktopChannel;
+((AidentDesktopChannel2) => {
+  AidentDesktopChannel2["Staging"] = "staging";
+  AidentDesktopChannel2["Rc"] = "rc";
+  AidentDesktopChannel2["Stable"] = "stable";
+})(AidentDesktopChannel ||= {});
 var AidentOnboardingUiArtifactSchema = zod_default.object({
   format: zod_default.literal("aident-onboarding-ui-v1"),
   version: AidentSemverSchema,
@@ -5712,7 +6008,7 @@ var AidentDesktopArtifactSchema = zod_default.object({
 }).strict();
 var AidentDesktopChannelManifestSchema = zod_default.object({
   schemaVersion: zod_default.literal(1),
-  channel: zod_default.enum(["stable", "rc"]),
+  channel: zod_default.nativeEnum(AidentDesktopChannel),
   desktopVersion: AidentSemverSchema,
   cliVersion: AidentSemverSchema,
   sourceCommit: zod_default.string().regex(/^[a-f0-9]{40}$/),
@@ -5893,6 +6189,15 @@ var KNOWN_CLEAN_LOADOUT_SKILL_REQUIRED_FILE_GIT_BLOB_SHA1 = {
       "references/mcp.md": "3e92c88b1ef94e863bd4ce977a36abc3a0df2138",
       "references/troubleshooting.md": "f819915c8829b028630ef1f8f29ae9433a072ca8"
     }
+  ],
+  "0.4.16": [
+    {
+      "SKILL.md": "bc15dbd5e86fc76a1f9a9870d7a910612f65ccb0",
+      "references/api.md": "240b913e8c85492f2441326033db91747c54863e",
+      "references/loadout.md": "be4dbd9e0aad75afe647800f64d2bb16c22d03a8",
+      "references/mcp.md": "3e92c88b1ef94e863bd4ce977a36abc3a0df2138",
+      "references/troubleshooting.md": "f819915c8829b028630ef1f8f29ae9433a072ca8"
+    }
   ]
 };
 async function fetchLoadoutSkillMetadata(baseUrl) {
@@ -5931,7 +6236,7 @@ async function getLoadoutSkillInventory(candidates = getInstalledLoadoutSkillCan
   const resolvedManagedReleasesRoot = await realpath2(managedReleasesRoot).catch(() => managedReleasesRoot);
   const inspected = await Promise.all(candidates.map(async (candidate) => ({
     candidate,
-    installation: await inspectLoadoutSkillDirectory(dirname2(candidate.path), resolvedManagedReleasesRoot)
+    installation: await inspectLoadoutSkillDirectory(dirname3(candidate.path), resolvedManagedReleasesRoot)
   })));
   const installations = [];
   const byRealPath = new Map;
@@ -5961,7 +6266,7 @@ async function inspectLoadoutSkillDirectory(skillDirectory, managedReleasesRoot
   const skillPath = join6(resolvedDirectory, "SKILL.md");
   let skillContent;
   try {
-    const skillStat = await lstat2(skillPath);
+    const skillStat = await lstat3(skillPath);
     if (!skillStat.isFile()) {
       return emptyInspection("malformed" /* Malformed */, resolvedDirectory, "SKILL.md is not a file");
     }
@@ -5984,7 +6289,7 @@ async function inspectLoadoutSkillDirectory(skillDirectory, managedReleasesRoot
   for (const path of LOADOUT_SKILL_REQUIRED_FILES.slice(1)) {
     try {
       const fullPath = join6(resolvedDirectory, path);
-      const fileStat = await lstat2(fullPath);
+      const fileStat = await lstat3(fullPath);
       if (!fileStat.isFile()) {
         return emptyInspection("malformed" /* Malformed */, resolvedDirectory, `${path} is not a file`, frontmatter.version);
       }
@@ -6087,7 +6392,7 @@ function isManagedReleasePath(directory, artifactSha256, managedReleasesRoot) {
     const normalized = path.replaceAll("\\", "/");
     return process.platform === "win32" ? normalized.toLowerCase() : normalized;
   };
-  return normalize(dirname2(directory)) === normalize(managedReleasesRoot) && normalize(basename(directory)) === normalize(artifactSha256);
+  return normalize(dirname3(directory)) === normalize(managedReleasesRoot) && normalize(basename(directory)) === normalize(artifactSha256);
 }
 function stateForMissing(error) {
   return isMissingError(error) ? "missing" /* Missing */ : "malformed" /* Malformed */;
@@ -6441,7 +6746,7 @@ function isExpired(creds) {
 
 // src/loadoutFavoriteSkills.ts
 import { createHash as createHash4 } from "node:crypto";
-import { lstat as lstat3, mkdir as mkdir6, readFile as readFile7, readlink, rename as rename2, rm as rm2, symlink, writeFile as writeFile6 } from "node:fs/promises";
+import { lstat as lstat4, mkdir as mkdir6, readFile as readFile7, readlink, rename as rename3, rm as rm2, symlink as symlink2, writeFile as writeFile6 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
 import path from "node:path";
 
@@ -6545,9 +6850,9 @@ function entrypointContent(pkg, content) {
   ].join(`
 `);
 }
-async function pathExists(target) {
+async function pathExists2(target) {
   try {
-    await lstat3(target);
+    await lstat4(target);
     return true;
   } catch (error) {
     if (error.code === "ENOENT")
@@ -6583,17 +6888,17 @@ async function writeManifest(home, manifest) {
   await mkdir6(path.dirname(manifestPath), { recursive: true, mode: 448 });
   await writeFile6(temporaryPath, `${JSON.stringify(manifest, null, 2)}
 `, { mode: 384 });
-  await rename2(temporaryPath, manifestPath);
+  await rename3(temporaryPath, manifestPath);
 }
 async function removeOwnedSkill(skill) {
   for (const linkPath of skill.linkPaths) {
-    if (!await pathExists(linkPath))
+    if (!await pathExists2(linkPath))
       continue;
-    const stat = await lstat3(linkPath);
+    const stat = await lstat4(linkPath);
     if (stat.isSymbolicLink())
       await rm2(linkPath);
   }
-  if (await pathExists(skill.installPath))
+  if (await pathExists2(skill.installPath))
     await rm2(skill.installPath, { recursive: true });
 }
 async function reconcileLoadoutFavoriteSkills(payload, home = getHome(), env = process.env) {
@@ -6632,13 +6937,13 @@ async function reconcileLoadoutFavoriteSkills(payload, home = getHome(), env = p
     const installPath = path.join(getCanonicalRoot(home, env), nextCommandName);
     const linkPaths = getHarnessRoots(home, env).map((root) => path.join(root, nextCommandName));
     const conflictingPath = (await Promise.all([installPath, ...linkPaths].map(async (candidate) => {
-      if (!await pathExists(candidate))
+      if (!await pathExists2(candidate))
         return null;
       if (previous && candidate === previous.installPath) {
-        return (await lstat3(candidate)).isDirectory() ? null : candidate;
+        return (await lstat4(candidate)).isDirectory() ? null : candidate;
       }
       if (previous && previous.linkPaths.includes(candidate)) {
-        const stat = await lstat3(candidate);
+        const stat = await lstat4(candidate);
         if (!stat.isSymbolicLink())
           return candidate;
         return path.resolve(path.dirname(candidate), await readlink(candidate)) === previous.installPath ? null : candidate;
@@ -6651,8 +6956,8 @@ async function reconcileLoadoutFavoriteSkills(payload, home = getHome(), env = p
         nextSkills.push(previous);
       continue;
     }
-    const allLinksExist = (await Promise.all(linkPaths.map(pathExists))).every(Boolean);
-    if (previous?.artifactVersionId === pkg.artifactVersionId && previous.displayName === pkg.displayName && previous.summary === pkg.summary && previous.installPath === installPath && previous.linkPaths.length === linkPaths.length && previous.linkPaths.every((linkPath) => linkPaths.includes(linkPath)) && await pathExists(installPath) && allLinksExist) {
+    const allLinksExist = (await Promise.all(linkPaths.map(pathExists2))).every(Boolean);
+    if (previous?.artifactVersionId === pkg.artifactVersionId && previous.displayName === pkg.displayName && previous.summary === pkg.summary && previous.installPath === installPath && previous.linkPaths.length === linkPaths.length && previous.linkPaths.every((linkPath) => linkPaths.includes(linkPath)) && await pathExists2(installPath) && allLinksExist) {
       result.unchanged.push(pkg.name);
       nextSkills.push(previous);
       continue;
@@ -6671,15 +6976,15 @@ async function reconcileLoadoutFavoriteSkills(payload, home = getHome(), env = p
     const createdLinkPaths = [];
     let backedUp = false;
     try {
-      if (await pathExists(installPath)) {
-        await rename2(installPath, backupPath);
+      if (await pathExists2(installPath)) {
+        await rename3(installPath, backupPath);
         backedUp = true;
       }
-      await rename2(temporaryPath, installPath);
+      await rename3(temporaryPath, installPath);
       for (const linkPath of linkPaths) {
         await mkdir6(path.dirname(linkPath), { recursive: true });
-        if (!await pathExists(linkPath)) {
-          await symlink(installPath, linkPath, "dir");
+        if (!await pathExists2(linkPath)) {
+          await symlink2(installPath, linkPath, "dir");
           createdLinkPaths.push(linkPath);
         }
       }
@@ -6688,7 +6993,7 @@ async function reconcileLoadoutFavoriteSkills(payload, home = getHome(), env = p
       await Promise.all(createdLinkPaths.map((linkPath) => rm2(linkPath, { force: true })));
       await rm2(installPath, { recursive: true, force: true });
       if (backedUp)
-        await rename2(backupPath, installPath);
+        await rename3(backupPath, installPath);
       await rm2(temporaryPath, { recursive: true, force: true });
       throw error;
     }
@@ -7251,8 +7556,8 @@ function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 export {
-  name,
-  inject,
+  apply,
   applyDshPlugin,
-  apply
+  inject,
+  name
 };