fix(cli): publish downloads atomically

Author: TheodoreSpeaks

packages/sim-cli/src/commands/protocol/files-get.test.ts

@@ -1,11 +1,18 @@
-import { createWriteStream, existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import {
+  createWriteStream,
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { Writable } from 'node:stream'
 import { Command } from 'commander'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { buildGeneratedCommands } from '../../runtime/build'
-import { isTerminalSafeContentType, streamToFile } from './files-get'
+import { isTerminalSafeContentType, saveToFile, streamToFile } from './files-get'
 import { attachProtocolCommands } from './index'
 
 const { output, requestRaw } = vi.hoisted(() => ({
@@ -49,6 +56,15 @@ function bodyOf(chunks: string[]): ReadableStream<Uint8Array> {
   })
 }
 
+function failingBody(): ReadableStream<Uint8Array> {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(new TextEncoder().encode('partial'))
+      controller.error(new Error('connection lost'))
+    },
+  })
+}
+
 function program(): Command {
   const root = new Command('sim').exitOverride()
   for (const group of buildGeneratedCommands()) root.addCommand(group)
@@ -113,6 +129,34 @@ describe('streamToFile', () => {
   })
 })
 
+describe('saveToFile', () => {
+  it('preserves the original destination when a forced download fails', async () => {
+    const target = join(dir, 'out.txt')
+    writeFileSync(target, 'precious')
+
+    await expect(saveToFile(failingBody(), target, true)).rejects.toThrow(/connection lost/)
+
+    expect(readFileSync(target, 'utf8')).toBe('precious')
+  })
+
+  it('leaves no partial destination when a new download fails', async () => {
+    const target = join(dir, 'out.txt')
+
+    await expect(saveToFile(failingBody(), target, false)).rejects.toThrow(/connection lost/)
+
+    expect(existsSync(target)).toBe(false)
+  })
+
+  it('publishes a completed forced download over the original', async () => {
+    const target = join(dir, 'out.txt')
+    writeFileSync(target, 'old')
+
+    await saveToFile(bodyOf(['new']), target, true)
+
+    expect(readFileSync(target, 'utf8')).toBe('new')
+  })
+})
+
 describe('isTerminalSafeContentType', () => {
   it('accepts text formats and rejects binary or unknown formats', () => {
     expect(isTerminalSafeContentType('text/markdown; charset=utf-8')).toBe(true)

packages/sim-cli/src/commands/protocol/files-get.ts

@@ -1,5 +1,7 @@
 import { once } from 'node:events'
 import { createWriteStream, type WriteStream } from 'node:fs'
+import { link, mkdtemp, rename, rm } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
 import { Readable, type Writable } from 'node:stream'
 import { pipeline } from 'node:stream/promises'
 import type { Command } from 'commander'
@@ -8,22 +10,50 @@ import { V2_OPERATIONS } from '../../generated/v2-api'
 import { resolvePath, SimApiError } from '../../http/client'
 import { printProtocolResult } from './result'
 
+function writeFailure(path: WriteStream['path'], error: unknown): SimApiError {
+  const code = (error as NodeJS.ErrnoException).code
+  if (code === 'EEXIST') {
+    return new SimApiError(
+      `${path} already exists. Pass --force to overwrite it, or choose another output path.`,
+      0
+    )
+  }
+  return new SimApiError(`Could not write ${path}: ${(error as Error).message}`, 0)
+}
+
 /** Streams a fetch body to disk while honoring write-stream backpressure. */
 export async function streamToFile(
   body: ReadableStream<Uint8Array>,
-  file: Writable & Pick<WriteStream, 'path'>
+  file: Writable & Pick<WriteStream, 'path'>,
+  reportedPath: WriteStream['path'] = file.path
 ): Promise<void> {
   try {
     await pipeline(Readable.fromWeb(body as Parameters<typeof Readable.fromWeb>[0]), file)
   } catch (error) {
-    const code = (error as NodeJS.ErrnoException).code
-    if (code === 'EEXIST') {
-      throw new SimApiError(
-        `${file.path} already exists. Pass --force to overwrite it, or choose another output path.`,
-        0
-      )
-    }
-    throw new SimApiError(`Could not write ${file.path}: ${(error as Error).message}`, 0)
+    throw writeFailure(reportedPath, error)
+  }
+}
+
+/** Stages a complete download beside its destination before publishing it. */
+export async function saveToFile(
+  body: ReadableStream<Uint8Array>,
+  target: string,
+  force: boolean
+): Promise<void> {
+  let temporaryDirectory: string | null = null
+
+  try {
+    temporaryDirectory = await mkdtemp(join(dirname(target), '.sim-download-'))
+    const temporaryPath = join(temporaryDirectory, 'payload')
+    await streamToFile(body, createWriteStream(temporaryPath, { flags: 'wx' }), target)
+
+    if (force) await rename(temporaryPath, target)
+    else await link(temporaryPath, target)
+  } catch (error) {
+    if (error instanceof SimApiError) throw error
+    throw writeFailure(target, error)
+  } finally {
+    if (temporaryDirectory) await rm(temporaryDirectory, { recursive: true, force: true })
   }
 }
 
@@ -111,10 +141,7 @@ export function attachFileGet(files: Command): void {
 
         const target = options.outputFile
 
-        await streamToFile(
-          response.body,
-          createWriteStream(target, { flags: options.force ? 'w' : 'wx' })
-        )
+        await saveToFile(response.body, target, Boolean(options.force))
         printProtocolResult(profile.output, {
           id: fileId,
           path: target,