@nowcrew/daemon 0.6.88-beta.3 → 0.6.88-beta.30

package/dist/storage-doctor.js

@@ -1,228 +0,0 @@
-import { constants } from "node:fs";
-import { access, lstat, readdir, realpath, statfs } from "node:fs/promises";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { generateStorageManifest, persistStorageManifestChunks, verifyStorageManifestChunkStore, parseStorageManifest, storageManifestDigest, } from "./storage-manifest.js";
-import { validateStorageEnvironment } from "./storage-layout.js";
-export class StorageDoctorAbortError extends Error {
-    code = "preflight_aborted";
-    scannedEntries;
-    constructor(scannedEntries, cause) {
-        super("storage doctor preflight was aborted", { cause });
-        this.name = "StorageDoctorAbortError";
-        this.scannedEntries = scannedEntries;
-    }
-}
-export function discoverLegacyStorageSources(input) {
-    if (!isAbsolute(input.legacyRoot))
-        throw new Error("legacy root must be absolute");
-    for (const value of [input.daemonDirectory, input.agentsDirectory]) {
-        if (!/^[a-z0-9][a-z0-9_-]{0,127}$/u.test(value))
-            throw new Error("legacy directory name is invalid");
-    }
-    return Object.freeze([
-        Object.freeze({ kind: "daemon-home", root: join(input.legacyRoot, input.daemonDirectory), logicalPrefix: "daemon" }),
-        Object.freeze({ kind: "agents-root", root: join(input.legacyRoot, input.agentsDirectory), logicalPrefix: "agent-items" }),
-    ]);
-}
-async function nearestExistingAncestor(path) {
-    let candidate = path;
-    for (;;) {
-        try {
-            await lstat(candidate);
-            return candidate;
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                throw error;
-        }
-        const parent = dirname(candidate);
-        if (parent === candidate)
-            throw new Error("target storage has no existing ancestor");
-        candidate = parent;
-    }
-}
-async function canonicalPotentialPath(path) {
-    const absolute = resolve(path);
-    const ancestor = await nearestExistingAncestor(absolute);
-    const canonicalAncestor = await realpath(ancestor);
-    return resolve(canonicalAncestor, relative(ancestor, absolute));
-}
-async function pathsOverlap(left, right) {
-    const [canonicalLeft, canonicalRight] = await Promise.all([
-        canonicalPotentialPath(left),
-        canonicalPotentialPath(right),
-    ]);
-    const leftToRight = relative(canonicalLeft, canonicalRight);
-    const rightToLeft = relative(canonicalRight, canonicalLeft);
-    const contained = (value) => value === "" || (!value.startsWith("..") && !isAbsolute(value));
-    return contained(leftToRight) || contained(rightToLeft);
-}
-async function defaultProbeTarget(targetWorkspaceRoot) {
-    try {
-        const ancestor = await nearestExistingAncestor(targetWorkspaceRoot);
-        await access(ancestor, constants.R_OK | constants.W_OK);
-        let targetState = "absent";
-        try {
-            const target = await lstat(targetWorkspaceRoot);
-            targetState = target.isDirectory() && (await readdir(targetWorkspaceRoot)).length === 0 ? "empty" : "non_empty";
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                throw error;
-        }
-        const filesystem = await statfs(ancestor, { bigint: true });
-        const available = filesystem.bavail * filesystem.bsize;
-        return Object.freeze({
-            status: "available",
-            targetState,
-            availableBytes: available > BigInt(Number.MAX_SAFE_INTEGER) ? Number.MAX_SAFE_INTEGER : Number(available),
-            writable: true,
-            // Staging and final roots are siblings on this filesystem. A destructive rename probe belongs
-            // to the separately approved write preflight, not this read-only doctor.
-            atomicRenameSupported: true,
-        });
-    }
-    catch (error) {
-        const code = error.code;
-        return Object.freeze({
-            status: code === "EACCES" || code === "EPERM" ? "permission_denied" : "unavailable",
-            targetState: "absent",
-            availableBytes: 0,
-            writable: false,
-            atomicRenameSupported: false,
-        });
-    }
-}
-const issue = (code, detail) => Object.freeze({ code, detail });
-function inspectManifestLinks(manifest) {
-    const warnings = [];
-    const blockers = [];
-    const credentialLinks = manifest.entries.filter((entry) => entry.link?.classification === "external" && entry.reason === "credential_material").length;
-    const unapprovedLinks = manifest.entries.filter((entry) => entry.link?.classification === "external" && entry.reason !== "credential_material" && entry.reason !== "local_runtime").length;
-    const brokenLinks = manifest.entries.filter((entry) => entry.link?.classification === "broken").length;
-    const unsupportedItems = manifest.entries.filter((entry) => entry.type === "unsupported").length;
-    if (credentialLinks > 0)
-        warnings.push(issue("credential_link_excluded", `${credentialLinks} credential link(s) excluded from migration`));
-    if (unapprovedLinks > 0)
-        blockers.push(issue("external_symlink_unapproved", `${unapprovedLinks} external link(s) require an explicit exclusion or portable mapping`));
-    if (brokenLinks > 0)
-        blockers.push(issue("broken_symlink", `${brokenLinks} broken link(s) cannot be migrated safely`));
-    if (unsupportedItems > 0)
-        blockers.push(issue("unsupported_file_type", `${unsupportedItems} unsupported filesystem item(s) found`));
-    if (manifest.summary.transformations > 0) {
-        warnings.push(issue("target_transformations_required", `${manifest.summary.transformations} target-only transformation(s) must be verified during apply`));
-    }
-    return { warnings, blockers };
-}
-export async function runStorageDoctor(input, dependencies = {}) {
-    const environment = validateStorageEnvironment(input.environment);
-    let scannedEntries = 0;
-    const onProgress = (progress) => {
-        scannedEntries = progress.scannedEntries;
-        input.onProgress?.(progress);
-    };
-    if (input.signal?.aborted)
-        throw new StorageDoctorAbortError(scannedEntries);
-    const manifest = typeof input.manifest === "string"
-        ? parseStorageManifest(input.manifest)
-        : input.manifest === undefined
-            ? await (input.manifestStoreRoot === undefined
-                ? generateStorageManifest({
-                    migrationId: input.migrationId,
-                    generatedAt: input.generatedAt,
-                    environment,
-                    workspaceId: input.workspaceId,
-                    targetWorkspaceRoot: input.targetWorkspaceRoot,
-                    sources: input.sources,
-                    policy: input.policy,
-                    ...(input.signal === undefined ? {} : { signal: input.signal }),
-                    onProgress,
-                    ...(input.progressIntervalEntries === undefined ? {} : { progressIntervalEntries: input.progressIntervalEntries }),
-                })
-                : persistStorageManifestChunks({
-                    migrationId: input.migrationId,
-                    generatedAt: input.generatedAt,
-                    environment,
-                    workspaceId: input.workspaceId,
-                    targetWorkspaceRoot: input.targetWorkspaceRoot,
-                    sources: input.sources,
-                    policy: input.policy,
-                    ...(input.signal === undefined ? {} : { signal: input.signal }),
-                    onProgress,
-                    ...(input.progressIntervalEntries === undefined ? {} : { progressIntervalEntries: input.progressIntervalEntries }),
-                }, { root: input.manifestStoreRoot })).catch((error) => {
-                if (error.code === "preflight_aborted") {
-                    throw new StorageDoctorAbortError(scannedEntries, error);
-                }
-                throw error;
-            })
-            : parseStorageManifest(JSON.stringify(input.manifest));
-    const target = await (dependencies.probeTarget ?? defaultProbeTarget)(input.targetWorkspaceRoot);
-    const warnings = [];
-    const blockers = [];
-    try {
-        await verifyStorageManifestChunkStore(manifest);
-    }
-    catch (error) {
-        blockers.push(issue("manifest_chunk_store_invalid", error instanceof Error ? error.message : "manifest chunk store is invalid"));
-    }
-    if (manifest.migrationId !== input.migrationId || manifest.workspaceId !== input.workspaceId.toLowerCase()
-        || manifest.environment !== environment || manifest.targetWorkspaceRoot !== input.targetWorkspaceRoot) {
-        blockers.push(issue("manifest_identity_mismatch", "manifest identity does not match the requested migration"));
-    }
-    if (!input.state.profileIdentityExact)
-        blockers.push(issue("profile_identity_drift", "profile, service or managed registry identity drifted"));
-    if ((await Promise.all(input.sources.map((source) => pathsOverlap(source.root, input.targetWorkspaceRoot))))
-        .some(Boolean)) {
-        blockers.push(issue("source_target_overlap", "target workspace and source roots must not contain one another"));
-    }
-    if (input.state.duplicateWorkspaceMappings > 0)
-        blockers.push(issue("duplicate_workspace_mapping", "more than one profile maps to this workspace"));
-    if (input.state.activeAgentExecutions > 0 || input.state.activeScheduledRuns > 0) {
-        blockers.push(issue("active_execution", "active agent execution or scheduled run must finish before migration"));
-    }
-    if (target.status === "unavailable")
-        blockers.push(issue("target_unavailable", "target storage is unavailable"));
-    if (target.status === "permission_denied" || !target.writable)
-        blockers.push(issue("target_permission_denied", "target storage is not writable by the daemon user"));
-    if (target.targetState === "non_empty")
-        blockers.push(issue("target_non_empty", "target workspace root is not empty"));
-    const multiplier = input.freeSpaceMultiplier ?? 1.2;
-    if (!Number.isFinite(multiplier) || multiplier < 1)
-        throw new Error("free space multiplier must be at least 1");
-    const requiredBytes = Math.ceil(manifest.summary.bytesToCopy * multiplier);
-    if (target.status === "available" && target.availableBytes < requiredBytes) {
-        blockers.push(issue("insufficient_space", `target requires at least ${requiredBytes} available bytes`));
-    }
-    if (!target.atomicRenameSupported)
-        blockers.push(issue("atomic_rename_unsupported", "target filesystem rename semantics are not verified"));
-    const links = inspectManifestLinks(manifest);
-    warnings.push(...links.warnings);
-    blockers.push(...links.blockers);
-    if (manifest.chunkStore !== undefined) {
-        if (manifest.chunkStore.credentialLinks > 0)
-            warnings.push(issue("credential_link_excluded", `${manifest.chunkStore.credentialLinks} credential link(s) excluded from migration`));
-        if (manifest.chunkStore.unapprovedLinks > 0)
-            blockers.push(issue("external_symlink_unapproved", `${manifest.chunkStore.unapprovedLinks} external link(s) require an explicit exclusion or portable mapping`));
-        if (manifest.chunkStore.brokenLinks > 0)
-            blockers.push(issue("broken_symlink", `${manifest.chunkStore.brokenLinks} broken link(s) cannot be migrated safely`));
-        if (manifest.chunkStore.unsupportedItems > 0)
-            blockers.push(issue("unsupported_file_type", `${manifest.chunkStore.unsupportedItems} unsupported filesystem item(s) found`));
-    }
-    const applyAllowed = blockers.length === 0;
-    const status = !applyAllowed ? "blocked" : warnings.length > 0 ? "warnings" : "safe";
-    const exitCode = status === "safe" ? 0 : status === "warnings" ? 2 : 3;
-    return Object.freeze({
-        status,
-        exitCode,
-        applyAllowed,
-        environment,
-        workspaceId: input.workspaceId.toLowerCase(),
-        profile: input.profile,
-        manifest,
-        manifestDigest: storageManifestDigest(manifest),
-        target,
-        warnings: Object.freeze(warnings),
-        blockers: Object.freeze(blockers),
-    });
-}