@nowcrew/daemon 0.6.89 → 0.6.90

package/dist/storage-runtime-controller.js

@@ -1,381 +0,0 @@
-import { createHash } from "node:crypto";
-import { dirname, join } from "node:path";
-import { z } from "zod";
-import { buildServiceSpec } from "./computer-service.js";
-import { buildManagedServiceRecord } from "./managed-service-lifecycle.js";
-import { createStorageControlController } from "./storage-control.js";
-import { runStorageDoctor } from "./storage-doctor.js";
-import { storageHelloIdentity, storageWorkspaceRootFingerprint, } from "./storage-identity.js";
-import { storageLayout, validateStorageEnvironment } from "./storage-layout.js";
-import { StorageMigrationFailure } from "./storage-migration-controller.js";
-import { launchStorageMigrationWorker, writeStorageWorkerHandoff } from "./storage-worker-handoff.js";
-import { writeStorageWorkerOperation } from "./storage-worker-operation.js";
-import { latestSourceStorageMigrationReceipt, monitorStorageMigrationStatus, storageMigrationStatusReplay, } from "./storage-status-replay.js";
-import { resolveWorkspaceStorageOwnershipClaim, } from "./storage-ownership.js";
-const UUID = z.string().uuid();
-function fingerprint(value) {
-    return `sha256:${createHash("sha256").update(value).digest("hex")}`;
-}
-function deterministicUuid(value) {
-    const chars = createHash("sha256").update(value).digest("hex").slice(0, 32).split("");
-    chars[12] = "4";
-    chars[16] = ((Number.parseInt(chars[16], 16) & 0x3) | 0x8).toString(16);
-    const hex = chars.join("");
-    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
-function storageId(input, workspaceId, ownership) {
-    if (ownership.workspaceId !== workspaceId || ownership.environment !== input.environment) {
-        throw new Error("Storage ownership claim does not match the migration identity");
-    }
-    return `storage_${ownership.claimFingerprint.slice("sha256:".length)}`;
-}
-function installationBase(input, workspaceId, migrationId, createdAt, ownership) {
-    const layout = storageLayout({
-        nowworkHome: input.nowworkHome,
-        environment: input.environment,
-        workspaceId,
-        runtimeBase: input.local.runtimeBase,
-        platform: input.platform,
-    });
-    return {
-        version: 1,
-        installationId: deterministicUuid(`installation\0${input.serverUrl}\0${input.profile}\0${workspaceId}\0${input.nowworkHome}`),
-        profile: input.profile,
-        serverUrl: input.serverUrl,
-        environment: input.environment,
-        workspaceId,
-        storageId: storageId(input, workspaceId, ownership),
-        nowworkHome: input.nowworkHome,
-        runtimeRoot: layout.runtimeRoot,
-        credentialRef: `profile:${input.profile}`,
-        ...(migrationId === undefined ? {} : { storageMigrationId: migrationId }),
-        createdAt,
-        updatedAt: createdAt,
-    };
-}
-function targetRecord(input, workspaceId, createdAt) {
-    const layout = storageLayout({
-        nowworkHome: input.nowworkHome,
-        environment: input.environment,
-        workspaceId,
-        runtimeBase: input.local.runtimeBase,
-        platform: input.platform,
-    });
-    const spec = buildServiceSpec({
-        platform: input.platform,
-        profile: input.profile,
-        userHome: input.userHome,
-        uid: input.uid,
-        nodePath: input.sourceRecord.nodePath,
-        entryPath: input.sourceRecord.entryPath,
-        profileHome: input.local.configRoot,
-        ...(input.serviceEnvironment === undefined ? {} : { environment: input.serviceEnvironment }),
-    });
-    return buildManagedServiceRecord({
-        spec,
-        daemonHome: input.local.configRoot,
-        agentsRoot: layout.agentItemsRoot,
-        nodePath: input.sourceRecord.nodePath,
-        entryPath: input.sourceRecord.entryPath,
-        packageRoot: input.sourceRecord.packageRoot,
-        npmPrefix: input.sourceRecord.npmPrefix,
-        generation: () => deterministicUuid(`service\0${spec.id}\0${workspaceId}`),
-        now: () => new Date(createdAt),
-    });
-}
-export function createStorageMigrationRuntimeController(rawInput, injected = {}) {
-    const input = {
-        ...rawInput,
-        profile: z.string().regex(/^[a-z0-9][a-z0-9_-]{0,47}$/u).parse(rawInput.profile),
-        serverUrl: z.string().url().parse(rawInput.serverUrl),
-        environment: validateStorageEnvironment(rawInput.environment),
-    };
-    if (input.sourceRecord.profile !== input.profile || input.sourceRecord.platform !== input.platform) {
-        throw new Error("Storage runtime source service identity does not match profile");
-    }
-    const dependencies = {
-        assertSourceIdentity: async () => undefined,
-        runDoctor: (doctorInput) => runStorageDoctor(doctorInput),
-        writeOperation: writeStorageWorkerOperation,
-        writeHandoff: writeStorageWorkerHandoff,
-        launchWorker: launchStorageMigrationWorker,
-        monitorWorker: monitorStorageMigrationStatus,
-        resolveOwnership: resolveWorkspaceStorageOwnershipClaim,
-        now: () => new Date(),
-        ...injected,
-    };
-    let workspaceId = null;
-    let machineId = null;
-    let identity;
-    let gate = null;
-    let sendStatus = null;
-    let control = null;
-    let ownership = input.ownership;
-    let identityBindTail = Promise.resolve();
-    const pendingControlMessages = [];
-    let drainingPendingControlMessages = false;
-    const drainPendingControlMessages = () => {
-        if (control === null || drainingPendingControlMessages || pendingControlMessages.length === 0)
-            return;
-        drainingPendingControlMessages = true;
-        const pending = pendingControlMessages.splice(0);
-        void (async () => {
-            for (const message of pending)
-                await control?.handle(message);
-        })().catch(() => undefined).finally(() => {
-            drainingPendingControlMessages = false;
-            drainPendingControlMessages();
-        });
-    };
-    const doctorInput = async (migrationId) => {
-        if (workspaceId === null || gate === null)
-            throw new Error("Storage migration runtime is not attached");
-        let profileIdentityExact = true;
-        await dependencies.assertSourceIdentity().catch(() => { profileIdentityExact = false; });
-        const target = storageLayout({
-            nowworkHome: input.nowworkHome,
-            environment: input.environment,
-            workspaceId,
-            runtimeBase: input.local.runtimeBase,
-            platform: input.platform,
-        });
-        return {
-            migrationId,
-            generatedAt: dependencies.now().toISOString(),
-            environment: input.environment,
-            workspaceId,
-            profile: input.profile,
-            targetWorkspaceRoot: target.workspaceRoot,
-            sources: [
-                { kind: "daemon-home", root: input.sourceRecord.daemonHome, logicalPrefix: "daemon" },
-                { kind: "agents-root", root: input.sourceRecord.agentsRoot, logicalPrefix: "agent-items" },
-            ],
-            policy: input.policy,
-            manifestStoreRoot: input.local.stateRoot,
-            state: {
-                profileIdentityExact,
-                duplicateWorkspaceMappings: input.duplicateWorkspaceMappings ?? 0,
-                activeAgentExecutions: gate.isBusy() ? 1 : 0,
-                activeScheduledRuns: 0,
-            },
-            freeSpaceMultiplier: 1.2,
-        };
-    };
-    const buildOperation = (doctor, freshInput) => {
-        if (workspaceId === null)
-            throw new Error("Storage migration workspace identity is missing");
-        const createdAt = freshInput.generatedAt;
-        const target = storageLayout({
-            nowworkHome: input.nowworkHome,
-            environment: input.environment,
-            workspaceId,
-            runtimeBase: input.local.runtimeBase,
-            platform: input.platform,
-        });
-        const { freeSpaceMultiplier, ...doctorBase } = freshInput;
-        const operationDoctorInput = {
-            ...doctorBase,
-            sources: freshInput.sources.map((source) => ({ ...source })),
-            policy: {
-                exclusions: freshInput.policy.exclusions.map((exclusion) => ({ ...exclusion })),
-                transformations: freshInput.policy.transformations.map((transformation) => ({ ...transformation })),
-            },
-            ...(freeSpaceMultiplier === undefined ? {} : { freeSpaceMultiplier }),
-        };
-        return {
-            version: 1,
-            migrationId: doctor.manifest.migrationId,
-            createdAt,
-            environment: input.environment,
-            workspaceId,
-            profile: input.profile,
-            expectedManifestDigest: doctor.manifestDigest,
-            doctorInput: operationDoctorInput,
-            migration: {
-                sourceRoots: {
-                    "daemon-home": input.sourceRecord.daemonHome,
-                    "agents-root": input.sourceRecord.agentsRoot,
-                },
-                stagingWorkspaceRoot: join(dirname(target.workspaceRoot), `.nowwork-staging-${doctor.manifest.migrationId}`),
-                targetWorkspaceRoot: target.workspaceRoot,
-                backupsRoot: input.local.backupsRoot,
-                backupArtifacts: input.backupArtifacts.map((artifact) => ({ ...artifact })),
-                ownership: {
-                    ownerEpoch: ownership.ownerEpoch,
-                    ownershipClaimFingerprint: ownership.claimFingerprint,
-                },
-                acceptedWarnings: [...input.policy.acceptedWarnings],
-            },
-            service: {
-                platform: input.platform,
-                userHome: input.userHome,
-                ...(input.uid === undefined ? {} : { uid: input.uid }),
-                ...(input.serviceEnvironment === undefined ? {} : { serviceEnvironment: input.serviceEnvironment }),
-                sourceWasRunning: true,
-                sourceRecord: input.sourceRecord,
-                targetRecord: targetRecord(input, workspaceId, createdAt),
-            },
-            installation: {
-                configRoot: input.local.configRoot,
-                target: {
-                    ...installationBase(input, workspaceId, doctor.manifest.migrationId, createdAt, ownership),
-                    storageMigrationId: doctor.manifest.migrationId,
-                },
-            },
-        };
-    };
-    const ensureControl = () => {
-        if (control !== null || workspaceId === null || gate === null || sendStatus === null || identity === undefined)
-            return;
-        const sourceStorageFingerprint = fingerprint(JSON.stringify({
-            profile: input.profile,
-            daemonHome: input.sourceRecord.daemonHome,
-            agentsRoot: input.sourceRecord.agentsRoot,
-            serviceId: input.sourceRecord.serviceId,
-        }));
-        control = createStorageControlController({
-            environment: input.environment,
-            workspaceId,
-            profile: input.profile,
-            sourceStorageFingerprint,
-            targetStorageFingerprint: identity.storageIdFingerprint,
-            ownership: {
-                ownerEpoch: ownership.ownerEpoch,
-                ownershipClaimFingerprint: ownership.claimFingerprint,
-            },
-            runDoctor: async (migrationId) => dependencies.runDoctor(await doctorInput(migrationId)),
-            runMigration: async (doctor) => {
-                await gate.closeAndFlush();
-                let workerLaunched = false;
-                try {
-                    const freshInput = await doctorInput(doctor.manifest.migrationId);
-                    const freshDoctor = await dependencies.runDoctor(freshInput);
-                    if (!freshDoctor.applyAllowed || freshDoctor.manifestDigest !== doctor.manifestDigest) {
-                        throw new StorageMigrationFailure("source_changed_after_preflight", "source data or doctor gates changed after server preflight");
-                    }
-                    const operation = buildOperation(freshDoctor, freshInput);
-                    const written = await dependencies.writeOperation(operation, { stateRoot: input.local.stateRoot });
-                    const handoffPath = await dependencies.writeHandoff({
-                        version: 1,
-                        migrationId: operation.migrationId,
-                        profile: operation.profile,
-                        operationPath: written.path,
-                        operationSha256: written.sha256,
-                    }, { stateRoot: input.local.stateRoot });
-                    await dependencies.launchWorker({
-                        entryPath: input.sourceRecord.entryPath,
-                        handoffPath,
-                        migrationId: operation.migrationId,
-                        platform: input.platform,
-                        userHome: input.userHome,
-                        ...(input.uid === undefined ? {} : { uid: input.uid }),
-                    });
-                    workerLaunched = true;
-                    const outcome = await dependencies.monitorWorker({
-                        stateRoot: input.local.stateRoot,
-                        backupsRoot: input.local.backupsRoot,
-                        migrationId: operation.migrationId,
-                        environment: operation.environment,
-                        workspaceId: operation.workspaceId,
-                        profile: operation.profile,
-                        ...(operation.migration.ownership === undefined ? {} : operation.migration.ownership),
-                    }, sendStatus);
-                    if (outcome.reopenAdmission)
-                        gate.reopen();
-                }
-                catch (error) {
-                    if (!workerLaunched) {
-                        gate.reopen();
-                        const failure = error instanceof Error ? error : new Error(String(error));
-                        throw Object.assign(new Error(failure.message, { cause: failure }), {
-                            code: error.code,
-                            reopenAdmission: true,
-                        });
-                    }
-                    throw error;
-                }
-            },
-            sendStatus,
-        });
-    };
-    const bindServerIdentityOnce = async (server) => {
-        const nextWorkspaceId = UUID.parse(server.workspaceId).toLowerCase();
-        const nextMachineId = UUID.parse(server.machineId).toLowerCase();
-        if (workspaceId !== null && workspaceId !== nextWorkspaceId) {
-            throw new Error("Storage migration server workspace identity changed");
-        }
-        if (machineId !== null && machineId !== nextMachineId) {
-            throw new Error("Storage migration server machine identity changed");
-        }
-        const layout = storageLayout({
-            nowworkHome: input.nowworkHome,
-            environment: input.environment,
-            workspaceId: nextWorkspaceId,
-            runtimeBase: input.local.runtimeBase,
-            platform: input.platform,
-        });
-        if (ownership.workspaceId !== nextWorkspaceId
-            || ownership.machineId !== nextMachineId
-            || ownership.environment !== input.environment) {
-            ownership = await dependencies.resolveOwnership({
-                nowworkHome: input.nowworkHome,
-                machineId: nextMachineId,
-                workspaceId: nextWorkspaceId,
-                environment: input.environment,
-                workspaceRootFingerprint: storageWorkspaceRootFingerprint(layout.workspaceRoot),
-            });
-        }
-        if (ownership.workspaceId !== nextWorkspaceId
-            || ownership.machineId !== nextMachineId
-            || ownership.environment !== input.environment) {
-            throw new Error("Storage ownership claim does not match authenticated server identity");
-        }
-        const createdAt = dependencies.now().toISOString();
-        const installation = installationBase(input, nextWorkspaceId, undefined, createdAt, ownership);
-        const nextIdentity = storageHelloIdentity({ installation, layout, ownership });
-        workspaceId = nextWorkspaceId;
-        machineId = nextMachineId;
-        identity = nextIdentity;
-        ensureControl();
-        drainPendingControlMessages();
-    };
-    const bindServerIdentity = (server) => {
-        const current = identityBindTail.then(() => bindServerIdentityOnce(server));
-        identityBindTail = current.catch(() => undefined);
-        return current;
-    };
-    const attach = (runtime) => {
-        gate = runtime.gate;
-        sendStatus = runtime.sendStatus;
-        ensureControl();
-        drainPendingControlMessages();
-    };
-    const replayStatus = async (send) => {
-        const receipt = await latestSourceStorageMigrationReceipt(input.local.backupsRoot, {
-            environment: input.environment,
-            profile: input.profile,
-        });
-        if (receipt === null)
-            return;
-        for (const frame of storageMigrationStatusReplay(receipt))
-            send(frame);
-    };
-    return Object.freeze({
-        statusOutboxPath: join(input.local.stateRoot, "storage-status-outbox.json"),
-        identity: () => identity,
-        bindServerIdentity,
-        attach,
-        replayStatus,
-        controller: Object.freeze({
-            handle: (raw) => {
-                if (control !== null && !drainingPendingControlMessages)
-                    return control.handle(raw);
-                if (pendingControlMessages.length >= 16)
-                    return Promise.resolve(false);
-                pendingControlMessages.push(raw);
-                drainPendingControlMessages();
-                return Promise.resolve(true);
-            },
-        }),
-    });
-}

package/dist/storage-runtime-readiness.js

@@ -1,241 +0,0 @@
-import { realpathSync } from "node:fs";
-import { lstat } from "node:fs/promises";
-import { isAbsolute, resolve } from "node:path";
-import { z } from "zod";
-import { buildServiceSpec } from "./computer-service.js";
-import { profilePath } from "./computer-profile.js";
-import { assertManagedServiceIdentity } from "./managed-service-lifecycle.js";
-import { managedServiceRegistryPath, readManagedServiceRegistry, } from "./managed-service-registry.js";
-import { installationsPath, resolveLocalStorageRoots } from "./storage-config.js";
-import { readStorageMigrationPolicy } from "./storage-migration-policy.js";
-import { createStorageMigrationRuntimeController, } from "./storage-runtime-controller.js";
-import { resolveEnvTag, resolveNowworkHome } from "./storage-layout.js";
-import { readStorageOwnershipClaim } from "./storage-ownership.js";
-import { parseDaemonLocalHomeMode, resolveDaemonLocalStateRoot } from "./daemon-local-home.js";
-import { isProductionServerHostname } from "./server-url.js";
-const notReady = (reason) => Object.freeze({ ready: false, reason });
-function canonicalPath(value) {
-    const absolute = resolve(value);
-    try {
-        return realpathSync.native(absolute);
-    }
-    catch (error) {
-        const code = error.code;
-        if (code === "ENOTDIR")
-            return absolute;
-        if (code !== "ENOENT")
-            throw error;
-    }
-    const missing = [];
-    let ancestor = absolute;
-    for (;;) {
-        const parent = resolve(ancestor, "..");
-        if (parent === ancestor)
-            return absolute;
-        missing.unshift(ancestor.slice(parent.length + (parent.endsWith("/") ? 0 : 1)));
-        ancestor = parent;
-        try {
-            return resolve(realpathSync.native(ancestor), ...missing);
-        }
-        catch (error) {
-            const code = error.code;
-            if (code === "ENOTDIR")
-                return absolute;
-            if (code !== "ENOENT")
-                throw error;
-        }
-    }
-}
-const samePath = (left, right) => canonicalPath(left) === canonicalPath(right);
-function environmentMatchesServer(serverUrl, environment) {
-    const hostname = new URL(serverUrl).hostname.toLowerCase();
-    if (hostname === "nowwork-dev.nowcoder.com")
-        return environment === "dev";
-    if (isProductionServerHostname(hostname))
-        return environment === "production";
-    return true;
-}
-function findSourceRecord(records, input) {
-    const matches = records.filter((record) => record.profile === input.profile
-        && samePath(record.daemonHome, input.currentDaemonHome)
-        && samePath(record.agentsRoot, input.currentAgentsRoot));
-    return matches.length === 1 ? matches[0] : null;
-}
-export async function probeStorageMigrationRuntime(rawInput, injected = {}) {
-    if (rawInput.platform !== "darwin" && rawInput.platform !== "linux") {
-        return notReady("platform_not_supported");
-    }
-    if (rawInput.platform === "darwin" && rawInput.uid === undefined) {
-        return notReady("platform_identity_missing");
-    }
-    const configuredNowworkHome = rawInput.environment.NOWWORK_HOME;
-    if (configuredNowworkHome === undefined)
-        return notReady("nowwork_home_missing");
-    const input = {
-        ...rawInput,
-        profile: z.string().regex(/^[a-z0-9][a-z0-9_-]{0,47}$/u).parse(rawInput.profile),
-        serverUrl: z.string().url().parse(rawInput.serverUrl),
-        platform: rawInput.platform,
-    };
-    let sourceLocalHome;
-    let targetLocalHome;
-    let targetEnvironment;
-    let nowworkHome;
-    let environment;
-    let local;
-    try {
-        sourceLocalHome = resolveDaemonLocalStateRoot({
-            userHome: rawInput.userHome,
-            platform: rawInput.platform,
-            profile: input.profile,
-            daemonHome: input.currentDaemonHome,
-        });
-        const requestedLocalHomeMode = parseDaemonLocalHomeMode(rawInput.environment.NOWWORK_LOCAL_HOME_MODE ?? rawInput.environment.NOWWORK_STORAGE_MODE);
-        if (requestedLocalHomeMode === "legacy")
-            throw new Error("storage migration target must use the canonical local .nowwork root");
-        targetLocalHome = resolveDaemonLocalStateRoot({
-            userHome: rawInput.userHome,
-            platform: rawInput.platform,
-            explicit: rawInput.environment.NOWWORK_LOCAL_HOME ?? resolve(rawInput.userHome, ".nowwork"),
-            mode: "nowwork",
-        });
-        targetEnvironment = {
-            ...input.environment,
-            NOWWORK_LOCAL_HOME: targetLocalHome,
-            NOWWORK_LOCAL_HOME_MODE: "nowwork",
-        };
-        const home = resolveNowworkHome({
-            environment: configuredNowworkHome,
-            userHome: input.userHome,
-            platform: input.platform,
-        });
-        if (home.mode !== "standard")
-            return notReady("nowwork_home_missing");
-        nowworkHome = home.root;
-        environment = resolveEnvTag({
-            ...(input.environment.NOWWORK_ENV_TAG === undefined
-                ? {}
-                : { environment: input.environment.NOWWORK_ENV_TAG }),
-        }).environment;
-        local = resolveLocalStorageRoots({
-            platform: input.platform,
-            userHome: input.userHome,
-            environment: targetEnvironment,
-        });
-    }
-    catch {
-        return notReady("storage_environment_invalid");
-    }
-    if (!environmentMatchesServer(input.serverUrl, environment)) {
-        return notReady("environment_server_mismatch");
-    }
-    const policyPath = input.environment.NOWWORK_STORAGE_POLICY_PATH;
-    if (policyPath === undefined)
-        return notReady("migration_policy_missing");
-    if (!isAbsolute(policyPath) || /[\0\r\n]/u.test(policyPath))
-        return notReady("migration_policy_invalid");
-    const dependencies = {
-        readManagedServices: readManagedServiceRegistry,
-        assertManagedServiceIdentity,
-        readPolicy: readStorageMigrationPolicy,
-        createController: createStorageMigrationRuntimeController,
-        readOwnership: readStorageOwnershipClaim,
-        ...injected,
-    };
-    let sourceRecord;
-    try {
-        const records = await dependencies.readManagedServices({ userHome: input.userHome, localHome: sourceLocalHome });
-        const found = findSourceRecord(records, input);
-        if (found === null)
-            return notReady("source_service_record_missing");
-        sourceRecord = found;
-    }
-    catch {
-        return notReady("source_service_registry_invalid");
-    }
-    const sourceSpec = buildServiceSpec({
-        platform: input.platform,
-        profile: input.profile,
-        userHome: input.userHome,
-        uid: input.uid,
-        nodePath: sourceRecord.nodePath,
-        entryPath: sourceRecord.entryPath,
-        profileHome: input.currentDaemonHome,
-        environment: input.environment,
-    });
-    const assertSourceIdentity = () => dependencies.assertManagedServiceIdentity({
-        spec: sourceSpec,
-        record: sourceRecord,
-        registry: { userHome: input.userHome, localHome: sourceLocalHome },
-    });
-    try {
-        await assertSourceIdentity();
-    }
-    catch {
-        return notReady("source_service_identity_drift");
-    }
-    let policy;
-    try {
-        policy = await dependencies.readPolicy(policyPath, {
-            profile: input.profile,
-            environment,
-            nowworkHome,
-            sourceDaemonHome: sourceRecord.daemonHome,
-            sourceAgentsRoot: sourceRecord.agentsRoot,
-        });
-    }
-    catch {
-        return notReady("migration_policy_invalid");
-    }
-    let ownership;
-    try {
-        ownership = await dependencies.readOwnership(nowworkHome);
-    }
-    catch (error) {
-        return notReady(error.code === "ENOENT"
-            ? "storage_ownership_claim_missing"
-            : "storage_ownership_claim_invalid");
-    }
-    if (ownership.environment !== environment)
-        return notReady("storage_ownership_claim_invalid");
-    const targetInstallationsPath = installationsPath(local.configRoot);
-    let targetInstallationsArtifact = null;
-    try {
-        const targetInstallations = await lstat(targetInstallationsPath);
-        if (!targetInstallations.isFile())
-            return notReady("target_installations_invalid");
-        targetInstallationsArtifact = { name: "installations.json", path: targetInstallationsPath };
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            return notReady("target_installations_invalid");
-    }
-    const runtime = dependencies.createController({
-        profile: input.profile,
-        serverUrl: input.serverUrl,
-        environment,
-        nowworkHome,
-        userHome: input.userHome,
-        platform: input.platform,
-        ...(input.uid === undefined ? {} : { uid: input.uid }),
-        sourceRecord,
-        local,
-        policy,
-        ownership,
-        serviceEnvironment: {
-            NOWWORK_HOME: nowworkHome,
-            NOWWORK_ENV_TAG: environment,
-            NOWWORK_STORAGE_POLICY_PATH: policyPath,
-            ...(targetEnvironment.NOWWORK_LOCAL_HOME === undefined ? {} : { NOWWORK_LOCAL_HOME: targetEnvironment.NOWWORK_LOCAL_HOME }),
-            ...(targetEnvironment.NOWWORK_LOCAL_HOME_MODE === undefined
-                ? {} : { NOWWORK_LOCAL_HOME_MODE: targetEnvironment.NOWWORK_LOCAL_HOME_MODE }),
-        },
-        backupArtifacts: [
-            { name: "profile.json", path: profilePath(input.profile, input.currentDaemonHome) },
-            { name: "service-descriptor", path: sourceRecord.descriptorPath },
-            { name: "managed-service-registry.json", path: managedServiceRegistryPath(input.userHome, sourceLocalHome) },
-            ...(targetInstallationsArtifact === null ? [] : [targetInstallationsArtifact]),
-        ],
-    }, { assertSourceIdentity });
-    return Object.freeze({ ready: true, runtime });
-}