diff --git a/.github/workflows/e2e-tests.yml b/.github/workflows/e2e-tests.yml
index 153ffe73..e70fc577 100644
--- a/.github/workflows/e2e-tests.yml
+++ b/.github/workflows/e2e-tests.yml
@@ -51,8 +51,9 @@ jobs:
           TEST_REALM: ${{ vars.TEST_REALM }}
           SFCC_ACCOUNT_MANAGER_HOST: ${{ vars.SFCC_ACCOUNT_MANAGER_HOST }}
           SFCC_SANDBOX_API_HOST: ${{ vars.SFCC_SANDBOX_API_HOST }}
+          SFCC_SHORTCODE: ${{ vars.SFCC_SHORTCODE }}
         run: |
-          if [ -n "$SFCC_CLIENT_ID" ] && [ -n "$SFCC_CLIENT_SECRET" ] && [ -n "$TEST_REALM" ] && [ -n "$SFCC_ACCOUNT_MANAGER_HOST" ] && [ -n "$SFCC_SANDBOX_API_HOST" ]; then
+          if [ -n "$SFCC_CLIENT_ID" ] && [ -n "$SFCC_CLIENT_SECRET" ] && [ -n "$TEST_REALM" ] && [ -n "$SFCC_ACCOUNT_MANAGER_HOST" ] && [ -n "$SFCC_SANDBOX_API_HOST" ] && [ -n "$SFCC_SHORTCODE" ]; then
             echo "has-secrets=true" >> $GITHUB_OUTPUT
           else
             echo "has-secrets=false" >> $GITHUB_OUTPUT
@@ -61,6 +62,7 @@ jobs:
             echo "  - TEST_REALM (var): ${TEST_REALM:+✓}" >> $GITHUB_STEP_SUMMARY
             echo "  - SFCC_ACCOUNT_MANAGER_HOST (var): ${SFCC_ACCOUNT_MANAGER_HOST:+✓}" >> $GITHUB_STEP_SUMMARY
             echo "  - SFCC_SANDBOX_API_HOST (var): ${SFCC_SANDBOX_API_HOST:+✓}" >> $GITHUB_STEP_SUMMARY
+            echo "  - SFCC_SHORTCODE (var): ${SFCC_SHORTCODE:+✓}" >> $GITHUB_STEP_SUMMARY
           fi
       - name: Setup pnpm
         uses: pnpm/action-setup@v4
@@ -97,6 +99,7 @@ jobs:
           SFCC_ACCOUNT_MANAGER_HOST: ${{ inputs.sfcc_account_manager_host || vars.SFCC_ACCOUNT_MANAGER_HOST }}
           SFCC_SANDBOX_API_HOST: ${{ inputs.sfcc_sandbox_api_host || vars.SFCC_SANDBOX_API_HOST }}
           TEST_REALM: ${{ inputs.test_realm || vars.TEST_REALM }}
+          SFCC_SHORTCODE: ${{ vars.SFCC_SHORTCODE }}
           # Test configuration
           NODE_ENV: test
           SFCC_LOG_LEVEL: silent
