@empire-builder-kit/nx 1.0.0-beta.9 → 1.0.0-rc.2

package/src/executors/fleet/fleet.js

@@ -1,529 +1,149 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildFleetPlan = buildFleetPlan;
-exports.probeGatewayTls = probeGatewayTls;
-exports.evaluatePortlessGateway = evaluatePortlessGateway;
-exports.fleetRestartDelay = fleetRestartDelay;
+exports.fleetExecutorCommand = fleetExecutorCommand;
+exports.fleetExecutorArguments = fleetExecutorArguments;
 const devkit_1 = require("@nx/devkit");
-const node_child_process_1 = require("node:child_process");
-const node_crypto_1 = require("node:crypto");
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
-const preflight_js_1 = require("../../foundation/preflight.js");
-const discovery_js_1 = require("../../foundation/discovery.js");
-const contracts_js_1 = require("../../local-dev/contracts.js");
-const gateway_js_1 = require("../../local-dev/gateway.js");
-const identity_js_1 = require("../../local-dev/identity.js");
-const ports_js_1 = require("../../local-dev/ports.js");
-const proxy_js_1 = require("../../local-dev/proxy.js");
+const context_discovery_js_1 = require("../../local-dev/context-discovery.js");
+const dev_command_core_js_1 = require("../../local-dev/dev-command-core.js");
+const errors_js_1 = require("../../local-dev/errors.js");
+const fleet_launcher_js_1 = require("../../local-dev/fleet-launcher.js");
+const local_context_js_1 = require("../../local-dev/local-context.js");
+const nx_workspace_js_1 = require("../../local-dev/nx-workspace.js");
+const personal_stage_js_1 = require("../../local-dev/personal-stage.js");
 const tls_js_1 = require("../../local-dev/tls.js");
