@moonshot-ai/kimi-code 0.39.0 → 0.40.0

package/scripts/postinstall/reach.mjs

@@ -28,32 +28,13 @@
 
 import { spawn } from 'node:child_process';
 import { promises as fs } from 'node:fs';
-import { delimiter, dirname, join, sep } from 'node:path';
+import { delimiter, dirname, join } from 'node:path';
+
+import { executableCandidates, pathFlavor } from './platform.mjs';
 
 const LEGACY_BIN = 'kimi';
 const IS_WINDOWS = process.platform === 'win32';
 
-/**
- * Expand a basename like `kimi` into the set of filenames the OS
- * would actually match on PATH.
- *
- * On POSIX: just `['kimi']`.
- *
- * On Windows: `['kimi', 'kimi.exe', 'kimi.cmd', …]` — every
- * extension in `PATHEXT`. Without this, our PATH walk would miss
- * the typical `kimi.exe` shim produced by `uv tool install` on
- * Windows.
- */
-export function executableCandidates(basename) {
-  if (!IS_WINDOWS) return [basename];
-  const pathext = (process.env['PATHEXT'] ?? '.EXE;.CMD;.BAT;.COM')
-    .toLowerCase()
-    .split(';')
-    .map((e) => e.trim())
-    .filter(Boolean);
-  return [basename, ...pathext.map((ext) => basename + ext)];
-}
-
 /**
  * Identify which package manager ran us. `npm_config_user_agent` is
  * set by npm, yarn (classic + berry), and pnpm, and starts with the
@@ -223,7 +204,7 @@ export async function ownPackageRoot(startDir) {
   return null;
 }
 
-async function isExecutableFile(filePath) {
+async function isExecutableFile(filePath, platform) {
   try {
     const info = await fs.stat(filePath);
     if (!info.isFile()) return false;
@@ -231,7 +212,7 @@ async function isExecutableFile(filePath) {
     // existence + a recognized extension is what PATHEXT-style lookup
     // checks. Callers only pass us candidates that already match an
     // extension in `executableCandidates()`, so "is a file" suffices.
-    if (IS_WINDOWS) return true;
+    if (platform === 'win32') return true;
     return (info.mode & 0o111) !== 0;
   } catch {
     return false;
@@ -304,20 +285,22 @@ export async function findFirstResolvableKimi(
   pathString,
   actionableShimPaths,
   allDetectedShimPaths,
+  platform = process.platform,
 ) {
   if (!ownRoot || !pathString) return { kind: 'none' };
-  const ownPrefix = ownRoot + sep;
-  const candidates = executableCandidates(LEGACY_BIN);
+  const { delimiter: flavorDelimiter, join: flavorJoin, sep: flavorSep } = pathFlavor(platform);
+  const ownPrefix = ownRoot + flavorSep;
+  const candidates = executableCandidates(LEGACY_BIN, platform);
   const skipSet = new Set(actionableShimPaths ?? []);
   const knownLegacySet = new Set(allDetectedShimPaths ?? []);
   const seenDirs = new Set();
-  for (const dir of pathString.split(delimiter)) {
+  for (const dir of pathString.split(flavorDelimiter)) {
     if (!dir || seenDirs.has(dir)) continue;
     seenDirs.add(dir);
     for (const name of candidates) {
-      const shim = join(dir, name);
+      const shim = flavorJoin(dir, name);
       if (skipSet.has(shim)) continue;
-      if (!(await isExecutableFile(shim))) continue;
+      if (!(await isExecutableFile(shim, platform))) continue;
       const kind = await classifyShim(shim, ownRoot, ownPrefix);
       if (kind === 'unreadable') continue;
       if (kind === 'own') return { kind: 'own' };

package/scripts/postinstall/takeover.mjs

@@ -0,0 +1,98 @@
+import { findFirstResolvableKimi } from './reach.mjs';
+import {
+  classifyShim,
+  deleteShim,
+  detectLegacyShims,
+  renameInPlace,
+} from './migrate.mjs';
+
+export async function planTakeover(ownRoot, detectionPath, reachabilityPath, platform) {
+  const detections = await detectLegacyShims(ownRoot, detectionPath, platform);
+  if (detections.length === 0) return { kind: /** @type {const} */ ('noop') };
+
+  const classifications = await Promise.all(
+    detections.map(async (detection) => {
+      const c = await classifyShim(detection.shimPath, platform);
+      return { ...c, detection };
+    }),
+  );
+
+  const actionable = classifications.filter((c) => c.kind !== 'blocked');
+  const blocked = classifications.filter((c) => c.kind === 'blocked');
+  const blocker = await findFirstResolvableKimi(
+    ownRoot,
+    reachabilityPath,
+    actionable.map((c) => c.shimPath),
+    classifications.map((c) => c.shimPath),
+    platform,
+  );
+
+  if (blocker.kind === 'own') {
+    return { kind: /** @type {const} */ ('proceed'), detections, classifications, actionable, blocked };
+  }
+  if (blocker.kind === 'blocked-legacy') {
+    return { kind: /** @type {const} */ ('blocked'), blocked, actionable };
+  }
+  if (blocker.kind === 'foreign') {
+    return { kind: /** @type {const} */ ('foreign'), path: blocker.path };
+  }
+  return { kind: /** @type {const} */ ('not-on-path'), detection: detections[0] };
+}
+
+export async function executeTakeover(classifications) {
+  const renames = [];
+  const consolidates = [];
+  const skippedForeignTarget = [];
+  const deletes = [];
+  const errors = [];
+  let preserved = false;
+
+  for (const c of classifications) {
+    if (c.kind === 'blocked') continue;
+
+    if (!preserved) {
+      if (c.kind === 'renameable') {
+        const r = await renameInPlace(c.shimPath, c.target);
+        if (r.success) {
+          renames.push(c);
+          preserved = true;
+        } else {
+          errors.push({ ...c, ...r });
+        }
+        continue;
+      }
+      if (c.kind === 'consolidate') {
+        const r = await deleteShim(c.shimPath);
+        if (r.success) {
+          consolidates.push(c);
+          preserved = true;
+        } else {
+          errors.push({ ...c, ...r });
+        }
+        continue;
+      }
+      if (c.kind === 'delete-only') {
+        const r = await deleteShim(c.shimPath);
+        if (r.success) {
+          skippedForeignTarget.push(c);
+        } else {
+          errors.push({ ...c, ...r });
+        }
+        continue;
+      }
+    } else {
+      const r = await deleteShim(c.shimPath);
+      if (r.success) {
+        deletes.push(c);
+      } else {
+        errors.push({ ...c, ...r });
+      }
+    }
+  }
+
+  return { renames, consolidates, skippedForeignTarget, deletes, errors, preserved };
+}
+
+export async function verifyTakeover(ownRoot, reachabilityPath, allDetectedShimPaths, platform) {
+  return findFirstResolvableKimi(ownRoot, reachabilityPath, [], allDetectedShimPaths, platform);
+}

