fix(manifest): clean up import temp zip and use tmpdir

src/services/__tests__/import-manifest-service.test.ts

@@ -1,7 +1,26 @@
-import { processManifestTemplate } from 'services/import-manifest-service';
-import { loadFile } from 'utils/file-system';
+import type { ListrTaskWrapper } from 'listr2';
 
-jest.mock('utils/file-system');
+import { execute } from 'services/api-service';
+import { compressFilesToZip, readZipFileAsBuffer } from 'services/files-service';
+import * as importManifestService from 'services/import-manifest-service';
+import { processManifestTemplate, uploadManifestTsk } from 'services/import-manifest-service';
+import type { ImportCommandTasksContext } from 'types/commands/manifest-import';
+import { loadFile, saveToFile, unlink } from 'utils/file-system';
+
+jest.mock('services/api-service', () => ({
+  execute: jest.fn().mockResolvedValue({}),
+}));
+
+jest.mock('services/files-service', () => ({
+  compressFilesToZip: jest.fn(),
+  readZipFileAsBuffer: jest.fn(),
+}));
+
+jest.mock('utils/file-system', () => ({
+  loadFile: jest.fn(),
+  saveToFile: jest.fn(),
+  unlink: jest.fn(),
+}));
 
 describe('processManifestTemplate', () => {
   const mockLoadFile = loadFile as jest.MockedFunction<typeof loadFile>;
@@ -33,3 +52,55 @@ describe('processManifestTemplate', () => {
     await expect(processManifestTemplate(mockPath)).rejects.toThrow(/Missing variable/);
   });
 });
+
+describe('uploadManifestTsk', () => {
+  const mockCompressFilesToZip = compressFilesToZip as jest.MockedFunction<typeof compressFilesToZip>;
+  const mockReadZipFileAsBuffer = readZipFileAsBuffer as jest.MockedFunction<typeof readZipFileAsBuffer>;
+  const mockSaveToFile = saveToFile as jest.MockedFunction<typeof saveToFile>;
+  const mockUnlink = unlink as jest.MockedFunction<typeof unlink>;
+  const mockExecute = execute as jest.MockedFunction<typeof execute>;
+
+  const zipPath = '/tmp/mapps-compress-test.zip';
+  // biome-ignore lint/suspicious/noExplicitAny: Listr renderer generic is unused by uploadManifestTsk
+  const taskStub = { output: '', title: '' } as unknown as ListrTaskWrapper<ImportCommandTasksContext, any>;
+
+  beforeEach(() => {
+    jest.spyOn(importManifestService, 'processManifestTemplate').mockResolvedValue({ name: 'test-app' });
+    mockCompressFilesToZip.mockResolvedValue(zipPath);
+    mockReadZipFileAsBuffer.mockReturnValue(Buffer.from('zip-bytes'));
+    mockSaveToFile.mockResolvedValue(undefined);
+    mockUnlink.mockResolvedValue(undefined);
+    mockExecute.mockResolvedValue({} as Awaited<ReturnType<typeof execute>>);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('unlinks the temp zip and processed manifest after a successful upload', async () => {
+    const ctx = {
+      manifestFilePath: '/project/manifest.json',
+      allowMissingVariables: false,
+      appId: 1 as const,
+    };
+
+    await uploadManifestTsk(ctx, taskStub);
+
+    expect(mockUnlink).toHaveBeenCalledWith(zipPath);
+    expect(mockUnlink).toHaveBeenCalledWith('/project/manifest.json.processed');
+  });
+
+  it('unlinks the temp zip and processed manifest when upload fails', async () => {
+    mockExecute.mockRejectedValueOnce(new Error('upload failed'));
+
+    const ctx = {
+      manifestFilePath: '/project/manifest.json',
+      allowMissingVariables: false,
+    };
+
+    await expect(uploadManifestTsk(ctx, taskStub)).rejects.toThrow('upload failed');
+
+    expect(mockUnlink).toHaveBeenCalledWith(zipPath);
+    expect(mockUnlink).toHaveBeenCalledWith('/project/manifest.json.processed');
+  });
+});

src/services/files-service.ts

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -42,7 +43,7 @@ export const decompressZipBufferToFiles = async (buffer: Buffer, outputDir: stri
 };
 
 export const compressFilesToZip = async (files: { path: string; replaceName?: string }[]): Promise<string> => {
-  const tempZipPath = 'temp.zip';
+  const tempZipPath = path.join(os.tmpdir(), `mapps-compress-${randomUUID()}.zip`);
   const output = fs.createWriteStream(tempZipPath);
   const archive = archiver('zip', { zlib: { level: 9 } });
 

src/services/import-manifest-service.ts

@@ -17,18 +17,26 @@ export const uploadManifestTsk = async (
   ctx: ImportCommandTasksContext,
   task: ListrTaskWrapper<ImportCommandTasksContext, any>,
 ) => {
+  let zipFilePath: string | undefined;
   try {
     const processedManifest = await processManifestTemplate(ctx.manifestFilePath, ctx.allowMissingVariables);
     ctx.manifestFilePath = `${ctx.manifestFilePath}.processed`;
     await saveToFile(ctx.manifestFilePath, JSON.stringify(processedManifest));
 
     task.output = `Zipping your manifest file`;
-    const zipFilePath = await compressFilesToZip([{ path: ctx.manifestFilePath, replaceName: 'manifest.json' }]);
+    zipFilePath = await compressFilesToZip([{ path: ctx.manifestFilePath, replaceName: 'manifest.json' }]);
     const buffer = readZipFileAsBuffer(zipFilePath);
     task.output = `Uploading your app manifest`;
     await uploadZippedManifest(buffer, { appId: ctx.appId, appVersionId: ctx.appVersionId });
     task.output = `your app manifest has been uploaded successfully`;
   } finally {
+    if (zipFilePath) {
+      try {
+        await unlink(zipFilePath);
+      } catch {
+        // best-effort cleanup of temp zip
+      }
+    }
     await unlink(ctx.manifestFilePath);
   }
 };