[ai-assisted] test: add recovery-path coverage and reduce manifest churn

Author: JooHyung Park

runtime/llama/runtime-manifest.json

@@ -24,7 +24,11 @@
       "assetName": "llama-b8855-bin-macos-x64.tar.gz",
       "assetUrl": "https://github.com/ggml-org/llama.cpp/releases/download/b8855/llama-b8855-bin-macos-x64.tar.gz",
       "assetSha256": "5f229b3a815280737f2e8b93b49d8ca9c6d0d87bddb280c69266ea1a06daa3e2",
-      "lastResolvedAt": "2026-04-20T15:20:36.252Z"
+      "lastResolvedAt": "2026-04-20T15:20:36.252Z",
+      "binaryRelativePath": "bin/darwin-x64/llama-server",
+      "binarySha256": "9351344633ce46a57be2c5ff40d2e06e51a0576c3e5c3c1f5780a7d36360d2c4",
+      "runtimeDependencyCount": 24,
+      "preparedAt": "2026-04-20T16:17:58.902Z"
     },
     "windows-x64": {
       "assetName": "llama-b8855-bin-win-cpu-x64.zip",
@@ -42,5 +46,5 @@
       "lastResolvedAt": "2026-04-20T15:20:36.252Z"
     }
   },
-  "updatedAt": "2026-04-20T15:36:51.802Z"
+  "updatedAt": "2026-04-20T16:17:58.903Z"
 }

scripts/prepare-llama-runtime.mjs