package/scripts/postinstall/ui.mjs

@@ -406,6 +406,97 @@ export function logForeignKimiInTheWay(foreignPath, pm) {
   );
 }
 
+/**
+ * A takeover that was executed but did NOT hold up under post-execution
+ * verification: `kimi` still resolves to a legacy/foreign file (or to
+ * nothing at all). The heading must not claim success — list what was
+ * actually changed, what still blocks resolution, and how to finish
+ * the job by hand.
+ */
+export function logMigrationIncomplete(input, pm) {
+  const { outcomes, verify } = input;
+  const { renames, consolidates, skippedForeignTarget, deletes, errors } = outcomes;
+  const isWindows = process.platform === 'win32';
+  const reinstallCmd = pmGlobalInstallCommand(pm, '@moonshot-ai/kimi-code');
+
+  const lines = [warningHeading('Couldn\'t finish switching to the new kimi'), ''];
+
+  if (verify.kind === 'blocked-legacy') {
+    lines.push(
+      pad('   Typing `kimi` still runs the old version. This file is in'),
+      pad('   the way and we couldn\'t change it:'),
+      pathInBox(verify.shim),
+      '',
+    );
+  } else if (verify.kind === 'foreign') {
+    lines.push(
+      pad('   Typing `kimi` runs a file we don\'t recognize (not the new'),
+      pad('   CLI, not the old one). It\'s still in the way:'),
+      pathInBox(verify.path),
+      '',
+    );
+  } else {
+    lines.push(
+      pad('   Typing `kimi` currently finds nothing at all — the old'),
+      pad('   shim was removed but the new one isn\'t reachable yet.'),
+      '',
+    );
+  }
+
+  const changed = [
+    ...renames.map((c) => c.shimPath + '  ->  ' + c.target),
+    ...consolidates.map((c) => c.shimPath + '  (removed; kimi-legacy kept)'),
+    ...skippedForeignTarget.map((c) => c.shimPath + '  (removed)'),
+    ...deletes.map((c) => c.shimPath + '  (removed)'),
+  ];
+  if (changed.length > 0) {
+    lines.push(pad('   Changes already made:'));
+    for (const line of changed) lines.push(pathInBox(line));
+    lines.push('');
+  }
+
+  if (errors.length > 0) {
+    lines.push(pad('   Changes that didn\'t go through:'));
+    for (const e of errors) {
+      lines.push(pathInBox(e.shimPath + '  (' + (e.message ?? e.code ?? 'error') + ')'));
+    }
+    lines.push('');
+  }
+
+  if (verify.kind === 'blocked-legacy') {
+    const c = verify;
+    lines.push(pad('   Delete it yourself, then install again:'));
+    if (isWindows) {
+      lines.push(pathInBox('Remove-Item ' + quotePowerShellPath(c.shim)));
+    } else {
+      lines.push(pathInBox('rm ' + quotePosixPath(c.shim)));
+      lines.push(pad('   (use sudo if it\'s in a system directory)'));
+    }
+    lines.push(pathInBox(reinstallCmd), '');
+  } else if (verify.kind === 'foreign') {
+    lines.push(
+      pad('   Delete or rename that file, then install again:'),
+      pathInBox(reinstallCmd),
+      '',
+    );
+  } else {
+    lines.push(
+      pad('   Open a new terminal and check `which kimi`. If it finds'),
+      pad('   nothing, reinstall to restore a working shim:'),
+      pathInBox(reinstallCmd),
+      '',
+    );
+  }
+
+  if (renames.length > 0 || consolidates.length > 0) {
+    lines.push(
+      pad('   The old version is still available as `kimi-legacy`.'),
+    );
+  }
+
+  emit(renderBox(lines));
+}
+
 /**
  * The legacy `kimi` was found, but the directory where the package
  * manager placed the new `kimi` shim is not on the user's PATH.

package/scripts/postinstall.mjs

@@ -37,9 +37,10 @@
  *   - `./postinstall/migrate.mjs` — legacy detection,
  *     `kimi`-vs-`kimi-legacy` classification, the rename / unlink
  *     primitives.
+ *   - `./postinstall/takeover.mjs` — the plan → execute → verify
+ *     state machine this orchestrator drives.
  *   - `./postinstall/ui.mjs` — `notify()` (with `/dev/tty` fallback),
- *     ANSI styling, the fixed-width box, and the five outcome
- *     renderers.
+ *     ANSI styling, the fixed-width box, and the outcome renderers.
  *
  * ## Workflow
  *
@@ -60,41 +61,26 @@
  *      shell can't be probed). Sharing one probe keeps detection
  *      and reachability symmetric and avoids running `$SHELL -l`
  *      twice.
- *   5. Detect EVERY previous Python `kimi-cli` shim on the detection
- *      PATH (`detectLegacyShims`). Returns `[]` for fresh-install /
- *      no-op. Multiple results happen when the user has installed
- *      `kimi-cli` through more than one Python tool (uv + pipx, or
- *      sudo-pip + pip-user). PATH order is preserved.
- *   6. Pre-flight classify each shim (`classifyShim`) — pure
- *      filesystem inspection, no writes. Each shim ends up
- *      `renameable`, `consolidate`, `delete-only`, or `blocked`.
- *   7. Decide abort vs proceed against the WHOLE set:
- *      `findFirstResolvableKimi` walks PATH treating the actionable
- *      shims as gone and reports what wins:
- *        - `own` → proceed to execute.
- *        - `blocked-legacy` → a legacy we can't remove still wins.
- *          Surface `logMigrationBlocked` with sudo / admin
- *          instructions; touch nothing.
- *        - `foreign` → some `kimi` we don't recognize (a user's own
- *          file) wins. Surface `logForeignKimiInTheWay` asking the
- *          user to delete or rename their own file; touch nothing.
- *        - `none` → no `kimi` on PATH at all (our shim's bin dir
- *          isn't in the shell's PATH). Surface
- *          `logNewCliNotOnPath`; touch nothing.
- *   8. Execute. The FIRST classification in PATH order that we can
- *      touch becomes `kimi-legacy` (preserves what `kimi` referred
- *      to before this install). Each subsequent shim is `unlink`ed —
- *      keeping it as a dormant duplicate adds no value. If the
- *      first shim's `kimi-legacy` target is already user-managed,
- *      we delete `kimi` anyway (still achieves takeover) and tell
- *      the user we couldn't preserve a fallback. Extension is
- *      preserved on Windows (`kimi.exe` → `kimi-legacy.exe`).
- *   9. One end-of-orchestration notice (`logMigrationDone`)
- *      summarizes every action — renames, consolidates,
- *      delete-only, deletes, and harmless blocked leftovers. The
- *      takeover-success line only fires on this path because Step 7
- *      already certified it.
- *  10. The manager completes the install with its usual summary.
+ *   5. `planTakeover`: detect EVERY previous Python `kimi-cli` shim
+ *      on the detection PATH, pre-flight classify each (no writes),
+ *      and simulate PATH resolution with the actionable shims gone:
+ *        - `own` wins → proceed.
+ *        - a blocked legacy still wins → `logMigrationBlocked`.
+ *        - a foreign `kimi` wins → `logForeignKimiInTheWay`.
+ *        - nothing resolves → `logNewCliNotOnPath`.
+ *      The abort branches touch NOTHING.
+ *   6. `executeTakeover`: the FIRST shim in PATH order that can be
+ *      preserved becomes `kimi-legacy`; each subsequent shim is
+ *      `unlink`ed. A failed preserve attempt does not promote the
+ *      next shim to deletion — it gets its own preserve attempt, so
+ *      a usable legacy fallback survives whenever one is possible.
+ *   7. `verifyTakeover`: walk the reachability PATH as it actually
+ *      is AFTER execution. Only `{ kind: 'own' }` renders the
+ *      success box (`logMigrationDone`); anything else renders
+ *      `logMigrationIncomplete` — what changed, what still blocks,
+ *      and how to finish by hand. The pre-flight simulation in
+ *      step 5 is never reported as proof of success.
+ *   8. The manager completes the install with its usual summary.
  *      This script always exits 0; any uncaught error is swallowed
  *      by the top-level `catch` so the install never fails because
  *      of the migration.
@@ -102,21 +88,20 @@
 
 import {
   detectPackageManager,
-  findFirstResolvableKimi,
   isGlobalInstall,
   ownPackageRoot,
   postinstallPaths,
 } from './postinstall/reach.mjs';
 import {
-  classifyShim,
-  deleteShim,
-  detectLegacyShims,
-  renameInPlace,
-} from './postinstall/migrate.mjs';
+  executeTakeover,
+  planTakeover,
+  verifyTakeover,
+} from './postinstall/takeover.mjs';
 import {
   logForeignKimiInTheWay,
   logMigrationBlocked,
   logMigrationDone,
+  logMigrationIncomplete,
   logNewCliNotOnPath,
   notify,
 } from './postinstall/ui.mjs';
@@ -143,124 +128,45 @@ async function main() {
   // installer's env).
   const paths = await postinstallPaths();
 
-  // Step 4: detect EVERY previous Python `kimi-cli` shim on the
-  // detection PATH. A user with both `uv tool install` and `pipx
-  // install` would have two; we must address all of them or the
-  // survivor still shadows the new CLI.
-  const detections = await detectLegacyShims(ownRoot, paths.detection);
-  if (detections.length === 0) return;
-
-  // Step 5: pre-flight classify every shim WITHOUT touching the
-  // filesystem yet. The orchestrator decides abort-or-proceed against
-  // the whole set rather than discovering mid-loop that we got partway
-  // and have to backtrack.
-  const classifications = await Promise.all(
-    detections.map(async (detection) => {
-      const c = await classifyShim(detection.shimPath);
-      return { ...c, detection };
-    }),
-  );
-
-  // Step 6: figure out what wins PATH resolution once every shim we
-  // CAN touch is treated as gone. Three possible blockers:
-  //   - a legacy shim we couldn't classify as actionable (sudo/admin
-  //     needed)
-  //   - an unrelated `kimi` we don't recognize (a user's own wrapper
-  //     script — they own the decision)
-  //   - nothing resolves (our shim isn't on PATH at all)
-  // For each we render a different notice and touch NOTHING. The
-  // common-case fourth result is "our shim wins" — we proceed.
-  const actionable = classifications.filter((c) => c.kind !== 'blocked');
-  const blocked = classifications.filter((c) => c.kind === 'blocked');
-  const actionableShimPaths = actionable.map((c) => c.shimPath);
-  const allDetectedShimPaths = classifications.map((c) => c.shimPath);
-
-  const blocker = await findFirstResolvableKimi(
+  // Step 4: plan against the whole detected shim set without writing.
+  const plan = await planTakeover(
     ownRoot,
+    paths.detection,
     paths.reachability,
-    actionableShimPaths,
-    allDetectedShimPaths,
+    process.platform,
   );
-  if (blocker.kind !== 'own') {
-    if (blocker.kind === 'blocked-legacy') {
-      logMigrationBlocked(blocked, actionable, pm);
-    } else if (blocker.kind === 'foreign') {
-      logForeignKimiInTheWay(blocker.path, pm);
-    } else {
-      // 'none' — our shim isn't on PATH at all.
-      logNewCliNotOnPath(detections[0], pm);
-    }
+  if (plan.kind === 'noop') return;
+  if (plan.kind === 'blocked') {
+    logMigrationBlocked(plan.blocked, plan.actionable, pm);
     return;
   }
-
-  // Step 7: execute. The FIRST classification in PATH order that
-  // we can touch becomes `kimi-legacy` (preserves what the user's
-  // `kimi` used to refer to). Every subsequent shim is just
-  // deleted — keeping it as a dormant duplicate adds no value.
-  const renames = [];
-  const consolidates = [];
-  const skippedForeignTarget = [];
-  const deletes = [];
-  const errors = [];
-  let preservedFirst = false;
-
-  for (const c of classifications) {
-    if (c.kind === 'blocked') continue; // already established harmless
-
-    if (!preservedFirst) {
-      preservedFirst = true;
-      if (c.kind === 'renameable') {
-        const r = await renameInPlace(c.shimPath, c.target);
-        if (r.success) {
-          renames.push(c);
-        } else {
-          errors.push({ ...c, ...r });
-        }
-        continue;
-      }
-      if (c.kind === 'consolidate') {
-        const r = await deleteShim(c.shimPath);
-        if (r.success) {
-          consolidates.push(c);
-        } else {
-          errors.push({ ...c, ...r });
-        }
-        continue;
-      }
-      if (c.kind === 'delete-only') {
-        const r = await deleteShim(c.shimPath);
-        if (r.success) {
-          skippedForeignTarget.push(c);
-        } else {
-          errors.push({ ...c, ...r });
-        }
-        continue;
-      }
-    } else {
-      // Not the first actionable shim. Just delete it.
-      const r = await deleteShim(c.shimPath);
-      if (r.success) {
-        deletes.push(c);
-      } else {
-        errors.push({ ...c, ...r });
-      }
-    }
+  if (plan.kind === 'foreign') {
+    logForeignKimiInTheWay(plan.path, pm);
+    return;
+  }
+  if (plan.kind === 'not-on-path') {
+    logNewCliNotOnPath(plan.detection, pm);
+    return;
   }
 
-  // Step 8: one notice summarizing everything that happened. The
-  // takeover-success language is only emitted when we know it's true
-  // (we already passed the reachability gate above).
-  logMigrationDone(
-    {
-      renames,
-      consolidates,
-      skippedForeignTarget,
-      deletes,
-      blockedHarmless: blocked,
-      errors,
-    },
-    pm,
+  // Step 5: execute (preserve the first preservable shim as
+  // `kimi-legacy`, delete the rest).
+  const outcomes = await executeTakeover(plan.classifications);
+
+  // Step 6: post-execution verification — the ONLY ground for a
+  // success claim. If reality diverged from the step-4 simulation
+  // (a rename failed, a new shim appeared), report it honestly.
+  const verify = await verifyTakeover(
+    ownRoot,
+    paths.reachability,
+    plan.classifications.map((c) => c.shimPath),
+    process.platform,
   );
+  if (verify.kind === 'own') {
+    logMigrationDone({ ...outcomes, blockedHarmless: plan.blocked }, pm);
+    return;
+  }
+  logMigrationIncomplete({ outcomes, verify, blocked: plan.blocked }, pm);
 }
 
 main().catch((err) => {

package/dist-web/assets/channel-5_2atmZK.js

@@ -1 +0,0 @@
-import{U as a,O as n}from"./mermaid.core-CGrLstUA.js";const t=(r,o)=>a.lang.round(n.parse(r)[o]);export{t as c};

package/dist-web/assets/classDiagram-OUVF2IWQ-CNk36E8O.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-V7JOEXUC-5w7loxVR.js";import{_ as i}from"./mermaid.core-CGrLstUA.js";import"./chunk-5VM5RSS4-K_NNkrmw.js";import"./chunk-XXDRQBXY-BwEKpC0s.js";import"./chunk-VR4S4FIN-Cp8JVohH.js";import"./chunk-32BRIVSS-0ImWpiFu.js";import"./index-CvgiEu-R.js";import"./_commonjsHelpers-CqkleIqs.js";var f={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{f as diagram};

package/dist-web/assets/classDiagram-v2-EOCWNBFH-CNk36E8O.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-V7JOEXUC-5w7loxVR.js";import{_ as i}from"./mermaid.core-CGrLstUA.js";import"./chunk-5VM5RSS4-K_NNkrmw.js";import"./chunk-XXDRQBXY-BwEKpC0s.js";import"./chunk-VR4S4FIN-Cp8JVohH.js";import"./chunk-32BRIVSS-0ImWpiFu.js";import"./index-CvgiEu-R.js";import"./_commonjsHelpers-CqkleIqs.js";var f={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{f as diagram};