-const node_tls_1 = require("node:tls");
-const dev_doctor_js_1 = require("../dev-doctor/dev-doctor.js");
-function parseSelected(input) {
-    const selected = input
-        .split(',')
-        .map((value) => value.trim())
+function normalizedSlices(value) {
+    const raw = Array.isArray(value) ? value : value === undefined ? [] : [value];
+    const slices = raw
+        .flatMap((entry) => entry.split(','))
+        .map((entry) => entry.trim())
         .filter(Boolean);
-    if (selected.length === 0) {
-        throw new Error('Fleet --slices must select at least one Product Slice.');
+    if (new Set(slices).size !== slices.length) {
+        throw new errors_js_1.LocalDevContractError('invalid-input', 'Nx Fleet Slice selection must not contain duplicates.');
     }
-    if (new Set(selected).size !== selected.length) {
-        throw new Error('Fleet --slices must not contain duplicate names.');
+    const invalid = slices.find((slice) => !/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(slice));
+    if (invalid) {
+        throw new errors_js_1.LocalDevContractError('invalid-input', `Nx Fleet Slice selector ${invalid} is invalid.`);
     }
-    return selected;
+    return slices;
 }
-function buildFleetPlan(options, context) {
-    const stage = (0, identity_js_1.requirePersonalFleetStage)(options.stage);
-    const projects = (context.projectsConfigurations?.projects ?? {});
-    const selected = parseSelected(options.slices);
-    for (const name of selected) {
-        if (!projects[name]?.tags?.includes('type:slice')) {
-            throw new Error(`Selected fleet project ${name} is not a Product Slice.`);
-        }
-    }
-    const sliceEntries = Object.entries(projects)
-        .filter(([, project]) => project.tags?.includes('type:slice'))
-        .filter(([, project]) => project.metadata?.ebk?.localDev !== undefined)
-        .flatMap(([name, project]) => {
-        try {
-            (0, contracts_js_1.validateLocalDevAdapter)(project.metadata?.ebk?.localDev);
-            return [{ adapter: project.metadata?.ebk?.localDev, name }];
-        }
-        catch (error) {
-            if (selected.includes(name)) {
-                throw new Error(`Selected Product Slice ${name} has an invalid metadata.ebk.localDev adapter: ${error instanceof Error ? error.message : String(error)}`);
-            }
-            return [];
-        }
-    });
-    const adapters = (0, contracts_js_1.validateFleetAdapters)(sliceEntries);
-    for (const name of selected) {
-        if (!adapters.has(name)) {
-            throw new Error(`Selected Product Slice ${name} has no valid metadata.ebk.localDev adapter.`);
-        }
-    }
-    const id = (0, identity_js_1.createFleetId)({
-        checkoutPath: context.root,
-        stage,
-        workspaceName: context.projectName ?? 'workspace',
-    });
-    return {
-        adapters,
-        hostname: (0, identity_js_1.createFleetHostname)(id, options.hostSuffix),
-        id,
-        selected,
-        stage,
-    };
+function timeoutMilliseconds(value) {
+    if (value === undefined)
+        return undefined;
+    const match = /^([1-9][0-9]*)(ms|s|m)$/.exec(value);
+    if (!match) {
+        throw new errors_js_1.LocalDevContractError('invalid-input', 'Nx Fleet timeout must use positive ms, s, or m units.');
+    }
+    const multiplier = { m: 60_000, ms: 1, s: 1_000 }[match[2]];
+    const result = Number(match[1]) * multiplier;
+    if (!Number.isSafeInteger(result) || result > 24 * 3_600_000) {
+        throw new errors_js_1.LocalDevContractError('invalid-input', 'Nx Fleet timeout is outside its supported range.');
+    }
+    return result;
 }
-async function developmentRouter(options) {
-    if (options.developmentRouterUrl?.trim()) {
-        const url = new URL(options.developmentRouterUrl.trim());
-        if (url.protocol !== 'https:') {
-            throw new Error('developmentRouterUrl must use HTTPS.');
-        }
-        return url;
-    }
-    const reader = (0, preflight_js_1.createFoundationParameterReader)({
-        profile: options.profile,
-        region: options.region,
-    });
-    const region = await reader.resolveRegion();
-    const report = await (0, preflight_js_1.evaluateFoundationPreflight)({
-        consumerStage: options.stage,
-        foundationStage: 'development',
-        readParameters: reader.read,
-        region,
-        requirement: discovery_js_1.STANDARD_FOUNDATION_REQUIREMENT,
-    });
-    if (!report.ok || !report.discovery) {
-        throw new Error(`Development Foundation preflight failed: ${report.issues.join('; ') || 'discovery unavailable'}`);
+function fleetExecutorCommand(options) {
+    const slices = normalizedSlices(options.slices);
+    if (options.all === true && slices.length > 0) {
+        throw new errors_js_1.LocalDevContractError('invalid-input', 'Nx Fleet execution accepts either all or explicit Slices, not both.');
     }
-    const url = new URL(report.discovery.routerUrl);
-    if (url.protocol !== 'https:') {
-        throw new Error(`Development Foundation Router ${url.toString()} must use HTTPS.`);
+    const foreground = options.foreground !== false;
+    const sstMode = options.sstMode ?? 'mono';
+    if (sstMode === 'multiplexer' && !foreground) {
+        throw new errors_js_1.LocalDevContractError('invalid-input', 'Nx Fleet multiplexer mode requires foreground ownership.');
     }
-    return url;
-}
-function packageVersion() {
-    const manifest = require('../../../package.json');
-    return manifest.version ?? '0.0.0';
-}
-function registrationRequest(options) {
+    const timeoutMs = timeoutMilliseconds(options.timeout);
     return {
-        action: 'register',
-        capability: options.capability,
-        clientFrameworkVersion: packageVersion(),
-        hostname: options.hostname,
-        protocol: {
-            maximum: contracts_js_1.GATEWAY_PROTOCOL_VERSION,
-            minimum: contracts_js_1.GATEWAY_PROTOCOL_VERSION,
+        foreground,
+        noWait: options.noWait === true,
+        selector: {
+            all: options.all === true || slices.length === 0,
+            slices,
         },
-        proxyPort: options.proxyPort,
-        sessionId: options.sessionId,
-        sessionManifestVersion: contracts_js_1.SESSION_MANIFEST_VERSION,
+        sstMode,
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
     };
 }
-async function waitForReadiness(route, signal, onStateChange, timeoutMs = 120_000) {
-    if (!route.adapter || !route.upstream)
-        return;
-    const deadline = Date.now() + timeoutMs;
-    const target = new URL(route.adapter.healthPath, route.upstream);
-    while (Date.now() < deadline && !signal.aborted) {
-        try {
-            const response = await fetch(target, {
-                redirect: 'manual',
-                signal: AbortSignal.timeout(2_000),
-            });
-            if (response.ok) {
-                route.state = 'ready';
-                onStateChange?.();
-                return;
-            }
-        }
-        catch {
-            // The supervised child may still be starting.
-        }
-        await new Promise((resolve) => setTimeout(resolve, 500));
-    }
-    route.state = 'unavailable';
-    onStateChange?.();
-    if (!signal.aborted) {
-        throw new Error(`${route.name} did not become ready at ${target.toString()} within ${timeoutMs}ms.`);
-    }
-}
-async function terminateChild(child) {
-    if (child.exitCode !== null || child.signalCode !== null)
-        return;
-    const exited = new Promise((resolve) => child.once('exit', () => resolve()));
-    if (process.platform === 'win32' && child.pid) {
-        const killer = (0, node_child_process_1.spawn)('taskkill', ['/pid', String(child.pid), '/t', '/f'], {
-            stdio: 'ignore',
-            windowsHide: true,
-        });
-        await new Promise((resolve) => killer.once('exit', () => resolve()));
-        await Promise.race([
-            exited,
-            new Promise((resolve) => setTimeout(resolve, 2_000)),
-        ]);
-        return;
-    }
-    if (child.pid) {
-        try {
-            process.kill(-child.pid, 'SIGTERM');
-        }
-        catch {
-            child.kill('SIGTERM');
-        }
-    }
-    const stopped = await Promise.race([
-        exited.then(() => true),
-        new Promise((resolve) => setTimeout(() => resolve(false), 5_000)),
-    ]);
-    if (!stopped && child.pid) {
-        try {
-            process.kill(-child.pid, 'SIGKILL');
-        }
-        catch {
-            child.kill('SIGKILL');
-        }
-        await Promise.race([
-            exited,
-            new Promise((resolve) => setTimeout(resolve, 1_000)),
-        ]);
-    }
-}
-async function probeGatewayTls(options) {
-    await new Promise((resolve, reject) => {
-        const socket = (0, node_tls_1.connect)({
-            ca: options.ca,
-            host: '127.0.0.1',
-            port: options.port ?? 443,
-            rejectUnauthorized: true,
-            servername: options.hostname,
-        });
-        let settled = false;
-        const finish = (error) => {
-            if (settled)
-                return;
-            settled = true;
-            socket.destroy();
-            if (error)
-                reject(error);
-            else
-                resolve();
-        };
-        socket.setTimeout(options.timeoutMs ?? 2_000, () => finish(new Error('Gateway TLS probe timed out.')));
-        socket.once('secureConnect', () => finish());
-        socket.once('error', (error) => finish(error));
-    });
-}
-async function evaluatePortlessGateway(options, dependencies = {}) {
-    if (options.gatewayState?.portless !== true ||
-        options.gatewayState.schemaVersion !== 1 ||
-        options.gatewayState.hostSuffix !== options.hostSuffix) {
-        return { portless: false };
-    }
-    const send = dependencies.send ?? gateway_js_1.sendGatewayCommand;
-    let registered = false;
-    try {
-        const status = await send(options.gatewaySocket, { action: 'status', capability: options.capability });
-        if (status.protocolVersion !== contracts_js_1.GATEWAY_PROTOCOL_VERSION) {
-            return {
-                portless: false,
-                warning: `Machine gateway protocol ${status.protocolVersion} is incompatible with client protocol ${contracts_js_1.GATEWAY_PROTOCOL_VERSION}; using explicit-port HTTPS without replacing the gateway.`,
-            };
-        }
-        await send(options.gatewaySocket, options.registration);
-        registered = true;
-        await (dependencies.probe ?? probeGatewayTls)({
-            ca: options.rootCertificate,
-            hostname: options.registration.hostname,
-        });
-        return { portless: true };
-    }
-    catch (error) {
-        return {
-            portless: false,
-            warning: `Portless gateway preflight failed (${error instanceof Error ? error.message : String(error)}); using the explicit-port HTTPS fallback.`,
-        };
-    }
-    finally {
-        if (registered) {
-            await send(options.gatewaySocket, {
-                action: 'unregister',
-                capability: options.capability,
-                hostname: options.registration.hostname,
-                sessionId: options.registration.sessionId,
-            }).catch(() => undefined);
-        }
-    }
-}
-function fleetRestartDelay(attempt) {
-    if (!Number.isInteger(attempt) || attempt < 0) {
-        throw new Error('Fleet restart attempt must be a non-negative integer.');
-    }
-    return Math.min(1_000 * 2 ** Math.min(attempt, 5), 30_000);
-}
-function startSlice(name, adapter, port, origin, stage, context) {
-    const executable = process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm';
-    return (0, node_child_process_1.spawn)(executable, [
-        'exec',
-        'nx',
-        'run',
-        `${name}:${adapter.target}`,
-        `--stage=${stage}`,
-        '--foundationStage=development',
-    ], {
-        cwd: context.root,
-        env: {
-            ...process.env,
-            [adapter.portEnvironment]: String(port),
-            EBK_AUTH_CALLBACK_URLS: JSON.stringify(adapter.auth?.callbackPaths?.map((path) => new URL(path, origin).toString()) ?? []),
-            EBK_AUTH_LOGOUT_URLS: JSON.stringify(adapter.auth?.logoutPaths?.map((path) => new URL(path, origin).toString()) ?? []),
-            EBK_CONSUMER_STAGE: stage,
-            EBK_FLEET_ORIGIN: origin.origin,
-            EBK_FOUNDATION_STAGE: 'development',
-            EBK_SECURE_COOKIES: 'true',
-        },
-        shell: false,
-        stdio: 'inherit',
-        windowsHide: true,
-        ...(process.platform === 'win32' ? {} : { detached: true }),
-    });
+function fleetExecutorArguments(options) {
+    const command = fleetExecutorCommand(options);
+    const arguments_ = [
+        'dev',
+        'up',
+        ...(command.selector.all ? ['--all'] : command.selector.slices),
+    ];
+    if (command.foreground)
+        arguments_.push('--foreground');
+    if (command.noWait)
+        arguments_.push('--no-wait');
+    if (options.sstMode)
+        arguments_.push(`--sst-mode=${command.sstMode}`);
+    if (options.timeout)
+        arguments_.push(`--timeout=${options.timeout}`);
+    return arguments_;
 }
 const executor = async (options, context) => {
-    const children = [];
-    const controller = new AbortController();
-    let proxy;
-    let fallbackGateway;
-    let heartbeat;
-    let portless = false;
-    let registered = false;
-    let capability;
-    let plan;
-    let manifestPath;
-    let fallbackIpcPath;
-    const paths = (0, tls_js_1.localTlsPaths)(options.appData);
-    const cleanup = async () => {
-        controller.abort();
-        if (heartbeat)
-            clearInterval(heartbeat);
-        if (registered && plan && capability) {
-            await (0, gateway_js_1.sendGatewayCommand)(paths.gatewaySocket, {
-                action: 'unregister',
-                capability,
-                hostname: plan.hostname,
-                sessionId: plan.id,
-            }).catch(() => undefined);
-        }
-        for (const child of [...children].reverse())
-            await terminateChild(child);
-        await fallbackGateway?.close().catch(() => undefined);
-        if (fallbackIpcPath && process.platform !== 'win32')
-            (0, node_fs_1.rmSync)(fallbackIpcPath, { force: true });
-        await proxy?.close().catch(() => undefined);
-        if (manifestPath)
-            (0, node_fs_1.rmSync)(manifestPath, { force: true });
-    };
+    const abort = new AbortController();
+    const onSignal = () => abort.abort();
+    process.once('SIGINT', onSignal);
+    process.once('SIGTERM', onSignal);
     try {
-        plan = buildFleetPlan(options, context);
-        const doctor = await (0, dev_doctor_js_1.inspectLocalDevelopment)({ appData: options.appData, hostname: plan.hostname, stage: plan.stage }, context);
-        if (doctor.tls !== 'ready' || doctor.trust !== 'ready') {
-            throw new Error('EBK local HTTPS trust is incomplete. Run dev-doctor, inspect the generated root, and explicitly run dev-setup --trust before fleet development.');
-        }
-        for (const required of [
-            paths.capability,
-            paths.leafCertificate,
-            paths.leafKey,
-        ]) {
-            try {
-                (0, node_fs_1.readFileSync)(required);
-            }
-            catch {
-                throw new Error('EBK local TLS state is missing. Run the generated dev-setup target, inspect the root, and explicitly approve trust installation before fleet development.');
-            }
-        }
-        const leaf = new node_crypto_1.X509Certificate((0, node_fs_1.readFileSync)(paths.leafCertificate));
-        if (!leaf.checkHost(plan.hostname)) {
-            throw new Error(`EBK local certificate does not cover ${plan.hostname}. Run dev-setup --upgrade --trust with --hostSuffix=${options.hostSuffix ?? 'ebk.localhost'}.`);
-        }
-        const remoteOrigin = await developmentRouter(options);
-        const reserved = new Set();
-        const proxyPort = await (0, ports_js_1.allocateFleetPort)(`${context.root}:${plan.id}:proxy`, {
-            reserved,
-        });
-        reserved.add(proxyPort);
-        capability = (0, node_fs_1.readFileSync)(paths.capability, 'utf8').trim();
-        const registration = registrationRequest({
-            capability,
-            hostname: plan.hostname,
-            proxyPort,
-            sessionId: plan.id,
-        });
-        const gatewayState = (() => {
-            try {
-                return JSON.parse((0, node_fs_1.readFileSync)(paths.gatewayState, 'utf8'));
-            }
-            catch {
-                return undefined;
-            }
-        })();
-        const gatewayPreference = await evaluatePortlessGateway({
-            capability,
-            gatewaySocket: paths.gatewaySocket,
-            gatewayState,
-            hostSuffix: (0, identity_js_1.normalizeFleetHostSuffix)(options.hostSuffix),
-            registration,
-            rootCertificate: (0, node_fs_1.readFileSync)(paths.rootCertificate),
-        });
-        portless = gatewayPreference.portless;
-        if (gatewayPreference.warning)
-            devkit_1.logger.warn(gatewayPreference.warning);
-        let gatewayPort;
-        if (!portless) {
-            gatewayPort = await (0, ports_js_1.allocateFleetPort)(`${context.root}:${plan.id}:gateway`, {
-                reserved,
-            });
-            reserved.add(gatewayPort);
-        }
-        const origin = new URL(`https://${plan.hostname}${gatewayPort ? `:${gatewayPort}` : ''}`);
-        const cache = (0, node_path_1.join)(context.root, '.ebk', 'cache');
-        (0, node_fs_1.mkdirSync)(cache, { recursive: true });
-        const routes = [...plan.adapters].map(([name, adapter]) => ({
-            adapter,
-            name,
-            selected: plan?.selected.includes(name) ?? false,
-            state: plan?.selected.includes(name) ? 'starting' : 'remote',
-        }));
-        for (const route of routes.filter(({ selected }) => selected)) {
-            const port = await (0, ports_js_1.allocateFleetPort)(`${context.root}:${plan.id}:${route.name}`, { reserved });
-            reserved.add(port);
-            route.upstream = new URL(`http://127.0.0.1:${port}`);
-        }
-        proxy = new proxy_js_1.FleetSessionProxy({
-            certificateExpires: doctor.certificateExpires ?? leaf.validTo,
-            consumerStage: plan.stage,
-            fleetOrigin: origin,
-            foundationStage: 'development',
-            remoteOrigin,
-            routes,
-            safeMethodFallback: options.safeMethodFallback,
-        });
-        await proxy.listen(proxyPort);
-        if (portless) {
-            await (0, gateway_js_1.sendGatewayCommand)(paths.gatewaySocket, registration);
-            registered = true;
-            proxy.setMode('gateway', 'registered');
-            heartbeat = setInterval(() => {
-                void (0, gateway_js_1.sendGatewayCommand)(paths.gatewaySocket, {
-                    action: 'heartbeat',
-                    capability,
-                    hostname: plan?.hostname,
-                    sessionId: plan?.id,
-                }).catch((error) => devkit_1.logger.warn(`Gateway heartbeat failed: ${String(error)}`));
-            }, 5_000);
-            heartbeat.unref();
-        }
-        else {
-            const registry = new gateway_js_1.GatewayRegistry(capability);
-            registry.register(registration);
-            fallbackGateway = new gateway_js_1.MachineGateway(registry, {
-                cert: (0, node_fs_1.readFileSync)(paths.leafCertificate),
-                key: (0, node_fs_1.readFileSync)(paths.leafKey),
-            });
-            fallbackIpcPath = (0, tls_js_1.createLocalIpcPath)((0, node_path_1.join)(context.root, '.ebk', 'cache'), plan.id);
-            if (process.platform !== 'win32')
-                (0, node_fs_1.rmSync)(fallbackIpcPath, { force: true });
-            await fallbackGateway.listen(gatewayPort, fallbackIpcPath);
-            proxy.setMode('explicit-port', 'standalone');
-            heartbeat = setInterval(() => {
-                try {
-                    registry.heartbeat(plan?.hostname ?? '', plan?.id ?? '');
-                }
-                catch (error) {
-                    devkit_1.logger.warn(`Explicit-port gateway heartbeat failed: ${String(error)}`);
+        const command = fleetExecutorCommand(options);
+        const plan = await (0, nx_workspace_js_1.loadWorkspaceFleetPlan)();
+        const identity = (0, personal_stage_js_1.createPersonalStageResolver)().resolve();
+        const gitCommonDirectory = (0, fleet_launcher_js_1.resolveGitCommonDirectory)(context.root);
+        const saved = (0, local_context_js_1.readSavedLocalDevContext)(gitCommonDirectory);
+        if (saved.kind === 'invalid') {
+            throw new errors_js_1.LocalDevContractError('local-context-invalid', saved.reason);
+        }
+        const explicit = {
+            ...(options.developmentRouterUrl
+                ? {
+                    developmentRouterOverrideOrigin: options.developmentRouterUrl,
                 }
-            }, 5_000);
-            heartbeat.unref();
-            devkit_1.logger.warn(`Machine gateway unavailable; using the HTTPS explicit-port gateway fallback at ${origin.origin}. This does not remediate resolver failures.`);
-        }
-        manifestPath = (0, node_path_1.join)(cache, `${plan.id}.json`);
-        const writeManifest = () => {
-            if (!manifestPath || !plan)
-                return;
-            (0, node_fs_1.writeFileSync)(manifestPath, `${JSON.stringify({
-                consumerStage: plan.stage,
-                fleetOrigin: origin.origin,
-                foundationStage: 'development',
-                gatewayMode: portless ? 'portless' : 'explicit-port',
-                hostname: plan.hostname,
-                routes: routes.map(({ adapter, name, selected, state, upstream }) => ({
-                    name,
-                    routePrefix: adapter?.routePrefix,
-                    selected,
-                    state,
-                    upstream: upstream?.toString(),
-                })),
-                schemaVersion: contracts_js_1.SESSION_MANIFEST_VERSION,
-            }, null, 2)}\n`, { mode: 0o600 });
-        };
-        writeManifest();
-        const restartAttempts = new Map();
-        const launch = (route) => {
-            if (controller.signal.aborted)
-                return;
-            route.state = 'starting';
-            writeManifest();
-            const child = startSlice(route.name, route.adapter, Number(route.upstream?.port), origin, plan?.stage ?? options.stage, context);
-            children.push(child);
-            child.once('exit', () => {
-                const childIndex = children.indexOf(child);
-                if (childIndex >= 0)
-                    children.splice(childIndex, 1);
-                if (controller.signal.aborted)
-                    return;
-                route.state = 'unavailable';
-                writeManifest();
-                devkit_1.logger.warn(`${route.name} local process exited; mutating requests now fail closed while the supervisor restarts it.`);
-                const attempt = restartAttempts.get(route.name) ?? 0;
-                const delay = fleetRestartDelay(attempt);
-                restartAttempts.set(route.name, attempt + 1);
-                setTimeout(() => {
-                    if (controller.signal.aborted)
-                        return;
-                    launch(route);
-                    void waitForReadiness(route, controller.signal, writeManifest)
-                        .then(() => restartAttempts.set(route.name, 0))
-                        .catch((error) => {
-                        route.state = 'unavailable';
-                        writeManifest();
-                        devkit_1.logger.error(String(error));
-                    });
-                }, delay).unref();
-            });
+                : {}),
+            ...(options.hostSuffix ? { hostSuffix: options.hostSuffix } : {}),
+            ...(options.maxRestartAttempts === undefined
+                ? {}
+                : { maxRestartAttempts: options.maxRestartAttempts }),
+            ...(options.profile ? { profile: options.profile } : {}),
+            ...(options.region ? { region: options.region } : {}),
+            ...(options.safeMethodFallback === undefined
+                ? {}
+                : { safeMethodFallback: options.safeMethodFallback }),
         };
-        for (const route of routes.filter(({ selected }) => selected))
-            launch(route);
-        await Promise.all(routes
-            .filter(({ selected }) => selected)
-            .map((route) => waitForReadiness(route, controller.signal, writeManifest).then(() => restartAttempts.set(route.name, 0))));
-        devkit_1.logger.info(`EBK fleet ready at ${origin.origin}`);
-        for (const route of routes) {
-            devkit_1.logger.info(`  ${route.adapter?.routePrefix ?? route.name}: ${route.state} (${route.selected ? route.upstream : remoteOrigin})`);
-        }
-        await new Promise((resolve) => {
-            const stop = () => resolve();
-            process.once('SIGINT', stop);
-            process.once('SIGTERM', stop);
+        const resolved = saved.kind === 'ready'
+            ? (0, local_context_js_1.reconcileSavedLocalDevContext)(saved.resolution.context, explicit)
+            : (0, local_context_js_1.resolveInitialLocalDevContext)(explicit, await (0, context_discovery_js_1.discoverLocalDevContext)(explicit, process.env));
+        if (saved.kind === 'missing') {
+            (0, local_context_js_1.writeSavedLocalDevContext)(gitCommonDirectory, resolved.context);
+        }
+        const manifest = require('../../../package.json');
+        const result = await (0, dev_command_core_js_1.executeFleetUpCore)(command, {
+            appData: (0, tls_js_1.defaultLocalDevAppData)(),
+            context: resolved.context,
+            frameworkVersion: typeof manifest.version === 'string' ? manifest.version : '0.0.0',
+            identity,
+            plan,
+            signal: abort.signal,
+            workspaceRoot: context.root,
+        }, {
+            reportCleanupFailure: (message) => devkit_1.logger.error(message),
         });
-        await cleanup();
+        devkit_1.logger.info(JSON.stringify({
+            attached: result.attached,
+            fleetId: result.fleetId,
+            operation: result.operation,
+            ...(result.slices ? { slices: result.slices } : {}),
+        }));
+        await result.afterWrite;
         return { success: true };
     }
     catch (error) {
-        devkit_1.logger.error(`[fleet] ${error instanceof Error ? error.message : String(error)}`);
-        await cleanup();
+        devkit_1.logger.error(error instanceof Error ? error.message : String(error));
         return { success: false };
     }
+    finally {
+        process.removeListener('SIGINT', onSignal);
+        process.removeListener('SIGTERM', onSignal);
+    }
 };
 exports.default = executor;
 //# sourceMappingURL=fleet.js.map