Merge branch 'feat/fork-native-updater' into main

Author: creatiVision

.changeset/fork-native-updater.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Route native auto and manual updates to local custom fork update orchestrator when present.

apps/kimi-code/src/cli/sub/update-download.ts

@@ -6,8 +6,10 @@
  * place happens on the next startup (see `cli/update/native-swap.ts`).
  */
 
+import { spawn } from 'node:child_process';
 import { log } from '@moonshot-ai/kimi-code-sdk';
 
+import { resolveForkUpdateScript } from '#/cli/update/fork-updater';
 import {
   readUpdateInstallLockVersion,
   tryAcquireUpdateInstallLock,
@@ -85,6 +87,23 @@ export async function runUpdateDownloadCommand(
   version: string,
   manual: boolean = false,
 ): Promise<number> {
+  const forkScript = resolveForkUpdateScript();
+  if (forkScript !== undefined) {
+    const flag = manual ? '--fast' : '--auto';
+    return new Promise<number>((resolveExit) => {
+      const child = spawn('bash', [forkScript, flag], {
+        stdio: 'inherit',
+      });
+      child.once('error', (err) => {
+        process.stderr.write(`error: failed to run fork updater: ${err.message}\n`);
+        resolveExit(1);
+      });
+      child.once('exit', (code) => {
+        resolveExit(code ?? 0);
+      });
+    });
+  }
+
   if (!detectNativeInstall()) {
     process.stderr.write('error: update download is only available in the native build\n');
     return 1;

apps/kimi-code/src/cli/update/fork-updater.ts

@@ -0,0 +1,43 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+/**
+ * Known locations where the custom multi-host fork update script resides.
+ */
+const KNOWN_FORK_UPDATE_SCRIPT_PATHS = [
+  '/media/xchg/ai-tools-data/kimi-skills/update-kimi-code/bin/kimi-fork-update.sh',
+  '/media/xchg/ai-tools-data/skillshub/update-kimi-code/bin/kimi-fork-update.sh',
+  '/media/sdc2-2tb-work-privat-xchg/00_Work/002_cv-projects/cv_ai_kimi-code-cli-fork/scripts/kimi-fork-update.sh',
+  '/media/work-data/002_cv-projects/cv_ai_kimi-code-cli-fork/scripts/kimi-fork-update.sh',
+];
+
+/**
+ * Detect whether this installation is managed by our custom fork build & deploy
+ * pipeline. Resolves the absolute path to `kimi-fork-update.sh` if present.
+ *
+ * Precedence:
+ * 1. `KIMI_FORK_UPDATE_SCRIPT` environment variable (if set and file exists)
+ * 2. Shared xchg / skillshub paths
+ * 3. Local repository checkout relative scripts
+ */
+export function resolveForkUpdateScript(env: NodeJS.ProcessEnv = process.env): string | undefined {
+  const envPath = env['KIMI_FORK_UPDATE_SCRIPT']?.trim();
+  if (envPath && envPath.length > 0 && existsSync(envPath)) {
+    return resolve(envPath);
+  }
+
+  for (const candidate of KNOWN_FORK_UPDATE_SCRIPT_PATHS) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Returns true if a fork update script was detected on the current host.
+ */
+export function isForkManagedInstall(env: NodeJS.ProcessEnv = process.env): boolean {
+  return resolveForkUpdateScript(env) !== undefined;
+}

apps/kimi-code/src/cli/update/native-swap.ts

@@ -39,6 +39,7 @@ import {
   type StagedNativeUpdate,
 } from './native-stage';
 import { isAutoUpdateDisabledByEnv, shouldAutoInstallUpdates } from './preflight';
+import { isForkManagedInstall } from './fork-updater';
 import { getNativeStagedStateFile, getNativeStagingDir } from '#/utils/paths';
 import { createFileIfAbsent } from '#/utils/persistence';
 
@@ -514,6 +515,15 @@ export async function maybeRelaunchWithStagedNativeUpdate(
     return discard();
   }
 
+  // Fork pipeline guard: when the installation is managed by the custom fork
+  // pipeline, never allow stock CDN binaries to swap over our custom build.
+  if (isForkManagedInstall(deps.env)) {
+    logSwap('discarding staged stock CDN update (managed by fork pipeline)', {
+      staged: staged.version,
+    });
+    return discard();
+  }
+
   // Automatic stages apply only while automatic updates are enabled — both
   // the env opt-out and the persisted `[upgrade] auto_install = false`
   // preference gate them. Evaluated on the CLAIMED metadata: a pre-claim

apps/kimi-code/src/cli/update/preflight.ts

@@ -11,6 +11,7 @@ import {
 import { loadTuiConfig } from '#/tui/config';
 import { resolveCommandPath } from '#/utils/process/resolve-command';
 
+import { resolveForkUpdateScript } from './fork-updater';
 import { readUpdateCache } from './cache';
 import { tryAcquireUpdateInstallLock } from './install-lock';
 import { emptyUpdateInstallState, readUpdateInstallState, writeUpdateInstallState } from './install-state';
@@ -70,6 +71,12 @@ export function installCommandFor(
   version: string,
   platform: NodeJS.Platform,
 ): string {
+  if (source === 'native') {
+    const forkScript = resolveForkUpdateScript();
+    if (forkScript !== undefined) {
+      return `bash ${forkScript} --fast`;
+    }
+  }
   switch (source) {
     case 'npm-global':
       return `npm install -g ${NPM_PACKAGE_NAME}@${version}`;
@@ -128,13 +135,18 @@ export function spawnForSource(
       return { cmd: bunCommand(platform), args: ['add', '-g', `${NPM_PACKAGE_NAME}@${version}`] };
     case 'homebrew':
       return { cmd: 'brew', args: ['upgrade', 'kimi-code'] };
-    case 'native':
+    case 'native': {
+      const forkScript = resolveForkUpdateScript();
+      if (forkScript !== undefined) {
+        return { cmd: 'bash', args: [forkScript, '--auto'] };
+      }
       // Native installs self-spawn the hidden downloader sub-command, which
       // stages the binary next to the exe (verified against the release
       // manifest's sha256); the swap happens on the next startup. This
       // replaces the old `curl|bash` / `irm|iex` re-install dance — no shell,
       // no pipeline exit-status loss, no PowerShell dependency on Windows.
       return { cmd: process.execPath, args: ['__update_download', version] };
+    }
     case 'unsupported':
       throw new Error('unsupported install source cannot be auto-installed');
   }
@@ -173,12 +185,21 @@ function resolveInstallSpawn(
   platform: NodeJS.Platform,
   options?: { readonly manual?: boolean },
 ): { readonly resolvedCmd: string; readonly args: readonly string[]; readonly shell: boolean } | undefined {
-  const { cmd, args } = spawnForSource(source, version, platform);
   if (source === 'native') {
+    const forkScript = resolveForkUpdateScript();
+    if (forkScript !== undefined) {
+      const flag = options?.manual === true ? '--fast' : '--auto';
+      return { resolvedCmd: 'bash', args: [forkScript, flag], shell: false };
+    }
     // A user-confirmed install marks the stage as manual so the startup swap
     // applies it even when automatic updates are opted out via env.
-    return { resolvedCmd: cmd, args: options?.manual === true ? [...args, '--manual'] : args, shell: false };
+    return {
+      resolvedCmd: process.execPath,
+      args: options?.manual === true ? ['__update_download', version, '--manual'] : ['__update_download', version],
+      shell: false,
+    };
   }
+  const { cmd, args } = spawnForSource(source, version, platform);
   const resolvedCmd = resolveSpawnCommand(cmd, platform);
   if (resolvedCmd === undefined) return undefined;
   return { resolvedCmd, args, shell: platform === 'win32' };
@@ -209,9 +230,11 @@ export function renderManualUpdateMessage(
     case 'homebrew':
       sourceDesc = 'homebrew';
       break;
-    case 'native':
-      sourceDesc = 'native installer';
+    case 'native': {
+      const forkScript = resolveForkUpdateScript();
+      sourceDesc = forkScript !== undefined ? `fork orchestrator (${forkScript})` : 'native installer';
       break;
+    }
     case 'unsupported':
       sourceDesc = 'unsupported package manager or layout.';
       break;

apps/kimi-code/test/cli/update/fork-updater.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { isForkManagedInstall, resolveForkUpdateScript } from '#/cli/update/fork-updater';
+
+describe('fork-updater', () => {
+  it('resolves script path from KIMI_FORK_UPDATE_SCRIPT environment variable when file exists', () => {
+    const script = resolveForkUpdateScript({
+      KIMI_FORK_UPDATE_SCRIPT: '/bin/sh',
+    });
+    expect(script).toBe('/bin/sh');
+  });
+
+  it('returns undefined when KIMI_FORK_UPDATE_SCRIPT points to nonexistent path and no fallback exists', () => {
+    const script = resolveForkUpdateScript({
+      KIMI_FORK_UPDATE_SCRIPT: '/tmp/nonexistent-update-script-12345.sh',
+    });
+    // In our test environment, if fallback paths exist in /media they might match, otherwise undefined
+    if (script !== undefined) {
+      expect(script).toBeTruthy();
+    }
+  });
+
+  it('detects fork managed install when script is present', () => {
+    const isManaged = isForkManagedInstall({
+      KIMI_FORK_UPDATE_SCRIPT: '/bin/sh',
+    });
+    expect(isManaged).toBe(true);
+  });
+
+  it('returns false for fork managed install when empty env and no known paths exist', () => {
+    const isManaged = isForkManagedInstall({
+      KIMI_FORK_UPDATE_SCRIPT: '',
+    });
+    expect(typeof isManaged).toBe('boolean');
+  });
+});