fix review findings: config reset, writeFile flags, archive stripping, plugin opts

- Refresh content tree on config reset (matching webdav-tree pattern)
- Honour create/overwrite flags in WebDAV writeFile per VS Code contract
- Strip single existing top-level root in ensureArchiveStructure to avoid
  double-nesting when re-wrapping site archives
- Add accountManagerHost to PluginHookOptions and resolveOptions
- Use Uri.from instead of Uri.parse for correct special-char handling
- Guard applyMiddleware against duplicate registration

Author: clavery

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

@@ -276,13 +276,19 @@ async function ensureArchiveStructure(
     `Re-wrapping archive contents under ${archiveDirName}/`,
   );
 
+  // 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;
+
   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');
-      rootFolder.file(filePath, content);
+      const adjustedPath =
+        stripPrefix && filePath.startsWith(stripPrefix) ? filePath.slice(stripPrefix.length) : filePath;
+      rootFolder.file(adjustedPath, content);
     }
   }
 

packages/b2c-tooling-sdk/src/plugins/manager.ts

@@ -25,6 +25,8 @@ export interface PluginHookOptions {
   instance?: string;
   /** Explicit config file path (if known) */
   configPath?: string;
+  /** Account Manager host override */
+  accountManagerHost?: string;
   /** CLI flags or equivalent options */
   flags?: Record<string, unknown>;
 }
@@ -38,6 +40,7 @@ export interface PluginHookOptions {
  */
 export class B2CPluginManager {
   private _initialized = false;
+  private _middlewareApplied = false;
   private _pluginNames: string[] = [];
   private _sourcesBefore: ConfigSource[] = [];
   private _sourcesAfter: ConfigSource[] = [];
@@ -84,6 +87,7 @@ export class B2CPluginManager {
             resolveOptions: {
               instance: hookOptions?.instance,
               configPath: hookOptions?.configPath,
+              accountManagerHost: hookOptions?.accountManagerHost,
             },
           };
           const result = await invokeHook<ConfigSourcesHookResult>(absPath, context, options, this.logger);
@@ -173,6 +177,9 @@ export class B2CPluginManager {
    * Registers collected middleware providers with the global registries.
    */
   applyMiddleware(): void {
+    if (this._middlewareApplied) return;
+    this._middlewareApplied = true;
+
     for (const provider of this._httpMiddleware) {
       globalMiddlewareRegistry.register(provider);
       this.logger?.debug(`Registered HTTP middleware provider: ${provider.name}`);

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

@@ -14,6 +14,7 @@ import * as path from 'node:path';
 import {WebDavClient} from '../../../src/clients/webdav.js';
 import {createOcapiClient} from '../../../src/clients/ocapi.js';
 import {MockAuthStrategy} from '../../helpers/mock-auth.js';
+import JSZip from 'jszip';
 import {
   siteArchiveImport,
   siteArchiveExport,
@@ -268,6 +269,62 @@ 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
+      const srcZip = new JSZip();
+      srcZip.file('oldRoot/meta/system-objecttype-extensions.xml', '<metadata/>');
+      srcZip.file('oldRoot/sites/RefArch/site.xml', '<site/>');
+      const zipBuffer = await srcZip.generateAsync({type: 'nodebuffer'});
+
+      let uploadedZip: Buffer | null = null;
+
+      server.use(
+        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({
+            id: 'exec-rewrap',
+            execution_status: 'finished',
+            exit_status: {code: 'OK'},
+          });
+        }),
+        http.get(`${OCAPI_BASE}/jobs/sfcc-site-archive-import/executions/exec-rewrap`, () => {
+          return HttpResponse.json({
+            id: 'exec-rewrap',
+            execution_status: 'finished',
+            exit_status: {code: 'OK'},
+            is_log_file_existing: false,
+          });
+        }),
+      );
+
+      await siteArchiveImport(mockInstance, zipBuffer, {
+        archiveName: 'my-import',
+        waitOptions: FAST_WAIT_OPTIONS,
+      });
+
+      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/...)
+      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');
 

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

@@ -37,7 +37,7 @@ function parseContentUri(uri: vscode.Uri): ParsedContentUri {
 
 export function contentItemUri(libraryId: string, isSiteLibrary: boolean, contentId: string): vscode.Uri {
   const uriPath = isSiteLibrary ? `/site/${libraryId}/${contentId}.xml` : `/${libraryId}/${contentId}.xml`;
-  return vscode.Uri.parse(`${CONTENT_SCHEME}:${uriPath}`);
+  return vscode.Uri.from({scheme: CONTENT_SCHEME, path: uriPath});
 }
 
 /**

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

@@ -35,5 +35,10 @@ export function registerContentTree(context: vscode.ExtensionContext, configProv
 
   const commandDisposables = registerContentCommands(context, contentConfig, treeProvider, fsProvider);
 
+  configProvider.onDidReset(() => {
+    contentConfig.clearCache();
+    treeProvider.refresh();
+  });
+
   context.subscriptions.push(fsRegistration, treeView, ...commandDisposables);
 }

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

@@ -52,7 +52,7 @@ function uriToWebdavPath(uri: vscode.Uri): string {
 
 /** Build a b2c-webdav URI from a WebDAV path. */
 export function webdavPathToUri(webdavPath: string): vscode.Uri {
-  return vscode.Uri.parse(`${WEBDAV_SCHEME}:/${webdavPath}`);
+  return vscode.Uri.from({scheme: WEBDAV_SCHEME, path: `/${webdavPath}`});
 }
 
 function isStale(timestamp: number): boolean {
@@ -203,17 +203,28 @@ export class WebDavFileSystemProvider implements vscode.FileSystemProvider {
     }
   }
 
-  async writeFile(
-    uri: vscode.Uri,
-    content: Uint8Array,
-    _options: {create: boolean; overwrite: boolean},
-  ): Promise<void> {
+  async writeFile(uri: vscode.Uri, content: Uint8Array, options: {create: boolean; overwrite: boolean}): Promise<void> {
     const webdavPath = uriToWebdavPath(uri);
     const instance = this.configProvider.getInstance();
     if (!instance) {
       throw vscode.FileSystemError.Unavailable('No B2C Commerce instance configured');
     }
 
+    // Honour create/overwrite flags per VS Code FileSystemProvider contract
+    let exists = false;
+    try {
+      await this.stat(uri);
+      exists = true;
+    } catch {
+      // stat throws FileNotFound when file doesn't exist
+    }
+    if (exists && !options.overwrite) {
+      throw vscode.FileSystemError.FileExists(uri);
+    }
+    if (!exists && !options.create) {
+      throw vscode.FileSystemError.FileNotFound(uri);
+    }
+
     try {
       const ext = path.extname(webdavPath).toLowerCase();
       const contentType = MIME_BY_EXT[ext];