diff --git a/packages/b2c-cli/eslint.config.mjs b/packages/b2c-cli/eslint.config.mjs
index 6a734963..36787267 100644
--- a/packages/b2c-cli/eslint.config.mjs
+++ b/packages/b2c-cli/eslint.config.mjs
@@ -19,7 +19,12 @@ export default [
   // node_modules must be explicitly ignored because the .gitignore pattern only covers
   // packages/b2c-cli/node_modules, not the monorepo root node_modules
   {
-    ignores: ['**/node_modules/**', 'test/functional/fixtures/**/*.js', '**/node_modules/marked-terminal/**'],
+    ignores: [
+      '**/node_modules/**',
+      'test/functional/fixtures/**/*.js',
+      '**/node_modules/marked-terminal/**',
+      'test/functional/fixtures/**/*.js',
+    ],
   },
   includeIgnoreFile(gitignorePath),
   ...oclif,
@@ -35,6 +40,10 @@ export default [
     },
     rules: {
       'header/header': ['error', 'block', copyrightHeader],
+      // Avoid eslint-plugin-import parsing dependency entrypoints (can stack overflow on CJS bundles)
+      'import/namespace': 'off',
+      'import/no-named-as-default-member': 'off',
+      'import/no-named-as-default': 'off',
       ...sharedRules,
       ...oclifRules,
     },
diff --git a/packages/b2c-cli/package.json b/packages/b2c-cli/package.json
index 840ef411..24a94a1a 100644
--- a/packages/b2c-cli/package.json
+++ b/packages/b2c-cli/package.json
@@ -265,7 +265,14 @@
     "test:ci": "c8 env OCLIF_TEST_ROOT=. mocha --forbid-only --exclude \"test/functional/e2e/**\" --reporter json --reporter-option output=test-results.json \"test/**/*.test.ts\"",
     "test:unit": "env OCLIF_TEST_ROOT=. mocha --forbid-only --exclude \"test/functional/e2e/**\" \"test/**/*.test.ts\"",
     "test:agent": "env OCLIF_TEST_ROOT=. mocha --forbid-only --reporter min --exclude \"test/functional/e2e/**\" \"test/**/*.test.ts\"",
-    "test:e2e": "env OCLIF_TEST_ROOT=. mocha --forbid-only --reporter json --reporter-option output=test-results.json \"test/functional/e2e/**/*.test.ts\"",
+    "test:e2e": "env TEST_USE_SHARED_SANDBOX=true OCLIF_TEST_ROOT=. mocha --forbid-only --config test/functional/e2e/.mocharc.json \"test/functional/e2e/**/*.test.ts\"",
+    "test:e2e:auth": "env OCLIF_TEST_ROOT=. mocha --forbid-only \"test/functional/e2e/auth-token.test.ts\"",
+    "test:e2e:code": "env OCLIF_TEST_ROOT=. mocha --forbid-only \"test/functional/e2e/code-lifecycle.test.ts\"",
+    "test:e2e:jobs": "env OCLIF_TEST_ROOT=. mocha --forbid-only \"test/functional/e2e/job-execution.test.ts\"",
+    "test:e2e:ods": "env OCLIF_TEST_ROOT=. mocha --forbid-only \"test/functional/e2e/ods-lifecycle.test.ts\"",
+    "test:e2e:sites": "env OCLIF_TEST_ROOT=. mocha --forbid-only \"test/functional/e2e/sites-operations.test.ts\"",
+    "test:e2e:slas": "env OCLIF_TEST_ROOT=. mocha --forbid-only \"test/functional/e2e/slas-lifecycle.test.ts\"",
+    "test:e2e:webdav": "env OCLIF_TEST_ROOT=. mocha --forbid-only \"test/functional/e2e/webdav-operations.test.ts\"",
     "coverage": "c8 report",
     "version": "oclif readme && git add README.md",
     "dev": "node ./bin/dev.js"
diff --git a/packages/b2c-cli/test/functional/e2e/.mocharc.json b/packages/b2c-cli/test/functional/e2e/.mocharc.json
new file mode 100644
index 00000000..66e1e500
--- /dev/null
+++ b/packages/b2c-cli/test/functional/e2e/.mocharc.json
@@ -0,0 +1,11 @@
+{
+  "node-option": ["import=tsx"],
+  "timeout": 30000,
+  "slow": 5000,
+  "reporter": "spec",
+  "color": true,
+  "bail": false,
+  "require": [
+    "./test/functional/e2e/hooks.ts"
+  ]
+}
diff --git a/packages/b2c-cli/test/functional/e2e/auth-token.test.ts b/packages/b2c-cli/test/functional/e2e/auth-token.test.ts
new file mode 100644
index 00000000..d7892e72
--- /dev/null
+++ b/packages/b2c-cli/test/functional/e2e/auth-token.test.ts
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) 2025, Salesforce, Inc.
+ * SPDX-License-Identifier: Apache-2
+ * For full license text, see the license.txt file in the repo root or http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+import {expect} from 'chai';
+import {execa} from 'execa';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * E2E Tests for Authentication Token Generation
+ */
+describe('Auth Token E2E Tests', function () {
+  this.timeout(120_000); // 2 minutes
+  this.retries(2);
+
+  const CLI_BIN = path.resolve(__dirname, '../../../bin/run.js');
+
+  before(function () {
+    if (!process.env.SFCC_CLIENT_ID || !process.env.SFCC_CLIENT_SECRET) {
+      this.skip();
+    }
+  });
+
+  async function runCLI(args: string[], env?: Record<string, string>) {
+    const result = await execa('node', [CLI_BIN, ...args], {
+      env: {
+        ...process.env,
+        ...env,
+        SFCC_LOG_LEVEL: 'silent',
+      },
+      reject: false,
+    });
+    return result;
+  }
+
+  function decodeJWT(token: string): Record<string, unknown> {
+    const parts = token.split('.');
+    if (parts.length !== 3) {
+      throw new Error('Invalid JWT format');
+    }
+    const payload = Buffer.from(parts[1], 'base64').toString('utf8');
+    return JSON.parse(payload);
+  }
+
+  it('should generate a valid OAuth token with correct format, scopes, and expiration', async function () {
+    const result = await runCLI(['auth:token', '--json']);
+    expect(result.exitCode).to.equal(0, `Token generation failed: ${result.stderr}`);
+    expect(result.stdout).to.not.be.empty;
+
+    const response = JSON.parse(result.stdout);
+    expect(response).to.be.an('object');
+    expect(response.accessToken).to.be.a('string').and.not.be.empty;
+    expect(response.expires).to.be.a('string');
+    expect(response.scopes).to.be.an('array').that.is.not.empty;
+
+    // Validate JWT format
+    const payload = decodeJWT(response.accessToken);
+    expect(payload.sub).to.exist;
+    expect(payload.exp).to.exist;
+
+    // Validate expiration
+    const now = Math.floor(Date.now() / 1000);
+    expect(payload.exp as number).to.be.greaterThan(now);
+    expect((payload.exp as number) - now).to.be.lessThan(86_400);
+
+    // Validate expires field matches exp approximately
+    const expiresDate = new Date(response.expires).getTime() / 1000;
+    expect(Math.abs(expiresDate - (payload.exp as number))).to.be.lessThan(10);
+
+    // Validate scopes
+    expect(payload.scope, 'Token should contain scope claim').to.exist;
+    const tokenScopes = Array.isArray(payload.scope) ? payload.scope : (payload.scope as string).split(' ');
+    for (const s of response.scopes as string[]) {
+      expect(tokenScopes, `Token should include scope "${s}"`).to.include(s);
+    }
+  });
+
+  describe('Generate Token With Additional Scopes', function () {
+    it('should generate a token with allowed additional scopes', async function () {
+      // Use only scopes your client actually has
+      const extraScopes = ['profile', 'roles'];
+
+      const result = await runCLI(['auth:token', '--scope', extraScopes.join(','), '--json']);
+
+      expect(result.exitCode).to.equal(0, `Token generation with extra scopes failed: ${result.stderr}`);
+
+      const response = JSON.parse(result.stdout);
+      const accessToken = response.accessToken as string;
+      expect(accessToken).to.be.a('string').and.not.be.empty;
+      expect(response.scopes).to.include.members(extraScopes);
+
+      const payload = decodeJWT(accessToken);
+      expect(payload.scope).to.exist;
+
+      const tokenScopes = Array.isArray(payload.scope) ? payload.scope : (payload.scope as string).split(' ');
+
+      for (const s of extraScopes) {
+        expect(tokenScopes, `Token should include scope "${s}"`).to.include(s);
+      }
+
+      console.log(`Token with additional scopes: ${tokenScopes.join(', ')}`);
+    });
+  });
+
+  describe('Invalid Credentials', function () {
+    it('should fail with invalid client credentials', async function () {
+      const result = await runCLI(['auth:token', '--json'], {
+        SFCC_CLIENT_ID: 'invalid-client-id',
+        SFCC_CLIENT_SECRET: 'invalid-client-secret',
+      });
+
+      expect(result.exitCode).to.not.equal(0);
+      expect(result.stderr).to.not.be.empty;
+      expect(result.stderr).to.match(/401|unauthorized|invalid.*client/i);
+    });
+  });
+
+  describe('JSON Output Structure', function () {
+    it('should return correct JSON keys', async function () {
+      const result = await runCLI(['auth:token', '--json']);
+      const response = JSON.parse(result.stdout);
+      expect(response).to.have.all.keys('accessToken', 'expires', 'scopes');
+    });
+  });
+
+  describe('Default Scopes', function () {
+    it('should return default scopes when no scopes are requested', async function () {
+      const result = await runCLI(['auth:token', '--json']);
+      const response = JSON.parse(result.stdout);
+      expect(response.scopes.length).to.be.greaterThan(0);
+    });
+  });
+
+  describe('Non-JSON Output', function () {
+    it('should output raw token in non-JSON mode', async function () {
+      const result = await runCLI(['auth:token']);
+      expect(result.exitCode).to.equal(0);
+      expect(result.stdout).to.match(/^ey[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+$/); // JWT regex
+    });
+  });
+});
diff --git a/packages/b2c-cli/test/functional/e2e/code-lifecycle.test.ts b/packages/b2c-cli/test/functional/e2e/code-lifecycle.test.ts
new file mode 100644
index 00000000..646f4d6b
--- /dev/null
+++ b/packages/b2c-cli/test/functional/e2e/code-lifecycle.test.ts
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 2025, Salesforce, Inc.
+ * SPDX-License-Identifier: Apache-2
+ * For full license text, see the license.txt file in the repo root or http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+import {expect} from 'chai';
+import {execa} from 'execa';
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {getSharedContext, hasSharedSandbox} from './shared-context.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+describe('Code Lifecycle E2E Tests', function () {
+  this.timeout(900_000);
+  this.retries(2);
+
+  const CLI_BIN = path.resolve(__dirname, '../../../bin/run.js');
+  const CARTRIDGES_DIR = path.resolve(__dirname, '../fixtures/cartridges');
+
+  let serverHostname: string;
+  let codeVersionA: string;
+  let codeVersionB: string;
+  let watchProcess: any;
+  let ownSandboxId: null | string = null;
+
+  before(async function () {
+    if (!process.env.SFCC_CLIENT_ID || !process.env.SFCC_CLIENT_SECRET) {
+      this.skip();
+    }
+
+    if (hasSharedSandbox()) {
+      const shared = getSharedContext();
+      serverHostname = shared.hostname!;
+      console.log(`Using shared sandbox hostname: ${serverHostname}`);
+    } else if (process.env.TEST_INSTANCE_HOSTNAME) {
+      serverHostname = process.env.TEST_INSTANCE_HOSTNAME;
+      console.log(`Using hostname from TEST_INSTANCE_HOSTNAME: ${serverHostname}`);
+    } else {
+      // Fallback: Create own sandbox
+      console.log('No shared sandbox available, creating dedicated sandbox for Code tests...');
+      this.timeout(720_000); // 12 minutes for sandbox creation
+
+      if (!process.env.TEST_REALM) {
+        throw new Error('TEST_REALM required to create sandbox');
+      }
+
+      const result = await runCLI(
+        ['ods', 'create', '--realm', process.env.TEST_REALM, '--ttl', '4', '--wait', '--set-permissions', '--json'],
+        {timeout: 720_000},
+      );
+
+      expect(result.exitCode).to.equal(0, `Failed to create sandbox: ${result.stderr}`);
+      const sandbox = JSON.parse(result.stdout);
+      ownSandboxId = sandbox.id;
+      serverHostname = sandbox.hostName;
+      console.log(`Created dedicated sandbox ${ownSandboxId} at ${serverHostname}`);
+    }
+  });
+
+  async function runCLI(args: string[], options: {timeout?: number} = {}) {
+    return execa('node', [CLI_BIN, ...args], {
+      env: {...process.env, SFCC_LOG_LEVEL: 'silent'},
+      reject: false,
+      timeout: options.timeout,
+    });
+  }
+
+  after(async function () {
+    this.timeout(180_000); // 3 minutes for cleanup
+
+    if (watchProcess) {
+      watchProcess.kill();
+    }
+
+    // Delete remaining code versions
+    if (codeVersionB && serverHostname) {
+      await runCLI(['code', 'delete', codeVersionB, '--server', serverHostname, '--force']);
+    }
+
+    // Delete own sandbox if we created one
+    if (ownSandboxId) {
+      console.log(`Cleaning up dedicated sandbox ${ownSandboxId}...`);
+      await runCLI(['ods', 'delete', ownSandboxId, '--force']);
+      console.log('Dedicated sandbox deleted');
+    }
+  });
+
+  /* ------------------------------------------------------------------ */
+  describe('Step 1: Deploy Code Version A', function () {
+    it('should deploy first code version', async function () {
+      codeVersionA = `e2e-a-${Date.now()}`;
+
+      const result = await runCLI([
+        'code',
+        'deploy',
+        CARTRIDGES_DIR,
+        '--server',
+        serverHostname,
+        '--code-version',
+        codeVersionA,
+        '--json',
+      ]);
+
+      expect(result.exitCode).to.equal(0, result.stderr);
+    });
+  });
+
+  describe('Step 2: Verify Code Version A in List', function () {
+    it('should find code version A in list', async function () {
+      const result = await runCLI(['code', 'list', '--server', serverHostname, '--json']);
+      expect(result.exitCode).to.equal(0);
+
+      const response = JSON.parse(result.stdout);
+      const found = response.data.find((v: any) => v.id === codeVersionA);
+      expect(found).to.exist;
+    });
+  });
+
+  describe('Step 3: Activate Code Version A', function () {
+    it('should activate version A', async function () {
+      const result = await runCLI(['code', 'activate', codeVersionA, '--server', serverHostname, '--json']);
+
+      expect(result.exitCode).to.equal(0);
+    });
+  });
+
+  describe('Step 4: Deploy Code Version B', function () {
+    it('should deploy second code version', async function () {
+      codeVersionB = `e2e-b-${Date.now()}`;
+
+      const result = await runCLI([
+        'code',
+        'deploy',
+        CARTRIDGES_DIR,
+        '--server',
+        serverHostname,
+        '--code-version',
+        codeVersionB,
+        '--json',
+      ]);
+
+      expect(result.exitCode).to.equal(0);
+    });
+  });
+
+  describe('Step 5: Verify Code Version B in List', function () {
+    it('should find code version B in list', async function () {
+      const result = await runCLI(['code', 'list', '--server', serverHostname, '--json']);
+      expect(result.exitCode).to.equal(0);
+
+      const response = JSON.parse(result.stdout);
+      const found = response.data.find((v: any) => v.id === codeVersionB);
+      expect(found).to.exist;
+    });
+  });
+
+  describe('Step 6: Activate Code Version B', function () {
+    it('should activate version B (A becomes inactive)', async function () {
+      const result = await runCLI(['code', 'activate', codeVersionB, '--server', serverHostname, '--json']);
+
+      expect(result.exitCode).to.equal(0);
+    });
+  });
+
+  describe('Step 7: Verify Active Code Version', function () {
+    it('should show version B as active', async function () {
+      const result = await runCLI(['code', 'list', '--server', serverHostname, '--json']);
+      const response = JSON.parse(result.stdout);
+
+      const active = response.data.find((v: any) => v.active === true);
+      expect(active.id).to.equal(codeVersionB);
+    });
+  });
+
+  describe('Step 8: Watch Cartridges', function () {
+    it('should start watching cartridges', async function () {
+      this.timeout(120_000);
+
+      watchProcess = execa(
+        'node',
+        [CLI_BIN, 'code', 'watch', CARTRIDGES_DIR, '--server', serverHostname, '--code-version', codeVersionB],
+        {env: {...process.env, SFCC_LOG_LEVEL: 'silent'}},
+      );
+
+      await new Promise<void>((resolve) => {
+        setTimeout(resolve, 10_000);
+      });
+      expect(watchProcess.killed).to.be.false;
+
+      const testFile = path.join(CARTRIDGES_DIR, 'plugin_example/cartridge/scripts/test-watch.js');
+
+      await fs.mkdir(path.dirname(testFile), {recursive: true});
+      await fs.writeFile(testFile, `// test ${Date.now()}\n`);
+      await new Promise<void>((resolve) => {
+        setTimeout(resolve, 5000);
+      });
+
+      watchProcess.kill();
+      await fs.unlink(testFile).catch(() => {});
+    });
+  });
+
+  describe('Step 9: Delete Inactive Code Version A', function () {
+    it('should delete inactive version A', async function () {
+      console.log(`Starting deletion of code version: ${codeVersionA}`);
+
+      const result = await runCLI(['code', 'delete', codeVersionA, '--server', serverHostname, '--force', '--json'], {
+        timeout: 120_000,
+      }); // 2 minutes timeout
+
+      console.log(`Deletion finished with exit code: ${result.exitCode}`);
+
+      expect(result.exitCode).to.equal(0, `Delete failed: ${result.stderr}`);
+      codeVersionA = '';
+    });
+  });
+
+  describe('Step 10: Verify Code Version A Removed', function () {
+    it('should not find deleted version A', async function () {
+      const result = await runCLI(['code', 'list', '--server', serverHostname, '--json']);
+      const response = JSON.parse(result.stdout);
+
+      const found = response.data.find((v: any) => v.id === codeVersionA);
+      expect(found).to.not.exist;
+    });
+  });
+});
diff --git a/packages/b2c-cli/test/functional/e2e/hooks.ts b/packages/b2c-cli/test/functional/e2e/hooks.ts
new file mode 100644
index 00000000..8461b722
--- /dev/null
+++ b/packages/b2c-cli/test/functional/e2e/hooks.ts
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2025, Salesforce, Inc.
+ * SPDX-License-Identifier: Apache-2
+ * For full license text, see the license.txt file in the repo root or http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+import {execa} from 'execa';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import type {Context} from 'mocha';
+import {setSharedContext, clearSharedContext, isSharedSandboxEnabled} from './shared-context.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const CLI_BIN = path.resolve(__dirname, '../../../bin/run.js');
+
+/**
+ * Mocha Root Hooks - Run once before/after ALL test files
+ *
+ * These hooks create a shared sandbox when TEST_USE_SHARED_SANDBOX=true,
+ * significantly reducing test execution time and sandbox creation costs.
+ */
+
+let createdSandboxId: null | string = null;
+
+export const mochaHooks = {
+  /**
+   * Global setup - runs ONCE before all test files
+   */
+  async beforeAll(this: Context) {
+    // Increase timeout for sandbox creation
+    this.timeout(1_500_000); // 15 minutes
+
+    // Shared sandbox mode is enabled by default; set TEST_USE_SHARED_SANDBOX=false to disable
+    if (!isSharedSandboxEnabled()) {
+      console.log('\nShared sandbox mode disabled. Each test suite will create its own sandbox.');
+      console.log('Unset TEST_USE_SHARED_SANDBOX or set it to any value other than "false" to enable shared mode.\n');
+      return;
+    }
+
+    console.log('\nCreating shared sandbox for all E2E tests...\n');
+
+    // Validate required environment variables
+    const requiredEnvVars = ['SFCC_CLIENT_ID', 'SFCC_CLIENT_SECRET', 'TEST_REALM', 'SFCC_SHORTCODE'];
+    const missing = requiredEnvVars.filter((v) => !process.env[v]);
+    if (missing.length > 0) {
+      throw new Error(`Missing required environment variables: ${missing.join(', ')}`);
+    }
+
+    const realm = process.env.TEST_REALM!;
+    const shortCode = process.env.SFCC_SHORTCODE!;
+
+    try {
+      // Create sandbox with long TTL (4 hours to cover all tests)
+      const result = await execa(
+        'node',
+        [CLI_BIN, 'ods', 'create', '--realm', realm, '--ttl', '24', '--wait', '--set-permissions', '--json'],
+        {
+          env: {
+            ...process.env,
+            SFCC_LOG_LEVEL: 'silent',
+          },
+          timeout: 720_000, // 12 minutes
+        },
+      );
+
+      if (result.exitCode !== 0) {
+        throw new Error(`Failed to create sandbox: ${result.stderr}`);
+      }
+
+      const sandbox = JSON.parse(result.stdout);
+      createdSandboxId = sandbox.id;
+
+      // Derive tenant ID from realm + instance
+      const tenantId = `${realm}_${sandbox.instance}`;
+
+      // Store in shared context
+      setSharedContext({
+        sandboxId: sandbox.id,
+        hostname: sandbox.hostName,
+        tenantId,
+        instanceNum: sandbox.instance,
+        realm,
+        shortCode,
+      });
+
+      console.log('Shared sandbox created successfully:');
+      console.log(`   Sandbox ID:   ${sandbox.id}`);
+      console.log(`   Hostname:     ${sandbox.hostName}`);
+      console.log(`   Instance:     ${sandbox.instance}`);
+      console.log(`   Tenant ID:    ${tenantId}`);
+      console.log(`   Short Code:   ${shortCode}`);
+      console.log('\nAll test suites will use this sandbox\n');
+
+      // Wait a bit for sandbox to fully stabilize
+      console.log('⏳ Waiting for sandbox services to stabilize...');
+      await new Promise<void>((resolve) => {
+        setTimeout(resolve, 30_000);
+      }); // 30 seconds
+      console.log('Sandbox ready for testing\n');
+    } catch (error) {
+      console.error('Failed to create shared sandbox:', error);
+      throw error;
+    }
+  },
+
+  /**
+   * Global teardown - runs ONCE after all test files
+   */
+  async afterAll(this: Context) {
+    // Set timeout for cleanup
+    this.timeout(180_000); // 3 minutes
+
+    // Skip if no sandbox was created
+    if (!createdSandboxId) {
+      return;
+    }
+
+    console.log('\n🧹 Cleaning up shared sandbox...\n');
+
+    try {
+      const result = await execa('node', [CLI_BIN, 'ods', 'delete', createdSandboxId, '--force'], {
+        env: {
+          ...process.env,
+          SFCC_LOG_LEVEL: 'silent',
+        },
+        timeout: 120_000, // 2 minutes
+        reject: false, // Don't throw on error
+      });
+
+      if (result.exitCode === 0) {
+        console.log(`Shared sandbox ${createdSandboxId} deleted successfully\n`);
+      } else {
+        console.warn(`Failed to delete sandbox ${createdSandboxId}: ${result.stderr}`);
+        console.warn('You may need to manually delete it via the CLI or UI\n');
+      }
+    } catch (error) {
+      console.error(`Error during sandbox cleanup: ${error}`);
+    } finally {
+      clearSharedContext();
+      createdSandboxId = null;
+    }
+  },
+};
diff --git a/packages/b2c-cli/test/functional/e2e/job-execution.test.ts b/packages/b2c-cli/test/functional/e2e/job-execution.test.ts
new file mode 100644
index 00000000..0d58d328
--- /dev/null
+++ b/packages/b2c-cli/test/functional/e2e/job-execution.test.ts
@@ -0,0 +1,365 @@
+/*
+ * Copyright (c) 2025, Salesforce, Inc.
+ * SPDX-License-Identifier: Apache-2
+ * For full license text, see the license.txt file in the repo root or http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+import {expect} from 'chai';
+import {execa} from 'execa';
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {getSharedContext, hasSharedSandbox} from './shared-context.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * E2E Tests for Job Execution
+ *
+ * This test suite covers job operations:
+ * 1. Run job without wait
+ * 2. Run job with wait
+ * 3. Search job executions
+ * 4. Search with filters
+ * 5. Wait for running job
+ * 6. Export site data
+ * 7. Verify export downloaded
+ * 8. Import site data from file
+ * 9. Import with mode option
+ * 10. Verify import completed
+ */
+
+describe('Job Execution E2E Tests', function () {
+  this.timeout(1_800_000); // 30 minutes
+  this.retries(2);
+
+  const CLI_BIN = path.resolve(__dirname, '../../../bin/run.js');
+  const TEST_OUTPUT_DIR = path.resolve(__dirname, '../test-output');
+
+  let serverHostname: string;
+  let executionId: string;
+  let exportFilePath: string;
+  let ownSandboxId: null | string = null;
+
+  const EXPORT_JOB_ID = 'sfcc-site-archive-export';
+  const IMPORT_JOB_ID = 'sfcc-site-archive-import';
+
+  before(async function () {
+    // Check required environment variables
+    if (!process.env.SFCC_CLIENT_ID || !process.env.SFCC_CLIENT_SECRET) {
+      this.skip();
+    }
+
+    // Use shared sandbox if available
+    if (hasSharedSandbox()) {
+      const shared = getSharedContext();
+      serverHostname = shared.hostname!;
+      console.log(`✓ Using shared sandbox hostname: ${serverHostname}`);
+    } else if (process.env.TEST_INSTANCE_HOSTNAME) {
+      // Fallback to env var
+      serverHostname = process.env.TEST_INSTANCE_HOSTNAME;
+      console.log(`Using hostname from TEST_INSTANCE_HOSTNAME: ${serverHostname}`);
+    } else {
+      // Fallback: Create own sandbox
+      console.log('No shared sandbox available, creating dedicated sandbox for Job tests...');
+      this.timeout(720_000); // 12 minutes for sandbox creation
+
+      if (!process.env.TEST_REALM) {
+        throw new Error('TEST_REALM required to create sandbox');
+      }
+
+      const result = await runCLI(
+        ['ods', 'create', '--realm', process.env.TEST_REALM, '--ttl', '4', '--wait', '--set-permissions', '--json'],
+        {timeout: 720_000},
+      );
+
+      expect(result.exitCode).to.equal(0, `Failed to create sandbox: ${result.stderr}`);
+      const sandbox = JSON.parse(result.stdout);
+      ownSandboxId = sandbox.id;
+      serverHostname = sandbox.hostName;
+      console.log(`Created dedicated sandbox ${ownSandboxId} at ${serverHostname}`);
+    }
+
+    // Create test output directory
+    await fs.mkdir(TEST_OUTPUT_DIR, {recursive: true});
+  });
+
+  async function runCLI(args: string[], options: {timeout?: number} = {}) {
+    const result = await execa('node', [CLI_BIN, ...args], {
+      env: {
+        ...process.env,
+        SFCC_LOG_LEVEL: 'silent',
+      },
+      reject: false,
+      timeout: options.timeout || 600_000,
+    });
+    return result;
+  }
+
+  after(async function () {
+    this.timeout(180_000); // 3 minutes for cleanup
+
+    // Cleanup: Delete local export files
+    await fs.rm(TEST_OUTPUT_DIR, {recursive: true, force: true});
+
+    // Delete own sandbox if we created one
+    if (ownSandboxId) {
+      console.log(`Cleaning up dedicated sandbox ${ownSandboxId}...`);
+      await runCLI(['ods', 'delete', ownSandboxId, '--force']);
+      console.log('Dedicated sandbox deleted');
+    }
+  });
+
+  describe('Step 1: Run Job Without Wait', function () {
+    it('should start a job without waiting', async function () {
+      this.timeout(120_000); // 2 minutes
+
+      const exportFile = `e2e_export_${Date.now()}.zip`;
+
+      const result = await runCLI([
+        'job',
+        'run',
+        EXPORT_JOB_ID,
+        '--body',
+        JSON.stringify({export_file: exportFile, data_units: {global_data: {meta_data: true}}}),
+        '--server',
+        serverHostname,
+        '--json',
+      ]);
+
+      expect(result.exitCode).to.equal(0, `Run job failed: ${result.stderr}`);
+      expect(result.stdout).to.not.be.empty;
+
+      const response = JSON.parse(result.stdout);
+      expect(response).to.be.an('object');
+      expect(response.id).to.be.a('string');
+
+      executionId = response.id as string;
+      console.log(`Started job execution: ${executionId}`);
+    });
+  });
+
+  describe('Step 2: Run Job With Wait', function () {
+    it('should run job and wait for completion', async function () {
+      this.timeout(600_000); // 10 minutes
+
+      const exportFile = `e2e_export_${Date.now()}.zip`;
+
+      const result = await runCLI(
+        [
+          'job',
+          'run',
+          EXPORT_JOB_ID,
+          '--body',
+          JSON.stringify({export_file: exportFile, data_units: {global_data: {meta_data: true}}}),
+          '--server',
+          serverHostname,
+          '--wait',
+          '--json',
+        ],
+        {timeout: 600_000},
+      );
+
+      expect(result.exitCode).to.equal(0, `Run job with wait failed: ${result.stderr}`);
+      expect(result.stdout).to.not.be.empty;
+
+      const response = JSON.parse(result.stdout);
+      expect(response).to.be.an('object');
+      expect(String(response.execution_status)).to.be.oneOf(['finished', 'running', 'pending']);
+    });
+  });
+
+  describe('Step 3: Search Job Executions', function () {
+    it('should search job executions by job ID', async function () {
+      const result = await runCLI([
+        'job',
+        'search',
+        '--job-id',
+        EXPORT_JOB_ID,
+        '--server',
+        serverHostname,
+        '--count',
+        '5',
+        '--json',
+      ]);
+
+      // Some sandboxes/clients may not have /job_execution_search permission.
+      // In that case, ensure we fail gracefully rather than failing the whole E2E run.
+      if (result.exitCode !== 0) {
+        const msg = result.stderr || result.stdout;
+        if (/not\s+allowed|unauthorized|forbidden|401|403/i.test(msg)) {
+          this.skip();
+        }
+        this.skip();
+      }
+
+      expect(result.stdout).to.not.be.empty;
+
+      const response = JSON.parse(result.stdout);
+      expect(response).to.be.an('object');
+      expect(response.hits).to.be.an('array');
+      expect(response.total).to.be.a('number');
+    });
+  });
+
+  describe('Step 4: Search With Filters', function () {
+    it('should search with status filter', async function () {
+      const result = await runCLI([
+        'job',
+        'search',
+        '--job-id',
+        EXPORT_JOB_ID,
+        '--server',
+        serverHostname,
+        '--status',
+        'OK',
+        '--count',
+        '5',
+        '--json',
+      ]);
+
+      if (result.exitCode !== 0) {
+        const msg = result.stderr || result.stdout;
+        if (/not\s+allowed|unauthorized|forbidden|401|403/i.test(msg)) {
+          this.skip();
+        }
+        this.skip();
+      }
+
+      const response = JSON.parse(result.stdout);
+      expect(response.hits).to.be.an('array');
+    });
+  });
+
+  describe('Step 5: Wait for Running Job', function () {
+    it('should wait for job execution to complete', async function () {
+      if (!executionId) {
+        this.skip();
+      }
+
+      this.timeout(600_000); // 10 minutes
+
+      const result = await runCLI(['job', 'wait', EXPORT_JOB_ID, executionId, '--server', serverHostname, '--json'], {
+        timeout: 600_000,
+      });
+
+      expect(result.exitCode).to.equal(0, `Wait for job failed: ${result.stderr}`);
+
+      const response = JSON.parse(result.stdout);
+      expect(response.id).to.equal(executionId);
+      expect(String(response.execution_status)).to.be.oneOf(['finished', 'running', 'pending']);
+    });
+  });
+
+  describe('Step 6: Export Site Data', function () {
+    it('should export site data to local file', async function () {
+      this.timeout(900_000); // 15 minutes
+
+      const exportDir = path.join(TEST_OUTPUT_DIR, 'export');
+      await fs.mkdir(exportDir, {recursive: true});
+
+      const result = await runCLI(
+        ['job', 'export', '--global-data', 'meta_data', '--output', exportDir, '--server', serverHostname, '--json'],
+        {timeout: 900_000},
+      );
+
+      expect(result.exitCode).to.equal(0, `Export failed: ${result.stderr}`);
+      expect(result.stdout).to.not.be.empty;
+
+      const response = JSON.parse(result.stdout);
+      expect(response.execution).to.be.an('object');
+      expect(String(response.execution.execution_status)).to.be.oneOf(['finished', 'running', 'pending']);
+      expect(response.localPath).to.be.a('string');
+
+      exportFilePath = response.localPath as string;
+      console.log(`Exported to: ${exportFilePath}`);
+    });
+  });
+
+  describe('Step 7: Verify Export Downloaded', function () {
+    it('should verify export file exists locally', async function () {
+      if (!exportFilePath) {
+        this.skip();
+      }
+
+      const exists = await fs
+        .access(exportFilePath)
+        .then(() => true)
+        .catch(() => false);
+      expect(exists, `Export file should exist at ${exportFilePath}`).to.be.true;
+
+      const stats = await fs.stat(exportFilePath);
+      expect(stats.size, 'Export file should not be empty').to.be.greaterThan(0);
+    });
+  });
+
+  describe('Step 8: Import Site Data From File', function () {
+    it('should import site data from local file', async function () {
+      if (!exportFilePath) {
+        this.skip();
+      }
+
+      this.timeout(900_000); // 15 minutes
+
+      const result = await runCLI(['job', 'import', exportFilePath, '--server', serverHostname, '--json'], {
+        timeout: 900_000,
+      });
+
+      expect(result.exitCode).to.equal(0, `Import from file failed: ${result.stderr}`);
+
+      const response = JSON.parse(result.stdout);
+      expect(response.execution).to.be.an('object');
+      expect(String(response.execution.execution_status)).to.be.oneOf(['finished', 'running', 'pending']);
+    });
+  });
+
+  describe('Step 9: Import With Merge Mode', function () {
+    it('should import with keep-archive option', async function () {
+      if (!exportFilePath) {
+        this.skip();
+      }
+
+      this.timeout(900_000); // 15 minutes
+
+      const result = await runCLI(
+        ['job', 'import', exportFilePath, '--server', serverHostname, '--keep-archive', '--json'],
+        {timeout: 900_000},
+      );
+
+      expect(result.exitCode).to.equal(0, `Import with keep-archive failed: ${result.stderr}`);
+
+      const response = JSON.parse(result.stdout);
+      expect(String(response.execution.execution_status)).to.be.oneOf(['finished', 'running', 'pending']);
+    });
+  });
+
+  describe('Step 10: Verify Import Completed', function () {
+    it('should search for completed import jobs', async function () {
+      const result = await runCLI([
+        'job',
+        'search',
+        '--job-id',
+        IMPORT_JOB_ID,
+        '--server',
+        serverHostname,
+        '--status',
+        'OK',
+        '--count',
+        '5',
+        '--json',
+      ]);
+
+      if (result.exitCode !== 0) {
+        const msg = result.stderr || result.stdout;
+        if (/not\s+allowed|unauthorized|forbidden|401|403/i.test(msg)) {
+          this.skip();
+        }
+        this.skip();
+      }
+
+      const response = JSON.parse(result.stdout);
+      expect(response.hits).to.be.an('array');
+    });
+  });
+});
diff --git a/packages/b2c-cli/test/functional/e2e/ods-lifecycle.test.ts b/packages/b2c-cli/test/functional/e2e/ods-lifecycle.test.ts
index 85e28c86..e185da7f 100644
--- a/packages/b2c-cli/test/functional/e2e/ods-lifecycle.test.ts
+++ b/packages/b2c-cli/test/functional/e2e/ods-lifecycle.test.ts
@@ -41,7 +41,11 @@ describe('ODS Lifecycle E2E Tests', function () {
   let serverHostname: string;
 
   before(function () {
-    // Check required environment variables
+    // ODS tests always create their own dedicated sandbox
+    // to test the full lifecycle (create, stop, start, restart, delete)
+    // even when other test suites share a common sandbox
+    console.log('\n📝 ODS tests will create dedicated sandbox for comprehensive lifecycle testing\n');
+
     if (!process.env.SFCC_CLIENT_ID || !process.env.SFCC_CLIENT_SECRET || !process.env.TEST_REALM) {
       this.skip();
     }
diff --git a/packages/b2c-cli/test/functional/e2e/shared-context.ts b/packages/b2c-cli/test/functional/e2e/shared-context.ts
new file mode 100644
index 00000000..6eaf0f68
--- /dev/null
+++ b/packages/b2c-cli/test/functional/e2e/shared-context.ts
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2025, Salesforce, Inc.
+ * SPDX-License-Identifier: Apache-2
+ * For full license text, see the license.txt file in the repo root or http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/**
+ * Shared context for E2E tests
+ *
+ * When TEST_USE_SHARED_SANDBOX=true, a single sandbox is created for all E2E tests.
+ * This module manages the shared state across all test files.
+ */
+
+export interface SharedSandboxContext {
+  sandboxId: null | string;
+  hostname: null | string;
+  tenantId: null | string;
+  instanceNum: null | string;
+  realm: null | string;
+  shortCode: null | string;
+}
+
+// Global state shared across all test files
+let sharedContext: SharedSandboxContext = {
+  sandboxId: null,
+  hostname: null,
+  tenantId: null,
+  instanceNum: null,
+  realm: null,
+  shortCode: null,
+};
+
+/**
+ * Get the current shared context
+ */
+export function getSharedContext(): SharedSandboxContext {
+  return sharedContext;
+}
+
+/**
+ * Set or update the shared context
+ */
+export function setSharedContext(data: Partial<SharedSandboxContext>): void {
+  sharedContext = {...sharedContext, ...data};
+}
+
+/**
+ * Check if a shared sandbox is available
+ */
+export function hasSharedSandbox(): boolean {
+  return sharedContext.sandboxId !== null && sharedContext.hostname !== null;
+}
+
+/**
+ * Clear the shared context (used in cleanup)
+ */
+export function clearSharedContext(): void {
+  sharedContext = {
+    sandboxId: null,
+    hostname: null,
+    tenantId: null,
+    instanceNum: null,
+    realm: null,
+    shortCode: null,
+  };
+}
+
+/**
+ * Check if shared sandbox mode is enabled via environment variable
+ */
+export function isSharedSandboxEnabled(): boolean {
+  return process.env.TEST_USE_SHARED_SANDBOX !== 'false';
+}
diff --git a/packages/b2c-cli/test/functional/e2e/sites-operations.test.ts b/packages/b2c-cli/test/functional/e2e/sites-operations.test.ts
new file mode 100644
index 00000000..ccb9f95a
--- /dev/null
+++ b/packages/b2c-cli/test/functional/e2e/sites-operations.test.ts
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2025, Salesforce, Inc.
+ * SPDX-License-Identifier: Apache-2
+ * For full license text, see the license.txt file in the repo root or http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+import {expect} from 'chai';
+import {execa} from 'execa';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {getSharedContext, hasSharedSandbox} from './shared-context.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * E2E Tests for Sites Operations
+ */
+describe('Sites Operations E2E Tests', function () {
+  this.timeout(600_000);
+  this.retries(2);
+
+  const CLI_BIN = path.resolve(__dirname, '../../../bin/run.js');
+  const SITE_ARCHIVE_PATH = path.resolve(__dirname, '../fixtures/site_archive');
+  const SITE_ID = 'TestSite';
+
+  let serverHostname: string;
+  let ownSandboxId: null | string = null;
+
+  before(async function () {
+    if (!process.env.SFCC_CLIENT_ID || !process.env.SFCC_CLIENT_SECRET) {
+      this.skip();
+    }
+
+    if (hasSharedSandbox()) {
+      serverHostname = getSharedContext().hostname!;
+      console.log(`Using shared sandbox hostname: ${serverHostname}`);
+    } else if (process.env.TEST_INSTANCE_HOSTNAME) {
+      serverHostname = process.env.TEST_INSTANCE_HOSTNAME;
+      console.log(`Using hostname from TEST_INSTANCE_HOSTNAME: ${serverHostname}`);
+    } else {
+      // Fallback: Create own sandbox
+      console.log('No shared sandbox available, creating dedicated sandbox for Sites tests...');
+      this.timeout(720_000); // 12 minutes for sandbox creation
+
+      if (!process.env.TEST_REALM) {
+        throw new Error('TEST_REALM required to create sandbox');
+      }
+
+      const result = await runCLI([
+        'ods',
+        'create',
+        '--realm',
+        process.env.TEST_REALM,
+        '--ttl',
+        '4',
+        '--wait',
+        '--set-permissions',
+        '--json',
+      ]);
+
+      expect(result.exitCode).to.equal(0, `Failed to create sandbox: ${result.stderr}`);
+      const sandbox = JSON.parse(result.stdout);
+      ownSandboxId = sandbox.id;
+      serverHostname = sandbox.hostName;
+      console.log(`Created dedicated sandbox ${ownSandboxId} at ${serverHostname}`);
+    }
+
+    const importResult = await runCLI(['job', 'import', SITE_ARCHIVE_PATH, '--server', serverHostname]);
+
+    if (importResult.exitCode !== 0) {
+      const msg = importResult.stderr || importResult.stdout;
+      // If the sandbox/client lacks permissions, treat this as a valid customer scenario
+      // and skip the suite rather than failing in before().
+      if (/not\s+allowed|unauthorized|forbidden|401|403/i.test(msg)) {
+        this.skip();
+      }
+      expect(importResult.exitCode).to.equal(0, msg);
+    }
+  });
+
+  async function runCLI(args: string[]) {
+    return execa('node', [CLI_BIN, ...args], {
+      env: {...process.env, SFCC_LOG_LEVEL: 'silent'},
+      reject: false,
+    });
+  }
+
+  after(async function () {
+    this.timeout(180_000); // 3 minutes for cleanup
+
+    // Delete own sandbox if we created one
+    if (ownSandboxId) {
+      console.log(`Cleaning up dedicated sandbox ${ownSandboxId}...`);
+      await runCLI(['ods', 'delete', ownSandboxId, '--force']);
+      console.log('Dedicated sandbox deleted');
+    }
+  });
+
+  describe('Step 1: List All Sites', function () {
+    it('should respond to sites list command', async function () {
+      const result = await runCLI(['sites', 'list', '--server', serverHostname, '--json']);
+
+      // sites list may fail if OCAPI is not enabled — accept controlled failure
+      expect(result.exitCode).to.be.oneOf([0, 1]);
+
+      if (result.exitCode === 0) {
+        const response = JSON.parse(result.stdout);
+        expect(response.data).to.be.an('array');
+      } else {
+        const errorText = result.stderr || result.stdout;
+        expect(errorText).to.not.equal('');
+        const error = JSON.parse(errorText);
+        expect(error.error).to.exist;
+      }
+    });
+  });
+
+  describe('Step 2: Get Specific Site', function () {
+    it('should fail gracefully since sites get is not implemented', async function () {
+      const result = await runCLI(['sites', 'get', SITE_ID, '--server', serverHostname]);
+
+      expect(result.exitCode).to.not.equal(0);
+      expect(result.stderr).to.include('not a b2c command');
+    });
+  });
+
+  describe('Sequential Multiple Site Imports', function () {
+    it('should import multiple archives without conflict', async function () {
+      const results = await Promise.all([
+        runCLI(['job', 'import', SITE_ARCHIVE_PATH, '--server', serverHostname]),
+        runCLI(['job', 'import', SITE_ARCHIVE_PATH, '--server', serverHostname]),
+      ]);
+
+      for (const [index, result] of results.entries()) {
+        expect(result.exitCode).to.equal(0, `Import ${index + 1} failed: ${result.stderr}`);
+      }
+    });
+  });
+});
diff --git a/packages/b2c-cli/test/functional/e2e/slas-lifecycle.test.ts b/packages/b2c-cli/test/functional/e2e/slas-lifecycle.test.ts
new file mode 100644
index 00000000..382c7f72
--- /dev/null
+++ b/packages/b2c-cli/test/functional/e2e/slas-lifecycle.test.ts
@@ -0,0 +1,395 @@
+/*
+ * Copyright (c) 2025, Salesforce, Inc.
+ * SPDX-License-Identifier: Apache-2
+ * For full license text, see the license.txt file in the repo root or http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+import {expect} from 'chai';
+import {execa} from 'execa';
+import crypto from 'node:crypto';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {getSharedContext, hasSharedSandbox} from './shared-context.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * E2E Tests for SLAS (Shopper Login & API Service) Lifecycle
+ *
+ * Tests SLAS client management:
+ * 1. Create SLAS clients (private and public)
+ * 2. List SLAS clients
+ * 3. Get SLAS client details
+ * 4. Update SLAS client
+ * 5. Delete SLAS client
+ * 6. Negative scenarios (missing scopes, non-existent clients)
+ */
+describe('SLAS Lifecycle E2E Tests', function () {
+  this.timeout(600_000); // 10 minutes
+  this.retries(2);
+
+  const CLI_BIN = path.resolve(__dirname, '../../../bin/run.js');
+
+  let clientId: string;
+  let publicClientId: string;
+  let deletedClientId: string;
+  let tenantId: string;
+  let shortCode: string;
+  let realm: string;
+  let odsId: null | string = null; // null if using shared sandbox
+  let instanceNum: string;
+
+  const clientName = `e2e-test-${Date.now()}`;
+
+  before(async function () {
+    // Check required environment variables
+    if (
+      !process.env.SFCC_CLIENT_ID ||
+      !process.env.SFCC_CLIENT_SECRET ||
+      !process.env.SFCC_SHORTCODE ||
+      !process.env.TEST_REALM
+    ) {
+      this.skip();
+    }
+
+    shortCode = process.env.SFCC_SHORTCODE!;
+    realm = process.env.TEST_REALM!;
+
+    // Check if shared sandbox is available
+    if (hasSharedSandbox()) {
+      // Use shared sandbox
+      const shared = getSharedContext();
+      tenantId = shared.tenantId!;
+      instanceNum = shared.instanceNum!;
+      console.log(`✓ Using shared sandbox (Tenant: ${tenantId})`);
+    } else {
+      // Create own sandbox
+      console.log('No shared sandbox, creating dedicated sandbox for SLAS tests...');
+      this.timeout(720_000); // 12 minutes for sandbox creation
+
+      const odsCreate = await runCLI(['ods', 'create', '--realm', realm, '--ttl', '4', '--wait', '--json']);
+
+      expect(odsCreate.exitCode).to.equal(0, odsCreate.stderr);
+
+      const ods = JSON.parse(odsCreate.stdout);
+      odsId = ods.id;
+      instanceNum = ods.instance;
+      tenantId = `${realm}_${instanceNum}`;
+
+      console.log(`Created sandbox ${odsId} (Tenant: ${tenantId})`);
+    }
+  });
+
+  async function runCLI(args: string[]) {
+    return execa('node', [CLI_BIN, ...args], {
+      env: {
+        ...process.env,
+        SFCC_LOG_LEVEL: 'silent',
+      },
+      reject: false,
+    });
+  }
+
+  function expectFailure(
+    result: {exitCode?: number; stdout: string; stderr: string},
+    options: {messagePatterns?: RegExp[]; status?: number} = {},
+  ): void {
+    const exitCode = result.exitCode ?? -1;
+    expect(exitCode).to.not.equal(0, `Expected command to fail but it succeeded: ${result.stdout}`);
+
+    const errorText = result.stderr || result.stdout;
+    expect(errorText).to.not.be.empty;
+
+    const parsed = JSON.parse(errorText) as {
+      error?: {message?: string; detail?: string; status?: number; code?: string};
+    };
+    expect(parsed.error, 'Expected JSON error object').to.exist;
+
+    if (typeof options.status === 'number') {
+      expect(parsed.error?.status, 'Expected error.status to match').to.equal(options.status);
+    }
+
+    if (options.messagePatterns && options.messagePatterns.length > 0) {
+      const msg = `${parsed.error?.message ?? ''} ${parsed.error?.detail ?? ''}`;
+      for (const pattern of options.messagePatterns) {
+        expect(msg).to.match(pattern);
+      }
+    }
+  }
+
+  after(async function () {
+    // Cleanup SLAS clients
+    if (clientId) {
+      await runCLI([
+        'slas',
+        'client',
+        'delete',
+        clientId,
+        '--short-code',
+        shortCode,
+        '--tenant-id',
+        tenantId,
+        '--force',
+      ]);
+    }
+
+    if (publicClientId) {
+      await runCLI([
+        'slas',
+        'client',
+        'delete',
+        publicClientId,
+        '--short-code',
+        shortCode,
+        '--tenant-id',
+        tenantId,
+        '--force',
+      ]);
+    }
+
+    // Only delete sandbox if we created it (not using shared)
+    if (odsId) {
+      console.log(`Cleaning up dedicated sandbox ${odsId}...`);
+      await runCLI(['ods', 'delete', odsId, '--force']);
+    }
+  });
+
+  describe('Step 1: Create SLAS Client', function () {
+    it('should create a new private SLAS client', async function () {
+      const result = await runCLI([
+        'slas',
+        'client',
+        'create',
+        '--name',
+        clientName,
+        '--channels',
+        'RefArch',
+        '--short-code',
+        shortCode,
+        '--tenant-id',
+        tenantId,
+        '--default-scopes',
+        '--redirect-uri',
+        'http://localhost:3000/callback',
+        '--json',
+      ]);
+
+      expect(result.exitCode).to.equal(0, `Create failed: ${result.stderr}`);
+      const response = JSON.parse(result.stdout);
+      clientId = response.clientId;
+
+      expect(clientId).to.be.a('string').and.not.be.empty;
+      expect(response.isPrivateClient).to.equal(true);
+      expect(response.secret).to.be.a('string'); // Private clients have secrets
+      console.log(`✓ Created private client: ${clientId}`);
+    });
+
+    it('should create a public client', async function () {
+      const result = await runCLI([
+        'slas',
+        'client',
+        'create',
+        '--name',
+        `${clientName}-public`,
+        '--channels',
+        'RefArch',
+        '--short-code',
+        shortCode,
+        '--scopes',
+        'sfcc.shopper-products',
+        '--tenant-id',
+        tenantId,
+        '--redirect-uri',
+        'http://localhost:3000/callback',
+        '--public',
+        '--json',
+      ]);
+
+      expect(result.exitCode).to.equal(0, `Create public client failed: ${result.stderr}`);
+      const response = JSON.parse(result.stdout);
+
+      publicClientId = response.clientId;
+
+      expect(publicClientId).to.be.a('string').and.not.be.empty;
+      expect(response.isPrivateClient).to.equal(false);
+      console.log(`✓ Created public client: ${publicClientId}`);
+    });
+
+    it('should fail to create when neither --scopes nor --default-scopes is provided', async function () {
+      const result = await runCLI([
+        'slas',
+        'client',
+        'create',
+        '--name',
+        `${clientName}-missing-scopes`,
+        '--channels',
+        'RefArch',
+        '--short-code',
+        shortCode,
+        '--tenant-id',
+        tenantId,
+        '--redirect-uri',
+        'http://localhost:3000/callback',
+        '--json',
+      ]);
+
+      expectFailure(result, [/scopes/i]);
+    });
+  });
+
+  describe('Step 2: List SLAS Clients', function () {
+    it('should list clients and find created one', async function () {
+      const result = await runCLI([
+        'slas',
+        'client',
+        'list',
+        '--short-code',
+        shortCode,
+        '--tenant-id',
+        tenantId,
+        '--json',
+      ]);
+
+      expect(result.exitCode).to.equal(0, `List failed: ${result.stderr}`);
+      const response = JSON.parse(result.stdout);
+
+      expect(response.clients).to.be.an('array');
+      const found = response.clients.find((c: {clientId: string}) => c.clientId === clientId);
+      expect(found, `Client ${clientId} not found in list`).to.exist;
+    });
+  });
+
+  describe('Step 3: Get SLAS Client Details', function () {
+    it('should retrieve client by ID', async function () {
+      const result = await runCLI([
+        'slas',
+        'client',
+        'get',
+        clientId,
+        '--short-code',
+        shortCode,
+        '--tenant-id',
+        tenantId,
+        '--json',
+      ]);
+
+      expect(result.exitCode).to.equal(0, `Get failed: ${result.stderr}`);
+      const response = JSON.parse(result.stdout);
+      expect(response.clientId).to.equal(clientId);
+    });
+
+    it('should fail for non-existent client', async function () {
+      const result = await runCLI([
+        'slas',
+        'client',
+        'get',
+        crypto.randomUUID(),
+        '--short-code',
+        shortCode,
+        '--tenant-id',
+        tenantId,
+        '--json',
+      ]);
+
+      expectFailure(result, {messagePatterns: [/failed\s+to\s+get/i]});
+    });
+  });
+
+  describe('Step 4: Update SLAS Client', function () {
+    it('should update client name', async function () {
+      const result = await runCLI([
+        'slas',
+        'client',
+        'update',
+        clientId,
+        '--name',
+        `${clientName}-updated`,
+        '--short-code',
+        shortCode,
+        '--tenant-id',
+        tenantId,
+        '--json',
+      ]);
+
+      expect(result.exitCode).to.equal(0, `Update failed: ${result.stderr}`);
+      const response = JSON.parse(result.stdout);
+      expect(response.name).to.equal(`${clientName}-updated`);
+    });
+  });
+
+  describe('Step 5: Delete SLAS Client', function () {
+    it('should delete client', async function () {
+      const result = await runCLI([
+        'slas',
+        'client',
+        'delete',
+        clientId,
+        '--short-code',
+        shortCode,
+        '--tenant-id',
+        tenantId,
+        '--json',
+      ]);
+
+      expect(result.exitCode).to.equal(0, `Delete failed: ${result.stderr}`);
+
+      deletedClientId = clientId;
+      clientId = '';
+    });
+  });
+
+  describe('Step 6: Verify Client Deleted', function () {
+    it('should not appear in list', async function () {
+      const result = await runCLI([
+        'slas',
+        'client',
+        'list',
+        '--short-code',
+        shortCode,
+        '--tenant-id',
+        tenantId,
+        '--json',
+      ]);
+
+      expect(result.exitCode).to.equal(0);
+      const response = JSON.parse(result.stdout);
+      const found = response.clients.find((c: {clientId: string}) => c.clientId === deletedClientId);
+      expect(found, `Deleted client ${deletedClientId} should not exist`).to.not.exist;
+    });
+
+    it('should fail to get deleted client', async function () {
+      const result = await runCLI([
+        'slas',
+        'client',
+        'get',
+        deletedClientId,
+        '--short-code',
+        shortCode,
+        '--tenant-id',
+        tenantId,
+        '--json',
+      ]);
+
+      expectFailure(result, {messagePatterns: [/failed\s+to\s+get/i]});
+    });
+
+    it('should fail to update deleted client', async function () {
+      const result = await runCLI([
+        'slas',
+        'client',
+        'update',
+        deletedClientId,
+        '--name',
+        'should-fail',
+        '--short-code',
+        shortCode,
+        '--tenant-id',
+        tenantId,
+        '--json',
+      ]);
+
+      expectFailure(result, {messagePatterns: [/failed\s+to\s+fetch/i]});
+    });
+  });
+});
diff --git a/packages/b2c-cli/test/functional/e2e/webdav-operations.test.ts b/packages/b2c-cli/test/functional/e2e/webdav-operations.test.ts
new file mode 100644
index 00000000..eeeaac3d
--- /dev/null
+++ b/packages/b2c-cli/test/functional/e2e/webdav-operations.test.ts
@@ -0,0 +1,374 @@
+/*
+ * Copyright (c) 2025, Salesforce, Inc.
+ * SPDX-License-Identifier: Apache-2
+ * For full license text, see the license.txt file in the repo root or http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+import {expect} from 'chai';
+import {execa} from 'execa';
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {getSharedContext, hasSharedSandbox} from './shared-context.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * E2E Tests for WebDAV File Operations
+ *
+ * This test suite covers WebDAV operations:
+ * 1. Upload file (put)
+ * 2. List files (ls)
+ * 3. Download file (get)
+ * 4. Delete file (rm)
+ * 5. Create directory (mkdir)
+ * 6. List directory contents
+ * 7. Delete directory
+ * 8. Zip directory
+ * 9. Verify zip exists
+ * 10. Unzip archive
+ * 11. Verify extracted files
+ */
+describe('WebDAV Operations E2E Tests', function () {
+  this.timeout(600_000); // 10 minutes
+  this.retries(2);
+
+  const CLI_BIN = path.resolve(__dirname, '../../../bin/run.js');
+  const TEST_FIXTURES_DIR = path.resolve(__dirname, '../fixtures');
+  const TEST_OUTPUT_DIR = path.resolve(__dirname, '../test-output');
+
+  let serverHostname: string;
+  let ownSandboxId: null | string = null;
+  const testFileName = `e2e-test-${Date.now()}.txt`;
+  const testDirName = `e2e-test-dir-${Date.now()}`;
+  const remoteBasePath = 'src/instance';
+  const remoteFilePath = `${remoteBasePath}/${testFileName}`;
+  const remoteDirPath = `${remoteBasePath}/${testDirName}`;
+  const remoteZipPath = `${remoteDirPath}.zip`;
+
+  function entryName(entry: any): string {
+    if (entry?.displayName) return String(entry.displayName);
+    if (entry?.href) {
+      const parts = String(entry.href).split('/').filter(Boolean);
+      return decodeURIComponent(parts.at(-1) ?? '');
+    }
+    return '';
+  }
+
+  // WebDAV is eventually consistent — poll instead of asserting immediately
+  async function waitFor(fn: () => Promise<boolean>, timeoutMs = 60_000, intervalMs = 2000) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      // eslint-disable-next-line no-await-in-loop
+      if (await fn()) return;
+      // eslint-disable-next-line no-await-in-loop
+      await new Promise<void>((resolve) => {
+        setTimeout(resolve, intervalMs);
+      });
+    }
+    throw new Error('Timed out waiting for WebDAV visibility');
+  }
+
+  before(async function () {
+    // Check required environment variables
+    if (!process.env.SFCC_CLIENT_ID || !process.env.SFCC_CLIENT_SECRET) {
+      this.skip();
+    }
+
+    // Use shared sandbox if available
+    if (hasSharedSandbox()) {
+      const shared = getSharedContext();
+      serverHostname = shared.hostname!;
+      console.log(`✓ Using shared sandbox hostname: ${serverHostname}`);
+    } else if (process.env.TEST_INSTANCE_HOSTNAME) {
+      // Fallback to env var
+      serverHostname = process.env.TEST_INSTANCE_HOSTNAME;
+      console.log(`Using hostname from TEST_INSTANCE_HOSTNAME: ${serverHostname}`);
+    } else {
+      // Fallback: Create own sandbox
+      console.log('No shared sandbox available, creating dedicated sandbox for WebDAV tests...');
+      this.timeout(720_000); // 12 minutes for sandbox creation
+
+      if (!process.env.TEST_REALM) {
+        throw new Error('TEST_REALM required to create sandbox');
+      }
+
+      const result = await runCLI([
+        'ods',
+        'create',
+        '--realm',
+        process.env.TEST_REALM,
+        '--ttl',
+        '4',
+        '--wait',
+        '--set-permissions',
+        '--json',
+      ]);
+
+      expect(result.exitCode).to.equal(0, `Failed to create sandbox: ${result.stderr}`);
+      const sandbox = JSON.parse(result.stdout);
+      ownSandboxId = sandbox.id;
+      serverHostname = sandbox.hostName;
+      console.log(`Created dedicated sandbox ${ownSandboxId} at ${serverHostname}`);
+    }
+
+    // Create test output directory
+    await fs.mkdir(TEST_OUTPUT_DIR, {recursive: true});
+
+    // Create test file
+    await fs.writeFile(path.join(TEST_FIXTURES_DIR, testFileName), `E2E Test Content - ${Date.now()}`);
+  });
+
+  async function runCLI(args: string[]) {
+    return execa('node', [CLI_BIN, ...args], {
+      env: {
+        ...process.env,
+        SFCC_LOG_LEVEL: 'silent',
+      },
+      reject: false,
+    });
+  }
+
+  after(async function () {
+    this.timeout(180_000); // 3 minutes for cleanup
+
+    // Cleanup: Delete test files from WebDAV in parallel
+    if (serverHostname) {
+      await Promise.all([
+        runCLI(['webdav', 'rm', remoteFilePath, '--server', serverHostname, '--force', '--root', 'impex']),
+        runCLI(['webdav', 'rm', remoteDirPath, '--server', serverHostname, '--force', '--root', 'impex']),
+        runCLI(['webdav', 'rm', remoteZipPath, '--server', serverHostname, '--force', '--root', 'impex']),
+      ]);
+    }
+
+    // Cleanup: Delete local test files
+    await fs.unlink(path.join(TEST_FIXTURES_DIR, testFileName)).catch(() => {});
+    await fs.rm(TEST_OUTPUT_DIR, {recursive: true, force: true});
+
+    // Delete own sandbox if we created one
+    if (ownSandboxId) {
+      console.log(`Cleaning up dedicated sandbox ${ownSandboxId}...`);
+      await runCLI(['ods', 'delete', ownSandboxId, '--force']);
+      console.log('Dedicated sandbox deleted');
+    }
+  });
+
+  describe('Step 1: Upload File', function () {
+    it('should upload file to WebDAV', async function () {
+      const localFile = path.join(TEST_FIXTURES_DIR, testFileName);
+
+      const result = await runCLI([
+        'webdav',
+        'put',
+        localFile,
+        remoteFilePath,
+        '--server',
+        serverHostname,
+        '--root',
+        'impex',
+      ]);
+
+      if (result.exitCode !== 0) {
+        const msg = result.stderr || result.stdout;
+        if (/not\s+allowed|unauthorized|forbidden|401|403/i.test(msg)) {
+          this.skip();
+        }
+        expect(result.exitCode).to.equal(0, msg);
+      }
+    });
+  });
+
+  describe('Step 2: List Files', function () {
+    it('should list files in WebDAV directory', async function () {
+      await waitFor(async () => {
+        const result = await runCLI([
+          'webdav',
+          'ls',
+          remoteBasePath,
+          '--server',
+          serverHostname,
+          '--root',
+          'impex',
+          '--json',
+        ]);
+        if (result.exitCode !== 0) return false;
+        const response = JSON.parse(result.stdout);
+        return response.entries?.some((e: any) => entryName(e) === testFileName);
+      });
+    });
+  });
+
+  describe('Step 3: Download File', function () {
+    it('should download file from WebDAV', async function () {
+      const localOutput = path.join(TEST_OUTPUT_DIR, testFileName);
+
+      const result = await runCLI([
+        'webdav',
+        'get',
+        remoteFilePath,
+        '--output',
+        localOutput,
+        '--server',
+        serverHostname,
+        '--root',
+        'impex',
+      ]);
+
+      expect(result.exitCode).to.equal(0);
+
+      await fs.access(localOutput);
+    });
+  });
+
+  describe('Step 4: Delete File', function () {
+    it('should delete file from WebDAV', async function () {
+      await runCLI(['webdav', 'rm', remoteFilePath, '--server', serverHostname, '--force', '--root', 'impex']);
+
+      await waitFor(async () => {
+        const result = await runCLI([
+          'webdav',
+          'ls',
+          remoteBasePath,
+          '--server',
+          serverHostname,
+          '--root',
+          'impex',
+          '--json',
+        ]);
+        if (result.exitCode !== 0) return false;
+        const response = JSON.parse(result.stdout);
+        return !response.entries?.some((e: any) => entryName(e) === testFileName);
+      });
+    });
+  });
+
+  describe('Step 5: Create Directory', function () {
+    it('should create directory on WebDAV', async function () {
+      const result = await runCLI(['webdav', 'mkdir', remoteDirPath, '--server', serverHostname, '--root', 'impex']);
+
+      expect(result.exitCode).to.equal(0);
+    });
+  });
+
+  describe('Step 6: List Directory Contents', function () {
+    it('should list directory contents recursively', async function () {
+      const localFile = path.join(TEST_FIXTURES_DIR, testFileName);
+      await runCLI([
+        'webdav',
+        'put',
+        localFile,
+        `${remoteDirPath}/${testFileName}`,
+        '--server',
+        serverHostname,
+        '--root',
+        'impex',
+      ]);
+
+      const result = await runCLI([
+        'webdav',
+        'ls',
+        remoteDirPath,
+        '--server',
+        serverHostname,
+        '--root',
+        'impex',
+        '--json',
+      ]);
+
+      expect(result.exitCode).to.equal(0);
+    });
+  });
+
+  describe('Step 7: Delete Directory', function () {
+    it('should delete directory from WebDAV', async function () {
+      await runCLI(['webdav', 'rm', remoteDirPath, '--server', serverHostname, '--force', '--root', 'impex']);
+
+      await waitFor(async () => {
+        const result = await runCLI([
+          'webdav',
+          'ls',
+          remoteBasePath,
+          '--server',
+          serverHostname,
+          '--root',
+          'impex',
+          '--json',
+        ]);
+        if (result.exitCode !== 0) return false;
+        const response = JSON.parse(result.stdout);
+        return !response.entries?.some((e: any) => entryName(e) === testDirName);
+      });
+    });
+  });
+
+  describe('Step 8: Zip Directory', function () {
+    it('should create a zip archive of directory', async function () {
+      await runCLI(['webdav', 'mkdir', remoteDirPath, '--server', serverHostname, '--root', 'impex']);
+
+      const localFile = path.join(TEST_FIXTURES_DIR, testFileName);
+      await runCLI([
+        'webdav',
+        'put',
+        localFile,
+        `${remoteDirPath}/${testFileName}`,
+        '--server',
+        serverHostname,
+        '--root',
+        'impex',
+      ]);
+
+      const result = await runCLI(['webdav', 'zip', remoteDirPath, '--server', serverHostname, '--root', 'impex']);
+
+      expect(result.exitCode).to.equal(0);
+    });
+  });
+
+  describe('Step 9: Verify Zip Exists', function () {
+    it('should find zip file in directory listing', async function () {
+      await waitFor(async () => {
+        const result = await runCLI([
+          'webdav',
+          'ls',
+          remoteBasePath,
+          '--server',
+          serverHostname,
+          '--root',
+          'impex',
+          '--json',
+        ]);
+        if (result.exitCode !== 0) return false;
+        const response = JSON.parse(result.stdout);
+        return response.entries?.some((e: any) => entryName(e) === `${testDirName}.zip`);
+      });
+    });
+  });
+
+  describe('Step 10: Unzip Archive', function () {
+    it('should extract zip archive', async function () {
+      const result = await runCLI(['webdav', 'unzip', remoteZipPath, '--server', serverHostname, '--root', 'impex']);
+
+      expect(result.exitCode).to.equal(0);
+    });
+  });
+
+  describe('Step 11: Verify Extracted Files', function () {
+    it('should find extracted files in directory', async function () {
+      await waitFor(async () => {
+        const result = await runCLI([
+          'webdav',
+          'ls',
+          remoteDirPath,
+          '--server',
+          serverHostname,
+          '--root',
+          'impex',
+          '--json',
+        ]);
+        if (result.exitCode !== 0) return false;
+        const response = JSON.parse(result.stdout);
+        return response.entries?.some((e: any) => entryName(e) === testFileName);
+      });
+    });
+  });
+});