bug fixing import zip conventions and adding multi-select

Author: clavery

packages/b2c-tooling-sdk/src/operations/jobs/site-archive.ts

@@ -50,6 +50,14 @@ export interface SiteArchiveImportResult {
  * - A Buffer containing zip data
  * - A filename already on the instance (in Impex/src/instance/)
  *
+ * **Buffer handling:** When passing a Buffer, the `archiveName` option controls
+ * the contract:
+ * - **Without `archiveName`:** The buffer should contain archive entries without
+ *   a root directory (e.g. `libraries/mylib/library.xml`). The SDK generates
+ *   an archive name and wraps the contents under it.
+ * - **With `archiveName`:** The buffer must already be correctly structured with
+ *   `archiveName/` as the top-level directory. It is uploaded as-is.
+ *
  * @param instance - B2C instance to import to
  * @param target - Source to import (directory path, zip file path, Buffer, or remote filename)
  * @param options - Import options
@@ -64,9 +72,17 @@ export interface SiteArchiveImportResult {
  * // Import from a zip file
  * const result = await siteArchiveImport(instance, './export.zip');
  *
- * // Import from a buffer
- * const zipBuffer = await fs.promises.readFile('./export.zip');
- * const result = await siteArchiveImport(instance, zipBuffer, {
+ * // Import from a buffer (SDK wraps contents automatically)
+ * const zip = new JSZip();
+ * zip.file('libraries/mylib/library.xml', xmlContent);
+ * const buffer = await zip.generateAsync({type: 'nodebuffer'});
+ * const result = await siteArchiveImport(instance, buffer);
+ *
+ * // Import from a buffer with explicit archive name (caller owns structure)
+ * const zip = new JSZip();
+ * zip.file('my-import/libraries/mylib/library.xml', xmlContent);
+ * const buffer = await zip.generateAsync({type: 'nodebuffer'});
+ * const result = await siteArchiveImport(instance, buffer, {
  *   archiveName: 'my-import'
  * });
  *
@@ -94,13 +110,20 @@ export async function siteArchiveImport(
     zipFilename = target.remoteFilename;
     needsUpload = false;
   } else if (Buffer.isBuffer(target)) {
-    // Buffer - use provided archive name
-    if (!archiveName) {
-      throw new Error('archiveName is required when importing from a Buffer');
+    if (archiveName) {
+      // Caller provides name — buffer must already contain the correct
+      // top-level directory structure (archiveName/...).
+      const baseName = archiveName.endsWith('.zip') ? archiveName.slice(0, -4) : archiveName;
+      zipFilename = `${baseName}.zip`;
+      archiveContent = target;
+    } else {
+      // No name — SDK generates one and wraps the buffer contents under it.
+      // The buffer should contain archive entries without a root directory
+      // (e.g. libraries/mylib/library.xml, sites/RefArch/site.xml).
+      const archiveDirName = `import-${Date.now()}`;
+      zipFilename = `${archiveDirName}.zip`;
+      archiveContent = await wrapArchiveContents(target, archiveDirName, logger);
     }
-    const baseName = archiveName.endsWith('.zip') ? archiveName.slice(0, -4) : archiveName;
-    zipFilename = `${baseName}.zip`;
-    archiveContent = await ensureArchiveStructure(target, baseName, logger);
   } else {
     // File path - check if directory or zip file
     const targetPath = target as string;
@@ -238,57 +261,28 @@ async function addDirectoryToZip(zipFolder: JSZip, dirPath: string): Promise<voi
 }
 
 /**
- * Ensures a zip buffer has the correct top-level directory structure required
- * by B2C Commerce site archive import. The archive must contain a single
- * top-level directory matching the archive name.
+ * Wraps the contents of a zip buffer under a new top-level directory.
  *
- * If the zip is already correctly structured, the original buffer is returned.
- * Otherwise, the contents are re-wrapped under the expected directory name.
+ * The input buffer should contain archive entries without a root directory
+ * (e.g. `libraries/mylib/library.xml`). The output will have all entries
+ * nested under `archiveDirName/` (e.g. `archiveDirName/libraries/mylib/library.xml`).
  */
-async function ensureArchiveStructure(
+async function wrapArchiveContents(
   buffer: Buffer,
   archiveDirName: string,
   logger: ReturnType<typeof getLogger>,
 ): Promise<Buffer> {
-  let zip: JSZip;
-  try {
-    zip = await JSZip.loadAsync(buffer);
-  } catch {
-    // If we can't parse the zip, pass it through as-is
-    logger.debug('Could not parse zip buffer for structure check; passing through as-is');
-    return buffer;
-  }
-
-  // Determine the unique top-level directory names
-  const topLevelEntries = new Set<string>();
-  for (const filePath of Object.keys(zip.files)) {
-    const topLevel = filePath.split('/')[0];
-    topLevelEntries.add(topLevel);
-  }
-
-  if (topLevelEntries.size === 1 && topLevelEntries.has(archiveDirName)) {
-    return buffer; // Already correctly structured
-  }
-
-  // Re-wrap all entries under archiveDirName/
-  logger.debug(
-    {archiveDirName, topLevelEntries: [...topLevelEntries]},
-    `Re-wrapping archive contents under ${archiveDirName}/`,
-  );
+  const zip = await JSZip.loadAsync(buffer);
 
-  // When a single top-level directory exists with a different name, strip it
-  // to avoid nesting (e.g. newRoot/oldRoot/...).
-  const stripPrefix = topLevelEntries.size === 1 ? [...topLevelEntries][0] + '/' : undefined;
+  logger.debug({archiveDirName}, `Wrapping archive contents under ${archiveDirName}/`);
 
   const newZip = new JSZip();
   const rootFolder = newZip.folder(archiveDirName)!;
 
   for (const [filePath, entry] of Object.entries(zip.files)) {
     if (!entry.dir) {
       const content = await entry.async('nodebuffer');
-      const adjustedPath =
-        stripPrefix && filePath.startsWith(stripPrefix) ? filePath.slice(stripPrefix.length) : filePath;
-      rootFolder.file(adjustedPath, content);
+      rootFolder.file(filePath, content);
     }
   }
 

packages/b2c-tooling-sdk/test/operations/jobs/site-archive.test.ts

@@ -166,12 +166,25 @@ describe('operations/jobs/site-archive', () => {
       expect(uploadedZip).to.not.be.null;
     });
 
-    it('should import from a Buffer', async () => {
-      const zipBuffer = Buffer.from('PK\x03\x04test-data');
+    it('should import from a Buffer with archiveName (caller owns structure)', async () => {
+      // When archiveName is provided, the buffer is used as-is
+      const srcZip = new JSZip();
+      srcZip.file('buffer-import/libraries/mylib/library.xml', '<library/>');
+      const zipBuffer = await srcZip.generateAsync({type: 'nodebuffer'});
+
+      let uploadedZip: Buffer | null = null;
 
       server.use(
-        http.all(`${WEBDAV_BASE}/*`, async () => {
-          return new HttpResponse(null, {status: 201});
+        http.all(`${WEBDAV_BASE}/*`, async ({request}) => {
+          const url = new URL(request.url);
+          if (request.method === 'PUT' && url.pathname.includes('Impex/src/instance/')) {
+            uploadedZip = Buffer.from(await request.arrayBuffer());
+            return new HttpResponse(null, {status: 201});
+          }
+          if (request.method === 'DELETE') {
+            return new HttpResponse(null, {status: 204});
+          }
+          return new HttpResponse(null, {status: 404});
         }),
         http.post(`${OCAPI_BASE}/jobs/sfcc-site-archive-import/executions`, () => {
           return HttpResponse.json({
@@ -196,7 +209,12 @@ describe('operations/jobs/site-archive', () => {
       });
 
       expect(result.execution.id).to.equal('exec-3');
-      expect(result.archiveFilename).to.include('buffer-import');
+      expect(result.archiveFilename).to.equal('buffer-import.zip');
+
+      // Buffer should be passed through as-is (no re-wrapping)
+      const resultZip = await JSZip.loadAsync(uploadedZip!);
+      const paths = Object.keys(resultZip.files).filter((p) => !resultZip.files[p].dir);
+      expect(paths).to.include('buffer-import/libraries/mylib/library.xml');
     });
 
     it('should import from remote filename', async () => {
@@ -269,11 +287,10 @@ describe('operations/jobs/site-archive', () => {
       expect(deleteRequested).to.be.false;
     });
 
-    it('should strip single existing top-level root when re-wrapping archive', async () => {
-      // Create a zip with a different top-level directory name
+    it('should auto-wrap buffer contents when archiveName is omitted', async () => {
+      // Create a zip without a root directory (like the content FS provider does)
       const srcZip = new JSZip();
-      srcZip.file('oldRoot/meta/system-objecttype-extensions.xml', '<metadata/>');
-      srcZip.file('oldRoot/sites/RefArch/site.xml', '<site/>');
+      srcZip.file('libraries/mylib/library.xml', '<library/>');
       const zipBuffer = await srcZip.generateAsync({type: 'nodebuffer'});
 
       let uploadedZip: Buffer | null = null;
@@ -292,48 +309,34 @@ describe('operations/jobs/site-archive', () => {
         }),
         http.post(`${OCAPI_BASE}/jobs/sfcc-site-archive-import/executions`, () => {
           return HttpResponse.json({
-            id: 'exec-rewrap',
+            id: 'exec-wrap',
             execution_status: 'finished',
             exit_status: {code: 'OK'},
           });
         }),
-        http.get(`${OCAPI_BASE}/jobs/sfcc-site-archive-import/executions/exec-rewrap`, () => {
+        http.get(`${OCAPI_BASE}/jobs/sfcc-site-archive-import/executions/exec-wrap`, () => {
           return HttpResponse.json({
-            id: 'exec-rewrap',
+            id: 'exec-wrap',
             execution_status: 'finished',
             exit_status: {code: 'OK'},
             is_log_file_existing: false,
           });
         }),
       );
 
-      await siteArchiveImport(mockInstance, zipBuffer, {
-        archiveName: 'my-import',
+      const result = await siteArchiveImport(mockInstance, zipBuffer, {
         waitOptions: FAST_WAIT_OPTIONS,
       });
 
+      // SDK should auto-generate an import-{timestamp} archive name
+      expect(result.archiveFilename).to.match(/^import-\d+\.zip$/);
       expect(uploadedZip).to.not.be.null;
 
-      // Verify the uploaded archive has the correct structure:
-      // my-import/meta/... and my-import/sites/... (not my-import/oldRoot/...)
+      // Contents must be wrapped under the generated root directory
       const resultZip = await JSZip.loadAsync(uploadedZip!);
       const paths = Object.keys(resultZip.files).filter((p) => !resultZip.files[p].dir);
-      expect(paths).to.include('my-import/meta/system-objecttype-extensions.xml');
-      expect(paths).to.include('my-import/sites/RefArch/site.xml');
-      // Ensure the old root was stripped
-      const hasOldRoot = paths.some((p) => p.includes('oldRoot'));
-      expect(hasOldRoot).to.be.false;
-    });
-
-    it('should throw error when archiveName is missing for Buffer', async () => {
-      const zipBuffer = Buffer.from('PK\x03\x04test-data');
-
-      try {
-        await siteArchiveImport(mockInstance, zipBuffer);
-        expect.fail('Should have thrown error');
-      } catch (error: any) {
-        expect(error.message).to.include('archiveName is required');
-      }
+      const archiveRoot = result.archiveFilename.replace(/\.zip$/, '');
+      expect(paths).to.include(`${archiveRoot}/libraries/mylib/library.xml`);
     });
 
     it('should throw JobExecutionError when import fails', async () => {

packages/b2c-vs-extension/src/content-tree/content-commands.ts

@@ -69,7 +69,7 @@ export function registerContentCommands(
   });
 
   async function runExport(
-    node: ContentTreeItem,
+    nodes: ContentTreeItem[],
     {offline, assetsOnly}: {offline: boolean; assetsOnly: boolean},
   ): Promise<void> {
     const instance = configProvider.getInstance();
@@ -78,6 +78,16 @@ export function registerContentCommands(
       return;
     }
 
+    // All selected nodes must be from the same library
+    const libraryId = nodes[0].libraryId;
+    const isSiteLibrary = nodes[0].isSiteLibrary;
+    if (nodes.some((n) => n.libraryId !== libraryId)) {
+      vscode.window.showErrorMessage('Cannot export content from different libraries at the same time.');
+      return;
+    }
+
+    const contentIds = nodes.map((n) => n.contentId);
+
     const dialogTitle = assetsOnly ? 'Select directory for static assets' : 'Select export directory';
     const folders = await vscode.window.showOpenDialog({
       title: dialogTitle,
@@ -90,15 +100,16 @@ export function registerContentCommands(
 
     const outputPath = folders[0].fsPath;
     const label = assetsOnly ? 'static assets for' : offline ? '(without assets)' : '';
-    const progressTitle = `Exporting ${label ? `${label} ` : ''}${node.contentId}...`;
+    const itemLabel = contentIds.length === 1 ? contentIds[0] : `${contentIds.length} items`;
+    const progressTitle = `Exporting ${label ? `${label} ` : ''}${itemLabel}...`;
 
     let result;
     try {
       result = await vscode.window.withProgress(
         {location: vscode.ProgressLocation.Notification, title: progressTitle, cancellable: false},
         async (progress) => {
-          return exportContent(instance, [node.contentId], node.libraryId, outputPath, {
-            isSiteLibrary: node.isSiteLibrary,
+          return exportContent(instance, contentIds, libraryId, outputPath, {
+            isSiteLibrary,
             offline,
             onAssetProgress: (_asset, index, total) => {
               progress.report({
@@ -118,7 +129,7 @@ export function registerContentCommands(
     let msg: string;
     if (assetsOnly) {
       if (result.downloadedAssets.length === 0) {
-        vscode.window.showInformationMessage('No static assets found for this content item.');
+        vscode.window.showInformationMessage('No static assets found for the selected content.');
         return;
       }
       msg = `Downloaded ${result.downloadedAssets.length} static asset(s)`;
@@ -143,23 +154,32 @@ export function registerContentCommands(
     }
   }
 
-  const exportCmd = vscode.commands.registerCommand('b2c-dx.content.export', async (node: ContentTreeItem) => {
-    if (!node) return;
-    await runExport(node, {offline: false, assetsOnly: false});
-  });
+  const exportCmd = vscode.commands.registerCommand(
+    'b2c-dx.content.export',
+    async (node: ContentTreeItem, selectedNodes?: ContentTreeItem[]) => {
+      const nodes = selectedNodes?.length ? selectedNodes : node ? [node] : [];
+      if (!nodes.length) return;
+      await runExport(nodes, {offline: false, assetsOnly: false});
+    },
+  );
 
   const exportNoAssets = vscode.commands.registerCommand(
     'b2c-dx.content.exportNoAssets',
-    async (node: ContentTreeItem) => {
-      if (!node) return;
-      await runExport(node, {offline: true, assetsOnly: false});
+    async (node: ContentTreeItem, selectedNodes?: ContentTreeItem[]) => {
+      const nodes = selectedNodes?.length ? selectedNodes : node ? [node] : [];
+      if (!nodes.length) return;
+      await runExport(nodes, {offline: true, assetsOnly: false});
     },
   );
 
-  const exportAssets = vscode.commands.registerCommand('b2c-dx.content.exportAssets', async (node: ContentTreeItem) => {
-    if (!node) return;
-    await runExport(node, {offline: false, assetsOnly: true});
-  });
+  const exportAssets = vscode.commands.registerCommand(
+    'b2c-dx.content.exportAssets',
+    async (node: ContentTreeItem, selectedNodes?: ContentTreeItem[]) => {
+      const nodes = selectedNodes?.length ? selectedNodes : node ? [node] : [];
+      if (!nodes.length) return;
+      await runExport(nodes, {offline: false, assetsOnly: true});
+    },
+  );
 
   const filter = vscode.commands.registerCommand('b2c-dx.content.filter', async () => {
     const current = treeProvider.getFilter();

packages/b2c-vs-extension/src/content-tree/content-fs-provider.ts

@@ -4,6 +4,9 @@
  * For full license text, see the license.txt file in the repo root or http://www.apache.org/licenses/LICENSE-2.0
  */
 
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
 import type {Library, LibraryNode} from '@salesforce/b2c-tooling-sdk/operations/content';
 import {siteArchiveImport, getJobLog, JobExecutionError} from '@salesforce/b2c-tooling-sdk';
 import JSZip from 'jszip';
@@ -149,11 +152,16 @@ export class ContentFileSystemProvider implements vscode.FileSystemProvider {
       await vscode.window.withProgress(
         {location: vscode.ProgressLocation.Notification, title: `Importing content to ${libraryId}...`},
         async () => {
-          const archiveName = `content-update-${Date.now()}`;
           const zip = new JSZip();
           zip.file(archivePath, xmlContent);
           const buffer = await zip.generateAsync({type: 'nodebuffer'});
-          await siteArchiveImport(instance, buffer, {archiveName});
+
+          // DEBUG: write archive to temp dir for inspection
+          const debugPath = path.join(os.tmpdir(), `content-update-${Date.now()}.zip`);
+          await fs.promises.writeFile(debugPath, buffer);
+          console.log(`[content-fs] Debug archive written to: ${debugPath}`);
+
+          await siteArchiveImport(instance, buffer);
         },
       );
     } catch (err) {

packages/b2c-vs-extension/src/content-tree/index.ts

@@ -25,6 +25,7 @@ export function registerContentTree(context: vscode.ExtensionContext, configProv
   const treeView = vscode.window.createTreeView('b2cContentExplorer', {
     treeDataProvider: treeProvider,
     showCollapseAll: true,
+    canSelectMany: true,
   });
 
   // Show active filter in tree view description