@nexusclawhq/cli 0.2.1

package/dist/nexus-cli/src/commands/dx-workflows.e2e.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/nexus-cli/src/commands/dx-workflows.e2e.test.js

@@ -0,0 +1,659 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_http_1 = __importDefault(require("node:http"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_test_1 = __importDefault(require("node:test"));
+const commander_1 = require("commander");
+const dx_1 = require("./dx");
+const pack_registry_1 = require("../services/pack-registry");
+const target_context_fixture_1 = require("../test-utils/target-context-fixture");
+async function createDxServer() {
+    const requests = [];
+    const server = node_http_1.default.createServer((req, res) => {
+        let body = '';
+        req.on('data', (chunk) => {
+            body += chunk.toString();
+        });
+        req.on('end', () => {
+            const payload = JSON.parse(body || '{}');
+            requests.push(payload);
+            if (payload.query.includes('InstallMetadataPackage')) {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    data: {
+                        installMetadataPackage: {
+                            packageName: payload.variables.manifest.name,
+                            status: payload.variables.dryRun ? 'noop' : 'applied',
+                            appliedMetadataKinds: payload.variables.manifest.includedMetadataKinds,
+                            appliedSeedKinds: payload.variables.manifest.includedSeedKinds,
+                            warnings: [],
+                        },
+                    },
+                }));
+                return;
+            }
+            if (payload.query.includes('RuntimeComposerPreview')) {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    data: {
+                        runtimeComposerPreview: {
+                            plan: {
+                                orderedPackages: [
+                                    {
+                                        packageType: 'core-baseline',
+                                        packageName: payload.variables.input.baseline.packageName,
+                                        version: '1.0.0',
+                                    },
+                                ],
+                            },
+                            effective: {
+                                diff: { humanSummary: ['objects +1'] },
+                                warnings: [],
+                            },
+                        },
+                    },
+                }));
+                return;
+            }
+            if (payload.query.includes('RollbackMetadataPackageInstall')) {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    data: {
+                        rollbackMetadataPackageInstall: {
+                            packageName: payload.variables.manifest.name,
+                            status: 'rolled-back',
+                            warnings: ['Rolled back deployment history hist-rollback.'],
+                        },
+                    },
+                }));
+                return;
+            }
+            if (payload.query.includes('PromoteCodeEnvironment')) {
+                const input = payload.variables.input;
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    data: {
+                        promoteCodeEnvironment: {
+                            success: true,
+                            targetWorkspaceId: input.targetWorkspaceId,
+                            sourceEnvironment: input.sourceEnvironment ?? 'dev',
+                            runtimePolicyRef: input.runtimePolicyRef ?? null,
+                            warnings: [],
+                            errors: [],
+                            precheck: {
+                                valid: true,
+                                targetWorkspaceId: input.targetWorkspaceId,
+                                sourceEnvironment: input.sourceEnvironment ?? 'dev',
+                                runtimeProviderId: 'worker-thread',
+                                runtimePolicyRef: input.runtimePolicyRef ?? null,
+                                allowPartialFailure: false,
+                                warnings: [],
+                                errors: [],
+                                packages: input.packages.map((pkg) => ({
+                                    packageName: pkg.manifest.name,
+                                    version: pkg.manifest.version,
+                                    packageClass: 'code-extension',
+                                    action: 'install',
+                                    valid: true,
+                                    warnings: [],
+                                    errors: [],
+                                    executionTrack: 'serializer-backed',
+                                    installedVersion: null,
+                                    runtimeProviderRequirement: 'hardened-isolate',
+                                })),
+                                drift: {
+                                    missingPackages: input.packages.map((pkg) => `${pkg.manifest.name}@${pkg.manifest.version}`),
+                                    versionMismatches: [],
+                                    extraCodePackages: [],
+                                },
+                            },
+                            appliedPackages: input.packages.map((pkg) => ({
+                                packageName: pkg.manifest.name,
+                                version: pkg.manifest.version,
+                                action: 'install',
+                                status: 'applied',
+                                warnings: [],
+                                executionTrack: 'serializer-backed',
+                                installedStateId: `installed:${pkg.manifest.name}`,
+                                deploymentHistoryId: `history:${pkg.manifest.name}`,
+                            })),
+                            rollbackResults: [],
+                        },
+                    },
+                }));
+                return;
+            }
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                errors: [{ message: `Unhandled operation: ${payload.query}` }],
+            }));
+        });
+    });
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', () => resolve()));
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+        throw new Error('Unable to resolve DX test server address');
+    }
+    return {
+        baseUrl: `http://127.0.0.1:${address.port}`,
+        requests,
+        close: () => new Promise((resolve, reject) => {
+            server.close((error) => (error ? reject(error) : resolve()));
+        }),
+    };
+}
+async function withTempWorkspace(run) {
+    const workspaceDir = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'nexus-dx-workflow-'));
+    const packageDir = node_path_1.default.join(workspaceDir, 'packages', 'org-base');
+    const compareDir = node_path_1.default.join(workspaceDir, 'packages', 'org-base-next');
+    const registryDir = node_path_1.default.join(workspaceDir, 'workspace-packages');
+    const envDir = node_path_1.default.join(workspaceDir, 'env');
+    node_fs_1.default.mkdirSync(packageDir, { recursive: true });
+    node_fs_1.default.mkdirSync(compareDir, { recursive: true });
+    node_fs_1.default.mkdirSync(registryDir, { recursive: true });
+    node_fs_1.default.mkdirSync(envDir, { recursive: true });
+    node_fs_1.default.writeFileSync(node_path_1.default.join(workspaceDir, 'nexus-project.yaml'), [
+        'schemaVersion: dx-workspace/v1',
+        'projectName: crm-demo',
+        'compatibleCoreVersion: 0.1.x',
+        'sourceRoots:',
+        '  - path: src/metadata',
+        '    kind: metadata-runtime',
+        '    writeTarget: true',
+        'localPackages:',
+        '  - name: org-base',
+        '    path: packages/org-base',
+        'registry:',
+        '  url: https://registry.example.com',
+        '  channel: preview',
+        '  rootDirectory: workspace-packages',
+        'defaultEnvironment: dev',
+        'environments:',
+        '  - name: dev',
+        '    path: env/dev.sandbox.yaml',
+    ].join('\n'));
+    node_fs_1.default.writeFileSync(node_path_1.default.join(envDir, 'dev.sandbox.yaml'), [
+        'schemaVersion: dx-environment/v1',
+        'name: dev',
+        'type: dev-sandbox',
+        'target:',
+        '  workspaceId: ws-dx',
+        'packageStack:',
+        '  baseline:',
+        '    packageName: core.baseline',
+        '    packageType: core-baseline',
+    ].join('\n'));
+    const baseManifest = [
+        'schemaVersion: v1',
+        'name: org-base',
+        'packageType: extension-pack',
+        'packageClass: metadata',
+        'description: DX workflow metadata baseline',
+        'version: 0.1.0',
+        'dependencies: []',
+        'compatibleCoreVersion: ^1.0.0',
+        'installOrder: 300',
+        'includedMetadataKinds: [objects, dashboards]',
+        'includedSeedKinds: []',
+        'visibility: internal',
+        'releaseChannel: preview',
+        'kindSupport:',
+        '  - kind: objects',
+        '    executionMode: installer-input-backed',
+        '  - kind: dashboards',
+        '    executionMode: installer-input-backed',
+    ].join('\n');
+    const nextManifest = baseManifest.replace('version: 0.1.0', 'version: 0.2.0');
+    node_fs_1.default.writeFileSync(node_path_1.default.join(packageDir, 'package.yaml'), `${baseManifest}\n`);
+    node_fs_1.default.writeFileSync(node_path_1.default.join(compareDir, 'package.yaml'), `${nextManifest}\n`);
+    try {
+        await run({
+            workspaceDir,
+            packageDir,
+            compareDir,
+            registryDir,
+            envDir,
+        });
+    }
+    finally {
+        node_fs_1.default.rmSync(workspaceDir, { recursive: true, force: true });
+    }
+}
+async function captureLogs(run) {
+    const logs = [];
+    const originalLog = console.log;
+    console.log = (...args) => {
+        logs.push(args.map((value) => String(value)).join(' '));
+    };
+    try {
+        await run();
+    }
+    finally {
+        console.log = originalLog;
+    }
+    return logs;
+}
+async function runDxCommand(argv) {
+    const program = new commander_1.Command();
+    (0, dx_1.registerDxCommands)(program);
+    return captureLogs(async () => {
+        await program.parseAsync(['node', 'dx-test', ...argv], { from: 'node' });
+    });
+}
+(0, node_test_1.default)('dx aliases resolve workspace/env contracts for publish, validate, install, composer diff, package diff, and rollback', async () => {
+    const server = await createDxServer();
+    const previousBaseUrl = process.env.NEXUS_BASE_URL;
+    const previousToken = process.env.NEXUS_AUTH_TOKEN;
+    process.env.NEXUS_BASE_URL = server.baseUrl;
+    process.env.NEXUS_AUTH_TOKEN = 'test-token';
+    try {
+        await withTempWorkspace(async ({ workspaceDir, packageDir, compareDir }) => {
+            (0, target_context_fixture_1.configureTargetContextFixture)({ workspaceDir, instanceUrl: server.baseUrl, workspaceId: 'ws-dx' });
+            const publishLogs = await runDxCommand([
+                'publish',
+                '--source',
+                packageDir,
+                '--workspace',
+                workspaceDir,
+            ]);
+            strict_1.default.ok(publishLogs.some((line) => line.includes('registry.url: https://registry.example.com')));
+            strict_1.default.ok(publishLogs.some((line) => line.includes('registry.channel: preview')));
+            strict_1.default.ok(publishLogs.some((line) => line.includes('publishMode: contract-preview')));
+            const validateLogs = await runDxCommand(['validate', '--workspace', workspaceDir, '--json']);
+            strict_1.default.equal(validateLogs.length, 1);
+            const validationResult = JSON.parse(validateLogs[0]);
+            strict_1.default.equal(validationResult.valid, true);
+            strict_1.default.ok(validationResult.summary.some((line) => line.includes('workspace=crm-demo')));
+            await runDxCommand([
+                'install',
+                '--source',
+                packageDir,
+                '--workspace',
+                workspaceDir,
+                '--env',
+                'dev',
+                '--dry-run',
+            ]);
+            const composerLogs = await runDxCommand([
+                'diff',
+                '--mode',
+                'composer',
+                '--workspace',
+                workspaceDir,
+                '--env',
+                'dev',
+            ]);
+            strict_1.default.ok(composerLogs.some((line) => line.includes('core-baseline core.baseline@1.0.0')));
+            const packageDiffLogs = await runDxCommand([
+                'diff',
+                '--mode',
+                'package',
+                '--source',
+                packageDir,
+                '--against',
+                compareDir,
+            ]);
+            strict_1.default.ok(packageDiffLogs.some((line) => line.includes('org-base 0.1.0 -> 0.2.0')));
+            await runDxCommand([
+                'rollback',
+                '--source',
+                packageDir,
+                '--workspace',
+                workspaceDir,
+                '--env',
+                'dev',
+                '--history-id',
+                'hist-rollback',
+            ]);
+        });
+    }
+    finally {
+        process.env.NEXUS_BASE_URL = previousBaseUrl;
+        process.env.NEXUS_AUTH_TOKEN = previousToken;
+        await server.close();
+    }
+    strict_1.default.equal(server.requests.length, 3);
+    const [installRequest, composerRequest, rollbackRequest] = server.requests;
+    strict_1.default.match(installRequest.query, /InstallMetadataPackage/);
+    strict_1.default.equal(installRequest.variables.workspaceId, 'ws-dx');
+    strict_1.default.equal(installRequest.variables.dryRun, true);
+    strict_1.default.equal(installRequest.variables.packageDirectory.includes('packages/org-base'), true);
+    strict_1.default.match(composerRequest.query, /RuntimeComposerPreview/);
+    strict_1.default.equal(composerRequest.variables.input.tenantId, 'ws-dx');
+    strict_1.default.equal(composerRequest.variables.registryRootDirectories[0].endsWith('/workspace-packages'), true);
+    strict_1.default.match(rollbackRequest.query, /RollbackMetadataPackageInstall/);
+    strict_1.default.equal(rollbackRequest.variables.workspaceId, 'ws-dx');
+    strict_1.default.equal(rollbackRequest.variables.deploymentHistoryId, 'hist-rollback');
+});
+(0, node_test_1.default)('dx promote resolves registry-backed code packages from the workspace registry contract', async () => {
+    const server = await createDxServer();
+    const previousBaseUrl = process.env.NEXUS_BASE_URL;
+    const previousToken = process.env.NEXUS_AUTH_TOKEN;
+    process.env.NEXUS_BASE_URL = server.baseUrl;
+    process.env.NEXUS_AUTH_TOKEN = 'test-token';
+    try {
+        await withTempWorkspace(async ({ workspaceDir, registryDir, envDir }) => {
+            const codePackageDir = node_path_1.default.join(workspaceDir, 'packages', 'tenant-sync');
+            node_fs_1.default.mkdirSync(node_path_1.default.join(codePackageDir, 'src', 'functions'), { recursive: true });
+            const manifest = {
+                schemaVersion: 'v1',
+                name: 'tenant.sync',
+                packageType: 'extension-pack',
+                packageClass: 'code-extension',
+                description: 'DX workflow code extension package',
+                version: '1.0.1',
+                dependencies: [],
+                compatibleCoreVersion: '^1.0.0',
+                installOrder: 500,
+                includedMetadataKinds: [],
+                includedSeedKinds: [],
+                includedCodeKinds: ['function'],
+                visibility: 'internal',
+                releaseChannel: 'preview',
+                kindSupport: [],
+                codeKindSupport: [
+                    {
+                        kind: 'function',
+                        executionMode: 'sandboxed-runtime',
+                    },
+                ],
+                codeExtensionGovernance: {
+                    contractVersion: 'code-extension-governance/v1',
+                    runtimeApiVersion: 'runtime/v1',
+                },
+                runtimeProviderRequirement: 'hardened-isolate',
+                executableArtifacts: [
+                    {
+                        extensionId: 'function:syncTenant',
+                        apiName: 'syncTenant',
+                        kind: 'function',
+                        sourcePath: 'src/functions/syncTenant.function.ts',
+                    },
+                ],
+            };
+            node_fs_1.default.writeFileSync(node_path_1.default.join(codePackageDir, 'package.json'), JSON.stringify(manifest, null, 2));
+            node_fs_1.default.writeFileSync(node_path_1.default.join(codePackageDir, 'src', 'functions', 'syncTenant.function.ts'), [
+                'export default async function syncTenant(input: Record<string, unknown>) {',
+                '  return { ok: true, version: "1.0.1", input };',
+                '}',
+                '',
+            ].join('\n'));
+            const published = (0, pack_registry_1.publishPackageToLocalRegistry)({
+                registryRoot: registryDir,
+                packageDirectory: codePackageDir,
+                manifest: manifest,
+            });
+            node_fs_1.default.writeFileSync(node_path_1.default.join(envDir, 'dev.sandbox.yaml'), [
+                'schemaVersion: dx-environment/v1',
+                'name: dev',
+                'type: dev-sandbox',
+                'target:',
+                '  workspaceId: ws-dx',
+                'packageStack:',
+                '  baseline:',
+                '    packageName: core.baseline',
+                '    packageType: core-baseline',
+                'codePackages:',
+                '  - packageName: tenant.sync',
+                '    version: 1.0.1',
+                '    source: registry',
+                'runtimePolicyRef: workspace:ws-dx:default-code-runtime',
+                'promotePolicy:',
+                '  sourceEnvironment: dev',
+                '  allowPartialFailure: false',
+            ].join('\n'));
+            (0, target_context_fixture_1.configureTargetContextFixture)({ workspaceDir, instanceUrl: server.baseUrl, workspaceId: 'ws-dx' });
+            const logs = await runDxCommand([
+                'promote',
+                '--workspace',
+                workspaceDir,
+                '--env',
+                'dev',
+            ]);
+            strict_1.default.ok(logs.some((line) => line.includes('Promoted ws-dx')));
+            strict_1.default.ok(logs.some((line) => line.includes('tenant.sync@1.0.1 -> applied')));
+            strict_1.default.equal(server.requests.length, 1);
+            const [promotionRequest] = server.requests;
+            strict_1.default.match(promotionRequest.query, /PromoteCodeEnvironment/);
+            strict_1.default.equal(promotionRequest.variables.input.targetWorkspaceId, 'ws-dx');
+            strict_1.default.equal(promotionRequest.variables.input.runtimePolicyRef, 'workspace:ws-dx:default-code-runtime');
+            strict_1.default.equal(promotionRequest.variables.input.packages[0].manifest.name, 'tenant.sync');
+            strict_1.default.equal(promotionRequest.variables.input.packages[0].manifest.version, '1.0.1');
+            strict_1.default.equal(promotionRequest.variables.input.packages[0].packageDirectory, published.packageDirectory);
+            strict_1.default.equal(promotionRequest.variables.input.packages[0].sourceUri, published.packageDirectory);
+        });
+    }
+    finally {
+        process.env.NEXUS_BASE_URL = previousBaseUrl;
+        process.env.NEXUS_AUTH_TOKEN = previousToken;
+        await server.close();
+    }
+});
+(0, node_test_1.default)('target mismatch fails before the mock server receives any request', async () => {
+    const server = await createDxServer();
+    try {
+        await withTempWorkspace(async ({ workspaceDir, packageDir, envDir }) => {
+            (0, target_context_fixture_1.configureTargetContextFixture)({ workspaceDir, instanceUrl: server.baseUrl, workspaceId: 'ws-dx' });
+            const descriptorPath = node_path_1.default.join(envDir, 'dev.sandbox.yaml');
+            node_fs_1.default.writeFileSync(descriptorPath, node_fs_1.default.readFileSync(descriptorPath, 'utf8').replace('workspaceId: ws-dx', 'workspaceId: ws-other'));
+            await strict_1.default.rejects(runDxCommand([
+                'install',
+                '--source', packageDir,
+                '--workspace', workspaceDir,
+                '--env', 'dev',
+                '--dry-run',
+            ]), /Target workspace mismatch before request: expected ws-other.*actual ws-dx/);
+        });
+        strict_1.default.equal(server.requests.length, 0);
+    }
+    finally {
+        await server.close();
+    }
+});
+(0, node_test_1.default)('dx pages workflow keeps page apply and metadata install on one workspace', async () => {
+    const requests = [];
+    const server = node_http_1.default.createServer((req, res) => {
+        let body = '';
+        req.on('data', (chunk) => { body += chunk.toString(); });
+        req.on('end', () => {
+            const payload = JSON.parse(body || '{}');
+            requests.push(payload);
+            if (payload.query.includes('customPageSourceFiles')) {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    data: {
+                        customPageSourceFiles: [
+                            {
+                                apiName: 'test_dashboard',
+                                mainFileName: 'test_dashboard.page.json',
+                                mainContent: JSON.stringify({
+                                    apiName: 'test_dashboard',
+                                    name: 'Test Dashboard',
+                                    description: 'A test dashboard page',
+                                    type: 'app',
+                                    status: 'draft',
+                                    objectName: null,
+                                    schema: '@external:test_dashboard.page.schema.json',
+                                    version: 1,
+                                    icon: 'dashboard',
+                                    route: '/dashboard/test',
+                                    isActive: true,
+                                    isSystem: false,
+                                }, null, 2) + '\n',
+                                schemaFileName: 'test_dashboard.page.schema.json',
+                                schemaContent: JSON.stringify({ layout: { columns: 2 } }, null, 2) + '\n',
+                                remoteUpdatedAt: '2026-05-10T04:33:12.041Z',
+                            },
+                        ],
+                    },
+                }));
+                return;
+            }
+            if (payload.query.includes('applyCustomPageSources')) {
+                const input = payload.variables.input;
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    data: {
+                        applyCustomPageSources: {
+                            applied: input.bundles.map((b) => ({
+                                apiName: b.apiName,
+                                action: 'UPDATE',
+                                remoteUpdatedAt: '2026-05-11T01:00:00.000Z',
+                            })),
+                            errors: [],
+                        },
+                    },
+                }));
+                return;
+            }
+            if (payload.query.includes('InstallMetadataPackage')) {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    data: {
+                        installMetadataPackage: {
+                            packageName: payload.variables.manifest?.name ?? 'pages-pack',
+                            status: 'applied',
+                            appliedMetadataKinds: ['pages'],
+                            appliedSeedKinds: [],
+                            warnings: [],
+                        },
+                    },
+                }));
+                return;
+            }
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ errors: [{ message: `Unhandled: ${payload.query}` }] }));
+        });
+    });
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', () => resolve()));
+    const address = server.address();
+    if (!address || typeof address === 'string')
+        throw new Error('Unable to resolve test server');
+    const previousBaseUrl = process.env.NEXUS_BASE_URL;
+    const previousToken = process.env.NEXUS_AUTH_TOKEN;
+    process.env.NEXUS_BASE_URL = `http://127.0.0.1:${address.port}`;
+    process.env.NEXUS_AUTH_TOKEN = 'test-token';
+    const workspaceDir = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'nexus-dx-pages-'));
+    try {
+        const pagesDir = node_path_1.default.join(workspaceDir, 'src', 'metadata', 'pages');
+        node_fs_1.default.mkdirSync(pagesDir, { recursive: true });
+        const packageDir = node_path_1.default.join(workspaceDir, 'packages', 'pages-pack');
+        node_fs_1.default.mkdirSync(packageDir, { recursive: true });
+        const envDir = node_path_1.default.join(workspaceDir, 'env');
+        node_fs_1.default.mkdirSync(envDir, { recursive: true });
+        node_fs_1.default.writeFileSync(node_path_1.default.join(workspaceDir, 'nexus-project.yaml'), [
+            'schemaVersion: dx-workspace/v1',
+            'projectName: pages-test',
+            'compatibleCoreVersion: 0.1.x',
+            'sourceRoots:',
+            '  - path: src/metadata/pages',
+            '    kind: metadata-runtime',
+            '    metadataKinds: [pages]',
+            '    sourceOfTruthMode: source-wins',
+            '    orphanPolicy: delete',
+            'localPackages:',
+            '  - name: pages-pack',
+            '    path: packages/pages-pack',
+            'registry:',
+            '  url: https://registry.example.com',
+            '  channel: preview',
+            'defaultEnvironment: dev',
+            'environments:',
+            '  - name: dev',
+            '    path: env/dev.sandbox.yaml',
+        ].join('\n'));
+        node_fs_1.default.writeFileSync(node_path_1.default.join(envDir, 'dev.sandbox.yaml'), [
+            'schemaVersion: dx-environment/v1',
+            'name: dev',
+            'type: dev-sandbox',
+            'target:',
+            '  workspaceId: ws-pages',
+        ].join('\n'));
+        (0, target_context_fixture_1.configureTargetContextFixture)({
+            workspaceDir,
+            instanceUrl: `http://127.0.0.1:${address.port}`,
+            workspaceId: 'ws-pages',
+        });
+        const pullLogs = await runDxCommand([
+            'pull',
+            '--workspace', workspaceDir,
+            '--kind', 'pages',
+        ]);
+        strict_1.default.ok(pullLogs.some((line) => line.includes('Pages pull:')));
+        strict_1.default.ok(pullLogs.some((line) => line.includes('created=1')));
+        const mainFile = node_path_1.default.join(pagesDir, 'test_dashboard.page.json');
+        const schemaFile = node_path_1.default.join(pagesDir, 'test_dashboard.page.schema.json');
+        strict_1.default.ok(node_fs_1.default.existsSync(mainFile), 'Main page file should exist after pull');
+        strict_1.default.ok(node_fs_1.default.existsSync(schemaFile), 'Schema sidecar file should exist after pull');
+        const mainContent = JSON.parse(node_fs_1.default.readFileSync(mainFile, 'utf-8'));
+        mainContent.name = 'Test Dashboard Modified';
+        node_fs_1.default.writeFileSync(mainFile, JSON.stringify(mainContent, null, 2) + '\n');
+        node_fs_1.default.writeFileSync(node_path_1.default.join(packageDir, 'package.yaml'), [
+            'schemaVersion: v1',
+            'name: pages-pack',
+            'packageType: extension-pack',
+            'packageClass: metadata',
+            'description: Mixed pages and objects test package for DX workflow packing.',
+            'version: 1.0.0',
+            'dependencies: []',
+            'compatibleCoreVersion: ^0.1.0',
+            'installOrder: 100',
+            'includedMetadataKinds: [pages, objects]',
+            'includedSeedKinds: []',
+            'visibility: internal',
+            'releaseChannel: preview',
+            'kindSupport:',
+            '  - kind: pages',
+            '    executionMode: installer-input-backed',
+            '  - kind: objects',
+            '    executionMode: installer-input-backed',
+        ].join('\n') + '\n');
+        const packLogs = await runDxCommand([
+            'pack',
+            '--source', packageDir,
+            '--workspace', workspaceDir,
+        ]);
+        strict_1.default.ok(packLogs.some((line) => line.includes('pages-pack@1.0.0')));
+        strict_1.default.ok(packLogs.some((line) => line.includes('pages: 1 records')));
+        const packPageDir = node_path_1.default.join(packageDir, 'custompage', 'test_dashboard');
+        strict_1.default.ok(node_fs_1.default.existsSync(packPageDir), 'Pack should create custompage/<apiName>/ directory');
+        strict_1.default.ok(node_fs_1.default.existsSync(node_path_1.default.join(packPageDir, 'test_dashboard.page.json')), 'Pack should write main file into custompage dir');
+        const installLogs = await runDxCommand([
+            'install',
+            '--source', packageDir,
+            '--workspace', workspaceDir,
+            '--workspace-id', 'ws-pages',
+        ]);
+        strict_1.default.ok(installLogs.some((line) => line.includes('pages: update test_dashboard')));
+        const applyRequest = requests.find((r) => r.query.includes('applyCustomPageSources'));
+        strict_1.default.ok(applyRequest, 'applyCustomPageSources mutation should have been called');
+        const metadataInstallRequest = requests.find((r) => r.query.includes('InstallMetadataPackage'));
+        strict_1.default.ok(metadataInstallRequest, 'installMetadataPackage mutation should have been called for remaining metadata');
+        strict_1.default.equal(applyRequest.variables.input.workspaceId, 'ws-pages');
+        strict_1.default.equal(metadataInstallRequest.variables.workspaceId, 'ws-pages');
+        strict_1.default.equal(applyRequest.variables.input.sourceOfTruthMode, 'SOURCE_WINS');
+        strict_1.default.equal(applyRequest.variables.input.bundles.length, 1);
+        strict_1.default.equal(applyRequest.variables.input.bundles[0].apiName, 'test_dashboard');
+        const ledgerPath = node_path_1.default.join(workspaceDir, '.nexus-revision-ledger.json');
+        strict_1.default.ok(node_fs_1.default.existsSync(ledgerPath), 'Ledger should exist after install');
+        const ledger = JSON.parse(node_fs_1.default.readFileSync(ledgerPath, 'utf-8'));
+        const pageBaseline = ledger.sourceBaselines?.pages?.find((e) => e.apiName === 'test_dashboard');
+        strict_1.default.ok(pageBaseline, 'Ledger should have baseline for test_dashboard');
+        strict_1.default.equal(pageBaseline.remoteUpdatedAt, '2026-05-11T01:00:00.000Z');
+    }
+    finally {
+        process.env.NEXUS_BASE_URL = previousBaseUrl;
+        process.env.NEXUS_AUTH_TOKEN = previousToken;
+        node_fs_1.default.rmSync(workspaceDir, { recursive: true, force: true });
+        await new Promise((resolve, reject) => {
+            server.close((err) => (err ? reject(err) : resolve()));
+        });
+    }
+});
+//# sourceMappingURL=dx-workflows.e2e.test.js.map