@@ -280,6 +280,7 @@ async function main() {
   await mkdir(CACHE_ROOT, { recursive: true });
 
   const manifest = await loadManifest();
+  let manifestDirty = false;
   const shouldRefresh = options.refresh || !manifest.release;
 
   if (shouldRefresh) {
@@ -308,8 +309,7 @@ async function main() {
         lastResolvedAt: new Date().toISOString(),
       };
     }
-    manifest.updatedAt = new Date().toISOString();
-    await saveManifest(manifest);
+    manifestDirty = true;
   }
 
   for (const target of targets) {
@@ -353,22 +353,38 @@ async function main() {
       await chmod(binaryDestination, 0o755);
     }
     const dependencyCount = await copyRuntimeDependencies(binarySource, outputDir);
-
     const binarySha = await computeSha256(binaryDestination);
-    manifest.platforms[target] = {
-      ...manifest.platforms[target],
-      binaryRelativePath: relative(RUNTIME_ROOT, binaryDestination).replace(/\\/g, '/'),
+
+    const binaryRelativePath = relative(RUNTIME_ROOT, binaryDestination).replace(/\\/g, '/');
+    const previousEntry = manifest.platforms[target] || {};
+    const preservePreparedAt =
+      previousEntry.binarySha256 === binarySha
+      && previousEntry.binaryRelativePath === binaryRelativePath
+      && previousEntry.runtimeDependencyCount === dependencyCount;
+    const preparedAt = preservePreparedAt
+      ? (previousEntry.preparedAt || new Date().toISOString())
+      : new Date().toISOString();
+
+    const nextEntry = {
+      ...previousEntry,
+      binaryRelativePath,
       binarySha256: binarySha,
       runtimeDependencyCount: dependencyCount,
-      preparedAt: new Date().toISOString(),
+      preparedAt,
     };
+    if (JSON.stringify(previousEntry) !== JSON.stringify(nextEntry)) {
+      manifest.platforms[target] = nextEntry;
+      manifestDirty = true;
+    }
 
     const size = (await stat(binaryDestination)).size;
     console.log(`[prepare-llama-runtime] prepared ${target}: ${binaryDestination} (${size} bytes, deps=${dependencyCount})`);
   }
 
-  manifest.updatedAt = new Date().toISOString();
-  await saveManifest(manifest);
+  if (manifestDirty) {
+    manifest.updatedAt = new Date().toISOString();
+    await saveManifest(manifest);
+  }
 }
 
 main().catch((error) => {

src/main/assistant/ModelInstallService.ts

@@ -28,6 +28,11 @@ import type {
   AssistantModelDownloadState,
   AssistantModelUploadRequest,
 } from '../../shared/types';
+import {
+  isResumeNotSatisfiable,
+  resolveCorruptedArtifactCleanupPaths,
+  resolveResumePreparation,
+} from './modelDownloadRecovery';
 
 interface DownloadSnapshot {
   state: AssistantModelDownloadState;
@@ -479,34 +484,34 @@ export class ModelInstallService {
       unlinkSync(finalPath);
     }
 
-    let existingPartBytes = existsSync(partPath) ? statSync(partPath).size : 0;
-    if (existingPartBytes >= artifact.expectedSizeBytes) {
+    const existingPartBytes = existsSync(partPath) ? statSync(partPath).size : 0;
+    const resumePreparation = resolveResumePreparation(existingPartBytes, artifact.expectedSizeBytes);
+    if (resumePreparation.resetPart) {
       this.safeDeleteFile(partPath);
-      existingPartBytes = 0;
     }
 
     const headers: Record<string, string> = {};
-    if (existingPartBytes > 0) {
-      headers.Range = `bytes=${existingPartBytes}-`;
+    if (resumePreparation.rangeHeader) {
+      headers.Range = resumePreparation.rangeHeader;
     }
     const response = await fetch(artifact.url, {
       method: 'GET',
       ...(Object.keys(headers).length > 0 ? { headers } : {}),
       signal,
     });
-    if (response.status === 416) {
+    if (isResumeNotSatisfiable(response.status)) {
       this.safeDeleteFile(partPath);
       throw new Error(`Failed to resume download for ${artifact.fileName}: HTTP 416`);
     }
     if (!response.ok && response.status !== 206) {
       throw new Error(`Failed to download ${artifact.fileName}: HTTP ${response.status}`);
     }
 
-    const appendMode = response.status === 206 && existingPartBytes > 0;
+    const appendMode = response.status === 206 && resumePreparation.nextPartBytes > 0;
     const fileStream = createWriteStream(partPath, { flags: appendMode ? 'a' : 'w' });
 
     if (this.activeDownloadTask && appendMode) {
-      this.activeDownloadTask.downloadedBytes += existingPartBytes;
+      this.activeDownloadTask.downloadedBytes += resumePreparation.nextPartBytes;
       this.updateDownloadProgress({ currentFile: artifact.fileName });
     }
 
@@ -556,8 +561,9 @@ export class ModelInstallService {
 
   private cleanupCorruptedArtifact(artifact: DownloadArtifact): void {
     const partPath = this.getPartPath(artifact.fileName);
-    this.safeDeleteFile(partPath);
-    this.safeDeleteFile(artifact.destinationPath);
+    for (const cleanupPath of resolveCorruptedArtifactCleanupPaths(partPath, artifact.destinationPath)) {
+      this.safeDeleteFile(cleanupPath);
+    }
   }
 
   private safeDeleteFile(filePath: string): void {

src/main/assistant/modelDownloadRecovery.test.ts

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2026 Grabtaxi Holdings Pte Ltd (GRAB), All rights reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in the LICENSE file
+ */
+
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  isResumeNotSatisfiable,
+  resolveCorruptedArtifactCleanupPaths,
+  resolveResumePreparation,
+} from './modelDownloadRecovery';
+
+test('resolveResumePreparation keeps resumable partial downloads', () => {
+  const result = resolveResumePreparation(1024, 4096);
+  assert.equal(result.resetPart, false);
+  assert.equal(result.nextPartBytes, 1024);
+  assert.equal(result.rangeHeader, 'bytes=1024-');
+});
+
+test('resolveResumePreparation resets oversized or complete partial files', () => {
+  const equalSize = resolveResumePreparation(4096, 4096);
+  assert.equal(equalSize.resetPart, true);
+  assert.equal(equalSize.nextPartBytes, 0);
+  assert.equal(equalSize.rangeHeader, null);
+
+  const oversized = resolveResumePreparation(8192, 4096);
+  assert.equal(oversized.resetPart, true);
+  assert.equal(oversized.nextPartBytes, 0);
+  assert.equal(oversized.rangeHeader, null);
+});
+
+test('isResumeNotSatisfiable only matches HTTP 416', () => {
+  assert.equal(isResumeNotSatisfiable(416), true);
+  assert.equal(isResumeNotSatisfiable(206), false);
+  assert.equal(isResumeNotSatisfiable(500), false);
+});
+
+test('resolveCorruptedArtifactCleanupPaths deduplicates paths', () => {
+  const paths = resolveCorruptedArtifactCleanupPaths('/tmp/a.part', '/tmp/a.part');
+  assert.deepEqual(paths, ['/tmp/a.part']);
+});

src/main/assistant/modelDownloadRecovery.ts

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2026 Grabtaxi Holdings Pte Ltd (GRAB), All rights reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in the LICENSE file
+ */
+
+export interface ResumePreparation {
+  resetPart: boolean;
+  nextPartBytes: number;
+  rangeHeader: string | null;
+}
+
+export function resolveResumePreparation(existingPartBytes: number, expectedSizeBytes: number): ResumePreparation {
+  if (existingPartBytes >= expectedSizeBytes) {
+    return {
+      resetPart: true,
+      nextPartBytes: 0,
+      rangeHeader: null,
+    };
+  }
+
+  return {
+    resetPart: false,
+    nextPartBytes: existingPartBytes,
+    rangeHeader: existingPartBytes > 0 ? `bytes=${existingPartBytes}-` : null,
+  };
+}
+
+export function isResumeNotSatisfiable(status: number): boolean {
+  return status === 416;
+}
+
+export function resolveCorruptedArtifactCleanupPaths(partPath: string, destinationPath: string): string[] {
+  return Array.from(new Set([partPath, destinationPath]));
+}